CS110 Session 2.1 PCW

CS110 Session 2.1 PCW.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": 271,
   "metadata": {},
   "outputs": [],
   "source": [
    "NAME = \"Feng Nian Tey\"\n",
    "COLLABORATORS = None"
   ]
  },
  {
   "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",
    "![image](https://user-images.githubusercontent.com/28986134/64927569-15dc4b80-d7fc-11e9-82ef-ae031a8e2f64.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": [
    "![image](https://user-images.githubusercontent.com/28986134/64927571-1f65b380-d7fc-11e9-8780-e1566104095e.png)\n",
    "\n",
    "As you can see in the diagram above, we separated the array according to the parameters specified in the MERGE(A, 1, 3, 6) function - the first part was terms 1-3, and the second part was terms 4-6. \n",
    "\n",
    "Then, the new array R was separated again into R<sub>1</sub> and R<sub>2</sub>, since the terms within that array was not sorted. \n",
    "\n",
    "The merge sort algorithm was performed for arrays R<sub>1</sub> and R<sub>2</sub>, and then for arrays L and R."
   ]
  },
  {
   "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, I'll have to determine the length of the two subarrays of A, since that will be the lengths of the lists L & R respectively. Then I will copy the elements in the two subarrays of A and fill them into the lists L & R. Then, I'll have to write a function that checks if the elements in L & R are sorted - if not, I'll have to repeat the whole process again for them.  \n",
    "\n",
    "Then, I will create a for loop to scan the first elements of both L and R to see which one is smaller. Once the smaller element has been identified, it will replace the first term in the parent list A. If the two elements are the same, they will be filled in side by side in the parent list A. This process will be repeated until the parents list A is fully-sorted."
   ]
  },
  {
   "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": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4, 6, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "import math as m\n",
    "Z = [2, 6, 7, 8, 1, 4, 6, 9]\n",
    "\n",
    "def merge(A, p, q, r):\n",
    "    n1 = q - p + 1\n",
    "    n2 = r - q\n",
    "    L = [None]*(q - p + 1)\n",
    "    R = [None]*(r - q)\n",
    "    for i in range(0, n1):\n",
    "        L[i] = A[p + i - 1]\n",
    "    for j in range(0, n2):\n",
    "        R[j] = A[q + j]\n",
    "    L.append(m.inf)\n",
    "    R.append(m.inf)\n",
    "    i = 0\n",
    "    j = 0\n",
    "    for k in range(p-1, r):\n",
    "        if L[i] <= R[j]:\n",
    "            A[k] = L[i]\n",
    "            i = i + 1\n",
    "        else:\n",
    "            A[k] = R[j]\n",
    "            j = j + 1 \n",
    "    return A\n",
    "            \n",
    "print(merge(Z, 1, 4, 8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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 4.\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": null,
   "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": 164,
   "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",
    "    if p < r:\n",
    "        q = (p+r)//2  #to make sure that we account for lists that have an uneven number of elements\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": null,
   "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": 167,
   "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": [
      "[1, 1, 2, 2, 4, 4, 6, 6, 6, 6, 7, 7, 8, 8, 9, 9]\n"
     ]
    }
   ],
   "source": [
    "import math as m\n",
    "Z = [2, 6, 7, 8, 1, 4, 6, 9, 2, 6, 7, 8, 1, 4, 6, 9]\n",
    "\n",
    "def merge(A, p, q, r):\n",
    "    n1 = q - p + 1\n",
    "    n2 = r - q\n",
    "    L = [None]*(q - p + 1)\n",
    "    R = [None]*(r - q)\n",
    "    for i in range(0, n1):\n",
    "        L[i] = A[p + i - 1]\n",
    "    for j in range(0, n2):\n",
    "        R[j] = A[q + j]\n",
    "    L.append(m.inf)\n",
    "    R.append(m.inf)\n",
    "    i = 0\n",
    "    j = 0\n",
    "    for k in range(p-1, r):\n",
    "        if L[i] <= R[j]:\n",
    "            A[k] = L[i]\n",
    "            i = i + 1\n",
    "        else:\n",
    "            A[k] = R[j]\n",
    "            j = j + 1 \n",
    "    return A\n",
    "\n",
    "def merge_sort(A,p,r):\n",
    "    if p < r:\n",
    "        q = (p+r)//2  #for an uneven number of items in the list we need to do this \n",
    "                         #to obtain the term before the midpoint\n",
    "        merge_sort(A,p,q)\n",
    "        merge_sort(A,q+1,r)\n",
    "        merge(A,p,q,r)\n",
    "    return(A)\n",
    "\n",
    "print(merge_sort(Z, 1, 16))"
   ]
  },
  {
   "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": 254,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "0561f29260f91795736500d62066a4c7",
     "grade": true,
     "grade_id": "cell-d09efb7c7fe55e69",
     "locked": false,
     "points": 0,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The merge sort algorithm took 0.10593581199645996 seconds and involved 277231 steps.\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import random\n",
    "import math as m\n",
    "\n",
    "### MERGE SORT ###\n",
    "\n",
    "counter = []\n",
    "\n",
    "def merge(A, p, q, r):\n",
    "    n1 = q - p + 1\n",
    "    n2 = r - q\n",
    "    L = [None]*(q - p + 1)\n",
    "    R = [None]*(r - q)\n",
    "    for i in range(0, n1):\n",
    "        L[i] = A[p + i - 1]\n",
    "        counter.append(1)\n",
    "    for j in range(0, n2):\n",
    "        R[j] = A[q + j]\n",
    "        counter.append(1)\n",
    "    L.append(m.inf)\n",
    "    R.append(m.inf)\n",
    "    i = 0\n",
    "    j = 0\n",
    "    for k in range(p-1, r):\n",
    "        if L[i] <= R[j]:\n",
    "            A[k] = L[i]\n",
    "            i = i + 1\n",
    "        else:\n",
    "            A[k] = R[j]\n",
    "            j = j + 1\n",
    "        counter.append(1)\n",
    "    return (A)\n",
    "\n",
    "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",
    "        counter.append(1)\n",
    "    return(A)\n",
    "\n",
    "Z = random.sample(range(100000), 10000)    #generates random lists to sort.\n",
    "start = time.time()                        #starts counting time.\n",
    "merge_sort(Z, 1, len(Z))                  #sorts list.\n",
    "end = time.time()                         #stops counting time.\n",
    "timediff = end-start                       #time difference\n",
    "\n",
    "print(f\"The merge sort algorithm took {timediff} seconds and involved {len(counter)} steps.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The bubble sort algorithm took 25.039914846420288 seconds and involved 124957307 steps.\n"
     ]
    }
   ],
   "source": [
    "### BUBBLE SORT ###\n",
    "Z = random.sample(range(100000), 10000)\n",
    "counter_bubble = []\n",
    "\n",
    "def bubbleSort(A):\n",
    "    x = len(A)\n",
    "    counter_bubble.append(1)\n",
    "    for i in range(x):\n",
    "        counter_bubble.append(1)\n",
    "        for j in range(0, x-i-1):\n",
    "            counter_bubble.append(1)\n",
    "            if A[j] > A[j+1]:\n",
    "                A[j+1], A[j] = A[j], A[j+1]\n",
    "                counter_bubble.append(1)\n",
    "            counter_bubble.append(1)\n",
    "    return A\n",
    "\n",
    "start = time.time()                        #starts counting time.\n",
    "bubbleSort(Z)                              #sorts list.\n",
    "end = time.time()                         #stops counting time.\n",
    "timediff_bubble = end-start               #time difference\n",
    "\n",
    "print(f\"The bubble sort algorithm took {timediff_bubble} seconds and involved {len(counter_bubble)} steps.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The insertion sort algorithm took 15.29994821548462 seconds and involved 75196566 steps.\n"
     ]
    }
   ],
   "source": [
    "### INSERTION SORT ###\n",
    "counter_insertion = []\n",
    "Z = random.sample(range(100000), 10000)\n",
    "def insertionSort(A):\n",
    "    for j in range(len(A)):\n",
    "        key = A[j]\n",
    "        i= j-1\n",
    "        while i >= 0 and A[i]>key:\n",
    "            A[i+1] = A[i]\n",
    "            counter_insertion.append(1)\n",
    "            i -= 1\n",
    "            counter_insertion.append(1)\n",
    "            A[i+1] = key\n",
    "            counter_insertion.append(1)\n",
    "    return A\n",
    "\n",
    "start = time.time()                        #starts counting time.\n",
    "insertionSort(Z)                              #sorts list.\n",
    "end = time.time()                         #stops counting time.\n",
    "timediff_insertion = end-start               #time difference\n",
    "\n",
    "print(f\"The insertion sort algorithm took {timediff_insertion} seconds and involved {len(counter_insertion)} steps.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The selection sort algorithm took 10.335607767105103 seconds and involved 50082211 steps.\n"
     ]
    }
   ],
   "source": [
    "### SELECTION SORT ###\n",
    "import sys \n",
    "Z = random.sample(range(100000), 10000)\n",
    "\n",
    "counter_selection = []\n",
    "\n",
    "# Traverse through all array elements \n",
    "def selectionSort(A):\n",
    "    for i in range(len(A)): \n",
    "        counter_selection.append(1)\n",
    "    # Find the minimum element in remaining  \n",
    "    # unsorted array \n",
    "        min_idx = i \n",
    "        for j in range(i+1, len(A)):\n",
    "            counter_selection.append(1)\n",
    "            if A[min_idx] > A[j]: \n",
    "                min_idx = j \n",
    "                counter_selection.append(1)\n",
    "              \n",
    "    # Swap the found minimum element with  \n",
    "    # the first element         \n",
    "        A[i], A[min_idx] = A[min_idx], A[i] \n",
    "        \n",
    "    return(A)\n",
    "\n",
    "start = time.time()                        #starts counting time.\n",
    "selectionSort(Z)                              #sorts list.\n",
    "end = time.time()                         #stops counting time.\n",
    "timediff_selection = end-start               #time difference\n",
    "\n",
    "print(f\"The selection sort algorithm took {timediff_selection} seconds and involved {len(counter_selection)} steps.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAncAAAEWCAYAAAAEirEAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3de9xc47n/8c9X4hASx4QmKtI6daOkRNWpKFUt6likqqKHVHfVprqr1d1KtUW7KVrVllZDnc8UdagtUT/HhDgGVaJIEAQJEklcvz/ue1jPZGaeeU4zLN/36/W8npl1vNa97nuta+611owiAjMzMzMrh8XaHYCZmZmZ9R4nd2ZmZmYl4uTOzMzMrESc3JmZmZmViJM7MzMzsxJxcmdmZmZWIj1K7iSNk3R2bwVTY/kPStqmr5bfXZK2kfR0i9b1M0kvSHq2FevrCkn7Sbq+3XH0FklHSvpjG9bbZ+1I0laSHmkwfoSkkNS/L9Zv5SVpgqSvtTuO3tTX57QG623ZOeX9RtJ4ST9rdxyt1jC5kzSn8PeWpDcK7/frzUBq7YCIWC8iJvTmeuqsuy0NujOSVgMOB9aNiA+0O55qEXFOROzQ7ji6o9bBNCKOiYhSnawi4h8RsU7lvaRpkrZvZ0w5jndNm8vJ7ZoNxg+VdKWk6XnaEVXjl5R0hqRXJT0r6TudrO+wPN0reb4lC+NGSLpJ0uuSHq7eV43mtfen90piKOmLkp6U9JqkyyWt+C6IqUdtW9J2uZ2+ntvt6g3W1e223dm8tTRM7iJiYOUP+DewS2HYOZ0t3HpsdeDFiHi+qzP2dU/Me7mn570ce1e8X7azu7pQPm8B1wJ71hk/DliL1F63Bb4nacc66/wM8H1gO2AE8GHgJ4VJzgPuAVYCfghcLGlIk/PW5brQei7zd0haD/gDsD+wCvA6cGpbg0q63bYlDQYuBX4ErAhMAi5osK6etO2689YVEU39AdOA7auGjQMuBM4CZgMPAqMK44cBlwAzgSeAQ+oseywwH3gTmAP8tXqdeV0XAWfndd0PrA38AHgeeArYobDM5YA/ATOAZ4CfAf1qrHvHvN75ed335uEHAlPzuh4HvlGYZxvg6cL7Q4CHgA/m9zsDU4CXgVuBDarK8bvAfcArpMqwVI24tgfeIFW+OcD4PPzzuZxfBiYA/1G17CPysucB/auW+Xvg+KphVwDfya+/D/wrb/NDwO6F6cYA/w84EXgpl+cY4JbCNJsDd+XtugvYvF79yfvz7Px6qbxfX8zbdRewSp26ckTen7OBR4Dt8vAlgZOA6fnvJGDJ4v7K8z5LqkfFsp1DqqvFmEYAARxA+mDzAvDDQhwDgDOBWaR68r1inagR98mkOvoqMBnYqlZZ5PdfBp7M5fEjOraDrmznXyjU1fz+rbztc3LMnW3nOLrW7saQ2stsUpvfrwttbhhwJal+PQZ8vUF5fo5UR2fn+vDdwriv5/lfyssbVhgXwLeAf+b4bs7DXsux7NNgnf3ztCOqhj9TVQY/Bc6vs4xzgWMK77cDns2v1ya120GF8f8ADups3hrrqezXr+b9enMeflGuG6/kbV+vMM944LfA1blc7wDWKIz/NPBwnvcUYCLwtTxuMeB/SPX2edI5YbmqWA7M9WUWcBCwCelY9TJwSoNyH0fj80wAa1Ztx8+q2sT3clwzgN1y/Xk015Ejq9Z1Mem4PBu4G9iwML7uOa0w79mkdv414OOkk/6rwHPAr+psYyXOI0ltcBqFtkNq98fnffkc6Vg+AFiG2seyN4DBed7/ARYAy+b3PwNOarTcwnp7fC7L0x4DnFt4vwbpGDCozvSdHS8b1YeP5f02O8d0fqU+9GbbJuUttxbGVfbFR2osv9ttu7N5625To5FVwU2jdnI3l9RQ+gHHArcXGvtk4MfAEqRM9HHgM3WWP756B7BocjcX+EzeEWeRGtcPgcVJB/QnCvNeTvqksAywMnAnhQStxnacXTVsp1wBBWxN+qSxUbEh5tc/yhVpSH6/EekgsmkukwPydixZ2KY7SQ1wRVJiUHMnsWgSuTbpJPTpvM3fI53EligsewqwGoUGWpj/k6QGo/x+BVJlHJbffyHHtRiwT17X0DxuDOkA8e1c/gMoJHd5W2aRPpn1B0bn9yvVqj90TKS+AfwVWDqX2cbkA1FV/Ovk+CvxjiCffICjgdvzvh5COhD9tFCOC4BfkA5mA6rLtkZMI0iN/fQ8/YakBvYfefxxpJPbCsAHSQe4Rsndl0ifuvqTLrU/Sz4QVq13XdIBektSuzmelARt3xvbWWM/dLad42iy3ZHa2qvAOvn9UArJQxNtbiLp0/xSwEjSCXS7OvPPIB/w8z6otM1PkU6OG+Uy+A05scnjA7iBVF8HFIatWWs9Vetc5ASQ1x0UPowAewH311nGvRQSSGBwnn8lYHdgatX0pwC/6WzeGuup7Nez8n6pbOtXgEG88yFhStUx+CVSQtIfOId3TmSD877dK+/3w3Jd+1phuY+RjvMDST0af6mK5fd53+6Q69TlpHq8KumYuXWDulLzPFNr/7FocreAdB6q1NeZpJPpIGC9vOwPF9Y1v7Cd3yXV98Xp5JxWmHe3PO0A4DZg/zx+IPCJBsf6BcCv8r7ZmnT8rbSlk0gfVFbMcf8VOLbWeSIPuxnYM7++nvSh/bOFcbs3sdzePJddARxRNWwOsHE3j5f18o4lSB8wDsv7bK+8T7qc3NFJ2yYloL+rWs4DlXKvGt7ttt3ZvPX+euNp2Vsi4pqIWEjqGdgwD9+ElPAcHRFvRsTjpBPIvj1Y1z8i4rqIWED6BDoEOC4i5pOy8xGSlpe0CvBZ4NCIeC3SZc0Tu7LuiLg6Iv4VyURSA9mqMIkk/Yp00ts2Imbm4V8H/hARd0TEwog4k3Sy/ERh3l9HxPSIeInUmEY2GdY+wNURcUPe5uNJB5DNq5b9VES8UWP+f5AqTGU79gJui4jpeZsvynG9FREXkHo3Pl6Yf3pE/CYiFtRY/k7APyPiL3n8eaRP+bs0sV3zSZV4zVxmkyPi1RrTLSQd+NaVtHhETIuIf+Vx+wFHR8TzeV/8hJRoVrwFHBUR8+qUTT0/iYg3IuJeUgOs1O+9SZ+0ZkXE08CvGy0kIs6OiBdz2ZyQt2OdGpPuReq5viUi3iSdSKIwvtXbCU22u8L615c0ICJmRMSDzaw831+6JekEMDcipgB/rNq2ovmkerBs3gd35+H7AWdExN0RMY/Uw7hZ1b00x0bES10sn3oG5v+vFIa9QjpR1pu+elry9NXjqpfVaN56xuVj4BsAEXFGRMzOZTMO2FDScoXpL42IO/O+Pod3jk2fAx6KiIvzfj+JdMKt2I/UK/V4RMwhlfu+VZcmf5r37fWkxOW8XI+fIR2bPtZgO+qdZ5oxH/h5ob4OBk7O5fAgqedng8L0kwvb+StSQvoJmjun3RYRl+dj6Bt53WtKGhwRcyLi9k5i/VFuuxNJPah7SxLpvHJYrrezST1hjc5nE4Gtc/lvQDo+bS1pqbwd/2hiub15LuusbnfQxPGyXn34BCmpOyki5kfExaQrQd3RWdvuyjb1pG13qewqeiO5Kzbw14GlcoVaHRgm6eXKH6nLeZUerOu5wus3gBfyzq28h1QQq5N28IzCuv9A+pTYFEmflXS7pJfy/J8jHRQqlid1yx4bEcWCXx04vGq7VyN9uqmoLrOBNGcY6VMJABHxFqkna9XCNE/VmzkignRwG50HfZF0AAdA0pclTSnEvT4dt7nusqtjy56siq2evwDXAefnG1t/KWnxGvE/BhxKOik9L+l8SZVyrV7/k3Qs85kRMbeJWKrV21fD6FgejcoGSYdLmppvln2ZdNvA4BqTdlhuRLxOujxbHN/K7YQm211EvEb6AHIQqe1dLekjTa5/GFA5wVQ0qj97ktrkk5ImStqssJxiG5lDKr+m2kg3zMn/ly0MW5Z0Saje9NXTkqevHle9rEbz1vP2tkrqJ+k4Sf+S9Cqp5wU61sOm6ns+lhTLsVa97E/H4311Pap+3+g4WO8804wXa9TXRusubudbpMulw2junFZdt75KuuLysKS7JO3cIM5ZuQ1VVNr2ENJVjcmF9V6bh9czkdSjtxHpVoobSL2BnwAei4gXmlhub57LOqvbHTRxvKxXH4YBz+T6WVF9XmpWZ227K9vUk7bdpbKr6MvvuXuKdLlm+cLfoIj4XJ3po87w7q57Humeg8q6l42I9ZpZd35K5RJSz9gqEbE8cA3pEm3FLNL9CH+WtEXVun9etd1L556snppOanCVOEVqbM/U25YazgP2yk/1bEraTvL704GDSZd5lid1MRe3udGyO8SWDS/E9hrpQFLx9tO/+RPWTyJiXVIv5M6k+84WERHnRsSWeV1BugRZa/3D87B6sfe0vs0gXY6tWK3ehJK2It0HtzewQi7bV+hYtjWXK2kAqVezoqvbWa0329miC089fJ8mXZJ9mFSnmoljOrCipOKn0WL9qV7PXRGxK+kD2+Wke3Aqyym2kWVI5deVNtK0iJhF2mfFnqQNSb1BtTxYY9rnIuLFPO7DVWVQXFajeeuGWHj9RWBX0v28y5Eul0LtelhtBoU6Xjj2VNSqlwvomET1ldepc2zppuJ2LkZqj9Np7pzWoW5FxD8jYjSpnv6CdCP8MnXWu0LVuErbfoGUgK5XWO9ykR50XGSd2a2knq7dgYkR8VBe3k6kxI8mltub57IOdVfSh0m9cY9WT9jF42W1GcCquX5WDO9GvM207eptWoZ0K1ettt+Ttt3ZvDX1ZXJ3J/CqpCMkDcifGteXtEmd6Z8j3cPQYxExg3QZ9QRJy0paTNIakrZusO4RuSFDum6/JOnejAWSPku6T6R6PRNIlyMuk7RpHnw6cJCkTZUsI2mnqh3TXRcCOyk9fr046V6EeaSG3JSIuIe0XX8ErouIl/OoZUgHiZkAkg4k9dw16xpgbaXH3ftL2od0/9hVefwU0mWaxSWNIl1+JK9rW0kfldSPdF/PfNIl2A4krSPpUzn5nks6MFWmOw/4H0lDlJ5i+jHpxuZ6ngNWqrok1RUXAj+QtIKkVUlJcT2DSCe6mUB/ST9m0U9iFRcDu0jaXNISpMuuxQNVV7ezWq+1s2qSVpH0+XyQm0f6xLnIfizE8Xabi4inSPX4WElLSdqA1OuxyFP5kpZQ+o7F5fKls1cL6zkXOFDSyFxPjgHuiIhpDULvtEyULmdVvppgyfy+4izSPlkh91R+nXTfV2Xe0Dvf13kW8FVJ60pagXSz+/hcBo+S2slRuQx2J11Su6SzeZs0iLRfXiQlQ8d0Yd6rgfUk7ZF7SA6hYxJ1HnCYpA9JGpiXfUG+vNvXpgBfzOeYHUk9VD2xcWE7DyWV2e10/ZyGpC9JGpJ7ACvH2nptAuAnuX5vRfqQe1Ge93TgREkr5+WuqvSEJdQ4luUe/8mkh4cqydytpPubJ+ZpOltub57LziEd17bKx4ejSbcA1Op96srxstpted5D8nloDzreWrSIHrTty0i3oOyZ5/kxcF9EPJyXO07SBOhZ225i3pr6LLnL3eC7kK7BP0H6lPBH0ifGWv5EuofmZUmX90IIXyYlaQ+RetkuJvUm1HJR/v+ipLtzhTuEdAKfRfrEe2WtGSPiBtJTYFdK2jgiJpEqwCl53sdIDx70WEQ8QrrR9Dek8tyF9PU0b3ZxUeeRPr2fW1j2Q8AJpMbxHPBR0tOxzcb2IulgdDjp5PE9YOfc/Q/pwZM1SGXyk+K6SSeJi0kn6amkg0+thGVJ0oMML5C65VcmXRaB9ATYJNKDDfeTHnKp+8WVuQGeBzye69ywetPWcTTpcs0TwN9z/PPqTHsd8DfSp9QnSYlpzUuDke4B+jbp8vkMUtf784Vld2k7aziWdLB6WdJ3uzBfMxYj7f/ppBvztwb+s860Hdpcfj2a1Js0nXTgPCq3r1r2B6YpXV48iNQuiIgbSXXtElL5rUHn99qOA87MZbJ3nWkqTxhD6pEs3q93FOmG9SdJdfd/I+JaAEkfzPPdn+O7FvglcFOe/sk8f8W+wChSOzkO2Cvy/bxNzNuZs/I8z5COi53d//W23I6/kGN6kfT1EMXjwxmk2ytuJrWJuaR63Ar/RToWvkz6sN3T88cVpNsLKg+I7ZGvLnT1nAbpyfAHJc0h3YC/b4PbJp7N65xOSoYOqiQKpJ6sx4Dbc53/O/ketAbHsomk25PuLLwfRNpHNLHcXjuX5ePaQXm7ns9x1Ds2NH28rLGeN4E9cpyzSPvx0k5m61bbzu1yT+DneV2b0vFYsxod20hP2nbdeeupPDVpZj0g6ZukA3dPew2qlzuQdNJaKyKe6M1lW9+T9CXSZa8ftDsWM2sdSVNIT/s3um2i79bv5M6s6yQNJV3Ku43Ui3E16bu6TuqFZe8C3Ei6HHsC6RPhRuHGamZmTejLe+7MymwJ0hPYs4H/I13K6a1vXN+Vd76keC1Sj6ATOzMza4p77szMzMxKxD13ZmZmZiXiHza2XjV48OAYMWJEu8MwM3tPmTx58gsR0fjH4M2a5OTOetWIESOYNGlSu8MwM3tPkdTdX1IwW4Qvy5qZmZmViJM7MzMzsxJxcmdmZmZWIk7uzMzMzErEyZ2ZmZlZiTi5MzMzMysRJ3eGpNUk3SRpqqQHJf1XHj5O0jOSpuS/z7U7VjMzM2vM33NnAAuAwyPibkmDgMmSbsjjToyI49sYm5mZmXWBkzsjImYAM/Lr2ZKmAqu2NyozMzPrDid31oGkEcDHgDuALYCDJX0ZmETq3ZtVY56xwFiA4cOHtyxW6xr9RO0OoWlxVLQ7BDOz9yzfc2dvkzQQuAQ4NCJeBX4HrAGMJPXsnVBrvog4LSJGRcSoIUP804hmZmbt5OTOAJC0OCmxOyciLgWIiOciYmFEvAWcDny8nTGamZlZ55zcGZIE/AmYGhG/KgwfWphsd+CBVsdmZmZmXeN77gzSvXX7A/dLmpKHHQmMljQSCGAa8I32hGdmZmbNcnJnRMQtQK277a9pdSxmZmbWM74sa2ZmZlYiTu7MzMzMSsTJnZmZmVmJOLkzMzMzKxEnd2ZmZmYl4uTOzMzMrESc3JmZmZmViJM7MzMzsxJxcmdmZmZWIk7uzMzMzErEyZ2ZmZlZiTi5MzMzMysRJ3dmZmZmJeLkzszMzKxEnNyZmZmZlYiTOzMzM7MScXJnZmZmViJO7szMzMxKxMmdmZmZWYk4uTMzMzMrESd3ZmZmZiXi5M7MzMysRJzcmZmZmZWIkzszMzOzEnFyZ2ZmZlYiTu7MzMzMSsTJnZmZmVmJOLkzMzMzKxEnd2ZmZmYl4uTOzMzMrESc3JmZmZmViJM7MzMzsxJxcmcASFpN0k2Spkp6UNJ/5eErSrpB0j/z/xXaHauZmZnV5+TOKhYAh0fEfwCfAL4laV3g+8CNEbEWcGN+b2ZmZu9STu4MgIiYERF359ezganAqsCuwJl5sjOB3doToZmZmTXDyZ0tQtII4GPAHcAqETEDUgIIrFxj+rGSJkmaNHPmzFaGamZmZlWc3FkHkgYClwCHRsSrzcwTEadFxKiIGDVkyJC+DdDMzMwacnJnb5O0OCmxOyciLs2Dn5M0NI8fCjzfrvjMzMysc07uDABJAv4ETI2IXxVGXQkckF8fAFzR6tjMzMysef3bHYC9a2wB7A/cL2lKHnYkcBxwoaSvAv8GvtCm+MzMzKwJTu4MgIi4BVCd0du1MhYzMzPrPl+WNTMzMysRJ3dmZmZmJeLkzszMzKxEnNyZmZmZlYiTOzMzM7MScXJnZmZmViJO7szMzMxKxMmdmZmZWYk4uTMzMzMrESd3ZmZmZiXi5M7MzMysRJzcmZmZmZWIkzszMzOzEnFyZ2ZmZlYiTu7MzMzMSsTJnZmZmVmJ9G93ANa7JK0EbA4MA94AHgDuiYhoa2BmZmbWEk7uSkLSVsAPgA8AU4DngaWAfYHVJZ0PnBgRc9oXpZmZmfU1J3flsQdwcEQ8Xj1C0hLA54EdgYtbHZiZmZm1jpO7koiIwxqMexMndWZmZu8LfqCiZCQdLGnZ/PoPku6UtH274zIzM7PWcHJXPmMj4lVJOwCrAt8EftHmmMzMzKxFnNyVT+Wp2M8Cf46IyXg/m5mZvW/4pF8+90q6BtgF+JukgbyT8JmZmVnJ+YGK8jkQ2Bh4LCJelzQY+GqbYzIzM7MWcc9dSUhaDSAiFkbEnRHxUn7/QkTco2RYe6M0MzOzvuaeu/I4WdJ84ApgMjCT9CXGawLbAjsARwPT2xahmZmZ9TkndyUREXtI2gDYD/hPYCjwOjAVuAbYPiLeaGOIZmZm1gJO7kokIu4D7mt3HGZmZtY+vufOzMzMrESc3JmZmZmViJM7MzMzsxLxPXclJOkDwHAK+zcibm1fRGZmZtYqTu5KRtIxwJeAh4GFeXAAn+tkvjOAnYHnI2L9PGwc8HXS16oAHBkR1/RB2GbvcWp3AF3gH6wxKzsnd+WzJ7B2RMzt4nzjgVOAs6qGnxgRx/dGYGZmZtb3fM9d+TxBN/ZrRNwMvNT74ZiZmVkrueeufGYD90j6OzCvMjAivtPN5R0s6cvAJODwiJhVPYGkscBYgOHDh3dzNWZmZtYb3HNXPtcCvwTuBh4s/HXH74A1gJHADOCEWhNFxGkRMSoiRg0ZMqSbqzIzM7Pe4J67komIP0laAhgeEY/1cFnPVV5LOh24qqfxmZmZWd9yz13JSNoJuB+4Ib8fKemybi5raOHt7sADPY/QzMzM+pJ77srnaGBT4CaAiJgiac3OZpJ0HrANMFjS08BRwDaSRpK+O2Ea8I0+itnMzMx6iZO78pkfES9LHb53q9MvtoqI0TUG/6nXojIzM7OWcHJXPlMl7Q0sJulDwH8Bt7c5JjMzM2sR33NXPgcDGwNvAZcCc4FD2xqRmZmZtYx77spnpYg4AjiiMkDSRqSvRjEzM7OSc89d+VxafMpV0hYs+pNiZmZmVlJO7srnW8AVklaW9BngVGCnNsdkZmZmLeLLsiUTEXdI+g7pe+7eBHYofhmxmZmZlZuTu5LIX1Rc/MqTpYGXgd9JIiL2aE9kZmZm1kpO7srjlHYHYGZmZu3n5K4kIuLGdsdgZmZm7ecHKkpG0iaSbpf0iqS5kuZJerXdcZmZmVlruOeufE4FvgScD3wcGAOs1s6AzMzMrHXcc1c+i0XEI0D/iJgfEacD27c7KDMzM2sN99yVz2uSlgDulXQMMAMY2OaYzMzMrEXcc1c+Y0j79WBgIbAWsFc7AzIzM7PWcc9dSUgaHxFjIuLxPGgu8KN2xmRmZmat55678tig3QGYmZlZ+7nnrjyWlvQxQLVGRsTdLY7HzMzM2sDJXXmsCpxA7eQugE+1NhwzMzNrByd35fFYRDiBMzMze5/zPXdmZmZmJeLkrjyOaHcAZmZm1n5O7koiIq5vdwxmZmbWfk7uzMzMzErEyV1JSVqm3TGYmZlZ6zm5KxlJm0t6CJia328o6dQ2h2VmZmYt4uSufE4EPgO8CBAR9wKfbGtEZmZm1jJO7kooIp6qGrSwLYGYmZlZy/lLjMvnKUmbAyFpCeAQ8iVaMzMzKz/33JXPQcC3SD9H9jQwMr83MzOz9wH33JVMRLwA7NfuOMzMzKw9nNyVjKQPAd8GRlDYvxHx+XbFZGZmZq3j5K58Lgf+BPwVeKvNsZiZmVmLObkrn7kR8euuziTpDGBn4PmIWD8PWxG4gNQLOA3YOyJm9V6oZmadkNodQfMi2h2BGeAHKsroZElHSdpM0kaVvybmGw/sWDXs+8CNEbEWcGN+b2ZmZu9i7rkrn48C+wOf4p3LspHf1xURN0saUTV4V2Cb/PpMYAJwRO+EaWZmZn3ByV357A58OCLe7IVlrRIRMwAiYoaklWtNJGksMBZg+PDhvbBaMzMz6y5fli2fe4HlW7nCiDgtIkZFxKghQ4a0ctVmZmZWxT135bMK8LCku4B5lYHd/CqU5yQNzb12Q4HneytIMzMz6xtO7srnqF5c1pXAAcBx+f8VvbhsMzMz6wNO7komIiZ2Zz5J55Eenhgs6WlSkngccKGkrwL/Br7QW3GamZlZ33ByVxKSbomILSXNJj0d+/YoICJi2UbzR8ToOqO2660YzczMrO85uSuPZQAiYlC7AzEzM7P28dOy5eGvRjczMzP33JXIypK+U29kRPyqlcGYmZlZezi5K49+wEDSPXZmZmb2PuXkrjxmRMTR7Q7CzMzM2sv33JWHe+zMzMzMyV2J+CtLzMzMzMldWUTES+2OwczMzNrPyZ2ZmZlZiTi5MzMzMysRJ3dmZmZmJeLkzszMzKxEnNyZmZmZlYiTOzMzM7MScXJnZmZmViJO7szMzMxKxMmdmZmZWYk4uTMzMzMrESd3ZmZmZiXi5M7MzMysRJzcmZmZmZWIkzszMzOzEnFyZ2ZmZlYiTu7MzMzMSsTJnZmZmVmJOLkzMzMzKxEnd2ZmZmYl4uTOzMzMrESc3JmZmZmViJM7MzMzsxJxcmdmZmZWIk7uzMzMzEqkf7sDsHc/SdOA2cBCYEFEjGpvRGZmZlaPkztr1rYR8UK7gzAzM7PGfFnWzMzMrESc3FkzArhe0mRJY6tHShoraZKkSTNnzmxDeGZmZlbh5M6asUVEbAR8FviWpE8WR0bEaRExKiJGDRkypD0RmpmZGeDkzpoQEdPz/+eBy4CPtzciMzMzq8fJnTUkaRlJgyqvgR2AB9oblZmZmdXjp2WtM6sAl0mCVF/OjYhr2xuSmZmZ1ePkzhqKiMeBDdsdh5mZmTXHl2XNzMzMSsTJnZmZmVmJOLkzMzMzKxEnd2ZmZmYl4uTOzMzMrESc3JmZmZmViJM7MzMzsxJxcmdmZmZWIk7uzMzMzErEyZ2ZmZlZiTi5MzMzMysRJ3dmZmZmJeLkzszMzKxEnNyZmZmZlYiTOzMzM7MScXJnZmZmViJO7szMzMxKxMmdmZmZWYk4uTMzMzMrESd3ZmZmZiXi5M7MzMysRJzcmZmZmZWIkzszMzOzEnFyZ2ZmZlYiTu7MzMzMSsTJnZmZmVmJOLkzMzMzKxEnd2ZmZmYl4uTOzMzMrESc3JmZmZmViAzYqVwAAA3iSURBVJM7MzMzsxJxcmdmZmZWIk7uzMzMzErEyZ11StKOkh6R9Jik77c7HjMzM6vPyZ01JKkf8Fvgs8C6wGhJ67Y3KjMzM6unf7sDsHe9jwOPRcTjAJLOB3YFHuqLlUl9sdS+EdHuCMzMzBbl5M46syrwVOH908CmxQkkjQXG5rdzJD3SotiaNRh4obcX+l5KRPtQ35TtOBcufVS24LKlr8q2ZweF1XsrDDMnd9aZWkerDn1WEXEacFprwuk6SZMiYlS74ygjl23fcdn2HZetlZ3vubPOPA2sVnj/QWB6m2IxMzOzTji5s87cBawl6UOSlgD2Ba5sc0xmZmZWhy/LWkMRsUDSwcB1QD/gjIh4sM1hddW79pJxCbhs+47Ltu+4bK3UFH7kz8zMzKw0fFnWzMzMrESc3JmZmZmViJM7axtJIekvhff9Jc2UdFWL41hH0gRJUyRNldSl+3EkjZD0xb6KryskLczbca+kuyVt3sQ80yQNrjF8vKS9agzfpiv7SNJikn4t6QFJ90u6S9KHmp0/L+NQSUt3ZZ6ekjSnj5c/UtLnCu8/31s/7yfph5IelHRfrg+bdj5Xh/nHSBrWG7H0NLZ69bCJ9XRol5JGSfp1d2Kuseyv5Lp8X67Xu3Zx/t38Sz/Wl/xAhbXTa8D6kgZExBvAp4FnurIASf0jYkEP4/g1cGJEXJGX+dGurB8YAXwROLeHcfSGNyJiJICkzwDHAlu3NyT2AYYBG0TEW5I+SNr3Tck/gXcocDbwet+E2Fq53owERgHXAETElfTCk+iSNgN2BjaKiHk5cV+iC/P3A8YAD9DLX3vU09i6aASFdhkRk4BJPV1orr8/JG3DK5IGAkO6MH9/YDfgKvrol37M3HNn7fY3YKf8ejRwXmWEpGUknZF7eu6pfDrOvQoXSforcH3uGTo19wZcJemayid9SRtLmihpsqTrJA2tEcNQ0vf5ARAR9+d5l5L05/wJ/R5J29ZaP3AcsFXuhTis10uo+5YFZsGivW2STpE0pjDtf0u6M/+tWRi+vaR/SHpU0s7VK6i3j6oMBWZExFsAEfF0RFTiGp3L9wFJvygsd46koyXdQTqRDgNuknRTt0ujm3LZTZB0saSHJZ0jpZ8ikHScpIdyD87xedgQSZfkMrlL0hZ5+DhJp0m6HjgLOBrYJ9ebfXK9OiVPu7qkG/Nyb5Q0PA8fr9QLequkx+v0aA0FXoiIeQAR8UJETM/zb5f30/15vy2Zh0+T9GNJt5Da4SjgnBzbgF4szkaxddpW600jaU1Jf9c7PdZrUNUui21A0oqSLs/le7ukDfLwcblcJuTyPaTGNqwMzAbm5G2YExFP5PlH5uXdJ+kySSvk4RMkHSNpInAE8Hngf3Nsa/Ri+ZolEeE//7Xlj3Rw3AC4GFgKmAJsA1yVxx8DfCm/Xh54FFiG1KvwNLBiHrcXqfdjMeADpIRmL2Bx4FZgSJ5uH9JXuVTHcSDwCinRPAxYPg8/HPhzfv0R4N85zur1vx1zu/+AhbkcH87btHGtGIFTgDH59TTgh/n1lwvlPx64NpfrWnmbl2pmH1XF9MG8jinACcDH8vBhuUyHkK4i/B+wWx4XwN6FZUwDBre6fhbK7pW8HYsBtwFbAisCj/DOtw5U6s25wJb59XBgan49DpgMDMjvxwCnFNb39nvgr8AB+fVXgMsL++SiHMe6pN99ro57YC7rR4FTga3z8KVIPyW4dn5/FnBooXy/V1jGBGBUH5RpvdjqttW8zQ3bM3AHsHthO5dm0Tr/9nvgN8BR+fWngCmFfXQrsCTpJ8peBBav2oZ+pK+G+jfwZ2CXwrj7Ctt0NHBSoTxPLUw3HtirlfXZf++vP1+WtbaKiPskjSD1FlxTNXoH4POSvpvfL0U6WQLcEBEv5ddbAhdF6hl6ttC7sw6wPnBD7mjpB8yoEcOfJV0H7AjsCnxD0oZ5ub/J0zws6Ulg7RrrfzcpXpbdDDhL0vpNzHde4f+JheEX5nL9p6THSUluUb19NLUyQUQ8LWkd0kn0U8CNkr5AOtFPiIiZOd5zgE8Cl5OS1Eua3OZWuDMingaQNIV0ye92YC7wR0lXky6zAWwPrKt3fmd0WUmD8usrI92C0JnNgD3y678AvyyMuzzvk4ckrVI9Y0TMkbQxsBWwLXCB0r189wBPRMSjedIzgW8BJ+X3FzQRV480iG0SnbfVmu05l+2qEXFZXsdcADX+ndctgT3z9P8naSVJy+VxV0fqWZwn6XlgFTr27C+UtCOwCbAdcGLephNJCf7EPOmZpES8os/L16zCyZ29G1wJHE/6ZL1SYbiAPSPikeLESjdgv1Y1XS0CHoyIzToLINKloTOAMyQ9QDqJNDo7NH3PWLtExG1K9zQNARbQ8TaMpaonb+J1rfc191GNWOaRekb/Juk50j1HNzaYZW5ELGy0zBabV3i9EOgf6Qu+P046we8LHExKXhcDNqtO4nKy0d16Uyz3Yiw162guuwnABEn3AweQeswaaUmdrhPbZDpvqzXbs6RluxFGo9/MXmRfLzJhRAB3AndKuoHUg3di9XRV3vXHDCsP33Nn7wZnAEdHvtet4Drg24X7mz5WZ/5bgD2V7r1bhZQkQrpkNiT3YCFpcUnrVc8saUdJi+fXHyAlmM8ANwP75eFrk3qkaiUxs4FBNYa3laSPkHo3XgSeJPUmLZl7KLarmnyfwv/bCsO/kMt1DeDDLLr9ne4jSRspP3kpaTHSpfgnSZfStpY0WOkm/tHAxOr5s3ddGSvdSL9cRFxDeuBjZB51PSnRq0w3ssbs0HibbiUljJDq4C1diGsdSWsVBo0klffDwAi9c0/l/rS4vBvE1kxbrTlNRLwKPC1ptzx8SaUnqxttQ7Ftb0O6D/DVJrdhmKSNqrchIl4BZknaKg9vefmaVbjnztouX+46ucaon5IuGd2Xk4dppCftql1CSlYeIN3LcwfwSkS8qXTD+a9zQtM/L6/659N2AE6WNDe//++IeFbSqcDvc+/CAtI9avNqXO65D1gg6V5gfER09gm+Lw3Ilw0h9U4ckHtKnpJ0ISnWf5Iu0RUtqfTwwmKkJKviEdIJahXgoIiYW7X9zeyjlYHTlW/eJ/V4nJKX9QPgphzrNZGfWK7hNFKv34yI2LbTUmiNQcAVkpYixV95mOYQ4LeS7iPVuZuBg2rMfxPw/by/jq0adwipF/m/gZmk+0KbNRD4jaTlSfX2MWBsLu8DgYuUnti8C/h9nWWMJ9X9N6jRC9kD9WLrtK12Ms3+wB8kHQ3MB75AVbukY50fB/w576PXSb2HzVocOD5/YJlL2j+V/XsAqdyWBh6n/n47n9QmDiHde/evLqzfrFP++TErBUkD8/08K5GShy0i4tl2x2VmZtZq7rmzsrgq9wYsAfzUiZ2Zmb1fuefOzMzMrET8QIWZmZlZiTi5MzMzMysRJ3dmZmZmJeLkzsx6RNIPlX7X9z6l38rctIvzj6l8D15+/0dJ6/ZifLtLivy9f5VhI/KXVffWOt6OWdKRfbUeM7NmOLkzs27LXyi7M7BRRGxA+umtp7owfz/Sb6q+ndxFxNci4qFeDHM06UuA9+1swu6Q1K8q5iMbzmBm1sec3JlZTwwlfbv/PICIeCH/lBuStpN0j6T7JZ1R+RJjSdMk/VjSLaTEaxRwTu71GyBpgqRRedo5kn4u6V5Jt+dfIEHSGvn9XZKOljSnVnD5VyS2AL5KneRO0tKSLsw9jxdIuqOw/tE5/gck/aIwz5y83juAzSoxSzqO/EXSSr+VC9BP0um5d/N6SQPyMiZIOlHSzZKmStpE0qWS/inpZz3ZKWb2/ubkzsx64npgNUmPSjpV0tYA+VcbxgP7RMRHSd+p+c3CfHMjYsuIOJv0o/H7RcTIGr+EsAxwe0RsSPqlh6/n4ScDJ0fEJsD0BvHtBlwbEY8CL1X9bFTFfwKzcs/jT4GN8zYMA35B+r3YkcAmlZ+4ynE9EBGbRsTbPw0WEd8H3sjbsl8evBbw24hYD3iZ/IP12ZsR8UnSL0VcAXyL9LvGY/IXcpuZdZmTOzPrtoiYQ0qGxpJ+hukCSWOAdYAnclIFcCbwycKsFzS5ijeBq/LrycCI/Hoz4KL8+twG848m/dQT+f/oGtNsWZkmIh4g/WwVwCbAhIiYGRELgHMK27CQ9LN3zXgiIio/CVfcBoAr8//7gQcjYkbuBX0cWK3J5ZuZdeBfqDCzHsm/XTsBmJB/h/cAYErDmeC1Jhc/P975pvWFdOGYlXu+PgWsLymAfkBI+l71pPUW0WDxc/N2N2Ne4fVCYECNcW9VTfcWPj6bWTe5587Muk3SOpLWKgwaCTwJPAyMkLRmHr4/MLHOYmYDg7q46tt55/JmvQcl9gLOiojVI2JERKwGPEHqqSu6BdgbID/x+tE8/A5ga0mD84MfoxtsQ9F8SYs3vylmZr3LyZ2Z9cRA4ExJD0m6D1gXGBcRc4EDgYtyb95bpPvKahkP/L7yQEWT6z0U+I6kO0kPdbxSY5rRwGVVwy4Bvlg17FRgSI7/CNJl2VciYgbwA+Am4F7g7oi4oonYTgPuKzxQYWbWUv5tWTN7z5G0NOnBhZC0LzA6Inbt5rL6AYtHxFxJawA3AmtHxJu9GLKZWcv4ng4zey/aGDhFkkhPoH6lB8taGrgpX0oV8E0ndmb2XuaeOzMzM7MS8T13ZmZmZiXi5M7MzMysRJzcmZmZmZWIkzszMzOzEnFyZ2ZmZlYi/x9BDwWq6PGgRgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt \n",
    "\n",
    "# x-coordinates of left sides of bars \n",
    "left = [1, 2, 3, 4] \n",
    "\n",
    "# heights of bars \n",
    "height = [timediff, timediff_bubble, timediff_insertion, timediff_selection] \n",
    "\n",
    "# labels for bars \n",
    "tick_label = [\"Merge Sort\", \"Bubble Sort\", \"Insertion Sort\", \"Selection Sort\"] \n",
    "\n",
    "# plotting a bar chart \n",
    "plt.bar(left, height, tick_label = tick_label, width = 0.5, color = ['blue', 'green', 'yellow', 'red']) \n",
    "\n",
    "# naming the x-axis \n",
    "plt.xlabel('Sorting Algorithm') \n",
    "# naming the y-axis \n",
    "plt.ylabel('Time Taken (s)') \n",
    "# plot title \n",
    "plt.title('The time taken for various sorting algorithms to sort 10,000 random numbers between 0 and 100,000') \n",
    "\n",
    "# function to show the plot \n",
    "plt.show() \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAr8AAAEWCAYAAABv4v9VAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3dd5xcZdn/8c83BUIJPUpLiFINiJQAD4qCYAFUQKkREBDBhuiDBWx0RVR+PCAgRoUA0jtiFBQIqNTQAqEZA5hICy0FSGjX74/7HnIymZmd3T27s9n5vl+vfe2cfp1+nfvc5xxFBGZmZmZm7WBAqwMwMzMzM+stTn7NzMzMrG04+TUzMzOztuHk18zMzMzahpNfMzMzM2sbTn7NzMzMrG10K/mVdLSkP5QVTG+RNE7S8S2atiSdLeklSXe2IoaeJmmCpC/1wnTWlXSvpNmSDu3p6XWWpMmStml1HGWRNEfSe1sw3ZC0Vg+N+8+S9mvQvWXHClt0SdpG0vRWx1G2ntwXO5hur5xT2o2kkXmdDmp1LL2tYfKbT3aVv7clvVZo3ru3guxntgI+DqweEZt3ZsAWHnhaMt0mfA+YEBFDI+LUVgdTLSLWj4gJrY6jK2qdbCJi6YiY2qqYekJE7BAR5wBI2l/SP1odE/Sdfa6ZAg5Jh0iaKGmepHE1um8n6RFJr0q6SdIaDcY1Mvfzah7mY1Xd/1fSM5JmSjpL0uLNDmvtaVFInCWtIOlKSa9IelLS51sdE3Rv35a0eN5HZ+V99rAOptXlfbvRsPU0TH7zyW7piFga+A/wmUK78zsaeTuQNLCTg6wBPBERr/REPG1mDWByVwbsySvdRfkqOt+Z6PfVodplPrujE9vxU8DxwFk1xrEScAXwY2AFYCJwcYNxXQjcC6wI/BC4TNKwPK5PAkcA2wEjgfcCxzQzbEe6cBy3bliUj5E95HTgdeDdwN7AryWt39qQgO7t20cDa5PO0x8Fvidp+1oT6c6+3cSwtUVEU3/AE8DHqtodDVwCnAvMJiUiowvdVwUuB2YAjwOHNhj/ONIG8Kc8rjuANXO3kUAAgwr9TwC+lH/vD/wTOBl4GZgKfDC3nwY8B+xXNa0zgb/mad0MrFHovl7u9iLwKLBH1bC/BsYDr1Qvk8J8X5OHnwIclNsfCMwF3gLmAMfUGHatHM9M4Hng4tz+lrwMXsnD7pnbfxq4L8/3rcCGVevs+8BDwEvA2cCQ3G0l4No83IvA34EBNeJZaLrA8nnYGXm815JKsmutm1WAScB3cvOywO+Bp4H/knasgYX1+A/gl3m8jwM71NlebszLcW6Oa5087nNzXE8CP6rMU9U28iJwfI119hqwQqHdxnkdDAbWzNN8Ibc7H1iualkfnud1HjCIwj4DLA78H+lg8lT+vXhxvqviCWCt/HvHvA5n52X2nTrLpOa2k7t9ELgrd7sL+GDV+vpJXj6v5XkrLtvTasQ0jjr7a+7+CdK+MxM4I8f1pTpxbw7cRtoWnwZOAxarsyxWBP4IzMrzcXxx2XVyPtfK7b4EvI8F982Xm5zPAL4G/Ct3P460rdyWY7ykMi90Y5/L7Q8iHU9eJB1fVq2zPIcAfyBtqy/n5fDuRsemwvH8sjzsLOAQ0gn5jRzH/R2cI44HxlW1Oxi4tdC8VF7269UYfh3SvjO00O7vwFfy7wuAnxa6bQc808ywdc43CxzHgU+RTrCzSOeNowv9j8zrZD9SQdDzwA8L3ZfI43yJtK9+F5he6P4+0rb2Muk8uVNVLGcAf87L+Z/AyqRjxEvAI8DGDZZ7AF8hbYMvkbZXFdbpH2rMx6DCPnE86dwxh7RvrUg6BlT2sZFV0zqUdI59HvgFhW0Y+CLwcI7jOhY8rwbw9Rzn44BIx+PnSPvrJGCDOvM4ATgBuDP3ezULHqv/J8/Dy8D9wDa5/U+oOpaREqNf5e6D8/r/eWE9zgWWbzTeKPdcthRpP1un0O484GfdOF7W2x4G5piez+vw61TlVmXt23mZfKLQ/Tjgojrj7/K+3WjYhvPUUQ+FET5B7eR3LunkPDBvnLfnbgOAu4EjgcVI2fhU4JMNDkYv5hU7iLTzXVRrhy3sDMXk903ggBzH8aQD1OmkpOMTpBPT0oVpzQY+krufQj6B5hU4LY9rELBJ3lDWLww7E/hQnschNeblZtLBbAiwESkZ2664UzRYzheSrmwG5OG3qtqo1yo0b0I6cGyR53u/vJ4WL6yzB4HhpCuzf5KTvryuziTt/IOBD5N3kDoH1+J0VwR2BZYEhgKXAldVr5u83h4DDi50uwr4TV7O7yIdzL5cWDZvkE7yA4GvkhLFenG9sw3k5nNJB8WhhWkfWLWNfCOv1yVqjO9GFkwGfgGcmX+vRaqusjgwjJSg/F/V/nFfXtZLVO8zwLHA7Xmeh5EOqMfV2yZYMOF7Gvhw/r08sElntp287l8C9s3zPiY3r1hYjv8B1s/dB1cv2xoxjaP+/roS6cT5udztm3m91kt+NyWdZAbl9fYw8K06070o/y0JjCLtq/8oYz7rrIe681mI7RpgmTzeecANpOPdsqREaL8S9rltScehTUjb4K+AW+oM+2VSErMkaT/aFFimiWPT0Xk97ULahpagKnnq4BxR6wR5CvDrqnYPArvWGP6zwMNV7U5jfqJyP/lCoLCdBel41HDYGtMaR9VxHNgGeH9u3hB4Ftgl9z8yT+u3ebl8IK/r9+XuPyOdkFcgHQMeJCe/eV1PAX5AOhduSzr/rFuI5fm8noaQjkOPA19g/vnspgbLPUgXVcsBI/I63b6wTjtKfqeQLtgq2+tjpIuBQaRj6tlV07opz+eI3G9l/9klj+t9edgfsWByFKRCpRXyMvwkKUdYjpQIvw9YpcGx/r/ABqRzx+WV+QJWI13o7ZjX3cdz87A654ltgQfy7w8C/wbuKHS7v8nxlnIuIxWyvFbV7jvAH7txvKy3PXyFdDFVyQluouvJb919m3SeCvJFd+62W2W51xh/l/ftRsM2mqcybvv9IyLGR8RbpKuVD+T2m5E2kmMj4vVIdQV/C+zVYFxXRMSdEfEm6SSzUSfieDwizs5xXExaucdGxLyIuJ50ZVWsQ/eniLglIuaREoYtJQ0nlaQ+kcf1ZkTcQ9rRdisMe3VE/DMi3o6IucUg8ji2Ag6PiLkRcR/wO9IJuRlvkG4TrJqHb1QH8SDgNxFxR0S8Fanu4jzSjlFxWkRMi4gXSVfBYwrTWYV0Zf5GRPw98pbTkYh4ISIuj4hXI2J2Hu/WVb2NIh10joqIsQCS3g3sQNpRX4mI50hX/sVt4smI+G1ej+fkGN/dUUz5tuWewPcjYnZEPAGcBOwr6SzgVODtiPhVXq+v1RjNBcD+uW7RvaSkbWqe5ykR8de8Pc0A/l+NeT41L+ta496btD0+l4c/hs5tE6MkLRMRL+Vtsl5/tbadTwH/iojz8rxfSDoAfqYw7LiImJy7v9FkXPX21x2ByRFxRe52KvBMvZFExN0RcXue9hOkE0r1sq2s411J29SrEfEQaRup6O35rDgxImZFxGTSwf/6iJgaETNJpXkb5/66vM+Rtp+zIuKefMz6PumYNbJGv2+QThpr5ePC3RExq8lj020RcVU+ttXajjtraVKSWTSTdIHa2X6ru1d+D+3kdCoWOI5HxISIeCA3TyJdTFZvh8dExGsRcT/ppFs53+0B/CQiXoyIaaRtvuJ/cnw/y+fCG0nJyZhCP1fm9TQXuBKYGxHnFs5nG9PYzyLi5Yj4Dymh6cy58+yI+Hdhe/13RPwtb++X1pj2iXk+/0Mqna7Mx5eBEyLi4TzsT4GNqup4n5CHfY20nQ4l3WlVHu7pBnGeFxEPRqoy+GNgj3xM2AcYHykPeTsi/kq6Bb9jnfHcBqwtaUVSAdjvgdUkLU1a3zfn/uqOt+RzWae23SaPl/W2hz1IhTaVnOCEOsuoGY3iXrrQXN2tmXF1Zt9uNGxdZSS/xZPaq8CQXJ9nDWBVSS9X/khXvo0SmepxLV2vxxqeLfx+DSAiqtsVxzet8iMi5pBKd1bNcW9RFffepNtQCw1bw6rAizkprHiSdBXZjO+RroLvVHpbwBcb9LsG8O2qWIfnGGrF+mSh2y9IV+nXS5oq6Ygm40PSkpJ+kyvmzyKVgi5XVW9ub9KV+mVV8Q4Gni7E+xvSVXPFO9tARLyafzazHaxEKlV5stCustzHkRLhjpKdy0il6NcB3yKVxnwNQNK7JF0k6b95nv+Qp1nU0XZRHduqdfqttivpQP6kpJslbVmnv3rbTvW0K9MvbpONYq+n3v66KgvuXwHUffJd0jqSrs0PLMwinTSrly2kEvNBVbEWf/f2fFZUH2fqHXe6vM9RNW/5mPUCtY8r55G24YskPSXp55IG09yxqSvLp5E5pFLxomVIJZ+d7be6e+X37E5Op2KBeZW0Rb7wnSFpJqmUrHo7bGqbZ8HtcFVgWkS8XdW9uNyb3YbqKfPc2dG0651T1gBOKRzbXyQdj2puX/ki4DTSHdpnJY2VVL0OG013MGn9rAHsXnUe3IqUbC4kJ94TSQnjR0jJ7q2kuwDF5LfReMs8l3Vq223yeNmV7bSzGsU9p9Bc3a2ZcXVm3240bF09+cDHNFJp7HKFv6ERUe9qrJHKw2FLFtqtXKvHThhe+ZGv+FYg3ZaYBtxcFffSEfHVwrCNSmueAlaQVLzqGEFKBDsUEc9ExEERsSrpSvoM1X/qexqptKEY65K5xGuh+cxxPJWnMzsivh0R7yWVjB0mabtmYgS+DawLbBERy5AOIJAOdBVHk5LHCwpJ8TRSyfRKhXiXiYgyKvY/z/ySz4oRwH8j4hbmb0MpUGlNSX+RdLekv0taLyJeJiVpHwQ+T7p9/VQe5ATSet8wz/M+VfMLHW8X1bFVxv0KhW1b0gLbdkTcFRE7kw6sV5HqkS6kwbZTPe3K9IvbZHXszZZI1vI0sHqlQZKKzTX8mlRCu3Zetj9g4WUL6fbdm1XjKm7fXZlPmuzWbd3c5xaYN0lLkUp3Fzqu5FLlYyJiFGlb/jTpFnozx6YytwNI9VsrpaOVuNek9oOqk4H3VsX3gUK/C4wr/342Il5oYthaquftAlIVluERsSypikqt7bCWp1n4WFvxFDC86gHLps8J3bTAsYXunzehzjmFdHz/ctX5aImIuLXQ/wLLPCJOjYhNSVWG1iHVlW52um+QjvvTSKXCxekuFRE/qzXN7GZSFYeNSfWabyZVw9icVJhTmZ964y3zXPYYMEjS2oV2jbbdZo+XtTTaTjur7r4dES/laVXvr/XmqTv7dqNh6+rJ5PdOYJakwyUtIWmgpA0kbdbZEUW6TfxfYJ88ni+SFnJ37ChpK0mLkSpi35FvV10LrCNpX0mD899mkt7XZKzTSFeRJ0gaImlD0oNuTb0dQ9Lukion95dIO+5buflZUl3Cit8CX8klFpK0lKRPVW0kX5e0uqQVSDvJxXk6n5a0Vk5MZuVpvEVt1dMdSioReDmP96gaw7wB7E6qD3WepAH5ltb1wEmSlpE0ICehC93i7qx8a+kS4CeShirdajuMVEJby1jgG/nA+x1SPUhISe7HSXWWdybVEYY0z3NI87wajQ/StVwI/EjSMKWnZI8sxHY/sL6kjSQNIV04ACBpMUl7S1o20m36yrpaSINtZzxpm/68pEGS9iRVS7m2QbzV67wz/gS8X9IuSneBvk7jk+5Q0nzNkbQeqX7cQvI6vgI4Ot99WI+U1FV0ZT6LngVWz8eE0nVzn7sAOCBvI4uTSnvuyLc9q6fzUUnvzxeds0j74ltdPDY9C4xUgzdj5GU9hFS3cWAed+Vp/iuBDSTtmvs5EpgUEY/kYY+WNAEgIh4j1Zs/Ko/js6S6t5fncZ0LHChplKTlSXVKxzU5bDOGkkrG50ranHQB3KxLgO9LWj7vg98odLuDlIR+L59PtiFd/FzUifF31X3ARySNkLQsqbpMd303z+dwUtWwyhP+Z5KWwfoAkpaVtHu9keTz6hZKdyVeYf4Dp/Xsk9f9kqRnKC7Lx4Q/AJ+R9MmcHwxRes9y5VhY61h2M+nY8VBEvM7851Qez/kGjcZb5rksV+O4Ajg2n8M/RDr3nFdnkKaOl3VcAhyac4LlSW9JqKs7+zZpf/1R3lbWI1XTHFcYd2j+e/C7s2/XHbaRHkt+80b5GVJdk8dJV2i/I1Wq74qDSAnHC6SrxFsb996hC0hJ24ukCuR7QyqdIT0gtxfpivYZ4ETSQybNGkOqiP4UaQM5KtcXasZmwB2S5pBKIb4ZEY/nbkcD5yjdZtkjIiaSlstppGRnCqmiffV8Xk+quzqVVHEd0itI/kZK6G4Dzoj676RdYLqkel5LkNbp7cBfag2UDyqfI5VYnpVPoF8gVU+ovIHiMurcnuqCb5AOolNJT9peQO1XtCxNKhG7VNJ9pNtVlRiWJV1FP0IqCTgvx30M6WGjmaTk7opOxnY86VbbJOAB4J7crrJzH0taH//KsRftCzyhdIvrK6RS51pqbjv5CvjTpBL7F0jVIz4dEc83iPcUYDelj7F06h3Keby7Az/P0xuV531enUG+Q0o0ZpMu6Bq9CusQ0jp6hnRyuLAy3i7OZ9GNpFKEZyQ1O0xndHmfi4gbSPUcLyeVqKxJ/ecnVibtV7NID8PczPwLrc4emy7N/1+QVK+u+Y9IF8NHkLbN13K7SsHFrqTnAl4iVSsqxj2c9CBuxV7A6Nzvz4DdKslIRPyFtE3dRLpd+yQLXnjXHbZJXyMlILNJJ/Kad1jqOCbH8zjpePtO4pKPgzuR6og+T7rQ/kIhSegxed1eTDru3E3zF4KNXJ3HdR/pWPj7PK0rSefKi/Kx6kHSPNezDGl/f4m07F4gvYmgnvNISc0zpAcDD83TnUZKFn9Aujs0jZQrVPKbWseyW0nnsEop70Ok5LvS3Mx4yzyXfS3H8xzpmPbVSM8Q1NKZ42W135KqRN1POgd1dB7rzr59FOlhwidJx6Bf5H2YfGEyh3Qu7Na+3cSwNVVef2H9kKQnSE+5/q3VsbSa0oNB10bEBkr1yh6NiIUOVJImk56MnZabpwL/E+mBBuuCfPEwHdg7Im4qedwnAitHxH5ljtd6R7743K6jW5Rm1n9I2of0Bq0y7kR0iV/ybm0nImYBj1duySmp1Bn6D+k9gShVdRlCuuq3Tsi3CpfLt+grddJuL2G860naMK+zzUm37a/s7nitNSJiIye+Zu0lIv7QysQXnPxaG5B0Iek287qSpks6kFTN5UBJ95Nude+ce/82cFBufyGwf/j2SFdsSbrl9Typ+tMuUc6rs4aSbtW9QrotfRLpNqyZmVlTXO3BzMzMzNqGS37NzMzMrG0M6rgXs0XXSiutFCNHjmx1GGZmi5S77777+YgY1uo4zHqCk1/r10aOHMnEiRNbHYaZ2SJFUne+/mXWp7nag5mZmZm1DSe/ZmZmZtY2nPyamZmZWdtw8mtmZmZmbcPJr5mZmZm1DSe/ZmZmZtY2nPyamZmZWdtw8mtmZmZmbcPJr5mZmZm1DX/hzcx6nY5Rq0PolDgqWh2CmZmVxCW/ZmZmZtY2nPyamZmZWdtw8mtmZmZmbcPJr5mZmZm1DSe/1idIOkvSc5IerNN9b0mT8t+tkj7Q2zGamZnZos/Jr/UV44DtG3R/HNg6IjYEjgPG9kZQZmZm1r/4VWfWJ0TELZJGNuh+a6HxdmD1no7JzMzM+h+X/Nqi6EDgz/U6SjpY0kRJE2fMmNGLYZmZmVlf5+TXFimSPkpKfg+v109EjI2I0RExetiwYb0XnJmZmfV5rvZgiwxJGwK/A3aIiBdaHY+ZmZktelzya4sESSOAK4B9I+KxVsdjZmZmiyaX/FqfIOlCYBtgJUnTgaOAwQARcSZwJLAicIYkgDcjYnRrojUzM7NFlZNf6xMiYkwH3b8EfKmXwjEzM7N+ytUezMzMzKxtOPk1MzMzs7bh5NfMzMzM2oaTXzMzMzNrG05+zczMzKxtOPk1MzMzs7bh5NfMzMzM2oaTXzMzMzNrG05+zczMzKxtOPk1MzMzs7bh5NfMzMzM2oaTXzMzMzNrG05+zczMzKxtOPk1MzMzs7bh5NfMzMzM2oaTXzMzMzNrG05+zczMzKxtOPk1MzMzs7bh5NfMzMzM2oaTXzMzMzNrG05+zczMzKxtOPk1MzMzs7bh5NfMzMzM2oaTXzMzMzNrG05+rU+QdJak5yQ9WKe7JJ0qaYqkSZI26e0YzczMbNHn5Nf6inHA9g267wCsnf8OBn7dCzGZmZlZP+Pk1/qEiLgFeLFBLzsD50ZyO7CcpFV6JzozMzPrLwa1OgDrfyStDIygsH1FxK3dHO1qwLRC8/Tc7uka0z+YVDrMiBEjujlZMzMz60+c/FqpJP0U2Ad4BHgrtw5gx+6Ouka7qNVjRIwFxgKMHj26Zj9mZmbWnpz8Wtl2BdaJiLklj3c6MLzQvDrwVMnTMDMzs37OdX6tbI/TM9vVNcAX8lsf/geYGRELVXkwMzMza8Qlv1a22cC9kv4GzKu0jIjDGg0k6UJgG2AlSdOBo4DBedgzgfGkqhNTgFeBA3oieDMzM+vfnPxa2f6S/zolIsZ00D2Ar3c1KDMzMzNw8msli4jfS1oMGBERU1odj5mZmVmR6/xaqSR9CngA+Gtu3kjSla2NyszMzCxx8mtlOxbYAngZICLuA9ZqaURmZmZmmZNfK9sbEfFyVTu/a9fMzMz6BNf5tbI9LGkPYICk9wDfBG5vcUxmZmZmgEt+rXyHAJsCbwNXAHOBb7U0IjMzM7PMJb9WthUj4nDg8EoLSZsA97QuJDMzM7PEJb9WtiskrVJpkPQh4NwWxmNmZmb2Die/VravA1dLepekTwJnAJ9qcUxmZmZmgKs9WMki4g5Jh5He8/s68ImIeLbFYZmZmZkBTn6tJPlDFsVXmi1JetfvryUREZ9rTWRmZmZm8zn5tbKc1uoAzMzMzDri5NdKERE3tDoGMzMzs474gTcrlaTNJN0uaaakuZLmSZrV6rjMzMzMwCW/Vr4zgH2Ai4DNgf2B4a0MyMzMzKzCJb9WtgER8SgwKCLeiIjfAh9rdVBmZmZm4JJfK98rkhYD7pf0U+BpYOkWx2RmZmYGuOTXyrc/abs6BHgLWBvYrZUBmZmZmVW45NdKIWlcROwfEVNzq7nAj1sZk5mZmVk1l/xaWTZsdQBmZmZmHXHJr5VlSUkbA6rVMSLu6eV4zMzMzBbi5NfKshpwErWT3wC27d1wzMzMzBbm5NfKMiUinOCamZlZn+Y6v2ZmZmbWNpz8WlkO7+4IJG0v6VFJUyQdUaP7CEk3SbpX0iRJO3Z3mmZmZtZenPxaKSLi+u4ML2kgcDqwAzAKGCNpVFVvPwIuiYiNgb1In1I2MzMza5qTX+srNifVG54aEa8DFwE7V/UTwDL597LAU70Yn5mZmfUDTn6tx0gaIGmZjvsE0tsiphWap+d2RUcD+0iaDowHvlFnugdLmihp4owZMzoZtZmZmfVnTn6tVJIukLSMpKWAh4BHJX23mUFrtIuq5jHAuIhYHdgROE/SQttwRIyNiNERMXrYsGGdnQUzMzPrx5z8WtlGRcQsYBdS6ewIYN8mhpsODC80r87C1RoOBC4BiIjbgCHASt0N2MzMzNqHk18r22BJg0nJ79UR8QYLl+DWchewtqT3SFqM9EDbNVX9/AfYDkDS+0jJr+s1mJmZWdOc/FrZfgM8ASwF3CJpDWBWRwNFxJvAIcB1wMOktzpMlnSspJ1yb98GDpJ0P3AhsH9ENJNYm5mZmQEg5w7W0yQNysltrxs9enRMnDixFZO2BnRMrSrefVcc5eOktRdJd0fE6FbHYdYTXPJrpZK0oqRTJd0j6W5Jp5BeS2ZmZmbWck5+rWwXkerh7grsln9f3NKIzMzMzLJBrQ7A+p0VIuK4QvPxknZpWTRmbWfRqlLS3POwZmblccmvle0mSXvlD1wMkLQH8KdWB2VmZmYGTn6tfF8GLgBeB+aRqkEcJmm2pA7f+mBmZmbWk1ztwUoVEUNbHYOZmZlZPS75tVIp2UfSj3PzcEmbtzouMzMzM3Dya+U7A9gS+HxungOc3rpwzMzMzOZztQcr2xYRsYmkewEi4qX8uWIzMzOzlnPJr5XtDUkDye8vkjQMeLu1IZmZmZklTn6tbKcCVwLvkvQT4B/ACa0NyczMzCxxtQcrVUScL+luYDvS2/Z3iYiHWxyWmZmZGeDk10om6byI2Bd4pEY7MzMzs5ZytQcr2/rFhlz/d9MWxWJmZma2ACe/VgpJ35c0G9hQ0qz8RbfZwHPA1S0Oz8zMzAxw8msliYgT8tfdfhERy0TE0Py3YkR8v9XxmZmZmYHr/FpJJK0BvFxJdCV9FNgFeAI4PSJeb2F4ZmZmZoBLfq08lwBLAUjaCLgU+A+wEemrb2ZmZmYt55JfK8sSEfFU/r0PcFZEnCRpAHBfC+MyMzMze4dLfq0sKvzeFrgBICL8dTczMzPrM1zya2W5UdIlwNPA8sCNAJJWAVzf18zMzPoEJ79Wlm8BewKrAFtFxBu5/crAD1sWlZmZmVmBk18rRUQEcFGN9ve2IBwzMzOzmlzn18zMzMzahpNf6zMkbS/pUUlTJB1Rp589JD0kabKkC3o7RjMzM1u0Ofm1Uki6If8/sYvDDwROB3YARgFjJI2q6mdt4PvAhyJifVI9YzMzM7Omuc6vlWUVSVsDO0m6iAVffUZE3NPB8JsDUyJiKkAex87AQ4V+DiJ9Le6lPM7nygrezMzM2oOTXyvLkcARwOrA/6vqFqR3/zayGjCt0Dwd2KKqn3UAJP0TGAgcHRF/qR6RpIOBgwFGjBjRZPhmZmbWDpz8Wiki4jLgMkk/jojjujAK1WgXVc2DgLWBbUhJ9t8lbRARL1fFMhYYCzB69OjqcZiZmVkbc/JrpYqI4yTtBHwkt5oQEdc2Meh0YHiheXXgqRr93J7fIfy4pEdJyfBd3QzbzMzM2oQfeLNSSToB+Capru5DwDdzu47cBawt6T2SFgP2Aq6p6ucq4KN5OiuRqkFMLSt2MzMz6/9c8mtl+xSwUUS8DSDpHOBe0lsa6oqIN+wa+XkAABVsSURBVCUdAlxHqs97VkRMlnQsMDEirsndPiHpIeAt4LsR8UIPzouZmZn1M05+rScsB7yYfy/b7EARMR4YX9XuyMLvAA7Lf2ZmZmad5uTXynYCcK+km0gPsX2EDkp9zczMzHqLk18rVURcKGkCsBkp+T08Ip5pbVRmZmZmiZNfK11EPM3CD6uZmZmZtZzf9mBmZmZmbcPJr5mZmZm1DSe/VhpJAyQ92Oo4zMzMzOpx8mulye/2vV/SiFbHYmZmZlaLH3izsq0CTJZ0J/BKpWVE7NS6kMzMzMwSJ79WtmNaHYCZmZlZPU5+rVQRcbOkNYC1I+JvkpYkfa7YzMzMrOVc59dKJekg4DLgN7nVasBVrYvIzMzMbD6X/FrZvg5sDtwBEBH/kvSu1oZkZlYCqdURdE5EqyMw65Nc8mtlmxcRr1caJA0CfAQ2MzOzPsHJr5XtZkk/AJaQ9HHgUuCPLY7JzMzMDHDya+U7ApgBPAB8GRgP/KilEZmZmZllrvNrpYqItyWdQ6rzG8CjEa54ZmZmZn2Dk18rlaRPAWcC/wYEvEfSlyPiz62NzMzMzMzJr5XvJOCjETEFQNKawJ8AJ79mZmbWcq7za2V7rpL4ZlOB51oVjJmZmVmRS36tFJI+l39OljQeuIRU53d34K6WBWZmZmZW4OTXyvKZwu9nga3z7xnA8r0fjpmZmdnCnPxaKSLigFbHYGZmZtYRJ79WKknvAb4BjKSwfUXETq2KyczMzKzCya+V7Srg96Svur3d4ljMzMzMFuC3PVjZ5kbEqRFxU0TcXPlrZkBJ20t6VNIUSUc06G83SSFpdHlhm5mZWTtwya+V7RRJRwHXA/MqLSPinkYDSRoInA58HJgO3CXpmoh4qKq/ocChpC/ImZmZmXWKk18r2/uBfYFtmV/tIXJzI5sDUyJiKoCki4CdgYeq+jsO+DnwnbICNjMzs/bh5NfK9lngvRHxeieHWw2YVmieDmxR7EHSxsDwiLhWkpNfMzMz6zTX+bWy3Q8s14XhVKNdvNNRGgCcDHy7wxFJB0uaKGnijBkzuhCKmZmZ9Vcu+bWyvRt4RNJdLFjnt6NXnU0HhheaVweeKjQPBTYAJkgCWBm4RtJOETGxOKKIGAuMBRg9enRgZmZmljn5tbId1cXh7gLWzu8J/i+wF/D5SseImAmsVGmWNAH4TnXia2ZmZtaIk18rVbOvNasx3JuSDgGuAwYCZ0XEZEnHAhMj4poy4zQzM7P25OTXSiVpNvPr6i4GDAZeiYhlOho2IsYD46vaHVmn3226F6mZmZm1Iye/VqqIGFpslrQL6TVmZmZmZi3ntz1Yj4qIq+j4Hb9mZmZmvcIlv1YqSZ8rNA4ARlN4ZZmZmZlZKzn5tbJ9pvD7TeAJ0pfazMzMzFrOya+VKiIOaHUMZmZmZvU4+bVSSKr5VoYsIuK4XgvGzMzMrA4nv1aWV2q0Wwo4EFgRcPJrZmZmLefk10oRESdVfksaCnwTOAC4CDip3nBmZmZmvcnJr5VG0grAYcDewDnAJhHxUmujMjMzM5vPya+VQtIvgM8BY4H3R8ScFodkZmZmthB/5MLK8m1gVeBHwFOSZuW/2ZJmtTg2MzMzM8Alv1aSiPCFlJmZmfV5TljMzMzMrG04+TUzMzOztuHk18zMzMzahpNfMzMzM2sbTn7NzMzMrG04+TUzMzOztuHk18zMzMzahpNfMzMzM2sbTn7NzMzMrG04+TUzMzOztuHk18zMzMzahpNfMzMzM2sbTn6tz5C0vaRHJU2RdESN7odJekjSJEk3SFqjFXGamZnZosvJr/UJkgYCpwM7AKOAMZJGVfV2LzA6IjYELgN+3rtRmpmZ2aLOya/1FZsDUyJiakS8DlwE7FzsISJuiohXc+PtwOq9HKOZmZkt4pz8Wl+xGjCt0Dw9t6vnQODPPRqRmZmZ9TuDWh2AWaYa7aJmj9I+wGhg6zrdDwYOBhgxYkRZ8ZmZmVk/4JJf6yumA8MLzasDT1X3JOljwA+BnSJiXq0RRcTYiBgdEaOHDRvWI8GamZnZosnJr/UVdwFrS3qPpMWAvYBrij1I2hj4DSnxfa4FMZqZmdkizsmv9QkR8SZwCHAd8DBwSURMlnSspJ1yb78AlgYulXSfpGvqjM7MzMysJtf5tT4jIsYD46vaHVn4/bFeD8rMzMz6FZf8mpmZmVnbcPJrZmZmZm3Dya+ZmZmZtQ0nv2ZmZmbWNpz8mpmZmVnbcPJrZmZmZm3Dya+ZmZmZtQ0nv2ZmZmbWNpz8mpmZmVnbcPJrZmZmZm3Dya+ZmZmZtQ0nv2ZmZmbWNpz8mpmZmVnbcPJrZmZmZm3Dya+ZmZmZtQ0nv2ZmZmbWNpz8mpmZmVnbcPJrZmZmZm3Dya+ZmZmZtQ0nv2ZmZmbWNpz8mpmZmVnbcPJrZmZmZm3Dya+ZmZmZtQ0nv2ZmZmbWNpz8mpmZmVnbcPJrfYak7SU9KmmKpCNqdF9c0sW5+x2SRvZ+lGZmZrYoc/JrfYKkgcDpwA7AKGCMpFFVvR0IvBQRawEnAyf2bpRmZma2qHPya33F5sCUiJgaEa8DFwE7V/WzM3BO/n0ZsJ0k9VRA0qL1Z2ZmZh0b1OoAzLLVgGmF5unAFvX6iYg3Jc0EVgSeL/Yk6WDg4Nw4R9KjPRJx161EVcxlcAIM9NSyPdoLlx5atuBlS08t2+4dFNYoKwyzvsbJr/UVtY7S0YV+iIixwNgyguoJkiZGxOhWx9Efedn2HC/bnuNla9a7XO3B+orpwPBC8+rAU/X6kTQIWBZ4sVeiMzMzs37Bya/1FXcBa0t6j6TFgL2Aa6r6uQbYL//eDbgxIhYq+TUzMzOrx9UerE/IdXgPAa4DBgJnRcRkSccCEyPiGuD3wHmSppBKfPdqXcTd0merZPQDXrY9x8u253jZmvUiueDMzMzMzNqFqz2YmZmZWdtw8mtmZmZmbcPJr1kmKSSdV2geJGmGpGt7OY51JU2QdJ+khyV1qj6gpJGSPt9T8XWGpLfyfNwv6R5JH2ximCckrVSj/ThJu9Vov01n1pGkAZJOlfSgpAck3SXpPc0On8fxLUlLdmaY7pA0p4fHv5GkHQvNO9X6xHgXx/1DSZMlTcrbQvX7uzsafn9Jq5YRS3djq7cNNjGdBfZJSaMlndqVmGuM+4t5O56Ut+nqjwN1NPwuNb6madav+YE3s/leATaQtEREvAZ8HPhvZ0YgaVBEvNnNOE4FTo6Iq/M439+Z6QMjgc8DF3QzjjK8FhEbAUj6JHACsHVrQ2JPYFVgw4h4W9LqpHXflPwp7m8BfwBe7ZkQe0/eZjYCRgPjAfIDptVvW+nKuLcEPg1sEhHz8kXNYp0YfiCwP/AgC7/6sKWxddJICvtkREwEJnZ3pHnb/SFpHmZKWhoY1onhBwG7ANcCD3U3HrNFhUt+zRb0Z+BT+fcY4MJKB0lLSTorlxTeWylhySVTl0r6I3B9Llk8I5coXStpfKW0SNKmkm6WdLek6yStUiOGVUjvNAYgIh7Iww6RdHYu5blX0kdrTR/4GfDhXJL1v6Uvoa5bBngJFi6tlXSapP0L/X5X0p35b61C+49J+rukxyR9unoC9dZRlVWApyPibYCImB4RlbjG5OX7oKQTC+OdI+lYSXeQko1VgZsk3dTlpdEFeblNkHSZpEcknS+lz3hJ+pmkh3IJ4C9zu2GSLs/L4y5JH8rtj5Y0VtL1wLnAscCeeZvZM29Tp+V+15B0Qx7vDZJG5PbjlErQb5U0tU6J6CrA8xExDyAino+Ip/Lw2+V19EBeZ4vn9k9IOlLSP0j74Gjg/BzbEiUuzkaxdbif1utH0lqS/qb5dzvWpGqfLG7/klaQdFVevrdL2jC3Pzovlwl5+R5aYx7eBcwG5uR5mBMRj+fhN8rjmyTpSknL5/YTJP1U0s3A4cBOwC9ybGuWuHzN+q6I8J///BcB6QSyIXAZMAS4D9gGuDZ3/ymwT/69HPAYsBSpZGo6sELuthupBG0AsDIp4dsNGAzcCgzL/e1JeqVbdRwHADNJifj/Asvl9t8Gzs6/1wP+k+Osnv47Mbf6D3grL8dH8jxtWitG4DRg//z7CeCH+fcXCst/HPCXvFzXzvM8pJl1VBXT6nka9wEnARvn9qvmZTqMdFfsRmCX3C2APQrjeAJYqTe3zcJym5nnYQBwG7AVsALwKPPf4FPZZi4Atsq/RwAP599HA3cDS+Tm/YHTCtN7pxn4I7Bf/v1F4KrC+rg0xzEKmFIj7qXzcn4MOAPYOrcfQvpU+Tq5+VzgW4Vl+73COCYAo3tgmdaLre5+mue54b4M3AF8tjCfS7Lw9v5OM/Ar4Kj8e1vgvsI6uhVYnPT54xeAwVXzMJD0esj/AGcDnyl0m1SYp2OB/ysszzMK/Y0Dduutbdl//usLf672YFYQEZMkjSSVOI2v6vwJYCdJ38nNQ0gJBcBfI6LytbmtgEsjlSw+UygdXBfYAPhrLqwbCDxdI4azJV0HbA/sDHxZ0gfyeH+V+3lE0pPAOjWm35cUqz1sCZwraYMmhruw8P/kQvtL8nL9l6SppIuAonrr6OFKDxExXdK6pERjW+AGSbuTkqEJETEjx3s+8BHgKlISf3mT89zT7oyI6QCS7iPdUr8dmAv8TtKfSLexAT4GjMrbG8Aykobm39dEqt7TkS2Bz+Xf5wE/L3S7Kq+PhyS9u3rAiJgjaVPgw8BHgYuV6hLfCzweEY/lXs8Bvg78X26+uIm4uqVBbBPpeD+tuS/nZbtaRFyZpzEXoLD8a9kK2DX3f6OkFSUtm7v9KVLJ9DxJzwHvZsG7Qm9J2h7YDNgOODnP08mkC6Cbc6/nkC5UKnp8+Zr1ZU5+zRZ2DfBLUunMioX2AnaNiEeLPSs9JPNKVX+1CJgcEVt2FECk269nAWdJepB0om10Bm26zmqrRMRtSvUqhwFvsmC1qyHVvTfxu1ZzzXVUI5Z5pJL1P0t6llTv8YYGg8yNiLcajbMXzSv8fgsYFOkjMZuTEqC9gENIif0AYMvqJDcnY13dZorLvBhLze0zL7cJwARJD5C+0nhfB9Pole25Tmx30/F+WnNflrRMF8Kotdwqy3ihdb1QjxEB3AncKemvpBLgk6v7q9LnjxdmPcl1fs0WdhZwbOS6tgXXAd8o1LHcuM7w/wB2Var7+25SEg3ptvSwXAKKpMGS1q8eWNL2kgbn3yuTEvD/ArcAe+f265BKNGslebOBoTXat5Sk9UglZC8AT5JKJBfPpVzbVfW+Z+H/bYX2u+fluibwXhae/w7XkaRNlN8eIGkAqarLk6Tb1VtLWknpQasxwM3Vw2d9ahkrPei0bESMJz2Mt1HudD0pEa70t1GNwaHx/NzK/K8p7k3avpuNa11JaxdabURa1o8AIzW/Pve+9PKybhBbM/tpzX4iYhYwXdIuuf3iSm8FaTQPxf16G1I95FlNzsOqkjapnoeImAm8JOnDuX2vL1+zvswlv2ZV8i3lU2p0Oo50W3ZSTq6eID0tXu1yUjL3IKk+4R3AzIh4XemhoFNzwjcoj29y1fCfAE6RNDc3fzcinpF0BnBmLqF6k1RHdl6NW6qTgDcl3Q+Mi4iOSoF60hL51jykEq79cmnbNEmXkGL9F+k2eNHiSg+XDSAloRWPkk7i7wa+EhFzq+a/mXX0LuC3yg9YkUrNTsvj+j5wU451fOQ3btQwllRq/HREfLTDpdDzhgJXSxpCir3yoOOhwOmSJpG2t1uAr9QY/ibgiLyuTqjqdijpDsR3gRmkOunNWhr4laTlSNvsFODgvKwPAC5VeuPAXcCZdcYxjrTdv0aNUuxuqBdbh/tpB/3sC/xG6dPsbwC7U7VPsuD2fjRwdl5Hr5JKn5s1GPhlvpibS1o/lfW7H2m5LQlMpf56u4i0PxxKqvv7705M32yR5M8bm/UASUvnOoUrkpKrD0XEM62Oy8zMrN255NesZ1ybS5QWA45z4mtmZtY3uOTXzMzMzNqGH3gzMzMzs7bh5NfMzMzM2oaTXzMzMzNrG05+zaxfkfRDSZMlTZJ0X/4ISWeG37/yHuDc/DtJo0qM77OSIr/3uNJuZP6YSVnTeCdmST/oqemYmS2KnPyaWb+RPzrwaWCTiNiQ9HnfaZ0YfiCwP/BO8hsRX4qIh0oMcwzpQxF7ddRjV0gaWBXzDxoOYGbWZpz8mll/sgrpC1nzACLi+fypaCRtJ+leSQ9IOqvykQtJT0g6UtI/SInpaOD8XGq8hKQJkkbnfudI+omk+yXdnr/gh6Q1c/Ndko6VNKdWcPlLbB8CDqRO8itpSUmX5JLriyXdUZj+mBz/g5JOLAwzJ0/3DmDLSsySfkb+0Iik83PvAyX9NpeOXy9piTyOCZJOlnSLpIclbSbpCkn/knR8d1aKmVlf4uTXzPqT64Hhkh6TdIakrQHyl8/GAXtGxPtJ7zj/amG4uRGxVUT8AZgI7B0RG9X4mthSwO0R8QHS19IOyu1PAU6JiM2ApxrEtwvwl4h4DHix6tO0FV8DXsol18cBm+Z5WBU4EdiW9BnbzSqf0c1xPRgRW0TEO58fjogjgNfyvOydW68NnB4R6wMvA7sWpv16RHyE9LW1q4GvAxsA++cPtpiZLfKc/JpZvxERc0jJ4sGkT71eLGl/YF3g8Zx0ApwDfKQw6MVNTuJ14Nr8+25gZP69JXBp/n1Bg+HHkD4nS/4/pkY/W1X6iYgHSZ/GBdgMmBARMyLiTeD8wjy8RfqsdjMej4jKJ6eL8wBwTf7/ADA5Ip7OpehTgeFNjt/MrE/zF97MrF+JiLeACcAESQ8A+wH3NRwIXmly9G/E/C8DvUUnjqG55HRbYANJAQwEQtL3qnutN4oGo5+b57sZ8wq/3wKWqNHt7ar+3sbnCzPrJ1zya2b9hqR1Ja1daLUR8CTwCDBS0lq5/b7AzXVGMxsY2slJ38786gP1HmTbDTg3ItaIiJERMRx4nFTSW/QPYA+A/MaG9+f2dwBbS1opP5g3psE8FL0haXDzs2Jm1r85+TWz/mRp4BxJD0maBIwCjo6IucABwKW5NPhtUr3WWsYBZ1YeeGtyut8CDpN0J+mhu5k1+hkDXFnV7nLg81XtzgCG5fgPJ1V7mBkRTwPfB24C7gfuiYirm4htLDCp8MCbmVlb0/w7eGZm1hWSliQ9WBaS9gLGRMTOXRzXQGBwRMyVtCZwA7BORLxeYshmZm3LdbjMzLpvU+A0SSK9QeGL3RjXksBNuaqCgK868TUzK49Lfs3MzMysbbjOr5mZmZm1DSe/ZmZmZtY2nPyamZmZWdtw8mtmZmZmbcPJr5mZmZm1jf8PLVIjBvpYMLEAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt \n",
    "\n",
    "# x-coordinates of left sides of bars \n",
    "left = [1, 2, 3, 4] \n",
    "\n",
    "# heights of bars \n",
    "height = [len(counter), len(counter_bubble), len(counter_insertion), len(counter_selection)] \n",
    "\n",
    "# labels for bars \n",
    "tick_label = [\"Merge Sort\", \"Bubble Sort\", \"Insertion Sort\", \"Selection Sort\"] \n",
    "\n",
    "# plotting a bar chart \n",
    "plt.bar(left, height, tick_label = tick_label, width = 0.5, color = ['blue', 'green', 'yellow', 'red']) \n",
    "\n",
    "# naming the x-axis \n",
    "plt.xlabel('Sorting Algorithm') \n",
    "# naming the y-axis \n",
    "plt.ylabel('Number of Steps Taken') \n",
    "# plot title \n",
    "plt.title('The number of steps taken for various sorting algorithms to sort 10,000 random numbers between 0 and 100,000') \n",
    "\n",
    "# function to show the plot \n",
    "plt.show() \n"
   ]
  }
 ],
 "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
}