draft_prims_kruskal.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx\n",
    "import random\n",
    "import time\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 1: Implementation \n",
    "1. Implement Prim’s Algorithm as a function prim_mst(graph). \n",
    "2. Implement Kruskal’s Algorithm as a function Kruskal_mst(graph).\n",
    " \n",
    "<b>Deliverable 1:</b> A well-documented source code package containing two separate files: one for \n",
    "implementing Prim’s algorithm and another for Kruskal’s algorithm. Each file should include a \n",
    "clearly  defined  function,  prim_mst(graph)  for  Prim’s  algorithm  and  Kruskal_mst(graph)  for \n",
    "Kruskal’s algorithm. These functions should take a graph as input and return its minimum spanning \n",
    "tree (MST). The code must be well-commented to explain the logic, and the graph input can be in \n",
    "the form of an adjacency list or matrix, as preferred."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Kruskal Implementation\n",
    "class Kruskal:\n",
    "    def __init__(self, size):\n",
    "        self.size = size  # Number of vertices\n",
    "        self.edges = []  # For storing edges as (weight, u, v)\n",
    "        self.vertex_data = [None] * size  # Store vertex names\n",
    "\n",
    "    def add_edge(self, u, v, weight): # u - starting vertex, v - ending vertex, weight - weight of the edge\n",
    "        if 0 <= u < self.size and 0 <= v < self.size:\n",
    "            self.edges.append((weight, u, v))  # Add edge with weight\n",
    "            \n",
    "    def add_vertex_data(self, vertex, data): \n",
    "        if 0 <= vertex < self.size:\n",
    "            self.vertex_data[vertex] = data  # Add vertex data\n",
    "\n",
    "    def find(self, parent, i):  # Find root of i\n",
    "        if parent[i] == i:\n",
    "            return i\n",
    "        return self.find(parent, parent[i])\n",
    "\n",
    "    def union(self, parent, rank, x, y):  # Union by rank\n",
    "        xroot = self.find(parent, x)  # Find root of x - start_vertex of edges\n",
    "        yroot = self.find(parent, y)  # Find root of y - end_vertex of edges\n",
    "        if rank[xroot] < rank[yroot]: \n",
    "            parent[xroot] = yroot\n",
    "        elif rank[xroot] > rank[yroot]:\n",
    "            parent[yroot] = xroot\n",
    "        else:\n",
    "            parent[yroot] = xroot\n",
    "            rank[xroot] += 1\n",
    "\n",
    "    def algorithm(self):\n",
    "        result = []  # MST\n",
    "        i = 0  # edge counter\n",
    "        mst_weight = 0 # Variable to store the total weight of the MST\n",
    "        self.edges = sorted(self.edges, key=lambda item: item[0])  # Sort edges by weight\n",
    "\n",
    "        parent, rank = [], []  # Parent and rank of each vertex\n",
    "\n",
    "        for node in range(self.size):  # Initialize parent and rank\n",
    "            parent.append(node)  # parent of node\n",
    "            rank.append(0) \n",
    "\n",
    "        while i < len(self.edges): \n",
    "            weight, u, v = self.edges[i]\n",
    "            i += 1\n",
    "            \n",
    "            x = self.find(parent, u)  # Find root of u\n",
    "            y = self.find(parent, v)  # Find root of v\n",
    "            if x!= y:\n",
    "                result.append((u, v, weight))\n",
    "                self.union(parent, rank, x, y)\n",
    "                mst_weight += weight\n",
    "\n",
    "        return result, mst_weight\n",
    "\n",
    "    def output(self, result, mst_weight):\n",
    "        # Output MST\n",
    "        print(\"Kruskal's Algorithm MST\")\n",
    "        for u, v, weight in result:\n",
    "            print(f\"{self.vertex_data[u]}-{self.vertex_data[v]} \\t{weight}\")\n",
    "\n",
    "        # Output adjacency matrix for the original graph\n",
    "        print(\"Adjacency matrix for the original graph:\")\n",
    "        adj_matrix = [[0] * self.size for _ in range(self.size)]  # Adjacency matrix of the graph\n",
    "        for weight, u, v in self.edges:\n",
    "            adj_matrix[u][v] = weight\n",
    "            adj_matrix[v][u] = weight  # For undirected graph\n",
    "        for row in adj_matrix:\n",
    "            print(row)\n",
    "\n",
    "        # Output adjacency lists for the original graph\n",
    "        print(\"Adjacency lists for the original graph:\")\n",
    "        for i in range(self.size):\n",
    "            adjacent_vertices = [v for _, v, _ in self.edges if v != i]\n",
    "            print(f\"Vertex {self.vertex_data[i]}: {', '.join([self.vertex_data[v] for v in adjacent_vertices])}\")    \n",
    "\n",
    "        print(f\"Total weight of MST: {mst_weight}\")    \n",
    "\n",
    "        # Create a NetworkX graph for the MST\n",
    "        G_mst = nx.Graph()\n",
    "        for u, v, weight in result:\n",
    "            G_mst.add_edge(self.vertex_data[u], self.vertex_data[v], weight=weight)\n",
    "\n",
    "        # Create a NetworkX graph for the original graph\n",
    "        G_original = nx.Graph()\n",
    "        for weight, u, v in self.edges:\n",
    "            G_original.add_edge(self.vertex_data[u], self.vertex_data[v], weight=weight)  # Add the edge to the graph\n",
    "\n",
    "        # Draw the original graph using matplotlib\n",
    "        pos_original = nx.spring_layout(G_original)  # positions for all nodes\n",
    "        nx.draw_networkx(G_original, pos_original, with_labels=True, node_color='lightblue', edge_color='gray')  # draw nodes and edges\n",
    "        labels_original = nx.get_edge_attributes(G_original, 'weight')  # get the edge labels\n",
    "        nx.draw_networkx_edge_labels(G_original, pos_original, edge_labels=labels_original)  # draw edge labels\n",
    "\n",
    "        plt.title(\"Original Graph\")\n",
    "        plt.figure()\n",
    "\n",
    "        # Draw the MST using matplotlib\n",
    "        pos_mst = nx.spring_layout(G_mst)\n",
    "        nx.draw_networkx(G_mst, pos_mst, with_labels=True, node_color='lightblue', edge_color='red')\n",
    "        labels_mst = nx.get_edge_attributes(G_mst, 'weight')\n",
    "        nx.draw_networkx_edge_labels(G_mst, pos_mst, edge_labels=labels_mst)\n",
    "        \n",
    "        plt.title(\"MST\")\n",
    "        plt.figure()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Prims Implementation\n",
    "class Prims:\n",
    "    def __init__(self, size):\n",
    "        self.adj_matrix = [[0] * size for _ in range(size)]  # Adjacency matrix of the graph\n",
    "        self.size = size  # Number of vertices\n",
    "        self.edges = []  # List to store the edges of the graph\n",
    "        self.vertex_data = [''] * size  # Stores the data of the vertices\n",
    "\n",
    "    def add_edge(self, u, v, weight):\n",
    "        if 0 <= u < self.size and 0 <= v < self.size:\n",
    "            self.adj_matrix[u][v] = weight  \n",
    "            self.adj_matrix[v][u] = weight  # For undirected graph\n",
    "            self.edges.append((weight, u, v)) # Add edge with weight\n",
    "\n",
    "    def add_vertex_data(self, vertex, data):\n",
    "        if 0 <= vertex < self.size:\n",
    "            self.vertex_data[vertex] = data  # Add the data to the vertex\n",
    "\n",
    "    def algorithm(self):\n",
    "        in_mst = [False] * self.size  # Keeps track of visited vertices\n",
    "        key_values = [float('inf')] * self.size  # Keeps track of the minimum weight of the edge\n",
    "        parents = [-1] * self.size # Keeps track of the parent of the vertex\n",
    "\n",
    "        key_values[0] = 0  # Starting vertex\n",
    "        mst_weight = 0  # Stores the weight of the MST\n",
    "        mst_edges = []  # List to store the edges of the MST (u - starting vertex,v - end vertex, weight)\n",
    "        for _ in range(self.size):\n",
    "            u = min((v for v in range(self.size) if not in_mst[v]), key=lambda v: key_values[v])\n",
    "\n",
    "            in_mst[u] = True  # Mark the vertex as visited\n",
    "\n",
    "            if parents[u]!= -1:  # Skip printing for the first vertex since it has no parent\n",
    "                mst_edges.append((self.vertex_data[parents[u]], self.vertex_data[u], self.adj_matrix[u][parents[u]]))\n",
    "                mst_weight += self.adj_matrix[u][parents[u]]  # Add the weight of the edge to the MST\n",
    "            for v in range(self.size):  # Update the key values and parents of the adjacent vertices of the current vertex\n",
    "                if 0 < self.adj_matrix[u][v] < key_values[v] and not in_mst[v]:\n",
    "                    key_values[v] = self.adj_matrix[u][v]\n",
    "                    parents[v] = u\n",
    "                    \n",
    "        return mst_edges, mst_weight\n",
    "\n",
    "    def output(self, mst_edges, mst_weight):\n",
    "        # Output the MST\n",
    "        print(\"Prim's Algorithm MST:\")\n",
    "        for edge in mst_edges:\n",
    "            print(f\"{edge[0]}-{edge[1]} \\t{edge[2]}\")\n",
    "\n",
    "        # Output adjacency matrix for the original graph\n",
    "        print(\"Adjacency matrix for the original graph:\")\n",
    "        for row in self.adj_matrix:\n",
    "            print(row)\n",
    "\n",
    "        # Output adjacency lists for the original graph\n",
    "        print(\"Adjacency lists for the original graph:\")\n",
    "        for i in range(self.size):\n",
    "            adjacent_vertices = [j for j in range(self.size) if self.adj_matrix[i][j] > 0]\n",
    "            print(f\"Vertex {self.vertex_data[i]}: {', '.join([self.vertex_data[v] for v in adjacent_vertices])}\")    \n",
    "\n",
    "        print(f\"Total weight of MST: {mst_weight}\")    \n",
    "\n",
    "        # Create a NetworkX graph for the original graph\n",
    "        G_original = nx.Graph()\n",
    "        for u in range(self.size):\n",
    "            for v in range(u+1, self.size):\n",
    "                if self.adj_matrix[u][v] > 0:\n",
    "                    G_original.add_edge(self.vertex_data[u], self.vertex_data[v], weight=self.adj_matrix[u][v])\n",
    "\n",
    "        # Create a NetworkX graph for the MST\n",
    "        G_mst = nx.Graph()\n",
    "        for edge in mst_edges:\n",
    "            G_mst.add_edge(edge[0], edge[1], weight=edge[2])\n",
    "\n",
    "        # Draw the original graph\n",
    "        pos = nx.spring_layout(G_original)\n",
    "        nx.draw_networkx(G_original, pos, with_labels=True, node_color='lightblue', edge_color='gray')\n",
    "        labels = nx.get_edge_attributes(G_original, 'weight')\n",
    "        nx.draw_networkx_edge_labels(G_original, pos, edge_labels=labels)\n",
    "\n",
    "        plt.title(\"Original Graph\")\n",
    "        plt.figure()\n",
    "\n",
    "        # Draw the MST graph\n",
    "        pos = nx.spring_layout(G_mst)\n",
    "        nx.draw_networkx(G_mst, pos, with_labels=True, node_color='lightblue', edge_color='red')\n",
    "        labels = nx.get_edge_attributes(G_mst, 'weight')\n",
    "        nx.draw_networkx_edge_labels(G_mst, pos, edge_labels=labels)\n",
    "        \n",
    "        plt.title(\"MST\")\n",
    "        plt.figure()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prim's Algorithm MST:\n",
      "A-C \t1\n",
      "A-F \t1\n",
      "F-D \t9\n",
      "D-B \t2\n",
      "D-E \t4\n",
      "Adjacency matrix for the original graph:\n",
      "[0, 18, 1, 17, 10, 1]\n",
      "[18, 0, 0, 2, 4, 20]\n",
      "[1, 0, 0, 12, 18, 4]\n",
      "[17, 2, 12, 0, 4, 9]\n",
      "[10, 4, 18, 4, 0, 12]\n",
      "[1, 20, 4, 9, 12, 0]\n",
      "Adjacency lists for the original graph:\n",
      "Vertex A: B, C, D, E, F\n",
      "Vertex B: A, D, E, F\n",
      "Vertex C: A, D, E, F\n",
      "Vertex D: A, B, C, E, F\n",
      "Vertex E: A, B, C, D, F\n",
      "Vertex F: A, B, C, D, E\n",
      "Total weight of MST: 17\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Run test\n",
    "def main():\n",
    "    choose = input(\"Prims or Kruskal?: \")\n",
    "    if choose == \"Prims\":\n",
    "        num_vertices = int(input(\"Enter the number of vertices: \"))\n",
    "        g = Prims(num_vertices)\n",
    "    elif choose == \"Kruskal\":\n",
    "        num_vertices = int(input(\"Enter the number of vertices: \"))\n",
    "        g = Kruskal(num_vertices)\n",
    "    else:\n",
    "        main()\n",
    "\n",
    "    # Generate the graph\n",
    "    for i in range(num_vertices):\n",
    "        vertex_name = chr(i + 97).upper()\n",
    "        g.add_vertex_data(i, vertex_name)\n",
    "\n",
    "    for i in range(num_vertices):\n",
    "        for j in range(i + 1, num_vertices):\n",
    "            weight = int(random.randint(0,20))\n",
    "            if weight != 0:\n",
    "                g.add_edge(i, j, weight)    \n",
    "    \n",
    "    # for i in range(num_vertices):\n",
    "    #     name = input(f\"Enter the name for vertex {i}: \")\n",
    "    #     g.add_vertex_data(i, name)\n",
    "\n",
    "    # for i in range(num_vertices):\n",
    "    #     for j in range(i + 1, num_vertices):\n",
    "    #         length = int(input(f\"Enter the length of the edge between vertices {i} and {j}: \"))\n",
    "    #         if length != 0:\n",
    "    #             g.add_edge(i, j, length)\n",
    "    #         else:\n",
    "    #             continue\n",
    "\n",
    "    mst, total_weight = g.algorithm()\n",
    "    return g.output(mst, total_weight)\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 2: Testing and Validation \n",
    "1. Create at least three different graphs to test your algorithms. These should include:\n",
    "- A sparse graph with 10-15 nodes.\n",
    "- A dense graph with 10-15 nodes.\n",
    "- A graph with varying edge weights, including negative weights, if your implementation allows. \n",
    "2. Record and analyze the output of each algorithm on these graphs. \n",
    "\n",
    "- Run both algorithms on each of the graphs. \n",
    "- Record the output MSTs and their total weights.\n",
    " \n",
    "<b>Deliverable 2:</b> Provide a comprehensive testing document that includes detailed descriptions and \n",
    "results of at least three different graph test cases used to validate both algorithms. These graphs \n",
    "should represent a variety of types, including a sparse graph, a dense graph, and a graph with varied \n",
    "edge weights. For each test case, the document should clearly present the input graph, the MSTs \n",
    "obtained from both Prim’s and Kruskal’s algorithms, and a summary of the total weight of each \n",
    "MST. This will demonstrate the correctness and functionality of your implementations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://www.baeldung.com/cs/graphs-sparse-vs-dense\n",
    "\n",
    "<img src=\"https://www.baeldung.com/wp-content/ql-cache/quicklatex.com-d9bce929eb79a6119ecd30d53af622ee_l3.svg\" style=\"width:500px;height:228px;background-color:white\">\n",
    "\n",
    "With $|V|$: The number of vertices, \n",
    "     $|E|$: The number of edges,  \n",
    "     $Max_U(V)$: The maximum number of edges in the graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_density(V, E):\n",
    "    # Density of a graph\n",
    "    density = 2*E/(V*(V-1)) #Unit: No. E/ No. nodes\n",
    "    return density"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prim's Algorithm MST:\n",
      "A-G \t11\n",
      "G-C \t5\n",
      "G-J \t6\n",
      "J-B \t2\n",
      "J-H \t11\n",
      "G-I \t11\n",
      "I-D \t5\n",
      "D-F \t10\n",
      "Adjacency matrix for the original graph:\n",
      "[0, 0, 0, 0, 0, 0, 11, 0, 0, 0]\n",
      "[0, 0, 19, 0, 0, 0, 0, 0, 0, 2]\n",
      "[0, 19, 0, 0, 0, 0, 5, 0, 0, 0]\n",
      "[0, 0, 0, 0, 0, 10, 0, 0, 5, 0]\n",
      "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
      "[0, 0, 0, 10, 0, 0, 0, 0, 0, 0]\n",
      "[11, 0, 5, 0, 0, 0, 0, 0, 11, 6]\n",
      "[0, 0, 0, 0, 0, 0, 0, 0, 0, 11]\n",
      "[0, 0, 0, 5, 0, 0, 11, 0, 0, 0]\n",
      "[0, 2, 0, 0, 0, 0, 6, 11, 0, 0]\n",
      "Adjacency lists for the original graph:\n",
      "Vertex A: G\n",
      "Vertex B: C, J\n",
      "Vertex C: B, G\n",
      "Vertex D: F, I\n",
      "Vertex E: \n",
      "Vertex F: D\n",
      "Vertex G: A, C, I, J\n",
      "Vertex H: J\n",
      "Vertex I: D, G\n",
      "Vertex J: B, G, H\n",
      "Total weight of MST: 61\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def generate_dense_sparse():\n",
    "    choose = input(\"Prims or Kruskal?: \")\n",
    "    if choose == \"Prims\":\n",
    "        num_vertices = int(input(\"Enter the number of vertices: \")) #int(random.randint(10,15))\n",
    "        g = Prims(num_vertices)\n",
    "    elif choose == \"Kruskal\":\n",
    "        num_vertices = int(input(\"Enter the number of vertices: \")) #int(random.randint(10,15))\n",
    "        g = Kruskal(num_vertices)\n",
    "    else:\n",
    "        generate_dense_sparse()\n",
    "\n",
    "    # Generate the graph\n",
    "    density = float(input(\"Enter the density (between 0 and 1): \"))\n",
    "    num_edges = int(density * (num_vertices * (num_vertices - 1)) / 2)  # Calculate the number of edges based on density\n",
    "\n",
    "    for i in range(num_vertices):  # Add vertices\n",
    "        vertex_name = chr(i + 97).upper()\n",
    "        g.add_vertex_data(i, vertex_name)\n",
    "\n",
    "    if density < 0.5:  # Sparse graph\n",
    "        edge_count = 0\n",
    "        while edge_count < num_edges: \n",
    "            u = random.randint(0, num_vertices - 1)\n",
    "            v = random.randint(0, num_vertices - 1)\n",
    "            if u != v and g.edges.count((0, u, v)) == 0:  # Check if the edge is already present\n",
    "                weight = random.randint(1, 20)\n",
    "                g.add_edge(u, v, weight)\n",
    "                edge_count += 1\n",
    "    else:  # Dense graph\n",
    "        all_edges = [(u, v) for u in range(num_vertices) for v in range(u + 1, num_vertices)]  # Generate all possible edges\n",
    "        random.shuffle(all_edges)\n",
    "        selected_edges = all_edges[:num_edges]  # Select the required number of edges\n",
    "        for u, v in selected_edges:  # Add the edges\n",
    "            weight = random.randint(1, 20)\n",
    "            g.add_edge(u, v, weight)\n",
    "\n",
    "    mst, total_weight = g.algorithm()\n",
    "    return g.output(mst, total_weight)\n",
    "\n",
    "generate_dense_sparse()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 3: Analysis \n",
    "- Analyze the performance of both algorithms on each graph. \n",
    "- Discuss the time complexity in the best, average, and worst-case scenarios for each algorithm.\n",
    " \n",
    "<b>Deliverable 3:</b> The third part requires a detailed analytical report. This report should include a \n",
    "thorough performance analysis comparing Prim’s and Kruskal’s algorithms, focusing on time \n",
    "complexity in various scenarios (e.g., best, average, and worst-case). Additionally, the report \n",
    "should feature a real-world application case study, demonstrating the practical use of MSTs and \n",
    "arguing which of the two algorithms would be more suitable for the specific scenario. The report \n",
    "should conclude with a comparative discussion of the two algorithms, drawing insights from both \n",
    "the theoretical aspects and the testing results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Prim's algorithm\n",
    "iterations = 100 # Number of iterations for running algorithm\n",
    "sparse_p, dense_p = [], []\n",
    "# Measure runtime for Prim's Algorithm\n",
    "density = 0\n",
    "for _ in range(iterations):\n",
    "    # Example (Can be generated)\n",
    "    g = Prims(10)\n",
    "    num_vertices = 10\n",
    "    density += 1/100\n",
    "    num_edges = int(density * (num_vertices * (num_vertices - 1)) / 2)  # Calculate the number of edges based on density\n",
    "\n",
    "    for i in range(num_vertices):  # Add vertices\n",
    "        vertex_name = chr(i + 97).upper()\n",
    "        g.add_vertex_data(i, vertex_name)\n",
    "\n",
    "    if density < 0.5:  # Sparse graph\n",
    "        edge_count = 0\n",
    "        while edge_count < num_edges: \n",
    "            u = random.randint(0, num_vertices - 1)\n",
    "            v = random.randint(0, num_vertices - 1)\n",
    "            if u != v and g.edges.count((0, u, v)) == 0:  # Check if the edge is already present\n",
    "                weight = random.randint(1, 20)\n",
    "                g.add_edge(u, v, weight)\n",
    "                edge_count += 1\n",
    "        start_time = time.time()\n",
    "        mst, total_weight = g.algorithm()\n",
    "        eureka = g.output(mst, total_weight)        \n",
    "        end_time = time.time()\n",
    "        runtime = (end_time - start_time)*1000000000\n",
    "        sparse_p.append({\"Runtime_p\": runtime, \"Density\": density})\n",
    "        clear_output(wait=True)\n",
    "\n",
    "    else:  # Dense graph\n",
    "        all_edges = [(u, v) for u in range(num_vertices) for v in range(u + 1, num_vertices)]  # Generate all possible edges\n",
    "        random.shuffle(all_edges)\n",
    "        selected_edges = all_edges[:num_edges]  # Select the required number of edges\n",
    "        for u, v in selected_edges:  # Add the edges\n",
    "            weight = random.randint(1, 20)\n",
    "            g.add_edge(u, v, weight)\n",
    "        start_time = time.time()\n",
    "        mst, total_weight = g.algorithm()\n",
    "        eureka = g.output(mst, total_weight)     \n",
    "        end_time = time.time()\n",
    "        runtime = (end_time - start_time)*1000000000\n",
    "        dense_p.append({\"Runtime_p\": runtime, \"Density\": density})\n",
    "        clear_output(wait=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Kruskal's algorithm\n",
    "iterations = 100 # Number of iterations for running algorithm\n",
    "sparse_k, dense_k = [], []\n",
    "# Measure runtime for Prim's Algorithm\n",
    "density = 0\n",
    "for _ in range(iterations):\n",
    "    # Example (Can be generated)\n",
    "    g = Kruskal(10)\n",
    "    num_vertices = 10\n",
    "    density += 1/100\n",
    "    num_edges = int(density * (num_vertices * (num_vertices - 1)) / 2)  # Calculate the number of edges based on density\n",
    "\n",
    "    for i in range(num_vertices):  # Add vertices\n",
    "        vertex_name = chr(i + 97).upper()\n",
    "        g.add_vertex_data(i, vertex_name)\n",
    "\n",
    "    if density < 0.5:  # Sparse graph\n",
    "        edge_count = 0\n",
    "        while edge_count < num_edges: \n",
    "            u = random.randint(0, num_vertices - 1)\n",
    "            v = random.randint(0, num_vertices - 1)\n",
    "            if u != v and g.edges.count((0, u, v)) == 0:  # Check if the edge is already present\n",
    "                weight = random.randint(1, 20)\n",
    "                g.add_edge(u, v, weight)\n",
    "                edge_count += 1\n",
    "        start_time = time.time()\n",
    "        mst, total_weight = g.algorithm()\n",
    "        eureka = g.output(mst, total_weight)       \n",
    "        end_time = time.time()\n",
    "        runtime = (end_time - start_time)*1000000000\n",
    "        sparse_k.append({\"Runtime_k\": runtime, \"Density\": density})\n",
    "        clear_output(wait=True)\n",
    "        \n",
    "    else:  # Dense graph\n",
    "        all_edges = [(u, v) for u in range(num_vertices) for v in range(u + 1, num_vertices)]  # Generate all possible edges\n",
    "        random.shuffle(all_edges)\n",
    "        selected_edges = all_edges[:num_edges]  # Select the required number of edges\n",
    "        for u, v in selected_edges:  # Add the edges\n",
    "            weight = random.randint(1, 20)\n",
    "            g.add_edge(u, v, weight)\n",
    "        start_time = time.time()\n",
    "        mst, total_weight = g.algorithm()\n",
    "        eureka = g.output(mst, total_weight)       \n",
    "        end_time = time.time()\n",
    "        runtime = (end_time - start_time)*1000000000\n",
    "        dense_k.append({\"Runtime_k\": runtime, \"Density\": density})\n",
    "        clear_output(wait=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x26ebb80af50>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA04AAAIjCAYAAAA0vUuxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABvfUlEQVR4nO3de3zO9f/H8ee1sQ2zOY1tLHM+5RTRaKFoCLFE6euwFKVySgclh/oWiZqOOnyjRERLJYdYVspKkY4SwtAYYjOHza59fn/styuXHa5dh+26tj3ut9t14/pcn8Pr87neuz6f1+d9+JgMwzAEAAAAACiQl7sDAAAAAABPR+IEAAAAADaQOAEAAACADSROAAAAAGADiRMAAAAA2EDiBAAAAAA2kDgBAAAAgA0kTgAAAABgA4kTAAAAANhA4gSgXDCZTJo5c6a7wyjQ4sWLZTKZdODAAXeHgiKYOXOmTCaTu8NAORAeHq5+/fq5OwwAInEC4ITci/3cV4UKFVS3bl2NGjVKR44ccXd4bte9e3er41PQy5MTupIWHh5uOS5eXl6qVq2aWrdurTFjxui7775zd3iFeuaZZ7R69Wp3h+GwX375RYMHD1b9+vXl5+enunXrqlevXnrppZfcHVqxS0tL09NPP62OHTsqMDBQvr6+ql+/voYOHarPPvvM3eEB8BAmwzAMdwcBoHRavHixYmJi9OSTT6pBgwa6cOGCvv32Wy1evFjh4eH69ddf5efn5+4wJUkXLlxQhQoVVKFChRLb5saNG3Xs2DHL+++//14vvviiHnvsMbVo0cIyvU2bNmrVqpUuXrwoX1/fcl2TER4erurVq+vBBx+UJJ05c0a7du3SypUrdfToUU2aNEnPP/+8m6OUsrKylJWVZVW+/f39NXjwYC1evNh9gTlo69at6tGjh6644gqNHDlSwcHBOnTokL799lvt27dPe/fudXeIxWbv3r2KiorSwYMHNWjQIEVGRsrf31+HDh3S2rVrtW3bNr377rsaPny4W+ILDw/XlVdeqTVr1rhl+wD+VXJXEADKrD59+qhjx46SpLvuuku1atXSs88+q08++URDhgxxc3Q53JHA9erVK08ML774onr16qXu3bvnmd/b27uEIvNsdevW1X/+8x+rac8++6yGDRumF154QU2aNNG9997rpuhylHQSXtyefvppBQYG6vvvv1e1atWsPktJSSnxeM6ePasqVaoU+3aysrI0aNAgHTt2TF9++aW6du1q9fmMGTP0+eefy2w2F7qekooXgHvRVA+Ay0VGRkqS9u3bZ5nWvXv3fJOFUaNGKTw83PL+wIEDMplMmjdvnt544w01atRIvr6+uvrqq/X999/nWdbf319HjhzRwIED5e/vr6CgIE2ZMiXPhc7lTeJy+6js3btXo0aNUrVq1RQYGKiYmBidO3fOatnz589r/PjxqlWrlqpWraoBAwboyJEjLm1ml18fp9y+DQkJCerYsaMqVaqk1q1bKyEhQZIUFxen1q1by8/PTx06dNCPP/6YZ71//PGHBg8erBo1asjPz08dO3bUJ598UmgsFy9eVI0aNRQTE5Pns7S0NPn5+WnKlCmWaS+99JJatWqlypUrq3r16urYsaOWLVvm2IEoQKVKlbRkyRLVqFFDTz/9tC5tLJGdna3Y2Fi1atVKfn5+qlOnjsaOHatTp05ZrSP3eH799dfq1KmT/Pz81LBhQ7377rt59n/WrFlq0qSJ/Pz8VLNmTV177bXauHGjZZ7L+ziZTCadPXtW77zzjqWp4ahRo7R582aZTCZ99NFHefZp2bJlMplMSkxMLHTf//rrL916662qUaOGKleurGuuuSZP87GEhASZTCZ98MEHevrpp1WvXj35+fnphhtuKFJt0b59+9SqVas8SZMk1a5d2+q9yWTS/fffr6VLl6pZs2aW8vfVV19ZzXfw4EGNGzdOzZo1U6VKlVSzZk3deuutefrx5Zb9L7/8UuPGjVPt2rVVr149STk1jhMnTlR4eLh8fX1Vu3Zt9erVSzt27LBax3fffafevXsrMDBQlStXVrdu3fTNN9/Y3O+VK1fq119/1RNPPJEnacp14403qk+fPkWK1959/uqrrzR27FjVrFlTAQEBGjFiRJ5ym8tWuQVQ/EicALhc7kVC9erVHV7HsmXL9Nxzz2ns2LH673//qwMHDig6OloXL160ms9sNisqKko1a9bUvHnz1K1bN82fP19vvPFGkbYzZMgQnTlzRrNnz9aQIUO0ePFizZo1y2qeUaNG6aWXXlLfvn317LPPqlKlSrrpppsc3jd77N27V8OGDVP//v01e/ZsnTp1Sv3799fSpUs1adIk/ec//9GsWbO0b98+DRkyRNnZ2ZZlf/vtN11zzTXatWuXHn30Uc2fP19VqlTRwIED872Qz1WxYkUNGjRIq1evVmZmptVnq1evVkZGhm677TZJ0ptvvqnx48erZcuWio2N1axZs9SuXbti6Y/k7++vQYMG6ciRI/r9998t08eOHauHHnpIXbt21YIFCxQTE6OlS5cqKioqT3nZu3evBg8erF69emn+/PmqXr26Ro0apd9++80yz8yZMzVr1iz16NFDL7/8sh5//HFdccUVeS7WL7VkyRL5+voqMjJSS5Ys0ZIlSzR27Fh1795dYWFhWrp0aZ5lli5dqkaNGikiIqLA9R47dkxdunTRhg0bNG7cOD399NO6cOGCBgwYkO93OGfOHH300UeaMmWKpk6dqm+//VZ33HFHocdVkurXr6/t27fr119/tTmvJH355ZeaOHGi/vOf/+jJJ5/UyZMn1bt3b6vlv//+e23dulW33XabXnzxRd1zzz2Kj49X9+7d89yckKRx48bp999/1/Tp0/Xoo49Kku655x699tpruuWWW/Tqq69qypQpqlSpknbt2mVZ7osvvtB1112ntLQ0zZgxQ88884xOnz6t66+/Xtu2bSt0Pz799FNJylPDWRT5xWvvPt9///3atWuXZs6cqREjRmjp0qUaOHCgLu9FUZRyC6AEGADgoEWLFhmSjE2bNhnHjx83Dh06ZKxatcoICgoyfH19jUOHDlnm7datm9GtW7c86xg5cqRRv359y/v9+/cbkoyaNWsa//zzj2X6xx9/bEgyPv30U6tlJRlPPvmk1Trbt29vdOjQwWqaJGPGjBmW9zNmzDAkGXfeeafVfIMGDTJq1qxpeb99+3ZDkjFx4kSr+UaNGpVnnbasXLnSkGRs3rw5z2e5x3L//v2WafXr1zckGVu3brVM27BhgyHJqFSpknHw4EHL9Ndffz3Pum+44QajdevWxoULFyzTsrOzjS5duhhNmjQpNNbc7Vx6vA3DMPr27Ws0bNjQ8v7mm282WrVqZWvXi6x+/frGTTfdVODnL7zwgiHJ+Pjjjw3DMIwtW7YYkoylS5dazbd+/fo803OP51dffWWZlpKSYvj6+hoPPvigZVrbtm0LjcEw/i0/l6pSpYoxcuTIPPNOnTrV8PX1NU6fPm213QoVKtgsPxMnTjQkGVu2bLFMO3PmjNGgQQMjPDzcMJvNhmEYxubNmw1JRosWLYyMjAzLvAsWLDAkGb/88kuh2/n8888Nb29vw9vb24iIiDAefvhhY8OGDUZmZmaeeSUZkowffvjBMu3gwYOGn5+fMWjQIMu0c+fO5Vk2MTHRkGS8++67lmm5Zf/aa681srKyrOYPDAw07rvvvgLjzs7ONpo0aWJERUUZ2dnZVttu0KCB0atXr0L3u3379ka1atXyTE9PTzeOHz9ueaWmphYpXnv3uUOHDlbHeO7cuVbl2zCKXm4BFD9qnAA4rWfPngoKClJYWJgGDx6sKlWq6JNPPrE0X3HE0KFDrWqscpv//fXXX3nmveeee6zeR0ZG5jtffvJb9uTJk0pLS5MkrV+/XlLO3eVLPfDAA0Vav7NatmxpVSPRuXNnSdL111+vK664Is/03P3+559/9MUXX1hq1E6cOKETJ07o5MmTioqK0p49ewod+fD6669XrVq1tGLFCsu0U6dOaePGjRo6dKhlWrVq1XT48OE8zSiLi7+/v6ScJlxSTlOrwMBA9erVy7KPJ06cUIcOHeTv76/NmzdbLd+yZUtLWZKkoKAgNWvWzKq8VKtWTb/99pv27NnjkphHjBihjIwMrVq1yjJtxYoVysrKslnTsXbtWnXq1EnXXnutZZq/v7/GjBmjAwcOWNW8SVJMTIx8fHws7wv7u7lUr169lJiYqAEDBuinn37S3LlzFRUVpbp16+bbtDMiIkIdOnSwvL/iiit08803a8OGDZZmspUqVbJ8fvHiRZ08eVKNGzdWtWrV8q29u/vuu/P086tWrZq+++47/f333/nGvXPnTu3Zs0fDhg3TyZMnLd//2bNndcMNN+irr76yqoW9XFpamqVMXerxxx9XUFCQ5TVs2LAixWvvPo8ZM0YVK1a0vL/33ntVoUIFrV271mq+opRbAMWvXCdOX331lfr376/Q0FCZTCaHhpH94IMP1K5dO1WuXFn169fXc8895/pAAQ/3yiuvaOPGjVq1apX69u2rEydOyNfX16l1XpoUSP82+7u8/b+fn5+CgoLyzFtQPwF7t3Pw4EF5eXmpQYMGVvM1bty4SOt31uXxBQYGSpLCwsLynZ4b9969e2UYhp544gmrC8CgoCDNmDFDUuGd/itUqKBbbrlFH3/8sTIyMiTl9Km6ePGiVeL0yCOPyN/fX506dVKTJk103333FalviaPS09MlSVWrVpUk7dmzR6mpqapdu3ae/UxPT8+zj5cfTylveXnyySd1+vRpNW3aVK1bt9ZDDz2kn3/+2eGYmzdvrquvvtqqud7SpUt1zTXX2CxHBw8eVLNmzfJMzx2V8eDBg1bTi/p3k5+rr75acXFxOnXqlLZt26apU6fqzJkzGjx4cJ4ErUmTJnmWb9q0qc6dO6fjx49LyukbOH36dIWFhcnX11e1atVSUFCQTp8+rdTU1DzLX/43Jklz587Vr7/+qrCwMHXq1EkzZ860ShZyk9uRI0fm+f7feustZWRk5LutXFWrVrWUqUuNGzdOGzdu1MaNG1WnTp18l80vXnv3+fLj6O/vr5CQkDx9oopSbgEUv7IzJJADzp49q7Zt2+rOO+9UdHS03cuvW7dOd9xxh1566SXdeOON2rVrl+6++25VqlRJ999/fzFEDHimTp06WUbVGzhwoK699loNGzZMu3fvttzNNZlMedrtSypwtKqCRpi7fB3OjkRX1O24S0Hx2Yo79y77lClTFBUVle+8ti7ab7vtNr3++utat26dBg4cqA8++EDNmzdX27ZtLfO0aNFCu3fv1po1a7R+/Xp9+OGHevXVVzV9+vQ8fcVcIbcPTW7s2dnZql27dr59iCTlSaqL8n1fd9112rdvnz7++GN9/vnneuutt/TCCy9o4cKFuuuuuxyKe8SIEZowYYIOHz6sjIwMffvtt3r55ZcdWldhXFGefXx8dPXVV+vqq69W06ZNFRMTo5UrV1oS7qJ64IEHtGjRIk2cOFEREREKDAyUyWTSbbfdlm8t0KW1NbmGDBmiyMhIffTRR/r888/13HPP6dlnn1VcXJz69OljWc9zzz2ndu3a5RtHfjVKuZo3b66dO3fqyJEjqlu3rmV606ZN1bRpU0kFj8iZX7z27nNRefrvFFBelOvEqU+fPlYj5VwuIyNDjz/+uN5//32dPn1aV155pZ599lnLyGBLlizRwIEDLU19GjZsqKlTp+rZZ5/VfffdV66fxYLyy9vbW7Nnz7Z0rM/tNF29evV8m5Vcfsfc09SvX1/Z2dnav3+/1d1hT3+uTcOGDSXlDPTQs2dPh9Zx3XXXKSQkRCtWrNC1116rL774Qo8//nie+apUqaKhQ4dq6NChyszMVHR0tJ5++mlNnTrVpcPAp6en66OPPlJYWJilxqVRo0batGmTunbtmu+FrKNyRxWMiYlRenq6rrvuOs2cObPQxKmw3/zbbrtNkydP1vvvv6/z58+rYsWKVjV3Balfv752796dZ/off/xh+bw45d4QSU5OtpqeXzPGP//8U5UrV7Ykq6tWrdLIkSM1f/58yzwXLlzQ6dOn7YohJCRE48aN07hx45SSkqKrrrpKTz/9tPr06aNGjRpJkgICAhwq5/369dPy5cu1dOlSPfzww3Yvfzl793nPnj3q0aOH5X16erqSk5PVt29fp2MB4HrluqmeLffff78SExO1fPly/fzzz7r11lvVu3dvywkjIyMjz0VBpUqVdPjwYY+/GASKU/fu3dWpUyfFxsbqwoULknIucP/44w9LMx5J+umnn4q1WZcr5NbWvPrqq1bTX3rpJXeEU2S1a9dW9+7d9frrr+e56JVk9T0UxMvLS4MHD9ann36qJUuWKCsrK8/F/smTJ63e+/j4qGXLljIMwzKi3blz5/THH3/oxIkTDu/P+fPnNXz4cP3zzz96/PHHLUnKkCFDZDab9dRTT+VZJisry+6LdCnvPvn7+6tx48aWJosFqVKlSoHbq1Wrlvr06aP33ntPS5cuVe/evVWrVi2bsfTt21fbtm2zGrL87NmzeuONNxQeHq6WLVva3qEi2Lx5c761F7l9bS5vLpiYmGjVZ+fQoUP6+OOPdeONN1pqR7y9vfOs86WXXrL5TKRcZrM5T/O22rVrKzQ01PJddOjQQY0aNdK8efPybXJnq5wPGTJELVu21FNPPaVvv/0233nsqdWxd5/feOMNq5EfX3vtNWVlZRV6UxeA+5TrGqfCJCUladGiRUpKSlJoaKiknCYv69ev16JFi/TMM88oKipKkyZN0qhRo9SjRw/t3bvXcpcpOTnZ6tk0QHnz0EMP6dZbb9XixYt1zz336M4779Tzzz+vqKgojR49WikpKVq4cKFatWplGYjBE3Xo0EG33HKLYmNjdfLkSV1zzTX68ssv9eeff0oqvJbB3V555RVde+21at26te6++241bNhQx44dU2Jiog4fPqyffvrJ5jqGDh2ql156STNmzFDr1q0tNT25brzxRgUHB6tr166qU6eOdu3apZdfflk33XSTpR/Stm3b1KNHD82YMaNIz706cuSI3nvvPUk5d+B///13rVy5UkePHtWDDz6osWPHWubt1q2bxo4dq9mzZ2vnzp268cYbVbFiRe3Zs0crV67UggULNHjwYDuOWk5H/O7du6tDhw6qUaOGfvjhB61atcpmE+wOHTpo06ZNev755xUaGqoGDRpYBu2Qcprr5caSX6KXn0cffVTvv/+++vTpo/Hjx6tGjRp65513tH//fn344Yfy8nLN/c8HHnhA586d06BBg9S8eXNlZmZq69atWrFihcLDw/M80+vKK69UVFSUxo8fL19fX8uNhUubZ/br109LlixRYGCgWrZsqcTERG3atEk1a9YsUkxnzpxRvXr1NHjwYLVt21b+/v7atGmTvv/+e8u51svLS2+99Zb69OmjVq1aKSYmRnXr1tWRI0e0efNmBQQEWIYcz0/FihX10UcfKSoqStdee62io6MVGRmpKlWq6MiRI/rkk0+UlJRU5McP2LvPmZmZuuGGGzRkyBDt3r1br776qq699loNGDCgSNsDULJInArwyy+/yGw2W9o458rIyLD8AN59993at2+f+vXrp4sXLyogIEATJkzQzJkzXXYyA0qr6Ohoy53gu+++Wy1atNC7776r6dOna/LkyWrZsqWWLFmiZcuWWR7o6qneffddBQcH6/3339dHH32knj17asWKFZaHf3qqli1b6ocfftCsWbO0ePFinTx5UrVr11b79u01ffr0Iq2jS5cuCgsL06FDh/JtWjZ27FgtXbpUzz//vNLT01WvXj2NHz9e06ZNczjunTt3avjw4TKZTKpatarCwsLUv39/3XXXXerUqVOe+RcuXKgOHTro9ddf12OPPaYKFSooPDxc//nPfwp8qGlhxo8fr08++USff/65MjIyVL9+ff33v//VQw89VOhyzz//vMaMGaNp06bp/PnzGjlypFXi1L9/f1WvXl3Z2dlFvjCuU6eOtm7dqkceeUQvvfSSLly4oDZt2ujTTz916bPE5s2bp5UrV2rt2rV64403lJmZqSuuuELjxo3TtGnT8jwYt1u3boqIiNCsWbOUlJSkli1bavHixWrTpo1lngULFsjb21tLly7VhQsX1LVrV23atKnAPneXq1y5ssaNG6fPP/9ccXFxys7OVuPGjfXqq6/q3nvvtczXvXt3JSYm6qmnntLLL7+s9PR0BQcHq3PnzlZJdkGaNm2qnTt36sUXX9RHH32kdevWKTMzU3Xq1FHnzp01Y8YM9evXr0gx27vPL7/8spYuXarp06fr4sWLuv322/Xiiy969A0ZoDwzGfQslCTLk90HDhwoKWeo2DvuuEO//fZbnk6Z/v7+Cg4Otrw3m806evSogoKCFB8fr759+yolJSVPp2QAZcfOnTvVvn17vffee0V6wCiQlZWl0NBQ9e/fX//73//cHY7DTCaT7rvvvmIZ3KK8WLx4sWJiYvT9999b+pEB8HzUOBWgffv2MpvNSklJsXp2Qn68vb0to/G8//77ioiIIGkCypDz58/nGXggNjZWXl5euu6669wUFUqb1atX6/jx4xoxYoS7QwEAOKBcJ07p6elWI2Pt379fO3fuVI0aNdS0aVPdcccdGjFihObPn6/27dvr+PHjio+PV5s2bXTTTTfpxIkTWrVqlbp3764LFy5o0aJFWrlypb788ks37hUAV5s7d662b9+uHj16qEKFClq3bp3WrVunMWPG5HmeEnC57777Tj///LOeeuoptW/fXt26dXN3SAAAB5TrxOmHH36wGgZ08uTJknIepLd48WItWrRI//3vf/Xggw/qyJEjqlWrlq655hqrts7vvPOOpkyZIsMwFBERoYSEhHzb4AMovbp06aKNGzfqqaeeUnp6uq644grNnDkz36G5gcu99tpreu+999SuXTstXrzY3eEAABxEHycAAAAAsIGh3wAAAADABhInAAAAALCh3PVxys7O1t9//62qVavynAQAAACgHDMMQ2fOnFFoaKjN57CWu8Tp77//ZhQsAAAAABaHDh1SvXr1Cp2n3CVOVatWlZRzcAICAtwcDQAAAAB3SUtLU1hYmCVHKEy5S5xym+cFBASQOAEAAAAoUhceBocAAAAAABtInAAAAADABhInAAAAALCh3PVxKgrDMJSVlSWz2ezuUFAGeHt7q0KFCgx/DwAAUIqROF0mMzNTycnJOnfunLtDQRlSuXJlhYSEyMfHx92hAAAAwAEkTpfIzs7W/v375e3trdDQUPn4+FBLAKcYhqHMzEwdP35c+/fvV5MmTWw+XA0AAACeh8TpEpmZmcrOzlZYWJgqV67s7nBQRlSqVEkVK1bUwYMHlZmZKT8/P3eHBAAAADtx6zsf1AjA1ShTAAAApRtXcwAAAABgA4kTAAAAANhA4lTOhYeHKzY21t1hFMpkMmn16tXuDgMAAADlGIlTGTFq1CiZTCaZTCb5+PiocePGevLJJ5WVlVXoct9//73GjBnj1LYXL16s7t27O7RcbswFvQ4cOKDk5GT16dPHqRgBAAAAZzCqXjExm6UtW6TkZCkkRIqMlLy9i3ebvXv31qJFi5SRkaG1a9fqvvvuU8WKFTV16tQ882ZmZsrHx0dBQUHFG1Qhhg4dqt69e1veR0dH68orr9STTz5pmRYUFCTv4j5wAAAAgA3UOBWDuDgpPFzq0UMaNizn3/DwnOnFydfXV8HBwapfv77uvfde9ezZU5988omknBqpgQMH6umnn1ZoaKiaNWsmKW9TPZPJpNdff139+vVT5cqV1aJFCyUmJmrv3r3q3r27qlSpoi5dumjfvn0FxpGQkKBOnTqpSpUqqlatmrp27aqDBw/mma9SpUoKDg62vHx8fFS5cmWrad7e3lZN9Q4cOCCTyaQPPvhAkZGRqlSpkq6++mr9+eef+v7779WxY0f5+/urT58+On78uNX23nrrLbVo0UJ+fn5q3ry5Xn31VSePOAAAwCXMZikhQXr//Zx/zWZ3RwQXInFysbg4afBg6fBh6+lHjuRML+7k6VKVKlVSZmam5X18fLx2796tjRs3as2aNQUu99RTT2nEiBHauXOnmjdvrmHDhmns2LGaOnWqfvjhBxmGofvvvz/fZbOysjRw4EB169ZNP//8sxITEzVmzBiXP0h4xowZmjZtmnbs2KEKFSpo2LBhevjhh7VgwQJt2bJFe/fu1fTp0y3zL126VNOnT9fTTz+tXbt26ZlnntETTzyhd955x6VxAQCAcspdd85RYmiq50JmszRhgmQYeT8zDMlkkiZOlG6+uXib7RmGofj4eG3YsEEPPPCAZXqVKlX01ltvycfHp9DlY2JiNGTIEEnSI488ooiICD3xxBOKioqSJE2YMEExMTGW+UeNGqVRo0ZJktLS0pSamqp+/fqpUaNGkqQWLVq4cvckSVOmTLGK5/bbb1d8fLy6du0qSRo9erQWL15smX/GjBmaP3++oqOjJUkNGjTQ77//rtdff10jR450eXwAAKAcyb1zfvlFYO6d81WrpP+/BkHpReLkQlu25K1pupRhSIcO5cznwFgKNq1Zs0b+/v66ePGisrOzNWzYMM2cOdPyeevWrW0mTZLUpk0by//r1KljWfbSaRcuXFBaWpoCAgKslq1Ro4ZGjRqlqKgo9erVSz179tSQIUMUEhLi5N7ZH2NKSook6ezZs9q3b59Gjx6tu+++2zJPVlaWAgMDXRoXAAAoZzzlzjmKHU31XCg52bXz2atHjx7auXOn9uzZo/Pnz+udd95RlSpVLJ9f+v/CVKxY0fL/3CZ2+U3Lzs7Od/lFixYpMTFRXbp00YoVK9S0aVN9++23du+PszHmxpeeni5JevPNN7Vz507L69dff3V5XAAAoJyx5845SjVqnFyoqJUqLq58sahSpYoaN25cPCu3U/v27dW+fXtNnTpVERERWrZsma655hq3xFKnTh2Fhobqr7/+0h133OGWGAAAQBnl7jvnKDEkTi4UGSnVq5fTnDW/2lqTKefzyMiSj62k7N+/X2+88YYGDBig0NBQ7d69W3v27NGIESPcGtesWbM0fvx4BQYGqnfv3srIyNAPP/ygU6dOafLkyW6NDQAAlGLuvnOOEkPi5ELe3tKCBTl9AE0m6+Qpd1C52Niy3by1cuXK+uOPP/TOO+/o5MmTCgkJ0X333aexY8e6Na677rpLlStX1nPPPaeHHnpIVapUUevWrTVx4kS3xgUAAEo57pyXGybDyO8bLrvS0tIUGBio1NTUPAMbXLhwQfv371eDBg3k5+fn8Dbi4nL6CF7a3DUsLCdpYkCV8slVZQsAAHig3FH1pPzvnDOqnscqLDe4HINDFIPoaOnAAWnzZmnZspx/9+/n7wUAAKBMio7OSY7q1rWeXq8eSVMZQlO9YuLtXTxDjgMAAMADRUfnDDm+ZUvOQBAhITnN88pyH41yhsQJAAAAcAXunJdpNNUDAAAAABtInAAAAADABhInAAAAALCBxAkAAAAAbCBxAgAAAAAbSJwAAAAAwAYSJzjlwIEDMplM2rlzp8PrGDVqlAYOHOiymAqTkJAgk8mk06dPl8j2AAAAUDaQOJUR+SUfq1atkp+fn+bPn++eoBw0atQozZw506HlTCZTga/w8HB16dJFycnJCgwMdH3gAAAAKLNInIqL2SwlJEjvv5/zr9lcopt/6623dMcdd+i1117Tgw8+mO88mZmZJRpTcVuwYIGSk5MtL0latGiR5f33338vHx8fBQcHy2QyuTlaAAAAlCYkTsUhLk4KD5d69JCGDcv5Nzw8Z3oJmDt3rh544AEtX75cMTExlundu3fX/fffr4kTJ6pWrVqKiorKt6nd6dOnZTKZlJCQIEk6deqU7rjjDgUFBalSpUpq0qSJFi1alO+2zWaz7rzzTjVv3lxJSUkym80aPXq0GjRooEqVKqlZs2ZasGCBXfvz6quvqkmTJvLz81OdOnU0ePDgfOcLDAxUcHCw5SVJ1apVs7wPCgrK01Rv8eLFqlatmtasWaNmzZqpcuXKGjx4sM6dO6d33nlH4eHhql69usaPHy/zJclvRkaGpkyZorp166pKlSrq3Lmz5XgBAACg7Kng7gDKnLg4afBgyTCspx85kjN91SopOrrYNv/II4/o1Vdf1Zo1a3TDDTfk+fydd97Rvffeq2+++abI63ziiSf0+++/a926dapVq5b27t2r8+fP55kvIyNDt99+uw4cOKAtW7YoKChIFy9eVL169bRy5UrVrFlTW7du1ZgxYxQSEqIhQ4bY3PYPP/yg8ePHa8mSJerSpYv++ecfbdmypcixF8W5c+f04osvavny5Tpz5oyio6M1aNAgVatWTWvXrtVff/2lW265RV27dtXQoUMlSffff79+//13LV++XKGhofroo4/Uu3dv/fLLL2rSpIlL4wMAAID7kTi5ktksTZiQN2mScqaZTNLEidLNN0ve3i7f/Lp16/Txxx8rPj5e119/fb7zNGnSRHPnzrW8P3DggM31JiUlqX379urYsaMkKTw8PM886enpuummm5SRkaHNmzdb+hBVrFhRs2bNsszXoEEDJSYm6oMPPigwcVq8eLHVtqtUqaJ+/fqpatWqql+/vtq3b28zZntcvHhRr732mho1aiRJGjx4sJYsWaJjx47J399fLVu2VI8ePbR582YNHTpUSUlJWrRokZKSkhQaGipJmjJlitavX69FixbpmWeecWl8AAAAcD+a6rnSli3S4cMFf24Y0qFDOfMVgzZt2ig8PFwzZsxQenp6vvN06NDB7vXee++9Wr58udq1a6eHH35YW7duzTPP7bffrrNnz+rzzz/PM/DCK6+8og4dOigoKEj+/v564403lJSUVKRt9+rVS/Xr11fDhg01fPhwLV26VOfOnbN7HwpTuXJlS9IkSXXq1FF4eLj8/f2tpqWkpEiSfvnlF5nNZjVt2lT+/v6W15dffql9+/a5NDYAAAB4BhInV/r/AQlcNp+d6tatq4SEBB05ckS9e/fWmTNn8sxTpUoVq/deXjlFwLikluzixYtW8/Tp00cHDx7UpEmT9Pfff+uGG27QlClTrObp27evfv75ZyUmJlpNX758uaZMmaLRo0fr888/186dOxUTE1PkgSmqVq2qHTt26P3331dISIimT5+utm3bunQ48YoVK1q9N5lM+U7Lzs6WlFO75u3tre3bt2vnzp2W165du+zuvwUAAIDSgcTJlUJCXDufA+rXr68vv/xSR48eLTB5ulRQUJAkWUahk5TvM5mCgoI0cuRIvffee4qNjdUbb7xh9fm9996rOXPmaMCAAfryyy8t07/55ht16dJF48aNU/v27dW4cWO7a2UqVKignj17au7cufr555914MABffHFF3atw5Xat28vs9mslJQUNW7c2OqVOygFAAAAyhb6OLlSZKRUr17OQBD59XMymXI+j4ws1jDCwsKUkJCgHj16KCoqSuvXr1dAQEC+81aqVEnXXHON5syZowYNGiglJUXTpk2zmmf69Onq0KGDWrVqpYyMDK1Zs0YtWrTIs64HHnhAZrNZ/fr107p163TttdeqSZMmevfdd7VhwwY1aNBAS5Ys0ffff68GDRoUaV/WrFmjv/76S9ddd52qV6+utWvXKjs7W82aNbP/wLhI06ZNdccdd2jEiBGaP3++2rdvr+PHjys+Pl5t2rTRTTfd5LbYAAAAUDzcWuP01VdfqX///goNDZXJZNLq1attLpOQkKCrrrpKvr6+aty4sdVAAm7n7S3lNtW6/DlBue9jY4tlYIjL1atXTwkJCTpx4oSioqKUlpZW4Lxvv/22srKy1KFDB02cOFH//e9/rT738fHR1KlT1aZNG1133XXy9vbW8uXL813XxIkTNWvWLPXt21dbt27V2LFjFR0draFDh6pz5846efKkxo0bV+T9qFatmuLi4nT99derRYsWWrhwod5//321atWqyOsoDosWLdKIESP04IMPqlmzZho4cKC+//57XXHFFW6NCwAAAMXDZBj5VY2UjHXr1umbb75Rhw4dFB0drY8++kgDBw4scP79+/fryiuv1D333KO77rpL8fHxmjhxoj777DNFRUUVaZtpaWkKDAxUampqnlqYCxcuaP/+/WrQoIH8/Pwc37G4uJzR9S4dKCIsLCdpKsahyOG5XFa2AAAA4DKF5QaXc2tTvT59+qhPnz5Fnn/hwoVq0KCB5s+fL0lq0aKFvv76a73wwgtFTpxKRHR0zpDjW7bkDAQREpLTPK8EapoAAAAAuF6p6uOUmJionj17Wk2LiorSxIkTC1wmIyNDGRkZlveFNVlzKW9vqXv3ktkWAAAAgGJVqkbVO3r0qOrUqWM1rU6dOkpLS9P58+fzXWb27NkKDAy0vMLCwkoiVAAAAABlSKlKnBwxdepUpaamWl6HDh1yd0gAAAAASplS1VQvODhYx44ds5p27NgxBQQEqFKlSvku4+vrK19fX7u248bxMlBGUaYAAABKt1JV4xQREaH4+HiraRs3blRERIRL1l+xYkVJ0rlz51yyPiBXbpnKLWMAAAAoXdxa45Senq69e/da3u/fv187d+5UjRo1dMUVV2jq1Kk6cuSI3n33XUnSPffco5dfflkPP/yw7rzzTn3xxRf64IMP9Nlnn7kkHm9vb1WrVk0pKSmSpMqVK8t0+fOYADsYhqFz584pJSVF1apVkzcjKwIAAJRKbk2cfvjhB/Xo0cPyfvLkyZKkkSNHavHixUpOTlZSUpLl8wYNGuizzz7TpEmTtGDBAtWrV09vvfWWS4ciDw4OliRL8gS4QrVq1SxlCwAAAKWPWx+A6w5FfciV2WzWxYsXSzAylFUVK1akpgkAAMADlZoH4Hoyb29vLnYBAAAASCplg0MAAAAAgDuQOAEAAACADSROAAAAAGADiRMAAAAA2EDiBAAAAAA2kDgBAAAAgA0kTgAAAABgA4kTAAAAANhA4gQAAAAANpA4AQAAAIANJE4AAAAAYAOJEwAAAADYQOIEAAAAADaQOAEAAACADSROAAAAAGADiRMAAAAA2EDiBAAAAAA2kDgBAAAAgA0kTgAAAABgA4kTAAAAANhA4gQAAAAANpA4AQAAAIANJE4AAAAAYAOJEwAAAADYQOIEAAAAADaQOAEAAACADSROAAAAAGADiRMAAAAA2EDiBAAAAAA2kDgBAAAAgA0kTgAAAABgA4kTAAAAANhA4gQAAAAANpA4AQAAAIANJE4AAAAAYAOJEwAAAADYQOIEAAAAADaQOAEAAACADSROAAAAAGADiRMAAAAA2EDiBAAAAAA2kDgBAAAAgA0kTgAAAABgA4kTAAAAANhA4gQAAAAANpA4AQAAAIANJE4AAAAAYAOJEwAAAADYQOIEAAAAADaQOAEAAACADSROAAAAAGADiRMAAAAA2EDiBAAAAAA2kDgBAAAAgA0kTgAAAABgA4kTAAAAANhA4gQAAAAANpA4AQAAAIANJE4AAAAAYAOJEwAAAADYQOIEAAAAADaQOAEAAACADSROAAAAAGADiRMAAAAA2EDiBAAAAAA2kDgBAAAAgA0kTgAAAABgA4kTAAAAANhA4gQAAAAANrg9cXrllVcUHh4uPz8/de7cWdu2bSt0/tjYWDVr1kyVKlVSWFiYJk2apAsXLpRQtAAAAADKI7cmTitWrNDkyZM1Y8YM7dixQ23btlVUVJRSUlLynX/ZsmV69NFHNWPGDO3atUv/+9//tGLFCj322GMlHDkAAACA8sStidPzzz+vu+++WzExMWrZsqUWLlyoypUr6+233853/q1bt6pr164aNmyYwsPDdeONN+r222+3WUsFAAAAAM5wW+KUmZmp7du3q2fPnv8G4+Wlnj17KjExMd9lunTpou3bt1sSpb/++ktr165V3759C9xORkaG0tLSrF4AAAAAYI8K7trwiRMnZDabVadOHavpderU0R9//JHvMsOGDdOJEyd07bXXyjAMZWVl6Z577im0qd7s2bM1a9Ysl8YOAAAAoHxx++AQ9khISNAzzzyjV199VTt27FBcXJw+++wzPfXUUwUuM3XqVKWmplpehw4dKsGIAQAAAJQFbqtxqlWrlry9vXXs2DGr6ceOHVNwcHC+yzzxxBMaPny47rrrLklS69atdfbsWY0ZM0aPP/64vLzy5oG+vr7y9fV1/Q4AAAAAKDccqnFKSkrSli1btGHDBu3YsUMZGRl2r8PHx0cdOnRQfHy8ZVp2drbi4+MVERGR7zLnzp3Lkxx5e3tLkgzDsDsGAAAAACiKItc4HThwQK+99pqWL1+uw4cPWyUqPj4+ioyM1JgxY3TLLbfkW/OTn8mTJ2vkyJHq2LGjOnXqpNjYWJ09e1YxMTGSpBEjRqhu3bqaPXu2JKl///56/vnn1b59e3Xu3Fl79+7VE088of79+1sSKAAAAABwtSIlTuPHj9c777yjqKgo/fe//1WnTp0UGhqqSpUq6Z9//tGvv/6qLVu2aPr06Zo1a5YWLVqkq6++2uZ6hw4dquPHj2v69Ok6evSo2rVrp/Xr11sGjEhKSrJKwqZNmyaTyaRp06bpyJEjCgoKUv/+/fX00087uPsAAAAAYJvJKEIbt6lTp2rKlCmqWbOmzRWuX79e586dU3R0tEsCdLW0tDQFBgYqNTVVAQEB7g4HAAAAgJvYkxsUKXEqS0icAAAAAEj25QZ2Dw5x/vx5nTt3zvL+4MGDio2N1YYNG+yPFAAAAABKAbsTp5tvvlnvvvuuJOn06dPq3Lmz5s+fr4EDB+q1115zeYAAAAAA4G52J047duxQZGSkJGnVqlWqU6eODh48qHfffVcvvviiywMEAAAAAHezO3E6d+6cqlatKkn6/PPPFR0dLS8vL11zzTU6ePCgywMEAAAAAHezO3Fq3LixVq9erUOHDmnDhg268cYbJUkpKSkMtgAAAACgTLI7cZo+fbqmTJmi8PBwde7cWREREZJyap/at2/v8gABAAAAwN0cGo786NGjSk5OVtu2bS0PqN22bZsCAgLUvHlzlwfpSgxHDgAAAECyLzeo4MgGgoODFRwcbDWtU6dOjqwKAAAAADxekRKn6OjoIq8wLi7O4WAAAAAAwBMVqY9TYGCg5RUQEKD4+Hj98MMPls+3b9+u+Ph4BQYGFlugAAAAAOAuRapxWrRokeX/jzzyiIYMGaKFCxfK29tbkmQ2mzVu3Dj6DAEAAAAok+weHCIoKEhff/21mjVrZjV99+7d6tKli06ePOnSAF2NwSEAAAAASPblBnYPR56VlaU//vgjz/Q//vhD2dnZ9q4OAAAAADye3aPqxcTEaPTo0dq3b59lJL3vvvtOc+bMUUxMjMsDBAAAAAB3sztxmjdvnoKDgzV//nwlJydLkkJCQvTQQw/pwQcfdHmAAAAAAOBuDj0AN1daWpoklaq+QvRxAgAAACCVwANwc5F4AAAAACgP7B4c4tixYxo+fLhCQ0NVoUIFeXt7W70AAAAAoKyxu8Zp1KhRSkpK0hNPPKGQkBCZTKbiiAsAAAAAPIbdidPXX3+tLVu2qF27dsUQDgAAAAB4Hrub6oWFhcmJ8SQAAAAAoNSxO3GKjY3Vo48+qgMHDhRDOAAAAADgeexuqjd06FCdO3dOjRo1UuXKlVWxYkWrz//55x+XBQcAAAAAnsDuxCk2NrYYwgAAAAAAz2V34jRy5MjiiAMAAAAAPJZDD8A1m81avXq1du3aJUlq1aqVBgwYwHOcAAAAAJRJdidOe/fuVd++fXXkyBE1a9ZMkjR79myFhYXps88+U6NGjVweJAAAAAC4k92j6o0fP16NGjXSoUOHtGPHDu3YsUNJSUlq0KCBxo8fXxwxAgAAAIBb2V3j9OWXX+rbb79VjRo1LNNq1qypOXPmqGvXri4NDgAAAAA8gd01Tr6+vjpz5kye6enp6fLx8XFJUAAAAADgSexOnPr166cxY8bou+++k2EYMgxD3377re655x4NGDCgOGIEAAAAALeyO3F68cUX1ahRI0VERMjPz09+fn7q2rWrGjdurAULFhRHjAAAAADgVnb3capWrZo+/vhj7d271zIceYsWLdS4cWOXBwcAAAAAnsCh5zhJUuPGjUmWAAAAAJQLdjfVu+WWW/Tss8/mmT537lzdeuutLgkKAAAAADyJ3YnTV199pb59++aZ3qdPH3311VcuCQoAAAAAPIndiVNBw45XrFhRaWlpLgkKAAAAADyJ3YlT69attWLFijzTly9frpYtW7okKAAAAADwJHYPDvHEE08oOjpa+/bt0/XXXy9Jio+P1/vvv6+VK1e6PEAAAAAAcDe7E6f+/ftr9erVeuaZZ7Rq1SpVqlRJbdq00aZNm9StW7fiiBEAAAAA3MpkGIbh7iBKUlpamgIDA5WamqqAgAB3hwMAAADATezJDezu4yRJp0+f1ltvvaXHHntM//zzjyRpx44dOnLkiCOrAwAAAACPZndTvZ9//lk9e/ZUYGCgDhw4oLvuuks1atRQXFyckpKS9O677xZHnAAAAADgNnbXOE2ePFmjRo3Snj175OfnZ5net29fnuMEAAAAoEyyO3H6/vvvNXbs2DzT69atq6NHj7okKAAAAADwJHYnTr6+vvk+6PbPP/9UUFCQS4ICAAAAAE9id+I0YMAAPfnkk7p48aIkyWQyKSkpSY888ohuueUWlwcIAAAAAO5md+I0f/58paenq3bt2jp//ry6deumxo0bq2rVqnr66aeLI0YAAAAAcCu7R9ULDAzUxo0b9c033+inn35Senq6rrrqKvXs2bM44gMAAAAAt7M7ccrVtWtXde3aVVLOc50AAAAAoKyyu6nes88+qxUrVljeDxkyRDVr1lTdunX1008/uTQ4AAAAAPAEdidOCxcuVFhYmCRp48aN2rhxo9atW6c+ffrooYcecnmAAAAAAOBudjfVO3r0qCVxWrNmjYYMGaIbb7xR4eHh6ty5s8sDBAAAAAB3s7vGqXr16jp06JAkaf369ZZBIQzDkNlsdm10AAAAAOAB7K5xio6O1rBhw9SkSROdPHlSffr0kST9+OOPaty4scsDBAAAAAB3sztxeuGFFxQeHq5Dhw5p7ty58vf3lyQlJydr3LhxLg8QAAAAANzNZBiG4e4gSlJaWpoCAwOVmpqqgIAAd4cDAAAAwE3syQ0ceo7Tvn37FBsbq127dkmSWrZsqYkTJ6phw4aOrA4AAAAAPJrdg0Ns2LBBLVu21LZt29SmTRu1adNG3333nVq2bKmNGzcWR4wAAAAA4FZ2N9Vr3769oqKiNGfOHKvpjz76qD7//HPt2LHDpQG6Gk31AAAAAEj25QZ21zjt2rVLo0ePzjP9zjvv1O+//27v6gAAAADA49mdOAUFBWnnzp15pu/cuVO1a9d2RUwAAAAA4FHsHhzi7rvv1pgxY/TXX3+pS5cukqRvvvlGzz77rCZPnuzyAAEAAADA3ezu42QYhmJjYzV//nz9/fffkqTQ0FA99NBDGj9+vEwmU7EE6ir0cQIAAAAg2ZcbOPUcpzNnzkiSqlat6ugqShyJEwAAAACpBJ7jlKs0JUwAAAAA4Ci7B4c4duyYhg8frtDQUFWoUEHe3t5WLwAAAAAoa+yucRo1apSSkpL0xBNPKCQkxOP7NAEAAACAs+xOnL7++mtt2bJF7dq1K4ZwAAAAAMDz2N1ULywsTE6MJ5HHK6+8ovDwcPn5+alz587atm1bofOfPn1a9913n0JCQuTr66umTZtq7dq1LosHAAAAAC5nd+IUGxurRx99VAcOHHB64ytWrNDkyZM1Y8YM7dixQ23btlVUVJRSUlLynT8zM1O9evXSgQMHtGrVKu3evVtvvvmm6tat63QsAAAAAFAQu4cjr169us6dO6esrCxVrlxZFStWtPr8n3/+KfK6OnfurKuvvlovv/yyJCk7O1thYWF64IEH9Oijj+aZf+HChXruuef0xx9/5NluUTEcOQAAAACpmIcjj42NdTQuK5mZmdq+fbumTp1qmebl5aWePXsqMTEx32U++eQTRURE6L777tPHH3+soKAgDRs2TI888kiBI/plZGQoIyPD8j4tLc0l8QMAAAAoP+xOnEaOHOmSDZ84cUJms1l16tSxml6nTh398ccf+S7z119/6YsvvtAdd9yhtWvXau/evRo3bpwuXryoGTNm5LvM7NmzNWvWLJfEDAAAAKB8sruP06UuXLigtLQ0q1dxys7OVu3atfXGG2+oQ4cOGjp0qB5//HEtXLiwwGWmTp2q1NRUy+vQoUPFGiMAAACAssfuGqezZ8/qkUce0QcffKCTJ0/m+dxsNhdpPbVq1ZK3t7eOHTtmNf3YsWMKDg7Od5mQkBBVrFjRqlleixYtdPToUWVmZsrHxyfPMr6+vvL19S1STAAAAACQH7trnB5++GF98cUXeu211+Tr66u33npLs2bNUmhoqN59990ir8fHx0cdOnRQfHy8ZVp2drbi4+MVERGR7zJdu3bV3r17lZ2dbZn2559/KiQkJN+kCQAAAABcwe7E6dNPP9Wrr76qW265RRUqVFBkZKSmTZumZ555RkuXLrVrXZMnT9abb76pd955R7t27dK9996rs2fPKiYmRpI0YsQIq8Ej7r33Xv3zzz+aMGGC/vzzT3322Wd65plndN9999m7GwAAAABQZHY31fvnn3/UsGFDSVJAQIBl+PFrr71W9957r13rGjp0qI4fP67p06fr6NGjateundavX28ZMCIpKUleXv/mdmFhYdqwYYMmTZqkNm3aqG7dupowYYIeeeQRe3cDAAAAAIrM7sSpYcOG2r9/v6644go1b95cH3zwgTp16qRPP/1U1apVszuA+++/X/fff3++nyUkJOSZFhERoW+//dbu7QAAAACAo+xuqhcTE6OffvpJkvToo4/qlVdekZ+fnyZNmqSHHnrI5QECAAAAgLuZDMMwnFnBwYMHtX37djVu3Fht2rRxVVzFxp6nAwMAAAAou+zJDexuqne5+vXrq379+s6uBgAAAAA8lkOJU3x8vOLj45WSkmI1NLgkvf322y4JDAAAAAA8hd2J06xZs/Tkk0+qY8eOCgkJkclkKo64AAAAAMBj2J04LVy4UIsXL9bw4cOLIx4AAAAA8Dh2j6qXmZmpLl26FEcsAAAAAOCR7E6c7rrrLi1btqw4YgEAAAAAj2R3U70LFy7ojTfe0KZNm9SmTRtVrFjR6vPnn3/eZcEBAAAAgCewO3H6+eef1a5dO0nSr7/+avUZA0UAAAAAKIvsTpw2b95cHHEAAAAAgMeyu48TAAAAAJQ3RUqc7rnnHh0+fLhIK1yxYoWWLl3qVFAAAAAA4EmK1FQvKChIrVq1UteuXdW/f3917NhRoaGh8vPz06lTp/T777/r66+/1vLlyxUaGqo33nijuOMGAAAAgBJjMgzDKMqMx44d01tvvaXly5fr999/t/qsatWq6tmzp+666y717t27WAJ1lbS0NAUGBio1NVUBAQHuDgcAAACAm9iTGxQ5cbrUqVOnlJSUpPPnz6tWrVpq1KhRqRlRj8QJAAAAgGRfbmD3qHqSVL16dVWvXt2h4AAAAACgtGFUPQAAAACwgcQJAAAAAGwgcQIAAAAAG0icAAAAAMAGhxKnrKwsbdq0Sa+//rrOnDkjSfr777+Vnp7u0uAAAAAAwBPYParewYMH1bt3byUlJSkjI0O9evVS1apV9eyzzyojI0MLFy4sjjgBAAAAwG3srnGaMGGCOnbsqFOnTqlSpUqW6YMGDVJ8fLxLgwMAAAAAT2B3jdOWLVu0detW+fj4WE0PDw/XkSNHXBYYAAAAAHgKu2ucsrOzZTab80w/fPiwqlat6pKgAAAAAMCT2J043XjjjYqNjbW8N5lMSk9P14wZM9S3b19XxgYAAAAAHsFkGIZhzwKHDx9WVFSUDMPQnj171LFjR+3Zs0e1atXSV199pdq1axdXrC6RlpamwMBApaamKiAgwN3hAAAAAHATe3IDuxMnKWc48uXLl+vnn39Wenq6rrrqKt1xxx1Wg0V4KhInAAAAAJJ9uYHdg0NIUoUKFfSf//zHoeAAAAAAoLRxKHH6+++/9fXXXyslJUXZ2dlWn40fP94lgQEAAACAp7A7cVq8eLHGjh0rHx8f1axZUyaTyfKZyWQicQIAAABQ5tjdxyksLEz33HOPpk6dKi8vuwflczv6OAEAAACQ7MsN7M58zp07p9tuu61UJk0AAAAA4Ai7s5/Ro0dr5cqVxRELAAAAAHgku5vqmc1m9evXT+fPn1fr1q1VsWJFq8+ff/55lwboajTVAwAAACAV83Dks2fP1oYNG9SsWTNJyjM4BAAAAACUNXYnTvPnz9fbb7+tUaNGFUM4AAAAAOB57O7j5Ovrq65duxZHLAAAAADgkexOnCZMmKCXXnqpOGIBAAAAAI9kd1O9bdu26YsvvtCaNWvUqlWrPINDxMXFuSw4AAAAAPAEdidO1apVU3R0dHHEAgAAAAAeye7EadGiRcURBwAAAAB4LLv7OAEAAABAeVOkGqerrrpK8fHxql69utq3b1/o85p27NjhsuAAAAAAwBMUKXG6+eab5evrK0kaOHBgccYDAAAAAB7HZBiGUZQZ77zzTi1YsEBVq1Yt7piKVVpamgIDA5WamqqAgAB3hwMAAADATezJDYrcx+mdd97R+fPnnQ4OAAAAAEqbIidORayYAgAAAIAyx67hyM+cOSM/P79C56H5GwAAAICyxq7EqWnTpgV+ZhiGTCaTzGaz00EBAAAAgCexK3FatWqVatSoUVyxAAAAAIBHsitx6tq1q2rXrl1csQAAAACARyry4BAAAAAAUF4VOXGqX7++vL29izMWAAAAAPBIRW6qt3///uKMAwAAAAA8Fk31AAAAAMAGEicAAAAAsIHECQAAAABsIHECAAAAABvseo6TJL344ov5TjeZTPLz81Pjxo113XXXMQIfAAAAgDLD7sTphRde0PHjx3Xu3DlVr15dknTq1ClVrlxZ/v7+SklJUcOGDbV582aFhYW5PGAAAAAAKGl2N9V75plndPXVV2vPnj06efKkTp48qT///FOdO3fWggULlJSUpODgYE2aNKk44gUAAACAEmcyDMOwZ4FGjRrpww8/VLt27aym//jjj7rlllv0119/aevWrbrllluUnJzsylhdIi0tTYGBgUpNTVVAQIC7wwEAAADgJvbkBnbXOCUnJysrKyvP9KysLB09elSSFBoaqjNnzti7agAAAADwSHYnTj169NDYsWP1448/Wqb9+OOPuvfee3X99ddLkn755Rc1aNDAdVECAAAAgBvZnTj973//U40aNdShQwf5+vrK19dXHTt2VI0aNfS///1PkuTv76/58+e7PFgAAAAAcAe7+zjl+uOPP/Tnn39Kkpo1a6ZmzZq5NLDiQh8nAAAAAJJ9uYHdw5Hnat68uZo3b+7o4gAAAABQatidOJnNZi1evFjx8fFKSUlRdna21edffPGFy4IDAAAAAE9gdx+nCRMmaMKECTKbzbryyivVtm1bq5cjXnnlFYWHh8vPz0+dO3fWtm3birTc8uXLZTKZNHDgQIe2CwAAAABFYXeN0/Lly/XBBx+ob9++LglgxYoVmjx5shYuXKjOnTsrNjZWUVFR2r17t2rXrl3gcgcOHNCUKVMUGRnpkjgAAAAAoCB21zj5+PiocePGLgvg+eef1913362YmBi1bNlSCxcuVOXKlfX2228XuIzZbNYdd9yhWbNmqWHDhi6LBQAAAADyY3fi9OCDD2rBggVycDA+K5mZmdq+fbt69uz5b0BeXurZs6cSExMLXO7JJ59U7dq1NXr0aJvbyMjIUFpamtULAAAAAOxhd1O9r7/+Wps3b9a6devUqlUrVaxY0erzuLi4Iq/rxIkTMpvNqlOnjtX0OnXq6I8//ihw+//73/+0c+fOIm1j9uzZmjVrVpFjAgAAAIDL2Z04VatWTYMGDSqOWGw6c+aMhg8frjfffFO1atUq0jJTp07V5MmTLe/T0tIUFhZWXCECAAAAKIPsTpwWLVrkso3XqlVL3t7eOnbsmNX0Y8eOKTg4OM/8+/bt04EDB9S/f3/LtNzh0CtUqKDdu3erUaNGVsv4+vrK19fXZTEDAAAAKH/s7uPkSj4+PurQoYPi4+Mt07KzsxUfH6+IiIg88zdv3ly//PKLdu7caXkNGDBAPXr00M6dO6lJAgAAAFAsilTjdNVVVyk+Pl7Vq1dX+/btZTKZCpx3x44ddgUwefJkjRw5Uh07dlSnTp0UGxurs2fPKiYmRpI0YsQI1a1bV7Nnz5afn5+uvPJKq+WrVasmSXmmAwAAAICrFClxuvnmmy3N3Vz9sNmhQ4fq+PHjmj59uo4ePap27dpp/fr1lgEjkpKS5OXl1ooxAAAAAOWcyXDFuOKlSFpamgIDA5WamqqAgAB3hwMAAADATezJDeweHCJXZmamUlJSLIMz5LriiiscXSUAAAAAeCS7E6c///xTo0eP1tatW62mG4Yhk8kks9nssuAAAAAAwBPYnTjFxMSoQoUKWrNmjUJCQgodKAIAAAAAygK7E6edO3dq+/btat68eXHEAwAAAAAex+7h6lq2bKkTJ04URywAAAAA4JHsTpyeffZZPfzww0pISNDJkyeVlpZm9QIAAACAssbu4chzn6l0ed+m0jI4BMORAwAAAJCKeTjyzZs3OxwYAAAAAJRGdidO3bp1K444AAAAAMBjOfQA3NOnT2vbtm35PgB3xIgRLgkMAAAAADyF3YnTp59+qjvuuEPp6ekKCAiw6utkMplInAAAAACUOXaPqvfggw/qzjvvVHp6uk6fPq1Tp05ZXv/8809xxAgAAAAAbmV34nTkyBGNHz9elStXLo54AAAAAMDj2J04RUVF6YcffiiOWAAAAADAI9ndx+mmm27SQw89pN9//12tW7dWxYoVrT4fMGCAy4IDAAAAAE/g8ANw810ZD8AFAAAAUEoU6wNwLx9+HAAAAADKOrv7OAEAAABAeWN3jdOTTz5Z6OfTp093OBgAAAAA8ER2J04fffSR1fuLFy9q//79qlChgho1akTiBAAAAKDMsTtx+vHHH/NMS0tL06hRozRo0CCXBAUAAAAAnsQlfZwCAgI0a9YsPfHEE65YHQAAAAB4FJcNDpGamqrU1FRXrQ4AAAAAPIbdTfVefPFFq/eGYSg5OVlLlixRnz59XBYYAAAAAHgKuxOnF154weq9l5eXgoKCNHLkSE2dOtVlgQEAAACAp7A7cdq/f3+Bn50/f96pYAAAAADAE7mkj1NGRoaef/55NWjQwBWrAwAAAACPUuTEKSMjQ1OnTlXHjh3VpUsXrV69WpL09ttvq0GDBnrhhRc0adKk4ooTAAAAANymyE31pk+frtdff109e/bU1q1bdeuttyomJkbffvutnn/+ed16663y9vYuzlgBAAAAwC2KnDitXLlS7777rgYMGKBff/1Vbdq0UVZWln766SeZTKbijBEAAAAoEWaztGWLlJwshYRIkZESdQOQ7EicDh8+rA4dOkiSrrzySvn6+mrSpEkkTQAAACgT4uKkCROkw4f/nVavnrRggRQd7b644BmK3MfJbDbLx8fH8r5ChQry9/cvlqAAAACAkhQXJw0ebJ00SdKRIznT4+LcExc8R5FrnAzD0KhRo+Tr6ytJunDhgu655x5VqVLFar44ShUAAABKEbM5p6bJMPJ+ZhiSySRNnCjdfDPN9sqzIidOI0eOtHr/n//8x+XBAAAAACVty5a8NU2XMgzp0KGc+bp3L7Gw4GGKnDgtWrSoOOMAAAAA3CI52bXzoWwqcuIEAEBBGIUKQGkWEuLa+VA2FXlwCAAA8hMXJ4WHSz16SMOG5fwbHk5HagClR2Rkzuh5BQ0WbTJJYWE586H8InECADiMUagAlAXe3jlDjkt5k6fc97Gx1KSXdyROAACH2BqFSsoZhcpsLtGwAMAh0dHSqlVS3brW0+vVy5nOc5xAHycAgEMYhQpAWRMdnTPkOH02kR8SJwCAQxiFCkBZ5O3NzR7kj6Z6AACHMAoVAKA8IXECADiEUagAAOUJiRMAwCGMQgUAKE9InAAADmMUKgBAecHgEAAApzAKFQCgPCBxAgA4jVGoAABlHU31AAAAAMAGEicAAAAAsIHECQAAAABsIHECAAAAABtInAAAAADABhInAAAAALCBxAkAAAAAbCBxAgAAAAAbSJwAAAAAwAYSJwAAAACwgcQJAAAAAGwgcQIAAAAAG0icAAAAAMAGEicAAAAAsIHECQAAAABsIHECAAAAABtInAAAAADABhInAAAAALCBxAkAAAAAbCBxAgAAAAAbSJwAAAAAwAYSJwAAAACwgcQJAAAAAGwgcQIAAAAAGzwicXrllVcUHh4uPz8/de7cWdu2bStw3jfffFORkZGqXr26qlevrp49exY6PwAAAAA4y+2J04oVKzR58mTNmDFDO3bsUNu2bRUVFaWUlJR8509ISNDtt9+uzZs3KzExUWFhYbrxxht15MiREo4cAAAAQHlhMgzDcGcAnTt31tVXX62XX35ZkpSdna2wsDA98MADevTRR20ubzabVb16db388ssaMWJEns8zMjKUkZFheZ+WlqawsDClpqYqICDAdTsCAAAAoFRJS0tTYGBgkXIDt9Y4ZWZmavv27erZs6dlmpeXl3r27KnExMQirePcuXO6ePGiatSoke/ns2fPVmBgoOUVFhbmktgBAAAAlB9uTZxOnDghs9msOnXqWE2vU6eOjh49WqR1PPLIIwoNDbVKvi41depUpaamWl6HDh1yOm4AAAAA5UsFdwfgjDlz5mj58uVKSEiQn59fvvP4+vrK19e3hCMDAAAAUJa4NXGqVauWvL29dezYMavpx44dU3BwcKHLzps3T3PmzNGmTZvUpk2b4gwTAAAAQDnn1qZ6Pj4+6tChg+Lj4y3TsrOzFR8fr4iIiAKXmzt3rp566imtX79eHTt2LIlQAQAAAJRjbm+qN3nyZI0cOVIdO3ZUp06dFBsbq7NnzyomJkaSNGLECNWtW1ezZ8+WJD377LOaPn26li1bpvDwcEtfKH9/f/n7+7ttPwAAAACUXW5PnIYOHarjx49r+vTpOnr0qNq1a6f169dbBoxISkqSl9e/FWOvvfaaMjMzNXjwYKv1zJgxQzNnzizJ0AEAAACUE25/jlNJs2esdgAAAABlV6l5jhMAAAAAlAYkTgAAAABgA4kTAAAAANhA4gQAAAAANpA4AQAAAIANJE4AAAAAYAOJEwAAAADYQOIEAAAAADaQOAEAAACADSROAAAAAGADiRMAAAAA2EDiBAAAAAA2kDgBAAAAgA0kTgAAAABgA4kTAAAAANhA4gQAAAAANpA4AQAAAIANJE4AAAAAYAOJEwAAAADYQOIEAAAAADaQOAEAAACADSROAAAAAGADiRMAAAAA2EDiBAAAAAA2kDgBAAAAgA0kTgAAAABgA4kTAAAAANhA4gQAAAAANpA4AQAAAIANJE4AAAAAYAOJEwAAAADYQOIEAAAAADaQOAEAAACADSROAAAAAGADiRMAAAAA2FDB3QEAAAAAKB/MZmnLFik5WQoJkSIjJW9vd0dVNCROAAAAAIpdXJw0YYJ0+PC/0+rVkxYskKKj3RdXUdFUDwAAAECxiouTBg+2Tpok6ciRnOlxce6Jyx4mwzAMdwdRktLS0hQYGKjU1FQFBAS4OxwAAHCJ0tyMpyzje4EzzGYpPDxv0pTLZMqpedq/v+TLlT25ATVOAADAI8TF5Vxc9eghDRuW8294eOm4E12W8b3AWVu2FJw0SZJhSIcO5cznyUicAKAMMZulhATp/fdz/jWb3R1R4UpbvCg+ZaEZT1nE9wJXSE527XzuQuIEAGVEabsrXNridRZJYsHM5pwO4/l1HsidNnGiZx6zsvy9uup7KcvHCEUTEuLa+dyFPk6AC9EGHO6Se1f48l90kynn31WrPGvEotx4TYZZkdqiECUrWSH6WpHKNnl7XLzOKpUjSZXgD1pCQk7iLElesi4TWxSpbOVsd/NmqXv3YgjAwX0tld+rHS79XgpT2PfitmPECblISuow5fZxOnIk/0S8tPRxklHOpKamGpKM1NRUd4fiFllZhrF5s2EsW5bzb1aWuyMqOz780DDq1TOMnJ+EnFe9ejnTgeKUlZW37F36MpkMIyzMc/7ec+MdpA+NJFkHnqR6RrQ+9Kh4nfXhhznfQX7fi8lUxN+Ikv7xLuEftGXLcjZRUJkYpA8NKWc+l3NwX13yvXq43O/F1qug78Vtx8iNJ+TSdJ1V0ocptzxcXibc/TdjT25A4lSOcGFffMrDCdQTlKYTkmGUXLybNxft4mbzZs+Jd5A+NMwyGebLgsyZZjIG6UOPidcZLklq3XV1U4I/aK4qE3ZzcF/dfrOihAq/M78tbjtGbjwhu+s6y5Hi4K7DlN8xCgtz73USiVMhymvixIV98XH7CbSc+PBDw7iibpbRTZuN27TM6KbNxhV1s4pcdsvyDXtn7wqXdLzvv5dlJKlengvkSy+UDyrMeP+9gr+k0nIjyOmktqR/vN30g5aVkWUc8S68TBz2DjOyMgrert1/407sqytuVjj8m1SChT/3EOVXBG0VB7fc0HHjCdnZP1VHy4MjxcHd1y2edtOLxKkQ5TFxcvcfSFnnqpMDCvbhh4YRXUizLlsnpNJ4w96eE4uzZbCkr81/fKFoAf/4Qv4Bl6YbQU4lte748XbXD5qT23Xob9yJbbqiCZtDv0n/X/izL9tQdjEWfkebV7nlho6byq+zf6qOlgdHfwu5brFG4lSI8pg4ldc/kJK6o+GKkwMKlpVlGHfVLLwJz901Pyz0hOSuG/Zesq4h81JWka517T2JOnNX2B3X5ub3ivZHY34v7x+Nq+ItFc0o3fHj7a4fNCe26/DfuBPbdOarcTje/y/8lydNua9sFa3wO9qsy97mVW65oeOm8uuO8uDMuYbrFmskToUoj4lTefwDKckahtKcmDpz8ZiVkWX8+MJm45v7lxk/vrC50CY0zmxz86aiNevavCnvitx5w95WJ3dX1/7kLud92QnU+/9PoEW585jfybfI5beEqshcEa+zzT7tcWlSa3ci7Yofb7v/4Da75gethLbr1N+4E/vq6PfqrnhzOXNutPcrdabsO3yc3HRCdvRP1Zny4My5xq1NTZ1e2PVInApRHhOn0nxh7wh31TA4crf/8vWUlj44iQ99aBzxtl74iHc9I/Eh26NQ2XvBumna5iIV4E3TNudZ1iUnBzsTxGXLitbJPb9rXWdrqxz5XlwympmDVWTZyv+PprA7587G62yzT0f+UB3epgtu2Wdf9r1kF6Hzw9ma9QxzAd+NWSbjbE3bVaaObNeRH1KnDpET5fD/d9Pu79WZeJ2pqc2N16lzYwmWfYePkyvKrwMcjdeZG0GuONc4dEPHcPLmtAd2UCVxKkR5TJxcdWHv6JV9SSYE7urP5ewQmyV5B/zSeB05gSY+VPgPdUEX6Y6eQH+bVrSLhd+m5T07XHoXsLCTUkEX2Y4kIs7UkDlVW+Vg34fNm50czczJKrLsy5YtznidbfbpTEeE7AK2ma3C2+I4fBHo4Datj5HJoWPk0L7mHl87f0idrZT79/cs/30t9GaQA/vqTLzO9A10+txYwmXfmRocp8qvgxy9znLmRpAz5xrDcPyc7FQC7qEdVEmcClEWEidH2yc7c2Hv6I9mSd9YcGftmiNtwHOXc+oOuJ2cOYE6OvKVMxesWZs2F+lLzdq0Oc+yziQijiaIzsTr8B1EJ75Up0YzK44e0Tb+aJyJ16kLDUc75Tvz3Th6EWhJuArez4ISrsL+Zg4qrPDk3YntWh1nO8qEM7/5uV9NQfta6PPEHPxenYn339EoC06kCxqN0qkmrq7ohGNn2Xe2Bseh8uskR66znLoR5MS5Jjdge5Nap1pFuOvOdhGQOBXCoxInB6u9Ha2ZcPTC3tELBpfcWLDzGDlbw+AsR9qAO3UH3AHOnLgdvePp1AWrE3fdHT2+TiUTznQ4d/Q4OfOlumvZS7+kEuqD43CzT0uTrvznL7RJlwv6c9l7Eehs8p47i72/oU5fyF16vItYJpxpUeFUMuFknyxH4/33Ijv/RLqgi2yHazZc0QnHgbLvbA2OI+XXFey9znLXucbZxN+hVhEe3G+ExKkQHpM4OVAV44qaCbs79Dt4weCSGwsOHCOn/qjdwNmqdkc481v7zf1FW/ib+60XdqafkmEYl9wZy3uxULSmTgUf3/ySLqeGy3bmYsHRC09nvlR3LesoJ7bpcLNPZ074TsTr6EWgM81bndlVZ7brDEdbVDhVfF0wCqC98eaeV/O7DrBVQ+ZwzYabyr6jx8kTrs3tuhdUym56OdOvypNHKrMnN/ASSl5cnDR4sHT4sPX0I0dypsfF5VnEbJbWjYnTSg1WXVkvV1dHtFKDtX5MnMzmwrfr3Shc7Sb1UJeXh6ndpB7ybhSe7/YstmyRDh+WqYCPTTKkQ4dy5su7mCTJS2Z1U4Ju0/vqpgR5ySwj/8WsYtXgwTIuO0ZGIcdIkiIjpbtqxmlVAcdplQbr7ppxiowseJdLkjlhi8J0WAX9IXrJ0BU6JHNCQQdKMmeatTM2QVsfeF87YxNkziysEEghIUWLLb/5Kjcq2sKXzxei5KJts6D5oqNl+nCVTPXqWk021asn04erpOjo/JfbskWVTxZ+fCufzFsQz+0rWrz5zhcZKdWrJ5kK+KsxmaSwMOVXCL1TirbdPPM586W6a1lHObHNZt2Ltuzl82UfKdr3ku98TsR76aRseetLdddy3a4v1V3Z8i5w0WQVbZv5zedE8XVqu86IjpZWrZLCQq3PNVfUNWtVIT8PThVfJxbOjbeu9c+Z6tVTofF6e0sLFkgfmaLVQAfUXZt1u5apuzarofbrI1O0YmNz5rtcZBezXvaeIMnI83voJUOS9JL3REV2uez8kVy0sp/vfE7+PjhynJwpv67i7S117y7dfnvOv/l9HxbOHF+n/lgd225IbbMWqPByFKuJCqmdz3WIO84XxaEEEjmP4vYaJ0erR52tmXCw3Zyjo/g4NfKVM81iXNHG3pnRLOxc1tk7tI4MXuDMaDr/NisouNlcvn2c3NCExzAMh+9wOfuAVodvKTt6B9GZ9j/uWtZRTsbrSLNPp8qDE/E6uui/54vC+8IU1mncoeLr5Had4sBIfk4VXxeUfUcf6eBQs3tXDPtmz3IuOkaOHCen+3Tnxl4So1o5W0VWwucap87l7jhfFBFN9Qrh9sTJwcLqVFMnJ9rNOdynZbMTI3W5s8+FI8PoXrKsvU0LnfkRcnTwgtxQHW326dAoVE70U3KKoycHBxNEK45c3ThzYnHmasFdyzrKyXjtbfbpTKd8Z+N1ZFGHB5W4bLuOFF93jGjmTIdap4qvs383ToycZPd1vbMPGnL0YtcVQ866aGCqIvXpdmKbDnFFMlGS5xpnm9u543xRBCROhXB74uRgoXOqZsKJZMLRCwZnOjw69awKZ/6oXTGMrr0nbgcTCqc6lDq7r0b+NV2HvcOKOHRv0S9YnebEScmpYYov3X5JDoHpzNWCu5Z1lJPx5r1BUvCyznTKd0W8jixa0M2R3L4wReoT62DxdXa7dnFBh1qXX2QX5ctxeuQkOzlzU7E4kp+iDjnrxHFyqNLIHd+NK5KJkjrXuKITmTvOFzaQOBXC3YmTozUMTlWPOjPK12YHLxic+ONyS8d8Z5r4OXvidiChcEnTIUfjzV2NI81M7LxgdQknTkoOJYiuitnRE0sJNjV12bKOKqF4nemU76p4Hb0uunwU1vr1iu/5cG7ZrotGA3Cq+NqzsIt+f+3mipojZy527T3A7jhO7vpuDMN9yYS923VVczt3nC8KQeJUCHcnTg63AXemqZMLhgS1+4LBiWTNqWYxDv5RO5WYuugOjD0JhaOj27ksXme44wfTiZOSo/0QnOZhJ5byLjf/9r6sX6D3//cLdOPN0kK5qxiV2HY9eKSufLnz99fZmo2SLEzuOE7l8dzoyHY9tLmdM+zJDSq4a1CK8io5xVsvaoFWabCyZbKMQiJJ2f8/dt1ExerWlMuGYfH2VuU3Fsi4Jf/lTJIqvxFbwHA6/z/yypEjOcX7ciZTzuf5jfL1/6P4DB4crY+Nm3WttihEyUpWiL5WpLJN3lqV32adGD0luK63JhThGI2vm8++/htwzn5dur+5I8/kM+zQ7oRktSxCuLsTktXyhssmOjMqTq7oaJluvjlndLfkZCkkRKbIyAKH43F0dDubcTgyn71yhxwqSdHR0mXHV4Uc30t5+3ir3cTuxR9jng274TihQLkjfE2Y4K0vD3e3TA8Ly/lJKWgkNHdzVzEqse2WtpG63Pn7+28hth7Vt169ohXikixM7jhO5fHc6Mh2nS1HpV0JJHIexe01TptzEnOHn2rtaFMnJ+8Q2H3D3gUjSTnVLMbOgJ0afMMNd6mcGrzA3XfVgFKMikAP48EjdeXLE35/S0MhLo81TqVNaShHRWRPbmAyjPyqIMqutLQ0BQYGKjU1VQEBASW+fbNZCg/PqfwxGWZFXlKDs0WRMkzeqldP2r+/kJvhZrNDd84VF5f3DoEdt0vt3mzu86qk/Gt+CnlgRe6iXoY5/1quQp514UjACfFmNeoZrro6YlXDlStbJh1WPf21ab+633DZOi79Ugur0Sv0S7Xftw/HqdNzOcc3v1q5bQ+t0jVz8zlIbooXAIqFE+eaEsfvb9G44zjx3ZRbduUGxZ7GeRh31zgZhpubh5b0HYISHknKUU4Po+umL9XhwQvKYBtlAOWYB47UVSB+f4vGHceJ76ZcosapEO6uccrlZOVP6eJoDZlzi9otLk5aekucYjVBYfr3i0lSmCYpVnd8GF34d+OmL9WcadYvr27RuX3JqtwoRK3HRcrbp/hrIAHAo5TkCcNZ/P4WjTuOE99NuWNPbkDi5Eal6Te+vIiLkyaNN6vBkX+bBx6oF6nnF3gX7feytH2ppS1eACgr+P0tGnccJ76bcoXEqRCelDjBM/F7CQAAUD7YkxswHDlwGUaBBgAAwOW83B0AAAAAAHg6EicAAAAAsMEjEqdXXnlF4eHh8vPzU+fOnbVt27ZC51+5cqWaN28uPz8/tW7dWmvXri2hSAEAAACUR25PnFasWKHJkydrxowZ2rFjh9q2bauoqCilpKTkO//WrVt1++23a/To0frxxx81cOBADRw4UL/++msJRw4AAACgvHD7qHqdO3fW1VdfrZdfflmSlJ2drbCwMD3wwAN69NFH88w/dOhQnT17VmvWrLFMu+aaa9SuXTstXLjQ5vYYVQ8AAACAZF9u4NYap8zMTG3fvl09e/a0TPPy8lLPnj2VmJiY7zKJiYlW80tSVFRUgfNnZGQoLS3N6gUAAAAA9nBr4nTixAmZzWbVqVPHanqdOnV09OjRfJc5evSoXfPPnj1bgYGBlldYWJhrggcAAABQbri9j1Nxmzp1qlJTUy2vQ4cOuTskAAAAAKWMWx+AW6tWLXl7e+vYsWNW048dO6bg4OB8lwkODrZrfl9fX/n6+romYAAAAADlkltrnHx8fNShQwfFx8dbpmVnZys+Pl4RERH5LhMREWE1vyRt3LixwPkBAAAAwFlurXGSpMmTJ2vkyJHq2LGjOnXqpNjYWJ09e1YxMTGSpBEjRqhu3bqaPXu2JGnChAnq1q2b5s+fr5tuuknLly/XDz/8oDfeeMOduwEAAACgDHN74jR06FAdP35c06dP19GjR9WuXTutX7/eMgBEUlKSvLz+rRjr0qWLli1bpmnTpumxxx5TkyZNtHr1al155ZXu2gUAAAAAZZzbn+NU0niOEwAAAADJvtzA7TVOJS03T+R5TgAAAED5lpsTFKUuqdwlTmfOnJEknucEAAAAQFJOjhAYGFjoPOWuqV52drb+/vtvVa1aVSaTySXrTEtLU1hYmA4dOkTzPziFsgRXoBzBVShLcBXKElzF1WXJMAydOXNGoaGhVuMq5Kfc1Th5eXmpXr16xbLugIAAfgzgEpQluALlCK5CWYKrUJbgKq4sS7ZqmnK59TlOAAAAAFAakDgBAAAAgA0kTi7g6+urGTNmyNfX192hoJSjLMEVKEdwFcoSXIWyBFdxZ1kqd4NDAAAAAIC9qHECAAAAABtInAAAAADABhInAAAAALCBxAkAAAAAbCBxKqJXXnlF4eHh8vPzU+fOnbVt27ZC51+5cqWaN28uPz8/tW7dWmvXri2hSOHJ7ClHv/32m2655RaFh4fLZDIpNja25AKFx7OnLL355puKjIxU9erVVb16dfXs2dPmbxjKD3vKUlxcnDp27Khq1aqpSpUqateunZYsWVKC0cKT2XutlGv58uUymUwaOHBg8QaIUsOesrR48WKZTCarl5+fX7HEReJUBCtWrNDkyZM1Y8YM7dixQ23btlVUVJRSUlLynX/r1q26/fbbNXr0aP34448aOHCgBg4cqF9//bWEI4cnsbccnTt3Tg0bNtScOXMUHBxcwtHCk9lblhISEnT77bdr8+bNSkxMVFhYmG688UYdOXKkhCOHp7G3LNWoUUOPP/64EhMT9fPPPysmJkYxMTHasGFDCUcOT2NvWcp14MABTZkyRZGRkSUUKTydI2UpICBAycnJltfBgweLJzgDNnXq1Mm47777LO/NZrMRGhpqzJ49O9/5hwwZYtx0001W0zp37myMHTu2WOOEZ7O3HF2qfv36xgsvvFCM0aE0caYsGYZhZGVlGVWrVjXeeeed4goRpYSzZckwDKN9+/bGtGnTiiM8lCKOlKWsrCyjS5cuxltvvWWMHDnSuPnmm0sgUng6e8vSokWLjMDAwBKJjRonGzIzM7V9+3b17NnTMs3Ly0s9e/ZUYmJivsskJiZazS9JUVFRBc6Pss+RcgTkxxVl6dy5c7p48aJq1KhRXGGiFHC2LBmGofj4eO3evVvXXXddcYYKD+doWXryySdVu3ZtjR49uiTCRCngaFlKT09X/fr1FRYWpptvvlm//fZbscRH4mTDiRMnZDabVadOHavpderU0dGjR/Nd5ujRo3bNj7LPkXIE5McVZemRRx5RaGhonhs8KF8cLUupqany9/eXj4+PbrrpJr300kvq1atXcYcLD+ZIWfr666/1v//9T2+++WZJhIhSwpGy1KxZM7399tv6+OOP9d577yk7O1tdunTR4cOHXR5fBZevEQDgsebMmaPly5crISGh2DrPomyrWrWqdu7cqfT0dMXHx2vy5Mlq2LChunfv7u7QUEqcOXNGw4cP15tvvqlatWq5OxyUchEREYqIiLC879Kli1q0aKHXX39dTz31lEu3ReJkQ61ateTt7a1jx45ZTT927FiBHfaDg4Ptmh9lnyPlCMiPM2Vp3rx5mjNnjjZt2qQ2bdoUZ5goBRwtS15eXmrcuLEkqV27dtq1a5dmz55N4lSO2VuW9u3bpwMHDqh///6WadnZ2ZKkChUqaPfu3WrUqFHxBg2P5IrrpYoVK6p9+/bau3evy+OjqZ4NPj4+6tChg+Lj4y3TsrOzFR8fb5XdXioiIsJqfknauHFjgfOj7HOkHAH5cbQszZ07V0899ZTWr1+vjh07lkSo8HCu+l3Kzs5WRkZGcYSIUsLestS8eXP98ssv2rlzp+U1YMAA9ejRQzt37lRYWFhJhg8P4orfJbPZrF9++UUhISGuD7BEhqAo5ZYvX274+voaixcvNn7//XdjzJgxRrVq1YyjR48ahmEYw4cPNx599FHL/N98841RoUIFY968ecauXbuMGTNmGBUrVjR++eUXd+0CPIC95SgjI8P48ccfjR9//NEICQkxpkyZYvz444/Gnj173LUL8BD2lqU5c+YYPj4+xqpVq4zk5GTL68yZM+7aBXgIe8vSM888Y3z++efGvn37jN9//92YN2+eUaFCBePNN9901y7AQ9hbli7HqHrIZW9ZmjVrlrFhwwZj3759xvbt243bbrvN8PPzM3777TeXx0ZTvSIYOnSojh8/runTp+vo0aNq166d1q9fb+m4lpSUJC+vfyvvunTpomXLlmnatGl67LHH1KRJE61evVpXXnmlu3YBHsDecvT333+rffv2lvfz5s3TvHnz1K1bNyUkJJR0+PAg9pal1157TZmZmRo8eLDVembMmKGZM2eWZOjwMPaWpbNnz2rcuHE6fPiwKlWqpObNm+u9997T0KFD3bUL8BD2liWgIPaWpVOnTunuu+/W0aNHVb16dXXo0EFbt25Vy5YtXR6byTAMw+VrBQAAAIAyhNQfAAAAAGwgcQIAAAAAG0icAAAAAMAGEicAAAAAsIHECQAAAABsIHECAAAAABtInAAAAADABhInAAAAALCBxAkAgEKMGjVKAwcOdHcYAAA3I3ECAHikUaNGyWQyyWQyqWLFiqpTp4569eqlt99+W9nZ2SUWx4IFC7R48WLL++7du2vixIkltn0AgGcgcQIAeKzevXsrOTlZBw4c0Lp169SjRw9NmDBB/fr1U1ZWVonEEBgYqGrVqpXItgAAnovECQDgsXx9fRUcHKy6devqqquu0mOPPaaPP/5Y69ats9QCnT59WnfddZeCgoIUEBCg66+/Xj/99JNlHTNnzlS7du20ZMkShYeHKzAwULfddpvOnDljmWfVqlVq3bq1KlWqpJo1a6pnz546e/asJOumeqNGjdKXX36pBQsWWGrD9u/fr8aNG2vevHlWse/cuVMmk0l79+4t3oMEACgRJE4AgFLl+uuvV9u2bRUXFydJuvXWW5WSkqJ169Zp+/btuuqqq3TDDTfon3/+sSyzb98+rV69WmvWrNGaNWv05Zdfas6cOZKk5ORk3X777brzzju1a9cuJSQkKDo6WoZh5Nn2ggULFBERobvvvlvJyclKTk7WFVdcoTvvvFOLFi2ymnfRokW67rrr1Lhx42I8GgCAkkLiBAAodZo3b64DBw7o66+/1rZt27Ry5Up17NhRTZo00bx581StWjWtWrXKMn92drYWL16sK6+8UpGRkRo+fLji4+Ml5SROWVlZio6OVnh4uFq3bq1x48bJ398/z3YDAwPl4+OjypUrKzg4WMHBwfL29taoUaO0e/dubdu2TZJ08eJFLVu2THfeeWfJHBAAQLEjcQIAlDqGYchkMumnn35Senq6atasKX9/f8tr//792rdvn2X+8PBwVa1a1fI+JCREKSkpkqS2bdvqhhtuUOvWrXXrrbfqzTff1KlTp+yKJzQ0VDfddJPefvttSdKnn36qjIwM3XrrrS7YWwCAJ6jg7gAAALDXrl271KBBA6WnpyskJEQJCQl55rl0QIeKFStafWYymSwj83l7e2vjxo3aunWrPv/8c7300kt6/PHH9d1336lBgwZFjumuu+7S8OHD9cILL2jRokUaOnSoKleu7ND+AQA8D4kTAKBU+eKLL/TLL79o0qRJqlevno4ePaoKFSooPDzc4XWaTCZ17dpVXbt21fTp01W/fn199NFHmjx5cp55fXx8ZDab80zv27evqlSpotdee03r16/XV1995XA8AADPQ+IEAPBYGRkZOnr0qMxms44dO6b169dr9uzZ6tevn0aMGCEvLy9FRERo4MCBmjt3rpo2baq///5bn332mQYNGqSOHTva3MZ3332n+Ph43Xjjjapdu7a+++47HT9+XC1atMh3/vDwcH333Xc6cOCA/P39VaNGDXl5eVn6Ok2dOlVNmjRRRESEqw8HAMCN6OMEAPBY69evV0hIiMLDw9W7d29t3rxZL774oj7++GN5e3vLZDJp7dq1uu666xQTE6OmTZvqtttu08GDB1WnTp0ibSMgIEBfffWV+vbtq6ZNm2ratGmaP3+++vTpk+/8U6ZMkbe3t1q2bKmgoCAlJSVZPhs9erQyMzMVExPjkv0HAHgOk5HfeKsAAMBuW7Zs0Q033KBDhw4VOXEDAJQOJE4AADgpIyNDx48f18iRIxUcHKylS5e6OyQAgIvRVA8AACe9//77ql+/vk6fPq25c+e6OxwAQDGgxgkAAAAAbKDGCQAAAABsIHECAAAAABtInAAAAADABhInAAAAALCBxAkAAAAAbCBxAgAAAAAbSJwAAAAAwAYSJwAAAACw4f8ACxxEqCaWw6sAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df1 = pd.DataFrame(sparse_p)\n",
    "df2 = pd.DataFrame(dense_p)\n",
    "df3 = pd.DataFrame(sparse_k)\n",
    "df4 = pd.DataFrame(dense_k)\n",
    "df_sparse = pd.merge(df1, df3, on='Density')\n",
    "df_dense = pd.merge(df2, df4, on='Density')\n",
    "\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.scatter(df_sparse['Density'], df_sparse['Runtime_p'], color='blue', label=\"Prim's Time\")\n",
    "plt.scatter(df_sparse['Density'], df_sparse['Runtime_k'], color='red', label=\"Kruskal's Time\")\n",
    "plt.title('Running Time vs. Density on Sparse Graph')\n",
    "plt.xlabel('Density')\n",
    "plt.ylabel('Running Time (nanoseconds)')\n",
    "plt.legend()\n",
    "\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.scatter(df_dense['Density'], df_dense['Runtime_p'], color='blue', label=\"Prim's Time\")\n",
    "plt.scatter(df_dense['Density'], df_dense['Runtime_k'], color='red', label=\"Kruskal's Time\")\n",
    "plt.title('Running Time vs. Density on Dense Graph')\n",
    "plt.xlabel('Density')\n",
    "plt.ylabel('Running Time (nanoseconds)')\n",
    "plt.legend()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "cds",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.17"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}