From 19a8f02eb3929d20e68bf54b0963dc79cc3231e8 Mon Sep 17 00:00:00 2001
From: Kerem Keptig <kerem.keptig@stud-mail.uni-wuerzburg.de>
Date: Tue, 7 Jan 2025 08:12:36 +0100
Subject: [PATCH] Upload New File
---
temporal-bipartite.ipynb | 428 +++++++++++++++++++++++++++++++++++++++
1 file changed, 428 insertions(+)
create mode 100644 temporal-bipartite.ipynb
diff --git a/temporal-bipartite.ipynb b/temporal-bipartite.ipynb
new file mode 100644
index 0000000..4e50728
--- /dev/null
+++ b/temporal-bipartite.ipynb
@@ -0,0 +1,428 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import pathpyG as pp\n",
+ "from pathpyG.algorithms.components import connected_components\n",
+ "from pathpyG.algorithms.temporal import lift_order_temporal\n",
+ "import numpy as np\n",
+ "import pandas as pd\n",
+ "import matplotlib.pyplot as plt\n",
+ "import torch\n",
+ "import networkx as nx"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\n",
+ "def preprocess(dataset_name: str):\n",
+ " \"\"\"\n",
+ " Read the original data file and return the DataFrame with columns ['u', 'i', 'ts', 'label', 'idx']\n",
+ " \"\"\"\n",
+ " u_list, i_list, ts_list, label_list = [], [], [], []\n",
+ " feat_l = []\n",
+ " idx_list = []\n",
+ "\n",
+ " with open(dataset_name) as f:\n",
+ " next(f)\n",
+ " previous_time = -1\n",
+ " for idx, line in enumerate(f):\n",
+ " e = line.strip().split(',')\n",
+ " u = int(e[0])\n",
+ " i = int(e[1])\n",
+ " ts = float(e[2])\n",
+ " assert ts >= previous_time\n",
+ " previous_time = ts\n",
+ " label = float(e[3])\n",
+ " feat = np.array([float(x) for x in e[4:]])\n",
+ " u_list.append(u)\n",
+ " i_list.append(i)\n",
+ " ts_list.append(ts)\n",
+ " label_list.append(label)\n",
+ " idx_list.append(idx)\n",
+ " feat_l.append(feat)\n",
+ "\n",
+ " return pd.DataFrame({\n",
+ " 'u': u_list,\n",
+ " 'i': i_list,\n",
+ " 'ts': ts_list,\n",
+ " 'label': label_list,\n",
+ " 'idx': idx_list\n",
+ " }), np.array(feat_l)\n",
+ "\n",
+ "\n",
+ "def reindex(df: pd.DataFrame, bipartite: bool = True):\n",
+ " new_df = df.copy()\n",
+ " if bipartite:\n",
+ " upper_u = df.u.max() + 1\n",
+ " new_i = df.i + upper_u\n",
+ " new_df.i = new_i\n",
+ " new_df.u += 1\n",
+ " new_df.i += 1\n",
+ " new_df.idx += 1\n",
+ " return new_df"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\n",
+ "class BipartiteTemporalPercolation:\n",
+ " def __init__(self, temporal_graph):\n",
+ " self.temporal_graph = temporal_graph\n",
+ "\n",
+ " def create_event_graph(self, delta_t):\n",
+ " event_edge_index = pp.algorithms.temporal.lift_order_temporal(self.temporal_graph, delta=delta_t)\n",
+ " event_graph = pp.Graph.from_edge_index(event_edge_index)\n",
+ "\n",
+ " if event_edge_index is None or len(event_edge_index) == 0:\n",
+ " print(f\"[DEBUG] No edges in event_edge_index for δ={delta_t}\")\n",
+ " else:\n",
+ " print(f\"[DEBUG] Number of edges in event_edge_index for δ={delta_t}: {len(event_edge_index)}\")\n",
+ "\n",
+ " return event_graph\n",
+ "\n",
+ " def percolation_analysis(self, delta_t_values):\n",
+ " \"\"\"\n",
+ " Perform temporal percolation analysis over a range of delta_t values.\n",
+ " \"\"\"\n",
+ " largest_components = {}\n",
+ "\n",
+ " for delta_t in delta_t_values:\n",
+ " print(f\"Processing δ={delta_t}...\")\n",
+ " try:\n",
+ " event_graph = self.create_event_graph(delta_t)\n",
+ " num_components, labels = pp.algorithms.components.connected_components(event_graph)\n",
+ "\n",
+ " print(f\"Number of components: {num_components}\")\n",
+ " print(f\"Labels: {labels}\")\n",
+ "\n",
+ " uniques, component_sizes = torch.unique(torch.tensor(labels), return_counts=True)\n",
+ " print(component_sizes)\n",
+ " print(uniques)\n",
+ "\n",
+ " if component_sizes.numel() == 0: # Check if component_sizes is empty\n",
+ " print(f\"No connected components found for δ={delta_t}.\")\n",
+ " largest_component_size = 0\n",
+ " total_components = 0\n",
+ " average_component_size = 0\n",
+ " else:\n",
+ " largest_component_size = component_sizes.max().item()\n",
+ " total_components = len(component_sizes)\n",
+ " average_component_size = component_sizes.float().mean().item()\n",
+ "\n",
+ " largest_components[delta_t] = {\n",
+ " \"largest_component_size\": largest_component_size,\n",
+ " \"total_components\": total_components,\n",
+ " \"average_component_size\": average_component_size,\n",
+ " }\n",
+ "\n",
+ " except Exception as e:\n",
+ " print(f\"Error at δ={delta_t}: {e}\")\n",
+ " largest_components[delta_t] = {\n",
+ " \"largest_component_size\": 0,\n",
+ " \"total_components\": 0,\n",
+ " \"average_component_size\": 0,\n",
+ " }\n",
+ "\n",
+ " return largest_components\n",
+ "\n",
+ " def find_critical_threshold(self, results):\n",
+ " \"\"\"\n",
+ " Identify the critical delta_t where the largest connected component (LCC) rapidly grows.\n",
+ " \"\"\"\n",
+ " # Extract the \"largest_component_size\" from the results\n",
+ " largest_component_sizes = [result[\"largest_component_size\"] for result in results.values()]\n",
+ " delta_t_values = list(results.keys())\n",
+ "\n",
+ " # Ensure there are enough data points\n",
+ " if len(largest_component_sizes) < 2:\n",
+ " raise ValueError(\"Not enough data points to determine the critical threshold.\")\n",
+ "\n",
+ " # Calculate the relative growth of LCC size\n",
+ " lcc_differences = np.diff(largest_component_sizes) / np.array(largest_component_sizes[:-1])\n",
+ "\n",
+ " # Find the index of the largest relative growth\n",
+ " critical_index = np.argmax(lcc_differences)\n",
+ "\n",
+ " # Return the delta_t corresponding to the largest jump\n",
+ " return delta_t_values[critical_index + 1]\n",
+ "\n",
+ " def compute_shortest_path_lengths(self, delta_t):\n",
+ " \"\"\"\n",
+ " Compute the average shortest path length for a specific delta_t.\n",
+ " \"\"\"\n",
+ " dist_matrix, _ = pp.algorithms.temporal.temporal_shortest_paths(self.temporal_graph, delta=delta_t)\n",
+ " dist_matrix[dist_matrix == float('inf')] = np.nan # Replace infinity with NaN for unreachable nodes\n",
+ " avg_path_length = np.nanmean(dist_matrix)\n",
+ " return avg_path_length\n",
+ "\n",
+ " def compute_clustering_coefficient(self, delta_t):\n",
+ " \"\"\"\n",
+ " Compute the clustering coefficient for a specific delta_t.\n",
+ " \"\"\"\n",
+ " # Use the temporal graph directly and convert it to a static graph\n",
+ " static_graph = self.temporal_graph.to_static_graph(weighted=False)\n",
+ "\n",
+ " # Convert static graph to NetworkX format\n",
+ " edge_index = static_graph.data.edge_index.cpu().detach().numpy()\n",
+ " nx_graph = nx.Graph()\n",
+ " nx_graph.add_edges_from(edge_index.T)\n",
+ "\n",
+ " # Compute the clustering coefficient\n",
+ " clustering_coefficient = nx.average_clustering(nx_graph)\n",
+ " return clustering_coefficient\n",
+ "\n",
+ " def plot_percolation_results(self, results):\n",
+ " \"\"\"\n",
+ " Plot the largest component size as a function of delta_t.\n",
+ " \"\"\"\n",
+ " delta_t_values = list(results.keys())\n",
+ " largest_component_sizes = list(results.values())\n",
+ "\n",
+ " plt.figure(figsize=(10, 6))\n",
+ " plt.plot(delta_t_values, largest_component_sizes, marker='o', linestyle='-', color='b')\n",
+ " plt.xlabel(\"δt (time threshold)\")\n",
+ " plt.ylabel(\"Largest Component Size\")\n",
+ " plt.title(\"Temporal Percolation Analysis: Largest Component vs δt\")\n",
+ " plt.grid(True)\n",
+ " plt.show()\n",
+ "\n",
+ " def plot_degree_distribution(self, delta_t, title):\n",
+ " static_graph = self.temporal_graph.to_static_graph(weighted=False)\n",
+ " edge_index = static_graph.data.edge_index.cpu().detach().numpy()\n",
+ " nx_graph = nx.Graph()\n",
+ " nx_graph.add_edges_from(edge_index.T)\n",
+ " if not nx.is_connected(nx_graph):\n",
+ " largest_cc = max(nx.connected_components(nx_graph), key=len)\n",
+ " nx_graph = nx_graph.subgraph(largest_cc).copy()\n",
+ " if not nx.algorithms.bipartite.is_bipartite(nx_graph):\n",
+ " raise ValueError(\"The graph is not bipartite.\")\n",
+ " node_sets = nx.algorithms.bipartite.sets(nx_graph)\n",
+ " set_a, set_b = node_sets\n",
+ " degrees_set_a = [nx_graph.degree(node) for node in set_a]\n",
+ " degrees_set_b = [nx_graph.degree(node) for node in set_b]\n",
+ " plt.figure(figsize=(8, 6))\n",
+ " plt.hist(degrees_set_a, bins=20, alpha=0.7, label=\"Set A Degrees\")\n",
+ " plt.hist(degrees_set_b, bins=20, alpha=0.7, label=\"Set B Degrees\")\n",
+ " plt.xlabel(\"Degree\")\n",
+ " plt.ylabel(\"Frequency\")\n",
+ " plt.title(title)\n",
+ " plt.legend()\n",
+ " plt.grid(True)\n",
+ " plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Number of duplicates: 0\n",
+ "Number of temporal edges: 157474\n",
+ "Temporal Graph with 9227 nodes, 18257 unique edges and 157474 events in [0.0, 2678373.0]\n",
+ "{'Edge Attributes': {}, 'Graph Attributes': {'num_nodes': \"<class 'int'>\"}, 'Node Attributes': {}}\n",
+ "Graph density: 0.0018498430756906205\n"
+ ]
+ },
+ {
+ "ename": "TypeError",
+ "evalue": "'Tensor' object is not callable",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[1;32mIn[32], line 32\u001b[0m\n\u001b[0;32m 30\u001b[0m \u001b[38;5;66;03m# Connected Components\u001b[39;00m\n\u001b[0;32m 31\u001b[0m num_components, labels \u001b[38;5;241m=\u001b[39m pp\u001b[38;5;241m.\u001b[39malgorithms\u001b[38;5;241m.\u001b[39mcomponents\u001b[38;5;241m.\u001b[39mconnected_components(temporal_graph)\n\u001b[1;32m---> 32\u001b[0m largest_component_size \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mmax\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mlabels\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcount\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43mset\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mlabels\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 33\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNumber of components: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mnum_components\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m 34\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mLargest component size: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mlargest_component_size\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n",
+ "\u001b[1;31mTypeError\u001b[0m: 'Tensor' object is not callable"
+ ]
+ }
+ ],
+ "source": [
+ "# Main Execution\n",
+ "file_path = \"reddit.csv\"\n",
+ "bipartite = True\n",
+ "\n",
+ "df, edge_feats = preprocess(file_path)\n",
+ "df = reindex(df, bipartite=bipartite)\n",
+ "\n",
+ "\n",
+ "\n",
+ "# Preprocess data\n",
+ "df, edge_feats = preprocess(file_path)\n",
+ "df = reindex(df, bipartite=bipartite)\n",
+ "\n",
+ "# Ensure all columns have consistent data types\n",
+ "df['ts'] = df['ts'].round(0).astype(int)\n",
+ "df['u'] = df['u'].astype(int)\n",
+ "df['i'] = df['i'].astype(int)\n",
+ "\n",
+ "# Optional: Check for duplicates (based on u, i, ts)\n",
+ "duplicates = df[df.duplicated(subset=['u', 'i', 'ts'], keep=False)]\n",
+ "print(f\"Number of duplicates: {len(duplicates)}\")\n",
+ "\n",
+ "# All temporal edges (default approach)\n",
+ "tedges = list(df[['u', 'i', 'ts']].itertuples(index=False, name=None))\n",
+ "temporal_graph = pp.TemporalGraph.from_edge_list(tedges)\n",
+ "print(f\"Graph created with {len(temporal_graph.edges)} unique edges and {len(tedges)} temporal events.\")\n",
+ "\n",
+ "print(temporal_graph)\n",
+ "\n",
+ "print(f\"First 10 temporal edges: {tedges[:10]}\")\n",
+ "\n",
+ "\n",
+ "\n",
+ "# Print temporal graph summary\n",
+ "print(temporal_graph)\n",
+ "\n",
+ "temporal_edges = temporal_graph.edges\n",
+ "print(f\"Number of temporal events: {len(temporal_edges)}\")\n",
+ "print(f\"First 5 temporal edges: {temporal_edges[:50]}\")\n",
+ "\n",
+ "\n",
+ "density = len(temporal_graph.edges) / (len(temporal_graph.nodes) * (len(temporal_graph.nodes) - 1))\n",
+ "print(f\"Graph density: {density}\")\n",
+ "\n",
+ "bipartite_percolation = BipartiteTemporalPercolation(temporal_graph)\n",
+ "\n",
+ "min = temporal_graph['time'].min()\n",
+ "max = temporal_graph['time'].max()\n",
+ "\n",
+ "delta_t_values = np.linspace(10000, max, 4)\n",
+ "analysis_results = bipartite_percolation.percolation_analysis(delta_t_values)\n",
+ "critical_delta_t = float(delta_t_values[np.argmax([result[\"largest_component_size\"] for result in analysis_results.values()])])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "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"
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2IAAAIjCAYAAABh3KjvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABYIElEQVR4nO3dd3xUVf7/8fckpEISiJRQQu9FgvROaEEQDB1EqWJZmjSVr64UdVmQKoJgg0VgKYKoqECkSAepAgICgkhJqCGEQAjJ+f3hI/NzTIBMNrkhw+v5eMxjd849987nzpw75O2994zNGGMEAAAAALCMW1YXAAAAAACPGoIYAAAAAFiMIAYAAAAAFiOIAQAAAIDFCGIAAAAAYDGCGAAAAABYjCAGAAAAABYjiAEAAACAxQhiAAAAAGAxghgAAEiX4sWLq3fv3lldBgBkSwQxAMhks2bNks1mU+3atbO6lIdSYmKi5s6dqyZNmigwMFBeXl4qXry4+vTpo927d2d1edne+fPnNWbMGO3fvz/N6xw8eFCdOnVSsWLF5O3trcKFC6tFixaaMWNG5hX6kDh16pS6d++uQoUKycvLS0FBQXrqqad07Ngxe5+4uDiNGTNGGzduzLpCAWR7NmOMyeoiAMCV1a9fX+fPn9fp06d1/PhxlS5dOqtLemjcunVLHTp00OrVq9WoUSO1bdtWgYGBOn36tJYuXapff/1VZ86cUZEiRbK61Gxr9+7dqlmzpubOnZums1fbtm1TaGioihYtql69eikoKEh//PGHduzYoZMnT+rEiRP2vvHx8XJzc5OHh0cm7oG1atWqpePHj2vo0KEqWrSobt26pUOHDqlNmzZq3bq1JOny5cvKly+fRo8erTFjxmRtwQCyrRxZXQAAuLJTp05p27ZtWrFihV588UUtXLhQo0ePtrSGpKQk3blzR97e3pa+blqMHDlSq1ev1tSpU/XKK684LBs9erSmTp2aNYU9wt59910FBATop59+Uu7cuR2WXbx40eG5l5eXhZVZ45dfflGjRo301ltvZXUpAFwclyYCQCZauHCh8uTJozZt2qhTp05auHChfVlCQoICAwPVp0+fFOvFxMTI29tbI0aMsLfFx8dr9OjRKl26tLy8vBQcHKxXX31V8fHxDuvabDYNHDhQCxcuVKVKleTl5aXVq1dLkiZNmqR69erpsccek4+Pj6pXr64vvvgixevfunVLgwcPVt68eeXn56d27drp3LlzstlsKc4AnDt3Tn379lWBAgXk5eWlSpUq6bPPPnvge3P27FnNmTNHLVq0SBHCJMnd3V0jRoxwOBu2b98+Pfnkk/L391euXLnUrFkz7dixw2G9efPmyWazacuWLRo8eLDy5cun3Llz68UXX9SdO3cUHR2tnj17Kk+ePMqTJ49effVV/fXikNOnT8tms2nSpEmaOnWqihUrJh8fHzVu3FiHDh1KUef69evVsGFD5cyZU7lz59bTTz+tI0eOOPQZM2aMbDabTpw4od69eyt37twKCAhQnz59FBcXl2KbCxYsUPXq1eXj46PAwEB169ZNf/zxh0OfJk2aqHLlyvrll18UGhoqX19fFS5cWBMnTrT32bhxo2rWrClJ6tOnj2w2m2w2m+bNm3fPz+XkyZOqVKlSihAmSfnz53d4/vd7xJK3n9rj9OnT9n5Hjx5Vp06dFBgYKG9vb9WoUUNff/31PWuSnD9eZsyYoUqVKsnX11d58uRRjRo1tGjRovu+hiS98sor+v7771WpUiWNHDlSGzduVGJion356dOnlS9fPknS2LFj7fvHmTEATjMAgExTvnx5069fP2OMMZs2bTKSzK5du+zL+/bta3Lnzm3i4+Md1vvPf/5jJJmffvrJGGNMYmKiadmypfH19TWvvPKKmTNnjhk4cKDJkSOHefrppx3WlWQqVKhg8uXLZ8aOHWtmzpxp9u3bZ4wxpkiRIuYf//iH+eCDD8yUKVNMrVq1jCSzatUqh2106dLFSDLPPfecmTlzpunSpYupWrWqkWRGjx5t7xcZGWmKFCligoODzbhx48yHH35o2rVrZySZqVOn3ve9+eijj4wkM3/+/DS9l4cOHTI5c+Y0BQsWNG+//bb597//bUqUKGG8vLzMjh077P3mzp1rJJmQkBDTqlUrM3PmTPPcc88ZSebVV181DRo0MM8884yZNWuWeeqpp4wk85///Me+/qlTp4wkU6VKFVO8eHEzYcIEM3bsWBMYGGjy5ctnIiMj7X0jIiJMjhw5TNmyZc3EiRPN2LFjTd68eU2ePHnMqVOn7P1Gjx5tJJlq1aqZDh06mFmzZpnnn3/eXtNfvfPOO8Zms5muXbuaWbNm2bdZvHhxc+3aNXu/xo0bm0KFCpng4GAzZMgQM2vWLNO0aVMjyXz33Xf2z2fcuHFGknnhhRfM559/bj7//HNz8uTJe77PLVu2NH5+fubgwYMP/EyKFStmevXqZX+evP2/PooVK2Z8fHzMpUuX7J9jQECAqVixopkwYYL54IMPTKNGjYzNZjMrVqy47+ul9XhJHludOnUyc+bMMdOnTzf9+vUzgwcPfuA+rVu3zlSvXt18/fXXZtKkSaZixYrmiSeeMMePHzfGGBMbG2s+/PBDI8m0b9/evp8HDhx44LYB4K8IYgCQSXbv3m0kmYiICGOMMUlJSaZIkSJmyJAh9j5r1qwxksw333zjsG7r1q1NyZIl7c8///xz4+bmZjZv3uzQb/bs2UaS2bp1q71NknFzczOHDx9OUVNcXJzD8zt37pjKlSubpk2b2tv27NljJJlXXnnFoW/v3r1TBLF+/fqZggULmsuXLzv07datmwkICEjxen81dOhQI8keEh8kPDzceHp6OoSI8+fPGz8/P9OoUSN7W3IQCwsLM0lJSfb2unXrGpvNZl566SV72927d02RIkVM48aN7W3JQczHx8ecPXvW3r5z504jyQwdOtTeFhISYvLnz2+uXLlibztw4IBxc3MzPXv2tLclB7G+ffs67FP79u3NY489Zn9++vRp4+7ubt59912HfgcPHjQ5cuRwaG/cuHGKIBsfH2+CgoJMx44d7W0//fSTkWTmzp1r0mLt2rXG3d3duLu7m7p165pXX33VrFmzxty5cydF378Hsb+bOHFiihqbNWtmqlSpYm7fvm1vS0pKMvXq1TNlypS5b21pPV6efvppU6lSpQftagqnTp0yuXLlMtu3b7e3xcbGmpCQEFOpUiWTmJhojDHm0qVLKY4FAHAWlyYCQCZZuHChChQooNDQUEl/XrbVtWtXLV682H6pU9OmTZU3b14tWbLEvt61a9cUERGhrl272tuWLVumChUqqHz58rp8+bL90bRpU0nShg0bHF67cePGqlixYoqafHx8HF7n+vXratiwofbu3WtvT76M8R//+IfDuoMGDXJ4bozR8uXL1bZtWxljHOoKCwvT9evXHbb7dzExMZIkPz+/e/ZJlpiYqLVr1yo8PFwlS5a0txcsWFDPPPOMtmzZYt9esn79+slms9mf165dW8YY9evXz97m7u6uGjVq6LfffkvxmuHh4SpcuLD9ea1atVS7dm199913kqQLFy5o//796t27twIDA+39Hn/8cbVo0cLe769eeuklh+cNGzbUlStX7LWvWLFCSUlJ6tKli8P7GRQUpDJlyqT4nHPlyqVnn33W/tzT01O1atVKdX/SqkWLFtq+fbvatWunAwcOaOLEiQoLC1PhwoUfePngX23YsEGjRo3SoEGD9Nxzz0mSrl69qvXr16tLly66ceOGff+uXLmisLAwHT9+XOfOnbvnNtN6vOTOnVtnz57VTz/95NS+T5o0Sfnz51edOnXsbTlz5tTrr7+uw4cPa+vWrU5tDwDuhyAGAJkgMTFRixcvVmhoqE6dOqUTJ07oxIkTql27tqKiorRu3TpJUo4cOdSxY0d99dVX9nu9VqxYoYSEBIc/LI8fP67Dhw8rX758Do+yZctKSjmJQokSJVKta9WqVapTp468vb0VGBiofPny6cMPP9T169ftfX7//Xe5ubml2MbfZ3u8dOmSoqOj9dFHH6WoK/k+nr/X9Vf+/v6SpBs3btz7jfzLa8XFxalcuXIpllWoUEFJSUkp7qEqWrSow/OAgABJUnBwcIr2a9eupdhumTJlUrSVLVvWfq/T77//Lkn3rOny5cu6efPmfWvKkyePJNlf//jx4zLGqEyZMine0yNHjqR4P4sUKeIQNpO3mdr+OKNmzZpasWKFrl27pl27dmnUqFG6ceOGOnXqpF9++eWB6589e1Zdu3ZV/fr1NWXKFHv7iRMnZIzRP//5zxT7lzyJzf3GTFqPl9dee025cuVSrVq1VKZMGQ0YMCBNIWrz5s0qVqxYivYKFSpIUpr2HQDSilkTASATrF+/XhcuXNDixYu1ePHiFMsXLlyoli1bSpK6deumOXPm6Pvvv1d4eLiWLl2q8uXLq2rVqvb+SUlJqlKlisMftX/193Dx1zNfyTZv3qx27dqpUaNGmjVrlgoWLCgPDw/NnTs3TZMY/F1SUpIk6dlnn1WvXr1S7fP444/fc/3y5ctL+vM3q0JCQpx+/Qdxd3dPc7ux6Jdc7lVT8usnJSXJZrPp+++/T7Vvrly5nNre/8rT01M1a9ZUzZo1VbZsWfXp00fLli2778yfd+7cUadOneTl5aWlS5cqR47//6dG8pgZMWKEwsLCUl3/QT/vkJbjpUKFCjp27JhWrVql1atXa/ny5Zo1a5beeustjR079p7bvn37dorJbyTZz2DfuXPnvrUBgDMIYgCQCRYuXKj8+fNr5syZKZatWLFCX375pWbPni0fHx81atRIBQsW1JIlS9SgQQOtX79eb7zxhsM6pUqV0oEDB9SsWbMUZ0DSavny5fL29taaNWscph2fO3euQ79ixYopKSlJp06dcjgr9Nffj5KkfPnyyc/PT4mJiWrevLnT9Tz55JNyd3fXggUL7Jeu3Uu+fPnk6+vr8KO6yY4ePSo3N7cUYfR/dfz48RRtv/76q4oXLy5J9jMn96opb968ypkzp1OvWapUKRljVKJECfvZzv9VesfL39WoUUPSn5dk3s/gwYO1f/9+bdq0SQUKFHBYlnxZqYeHR7rGjKQ0HS/Sn5cUdu3aVV27dtWdO3fUoUMHvfvuuxo1atQ9f8ohODhYP//8sxITEx1CbvIsmMkzeGbUewrg0caliQCQwW7duqUVK1boqaeeUqdOnVI8Bg4cqBs3btjvt3Fzc1OnTp30zTff6PPPP9fdu3cdLrOSpC5duujcuXP6+OOPU329v18Clxp3d3fZbLYUU3GvXLnSoV/ymYpZs2Y5tM+YMSPF9jp27Kjly5enOq37pUuX7ltPcHCw+vfvr7Vr16bYtvTn2ZPJkyfr7Nmzcnd3V8uWLfXVV185TIMeFRWlRYsWqUGDBvZLHTPKypUrHe5X2rVrl3bu3Kknn3xS0p/3p4WEhOg///mPoqOj7f0OHTqktWvX2n/81xkdOnSQu7u7xo4dm+KsljFGV65ccXqbyWHwrzXez4YNG1I9o5Z8z1tql2Immzt3rubMmaOZM2eqVq1aKZbnz59fTZo00Zw5c1INdA8aM1Lajpe/v0+enp6qWLGijDFKSEi457Zbt26tS5cuacGCBfa2hIQEvf/++/Lx8VGTJk0kSb6+vpLS/p4CQGo4IwYAGezrr7/WjRs31K5du1SX16lTR/ny5dPChQvtf0B27dpVM2bM0OjRo1WlShX7PSnJnnvuOS1dulQvvfSSNmzYoPr16ysxMVFHjx7V0qVLtWbNGvsZi3tp06aNpkyZolatWumZZ57RxYsXNXPmTJUuXVo///yzvV/16tXVsWNHTZs2TVeuXFGdOnX0448/6tdff5XkeDbg3//+tzZs2KDatWurf//+qlixoq5evaq9e/fqhx9+0NWrV+9b0+TJk3Xy5EkNHjzYHl7z5MmjM2fOaNmyZTp69Ki6desmSXrnnXcUERGhBg0a6B//+Idy5MihOXPmKD4+3uG3szJK6dKl1aBBA7388suKj4/XtGnT9Nhjj+nVV1+193nvvff05JNPqm7duurXr59u3bqlGTNmKCAgIF2/K1WqVCm98847GjVqlE6fPq3w8HD5+fnp1KlT+vLLL/XCCy84/FZWWreZO3duzZ49W35+fsqZM6dq1659z/sIBw0apLi4OLVv317ly5fXnTt3tG3bNi1ZskTFixdP9Xe8JOny5cv6xz/+oYoVK8rLy8shzEhS+/btlTNnTs2cOVMNGjRQlSpV1L9/f5UsWVJRUVHavn27zp49qwMHDjxwnx50vLRs2VJBQUGqX7++ChQooCNHjuiDDz5QmzZt7js5zIsvvqiPP/5Y/fv314EDB1SiRAktXbpUO3fu1IQJE+z39Pn4+KhixYpasmSJypYtq8DAQFWuXFmVK1d+YO0AYJclczUCgAtr27at8fb2Njdv3rxnn969exsPDw/7tO9JSUkmODjYSDLvvPNOquvcuXPHTJgwwVSqVMl4eXmZPHnymOrVq5uxY8ea69ev2/tJMgMGDEh1G59++qkpU6aM8fLyMuXLlzdz5861T63+Vzdv3jQDBgwwgYGBJleuXCY8PNwcO3bMSDL//ve/HfpGRUWZAQMGmODgYOPh4WGCgoJMs2bNzEcffZSm9+vu3bvmk08+MQ0bNjQBAQHGw8PDFCtWzPTp0yfF1PZ79+41YWFhJleuXMbX19eEhoaabdu2OfRJnr4++TelkiXvZ/LvWSXr1auXyZkzp/158vT17733npk8ebIJDg42Xl5epmHDhqn+VtQPP/xg6tevb3x8fIy/v79p27at+eWXX9L02sm1/vU3x4wxZvny5aZBgwYmZ86cJmfOnKZ8+fJmwIAB5tixY/Y+jRs3TnWK9l69eplixYo5tH311VemYsWKJkeOHA+cyv777783ffv2NeXLlze5cuUynp6epnTp0mbQoEEmKirKoe9fp69Pft/u9fjrPp48edL07NnTBAUFGQ8PD1O4cGHz1FNPmS+++OKedf3Vg46XOXPmmEaNGpnHHnvMeHl5mVKlSpmRI0c6HCf3EhUVZfr06WPy5s1rPD09TaVKlczHH3+cot+2bdtM9erVjaenJ1PZA0gXmzEW3aEMAMjW9u/fr2rVqmnBggXq0aNHVpeTaU6fPq0SJUrovffec/rsEwAAacU9YgCAFG7dupWibdq0aXJzc1OjRo2yoCIAAFwL94gBAFKYOHGi9uzZo9DQUOXIkUPff/+9vv/+e73wwgsZPjshAACPIoIYACCFevXqKSIiQm+//bZiY2NVtGhRjRkzJtVpwgEAgPO4RwwAAAAALMY9YgAAAABgMYIYAAAAAFiMe8QyQFJSks6fPy8/Pz+HHzoFAAAA8GgxxujGjRsqVKiQ3Nzufd6LIJYBzp8/zyxiAAAAAOz++OMPFSlS5J7LCWIZwM/PT9Kfb7a/v38WV4OMlpCQoLVr16ply5by8PDI6nKQTTBukB6MG6QH4wbpxdjJHDExMQoODrZnhHshiGWA5MsR/f39CWIuKCEhQb6+vvL39+dLCmnGuEF6MG6QHowbpBdjJ3M96JYlJusAAAAAAIsRxAAAAADAYgQxAAAAALAYQQwAAAAALEYQAwAAAACLEcQAAAAAwGIEMQAAAACwGEEMAAAAACxGEAMAAAAAixHEAAAAAMBiBDEAAAAAsBhBDAAAAAAsRhADAAAAAIsRxAAAAADAYgQxAAAAALAYQQwAAAAALEYQAwAAAACLEcQAAAAAwGIEMQAAAACwGEEMAAAAACxGEAMAAAAAixHEAAAAAMBiBDEAAAAAsBhBDAAAAAAsRhADAAAAAIsRxAAAAADAYgQxAAAAALAYQQwAAAAALEYQAwAAAACLEcQAAAAAwGIEMQAAAACwGEEMAAAAACxGEAMAAAAAixHEAAAAAMBiBDEAAAAAsBhBDAAAAAAsRhADAAAAAIsRxAAAAADAYgQxAAAAALAYQQwAAAAALEYQAwAAAACLEcQAAAAAwGIEMQAAAACwGEEMAAAAACxGEAMAAAAAixHEAAAAAMBiBDEAAAAAsBhBDAAAAAAsRhADAAAAAIsRxAAAAADAYgQxAAAAALAYQQwAAAAALEYQAwAAAACLEcQAAAAAwGIEMQAAAACwGEEMAAAAACyW7YLYzJkzVbx4cXl7e6t27dratWvXffsvW7ZM5cuXl7e3t6pUqaLvvvvunn1feukl2Ww2TZs2LYOrBgAAAID/L1sFsSVLlmjYsGEaPXq09u7dq6pVqyosLEwXL15Mtf+2bdvUvXt39evXT/v27VN4eLjCw8N16NChFH2//PJL7dixQ4UKFcrs3QAAAADwiMtWQWzKlCnq37+/+vTpo4oVK2r27Nny9fXVZ599lmr/6dOnq1WrVho5cqQqVKigt99+W0888YQ++OADh37nzp3ToEGDtHDhQnl4eFixKwAAAAAeYTmyuoC0unPnjvbs2aNRo0bZ29zc3NS8eXNt37491XW2b9+uYcOGObSFhYVp5cqV9udJSUl67rnnNHLkSFWqVClNtcTHxys+Pt7+PCYmRpKUkJCghISEtO4Ssonkz5TPFs5g3CA9GDdID8YN0ouxkznS+n5mmyB2+fJlJSYmqkCBAg7tBQoU0NGjR1NdJzIyMtX+kZGR9ucTJkxQjhw5NHjw4DTXMn78eI0dOzZF+9q1a+Xr65vm7SB7iYiIyOoSkA0xbpAejBukB+MG6cXYyVhxcXFp6pdtglhm2LNnj6ZPn669e/fKZrOleb1Ro0Y5nGmLiYlRcHCwWrZsKX9//8woFVkoISFBERERatGiBZeuIs0YN0gPxg3Sg3GD9GLsZI7kq+UeJNsEsbx588rd3V1RUVEO7VFRUQoKCkp1naCgoPv237x5sy5evKiiRYvalycmJmr48OGaNm2aTp8+nep2vby85OXllaLdw8ODQezC+HyRHowbpAfjBunBuEF6MXYyVlrfy2wzWYenp6eqV6+udevW2duSkpK0bt061a1bN9V16tat69Bf+vPUa3L/5557Tj///LP2799vfxQqVEgjR47UmjVrMm9nAAAAADzSss0ZMUkaNmyYevXqpRo1aqhWrVqaNm2abt68qT59+kiSevbsqcKFC2v8+PGSpCFDhqhx48aaPHmy2rRpo8WLF2v37t366KOPJEmPPfaYHnvsMYfX8PDwUFBQkMqVK2ftzgEAAAB4ZGSrINa1a1ddunRJb731liIjIxUSEqLVq1fbJ+Q4c+aM3Nz+/0m+evXqadGiRXrzzTf1f//3fypTpoxWrlypypUrZ9UuAAAAAED2CmKSNHDgQA0cODDVZRs3bkzR1rlzZ3Xu3DnN27/XfWEAAAAAkFGyzT1iAAAAAOAqCGIAAAAAYDGCGAAAAABYjCAGAAAAABYjiAEAAACAxQhiAAAAAGAxghgAAAAAWIwgBgAAAAAWI4gBAAAAgMUIYgAAAABgMYIYAAAAAFiMIAYAAAAAFiOIAQAAAIDFCGIAAAAAYDGCGAAAAABYjCAGAAAAABYjiAEAAACAxQhiAAAAAGAxghgAAAAAWIwgBgAAAAAWI4gBAAAAgMUIYgAAAABgMYIYAAAAAFiMIAYAAAAAFiOIAQAAAIDFCGIAAAAAYDGCGAAAAABYjCAGAAAAABYjiAEAAACAxQhiAAAAAGAxghgAAAAAWIwgBgAAAAAWI4gBAAAAgMUIYgAAAABgMYIYAAAAAFiMIAYAAAAAFiOIAQAAAIDFCGIAAAAAYDGCGAAAAABYjCAGAAAAABYjiAEAAACAxQhiAAAAAGAxghgAAAAAWIwgBgAAAAAWI4gBAAAAgMUIYgAAAABgMYIYAAAAAFiMIAYAAAAAFiOIAQAAAIDFCGIAAAAAYDGCGAAAAABYjCAGAAAAABYjiAEAAACAxQhiAAAAAGAxghgAAAAAWIwgBgAAAAAWI4gBAAAAgMUIYgAAAABgMYIYAAAAAFiMIAYAAAAAFiOIAQAAAIDFCGIAAAAAYDGCGAAAAABYjCAGAAAAABYjiAEAAACAxQhiAAAAAGAxghgAAAAAWIwgBgAAAAAWI4gBAAAAgMUIYgAAAABgMYIYAAAAAFiMIAYAAAAAFiOIAQAAAIDFsl0QmzlzpooXLy5vb2/Vrl1bu3btum//ZcuWqXz58vL29laVKlX03Xff2ZclJCTotddeU5UqVZQzZ04VKlRIPXv21Pnz5zN7NwAAAAA8wrJVEFuyZImGDRum0aNHa+/evapatarCwsJ08eLFVPtv27ZN3bt3V79+/bRv3z6Fh4crPDxchw4dkiTFxcVp7969+uc//6m9e/dqxYoVOnbsmNq1a2flbgEAAAB4xKQriN29e1c//PCD5syZoxs3bkiSzp8/r9jY2Awt7u+mTJmi/v37q0+fPqpYsaJmz54tX19fffbZZ6n2nz59ulq1aqWRI0eqQoUKevvtt/XEE0/ogw8+kCQFBAQoIiJCXbp0Ubly5VSnTh198MEH2rNnj86cOZOp+wIAAADg0ZXD2RV+//13tWrVSmfOnFF8fLxatGghPz8/TZgwQfHx8Zo9e3Zm1Kk7d+5oz549GjVqlL3Nzc1NzZs31/bt21NdZ/v27Ro2bJhDW1hYmFauXHnP17l+/bpsNpty5859zz7x8fGKj4+3P4+JiZH056WOCQkJadgbZCfJnymfLZzBuEF6MG6QHowbpBdjJ3Ok9f10OogNGTJENWrU0IEDB/TYY4/Z29u3b6/+/fs7u7k0u3z5shITE1WgQAGH9gIFCujo0aOprhMZGZlq/8jIyFT73759W6+99pq6d+8uf3//e9Yyfvx4jR07NkX72rVr5evr+6BdQTYVERGR1SUgG2LcID0YN0gPxg3Si7GTseLi4tLUz+kgtnnzZm3btk2enp4O7cWLF9e5c+ec3dxDIyEhQV26dJExRh9++OF9+44aNcrhTFtMTIyCg4PVsmXL+wY4ZE8JCQmKiIhQixYt5OHhkdXlIJtg3CA9GDdID8YN0ouxkzmSr5Z7EKeDWFJSkhITE1O0nz17Vn5+fs5uLs3y5s0rd3d3RUVFObRHRUUpKCgo1XWCgoLS1D85hP3+++9av379A8OUl5eXvLy8UrR7eHgwiF0Yny/Sg3GD9GDcID0YN0gvxk7GSut76fRkHS1bttS0adPsz202m2JjYzV69Gi1bt3a2c2lmaenp6pXr65169bZ25KSkrRu3TrVrVs31XXq1q3r0F/689TrX/snh7Djx4/rhx9+cLjcEgAAAAAyg9NnxCZPnqywsDBVrFhRt2/f1jPPPKPjx48rb968+u9//5sZNdoNGzZMvXr1Uo0aNVSrVi1NmzZNN2/eVJ8+fSRJPXv2VOHChTV+/HhJf97P1rhxY02ePFlt2rTR4sWLtXv3bn300UeS/gxhnTp10t69e7Vq1SolJiba7x8LDAxMcfklAAAAAGQEp4NYkSJFdODAAS1ZskQHDhxQbGys+vXrpx49esjHxyczarTr2rWrLl26pLfeekuRkZEKCQnR6tWr7RNynDlzRm5u//8kX7169bRo0SK9+eab+r//+z+VKVNGK1euVOXKlSVJ586d09dffy1JCgkJcXitDRs2qEmTJpm6PwAAAAAeTU4HMUnKkSOHevTooR49emR0PQ80cOBADRw4MNVlGzduTNHWuXNnde7cOdX+xYsXlzEmI8sDAAAAgAdy+h4xd3d3hYaG6urVqw7tUVFRcnd3z7DCAAAAAMBVOR3EjDGKj49XjRo1dPjw4RTLAAAAAAD353QQs9lsWr58udq2bau6devqq6++clgGAAAAALi/dJ0Rc3d31/Tp0zVp0iR17dpV77zzDmfDAAAAACCN0jVZR7IXXnhBZcqUUefOnbVp06aMqgkAAAAAXJrTZ8SKFSvmMClHaGioduzYoT/++CNDCwMAAAAAV+X0GbFTp06laCtdurT27dunqKioDCkKAAAAAFyZ02fE7sXb21vFihXLqM0BAAAAgMtK0xmxwMBA/frrr8qbN6/y5Mlz39kR//77YgAAAAAAR2kKYlOnTpWfn58kadq0aZlZDwAAAAC4vDQFsV69eqX6/wEAAAAAzkvzZB13795VYmKivLy87G1RUVGaPXu2bt68qXbt2qlBgwaZUiQAAAAAuJI0B7H+/fvL09NTc+bMkSTduHFDNWvW1O3bt1WwYEFNnTpVX331lVq3bp1pxQIAAACAK0jzrIlbt25Vx44d7c/nz5+vxMREHT9+XAcOHNCwYcP03nvvZUqRAAAAAOBK0hzEzp07pzJlytifr1u3Th07dlRAQICkP+8dO3z4cMZXCAAAAAAuJs1BzNvbW7du3bI/37Fjh2rXru2wPDY2NmOrAwAAAAAXlOYgFhISos8//1yStHnzZkVFRalp06b25SdPnlShQoUyvkIAAAAAcDFpnqzjrbfe0pNPPqmlS5fqwoUL6t27twoWLGhf/uWXX6p+/fqZUiQAAAAAuJI0B7HGjRtrz549Wrt2rYKCgtS5c2eH5SEhIapVq1aGFwgAAAAAribNQUySKlSooAoVKqS67IUXXsiQggAAAADA1aX5HjEAAAAAQMYgiAEAAACAxQhiAAAAAGAxghgAAAAAWMzpIFayZElduXIlRXt0dLRKliyZIUUBAAAAgCtzOoidPn1aiYmJKdrj4+N17ty5DCkKAAAAAFxZmqev//rrr+3/f82aNQoICLA/T0xM1Lp161S8ePEMLQ4AAAAAXFGag1h4eLgkyWazqVevXg7LPDw8VLx4cU2ePDlDiwMAAAAAV5TmIJaUlCRJKlGihH766SflzZs304oCAAAAAFeW5iCW7NSpU5lRBwAAAAA8MpwOYpK0bt06rVu3ThcvXrSfKUv22WefZUhhAAAAAOCqnA5iY8eO1bhx41SjRg0VLFhQNpstM+oCAAAAAJfldBCbPXu25s2bp+eeey4z6gEAAAAAl+f074jduXNH9erVy4xaAAAAAOCR4HQQe/7557Vo0aLMqAUAAAAAHglOX5p4+/ZtffTRR/rhhx/0+OOPy8PDw2H5lClTMqw4AAAAAHBFTgexn3/+WSEhIZKkQ4cOOSxj4g4AAAAAeDCng9iGDRsyow4AAAAAeGQ4fY9YshMnTmjNmjW6deuWJMkYk2FFAQAAAIArczqIXblyRc2aNVPZsmXVunVrXbhwQZLUr18/DR8+PMMLBAAAAABX43QQGzp0qDw8PHTmzBn5+vra27t27arVq1dnaHEAAAAA4Iqcvkds7dq1WrNmjYoUKeLQXqZMGf3+++8ZVhgAAAAAuCqnz4jdvHnT4UxYsqtXr8rLyytDigIAAAAAV+Z0EGvYsKHmz59vf26z2ZSUlKSJEycqNDQ0Q4sDAAAAAFfk9KWJEydOVLNmzbR7927duXNHr776qg4fPqyrV69q69atmVEjAAAAALgUp8+IVa5cWb/++qsaNGigp59+Wjdv3lSHDh20b98+lSpVKjNqBAAAAACX4vQZMUkKCAjQG2+8kdG1AAAAAMAjIV1BLDo6Wrt27dLFixeVlJTksKxnz54ZUhgAAAAAuCqng9g333yjHj16KDY2Vv7+/rLZbPZlNpuNIAYAAAAAD+D0PWLDhw9X3759FRsbq+joaF27ds3+uHr1ambUCAAAAAAuxekgdu7cOQ0ePDjV3xIDAAAAADyY00EsLCxMu3fvzoxaAAAAAOCR4PQ9Ym3atNHIkSP1yy+/qEqVKvLw8HBY3q5duwwrDgAAAABckdNBrH///pKkcePGpVhms9mUmJj4v1cFAAAAAC7M6SD29+nqAQAAAADOcfoeMQAAAADA/yZdQezHH39U27ZtVbp0aZUuXVrt2rXT5s2bM7o2AAAAAHBJTgexBQsWqHnz5vL19dXgwYM1ePBg+fj4qFmzZlq0aFFm1AgAAAAALsXpe8TeffddTZw4UUOHDrW3DR48WFOmTNHbb7+tZ555JkMLBAAAAABX4/QZsd9++01t27ZN0d6uXTudOnUqQ4oCAAAAAFfmdBALDg7WunXrUrT/8MMPCg4OzpCiAAAAAMCVOX1p4vDhwzV48GDt379f9erVkyRt3bpV8+bN0/Tp0zO8QAAAAABwNU4HsZdffllBQUGaPHmyli5dKkmqUKGClixZoqeffjrDCwQAAAAAV+N0EJOk9u3bq3379hldCwAAAAA8EtIVxCRp9+7dOnLkiCSpYsWKql69eoYVBQAAAACuzOkgdvbsWXXv3l1bt25V7ty5JUnR0dGqV6+eFi9erCJFimR0jQAAAADgUpyeNfH5559XQkKCjhw5oqtXr+rq1as6cuSIkpKS9Pzzz2dGjQAAAADgUpw+I/bjjz9q27ZtKleunL2tXLlymjFjhho2bJihxQEAAACAK0rX74glJCSkaE9MTFShQoUypCgAAAAAcGVOB7H33ntPgwYN0u7du+1tu3fv1pAhQzRp0qQMLQ4AAAAAXJHTlyb27t1bcXFxql27tnLk+HP1u3fvKkeOHOrbt6/69u1r73v16tWMqxQAAAAAXITTQWzatGmZUAYAAAAAPDqcDmK9evXKjDqQARKTErX5zGZduHFBBf0KqmHRhnJ3c8/qsgD8Dccq8PDjOAWyh+x8rKb7B50vXryoixcvKikpyaH98ccf/5+Lup+ZM2fqvffeU2RkpKpWraoZM2aoVq1a9+y/bNky/fOf/9Tp06dVpkwZTZgwQa1bt7YvN8Zo9OjR+vjjjxUdHa369evrww8/VJkyZTJ1PzLaiiMrNGT1EJ2NOWtvK+JfRNNbTVeHCh2ysDIAf8WxCjz8OE6B7CG7H6tOT9axZ88eVa5cWQULFtTjjz+ukJAQ+6NatWqZUaPdkiVLNGzYMI0ePVp79+5V1apVFRYWposXL6baf9u2berevbv69eunffv2KTw8XOHh4Tp06JC9z8SJE/X+++9r9uzZ2rlzp3LmzKmwsDDdvn07U/clI604skKdlnZyGISSdC7mnDot7aQVR1ZkUWUA/opjFXj4cZwC2YMrHKs2Y4xxZoWqVauqVKlSeu2111SgQAHZbDaH5cWKFcvQAv+qdu3aqlmzpj744ANJUlJSkoKDgzVo0CC9/vrrKfp37dpVN2/e1KpVq+xtderUUUhIiGbPni1jjAoVKqThw4drxIgRkqTr16+rQIECmjdvnrp165amumJiYhQQEKDr16/L398/A/Y07RKTElV8evEUgzCZTTYV9iusw/84nG1O0z5sEhIStGbNGoWFhcnDwyOry0E28fdxk5iUqIqzKurcjXOp9udYhcT3TVbLrscp4wbplV3HTlqO1SL+RXRqyKksOVbTmg2cvjTxt99+0/Lly1W6dOn/qUBn3blzR3v27NGoUaPsbW5ubmrevLm2b9+e6jrbt2/XsGHDHNrCwsK0cuVKSdKpU6cUGRmp5s2b25cHBASodu3a2r59+z2DWHx8vOLj4+3PY2JiJP05mFP7jbXM9OPvP94zhEmSkdHZG2cVMCHAwqpc1MGsLgDZUhrHDccqHPB981B66I9Txg3Sy8XGjpHRHzF/aMNvG9S4WGPLXz+tecDpINasWTMdOHDA8iB2+fJlJSYmqkCBAg7tBQoU0NGjR1NdJzIyMtX+kZGR9uXJbffqk5rx48dr7NixKdrXrl0rX1/fB+9MBtp0bZOlrwcAAABkB99v+V43D9+0/HXj4uLS1M/pIPbJJ5+oV69eOnTokCpXrpziNGa7du2c3WS2M2rUKIczbTExMQoODlbLli0tvzQx5+85NeX3KQ/s902Xb9SgaAMLKnI9CQkJWr9+vZo2bZqtTtsja/193Gw5s0Vtl7Z94Hocq482vm+yVnY9Thk3SK/sOnbSeqw+2eDJLDkjlny13IM4HcS2b9+urVu36vvvv0+xzGazKTEx0dlNpknevHnl7u6uqKgoh/aoqCgFBQWluk5QUNB9+yf/b1RUlAoWLOjQJyQk5J61eHl5ycvLK0W7h4eH5YM4tGSoivgX0bmYczJKebtf8jWyT5Z78qG6nj07SUhIkLe7t3LnzJ2tvqSQtf4+bp4s9yTHKh6I75uslV2PU8YN0iu7jp20HquhJUOz5FhN63vp9KyJgwYN0rPPPqsLFy4oKSnJ4ZFZIUySPD09Vb16da1bt87elpSUpHXr1qlu3bqprlO3bl2H/pIUERFh71+iRAkFBQU59ImJidHOnTvvuc2Hjbubu6a3mi7pz0H3V8nPp7Wa9lD9gwE8ijhWgYcfxymQPbjKsep0ELty5YqGDh2a4r4qKwwbNkwff/yx/vOf/+jIkSN6+eWXdfPmTfXp00eS1LNnT4fJPIYMGaLVq1dr8uTJOnr0qMaMGaPdu3dr4MCBkv48g/fKK6/onXfe0ddff62DBw+qZ8+eKlSokMLDwy3fv/TqUKGDvujyhQr7F3ZoL+JfRF90+SJb/I4C8CjgWAUefhynQPbgCseq05cmdujQQRs2bFCpUqUyo5776tq1qy5duqS33npLkZGRCgkJ0erVq+2h8MyZM3Jz+//Zsl69elq0aJHefPNN/d///Z/KlCmjlStXqnLlyvY+r776qm7evKkXXnhB0dHRatCggVavXi1vb2/L9+9/0aFCBz1d7uls+8viwKOCYxV4+HGcAtlDdj9WnQ5iZcuW1ahRo7RlyxZVqVIlxTWQgwcPzrDiUjNw4ED7Ga2/27hxY4q2zp07q3Pnzvfcns1m07hx4zRu3LiMKjHLuLu5q0nxJlldBoAH4FgFHn4cp0D2kJ2P1XTNmpgrVy79+OOP+vHHHx2W2Wy2TA9iAAAAAJDdOR3ETp06lRl1AAAAAMAjw+nJOv7KGCNjUk4ZCQAAAAC4t3QFsfnz56tKlSry8fGRj4+PHn/8cX3++ecZXRsAAAAAuCSnL02cMmWK/vnPf2rgwIGqX7++JGnLli166aWXdPnyZQ0dOjTDiwQAAAAAV+J0EJsxY4Y+/PBD9ezZ097Wrl07VapUSWPGjCGIAQAAAMADOH1p4oULF1SvXr0U7fXq1dOFCxcypCgAAAAAcGVOB7HSpUtr6dKlKdqXLFmiMmXKZEhRAAAAAODKnL40cezYseratas2bdpkv0ds69atWrduXaoBDQAAAADgyOkzYh07dtTOnTuVN29erVy5UitXrlTevHm1a9cutW/fPjNqBAAAAACX4vQZMUmqXr26FixYkNG1AAAAAMAjIc1nxM6fP68RI0YoJiYmxbLr169r5MiRioqKytDiAAAAAMAVpTmITZkyRTExMfL390+xLCAgQDdu3NCUKVMytDgAAAAAcEVpDmKrV692+O2wv+vZs6dWrVqVIUUBAAAAgCtLcxA7deqUihYtes/lRYoU0enTpzOiJgAAAABwaWkOYj4+PvcNWqdPn5aPj09G1AQAAAAALi3NQax27dr6/PPP77l8/vz5qlWrVoYUBQAAAACuLM3T148YMUItWrRQQECARo4cqQIFCkiSoqKiNHHiRM2bN09r167NtEIBAAAAwFWkOYiFhoZq5syZGjJkiKZOnSp/f3/ZbDZdv35dHh4emjFjhpo2bZqZtQIAAACAS3DqB51ffPFFPfXUU1q6dKlOnDghY4zKli2rTp06qUiRIplVIwAAAAC4FKeCmCQVLlxYQ4cOzYxaAAAAAOCRkObJOgAAAAAAGYMgBgAAAAAWI4gBAAAAgMUIYgAAAABgsXQFsejoaH3yyScaNWqUrl69Kknau3evzp07l6HFAQAAAIArcnrWxJ9//lnNmzdXQECATp8+rf79+yswMFArVqzQmTNnNH/+/MyoEwAAAABchtNnxIYNG6bevXvr+PHj8vb2tre3bt1amzZtytDiAAAAAMAVOR3EfvrpJ7344osp2gsXLqzIyMgMKQoAAAAAXJnTQczLy0sxMTEp2n/99Vfly5cvQ4oCAAAAAFfmdBBr166dxo0bp4SEBEmSzWbTmTNn9Nprr6ljx44ZXiAAAAAAuBqng9jkyZMVGxur/Pnz69atW2rcuLFKly4tPz8/vfvuu5lRIwAAAAC4FKdnTQwICFBERIS2bNmin3/+WbGxsXriiSfUvHnzzKgPAAAAAFyO00EsWYMGDdSgQYOMrAUAAAAAHglOB7H3338/1XabzSZvb2+VLl1ajRo1kru7+/9cHAAAAAC4IqeD2NSpU3Xp0iXFxcUpT548kqRr167J19dXuXLl0sWLF1WyZElt2LBBwcHBGV4wAAAAAGR3Tk/W8a9//Us1a9bU8ePHdeXKFV25ckW//vqrateurenTp+vMmTMKCgrS0KFDM6NeAAAAAMj2nD4j9uabb2r58uUqVaqUva106dKaNGmSOnbsqN9++00TJ05kKnsAAAAAuAenz4hduHBBd+/eTdF+9+5dRUZGSpIKFSqkGzdu/O/VAQAAAIALcjqIhYaG6sUXX9S+ffvsbfv27dPLL7+spk2bSpIOHjyoEiVKZFyVAAAAAOBCnA5in376qQIDA1W9enV5eXnJy8tLNWrUUGBgoD799FNJUq5cuTR58uQMLxYAAAAAXIHT94gFBQUpIiJCR48e1a+//ipJKleunMqVK2fvExoamnEVAgAAAICLSfcPOpcvX17ly5fPyFoAAAAA4JGQriB29uxZff311zpz5ozu3LnjsGzKlCkZUhgAAAAAuCqng9i6devUrl07lSxZUkePHlXlypV1+vRpGWP0xBNPZEaNAAAAAOBSnJ6sY9SoURoxYoQOHjwob29vLV++XH/88YcaN26szp07Z0aNAAAAAOBSnA5iR44cUc+ePSVJOXLk0K1bt5QrVy6NGzdOEyZMyPACAQAAAMDVOB3EcubMab8vrGDBgjp58qR92eXLlzOuMgAAAABwUU7fI1anTh1t2bJFFSpUUOvWrTV8+HAdPHhQK1asUJ06dTKjRgAAAABwKU4HsSlTpig2NlaSNHbsWMXGxmrJkiUqU6YMMyYCAAAAQBo4FcQSExN19uxZPf7445L+vExx9uzZmVIYAAAAALgqp+4Rc3d3V8uWLXXt2rXMqgcAAAAAXJ7Tk3VUrlxZv/32W2bUAgAAAACPBKeD2DvvvKMRI0Zo1apVunDhgmJiYhweAAAAAID7c3qyjtatW0uS2rVrJ5vNZm83xshmsykxMTHjqgMAAAAAF+R0ENuwYUNm1AEAAAAAjwyng1jjxo0zow4AAAAAeGQ4fY+YJG3evFnPPvus6tWrp3PnzkmSPv/8c23ZsiVDiwMAAAAAV+R0EFu+fLnCwsLk4+OjvXv3Kj4+XpJ0/fp1/etf/8rwAgEAAADA1aRr1sTZs2fr448/loeHh729fv362rt3b4YWBwAAAACuyOkgduzYMTVq1ChFe0BAgKKjozOiJgAAAABwaU4HsaCgIJ04cSJF+5YtW1SyZMkMKQoAAAAAXJnTQax///4aMmSIdu7cKZvNpvPnz2vhwoUaMWKEXn755cyoEQAAAABcitPT17/++utKSkpSs2bNFBcXp0aNGsnLy0sjRozQoEGDMqNGAAAAAHApTgcxm82mN954QyNHjtSJEycUGxurihUrKleuXJlRHwAAAAC4HKcvTVywYIHi4uLk6empihUrqlatWoQwAAAAAHCC00Fs6NChyp8/v5555hl99913SkxMzIy6AAAAAMBlOR3ELly4oMWLF8tms6lLly4qWLCgBgwYoG3btmVGfQAAAADgcpwOYjly5NBTTz2lhQsX6uLFi5o6dapOnz6t0NBQlSpVKjNqBAAAAACX4vRkHX/l6+ursLAwXbt2Tb///ruOHDmSUXUBAAAAgMty+oyYJMXFxWnhwoVq3bq1ChcurGnTpql9+/Y6fPhwRtcHAAAAAC7H6TNi3bp106pVq+Tr66suXbron//8p+rWrZsZtQEAAACAS3I6iLm7u2vp0qUKCwuTu7u7w7JDhw6pcuXKGVYcAAAAALgipy9NTL4kMTmE3bhxQx999JFq1aqlqlWrZniBya5evaoePXrI399fuXPnVr9+/RQbG3vfdW7fvq0BAwboscceU65cudSxY0dFRUXZlx84cEDdu3dXcHCwfHx8VKFCBU2fPj3T9gEAAAAApHTeIyZJmzZtUq9evVSwYEFNmjRJTZs21Y4dOzKyNgc9evTQ4cOHFRERoVWrVmnTpk164YUX7rvO0KFD9c0332jZsmX68ccfdf78eXXo0MG+fM+ePcqfP78WLFigw4cP64033tCoUaP0wQcfZNp+AAAAAIBTlyZGRkZq3rx5+vTTTxUTE6MuXbooPj5eK1euVMWKFTOrRh05ckSrV6/WTz/9pBo1akiSZsyYodatW2vSpEkqVKhQinWuX7+uTz/9VIsWLVLTpk0lSXPnzlWFChW0Y8cO1alTR3379nVYp2TJktq+fbtWrFihgQMHZtr+AAAAAHi0pTmItW3bVps2bVKbNm00bdo0tWrVSu7u7po9e3Zm1idJ2r59u3Lnzm0PYZLUvHlzubm5aefOnWrfvn2Kdfbs2aOEhAQ1b97c3la+fHkVLVpU27dvV506dVJ9revXryswMPC+9cTHxys+Pt7+PCYmRpKUkJCghIQEp/YND7/kz5TPFs5g3CA9GDdID8YN0ouxkznS+n6mOYh9//33Gjx4sF5++WWVKVMm3YWlR2RkpPLnz+/QliNHDgUGBioyMvKe63h6eip37twO7QUKFLjnOtu2bdOSJUv07bff3ree8ePHa+zYsSna165dK19f3/uui+wrIiIiq0tANsS4QXowbpAejBukF2MnY8XFxaWpX5qD2JYtW/Tpp5+qevXqqlChgp577jl169Yt3QVK0uuvv64JEybct49VPxJ96NAhPf300xo9erRatmx5376jRo3SsGHD7M9jYmIUHBysli1byt/fP7NLhcUSEhIUERGhFi1ayMPDI6vLQTbBuEF6MG6QHowbpBdjJ3MkXy33IGkOYnXq1FGdOnU0bdo0LVmyRJ999pmGDRumpKQkRUREKDg4WH5+fk4VOXz4cPXu3fu+fUqWLKmgoCBdvHjRof3u3bu6evWqgoKCUl0vKChId+7cUXR0tMNZsaioqBTr/PLLL2rWrJleeOEFvfnmmw+s28vLS15eXinaPTw8GMQujM8X6cG4QXowbpAejBukF2MnY6X1vXR61sScOXOqb9++2rJliw4ePKjhw4fr3//+t/Lnz6927do5ta18+fKpfPny9314enqqbt26io6O1p49e+zrrl+/XklJSapdu3aq265evbo8PDy0bt06e9uxY8d05swZhx+gPnz4sEJDQ9WrVy+9++67Tr4bAAAAAOC8dE9fL0nlypXTxIkTdfbsWf33v//NqJpSqFChglq1aqX+/ftr165d2rp1qwYOHKhu3brZZ0w8d+6cypcvr127dkmSAgIC1K9fPw0bNkwbNmzQnj171KdPH9WtW9c+UcehQ4cUGhqqli1batiwYYqMjFRkZKQuXbqUafsCAAAAAE5NX38v7u7uCg8PV3h4eEZsLlULFy7UwIED1axZM7m5ualjx456//337csTEhJ07Ngxh5vjpk6dau8bHx+vsLAwzZo1y778iy++0KVLl7RgwQItWLDA3l6sWDGdPn060/YFAAAAwKMtQ4KYFQIDA7Vo0aJ7Li9evLiMMQ5t3t7emjlzpmbOnJnqOmPGjNGYMWMyskwAAAAAeKD/6dJEAAAAAIDzCGIAAAAAYDGCGAAAAABYjCAGAAAAABYjiAEAAACAxQhiAAAAAGAxghgAAAAAWIwgBgAAAAAWI4gBAAAAgMUIYgAAAABgMYIYAAAAAFiMIAYAAAAAFiOIAQAAAIDFCGIAAAAAYDGCGAAAAABYjCAGAAAAABYjiAEAAACAxQhiAAAAAGAxghgAAAAAWIwgBgAAAAAWI4gBAAAAgMUIYgAAAABgMYIYAAAAAFiMIAYAAAAAFiOIAQAAAIDFCGIAAAAAYDGCGAAAAABYjCAGAAAAABYjiAEAAACAxQhiAAAAAGAxghgAAAAAWIwgBgAAAAAWI4gBAAAAgMUIYgAAAABgMYIYAAAAAFiMIAYAAAAAFiOIAQAAAIDFCGIAAAAAYDGCGAAAAABYjCAGAAAAABYjiAEAAACAxQhiAAAAAGAxghgAAAAAWIwgBgAAAAAWI4gBAAAAgMUIYgAAAABgMYIYAAAAAFiMIAYAAAAAFiOIAQAAAIDFCGIAAAAAYDGCGAAAAABYjCAGAAAAABYjiAEAAACAxQhiAAAAAGAxghgAAAAAWIwgBgAAAAAWI4gBAAAAgMUIYgAAAABgMYIYAAAAAFiMIAYAAAAAFiOIAQAAAIDFCGIAAAAAYDGCGAAAAABYjCAGAAAAABYjiAEAAACAxQhiAAAAAGAxghgAAAAAWIwgBgAAAAAWI4gBAAAAgMUIYgAAAABgMYIYAAAAAFiMIAYAAAAAFiOIAQAAAIDFsk0Qu3r1qnr06CF/f3/lzp1b/fr1U2xs7H3XuX37tgYMGKDHHntMuXLlUseOHRUVFZVq3ytXrqhIkSKy2WyKjo7OhD0AAAAAgD9lmyDWo0cPHT58WBEREVq1apU2bdqkF1544b7rDB06VN98842WLVumH3/8UefPn1eHDh1S7duvXz89/vjjmVE6AAAAADjIFkHsyJEjWr16tT755BPVrl1bDRo00IwZM7R48WKdP38+1XWuX7+uTz/9VFOmTFHTpk1VvXp1zZ07V9u2bdOOHTsc+n744YeKjo7WiBEjrNgdAAAAAI+4HFldQFps375duXPnVo0aNextzZs3l5ubm3bu3Kn27dunWGfPnj1KSEhQ8+bN7W3ly5dX0aJFtX37dtWpU0eS9Msvv2jcuHHauXOnfvvttzTVEx8fr/j4ePvzmJgYSVJCQoISEhLStY94eCV/pny2cAbjBunBuEF6MG6QXoydzJHW9zNbBLHIyEjlz5/foS1HjhwKDAxUZGTkPdfx9PRU7ty5HdoLFChgXyc+Pl7du3fXe++9p6JFi6Y5iI0fP15jx45N0b527Vr5+vqmaRvIfiIiIrK6BGRDjBukB+MG6cG4QXoxdjJWXFxcmvplaRB7/fXXNWHChPv2OXLkSKa9/qhRo1ShQgU9++yzTq83bNgw+/OYmBgFBwerZcuW8vf3z+gykcUSEhIUERGhFi1ayMPDI6vLQTbBuEF6MG6QHowbpBdjJ3MkXy33IFkaxIYPH67evXvft0/JkiUVFBSkixcvOrTfvXtXV69eVVBQUKrrBQUF6c6dO4qOjnY4KxYVFWVfZ/369Tp48KC++OILSZIxRpKUN29evfHGG6me9ZIkLy8veXl5pWj38PBgELswPl+kB+MG6cG4QXowbpBejJ2Mldb3MkuDWL58+ZQvX74H9qtbt66io6O1Z88eVa9eXdKfISopKUm1a9dOdZ3q1avLw8ND69atU8eOHSVJx44d05kzZ1S3bl1J0vLly3Xr1i37Oj/99JP69u2rzZs3q1SpUv/r7gEAAABAqrLFPWIVKlRQq1at1L9/f82ePVsJCQkaOHCgunXrpkKFCkmSzp07p2bNmmn+/PmqVauWAgIC1K9fPw0bNkyBgYHy9/fXoEGDVLduXftEHX8PW5cvX7a/3t/vLQMAAACAjJItgpgkLVy4UAMHDlSzZs3k5uamjh076v3337cvT0hI0LFjxxxujps6daq9b3x8vMLCwjRr1qysKB8AAAAA7LJNEAsMDNSiRYvuubx48eL2e7ySeXt7a+bMmZo5c2aaXqNJkyYptgEAAAAAGS1b/KAzAAAAALgSghgAAAAAWIwgBgAAAAAWI4gBAAAAgMUIYgAAAABgMYIYAAAAAFiMIAYAAAAAFiOIAQAAAIDFCGIAAAAAYDGCGAAAAABYjCAGAAAAABYjiAEAAACAxQhiAAAAAGAxghgAAAAAWIwgBgAAAAAWI4gBAAAAgMUIYgAAAABgMYIYAAAAAFiMIAYAAAAAFiOIAQAAAIDFCGIAAAAAYDGCGAAAAABYjCAGAAAAABYjiAEAAACAxQhiAAAAAGAxghgAAAAAWIwgBgAAAAAWI4gBAAAAgMUIYgAAAABgMYIYAAAAAFiMIAYAAAAAFiOIAQAAAIDFCGIAAAAAYDGCGAAAAABYjCAGAAAAABYjiAEAAACAxQhiAAAAAGAxghgAAAAAWIwgBgAAAAAWI4gBAAAAgMUIYgAAAABgMYIYAAAAAFiMIAYAAAAAFiOIAQAAAIDFCGIAAAAAYDGCGAAAAABYjCAGAAAAABYjiAEAAACAxQhiAAAAAGAxghgAAAAAWIwgBgAAAAAWI4gBAAAAgMUIYgAAAABgMYIYAAAAAFiMIAYAAAAAFsuR1QW4AmOMJCkmJiaLK0FmSEhIUFxcnGJiYuTh4ZHV5SCbYNwgPRg3SA/GDdKLsZM5kjNBcka4F4JYBrhx44YkKTg4OIsrAQAAAPAwuHHjhgICAu653GYeFNXwQElJSTp//rz8/Pxks9myuhxksJiYGAUHB+uPP/6Qv79/VpeDbIJxg/Rg3CA9GDdIL8ZO5jDG6MaNGypUqJDc3O59JxhnxDKAm5ubihQpktVlIJP5+/vzJQWnMW6QHowbpAfjBunF2Ml49zsTlozJOgAAAADAYgQxAAAAALAYQQx4AC8vL40ePVpeXl5ZXQqyEcYN0oNxg/Rg3CC9GDtZi8k6AAAAAMBinBEDAAAAAIsRxAAAAADAYgQxAAAAALAYQQwAAAAALEYQAyTNnDlTxYsXl7e3t2rXrq1du3bds++8efNks9kcHt7e3hZWi4fBpk2b1LZtWxUqVEg2m00rV6584DobN27UE088IS8vL5UuXVrz5s3L9DrxcHF23GzcuDHF943NZlNkZKQ1BeOhMH78eNWsWVN+fn7Knz+/wsPDdezYsQeut2zZMpUvX17e3t6qUqWKvvvuOwuqxcMiPeOGv3GsRRDDI2/JkiUaNmyYRo8erb1796pq1aoKCwvTxYsX77mOv7+/Lly4YH/8/vvvFlaMh8HNmzdVtWpVzZw5M039T506pTZt2ig0NFT79+/XK6+8oueff15r1qzJ5ErxMHF23CQ7duyYw3dO/vz5M6lCPIx+/PFHDRgwQDt27FBERIQSEhLUsmVL3bx5857rbNu2Td27d1e/fv20b98+hYeHKzw8XIcOHbKwcmSl9Iwbib9xrMT09Xjk1a5dWzVr1tQHH3wgSUpKSlJwcLAGDRqk119/PUX/efPm6ZVXXlF0dLTFleJhZbPZ9OWXXyo8PPyefV577TV9++23Dn8EdevWTdHR0Vq9erUFVeJhk5Zxs3HjRoWGhuratWvKnTu3ZbXh4Xbp0iXlz59fP/74oxo1apRqn65du+rmzZtatWqVva1OnToKCQnR7NmzrSoVD5G0jBv+xrEWZ8TwSLtz54727Nmj5s2b29vc3NzUvHlzbd++/Z7rxcbGqlixYgoODtbTTz+tw4cPW1EusrHt27c7jDNJCgsLu+84A5KFhISoYMGCatGihbZu3ZrV5SCLXb9+XZIUGBh4zz585+Dv0jJuJP7GsRJBDI+0y5cvKzExUQUKFHBoL1CgwD3vwShXrpw+++wzffXVV1qwYIGSkpJUr149nT171oqSkU1FRkamOs5iYmJ069atLKoKD7uCBQtq9uzZWr58uZYvX67g4GA1adJEe/fuzerSkEWSkpL0yiuvqH79+qpcufI9+93rO4f7Cx9NaR03/I1jrRxZXQCQ3dStW1d169a1P69Xr54qVKigOXPm6O23387CygC4mnLlyqlcuXL25/Xq1dPJkyc1depUff7551lYGbLKgAEDdOjQIW3ZsiWrS0E2ktZxw9841uKMGB5pefPmlbu7u6Kiohzao6KiFBQUlKZteHh4qFq1ajpx4kRmlAgXERQUlOo48/f3l4+PTxZVheyoVq1afN88ogYOHKhVq1Zpw4YNKlKkyH373us7J63/tsF1ODNu/o6/cTIXQQyPNE9PT1WvXl3r1q2ztyUlJWndunUO/0XofhITE3Xw4EEVLFgws8qEC6hbt67DOJOkiIiINI8zINn+/fv5vnnEGGM0cOBAffnll1q/fr1KlCjxwHX4zkF6xs3f8TdO5uLSRDzyhg0bpl69eqlGjRqqVauWpk2bpps3b6pPnz6SpJ49e6pw4cIaP368JGncuHGqU6eOSpcurejoaL333nv6/fff9fzzz2flbsBisbGxDv+F8NSpU9q/f78CAwNVtGhRjRo1SufOndP8+fMlSS+99JI++OADvfrqq+rbt6/Wr1+vpUuX6ttvv82qXUAWcHbcTJs2TSVKlFClSpV0+/ZtffLJJ1q/fr3Wrl2bVbuALDBgwAAtWrRIX331lfz8/Oz3eQUEBNjPqP/936ohQ4aocePGmjx5stq0aaPFixdr9+7d+uijj7JsP2Ct9Iwb/saxmAFgZsyYYYoWLWo8PT1NrVq1zI4dO+zLGjdubHr16mV//sorr9j7FihQwLRu3drs3bs3C6pGVtqwYYORlOKRPFZ69eplGjdunGKdkJAQ4+npaUqWLGnmzp1red3IWs6OmwkTJphSpUoZb29vExgYaJo0aWLWr1+fNcUjy6Q2ZiQ5fIf8/d8qY4xZunSpKVu2rPH09DSVKlUy3377rbWFI0ulZ9zwN461+B0xAAAAALAY94gBAAAAgMUIYgAAAABgMYIYAAAAAFiMIAYAAAAAFiOIAQAAAIDFCGIAAAAAYDGCGAAAAABYjCAGAAAA4JGxadMmtW3bVoUKFZLNZtPKlSud3oYxRpMmTVLZsmXl5eWlwoUL691333VqGwQxAMAj57nnntO//vWvrC7jfzJv3jzlzp07TX1Xr16tkJAQJSUlZW5RAJAN3Lx5U1WrVtXMmTPTvY0hQ4bok08+0aRJk3T06FF9/fXXqlWrllPbIIgBAB56sbGx6t27twoUKGD/L4/jxo2zL9+4caNsNpuio6MfuK0DBw7ou+++0+DBgzOx4odLq1at5OHhoYULF2Z1KQCQ5Z588km98847at++farL4+PjNWLECBUuXFg5c+ZU7dq1tXHjRvvyI0eO6MMPP9RXX32ldu3aqUSJEqpevbpatGjhVB0EMQDAQ2/evHn65ptv9OWXX+rEiRNavXq1nnjiiXRta8aMGercubNy5cqVwVU+3Hr37q33338/q8sAgIfewIEDtX37di1evFg///yzOnfurFatWun48eOSpG+++UYlS5bUqlWrVKJECRUvXlzPP/+8rl696tTrEMQAAA+9SpUqKTY2VkuXLtWRI0dUunRpPfXUU5Kk06dPKzQ0VJKUJ08e2Ww29e7dO9XtJCYm6osvvlDbtm0d2mfNmqUyZcrI29tbBQoUUKdOnezLkpKSNH78eJUoUUI+Pj6qWrWqvvjiC4f1Dx8+rKeeekr+/v7y8/NTw4YNdfLkSfv648aNU5EiReTl5aWQkBCtXr3avu7p06dls9m0YsUKhYaGytfXV1WrVtX27dsdXmPevHkqWrSofH191b59e125csVh+YEDBxQaGio/Pz/5+/urevXq2r17t31527ZttXv3bntdAICUzpw5o7lz52rZsmVq2LChSpUqpREjRqhBgwaaO3euJOm3337T77//rmXLlmn+/PmaN2+e9uzZ4/BvR1rkyIwdAAAgI1WtWlXPP/+83nzzTZ05c0Z9+/ZVrVq1NHToUAUHB2v58uXq2LGjjh07Jn9/f/n4+KS6nZ9//lnXr19XjRo17G27d+/W4MGD9fnnn6tevXq6evWqNm/ebF8+fvx4LViwQLNnz1aZMmW0adMmPfvss8qXL58aN26sc+fOqVGjRmrSpInWr18vf39/bd26VXfv3pUkTZ8+XZMnT9acOXNUrVo1ffbZZ2rXrp0OHz6sMmXK2F/njTfe0KRJk1SmTBm98cYb6t69u06cOKEcOXJo586d6tevn8aPH6/w8HCtXr1ao0ePdti3Hj16qFq1avrwww/l7u6u/fv3y8PDw768aNGiKlCggDZv3qxSpUplyOcCAK7m4MGDSkxMVNmyZR3a4+Pj9dhjj0n68z+wxcfHa/78+fZ+n376qapXr65jx46pXLlyaXsxAwDAQ65du3bm22+/tT+/deuWKVSokImIiDDGGLNhwwYjyVy7du2+2/nyyy+Nu7u7SUpKsrctX77c+Pv7m5iYmBT9b9++bXx9fc22bdsc2vv162e6d+9ujDFm1KhRpkSJEubOnTupvmahQoXMu+++69BWs2ZN849//MMYY8ypU6eMJPPJJ5/Ylx8+fNhIMkeOHDHGGNO9e3fTunVrh2107drVBAQE2J/7+fmZefPm3Xf/q1WrZsaMGXPfPgDwKJFkvvzyS/vzxYsXG3d3d3P06FFz/Phxh8eFCxeMMca89dZbJkeOHA7biYuLM5LM2rVr0/zaXJoIAHionTt3Tl9//bWqVq1qb/P29latWrW0atUqp7Z169YteXl5yWaz2dtatGihYsWKqWTJknruuee0cOFCxcXFSZJOnDihuLg4tWjRQrly5bI/5s+fb7/Eb//+/WrYsKHD2adkMTExOn/+vOrXr+/QXr9+fR05csSh7fHHH7f//4IFC0qSLl68KOnPG8Nr167t0L9u3boOz4cNG6bnn39ezZs317///e9UL0H08fGx7xsAIKVq1aopMTFRFy9eVOnSpR0eQUFBkv78Dr97967D9+yvv/4qSSpWrFiaX4sgBgB4qF24cEGSdOfOHYd2Y4wuX77s1Lby5s2ruLg4h235+flp7969+u9//6uCBQvqrbfeUtWqVRUdHa3Y2FhJ0rfffqv9+/fbH7/88ov9PrF7XQbprL8GueSg6Mx082PGjNHhw4fVpk0brV+/XhUrVtSXX37p0Ofq1avKly9fhtQLANlVbGys/ftckk6dOqX9+/frzJkzKlu2rHr06KGePXtqxYoVOnXqlHbt2qXx48fr22+/lSQ1b95cTzzxhPr27at9+/Zpz549evHFF9WiRYsUlzTeD0EMAPBQK126tGw2m7Zs2WJvu3Pnjnbu3KnSpUtLkjw9PSX9ORnH/YSEhEiSfvnlF4f2HDlyqHnz5po4caJ+/vlnnT592h5mvLy8dObMmRT/ZTQ4OFjSn2eyNm/erISEhBSv5+/vr0KFCmnr1q0O7Vu3blXFihXT/B5UqFBBO3fudGjbsWNHin5ly5bV0KFDtXbtWnXo0MF+Y7kk3b59WydPnlS1atXS/LoA4Ip2796tatWq2b8Phw0bpmrVqumtt96SJM2dO1c9e/bU8OHDVa5cOYWHh+unn35S0aJFJUlubm765ptvlDdvXjVq1Eht2rRRhQoVtHjxYqfqYLIOAMBDLXfu3OrVq5dee+015c2bV8WKFdP48eN148YN9e/fX9Kfl4LYbDatWrVKrVu3lo+PT6rT0+fLl09PPPGEtmzZYg9lq1at0m+//aZGjRopT548+u6775SUlKRy5crJz89PI0aM0NChQ5WUlKQGDRro+vXr2rp1q/z9/dWrVy8NHDhQM2bMULdu3TRq1CgFBARox44dqlWrlsqVK6eRI0dq9OjRKlWqlEJCQjR37lzt37/fqd/0Gjx4sOrXr69Jkybp6aef1po1axxmXrx165ZGjhypTp06qUSJEjp79qx++ukndezY0d5nx44d8vLySnFJIwA8apo0aaI/bw9LnYeHh8aOHauxY8fes0+hQoW0fPny/62QDLjHDQCATBUXF2eGDx9uihUrZvz9/U3jxo3N7t27HfqMGzfOBAUFGZvNZnr16nXPbc2aNcvUqVPH/nzz5s2mcePGJk+ePMbHx8c8/vjjZsmSJfblSUlJZtq0aaZcuXLGw8PD5MuXz4SFhZkff/zR3ufAgQOmZcuWxtfX1/j5+ZmGDRuakydPGmOMSUxMNGPGjDGFCxc2Hh4epmrVqub777+3r5s8Wce+ffvsbdeuXTOSzIYNG+xtn376qSlSpIjx8fExbdu2NZMmTbJP1hEfH2+6detmgoODjaenpylUqJAZOHCguXXrln39F154wbz44otper8BAJnPZsx94iAAAC7m1q1bKleunJYsWfLInB26fPmyypUrp927d6tEiRJZXQ4AQNwjBgB4xPj4+Gj+/PlOT/SRnZ0+fVqzZs0ihAHAQ4QzYgAAAABgMc6IAQAAAIDFCGIAAAAAYDGCGAAAAABYjCAGAAAAABYjiAEAAACAxQhiAAAAAGAxghgAAAAAWIwgBgAAAAAWI4gBAAAAgMX+H3d9XKGvQ5dEAAAAAElFTkSuQmCC",
+ "text/plain": [
+ "<Figure size 1000x600 with 1 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Plot the analysis results\n",
+ "delta_t_values = list(analysis_results.keys())\n",
+ "largest_component_sizes = [result[\"largest_component_size\"] for result in analysis_results.values() if \"largest_component_size\" in result]\n",
+ "total_components = [result[\"total_components\"] for result in analysis_results.values() if \"total_components\" in result]\n",
+ "average_component_sizes = [result[\"average_component_size\"] for result in analysis_results.values() if \"average_component_size\" in result]\n",
+ "\n",
+ "# Plot Largest Component Size vs δt\n",
+ "plt.figure(figsize=(10, 6))\n",
+ "plt.plot(delta_t_values, largest_component_sizes, marker='o')\n",
+ "plt.xlabel(\"δt (seconds)\")\n",
+ "plt.ylabel(\"Largest Component Size\")\n",
+ "plt.title(\"Largest Component Size vs δt\")\n",
+ "plt.grid(True)\n",
+ "plt.show()\n",
+ "\n",
+ "# Plot Total Components vs δt\n",
+ "plt.figure(figsize=(10, 6))\n",
+ "plt.plot(delta_t_values, total_components, marker='o', color='r')\n",
+ "plt.xlabel(\"δt (seconds)\")\n",
+ "plt.ylabel(\"Total Components\")\n",
+ "plt.title(\"Total Components vs δt\")\n",
+ "plt.grid(True)\n",
+ "plt.show()\n",
+ "\n",
+ "# Plot Average Component Size vs δt\n",
+ "plt.figure(figsize=(10, 6))\n",
+ "plt.plot(delta_t_values, average_component_sizes, marker='o', color='g')\n",
+ "plt.xlabel(\"δt (seconds)\")\n",
+ "plt.ylabel(\"Average Component Size\")\n",
+ "plt.title(\"Average Component Size vs δt\")\n",
+ "plt.grid(True)\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\n",
+ "# Clustering Coefficient & Shortest Path Length\n",
+ "clustering_pre = bipartite_percolation.compute_clustering_coefficient(0.5 * critical_delta_t)\n",
+ "clustering_at = bipartite_percolation.compute_clustering_coefficient(critical_delta_t)\n",
+ "clustering_post = bipartite_percolation.compute_clustering_coefficient(1.5 * critical_delta_t)\n",
+ "\n",
+ "avg_path_length_pre = bipartite_percolation.compute_shortest_path_lengths(0.5 * critical_delta_t)\n",
+ "avg_path_length_at = bipartite_percolation.compute_shortest_path_lengths(critical_delta_t)\n",
+ "avg_path_length_post = bipartite_percolation.compute_shortest_path_lengths(1.5 * critical_delta_t)\n",
+ "\n",
+ "print(f\"Clustering Coefficient (δt < δt_c): {clustering_pre}\")\n",
+ "print(f\"Clustering Coefficient (δt = δt_c): {clustering_at}\")\n",
+ "print(f\"Clustering Coefficient (δt > δt_c): {clustering_post}\")\n",
+ "\n",
+ "print(f\"Average Path Length (δt < δt_c): {avg_path_length_pre}\")\n",
+ "print(f\"Average Path Length (δt = δt_c): {avg_path_length_at}\")\n",
+ "print(f\"Average Path Length (δt > δt_c): {avg_path_length_post}\")\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "myDefault",
+ "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.12.5"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
--
GitLab