User_Defined_Data_Structures.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# User-Defined Data Structures\n",
        "\n",
        "In computer science, a data structure is a logical and abstract representation of how data are organized, stored, and retrieved in computer memory; so that it can be used effectively.\n",
        "\n",
        "\n",
        "**User-defined data structures** : Data structures that aren’t supported by python but can be implemented using the language's basic programming constructs.\n",
        "\n",
        "In this notebook an easy implementation of some of these."
      ],
      "metadata": {
        "id": "-bZWtfzr4MXz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1. Data structure implementation: Directed Graph\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "GTXPQdIRnsuG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "    A -> B\n",
        "    A -> C\n",
        "    B -> C\n",
        "    B -> D\n",
        "    B -> E\n",
        "    D -> E"
      ],
      "metadata": {
        "id": "Wk9sqKOEzTXq"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAbUAAAGdCAIAAAAaN3rRAAAgAElEQVR4Ae2deVxN2///V9FAriEqc2SMCFckF4nMJVOUqUIyqxCJJjJlnsoUmZOikpLhKhTdWylCxlIqN2V27v1e1+/x/ezfXd/1Oed02vucfc7ZZ593f9y7ztprvdf7/Xzv/bLO2XuvhQTwBwSAABAAAuIIIHGVUAcEgAAQAAIC0Ec4CYAAEAAC4gmAPornArVAAAgAAdBHOAeAABAAAuIJgD6K5wK1QAAIAAHQRzgHgAAQAALiCYA+iucCtUAACAAB0Ec4B4AAEAAC4gmAPornArVAAAgAAdBHOAeAABAAAuIJgD6K5wK1QAAIAAHQRzgHgAAQAALiCYA+iucCtUAACAAB0Ec4B4AAEAAC4gmAPornArVAAAgAAcXp46dPnwoLC/Pz8/Py8h4/flxcXPzt2zdIABAAAkCAswTkqI/37t3bvXu3q6urpaWloaEhEvfXsmXLQYMGLViw4PDhw/n5+ZzFBI4BASCghgTY18f4+PhZs2a1aNFCnB7WUGdqaurt7Z2WlqaGmYCQgQAQ4BoB1vSxtLQ0MDDQxMSkBgmkd7h379579uzhGizwBwgAAbUiwII+vn37dsWKFTo6OqLSZ2BgMGbMmNWrV0dGRv76668PHz4sLCwsKSl5+fLl/fv3U1JSDh486O3tbWNjU7duXdHuLVq02LJli1rlA4IFAkCAOwRk1ccdO3bo6+sLSVuPHj2CgoIyMzN/MPm7fv26t7d3mzZthKx16dLlzJkz3EEGngABIKAmBKTXx+zs7CFDhghpmYuLy61bt5ioopi2Fy9eHDNmjJDl6dOn//HHH2qSFQgTCAABLhCQUh8PHjyora1NSticOXMKCgrEqJ20Vbdu3bK3tyeHMDExSUpK4gI18AEIAAF1ICCNPi5fvpyUrUGDBt2+fVtaGayhX3R0dPv27cnh4L6NOpyXECMQ4AIBxvo4Y8YMUq3WrVtXg8LJfPjPP/+cO3cuOejatWu5wA58AAJAgN8EmOnj5MmTsU41bdo0KSlJZvWja+DAgQN4aITQqlWr+J0YiA4IAAGlE2CgjzNnzsQK1bNnz6dPn9LVNpbapaSkNGzYEPsQFBSkdHzgABAAAjwmQFcffXx8sDBZWVlVVFSwJHrMzNy7d8/IyAh7cvDgQR7nBkIDAkBAuQRo6ePhw4exJPXs2VNZ4khJaUZGRr169bA/8DKick8gGB0I8JhAzfqYm5urq6tL6ZGRkRG7D/Ewmz3+2/rSpUtYH83NzXmcHggNCAABJRKoWR+HDRuGxSgxMfFfjVLy/3fs2IG9Wrx4sRIJwtBAAAjwlUAN+rh7924sQ4GBgUoWxf8e3snJCft29epVvmYI4gICQEBZBCTpY2VlpYGBAaVBv/zyy3+rk/I/lZeX41e/Bw4cqCyCMC4QAAJ8JSBJH319ffEE7ebNm8pXRBEP9u/fjz08fvw4X5MEcQEBIKAUAtXq4x9//KGnp0epj6urq4g0caWiT58+lJMWFhZKIQiDAgEgwFcC1epjSEgInprl5+dzRQ5F/IiKisJ+xsXF8TVPEBcQAAKKJ1CtPnbq1InSnalTp4qIErcqunfvTrk6ceJExROEEYEAEOArAfH6mJycjCdl169f55Ycinizc+dO7O2bN2/4miqICwgAAQUTEK+P8+fPpxSnS5cuInLEuYqKigqsj/v371cwQRgOCAABvhIQr494m63Vq1ezKIdhYWFYyC5evMiiZTs7O8qyg4MDX1MFcQEBIKBgAmL0MTc3F6uY7JslkCJoamqqqamJENLU1Bw5ciR5SMby3r17KZ8bNmyoYIIwHBAAAnwlIEYf8UqL9evXl1G2yO4ZGRmUhGloaFCFoqIisoEs5fz8fKzpGRkZfM0WxAUEgIAiCYjRR/zjo62trSyaJdTX1dUVKyOlZX5+fkJtZPmIX/UJDw9XJEEYCwgAAb4SEKOP1tbWlH55e3vLIlhk36qqKmqDbPz9WkNDw9DQ8H/+53/IZrKU8WaKS5Ys4Wu2IC4gAAQUSUCMPhobG1P6GB4eLotgkX3JR3DwF2GE0Pnz58lmspTnzZtHWba3t1ckQRgLCAABvhIQo49aWlqU0Fy+fFkWwSL7tm/fnpo5amtrP336lCpraGgMGzaMbCZLGb/w07t3b75mC+ICAkBAkQSE9fHt27d4fpeZmSmLYOG+qamp2OaMGTN+/PhhZ2dH/RapoaFRWFiIW8pSOHjwIDWKiYmJIgnCWEAACPCVgLA+vnr1CmvZ48ePZREs3NfZ2RnbTEtL+/HjR0xMDK7x8fHBLWUpnD59mrJpZGTE12xBXEAACCiSgLA+Pn/+HCsXKzsUVlRU1KpVCyGkoaHRoUMHSgH/+uuvBg0aaPznr1GjRqzcpcELVTRp0kSRBGEsIAAE+EpAWB+LioqwPj58+FCWCR3Vd8uWLdhg06ZNf/n3r1GjRrj+7Nmzsg904sQJymCzZs34mi2ICwgAAUUSENbHyspKLFvp6ekyytY///zTrl076m4MNitU0NTUHDx4sIwD/fjxY9++fZTljh07KpIgjAUEgABfCQjro0AgwMviXrhwQUbZunr1KqVZQk+GY4nE0vns2TMZx/L396fMWllZ8TVbEBcQAAKKJCBGH/HKjzt27JBRsyZOnIiVMSws7MZ//wUFBWGhlP1ZdBcXF8paly5dTpw4cf/+fUVyhLGAABDgHwEx+jh69GhKaDw8PGTRx4qKCvycY+vWrf/55x8ha9++fatTpw5166Z+/foCgUCoAaOPffv2xWpLFerUqWNhYeHi4hIaGpqUlFRcXMy//EFENAl8+PChrKystLT03bt3NLtAMyAgRh9XrFhB6Uvfvn0ZKZRQ4/Xr12PBqm5v2NmzZ+M2J0+eFLLA6CP1/iK2JrbQokWLESNGLFu2LCIiIjMz89u3b3AG8JJAdnZ2eHj4/PnzbWxsTExM6tatS54PtWvXbt68ed++fadNm7Zp06br16/zEgIEJTsBMfp45swZfDJ9+fKFkUjhxv/880/r1q2puSFCqLqHwO/du4fbDBw4EHdnWrhz5w722dzcXOh6wIeECrVq1TI3N3d2dt6wYUN8fPzLly9lBwoWlEjg4sWLs2bNatWqlVCia/xYp04dOzu7sLCwt2/fKtF/GJprBMToI/mIT1xcHFOpotrfv39/0L9/W7ZskWAkKCjo34aD3r59K6GlhEPBwcHUNdCmTRsK8f3790+ePOnr62tvb4+X+63xOjE0NLSxsVm8ePGBAwfu3Lnz8eNHriUM/BEl8PLly9WrV0shi6Lng6am5vTp02/cuCE6CtSoIQEx+igQCCwsLKhTx93dXYIqceeQpaUl5bCbm5vYLL59+/b69eu7du1yd3e3srJq0KCB6LUhtqZLly6Ojo6BgYHnz59/8uSJWONQqSwCL168wMvxCaWvYcOGtra2Xl5e+/bti4uLu337dnZ2dk5Ozt27d5OTk48ePbp27dqJEydW92/niBEjkpOTlRUXjMsRAuL1ce3atdTZ1rhxY+6IYHWePHz4EF8b586do0n20aNH586d8/f3nzBhAr5lj+1UV2jUqNEvv/wyb968vXv33rx5s6KiguZw0Ix1AgEBAbVr1xbKVK9evYKCgu7evVvd2SJa/+LFi/Dw8DFjxgiZQgg5OTnBP4qsJ06FDIrXx+zsbHyuyHjbRPR0ZL1m5cqVlLf6+vpSo6+qqkpLSwsLC1u4cKG1tXWTJk0wAcmF9u3bOzg4+Pn5nTlz5sGDB1I7AB3pE7h69WqvXr2E8uLh4cFIFkXPwzdv3mzYsKFNmzakZV1d3Z07d9L3DVryiYB4fRQIBHiVXGtra9EziTs1//M//9O4cWPqhF64cCGLuXn27NmFCxfWrVvn5OTUrVs3/CAnefGIluvVq9e3b99Zs2Zt3749JSWltLSURZfAlEAgWLdunRB2T0/PkpISFs/Jffv2UXcX8UCTJ0+GB4PU8PSrVh+PHj2KT46kpCQWTz52TYWGhmI/f/vtN/ml8MuXLxkZGYcPH/b09LS1tW3WrBkeV3LB2Nh49OjRPj4+kZGRWVlZ8vNQHSxPmzaNpO3g4PDgwQN2zyjK2t9//+3r60uOZWZmdu/ePXWADDFiAtXqo0Ag6Ny5M3V+sPJ+tDxO4i9fvhgaGlJOTpgwAUelmEJRUVFiYuLmzZunT5/eq1cvbW1t8nKqrqytrd2rV68ZM2Zs3rw5MTGxqKhIMd6q+ih//PEH3kIDIVSrVq2wsDB5nFSkzdu3b5Nf5Bs2bHj58mVVJwn+0ycgSR/J7aqPHDlCnjccKS9fvhzLUGpqKv2w5dQyKysrMjLSx8dn9OjReJsK7GF1hWbNmtna2np6eh45cuTu3btfvnyRk3sKMDtt2rT379+zPlB5eXm/fv0wwJ49e2ZnZyvsJHRzc8ND165dOy4ujvUAwSA3CUjSR4FA0KdPH+rMMDIyqqioUNgZSWegtLQ0fNbOnDmTg3xLS0tTUlK2b98+a9asvn371qtXDzssoaChodGtWzcnJ6d169ZduHDh+fPnHAytOpdatGhhamrK7vODX79+HThwICZmZ2cn9WsLdM4rsW3ItQJ0dHSuXbtWHQGo5xOBGvTx0qVL+Lx0dnYWe+ooqxJ/8dHT03vx4oVKZCUvL+/06dN+fn4ODg7t27fHbCUXGjdubG1tvXDhwrCwsLS0tKqqKm4G++bNGxxIaGgoW05OnDgRm50yZYqyzrcdO3ZgN5o1a/bo0SO2AgQ7nCVQgz4KBIIFCxbg0yI0NFRZZ6fQuO7u7tirXbt2cZavZMcqKipu3ry5Z88eDw+PX375hVwzGEcnttCpU6cJEyb4+/ufO3eOOxfqlStXSG+dnJwqKyslE6jxKH54CyE0fvx4odNAwR/Jm4H9+/ev0XlooOoEatZHgUBgbm6Oz3sWd2SV+uTeuHEj9sfR0VHVc0D6/+TJk/PnzwcGBjo6Onbp0gWHKbnQoEEDKysrd3f3Xbt23bhxQ1kvEW/btk3Iz44dO169epUMkFEZ75mBEOrfv//379+lPmfY6ujj44NjZPd5MkZkoLFiCNDSx1u3blF7yFD3Da9du8bW2SaFnQMHDuATtHPnzsrSAsWk58OHD7dv3z5w4MDixYttbGzwzXpMoLqCiYmJvb29r6/vyZMnc3NzFeMteR+Dcox6aHTz5s1SOFBRUYFfqdbX15d9BWUpTjaxXcaNG4exR0dHSxEadFEVArT0USAQkI9D1q1bNyUlReypI+/K8PBwfGrWqVPn1q1bqgKaLT9fvnwZFxcXEhLi7Oxsbm6O/93CWMQWqKUwXV1dt27dmpycXFJSwpY/pJ0+ffrgBeGF3JgyZQrTdzE9PDywkaioKHmfWvTtl5eXN2/enPKtU6dOJAEo84wAXX0UCATkjy8IodOnT9M/pVhpuWHDBnzBIIRiYmJ4lgwpwvn27VtmZmZERIS3t/fw4cNbtGhBIpJQbtmy5YgRI5YvX3706FG2nqunVjuubtD27dtfuXKFZow3b97Edji4SAq5BuDatWtpBgXNVI4AA30UCATkkrcIoaCgIFaEj44RciVdSp1VjrViHC4uLk5KSgoNDXVxcendu7euri4WGgmF2rVr9+jRY+rUqRs2bEhISHj16hVTb3NzcyXYx6t8btiwgY5lvIh948aNKysr6ZwhCm7j6OhIxaurqwtL09PJqSq2YaaPAoFg+/bt5GUwZswYef8wdPPmzR49euBB69atGxsbq4qsleVzTk7OiRMnVq1aZWdn17ZtW0xScsHIyGjIkCFLliw5ePBgenr6p0+fJPt/6tQpyQbx0UmTJpWXl0uwhrd1QwjJvgmSnHSTXDXKx8dHQjhwSHUJMNZHgUBw+vRp8lFnLS0tySvgSn2Cfvz40cvLC19XCCFTU9M7d+6oLm4ueF5eXn7t2rWdO3fOmTOnX79+9evXJwlLKHfp0mXy5MlBQUExMTEFBQVCsaxevVpCX6FDbdu2lfCi3qRJk6j2bdu2lfrkUUBH/AtpgwYNYCllofOBHx+l0UeBQJCdnd2/f3/ypDc1NWXxHcRv375t3LhRX1+fHEKK3/j5kSR5R5Gfnx8VFbVmzZrx48d37NiRZC6hrK+vP2DAgHnz5u3bty81NXX06NE0lzjC37XXr18vGtqzZ8/woFu3blWAzEk9BDmF3LNnj2gsUKPqBKTURyps0SmDiYnJ+vXrX716JfU5l5OT4+3tLbS+d/369ffu3avqrFXF/8rKyrS0tP379y9YsGDgwIFC/0ph8WKlMGHCBKEl4PBv3FpaWh8/fpT6RFJMx7Fjx1IcBgwYoCr5BT/pE5BJHwUCQUZGBv4pnbxgBg8evHnz5szMTDqn6V9//XXjxo01a9bgVwZJU25uboWFhfRDgpasE3j69GlsbGxwcPCUKVPMzMzI7Mhebt269aVLl7DPeG8PFxcXOicP/Tb//PPP69ev09PTX716JbrbMH07ZEvyCfbHjx/jKKDADwKy6iNF4cKFCzY2NmIvlbp161paWs6cOdPPz2/nzp2HDx8+duzYoUOHtm3b5uPjM2XKFPLei5CFyZMn3759mx+g+RTF58+f09PTDx06tHTp0qFDhzZt2lQocYw+Uo9MBgUFCQSCgoIC3FfqveFI/frx40dVVdWaNWt69OihpaWFjWtra3fv3n3btm1//vmnUHtGH79//443y4Rlxvl0klOxsKOPlK3r16/PnDmT5gMl+EwVLRgZGXl6eubk5PAPN18jwl+KRbNJv2bkyJH4DUUdHZ2///6bkVSJbVxQUECtZCz62yj1aH2PHj1kXHt8woQJVIwODg58za/axsWmPlIQP3z4EBkZ6ezsjN8xoHmFdOzY0cPD4+LFi2qbDNUNfO7cuTSzLLkZVrHhw4eL1TtGlcXFxdXNbclH2c3MzBiZFWq8Z88eKihDQ0PVzSB4LpYA+/pIDpOXlxcZGenr6ztlypQBAwaQD99169bNxsZm+vTpAQEB586dU61VDskYoSwQCPr371/dm4WSBbG6o/7+/kIyJMVHvHqppqZm7dq1Fy1adPjw4aSkpL179zo6OjZs2JC6ky7jy7K//fYbjgI2O+TZ5SBffRSCRb40Jo9VpoWGg48KI0D/IUosJZILsbGxUggi2SU5OZkaQkNDQ1NTMzk5mTz648eP4uLiuXPnyv4I0d9//42nvfDmgsJOOcUMBPqoGM58HuXx48eSxY7O0T59+kyePBm3zM/PF5Izph8dHR3xlHbdunVMuzNqj/dP37ZtG58zrX6xgT6qX87Zjjg6OhrrGp0Cnm3Vr1/f0dHx0KFD1PNbv/76K+7++fNnRgol1Piff/7Bt5Vr1ar14cMHoQbsfrS1taU8X7ZsGdt0wZ4yCYA+KpM+P8b29/fHuiahgGdzZmZmXl5eSUlJQuGfP3+e6q6npyejfr148YIypamp2adPHxmt1djd2dmZGs7V1VUoKPio0gRAH1U6fZxwfuLEiXhKWJ0+ampqjhgxYtu2bQ8ePKjO6cjISKp706ZNa5QkyQ3u3r2L9dHR0VFyY9mP4t0+eLaafXWZUp960Ef1ybW8IsW/vmFxxFPFVq1azZ49Oyoqis7tuIiICMpCy5YtZdSs+/fvY320t7eX0VqN3efPn08Np/hN2OWVVLD7HwKgj3AiyETg/fv3WBZxwcrKKiAggOlKS8ePH6csGBkZ1ShJkhsUFxdTpjQ0NDp37iy5sexH58yZQw03efJkmWhCZ44RAH3kWEJUzZ1bt25R0tCwYcMpU6YcPnz49evX0gURGxtLmapTp47smmVgYIC/9T99+lR2gxIsTJkyhfLczc1NutihFzcJgD5yMy8q41V4eLi3t3dycrLsHqelpVEqgxCS/Y7z3LlzsT5OnDhRrLp9/vy5qqpK7CFGlXjxgRUrVsjOASxwhwDoI3dyoe6ePH/+HOtjbm4uI4USbfz06VP8MyhCaNy4cW/fviWbHT9+vHHjxvr6+llZWWS9FOV27dpRnsMSFTw7iUEfeZZQ1Q5HT0+PEhpWNiz09PTEgosQ0tLSGjx4sK+vb0BAwIgRI/ChJk2alJWVSSGLVJdv375hUwkJCaqdAPD+vwmAPv43D/ikVAJ48cdVq1ZJLVi449evX/Er2NSr1rq6uvhLN17GfMGCBbiLFIU7d+5gfXzx4oVS+cHgLBMAfWQZKJiThQDe0cXa2loKqRLt8ueffy5dupRa+ZFURuqrt66ubmBgoGgvRjVbt26l9LFVq1ayxA59OUgA9JGDSVFfl44dO4bnYjK+YkhqXHFx8datW21tbZs3b66trd22bdsxY8bs2rVLlq/V2D5ePx8e7uHfiQv6yL+cqnBERUVFWB/Pnj2LNYizhc+fP+NpaXh4uAqjB9fFEQB9FEcF6pRHYMCAAZREKuC9QNll9+jRo1jQYZck5Z018hoZ9FFeZMGudATwFgsIodLSUtklTK4Whg4dSunjsGHDpIsXenGZAOgjl7Ojjr69efMGz8hkv3kiV3HEq2AghCIiItQxW3yPGfSR7xlWwfhcXFwoiTQwMJBxf0G56uPUqVMpP5s3b66CmMHlmgmAPtbMCFoomEB6ejqeQgYFBclV46Q2LuSkghHBcIohAPqoGM4wCjMCTk5OlETWrl375cuXUquY/DriN3CaNGlCZ/U2ZvFDa24QAH3kRh7Ai/8mkJWVhaeQkydPlp/MSWc5PDwcuxcaGvrfvsMn/hAAfeRPLnkWiY+PD9ag8PBw6YRMHr2ePHmCt8+2sLDgGXYIhyQA+kjSgDK3CHTr1o2SSA0NjXv37slD7KSwaW1tjYX76tWr3EIG3rBKAPSRVZxgjFUCKSkpWIk6d+4stECZFNImexe8VDhCyM/Pj9VwwRjnCIA+ci4l4BBFIDs7e9euXU2aNMESOWjQIIFAILvGSW1h1apV2Bk7OzvIFO8JgD7yPsWqFGBubu7evXudnJyaNWuGlYgsDB06lMV1KxgJ5erVq7EnZmZmZWVlqkQWfJWKAOijVNigE3sEHjx4EBYW5uzs3LJlSyxAQgVyJXBLS0vFP/GzcOFC7FKzZs1ycnLYAwCWuEsA9JG7ueGxZ48ePTpw4MD06dONjY2x7kgorF271s7ODjdo3rx5UlISo9mf1I3LysrGjBmDhzYyMmK6LyOP88j70EAfeZ9irgRYUFBw+PBhFxcXExMTLDd0Cjo6OhUVFQKBAG8TSPUKCAiQWvVodjx//nyLFi2wkx06dMjMzOQKUPBD/gRAH+XPWI1HePbsWURExKxZszp06IBVhmlh7ty5GKGXlxfZvW/fvikpKTTFjlGz169fu7q6kmMNHjz41atX2BMoqAMB0Ed1yLJCY3z16lVkZOScOXM6d+5M6ovU5fT0dDKAgwcP6urqktamTJmSmZnJSP4kNH737p2fnx+1JQMeZdGiRaQPUFYTAqCPapJohYa5ZMkSrCyyFDQ0NGxsbERdz8vLGzlypJBlOzu7mJgYCcJX46HMzMyFCxdqa2uTlo2NjU+fPi3qA9SoAwHQR3XIshJidHR0JFVG6vKxY8eq8z48PFz0lreRkZG7u/v58+crKipqFMQfP378888/qampa9as6dmzp6iTXl5eHz58qM4BqOc9AdBH3qdYOQF++/atf//+oorDqKbGdRW/fv0aHBxsaGgo1qypqamjo6Ovr+/evXvPnDkTFxcXHx8fHR196NCh4OBgNzc3S0tLoe/R2I6rq2tubq5y2MGonCEA+siZVPDOkefPn9N8fAerklCB/gt8e/fu7du3r1B3KT62bNnSx8fn8ePHvMsGBCQNAdBHaahBH5oE0tLStLW1yae7GWnWs2fPaA5ENcvMzFy7dq2lpSWjURBC7du39/DwiI+PZzQcNOY9AdBH3qdYyQGePXuWqVpR7WXZTvrt27cJCQnr16+fMWPGwIEDO3bsaGBg8NNPP+np6enr67dp08bCwmLixImrVq06efLkkydPlMwIhucqAdBHrmaGR35t375dColMTEzkEQMIRSUJgD6qZNpUzunly5fTl0hNTc2ePXuqXIzgMP8IgD7yL6ccjWjUqFH0JXLHjh0cDQPcUicCoI/qlG3lxXrhwoUGDRrQ1Me6devCjlfKyxWM/H8EQB//jwWU5ERg3759NJWRarZgwQI5eQJmgQAjAqCPjHBBY8YE/Pz8SHGcO3duvXr1JD/xc+/ePcbDQAcgIAcCoI9ygAom/yXg5uZGimN4eLhAIIiNjSUrybKGhoatre2/veH/QEDJBEAflZwAvg7/9u3bESNGYO1r1KgR+fT13r178SGhwokTJ/jKBOJSOQKgjyqXMhVwOCcnx9zcHAtf165df//9dyG/ye1cqJYaGhqtWrUSagYfgYASCYA+KhE+P4dOTEwkNx20tbUtLS0VG6rQArQIIX9/f7EtoRIIKIUA6KNSsPN20EOHDuFpI0Jo5syZkkMdPnw42f7ly5eS28NRIKBIAqCPiqTN87GCgoJIsVu1alWNAZeVlXXr1o3q5eTkVGN7aAAEFEkA9FGRtPk8loeHBymOu3fvphltdnZ2o0aNEELJyck0u0AzIKAYAqCPiuHM51Hev39vb2+PxVFPT+/8+fOMAr506VLv3r0ZdYHGQEABBEAfFQCZz0Pk5+dbWFhgcezQoYPQdlo0gz948CDNltAMCCiMAOijwlDzcKCrV682b94ci+OgQYMKCwt5GCeEpK4EQB/VNfMyxx0ZGYmVESEEd1dkJgoGOEcA9JFzKVEJhzZu3EiKo7e3t0q4DU4CAUYEQB8Z4YLG/0tg8eLFpDhu3boVuAABXhIAfeRlWuUV1NevXydNmoTFUUtL6/Tp0/IaDOwCAWUTAH1UdgZUZ/xnz55ZWVlhcTQ2Nk5NTVUd98FTIMCYAOgjY2Tq2SE1NbVNmzZYHC0tLZ8+faqeKCBq9SEA+qg+uZY+0tJcUfwAACAASURBVDNnzujo6GBxnDBhwpcvX6Q3Bz2BgIoQAH1UkUQpz81t27ZhZUQILVq0SHm+wMhAQKEEQB8VilvlBlu2bBkpjhs2bFC5EMBhICA1AdBHqdHxv6OzszMpjseOHeN/zBAhECAIgD4SMKD4L4GioiJra2ssjs2aNUtJSfn3IPwfCKgLAdBHdck0/TgzMjI6duyIxfHnn39++PAh/e7QEgjwhgDoI29SyU4gMTExP/30ExZHOzu7qqoqdkyDFSCgagRAH1UtY/L0d8+ePVgZEUJz586V52hgGwhwnQDoI9czpDD/fH19SXEMDAxU2NAwEBDgJgHQR27mRdFeubi4kOIIq9UqOgEwHicJgD5yMi0KdKqsrGzYsGFYHPX19S9duqTA8WEoIMBdAqCP3M2NAjzLysoyMzPD4titW7fs7GwFjAtDAAGVIAD6qBJpkouTCQkJ+vr6WByHDx9eVlYml5HAKBBQTQKgj6qZN5m9PnDgAFZGhJCrq6vMJsEAEOAbAdBHvmWUTjwBAQGkOPr5+dHpBW2AgLoRAH1Ut4wL3N3dSXHcu3ev2iGAgIEAPQKgj/Q48aJVZWXlmDFjsDj+9NNPsbGxvIgMggACciEA+igXrBw0+uDBg59//hmLY6dOne7evctBP8ElIMAdAqCP3MmFHD25cuVK06ZNsTgOHjz49evXchwPTAMBXhAAfeRFGiUGERERgZURITR16lSJzeEgEAAC/58A6CPPT4WQkBBSHJcvX87zgCE8IMAeAdBH9lhyz9LChQtJcdy+fTv3fASPgAB3CYA+cjc3snj2+fPn8ePHY3HU0dE5e/asLAahLxBQQwKgjzxMekFBgaWlJRbHtm3bpqWl8TBOCAkIyJkA6KOcASvc/K+//tq6dWssjv3793/+/LnCvYABgQAfCIA+8iGLOIZTp07Vrl0bi+OkSZO+ffuGj0IBCAABRgRAHxnh4nTj0NBQrIwIoSVLlnDaXXAOCHCeAOgj51NEz0EvLy9SHDdt2kSvH7QCAkCgWgKgj9WiUaEDTk5OWBw1NDSOHz+uQs6Dq0CAswRAHzmbGlqOvXr1auDAgVgcW7Roce3aNVo9oREQAAI1EQB9rIkQh4/fuXOnffv2WBwtLCwePXrEYX/BNSCgYgRAH1UsYdjd6OhoPT09LI5jx4798OEDPgoFIAAEZCcA+ig7QyVY2LVrF1ZGhNC8efOU4AQMCQT4TgD0UfUyvHLlSlIcg4ODVS8G8BgIqAIB0EdVyBLh44wZM0hxPHz4MHEQikAACLBJAPSRTZpytVVaWjp06FAsjgYGBpcvX5briGAcCKg5AdBH1TgBfvvtty5dumBxNDc3v3//vmq4Dl4CAZUlAPqoAqmLi4tr1KgRFseRI0e+fftWBfwGF4GAihMAfeR6AsPCwrAyIoRmzZrFdY/BPyDAFwKgj5zO5Jo1a0hxXLNmDafdBeeAAL8IgD5yN5+zZ88mxXH//v3c9RU8AwJ8JAD6yMWsVlRUjBo1CotjgwYNLl68yEVHwScgwGsCoI+cS29ubm6PHj2wOJqammZmZnLOS3AICKgBAdBHbiU5KSnJ0NAQi+OQIUNKSkq45SJ4AwTUhgDoI4dSfeTIEayMCKHp06dzyDlwBQioHwHQR67kfN26daQ4+vj4cMUz8AMIqCsB0EdOZH7+/PmkOO7cuZMTboETQEC9CYA+Kjn/Hz9+dHBwwOJYp06dc+fOKdknGB4IAIH/EAB9VOaJ8Pjx4z59+mBxbNeu3a1bt5TpEIwNBIAAQQD0kYCh2OL169dbtmyJxXHAgAEvX75UrAswGhAAApIIgD5KoiO/YydOnNDU1MTiOGXKFPmNBZaBABCQjgDoo3TcZOq1efNmrIwIIU9PT5nMQWcgAATkQwD0UT5cq7e6dOlSUhy3bNlSfVs4AgSAgDIJgD4qlL6joyMWx1q1ap08eVKhw8NgQAAIMCEA+siElgxtX7x48csvv2BxbNWq1Y0bN2SwB12BABCQOwHQR7kjFggEt27dMjExweLYt2/fJ0+eKGJgGAMIAAEZCIA+ygCPXteoqChdXV0sjuPGjfv06RO9rtAKCAABZRIAfZQv/R07dmBlRAgtWLBAvuOBdSAABNgjAPrIHksRSytWrCDFcf369SJNoAIIAAHuEgB9lFdupk2bRopjRESEvEYCu0AACMiHAOgj+1xLSkpsbGywOBoZGSUnJ7M/DFgEAkBAzgRAH1kGfO/evc6dO2Nx7NmzZ15eHstjgDkgwGsClZWVly9fDgkJmTFjxoABA9q1a6evr6+rq6ulpaWnp2dkZGRmZjZixIiFCxeGhYXdu3dPfjBAH9lke+HChQYNGmBxHD16dEVFBZsDgC0gwF8CeXl569atGzBgAL6CaBaaNGkyefLko0ePfvjwgV08oI+s8dy3bx+Zzjlz5rBmGgwBAV4TiIiIsLa2Ji8f6cp16tRxc3NLS0tjixboIzsk/fz8yIz6+/uzYxesAAFeE9ixYwf56gR5EXXq1GnSpEm+vr779++Pjo6+fPnylStXEhISTp48uW3btkWLFtna2jZp0oTsgsujRo1KSUmRnRzoo+wMBW5ubjgxCKHw8HAWjIIJIMBrAqdPn+7atSt54SCEGjRo4OLicubMmfLy8h/0/nJzc7dt2zZkyBAhUwghJyenR48eyUIR9FEWeoK3b9+OGDECJ0ZfXz8+Pl4mi9AZCPCdQElJiZOTE75qqIKNjc3JkyfpSaL4Vi9fvgwMDCTXnEYIaWlpbd26VWqioI9SoxPk5OR0794dp7lr166///679OagJxBQAwIxMTHNmzfHVw1CaNSoUdevXxeveVLV7tmzp1WrVuQQ48aNKy0tlYIu6KMU0P63S2JiIvnbh62trXQJkHJ46AYEVJBASEgIKVudOnWKjo6WSgNr6PT333+vXr2aHKt9+/apqalMmYE+MiX2v+0PHTpEop85c6Y0VqAPEFAnAosXLyavmsWLF3///r0GnZPt8N27d/v27YsH1dbWjo6OZoQc9JERrv9tHBQUhIkjhFatWsXYBHQAAmpGYM6cOfiq0dLSOnHihGzSx6C30ObyjBalZk0fU1NTj9f05+/vjxlFRETU1Pw4Bx+u9vDwwCEghHbv3q1m5zmECwQYE1iwYAG+atq2bXv37l0G8sZG09DQUOwAQigmJoZmDKzpo0AgmDBhAumEjOW1a9fSjEExzd6/f29vb4+D0tPTO3/+vGKGhlGAgOoSCAgIwFdN165dnz9/zobiMbZB/iZWt27dO3fu0EHKpj6mpqZiEDIW6tevz6nJY35+fu/evXFQHTp0oMmXTg6gDRDgK4ETJ06QV83Lly8ZCxt7HQ4cOICd6dKly7t372rEzqY+sjiFXLNmTY2uK6zB1atXyScSBg0aVFhYqLDRYSAgoKIEHj9+jJcj+Omnn7Kzs9nTOiktbdy4EUukk5NTjWBZ1kdWppCcmjxGRkZioNQT+TUyhQZAAAgIBILRo0fjaycmJkZKSWO72+zZs7FX+/fvl5wplvWRlSkkdyaP5L82CCFvb2/JNOEoEAACFAFyuZbVq1ezrXLS2/v+/Tt+raNRo0bFxcUSUsa+Pso4hfzpp5848suj0ONasrylJCEBcAgI8I9AZWWloaEhNU2ztLSUXszk0/P69et4Cunu7i6BP/v6KOMUkguTx69fv06cOBET1NLSOn36tASIcAgIAAGSwKpVq/Dlc+PGDfmonExWydmPhBV25aKPUk8hufDL47Nnz6ysrHB2jY2Nb968SeYeykAACEggUFZWVqdOHeoKcnV1lUnG5Na5srKyfv36lJNTp06tLhy56KPUU0ilTx7T0tLatGmDxbFfv35Pnz6tjh3UAwEgIEqAfMHs8ePHcpM4WQ0HBwfjK726ZdDkpY9STCGV/svjmTNntLW1MbIJEyZ8+fJFNP1QAwSAgAQCeL3bmTNnyqph8uz/4cMHPM9duXKl2IjkpY9STCGVO3nctm0bVkaE0KJFi8TygkogAAQkEIiLi8PX0a1bt+SpbyzYXrhwIeWtsbGx2KDkqI+MppDKnTwuW7YMJxUhtGHDBrGwoBIIAAHJBFxdXalLqVevXiwImJxNZGRk4Atf7CbMctRHRlNIJU4enZ2dMSOE0NGjRyWfAXAUCACB6gg0bdqUuprWrVsnu7jVqlWLvDZFy2PHjpVxlC5dulBmPT09RYOSrz6mpaWJhiRao6zJ4+vXr8ld05o1a8bKnj6ilKEGCHCWQEBAQEFBASvu3blzB1/drLxNqKmpiQ2KLciuj/i7o7m5uSgE+eojzSmkUiaPGRkZHTt2xNB79+798OFDUUBQAwT4TYB6C3DMmDGMFkYUy2Tr1q3UBdW8eXMZp3VUdwXoY2JiIhYB0S0A5K6PNU4hlTJ5jImJqVevHuZiZ2dXWVkpNuVQCQT4TYDcfdPAwMDT01PC89KSUUydOpW6psaPH8+uPrZs2fKGuL+8vDwZB6qqqsI6kJiYKBSg3PWxximk4iePe/bswUQQQnPnzhWCAh+BgPoQENqnhbo0fvnll3379lVVVTHi0LNnT6p7cHCwjLIlNH/s2LEjKwbFGunQoQPldmhoqFC8itBHCVNIxU8efX19SXEMDAwUIgIfgYBaEdi1axd5RVBl6outtra2i4vLlStXaALBb6RERUWJVSKmlfj7tVz1ccyYMVTU8+bNE4pUEfooYQqp4Mmji4sLeSocPHhQCAd8BALqRuDs2bPkRSG2bGZmtn79+pcvX0qAU15ejvuytYOCYvQRb/9gb28vFKCC9FHsFFKRk8eysrJhw4bh/DVu3PjSpUtCLOAjEFBDAjdv3sTXRXUFrFPjxo2LiooSSyk/Px93Z2udcDwutkwWMjMzmU5IxbYPDAykzFpZWQmFpiB9FAgE5Io4lDcKmzxmZWWZmZlhst26dcvOzhYCAR+BgHoSePz4Mb40aBaaN2++YsUKoYvo3r17uPu7d+/EKhHTSsXoI353TvQRH8Xpo9AUUmGTx4SEBH19fZy54cOHl5WVqeeVAFEDAVEC5A1cfJnQLAwePPjgwYOfP38WCATkw48fP35kKoVi2ytGH3fv3k3F27VrVyE+itNHgUBAPozt6+sr5Io8PpI78iCEXF1d5TEK2AQCKk0A7xJDUxZxM0q/9PT03N3dDx8+jOsrKyvF6h3TSqyP+vr6/iJ/JSUlTA2Kbb99+3bKcyXMH0tLS69fv37o0KGgoKChQ4digvPnzw8JCTl27NitW7eYPkZA81wkN5ZECK1evZpmR2gGBNSKQKdOnfCFyUqhsLBQrBIxrcT6KNf713hBtn79+gnlXS7zx5KSkiNHjkyfPr19+/Y0cZubm8+bNy8qKurjx49CLkr30d3dnRx679690tmBXkCA9wQGDRqElYi8aqQus3XnBHslV31ctGgRFamdnZ1QrlnWx4iIiJEjR0qNFSGko6Pj5OR08eJFIUfpf6ysrMQPNCGE6tevHxsbS787tAQCfCXw8ePHgoKCtLS0c+fO7dmzx8/Pb86cOfb29o0bN5blmhXtGx0dzXSqKLa9YvRx7NixVAiir4qwo4/v3r0LCAho1qyZKCmqpmnTphYWFqNGjXJ0dHR2dp40adLw4cN79OjRqFGj6rp069ZNiknfgwcPevXqhW126tQpIyODr6c7xAUEhAi8efMmKyvr8uXLERERGzdu9PT0dHJysrGx6dq1K3mXEl8grBQ0NDQQQpaWlnjt/fXr14vVO6aVWB/F/v7o7+9/6tQppjZF23fu3JnisGnTJiGeLOjjhg0bxMqcra1tSEjI9evXJd/sLykpSUhI8PX1tbS0FM1Wp06dIiIihJyu7uOVK1fw8koIocGDB79+/bq6xlAPBFSOQHUTwD59+hgbG+vo6IheQQqoadasGXWROjk5UcM5OjqKypAUNVgfq4vC3t5eCrNkl0+fPmHj8fHxQqeETPqYkJBgbm6OrVOFIUOGHD58+P3796QTNMuFhYWhoaE9evQQsjlixIisrCwh14U+Hj16lOwlYc8doY7wEQhwh0BpaWl1E0AWvwXr6em1a9fOyspq/Pjx8+bNGz9+PHntMCrPnz//3bt3FMBNmzZRfVu3bk3zkpfcrEZ9dHBwkGyhxqNXrlzB8YruhS29Pnp7e2O7VGHGjBn37t2r0SE6DRITE0eMGCFkf/v27dWdxyEhIWTj5cuXV9cS6oGAEgl8/Pjx6dOnor8AUhNAXV1d8jSWpWxoaGhubj5s2LDp06cvX748NDT0+PHjKSkpeXl5b9++FSJw6dIlKcaysLAQWnObfMZZ9pV1fvz4YWNjM0ji39q1a+noiYQ2K1eupGIXffhRIBBIo4/Pnz8fPHgwCdTOzo6tO1ZkJPHx8RYWFuRAM2bMEEqtQCDAm0hQLSXIqGhfqAEC7BIoLS3Nzs4W+wsguxNAExMTPAEMCAgICwuLjY29c+fOy5cvv379yiio3377jbzKaixraGisW7dO7BA4xk2bNpHXMmfL+BvwwoULRSNirI9paWnGxsaYoL6+/tGjR+Ua/Pr16/FwCKEBAwYUFRVRkXz+/Jn8aqCjo3P27FnRIKEGCLBFQJETwO7du4tOAHNzc0UngDJGV1xcTF5i1ZWpb7sODg55eXnVjTht2jSqe9++feUqC6wYz8rKwsEmJCSIBsVMHy9fvkwuKztq1KiioiJWHJVs5Pbt2+QL1GZmZo8fPy4oKCBv6bRt2zYtLU00QqgBAowIKHIC2K9fP+oXQHIC+OLFC6YTQEYBim1cu3ZtrBTVFfB9GLEWqMro6Gjcna1f2ySLgyxHvby8KG+bNWsmNigG+piSkkL+PuLp6SmLZ0z7Ck0V27Rp06JFC5yJ/v37P3/+XGyEUAkESAIKngDa2toK/QIojwkgGaB05ebNm+OrSWyBvA8jeYiWLVtSFtzd3Zle5opsLxAI8IuVXl5eYoOiq4+///47/mWB2gFVkZHgsYTeiqHSMGnSpG/fvokNDyrVkAA1AUxKShJ9BpA8h8WqAP1KPT09ExOTfv36jRs3bt68eUqfAMqY6N69e1OPMYoSEL0PI3ksPz8/bISthc6wArBY2Lx5M/YzJydHbFC09LGqqqp79+7Y1pYtW1j0kqmpefPmYU8QQkuWLBEbGFTylQCeAEZHR5MvgcjjFnD37t1tbW2nTZtG3gLOzc0tLy/nGd7Ro0eLPkwj4T6MhPCLioqwqXnz5jG9wBXT/uvXr4aGhpSSTJo0qbpwaOkjfuwTIST7DXXZ4yd3rF67dm11sUG9ihKACaDiEzdr1iw87aBzH0ayh56enthaRkaG7Jc86xZ8fHywhxLuW9Ssj+T2FC4uLqw7Kp1BKysrHJ7QQ1iSMwdHlU4AJoBKT4GoA+QuXXTuw4haIGtKS0vxT3uDBw+W7hqXX6/09HSsHmIfGcSx1KCPT548wfdkevTo8f37d/k5zchyfn5+nTp1qCB79OiB44ECFwjgCeDRo0eF3gKW0y+AHh4eQr8AfvnyhQsoVMUHPA2ifx9Gcmh4L2yEEFuvYzOSCAmN8XMvurq6z549kxBIDfpIfrO+deuWhCEVf+jQoUP4HwHYhlBCjlk/RE4A9+7di5eBkesvgMuWLcMvgfDyF0DW08TI4NmzZ5neh6nRPvkWSVJSkuIlQuyIixcvxrqxbds2yVFI0sekpCRsaNWqVWIHU26lg4MD5aGuri5+aFxywHCUDgFyArhp0yZyGRj5TQD9/f3xSyAvXryACSCdTLHVJjU1lS1T2E5WVpaWlhZ1hTZt2rSgoEC5cvHjxw88TUYIOTg4YFerK0jSR7zhn7Gx8d9//6302EQdyM3NxQru6elZXZBQL0Tg06dP1FvA0dHRipwAbtmyhXoLGCaAQhnh68eDBw/iK7RHjx5v374VvYoVVnPq1CnsjLGxsehqFKJZqFYfr127hm3t379fYTEwHQi/fK2trV1aWioaoXrWwARQPfPOqajT0tJ8fHzwDQxqjcjy8nKm1zgr7c+cOYMFDSF09epVOqyq1Uf8DI2JiQkr/snJyPPnz3HYISEhdGLmQZtPnz49e/YsLS2NmgCuWbOGWgha3r8AwgSQByePXEMoLS2NjIycPn06froQX55UoXv37vn5+XJSg+rMhoWFkW4cP36cJgTx+lhaWorNcX8dDvxKvNgVimiC4FozoQmgl5cXXgharr8A7t+/n1oGBn4B5NopwWV/0tPTg4KCBgwYgHVDqICfNkEI6evrX7x4sTotY72efNQRIXTw4EH6JMXr4549e3B4ypoP08d09epV7O3NmzfpB6/ElqITQHd3d3t7ewVMACMjI1NSUuAXQCVmnx9D//HHH6dPn3Zzc8MrIeDXZvD1iAtUS/wRIeTn50f/Gpeu5aNHj2xtbclBjx49ygi+eH3Ea9PKvjyvdIEx7WViYkJRWLFiBaP45de4tLQ0JycnKSnp6NGjmzZtktMEsG7duvgtYA8PD39/f5gAyi+nYFkgEGRmZoaEhNjY2JC6I7lsYGBAofP19SVbWlhYXLlyhenFTrP95s2bSb02MjK6dOkS0wyK0cdPnz7hxY6OHDlC05vqmg0ZMoQkghCqVauWgYGBubn5woUL2VoebcmSJdQovXr1YopAuvbUBPDWrVv4F0A5TQANDAzwW8DLli3bsmULTAClSxn0kprA+/fvz5075+7ujnfgIqVH6AIX/bh06VI89LFjx+rXr0+2cXJy+v3336sTECnqjx8/Ti6HiBAaMmRIQUEB9oF+QYw+ko89vn79Wgr/yC5Dhgypbl0QDQ2N2rVrHzx4kGwvXTkhIQETf/PmDf34JbSkJoDJycl4Aujs7ExtBcfiL4B169Zt27YttQwMngDGxMTcuXMHfgGUkB04pAACOTk5W7ZsGTZsWHWXML7oJBfS09NJbx89ekTuwEz1HT9+fEJCgnSXP9Wrqqpq586dXbt2FXLG39+fHJ1RWYw+BgcHUwN07txZFnepvkOGDBH7Tw1FXOM/fw8ePJBxoA8fPmAocXFxdBCInQCOHTuW9V8ADQwMunXrRi0DAxNAOqmBNsolcPny5QULFnTo0IG6psRev/hyk1zQ1NTs27ev2HAOHDiAV4rERoyNjZcuXZqcnPznn3/S1ISioqKIiIgJEyZgI7gwatSou3fvih2dZqUYfXR0dKQGmDp1Kk0XJTQj9fH8+fM3btyIj48PDAw0NTXF3BctWiTBAs1D+N8NvDOG2AngkCFDunbtyvoE0NLScty4cTABpHnaQTOOEzh9+jRCSMZpIyUjO3bsqC7YL1++BAYGir0YNTQ0LC0t3d3dt2zZcubMmatXr2ZkZGRmZt6+fTsxMfHIkSNr166dNGlS+/btsRqShf79+0dHR1c3Lv16MfqIt1cNCQmhqU0SmpH6WFpailu+fv2aikdDQ6N///64XurCpEmTKINNmjQxNjYmn0olwUlRFjsBvHLlCtwCpn+eQUuVIxAeHi7FxSLapca3Nj5//rx9+/ZevXqJ9pWiZuLEiWJ3kpGOvxh91NfXp9w6c+aM1GqFO1anj3/++Sc1iqamppWVFW4vdUHoKSf6ZKlfAEUngLdv34ZfAKU7q6AXPwhs2bKF/nUktuWUKVPoo0hLS1u+fDm5FLdYm6KVtWvXHj58+M6dO1lfhEFYHz99+oSHv3nzptRqhTuK1cfPnz+7ubnhgYKDg3F7qQs7d+7EBoUK1ARw6NCh06ZNw78AwgSQ/okLLdWWALlZgtBlRefjhQsXpED34sWLU6dO+fj42Nvbd+vWrXHjxuQ3fR0dnRYtWlhaWk6bNm3Dhg1Xrlz5/PmzFKPQ6SKsjyUlJTjs3NxcqdUKdyT1sV+/foMGDRowYAC5CWKDBg3++OMP3F7qwrFjxyjPGzRosH///piYGJgA0jkDoA0QkEyAXBAMiwOdQuvWrSVbZnS0qqqqoqLiw4cPjHrJ2FhYH1+8eIEjZ2U9IlIfsWWywMqvnD9+/Dh79ixlFj+MKiMa6A4EgABFYObMmeQ1S7O8cuVKVQcoSR+fPHki9WwOd6xRH6k3InF7qQt4fQ7QR1U/KcF/DhIYP348TVnEzarbFJCD0VXnkrA+kitT5OTkSK1WuCOpj97e3v7/+Zs6dWrbtm0pjpqamtra2u/evcNdpCtERERQBtmd1VcHDuqBgLoREH0XDkuhUEFTU9Pa2poHfIT18evXrzjUa9euSSdVZC9SH8nne378+DFhwgT8s+v169fJXlKU8X4X5ubmPEgMhAAEuEbg+PHj+ILFKlFdISwsjGv+S+GPsD4KBAK8cFtkZKQUOiXURYI+btq0CcM9ffq0UEemH728vChrw4YNkwIEdAECQEACgSNHjuCrtcaCjo7O+/fvJVhTlUNi9LFPnz5U/KxsdV2dPn79+tXKygr/c3T79m2mgijU3t7ennJ7zpw5qkIf/AQCKkFg+/btpCbWq1cPX7lkPS67uLioRFw1OilGH6dPn07FOX78eCENkuIjqY/498cVK1Y0bdqUGqVWrVotWrSQfX8bvMRZaGhojWFDAyAABGgSCAgIwMKHEAoPD79586auri5+P5g8SpV5syW9GH0MDQ2lgmzdurUUgijUhdRHkiMFl/pX6MKFC0K9mH4kbyulpKTQTDw0AwJAQDIBb29v8rI9ffo01T4uLg4hJCqRGhoanTt3lmxThY6K0cfU1FRM5NGjR0ylSqi92Hte1D1rhFCdOnViY2OFukjxET/cgxDixw8fKnQOgat8JTB79mwsBfXr109MTCQjPX78OD5KFgICAshmKl0Wo48CgaBhw4ZUwDt27JBCrcguXl5eg8T9jRkzZv369Wzt94jfVhwwYIBK5wOcBwIcIYDX8UIItWjRIi0tTdSxvXv3kspIlZ88eSLaUkVrxOsjRjN48GBS7DhbxkskBQUFqWgmwG0gwBECm4qYZwAAHKhJREFUVVVVw4cPx8LXpUuX3Nzc6nwLCQnBLTU0NEaOHFldS1WsF6+PkZGROGZW3qKRq7CeO3cOe5udna2KaQCfgQBHCBQWFvbr1w9fUJaWloWFhZJ9W7VqFW7PdAMsyZaVflS8Pn79+rVBgwZUzD4+PnJVN9mNjx49mnLVyspK6UDBASCgugTy8vLwOtMIoeHDh1dVVdEJZ/78+QihBg0a0GmsQm3E66NAIFiwYAElOg0aNPjy5YvsKiYnC3fv3sX/du3fv1+F0IOrQIBTBG7dukVueODo6MjIvalTp86bN49RF+43rlYfs7KysO4EBQXJSd1kNzt58mTKz7p16+bl5XGfOHgIBDhIIDExkdxWcNasWVI4qSq7z9MPrVp9FAgEzs7OlPTo6uqWlJTIrmWsW0hJScEiThUWLFjw8uVL+vFDSyAABKjdZvCl5OXlBUwoApL08ffff8fIXF1dWVc32Q1aWlpiD3GhVq1aPj4+5eXlkGMgAARqJCC0zwyfnl6sMfYaG0jSR4FAsHTpUqw7UVFRsisaixaCgoKwb6NGjdLS0sIfqZ+KAwMDv3z5UiMCaAAE1JaA0A4z27dvV1sUYgOvQR8/fPjQpk0bSncMDQ0LCwtZFDhZTJHfrEeMGCEQCAoLCxctWkRKJEKoWbNmW7duFRs5VAIBNScgtLfMkSNH1ByIaPg16KNAIIiKisKiM2TIEFlEja2+RUVFrVq1orzS0dEhH159+PChq6srdpgqdOjQITw8XDR4qAECakuA3FWmVq1a586dU1sUEgKvWR8FAgH5jrqLiwtbMiedHYFA8Msvv2AFFCt8d+/exfe1ccuePXseP35cAgs4BATUhAC5n4y+vv6VK1fUJHCmYdLSR4FAMGrUKCw0CxYskE7aZO/1/fv3kSNHYk+WLFkiIeAbN27gR8dxl/79+8fGxkroBYeAAL8JkDvJtGnTJiMjg9/xyhIdXX18+/Ztz549scq4u7vLLnZMLbx//37o0KHYh4kTJ9KJPD4+ftCgQbgXVRg+fDj8m0mHHrThE4E//viDXE/L3Nz80aNHfAqQ9Vjo6qNAIHjy5EmnTp2w0Njb21dVVTHVOKnb379/39zcHI9O3ZOhj+PMmTMWFha4O1UYP3787du36RuBlkBAdQk8f/6cvAQGDBhQUlKiuuEoxnMG+igQCB49emRmZoZVpmPHjqzs4VWjaB47dkxXVxePO2bMGOnoHD582NTUFNuhCtOnT79//750BqEXEFAJAllZWR07dsRn/ujRoz99+qQSnivXSWb6KBAIiouLra2tMWiEkK+vb40CJ3WDsrIy8rdkhNDMmTNlRLZz587WrVuTISCE5s2b9+zZMxktQ3cgwEECv/76K97OBCHk5OTEQSe56RJjfaTCIBcWRgh17Njx+PHjUotgdR1DQ0PJd0IRQoGBgWxxDAkJ0dfXJ1VSQ0Nj2bJlpaWlbA0BdoCA0gnExcXVrVsXn+ceHh5Kd0mFHJBSHwUCQVhYmJ6eHuaOELKwsDh27Fh1Yke//tOnT1u3bsXPpVNDdOjQIT4+nl2ylZWVq1ev1tHRIaOoV6+ev78/fPtgFzVYUwoBoS0QfHx8lOKG6g4qvT5Sd2wmTZpEigv1yoq3t7d0+7UmJia6ubkJCRZCaPHixfITrNevXy9ZskQoCiMjo82bN6tuXsFzICC0+cH69euBCVMCMukjNVhMTIzYdSKaN2/u7Oy8a9eumzdvlpWViZ0/FhYWJicnb9y40d7e/qeffhISKYSQvb29Ym4xP3r0SOhHA4SQiYnJvn37mDKF9kBA6QTIbQ8QQrt371a6S6roAAv6SIV95swZGxsbUYHDNbq6uq1atTI1NTUzM+vUqVPz5s1r1aqFj4oWJk2adO3aNQUz/e2335ycnISc6d69+7FjxxTsCQwHBKQmsHLlSvIchrNXapKs6SPlQUZGhpeXl4mJCZkeRuWePXsGBQUVFBRIHZLsHW/evGlvby/kdr9+/aKjo2U3DhaAgFwJUFsdUGevrq7uhQsX5Docv42zrI8YVnp6+saNGx0cHESfpBHSHYRQp06dnJyc9uzZ8/DhQ2xB6YXExETRGfHQoUOTkpKU7hs4AATEEpg6dSq+vgwNDW/cuCG2GVTSJCAvfSSHLy8vz8jIiImJOXz48K5du7Zt27Z79+6IiIj4+PisrKz379+TjblWjoqK6tOnDz7nqIKDg4PY7YC55jz4oz4Evnz5Ymdnh0/UDh06/Pbbb+oTvpwiVYQ+ysl1RZqNiIggXxyizkJnZ+esrCxFugFjAQGxBEpLSwcOHIjF8eeff3769KnYllDJiADoIwNce/bsEXoqEyHk7u6u3F9LGQQATflI4PHjx+TaMYMHD4bNRdjKM+gjY5IbN25s0qQJ/reaKnh5ecHb/oxRQgeZCdy7d4+8Herg4CCzSTDwfwRAH/+PBf3S+/fv16xZQ762hRCqW7eun58fx39OpR8jtOQ+gatXrzZu3Bj/Uz1jxgzu+6xaHoI+Sp+vN2/eeHl54bOTKjRp0mTjxo3SG4WeQIAegfPnz5N70i1atIheP2jFgADoIwNYYpsWFBS4u7sLqWSbNm327Nkjtj1UAgHZCURERJCn3OrVq2W3CRZECYA+ijKRpiYrK4t89Iw6d83MzCIiIqQxB32AQPUEduzYQYrjpk2bqm8LR2QiAPooEz6hzmlpaQ4ODuS5ixDq06dPVFSUUEv4CASkI0Bu+44QCgsLk84O9KJDAPSRDiVmbZKSksh9cii5tLGxuXTpEjND0BoI/DeBZcuWkf/6njp16r+PwyeWCYA+sgwUmzt//ny/fv3IsxkhZGdnd/PmTdwGCkCAPoE5c+bg06levXoJCQn0+0JL6QiAPkrHjW6vY8eOde/eHZ/WVMHJyQne/aJLENr9hwC5n3vz5s3h9VbFnBegj4rgvG/fvnbt2gmp5OzZs2F3TUXQV/ExPnz4QO75bmpqCtvJKSyloI8KQy3YsmWLkZGRkEouWbLk9evXinMCRlIpAq9fv7ayssLnTN++fV+9eqVSEai2s6CPCs3fp0+f/P3969Wrh894hJCOjs7q1asrKysV6goMxnkCDx48IFdFGTZs2Lt37zjvNa8cBH1UQjpLS0uXLVumoaFBqqS+vj7sEKKEZHB1yNu3b7dq1QqfIRMnTuSqp3z2C/RRadl99uzZvHnz8AVAFVq1arVz506l+QQDc4PA5cuXGzRogM8NNzc3bvildl6APio55ffv358+fTq+EqiCqanp4cOHlewZDK8kAmfPniW/W3h6eirJERhWAPrIiZPg9u3bEyZMEFJJCwuL06dPc8I/cEJRBA4ePEieBv7+/ooaGcYRQwD0UQwUZVWlpKQMHz6cvDwQQoMGDYqPj1eWSzCuIgmEhoaS2d+2bZsiR4exRAmAPooyUXJNbGxs//79yesEITR69GjYa0nJiZHz8GvWrCGTfujQITkPCOZrJgD6WDMjpbQ4fvw4uWg+deU4OjrevXtXKf7AoHIlsGTJEiyOmpqasKCJXGnTNw76SJ+VElqGh4d36NABXzlUwdXVlVMb4SqBC7+GdHV1xSlu1KhRcnIyv+JT4WhAH1UgeVu3bm3WrBm+hKjCokWL4FUKFUheTS6S9+WMjY3T09Nr6gHHFUcA9FFxrGUZ6cuXL0FBQeQzcQghLS2tlStX/vHHH7JYhr7KIlBRUUGug9e9e3f4WqCsXFQ3LuhjdWS4WF9eXu7j41OrVi1yLtmwYcPg4OBv375x0WPwqRoCL168sLCwwHns379/cXFxNW2hWmkEQB+Vhl7qgV++fLlgwQJ8aVGFFi1abN++XWqb0FGRBLKzszt16oQzOGrUqI8fPyrSARiLJgHQR5qgONcsLy/PxcUFX2NUoWPHjgcOHOCcr+AQQSA1NZX8NdnJyYk4CEVuEQB95FY+mHqTkZExadIkIZXs1avXyZMnmZqC9gogEB8fr6enh/M1d+5cBQwKQ0hNAPRRanQc6njt2rVRo0bhq44qDBgw4MKFCxzyUu1dOXHiBJmjFStWqD0SrgMAfeR6huj7d/HixYEDB5JXIEJoxIgRV69epW8EWsqJwL59+8jUBAcHy2kgMMsiAdBHFmFywtSpU6d+/vln8lJECE2cOBEerFNiejZs2EBmZNeuXUp0BoamTwD0kT4rVWp58ODBzp07k9ckQmjmzJm5ubmqFAYvfPX19SUTcfToUV6EpRZBgD7yOc07duxo2bIleXEihObPn//ixQs+h82l2MgnsXR0dGJjY7nkHfhSAwHQxxoA8eDwunXrGjVqRKqkpqbmihUrysvLeRAdl0OYNm0axm5gYHDt2jUuewu+iRIAfRRlwsOaioqKVatWaWtr48sVIVS/fv2AgIDPnz/zMGBlh/T161d7e3tMu127dpmZmcp2CsZnTAD0kTEy1e1QWFi4ePFifNFShaZNm4aGhqpuUBz0vKysbNCgQZhzr169CgoKOOgnuFQjAdDHGhHxrUF+fr6bmxu+eqlC+/btw8LC+BaqMuIpKCjo1asXxmttbV1WVqYMR2BMFgiAPrIAURVN3Lt3b8qUKfgypgo9evSIjIxkJZyzZ88mJiayYkqFjGRmZrZr1w5THTt27NevX1XIf3BViADooxAQ9fr466+/jhkzBl/PVMHKyiomJkZGEBYWFu3atausrJTRjgp1v3btWpMmTTDMadOmqZDz4KpYAqCPYrGoV2VCQoK1tTW+sKnCsGHDrly5Ih2Iw4cPU0amT58unQWV6xUTE0Pe/lqwYIHKhQAOixIAfRRloqY1Z86cIVckpARu3Lhxt27dYkrE1NRUU1OTsrBv3z6m3VWu/dGjR6lgqf/6+vqqXAjgsFgCoI9isahv5ZEjR7p06UJe7QihadOm5eTk0ISya9cu3F1DQ0NLSys7O5tmX1VsRsaLENq4caMqRgE+iyUA+igWi7pX7tq1y9jYGMscVfDw8Hj69GmNaFq2bIknj1THgQMH1tiLrQbl5eU5OTnXr1+Pj4+PjY1NSEj49ddf8/Ly5PRLaHBwMElp//79bAUCdrhAAPSRC1ngqA8bNmxo3Lgxef0jhLy9vUtLS6vzOCQkRKg99dHHx6e6LjLWl5WVnT171tPTc9CgQQYGBmJHpypbtGgxbNiwVatWxcXFffr0ScZxBQLB8uXLyeFOnDghu02wwCkCoI+cSgfnnKmsrPTz89PV1SWFQE9Pb+3ataJbAlRWVurr65MtyTK7rx6Xl5fv3r17yJAh5BD0y1paWmPHjo2IiJB63x53d3c8nJ6eXnx8POeSBw7JTAD0UWaEamCguLh46dKlWA6ogqGh4ebNm8no/fz8hNrgj5qamq1atWLlSemMjAw3Nzehr/B4IFzQ0dHR09Mj7ynjQ2ShUaNGnp6ejx8/JgOpsezk5ISNNGvWLDU1tcYu0EAVCYA+qmLWlOPz48eP58yZg3WBKrRt23bv3r0CgaC4uFhHR0foqNDHKVOmyOL677//LvpMOzWEpaXl0qVLIyIi7ty5U1xc/Oeff/749+/bt2+vXr369ddfw8LCPDw8zM3NhbyiPs6bN4/OfuIfP34kl2rv3Lkz/TtXssQOfZVCAPRRKdhVeNDff/+dnD1R4tKtW7cRI0aI1R2hyh07dkgR/Ldv35YtWyZkCiE0fvz4EydOVFZW/iuGtP7/+vXr/fv3k3tPU5Z1dXU3bNggwb3i4uL+/ftjN/r06QMrxUnAxYNDoI88SKISQkhNTR07dixWCkaFjIwMRh5funRJaK1fAwODgICAkpISWnJYfaOHDx8uXbpUaD/xAQMGiF1r5+HDh926dcORDh06tKKiglEg0FjlCIA+qlzKOORwYmKiFHdILC0t6ccQGBiIJQkhpKOjExwc/Ndff1UveoyPlJWVeXp6kqNoamqGh4eTTt65c6d169a4zYQJE8ijUOYrAdBHvmZWcXFt3boVCwfNgqenJx3/yPVlEUJTp04tKipirH/0OmRlZQ0bNoz0H+8vmJycTC4w7OrqSsd5aMMDAqCPPEiikkMQ/TmSVJnqymfPnpXg94cPH4YPH4776urqRkRE0BM6mVpt3LgRD4oQcnV1jYqKIu+VL126VILbcIhnBEAfeZZQRYeTmppKCgrNsqampqGhYVFRkVh3P336NHjwYGyqZ8+eubm5Mskek85Xrlxp2rQpHp0srF27VqzDUMlXAqCPfM2sguIidxEgpYROefz48WK9JB+gGTVq1OfPn5noGwttCwoKRB8DglXWxSaL35Wgj/zOr3yjS0xMpKODEtoIPWEuEAhmzZqF248bN44FtZPKRFlZWe/evbEnDg4O8kUJ1jlJAPSRk2lREaekuHmNFQcX0tLScLibN2/G9cOGDZNK2VjrVFJSYmpqiv2R/IMpDgEKfCIA+sinbCo0lnPnzmHtkKXQq1cvym/yp8wuXbowfeqbNV0kDOXk5NSrV4+KzsDAoLCwUKGIYTBlEwB9VHYGVHb8vn37amhoyKKMuO/8+fMFAkGfPn1wzd27dwmZUmYxKioKe+Xo6Kiy6QLHpSEA+igNNegTERGBVYOVAvne3u7du5WpiCJje3l54RhPnjwJ2VcfAqCP6pNrNiM1MzMjnwrE8iF7YfTo0SICpfwKvKa6qakpmxzBFrcJgD5yOz+c9G7v3r2y62B1FnJycpQvhyIexMTEYIe3b9/OybSAU+wTAH1knynvLX779u3Dhw8VFRWlpaVFRUXPnz9//PhxXl5eVlZWRkZGWlrajRs3rly5cunSpdjY2KioqJMnTx49evTQoUP79u3buXNnaGjohg0bgoKC1qxZs3LlSnIdncWLF4tIE1cq8Ea4JiYmvE8xBEgRAH2EM0HJBMhVdeX3erXsKnvjxg08hYyIiFAyNRheIQRAHxWCGQapngDeCGzOnDmyq5hcLdjY2FASaWNjU31AcIQ/BEAf+ZNLVYwkLi4OT8rS09Plqm6yGz9+/Dj29uHDh6oIHHxmRAD0kREuaMwygdmzZ1OK06tXL9n1S94Wvn///tNPP1EOwz7XLJ8KnDQH+sjJtKiNU61ataLkJigoSBZ1E1oDnLJZv3797t27Ozk5bdy4saqqShb7uO/06dMp44MHD1abLKlvoKCP6pt7pUeelZVFaQ1C6N69e1iDpChIeBiTeslHT08vLi5OCstCXU6cOEH5rKmpycom2krPAjgggQDoowQ4cEi+BMLCwiitadSokZAMMf1YnT7Wrl2bmlrWrl1bU1NTdoksLi7Gmn7t2jX5AgLryiYA+qjsDKjx+B4eHpTWDB8+nKkgCrXH+tiyZcsb//7t379/6tSpeIEJDQ0NXV3dBw8eCPVl+rFt27aU21u3blXj7KlF6KCPapFmbgZpbW1NCc2yZcuYipRQe6yPHTt2FDpUUlIyaNAgaiBNTc0hQ4YINWD6ES8JPGfOHG6CBa/YIgD6yBZJsMOYAH7yMTw8nKlICbWXoI8/fvz4+PGjkZERbnP//n2h7ow+ent7U2pra2vLOGbooFIEQB9VKl38clZHR4cSmkuXLjFSKNHGWPtE549UY/ItnY0bN4paoF+zfft2ym0zMzN+JQSiESYA+ihMBD4rhsC7d+8olUEIyb7aY436ePXqVWo4DQ2NqVOn0ldD0ZaRkZGUqRYtWiiGFYyiLAKgj8oir+7jkjeCZb9nUqM+Pnv2jBI1TU1NW1tbUdWjX3P+/HnKlL6+vrpnke/xgz7yPcNcja+oqIhSGYTQw4cP6cuT2JY16uPDhw+xPo4ZM0asEZqVsbGxlKmGDRtylS74xQ4B0Ed2OIIVpgRKS0uxPmZnZ9PUpuqa1aiPWNQQQjIuhHHmzBnKcwMDA6ZRQ3vVIgD6qFr54o+3X758wfp448aN6oSPZn2N+uju7o6HO3ToEE2zYpvhx9rbt2/Pn3xAJOIIgD6KowJ1CiHQuHFjSrNOnz4tVonoV0rWx4KCAnyvXFNTs7i4mL5l0ZYBAQGU2/369VMIJxhEaQRAH5WGHgbu2bMnJTQhISGiMsSoRoI+RkdHGxoa4gazZ89mZFm08cyZMym3YTtD3p/DoI+8TzF3A3R0dKSEZtq0aaIyxKgGy5++vr7/v39Tp05t3bo1QkhLSwshpKmp2bZtW9m31cb70K5evZq7cMEzNgiAPrJBEWxIRSAwMJDSxy5dujBSQ9HGWB8pg/i/5A7dnTt3fvbsmWhfRjXfv3+vXbs2Zf/UqVNSxQ2dVIYA6KPKpIp/jl66dAkLWWlpKSOdEmosVh9r1aqlq6tLDeHh4fH582ehXlJ8vHnzJva5oKCAf0mBiEgCoI8kDSgrlEBVVRXWmsjISCnUCnexsbEZJO7P2tp62bJlMi4uiUf58ePHmjVrKJ/h5rVCzxUlDQb6qCTwMOx/CAwZMoSSG0dHR1KGOFvG95Q8PDwgh7wnAPrI+xRzOsBt27ZR+qipqfn+/XvOyiLl2G+//YYnvHFxcZwmC86xQQD0kQ2KYENaAq9evcKKs2vXLo7r4+LFiylvYWUKaROuYv1AH1UsYfxzd8KECZTodO3alcv6+P79e3y3Z8WKFfxLBEQkSgD0UZQJ1CiUQEJCAp5CyniXRq7y6u/vj/3Mz89XKCMYTEkEQB+VBB6GJQj88ssvlPTI/iCknCSytLQUTx5nzJhB+A5FPhMAfeRzdlUlNryiIkJI9ncN5SGRc+bMwZPHrKwsVQELfspIAPRRRoDQnR0CdnZ2WIByc3PloXFS24yLi8O+LV68mJ2AwYoqEAB9VIUsqYGP5KMz1tbWUmsZ6x0rKyvbtGlD6WPz5s0rKirUIBsQ4v8nAPoIpwJXCAQHB+NpmqenJ+tKJ53B8ePHY68iIyO5Agv8UAgB0EeFYIZB6BEYOXIkFqOdO3dKp2gs9sJbuSKE5s6dSy8IaMUfAqCP/MklDyJ59epVq1atsERGRESwKHZMTZHzWSsrKx7ghRCYEgB9ZEoM2suXwLVr18hFyWTcC4GpJuL2eO01hFCrVq2ePHki37DBOicJgD5yMi3q7RTeAIuaSG7YsAHLlmIK+D1ChFDDhg3T0tLUOyHqGz3oo/rmnsuRHz9+HH/LRgi5urr+9ddfChDH169fjxo1Cg+tr69//fp1LoMC3+RKAPRRrnjBuPQEzp8/X7duXSxVXbt2TU5OlqtEnjhxokmTJnhEExOT9PR06QOAnqpPAPRR9XPI3wjS09O7du2KBQsh5OHh8ebNG9ZVMi8vb+LEieRANjY2L1++5C9aiIwWAdBHWpigkbIIVFVVTZs2jVQubW1tX19fGfdjwAqbn5/v4eFB2kcIeXl5KSteGJdTBEAfOZUOcEY8gUOHDhkaGgqpmIuLS0pKClY6poWYmBjy2W/KeJcuXS5cuCDeCahVPwKgj+qXc9WM+O3bt4sWLRKSSIRQy5Yt58yZc/LkyRcvXtQokfn5+YcOHXJ2dm7YsKGQqTp16gQEBKgmG/BaXgRAH+VFFuzKg0BeXh65lI6Qxunr6/fr18/R0XHBggUrV65cvXr1ihUrPDw8xo8f//PPP9erV0+oPfWxfv36K1asKC4ulofDYFOlCYA+qnT61NT5oqKi4OBgMzMzsXpHv9LS0nLnzp3v379XU44Qdk0EQB9rIgTHOUwgPT3d399/0KBB2traNGWxfv36I0aM2Lx5c25uLocjA9c4QQD0kRNpACdkJ5Cenh4REeHn5+fm5ubg4GBra2tjYzNs2LAJEya4u7sHBgaeOHEClraVnbNaWQB9VKt0Q7BAAAgwIAD6yAAWNAUCQECtCPw/fRkJomGNqdwAAAAASUVORK5CYII=)"
      ],
      "metadata": {
        "id": "ZRkz7vG3yw0m"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Exploit the key-value structure of a dictionary to form any graph\n",
        "\n",
        "graph = {'A': ['B', 'C'],\n",
        "         'B': ['C', 'D', 'E'],\n",
        "         'C': [],\n",
        "         'D': ['E'],\n",
        "         'E': [] }\n",
        "\n",
        "print(graph)\n",
        "\n",
        "print(graph['B'])\n",
        "print(graph['E'])"
      ],
      "metadata": {
        "id": "VZ3I8e0UntLK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1e6f07ca-f3a1-44b6-b83c-8a454e354154"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'A': ['B', 'C'], 'B': ['C', 'D', 'E'], 'C': [], 'D': ['E'], 'E': []}\n",
            "['C', 'D', 'E']\n",
            "[]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Each node corresponds to an informative content stored in this other dictionary\n",
        "\n",
        "content_graph = {'A': \"K23Fcv$RO&7r\",\n",
        "                 'B': 1.07,\n",
        "                 'C': None,\n",
        "                 'D': [\"Name\",\"Surname\", 12345,\"City\",\"Age\"],\n",
        "                 'E': None}\n",
        "\n",
        "print(content_graph)\n",
        "print(content_graph['D'])\n",
        "print(content_graph['D'][3])\n",
        "print(content_graph['E'])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dLmv__OD6AIC",
        "outputId": "d1f3456b-a6ae-48e0-f0b1-234ec209ae15"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'A': 'K23Fcv$RO&7r', 'B': 1.07, 'C': None, 'D': ['Name', 'Surname', 12345, 'City', 'Age'], 'E': None}\n",
            "['Name', 'Surname', 12345, 'City', 'Age']\n",
            "City\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Function that will output a list containing all the oriented edges\n",
        "\n",
        "def edges(graph):\n",
        "    edges = []\n",
        "    for node in graph: # the for loop iterates over all the keys in the graph-dictionary : A,B,C,D,E\n",
        "        for i in graph[node]:  # here we work on the values of the graph-dictionary : ['B', 'C'], ['C', 'D', 'E'], ...\n",
        "            if (i, node) not in edges:\n",
        "                 edges.append((node, i))\n",
        "    return edges\n",
        "\n",
        "print(edges(graph))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "upUdsjlrvhZD",
        "outputId": "1891bce6-3509-4a36-fe05-ca3ee827e03e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[('A', 'B'), ('A', 'C'), ('B', 'C'), ('B', 'D'), ('B', 'E'), ('D', 'E')]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        " Find all the paths between two nodes of a graph."
      ],
      "metadata": {
        "id": "tzyHYGCPxcwk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Paths-finding algorithm\n",
        "# Find all the possible paths that can be traced on a graph starting from one node to reach another,\n",
        "# exploiting the connections present between them.\n",
        "# Basically : a sequence of nodes P = ( n1_start, n2, n3, …, nn_end ) adjacent connected to each other\n",
        "# which defines a possible path from a starting node n1_start to a destination node nn_end.\n",
        "\n",
        "def find_path(graph, start, end, path=[]):\n",
        "\n",
        "      path = path + [start]\n",
        "\n",
        "      if start == end:\n",
        "          return [path]\n",
        "\n",
        "      if start not in graph.keys():\n",
        "         return None\n",
        "\n",
        "      if end not in graph.keys():\n",
        "         return None\n",
        "\n",
        "      paths = []\n",
        "      for node in graph[start]:\n",
        "          if node not in path:\n",
        "              subpaths = find_path(graph, node, end, path)\n",
        "\n",
        "              for subpath in subpaths:\n",
        "                    paths.append(subpath)\n",
        "\n",
        "      return paths\n",
        "\n",
        "f = find_path(graph, 'A', 'A')\n",
        "print(\"Possible path from 'A' to 'A' : \" , f)\n",
        "\n",
        "f = find_path(graph, 'Z', 'D')\n",
        "print(\"Possible path from 'Z' to 'D' : \" , f)\n",
        "\n",
        "f = find_path(graph, 'A', 'Z')\n",
        "print(\"Possible path from 'A' to 'Z' : \" , f)\n",
        "\n",
        "f = find_path(graph, 'A', 'E')\n",
        "print(\"Possible path from 'A' to 'E' : \" , f)\n",
        "\n",
        "f = find_path(graph, 'E', 'A')\n",
        "print(\"Possible path from 'E' to 'A' : \" , f)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CyJIbuLZzXZ5",
        "outputId": "3b14039f-4130-4433-cc2a-c6e0204e7bda"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Possible path from 'A' to 'A' :  [['A']]\n",
            "Possible path from 'Z' to 'D' :  None\n",
            "Possible path from 'A' to 'Z' :  None\n",
            "Possible path from 'A' to 'E' :  [['A', 'B', 'D', 'E'], ['A', 'B', 'E']]\n",
            "Possible path from 'E' to 'A' :  []\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Explanation of the Paths-finding recursive code"
      ],
      "metadata": {
        "id": "Sc7yPs3pZJsy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Explanation of the recursive code\n",
        "\n",
        "def find_path_expl(graph, start, end, path=[]):\n",
        "      print(\"Input value :  find_path_expl(start, end, path)\", (start, end, path) )\n",
        "\n",
        "      path = path + [start]\n",
        "      print(\"° Value of path updated: path = path + [start] = \",path )\n",
        "\n",
        "      if start == end:\n",
        "          print(\"\\t*\\t*\\t start == end\")\n",
        "          return [path]\n",
        "\n",
        "      if start not in graph.keys():\n",
        "         print(\"\\t*\\t*\\t start not in graph.keys()\")\n",
        "         return None\n",
        "\n",
        "      if end not in graph.keys():\n",
        "         print(\"\\t*\\t*\\t end not in graph.keys():\")\n",
        "         return None\n",
        "\n",
        "      paths = []\n",
        "      print(\">> Enter in Outer loop with graph[start] =\",graph[start] )\n",
        "      for node in graph[start]:  # Note: if graph[start]==[], it does not enter the for loop\n",
        "          print(\"Working with node:\", node)\n",
        "          if node not in path:\n",
        "              print(\"Node not in path is \", (node not in path))\n",
        "\n",
        "              print(\"Recursive call :  find_path_expl(node, end, path)\", (node, end, path) )\n",
        "              subpaths = find_path_expl(graph, node, end, path)\n",
        "              print(\"- continue afther resolution of recursive call -\\nsubpaths :\",subpaths )\n",
        "\n",
        "              for subpath in subpaths: # Note: if subpaths==[], it does not enter the for loop\n",
        "                    print(\"\\t inside loop subpath : \", subpath)\n",
        "                    paths.append(subpath)\n",
        "\n",
        "      print(\"ending return :\",paths )\n",
        "      print(\"\")\n",
        "      return paths\n",
        "\n",
        "\n",
        "print(graph)\n",
        "print(\"\")\n",
        "f = find_path_expl(graph, 'A', 'E')\n",
        "print(\"\\nPossible path : \" , f)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AHNXNvF5PwMI",
        "outputId": "a2d10563-a68f-493a-a3e1-fcf4e2620dfb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'A': ['B', 'C'], 'B': ['C', 'D', 'E'], 'C': [], 'D': ['E'], 'E': []}\n",
            "\n",
            "Input value :  find_path_expl(start, end, path) ('A', 'E', [])\n",
            "° Value of path updated: path = path + [start] =  ['A']\n",
            ">> Enter in Outer loop with graph[start] = ['B', 'C']\n",
            "Working with node: B\n",
            "Node not in path is  True\n",
            "Recursive call :  find_path_expl(node, end, path) ('B', 'E', ['A'])\n",
            "Input value :  find_path_expl(start, end, path) ('B', 'E', ['A'])\n",
            "° Value of path updated: path = path + [start] =  ['A', 'B']\n",
            ">> Enter in Outer loop with graph[start] = ['C', 'D', 'E']\n",
            "Working with node: C\n",
            "Node not in path is  True\n",
            "Recursive call :  find_path_expl(node, end, path) ('C', 'E', ['A', 'B'])\n",
            "Input value :  find_path_expl(start, end, path) ('C', 'E', ['A', 'B'])\n",
            "° Value of path updated: path = path + [start] =  ['A', 'B', 'C']\n",
            ">> Enter in Outer loop with graph[start] = []\n",
            "ending return : []\n",
            "\n",
            "- continue afther resolution of recursive call -\n",
            "subpaths : []\n",
            "Working with node: D\n",
            "Node not in path is  True\n",
            "Recursive call :  find_path_expl(node, end, path) ('D', 'E', ['A', 'B'])\n",
            "Input value :  find_path_expl(start, end, path) ('D', 'E', ['A', 'B'])\n",
            "° Value of path updated: path = path + [start] =  ['A', 'B', 'D']\n",
            ">> Enter in Outer loop with graph[start] = ['E']\n",
            "Working with node: E\n",
            "Node not in path is  True\n",
            "Recursive call :  find_path_expl(node, end, path) ('E', 'E', ['A', 'B', 'D'])\n",
            "Input value :  find_path_expl(start, end, path) ('E', 'E', ['A', 'B', 'D'])\n",
            "° Value of path updated: path = path + [start] =  ['A', 'B', 'D', 'E']\n",
            "\t*\t*\t start == end\n",
            "- continue afther resolution of recursive call -\n",
            "subpaths : [['A', 'B', 'D', 'E']]\n",
            "\t inside loop subpath :  ['A', 'B', 'D', 'E']\n",
            "ending return : [['A', 'B', 'D', 'E']]\n",
            "\n",
            "- continue afther resolution of recursive call -\n",
            "subpaths : [['A', 'B', 'D', 'E']]\n",
            "\t inside loop subpath :  ['A', 'B', 'D', 'E']\n",
            "Working with node: E\n",
            "Node not in path is  True\n",
            "Recursive call :  find_path_expl(node, end, path) ('E', 'E', ['A', 'B'])\n",
            "Input value :  find_path_expl(start, end, path) ('E', 'E', ['A', 'B'])\n",
            "° Value of path updated: path = path + [start] =  ['A', 'B', 'E']\n",
            "\t*\t*\t start == end\n",
            "- continue afther resolution of recursive call -\n",
            "subpaths : [['A', 'B', 'E']]\n",
            "\t inside loop subpath :  ['A', 'B', 'E']\n",
            "ending return : [['A', 'B', 'D', 'E'], ['A', 'B', 'E']]\n",
            "\n",
            "- continue afther resolution of recursive call -\n",
            "subpaths : [['A', 'B', 'D', 'E'], ['A', 'B', 'E']]\n",
            "\t inside loop subpath :  ['A', 'B', 'D', 'E']\n",
            "\t inside loop subpath :  ['A', 'B', 'E']\n",
            "Working with node: C\n",
            "Node not in path is  True\n",
            "Recursive call :  find_path_expl(node, end, path) ('C', 'E', ['A'])\n",
            "Input value :  find_path_expl(start, end, path) ('C', 'E', ['A'])\n",
            "° Value of path updated: path = path + [start] =  ['A', 'C']\n",
            ">> Enter in Outer loop with graph[start] = []\n",
            "ending return : []\n",
            "\n",
            "- continue afther resolution of recursive call -\n",
            "subpaths : []\n",
            "ending return : [['A', 'B', 'D', 'E'], ['A', 'B', 'E']]\n",
            "\n",
            "\n",
            "Possible path :  [['A', 'B', 'D', 'E'], ['A', 'B', 'E']]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### For more complex graph implementation and resolution\n",
        "> See : Implementing Dijkstra's Shortest Path Algorithm.\n",
        "\n",
        "https://benalexkeen.com/implementing-djikstras-shortest-path-algorithm-with-python/\n",
        "\n"
      ],
      "metadata": {
        "id": "b4Dfi2maX4LQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2. Data structure implementation: LIFO (Last In First Out) - Stack\n",
        "An easy implementation"
      ],
      "metadata": {
        "id": "kfEAT5G-YjqC"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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)\n"
      ],
      "metadata": {
        "id": "98b2mnbJb4jn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "stack = []\n",
        "\n",
        "# append() function to push element in the stack\n",
        "stack.append(14)\n",
        "stack.append(7)\n",
        "stack.append(10)\n",
        "stack.append(3)\n",
        "\n",
        "print('Initial stack : ',stack)\n",
        "\n",
        "print('Stack Size:', len(stack))\n",
        "\n",
        "print('Element on the Top of the stack: ',(stack[len(stack)- 1]) )\n",
        "\n",
        "# pop() function to pop element from stack in  LIFO order\n",
        "print('\\nElement popped from stack: ', stack.pop())\n",
        "\n",
        "print('\\nCurrent stack : ',stack)\n",
        "\n",
        "print('Element on the Top of the stack: ',(stack[len(stack)- 1]) )\n",
        "\n",
        "print('\\nElement popped from stack: ', stack.pop())\n",
        "\n",
        "print('\\nCurrent stack : ',stack)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TPtSrSwwcDdg",
        "outputId": "cfe52a9b-52ec-409a-9638-302fe6c4ba93"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Initial stack :  [14, 7, 10, 3]\n",
            "Stack Size: 4\n",
            "Element on the Top of the stack:  3\n",
            "\n",
            "Element popped from stack:  3\n",
            "\n",
            "Current stack :  [14, 7, 10]\n",
            "Element on the Top of the stack:  10\n",
            "\n",
            "Element popped from stack:  10\n",
            "\n",
            "Current stack :  [14, 7]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Implementation using collections.deque\n",
        "# Python stack can be implemented using the deque class from the collections module.\n",
        "# Deque offers O(1) time complexity for append and pop operations compared to list's O(n) time complexity\n",
        "\n",
        "from collections import deque\n",
        "\n",
        "stack = deque()\n",
        "\n",
        "# append() function to push element in the stack\n",
        "stack.append(14)\n",
        "stack.append(7)\n",
        "stack.append(10)\n",
        "stack.append(3)\n",
        "\n",
        "print('Initial stack : ',stack)\n",
        "\n",
        "print('Stack Size:', len(stack))\n",
        "\n",
        "print('Element on the Top of the stack: ',(stack[len(stack)- 1]) )\n",
        "\n",
        "# pop() function to pop element from stack in  LIFO order\n",
        "print('\\nElement popped from stack: ', stack.pop())\n",
        "\n",
        "print('\\nCurrent stack : ',stack)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DEJ33yarlVjK",
        "outputId": "228247dc-7f43-4231-94c4-151592cb47b3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Initial stack :  deque([14, 7, 10, 3])\n",
            "Stack Size: 4\n",
            "Element on the Top of the stack:  3\n",
            "\n",
            "Element popped from stack:  3\n",
            "\n",
            "Current stack :  deque([14, 7, 10])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3. Data structure implementation: FIFO (First-In First-Out) - Queue\n",
        "An easy implementation"
      ],
      "metadata": {
        "id": "QJs8UtD9e_KJ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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)\n"
      ],
      "metadata": {
        "id": "XmDVe6RrjVBi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "queue = []\n",
        "queue.append(2)\n",
        "queue.append(3)\n",
        "queue.append(4)\n",
        "queue.append(5)\n",
        "queue.append(6)\n",
        "queue.append(7)\n",
        "queue.append(8)\n",
        "\n",
        "print(\"Initial queue : \", (queue))\n",
        "\n",
        "print('Queue Size:', len(queue))\n",
        "\n",
        "print('Front element: ',(queue[0]) )\n",
        "\n",
        "print('Back element: ',(queue[len(queue)- 1]) )\n",
        "\n",
        "print(\"\\nElements dequeued from queue : \")\n",
        "print(queue.pop(0))\n",
        "\n",
        "print(\"\\nCurrent Queue: \",(queue))\n",
        "print('Front element: ',(queue[0]) )\n",
        "\n",
        "print(\"\\nElements dequeued from queue : \")\n",
        "print(queue.pop(0))\n",
        "\n",
        "print(\"\\nCurrent Queue: \",(queue))\n",
        "print('Front element: ',(queue[0]) )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S9iXFW4Pgjs2",
        "outputId": "c3172555-0208-49f1-8096-fbe93e992d0d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Initial queue :  [2, 3, 4, 5, 6, 7, 8]\n",
            "Queue Size: 7\n",
            "Front element:  2\n",
            "Back element:  8\n",
            "\n",
            "Elements dequeued from queue : \n",
            "2\n",
            "\n",
            "Current Queue:  [3, 4, 5, 6, 7, 8]\n",
            "Front element:  3\n",
            "\n",
            "Elements dequeued from queue : \n",
            "3\n",
            "\n",
            "Current Queue:  [4, 5, 6, 7, 8]\n",
            "Front element:  4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Implementation using collections.deque\n",
        "# Deque offers O(1) time complexity for append and pop operations compared to list's O(n) time complexity\n",
        "\n",
        "from collections import deque\n",
        "\n",
        "queue = deque()\n",
        "\n",
        "queue.append(2)\n",
        "queue.append(3)\n",
        "queue.append(4)\n",
        "queue.append(5)\n",
        "queue.append(6)\n",
        "queue.append(7)\n",
        "queue.append(8)\n",
        "\n",
        "print(\"Initial queue : \", (queue))\n",
        "\n",
        "print('Queue Size:', len(queue))\n",
        "\n",
        "print('Front element: ',(queue[0]) )\n",
        "\n",
        "print('Back element: ',(queue[len(queue)- 1]) )\n",
        "\n",
        "print(\"\\nElements dequeued from queue : \")\n",
        "print(queue.popleft())\n",
        "\n",
        "print(\"\\nCurrent Queue: \",(queue))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qadiM7xXmTic",
        "outputId": "74519edb-c04e-47bc-9dcc-b7eff81f3a48"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Initial queue :  deque([2, 3, 4, 5, 6, 7, 8])\n",
            "Queue Size: 7\n",
            "Front element:  2\n",
            "Back element:  8\n",
            "\n",
            "Elements dequeued from queue : \n",
            "2\n",
            "\n",
            "Current Queue:  deque([3, 4, 5, 6, 7, 8])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 4. Data structure implementation:  Binary Tree\n",
        "\n",
        "\n",
        "A binary tree is a Graph data structure (precisely : directed acyclic graph) where each node can have at most two child nodes, which are referred to as the left child and the right child.\n"
      ],
      "metadata": {
        "id": "XH36dAS8n3xo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "import graphviz"
      ],
      "metadata": {
        "id": "76hnCv3WMQUt"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating node class\n",
        "class Node:\n",
        "\n",
        "    def __init__(self, data):\n",
        "        self.data = data          # value  stored in the node\n",
        "        self.leftChild = None     #  left child node of the current node\n",
        "        self.rightChild = None    #  right child node of the current node\n",
        "\n",
        "\n",
        "    def insert(self, data):\n",
        "        rc = random.choice([1,0])  # In this case the insertion (in right or left place) of node\n",
        "        # in the binary trees will be random\n",
        "        if rc == 1:\n",
        "          if self.leftChild:\n",
        "                self.leftChild.insert(data)\n",
        "          else:\n",
        "                self.leftChild = Node(data)\n",
        "                return\n",
        "        else:\n",
        "            if self.rightChild:\n",
        "                self.rightChild.insert(data)\n",
        "            else:\n",
        "                self.rightChild = Node(data)\n",
        "                return\n",
        "\n",
        "\n",
        "def visualize_binary_tree (root):  # Allows display of the binary tree in file png\n",
        "     dot = graphviz.Digraph()\n",
        "     dot.node(str(root.data))\n",
        "     def add_nodes_edges(node):\n",
        "          if node.leftChild :\n",
        "              dot.node(str(node.leftChild.data))\n",
        "              dot.edge(str(node.data), str(node.leftChild.data))\n",
        "              add_nodes_edges(node.leftChild)\n",
        "          if node.rightChild:\n",
        "             dot.node(str(node.rightChild.data))\n",
        "             dot.edge(str(node.data), str(node.rightChild.data))\n",
        "             add_nodes_edges(node.rightChild)\n",
        "     add_nodes_edges(root)\n",
        "     dot.render('binary_tree', view=True, format='png')\n",
        "     print(\"RENDERING\", dot.render('binary_tree', view=True, format='png'))\n",
        "\n",
        "\n",
        "# Creating BinaryTree\n",
        "root = Node(\"INIZIO\")\n",
        "root.insert(14)\n",
        "root.insert([\"Ugo\",\"Stam\",45])\n",
        "root.insert(31)\n",
        "root.insert(10)\n",
        "root.insert(19.678)\n",
        "root.insert(\"$\")\n",
        "\n",
        "visualize_binary_tree(root)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jMrjs9fbZ7KD",
        "outputId": "62f29c76-60d6-40cb-9c09-70b99e6f2e11"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "RENDERING binary_tree.png\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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)\n"
      ],
      "metadata": {
        "id": "Vgs2_4QCUwIq"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Useful references\n",
        "\n",
        "https://www.edureka.co/blog/data-structures-in-python/\n"
      ],
      "metadata": {
        "id": "aakN7a6aeXoT"
      }
    }
  ]
}