{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "2bbc5d9c",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# More Linked List Operations\n",
    "#### CS 66: Introduction to Computer Science II"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "773a6458",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## References for this lecture\n",
    "\n",
    "Problem Solving with Algorithms and Data Structures using Python\n",
    "\n",
    "\n",
    "Section 3.6 (Big O of list operations): [https://runestone.academy/ns/books/published/pythonds/AlgorithmAnalysis/Lists.html](https://runestone.academy/ns/books/published/pythonds/AlgorithmAnalysis/Lists.html)\n",
    "\n",
    "Section 4.19-4.23: [https://runestone.academy/ns/books/published/pythonds/BasicDS/toctree.html](https://runestone.academy/ns/books/published/pythonds/BasicDS/toctree.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "534a7954",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Review: This is what our linked list Node class looked like"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "48c26dd6",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node:\n",
    "    def __init__(self,initdata):\n",
    "        self.data = initdata\n",
    "        self.next = None\n",
    "\n",
    "    def getData(self):\n",
    "        return self.data\n",
    "\n",
    "    def getNext(self):\n",
    "        return self.next\n",
    "\n",
    "    def setData(self,newdata):\n",
    "        self.data = newdata\n",
    "\n",
    "    def setNext(self,newnext):\n",
    "        self.next = newnext"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9bcaeb0",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Review: An Unordered List Data Structure based on a Linked List\n",
    "\n",
    "We previously looked at the UnorderedList ADT:\n",
    "\n",
    "> * `List()` creates a new list that is empty. It needs no parameters and returns an empty list.\n",
    "> * `add(item)` adds a new item to the list. It needs the item and returns nothing. Assume the item is not already in the list.\n",
    "> * `remove(item)` removes the item from the list. It needs the item and modifies the list. Assume the item is present in the list.\n",
    "> * `search(item)` searches for the item in the list. It needs the item and returns a boolean value.\n",
    "> * `isEmpty()` tests to see whether the list is empty. It needs no parameters and returns a boolean value.\n",
    "> * `size()` returns the number of items in the list. It needs no parameters and returns an integer.\n",
    "> * `append(item)` adds a new item to the end of the list making it the last item in the collection. It needs the item and returns nothing. Assume the item is not already in the list.\n",
    "> * `index(item)` returns the position of item in the list. It needs the item and returns the index. Assume the item is in the list.\n",
    "> * `insert(pos,item)` adds a new item to the list at position pos. It needs the item and returns nothing. Assume the item is not already in the list and there are enough existing items to have position pos.\n",
    "> * `pop()` removes and returns the last item in the list. It needs nothing and returns an item. Assume the list has at least one item.\n",
    "> * `pop(pos)` removes and returns the item at position pos. It needs the position and returns the item. Assume the item is in the list.\n",
    "\n",
    "We also talked about how the built-in Python `list` type is a pretty good match for this.\n",
    "\n",
    "Now, we will implement the ADT as a linked list - following Section 4.21 in the book"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46ef1b22",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## A start to UnorderedList\n",
    "\n",
    "The code we've written so far for the linked-list-based `UnorderedList` looks like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "16e33c57",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "class UnorderedList:\n",
    "\n",
    "    def __init__(self):\n",
    "        self.head = None\n",
    "        \n",
    "    def isEmpty(self):\n",
    "        return self.head == None\n",
    "    \n",
    "    #this method is really a prepend - it puts the new node at the beginning\n",
    "    def add(self,item):\n",
    "        temp = Node(item)\n",
    "        temp.setNext(self.head)\n",
    "        self.head = temp\n",
    "\n",
    "        \n",
    "#testing it out\n",
    "my_list = UnorderedList()\n",
    "print(my_list.isEmpty())\n",
    "\n",
    "my_list.add(31)\n",
    "my_list.add(77)\n",
    "my_list.add(17)\n",
    "my_list.add(93)\n",
    "my_list.add(26)\n",
    "print(my_list.isEmpty())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb9b02e5",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Traversing a linked list\n",
    "\n",
    "Some of the operations you need to perform with a linked list require you to traverse (i.e., loop over) all/many items in the list.\n",
    "\n",
    "For example, if I wanted to display each item in a list, I could do it with a loop as in the `display()` method below:\n",
    "\n",
    "_we're going to add on to the book example_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b038d81d",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class UnorderedList:\n",
    "\n",
    "    def __init__(self):\n",
    "        self.head = None\n",
    "        \n",
    "    def isEmpty(self):\n",
    "        return self.head == None\n",
    "    \n",
    "    #this method is really a prepend - it puts the new node at the beginning\n",
    "    def add(self,item):\n",
    "        temp = Node(item)\n",
    "        temp.setNext(self.head)\n",
    "        self.head = temp\n",
    "        \n",
    "    def display(self):\n",
    "        current = self.head #start with the Node at the head\n",
    "        while current: #this will keep going until current equals None\n",
    "            print(current.getData()) #display the current Node's data\n",
    "            current = current.getNext() #move on to the next Node in the list"
   ]
  },
  {
   "attachments": {
    "traverse.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "e12502fa",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "<div>\n",
    "<img src=\"attachment:traverse.png\" />\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "46a83244",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "54\n",
      "26\n",
      "93\n",
      "17\n",
      "77\n",
      "31\n"
     ]
    }
   ],
   "source": [
    "my_list = UnorderedList()\n",
    "\n",
    "my_list.add(31)\n",
    "my_list.add(77)\n",
    "my_list.add(17)\n",
    "my_list.add(93)\n",
    "my_list.add(26)\n",
    "my_list.add(54)\n",
    "my_list.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0b62137",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Let's do it with `__repr__` instead"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "63249c25",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "54 -> 26 -> 93 -> 17 -> 77 -> 31 -> None\n"
     ]
    }
   ],
   "source": [
    "class UnorderedList:\n",
    "\n",
    "    def __init__(self):\n",
    "        self.head = None\n",
    "        \n",
    "    def isEmpty(self):\n",
    "        return self.head == None\n",
    "    \n",
    "    #this method is really a prepend - it puts the new node at the beginning\n",
    "    def add(self,item):\n",
    "        temp = Node(item)\n",
    "        temp.setNext(self.head)\n",
    "        self.head = temp\n",
    "            \n",
    "    def __repr__(self):\n",
    "        list_representation = \"\"\n",
    "        current = self.head #start with the Node at the head\n",
    "        while current: #this will keep going until current equals None\n",
    "            list_representation += str(current.getData())+\" -> \"\n",
    "            current = current.getNext() #move on to the next Node in the list\n",
    "        list_representation += \"None\" #the last one in the list points to None\n",
    "        return list_representation\n",
    "            \n",
    "my_list = UnorderedList()\n",
    "\n",
    "my_list.add(31)\n",
    "my_list.add(77)\n",
    "my_list.add(17)\n",
    "my_list.add(93)\n",
    "my_list.add(26)\n",
    "my_list.add(54)\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36868886",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Traversing to get an item by its index\n",
    "\n",
    "If you want to get an item by its index, you need to traverse the list and count until you find it.\n",
    "\n",
    "_Note:_ This is not one of the methods that is listed in the ADT, but I think it is ok to allow it since it's something that you can do with a built-in Python list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0ae538b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "54 -> 26 -> 93 -> 17 -> 77 -> 31 -> None\n",
      "17\n",
      "31\n"
     ]
    }
   ],
   "source": [
    "class UnorderedList:\n",
    "\n",
    "    def __init__(self):\n",
    "        self.head = None\n",
    "        \n",
    "    def isEmpty(self):\n",
    "        return self.head == None\n",
    "    \n",
    "    #this method is really a prepend - it puts the new node at the beginning\n",
    "    def add(self,item):\n",
    "        temp = Node(item)\n",
    "        temp.setNext(self.head)\n",
    "        self.head = temp\n",
    "            \n",
    "    def __repr__(self):\n",
    "        list_representation = \"\"\n",
    "        current = self.head #start with the Node at the head\n",
    "        while current: #this will keep going until current equals None\n",
    "            list_representation += str(current.getData())+\" -> \"\n",
    "            current = current.getNext() #move on to the next Node in the list\n",
    "        list_representation += \"None\" #the last one in the list points to None\n",
    "        return list_representation\n",
    "    \n",
    "    def get(self,index):\n",
    "        \n",
    "        if index < 0:\n",
    "            raise Exception(\"list index \"+str(index)+\" is out of range\")\n",
    "        \n",
    "        current = self.head\n",
    "        item_counter = 0\n",
    "        \n",
    "        while current and item_counter < index:\n",
    "            \n",
    "            current = current.getNext()\n",
    "            item_counter += 1\n",
    "            \n",
    "        if current == None:\n",
    "            raise Exception(\"list index \"+str(index)+\" is out of range\")\n",
    "            \n",
    "        return current.getData()\n",
    "            \n",
    "my_list = UnorderedList()\n",
    "\n",
    "my_list.add(31)\n",
    "my_list.add(77)\n",
    "my_list.add(17)\n",
    "my_list.add(93)\n",
    "my_list.add(26)\n",
    "my_list.add(54)\n",
    "print(my_list)\n",
    "\n",
    "print(my_list.get(3))\n",
    "\n",
    "print(my_list.get(5))"
   ]
  },
  {
   "attachments": {
    "traverse.png": {
     "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgAAAACdCAYAAADCH8BOAAAC/GlDQ1BpY2MAAHjajZPLbxtVFMZ/Y4+nlRKxwbTFqtAVizZCSTR9qE2EaGvHrpU2GGuaFCdCqibja3vIzXh6Z5w+1AXqhh0tiD3iIVb8ARXqgl1XKJWqgpAq1lQIVKmoG1TMwo+ZlkA5q3O/853vfPdcXch96oahygjYDGLtVEuisbomdv1EhleZoMCE60VhsV5fAnDDUPGPePIDBsC9mZ3r/xkTTRl5YOwGus3I2wTjMmTPe6GOwbwLzF2Kwxhyu4G8bqyuQW4/kG8PchvIrw/yMpDXy84C5BrAS17HbUKuA0yvp/B2Kh94ACBflYHUviecaknUdbflK5my+4Ly/4xN1RvNexmYDOOSAxwA/mjp0yvAFBiFq53ld4E9YJT8eHF5iDeC9do7A77xwUb3rDPkfN2U5QowDcbtaOtcZcS52lmoDTm/vO+eqQMFMP4K4/pQJ7MvULWlgX7mhIwq50Z4yz+9OMRboaovDfQzH+meswK8DplvXV2pDvkPZLAy7M1mmm75LDAL2SnqSDQtfBQChyolBFUkAQ/R+Hh0qaPpjlltHo6rF+khETicp3Sz0JtKVK7rC763fePRM93d1JQ2kgA5nlJNnSM2xswZwkThzrXb+xKN++at9+5N3rlGEYWijWQTiU+AJEoppDy0gpuFRMHbvvFIflh7UuP6dILaP9q/2fftz+2v7F//ZUft53ZUTM2XBDu6lyhWUWOHO7N8FD4rBPhcQqKJcFEEXEGkdzHqNl8zD5mL5pw5jzBPmqfME2bZnDPfNJdGDKtila0iwnrDmrcOWWesYnIT66BVtuatg1blmRfwUndNv6BMsWRqIzOsI4nYQOOzhUQRISGWl2OAhW54RfvtTiwO2/ZxUQxDJcVi4M1OC1cpof12J46ElpHUW7I5S2N1TQy+42MHAzD2bCdY/Da89Ttk7ybYWg++iWDv0QSbKsArn8GtY15Pbw3/t2F8D1HryOHBabIEuZ/7/ccHYNcn8PTjfv/PL/r9p19C9gF8p/4GqSMK1roTvtgAAAAGYktHRAD/AP8A/6C9p5MAAAAJcEhZcwAAFxIAABcSAWef0lIAAFnOSURBVHja7b13dFTX1ff/vdM1mlEdjVDvBdFEkSiiiCI6BhzbcezYxo7j13FsJ2YlBpc3cdzjX+L48RPbCbEdjBsQMMZgqgDThEWTEBLqXUJCvU1vvz94782dqzuSRpphBDqftWZJ0/fdc84+++yzzz6UzWazgUAgEAgEwphC4GkBCAQCgUAg3HqIA0AgEAgEwhiEOACEMYHVaoXFYvG0GAQCgTBqIA4AYUxw6dIlbNu2zdNiEAgEwqiBOACEEaPX61FbWwuz2expURxSWVmJkydPelqMMY3FYkFlZSW6u7s9LQqBQABxAAguoKamBu+++y56enqYx+jNJTabjfnfZDLBYDBgqBtPLBYLTCaT3WfS77VarcxrdDqdXXjfarVCr9czrwEAiqIgEJDm7kmMRiNeeOEF3HPPPfjggw9QVlYGo9HoabEIhDGLyNMCEG5vmpub8dVXX+Hs2bN4//33MW/ePMyfPx9ffPEFYmNjcfHiRaxZswZtbW04cOAA+vr6kJGRgbvvvhslJSUoLS3FunXrIBAI0NDQgJycHKxevRpVVVXYvXs3tFotli9fjoULFyI/Px+lpaUQiUTQarWYNWsWdu7cidbWVgQHB+Pxxx+HVqvFV199hZaWFkRHR+ORRx6Bv7+/p9VEwE0nrLOzE9nZ2fjhhx8QERGBxYsXY/Xq1Zg9ezZUKhVx0giEWwhxAAagtbUVe/fuRW9vLyiK8rQ4HsVmsyEgIADr16+Hj48P87hcLkdYWBiUSiWSk5MREhICk8mEbdu2wcvLC3fddRf8/PzQ0NCARYsWgaIovPnmm4iMjIRSqcTWrVsxffp0REVF4ejRoygoKMDs2bPx5z//GcuXL0dYWBh27dqFxMREVFZW4g9/+ANWrVqFdevW4csvv4RYLMazzz6L0tJSCAQC6HQ6JCcnY/ny5Xj33XchEonw9NNPD+uarVYrjhw5guLi4jH/+7sCo9GI2tpaAIDZbEZ1dTU+/vhjfP3115g4cSJWrlyJFStWYPz48VAoFJ4Wl0C44yEOwADodDqUlpais7NzzA8ANpsNISEh/UK2Pj4+SEtLw5kzZ5CVlYXAwEBotVqYzWasX78ev/zlLwEAixYtglarRUdHB4KCgnD16lU89thjCA8Px5kzZxASEoJTp07hoYceQl5eHioqKqDT6VBXV4fu7m6UlJTAZrNBpVLh+eefR0hICPLy8nDq1CmEh4cjMzMTKpUKKpUKcXFx6Ovrw6RJk3DhwoURXXdDQwMKCwvJzNQFmM1maDSafo9rNBrk5ubi/Pnz+Oc//4n77rsPv//97xEaGuppkQmEOxriAAxAZGQk3n777SGvWd/pUBQFoVA46OtsNhu8vb2RmpoK4OZMev/+/Th79iwkEgnq6+thMpkgEAiQlZWFw4cPIzIyEiaTCTNmzMD+/fuhUqng5+cHq9WKdevWISUlBSdPnkRiYiJCQkIAABs2bIBcLscPP/yAnTt34p133oHVasV//vMfUBSFa9euQSqVDvt6BQIBHnvsMWzYsMHTqr/toSgKfX19WLduHa5fv97vuYCAAMyYMQPLly/H4sWLERAQ4GmRCYQ7HuIADMJQBryxjlgshl6vR3d3N2QyGQD7pLumpiZs2bIFv/nNbzBlyhRUV1czTlVGRgZ27tyJrVu3Ij09HT4+PkhOToZSqcS0adMQExODlpYWKBQK2Gw25vewWq3Q6XT42c9+hvvuuw+bNm3ChQsX8OOPP2LixIl46KGH8Mknn+DSpUsA7BMInUEgEJDZv4sQCoV2kTS5XI7x48dj2bJlWLFiBSZPnmy3vEQgENwLcQAIIyY0NBQWiwX/9//+XyxcuBD3338//P39IRaLAQBKpRLjxo3Dtm3bEBkZiebmZnh7ewMA1Go1pk+fju+++w6/+93vAABTpkxBVlYWXn31VQQHB0Ov1+Ppp5+GXC63GyD27t2LH3/8Eb6+vtBoNEhLS0NXVxeys7PR0tKC4uJiBAcHAwBkMhl8fX09raoxjc1mg0gkQlRUFLKysrBq1SrMmjULarWaOFkEggegyGFAhJFis9lQW1uLrq4uREZGws/PDy0tLfD392dC8G1tbaioqEBgYCCUSqXdYN7X14euri6EhIQwM3yz2Yy6ujp0dHQgNDQUISEh0Gg00Ol0CAoKAgD09vaisbERnZ2diIqKQmhoKLRaLYqLiyEWi6FWqyEUChEUFIS+vj679xJuPQaDAadPn0ZERARiY2MZB5FAIHgG4gAQCAQCgTAGIXE3AoFAIBDGIMQBIBAIBAJhDEIcAAKBQCAQxiDEASAQCAQCYQxCHAACgUAgEMYgxAEgEAgEAmEMQhwAAoFAIBDGIMQBIBAIBAJhDEIcAAKBQCAQxiDEASAQCAQCYQxCHAACgUAgEMYgxAEgEAgEAmEMQhyAUYBWq4XFYvG0GKMSm80GjUYDq9XqaVFGJRaLBRqNxtNijFpMJhO0Wq2nxSAQRiXEAfAwZrMZ//73v1FTU+NpUUYler0e//jHP9De3u5pUUYlDQ0N+Pjjj4kD6YDCwkJ8/fXXnhaDQBiViDwtgKtpbW1FTk4OWlpaEBQUBIqiMHfuXNTW1qK6uhpLliyBr68v8vPzUVFRgYULFyIwMBBFRUUoKChAREQEUlNTcfHiRZSXl2Pu3LmIiorCiRMnoNVqkZGRAZPJhDNnzkAmk2HlypXw8vLC9evXkZOTg87OTkRGRiIjIwMKhQJFRUW4du0aJk2ahNraWtTU1CAmJgYLFy6EWCzGtWvXcOzYMRgMBkRGRoKiKMyaNQthYWFu0U9NTQ3Onz+P7u5uhIeHw2azISMjA3l5edDpdMjMzIRUKsWZM2fQ29uLzMxMyOVy5ObmoqamBklJSYiLi8Pp06dx48YNLF++HGKxGGfOnAFFUcjMzMT169eRm5uLsLAwLF68GEKhEBUVFcjNzYVer0dSUhJmzpwJkUiEH3/8ES0tLUhOTkZJSQmampqQmpqKmTNnAgByc3Nx4sQJKBQKBAQEQCKRYMGCBfDz83O5bmw2G4qLi3H58mUYjUaMGzcOEokEs2bNwqlTp+Dt7Y358+dDr9fj5MmTjCxWqxUnT55EW1sb0tPT4e3tjVOnTsFoNGLNmjXo7OzEjz/+iICAAMyePRvXrl3DlStXMHnyZMycORMWiwVXr15Ffn4+ACA1NRWTJ0+GxWLBDz/8AKvVisjISBQUFKCnpwdz587F+PHjYTKZcOrUKZw4cQLBwcGgKAoBAQGYO3cuvLy8XK4fs9mMS5cuobi4GAKBAGq1Gn5+fkhISMDJkycRExODqVOnorOzEydPnkR4eDhmzJiB7u5unD59Gnq9HvPmzYNWq8WZM2egVCqxYsUKlJaW4tq1awgPD8fUqVORm5uLyspKzJ8/H0lJSTAajTh//jxKS0shk8kwa9YsxMXFoaenBydPnoSfnx98fHxw5coVWCwWLF26FGFhYejr68Px48dx6dIlKJVK2Gw2hIWFYc6cORAIyNyHQLijHIAbN27g3XffRVBQEGJjY1FfX4+9e/ciOTkZBoMBu3btQmJiIiZNmgSj0Yi9e/ciMjISgYGBMJlMuH79Ovbv349p06ZBLpdDIpGgsrISkZGR0Ov1OHz4MAoKCqBQKBAVFYWGhgb09vaitbUVW7ZsQXR0NFQqFS5evIiysjI8+eSTMJvN2LNnD3bv3o2FCxfCx8cHO3bsQFBQEKZOnQqTyQSz2QydToe+vj4IBAKYzWa36OfatWv4xz/+gZSUFKjVauTn5yM3NxeTJ09Gd3c3vvnmG0yaNAlhYWHo7e3Fjh07MGHCBERHR8NoNOLq1as4fvw4kpOT4e/vD6PRiNraWsTGxqK3txcHDhxAeXk5ACAyMhJVVVXIyMhAWVkZdu7ciQkTJsDX1xcHDx5EY2Mj7rvvPmg0GmzZsgURERGYNWsWpFIpPvnkE4SHhyM8PBxGoxFmsxlarRYSiQQymcxtywGnTp3Crl27MH36dPj4+CA7Oxvd3d2YNWsW6uvrceXKFcyZMwcA0NzcjJycHMycORNisRhGoxE5OTm4cOEC1Go1IiIi0NbWhtbWVlAUhc7OTnzzzTcoKCiASCRCQEAAysvLkZ6ejqNHj+LMmTOYMmUKzGYzvvjiC9x1112YM2cOOjo68NFHHyEtLQ1Tp06FTqfDli1b8MYbb0AsFsNgMMBkMjFtRyaTwWazuUU/u3btwvnz55GWlgaBQID//Oc/iIiIQHx8PIqKilBUVISpU6fCZrOhpKQEFy9exPTp02G1WqHVarF//34UFxdDIpEgJiYG9fX16O7uhtlsRnV1Nb7//nvMmDEDUqmU6XsJCQnYvn07amtrMXHiRHR1deGjjz7CL3/5S4SGhqKqqgrffvstFi1ahKSkJBQXF2Pbtm3YvHkzrFYrox+NRgObzQa9Xu8W3RAItyN3lANw9OhRRERE4Ne//jUoioLJZIK/vz+USiUSExNx7NgxZvBIS0tjZlnAzVlXSEgIjh07hri4OKxZswZCoRBWqxUCgQA/+clPcP36deTn5+O1115DaGgobDYbKIrChx9+CJPJhNjYWADAhAkT8J///AfLli3DlClTMHv2bPj7++PnP/85AKCvrw91dXWYOnUqJk+ejGnTpmH9+vVISUlxm26sViu+++47ZGVlYc2aNQAAjUaDXbt2wdvbG1lZWcjNzWWuadGiRTh37hyjr/nz50MkEuHPf/4zfvGLXyA9PR3AzVmzQCDAAw88wEQRfvOb38DX1xdWqxVWqxU7d+5EYGAgwsLCYLPZkJKSgsOHD2PRokXIzMzEsWPHsGrVKsydOxdmsxm1tbVob29HeHg4MjIycOzYMdx///0ICQlxm370ej3279+Phx9+GGlpaQCAmTNn4uTJk1AoFFi+fDlqa2thtVrh5eWF5cuXo6SkBFarFRKJBCtXroRer8eXX36JX/3qV4iPj2cGYoqisGHDBhw/fhxKpRKPPPIIpFIpbDYbent7sXv3bsyePRsqlQoAEB4ejj179iAjIwMrVqzA6dOn8cQTTyAhIQFarRavvPIKurq6EBoaigULFqCmpgYbNmyASOS+7tzQ0IBz587h97//PcLDwwHcbOcVFRVQqVRYtmwZjh8/DpvNhoCAACxbtgzff/89bDYb/P39cd9996GiogI3btzASy+9BLVaDavVCoqioFar4ePjg40bNyIxMRFLly6FUCgEAFRWVuLo0aNYv349fH194efnh+rqauzbtw+/+93vsGzZMlRXV+OZZ56Bn58fysvL8emnn8JkMsHHxweZmZkQi8V49NFH3aYbAuF25Y5yADo6OpCUlASKogAAYrEYDz74ICiKgsViGXRmZLFYMH78eCxatIgxQOxQoVgsxqpVqxAaGgrgpmG3Wq1obGyEyWRCUVERM2DSoWAAEAqFCA4OZj5HKBTayeKuGRsbepaYkJDAPObt7Y2HHnoIAoFgSIlkNpsN6enpTHie1gH9nFKpxNq1a+Hr68vozmAwoKmpCWKxGFevXoXNZoPNZsOcOXMgFosBADKZDAEBAXb64X6vu9Hr9bDZbIiOjmYei4iIwIMPPsjIMBQ5srKyEB8fb6cb4KYDFh4ejpUrV0IqlTLPd3d3o7u7G+3t7ejt7bXTM/2d3t7e8Pf3Z3RKURQjy1DlGind3d1QKpUYN24c89iECRMwYcIERo7BkEqlWLNmDdRqNXMtbP2kpKTY9T3gZp/u7e1FfX096uvrAQB+fn4YP3488xpfX1+mrwkEAggEglvevwiE25E7ygGIiYlBbm4u5s6dC29vbxiNRpSWliIqKgo+Pj4QCARobW0FcHO5oLi4GBkZGcz76dm+zWZjZidsI07PdtmvFQgEiIuLg9FoxBNPPAGBQACLxYLm5mZmndpqtdoladEzY+C/RrCnpwfAzYG6s7MTfn5+kEgkLtONVCpFWFgYTp8+jbi4OIjFYmg0GlRVVSE+Pp4ZrGk5ampqUFtba2c8aZ1wZaefY0NHEiQSCeLj4zFlyhQm8mAymXDjxg3IZDJYLBZYLBbm/bTu6fsURcFsNjMOil6vR09PDwIDA/s5CiNBoVAwuQ6rVq0CRVHo6OhAY2MjJk2aBIlEAq1Wi97eXkilUly7dg0tLS39rpnbPujHLRYLM3CzIwP+/v6IiIjAokWLMH36dACATqdDW1sbBAIBowu6/dD3af2IxWLodDro9XooFApoNBpotVqoVCq7tjtSQkJCoNFoUFBQgGnTpgEAmpqa0NfXh8TERIhEInR1dcFkMjHOXk9PD3OtVquVaRNc/bDbFq0r2tFRq9WIjIzET37yEyby0NvbyzhLdNuh9UF/D31fKBSir68PZrMZQqEQ3d3dTFSCQBjrCF955ZVXPC2EqwgLC0NeXh6+++47lJeXIzs7GyUlJZg6dSq8vb2h1Wrx9ddfo7q6GqdPn0ZlZSUaGxsxefJk5OfnY+vWrcjLy0NNTQ0uXryImJgY+Pj4oKurC1u2bMGxY8dQWVmJK1euoLu7m4k2hIaG4sSJEzhz5gyuXbuGgwcPIicnBykpKSgsLMTnn3+O+vp6JmT673//G7W1tUhOToZarUZPTw+2b9+OiooKHDlyhEkadHUiV3h4OA4dOoQTJ06gpKQEBw8eRFtbG1JTUyGXy9HQ0IA9e/agoqICZ86cQWVlJXp6ejBhwgQcOnQIu3btwrVr11BeXo6ioiIkJibCy8sL1dXV2LJlC86cOYPa2lpcuHABFEUhOjoaAoEAwcHB2LNnD/Ly8lBQUIB9+/ahuLgYEydOxJEjR/Dtt9+io6MDkyZNwsmTJ7F79260tLQgNTUVfn5+qKiowP79+xmZb9y4gUmTJrk05E3LuXPnTuTm5qKwsBDff/89KIrCxIkT4eXlhcuXL+Po0aMoKirChQsXUF5eDoqiEB8fjy+++ALff/89ysrKUFRUhPr6eqSkpEAoFOLKlSvYsmULLly4gLq6OuTm5kKtViMoKAgSiQTe3t7YsWMHSkpKcOHCBezduxctLS1ISkrCl19+iaNHj8JqtSI5ORk7duzAoUOHYDKZMHnyZPj5+SE3NxfHjh1DQUEBDh48CJPJxMzMXYWXlxe8vLywbds2FBYW4uLFizh8+DBUKhXi4uIgk8lw7Ngx/Pjjj7h06RLy8/NRWVnJhO0//vhjnDhxAtXV1cjLy2McB4qikJ2djS+++AIFBQWorq7G5cuXGafdz88POp0OO3fuRHl5Oc6ePYvvvvsOABAUFIRPPvkE586dg1wuR2hoKLZu3YrTp09DIpFg8uTJEIvFOHLkCC5evIjz58/j6NGj8PPzQ1RUlEv1QyDcjlC2Oyw+ptfrUVpaitbWVgQHByMmJgYKhQLAzSzm4uJiNDc3Iz4+HjKZDG1tbUwSW1NTExMBEAqFiI2NZSIJFRUVMJlMAG7OMgICApisfeDmun5ZWRna29uhUqkQFRWFgIAANDc3o7m5GUKhENHR0dDr9WhsbIRAIEBkZCT8/PyY5YOWlhaMGzcOUVFRTBjd1fT29qK4uBh9fX0ICwtDdHQ0E5LW6XS4evUq+vr6kJyczOyhjo2NRXNzMzo7O5kIgEwmQ1xcHCQSCfr6+lBdXc3MvgBg3LhxduHi9vZ2lJeXo6+vj7lGhUKBuro6dHV1QSQSITY2Fu3t7Whvb4dQKERcXBy8vLyg1WpRUFCAvr4+hIeHIzIyEnK53C36aWtrY9b2IyIiEBERwTgaPT09yM/PB0VRSE5ORldXFyiKQmRkJGpqaqDVahn9KJVKxMbGQiAQoKOjA3V1dcwMl6IoREVF2e1kaGpqQkVFBcxmM0JDQxEVFQWxWIzKykpotVrI5XJER0ejrq4OfX198PLyQmxsLMRiMbq6unDlyhXYbDZGZldGj9g0NjaivLwcEokE0dHRCAkJYfrAjRs3UFhYCKVSibi4ONy4cQNKpRIqlQpVVVVMcqvVaoVKpUJERAQA4Pr162hpaWH0Q7cF+je2Wq3MDhqRSITw8HBERETAbDajqqoKRqMRfn5+CAkJQXV1NfR6PXx8fBATEwOKotDU1ISioiJ4eXkhMjISISEhbs2XIBBuF+44B4DgedihXgLBWUj7IRBuDWQzrJN0dXXhb3/7W7/1X8JNysvL8c9//pNUX3PAuXPn8Pnnn3tajFHL7t27cfz4cU+LQSCMCYgD4CTd3d3YsWMHOjo6PC3KqKSmpgb79u0j5WkdUFBQgEOHDnlajFHLDz/8gPPnz3taDAJhTEAcACehw5MkROkYohsCgUAY/RAHgEAgEAiEMQhxAJyEoihSR3wA6NoIBH5I+yEQCKMFshfGSQIDA/Hb3/7WrrIf4b8kJyfjF7/4BXx8fDwtyqgkIyPDrtoggUAgeAriADiJQqHAvffe62kxRi1hYWFuO8nwToBdPpdAIBA8CYlFEggEAoEwBiEOgJPo9XqcPXuWbHNzQHt7O86fP89UTSTYU19fj/z8fE+LQSAQCMQBcJbW1la8/PLLaGxs9LQoo5KCggK8/fbbzKFCBHuOHDmC999/39NiEAgEAnEAnMVisUCv1/c7/Y5wE7PZDIPBQPTjAFo/BAKB4GmIAzBMSLEbxxDdEAgEwuiHOADDgH2mO6E/RDcDQ/RDIBBGA2QboJMoFArMmzcPSqXS06KMSoKDg5Geng6ZTOZpUUYl0dHR6Ovr87QYBAKBQI4DdhabzQaDwQCpVEpC3TxYrVYYjUbiADjAbDbDarVCIpF4WpRRyTPPPIPQ0FC88MILnhaFQLjjIREAJ6EoigxuAyAQCIh+BkAkIl2OQCCMDkgOgJNYrVZ0dHTAYrF4WpRRiclkQmdnJ1nndoBOpyNbJAkEwqiAOABO0tLSgo0bN6KhocHTooxK8vLy8Morr5BBzgEHDx7EO++842kxCAQCgTgAzqLX61FSUgKdTudpUUYl3d3dqKioIHvdHdDS0oKqqipPi0EgEAjEARgOFEWRBMABIPpxDNENgUAYLRAHYBiQOgADQ3TjGKIbAoEwWiAOgJOIxWIEBASQbG4HyGQy+Pr6QigUelqUUYm3tzd8fX09LQaBQCCQOgDOYjKZUFNTg8jISEilUk+LM+ro6+tDS0sLoqKiiBPAQ0dHB3p7exEVFeVpUUYlpA4AgXDrINNYJxGLxUhISPC0GKMWhUIBhULhaTFGLQEBAQgICPC0GAQCgUCWAIYDCZoMDNGPY0j+CIFAGC0QB8BJuru78cEHH6C1tdXTooxKKisr8cknn5Btkg44f/48tm/f7mkxCAQCgTgAztLV1YUvv/wS7e3tnhZlVFJVVYVvv/2WHHjjgPz8fOzfv9/TYhAIBAJxAJyFDt+SvdwEAoFAuJ0hDgCBQCAQCGMQ4gA4CankNjBEPwND9EMgEEYLZBugkwQGBuKZZ56BWq32tCijkqSkJDz66KPw8fHxtCijktmzZyM8PNzTYhAIBAJxAJxFoVDgZz/7mafFGLVEREQgIiLC02KMWiZNmoRJkyZ5WgwCgUAgSwAEAoFAIIxFiAPgJAaDARcuXIBWq/W0KKOSzs5O5OXlwWw2e1qUUUljYyOKioo8LQaBQCAQB8BZWlpa8Pzzz6OxsdHTooxK8vPz8frrr6O7u9vTooxKDh8+jL/+9a+eFoNAIBCIA+AsFosFer0eFovF06KMSsxmM/R6PaxWq6dFGZWYTCYYDAZPi0EgEAjEARguZCuXY4huCAQCYfRDHIBhQA50GRiin4EhuiEQCKMB4gA4ibe3N2bNmkWOvHVAUFAQpk6dCi8vL0+LMiqJiIjAlClTPC0GgUAggLKR6YhT2Gw26PV6yGQyEurmwWq1wmAwEAfAAWazGRaLBVKp1NOijEqeeeYZhIaG4oUXXvC0KATCHQ8pBOQkFEWRwW0ABAIB0c8AiEQiiESk2xEIBM9DlgCcxGq1oquri+wCcIDJZEJ3dzdZ53aAXq9Hb2+vp8UgEAgE4gA4S2trK37/+9+TOgAOuHLlCl599VX09PR4WpRRCakDQCAQRgvEAXASnU6Hq1evkkqADujs7ERJSQnZ6+6ApqYmlJWVeVoMAoFAIA7AcCBHug4M0Y9jiG4IBMJogWQjDQOyz31giG4cQ3QzOLSOBtMVcaQIhJFBHAAnEYlE8Pf3J5ncDpBKpfDx8YFQKPS0KKMSuVwOHx8fT4vhcWgnmjvYW61WWK1WmM1mu3LS7MGeHUVh/yUOAYHgHKQOgJOYTCaUl5cjNjYWMpnM0+KMOnp7e3H9+nXEx8cTJ4CH1tZW9PT0IC4uztOi3FL4Bnz6ZrVaYbPZQFEUnnvuOYSGhuL555+HzWaz223DHfjZN4FA0O9xAoEwMMQBIBAIboE76NMDPf2XHuDp+xqNBps2bYKXlxfuvfdeWCwWJCUlwdfXFwDQ19cHk8kEf39/iMViuygc7QQIBIJ+zgFxBggEfkgcm0AguBT2wM8e8C0WC+MMmEwm6HQ6ZtA2Go34y1/+guPHj0Mmk6G8vBxyuRx//OMfERoaCovFgt27d+Orr76CUqlEYmIipk6dihkzZkCtVkMgEEAoFEIoFDJOAJ9DQCAQ/gtxAJyku7sbX331Fe69916oVCpPizPqqKqqwqlTp/DTn/6UVATk4cKFC6iursZ9993naVHcAnvQZw/89OCv1WpRWFiII0eOoLm5GS+99BJiY2Nhs9nw8MMPo7a2FvHx8di4cSNkMhl8fHyY8P7atWsRHx+PmpoaXLlyBZ9//jkAYMWKFTAYDBAKhRCJRIwTQDsFtDNAHAECwR7iADhJV1cXtm3bhkWLFhEHgIeqqirs2rULq1atIg4AD5cvX8apU6fuOAeAO+O3Wq3MwG82m2E2m5GTk4Mvv/wStbW1mDBhAu655x5ERkZCLBYDAKZOnYrw8HAEBARg3Lhx/b4jODgYwcHBzPdpNBqIRCKIxWIYjUZs374dNTU1WLt2LWJiYiASiWC1WiEUCmGz2RingP6fQBjrEAfASUjKxMAQ/YwtuOF+etBn3wwGAyiKQmFhIcaPH48//OEPSE5O5t1JM9QtthRF2Z3I6eXlheTkZBw4cABHjhzBmjVr8JOf/ARBQUFMVEAkEjGDv9VqJdEAwpiHOAAEAmFYcGf93IH/xo0b6OvrQ2xsLHx8fLB582YmFO8OZs+eja1bt+LIkSP46KOPkJeXh1deeQXBwcEQCoWwWq39lggAUk+AMHYhDoCTEGMxMEQ/g3Mn6Ig766f37tPHHefl5eFvf/sbMjIy8MILL9yya/b29sb69esxZ84cXL16FX5+fjAYDMzsn77RywL0VtU74TchEJyFOABOEhAQgKeeegpBQUGeFmVUkpiYiIcffhhKpdLTooxKZs2ahdDQUE+LMSL41vrNZjNMJhMMBgOys7Px/vvvY+HChXj88cc9MrjS+QJ0rsC1a9egUCigVqthtVrtthGydwsQCGMJ4gA4iVKpxEMPPeRpMUYtkZGRiIyM9LQYo5YpU6ZgypQpnhZjRHBD/vTgbzKZcPDgQfz973/H//k//wcbNmyAVCp16rNdvS5P5wocO3YMubm5ePHFFxETE8NcB18tAQJhrEAKAQ2B1tZWFBYW2lUloxEIBEhJSeHNWh4r1NXVobS0lNdwi8ViTJs2bcxGBGw2G4qLi9HY2NhPPzabDT4+PkhNTXV6oPQU9KyfHfI3Go3M7erVqxCLxcjKyhpSJUiz2Yz8/Hx0dnZCIBDgf//3fxEYGIgHHngAVqsVarUakydPHrFT0NTUhE2bNqG9vR1/+tOfEBUVxewg4OYFkEgAYaxAHIAhcPXqVaxduxb19fV2xsFms0GtVuPbb79FWlqap8X0GPv27cNDDz3U74hkq9WK1NRU7N27F2FhYZ4W02O8++672Lx5c7/HLRYL1q9fj88///y22DLJ3ddvMpnsBn9vb28EBgY6NYs2m8148sknsXXrVggEAlgsFlAUBaFQCIvFgs2bN+P11193ifwtLS147rnnoNfrmeRAsVhs5wTQdQOIE0AYC5B41xBITEzEzJkz7UKdJpMJZrMZ06dPx/jx4z0tokdJT09HQkKCnW5MJhMsFgsWLFgwpgd/AFi4cCHUanU//VAUhRUrVtwWgz83259e7zcajSgsLERRURECAgKcDqGLRCKsWLECYrEYJpOJ+Xyj0QhfX18sXbrUZdegVqvx9ttvw2Aw4O9//zu6urpgNBqZxEV28SIyLyKMBYgDMASkUilWr17dL0wrEomwatUqu/3IYxG1Wo0VK1b0e9zX1xerV6/2tHgeZ/z48Zg9e3a/x+Pi4pCZmelp8QbFUcKfyWRCY2Mj3nnnHZSVlQ378KfZs2cjJSWl3+PTpk1DamqqS68lIiICr7/+OsrKynD+/HkmikE7AexyxQTCnQ5xAIbI/PnzER8fb/dYdHQ0Fi1a5GnRPA5FUVi+fHm/nRHTp0/H1KlTPS2ex5HJZLjrrruYinc0CxcuZBLSRjPs2T89+BuNRmg0Gnz66acjTowNDQ3tN9OnKApr1qxxy9HJqamp+OijjzBx4kRotVomkkEfQUyiAISxAnEAhgifkcrMzLwtDPitYPLkyXZ5EAKBAKtWrYKfn5+nRRsVzJs3DwkJCcx9b29vrFmzZtRnnbP3+nOT/s6ePYvc3Fxs2rRpxGWxV61ahYCAAOZ+ZGQkFi9e7LbrSk5ORnJyMiiKgsFggMFgYJb12CcUEieAcCczuq3PKEIoFGLlypXMgCaXy7F69WrecqZjEYVCgdWrVzMDWmhoKJYsWeJpsUYN3AFt0qRJt0XiKF/432g0QqvV4vz587j//vsxc+bMEX/PlClTMGPGDOb+vHnzkJiY6NZrk8lk0Ol0KC8vZ5wargNAINzJjOnRi93BuZ2de5+iKEydOhVTpkzByZMnMXHiRKSnpzMGkvvakcB+vyezkZ3Rj1AoRGZmJqKjo1FVVYWMjAwkJCT0M6SuuJ7bVT8rV67E1q1b0dvbi2XLliEoKIh3aynfNVEUNeQa+YN9ljPXx078M5vNzGzZaDTi6aefRlRUlEt+A6VSidWrV+Po0aOQSCRYs2ZNvyUTd1BUVIR///vfeOONN5iSwewjhelrc3U7G6y9DNf5cCTncNrPaOlb3PsjcczuFNvsKsacA8AO6zn6n77PhqIo+Pj4YNmyZTh58iQWL16MwMBAmEwm3tfyfQaXgTor2/C40xBxdcP9O1T9WCwWREZGYt68eaitrcXKlSshkUhgMpkcXvdw9MPdouUp/XB1w70ePv2kpqZi4sSJKCsrw5IlS5ikM3fph08vzuiHO/jTs2S9Xg+JRIL4+HiXDtJLlixBREQE/Pz8kJGR4bLPHYh58+bho48+wunTp3HXXXfxHiE83ORGPn0Op285y1DajzO2h/u/OxiJ7XG1bhzph68v3Sr9uIsx4wBwTy3jNjD2TNVRYxMKhViwYAEmT56MxYsX2xnwoTYsLo4alaObzWZzS2MbqX5og5mVlYVr164hPT0dBoOBiY440g99Pc7qh32Qiyf140hfXP0AgI+PD7KysuDv74+kpCQYDAY7/fHpZzD4HCJ2MRuuftjfNZTrZRf9oZP/mpuboVarXT5DT0hIwIIFCxAcHHzLto6Gh4dj1apVOHr0KObPn4+AgACIxWLm8CD6+GBXRFIA9MstcNSG2O8dCnztZyhyc9sPX+SD7mvu7luO9DMU2zwU/Qzl9VydOZqM0Y+x+5q79OMMJpMZ7Z1dCAr0H5LjOiYcAL6zyuka4R0dHTCbzXbP0+9h/wX+2wDWrFkDiUSC8vLyfs/zvQ8A4yiwfxRuQ6IfoxuVXC5HYGAgRCKR3ePsgc6V+qH1Quuop6cHXV1ddo8PNOulKApqtRrLly+HVqtFeXm53fdwOyH7f7PZzHtCmyP9CAQCKBQKZu85rRuusXKVbgD7KnhWqxUdHR3o6+uzM1qOHAH6t09KSoJSqURTUxNv5MjRe81mMzMz5eqH7yYUCuHn5welUsnoh51wOJhuuLN/etufwWDAtm3bMG3atAFLGtP6MRgMQ9Y17UDK5XI0NzfzRkccyWoymSAWi4f8mwsEAgQEBEAqlWLVqlXYvXs3SkpKkJaWBqPRyBwfTOttuO2Ja3vov0ajEa2trTAajUNyJAdjoL5FJ3Fyyx47akMCgQASiQQqlQoSiYQ5Qtkd4W9Htlmr1aK9vX3Itnkk+hnMNnN1Q1EUvLy8oFKp7CpI0u3Elfpxlrr66/jjm+/h3bdegjoocNDX3/EOgKMjS202G7Zv347PP/+c2cc/VO/bYrEgJyfHKTnogZSd6cyGa9gtFgu8vLzw17/+lVlnpU8vo2cm7tKP1WqFwWDAu+++izNnzjCFapzRz5kzZ5ySobW1FV5eXg5LBnONj8FgQEJCAl577TX4+/vDarUyHdgd5VzZiXBWqxWdnZ3YtGkT6uvrGSPJd118nwMABw4cGPJ3WywWtLa2ws/PDzKZbFDdAIBOp0NmZiY2bdrErGvTuuF7H1durgNAOwGNjY0oKSnBI488MqDM1dXV2LhxI7RarVMhdHoA+Ne//jXk9xiNRrS1tUGtVg85KVej0eCpp57Cz372MyQlJeHXv/41JBIJ9Ho9UyLYYrEwpwYOF76DkwAgJycHb7zxBiQSCe/s1JUJiBqNBn19fVCr1QOGtun/bTYbzGYzXnzxRcybN4/pW9wB0hXw2WYA2LFjB7744gunbc9wcGSb+SZaFEUxtvntt99GfHw87yTRU+gNBlRW1cFkMg/p9Xe8AwDwH15isVhQXl6OmJgYPPvss0OebQwHiqKwZcsW9PT04Pnnnx/0uyiKQnNzM1599VW0t7cjLCwMFEXZRQJcHQHg6kev16OkpASZmZlYtWpVv0RHV2I0GrF582bMnTsX99xzz6DfJRQKcf78eezZswc9PT1QKBS8xskd+qHbTnd3NyorK7FhwwZMmTLFbe2Hoii0trbi5Zdfxv3334+0tLRBv0sgEGDv3r0oKiqCwWDo56AMxUHiDlr0FrmioiIoFIpB6zt0dHTgxo0beP7555lT+dyBUChEfn4+/va3v+Hxxx9HRETEkNZ333vvPVRWVgK4eV7Fgw8+iPz8fGi1WkgkErsSwbTD7Wx74kaO2DsM6urqIBAI8PLLL7s12VEoFGL//v04cuQIXnrpJXh5eQ2aG6DVavHGG2+grq4OZrO53+e5KgLJ1g+7b9lsNpSWliI6OhpPPvmkWwdUoVCI999/HzqdDhs3bhx0YiUQCNDU1IS33noLra2tiIqKYuwxHTHyZBSAAkAJqJv/DIE73gEYaC3TbDYjMjKSt0qbqzl06BDa29uH/F0NDQ3w8vJiEq+4Axx9Xa7K8ubqR6/XA7i5X3rOnDlu1Y1er0dAQADi4+OH/F16vR7fffcds3+bvf7mKieJqxt2OJz+TVJTUzFr1iy36qepqQm+vr6YPHnykNtPcXExSkpKYDAYeEOZA+nGUZ8xGAwoLCzExIkTHUay2J+hUCiQnp6O8PBwt+rHZrt5qFJaWhri4uKG9J7//Oc/dtcvEomgVCrR3NzMOE20Q0xHAZxtT+ywP/v8BLrUcWBgIObMmeP2g6DKy8tx4cIFzJkzB3K5fNDXazQaBAYGMrbHUb7NSOHrX7R+LBYLIiIiMHfuXLcPpN988w00Gg0yMjKGFK2qr6+HXC5n9ENHndh9i77vaaxWK1pa2+HtLYdS4d3v+Tu+DoAjQ0YPHLdSDmdfb7PZYDAYoNfreYuUuEou2kBx9XOry6I6+130UgW3iIurdcN35r1er3drVIRPDmffY7FYhlXkhi/iQUeFfHx8sHLlyiEllw1H7lutIzbFxcWoqalhdEVXBhzJdfDtpNDr9cza/63SzXDewz7vga0PV9kfdv/i9i2+3VXu1M9w2g57S6yrdeMqdDo93vz/PsSps+d5n7+jIwB860t0Q9PpdLfUARiu/LSxAP6bAMfdpjTS7+Cb3ep0un7hv9GG1WqFTqdjZrl0Io7VanXZTMVR9OhWOgDDxWw2Q6fT2SUp8SUEcq/X0TUbjUY8+uijmDx5sqcvzS0cOHAAFEUhPj7eocPkbASAO/s3Go3MoDHaods5nVw5WNsZDny2hx5QRzO0baaTXLl2ebRgtdpwo7UNfRot7/Mix2+0Mpm4oaGhLtsL6+h7tFotAgICBg0tDobRaERBQQFCQkIYuWnvjPbAac9toEZ248YNnDx5EjqdDsDN0q3Lly+3Sxi8ePEitFot5s6d6zb90PICYBJx2AlvztLT04PS0lLExsYyR7c6igAMNMBptVrs378f+fn5CA8Px/r16xESEgIAMBgM+OGHH3Dp0iXI5XI89NBDCAwcPCPVWegIAB2mpPXDTVhylpaWFtTV1SE+Ph5KpZJJ/GEbcNoBcDQg6PV6HD58GFeuXEFsbCzuvvtuyOVymEwmnDp1CufPn4dYLMa6dev6nTHhCiiKYvRDr03SehlsxsPnBNA3X19f1NfXo7u7G0lJSbxJiUOhr68PN27cQF5eHubNm4fg4GBoNBocO3YMHR0ddrsZMjMzb8m2wMjISJw/f56xDdxdH0M17IWFhRCLxYiJiWH6F3uAG8wBKCsrw48//mj3G4WEhGDq1KnIzs62e69CocCiRYvg7+/vcn3QstK7AIbafgbCZDLh6tWrUKlUCA0NtbM/bOd6oMmZzWZDXl4eTpw4AZ1Oh6VLlyItLQ0URaGnpwfXr19Hfn4+1qxZA29vbyekGzrsCADdTtk5AMPVj1arxdWrVxEbGwuVSjXyZQTq/y1NOEgKcOgAmEwm7N+/H+fOncPbb7+N4OBgtyjSaDTi4MGDOHfuHCZNmoTf/OY3I/o8vV6Pl156CS0tLVi+fDmWL1+O5ORkJvmFXn8bzAEoLi7GP//5T2RlZUEikcBoNNolX9XV1eGll16CWq1Genq6W450ZTcy2pERi8UjCkveuHEDv/zlL6FUKrFq1SosWbIEsbGxjGPBNlL02ex8fP311ygrK8Ps2bNx6NAh5Ofn469//SsUCgU+/fRTlJSUMKFidzqPtH5EIpHdDo+RhOFKS0uxYcMGJCQkYMWKFZg3bx4zALHD6gN9x2effYZLly5h3bp1OHjwINrb2/Gb3/wGx48fx6FDh7BkyRIUFhbij3/8I95//323OEgWi4WZwYnFYqb9sLdRcX9fvqx1+q9Go4FGo8Hly5fx8ssvIyMjA2vWrGH048zv/P333+PAgQMoLS3FxIkTERwcDLPZjJqaGjQ1NUEgEECr1eLcuXNITEy8JQ5AREQEDh061G/Jzdm99Z999hm++eYbLFy4ECtXrsTkyZPh6+vLOALsvBU+uru7UVZWxjj6RUVFCAwMRHJyMioqKpiozo0bN1BbW4v09HS3OAD0ZIBOQOYelDScHBuj0Yg333wTJSUlWLZsGZYtW4akpCR4eXkx9mcw20xXb1ywYAF6enrw+uuv4+2330ZycjJ2796N7OxslJeXY+nSpW51AGg7KRQKmV0jIpFowP41GF1dXXjqqacglUqxcuVKrFixAuPHjx9S7sZQOfvjJWi1OmQtmuvYAZBKpbjnnntQUVHBeJyOvGB6psj3HG1MHBkHsViMRx55BAkJCTh37pxLLlCv1yM/Px9XrlzBli1bMH36dCxZsgQzZ86EWq1m9uEO1MgsFgvi4uLw7LPP9lO+xWLBjh07EBwcDLlc7pY1H7rhcNci6eeGG4qjveQrV64gJycH77//PmbPno0lS5YgNTUVfn5+jJPkKNucPgnuySefRExMDNLT0/HTn/4UpaWlkMvlOH78OF5//XUEBwdDqVS6xQFgb1fi5kWMNPxvs9nQ0dGBw4cPIzs7G+Hh4ZgzZw4yMzORnJwMmUzG7E/mo62tDXv37sXmzZsxf/58qFQqvPXWW7j//vuRnJyMyZMnIyQkBGFhYcjOzkZnZ6fLHQA6AsDWD/s5R+2H/Ry7wInNZkNBQQEOHDiA9PR0NDY2YseOHdizZw8SExOxZMkSrF69GtOmTWMGo4H0v2rVKiQlJeHll19mHvP19cUzzzzD6PWzzz5DRESE206U5MqnUqmg1Wp5nUhnltzMZjOqqqpQVVWFr7/+GikpKViwYAHmzJmD0NBQ5jWOmDFjBqZPn85knL/zzjt48MEHERkZiZdeegkURcFoNOLdd9/FokWLEBER4Ra98Nke9jLAcPuX0WhEUVERioqK8MknnyA1NRWZmZlIS0tDUFAQkwjoCLVajd/+9reIi4tDS0sLvvnmG1y/fh0pKSm49957MXHiRGzcuNFta/Fs2zOQbR6ufmgnOzc3F3//+98xZ84crFmzBpmZmYiMjByxPT15JhetbR1YsjBj4BwAqVQKgUCAy5cvY+/evbh+/TpmzZrFHPqi0+lw5MgR5OXlwWq1YuLEiVi9ejUT6qRnhkajESqVCvfccw/jyXd0dOC7775DRUUF5HL5oAOpRqNBQ0PDgA2Doij09vZCo9EA+K8hP3r0KI4fP47Q0FDMmDEDM2fORGRkJEwm04AlMTs6OvDll19CLBZj6dKlTOfNzc1FWVkZli1bhlOnTo3ox9Dr9aivr7cLeVEUhaamJmi1WtTW1kIqlUIul8PLywteXl6QyWTMrM6ZhkZRFJPkBNx03JqamvDNN99g3759iI6OxsyZMzFjxgyoVCqHSwBisRiPP/44E/6Vy+XMDDM3Nxfd3d3YvXs3iouLkZKSgmeffXbYnnhvby8aGhrs2oZQKERNTQ00Gg2qqqpgMBjg7e3N6EYqlTJbuJztiPRn0+3MYrGgtrYWtbW12LNnD+Li4jB9+nRERkY6DON2d3fDZrMxJ+SFhoZCo9GgsbER06ZNg06nQ2lpKXbt2oVJkyaNyIC3tbWhpaXF7jGBQIDGxkb09vairKwMSqVyQP2wYSer0UsdfX190Gg0qKiowPXr1+1m40ajEYWFhSgqKsKnn36K6dOnY/Xq1UxtBke6VygUUCgU/Z6nHbfCwkIcO3YMb7755ogO3GpsbERXV1e/vdwdHR2w2WwoLi5mQtxGoxFBQUGoqqpCd3c3fH19oVAoIJPJmK2B7GJMfFAUhfb2dua+VqvFxYsXcenSJfz73/9mzhC5cePGgJ9Bf8eXX36JkJAQTJ8+nfltAeD48eOoqanBr3/962HrxmKxoL6+HhqNxm6niFarRU9PD5qbm1FaWsrYHbr9DFUXfNel1WrR29vLPNbd3Y2TJ0/i9OnTUKvVSE1NRVpaGjo6OhAdHc37OWq1GgEBAaipqcHBgweZHTLAzXbl7e3tkgx8g8GAuro6O9ssEAhw/fp1aLVa1NXVMX1LLpdDJpMxtlkkEjmtH4FAwOxCAW7a5xs3bmDPnj3Yv38/YmNjsXjxYsbRdlTXYSjQ5nTAnkVRFNra2nDu3DmsX78eWq0Wn332GdLT0zFu3Djs2bMHjY2NuOuuuwAAhw8fxp49e/Dggw/CYrFAKpViyZIl8Pf3R3Z2Nnbs2IGNGzfCZDLhk08+gUAgwH333YfW1la89957SElJcSjL1atX8eqrr9o1Vj7MZjMqKir6PU439vr6epw4cQLz589Hd3e3w88RCoWoqKjApEmTYLVa8fLLL+Odd96Bl5cXPv/8c9x1112M0zKSxlZdXY0XX3wR7e3tdsZYr9ejrq4OX331Fby9ve3WttkeprMzXZ1Oh7a2tn6Pm0wmlJeXo7y8HNnZ2Vi4cCGT/8DXLthRkUOHDiEhIQHJyck4cOAAOjs7sWTJEqxatQqbN2/GhAkTmDbiLBcuXMAbb7wBs9lsd51dXV2orq7Gxx9/DJlMxnQ4vmSc4YTh+K5dr9ejqKgIxcXFCAoKchiBCQgIAEVRzKyksbERjY2NjMNQW1uLN954A1VVVfjTn/40om1g+/btw9atW/tdY1NTE5qbm/H+++8zuuFrP2z98FU8ZCfPtrW1wWQyoa6ujrcwS09PD06cOIGzZ88iMjIS/v7+w85A/+KLLxhHa7iYzWZs2bIFx48f7zdrqqiogFgsxpUrV+y+t6OjA1u2bGEcbL7DgQZrT3z2h/7sU6dO4cKFC1AqlYOeBllWVoYzZ87gnXfesfvOvr4+7NixA+vWrYOPj8+w9dPV1YW33noLxcXFdm3ZYrGguLgYpaWluHTpkl2/clYXXOjP5kLngh06dAg5OTkQCoWYNm2aw8/p7u7Ge++9h5ycHDzxxBNuWUKrr6/H888/z+Sk0BgMBlRXV2Pnzp1MhNMVtpn+bD7n0GQyobS0FKWlpdi3bx8ee+wxPPvss8POmaOlGtABsNlsCAgIwC9+8QskJCRAq9Xi4MGDMBgM6OnpwcGDB5GUlIQLFy4wQp4+fRpr166Ft7c3goODkZeXB71ej87OTvT29sJisaCpqQlNTU34wx/+wByv29jYiLKyMoeypKam4oMPPhhSBOCJJ55gZKIRi8UIDw/HjBkzMGPGDISGhmLHjh0OPyslJQUffvghpk+fDq1WiwceeABnz56F0WhEQ0MDIiIicPnyZXR2dqKqqgpJSUnDmqnExcXhvffe6xcBuH79On71q19h3bp1SEpKYjxbOhJAz+KcmeEKBAJUVVXh0UcfRUNDg91zMpkMMTExmDVrFqZMmQI/Pz/U1tYO+pnZ2dnIycnB7373O/j5+cFgMCAjIwPp6ekAgIyMDOTk5AzbAZg1axb+9a9/2UUjhEIhcnJy8Oc//xkPPvggwsPD++lHIpEMOwLw448/4sknn0RPT4/dc97e3oiNjcWMGTMwbtw47Nu3j/cz/P39sWLFCvzP//wPKioqUF5eDrFYzERBEhIS8NFHH+HSpUt47733oFarh51Zf/fdd2PevHn9fucdO3Zg165deOKJJ+Dj42OnH3oW5ygCwN6OpdVq0dfXh97eXmRnZ6O5uRmZmZl4+eWX+w3ugYGBmDFjBtatW8fkggyH2tpa5Ofn48033xzW+2lEIhGefvppPPTQQ3aPUxSF1157DQEBAfj1r39tF77NyclhlmToCACtM3pmN1B7EggEeO2117B169Z+j6tUKkyYMAEzZszA9evX0dfXN6D82dnZUKvViI2NtXu8sLAQTU1NI64/4e/vjz/+8Y/Qav+bIU7P0jdu3IiwsDAsWrQIcrkc3t7edlGk4UYANBoNnnvuORw/ftzuOaFQiJCQEEyZMgVTp04ddDnY398fb775JmpqavDaa68hODgYa9asGZE+uERFRfWzzXQE4Omnn8bSpUsxceJEJprl7e3NRNhGEgH4+c9/jurqarvnZDIZEhISsHTpUqxcuZJZrh0pg45YIpGICfUKBAKmahWdxBIXFwc/Pz9YrVZEREQgICAAXl5eOH36NL799lvMmTMHISEh6O3tZWbcRqMREonEbuYjk8kGXNugB6jB6OnpYRLy6Nr006dPR1ZWFlJTU+Hj4wOtVovOzs4BPycoKAhBQUEAbs4kvLy80NzcDC8vL/j4+GDr1q0oLy9HZWUldu7cieeee25YP4hEIkFUVBTv41KpFCqVCmFhYfDx8YFSqbRraBKJxOk8AKvVyvyGQqEQYWFhmDNnDhYtWoSUlBTIZDL09fX1CyvzcfjwYZw6dQobN25kwnVhYWGoqamxu46RVMmTy+X9DCAAZmlErVYjLCwMvr6+/cJxtIPkLPX19cz7xGIxoqKiMGfOHGRkZCA2NpZZShnos3/xi18gKioKRqMR/v7+qKmpQXBwMFNYRqFQICMjA3/5y19w8eLFYTsAvr6+8PX17fd4cHAwZDIZxo0bB39//376oR1IroGi82P0ej2T9NfT04Pu7m6EhYVBJBLZJQR7eXkhOTkZy5cvx4oVK5CamgqlUokLFy4MeztUYWEhRCIRkpOTh/V+Nux+zMbPzw+BgYF2hYN6e3shEAgQHByM4OBgBAYGwsfHhxn4aKdpMKPOtgM+Pj5MDsD06dOhUqlgNBqxf//+AR0Ak8mEc+fOITMzs9/EIicnB/Hx8bzX5QwCgYBZ1mSj0WigUCjg5+eH0NBQKBQKKJVK+Pj42E1AhrMWrdFoGEeYoigEBgZiypQpyMzMxKRJk+Dj4wOdToeCggKHn0GfiyGXy5GSkoLQ0FD88MMPWL16tUuL79B9n4tEIoFMJkNgYCBCQ0Ph6+vL2Ge27RmOfmi7Tv8+YWFhmDt3LpNsGxISMuIcAKvVBqvt5oRqQAeAXk/v7u5GREQE+vr60NfXh66uLowbNw6JiYmQSCRYvHgxk7DS2NgIm82GkpISxMXFYe3atWhpacHJkyfR09OD3t5ejBs3DlarFSdPnsSCBQvQ0dGBgwcPwtvbG3q9fthbi4D/ViBLS0vD6tWrsXjxYsTFxUEoFKK3txc9PT122eKOOHz4MFPJrLS0FK2trZgyZQrS09Nx7733QiQSYceOHfj+++/x29/+1iXeGB+0rNwbHaIdTpgpMDAQMTExuOuuuzB//nyEhYXBarUy+hlKQZ0DBw5g+/bt2LBhA0wmE8rKyhAZGYm0tDQcP34cVVVVUCqVKCgowLp169yiG/Yea65ehrt3G7hpmMaNG4d58+Zh5cqVSE9Ph0qlgsFgQFdXF7q6ugZMAgRuGqmsrCxYLBa89tprWLBgAVQqFXbs2IGkpCRMmjQJlZWV6Orq4jUyrtDNYPrhJudyK7NxK0QmJiZi3bp1TJnW+fPnY/Xq1cjIyEBwcHC/AX8g/Wi1WrS1tUGv16Otrc1uYCgrK0NgYKDbK+Rx5Tt48CC2bt2KRx99dETtSSKRIDExEVlZWViyZAlSUlIgkUig0WjQ1dUFrVY7aA2Jzs5OtLS0MFtr2Vy7dg0xMTFu211Dw94Fwv2ftj3OOnk2mw1yuRypqalYuXIlMjMzERcXxyQn031rIP0cPXoUEokEc+bMYfKAsrKymAhDW1sbDAYDWlpa4OXl5dIMevZ1sHfIcPvYSCq1+vn5Yf78+Vi7di2WLFmCpKQkl/aFiPAQpiqgQwfAaDTiu+++Q2VlJbZv347nnnsOBw4cQGVlJb7++mts3rwZjzzyCLZt24ZLly4xSYHTpk3D9OnTsXDhQnz44YfYvHkz5HI5kpOTceTIEXz//fd44IEH8PDDD2Pbtm1MKCgxMRFXr17FkSNHhh0uBm7OGF9//XWEhYVBpVLBYrFAq9VCp9P128IyEEqlEp999hl2796NtrY2PPLII5gxYwYEAgETYQgODkZcXJxbtgACGFDW4W7FCQ4OxpYtWxAbGwulUgmz2QytVguNRuPw2E0uJpMJP/zwAxoaGvC///u/sNlsEIvFeOGFF5Ceno7Fixfj1VdfhUgkwoQJE7BixQq36IdPTrb8w80CHj9+PL7++mvExsZCIpFAp9NBo9HYnUw22Gf/8MMPOHr0KCwWC0JCQvDwww8zHv3HH38MkUiEzs5OrF27FhkZGW7TDZ9+hrKtjatHm80GmUwGb29vLFy4kCm7S89WnOXo0aP47rvvYDab8cknn2D16tW4++67mQzr5ORktw9wXEpKSuxOnBtuG9qwYQOeeOIJhIaGwmazMUmU7N0Fg32uyWSCWq3u5wBYrVbIZDLeqJir4crK/X84SKVSvPDCC1CpVAgMDITFYkFvb2+/UzUH+o6YmBj861//wjfffAODwYC4uDjcd999AIC9e/fi8OHDkEqlePfdd3HfffchKyvLrfph3+fqzVkHwN/fHx988AHi4uLg6+vrlnLCD9y7BjbbzYmOQweAPiDjpz/9KSiKgkKhwE9+8hOsXbuWue/n54dNmzYxyUEBAQFMZm9CQgJeffVVtLW1wd/fHz4+Pli/fj2zLjJx4kS88soraGtrg0KhgK+vL7Ra7Ygyfmm56W1DtKfKZqgHxcyZMwfjx49HdXU1/P39mUMf2CxcuBDz5s0bUcRiMAbLOHa2gSiVSkY/fGWFh6IfsViMP/3pT3Z7menEQKFQiCeffBLl5eWwWq1ISEhw+0zOWb0NhkqlgkqlYoq38NX2HuzzlyxZgujoaIjFYruBcv78+UhJSUFlZSX8/f0RGxs74jbvTt1wzw9oaWnB+PHjRzw4L126FAsWLGAqN0qlUkauRx55xCPV1KqqquDn58fYqOG2ofHjx9vt+efT6WCo1Wq8/fbbzE4S9ntfeuklpiCZu3H1EcBisRhTpkxh9vzTy4N83+Po+5KTk/HKK6+grKwMYrEYiYmJjA1et24dVq5cybSrW2mbB7s/FLy8vJgdH+6CffiUQ8tDUVS/rVt8W7kkEgnvOhJwc7BhH+/KPepVLpfbZfk6Ogp2JPCd5TzUDE1/f/8BC2yIRCK3Gu+B5HalZ8j32YN9Pr0tiA+xWDzgjg5Xyj2QbkZ6EJAj/bC/0xFyudzhuj7tYHhKP9xrcvRePoO2fft2mM1mLF26dESyDdR+boVuuLS3t6Ourg5JSUkjyuKm4Ws/9OcOpYaHWCzmLX5EURTvsoA7GMz+uMIGDadvATfHCr6Bkt5Sfqv0407duIqBgjWjp2ixG+H+KCMt1DBcGYYjM9+2Elc2ML7PZG+lG+06Gum2G2f1wy5Reyv14ur24+g9fNdNf4ZQKERzczP27t07aAiYfTrjaNYRjUajgZeXF8aNGzeo4zQcuYbqeLlLN8OR2Zm2M1y5+G5DdQJcLYez73H3xMwVyKRS/OrxB5A2nX8yckcfBsSGbbjZezbr6uqQk5PDG4pyJXV1dejp6UFOTo7DBBd2qPnGjRvQarX95HWHfOyOx62lX1xcjLNnzzIyu+P7jUYjOjo6UFFRMST9CIVCXLlyhckGdsX+5KHqiP19FosFeXl5TPKPO/RDURRaW1vR3d2NgoICSKVSh7sq2NXaSktLGV05oxs+Y0zfRCIRYmNjcfnyZbS3tw84U6coCn19ffjxxx8RHBzstqpsQqEQ+fn56Onpwfnz53H9+vVBv4uiKDQ0NNjJHxgYiDVr1sBsNtsNfK4YjPjajlAoRHt7O86ePWsXknV1+6HbQmdnJ3JychyGxNm2h64VQica3uq+RW9Praurw+nTp10S0XOEUChEQ0MDdDodzpw549CxZ/ct+uwaWlaubR5NToBYLELmPMfbRcesAyAWixEREYGDBw/iscce4832dQa+dXT2/3Tt+J///Oe8ZUb5vG46N4KvE7pDP2wHQCKRICwsDDt37sTu3btdph9H62RarRbXr1/Hnj17ePXJHYysViuio6PtiiS5M6rD1o9IJIK3tzeCgoLw7rvvQiAQ9Mv+dUY/g7Udm80GnU6Hv/zlL0yt8cH0Y7FYkJaWxlvMZijXyv08+hYREYHs7Gxcvnx5wGWAwMBAqNVqvPfee25dz6coCmazGQqFAh988MGQv8toNOLee+9l7nd0dECn00Eul/crdzsSw85+L7v9BAcHo62tDU899RSTUc4+h8EZBms/JpMJJpMJv/zlL/u9x5HtEQqFCA4OviW2h6sfoVCIyMhIHDx4EJcuXbpltnnDhg1D0g9ws+Kgv7//LbE9Tl0r/l9p/iGqaEw4AOxGTXdAkUiE+fPnY8KECUyWrk6nY47fdfZs+cEMMve13K00YrEYUqkUXl5e8Pb2ZgZ/tVrtsMqUq6B1wzZQUqkUd999NzIzM/vph07eGY5+2LI76ji0ftgzfrFYDJlMxujH29ubSS7l6sfVAw47BE7rx8fHB4899hi6urrQ19cHrVYLvV4PvV7PWyPcmbbD/k4+/bCNIS0XrR96n79SqURAQIBdWdKhtB++CABbv/Te5/z8/AEdgJiYGHz99dcjqgHhbugcBI1GgwsXLsBgMMDX19fu9ERXzHy5bUcoFCIlJQUbN25ET08PtFottFqt3Sml3PMbBoKv/bBlp0+oo2H3WzqyI5FImL4ll8vh6+uLoKCgAStIugJuG6P1Q9vmnp4eaDQaRj+0beZL8B5MP1xnjP3b0ktWXNvDZ5u9vb1vmX6cRSaVIC4mEmLx0Ib2O9oB4K7Z0g2M/kEVCgWsVitT2IE+W95VDgA7hMhuhNxtIrRcEomEKbRBF99g1/3nhptG2tD41njZ+qGTMmn90OdfszvhcPRDD9DcUr1sPXEP16BlopN8aCdJKpUyBVrY1bdcqR/2b8TWj6+vLwQCAWMcaOeRPkhpOA4A93fhGij69ewDuNgOAK0fuv2w6/7TA9tQjBR7AGS3C7FYjAULFmDChAmD6s5dJ7G5mn/+8584dOgQli9fztS55zpNzjqVfE4UrUO6n9MOGr1Xne5btIM9XAdgsHVpul3SsrEdAHqQUyqV8PLy6md7XJ0A6Mj2eHt7M0XL6HbtatvMvY6BbDPdx+n+Rdtm9rkIdHuhP8sTREdF4B/vvQZv76ElQt7RDgDA7wTQnZA+1Y3dEaRSKXMUqLMDnKOGxpWH/Vq6A9AysRsaXXGLHuD41ppcsTbJHeTYctAzOPYgTOvHmXAc+7XckKojB4AtF/s34+qHfbCNK8K2XN1w18Fp/chkMiaKQy+bDMeAD6QfR0sC3Bkc/dvQ+uE7+Gcoa5V818x2fkQiEfz9/dHd3W1XvOd2pb6+Hjt27EBcXJxduV/2+QnDjQI4cgKkUimMRiNzBC67XTk6hngwuKc9cr+f7UCy83m4fZ4ebNnth2/i4Urbw+5b7H5O62CkttmRfrhOHZ/94bM93IORuPrxpBMgFAqgVA59i+gd7wAA4B386QNObDYb0wlkMhnjYTpT9IXPc2Q/Bwy8Bs7uhHRDozviYEbcFbphy0APJOwQP603+hxzviN4hwLfTJf7HNtgAfwOEnugu9X6Ybcdi8XCO/hz289wdMPWD7tdccO57AgA24jT+qH1xZ6lDGa82Yaeu2xGf0dLSwsuXbqEtLQ0txXCuhXs3LkTvb29TLU1bgRgqDpzBDd6RPctehDjOtbcAc4V7Yd+ntu32BMf9iDH7VtcnbgCtmy0DOz+xU6qpfXDnv0PRz+uss10JJKrH3YE4HbhjncAuB4mN5lEKBQys1324M9+3VDgqwjF9zy3kfF5v3SDp+XidkJXrjWxZydisZh3/Z2rH3ZJ0OEaKK6+2AaK20m54dOB9OPqhCX6++lqh2z9sI2TyWRiQv/OrlHy6YP7HHdbHTdXgA7V0oaKPWPhC2sPlgPAF/pnO2BarRZ/+ctfMHv2bGzatOm2M3zAzVP7vvzyS6SmpsLf358Z/NhRN+5ugKHCt7wmkUjs2o9AIGB+J7btcda5Hqntofs+u/0M1LfcYXvoQZY9qNNy0ctq7rTNfPaH6wBz+5ajyYen8wCcYUw4AHyDHP2Di0QipnGxvW9nGxlgXwqS73G2TDTsUCt7vY0eWOgGxx38XQmtG3rNjW0wuPrhq3ftrH4G+p+Wh60rrpFiOwNs/bijA7LbD52Bz15/pw0DWz/DyVh2tu2wHQD6d2Lrh60bbvsZTDfca2YbQLYjEBoaim3btmHevHmYO3euS/R9K2lvb0dYWBiSk5MZYz7cnImBdEm3X67zSLdptu1h963hOJDO2B62g8LXt9j2xx3RNaC/E8Jdf6eXRbhLIyOJPg5ke9hRkoFsM9tRYjuLt9PgD9zhDgDbSNKzfXomxx1Y6MbFDn0Pd4BjZ5SyH+fKxZefwE024ya4sQc5V+iH6yCx5XekH/bsdrhbcgZzANgeObc+AVs/A53b7gr9sOWh2w9XP9y2M1IDzg1NOirVzJaP3T749OPsTgB2EiB78KeXGKRSKRITE1FeXo63334bn376KdRq9Yh1fqswGo2oqanB1KlT4ePjY7dk4iixy1m47Ze2PWwdi0Qiu6jRcJ1rwH4m66h/DWZ7uFEf7nKIKwc5ejsv27mm9eNq28zVw3BsM9sZHkg/rrI/t4I72gGg4SZmcJcFBjr5y1kcDXDsNW023PKg3MGObYjcUZCDrRv6qFO60bOXTfhm/q7SDwDekw35HBS+xDR28RBX7wKg/7LXPrnOEbf9uFI/fEmRXP1w9+pzHQFH7Wco7YKbO8POv/D29kZGRgZ2796Njz/+GC+++OKI9H2r6OrqwuXLl1FUVMRs62Kfdc9NvB1ue2L/Pnx65a55sx1HV9oe+u9AS0h87YcdNXJHljtXP7T9YeuHfeKeq2wz3//0jJ8tG59++CYit6JYkru44x0AdgYs23Nl/6DshjXUE6kG+i42A72fb0sKu2YBdyuWu2oAsPVDP+Yob8Jd+nGUoMOnH25WvqPCLa7UEQC7wYD+TfgMt6v0w/1/IP2wr52v3XD1M5COuPpmJ7AZjUZm/VMmkyEoKAiLFy+GTqeDVqu9ZXXYh0tlZSVefPFFKBQK5kRMeu+7o8z3kS4BAODtW2zbwzf4O9t2uO8ZrP1wl5G4sg3UflzFUCZnt8L2sHU4VNvD1c3tFv4HxoADANiv63Czy7lrc1zv0hWNjNsoHHVGPkeAz3C7oxNy5eAaKbZu3K2fwWTjdkY+I+LKHAA29PexQ5eO9OPsLGW4+uHO7PjaznCS2LjRBL4ogNFoREREBHQ6HU6cOIGsrKxhHxHsbhobG7Fp0yZUVFRgxYoVdrN/RztuXL2UxNUtN9eIvWw0UgeAj4FsDy2jo7bjztkte3cL/d1Wq5W3fw1XP44SANnXw74/kO3h+3u7zf6BMeQAsP9nJ3mMtOMNBNuzdPQ/Vz62jAD6DWx8r3elfgAwThGtn5F0vKHoiE8/fLNdrn64OnG3fthOJFc37tCPo61dfEaKjSNnyFn9cMOx3O1q3OTQCxcuoLy8HAkJCVi6dKldjXtP09DQgN///vcoKSnBihUrEBQUBIVCYTf7Z9eVcFXlTUe2hx1ydmf7uR1sD1uuW2V7XGGbHdmh24kx4QDQ8A0q7IZH44pG5sjjdCTPUOV1t264A8xA24pG+l23o364/7tDP/R3eFI/9OBPJz/SMzE6AmA2m+0cAHome/78eXz44Yd4+umn8cQTT7j1PHZn2LZtG65du4alS5di3LhxTKVEpVIJhULBRAC4Sbeu3PLG/d/R7+uK/uXKtjOU17tCP7fC9rhKP9zX3G4DP82YcgBoBvvhXNXIblfcrZ87RTeOruVO0g87AkAvldFJa9wzIaxWK1JSUgAA//M//4Oqqio8//zzCA0N9Zj8ZrMZeXl50Gg0WL58OQIDA5lSt+wIAF/JbXfM6oYyaNxJ7WckshPb7H7GpAMwGKSBDAzRz8DcKfphD4DsOhHsSpF8CWwTJkyAQqHAoUOHYLVa8de//vWWLwc0Njbi5MmTsFgsKC8vh0AggEql6jf4O8r892RS153SftwB0Y1rIQ4AgUBwCHspgI4CSCQS3mJZ7H3o0dHRUCqV0Ov12LdvH+bNmwc/Pz+7ehPuoLu7G4cOHcJHH32Ezs5OzJs3D0FBQcwBLgqFgrkN5gDcbgldBIKzEAeAQCAMCHuXBT3Ic4vWsJ9jZ0drNBrk5OSgtLQUnZ2dEIvFuOeeezB+/HiX5wecO3cOb731FoqKihAbG4tFixYhMDDQ7vRIOgJAD/4DHbhFBn/CnQ5xAAgEwoBw6wvQyYB8FeYA2O0hp/MHOjs7UVtbi2vXruGbb77BjBkzsGrVKqxevRoKxdBPL6OxWCzo7OxkohKVlZXYvn07enp6sHTpUqhUKrujo2kHgD4qmX7O1fv+CYTbCcrmyj1dBALhjoUO+dOla+mtgHq9Hnq9HlqtFlqtFhqNxu6m1Wqh0+mY1zQ1NaGqqgp6vR5PPfUU5s+fD5VKhZqaGuj1eqjVaiYpz9/fn6kr0NbWhosXL6K8vBzXrl1DcXExkpKSEBUVhfb2dgBgQvr0aZp0kh97vz938GeXkyYOAGEsQRwAAoEwJLjhf7YTYDAYoNfrodPpoNPpmIGfvtGP6/V65vVarRYAIBaLIZfLkZubi/Lycua+QqHAgw8+iOTkZOh0OmRnZ2Pfvn0Qi8VQKBQIDg5GSEgIfHx8mDA++8x29mDPHvS5x0iLxeJ+1TYJhLEAcQAIBMKQoZ0A9uEstBPAjgbQpYHpgZ/+32AwMDej0Wh30hvbkTAYDLBYLPD394eXlxfznQCYWgTsM+TZBxXRgzxd4Ic98LMPM+IO/uxcBwJhLEByAAgEwpBhn4vAvs+t4c49Q50+X54e3PkcAEcHKvGVp3Z0hj27TDF3tk8X+uEej0wGf8JYhTgABALBKbiHI9GPcWuls88PkMlk/QZ/+mY2m5kbvbzALgHL/Wzukazsc9nZTgB3ts8e+EnSH4FAHAACgTAMHNWL54sEsM9Ol8lkzMDPd54A9/Q39mfzRRjYEQD2je0QsCv8uetsewLhdoQ4AAQCYVjwHSfLDdWLRCKYTKZ+Zwiw1/3phEJuWWHuwSzcz+U6F+wbPdsfbOAngz9hLEOSAAkEwohgh+vZWwWtVisT2qeTBen79IyfPfPnm/3TOMoDoAd39kDPvk+/hu9MezL4E8Y6xAEgEAgugXs8Mjupjz3LZ8/22ev+fLN/Gj4HgBsNYDsF7Nk+X3U/MvgTCMQBIBAILoZdLwCAXUSA/T/3QCG+HQBA/6UG9mye6wywQ/zsGT87V4FAINyEOAAEAsHlcM8HYM/suScI8p0oyP4MRzsNuAM8X4ifDPwEgmOIA0AgENwG27xwowL0X0cDP99ZA3zbDR3d2O8jEAj9IQ4AgUC4JXCdAXaYn/s/+3XsQZzPEeAm9JFBn0AYGsQBIBAIHoNrfgYzR3yDOxnwCYThQRwAAoFAIBDGIKT4NYFAIBAIY5D/HwBDGqEC8yeCAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEyLTAxLTIzVDExOjI4OjQxLTA2OjAwpBJKawAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMi0wMS0yM1QxMToyODo0MS0wNjowMNVP8tcAAAAYdEVYdFBORzppQ0NQAGNodW5rIHdhcyBmb3VuZKrzXC4AAAAUdEVYdFBORzpJSERSLmJpdF9kZXB0aAA4KYV+UAAAABV0RVh0UE5HOklIRFIuY29sb3JfdHlwZQA2BkqnKwAAABt0RVh0UE5HOklIRFIuaW50ZXJsYWNlX21ldGhvZAAw+zsHjAAAAB90RVh0UE5HOklIRFIud2lkdGgsaGVpZ2h0ADEwMjMsIDMxM5EUM5gAAAAodEVYdFBORzpwSFlzAHhfcmVzPTU5MDYsIHlfcmVzPTU5MDYsIHVuaXRzPTEWwuj5AAAAAElFTkSuQmCC"
    }
   },
   "cell_type": "markdown",
   "id": "91e2cc6d",
   "metadata": {},
   "source": [
    "\n",
    "<div>\n",
    "<img src=\"attachment:traverse.png\" />\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6a70fb1",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The `__getitem__` magic method\n",
    "\n",
    "And we can instead implement `__getitem__` in place of our `get` method, which will allow us to use `[ ]` notation instead"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "98513e1e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "54 -> 26 -> 93 -> 17 -> 77 -> 31 -> None\n",
      "17\n",
      "31\n"
     ]
    }
   ],
   "source": [
    "class UnorderedList:\n",
    "\n",
    "    def __init__(self):\n",
    "        self.head = None\n",
    "        \n",
    "    def isEmpty(self):\n",
    "        return self.head == None\n",
    "    \n",
    "    #this method is really a prepend - it puts the new node at the beginning\n",
    "    def add(self,item):\n",
    "        temp = Node(item)\n",
    "        temp.setNext(self.head)\n",
    "        self.head = temp\n",
    "            \n",
    "    def __repr__(self):\n",
    "        list_representation = \"\"\n",
    "        current = self.head #start with the Node at the head\n",
    "        while current: #this will keep going until current equals None\n",
    "            list_representation += str(current.getData())+\" -> \"\n",
    "            current = current.getNext() #move on to the next Node in the list\n",
    "        list_representation += \"None\" #the last one in the list points to None\n",
    "        return list_representation\n",
    "    \n",
    "    def __getitem__(self,index):\n",
    "        \n",
    "        if index < 0:\n",
    "            raise Exception(\"list index \"+str(index)+\" is out of range\")\n",
    "        \n",
    "        current = self.head\n",
    "        item_counter = 0\n",
    "        \n",
    "        while current and item_counter < index:\n",
    "            \n",
    "            current = current.getNext()\n",
    "            item_counter += 1\n",
    "            \n",
    "        if current == None:\n",
    "            raise Exception(\"list index \"+str(index)+\" is out of range\")\n",
    "            \n",
    "        return current.getData()\n",
    "            \n",
    "my_list = UnorderedList()\n",
    "\n",
    "my_list.add(31)\n",
    "my_list.add(77)\n",
    "my_list.add(17)\n",
    "my_list.add(93)\n",
    "my_list.add(26)\n",
    "my_list.add(54)\n",
    "print(my_list)\n",
    "\n",
    "print(my_list[3])\n",
    "\n",
    "print(my_list[5])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0b67b92",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## Group Activity Problem 1\n",
    "\n",
    "Note that the ADT description includes a `search` operation. Add this to your `UnorderedList` class.\n",
    "\n",
    "_Hint:_ You will need to do a traversal like with `get`, but you're going to be looking for a value in the list that matches your item.\n",
    "\n",
    "_Hint 2:_ You can find a solution to this exercise in the book: https://runestone.academy/ns/books/published/pythonds/BasicDS/ImplementinganUnorderedListLinkedLists.html\n",
    "\n",
    "It should work with code like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "097b933c",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = UnorderedList()\n",
    "\n",
    "my_list.add(31)\n",
    "my_list.add(77)\n",
    "my_list.add(17)\n",
    "my_list.add(93)\n",
    "my_list.add(26)\n",
    "my_list.add(54)\n",
    "print(my_list)\n",
    "\n",
    "print( my_list.search(17) ) #should print True\n",
    "print( my_list.search(34) ) #should print False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f913ce0",
   "metadata": {},
   "source": [
    "## Group Activity Problem 2\n",
    "\n",
    "Create a method called `__contains__` that otherwise is the same as your `search` method.\n",
    "\n",
    "This allow you to write code as below. Discuss in your group what the difference is between these two approaches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "810a704d",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = UnorderedList()\n",
    "\n",
    "my_list.add(31)\n",
    "my_list.add(77)\n",
    "my_list.add(17)\n",
    "my_list.add(93)\n",
    "my_list.add(26)\n",
    "my_list.add(54)\n",
    "print(my_list)\n",
    "\n",
    "print( 17 in my_list ) #should print True\n",
    "print( 34 in my_list ) #should print False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4339b5e4",
   "metadata": {},
   "source": [
    "## Group Activity Problem 3\n",
    "\n",
    "What is the Big O of `get`/`__getitem__` and `search`/`__contains__`?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d3831cd",
   "metadata": {},
   "source": [
    "## Group Activity Problem 4\n",
    "\n",
    "What things from the ADT do we still have left to implement? Write down a to-do list."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93ea89bb",
   "metadata": {},
   "source": [
    "## Group Activity Problem 5\n",
    "\n",
    "Take a look at the implementation of the `size` method in the book ([https://runestone.academy/ns/books/published/pythonds/BasicDS/ImplementinganUnorderedListLinkedLists.html](https://runestone.academy/ns/books/published/pythonds/BasicDS/ImplementinganUnorderedListLinkedLists.html) ). What is the Big O of that approach?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de401b12",
   "metadata": {},
   "source": [
    "## Group Activity Problem 6\n",
    "\n",
    "I claim that it is possible to do `size` in $O(1)$ time. Discuss ideas for how you might pull that off."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80c3bdcf",
   "metadata": {},
   "source": [
    "## Group Activity Problem 7\n",
    "\n",
    "Come up with a strategy for how you would implement `append` - just describe the approach, you don't actually have to code it up. What would the Big O of that approach be? Can you think of any ways to improve it?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9bf384d",
   "metadata": {},
   "source": [
    "## Group Activity Problem 8\n",
    "\n",
    "How do the complexities of the methods we've discussed so far compare with the complexities of Python lists ([https://runestone.academy/ns/books/published/pythonds/AlgorithmAnalysis/Lists.html](https://runestone.academy/ns/books/published/pythonds/AlgorithmAnalysis/Lists.html) )? Which things are the same? Which things are Python lists better at? Which things are linked lists better at?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28c08478",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Implementing a `pop` method\n",
    "\n",
    "Now we're going to do something that requires us to keep track of a __trailing reference__ in our traversal - it keeps  track of the item _before_ the current one.\n",
    "\n",
    "We'll then be able to use the trailing reference to \"jump\" over the one we're removing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "12117711",
   "metadata": {},
   "outputs": [],
   "source": [
    "class UnorderedList:\n",
    "\n",
    "    def __init__(self):\n",
    "        self.head = None\n",
    "        \n",
    "    def isEmpty(self):\n",
    "        return self.head == None\n",
    "    \n",
    "    #this method is really a prepend - it puts the new node at the beginning\n",
    "    def add(self,item):\n",
    "        temp = Node(item)\n",
    "        temp.setNext(self.head)\n",
    "        self.head = temp\n",
    "            \n",
    "    def __repr__(self):\n",
    "        list_representation = \"\"\n",
    "        current = self.head #start with the Node at the head\n",
    "        while current: #this will keep going until current equals None\n",
    "            list_representation += str(current.getData())+\" -> \"\n",
    "            current = current.getNext() #move on to the next Node in the list\n",
    "        list_representation += \"None\" #the last one in the list points to None\n",
    "        return list_representation\n",
    "    \n",
    "    def __getitem__(self,index):\n",
    "        \n",
    "        if index < 0:\n",
    "            raise Exception(\"list index \"+str(index)+\" is out of range\")\n",
    "        \n",
    "        current = self.head\n",
    "        item_counter = 0\n",
    "        \n",
    "        while current and item_counter < index:\n",
    "            \n",
    "            current = current.getNext()\n",
    "            item_counter += 1\n",
    "            \n",
    "        if current == None:\n",
    "            raise Exception(\"list index \"+str(index)+\" is out of range\")\n",
    "            \n",
    "        return current.getData()\n",
    "    \n",
    "    def pop(self,index):\n",
    "        \n",
    "        if index < 0:\n",
    "            raise Exception(\"list index \"+str(index)+\" out of range\")\n",
    "        \n",
    "        \n",
    "        current = self.head\n",
    "        previous = None\n",
    "        item_counter = 0\n",
    "        \n",
    "        while current and item_counter < index:\n",
    "            previous = current\n",
    "            current = current.getNext()\n",
    "            item_counter += 1\n",
    "            \n",
    "        if current == None:\n",
    "            raise Exception(\"list index \"+str(index)+\" out of range\")\n",
    "            \n",
    "        #this if-else statement corrects an error in the video\n",
    "        #I didn't originally check for the edge case of popping\n",
    "        #the first item\n",
    "        if previous == None:\n",
    "            self.head = current.getNext()\n",
    "        else:\n",
    "            previous.setNext(current.getNext())\n",
    "            \n",
    "        return current.getData()"
   ]
  },
  {
   "attachments": {
    "prevcurr.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "79284410",
   "metadata": {},
   "source": [
    "\n",
    "<div>\n",
    "<img src=\"attachment:prevcurr.png\" />\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "48962095",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "54 -> 26 -> 93 -> 17 -> 77 -> 31 -> None\n",
      "17\n",
      "54 -> 26 -> 93 -> 77 -> 31 -> None\n",
      "54\n",
      "26 -> 93 -> 77 -> 31 -> None\n",
      "26\n",
      "93 -> 77 -> 31 -> None\n",
      "93\n",
      "77 -> 31 -> None\n",
      "77\n",
      "31 -> None\n",
      "31\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "my_list = UnorderedList()\n",
    "\n",
    "my_list.add(31)\n",
    "my_list.add(77)\n",
    "my_list.add(17)\n",
    "my_list.add(93)\n",
    "my_list.add(26)\n",
    "my_list.add(54)\n",
    "print(my_list)\n",
    "\n",
    "print(my_list.pop(3))\n",
    "print(my_list)\n",
    "\n",
    "#let's test emptying out the list\n",
    "while not my_list.isEmpty():\n",
    "    print(my_list.pop(0))\n",
    "    print(my_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b9b655f",
   "metadata": {},
   "source": [
    "## Group Activity Problem 9\n",
    "\n",
    "Implement a `remove` method for `UnorderedList` which allows you to remove items by their value (rather than their index, which is what `pop()` does.\n",
    "\n",
    "_Hint:_ You will need a trailing reference, just like with `pop`, but instead of counting to find the Node to remove, you will look at the data.\n",
    "\n",
    "_Hint 2:_ You can find a solution to this exercise in the book: [https://runestone.academy/ns/books/published/pythonds/BasicDS/ImplementinganUnorderedListLinkedLists.html](https://runestone.academy/ns/books/published/pythonds/BasicDS/ImplementinganUnorderedListLinkedLists.html)\n",
    "\n",
    "It should work with code like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21e6c077",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = UnorderedList()\n",
    "\n",
    "my_list.add(31)\n",
    "my_list.add(77)\n",
    "my_list.add(17)\n",
    "my_list.add(93)\n",
    "my_list.add(26)\n",
    "my_list.add(54)\n",
    "print(my_list)\n",
    "\n",
    "my_list.remove(17)\n",
    "print(my_list)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}