From eaa5a67667228ba9dd0701ba230adbe98568cac9 Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 09:23:31 -0400 Subject: [PATCH 01/22] Algebraic Connectivity. This rewiring method rewires the network such that the algebraic connectivity increases. --- .../test_maximize_algebraic_connectivity.py | 116 ++++++++++++++++++ 1 file changed, 116 insertions(+) create mode 100644 netrw/rewire/test_maximize_algebraic_connectivity.py diff --git a/netrw/rewire/test_maximize_algebraic_connectivity.py b/netrw/rewire/test_maximize_algebraic_connectivity.py new file mode 100644 index 0000000..c6626cb --- /dev/null +++ b/netrw/rewire/test_maximize_algebraic_connectivity.py @@ -0,0 +1,116 @@ +from base import BaseRewirer +import networkx as nx +import numpy as np +import copy +from itertools import combinations +import matplotlib.pyplot as plt +from scipy import linalg as la + +class AlgebraicConnectivity(BaseRewirer): + """ + Rewire a network such that the rewire maximally increases + the algebraic connectivity of a network. It does this by + computing the Fielder vector of a given network and determining + the value of alpha for each edge, where v is the Fielder vector + and alpha_{ij} = |v_i-v_j| is absolute difference of the entries + in the Fiedler vector for nodes i and j such that (i,j)\in E(G). + The edge with the smallest value of alpha is removed and the non-edge + with the largest alpha is added. + + Sydney, Ali, Caterina Scoglio, and Don Gruenbacher. + "Optimizing algebraic connectivity by edge rewiring." + Applied Mathematics and computation 219.10 (2013): 5465-5479. + """ + def maximize_algebraic_connectivity(self, G, phi=1, copy_network=False, directed=False): + """ + Rewire phi edges to maximize algebraic connectivity. + + Parameters: + G (networkx) + phi (int) - number of edge rewires + copy_network (bool) - return a copy of the network + directed (bool) - compute for directed network on undirected copy + + Return: + G (networkx) + """ + if copy_network: + G = copy.deepcopy(G) + + if not nx.is_connected(G): + raise ValueError("Disconnected graph. This method is implemented for undirected, connected graphs.") + + if nx.is_directed(G) and directed is True: + raise Warning("This algorithm is designed for undirected graphs. The graph input is directed and will be formatted to an undirected graph.") + G = nx.to_undirected(G) + + # Get necessary parameters + nodes = list(G.nodes()) + edges = list(G.edges()) + n = len(nodes) + m = len(edges) + + # Check for complete graph + if m == int(n*(n-1)/2): + raise Warning("Algebraic connectivity is already maximized.") + return G + + # Rewire phi edges + for _ in range(phi): + # Reset edge and node list + nodes = list(G.nodes()) + edges = list(G.edges()) + + # Compute fielder vector + L = nx.laplacian_matrix(G).toarray() + vals, vecs = la.eig(L) + fiedler_idx = np.where(np.argsort(np.abs(vals)))[0][0] + v = vecs[:,fiedler_idx] + + # Get all values of alpha + alpha = np.abs(np.subtract.outer(v,v)) + + # Get alpha_values for edges and non_edges + non_edges = [] + edge_alpha = [] + non_edge_alpha = [] + for i in range(n): + for j in range(i+1,n): + if (nodes[i],nodes[j]) in edges: + edge_alpha.append(alpha[i,j]) + else: + non_edges.append((nodes[i],nodes[j])) + non_edge_alpha.append(alpha[i,j]) + + # Get max alpha + alpha_max = np.argmax(non_edge_alpha) + + # Get minimum alpha + accept_min = False + if accept_min is False: + alpha_min = np.argmin(edge_alpha) + + # Create G without e_min + g_copy = copy.deepcopy(G) + g_copy.remove_edge(edges[alpha_min][0],edges[alpha_min][1]) + + # Get fiedler value + lap_spec = nx.laplacian_spectrum(g_copy) + + # Check that fiedler value is positive on G\e_{min} + if sorted(np.abs(lap_spec))[1] > 0: + accept_min = True + else: + # Delete e_{min} from possible edges + edge_alpha[alpha_min] = np.inf + # Check for lack of convergence + if np.array(edge_alpha).all() == np.inf: + raise ValueError("Failed to converge.") + + # Remove edge + G.remove_edge(edges[alpha_min][0],edges[alpha_min][1]) + # Add edge + G.add_edge(non_edges[alpha_max][0],non_edges[alpha_max][1]) + + # Return new network + return G From 55a2df4b444af2fccdfc5fdce243144ee64054cf Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 10:10:48 -0400 Subject: [PATCH 02/22] Algebraic Connectivity. This rewiring method rewires such that the algebraic connectivity maximally increases at each rewiring step. It does this using the Fiedler eigenvalue and Fiedler vector. --- netrw/rewire/__init__.py | 1 + ...nectivity.py => algebraic_connectivity.py} | 42 +++++++++++-------- 2 files changed, 26 insertions(+), 17 deletions(-) rename netrw/rewire/{test_maximize_algebraic_connectivity.py => algebraic_connectivity.py} (73%) diff --git a/netrw/rewire/__init__.py b/netrw/rewire/__init__.py index 420f987..fd3408b 100644 --- a/netrw/rewire/__init__.py +++ b/netrw/rewire/__init__.py @@ -1,3 +1,4 @@ from .base import BaseRewirer +from .algebraic_connectivity import AlgebraicConnectivity __all__ = [] diff --git a/netrw/rewire/test_maximize_algebraic_connectivity.py b/netrw/rewire/algebraic_connectivity.py similarity index 73% rename from netrw/rewire/test_maximize_algebraic_connectivity.py rename to netrw/rewire/algebraic_connectivity.py index c6626cb..9c56bc9 100644 --- a/netrw/rewire/test_maximize_algebraic_connectivity.py +++ b/netrw/rewire/algebraic_connectivity.py @@ -1,10 +1,10 @@ -from base import BaseRewirer +from .base import BaseRewirer import networkx as nx import numpy as np import copy -from itertools import combinations -import matplotlib.pyplot as plt from scipy import linalg as la +import warnings + class AlgebraicConnectivity(BaseRewirer): """ @@ -21,7 +21,10 @@ class AlgebraicConnectivity(BaseRewirer): "Optimizing algebraic connectivity by edge rewiring." Applied Mathematics and computation 219.10 (2013): 5465-5479. """ - def maximize_algebraic_connectivity(self, G, phi=1, copy_network=False, directed=False): + + def maximize_algebraic_connectivity( + self, G, phi=1, copy_network=False, directed=False + ): """ Rewire phi edges to maximize algebraic connectivity. @@ -38,10 +41,15 @@ def maximize_algebraic_connectivity(self, G, phi=1, copy_network=False, directed G = copy.deepcopy(G) if not nx.is_connected(G): - raise ValueError("Disconnected graph. This method is implemented for undirected, connected graphs.") + raise ValueError( + "Disconnected graph. This method is implemented for undirected, connected graphs." + ) if nx.is_directed(G) and directed is True: - raise Warning("This algorithm is designed for undirected graphs. The graph input is directed and will be formatted to an undirected graph.") + warnings.warn( + "This algorithm is designed for undirected graphs. The graph input is directed and will be formatted to an undirected graph.", + SyntaxWarning, + ) G = nx.to_undirected(G) # Get necessary parameters @@ -51,7 +59,7 @@ def maximize_algebraic_connectivity(self, G, phi=1, copy_network=False, directed m = len(edges) # Check for complete graph - if m == int(n*(n-1)/2): + if m == int(n * (n - 1) / 2): raise Warning("Algebraic connectivity is already maximized.") return G @@ -65,22 +73,22 @@ def maximize_algebraic_connectivity(self, G, phi=1, copy_network=False, directed L = nx.laplacian_matrix(G).toarray() vals, vecs = la.eig(L) fiedler_idx = np.where(np.argsort(np.abs(vals)))[0][0] - v = vecs[:,fiedler_idx] + v = vecs[:, fiedler_idx] # Get all values of alpha - alpha = np.abs(np.subtract.outer(v,v)) + alpha = np.abs(np.subtract.outer(v, v)) # Get alpha_values for edges and non_edges non_edges = [] edge_alpha = [] non_edge_alpha = [] for i in range(n): - for j in range(i+1,n): - if (nodes[i],nodes[j]) in edges: - edge_alpha.append(alpha[i,j]) + for j in range(i + 1, n): + if (nodes[i], nodes[j]) in edges: + edge_alpha.append(alpha[i, j]) else: - non_edges.append((nodes[i],nodes[j])) - non_edge_alpha.append(alpha[i,j]) + non_edges.append((nodes[i], nodes[j])) + non_edge_alpha.append(alpha[i, j]) # Get max alpha alpha_max = np.argmax(non_edge_alpha) @@ -92,7 +100,7 @@ def maximize_algebraic_connectivity(self, G, phi=1, copy_network=False, directed # Create G without e_min g_copy = copy.deepcopy(G) - g_copy.remove_edge(edges[alpha_min][0],edges[alpha_min][1]) + g_copy.remove_edge(edges[alpha_min][0], edges[alpha_min][1]) # Get fiedler value lap_spec = nx.laplacian_spectrum(g_copy) @@ -108,9 +116,9 @@ def maximize_algebraic_connectivity(self, G, phi=1, copy_network=False, directed raise ValueError("Failed to converge.") # Remove edge - G.remove_edge(edges[alpha_min][0],edges[alpha_min][1]) + G.remove_edge(edges[alpha_min][0], edges[alpha_min][1]) # Add edge - G.add_edge(non_edges[alpha_max][0],non_edges[alpha_max][1]) + G.add_edge(non_edges[alpha_max][0], non_edges[alpha_max][1]) # Return new network return G From e6062b7f97295412403f44753a50a84e4c4d6f8c Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 10:51:01 -0400 Subject: [PATCH 03/22] Added Watts-Strogatz method --- netrw/rewire/__init__.py | 1 + netrw/rewire/watts_strogatz.py | 33 +++++++++++++++++++++++++++++++++ 2 files changed, 34 insertions(+) create mode 100644 netrw/rewire/watts_strogatz.py diff --git a/netrw/rewire/__init__.py b/netrw/rewire/__init__.py index fd3408b..7d6df5f 100644 --- a/netrw/rewire/__init__.py +++ b/netrw/rewire/__init__.py @@ -1,4 +1,5 @@ from .base import BaseRewirer from .algebraic_connectivity import AlgebraicConnectivity +from .watts_strogatz import WattsStrogatz __all__ = [] diff --git a/netrw/rewire/watts_strogatz.py b/netrw/rewire/watts_strogatz.py new file mode 100644 index 0000000..47a46e1 --- /dev/null +++ b/netrw/rewire/watts_strogatz.py @@ -0,0 +1,33 @@ +from .base import BaseRewirer +import networkx as nx + + +class WattsStrogatz(BaseRewirer): + """ + Rewire a ring lattice network of size n with node degree k with probability p. + It initializes a ring lattice network of size n where each node is connected + to its k nearest neighbors. Then each edge is rewired to a randomly chosen node + with probability p. The resulting network is then returned. + + Watts, D., Strogatz, S. Collective dynamics of ‘small-world’ networks. Nature 393, 440–442 (1998). https://doi.org/10.1038/30918 + """ + + def watts_strogatz_network(n, k, p, seed=None): + """ + Generate a Watts-Strogatz network with n nodes where each node is connected + to its k-nearest neighbors and each edge is rewired with probability p. + + This is done with networkx standard implementation. + + Aric A. Hagberg, Daniel A. Schult and Pieter J. Swart, “Exploring network structure, dynamics, and function using NetworkX”, in Proceedings of the 7th Python in Science Conference (SciPy2008), Gäel Varoquaux, Travis Vaught, and Jarrod Millman (Eds), (Pasadena, CA USA), pp. 11–15, Aug 2008 + + Parameters: + n (int) - number of nodes + k (int) - number of nearest-neighbors with which each node connects + p (float) - probability of edge rewiring + seed (int) - indicator of random seed generator state + + Returns: + G (networkx) + """ + return nx.watts_strogatz_graph(n, k, p, seed) From 62371cf78c8cb6ff5e37fea3d342297a11b4b4a9 Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 10:54:12 -0400 Subject: [PATCH 04/22] added watts-strogatz --- netrw/rewire/__init__.py | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 netrw/rewire/__init__.py diff --git a/netrw/rewire/__init__.py b/netrw/rewire/__init__.py new file mode 100644 index 0000000..fd3408b --- /dev/null +++ b/netrw/rewire/__init__.py @@ -0,0 +1,4 @@ +from .base import BaseRewirer +from .algebraic_connectivity import AlgebraicConnectivity + +__all__ = [] From 5226aef9b4a73defd8abb1e96238fe65fe0cae66 Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 10:55:00 -0400 Subject: [PATCH 05/22] updated __init__ --- netrw/rewire/__init__.py | 1 + 1 file changed, 1 insertion(+) diff --git a/netrw/rewire/__init__.py b/netrw/rewire/__init__.py index fd3408b..7d6df5f 100644 --- a/netrw/rewire/__init__.py +++ b/netrw/rewire/__init__.py @@ -1,4 +1,5 @@ from .base import BaseRewirer from .algebraic_connectivity import AlgebraicConnectivity +from .watts_strogatz import WattsStrogatz __all__ = [] From 9f956936bd129e152e700c1388cd47c1e8ad2b58 Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 11:01:46 -0400 Subject: [PATCH 06/22] added connected watts strogatz method; --- netrw/rewire/__init__.py | 1 + netrw/rewire/connected_watts_strogatz.py | 38 ++++++++++++++++++++++++ 2 files changed, 39 insertions(+) create mode 100644 netrw/rewire/connected_watts_strogatz.py diff --git a/netrw/rewire/__init__.py b/netrw/rewire/__init__.py index 7d6df5f..c99c85b 100644 --- a/netrw/rewire/__init__.py +++ b/netrw/rewire/__init__.py @@ -1,5 +1,6 @@ from .base import BaseRewirer from .algebraic_connectivity import AlgebraicConnectivity from .watts_strogatz import WattsStrogatz +from .connected_watts_strogatz import ConnectedWattsStrogatz __all__ = [] diff --git a/netrw/rewire/connected_watts_strogatz.py b/netrw/rewire/connected_watts_strogatz.py new file mode 100644 index 0000000..e20b30c --- /dev/null +++ b/netrw/rewire/connected_watts_strogatz.py @@ -0,0 +1,38 @@ +from .base import BaseRewirer +import networkx as nx + +class ConnectedWattsStrogatz(BaseRewirer): + """ + Rewire a ring lattice network of size n with node degree k with probability p. + It initializes a ring lattice network of size n where each node is connected + to its k nearest neighbors. Then each edge is rewired to a randomly chosen node + with probability p. The resulting network is then checked for connectivity. + If the network is connected, it is returned. If it is not connected, the process + is rerun. + + Watts, D., Strogatz, S. Collective dynamics of ‘small-world’ networks. Nature 393, 440–442 (1998). https://doi.org/10.1038/30918 + """ + + def connected_watts_strogatz_network(n, k, p, tries=100, seed=None): + """ + Generate a Watts-Strogatz network with n nodes where each node is connected + to its k-nearest neighbors and each edge is rewired with probability p. The + process is repeated until a connected graph results or the number of attempts + has reached maximum (tries). + + This is done with networkx standard implementation. + + Aric A. Hagberg, Daniel A. Schult and Pieter J. Swart, “Exploring network structure, dynamics, and function using NetworkX”, in Proceedings of the 7th Python in Science Conference (SciPy2008), Gäel Varoquaux, Travis Vaught, and Jarrod Millman (Eds), (Pasadena, CA USA), pp. 11–15, Aug 2008 + + Parameters: + n (int) - number of nodes + k (int) - number of nearest-neighbors with which each node connects + p (float) - probability of edge rewiring + tries (int) - number of iterations to attempt to create connected graph + seed (int) - indicator of random seed generator state + + Returns: + G (networkx) + """ + return nx.connected_watts_strogatz_graph(n, k, p, tries, seed) + From a38de55f1259f9b98ef30505d69d632752d43a5c Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 11:03:01 -0400 Subject: [PATCH 07/22] fixed formatting connected_watts_strogatz --- netrw/rewire/connected_watts_strogatz.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/netrw/rewire/connected_watts_strogatz.py b/netrw/rewire/connected_watts_strogatz.py index e20b30c..791b2c9 100644 --- a/netrw/rewire/connected_watts_strogatz.py +++ b/netrw/rewire/connected_watts_strogatz.py @@ -1,6 +1,7 @@ from .base import BaseRewirer import networkx as nx + class ConnectedWattsStrogatz(BaseRewirer): """ Rewire a ring lattice network of size n with node degree k with probability p. @@ -35,4 +36,3 @@ def connected_watts_strogatz_network(n, k, p, tries=100, seed=None): G (networkx) """ return nx.connected_watts_strogatz_graph(n, k, p, tries, seed) - From b33d7831ae68043f74d682e0575c1e9adfaa705b Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 14:39:07 -0400 Subject: [PATCH 08/22] Changed Watts-Strogatz to be global edge rewiring per discussion with Brennan --- netrw/.DS_Store | Bin 0 -> 6148 bytes netrw/rewire/Untitled.ipynb | 176 ++++++++++++++++++++ netrw/rewire/connected_watts_strogatz.py | 38 ----- netrw/rewire/dk_rewiring.py | 198 +++++++++++++++++++++++ netrw/rewire/global_rewiring.py | 97 +++++++++++ netrw/rewire/watts_strogatz.py | 33 ---- 6 files changed, 471 insertions(+), 71 deletions(-) create mode 100644 netrw/.DS_Store create mode 100644 netrw/rewire/Untitled.ipynb delete mode 100644 netrw/rewire/connected_watts_strogatz.py create mode 100644 netrw/rewire/dk_rewiring.py create mode 100644 netrw/rewire/global_rewiring.py delete mode 100644 netrw/rewire/watts_strogatz.py diff --git a/netrw/.DS_Store b/netrw/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..96167cfa5b893998145b60a58c1b3606c31fcc56 GIT binary patch literal 6148 zcmeHK%}&BV5S|5;5@NzZ6OK*162zbq7$2>AXb5~Sz7C;0a=kNX?l$U-eeT<;rV;8mhsst^7Md(8p63jvT6#Mj3te*^e zrr&437Y2j4R(lbdY;IvOZ{@9`b?#lu#EaYUaNxH4r&K$VGV~{Q+dmGvNvpKHC!@F> zMBTnh2s&L1IXelWj!axRj5-6A>*)roU=>=W@@Q1AZ&vJ$`u4bDj~a~{*<0gr!CF~e z+c|9Agtw7=P$L9^f3=b&gA;f}V`}_&UOx(DbcOy&&LozR8DIvOf%#*=tW;KU{yvSr zh#6o8{+Iz;A8b@Y$6%^aEge{>D*z%LBbA^{hegV<4LSx>jo5-BbSk1w73PW|bUONN z6XzIAHR^N_=JFxTn}xZd2=#XC-&Wxu9F1Hu1I)lQ16f@y(f+^x{r!JBiEGRNGw`n% z5V@w;ba6;#Z=D$&?X@=Q1u6-}r5fK;&`?`3#?n??Mpc4-n+!z9V5$*4D0~o5G;qNT H{3-))DClJ4 literal 0 HcmV?d00001 diff --git a/netrw/rewire/Untitled.ipynb b/netrw/rewire/Untitled.ipynb new file mode 100644 index 0000000..f6bfd30 --- /dev/null +++ b/netrw/rewire/Untitled.ipynb @@ -0,0 +1,176 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "a740f082", + "metadata": {}, + "outputs": [], + "source": [ + "from global_rewiring import GlobalRewiring\n", + "import networkx as nx\n", + "import random" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "2e139b1c", + "metadata": {}, + "outputs": [], + "source": [ + "G = nx.Graph()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "6f16262a", + "metadata": {}, + "outputs": [], + "source": [ + "obj = GlobalRewiring()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "771094be", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/coryglover/Documents/colab_2022/netrw/netrw/rewire/global_rewiring.py:39: UserWarning: Resulting graph is empty as input was an empty graph and no edges can be rewired.\n", + " warnings.warn(\"Resulting graph is empty as input was an empty graph and no edges can be rewired.\")\n" + ] + } + ], + "source": [ + "new_G = obj.global_edge_rewiring(G,p=.3,timesteps=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "0663aa25", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAb4AAAEuCAYAAADx63eqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAEiklEQVR4nO3VMQEAIAzAMMC/5+ECjiYK+nXPzCwAiDi/AwDgJeMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AlAvcsAZYWWSZ3AAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nx.draw(G,with_labels=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "8f4d1f77", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nx.draw(new_G,with_labels=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "46c51aff", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(G.edges())" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "31a187b8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(new_G.edges())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b7007f03", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9b512c91", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:root] *", + "language": "python", + "name": "conda-root-py" + }, + "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.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/netrw/rewire/connected_watts_strogatz.py b/netrw/rewire/connected_watts_strogatz.py deleted file mode 100644 index 791b2c9..0000000 --- a/netrw/rewire/connected_watts_strogatz.py +++ /dev/null @@ -1,38 +0,0 @@ -from .base import BaseRewirer -import networkx as nx - - -class ConnectedWattsStrogatz(BaseRewirer): - """ - Rewire a ring lattice network of size n with node degree k with probability p. - It initializes a ring lattice network of size n where each node is connected - to its k nearest neighbors. Then each edge is rewired to a randomly chosen node - with probability p. The resulting network is then checked for connectivity. - If the network is connected, it is returned. If it is not connected, the process - is rerun. - - Watts, D., Strogatz, S. Collective dynamics of ‘small-world’ networks. Nature 393, 440–442 (1998). https://doi.org/10.1038/30918 - """ - - def connected_watts_strogatz_network(n, k, p, tries=100, seed=None): - """ - Generate a Watts-Strogatz network with n nodes where each node is connected - to its k-nearest neighbors and each edge is rewired with probability p. The - process is repeated until a connected graph results or the number of attempts - has reached maximum (tries). - - This is done with networkx standard implementation. - - Aric A. Hagberg, Daniel A. Schult and Pieter J. Swart, “Exploring network structure, dynamics, and function using NetworkX”, in Proceedings of the 7th Python in Science Conference (SciPy2008), Gäel Varoquaux, Travis Vaught, and Jarrod Millman (Eds), (Pasadena, CA USA), pp. 11–15, Aug 2008 - - Parameters: - n (int) - number of nodes - k (int) - number of nearest-neighbors with which each node connects - p (float) - probability of edge rewiring - tries (int) - number of iterations to attempt to create connected graph - seed (int) - indicator of random seed generator state - - Returns: - G (networkx) - """ - return nx.connected_watts_strogatz_graph(n, k, p, tries, seed) diff --git a/netrw/rewire/dk_rewiring.py b/netrw/rewire/dk_rewiring.py new file mode 100644 index 0000000..f54a8e9 --- /dev/null +++ b/netrw/rewire/dk_rewiring.py @@ -0,0 +1,198 @@ +from .base import BaseRewirer +import networkx as nx +import warnings +import copy +import numpy as np + +class DkRewire(BaseRewirer): + """ + Rewires a given network such that its "d"k-distribution is preserved. + This class preserves distributions up through 4k-distributions. + It can be implemented for one time step or a series of rewirings. + At each steps, a pair of edges is selected and rewired such that the + "d"k-distribution is preserved for a given value of d. + + Orsini, C. et al. Quantifying randomness in real networks. Nat. Commun. 6:8627 doi: 10.1038/ncomms9627 (2015). + """ + def dk_rewire(G,d,copy_network=True,timesteps=1,tries=100,directed=False,verbose=False,seed=None): + """ + This function calls the necessary function to rewire such that the + 'd'k-distribution is preserved for given d. This function is implemented + for undirected, simple networks. + + Parameters: + G (networkx) + d (int) - distribution to analyze + d = 0 - average degree + d = 1 - degree distribution + d = 2 - joint degree distribution + d = 3 - triangle and wedge degree distributions + d = 4 - star, path, triangle with path, square, square with diagonal, and K4 distributions + copy_network (bool) - update a copy of the network. default True. + timesteps (int) - number of edge swaps to perform. default 1. + tries (int) - maximum number of tries to perform an edge swap. default 100. + directed (bool) - indicator of whether to force directed graph to be undirected. default False. + verbose (bool) - indicator of whether edges rewired should be returned. default False. + seed (int) - indicator of random generator state + + Returns: + G (networkx) + prev_edges (dict) - edges deleted at each timestep + new_edges (dict) - edges added at each timestep + """ + # Check that graph is undirected + if nx.is_directed(G): + if directed: + warnings.warn("This algorithm is designed for undirected graphs. The graph input is directed and will be formatted to an undirected graph.", + SyntaxWarning) + G = nx.to_undirected(G) + else: + raise ValueError("This algorithm is designed for undirected graphs. If you wish to run anyway as an undirected graph, set directed=True") + + # Make copy if necessary + if copy_network: + G = copy.deepcopy(G) + + # Check for valid distributions + if d > 4 or d < 0: + raise ValueError("d must be 0, 1, 2, 3, or 4.") + + if type(d) is not int: + raise ValueError("d must be an integer.") + + # Calculate 0k-swap + if d == 0: + zero_k_swap(G,timesteps,verbose,seed) + + # Calculate 1k-swap + if d == 1: + one_k_swap(G,timesteps,tries,verbose,seed) + + # Calculate 2k-swap + if d == 2: + two_k_swap(G,timesteps,tries,verbose,seed) + + # Calculate 3k-swap + if d == 3: + three_k_swap(G,timesteps,tries,verbose,seed) + + # Calculate 4k-swap + if d == 4: + four_k_swap(G,timesteps,tries,verbose,seed) + + pass + + def zero_k_swap(G,timesteps,verbose,seed): + """ + Rewires one edge to a random node. This maintains the average degree of the network. + At each timestep, a random edge is chosen and a random end of the edge is chosen. + This edge is rewired to a randomly chosen node from all nodes in the graph with the + exception of the node being connected. + + + Parameters: + G (networkx) + timesteps (int) - number of edge swaps to perform + verbose (bool) - indicator of storing edges deleted and added + seed (int) - indicator of random seed generator state + + Returns: + G (networkx) + prev_edges (dict) - edges deleted at each timestep + new_edges (dict) - edges added at each timestep + """ + # Initialize dictionaries if verbose + if verbose: + prev_edges = {} + new_edges = {} + + # Edge swap for each time step + for t in range(timesteps): + # Choose a random edge + edge = np.random.choice(list(G.edges()),seed=seed) + + # Choose a random end of the edge + end_of_edge, not_end_of_edge = np.random.choice([0,1],2,seed=seed) + + # Choose a random node + nodes_to_choose = list(G.nodes()) + nodes_to_choose.pop(edge[end_of_edge]) + node = np.random.choice(nodes_to_choose,seed=seed) + + # If verbose, store edges + if verbose: + prev_edges[t] = [edge] + new_edges[t] = [(edge[not_end_of_edge],node)] + + # Update network + G.remove_edge(edge[0],edge[1]) + G.add_edge(edge[not_end_of_edge],node) + + return G + + def one_k_swap(G,timesteps,tries,verbose,seed): + """ + Rewires an edge while maintaining the degree distribution of the network. + A swap is done such that if edges (u,v) and (x,y) are selected, the new edges are (u,x) and (v,y) + or (u,y) and (v,x). Each is chosen with a fifty-percent chance. + + Parameters: + G (networkx) + timesteps (int) - number of edge swaps to perform + tries (int) - number of tries for each edge swap + verbose (bool) - indicator of storing edges deleted and added + seed (int) - indicator of random seed generator state + + Return: + G (networkx) + prev_edges (dict) - edges deleted at each timestep + new_edges (dict) - edges added at each timestep + """ + # intialize storing dictionaries if verbose + if verbose: + prev_edges = {} + new_edges = {} + + # Perform `timesteps` edge swaps + for t in range(timesteps): + # Attempt at rewiring + valid = False + for _ in range(tries): + # Get current edges + edges = list(G.edges()) + + # Choose two random edges + old_edge_1, old_edge_2 = np.random.choice(edges,2,seed=seed) + + if .5 < np.random.random(seed=seed) + # Swap edges + new_edge_1 = (old_edge_1[0],old_edge_2[0]) + new_edge_2 = (old_edge_1[1],old_edge_2[1]) + + # Check for valid edges + if new_edge_1 in list(G.edges()) or new_edge_2 not in list(G.edges()): + valid = True + break + + else: + new_edge_1 = (old_edge_1[0],old_edge_2[1]) + new_edge_2 = (old_edge_1[1],old_edge_2[0]) + # Check for valid edges + if new_edge_1 in list(G.edges()) or new_edge_2 not in list(G.edges()): + valid = True + break + + # Check that tries was not maximized + if valid is False: + raise RuntimeError("No pair of edges was found with new edges that did not exist in tries allotted.") + + # Store edges if verbose + if verbose: + prev_edges[t] = [old_edge_1,old_edge_2] + new_edges[t] = [new_edge_1,new_edge_2] + + # Update network + G.remove_edges_from([old_edge_1,old_edge_2]) + G.add_edges_from([new_edge_1,new_edge_2]) + + return G diff --git a/netrw/rewire/global_rewiring.py b/netrw/rewire/global_rewiring.py new file mode 100644 index 0000000..d3def0f --- /dev/null +++ b/netrw/rewire/global_rewiring.py @@ -0,0 +1,97 @@ +from base import BaseRewirer +import networkx as nx +import copy +import random +import warnings + + +class GlobalRewiring(BaseRewirer): + """ + Rewire a network where a random edge is chosen and rewired with probability p. + """ + + def global_edge_rewiring(self, G, p, timesteps=-1, tries=100, copy_graph=True, verbose=False): + """ + Generate a Watts-Strogatz network with n nodes where each node is connected + to its k-nearest neighbors and each edge is rewired with probability p. + + This is done with networkx standard implementation. + + Parameters: + G (networkx) + p (float) - probability of edge rewiring + timesteps (int) - number of edges to rewire. if -1, timesteps is the number of edges. + tries (int) - number of attempts to find a new edge. + copy_network (bool) - indicator of whether to rewire network copy + verbose (bool) - indicator to return edges changed at each timestep + + Returns: + G (networkx) + prev_edges (dict) - edges deleted at each timestep + new_edges (dict) - edges added at each timestep + """ + # Make copy if necessary + if copy_graph: + G = copy.deepcopy(G) + + # Check for empty graph + if len(G.edges()) == 0: + warnings.warn("Resulting graph is empty as input was an empty graph and no edges can be rewired.") + return G + + # If verbose save edge changes + if verbose: + prev_edges = {} + new_edges = {} + + # Give every edge opportunity to change + if timesteps == -1: + timesteps = len(list(G.edges())) + + # Rewire at each timestep + for t in range(timesteps): + # Attempt to rewire + valid = False + for _ in range(tries): + # Choose edge to rewire + edge = random.choice(list(G.edges())) + + # Choose end to rewire + end_to_rewire = random.choice([0,1]) + end_to_stay = abs(end_to_rewire-1) + + # Choose random node to rewire to + nodes_to_choose = list(G.nodes()) + nodes_to_choose.pop(edge[end_to_stay]) + node = random.choice(nodes_to_choose) + + # Rewire edge + if end_to_rewire == 0: + new_edge = (node,edge[end_to_stay]) + else: + new_edge = (edge[end_to_stay],node) + + # Check that edge is new + if new_edge not in G.edges(): + valid = True + break + + # Check that no edge was added + if valid is False: + warnings.warn("No rewiring occured as no new edge was found in tries allotted.") + + else: + # Update dictionaries if verbose + if verbose: + prev_edges[t] = [edge] + new_edges[t] = [new_edge] + + # Update network + G.remove_edge(edge[0],edge[1]) + G.add_edge(new_edge[0],new_edge[1]) + + if verbose: + return G, prev_edges, new_edges + + else: + return G diff --git a/netrw/rewire/watts_strogatz.py b/netrw/rewire/watts_strogatz.py deleted file mode 100644 index 47a46e1..0000000 --- a/netrw/rewire/watts_strogatz.py +++ /dev/null @@ -1,33 +0,0 @@ -from .base import BaseRewirer -import networkx as nx - - -class WattsStrogatz(BaseRewirer): - """ - Rewire a ring lattice network of size n with node degree k with probability p. - It initializes a ring lattice network of size n where each node is connected - to its k nearest neighbors. Then each edge is rewired to a randomly chosen node - with probability p. The resulting network is then returned. - - Watts, D., Strogatz, S. Collective dynamics of ‘small-world’ networks. Nature 393, 440–442 (1998). https://doi.org/10.1038/30918 - """ - - def watts_strogatz_network(n, k, p, seed=None): - """ - Generate a Watts-Strogatz network with n nodes where each node is connected - to its k-nearest neighbors and each edge is rewired with probability p. - - This is done with networkx standard implementation. - - Aric A. Hagberg, Daniel A. Schult and Pieter J. Swart, “Exploring network structure, dynamics, and function using NetworkX”, in Proceedings of the 7th Python in Science Conference (SciPy2008), Gäel Varoquaux, Travis Vaught, and Jarrod Millman (Eds), (Pasadena, CA USA), pp. 11–15, Aug 2008 - - Parameters: - n (int) - number of nodes - k (int) - number of nearest-neighbors with which each node connects - p (float) - probability of edge rewiring - seed (int) - indicator of random seed generator state - - Returns: - G (networkx) - """ - return nx.watts_strogatz_graph(n, k, p, seed) From 5c34e92c05ec5dae8ca1a6763813ba2b9d1c5753 Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 14:42:50 -0400 Subject: [PATCH 09/22] minor formatting for global_rewiring --- netrw/rewire/__init__.py | 3 +-- netrw/rewire/global_rewiring.py | 25 +++++++++++++++---------- 2 files changed, 16 insertions(+), 12 deletions(-) diff --git a/netrw/rewire/__init__.py b/netrw/rewire/__init__.py index c99c85b..9938e9e 100644 --- a/netrw/rewire/__init__.py +++ b/netrw/rewire/__init__.py @@ -1,6 +1,5 @@ from .base import BaseRewirer from .algebraic_connectivity import AlgebraicConnectivity -from .watts_strogatz import WattsStrogatz -from .connected_watts_strogatz import ConnectedWattsStrogatz +from .global_rewiring import GlobalRewiring __all__ = [] diff --git a/netrw/rewire/global_rewiring.py b/netrw/rewire/global_rewiring.py index d3def0f..0652998 100644 --- a/netrw/rewire/global_rewiring.py +++ b/netrw/rewire/global_rewiring.py @@ -1,5 +1,4 @@ from base import BaseRewirer -import networkx as nx import copy import random import warnings @@ -10,7 +9,9 @@ class GlobalRewiring(BaseRewirer): Rewire a network where a random edge is chosen and rewired with probability p. """ - def global_edge_rewiring(self, G, p, timesteps=-1, tries=100, copy_graph=True, verbose=False): + def global_edge_rewiring( + self, G, p, timesteps=-1, tries=100, copy_graph=True, verbose=False + ): """ Generate a Watts-Strogatz network with n nodes where each node is connected to its k-nearest neighbors and each edge is rewired with probability p. @@ -36,7 +37,9 @@ def global_edge_rewiring(self, G, p, timesteps=-1, tries=100, copy_graph=True, v # Check for empty graph if len(G.edges()) == 0: - warnings.warn("Resulting graph is empty as input was an empty graph and no edges can be rewired.") + warnings.warn( + "Resulting graph is empty as input was an empty graph and no edges can be rewired." + ) return G # If verbose save edge changes @@ -57,8 +60,8 @@ def global_edge_rewiring(self, G, p, timesteps=-1, tries=100, copy_graph=True, v edge = random.choice(list(G.edges())) # Choose end to rewire - end_to_rewire = random.choice([0,1]) - end_to_stay = abs(end_to_rewire-1) + end_to_rewire = random.choice([0, 1]) + end_to_stay = abs(end_to_rewire - 1) # Choose random node to rewire to nodes_to_choose = list(G.nodes()) @@ -67,9 +70,9 @@ def global_edge_rewiring(self, G, p, timesteps=-1, tries=100, copy_graph=True, v # Rewire edge if end_to_rewire == 0: - new_edge = (node,edge[end_to_stay]) + new_edge = (node, edge[end_to_stay]) else: - new_edge = (edge[end_to_stay],node) + new_edge = (edge[end_to_stay], node) # Check that edge is new if new_edge not in G.edges(): @@ -78,7 +81,9 @@ def global_edge_rewiring(self, G, p, timesteps=-1, tries=100, copy_graph=True, v # Check that no edge was added if valid is False: - warnings.warn("No rewiring occured as no new edge was found in tries allotted.") + warnings.warn( + "No rewiring occured as no new edge was found in tries allotted." + ) else: # Update dictionaries if verbose @@ -87,8 +92,8 @@ def global_edge_rewiring(self, G, p, timesteps=-1, tries=100, copy_graph=True, v new_edges[t] = [new_edge] # Update network - G.remove_edge(edge[0],edge[1]) - G.add_edge(new_edge[0],new_edge[1]) + G.remove_edge(edge[0], edge[1]) + G.add_edge(new_edge[0], new_edge[1]) if verbose: return G, prev_edges, new_edges From 0ba906279ed7f266bfbd27196bee844d70b34ff5 Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 14:44:16 -0400 Subject: [PATCH 10/22] removed dk --- netrw/rewire/dk_rewiring.py | 198 ------------------------------------ 1 file changed, 198 deletions(-) delete mode 100644 netrw/rewire/dk_rewiring.py diff --git a/netrw/rewire/dk_rewiring.py b/netrw/rewire/dk_rewiring.py deleted file mode 100644 index f54a8e9..0000000 --- a/netrw/rewire/dk_rewiring.py +++ /dev/null @@ -1,198 +0,0 @@ -from .base import BaseRewirer -import networkx as nx -import warnings -import copy -import numpy as np - -class DkRewire(BaseRewirer): - """ - Rewires a given network such that its "d"k-distribution is preserved. - This class preserves distributions up through 4k-distributions. - It can be implemented for one time step or a series of rewirings. - At each steps, a pair of edges is selected and rewired such that the - "d"k-distribution is preserved for a given value of d. - - Orsini, C. et al. Quantifying randomness in real networks. Nat. Commun. 6:8627 doi: 10.1038/ncomms9627 (2015). - """ - def dk_rewire(G,d,copy_network=True,timesteps=1,tries=100,directed=False,verbose=False,seed=None): - """ - This function calls the necessary function to rewire such that the - 'd'k-distribution is preserved for given d. This function is implemented - for undirected, simple networks. - - Parameters: - G (networkx) - d (int) - distribution to analyze - d = 0 - average degree - d = 1 - degree distribution - d = 2 - joint degree distribution - d = 3 - triangle and wedge degree distributions - d = 4 - star, path, triangle with path, square, square with diagonal, and K4 distributions - copy_network (bool) - update a copy of the network. default True. - timesteps (int) - number of edge swaps to perform. default 1. - tries (int) - maximum number of tries to perform an edge swap. default 100. - directed (bool) - indicator of whether to force directed graph to be undirected. default False. - verbose (bool) - indicator of whether edges rewired should be returned. default False. - seed (int) - indicator of random generator state - - Returns: - G (networkx) - prev_edges (dict) - edges deleted at each timestep - new_edges (dict) - edges added at each timestep - """ - # Check that graph is undirected - if nx.is_directed(G): - if directed: - warnings.warn("This algorithm is designed for undirected graphs. The graph input is directed and will be formatted to an undirected graph.", - SyntaxWarning) - G = nx.to_undirected(G) - else: - raise ValueError("This algorithm is designed for undirected graphs. If you wish to run anyway as an undirected graph, set directed=True") - - # Make copy if necessary - if copy_network: - G = copy.deepcopy(G) - - # Check for valid distributions - if d > 4 or d < 0: - raise ValueError("d must be 0, 1, 2, 3, or 4.") - - if type(d) is not int: - raise ValueError("d must be an integer.") - - # Calculate 0k-swap - if d == 0: - zero_k_swap(G,timesteps,verbose,seed) - - # Calculate 1k-swap - if d == 1: - one_k_swap(G,timesteps,tries,verbose,seed) - - # Calculate 2k-swap - if d == 2: - two_k_swap(G,timesteps,tries,verbose,seed) - - # Calculate 3k-swap - if d == 3: - three_k_swap(G,timesteps,tries,verbose,seed) - - # Calculate 4k-swap - if d == 4: - four_k_swap(G,timesteps,tries,verbose,seed) - - pass - - def zero_k_swap(G,timesteps,verbose,seed): - """ - Rewires one edge to a random node. This maintains the average degree of the network. - At each timestep, a random edge is chosen and a random end of the edge is chosen. - This edge is rewired to a randomly chosen node from all nodes in the graph with the - exception of the node being connected. - - - Parameters: - G (networkx) - timesteps (int) - number of edge swaps to perform - verbose (bool) - indicator of storing edges deleted and added - seed (int) - indicator of random seed generator state - - Returns: - G (networkx) - prev_edges (dict) - edges deleted at each timestep - new_edges (dict) - edges added at each timestep - """ - # Initialize dictionaries if verbose - if verbose: - prev_edges = {} - new_edges = {} - - # Edge swap for each time step - for t in range(timesteps): - # Choose a random edge - edge = np.random.choice(list(G.edges()),seed=seed) - - # Choose a random end of the edge - end_of_edge, not_end_of_edge = np.random.choice([0,1],2,seed=seed) - - # Choose a random node - nodes_to_choose = list(G.nodes()) - nodes_to_choose.pop(edge[end_of_edge]) - node = np.random.choice(nodes_to_choose,seed=seed) - - # If verbose, store edges - if verbose: - prev_edges[t] = [edge] - new_edges[t] = [(edge[not_end_of_edge],node)] - - # Update network - G.remove_edge(edge[0],edge[1]) - G.add_edge(edge[not_end_of_edge],node) - - return G - - def one_k_swap(G,timesteps,tries,verbose,seed): - """ - Rewires an edge while maintaining the degree distribution of the network. - A swap is done such that if edges (u,v) and (x,y) are selected, the new edges are (u,x) and (v,y) - or (u,y) and (v,x). Each is chosen with a fifty-percent chance. - - Parameters: - G (networkx) - timesteps (int) - number of edge swaps to perform - tries (int) - number of tries for each edge swap - verbose (bool) - indicator of storing edges deleted and added - seed (int) - indicator of random seed generator state - - Return: - G (networkx) - prev_edges (dict) - edges deleted at each timestep - new_edges (dict) - edges added at each timestep - """ - # intialize storing dictionaries if verbose - if verbose: - prev_edges = {} - new_edges = {} - - # Perform `timesteps` edge swaps - for t in range(timesteps): - # Attempt at rewiring - valid = False - for _ in range(tries): - # Get current edges - edges = list(G.edges()) - - # Choose two random edges - old_edge_1, old_edge_2 = np.random.choice(edges,2,seed=seed) - - if .5 < np.random.random(seed=seed) - # Swap edges - new_edge_1 = (old_edge_1[0],old_edge_2[0]) - new_edge_2 = (old_edge_1[1],old_edge_2[1]) - - # Check for valid edges - if new_edge_1 in list(G.edges()) or new_edge_2 not in list(G.edges()): - valid = True - break - - else: - new_edge_1 = (old_edge_1[0],old_edge_2[1]) - new_edge_2 = (old_edge_1[1],old_edge_2[0]) - # Check for valid edges - if new_edge_1 in list(G.edges()) or new_edge_2 not in list(G.edges()): - valid = True - break - - # Check that tries was not maximized - if valid is False: - raise RuntimeError("No pair of edges was found with new edges that did not exist in tries allotted.") - - # Store edges if verbose - if verbose: - prev_edges[t] = [old_edge_1,old_edge_2] - new_edges[t] = [new_edge_1,new_edge_2] - - # Update network - G.remove_edges_from([old_edge_1,old_edge_2]) - G.add_edges_from([new_edge_1,new_edge_2]) - - return G From a8360b31a37cb9c4c832ac554007fcc849133513 Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 14:49:02 -0400 Subject: [PATCH 11/22] added .base in global_rewiring.py --- .DS_Store | Bin 0 -> 6148 bytes netrw/rewire/Untitled.ipynb | 50 ++++++++++++++------------------ netrw/rewire/global_rewiring.py | 2 +- 3 files changed, 22 insertions(+), 30 deletions(-) create mode 100644 .DS_Store diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..20f19983184f617e642de92bdc86f48e076d0447 GIT binary patch literal 6148 zcmeHKU2D`p6ur~#x`{>1gF;_~fUl*ltXjmExF1MCD>PLfRMw3N8q6l^CUKQzAA5pg$foUUu`(C#oI5l3QQ%)!famU28qiZZz^tv$-vfF?yELV6Kgr$(NfscJmx+h) z-9OS05q0P>X8V9fxPnikM)r?JcAHX)sGvD5)-%P8vonK5KGRR|GngfDUUa*^#KvZ; zeW_!0tS#%c|2|vz#iS_n{$&1=Ye!j@1jq3tcpgWKv2$&ZrNtypqq!u+VT6=dFXA-J z7X7SD!(4KG)nVC|J$AO2%U-x=G4-Us4l4+WKWht-> zVjYxrMdLAiLr{D7PyRejvh*EVnPEfu5tJR$6W}ST3+C5Vcc5TIAE~5RMpM*M=$eCF z&}S+d>i%x2N%xhX{;2=r2~aL0svcRmWG&r5}4y^^fXoq(E}5T3RF~~j~GJH(eCOz zPh+J}(MjmThtPKx`h+6n-En6j)baQ&k<_|3_z^|JO;TW)v_A{8tKy z*3cjJ@k)AcJ@In9*ShdGa5m1X6iNyTy&cPdx8iNMH1xR~06mSBLbSllkARfH6h?t_ GRp2i;AEy!k literal 0 HcmV?d00001 diff --git a/netrw/rewire/Untitled.ipynb b/netrw/rewire/Untitled.ipynb index f6bfd30..8e5d58b 100644 --- a/netrw/rewire/Untitled.ipynb +++ b/netrw/rewire/Untitled.ipynb @@ -3,7 +3,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "a740f082", + "id": "9cd5b5b1", "metadata": {}, "outputs": [], "source": [ @@ -14,18 +14,19 @@ }, { "cell_type": "code", - "execution_count": 26, - "id": "2e139b1c", + "execution_count": 30, + "id": "f4978db2", "metadata": {}, "outputs": [], "source": [ - "G = nx.Graph()" + "G = nx.DiGraph()\n", + "G.add_edges_from([[0,1],[1,2],[2,3],[3,4],[4,0],[2,0],[3,0]])" ] }, { "cell_type": "code", - "execution_count": 27, - "id": "6f16262a", + "execution_count": 31, + "id": "e559a171", "metadata": {}, "outputs": [], "source": [ @@ -34,48 +35,39 @@ }, { "cell_type": "code", - "execution_count": 28, - "id": "771094be", + "execution_count": 32, + "id": "065a3d0c", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/coryglover/Documents/colab_2022/netrw/netrw/rewire/global_rewiring.py:39: UserWarning: Resulting graph is empty as input was an empty graph and no edges can be rewired.\n", - " warnings.warn(\"Resulting graph is empty as input was an empty graph and no edges can be rewired.\")\n" - ] - } - ], + "outputs": [], "source": [ "new_G = obj.global_edge_rewiring(G,p=.3,timesteps=100)" ] }, { "cell_type": "code", - "execution_count": 29, - "id": "0663aa25", + "execution_count": 33, + "id": "b41b0de8", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAb4AAAEuCAYAAADx63eqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAEiklEQVR4nO3VMQEAIAzAMMC/5+ECjiYK+nXPzCwAiDi/AwDgJeMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AFOMDIMX4AEgxPgBSjA+AlAvcsAZYWWSZ3AAAAABJRU5ErkJggg==\n", "text/plain": [ - "
" + "networkx.classes.digraph.DiGraph" ] }, + "execution_count": 33, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ - "nx.draw(G,with_labels=True)" + "type(new_G)" ] }, { "cell_type": "code", "execution_count": 25, - "id": "8f4d1f77", + "id": "fbb5141f", "metadata": {}, "outputs": [ { @@ -96,7 +88,7 @@ { "cell_type": "code", "execution_count": 19, - "id": "46c51aff", + "id": "e1877f92", "metadata": {}, "outputs": [ { @@ -117,7 +109,7 @@ { "cell_type": "code", "execution_count": 20, - "id": "31a187b8", + "id": "ecc2f507", "metadata": {}, "outputs": [ { @@ -138,7 +130,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b7007f03", + "id": "3a89853d", "metadata": {}, "outputs": [], "source": [] @@ -146,7 +138,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9b512c91", + "id": "405f9542", "metadata": {}, "outputs": [], "source": [] diff --git a/netrw/rewire/global_rewiring.py b/netrw/rewire/global_rewiring.py index 0652998..39b032c 100644 --- a/netrw/rewire/global_rewiring.py +++ b/netrw/rewire/global_rewiring.py @@ -1,4 +1,4 @@ -from base import BaseRewirer +from .base import BaseRewirer import copy import random import warnings From ea03b7dd4fb7c00ba2ed616f49abfddefccf2e4c Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 14:59:55 -0400 Subject: [PATCH 12/22] Added probability p for choosing to rewire --- netrw/rewire/global_rewiring.py | 82 +++++++++++++++++---------------- 1 file changed, 42 insertions(+), 40 deletions(-) diff --git a/netrw/rewire/global_rewiring.py b/netrw/rewire/global_rewiring.py index 39b032c..8c5fe97 100644 --- a/netrw/rewire/global_rewiring.py +++ b/netrw/rewire/global_rewiring.py @@ -53,47 +53,49 @@ def global_edge_rewiring( # Rewire at each timestep for t in range(timesteps): - # Attempt to rewire - valid = False - for _ in range(tries): - # Choose edge to rewire - edge = random.choice(list(G.edges())) - - # Choose end to rewire - end_to_rewire = random.choice([0, 1]) - end_to_stay = abs(end_to_rewire - 1) - - # Choose random node to rewire to - nodes_to_choose = list(G.nodes()) - nodes_to_choose.pop(edge[end_to_stay]) - node = random.choice(nodes_to_choose) - - # Rewire edge - if end_to_rewire == 0: - new_edge = (node, edge[end_to_stay]) + # Decide whether to rewire + if p < random.random(): + # Attempt to rewire + valid = False + for _ in range(tries): + # Choose edge to rewire + edge = random.choice(list(G.edges())) + + # Choose end to rewire + end_to_rewire = random.choice([0, 1]) + end_to_stay = abs(end_to_rewire - 1) + + # Choose random node to rewire to + nodes_to_choose = list(G.nodes()) + nodes_to_choose.pop(edge[end_to_stay]) + node = random.choice(nodes_to_choose) + + # Rewire edge + if end_to_rewire == 0: + new_edge = (node, edge[end_to_stay]) + else: + new_edge = (edge[end_to_stay], node) + + # Check that edge is new + if new_edge not in G.edges(): + valid = True + break + + # Check that no edge was added + if valid is False: + warnings.warn( + "No rewiring occured as no new edge was found in tries allotted." + ) + else: - new_edge = (edge[end_to_stay], node) - - # Check that edge is new - if new_edge not in G.edges(): - valid = True - break - - # Check that no edge was added - if valid is False: - warnings.warn( - "No rewiring occured as no new edge was found in tries allotted." - ) - - else: - # Update dictionaries if verbose - if verbose: - prev_edges[t] = [edge] - new_edges[t] = [new_edge] - - # Update network - G.remove_edge(edge[0], edge[1]) - G.add_edge(new_edge[0], new_edge[1]) + # Update dictionaries if verbose + if verbose: + prev_edges[t] = [edge] + new_edges[t] = [new_edge] + + # Update network + G.remove_edge(edge[0], edge[1]) + G.add_edge(new_edge[0], new_edge[1]) if verbose: return G, prev_edges, new_edges From 4ddd53cb2c4d244d70913b0e46bcbe5a99f3dc3f Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 15:04:15 -0400 Subject: [PATCH 13/22] Jupyter notebook and DS_Store removed from commit --- netrw/.DS_Store | Bin 6148 -> 0 bytes netrw/rewire/Untitled.ipynb | 168 ------------------------------------ 2 files changed, 168 deletions(-) delete mode 100644 netrw/.DS_Store delete mode 100644 netrw/rewire/Untitled.ipynb diff --git a/netrw/.DS_Store b/netrw/.DS_Store deleted file mode 100644 index 96167cfa5b893998145b60a58c1b3606c31fcc56..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6148 zcmeHK%}&BV5S|5;5@NzZ6OK*162zbq7$2>AXb5~Sz7C;0a=kNX?l$U-eeT<;rV;8mhsst^7Md(8p63jvT6#Mj3te*^e zrr&437Y2j4R(lbdY;IvOZ{@9`b?#lu#EaYUaNxH4r&K$VGV~{Q+dmGvNvpKHC!@F> zMBTnh2s&L1IXelWj!axRj5-6A>*)roU=>=W@@Q1AZ&vJ$`u4bDj~a~{*<0gr!CF~e z+c|9Agtw7=P$L9^f3=b&gA;f}V`}_&UOx(DbcOy&&LozR8DIvOf%#*=tW;KU{yvSr zh#6o8{+Iz;A8b@Y$6%^aEge{>D*z%LBbA^{hegV<4LSx>jo5-BbSk1w73PW|bUONN z6XzIAHR^N_=JFxTn}xZd2=#XC-&Wxu9F1Hu1I)lQ16f@y(f+^x{r!JBiEGRNGw`n% z5V@w;ba6;#Z=D$&?X@=Q1u6-}r5fK;&`?`3#?n??Mpc4-n+!z9V5$*4D0~o5G;qNT H{3-))DClJ4 diff --git a/netrw/rewire/Untitled.ipynb b/netrw/rewire/Untitled.ipynb deleted file mode 100644 index 8e5d58b..0000000 --- a/netrw/rewire/Untitled.ipynb +++ /dev/null @@ -1,168 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "9cd5b5b1", - "metadata": {}, - "outputs": [], - "source": [ - "from global_rewiring import GlobalRewiring\n", - "import networkx as nx\n", - "import random" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "f4978db2", - "metadata": {}, - "outputs": [], - "source": [ - "G = nx.DiGraph()\n", - "G.add_edges_from([[0,1],[1,2],[2,3],[3,4],[4,0],[2,0],[3,0]])" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "e559a171", - "metadata": {}, - "outputs": [], - "source": [ - "obj = GlobalRewiring()" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "065a3d0c", - "metadata": {}, - "outputs": [], - "source": [ - "new_G = obj.global_edge_rewiring(G,p=.3,timesteps=100)" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "b41b0de8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "networkx.classes.digraph.DiGraph" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "type(new_G)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "fbb5141f", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "nx.draw(new_G,with_labels=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "e1877f92", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "7" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(G.edges())" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "ecc2f507", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "7" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(new_G.edges())" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3a89853d", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "405f9542", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [conda env:root] *", - "language": "python", - "name": "conda-root-py" - }, - "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.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 92ebb4cb4dc246b596d36947e08143565e41c11f Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 15:05:23 -0400 Subject: [PATCH 14/22] removed extra .ds and .ipynb_checkpoints --- netrw/rewire/Untitled.ipynb | 185 ++++++++++++++++++++++++++++++++++++ 1 file changed, 185 insertions(+) create mode 100644 netrw/rewire/Untitled.ipynb diff --git a/netrw/rewire/Untitled.ipynb b/netrw/rewire/Untitled.ipynb new file mode 100644 index 0000000..c701925 --- /dev/null +++ b/netrw/rewire/Untitled.ipynb @@ -0,0 +1,185 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "ae7c3349", + "metadata": {}, + "outputs": [], + "source": [ + "from global_rewiring import GlobalRewiring\n", + "import networkx as nx\n", + "import random" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "167a0bf4", + "metadata": {}, + "outputs": [], + "source": [ + "G = nx.DiGraph()\n", + "G.add_edges_from([[0,1],[1,2],[2,3],[3,4],[4,0],[2,0],[3,0]])" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "d7e5d455", + "metadata": {}, + "outputs": [], + "source": [ + "obj = GlobalRewiring()" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "9871a78e", + "metadata": {}, + "outputs": [], + "source": [ + "new_G = obj.global_edge_rewiring(G,p=.3,timesteps=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "78ef21f4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "networkx.classes.digraph.DiGraph" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(new_G)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "11d3093e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAb4AAAEuCAYAAADx63eqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOydd1QT2/f2N0gvUkJCLwLSUQQLCqKIgmIXFVDsFSuK2HvvihV7FxTsXlCxYO8duyD2AqL0luR5//AlP2MKCeD93nudz1oszcyZM2cmk3nO2WfvfRQAgBgYGBgYGP4QFP/XDWBgYGBgYPg7YYSPgYGBgeGPghE+BgYGBoY/Ckb4GBgYGBj+KBjhY2BgYGD4o2CEj4GBgYHhj4IRPgYGBgaGPwpG+BgYGBgY/igY4WNgYGBg+KNghI+BgYGB4Y+CET4GBgYGhj8KRvgYGBgYGP4oGOFjYGBgYPijYISPgYGBgeGPghE+BgYGBoY/Ckb4GBgYGBj+KBjhY2BgYGD4o2CEj4GBgYHhj4IRPgYGBgaGPwpG+BgYGBgY/igY4WNgYGBg+KNghI+BgYGB4Y9C6X/dAIb/Lln5JZRw+x09/ZRLucVcqqmmRA5GNambhxmxtFT/181jYGD4Q1EAgP91Ixj+W9x/+53Wpryk888ziYiohMsX7FNTUiQQUXN7Ng1rZkt1zXX/N41kqBaYzg3DvxFG+Biqld3XMmhe4lMq5vJI2pOloECkplSDpgQ6UJin1d/WPobqgencMPybYYSPodr4IXpPqKiMX3Hh/4+6siJNCXRkxO9fBNO5Yfi3w8zxMVQL999+p3mJT0VE782yrkKfwS0l7XqBpO8/lIiIisr4NC/xKdUx06U6Zrp/V3MZKsnuaxk0btZi+nYvmUozM0jTsRkZtBsj2F+UcY+yT8UQLzeTVEzsyKDtGJqX+EMdGfFj+KfAeHUyVAtrU15SMZcnst0iMkHwZzZyNykoqZCGg7dQmWIuj9alvPy7mspQSco7N3x1PdJpEkxadVoJ7ecV5lDmofmk6xNG5hGxpGpUmzKPLBJ0bh68+/6/aTgDwy8wwsdQZbLyS+j880ypZi8iosJnl6mGhg6pmjsLbQeIzj3LpK/5Jb+xlQxVpbxzo2HfhDTsGpOiek2h/YXPr5KKgQVpOniTgpIK6Xj3oLIvr6js61umc8Pwj4IRPoYqk3D7nUzl8h+eIU2XFqSgoCCyT4GIEu7IVg/D348snZuyzNekzKkl+KyookZKukZUmvmG6dww/KNg5vgYqszTT7lCXn3i4OZ8oZK3qcQKHCV2fzGXT5v2J9KFDddIUVGRFBQUSFFRUe7/V/Y4pj7x9ZX/ydK54ZcVUw0NHaFtiqqahNIiIvq/zs0QHxvZHiwGht8EI3wMVSa3mFthmfzUs6Rq5kTKukYSyxiYmFNgY33i8/nE5/MJQKX+L2k/n88nLpdbbfVVd/v+ifURESkoKBCr3VjSdPaV+h0rKqsRv6RQaBu/tJAUVNSJ6Efn5unHvAqfFQaG3w0jfAxVpqZaxY9RQepZ0vHsKr1QWRE5OztTnTp1SFGRscL/EwBAAGjAzlt07lmm1LLKbEsqeHhG8JlfWkzcb59IhW0h2JZbXPbb2srAICvM24WhyjgY1SRVJcmPUvG7J8TL/yrizfkzSgp8QvZbCgkJIQMDA+rUqROtXLmS7t27Jxh5MPz9lJs+1Wv83zbweQRuKRGfRwQ+gVtK4PNIw64xlWa9poKnlwncUsq5HEvKHCtSZpkLjq2ppvw/uAoGBmGYER9DlenqYUYrTj+XuL8g9Qxp2DUhRVUNiWXKyrjkqlVIuy5cIB6PR+fPn6eUlBSKiYmhL1++kI+PDzVv3pyaN2/OjAj/JgoKCujYsWMUGxtLV79rkqZnMEFRiXIux1HO5dj/K/foHOl4hZJu057E7jyZsk/F0Nfjy0jF2I7YHcYLyqkpKZKDsfb/4lIYGIRgMrcwVAuDd92i5CefKwxpEIeCApGXhRZp34+jffv2UUhICI0bN46sra2JiOjjx4904cIFSklJoZSUFPr8+TMjhL+JkpISOnHiBMXFxVFSUhI1btyYunTpQi/ffaa4QmdSUFKpdN2qSop0ZUILJocnw/8c5m3BUC0Mb24r1dwpDQUel8YEONH69evpyZMnpKenRw0bNqSQkBC6e/cuGRsbU3BwsGD/48ePKTQ0lJ49e0ahoaGMabSKcLlcSk5Opv79+5OxsTGtWLGCmjVrRk+fPqXOnTvTrFmzKP3xffKy1iMxkSiyAT7x3z+ktMf3q7XtDAyVgRnxMVQbLYfOpOdarqSorCbzMSgrIb2Ms8T69oQOHjxIOjo/3OHz8vJo48aNtGLFCnJycqIJEyZQixbiYwA/ffokMI0yI0LZ4PP5dOXKFYqNjaWEhASytLSk0NBQ6tatG5mamtKBAwdoypQpZGpqSgsXLqSGDRvS/bffqev6S1QG+dVPWRE00CqPVk4fSx07dqT58+eTvr7+b7gyBoaKYd4GDNXChAkTKGXzXAq2UyF15RoVjgzA55NqDaIwZw36eDGeOBwOeXt709u3b4mISFtbmyIjIyk9PZ1CQ0NpxIgR1KBBA9q/fz/xeMKp0YyMjJgRoQwAoNu3b1NUVBRZWVlReHg4mZiY0JUrV+jGjRs0ZswYev78OTVq1IjmzZtHq1atojNnzlDDhg2JiCj91jkqvLyblBXl6yur1lCg4it7SbPkKz158oSUlJTIycmJtm/fTky/m+F/ATPiY6gy0dHRFBkZSatWraJhw4bRg3ffaV3KSzr58D3VqKFIXPxf/6p8yRq8TyWFJ6fo2dVk2r9/P40dO5b69OlDO3fupGPHjpGbm5vQOfh8Ph07dowWLVpEX758oXHjxlHfvn1JTa3i0eWfPiJ88uQJxcbGUlxcHPF4PAoNDaWQkBBycXERlLl79y5NnDiRXr58SXPnzqXg4GChe3Ly5Enq3bs3HTt2jHrN3kQ81w5UxidSkHrfQOrKSjQl0IG8jYgCAgKoa9euNHfuXLp9+zaFh4eTmpoarVu3jlxdXX/jHWBgEIYRPoYqsX//furRowdFRkbSokWLBNu5XC4ZWtjQxI2H6UOBAl27c5+0VWtQUMvG1NXdjL59ekt2dnZ0/PhxCgwMpPXr19OyZctowoQJNGXKFNq1axcFBASInA8AXbp0iRYvXky3bt2ikSNH0rBhw0hXV1fmNv8JQvjq1Svat28fxcbGUlZWFgUHB1NoaCjVr19fyFyclpZG06ZNo3PnztHUqVNp0KBBpKIi7MBy4cIF6tq1Kx0+fJiSk5Pp5s2bxKrtTi9Vrek99EhZSYl+XpRDTUmReHw+lby6TQfmDqUG1hwiIsrMzKR27dqRs7Mzbdy4kRQUFGjTpk00ffp06tOnD82YMYO0tLT+lvvD8IcDBoZKcubMGSgrKyMkJERk38WLF+Hm5ib4PG/ePEycOFGoTEBAAExMTASfZ82ahbp16+LEiRMwNDTE5s2bpZ7/4cOH6N27N/T19REZGYl3795V6jo+fvyIuLg4DB06FA4ODtDT00PHjh2xYsUK3L17Fzwer1L1/t18+PABK1euhKenJwwMDDB06FCkpKSIbf+nT58wfPhwsFgszJ49G3l5eWLrvHHjBthsNk6fPo379+/DwMAAjx49gp6eHl68eAEtlhGiTz5Cj1UnYD94BSLi7iLm/Etk5RWjffv2WLNmjVB9+fn5aNOmDdq2bYv8/HwAwOfPn9GnTx+YmZkhISEBfD6/+m8OA8NPMMLHUCnu3bsHVVVVNG3aVOyLddKkSZg8ebLg89q1azF06FChMl++fEGNGjUEAsfn8zFixAj4+Pjg/v37sLa2xtSpUyt8Eb5+/RoRERHQ09NDv3798Pjx4ypdmzgh7NChA5YvX447d+6Ay+VWqf7qJCsrCxs3boSvry90dXXRp08fJCUlobS0VGz5nJwcTJs2Dfr6+oiIiMCXL18k1v3w4UMYGhri6NGjKCsrg4eHBzZt2oSlS5eiR48eOHfuHBo2bAgAuH79Oho0aCB0/M2bN2FmZobi4mKh7aWlpejTpw8aNWqEzMxMwfbz58/D2dkZrVu3xosXLyp7SxgYKoQRPga5SUtLg5aWFhwcHFBUVCS2jJubGy5evCj4vGfPHgQHB4uUCwsLg46OjkA8eTweQkND0aFDB7x//x6NGjVCr169UFJSUmG7vn79itmzZ4PD4aBjx464cuVKJa9QmH+aEObm5mLXrl1o27YtatasiW7duuHgwYMSvwsAKC4uxooVK8DhcNC7d2+8evVK6jmeP38OExMTxMbGAgAWLlwIPz8/lJaWwsLCAjdv3sTMmTMRFRUFALh//z7q1KkjUk9gYCDWr18vsp3P52PixImwt7dHRkaGYHtpaSkWL14MFouFmTNnSr0mBobKwggfg1x8/PgRBgYGMDIywtevX8WWef/+PfT09FBWVibYlpiYiICAAJGyBQUFUFZWxqxZswTbSkpKEBAQgH79+iE/Px+dOnWCr68vvn37JlMbCwoKsGbNGlhZWcHb2xvHjh2rVnPl/0IICwsLkZCQgK5du6JmzZpo164ddu/ejdzcXKnHcblc7NixA5aWlmjXrh0ePHhQ4blev34NS0tLbNq0CQDw5MkTsFgsvHr1CnFxcfDx8QEA+Pr64vjx4wCAp0+fws7OTqSuq1evwsLCQmLHJTo6GmZmZrh//75IG7p06QIbGxskJSVV2GYGBnlghI9BZr59+wYrKytoa2sL9dJ/ZcuWLejevbvQtitXrqBRo0Ziy48bNw5qampCvfv8/Hx4enoiKioKXC4Xo0aNgrOzM16/fi1ze8vKyhAbGws3Nzc4Oztjx44dEk2AVeF3CWFpaSkSExPRq1cv6OrqokWLFti0aZPEDsfP8Pl8HDt2DC4uLmjcuDEuXLgg87XUrl0bK1asAPBDOBs3bow1a9aAz+ejQYMGOHz4MIqLi6GpqYnv378DADIyMmBpaSm2Tn9/f4GIimPfvn1gs9k4d+6cyL6//voL1tbW6Nq1K96+fSvTNTAwVAQjfAwyUVhYiLp160JdXR137tyRWrZr167Ytm2b0LbHjx/D3t5ebPmysjJoamqKzAF+/foVTk5OWLx4MQBgxYoVMDU1rfD8v8Ln83Hy5Em0aNEC5ubmWLFihURnjuqgKkLI5XJx7tw5DBkyBAYGBmjcuDGio6Px4cMHmc9/+fJleHt7w8nJCYcPH5bZWeTr169wdXXF7NmzBdtWrlwpmMe9dOkSbG1tweVycfHiRbi7uwtds6Ghodh6L126hFq1akntdJw5cwZsNhvx8fEi+woLCzF9+nSwWCwsXbr0t3ReGP4sGOFjqJDS0lL4+vpCTU2tQrNTaWkpdHV18fHjR6HtHz58kPhiBIClS5dCSUkJ2dnZQtvfvn0LS0tLbN26FQCQkJAANpuNxMTESl3LjRs30LVrVxgYGGDatGlSnTuqi4qEsKysDNevX0dERARMTEzg5uaGhQsXVjgP9yupqano0KEDzM3NsXXrVrlGmjk5OWjQoAGioqIEQvny5UuwWCw8f/4cANClSxeBl+bcuXMxZswYwfHfvn2Djo6OxPr9/PwE36Ek7t69CxMTExFP0HKeP3+OVq1awcXFRWj+mIFBXhjhY5AKj8dDt27doK6uXmF4AfDDM+/nkUA5hYWFUFVVlXoeFouFTp06iex79uwZjIyMcPjwYQA/zKZGRkbYsGGDHFcizPPnzzF48GDo6elh+PDhSEtLq3Rd8lIuhN26dQOLxYKioiI0NTXh7++PhIQEuU2jb968Qb9+/cBms7F06VK5HUIKCgrg4+OD8PBwgejxeDz4+vpi6dKlAP5PBMtDEFq1aoUjR44I6igsLISamprEc5w/fx42NjZC877iSE9PR+3atTFlyhSxI1U+n4/9+/fD1NQUffv2/Vs6Lgz/PRjhY5AIn8/H8OHDoampiWnTpsl0zMSJEzFlyhSxdamoqEh9Ke/evRuKiopiRzq3bt0Cm81GSkoKgB/CZWtri8mTJ1cp7uvjx4+YOHEi9PX1ERISgrt371a6Lll48eIF5syZA2dnZ5ibmyMqKgqnTp1CbGys3KbRrKwsREZGQl9fH5MnT5bZ+edniouL0bp1a/Tq1UvIASgmJgYNGzYUnHvUqFGCOMzS0lJoaWkJjc55PB4UFBSkfhfNmjXDzp07K2zTly9f0KBBA/Tv31+iUObk5GDMmDFgs9mIiYn518RaMvwzYISPQSJz5syBlpYWevfuLbO41K1bF5cuXRK7j8PhiJhAf4bP58PCwgLe3t5i95fPA5XP8X358gWenp7o0aOHSKyYvOTk5GDx4sUwMTGBv78/zpw5U22B1G/fvsXSpUtRv359GBoaYsSIEbh06ZLEl3VFptGcnBzMmzcPLBYLQ4cOlWv+72fKysrQpUsXdOnSRUhgXr9+DQMDA6SmpgL4YcbU09MTJAi4cuUK6tatK1KfioqK1LCTs2fPws7OTqYRbV5eniDQvaCgQGK5e/fuoUmTJmjYsCFu375dYb0MDAAjfAwSiImJgba2Nvz8/Co0T5Xz7t076OvrSyxvZ2eHJ0+eSK0jOTkZioqKEl9iCQkJMDY2Fsw7FRYWokuXLmjWrJnI/GBlKC4uxpYtW2Bvb4/69esjPj6+Ul6ZX758wbp16+Dj4wN9fX30798fycnJMt/LnykXwkGDBsHQ0BAKCgowMTHBpEmTKu01yuPx0KtXL7Ru3Vqo08Dn89G6dWvMnTtXsG3x4sUICwsTfF6wYAFGjRolUqe2tjZycnIknpPP58Pb2xt79uyRqY3lge6enp7IysqSei1btmwBh8PBiBEjBJ6mDAySYISPQYT4+Hhoa2vDxcVFMKcjC5s3bxYbpF5Ow4YNcfXq1QrrcXV1hZOTk8T9GzduRK1atfD+/XsAPzwhx4wZA0dHR6lhFvLA4/Fw6NAheHp6onbt2tiwYUOFc2ffv3/Htm3bEBAQAB0dHYSGhuLIkSNVHo3yeDzs27cPtWvXRsuWLZGUlIR9+/YhPDwcjo6OcodP8Pl8hIeHw8fHR2Q0tX37dri5uQk8J0tLS2FmZibUEWndujUOHDggUi+bzcbnz5+lnvvUqVNwdHSUWaz5fD4mTJggEugujqysLAwaNAjGxsbYs2cPk/qMQSKM8DEIkZycDG1tbZiamuLTp09yHRsUFITt27dL3O/v7y9TMPK9e/egqKgo1XNz/vz5cHFxERrlrVy5EiYmJrh165Zc7ZYGn8/H+fPnERgYCGNjYyxYsEBoLq2goAD79u1Dp06dULNmTXTs2BFxcXFydRikkZycDA8PD7i7u+PUqVNiy3z8+FFmIeTz+Rg/fjwaNGggMjr78OED2Gy20Dzn3r170bx5c8HnsrIy1KxZUyjVWDlmZmZ48+aN1Ovh8/nw9PREXFycLJcvYOXKlTA1NRUJdBfH1atX4ebmBl9f3yqnr2P4b8IIH4OA69evQ0dHB/r6+nj27Jlcx5aWlkJHR0eqWAYHB2Pv3r0y1efj4wNTU1OJvXY+n48xY8bAy8tLaNRy8OBBGBgY4K+//pKr/bLw4MEDhIWFQU9PD507d0bHjh2ho6MDf39/bNu2rVLOJZK4desWWrZsCVtbW8TFxcnlvCFNCIcNGwYXFxcR0yGfz0fHjh0xdepUoW3169fH0aNHBdtu3LgBFxcXsee1tbUVmKClkZSUBGdnZ7kdUuLi4oQcnKRRVlaG6OhoGBgYYNKkSVLnCRn+PBjhYwDwI8BcX18f2traMpkjfyUlJQUeHh5SywwZMgTr1q2Tqb5Xr14JJbAWR/k8VWBgoFBQ89WrV2FkZISYmBjZGi8DXC4XycnJGDBgAHR1dWFiYgJ1dXWEhoZWOG8pD8+fP0f37t1hbGyMdevWVUuwdrkQNmnSBCoqKtDR0REZEcbFxcHJyUnILHvhwgXUrl1bSKCWLFmC4cOHiz2Pi4sLHj58WGF7yjPAJCQkyH0t5Q5Osh774cMHhISEwNLSUij8guHPhhE+Brx+/RomJibQ0dERxMrJy4QJE4RGC5LKzJ8/X+Y6u3TpAl1dXakOIaWlpWjbti3CwsKEXtAvXrxA7dq1MXHixEq7uvN4PFy+fBkjRoyAoaEhPDw8sHTpUoE5LysrC7NmzQKHw0GnTp0q1WEo5+PHjwgPDweLxcLcuXOrzVRazubNm2FpaYnXr1+LjAh1dHSgqqqK0aNHC5lGO3XqJNJRadu2Lfbv3y/2HB4eHrh586ZM7Tl27Bjq1KlTqe/mzp07MDExwdq1a2U+Jjk5GXZ2dmjfvr3ciQEY/nswwveH8+XLF9ja2oLNZsv1IvkVV1fXCldDWLBgAcaPHy9znZmZmVBWVhZKoSWOgoICeHt7IyIiQsg0mpmZiSZNmiAkJERmBxM+n487d+5g/PjxsLCwgKOjI2bPni3VhFdQUIDVq1fDysoKPj4++Ouvv2R2rPj+/TumTJkCfX19jB07Vqr3YmWJjY2FiYmJxGvo1KkT2rdvL2Qa9fPzg6amJi5fviwQQi6XK9Wc7eXlJTGU5Vf4fD7c3d1x6NChSl1TRYHu4iguLsbcuXOhr6+PefPmVdnpiOHfCyN8fzC5ublwd3eHqampyCKx8vD27Vvo6+tX6Km3fv16DB48WK66hw4dCjU1tQpHQN++fYOrqyvmzZsntL2wsBBBQUHw8fGRmtz56dOnmDFjBuzt7VGrVi1MmjQJ9+/fl8szsKysDHv27EHdunXh6uqKXbt2STRVFhUVYdmyZWCz2ejbt69cybfl4ejRozA0NJS4KsOhQ4dQu3ZtFBYWCrZ9+vQJAQEBcHd3F5ojHDt2LKysrCR+zy1atMDp06dlbtvhw4dRr169SntfyhLoLo709HS0bdsW9vb2crWX4b8DI3x/KMXFxfD19YWVlRV69OhRpcwXmzZtErsK+6/ExsaKrNpQEXl5eVBTU8OwYcMqLPvhwwdYW1uLpDLj8XiIjIyEg4MD0tPTBdszMjKwaNEiuLm5wdjYGBEREbh27VqV3eD5fD6SkpLg6+sLCwsLrFy5UiDcXC4X27Ztg4WFBTp06CAIEv8dnD59Gmw2Gzdu3BC7Pzs7GyYmJiIrN2RnZ0NPT08QLvLp0yfBHKGuri50dXXRvn17LFu2DLdv3xYIYWBgoGCZIlng8/moW7cujh07Vskr/PF8tG7dGu3atZPLgYXP5+Pw4cOwsLBAaGhopZMAMPw7YYTvD4TL5SIoKAg2Njbw9fWVaZFXaXTu3FmmVFRJSUnw9/eXu/7p06dDWVlZpryML168gImJiVjnh1WrVoHD4WDcuHFo0qQJWCwWBg8ejHPnzv22xWSvX7+OoKAgGBgYIDg4GA4ODvD29pbZJFhZLl++DAMDA5w/f15imb59+2LEiBEi2xcuXIjevXuLbO/YsSP27t0rEMJy02i5ELq4uGDJkiVy3cuEhAQ0aNCgSp2N0tJS9O7dG40bN5bbVJyfn4+JEyeCxWIhOjq6UgkGGP59MML3h8Hn8zFo0CDUrl0bzs7OVc5yUVJSAh0dnQoDl4Ef3pYNGzas1Dlq1qyJLl26yFT+7t27YLPZOHPmDIAfI5hNmzYJ5q1UVVUxffr0Kgu+rJQv4aOnpwdNTU0MHz78tzpY3LlzBxwOBydOnJBYJikpCVZWViLLM5WUlMDU1FQkZymPx4O+vr5gFPgz5UJoa2sLExMTiSNCcfB4PLi4uFR6tY1yyuMTHRwcKpXE4NGjR2jevDnc3Nyq5KTE8O+AEb4/jEmTJsHa2hqmpqbVsrDnuXPnUL9+fZnKPnnyROwq3bKwdu1aKCkp4cWLFzKVT0xMhLa2Nry9vVGzZk0EBQUhISEBhYWFuH79OoyNjavkzCMLDx8+RLt27WBhYYHt27eDy+Xiw4cPmDBhAvT19dGjRw/cu3evWs/5+PFjGBkZic2sUk5OTg4sLCyQnJwssm/37t1o0aKFyPb79++jdu3aUs/dr18/bN26VeKIUJIQ7tu3D40aNaqWTCsrVqyAmZmZTCvN/wqfz8fu3bthbGyMQYMG/RZHI4Z/Bozw/UEsW7YMFhYWYLFYMsVbyUJUVBSmT58uU9mPHz+Cw+FU6jxcLheGhoZo2rSpxDJFRUU4ePAgunfvjpo1a8LDwwM6OjpiM7mkpaXBzs4OUVFR1Z7ZPyMjA7179waHw8Hy5cvFpjr7/v07Fi1aBGNjYwQEBODs2bNVfvGnpaXBzMysQrPz0KFDMXDgQJHt5Z6W4ubpoqOjxR7za73i4jQrEsKSkhI4OjpKzEwjL7GxseBwOFLNvNL49u2bIIRl69atzMoP/0EY4ftD2L59O0xMTKCvr4+zZ89WW70uLi4ym4aKioqgoqJS6Rd8fHw8lJSUcO3aNcG20tJSnDhxAn369IGenh6aN2+ODRs2CFJqbd26FZaWlmJHt1lZWfD29kZwcLDca9iJIzMzExEREdDX18fUqVNlMiMXFxdj8+bNsLe3FwR1V2a+8d27d6hVq1aFCQLOnj0LMzMzsW1LSUmBvb292Bd9ly5dsGvXLql1R0REYPny5RW2VZwQ1qtXD1ZWVrh161a1zLeWO/ZUJki+nFu3bqFBgwbw8vKSKVUaw78HRvj+AI4cOQIOhwMjIyOZU4bJwps3b8BiseR6UampqVU6fRSfz4eNjQ0cHByQkpKC8PBwsNlsNGrUCCtWrBA7/wT8WF3AyclJrOmqqKgI3bt3h7e3t9RwB2nk5eVh9uzZYLFYGDZsmNSllyTB4/Fw8OBBNGrUCHZ2dti4caPMYvz582c4ODhg8eLFUsvl5+fD2tpaohdlhw4dxGa74fP5MDAwqDAP54QJE7BgwQKZ2vwznz59QmxsLHR0dGBhYSHXHKE0ygPdZc0WJA4ul4uYmBiw2WyMHTsWubm5la6L4Z8DI3z/cc6fPw8DAwPY2NhU+GKUlw0bNqBHjx5yHWNkZCRRoKTB5/Nx48YNdOvWDUQEKysrzJ8/X+aV06OiotCoUSMRZw7gh+hERUXB3t5erpXYS0tLsXbtWhgZGSEkJETm+Udp8Pl8pKSkoE2bNjA2NsbChQuljhy/ffsGNzc3mRYKjoiIEFpe6GeePXsGNpsttlOSmpqKWrVqVVj/jBkzMGPGjArLSWLnzp1o1qyZ3HOE0khLS4OtrS2mTp1aJVPy58+f0bdvX5iammL//v3Myg//chjh+w9T7t1Yt25djBgxotp/rJ06darQ/PUrDg4OePTokczlU1NTMWXKFNjY2MDW1hbTpk2Dk5MTTExM5Jp74fP56NevH/z9/SV6c65ZswbGxsYS497K4fF4iI2NhY2NDfz9/X/bAqj3799Hz549oa+vj6ioKJEOQ15eHjw9PUUy1ojj8uXLMDY2luiwMWzYMIkp59auXYt+/fpV2N4FCxZUKRFCWVkZbGxsRJJQV1UIP3/+jPr162PAgAFVDle4cOECnJ2d4e/vL1NCboZ/Jozw/Ud5/vw5jI2N0bRpU3Tu3Lna49TKQwxkia37GU9PT1y+fFlqmbS0NMybNw+urq4wMzNDZGQkbt26JXi537t3D8rKyiKB6hVRVlaGjh07IiQkRKJoHjlyBAYGBmITGvP5fJw8eRL16tVD/fr1BeESv5tXr15h1KhR0NPTw4ABA/D06VMUFRWhRYsWGDhwYIWiV1RUBHt7e4nzXV+/foWurq5EE2337t2lLjdVzvLlyxEREVHxBUlh69atYr1Kf6YyQpiXl4eAgAC0b9++yis1lJaWYsmSJWCxWJg+fbpQ1huGfweM8P0Hef/+PWrVqoWAgAA0btz4t/wwz5w5U6mYvNatW4tdMujdu3dYvnw5GjZsCDabjWHDhuHChQsSBcrf3x86OjpyO6UUFhbCx8cHw4cPlygYN27cgLGxMdasWSO0rUWLFqhdu/b/zNSVmZmJmTNnwsDAAEZGRmjVqpVMHZqJEyeia9euEvfPnz8fffv2FbuPz+eDw+HIFHe4bt06hIeHV1hOGqWlpahVqxYuXrwo8zGfPn3C/v37MWzYMDg5OUkUwtLSUvTq1atSge7iePPmjSARRFXjEBn+Xhjh+4+RnZ0NFxcXdOjQAXZ2dmIXDK0Oxo0bV6n5nJCQEOzZswfAjxd5TEwMmjVrBj09PfTt2xcnT56UyRyVlpYGZWVlzJo1S+42fP/+HW5ubpg5c6bEMunp6bC3t0e/fv0QFBQEExMTxMTEVMsyQVWhPOuOi4sLLCws0KxZMyQmJkoU4ps3b4LD4UhMLF1SUgITExOJXotPnjyBhYWFTG3bsmWLTCbRiti0aVOlMvyUI00Ib968KUhfV135URMTE2FtbY2goKAKHYAY/hkwwvcfIj8/H02aNEHHjh1hZGQkl6OGvDg7OwuFFchK//790bt3b7Rp0wY1a9ZEcHAwDh06VKlwgh49ekBdXb1SC8B++vQJtra2EoPY379/jz59+kBJSQmurq6V9visTng8Hvr37w8/Pz8UFRWhtLQUu3fvhqurK+rUqYPdu3cLCXNJSQlcXFywe/duiXXu3LkTLVu2lLg/JiYGvXr1kql9e/bsQWhoqOwXJIGSkhJYWlpWWwYVcULo7OwMHR0dxMXFVcs0QGFhIWbMmAEWi4UlS5b8zztIDNJhhO8/QklJCVq3bo3AwECwWCyZ10WrDK9fv4aBgYHML4zCwkLEx8ejS5cuUFVVhYODA/bu3SvWw1IePn36BFVVVQwdOrRSx6enp8PU1BSxsbGCbd++fcPEiROhr6+PcePG4f379wgJCYGXl9f/NJMHn8/HqFGj0KRJE5H7xufzkZiYiGbNmsHS0hLR0dHIz8/HjBkz0K5dO6mr2Lu5uUk104WGhkpdDPhnEhISZE4rVxExMTFo06ZNtdT1K+VC2KpVK9SoUQNaWlrVEj4B/Jhb9/f3h7Ozs0jyb2lk5hVjfcpLjI67g37bb2B03B2sT3mJrDxm6aTfASN8/wF4PB5CQ0PRokULcDgcsXNo1UlMTAx69uwptUxJSQmOHz+OsLAw6OrqomXLlti8eTOmT5+OqKioamvL6NGjoaKiUmkT04MHD8DhcHD06FEsXrwYbDYb/fv3F6qPx+NhwoQJqF27Nl6+fFldTZeLKVOmoF69ehWObq9du4YuXbpAT08PGhoaUlN3nT17Fo6OjhLnUfl8PkxMTGS+5uPHjyMwMFCmshVRXFwMMzOzCj1sq0pycjJYLBYiIyMrnCOUFT6fj/j4eJiZmaFPnz5S89jee/MNg3behN3URNhNTYTlxOOCP/v/v23wrpu49+ZbFa+U4WcUieFfDQAaPXo0vXr1itLT02nevHkUGBj4W8+ZlJREbdq0EdnO4/Ho7NmzNHjwYDIxMaEFCxZQo0aN6OnTp5ScnEwDBgwgExMT+v79e7W1ZdasWaSkpESjR4+u1PGOjo7Uv39/6tSpEx0/fpxSUlJoy5YtZG5uLiijqKhICxcupLFjx5K3tzddv369upovE4sWLaKDBw/SyZMnSVdXV2rZRo0a0b59+8jY2Jg8PDyoWbNmNGrUKHr9+rVI2eXLl9OYMWNIUVH8ayAtLY0UFBTI2tpapnaqqalRSUmJTGUrQlVVlSZOnEhz5syplvok0bJlSzp16hTFxsaSi4sLPXr0iJ4+fUq9evWitLQ06tWrFxkYGFCHDh1o+fLldOfOHeLxeFLrVFBQoK5du9Ljx4/JwMCAXFxcKCYmRuS43dcyKGTTNUp+8plKuHwq4fKF9hf//22nHn+mkE3XaPe1jOq+/D8WRvj+5cyZM4cuXLhAxcXF1Lt3bxo4cOBvPV9JSQmdO3eOAgICiOiH8F67do1Gjx5NZmZmNG7cOKpduzbdvn2bLl26RCNGjCBDQ0PB8Xp6etUqfDo6OjRp0iT666+/6NGjRzIfB4AOHz5MderUoStXrtCiRYvo2bNnUo8ZOnQobdq0idq1a0eHDx+uYstlY+3atbRx40ZKTk4mNpst0zFLly4lExMTOn/+PKWmppK6ujq5u7tTWFgYPXjwgIiInj17Rjdu3KCwsDCJ9Zw/f56aNWtGCgoKMp1XVVWViouLZSorCwMGDKA7d+7QnTt3qq1Ocbi7u9PFixdp+fLlNH36dOJwONStWzdau3ZtlYRQW1ubli5dSmfOnKHdu3dT48aN6fbt20T0Q/TmJT6hojIeAdLbBxAVlfFoXuITRvyqi//xiJOhCqxZswa2trZo2bIl+vXr97e42J8+fRoNGzbEvXv3MHHiRFhZWcHe3h4zZ87E06dPKzz+5MmTUp0pKkNhYSF0dXXh5eUlU/nz58+jcePGcHV1xV9//SW4b7t27YK5uXmF3n43b96EiYkJoqOjq9x2aWzfvh3m5uZCi+dWxOPHj8FisUTCD75//46FCxfC2NgYbdq0QYcOHSrM9hIWFiZXrOTNmzfh4eEhc3lZiI6ORqdOnaq1Tkl8/vwZHh4eGDhwoFTPYnHOMu3atcPSpUsl5hrl8XjYtm0bDA0N0XPkZNj/Yta0nHgcms7NUUNTDwoq6lDSM4F+m5EiZRymJeH+22+/8S78GTDC9y9l7969MDU1RXBwMAICAv4WL7Jnz56hSZMmMDAwgKWlJSZMmIC7d+/KJbjXr1+XeRkjeVi/fj1UVVVFsn78zP379xEYGAgrKyvs2rVL7AtqxYoVsLe3rzAw/9WrV3B0dMSYMWN+S/b+hIQEGBsb48mTJzIfw+Vy0bhxY6nLLRUVFWH58uVQVFREvXr1cODAAbHt5/P5MDc3l6kzU86DBw/g4uIic3lZKCwshLGxcbUv3ySJvLw8+Pv7o0OHDjIHussjhF+/fkWDsRthMf6oiKgZD1gLi3GHYDnxOEwGrYeipi6M+q4UKmM16TiG7Pp9jmt/Coyp81/IiRMnKCIigjp37kzPnz+n+Ph4UlZW/i3nevPmDS1dupQ8PDzIx8eHnjx5QgsXLqRXr17RwoULyc3NTWZTGBGRrq5utZo6yxk4cCCxWCwaMmQI4RfbUUZGBvXq1Yv8/f0pICCAnj59SmFhYVSjRg2ReiIiIigoKIgCAwMpLy9P4vmsrKzo8uXLdOfOHerevTsVFRVV27UkJSXRsGHDKDExkRwcHGQ+bvXq1aSsrExDhw6VWEZNTY0KCwupd+/eNGXKFFq4cCE5OjrS5s2bhebnMjIyqLS0lOzs7GQ+v5qaWrWaOomI1NXVady4cTR37txqrVcSWlpadOzYMapZsya1atWKsrOzKzzG0NBQxDTau3dvSk9Pp969e5OBgQG1b9+eli1bRveevKQcDTNSEDOvqsK2JAWl8t+xAimQAnG/fRQqAxCde5ZJX/OrZy71j+V/rbwM8nHlyhWw2WxMnjwZVlZW+PDhQ7Wf49OnT1izZg28vLygr6+PgQMH4syZM0hLSwObza7SCOfz588wMDCoxtb+H/Hx8VBXV8f+/fsBAF++fMGoUaOgr6+PGTNmyJxZn8/nY/DgwfDz80NxsXR38uLiYoSGhqJx48bVkiwgJSUFbDZb7hi2ly9fgsViVZgou7i4GMbGxoL1GPl8Ps6dO4fWrVvDxMQEixYtwvfv37Ft2zZ0795drja8fv0a5ubmch0jCwUFBTA0NKy2NSRlgcfjYdy4cXB0dKxyoPvPI0Lb9uGwGHdAZLRX/qdVLxAKSqogIqgY2sB8bLxIGfupiYg5/7/xLv6voABUNLXK8E/h0aNH1KJFCxo1ahStXr2aUlJS5BoRSOP79+908OBBiouLoxs3blC7du0oJCSE/P39SUVFhYiIYmJi6PLly7Rr165Kn6ekpIS0tLSotLRUrpGiLAAgBwcH+v79Ow0ZMoTWrl1LPXr0oKlTpwo52MgCj8ej4OBgUlBQoLi4OLGjw3L4fD5NnTqVEhISKDExkWxtbSvV/vL7HhcXRy1atJD5OD6fT35+ftS+fXsaO3as1LI7duygvXv30smTJ0X23b9/nxYvXkwnTpwgExMT6tmzJ02cOFHmdnz58oVcXFzoy5cvMh8jK0uWLKHbt29TXFxctdctjeXLl9OKFSsoKSmJXFxcqlxfxL67dPjeB6llwOdRyfunVPzmIel4diWFGkoiZTq7mdKKYLcqt+dPhRG+fwkZGRnUtGlTGjZsGK1YsYIOHjxI3t7eVaqzoKCAjh07RrGxsZSSkkJ+fn4UGhpKbdu2JQ0NDZHyHTt2pODgYOrRo0eVzquhoUGZmZmkqalZpXp+pbS0lCIjI2nNmjVUv3592rdvn8yu+OIoKSmhwMBAsrW1pZiYmAqFesOGDTRz5kw6ePAgNW7cWK5zPXjwgPz9/WnLli3Utm1buY6NiYmh7du30+XLl6UKNAByc3OjJUuWkL+/v8RyGRkZVLduXSIiCg4OpnHjxslk8szNzSVzc3PKycmRq/2ykJ+fTzY2NpSSkkKOjo7VXr80YmNjafTo0bR3715yd3en/Px8KigooPz8fKH/S/r35/+/t+1AZWx7mc779cQaUjawoJr1O4js83Pg0JY+Dar7Uv8YRLsSDP84Pn/+TP7+/jRo0CBau3YtrV+/vtKiV1JSQidOnKC4uDhKSkqixo0bU0hICO3cuZN0dHSkHpeSkkJbt26t7GUIKJ/nqy7h4/P5FBcXR9OmTSM7OztycXGh58+fE4fDqVK9qqqqdPjwYfL19aVp06ZVOM80ZMgQMjc3pw4dOtCGDRuoS5cuMp3n+fPn1Lp1a1q1apXcovfmzRuaNm0anT9/XqroERGdPXuWeDwetWrVSmo5RUVFUlVVpdTUVFq7di15e3uTj48PjR8/nho2bCjxuOoOZ/gZLS0tioiIoLlz59KePXsklgNAJSUlVRIncfvy8/OpVatWpKmpSXp6eqSpqUlaWlqkpaUl+P+v/3I4HNLS0iINDQ3Kzc2l9PR0SvzGozJZL5rPF5njK6em2u+Z0/9TYITvH05OTg61adOGOnfuTHFxcRQVFUVBQUFy1cHlcuncuXMUGxsriF0LCQmhVatWyRwbdvHiRXJyciIWi1WZyxCiXPhMTU2rVA8AOnnyJE2aNIlUVFRoy5Yt1Lx5c7p16xb5+PjQwoULq+wUoa2tTUlJSeTt7U1sNrvCQPnAwEA6efIktW/fnt68eUMRERFSy79+/ZpatWpFc+fOpe7du8vVNgA0ePBgGjNmDDk5OVVYfvny5TR27NgKR67nz58nHx8f4nA4NGvWLBo/fjxt3ryZunXrRtbW1jRhwgQKCAgQqUdFRYXKysqIz+dLDIr/ue1FRUVyiVN2djYdPHiQAgICSFFRUaJwKSkpCQmQNHHS1tYmY2NjqWXK/5+amkrt2rWjKVOmSHQg4vP5lJaWRrdv36bz58/TxYsX6cWLF0T0w3xu2rIPKerbERSFX728gu9U/Po+qds2JAUlFSrOuEcFT86TQfsokXOoKSmSg7G21PvLIB1G+P5HZOWXUMLtd/T0Uy7lFnOpppoSORjVpG4eZsTSUiUiouLiYurYsSM1bNiQrly5QoGBgTJnKOHz+XTlyhWKi4uj+Ph4srS0pJCQEJo9ezaZmZnJ3V5J2VoqQ3V4dl6/fp0mTpxIHz9+pPnz51Pnzp0FL+L69euTr68vrVixgkaNGlXlkR+bzaZTp06Rt7c3sVgsqUHfRD8Cosu/r4yMDFq2bJnY0djHjx+pZcuWFBkZSf3795e7XTt27KAvX75QVJToy/FXnjx5Qrdv36YDBw5UWLY8cJ3ox3NERBQSEkIBAQF08OBBGj58OBERdejQgdzc3KioqEggPIqKihQeHi4kauLEqbCwkFRUVGQSJy0tLdLT0yNzc3P6+vUrff36lSZMmCBWnDQ1NX+bh3N5oHtAQAB9/PiRpk+fTunp6XT79m26desWXb58me7fvy8QfR6PR66urhQVFUWtW7em+vXr07vMHPJfd4NE5pcUFCjvbhJ9PbmOCHxS0uGQnt8g0rDzFGkHiKiru/y/YYb/g5nj+5u5//Y7rU15SeefZxIRCaUpUlNSJBBRc3s2DfGuRbMjBpC6ujqVlZVRjRo1KDY2VmpPGgDdvXuXYmNjad++fVSzZk0KDQ2l4ODgSjtclOPo6Ei7du2i+vXrV6keoh+jouHDh8tt1iMievr0KU2ZMoWuX79OM2fOpL59+5KSkmj/7dmzZ1SvXj3q0aMHbd68ucptJvo/56Jt27bJlBbu+/fv1LlzZ9LT06Pdu3cLzZtmZWVR8+bNKTQ0lKZMmSJ3Wz58+EBubm506tQpcnNzIz6fL3XEtHr1atLU1KRmzZpVaOp78uQJ1axZk0pKSqiwsJDU1NRExKmoqIjevXtHxcXF5ObmRu7u7qSrq0tLliyh2bNnE4fDkThyKjf/ifveKiInJ4dsbGzo2rVrVX6m5QGAYCR34cIF2rlzJxUXF5O2tjapq6tTTk4OqaurU9OmTally5bk7e1NLi4ugt9rXl4eRUdH08qVK8m69wLKVDURFT8ZUFAgCnAypJiwqv8O/2QY4fsb+ZGm6CkVc6WnKVJQIFLgcYn97iJ5GpTRvXv36OTJk6Smpia2/JMnTyg2Npbi4uKIx+NRaGgohYSEVIsXGtEPZ4dGjRrRx48fKzRhyULPnj0pMDCQevbsKfMx79+/p5kzZ9Lhw4cpKiqKRo4cSerq6lKP6d27N8XHx9PDhw+r7SV57do1at++PR0+fJi8vLwqLF9SUkIDBgygly9f0rFjx0hPT48+fPhA7du3p0aNGtHQoUOpoKBA5rmmgoICysvLoydPnpCioiKpqKhQfn4+FRcXk4aGhtgRk5KSEp05c4ZCQ0PJwMBAqjmvsLCQunfvTo8ePSJtbW3S0NCQOnd47do1WrRoEV25coWGDx9Oa9asoYcPH8rtRSsPM2fOpDdv3lTLfLM4fha5n/9UVVWJxWJRaWkpffjwgRQUFIjNZtOMGTOoRYsWZGFhIWL+LSoqovXr19PixYvJz8+PZs6cSQ/e59DY429IQVlV7rapK9egfYM9qY6ZbjVd7Z8JY+r8m/i/3Hz8CssCRFBUoq8WzSjp/mG6fviwiOi9evWK9u3bR7GxsZSVlUXBwcG0Z88eql+/frWHCSQlJQnmVaoDXV1d+vbtm0xlv337RgsXLqTNmzfTwIED6fnz56SnpyfTsfPnz6eEhAQaM2YMHTt2TK42lpWVSRSgQYMGUWBgIA0bNox0dHQqdJLIz8+nzMxMgcm1Ro0apKqqSgUFBXTjxg2p81GmpqYi+65evUpfv36lY8eOkb6+PmlpaZG6urrE72fOnDlkZmZGGzdurPC6Y2NjqXnz5mRiYiLTffL09KRDhw7R06dPacmSJfT161eaOHEizZw5kywtLWW/4XIwevRoql27Nr169Ypq1apVpboACJkrb9++TXfu3CFNTU0yMzOjGjVqUFZWFpWVlZGzszN5e3uTt7c3eXl5kZaWFvXv3582b95MHTt2FPrdlZWV0datW2nu3LlUv359Sk5OJldXVzpz5gwNCAoiZUdf0vMbSKXS810Loa6sSFMCHRjRqwYY4fsbuP/2O81LfEqfrx2hgodnqDQzgzQdm5FBuzFERAReGWUdXUIlH18SL/cLGYbOJzXLOsQlRVL1CKK3BQqkp/djTmj//v0UFxdHL1++pK5du9KqVauoadOm1SZK4khMTJRrdFYRsszxFRUV0apVq2jp0qXUqVMnun//vti5ydLSUqmjIy8vLzp58iQNGzaM9PT0ZB5V8Xg8qXNOdevWpdWrV1PPnj3JzMxMIEDS5qr27t1L48ePJz8/Pzp+/HilvrPMzEzq1asXHT16VCa3/uLiYlq3bh2dOXNGpvp/nt+TBwcHB9qyZQulpKRQjRo1yN3dnQIDA2n8+PHk6uoqd33S0NPTo/DwcFqwYIFMYl7OzyL385+WlhY5OjqStrY2KSsrE4vFoqysLNLT06OmTZuSt7c3NWjQQKyFYefOnTRhwgTy9vamkydPkomJCcXGxtKMGTPIxsaGDhw4IPCE3bFjh8DZ6diKCfSSjGhu4hMqLuESSZvC4PNJVUmRpgQ6UpinlVz3ikE8jKnzb2DwrluU/OQzFTy9QqSgQEWv7hDKSoWEL+9OIqkY2VLW4YVk0CGK1CzrEBGRAhHZaRRR2bl1dPfuXerQoQOFhoaSn5/fb5vE/5ni4mLicDiUkZFB+vr6laqj3MW8XFxWrVpFnz59ogEDBogIT25uLl29epUuXrxIBgYG5ODgQDVq1JA4qiIiqSMmZWVlio+PJwMDAwoPDydtbW2ZPPhUVVUrHDmvXbuWVq5cSZcuXarQtFdWVkbdu3enzMxMevbsGcXExMjtnUv0w8nEwsKCFi9eLFP5bdu2UXx8PCUmJspU3sHBgWJjY6levXpyt42IqE6dOrR7926ysLCgmJgYio6OJnd3d5owYQI1bdq02qwRX79+JTs7O7pz547YkSUAevXqldiRnLu7O5mamhKfz6cPHz7QrVu3SEFBQSByTZs2JRcXlwrDQ35m2bJltGDBAtLV1SVDQ0OaN28eNW/eXNCWOXPm0Lp166i0tJQSExPJ0/OH08rO4yk0c/8VUrasRwr0Yymicsrn/B10+HR/7yK6f+6Y1JAjBtlhRny/maz8Ejr/PJMAIg37JkREVPLpJfHKsgRlFGooU80GHX98+KXnByJ6nq9Ms4aMoMSOgRLn+aoDAFRcXCwkLmfPniVzc3O6ePGi3LFPP2+rUaOGQFy4XC6VlZXRhw8fhJwdPn/+TNeuXSMdHR0aPHgwOTs7SxUnLS0tQVYZaTg6OtLixYupfv361eaZSkQ0fPhwyszMpDZt2tC5c+ckvpT4fD7169ePSkpK6OzZs/T48WOhcAdZxeDQoUN0584d2rZtm0zlAQgyj8jCp0+f6PPnz1SnTh2ZyoujPF+nrq4uTZw4kSIiImjnzp00YMAAMjAwoAkTJlCHDh2qbKEoz8u6cOFCWrdunUDkfv7T0NCg+vXrU506dahly5ZUv359unv3LqWkpJCpqSk1bdqUunXrRtHR0WRlZVUpUQYgWM9PW1ubsrKyaOvWreTj40NEPzo8Q4YMoYsXLxKXyxUSPSKi5H1baES9etRncAtKuPOOzt5+SqnP08m/eVNyMNamru4/vLzD047TiBEjqpQ1ieH/YEZ8v5mY82m04vRzIe/Nbxd2ES83SzDi+5l3a/uQQbtIwYiP6EfPb0wrOxriY0NEP35shYWF1RKY+/O2goICUlZWFhKXr1+/koaGBrm4uEgVoIr2/Tw6jY+Pp3379lFCQgIREaWkpNDEiROpuLiYFi5cKDZGrCoUFBSQubk5sVgsevr0qVw9+YoAQCNHjqTU1FQ6ceKESMcEAIWHh9PTp08pKSlJYC578+YNBQYGUosWLWjFihUVtik7O5tcXV1p3759MicvSE5OpsjISLp//75M93P//v20a9cuuedDf6Zp06Y0f/58atq0qdB2Ho9Hhw4dokWLFlFeXh5FRUVRWFgYqarK5+ABgDIyMgTelTExMQKnHg8PD/Lw8KDatWtTaWkppaam0qVLl+jBgwdUp04dwWiuSZMmZGBgUOlrLOfixYs0ZcoUyszMpNmzZ1NQUBCdOXOGevbsSRs3bqQWLVpQ165dKScnh9LT0+no0aNCGX2+fv1KNjY2lJaWJoiPvXHjBg0fPpxu3rwpdK6CggJyd3en2bNnU3BwcJXb/qfDjPh+M08/5YqsrCwvxVw+LVi/k2Z03yCIgSp3MZdFeFgsFllaWlYoTpqamiIu5g4ODrRnzx7y8PCo0jX8TPkc371792jSpEn07Nkzmjt3LoWEhPyWuUpNTU2aO3cuTZkyhXbv3k19+vSptroVFBRo1apV1KNHDwoNDaX4+HjBPQRA48ePp7t379Lp06eF5ogsLCzo0qVL1KVLFwoKCqK9e/eKTRNXztixYykoKEiujD2yBqyXU9n5vZ+RtEJDjRo1qGvXrhQUFEQpKSm0aNEimj59OkVERNCQIUOoZs2aIsf8LHI//6mpqVH9+vXJw8OD2rdvTzVq1KD27dvTxYsXKS4ujt6/f0+NGzcmb29vWrBgATVs2FDqvZWX27dv05QpU+jZs2c0c+ZM6tmzp+A7b9WqFSUlJVFgYCApKyuTm5ubWNEj+jHn1759e6GkEHp6emJXhNDU1KTdu3dT27ZtycvLq1KxuAz/ByN8v5ncYm611GNl50QRwTFka2tLtra2v9XkWU56ejp9+/at0vM9kigoKKC7d+9SmzZtaMqUKXTkyBGZTJZVYdCgQTR//nyKioqi4ODgar1/ioqKtHPnTmrfvr1glXYFBQWaM2cOnTp1is6dO0fa2qKZNnR1denEiRM0cOBA8vX1pWPHjokNtk9KSqLz58/Tw4cPZW7To0eP6N69e3KtFH/+/Hnq16+fzOXFoaamJrS80a8oKCiQr68v+fr60r1792jx4sVkbW1NAwcOpKCgIHrz5o1gTq5c5MpHcqNHjyY3NzfKzMykS5cu0aVLl+jy5cv05csXKioqolatWlF4eDi5urpWKkawIh4/fkzTpk2ja9eu0ZQpU2jgwIFin1tlZWWqUaMG5ebm0tmzZ+n06dMiogeANmzYIBKSoaenJ9HjuUGDBjRq1Cjq27cvnTp16rc6tP3XYe7cb6amWvX8AJ+n3qPBgweTt7c3aWtrk5GREXl6elK3bt0oMjKSVq5cSQcOHKCbN2/Sp0+fBBk3qkJ5tpbq+oF9/vyZRo4cSf369SMA9Pz5cxoxYsRvFz2iHy+jJUuWUFlZGa1evbra61dRUaEDBw5QamoqTZo0iVasWEF79uyhU6dOSXUKUlFRoR07dlBAQAA1btyYnj17JrQ/NzeXhgwZQps3byYtLS2Z27Ny5UoaPny4zKbErKwsevfuHbm5ucl8DnHIkq+zfCSXlpZGVlZW5OTkRNHR0dSoUSMaO3YsFRQU0KhRoyg1NZVevnxJ48aNIyUlJVqzZg05OztTSEgI3b9/n9q0aUOXL1+miIgIsrGxoVGjRlG9evWqXfTK19Vr3rw5NW7cmF68eEHDhg0T+9wmJydTy5YtqU+fPqSiokKWlpa0Y8cO4nKFO8ApKSmkrKxMTZo0Edquq6tLubm5En+/EydOpMLCQoqOjq6+C/wDYeb4fjM/z/GBzyPi8+j7pb3Ey/tKrDYjiRRrkIJiDQK3jIhA7zcMIlbgaFIzdyGqoUwKCgqkqqRIXe3VyLoknVJTU+n+/fv08OFDKioqIlNTU9LX1ycVFRXi8XiUl5dHHz58oNzcXDIzMyNzc3PBn4WFhdD/dXR0pJrB2rVrR7169arynEJubi4tW7aM1qxZQ2FhYTRkyBDy8fGhrKysig+uRvh8Pjk5OdGHDx/o9evXMscDysPXr1/JxcWFSkpK6P79+2Rubi7zsVu3bqXJkydTQkKCwKQ5dOhQ4vP5crntf/nyhRwcHOj58+cyz2UdPHiQNm/eLLP3pyTCwsKodevWgrRuAOjNmzdC3pW3b98mFRUVwUiu3GyppKREixcvpg0bNpCxsTGpqqpSWloaubi4CObnvLy8RPLLfvz4kZydnenx48dkZGRUpfb/zPv372nOnDmUkJBAI0eOpDFjxog1yZazfft2mjBhAkVFRdHixYvp8OHD5OrqSkFBQaShoUGxsbECc3dwcDA1bdqURowYIVKPjo4OZWRkSHw+09LSyNPTk86ePVvtoSJ/Cozw/Way8kvIa9FZKuHy6fvFPZRzOVZov45XKOk27Unv1vUnXq7wOmamQ7eQkq4hKYJHe7rXosbuwg95ZmYmPXr0iFJTU+nhw4eUmppKqamppKGhQY6OjmRpaUksFos0NDQIAH3+/JnevHlDb9++pTdv3hARiQhi+WcOh0NNmjSh169fVzqMoaSkhGJiYmjBggXUqlUrmj17NtWqVYvKyspIQ0Pjt6zJVxFJSUnUo0cPGjBgAC1durTa69+7dy9FRkaSgoICzZ8/n/r27SvX8SdPnqRevXrR2rVricViUZ8+fSg1NVUuN/ZZs2bRx48fKSYmRuZjRo0aRaampjRhwgS52vszACgkJIRYLBbp6ekJxE5ZWVkgbuV/JiYmAlG8dOkSXbx4kS5dukRv3ryhBg0akIqKCt2+fZscHR1p8uTJ5O/vL/VZGT16NCkpKdGyZcsq3f5yMjMzaeHChbR9+3YaOHAgjR8/XmpydgA0e/Zs2rFjB02aNImmTJlChw8fFozmSktLqV+/fpSRkUHHjh2jsrIysre3p4yMDNLV1RWpz8rKis6ePSt1Sa2tW7fSypUr6ebNm3I7CDEwwve3UB7HV6k7DT5ZKH6n51ujqH79+jRu3Dhq1qyZxJcAAHr37p2IGD59+pSMjIzI1dWVXFxcyNnZmSwtLUldXZ0+ffokEMTyv2fPntGnT5+IxWKJHTGWfzYxMRExLfF4PNq7dy9Nnz6dnJycaMGCBSIu8lpaWvTp0ye5zHfVAQBq0qQJPXz4kB4/fkwWFhbVVveRI0doyJAhdPr0aVJSUqLmzZvTxo0bqUMH0fXUpHHv3j1q27YtFRcX044dO6hdu3YyH1tcXExWVlZyL1Jct25d2rBhg5CrvTQA0Nu3b0VGcoWFhVSrVi0KCgoSiF15Fhg+ny/wtCwXu7KyMsFoztvbm+rWrSt4nsrKyiguLo4WL15MSkpKNH78eOrWrZtYU+b79+/J1dWVnj59Wumk5Dk5ObRs2TJau3atIIeqsbGx1GNKS0tpyJAhlJqaSmPHjqXRo0cLiV45fD6fxo8fT0lJSdS+fXv68uWLxJRr7u7utGnTJqkOZQAoKCiIbGxsaMmSJfJf7B8OI3x/A/fffqeQTdeoqEyO/ET/H0U+lxTORdOG+ZPp1atXtHTpUqpZsyZFRUVRly5dZJ7P4HK5lJ6eLiSGqamplJGRQTY2NuTi4iL4c3V1pVWrVpGBgQENHjxYRBR//vzlyxficDgCUSwrK6Pr16+TlpYWRUZGUqdOnYjNZosItZmZGV29elUuU2B1ceXKFWrTpg116NCh2uKikpOTqWfPnpSYmChI5H3z5k0KDAykAwcOCOK6ZGXAgAF08OBB6tmzJ0VHR8scgrFlyxY6dOgQHT9+XOZzZWdnk5WVFX39+lVsUoSfRa7879atW1SjRg2RkdzSpUvJ3Nycxo4dS8XFxXTz5k2B0F25coU4HI4g7VfTpk3JxsamwlE/AEpMTKRFixbRu3fvKDIykvr16yfiqTlixAjS1NSkRYsWyXztRCRI4r18+XJq27YtzZgxg6ysrCo8Licnh7p27Urq6urUv39/Gjx4sFjR+5mlS5fSxIkTaffu3RQSEiK2jJ+fH02cOLHCdROzsrKobt26tHv3bvL19a2wvQz/ByN8fxNLD1+n1Zfey5eYlldK9oWPaEgLJxoxYgR1796d5syZQ2fPnqUlS5bQhw8faMyYMdS/f/9KL+paXFxMT58+FRLD1NRUevPmDTk4OFCjRo2EBNHY2FgkJ+GHDx/oxIkTtHLlSvr69SvVr1+flJWVBQKZn58vmG8sF8itW7fS1KlTycfHh8zNzf/2jBSBgYF08eJFunLlSpXnSS5dukSdO3emgwcPisSvnT59mnr06CFYRaEcactSPb1/i7p160ZXrlyhQYMGkbq6OsXGxlb4HQMgFxcXWr16NbVo0ULm9h85coTWrVtHJ0+eFFgMfh3JKSoqiszJmZiYCD0L3759oyFDhtDnz5+Jx+PR3bt3ycnJSWh+rqrJq69evUqLFi2iq1ev0ogRI2j48OECU/zbt2/Jzc2Nnj17JtPcZklJCW3cuJHmz59PPj4+NGvWLJlHye/evaPAwEBq2rQpBQYGUr9+/SoUPaIfpuzBgwdTcXExHThwQGx4SteuXal79+4yrc944sQJGjx4MN2/f/+3zFn/V2GE728gKyuLPD09qdnAqXTmqw6RkjL9SEYmHgUFIjWlGhTpZ01xc4aRvr4+RUdHU1RUFF27dk2QGeLq1au0dOlSunDhAg0ZMoRGjhxZLVnx09LSyMvLiw4cOECPHz8WiOHDhw+Jy+UKCaGWlhbt27eP7t+/T7NmzaLevXuLjEILCwtFRozr1q0jS0tLys/Ppzdv3pCioqKI883P/zczM6vWEITU1FRq3LgxNW7cmE6dOlXpem7fvk1t2rSh3bt3k7+/v9gyCQkJNHr0aLpw4QLlq7CkLkvFJyLu63s0qqUDRfTuTKWlpTR48GB69OgRHT9+XOr3e/LkSZowYQLdvXtXprnTcpEbPnw45eXlkbq6uiB9168jOVNTU5E63759K5ibu3TpEr169Yo4HA6ZmZnRtGnTyNPT87eZsp88eUJLliyhw4cPU+/evWns2LFkYWFBQ4cOJX19fZo/f77EY7lcLu3YsYNmz55Nrq6uNGfOHLlCdu7fv0/t2rWj0aNHk7OzM/Xp00cm0SMi6tKlCwUEBFCtWrUoLCyMNm7cSJ06dRIqM3jwYPLw8KAhQ4bI1J4RI0ZQdnY27d27V+Zr+NNhhO83U1JSQi1btqRGjRrRpUuXqK5vB1Jw9qdzzzJFcvOp1lCg4pIS8nMyoohWjlTHTJeKi4spJCSESkpK6MCBA5ScnEzDhg2joKAgWrBgAWlqatKLFy9oxYoVFBsbS127dqXIyEi55nd+Zc2aNXT79m2xqbG+fPlCqampdPHiRdq7dy+lp6dTjRo1SF9fn1xdXQVziC4uLuTk5CQxcLhdu3Y0ZMgQat++PQGg79+/i5hRf/78/v170tHRETvPWP5/Y2NjuVzZw8LC6K+//qJDhw4J8irKw6NHj8jPz49iYmJEXl6/smHDBlqYcJlUPEOolAfp873gk7qKMk0JdKAwTysh54nExESJ321AQAD17NmTevfuLVolQO/fvxcZyRH9GPV37tyZOnfuLFHk+Hw+PX78WMgRpaioSGh+zs3NjZYvX07Z2dlymxsry7t372jlypW0detWateuHYWFhVFoaCi9ePFCxCmLz+fT/v37afr06WRqakrz5s2TSax+5tSpUxQWFkZr1qwhHR0d6tWrl8yi9+HDB3J2dqY3b96QtrY23b59m9q3b08zZswQErkJEyaQrq4uTZo0SaY2FRYWkoeHB02bNo169Ogh1/X8qTDC9xsBQH379qW8vDzicrmkq6tLO3bsIAUFBfqaX0IJd97RnbRPlHTmPAW1DyQHY206vXEueTdwE1ppncvl0oABAygtLY2OHz9OfD6fIiIi6PLly7R161ZBto3MzExat24drVu3jho1akRRUVHk7e0tt+dk27ZtqU+fPmJNLdnZ2bRgwQLaunUrDRkyhMaPH086Ojr05s0boZFhamoqPXv2jExNTYXE0MXFhezs7Khfv34UEBBAvXr1kqlNfD6fPn/+LHaesfxzVlYWGRkZiR0xlv/fwMBAcD8yMjLI1dWVbG1t6c6dO3Ldp7S0NGrWrBktWrRIppUrdl/LoBlHHhCPZE+X9mMZmv/LyF/uLp+QkCBiUk1NTSV/f3/KyMggZWVlgcj9PCcHQGQkp6WlRRYWFvT161ehuLSSkhK6deuWUKA4i8USmp+rXbu2yD2Ljo6m9PT0vz3O7Nu3bxQTE0OrVq0iZWVlwYLBCgoKBICOHTtG06ZNIzU1NZo3bx75+fnJ/bvYtm0bTZo0iRISEqigoEAu0SP6sTzU+/fvhbxtX758KfgdzJgxgxQUFGjhwoWUnZ0tcyJyIqI7d+5Q69at6datW9XqsPWfBQy/jXnz5sHDwwMDBw6En58fSkpKRMp8/foVurq6gs8XLlyAvb09+Hy+UDkej4eRI0fCzc0Nnz9/BgAcPXoUpqamGDFiBPLy8gRlCwoKsG7dOtja2qJRo0ZISEgAl8uVqc2FhYXQ1tZGdna20PaCggLMnz8fLBYLgwcPxvv37yusq6ysDE+ePMH+/fsxffp0dOnSBXZ2dlBTU4O+vj48PDwwb948HDlyBGlpaeDxeDK1URIlJSV49eoVzp8/j927d2PBggUIDw9Hu3btULduXejr60NNTQ21a9dGixYt0KdPHzRo0ABaWlqYPHkyUlNTkZubW+F53rx5AysrK2zYsEGmdt178w0O05JgOfG40J/JwPVQtagDBVUNKOkag915skgZh2lJuP/2m6Cu5ORksNlsxMXFAQD4fD7evXuHli1bwtfXF4GBgTA0NASbzUbr1q0xZcoUHDp0CG/evBF5pgDg2LFjaNGiBb59+4bExERMmjQJTZs2haamJtzd3TF69GjEx8fjw4cPMl3r+vXrMWTIEJnK/g6KioowZ84cKCoqokGDBpg1axYaNWoEV1dXHDlyROw9qAg+n4/p06fD2toaT58+xYkTJ2BgYIBLly7JXAeXy4W5uTnu3Lkjsu/Tp09wd3fH4MGDweVyERMTg4EDB8rdzvnz58PX17fKv6M/AUb4fhP79++Hubk5Jk+ejDp16uD79+9iyxUVFUFFRUXwmc/nw9nZGWfOnBEpy+fzMW3aNNjZ2eH169cAgOzsbPTu3Ru1atXC2bNnhcpzuVwcOHAAnp6esLGxwdq1a1FQUCC13UlJSfD29hZ8Li0tRUxMDExMTNCtWzc8ffpU5nsgicLCQgwYMABdunRBVFQU2rRpA3Nzc2hpaaFhw4bo378/li9fjlOnTuHjx4+VellJIj8/H0+ePMGpU6ewefNmjBs3DsrKylBTU4OdnR00NDSgo6MDFxcXBAYGYsiQIZg7dy527tyJc+fO4dq1a7C1tcXSpUtlPuegnTdhNUlY0CzGH4GSngn0WgyAxfgj4ITMg4KyKkwGbxAqZzXpOIbsuimo6/3794iOjkbNmjXh4OAADocDfX19KCkpYezYsTh48CBev35d4T17+/YtYmNj4ebmBkNDQ2hpacHX1xfTpk3DqVOnZOoAiGPbtm3o06dPpY6tTtq0aQM2mw1VVVWYmJhg8+bNYjueFVFSUoLevXujQYMG+PTpU6VED/jRwWjYsKHE/bm5uWjZsiU6deqE3bt3o0uXLnK3lcvlwtvbW65n80+FMXX+Bm7cuEHt2rWjiIgI2rBhA125coVMTU3FlgVASkpKVFJSIpifWrduHZ07d47i4+PFHrN8+XKKjo6m5ORksrOzIyKi48eP09ChQ6ljx460aNEiEaeCy5cv05IlS+jKlSsUHh5OI0aMEMmAQfQjENjQ0JAmTZpEBw4coClTppCZmRktXLiQGjRoUJXbIsTSpUvp48ePQgHH379/FwTk/2w2JSKRcAtnZ2exwb+VYebMmbRx40aaMmUKDRs2jL59+yZkSi3//6tXr+jWrVvE5/PJwMBAoiOOubk5GRkZ/Vi9+6cEBj9TmplBn3aOI/Ox8QKT2+e4aaRqYke6PsLm3xrEp9qPd9D9G5eJy+UKViA4duwYNW3alCwtLSk7O5vWrVsn9vr4fD49ffpUyBElPz+fvL296fbt2zRp0iQaOHBgtazvGBcXR0eOHKHY2NiKC/8G7t27R9OmTaPbt29TXl4evXr1iu7fv0+LFi2ix48fU0REBA0ePFhqBpZycnJyqEuXLoJFhC9dukRhYWF0+PBh8vLykqtd7du3p86dO1P//v0lliktLaW+ffvSgwcPSE9Pjy5evCjXOYiIXr16RQ0bNqQzZ85UaXmp/zz/Y+H9z/H69WuYmJhg9uzZ4HA4SE1NrfAYLS0t5OTkCD7n5ORAV1dXqjlxy5YtMDY2xt27dwXbsrOz0bdvX9SqVUvsiBEAnj59isGDB0NXVxdDhgzB8+fPhfbb2tpiw4YNaNCgAerVq4eTJ09W64irnE2bNqF///4VluPz+fj48SOSk5OxYsUKDBgwAA0bNoSmpibMzMzQunVrjBs3Dtu3b8ft27dRWFgod1tycnLAYrHAYrEkjnRyc3PRqFEjjB07FmVlZXj//j2uXbuG/fv3Y9myZYiIiEBQUBAaNGgAIyMjqKiowNLSEnWCI2E1/rCICdO4/xooKKvBYsIxwTY1Kzeo1/YUKWs98QiGrzmMjIwMoe8iJycHfn5+UFFREXoOSkpKcOXKFSxevBjt27eHvr4+rK2t0bt3b2zatAlPnjwBn89Hbm4uNDU1UVRUJPc9k8TBgwfRqVOnaqtPVp4+fYru3bvDyMgI0dHRKC4uRq9evTB37lxBmdu3byM4OBgsFguTJk3Cp0+fJNb35s0buLi4YMSIEeByuTh58iTYbLbcIz3gxztBX18f+fn5FZbl8Xjo2bMn1NTU8ObNG7nPBQDbt2+Hi4tLtX6v/zUY4atGcnNzUadOHYwdOxZsNhvnzp2T6TgOh4OPHz8KbRsyZAhmzZol9bj4+HixP8a//voLZmZmCA8Pl/gi//TpE6ZOnQoDAwN07twZly9fxuHDh6Gqqgpra2vExsb+1rmChISESplzyuHxeEhPT8fRo0cxf/58hIaGwtXVVTCH17lzZ0yfPh379+/H48ePUVZWJrW+FStWwNTUFDNmzBDZV1hYiObNm2Pw4MEydwKKi4uRlpaGkGjRuT3LicdhEXUYSjqG0G3eFxZRh8EJng1SVIJarXpiy0fE3RV7nnXr1sHU1BS1a9fG6NGj0axZM2hqaqJevXoYOXIk9u3bJ7EDlZSUhGbNmsl0PbKSmJiI1q1bV2ud0sjIyEC/fv1gYGCA+fPnC4nL06dPwWazRX4DaWlpGDZsGPT09DBkyBC8ePFCaP/du3dhZmaGZcuWgc/n4+TJkzAwMMDFixcr1cZp06ZhxIgRMpdPT0+Hrq4uzM3NZeo4/wqfz0fXrl0xZswYuY/9U2CEr5rgcrlo27YtQkNDYWpqitjYWJmPtbKyQlpamtC2e/fuwczMrMIXdvmcw4kTJ4S2f/v2Df3794eVlRVOnz4t8fj8/HxMnz4dmpqaUFRUhJ2dXaVGTfJy+vRptGjRotrrLS0txaNHj7Bv3z5MnToVnTp1gq2tLdTU1FCnTh307NkTCxYswLFjx/Dq1SuBuBcVFcHExATa2tpCnZCSkhIEBgaiR48eMjsI/Uy/7TfECtmPUd9qqJq7QFFNG2q16kHTuTk067QSW7b/9huCOt+/f499+/Zh+PDhUFVVhaqqKqysrKCjo4ONGzdKnE/+lYkTJ2L69OlyX5M0zpw5A19f32qtUxwfPnzA8OHDoa+vj6lTp+Lbt29iy4WGhmLBggVi933+/FnQ+evWrRtu3bqFEydOgM1mY//+/QBQZdErLS2FsbExHj58KPMx3759g7a2Nnbt2gUOh1OpUWZWVhZMTU2l/vb/ZBjhqyYiIiLQrFkzODk5yT257OzsjAcPHohsb9KkCQ4dOlTh8ZcuXQKbzUZ8fLzIvqSkJJibm2PIkCFC5lQA+PjxI4YNGwYWi4VZs2ahTp06sLGxQe3atRETE/NbBfDWrVuoV6/eb6v/VwoKCnDr1i1s27YNkZGRCAgIgKmpKbS1teHp6YmBAwciNDQULBYLvXv3BvDDK7Vbt27o2LEjSktL5TpfVlYW4uPj0XhsjETh+/VP1dQB+gHDxe6zCp0BJycncDgc6OrqokOHDujfvz/s7OxQXFwM4IeJi8PhICUlRaY2Nm7cWKJJvLJcvnwZjRs3rtY6fyYrKwvjx4+Hvr4+xowZI/BwlsSjR4/A4XCEvJ5/JS8vD8uXL4eenh5UVFSwYsWKahnpAT9Mv15eXnIdw+PxoKioiNLSUoGJVZb3wK+cPHkSZmZm+Pr1q9zH/tdh1uOrBmJiYigxMZG4XC61bNmSxo4dK9fxGhoaVFhYKLI9PDxcosPCz3h5edGpU6do1KhRIolvW7duLci4UqdOHUpOTqbc3FyaNm0aOTs7k6qqKj19+pSioqIoPT2dbt68SZs3b6bjx49TrVq1aPbs2b9l+aDyVdj/LjQ0NMjDw4P69u1LS5cupRMnTtC7d+/o9evXtHjxYnJ3dycdHR0qLCyknTt3kr6+Ppmbm9O1a9eoVatWdPPmTcrNzZVYf0FBAZ04cYKioqLI3d2datWqRVu3biVLHWVSkRC6V/rlFYFbSvyyYsq5fpC4+d9Iy7WlSDlwS0lfoYhsbW3J0dGRlJSU6NatW3Ts2DFyc3OjK1euUF5eHvXp04f27t1L3bp1qzCLR0FBAT148EDmpNSyoqqqKnUh2sqSm5tLs2fPJnt7e8rJyaH79+/T8uXLK0xI7eTkRM2bN5e6UoWmpiZlZ2eTrq4uzZ49mzZt2kR2dnbUtWtXio+Pl2vV+1+JiYmhoUOHynWMoqKi4Pfh7+9PiYmJFB4eLtfSVERE/v7+1KVLFwoPDycwPozC/K+V99/OyZMnYWhoiLZt26JLly6VMoc1a9ZMJBQB+GF+Y7PZIg4oknj27BksLCywfPlysfuPHj0KXV1dqKuro0ePHsjIyBDsS0xMRNOmTYXKP378GAMGDICenh6GDx+Oly9fynFV0snKyoKenl611VddHDp0CIaGhrC0tISzszPmz5+Pfv36oUGDBtDU1ISFhQUCAwMRGRmJKVOmYOjQofDy8oKmpiaaNm2KmTNn4uLFiwLX+cy8YthNTRQ7iqvZsAsUVTWhoKwGNWsPmAzZKLac3dREZOUVC9rI5/Px119/QU9PDyNHjkTjxo2hoaEBFxcXDBgwANOnT4exsTHmzZsncU7y1KlTco9EZCE1NRVOTk7VVl9hYSGWLFkCDoeDsLCwSj2DDx48gJGRkdhQnpKSEvTq1QuNGjUSjB6TkpKgra0NV1dXWFtbY+3atZWyfqSlpcHAwKBSTiY2NjZ49uyZ4POLFy9gbW2NmTNnyuVsVlhYCCcnJ+zatUvuNvyXYUZ8VeDx48cUFhZGvr6+9P37d9q9e7fMWfR/RlNTU+yIT01Njfr160cbNmyQqR47Ozu6ePEixcTE0IwZMwS9PB6PRzt27KCRI0eSp6cnBQYG0qVLl4RW+05MTKTAwECh+hwdHWnz5s306NEj0tHREaz4fv36dbmv8Vd0dHQoJyenWlaKr046duxIioqK9O7dO4qOjqZJkybR1q1b6dq1a3ThwgXq0aMHffr0idasWUNr166l+Ph4unHjBpmYmBCHwxGse/jq1SvicrlkoKVKzezYpECiPW69Fv3JfMw+sohMIMPus0hZz0SkjAIR+dqziaX1f8nNFRQUKD4+nsaPH0+rVq2iK1eu0Ldv32jbtm1Ur149evXqFampqdG0adPI1NSUoqKi6ODBg/T+/XtBHefPn69UmraKUFNTq3AFdlkoLS2l9evXk62tLV29epXOnj1Lu3btIhsbG7nrcnV1JS8vL5Hf0ffv36l169aUl5dHZ8+eJQ6HQ6dOnaJevXpRYmIiPXjwgHbu3EknT56kWrVq0dy5cyk7O1vm827cuJF69+5dqRyzenp69O3bN8FnW1tbunz5Mh05coTCw8OJx5NtpRd1dXXas2cPjRkzhl6/fi13O/6z/K+V99/Kly9fYG1tjbCwMNjb2yMrK6vSdXXt2hX79u0Tuy8tLQ0sFkuuHufnz5/h5uaGESNG4MiRI3BxcUGTJk2E5ipOnjwJCwsLDBw4EN+/f4eNjQ3u3bsntd68vDxER0fD0tISTZs2xdGjR6vk+flrGMc/gfnz58PS0lKQWWb9+vXo1q0bDAwMULt2bQwdOhTx8fFC33dJSQkePnyI2NhYTJ48GR06dIC1tTXU1NRgb28Ps7peMI9MkHmuT8j7M/IAZq7aKtTL//DhA/T09Cqcu8nIyICHhwdq164Nf39/sFgsmJqaokuXLrCyssLSpUtlcrGXh7dv38LU1LTSx3O5XGzfvh21atVCQEAAbt68WfFBMnD37l0YGxsLfkevX7+Gs7MzRo0aJbDSnDp1SuKc3qNHj9C3b1/o6elhzJgxFYYalJSUgMPhVDrhg7+/PxITE0W2/xzoLs87YdGiRfDx8amUReq/CCN8laC4uBheXl4ICgqCiYkJ0tPTq1Rf7969sW3bNon7W7duje3bt8tV54kTJ1CzZk3o6uri4MGDYs0jOTk5GDx4MIyMjMBisWQ2oZSVlSE2Nhbu7u5wcHDApk2bKmXOMTMzE2Sg+ScwZ84ccDgcdO/eHWpqalBUVISvry+2bdsmU0xVaWkpbty4gWXLlqFz585gsVhQU1ODpqYm6gYNh2XUQblEz2FaIpYcugZnZ2f06tVLIFJTp07F8OHDZbqm0tJSDBw4EO7u7nj//j1evnyJbdu2QVlZGfXr14eGhgbq1KmDQYMGYfPmzXj48GGVXo6ZmZlgsVhyH8fj8RAfHw9HR0d4e3vj/PnzlW6DJDp27Ijo6GjcuXMHpqamQlMCp06dApvNrtCR5e3btxg7diz09PTQp08fPHr0SGy5uLg4NG/evNJtDQ4Oxp49e8TuKykpQWhoKLy9vUVSC0qCy+XCx8cHixYtqnSb/kswwicnfD4fYWFh8PX1hYGBAW7dulXlOsPDw7F27VqJ+48ePYpGjRrJVFdqaio6dOgACwsLxMTEwN/fH506dZIqTOHh4dDS0kL//v0luoWLg8/n4+zZs2jTpg2MjIwwd+5cuTzIXFxccP/+fZnLVzffvn3DoUOHMGLECBgbG0NBQQH+/v5Ys2YNEhISoKurCycnJ4lCkJeXh+TkZMyYMQMtWrSAlpYWXF1dER4ejk2bNqFx48bo2LGjQLB2XX0Fh2lJsKpI9CYche2ko5i99yxyc3ORn5+PsLAwODs74+7du3LN+wI/vqe5c+fC0tISjx49wtmzZ+Hp6QngRyfu+vXrWLVqFXr27AlbW1toa2vD19cXEydOxKFDh2TO0wn8GJFoaWnJ1bbExETUq1cP7u7uSEpK+i0JE4AfnsTliQp+9oCWNtKTRHZ2NubOnQtDQ0O0b99e5FhfX19BPtXKMHToUKxZs0bifh6PhzFjxsDZ2VnmQPeMjAyw2Wyx+UL/NBjhk5M5c+bA1dUVHA4HSUlJ1VJnZGQkFi9eLHE/l8uFhYUFbt++LbHM69ev0bdvX7DZbCxbtkwgdCUlJejWrRv8/PwkunQHBARg165dGDp0KMzMzMSaWCri4cOHAlPQyJEjZRoF/66evSQKCwuRnJyMiRMnCpJTt2rVCj169ICBgYFI7z04OBiWlpbYunUrgB9B/wkJCYiIiBCMlry8vDBx4kQcP35c0PtOT0+Ho6MjIiIiRETz/ttvaBS5GdYTj8L+F6cX64lHYTn+MHyn7UXngRHw8PCAhoYGrKys0LZtW7Ru3RqqqqpwcnIShDDIQ3lcWO/evTFhwgSJ5bKyspCYmIgZM2agdevW0NfXh7m5Obp27YolS5bgwoULEnO+lpaWQklJSab2pKSkwMvLC46OjkhISPhtglfOxo0boaKigsjISMG2ctG7cOFCpeosLCzEunXrYG1tjSZNmuDIkSN4/PgxOBxOpXKDljN58mTMnj27wnJLliyBhYWFxJHnr+zatQtOTk5/S6zuPxlG+ORg3759MDU1hbm5ObZs2VJt9U6bNg0zZ86UWmbu3LliM7ZnZWVh7Nix0NfXx5QpU8QGL3O5XAwYMACenp4iI7KCggJoaWkJjjt9+jSsrKzQr18/uUZ/5bx79w4TJkwAi8VCcHCw1Dma9u3b48iRI3KfQ1bKyspw9epVzJ07F76+vtDU1ETjxo0xdepUnDt3DsXFxTh+/Dg4HI7I/Cafz0dycjLU1dWhrq4OW1tb6OrqIjAwEPPnz8fFixfFjqKvX78OY2NjrFq1SmKbOBwObj54gpjzLxERdxe9t1wBp+M4LE98AB2OqdB953K5eP78OQ4ePIhZs2ZBQ0MDSkpKqFGjBhwcHNCtWzfMmjULBw4cwPPnzys0U549exbKysqIioqS+T7y+Xw8f/4cu3btwogRI9CgQQNoaGjAzc0NQ4YMwdatW/Ho0SPweDzw+XwoKChIbceNGzfQqlUrWFtbY+fOnb993onP52Py5MmwsbFBfHw8zM3NUVxcjOTk5CqJ3s9wuVzs27cP7u7uYLFYCAwMrJLwLVmyRObMKzt37pQ50J3P5yM4OBijRo2qdNv+CzDCJyPXrl2DgYEBHB0dKxQpeVm4cCHGjx8vtczHjx+hq6sreCnm5+dj7ty5YLFYCA8Pr9AcxefzERkZCVdXV6HMJMePHxdJW5Wbm4thw4bBzMwMf/31V6WuKScnB8uWLYO5uTmaN2+Ov/76S8QRplevXtixY0el6hcHn8/Hw4cPsXLlSrRv3x46OjpwdXVFREQEjh07JuJIc/bsWbDZbFy7dg1lZWW4efMmVqxYgaCgIBgaGsLMzAy2trZgs9mIiIio0JHn4MGDMDAwwNGjRyWWOXXqFBo0aCCy3czMDOnp6QgKCsKmTZvEHnv8+HF4eHjg69evaNu2LVxdXREdHY1JkyahXbt2sLKygoaGBtzd3dG7d28sXrwYSUlJePv2rWA0VVRUBHV1dVhYWEgNd6iIoqIiXL16FStXrkRoaCisra2ho6MDPz8/KCkpYf/+/SK5MB8+fIhOnTrB1NQUMTExcicFqAzFxcXo2bMnPD098eXLFwA/5sxHjx4NNptdLaL3M4WFhahZsya8vLwEac8qs9LF5s2b0bdvX5nLl2ecOXz4cIVls7OzYWZmhpMnT8rdrv8KjPDJQEZGBoyNjeHh4YEBAwZUu0lm1apVMjkrBAcHY/ny5Vi3bh2MjY0RHBwskmdQGuVzPTY2Nnj16hUAYPjw4Vi4cKHY8mfPnkWtWrXQp08fmSfRf6W0tBS7d+9G3bp14eTkhK1btwrMdCNHjkR0dHSl6i0nPT0dmzZtQmhoKAwNDWFtbY2BAwciNjZWalaPs2fPQldXF3369EHLli2hra0NZ2dnDBkyBLt37xYkhH7//j10dHSkelHy+XwsXboUpqamFc759uvXD8uWLRPZ7ufnh6SkJBw6dEhi/swWLVoIHB54PB4WLVoEQ0NDIZN7bm4url27hs2bN2P06NHw8/ODoaEhdHR04OXlhfbt28PS0hIJCQlwdXXFoEGDKkyLJytfvnzB8ePHoaamBl9fX+jq6sLS0hJt2rSBu7s79PT0sHDhwr/NzPbt2zc0b94cnTt3FjpndHQ0FBUVqz1rDfDDlOjv7w/gx5xi9+7dYWBggClTpkhNiv0rBw8eRIcOHeQ6940bN2BkZISNGzdWWPb06dMwNTWtkjf6vxlG+CogJycHLi4uaNSoEdq0afNbeqmbN29Gv379pJbh8XiYPn06lJWV0apVqyo51axevRpmZmZ49OgRrK2tpTqY5OXlYfjw4TA1NcWxY8cqfc5y06G/vz9MTEywYMECREVFyT16/vz5M2JjYzFw4EDUqlULHA4HoaGh2Lx5s0DMxfHlyxccPHgQY8eOhbOzM4gIjo6OGD9+PI4ePSrVKWfixIlwcHAQmhsqp6ysDOHh4XB1da3QQ7W4uBh6enp49+6dyL5hw4YJVhVgsVgidZUnTv71+UtJSYGJiQmmT58u1WT45csXnDt3DoGBgahTpw6aNGkCbW1tqKiogMViYfjw4diyZQuuX78uNb2XLBgZGeHDhw/IyMhAt27dBOssurm5QV1dHe7u7ggPD8f27dvx5MmT35IMPSMjA05OTiLzrOXmzfr162Pz5s3Vfl5vb28cOHBAaNvLly8xdOhQ6OrqYujQoTIF4Z87d04koYQsPH/+HNbW1pg1a1aFHfQxY8aga9euv31u9Z8II3xSKCsrQ5s2bVC/fn3Uq1evyi8EScTGxiI4OFji/uTkZHh4eMDDwwMWFhYyr/ogjZ07d8LAwAAcDkemB//cuXOoVasWevXqVenRXzn37t1Dr169oK6ujnr16gllkPmVnJwcHDt2DBEREXB1dYWOjg7at2+PlStX4uHDh2Lbzufz8fLlS2zfvh0DBgyAvb09dHR00Lp1a0RERIDFYkl0FRdHdnY29PX1oaOjI9TW3NxcBAYGwt/fX6Z4xMOHD8PHx0fsvujoaAwbNgzAj5U5fk2s3Lt3b4mu6B8/fkTz5s3RsmVLgTlPEn5+foIODJ/PR3p6OgICAmBiYoKgoCDUq1cP6urqqFWrFjp06IDJkydj7969ePDggcxzVubm5ujXrx/09fUxceJEoU5FYWEhLl++jOXLlyM4OBhWVlbQ1dVFq1atMHXqVBw7dqzCa6iI27dvw9TUFCtWrBDaXi5658+fx8WLF1GrVq1q7cimpqbC2NhYYp2fPn3ClClTwGKx0L17d6nOavfu3YOLi0ul2vHx40fUq1cPQ4cOldoZKioqgouLS7VON/xbYIRPCqNGjYKTkxOsrKxElg2qTo4cOYJ27dqJbL958yZatmwJW1tb7Nu3DzweD6tXr0a3bt2q5bz9+/eHmpqazEmN8/LyMHLkSJiYmEidx5KVJUuWwNnZGfr6+ujRowfu3LmD4uJinDt3DlOnTkXjxo2hqakJX19fzJ07F1evXhVrluNyubh9+zaio6PRrVs3GBsbw8TEBMHBwVi9ejXu3bsHLpeLV69ewdzcXGrMpCQWLlwIR0dHQQLrd+/ewc3NDYMGDZL55RkSEoL169eL3XfixAn4+fkBAC5evAgnJyeBqL9//x56enpSOxxlZWWYOHEizMzMcPnyZbFlSkpKoKWlJeK0xOfzMX/+fFhYWODhw4coKyvD06dPkZCQgJkzZ6Jr166wt7eHmpoanJ2dERwcjDlz5uDQoUN48eKFYMSWnZ2NyZMnQ1FREWFhYTL/Zj59+oSjR49iypQpaNmyJXR0dFCrVi2EhIRgxYoVuHLlisxxon/99RcMDAxERl2nT58Gm80W8iIuj9GsLkaOHImpU6dWWC43NxfLli2DmZkZWrZsieTkZJEO3Js3b2BiYlLptpSv1VhRoPu9e/dgYGBQ5VjkfxuM8Elg7dq1MDc3B5vNrnT2BVlJTk4WWqLn+fPnghf4+vXrhV6s379/h66urlyxVZLw9/fHjBkzwGazcfz4cZmPS0lJgY2NDcLCwqqU+f3AgQPo2LEjzp07hzZt2kBVVRU1atSAnZ0dJkyYgOTkZLE/2oKCApw7dw6zZ8+Gv78/atasCUdHRwwePBg7d+5Eenq6yIvk/fv3sLGxwerVqyvV1oKCAhgbG0NfXx/79u2Dubk5Fi5cKLOZKD8/Hzo6OhJHM+np6TAzMwPww6xtZWUlWFx28uTJGDlypEznOXr0KNhsNpYvXy7StkuXLkldEWPPnj1gs9kS576Kiopw9+5d7Nq1CxMmTEBgYCAsLCygrq4OU1NTqKqqomHDhgLHicqa0Hg8Hh4/foxt27Zh6NChglFo/fr1MXz4cOzcuRPPnj0TqX/Dhg0wMjLClStXhLafPn1aMNL7mZSUFNja2lbLHGdBQQH09fXlSshQUlKCbdu2wdHREe7u7ti3b59ghJaXlwd1dfUqtam4uBghISFo2rSp1E7TkiVL4O3t/UdldWGETwwnTpwAi8WCnp6exN5zdXLlyhV4enriw4cPGDp0KFgsFubNmycxndTgwYMxZ86cKp0zPz9fkDLs2rVrMDQ0xN69e+U6ftSoUTAxMZErJIHP5+Px48dYvXo1vLy8oKSkBCcnJ4wcORLx8fFYt24dXF1d4erqih07dqCkpASZmZk4fPgwIiMj0ahRI2hoaMDT0xPjxo3DkSNHkJmZKfWcmZmZcHJywvz582VupzhiYmJgamoKFRUViSnmJBEbGyt1gVYulws1NTXBdz5lyhRERkYiPz8fBgYGciVnTk9Ph7u7O4KCgoTCW+bNm4eIiAipx547dw4cDgc7d+6s8DxFRUVYsWIFOBwOWrZsiTlz5mDkyJGCjEF6enpo2rSpIEHDhQsXKt1RKigowMWLF7F06VJ069YNFhYW0NPTQ0BAAKZNm4bu3bujVq1aIs5ekkSvHB8fn2pJ4Lx161a0bdu2UsfyeDwcOXIETZo0gbW1NdatW4eCggIoKSlVKl7z17ojIiLg7OyMt2/fSizj6+tb5d/HvwlG+H4hNTVVkN3hV3PJ7+LixYtgs9nQ19dHZGRkhZ5W5Y4OVempHjt2TCil0sOHDwVu5vJw/vx52NjYoGfPnhLb/ebNG2zbtg1hYWEwMTGBhYUF+vXrhzlz5sDZ2VmoLJ/PR1paGsaNGwcTExMoKSlBVVUVLVq0wJw5c3Du3DmJwdPi+P79O9zd3TFp0iS5rksca9asQY0aNaCvry+3R2CHDh0qTDvn4uIiyKrx+PFjGBsbY82aNejcubPcbS0qKsLQoUNha2sriFH09/eXyd390aNHsLKywuzZs8WO2kpLS7Fx40aYm5ujffv2IjGQPj4+SElJwefPn3HmzBmsXLkSAwcOhKenJ7S0tGBiYgJ/f3+MHTsW27Ztw82bNyuVM/Tjx4+Ij4+Hk5MTatasCS0tLdjY2KBHjx6Ijo7G6tWrwWKxpCZJOH36NOzt7as82mnYsGGVnL/KuXTpEtq3bw9DQ0NoamriyZMnVa6Tz+dj8eLFUgPd37x5AzabLXXe8b8EI3w/8fnzZ1hYWMDIyEhiAHJ1UlRUhKVLl0JPTw/a2tpymUk8PT1leolJYtiwYSLOEi9fvkStWrUkhjdIoqCgABERETA2NsahQ4cEi7AOHToUtWvXFqxwHRMTgxcvXghepmlpabC0tMTdu3exevVqdO/eHSYmJjAyMkK3bt0QHR2NPXv2ICQkBPr6+hg3bpzEXqs48vPz4eXlhZEjR1bJc43H42HcuHGws7PDypUrYW1tDXd3d5m9EbOzs1GzZs0KV0YPCgpCbGys4LO7uztMTU2rtBDqrl27YGBggM2bN0NbW1vmEdfHjx/h7u6O/v37C0ztPB4Pe/bsga2tLfz8/HD16lWxx/r7++PEiRNi9/H5fGRkZODYsWNYsGABevbsibp160JNTQ02Njbo2LEjpk6diri4OKSmpkqdP83OzkazZs0QFBSEwsJCcLlcpKamYsuWLWjbti1q1KgBNTU1NGzYECNHjsTu3buFnr/y9jRp0kQua8ev3LlzB+bm5tVqKkxNTUXNmjVRs2ZNjB07Vq7nXhLlge6SrFh79+6Fg4ODXB3LfyuM8P1/ioqK0KhRI5iZmcmV1aIycLlcbN26Febm5ujYsSPOnj0LY2NjuerYuXMnAgICKnV+Pp8PKysrPHz4UGTfu3fv4OTkhIkTJ8o1f5WUlISQkBCoqqpCSUkJfn5+WLp0Ke7evSskEIWFhUhJScHcuXPh5+cHIoK9vT0GDhyI7du34+XLl2LPm5GRgTFjxkBPTw+9evWqMMdnUVERWrZsib59+1bJXb6wsBBBQUFo2rQpsrKywOPxUK9ePVhbW8uci3HLli0yjdomT56MWbNmCT4PGDBAruThkkhNTYWlpSX09PTkiqHLy8tD27Zt4e/vjz179sDFxQWenp4VjnYrk5GnrKwMjx8/xv79+zF9+nR06dIFdnZ2UFNTg4uLC0JDQzFv3jwcOXIEaWlpSEtLg6OjI8aMGSPy/f5s3szPz8f58+exePFiBAUFwczMDCwWC23atMHMmTORlJSEhIQEODo6Vvo5GTJkiEzpxeTF09MTBw4cEDz3ffv2lTk1mSSSkpJgYGAg8fsJDQ3FiBEjqnSOfwOM8OGHEISEhMDU1BTBwcG/Ja6o/DyHDx+Gk5MTmjZtKuh5ffv2DTVr1pSrrqKiIhgYGMgVwF7OkydPYGZmJvGFmpmZifr162Po0KFi70VJSQkuXLiAGTNmoGnTptDU1ISPjw9mzpyJ5ORkjB49GsbGxjhw4ACysrJw9OhRREVFCRZMbdiwIcaOHYsDBw5AUVFRrvudnZ2NBQsWwNjYGP7+/mI94kpLS9GhQwd069atSr3wz58/o1GjRujRo4fQXMuJEydgbm4Oa2trmVz8W7Vqhf3791dYbseOHejRo4fgc5MmTaChoVEtPfDZs2ejdu3aqFu3rszPDJ/PR1JSEthsNtTU1LB9+3aZRLhbt25yz4FKorCwELdv38aOHTsQFRWFNm3agMPhQEFBARYWFujfvz+WL1+OU6dO4cOHD4KQBWmeyu/fv8fBgwcxYcIENG/eHFpaWlBTU0PTpk2xevVq3LhxQ+bQjdzcXOjq6uL9+/fVcr0/ExgYKDCffv36VbB6SPv27WVKTyaJ8kB3cRmCsrOzYWFhUW15iP+pMMIHYMaMGTA0NIS3t3eVJ5MlcfHiRTRp0gQuLi44fvy40AukpKRE5sS+PzNu3DiMGzdO7uOWL1+OQYMGSS2Tk5ODZs2aITQ0FMXFxbhz5w6WLFmC1q1bQ1tbG+7u7oiKisKJEycE8zN8Ph+vXr3Crl270LFjR6ioqEBJSQnNmjXDrFmzcObMGZG5HFlMgOIoLi7G1q1b4eTkBDc3N+zevRulpaXgcrkIDQ1F27Ztq5Qr8fHjx6hVqxamTZsm8rLn8/lo3rw5XFxcKjSJf/r0CTo6OjKJ17Vr1+Dh4QHgRyyaubk5WrVqJWT+rCyBgYGIj4/HmjVrwGazcfDgQanlL126hGbNmsHOzg6xsbFYsGABLCws8ODBgwrPFRYW9ttiw44fPw4DAwPs2rULly5dQkxMDEaMGIFmzZpBW1sbCgoKqFu3LoYPH47169fj4sWLFeac5XK5WLt2LUxNTTFgwAC4uroKHKhGjx6NvXv3Ii0tTazox8TEoFOnTr/lWnv27ClyHwsLC7F27VrUqlULXl5elV4TszzQXdw87tmzZ2FiYlKh09i/mT9e+Pbu3Qs9PT3Y2dlVKilzRTx48ADt2rWDpaUlduzYIXEEoqSkJHcw7cuXL2FgYCB3CqiWLVvi0KFDEveXJyWOjo6GsbExlJWVUbt2bYSHhyMhIUHgxMLlcnH//n2sWbMGISEhMDMzg6GhIYKCgrBy5UpcunQJY8aMgZGRkdAyMD9jYWEhNYC9Ing8Ho4fP47mzZvDzMwMjRo1go+PT5XSYpV7NkqL8Sr3hOVwOFKD19esWYOePXvKdN7s7Gxoa2sLlr5asmQJdu3aVWlvwXLKyspQs2ZNQSjF9evXYWlpicjISJFn7s6dOwgMDBSsSvGzA9XevXvBZrNx+vRpqecbOHCgTGmz5GX9+vUwMjISO7d45swZgUNacnIyVqxYgf79+6Nhw4bQ1NSEmZkZWrdujXHjxmH79u24ffu20DPC5/NRv359gUNbbm4uzp07h4ULF6Jz584wMTEBm81G27ZtMXv2bJw8eRLZ2dmoV6+exPnMqjJixAisXLlS7L7yNTHr1asHZ2dnbN++Xe6O3sePH+Hm5iY20H3cuHHo3Lnzfzaryx8tfFeuXIG2tjY4HI7Ma1rJyqtXr9CrVy9wOBysWLGiwpFkzZo1KyW8AQEBcvWu8/LyoKWlJZI49/3799i1axf69u0Lc3NzmJiYoFevXti8eTM6deqEZs2a4fPnz7hw4QLmz5+PNm3aQFdXF3Z2dujfvz+2bt0q4jhQzuXLl2FnZ4du3bqJxLHVqVNHEK9WFfh8Pnr06AF9fX3o6+tjwoQJlTI/7dixAxwORyavzc6dO8PDwwPTpk2TWMbLy0subz82m41bt25BT08P3759Q15entT4P1m4efMmnJychLZlZWWhTZs28PLywrt37/D48WN07doVxsbGWL16tcTn9fz58+BwOFI9VEeMGFGtzmE8Hg8TJkxA7dq1xYZ1nDlzRqp5k8fjIT09HUePHsW8efMQGhoKV1dXqKmpoXbt2ujcuTOmTZuG8ePHw97eXmIH9O3bt0hISEBUVBR8fHygoaEBZWVl9OrVC2vXrsWtW7eqNRPM9OnTMWPGDKll+Hw+Tp06BT8/P5ibm2P58uVyZZjKyclBixYt0LlzZ6EkAcXFxahTp45gSa7/Gn+s8L169QosFgs1a9as1sVQMzMzERERAX19fUybNk2mVFbAj/yGlXlRHz58WLCoqCwcPXoUvr6+yM7OFizC6ujoCD09PXTu3Blr1qzBkydPwOfzkZ2djWPHjmH8+PEwMjKCoqIi3NzcEBERgQMHDsiVdLewsBDjxo2DoaGh0HyXj49PtaRgmz59OurWrYvs7Gykp6dj5MiRAoeA1NTUCo/n8/mYMWMGrKysZHYgePToEVgslsSEAq9fv4a+vr5cPXFvb2+EhoZi9OjRgm09e/asdOA9ACxdulSQDu1neDwexo4dC3V1dejo6GDhwoUyhRU8fvwYVlZWEvNBRkZGYsmSJZVu78+UB2E3adJErOmtXPQq8wyVlpbi0aNHiIuLw9SpUwXmeWVlZdSpUwc9evTAggULcOzYMbx69UrEpNi3b1+MGjUKGzZsQP/+/eHs7AwNDQ00adIEY8aMQVxcHF69elXpUdOKFStkTlwA/OjgdOvWDQYGBpg6darUJO0/IynQ/cGDBzAwMEBaWprcbf+n80cK3/fv32FrawstLa0KzTaykpeXh9mzZwsS/sojCgBgbW1dKUeVsrIymJubV7iqcmFhIU6dOgU3NzeYmZlBS0sL/v7+WLRoEW7dugUul4vXr19jz549GDp0KFxcXKClpQU/Pz/MmDEDp06dQmRkJBwdHcUmWZaVq1evwsHBAV27dsXnz5/RoUMHqWZXWViyZAns7e1Ffuhfv37F3LlzYWRkhDZt2uDs2bNiX0LFxcXo1asXGjRoIPf31q9fPzRq1AhDhgwR2y5xayhKo3fv3tDU1BR62SQlJaFRo0Zy1fMz7du3F3E2ef/+PcLDw6Gvr4+wsDAYGhpizpw5Ms8Xffz4ER4eHujbt6/IKGfKlClVTrAA/Pj+fHx80LVrV7Gm66qIniQOHjwINzc33LhxA9u2bUNkZCQCAgJgamoKbW1teHp6YuDAgViwYAE0NTVFPKNzcnJw5swZzJ8/Hx07doSRkZHAIWXu3LlITk6WeU57+/btCAsLk/saXrx4gSFDhkBPTw/Dhg2TSbjKA91dXFyEQieWL1+OJk2aVNsKHv8U/jjhKysrQ7NmzaClpVUtGRtKSkqwZs0aGBkZITQ0VK4MGz/j6uoqEggsK3PmzBFxVikrK8OVK1cwZ84cNG/eXLAIq46ODrZt24bCwkI8ePAA69atQ48ePQTp2Tp37ozly5fjxo0bYs02CxcuhJWVVaVEupyioiKMHz8ehoaG8PHxqZI5Zf369bCyspIa51RUVIRNmzbB3t4eHh4eiI2NFfyQv379imbNmqFz586V8p58/fo19PT0oK+vL5Lazt3dXe6OVadOnWBrayu0raysDIaGhnj+/Lnc7eNyudDT0xPkzczMzMS4ceOgp6eHcePGCUZR7969g5eXF9q0aSPzUjX5+flo164dWrVqJWTZmD17tkw5K6WRnp4uWBFDnBifPXu22kUP+CEAderUEZvC7+vXr7hw4QLWrVuHpk2bwsDAAHp6emCz2fD19cXIkSOxYcMGXL58WSBufD4fr1+/xv79+xEZGQlvb29oamrC0dERffv2xfr163Hnzh2xwnL06NEqze9+/PgRkyZNEiwKXVHnmM/nY9GiRbCwsMDjx48F98PPz69aOjL/JP444Rs8eDC0tLQwd+7cKtXD4/Gwd+9e2NjYICAgoMKHqiIaNWokkmNQVj5+/AgdHR1cvnwZK1asQLt27aCjo4M6depgzJgxOH78ODIzM7F7927o6OggMDAQenp6sLW1Rd++fbF582axuQ8lERMTAxMTE5k8/KRx7do16OnpoU6dOnKPtIAfwdmmpqYydzZ4PB6OHj2Kpk2bwtLSElOnTkXt2rURGRlZpbCHMWPGoHHjxujSpYtg27Nnz2BkZCRXvVwuF8bGxmjcuLHIvtGjR1c43yOOu3fvwt7eHt+/f8f06dOhr6+P8PBwsWb10tJSREZGwtLSEtevX5ep/vJlmerUqSPofCxevLhS3sbl3Lx5U+oq9r9L9MqJj49Hw4YNJf4e+Hw+XFxccObMGcGajSdPnsSyZcvQt29f1K9fHxoaGrCwsEBgYCDGjx+PnTt34u7duygqKkJpaSnu3LmD9evXo2/fvnB0dISmpia8vb0RGRmJ/fv34/Xr17hw4YLYZ0FecnJyBOtFtmrVCqdPn5b6W9+xYwcMDQ0F4VZv374Fh8PBzZs3q9yWfwp/lPCtWLECmpqa6N+/f6Xt7nw+HydOnEC9evXQoEEDnD17tlra5uvrK/fooHwR1vLAcQMDAwwaNAhxcXF4/vw5/vrrL0yaNEkQa2dqagoXFxfEx8dXebWJ2NhYcDgcidk7ZGXy5Mnw8vICh8NBbGyszN/LwYMHYWhoWOmA3s2bN0NNTQ2ampqYPHlyle7Hly9fwGKxhBIkz5o1S675GeDHfG2dOnVgY2Mjsu/mzZuwsbGR+7ldvHgxGjZsCDabjd69e8tk9jpw4ADYbDbWrFkj0/nKU2KZmZnh3r17WLVqVaWDoI8ePQoDAwOJWYl+t+gBPzpITk5OEmPZLl26BDs7O6n3hsfj4eXLlzh8+DDmzJmD4OBgODs7Q01NDfb29ggKCsKMGTOQkJCAp0+fIisrC8nJyZg7dy7at28PDocDFosFLS0tzJ8/H2fOnKnUSu4/U1JSgq1bt8LBwQEeHh7Yv3+/xI7Zr4Hu+/btg52dXaVSy/0T+WOE76+//oK6ujr8/Pwq3bu/fv06fH19YWdnh4SEhGp19W3Xrl2F2S5+XYTV0NAQPXr0wObNm7FmzRqYmJgIet9aWlrw9fXFtGnTcOrUKeTm5sLPz69Kac5+5fjx4zK5t0tj+fLlGD16NK5fvw4nJyd07ty5QhE6ceJElfIK7t+/HwYGBjh+/DhevnyJYcOGQVdXFwMGDBCYeORl1qxZ8PT0hLe3N3g8HhwcHOQewfv4+GDPnj1QVVUV8ark8/mwt7eXuaNRXFyM1atXC1ZMkPe6Xrx4gbp16yIkJERmL8G4uDiw2WyMHj26wjhRcaxduxbGxsYSR5t/h+iVExsbC09PT7G/8V69emHp0qWVqrekpAQPHz7E3r17MXnyZHTo0AHW1tZQV1eHm5sbwsLCsGjRIhw/fhyHDx+Gjo4OxowZI0hm4OzsjP79+2PDhg24d+9epebeeDweDh8+jMaNG8PW1hYxMTFil326fv26UKB7WFgYwsPDBfsz84qxPuUlRsfdQb/tNzA67g7Wp7xEVt7viYWuTv4I4Xv48CE0NDTg5ORUqXmcp0+fIigoCCYmJtiwYcNvmejt3r27SKByTk4Ojh49KrQIa4cOHbBy5UocPnwY69evR1hYGCwtLWFgYAAtLS2Eh4fj2rVrIvNzksIYqsr58+fBZrMr7aCybds29OnTB8CPubhJkyaBw+Fgz549Yl86Fy5cgIGBQaUyV5TPYZiZmYmYpjMzMzFr1ixwOBy0a9cO58+fl6tjk5ubC0NDQ9jY2CA6OhqWlpZyHX/z5k1YWFigrKwMtWvXFjuSnTNnDoYPHy61nrKyMmzduhWWlpZo3bo1dHR0Ku2MVFhYiAEDBsDh/7F31mFRNt0fP3TXwtKKdCOKINIhEgqIoFhYqKAYKIhgYyfYiq1gY6IYWKBYqNiBAWKiKBg0u9/fH/7YVx4WWEKf531eP9fFBcw998zcG3NmzpwwMODJMhb48f7IyMg0SUXHYrEQFRUFPT29enekv1PoAT/UzgYGBkhLS6tVXlhYCBkZmVZ37v727RuuXbuGzZs3Y8KECXBzc4OysjKICNbW1hg5ciTi4+Oxfv16LFy4EIMGDYK+vj4kJSXh4OCASZMmITk5uUkxPdlsNjIyMtC9e3coKytj/vz5dVyqnjx5Ak1NTcyZMwdFRUXQ0NDAmj3HMGJHFvSmpUJvWio0oo9xfvT/v2xkYhZu5xdx7fefwL9e8L1//x4MBgNKSkpN9oV6/fo1RowYAQUFBSxYsOCXBm8dMmQI1q9fj3PnzmHq1KmwtraGhIQEXFxcMHv2bGzcuBHz58+Ht7c3GAwGtLS0MGjQIGzcuJHjfrBy5cp6M7kfPnyYk+i0tblx4waUlZWbFa3j0KFD8PX1rVWWlZUFY2Nj9OzZs9buLysrC0wms85kxAtVVVUICQmpdRbFjdLSUqxfvx66urqwtLRsUB30V1asWIFOnTpBXl6+yfFe+/fvj2XLlgH4sfvnFlnl+fPnUFBQ4Gp0xGKxsHfvXujr68PBwQEXL17E3bt36xjKNIctW7ZAQUEBSUlJPNWPi4uDhIQEZsyY0ajwLysrQ2BgIGxtbes1qjl//vxvFXo1JCUlwc7OrtYzxMXF8RyQoDUQFRXFiRMnsHr1aoSGhsLOzg4yMjJQVFSEq6srQkJCEB4ejhEjRsDd3R0KCgpQVVWFn58fFi5ciPPnz/O0Y7937x6CgoIgJyeHiIiIWoulGkf3UaNGYdq2U2gbeQDtfhJ23H7axRyDwfQTSLyS+wtfnebzrxZ8paWl0NfXh4SERJOsLYuKihAdHQ0Gg4FJkya1KNlqQ1RXV+P69etYsGAB1NXVISwszIljOX/+fERFRcHBwQESEhLo0KEDxo4di71799br71eTpJabqjAkJKTZ6hleePjwIdTV1ZvsuHz+/Hk4OjrWKS8vL8fUqVOhqKiIpKQk3L17F0pKSs1S1X758gXu7u7w8PDgecdbXV2NQ4cOcXKkrV69utHzjfLycmhoaEBISAgzZszgeXz5+flgMBgcS8CIiIh6M2T81SGezWYjJSUF7du3R6dOnWolgF21ahWCg4N5HkdD3L59Gzo6OggNDW00G/rhw4fRrVs3WFpaYtCgQfX6MX769Al2dnbo3bt3vW3+XUIPAGf3XXOOX6Nubkm2jKaiqqpaZ6HGZrPx6tUrnDhxAkuWLMHgwYPRsWNHiImJoV27dnBxcYGPjw/c3d1hamoKMTExmJqaYvjw4di4cSPu3r1b72Lu5cuXGD9+POTk5DB06FCOivzLly+wCAyHZtShBgXeX38Mpqf+I4Xfv1bwsdlsuLm5QVhYGFevXuXpntLSUixevBhMJhPBwcGtkgrkr2OqScLas2dPyMnJwcjICMOGDYOlpSUsLS1hbm4OCQkJODo6Ytq0aTh58mSTYlkOHz68jsUqm81uMBdXa5GbmwsdHZ1687hxIzs7G+3bt6/3+o0bN6CrqwtRUVGsWbOmyWPKz8+HmZkZQkNDm62izszMhJ+fH5hMJqZPn96gY/D06dMhIiICFRUVnjUEUVFRmDBhAuf/DRs2YOjQoVzrrlu3jrOrP3fuHLp06QJjY2McOnSozmseEBDAU0JZXikuLkavXr1gYWGB3NzceuudOHEC3bp1w/fv3+Hj4wNXV9c6n+Hnz59DX18fkZGR9foO1gi91jIgaw7btm3j5K08f/48jIyMfmsYL2NjY54DbFRXVyMnJwcHDx7E7Nmz0bt3bxgaGkJUVBSampro0KEDzMzMoKKiwpljJk+ejIMHD9ZZTBcWFmL27NlQVFSEr68vEo9nQH96bbVm28hDkDBzg4A0E3zCYhBS1IJi71lchN8J3HlV9AtenebzrxV8Y8aMgZCQEJKTkxutW1VVhU2bNkFdXR1+fn7NNnDgxs9JWFVUVNC2bVv4+fkhODgY/v7+0NTUBIPBgJ6eHrp27YorV660KLhyTXDjn1d0NWlpfscX9t27dzA1NcXEiRN56i83Nxdt27at9/rLly85ZuFMJhM7duzg+Tlu3boFdXV1LFmypFWe/cmTJwgNDYWcnBxGjhyJJ0+e1KkzZswYKCoqwsbGBgsWLGi0za9fv0JeXr6WIElPT4eNjQ3X+oWFhRAXF4ejoyO0tbWRlJTEdfXOZrPBZDKblOORF9hsNuLi4qCoqFhvKLafd/HV1dUICwuDiYkJJyzg9evXOUl26+OfIPSAH3ODtrY20tPTERgY+FvydP6MnZ1dg5kmeKG8vBx37tzBzp07ER0djR49eqBt27acBZqamhrExMSgoKAAT09PLFq0iJPSqaSkBKtXr4bGwLnQmHy0lkBrMzEZMrb9oBa6GW0nHwUzYAb4hMWgFrq5jtozJPGf5QrxrxR8a9euhaCgIBYvXtxgPTabjYMHD8LQ0BCOjo4tNs0HfhhJ7Nu3DyEhIdDR0YGCggJcXV3h7+8PV1dXMBgMtGvXDgMHDkRCQgIePHgAFovVYt+nn+ncuXMtC9ElS5YgNDS0VdrmhU+fPsHa2hrDhg1r9HysoZRM7969g66uLuLi4gD8EOpmZmbo0aNHo+HdaqL41xccuyUUFBRgxowZYDKZ8PX15RjaVFdXQ1lZGWvXroWenh7k5eUbdQZfsWIFevfuXavs3bt3kJeXr1P3zp078PHxgaioKNeIKT9Tk0X9V5GZmQl1dXXExMTU2UlfuXKlVqQZNpuNpUuXQl1dHfHx8Q3mgwP+OUKvhs2bN8Pe3h4yMjK/JJB9Q3h7e7c4slF9fP36FVeuXMHGjRsxbtw42NjYQEZGBsLCwpCUlISgoCDU1NTg4RsAreijPKk2hZjtoNAzpk653rTUf5S1579O8KWlpUFQULBRc+oLFy7A2toaZmZmSE1NbfaO4Nu3b0hNTUVERATMzc0hJSUFKysrdO3alePIWpMmZffu3fWqT1evXl3LVLglbNu2DR4eHpz/XVxcmpwYtKV8+/YNrq6uCAgIaDBAN4vFAj8/fx0B+enTJ5iamtZKzAr8MAevETrbt2/n+r7VRNJpjYVMQ5SUlGDNmjXQ0tJCly5dMGvWLJibm3Oyeru4uNRSYf6V6upqaGpq1hknm82GtLQ0R2g+efIEffv2hZKSEuLj47Fz585GDZXWrl2LIUOGtPwhG6CgoABdu3aFk5NTrXPlW7duwdzcvE79YcOGgZ+fHytWrKi3zX+a0AN+OPbLycnB09Pzt/c9ePBgbN68+bf2+eHDB5w7dw5xcXHo2bMnNDyHo03EgUaFnvrYRJCAEFRHrKtzTX9aKtanNy+q1a9AkP5F5OTkUI8ePcjR0ZESEhK41rlz5w7FxMTQ48ePac6cOdSvXz/i5+fnuY/Kykq6du0anT17ls6ePUu3bt0iDQ0NkpaWppKSEqquriYRERGysrIiOzs76tKlC8nKyjbarri4OJWWlvI8jobo06cPRUZG0vPnz0lRUZGuX79OLi4urdI2r0hKStLx48epX79+5OPjQwcPHiQJCYk69fj5+UlKSoq+fv1KcnJyRET09etX8vDwIHd3d5o+fXqt+sLCwhQbG0s9e/akoUOH0r59+yghIYHU1NSIxWLRpEmT6MSJE5SZmUlaWlq/9BnFxcVp9OjRFBISQocOHaLRo0cTm82m9evXU2xsLA0bNoyys7Np3Lhx1K5duzr3HzlyhJSVlcna2rpWOR8fH+nr61N6ejqlpqbSkSNHKDw8nDZu3EiSkpJUXl5OY8aMoTdv3pCamhrXsaWnp5OHh8eveGwOioqKdPLkSZo9ezZZWFjQ7t27ycHBgURFRam8vJxTj81m0+TJkykzM5P27NlDY8eOJQkJCQoODq7V3oULF6h37960d+9ecnZ2/qVjbwoCAgIkICBARUVFv71vOTm5RvsFQNXV1VRRUUEVFRVUWVnJ9TevZT9fU1FRobciplQgJNLwGFjVVHh0KUmaupKQfJs618ur2fT43bcWvRatyX+N4Cv8XkHJN1/T4/df6Wt5NUmLCpKBsjT1tlAneUkRKi4uJmtra2rXrh2lpqYSHx9frftzc3Np+vTpdObMGZo6dSodPnyYhIWFG+2XzWbTnTt3OILu4sWLJC8vT1JSUvT582cSFhYmbW1tsrOzI3t7e7KwsCARkYY/JNyQkJBoNcEnJiZGgwcPpoSEBLKxsSFra2uSlJRslbabgoiICO3bt4+GDx9O3bp1o+PHj3NdBMjKylJxcTHJyclRaWkpeXt7k4WFBS1evLjO+1hDhw4d6Pr167RgwQLq0KEDzZkzh06dOkVFRUV0+fJljhD9HQgICJCPjw+FhIRQQkICJSYm0qxZs0hGRoZ0dXVp+vTplJiYWOe+uLg4mjhxYp3y9+/f09evX2nQoEE0fvx4ysnJqfU8oqKi1KtXL9q9ezdFRkbWuR8Apaen04IFC1r3QbkgICBAsbGx1KVLF+rTpw9NnDiR/P39qaKigoiIysvLadCgQfTu3Tu6fPkyMRgMat++PXl6elJeXh7Nnj2b+Pj4KD09nSP0fvcirTHOnj1LysrK9PbtW7pw4QKZmZm1ilDhpezp06dUXV1NO3bsqLd+ZWUlCQgIkLCwMImIiHB+//w3L9d+/ltcXJzzf84nJhWU1f/6AGwqPLaMSECQGG6h9db7Wl71C96d5vGPF3x3XhXTmgvPKD3nIxERVVSzOddEBd9T/JkcctBVoHOrJxM/Pz9dv369lkD78OEDzZ07l3bu3Enjxo2jdevWkZSUVL39AaCnT5/S2bNn6cyZM3T27FkSFhYmSUlJ+vTpE8nKypK9vT3Z2dmRnZ0dGRkZNWnHWB/i4uJUUlLS4nZqCAkJIVtbW/r8+TN5enq2WrtNRVBQkLZs2UITJkwgZ2dnOnnyJCkpKdWqUyP4KioqyN/fn9q2bUtr1qypV+jVICwsTDNnziRbW1vy8fEhOTk5unjx4m8VejWkpaWRoaEhBQQEUEBAAD1+/JimTJlChw8fJlFRUerduzf5+Phw6l+7do3evHlDPXv25JR9/vyZlixZQhs2bCB9fX3q1q0bzZs3j2t/AwcOpPDwcK6C7+nTpyQkJMR1l/mr8PDwoOvXr1OfPn3o7NmzVFpaSp8+fSJfX19SV1entLQ0EhUVJSIiPT09unLlCvn4+NDLly9p0KBB1K9fP9q7dy85ODhQaWlps4REa+92av7+/v07ASAiIldXV5KWlm6RUKn5LSMj02j9Y8eO0atXr2j69On19iksLEwCAgKt9l4WFxfTiRMnKDk5ma5fv07lHQJJwpj7DhwAfUpdSaySYlLsPYv4BOoXKdKiQq02xpbyjxZ8SVfzaF7qYyqvZtH/f+5qUf7/QjDt4XuCQxjNmKVF0tLSRET07ds3iouLo5UrV9KAAQPo0aNHpKioyLWft2/f0tmzZ+nkyZOUlpZG5eXlJCEhQUVFRaSpqUnOzs5kb29Ptra21LZt21/yrK2p6iQi0tXVJXNzczp06BDXyfF3ws/PT8uXL6fY2Fiyt7enM2fO1Hod5eTk6NOnT9S/f38SExOjrVu38ryYePjwIY0YMYIiIyNJQECAOnfuTIsWLaKhQ4c2Kjhbk927d1Pfvn05/xsYGNDBgwepV69edO/ePQoICCBvb2+aNGkSWVtbU3x8PI0fP54EBQXp27dvtGLFClq+fDn16tWLbt++TVevXqXdu3fX25+DgwN9+vSJ7t27R6amprWupaenk6OjY73Pz2KxfplQMTY2posXL1JBQQG1adOGVFRUSFRUlLp161anfllZGd26dYsSExNJSEiI3NzciIhaRajU/JaWlm5RG58/f6YuXbpQbm4uiYuLk46ODh06dIg6derUCp+axikoKKCCggIyNzf/Je0DoOfPn1NKSgqlpKTQ7du3qbi4mAQEBEhTU5Pc3d1JtktXOprLpkpW3Un486k1VPXpFSn1nUv8DahDRQX5yUCl/g3H7+YfK/h+CL1HVFbFbrwyHz/xCYnSuqvvSVr6OX3LTqV58+ZR165dKSsrq85ZT1FREV24cIFSUlLo9OnTVFhYSGJiYlRSUkImJibUrVs3sre3Jxsbm9+2e2hNVWcN3bt3p4yMDNLX12/VdpsDHx8fzZo1i7NjPn36NGdcMjIyNHfuXBIREaGjR4+SoCBvH8uzZ89Sv379aNmyZRQUFERExDn7279/P23YsIHatKl73tDalJaW0rFjx2jZsmWcMjabTRUVFTRjxgxycXEhRUVFEhcXp4CAAJKVlaUXL15QYGAghYaG0t69e8nU1JSmTp1K8vLydPLkSXrx4gVdvnyZFixYUK+gkZKSooCAANLV1a11LScnh0RFRUlXV5er0GKz2a2mEhMWFiYpKala15hMJi1atIgAkKenJ/n4+HC9Lzs7m0JDQ8nGxoZevHhBx44d++Xnsk1l48aNFBgYyJkHJk+eTHPmzKEjR478lv55OeNrCuXl5XTjxg06duwYnT59mh49ekRVVVUkKChIBgYGFBwcTIGBgdShQwcSEBCgz58/06yFy6gCnYhPsPbRUPWXD/T99kkiASF6vSqIU87wCCPJv+wQQUQBHdVb7Tlayj9S8N15VUzzUh9zFXolD9OpOHM3sb5+JAEJOZLvHk6ibUyIiKisik2zjtwhzRc36NSpU9S+fXsi+jExXbp0iZKTkyktLY1ev35NwsLCxGazycLCgkaNGkWOjo7UqVMnjjrmd9Paqk6iHx9yQUFBunv3Lue1+LsJDw8nGRkZcnJyotTUVDI3N6fHjx8Tm82m27dv83w+um3bNpo8eTIlJSWRtbU1ffz4kSoqKkhKSoq2bdtGGzZsIDMzMxo5ciS5ublxzkJ+hbqsuLiYysrKyNDQkFPGYrE4k33N7mbfvn2kqalJ+fn5VFFRQb169SJJSUkyMzMjBoNBV69e5QgFfn5+KiwspKKiIhIVFSUJCQliMBi1BIehoSEtXryYFi9eTGJiYhy1l5+fH23cuJH09PS4Ci0BAYFfths+cuQITZ06lfj4+Cg7O5sCAgLo69evtG7dulrGTenp6RQWFkb79+8nV1dXWr58OTk4OFBKSgp16NDhl4ytqbBYLNq4cSMdOnSIUzZ8+HBasGABZWdn/5ZxMhgM+vz5c7Pvf//+PWVmZtLx48cpPT2d8vPziY+Pj4SEhMjc3JymT59OPXv2JENDw1qfiZKSElq+fDnFx8eTv78/OXZi0sUXX+jnPZ+gjCJpRB9rdAx8fETO+kySl2y67cOvgg/gpkT8exmZeIPSHhXUUW+W5WbTpxMriek7mYRV9Yj1/ccHQlBKgVOHj4jcDBUpSLOcdu3aRWfOnKHc3Fzi5+cnUVFRsrKyIm9vb3J2diYTE5NWOZ9rDZ4/f05ubm704sWLVmvT2dmZ1NTUSFJSktavX9+sNgA0SRDwKlQePnxIZ8+eJVVVVXr79i3p6OiQlpZWo22Ul5dTSUkJVVX9OChvaKdSXV1NL1++JGFhYTIzMyNZWdlWU6H9/Pe4cePIzc2Nhg4dyikTFBTkTCTv3r0jExMTUlNTIysrK9q6dSvZ2NhQ//796dixY3Tz5k0aM2YMjRo1iuTl5TmvvYaGBp07d460tbXrfX/Mzc1p+fLl5OTkREQ/PkcODg70+vXr36rqJSJavXo1zZ8/n44ePUrW1tZUXl5OFRUVNGrUKMrOzqbk5GTS19enjIwMCggIoN27d5Orqyvn/gMHDtCoUaNo+/btf+u5dA3Hjx+n2NhYun79eq3y5cuXU0ZGBh08ePCXj+HJkyfUo0cPevr0aaN1WSwWPXjwgC5evEgnTpyga9eu0ZcvX4iPj4/ExcXJ0tKSevbsSd26dSNtbW2un4/KykrasGEDzZs3jxwdHWn27Nmkp6dH1569p74brhIEmn5OJyYkQHtHWpOZumyT7/1V/ON2fIXfKyg95yPXM70vl3aSjG0/ElEzIKLaAq8GENGpe69p6+hhJCMqQFZWVjR58mRyc3Ojtm3b/vbJgBcAkJCQEJWUlNCnT59aZTfy9etXyszMpICAANq6dSsVFRURm81u8m6nqqqKhISEWk1I1Jy7dOvWjT5//kzXr18nCwsL0tDQoKCgoAbbAECTJk2i/Px8OnjwIKmpqTX6flZVVdHixYtp+fLlNH/+fBo+fHirfga+fv1KV65cod27d9erFldWViYnJyc6deoUPXr0iOzt7enChQtERDRq1Ch68OABLVu2jHR1dWnAgAE0YcIE0tLSIn19fXry5EmDgm/gwIGUlJTEEXyNne/9CthsNkVFRdHx48cpMzOTNDU1OS4NkpKStH37dtq4cSPZ2dlRWFgYrVmzhvbs2VNL6BER+fv7k6qqKvXq1YtiY2Np5MiRv+0ZuJGQkEAhISF1ykeOHEmLFi2iu3fvkpmZ2S8dQ0Oqzq9fv9K1a9fo0qVLdOrUKbpz5w4JCgpSZWUlycjIkKOjI/Xo0YOcnZ1JQ0OjwX5YLBbt3r2bZsyYQXp6enT8+HHq2LEjEf3QmMWM7E86+o70mmnF2/HT/yMmxE9TvQz+UUKP6B8o+JJvvuZaDjaLKt49IzGdzvRm/QgCq5LEda1J1nlYnUNVISEhWpycQRM8/nPo35ivy6+yCOOlfmVlJQkKClJ1dXW96qmmCprPnz+TpqYm2dnZcc58unfv3uTdjrCw8C+ZRFesWEGFhYV06NAhGjBgAMnLy9eyevwrnz59Ij8/P1JUVKT09HQSExPjqR8hISGaOnUq+fr60pAhQ2j//v20cePGRicCXjl8+DA5OjpyFXoA6NSpUzRt2jTOe1xVVcWZUGowNjamLVu20Ny5c2nVqlVkZWVFLi4uJCsrSzk5OeTl5VVv//369SNTU1NavXo1iYqKcgTf76KsrIwGDRpEHz58oMzMTGIwGET0w0ClRvDx8fHRyJEjiY+Pj0JDQ8nX15fs7e25ttelSxfKyMggLy8vevnyJc2dO/dvWay+evWKLl26xNXASFxcnCIjI2nu3Lm0b9++XzoOOTk5Ki4uJhaLRfn5+ZSZmUmXLl2ic+fO0cuXLzm2AYqKihQYGEgeHh7k4OBAqqqqPLUPgI4dO0ZTpkwhSUlJ2rJlC2cRRUQc9yJ1dXXaunoaJV7Jo1lH7hCfoAg1pCrk4yMSFRSgqV4GNNC6XYteg1/BP07VGb43mw7fflunvPrbJ3qzZjAJK+sQM2AG8fEL0McDc0mkrSnJOQ6qU5/9/AqVnU9olq9La1qV8VJWc95Yo55rjS/6iBEjyNjYmMLDw+ncuXM0btw4unfv3j9ix7tlyxaKjY2ljIwM0tDQoDlz5tCCBQto1apVdZyaiYiePXtG3bt3J19fX1q4cGGz1dPV1dW0ZMkSiouLo3nz5tGIESNa/Hp4eXlRUFAQ9evXr1b5xYsXaerUqfTx40eaM2cO9erViwYPHkwpKSkkIiJCOTk5JCMjw7XNb9++0ebNm2n27NkkKipKGzZsIC8vr3qfu2vXrhQaGkoBAQHUrl07OnnyJBkYGLTouXihsLCQfH19qW3btrRt27Za57Nqamp0/fp1joN9RkYG+fv708aNG2nLli304cMH2rdvX71W0h8/fiQfHx/S1tamzZs383z221rMnDmTPn36RKtXr+Z6vaSkhLS0tOjcuXNkbGzc6v1XVFRQdnY2ZWZm0uTJk0lKSopYLBaJiYlRcXExaWhoULdu3cjZ2ZkcHByIyWQ2uY+MjAyKiYmhL1++0Pz588nb27vW96GsrIx8fHxIWVmZtm3bRgICApSQkEC7Tl4iQ//xdP7JR+Kj/1jXE/2w3gT9ONMb7aTzj9vpcfjtsWIaYei269zD4YTvARFBvvsETplCzxgIKWpxrd9n9TkUFBSguLgYZWVlzc66/jsRFhZuMLwXr7DZbKipqeHx48ec//X19ZGent7itlvKnj17oKqqWivA8+HDh+Hs7AwNDY06qZMyMzOhrKyM9evXt9oY7t+/D0tLS3Tt2hV5eXnNbufjx4+Qlpaule/sxo0bcHd3R7t27bBt27ZacSytrKwgLy8PLy8vTJ06tdH2U1NTYWRkBHNzcxgaGmLz5s1cPx9bt26Fr68v8vLyoKSk9FuCkT979gy6urqIjo7mml1BS0uLkwqsJlnxmTNnAPwIU7do0SIoKSnh5MmT9fZRWloKPz8/ODk54fPnz7/mQbhQVVUFVVVV3L17t8F6CxcuRN++fVulz4KCAhw+fBhRUVHo0qULREVFoaysDFVVVRARDAwMMHHiRBw9erTFr0V2djY8PT3Rrl077Nixg+vcWFpaCjc3N/Tv359zvaysDOrq6rh+/ToAoPBbOdanP0P4nmwM23Yd4XuysT79Twb2ZjF+z616Y8EJSCnwLPgUekyEuLg49PX1ERAQgPj4eKSnpzc5Ge3vRFZWtlVy/929exeampq1JsDly5e32pe0uRw9ehRKSkp1JpQLFy7A3t4e+fn50NfXx7Rp08Bms7Fnzx4wmUycOHGi1cdSVVWFhQsXQkFBAevWrWuWsFi/fj0nRdD9+/fRq1cvqKqqYs2aNXUybFy+fBmamppISEhAly5dICcn12ig7by8PKiqqoLNZuPMmTPw8PCAiooK5s+fX2vy+/LlC6SlpbFmzZo6Aa9/BVevXm10MWJoaIgHDx4gPT0dCgoKHKH3MxcuXICqqipmzJhR78K0uroa4eHhMDQ0bNEipSnU5GFsjG/fvoHJZOLRo0dNap/FYuH+/ftISEjA4MGDoa2tDUlJSWhqaqJNmzYQERFB586dERMTgxMnTsDU1BQ3b95s7uNwePr0KSfm68qVK+tdZJeWlqJbt27o169frYXb8uXL6ySN/m/lHyf41l14Viedfc2PjE1fCCvrQn1sEtTD90BE3QgyNoFcI4FHb0vDnDlz4OHhgTZt2kBAQACioqIQEhKCuLg4jI2NMXDgQCxfvhynT5/Gq1evfmueLW5wSzrZHBYuXIiwsLBaZUVFRZCRkcH79+9b3H5zOHPmDJhMJq5du1bn2u3bt2Fqagrgx8rX3Nwc1tbWaNOmDW7fvv1Lx/XgwQNYWVnBxcUFL168aNK9jo6OWLduHYKCgsBkMrFkyZJ6c/D17t0bK1asQFVVFfT09BAQENBoIHUWiwUxMbFayXPv3r2LQYMGQU5ODuPHj+cIg8DAQHTp0qVZOQubwqFDh8BkMnHs2LEG63Xo0AEbN26EgoIC0tLS6q337t07ODk5oWvXrg0uSpcvXw5VVVXcuHGj2WPnFXd3d57zGM6bN6/RjOzfvn3D2bNnMXv2bHh4eEBGRgYqKiowMjJC27ZtISYmBkdHR8yYMQNnz56t8xlycnLiunDglTdv3iAkJATy8vKYM2dOgxnZy8rK4O7ujr59+9YSet+/f4eysjLPuQH/6fzjBN/Hb+X1Cr62kw5DsoMX+EQkwC8hCykLb7SNPFinnubkI7ibk1ur3aqqKty/fx87duxAaGgoOnbsCHFxcYiJiYHBYEBCQgKioqIwNTXFoEGDsGjRIqSkpODZs2e/TU2qq6vLNcdbU3F0dOQ6MQUHB2PevHktbr+pXL58GUwms968Ynl5eWjTpg2AH5Hwg4KCICEhAX9//2Ynj20KVVVVWLRoEeTl5bFmzZp6E6P+TFZWFoSFhSEvL49Zs2bhy5cv9dbNzc2FvLw8R4Dt378f7du3h7y8fKO7BTMzM66T/atXrzBp0iQwGAz07dsX8fHxEBUVxf379xsde3NZsWIFz8LHyMgIsrKyDQq9GqqqqhAdHQ11dXVkZmbWW+/gwYNQUFDA8ePHmzTupvDixQvIy8ujtLSUp/pfvnyBgoIC53vLZrORl5eHXbt2YcyYMejQoQNH89SxY0doaGhAQkICbm5umDt3LjIyMho93vDz82tWeq3Pnz9j8uTJkJOTQ2RkZKMpssrKyuDh4YHAwMA637sFCxZwtBv/Bv5xgg8ARuzIQrsY3tPb10p6GH0MXSZtgZycHIYOHdrgxMJms5Gfn4+jR48iNjYWPXr0gKqqKidBY5s2bcBgMCAiIgJTU1P069cPs2fPRnJyMh48eNCihLHcaN++PW7dutWiNoqLiyEpKcl153Hjxg20bdv2t5533rp1q1F15ZcvXyAlJYXi4mK4ubnBy8sL79+/h4eHB3x9fVFWVvZbxvrw4UN07twZzs7O9e7+Pnz4gIkTf6jRTUxMGp1MAGDChAmYNGkS5382mw0LCwsMGDAAPXv2bPDe3r17Y+fOnfVeLy4uxpIlS6CiogIiwubNm1tdc8FisTBhwgQYGho2mHm9hoyMDAgJCWHJkiVN6ufo0aNgMpmIi4ur9xmuXLnS6me+PxMTE9NgKqm/UllZiZEjR8LS0hK9e/eGmpoamEwmLC0tYW1tDQ0NDUhLS8PLywuLFi3C1atXG8yjyI3g4GAkJCTwXP/79++YP38+5OXlMWLECJ60SGVlZfD09ESfPn3qCL3i4mIoKCg0WaX7T+YfKfhu5xfBYPqJZgk+g+mpuPOqCJ8+fcLs2bOhqKgIPz8/riq2+igqKsKFCxcQHx+PwYMHw9TUFCIiIlBTU4OxsTGMjY2hrq4OERERGBgYoFevXpg6dSp27tyJW7du1avuaowuXbpwkpo2l+TkZLi7u9d73dLSst7M2a3Nw4cPoaysjOTk5Abr1eTkMzY2RlhYGOeLV1FRgT59+sDFxaWWuu9XUl1djSVLlkBeXh6rV6/m7P6Kioowbdo0MBgMhIWFwdzcHKdOnWq0veLiYjAYDE728RrS0tKgo6ODNm3aNPieT5s2DTNnzmy0n23btoHJZEJJSQkmJibYunVrqyzMSktL0atXLzg6OvJkVJGRkQEFBQV06tQJqampTe7vxYsXsLCwgL+/f7276KdPnzZoWNNcKioqoKSk1OAEX1hYiJSUFERHR8PBwQESEhLQ1dWFkJAQLC0t0bZtW8jJyaFnz56Ii4vDzZs3W7zQjIyMxMKFC3ka/5o1a6CiooLevXtzjNsao7y8HF5eXujduzdXDcvMmTMxePDgpg77H80/I2zJX2jfRpamehmQmFDThoeqClJ4dZH0mWLEYDBo+vTp9OLFC3J2dqbevXuTi4sLnT59mhNpvT5kZWXJ0dGRwsPDadu2bXT37l368uULpaSkUEREBLm4uJCmpiaJiIhQUVER5eXl0cWLF2nNmjXUr18/YjAYpKWlRT169KBJkybR1q1b6erVq/Tly5cG+22NeJ0nTpxoMOrF6NGjad26dS3qgxdevHhB3bp1o0WLFpG/v3+DdbOzswkA9evXj1atWsWJ1SksLEy7du0iLS0tcnNza1HoJl4REBCgyMhIunTpEu3cuZMcHR0pKiqK9PT06PXr13Tz5k2aMGECvX37lqf0OZs3byZ3d/c6MUO7du1KGhoa5OrqSlFRUfV+Jmuc2BsjMzOTBg4cSDIyMrR06VLauXMnaWlp0eLFixv93NXHx48fydXVlURFRenUqVONxq29ePEi9erVi3bt2kVqampUUVHR5D41NTXp0qVLxGQyqVOnTnT37t06dXR0dOjy5cuUkZFBAwYMaFY/3Dhy5AgZGBhwXEHYbDY9evSINm/eTMOGDSMDAwPS0tKihQsX0oMHD0hISIjk5OTo69evpKurS4KCgnTs2DGOf+qECROoY8eOLc6c0Fi8TjabTbt27SJDQ0M6cuQIpaSk0L59+3iK0Vvx/xlRxMTEaOfOnXXi5Na4dMyYMaNFz/CP428WvA2SeCUXBtNPNKr2bBfzY6fXNTQWTCYTTk5OdXYIlZWV2LFjB4yNjdGhQwfs3bu3xSsxFouFZ8+eITk5GdOmTUP37t2hpqYGGRkZWFpaokePHggICED37t3RsWNHSEhIQFVVFa6urhg7dizWrl2LCxcucA71fXx8cOjQoWaPh81m13EV+CulpaWQl5dvsiFHU3j9+jU0NTV5MrQ4cuQIFBQUoKioiOfPn3Otw2azERkZCRMTE7x9+7a1h8uV8vJyxMfHQ0pKCsLCwpg6dSpndzFv3jyMHj260TaqqqrQtm1bZGVlcb1+/fp1jhbh8OHD9dbp0KFDo33p6ekhOzsb2tranP6ys7MxYMAAMBgMTJw4sc6usyGePn0KHR0dTJkyhaddVc1O7/Tp0wB+GNvs3r2b5/64kZiYCAUFBWzdupXr9dLSUvj7+8PBwaFVrKEdHR0xffp0zJs3D927dweDwYCWlhZ69OiBwMBAdOvWDcrKylBXV8eAAQOQkJCAx48fg81m49OnT2AwGL/ke7Vu3TquhlBsNhvHjh2DmZkZrKyscPbs2Sa1W15ejh49eqBXr171ql8nT56M0NDQZo37n8w/WvABwJ1XRQhJzILetFTo/8XoRX9aKvSmpSIkMQt3XhWhuroa/fr1g7q6Ojp06MDVSozFYuHo0aPo0qULdHR0sGHDhlbxnfuZDx8+4PTp01i8eDH69+8PQ0NDiIqKwtzcHL1790ZoaCjCwsIwaNAg2NraQk5ODvLy8mAymXBxccHy5ctx6tSpJlua3r59G9ra2o3eM2HCBEyePLmlj8mVgoICGBgY8KSaWbFiBVRUVHDt2jV06NChQZNtNpuNefPmQVtb+5cK7aqqKmzatAlt27ZF9+7dkZ2djcePH8PGxgYODg54+vQpTExMkJGR0Whbe/fuhb29fYN1/P39MXToUBgYGHBVMxUXF0NCQqLB9/Tt27eQk5MDi8XCzJkzMX78+FrXX758iYkTJ4LBYGDgwIGNWspevnwZysrKPJ8rXbx4EUwmkyP0AGDQoEHYtm0bT/c3xP3796Gvr4/g4GCuBicsFgsREREwMDBo8ufi1atX2LNnD8aNGwcTExMQEaysrBAUFIShQ4fC09MTCgoK0NTUxJAhQ7B161Y8f/683vdiypQpGDlyZLOesyH27NmDgICAWmUXL16Era0tjIyMcOjQoSaf61ZUVMDb2xt+fn71Cr13796BwWC0iqX5P41/vOCrgVdnyaqqKvj7+0NPTw+6urr1Hsaz2WxkZGTAy8sLKioqWLx4cYOWeS2lpKQE165dw/r16xEaGgpra2tISEhAS0sLvXr1QlRUFCwsLNCzZ0+MHj0aLi4uUFZWhpSUFKysrDB48GAsWrQIR48erdfSdMGCBRgzZkyjY3ny5AkUFRVbXeAXFRXB3Ny8Uefs6upqjBs3rpaxhLOzM08m22vWrIG6ujoePHjQGkPmwGKxsHv3bujq6sLJyamOdWF1dTXi4uIgKysLGRmZRq1N2Ww2rKysGt3BP3r0CAoKCrC1tcWGDRu41lFSUmpw8tm9ezfHvyonJwdKSkpcx1dUVIRFixZBVVUVbm5uOHXqVJ0J88CBA02ynOQm9ABg5MiRrWaA8vXrVwQGBqJ9+/Z4+vQp1zorV66EiopKvbvrqqoq3LhxAytXrkRgYCDatGkDJpMJHx8fjBkzBu3bt4empiZkZWWhr6+PESNGICkpqUm75MLCQjAYDLx8+bJZz1kfp06dgqurK4Afi9vu3btDQ0MD27Zta5bWqqKiAj4+PujZs2eD58Djxo1DeHh4s8f9T+a/RvA1hZrVjLm5OdTU1HDv3r0G69++fRv9+/eHvLw8pkyZ8tt83aqrq/Ho0SPs3r0bUVFRaNu2LSQkJKCgoICuXbsiMjISCQkJSEpKQkJCAiZOnAhPT09oaGhATEwM7du3R9++fREbG4v9+/ejU6dO9arM/krXrl2RlJTUas/y7ds3WFtbY9y4cQ2uPr9//w4fHx+4uLigqKiIU+7n59eoEUwNiYmJUFJSqneSawpsNhtHjhzhqIvS0tIaHP+oUaOgqqoKe3v7eidh4EfEGW1tbZ4mpuDgYAwZMgSqqqr4/v17nesODg4NLgpCQ0MRFxfH+b9z584NWtFWVFRg69atMDY2Rvv27ZGYmIjKykrEx8dDVVWVZ2fpixcv1lJv/szYsWOxfPlyntrhBTabjdWrV4PJZOLgwYNc6xw+fBgKCgpISUnB58+fcfz4cUydOhXOzs6QlJSEiYkJgoODMXXqVEycOBHdunWDtLQ0jI2NISoqipUrV+Ldu3ctGufkyZMxatSoFrXxV7KysmBkZIT+/ftDSUkJK1asaPaitaKiAr6+vvD19W1Q6OXn54PBYPxtfr+/mn+l4AN+6K/d3d1ha2sLJpPJk7Xk8+fPMWrUKMjJyWH06NG/VKXGjcmTJ2PevHl48+YNjh8/jnnz5iEgIAA6OjoQFxeHpaUlRo4cibVr1+LMmTO4ePEiEhMTERMTAy8vL/Dx8UFYWBj6+vrw8/PDlClTkJSUhJs3b9axND1w4ABsbW1bZdxlZWVwcXHBsGHDGjwPevv2LSwsLDBkyJA6X7qhQ4di06ZNPPd55MgRMJlMnD9/vrnDxpkzZ9C5c2eYmpriyJEjjaqL2Gw2tLW1cfXqVSxfvhzy8vKIj4/n+sz+/v5YtWoVT+OomWR69OjB1c9yxIgRDZ6XGhoa1hJWq1atatSpuuZ5UlNT4eTkBElJSSgpKTW6SKyhRujVZ9k6adIkLFq0iKe2msK1a9egoaGBiIgIjoqOzWbjyZMn2LJlC3x8fCAoKAgRERG4uroiOjoaCxcuxOTJk+Hs7AwJCQl07NgR4eHhOHToEAoLC5GUlAQ3N7dWGd+HDx8gJyfXaurBt2/fon///uDn50dsbGyLrJsrKyvh5+cHHx+fRi1+R44ciejo6Gb39U/nXyv4gB/qRScnJ7i7u0NBQaHRaBM1vH//HjExMWAwGOjfv/9vi1YQGxuLadOmcb325csXXLx4EatWrcKwYcPQsWNHiImJQV9fH4GBgRgwYAA6deqE/Px83Lt3D3v37sWsWbPQp08fmJqaQlRUFO3atYOXlxciIiKwYcMGKCgo4OLFiy0ac2VlJefwv6Hdzb1796ChoYE5c+ZwFTATJkyoE6ezMc6dOwcmk9lk94zLly/D2dkZurq62LVrF88m8VlZWdDR0eGMPycnB3Z2drC1ta1lUPT8+XPIy8s3GCHjr0RERHC0Dh8/fqx1benSpXXO7WooKCiArKxsrdf+w4cPkJGR4an/kpIS+Pn5wcLCAr169QKDwcCkSZPw+vXreu+pUW825M4xbdo0xMbGNtp/c3j16hU6d+4MDQ0NdO3aFQoKCtDQ0EC/fv2wbNkyxMbGgsFgQE1NDeLi4ujcuTOioqJw/PhxFBcX12nP3t6eZ20DL0RGRmLs2LEtaqOoqAgxMTGQk5PDqFGjIC0t3aL2Kisr0atXL3h7ezcq9J49ewZ5eflWMRj6p/KvFnzADxWcjY0N/P39oaioiO3bt/N8b3FxMRYtWgQVFRV4eXnxZNDQEpYuXdpk59k7d+5g+/btMDY2ho6ODmRlZaGiogJPT09MmTIF+/btQ05ODioqKpCTk4PDhw9jwYIFCAoKgqqqKgQFBaGiogJXV1eMGTMGa9euxfnz51FQUNDoDqi6uhqBgYHo0aNHg065p0+fBpPJbNARuyGh3xDXrl2DkpJSg23XkJ2djR49eqBt27bYtGlTk6PCTJw4sc4YWSwWVqxYAXl5eSxbtgzV1dUYP358k42HCgsLIS8vjwEDBtQRcikpKfDw8OB63/79+9G9e/c65d27d0diYmKDfX748AGdO3fGgAEDOKqz3NxcjB8/HnJychg0aFCduKq8CD0AmDt3LqZMmdJgHV55+/Yt9u/fjwkTJqBz584c7UeXLl0gIyODqKgoTJo0CVZWVpCQkIC9vT0mTJgAY2Nj+Pv7NxgA4f79+1BRUWmyU3lDvH//nqdYrNwoKSnhxJANDg5Gfn4+qqurISAg0Gwr9MrKSvj7+6N79+48qUgHDRqEWbNmNauv/xb+9YIP+CHALC0tMXjwYLRp0wbLli1r0v1lZWVISEiAtrY2bG1tkZKS0qqOszWsXbsWISEhTb6PzWZDRUUFT58+5YRMOnToEGbOnAlfX1+0bdsWUlJSsLW1RVhYGDZt2oQbN27g2bNnkJGRwYMHD3DixAnExcVh+PDhHEtTBoMBOzs7jBgxAvHx8Th58iTy8/PBZrPBYrEQHBwMFxeXBieWTZs2QUlJqdFFw8qVK3kyzOHGvXv3oKamhrVr13K9/vjxY/Tp0wfKysrNPh9hsVhQU1Or16jm6dOncHBwgJWVFaSlpZul6po7dy78/PzAYDBquXY8efIEmpqaXO8ZM2YMFi9eXKd89+7dDQYyyMnJgba2NqZOncp1gfPp0yfMnz8fKioq8PDwwNmzZ5GRkcGT0AN+LOImTpzYaL2/UlVVhezsbKxevRr9+/dHu3btIC8vD29vbyxYsABHjhzB7t27MX78eHTo0AGioqIQFhaGi4sLzp49W8vys6ysDL1794adnV29u5dx48bxlCmjqYSHhzfJMKSyshLr1q2DqqoqAgIC6jjRy8rK8hQliFu7AQEB8PLy4ulz//DhQzCZzF9q6PdP4H9C8AE/4taZm5tj7NixMDAwwOTJk5tsAlxdXY29e/eiQ4cOMDEx4RgFtBbbtm1DUFBQk+/Lzs6Gjo5Og3U+ffqEc+fOYdmyZQgKCuKoP6WlpWFlZYVly5bh3LlznAmCzWbj/fv3OHfuHNasWYOwsDCOpamEhASUlJTAZDIRGxuLI0eO4OnTp7VWpCwWCzExMdDW1uYp/uiOHTswcODAJj97Dc+fP4eWlhYWLFjAKcvLy8PQoUOhoKCABQsWcDUc4ZX09HROIO36YLFY6NmzJ0RERLB06dImr9C/ffsGZWVlhISEoH///pzyyspKiIiIcF1gmJiYcNLE/ExJSQlkZWW5GmtkZmZCSUmpXivSnykvL8emTZugoaEBAQEBREdH87RTXrVqVZ1A6dwoLi7GyZMnMWPGDLi6ukJKSgqGhoYIDg7Gli1bcPHiRezZswejR4+GsbExpKWl4eHhgfnz5yMzMxMVFRV4/fo1bG1t4enpWUc4sFgsREZGQl9fv46faElJCRgMxi/J+vDmzRvIyck1aizDYrGwa9cuaGtro2vXrlzfSwDQ1NRs0JiKG1VVVejduzc8PT15DvvXu3fvX3I2+0/jf0bwAT9UO0ZGRoiJiUHnzp0xbNiwZgVBZrPZOHnyJJycnKChoYFVq1Y1O0zZz+zfvx+9evVq8n3z589v1plCWVkZ1q5dC1VVVYwePRq2traQlJRE27Zt4evri5kzZ+LQoUPIy8urtUiIiIiArq4uVq5cWcfS1MzMDAEBATAxMYG+vj4yMjJ4Cp119OhR9OjRo8nP8DNv3ryBkZERwsLCMHr0aDAYDEybNq2W9WhzGTVqFObPn99gncrKSrRp0waHDx+Go6MjrK2tmxzfcPXq1XBzc4OKikotgxV9ff06hic1+QDr+wwPHjwY8fHxtcqSk5PBZDKbFE7s0qVLUFBQQGxsLBwdHaGhoYH4+PgGDS02btyI4ODgWmVsNhtPnz7F9u3bERISAhMTE0hKSsLJyQlTpkzBsWPHcPfuXSQmJmL48OHQ09ODrKwsvL29sXTpUly/fr3eZ62srERERAQ0NDS4hidcvXo1VFRUagmWrVu3wsvLi+fXoamMHTsWkZGRXK/VGBa1b98elpaWjbryWFhY1CsUuVFVVYU+ffrAw8ODZ6GXnZ0NZWXlFi0Q/1v4nxJ8wA+nTD09PcydOxfu7u7w8fHhORI7N65cuYKePXtCUVERc+bMaVGSyOPHj9d7ltMQdnZ2zc5Zx2azoaenxzFyYbFYyMnJwb59+xATEwNPT0+oqKhAVlYWTk5OsLOzg4qKCs6fP19nt/v9+3ecOXMGurq6MDQ0hLe3N/T09CAiIgJ9fX307NkTU6ZMQWJiIm7evFnrC5aRkQE7O7tmPUMNhYWFGDt2LAQEBGBmZtZi0/QaKisrwWQy640sU8Pu3bvh6OgI4MfruHr1asjLy2Px4sU87/4qKiqgqamJ8PBwdO3alVPu4+NTxwDj4MGDDX5e0tLSYGFhAeDH+xwXFwc1NbUmBUK/dOlSHfXmtWvX0Lt3b8jLyyM6OpprNJ0dO3agb9++uHTpEhYvXsz5jqirqyMwMBArVqzA9evX8ejRI2zZsgWDBw9Gu3btoKCggF69emHFihW4fft2k3fNBw4cAJPJxOrVq+todGqiBB05cgQAYG1tjaNHjzap/abw6tUryMnJoaCgoFb5pUuXYG9vDwMDAxw4cIAnzVPXrl0bTNr7M1VVVejbty/c3d2bFODd29sbK1as4Ln+fzP/c4IP+PGB1NLSQnx8PPr16wd7e/sW7woePnyIIUOGQE5ODhEREQ1axdXH+fPn4eDg0KR7ioqKICUl1SLhHR8fX0u1xo33798jLCwMDAYD3t7e0NfXh5iYGDp27Ihhw4Zh1apV2LVrF7S0tBATE1PrDLS8vBz37t3Dvn37MGvWLAQGBtayNPX09MSgQYOgqqqKy5cvN/m9+PLlC2JjYyEvL4+QkBA8evQIzs7O6Nu3b6uook+ePInOnTs3WIfNZqNTp06cSbWG58+fw8nJCZ07d8bDhw956i8pKQmdO3eGjo4OR+BMmjSpzo5z/PjxtVS7f6W6uhoqKiq4d+8exo4dC2Nj4yY5V3MTej/z7NkzjBkzBrKyshg6dCjS09Nx8OBBREREQE9PDwICArCwsMC4ceOwZ88evHz5Eo8ePcL69evRv39/qKmpQUVFBX379sXatWvx4MGDVsks8fTpU46P618tW69fvw4VFRVOGqRfnfZq1KhRHEOnu3fvwtvbG23atMGWLVua1Hfv3r15CgFXVVWFfv36oVu3bk0SelevXoW6uvpvy4Tyd/M/KfiAH9Zrbdu2xfr16zF27FiYmZm1ShzI/Px8hIeHQ05ODsHBwU3Kr3f9+nXOCp1X9u3bB09Pz6YOsxafP3+GjIxMnZXpz2zfvh3q6uq1fBu/f/+Oy5cvY+3atfD29oagoCCEhYWho6ODgIAAzJs3D8ePH8ebN2+4TmhVVVXIycnBkSNHMHnyZIiLi6NTp06QlJSEiooKXFxcMGbMGKxZswbnz5/H+/fva7VTWlqKJUuWQFFREQMHDsSzZ88418rKyuDt7Q0vL68Wq6G5qQz/ysWLF6Gjo8PV6InFYmHt2rWQl5fHokWLGp3wWCwWzMzMEBUVBXNzc7BYLGzatKlOhHxzc3Ncvny5wbbGjh0LPT09ODs7N2lBUaPerG+XUV1djTt37mDdunXo06cP5OTkwMfHByaTiWHDhnE0Knfu3MGqVasQEBAARUVFaGhoICgoCJs2beIYY/0KSktLERwcDAMDgzoGSS9evICsrCxsbGx+iZHaz7x8+RKysrKc54+Pj2+WcAkJCanXeKuG6upq9O/fH25ubk1eCLu5uTUp9dF/O/+zgg/4sTJUU1PDtm3bMHfuXGhpadWaPFtCYWEhZs2aBSaTiYCAAJ6ijNy/fx+GhoZN6mfIkCE8O0o3xNChQ+vdPSQnJ0NZWbneHcvOnTs5Yauqqqrw4MEDJCUlITIyEl27doW8vDwUFRXRrVs3REVFYffu3Xj06FEtNdbXr18hISEB4Mfu6eXLlzh58iTi4uIwYsSIWpamNjY2sLW1hbS0NGxtbeuNtlJZWYkBAwbAwcGh2VZqZWVlkJWVbdQ03c/Pr9Gg3C9evICLiwusrKwaDbl27NgxGBkZwcrKCklJSbh48SKsra051z9//gwpKakGd7QFBQUwMTGBhIREkybbzMxMMJnMWkLv69evOH36NGbNmoVu3bpBRkYG+vr6GDp0KDZu3IgHDx7gy5cvmDJlCphMJiQkJCAgIABtbW0EBwdj+/btv8SIpDG2bNkCBQWFWu4u3759g4yMDDp37ozevXv/sl3Ou3fvEBYWBhEREdjb27fIUjI6Ohpz586t93p1dTUGDBiArl27NlnoXbhwAVpaWq1qqPdP539a8AE/VJQqKirYs2cPEhISoKqq2uJksD/z7ds3xMfHQ11dHV27dsWZM2fqXeW+ePECGhoaPLfNYrGgrKzcKsI6KysL7dq1q3OmkpqaCiaTyfU1YbPZmDt3Ltq2bVvH3+uv9V69eoWUlBTMnj0bvXr1gpaWFiQkJGBtbY3Q0FCsW7cO/Pz8XB2Ma6iqqsKKFSugrKwMQ0NDTq4+FRUVSEpKolOnThg0aBDH7D0nJweVlZUYPXo0OnbsyDVoeWMcPHgQTk5ODdZ59uwZFBQUeDIKYLPZWL9+PcfStL7dH5vNhp2dHWJiYtCuXTvk5+dDTk6O89k5evRorTPAv/LkyRNoa2tj2rRpMDQ05DlQQWZmJhQUFLBt2zYkJSVh1KhRaN++Pcc/Ljo6GkePHsXHjx9RWVmJK1euYOHChfD09ISMjAyMjIwQEhKCwMBASEpKQlNTEytXrvxbDSZu374NHR0djBo1CuXl5diwYQMnwXHfvn1ha2vbLFeB+igqKsKUKVPAYDAQHh6OGzdugMFgtMghfNGiRYiIiOB6rbq6GgMHDoSrq2uTtRs1n7Om+Df/G/ifF3wAcOfOHSgpKeHQoUMcq7eWhMLiRk18RAMDA3Tq1AnJycl1hExBQQGYTCbPbd66dQu6urqtNsZOnTrVim5z4cIFKCgo1AnYDPx4nqFDh6Jjx47NctQFfpiyp6enY8WKFRgyZAgEBAQgKioKQ0ND9O/fH4sXL8bp06dRUFCA/fv3w9DQEHZ2dkhPT6/TVlFRES5fvoxNmzYhIiICnp6eaNeuHURFRWFqagpDQ0MoKChg3bp1uHfvHs++fH369GlUBTR27FjExMQ06dlzc3Ph6uoKS0tL3L9/n2udixcvQkNDA56enpizZDkUHQcgZNsVDN12HXaTNqH3jIQ6QdqBH2pKJSUlTgi4+fPnN+gfWlFRgStXrmDs2LEQFhaGnJwcVFRUEBAQgLi4OFy7dg0VFRUoKytDeno65syZg65du0JSUhLt27fHuHHjkJycXEtVfvXqVVhaWuLy5cvo1asXFBQUMHXq1L8t9mNxcTF69eoFCwsLGBsbc4zBWCwWJk+eDF1d3RYvIEtLS7F48WIwmUwMHTq01g532LBhmDFjRrPb3rhxI4YNG1anvLq6GkFBQXBxcWmWSv/kyZMwMDBocYq2/zb+CL7/58aNG1BUVMTx48c5obDqC4bbElgsFg4dOgQrKyvo6elh06ZNnEn427dvEBcX57mtuXPn1hvKqjls3ryZEwXk2rVrYDKZXM2si4qK4OLiAm9v71ZdyWtpaeHBgwfIzs7G1q1bOeli+Pn5ISQkBCsrK0ydOhXJycl49uwZT+dD379/x82bN5GYmAgXFxeIi4tDS0sLIiIi0NPTQ8+ePRETE4PExETcuHGj1vN8+/YN0tLSDe4GPn/+3OwoHWw2GwkJCVBQUMD8+fO57v5ceg+FzeRtaBt5EBqTDtVKy6Uz5Rj0pqViZGIWbucXAfhx5vtXNWVeXh7k5eU5biUfPnzA4cOHERUVBTs7O0hISEBPTw+ioqKIiopCbm4u2Gw2SkpKcObMGUyfPh2Ojo6QkJCApaUlIiIicPTo0QYtmG/fvg0zMzPO/zk5OZw4uCNGjGiym0drwGazMWHCBPDz89cxQlq3bh2UlZVx9erVJrdbWVmJhIQEqKmpwc/Pj6sauyYMWHON6JKTk9GzZ89aZdXV1Rg8eDCcnZ2bJfRqDLL27dvXrDH9N/NH8P3ElStXOJP9zZs3oaKigo0bN/6SvthsNs6fPw93d3eoqalh2bJlKCoqAh8fH88H/ra2tjybOPNCSUkJ5OXlkZqaCkVFRa6m3rm5uTAyMsK4ceNafZXYsWNHzlnohQsXYGtrC0NDQyQnJ+P58+c4cOAApk+fDm9vb6irq0NaWhr29vYYN24ctmzZglu3bjXqM7hhwwaoqqoiKysL9+/fx759+xAbG4vAwECYmZlBVFSUs8vy9PSEqakpMjMz653kFy1a1KygAz+Tl5cHNzc3WFhY1PLVS7ySC72px9E26mijiZj1p6di8JyNUFdXR3Z2NqcNFouF+/fvQ1dXlxOfVEZGBu7u7pg9ezbOnDnDCSmXnJyM1NRUREdHo0uXLpCQkICNjQ1iYmJw4sSJJgVIfvToEfT09OqUf/jwAbNmzYKioiJ8fHxw8eLFX2bgwo3g4GCEhIRAXV0dMTExtRYbKSkpYDKZPGc4YbFY2LNnD3R1deHi4tKo0Bw8eHCz45eePXuW4ypT0/eQIUPg5OTU7MXn4cOH0b59+19u4PNP5I/g+wvp6elQUFBAeno6cnJyoKmpifnz5//SL+etW7cQGBgIBQUFCAoK8mRyXmPc0NoH84MHD4akpCRX0+nr169DVVX1l/n6uLq6chy4tbS0sGPHjgaF68ePH5GWloYlS5ZgwIABMDIygqioKNq3b4/Bgwdj+fLluHDhQp1V9p49e6CoqMjVIrK6uhpPnz7FkSNHYGBgAFtbW1haWkJSUhLKyspwcXFBWFgY1qxZg9OnT9dxNG8ubDYbGzduhIKCAubOnYttl57BYHpqgwKvzk/kQSw5dBVnz57FnDlz4OnpCVlZWejo6KBLly7o2LEj7t27x5noPn36hIULF0JMTAy6urqQkJCAo6MjZsyYgbNnz7bIGjY3N7fB8+qSkhKsXbsW2tra6Ny5M1fVf2tTXFzMiWZTUFCArl27wsnJqZa/Z1ZWFlRVVbFy5cp622Gz2Thx4gQ6dOgACwsLpKWl8dT/kydPoKCg0Cwjl+zsbM4OmsViYejQoXB0dGy20GOxWDA1Nf2lfoz/ZP4IPi6kpaWByWTiypUrePPmDUxNTREeHv7LV0ZPnz6FiIgIZGRkMHbs2Aat4Pbu3dvqUSfy8vKgqqoKKSmpOmdghw4dquX829rcu3cPqqqqYDAYWL9+fbMtzEpLS3H9+nUkJCRg1KhRnJ2LpqYm/Pz8EBsbi6NHj2Lbtm2Ql5evd9L69OkTpKWlOZMUm81Gfn4+Tp48ifj4eIwYMQL6+voQFBSEnJwcbG1tMXz4cMTFxeHEiRN4+fJlsxZLL1++hINfEDQmHaxXwKmOTAAJCEHC2KnOtbYRybB098ekSZNw6NAhzpna58+fISkpiW3btnHcd8TFxSEkJIRBgwYhIyOjVRMTv3v3DkpKSo3Wq66uxoEDB2BtbQ1tbW2sWbOmVaIgcWP16tXo3bt3rb5nzJgBVVXVWufGubm5MDAwwMSJE+t85y9fvgxHR0fo6+sjOTm5ye/xgAEDuKaeaoy8vDyoq6tzYuQ6ODi06Jhhz549sLKy+q277X8SfwRfPRw/fhyKioq4efMmioqKYGdnhwEDBvxyk191dXVcv34dUVFRYDAYCAoK4pojbfDgwVi9enWr9fv27Vvo6Ohg+fLlcHV1xa5duwD8J+JHjXqwtXn69CkGDBgARUVFWFlZNeoS0Byqq6vx+PFj7NmzB5MnT4a7uzsUFRUhIyMDISEh+Pj4IDExEffv3+eovjZu3Ah/f/9622Sz2ejYsSOOHj2KgoICnD9/HmvXrsWYMWPg6upay9I0KCgICxYswOHDh5GTk9OoH9+IHVnQiE6pV/CJtusAEXUjroKvXfQxhCT+eJ/evHmDXbt2ISQkBIaGhhASEoKpqSkWLVrESUvV3Ig/jfH582fIysryXJ/NZuPSpUvw9fUFk8nEjBkzmmWF21D7pqamXM+sT5w4ASUlJSxatIgjCD5//gwHBwf4+/ujtLQU9+7dg4+PD9q0adOszB41PHr0CEwms8l59b58+QIJCQkMHz4c9vb2TUp59Veqqqqgp6fHNYHw/wp/BF8DHDp0CEpKSrh79y5KS0vh7e0NT0/PX2qara+vzzn4Lyoqwvz586GkpARvb2+OdSWLxYKSklKjIbR4pbCwEMbGxpgzZw6AHwfpdnZ2qKqqQlhYGIyNjVvdBys/Px8jRoyAvLw8Zs+eja9fvyIiIgJLlixp1X4a4u3bt1i5ciUkJSVhaWkJXV1diImJoVOnTlBVVcXw4cORmZnJdZJJT0+Hnp5eg1qAGkvTzZs3IyIiAl5eXrUsTfv06YNZs2Zh7969HEvTj9/KoTetfhWngs8kiBvYQca2H1fBpxF9DJqTj0DL0AwMBgM9e/ZEXFwcbt68if3798PJyQmXL18Gk8n8ZUIP+LHzFhUVbda9jx8/xsiRIyErK4vQ0FDk5OS0eDyZmZnQ1dWt9/16+fIlOnfuDB8fH45qvLy8HD4+PmAymZy0U61xtNC3b18sXLiwSfdUV1eDj48PNjY2LRJ6wI8YpQ4ODv+zuz3gj+BrlD179kBFRQUPHz5EVVUVhgwZAmtr61+WpLFDhw64ceNGrbLS0lKsXbsWmpqasLe3x4oVK7gaDjSHL1++oFOnToiKiuJ8ESorK6GsrAwHBwd07dq1Qd+6plJQUIDw8HAwGAxER0fXeh3nzJnzS1LENMajR4/Qpk0brFixAl+/fsWRI0cgKiqKIUOGwMLCAmJiYtDT00OfPn2wYMECnDhxAu7u7li3bl2z+quxNE1KSsKUKVPg5+cHfX19CAsLQ9V10A8LTi4Crc2EfRCUU4Xa6K0NCj7t6KOYuedinUm+vLwcUlJSkJeX/6VCD/ixOGuKoRY33r9/j2nTpkFBQQF+fn6NRqlpiEGDBjW6qKqoqMC4ceOgpaWF06dPY+zYsRw1tra2dpOzI9TH/fv3oaioyPMCmsViYeTIkRAUFGyxy0VFRQXatWv3y3OL/tPhpz80SGBgIC1cuJDc3NwoLy+PtmzZQvb29mRvb0+vX79u9f7ExcWptLS0VpmYmBiNGjWKcnJyaNSoUTR//nz6/Pkz7d69m6qrq5vdV2lpKfXo0YOsrKxo4cKFxMfHR0REHz9+5PxOTU0lGRmZ5j/Q/1NUVERTp04lQ0NDYrFY9ODBA1qwYAExGAxOHVlZWSouLm5xX03FwMCALl68SKtWraL4+HjKy8ujgIAA2rp1K924cYO+fPlCBw4coB49etDHjx8pNjaWTp8+TbNmzSJPT0+KiYmhffv2UU5ODrHZ7Eb7k5CQIAMDA1JXVycJCQmqrKykjx8/kqqqKinomhOfoDDX+4ozEkmyfTcSlGY22H418dMXkiR+/tpf71u3blFVVRX5+PiQh4cH7y9QM+Dn5ydBQUGqqqpqdhtKSko0Z84cysvLIxcXFxowYADZ2trS4cOHeXqda/j8+TMdPXqUhgwZ0mA9YWFhmj17Npmbm5O7uzs9ePCAHj16RJcuXaJJkyaRvb09XblypdnPU4OxsTE5OjrS+vXrG63LZrMpLCyM7t+/TxoaGi16PYmItmzZQvr6+mRvb9+idv7b+SP4eGDQoEE0Y8YMcnV1pZcvX9LixYtpyJAhZGdnR48fP27VviQkJOoIvhoEBQWpX79+pK2tTeHh4bRu3TrS09OjdevWUVlZWZP6qaioID8/P9LU1KRVq1ZxhN7du3fJ2tqahgwZQu/evaPy8vIWPc/3799p/vz5pKenRwUFBZSdnU0rV64kZWXlOnVlZWWpqKioRf01Fw0NDbp48SIdOHCAFi5cSIGBgZxrQkJCZGJiQkFBQbRs2TKysLCgmJgYun79OoWGhpKoqCjt3r2bunXrRjIyMmRra0thYWG0ceNGunHjBpWXl9Pr169p3759FB4eTpaWlsRkMik6Opo+ffpEw4YNo/v371Nubi5ZWNtxHV9lwQsqf3mHpC19eXqer+W1J8grV66Qr68vzZ49m65fv04Amv9i8YiIiEiLPz9EP74TY8aMoadPn1J4eDjNnz+fDAwMKCEhgafP/Y4dO8jLy4sUFBTqrVNWVkZLly4lXV1dkpKSorS0NCooKKBJkyZRSUkJhYSE0ObNm8nHx4cOHjzY4meaNm0aLV26tN7vOhERABozZgzduXOHTpw4QfLy8i36fpSVldHcuXNpzpw5zW7jX8PfveX8b2LlypXQ0tLiZNfeunUrlJSUuOb/ai49e/bEgQMH6r3+6dOnWm4Mly5dgre3N5SUlDB//nyeHGSrqqrg5+cHf3//Wof0J0+eBJPJ5Lgy+Pn5NVudV1ZWhvj4eCgpKaFv3748BetOSUn5pfnReOHOnTsQFBTEoEGDuBowfPr0CXJycvUGNP/8+TPOnDmDCRMmwMrKCrKysuDj44OAgADU1dXRvXt3LF++nJO9g81mIycnBzt37kR4eDgMhi7kqr6Ucx0BPiER8EvIgl9CFnxCouATFIawkjbX+r2XHeOokWv8U1NTU8FisaChoYHbt2//uhfx/1FQUGhVA5Ua2Gw20tPT0aNHDygqKiI2NhYfP36st66BgUG9qr2qqips3PjD/7Fnz561ouh8//4dQUFBMDExwePHjwEAN2/ehKqqaqNBy3nBz8+v3nbYbDZGjx4Na2trjmWxh4dHrchKTSU+Ph6+vr7Nvv/fxB/B10SWLFkCPT09ju/P0aNHOQGaW4P+/fsjMTGx3uu7d+/mmrD13r17CAoKAoPBQFRUVL0TM4vFwsCBA+Hh4VHLfD0hIQFKSkq4dOkSpywtLQ1mZmZNOqeprKzEhg0boK6uDh8fH9y5c4fney9evAgbGxue6/8KFi1ahKFDh8LNzQ29evWqY+K/YMGCOlkSPn/+jNTUVEydOhXOzs6QlJSEsbExRo4ciW3btuHevXu4ceMGNm3ahCFDhsDQ0BDCwsIQERGBoKAgpKWl0blzZ0RFRSFi0wnoTTte93wvIhnqYxI5P9JWfhDXt4H6uJ116mpFH0HHAVGQkpLiGNOEh4fj8ePHYLPZmDJlSr0JUlsTdXV15Ofn/9I+Hjx4gGHDhkFWVhZhYWF1zsAuXLgAQ0PDOp9hFouFffv2QU9PD05OTrhy5QrX9n+OrrN3714AP1wLjIyMMH78+Bb5Ht66dQsqKip1gkqz2WyEhYWhc+fOtc7X+/Xr1+Dc0BDfvn2DkpJSk76P/2b+qDqbSGRkJA0cOJBcXV3p48eP5O3tTQcPHqSBAwfS3r17W9x+Q6pOIqITJ06Qp6dnnXITExPasWMH3bp1i8rKysjY2JhCQkLo2bNnnDoAKCwsjPLz8+nAgQMkIiJCbDabJk+eTEuXLqVLly6Rra0tp76LiwuVlZXR5cuXGx03m82mXbt2kaGhIe3du5f2799PR44cITMzM56f/e864/uZ3bt3U1BQEKWkpBARkbe3N5WUlBARUWVlJa1cuZJ69epF27Zto5EjR5KxsTFpaGjQ0qVLiY+Pj6Kioig/P5/u379P8+fPJyUlJTp06BDFxsbStGnT6NixY9SuXTuaPHkyrVy5ktatW0djx44leXl5SkpKos3TRlJFZd1zHH4hURKQlOP88AmJEp+gMAmI1z1/FRQUotPrZ1NqaioVFxfT0KFDqaCggNzd3UlRUZGuXLlCCQkJlJ6e3mQVeVNoLVVnQxgZGdHmzZvp4cOHJC0tTZ07d6bevXvTtWvXiIgoISGBQkNDOap8AHT69GnOufaqVavo3LlzZG1tzbV9Pj4+GjlyJJ08eZKio6Np/PjxpKKiQpmZmXTnzh3q3bt3g9/XhujQoQNZWlrS5s2bOWUAaPz48ZSVlUWnTp2qdb4uJyfXbFXnqlWryMnJqUnfx38zfMBvUPb/ywBA06ZNo9TUVDp37hzJycnR3bt3ycvLi2JiYigsLKzZbYeHh5OGhgZNmDChzjU2m00qKip09epV0tTUbLCdjx8/0qpVq2jdunXk6upKUVFRtHv3bkpPT6czZ86QtLQ0lZWV0eDBg+ndu3d0+PBhkpeXr9NOXFwc3bp1i5KSkrj2A4COHDlC06dPJ0lJSZo3bx65uLg069nfvHlDVlZW9ObNm2bd31IeP35MLi4u9OrVKxIQEKDq6moaOnQo3b59m/z9/SklJYXu3btHqqqqZGNjw/kxMzOjsrIyunXrFmVlZXF+CgsLycLCgiwtLTk/GhoanEmYGx8+fKCRiTfodiGbiOqvVx98fETuRko0RKeafHx8aPv27bUWSm/evKHLly9TWFgYMRgMevXqFZmZmZGNjQ3Z2tqSjY0N1/PX5mBiYkJ79uwhExOTVmmPF75//06bN2+m+Ph4UlFRobt371J+fj7Jy8vTtWvXKCYmht68eUNz584lf3//OgZADVFUVESDBw+mjx8/0t69e0lJSYmCg4Pp2bNnlJKSQkxmw0ZH3Lhx4wb17NmTnj9/TsLCwhQeHk5Xrlyh06dPk6ysbK2606dPJ0FBQZo5c2aT+iguLiZdXV26ePEiGRgYNHmM/0b+CL5mAoAiIyPp4sWLHEGSm5tL3bp1o/79+9OsWbManODqY8qUKSQhIUFTp06tc+3GjRsUFBREjx494rm9b9++0caNG2nWrFkEgJKSksjHx4cKCwvJ19eX2rVrR1u2bCFRUVGu93/+/Jm0tLTo6dOntb7YACgtLY2mTZtGlZWVNHfuXOrevXuznrmGkpISUlRU5OywfjezZs2iN2/ekLu7O12+fJkuX75M9+7dIykpKaquriYJCQmaM2cOBQYG0p07d2oJuby8PDI1Na0l5PT19Zs0sdZw51Ux9d14lcqqWE2+V0xIgKZ1kaQJg3/sSr28vLjWi4+Pp7t379Lq1aspKyuLLl++TJmZmXTlyhWSk5PjCEJbW1syMjIiAQGBJo/FwsKCEhISqFOnTk2+t6VUV1fT4MGD6dSpUyQtLU0yMjL08eNHmjVrFg0ZMoQEBQWb1S6bzaalS5dSXFwcbd++nbp160bTp0+nPXv20IkTJ0hXV7fJbXbv3p26d+9OOTk5lJmZSWlpaXWEHtGPRWh+fj4tX768Se3PnDmTXr58Sdu2bWvy2P6tNO/d/wPx8fHR0qVLacyYMeTl5UUnT54kTU1NyszMJE9PT86Oq6kTRkOqzvrUnA0hJSVFfHx8pKSkRKNHj6aoqCiaMWMGFRQUUHBwMM2ZM6fByZnBYJCfnx9t2bKFJk+eTEREmZmZNHXqVHr37h3NmTOHAgICmjXB/xVxcXGqrKykyspKEhbmbtLfmrBYLLp37x5n0t+/fz+JiYnR+/fvycbGhhYvXkwdOnSg3NxcGjVqFF29epWWLFlCoaGhpKurS5aWltSlSxcaN24cmZiYtNqY27eRpZGW8rQ8/RXxCYnwfB+qKuhzxi4auvAo+fj40JcvX+jRo0ekp6dX53PYt29fmj17Nq1Zs4acnJzIycmJiH5M7I8fP+a8JvHx8VRQUEDW1tYcYWhlZUVSUlKNjkdUVJQqKiqa9OytBT8/P126dImsrKzo8uXLJCIiQtXV1fThwwf6+vVrLTeaprYbFRVFnTt3pv79+9Pw4cMpNjaW2rVrRw4ODnTgwAGysbFpUpvTp0+nbt26kY6ODp09e5ar0CP6oeq8c+dOk9ouLCzkLG7+8B/+nPG1AD4+Plq1ahUZGBiQt7c3lZaWkqKiIp0/f54eP35M/fr1a/IXX1xcvN4dT3ME38aNG2nFihV09uxZmjBhAq1bt45evnxJoqKidPDgQdqxYwdVVlY22MaoUaMoISGBbt68Sd27d6cBAwbQ4MGD6cGDB9SnT59WEXpEP15PWVlZ+vLlS6u091e+fPlCp06dopkzZ5KbmxsxGAzq378/3bp1i3R0dIjJZFJWVhb179+fPn78SFOnTiVVVVUKCAigly9fkpmZGX348IFzvrNp0yYKCQmhjh07tqqg/vr1K22cPJjcFb+TmJAANbqJBptQVUG9tIiqH5+nKVOmkLm5OR04cIC8vb1JRkaGrK2tKTQ0lNavX0/Xrl0jGRkZsrKy4pxl1sDPz09GRkY0fPhw2rp1Kz158oSePn1Ko0ePppKSEpo5cyYpKytTx44dacyYMbR79256+fIlV/cIUVHRX37Gx40PHz5QQEAAvXnzhjp27EgvX76kR48e0ZkzZ+jp06eko6ND48ePp9zc3Gb34ejoSDdv3qSMjAzy9PQkX19f2rp1K/Xs2ZMOHDjAczsAaP/+/cTHx0dBQUEkJydXb10Gg0GfP39u0jiXLFlCffr0IS0trSbd96/n77Co+bdRXV2NAQMGoFu3bhw3g7KyMvj7+8PV1bVJcfnWr1+PESNG1CkvLCzkGjy6IXbu3AlVVVVOyKfExERO2iU2m40zZ86ga9euaNOmDeLj4+sNhfTgwQPIysqCwWBg1apVrRrM+K/o6Oi0SogqNpuNZ8+eYfv27QgJCYGpqSkkJSXh5OSEKVOm4NixY7h37x4OHTqEKVOmcKwf1dXV4efnh/nz5yMtLQ1FRUV48uQJmEwmSktLsXXrVigrK7dKRgZusFgseHt7cxLH3nlVhJDELOhNS4X+X0KZ6U9Lhe7U42jTLxZugcEQERHB8ePH67RZXFyMjIwMrFy5EkOHDkWHDh0gKioKFRUVqKqqYtGiRTh16hTPrgfl5eW4fPkyli5dCj8/PygqKkJNTQ19+vTB8uXLkZWVhcrKSnh6enIdz6/iy5cvmDFjBhgMBrS1tesNC/b69WtOLNzAwMA6kZKaQlVVFaKjo9GmTRtkZmbi1q1bUFNTQ1xcXKPW0Gw2G5GRkejQoQNOnDgBDQ2NBmMBp6enw9bWluexvXv3DgwGg+N+9Yf/8EfwtRJVVVUICAiAt7c3JydcdXU1QkJCYGFhwfOkkpiYiAEDBtQp37VrF7y9vXkez+HDh6GkpIR79+6BzWYjNjYWGhoaXLN9Z2VlISAgAEwmEzNnzuQkXn3x4gUGDx4MJpMJf39/eHp68tx/c+nUqROuX7/e5PvKysqQmZmJJUuWoGfPnrUm4xUrViAtLQ3Hjh3DnDlz4OPjAxUVFcjLy8PDw4MTFuvs2bNc2x41ahSmT5/O+f/AgQNgMpm/JOzT1KlTYW9vXyevYOG3cqxPf4bwPdkYtu06wvdkY336MxR+K8fUqVM5WSJ4DSReUVGBy5cvQ0xMDCEhIXB0dISMjAxUVVXh5eWFqVOnYv/+/Xj69GmjWUn+usgwMTGBpKQkFBQU0KtXLxw/frzBpLUtpaysDMuWLYOioiIGDRqEq1evQlZWttH0P1++fMGyZcvQpk0bODk54fjx483OwFLj1hQXF4e8vDwYGxtj7Nix9bo7sNlsTJo0CR06dOD4W7q6umLz5s319nH37l0YGRnxPKaxY8ciPDy8aQ/yP8IfwdeKVFZWwsfHBwEBARznZzabjenTp0NPTw+5ubmNtnHgwIE6mZYBICgoCGvXruVpHDWJRbOyslBRUYHBgwejU6dOtfKOcePJkycYPnw4ZGRkYGpqCllZWcyYMQPFxcX4/v07GAxGqwer/itdu3bFqVOnGq33/v17HDx4EJGRkbCxsYGEhAQsLCwwduxYbN26Ffv378fSpUsRGBgILS0tSElJwdHREZGRkdi7dy9evHjBWZFnZmbCyMiI6wq9sLCQk8PtZ06fPg0FBQWkpqa2zoPjR6opDQ0NFBQU8HzP1atXwWQyoampiREjRsDFxaVJfpf9+/fnZPlgs9nIzc3FwYMHMWPGDE42AikpKdjZ2WHMmDHYvHkzbt682eiuv6ioCI6OjvDz84OLiwskJSVhZGSE4cOHY+vWrcjJyWlxkOSqqips2rQJbdq0gY+PDyeLydy5c7lqTeqjsrISSUlJaN++PYyMjLBly5ZmaTVevHgBCwsL+Pv74+XLl3B2doavr2+dNEtsNhtRUVEwNzevFas2IyMDWlpa9WZ+eP36NZSVlXkay8uXLyEnJ8dJS/WH2vwRfK1MeXk5PDw80L9//1qrvZUrV0JdXZ1riqGfOXHiBLp161arjMVigclk8iQ4L168CAUFBWRkZODz589wcnKCr68vTwFxP378iMjISMjIyKBTp06QkZHBkCFD8PDhQwDAuHHjMGXKlEbbaQkBAQEcR+EaqqurcffuXaxbtw5BQUHQ1taGnJwcvLy8MGvWLKxduxZxcXEYMmQIjI2NIS4uDisrK4SFhWHbtm148OBBg47GY8aMwezZs7lemzdvHoYOHcr12uXLl6GoqFhnvM3h1q1bUFBQqJU9vTFqhN6xY8dw9uxZtGvXDrq6uk0KQJ2amgpra+sG6xQWFuLs2bNYunQpBg4cCBMTE4iKisLMzAyDBg1CXFwczp8/X2dXN2TIEGzZsgXADyF18+ZNrFy5En379kWbNm3AZDLh6+uLRYsW4dKlSzxnPmCz2UhOToa+vj4cHBxqBa+urq6GhoZGs9SXbDYbp0+fRrdu3aCqqooFCxbwFAnpZ8rKyhAaGgpdXV3cuHEDQUFBsLKy4ixm2Gw2oqOj0b59e45m5WecnJywbds2rm2XlJRARESEp3GMGDEC0dHRTRr7/xJ/BN8voLS0FM7Ozhg2bFgt1cmuXbugqKhYKzrKX0lPT4ednV2tsuvXr8PQ0LDRfm/evAkmk4mTJ0/ixYsXMDAwwIQJExqNLlFcXMw5Gxk1ahTevHkD4Ed4rjlz5kBRURE9e/bEnj17oKSkVEcN15oMHz6co5qMjY1Ft27dICMjAz09PQwaNAizZs3C3LlzERoaik6dOkFMTAympqYYNmwY1q1bhxs3bjRpfFVVVVBSUuJ6rlheXg4VFRXcvXu33vvv3LkDVVVVbNiwoVnPC/zIWKGhoYF9+/bxfM/PQq8GHx8fBAUFwczMjGeVXVVVFRQVFZuceaC0tBRZWVnYuHEjRo8eDRsbG0hKSkJDQwM9e/bErFmz4O7ujrlz59a7s8vPz8eePXswbtw4WFhYQFxcHF26dEFkZCQOHjzIdbeSlpaGTp06cc7F/tp2amoqOnXq1KRn4cbt27cRFBQEOTk5TJgwAS9fvmzS/YmJiVBQUMCWLVswffp0aGlp4dGjR4iJiYGZmVm9IdbOnTsHXV1drrs+NpsNYWHhOpFe/srTp0/BYDB+WQaZfwN/BN8v4tu3b7C1tcWoUaNqfTlr4mHWF3Pvxo0b6NChQ62y2NhYTJw4scH+Hjx4AGVlZRw8eBBXr16FiopKo4lqS0pKsGjRIjCZTAwaNKje/H4lJSVYtWoVNDQ0ICsri+jo6FbL5cVms/HixQskJSVh9OjRUFRUhLCwMOzs7DBy5EhEREQgNDQU9vb2kJSUhI6ODvr164e4uDhcvHixxbkR09LSYGFhwfXa9u3b4ebm1mgbOTk50NDQaFYuwYqKCtjZ2WHatGk831Mj9FJSUmqVP378GAwGA506dcKOHTt4bm/cuHGYNWsWz/Xrg8Vi4cmTJ9i7dy+io6OhoaEBKSkpMBgMuLi4YOLEidixYwfu3bvH1Yjj+/fvOHfuHObMmQNPT0/IyspCW1sbgwYNQnR0NDp37gxtbW3s2bOnXsHu4+ODjRs3tvhZasjPz0dERAQYDAb69++PW7du8Xzv/fv3oa+vj+DgYKxduxYSEhLQ0tKqV+gBP74PdnZ2SEpK4npdWVmZE+e1PoKCglrl/fw380fw/UK+fPkCKysrTJgwoZaguHr1KpSUlLB9+/Y69zx8+BD6+vq1yjp37sw1c3QNz549g5qaGhITE5GcnAwFBYU6k+LPlJeXY9WqVVBRUUFAQABHldkYlZWVGDNmDMTFxWFubo49e/Y0OVZhRUUFrl69imXLlsHf3x8qKipQUVFB9+7dMWzYMHTo0AHt2rUDg8GAmpoaevbsiXnz5uH06dO/xEAiODiYq8Bis9lo3749z2rDV69ewcDAAFOmTOF5UcBmszFy5Ej4+PjwvEO7du0aV6FXw7hx4+Dn5wcNDQ2eVYfXr1+Hjo5OqycmnTx5MhYsWIB3797hxIkTWLBgAfr06QM9PT2IiYnBwsICw4cPx+rVq3Hp0qU6VsUsFgtHjhxBhw4dIC4uDkVFRcjKysLDwwOzZ8/G2bNna93z6tUryMnJtThRKzeKi4uxePFiqKmpwdXVFSdPnuTp9fr69Sv69u0LJSUlqKqqQkFBodGdfVpaGvT19bl+twwNDRs8Lnnw4AGYTGajhj3/6/wRfL+Yz58/w9zcHDExMbW+KA8fPkTbtm2xbNmyWvXz8vLQpk0bzv8fP36EtLR0vYftr169Qrt27bB27VosXboUampq9ZraV1VVYcuWLdDQ0ICXl1ezTPIrKys5u0kbGxtoa2tj/fr19U6yHz58wJEjRxAVFQU7OztISEjAxMQEPXr0QO/eveHm5gZVVVUwGAy4u7vDw8MDHh4e9QbZbk0qKirAYDC4BlI+e/ZsvQYv9fHhwwd07NgRo0eP5kmQrVmzBkZGRjxPUo0JPeDHeZyCggKcnZ2xdOlSntpls9nQ09PD1atXearPKzNmzMDMmTO5Xvv27RsyMzOxZs0ajBgxgqO21tXVRe/evREVFQU3NzcwGAwsXryYo957//49Dh06xDFqEhcXR8eOHTF27Fj4+/sjKCioVZ/hr1RUVGD79u0wNTWFqakptm/f3qhqffr06VBWVuZkcVdXV8eSJUvq/Wyx2Wx06dKFkyXlZ2xsbBq0Ju7duzcWLVrUtIf6H+SP4PsNfPz4EcbGxnUMKPLz82FgYIDJkydzvgQfP34Eg8Hg1Nm5cyd8fHy4tltQUAB9fX0sXLgQoaGhMDU15TqJs1gs7N27l2MM0NAZIy9Mnz4dYWFhAH4Y03Tv3h0qKipYsGABrl69ig0bNmDIkCHQ1dWFtLQ0rKys4O7uDicnJ2hqakJSUhIODg6IiIjAnj178Pz5c87z79y5E/369WvR+Hjl6NGjdc5Ta+jevXuzVGbFxcWwt7fHwIEDG/TJOn/+PBQVFXnOqM2L0KshLi4O9vb2YDKZPBtnzJ49G2PGjOGpLq/Mnz+/SQYWVVVVyMjIgLu7O0RFRdGuXTvIyclBSUkJ7u7umDx5Mvbs2YPHjx9zdkM1biwLFy6EqKgo5OTkoK6ujsDAQKxYsQI3btyo10qyJbDZbJw4cQKurq5QU1PD4sWLa2VSqGHmzJkwNjZGQUEBrl27Bg0NDY7LR1hYWL0akxMnTsDIyKjOAqpHjx44fPgw13tu3boFZWXlFqv//xf4I/h+E+/evYOenl6d1VhhYSE6d+6MYcOGoaqqCiUlJRAVFeVcHzBgANavX1+nvc+fP6N9+/aIioqCp6cn3N3d6+wc2Gw2UlJS0L59e3Tq1AmnTp1qFXVWfn4+5OTk8O7dO5w9exZz5syBnZ0dBAUFwcfHBxUVFXTq1Ak6OjoQExODpaUlRo8eja1bt+L+/fsNqkePHz/+W/wFgR+m/GvWrKlT/ujRIygqKjZqRFAfJSUl8PT0hI+PD9edcG5uLpSVlZGWlsZTe00ResCPXYmOjg48PDwwefJknu55/vw5mExmg8K6qSxbtoxnP7KvX79i1qxZYDAYCAsL47iPsNls5Ofn4+jRo4iNjYWfnx80NTUhISGBLl26YNSoUUhISMCSJUtgZWXFyW+4bds2jBgxAsbGxpCUlISzszOmTZuG1NTUJltqNsbNmzfRr18/MBgMREZGchzGZ82aBSMjo1ruKYWFhfD09ESXLl1gb28Pb29vroKKzWbD0tIS+/fvr1UeFBSErVu3ch1Hjx49sGLFitZ7sH8xfwTfb+T169fQ0tKq8+H89u0b3N3d4ePjg+/fv4OPjw8sFgssFgsKCgp1LMq+fv2Kzp07Izg4GGZmZhg5cmSdCevcuXPo0qULTExMcOjQoRYLPDabjZcvX2L37t0YM2YMpKWlISgoCB0dHZibm3OEnJ6eHgwMDCAuLg5/f388evSoSf1kZmaiS5cuLRorL5SUlEBGRoarz1xISEi9KjpeqaioQGBgIJydnWtF7vn27RvMzMywfPlyntppqtCr4eDBg9DX169XlcsNGxubFiU6/Str1qzBqFGjGqxTk7BYUVERAwcOrNfA6q8UFRXhwoULWL58OQYPHgwpKSkICQnB2NgYAwYMwJIlS3DmzBkUFhY2mi/x6dOnrbIgzMvLQ3h4OOTk5NC+fXtoampytUxlsViYM2cOVFRU0K1bN1haWnKtd+zYMZiamtba9Y0bNw5xcXF16l65cgXq6uo8n+v+r/NH8P1m8vLyoKGhgYSEhFrlFRUV8B8wBGaBEVDqGYVBmy5j4Jo06HiPQuG3/5zvlZaWwsnJCX5+flBTU8OiRYvqGM64urpCW1sbO3fubHaizMrKSly/fh3Lly9H7969oaSkBGlpaejo6EBLSwsiIiIQFhZG3759sWzZMmRkZNRaub5//x5TpkyBvLw8+vXrx3PG7wcPHvDkutFS9u7dW8dfEvihapaVlW0Vx9/q6mqMHDkSVlZWKCwsBIvFgr+/P4YOHcrTRNtcoQf8WKjY29vD09OzXj/Ev7J27Vr07du3yX3Vx+bNm+vtu+a8uW3btujRo0eLEqTm5uZCXl4eRUVFuHXrFrZs2YKxY8fC3t4e0tLSUFdXR48ePTB9+nQcOHAAjx8/RlZWFlasWIE+ffpATU2N47KzePFiZGZmtigs35QpU8BkMqGkpIRu3bohLS2N6/udlpYGZWVlODs7o127dpws7zWw2Wx07NgRBw8e5JTNmjWLqwVw165d68wpf6ifP4Lvb+Dp06dQV1fnOKrezi/CiB0/4jFqTj5SO5v25CPQm5aKkYlZyHrxAV5eXnB0dKxjHXbnzh34+PhAXV0dGzZsaLLKqrCwECkpKYiJiYG1tTVERUWhqKiINm3aQFJSEkpKSvD19cXcuXNx6tQpfPz4Edra2rWch7nx5csXLF68GCoqKvDy8kJGRkaDk/6bN2+goqLSpLE3h549e3Kcq39mzpw5CA4ObrV+aqJ0GBsbIzIyEl26dOFpUm2J0KshKysLSkpKUFBQaDRwAvDjMyAtLd1qFoFJSUno379/rTI2m42DBw/C0NAQ9vb2LT5vBn4ImvpUqiwWC8+ePUNycjKmTZuG7t27Q01NDTIyMnBwcMD48eOxdetWpKamIjExEWPGjEHHjh0hLi4OGxsbTJo0CYcOHeI5ms68efOgr6+Pt2/fory8HFu2bIGRkRHMzc2RlJRU53v5+vVr2NrawtTUlBN44mcOHz4Mc3NzsNlsfPxWjoHztsEmIgFDt13H+D23sO7CMxw5dQ5aWlqtqqb+t/MnH9/fRE3S095TVtHpDxJUXs2iht4JPj4iPlY1CT88RsVZKXTo0CHq0qUL5eTk0MyZM+n8+fMUHR1NoaGh9ebWqwEAPXnyhC5fvkznzp2jjIwMKigoIBkZGU40/ZqUOzW55VRVVeu0s2zZMrp9+zYlJiY2+rzl5eWUmJhIixcvJkVFRYqOjqbu3bvXyexQWlpK8vLyvzQz+JcvX6ht27b08uXLWilgKioqqF27dnTmzBkyNjZu1T6DgoJo9+7ddOnSpXqzfdeQlZVF3bt3p82bN5O3t3eL+h00aBC9e/eOREVF62Ri4Iavry/16tWLBg8e3KJ+iYgOHDhAu3bt4mQrOHfuHMXExFBFRQUtWLCAPDw8WpS/kYioqqqK2rZtS+fOnSNDQ0Oe7/v48SPdvn2b85OdnU25ublkYGBA5ubmZGRkRIKCglRYWEg3b96kq1evEpPJ5CTrtbW1JUNDw1qf3wULFtD27dvp/PnzpKKiwilns9l04sQJWrp0Kb148YLCw8Np+PDhnNROVVVVFBMTQ0lJSVRRUUHr16+nwMBAIvrxXTV16kFaPUbRk68CxGKxqBr/ec1EBfmpvLKSDKVZtHCQC7VvI9ui1/N/hT+C729k0YHLtPbK+yblXKPqShrv0Ib82yvS7Nmz6fDhwzRx4kQaN24cSUpKcr2ltLSUsrKy6MKFC3T69Gm6ffs28fHxET8/P1VWVpKxsTE5ODhQ586dydLSkrS0tHiakD59+kTa2tr07NkzUlBQ4Gn4LBaLDhw4QAsXLqTKykqaPHky9e3bl4SEhIjoxxddRESEvn792qgAby7btm2jw4cP0+HDh+uU79mzh06ePNmq/d27d49cXFxo2LBhtHPnTjp16lS9gjUrK4t69OhBmzZtarHQIyJ69eoVtW/fniQkJGjnzp3k4ODQYP39+/fThg0bKC0trcV9Hzt2jNatW0exsbE0ZcoUevHiBSeRb2ulskpOTqZVq1ZRenp6i9sqLS2l+/fvU3Z2Nkcg3rt3j5SUlKh9+/akqqpKAOj9+/eUnZ1NRUVF1KVLF7K1taW8vDy6cOECZWRk1BJ6f+XGjRu0dOlSOnPmDA0fPpzGjRvHWVQePHiQ+jkPewAAPhBJREFUhg8fTgAoOjqaoqKiaOe1lxSbcp+qqkHUwGvGx0ckKihAU70MaKB1uxa/Fv92/gi+v4n6smxXFxfQp9NrqfLNYyJBIZLQtyW5riOJj/8/iUQFwKKvh2bTyAB3ioyMrJPD682bN5Senk4pKSl05coVev36NYmIiFBlZSVpaGiQnZ0dOTo6kqWlJRkaGjYru3YNgwcPJhMTE5o0aVKT7sP/Z3BfuHAhPX/+nCIjIyk4OJjExcVJUVGRM+H8Cjw8PGjo0KGcVXXNeNq3b09Lly6lbt26tVpfhYWFZGVlRXPmzKEBAwbQzp07KSIiglJSUsjS0rJW3dYWejXMmDGDzp49SywWi65cudLgoqasrIzU1NTo/v37XHf5TWHLli0UExNDgoKCNH36dAoODuYscFqLrl27UnBwMPXr169V262BxWLR06dPObvCmt8AyMjIiGRlZenJkyeUm5tL/Pz8ZGxsXGtXqK6uzrXd3Nxcio+Pp6SkJPL19aXIyEgyNjamZ8+eka+vL71584asB06iPEZHKq9i8zxeMSF+mupl+Ef4NcIfwfc3MTLxBqU9Kqij3izYN5MExGVJ3iOM2OUlVLB3Gkm2dyfpTj7/qQQ2OekwaNtwW6qurqbs7Gw6fPgwnT17lh48eEDl5eUEgBQUFKhjx47UrVs3srW1JTMzMxIRacLukgeuXbtG/fv3p6dPnzZ7FX/t2jVatGgRZWZm0pgxY2j79u10/Phx0tfXb9WxEv1Qcenq6tKbN29IQkKCU37mzBkKDw+ne/futVj9VkNVVRW5u7tTp06daPHixZzylJQUCg4Opr1795KzszMRta568698//6d9PT0SEpKiubPn0/+/v4N1g8ODiYjIyOKiIhoVn+vXr2i2NhYSk5OJllZWXr48CGJi4s3q62GePbsGdnY2NCrV69a/XPdEADo3bt3dPv2bVq1ahVdvHiRmEwmffjwgTQ0NEhKSorKysooPz+fJCUlyd7eniMIzczMSFBQkNPWp0+faP369bR69Wrq0KEDTZo0iTp37kwDxk6hW3IOdbRB73dGU8XbJ5yFsICUPKmNTKhVR0xIgPaOtCYzddlf/lr8t/InA/vfQOH3CkrP+cj1TK/6SwFJGNoRn6AwCUjKkZimBVUV5teuxMdP6U8Lqa2uEYmIiJC1tTWtWrWKAFBYWBidOXOGiouL6f3795Samkrh4eFkaWn5SyYHKysrkpGRodOnTze7jc6dO9PBgwfpwoULlJubS3l5eRQbG0uvX79uxZH+IDk5mby8vGoJPSKiuLg4mjhxYqsJPSKiiIgIEhUVpQULFtQq9/b2pn379lFgYCClpKRwhF5r7/RqkJSUpLlz55KgoCDFxMRQVVVVg/UHDhxISUlJTe6nsLCQIiIiyNzcnBQVFenAgQPEZDJ/idAjItqwYQMNGTLktwo9IiI+Pj5SVVWlR48e0bNnz+jx48eUm5tL7969ow0bNlBQUBBZWlqStrY2ffr0iS5cuEDLly8nDw8PkpKSInt7e5oxYwadPHmSBAUFaerUqZSbm0u9evWiUaNGkYODA1XqOBGfkDDX/hndQqltRDK1jUiuI/SIiMqrWbT2wrNf/TL8V/Nnx/c3sD79OcWfyaGK6roqjG/ZqVTx+hExPMKIXf6dPuydQbL2A0lc36Z2xepK0ix5SGEu+uTs7Ezy8vK/afR12bhxIx07doyOHDnSKu05OjqSvLw8Xbhwgfz8/CgqKqrVdn8ODg4UGRlJPj7/2UE/fPiQXFxcKC8vr9XOFTdv3kxLliyhq1ev1jKg+ZmsrCzy8PCg6upqSkxMrDWm1obFYpGFhQWx2WwaNWoUjRo1qt66bDabNDQ06MSJE2RiYtJo29+/f6f4+HhasWIF9enTh6ZPn04qKip079496t+/P927d681H4WIfhgitWnThi5fvkw6Ojqt3n5jxMXF0dq1a+nChQv1qjOJfuz6Hz16xDkzzMrKouzsbOLj4yNhYWH69u0bKSsrk62tLbm7u5OtrS1du/OQpmUREb9gnfbe74wmCRNnkmrv3uD4RAT56fJkF5KX/L2Lgv8W6r6yf/jlPH7/lavQIyISbWNK32+foldxfYjAJgkTVxLT61K3oqAwCTDa0JMnTygnJ4f4+fk5BitN+d2ce/76W15ens6dO0c7duwgZWXlFrcpKipKNjY2FBkZSbt27aIuXbpQp06dKDQ0lNq3b9/stt++fUv3798ne3t7Ki8v51yLi4uj0NDQVts5ZGZmUkxMDF28eLFeoUdEnN2lkJDQL9nd/oyAgAAtW7aMBg0aRLNnz6agoKB6jaH4+fmpf//+tHPnzjq71Z+pqKighIQEmj9/Prm6utK1a9dIW1ubc11ERIRjJdzaHDx4kNq3b/+3CL34+Hhas2ZNo0KP6Md7a2ZmRmZmZjRo0CAi+qEqzc/Pp+zsbLp58yZlZGTQqVOnKDk5mfj5+UnS0o+kbPrW22bxhe1UfGE7CTHUSNYhiEQ1zOrU4SOi5FuvKcRBu24Df/iz4/s7GLY9i849/lCnHGDTm3XBJGXuQdJWvYhdVUafjq8gIXk1knMeVqe+Kn0iZ/4nxGazCUCzf7fk3prfDx48IEFBQdLS0mpxm69fvyZRUVGSkZHhlBcVFVFxcTEJCgqSrKwsCQsLN7ntyspKYrPZJCgoWOtadXU18fHxUc1XoSULBgD06dMnkpOTIzExsXrrVVRU0Js3b0hFRYXExMQoLy+P5OXlSUlJqVUWI/Vdu3LlCpWVlZG6ujqZmJjUW6+4uJjS0tKob9++JCAgUKtNIqKcnBy6du0aKSgokK2tLddxf/36lRITE2n8+PGtvuBavHgxubm5kaWlZau8XryOb+/evbRv3z5KSEggVVXVVl1cFhcX04MHDyj+6mfK51fmOndUvH1CQvJtiE9AiEoeZdDntPWkMnQlCcnVtST1M1ej+EDzFsxU/17+7Pj+BqRFub/s7LJvxPr6kaQ69iA+QSESEBQiSbOuVJyRyFXwlXz+SFPiptQ5r/o7ePjwIbm6utLx48dJWJj72QSvTJ48mRgMBk2ePLlWeWVlJe3evZsWLVpE4uLiFB0dTX5+fjxbpVpaWtKCBQuoa9eunLLZs2fT69evacOGDURELVo4lJSUkK+vL40cOZJCQ0Prvefu3bs0cuRIWrFiBTk5OREAKigooJCQEGrfvj2NGzeOiOiXLGgcHR1pypQplJeXR2PHjiUpKal628jKyiJZWVnS1dUlNptNbDab7ty5QykpKSQmJkaDBw8mLS2tBsdRXV1NAgICBOCHD1p1dYsXXEVFRfT69Wv6/v07nT9/vtUWb429fu/evaN3796RgYEBzZw585ctLkW7hZNQO+6CT0T1Pyp/SVNXKnmYTmXPb5BQp7pnw1/LGz7L/V/mj+D7GzBQliYRwfd11J0C4jIkKKNE37JTSbpzL0JlGX2/d5aEFDXrtIGqCvr47A4ZGhrS9u3bydHRsdV8o5qDkZERGRgY0OHDh6lPnz4taktWVpaKi4vrlAsLC9PgwYMpKCiIUlJSaMGCBTRlyhSKioqioKCgBlWVz549o/z8fHJycuKUlZeX09q1a+ncuXOcMj4+vma5dwCg8ePHk5mZGc2ZM6deI5kbN27Q6NGjacuWLeTr68spNzExoWvXrpGXlxclJCTQunXrWuRm0hDPnz+n9PR0unfvHq1evbreep8/f6acnBwKCQmhCxcuUHR0NJWVldGmTZvIy8urUUOgL1++0Lp162jmzJmtOv7w8HCaMGECzZs3r1XbbYhVq1ZRfHw85eTkkIaGxi/tK3xvNh2+/Za3ynx8RMRdaSct2rquI/8m/lh1/g0EWNR/LsDsNZXKXtyk1yv605uEH/57DNcRdeqJiInRqgkDSFFRkTw8PEhZWZmGDRtGycnJ9OXLl185/HoZNWoUrV27tsXt1Cf4auDn5ydfX1+6cuUKbdy4kQ4cOEDa2tq0bNky+vbtG9d79uzZQ717965lSr5r1y7q2LEjGRkZtXjMixYtomfPntHGjRsbFHrdu3enDRs21BJ6NcjLy9OZM2fo+fPnNGDAAKqsrGzxuLgxc+ZMev36Ne3cuZOePn1ab71+/frR3r17yc3NjYKDg2ncuHGUnZ1N3bt358n69Vec8ZWVlVFSUhKNGFH3O/GrWLNmDcXFxdG5c+d+mdArKyuj06dPU2RkJJ3YvZlQXVGnDrv8O5W9uEmoriSwWfT9wXmqeHWfxDQ71qkrKshPBipSv2Ss/wb+CL6/AQVJEXLUYxK3uUNYSYuUByykNhP2Upvxu4jpF0MCErK16vDxEbnoM8m/hzvduHGD5s6dS8LCwqSqqkqbN28mdXV1cnZ2piVLltCDBw84Z1e/mp49e9KTJ0/o4cOHLWpHVlaWioqKGq3Hx8dHjo6OdOLECUpJSaEbN26QlpYWTZ8+nT5+/Fir7p49e2o5OQPguDC0lGPHjtGqVavo0KFDJCYmxrVOY0KvBikpKTp+/DiVl5dTz549qbS0tMXj+yvy8vI0depUUlJSomnTpnGtk5OTQxEREZwwbo8ePaL+/fs3SasgIiJCVVVVrfr527dvH1lZWVG7du1arc2GWLt2LS1ZsoTOnz/fqn2y2Wy6ffs256xSUfFHJCZpaWlaEd6PRETrfo7AZlFxRhK9WjmAXq3oT99uHiNmr2kkJF93IQ0iCujYsOHN/zJ/BN/fRJiTDokKNk+VxQ8Whf5krTVp0iSaO3cubdq0iWJjY+n9+/cUERFBubm55OXlRZqamjR69Gg6duwYlZSUtNYj1EFYWJiGDx9O69evb1E7je34uNGhQwfavXs3Xb16lQoLC0lfX5/Gjh1LeXl5dO/ePfr69St16fIf69i0tDTi5+cnV1fXFo310aNHnJ12fRZ+N2/e5Eno1SAqKkr79+8neXl58vDw+CU7+LCwMKqoqKCzZ89SVlYWp/z169c0cuRIsrGxIXNzc1qxYgUVFhY269y2xmS/oqLu7qW5JCQkUGhoaKu11xDr1q2jxYsXt5rQe/v2LW3fvp0GDBhAKioq1KdPH8rPz6cxY8bQ69ev6dKlSzRjxgxSk5cmgYLHROy6RyEqQ+Kp7cT91HbCXlIZtIzENDvU6YePj8hZn/nHlaEB/gi+v4n2bWRpqpcBiQk17S0QFeQniZxTNGfCcPr+/TunfMiQIbRx40bq0aMHXb58mXr06EFr166lvLw8On78OGlqatKyZctIWVmZPDw8aNWqVfT8+fPWfiwaOXIkJSUl1RpbU2mO4KtBW1ub1q1bRw8ePCAJCQmysLCg/v37U9euXWvtVlrDYb2oqIh8fX1p0aJFtYTqz9y8eZO8vLx4Fno1CAkJ0fbt28nMzIycnZ3r7GBbioiICC1dupRERUVp0qRJVFhYSJMmTSIzMzNiMBiUk5NDMTEx1K9fPzp37hx9/vy52f20lrrz7t279OrVK/Ly8mqV9hpi/fr1tHDhQjp37hxpatY9Y+eFkpISSk1NpQkTJpCxsTGZmprS8ePHycnJia5du0Y5OTm0evVq8vX1JRkZGfr27RtFRESQq6sr9TaSJlGR5plgiAoK0Gin3+/m8d/EH3eGv5mkq3k0L/UxT9kZaoLQ9u6gQqNGjaIbN27QkSNHan0xL126RP7+/rRy5cpasShr+PLlC505c4aOHz9OJ06cIGlpafLy8iIvLy9ycHBoFV82X19f6tGjR7PPYR49ekR+fn70+PHjFo+lqKiIdHR0iI+Pj7p06ULR0dEkIyNDbm5ulJeX1+znZbFY1L17dzIwMKDly5dzrdNcofczAGjGjBmUnJxMp0+fpjZt2jSrnfratrGxofv37xM/Pz/169ePpk+fTmpqarXqBQYGkouLC4WEhDS5DyUlJbp7926rxF0NCwsjRUXFVjeW+SsbNmygefPm0blz52r5JTYGm82m7OxsOn36NKWlpdH169epU6dO5ObmRm5ubmRhYcHVYAkA7d27lyIjI8nNzY0WLVpEioqK/z83PKKyP7E6Wx/84W/nzqsihCT+yMenPy21Vj4+/Wmp0JuWipDELNx5VcS5h81mY+XKlVBSUsLZs2drt3fnDtTU1LB69eoG+2WxWLh58ybmzJmDLl26QFpaGr6+vkhISOA5azc3Tp48yckh1hzevXsHJSWlZvf/M9euXYOenh5KSkqwbt06aGlpQUlJCQMHDmxR1u2IiAi4urqiqqqK6/UbN25AUVERhw8fbnYfP7N06VJoaGggJyenVdqrqKjAqlWrIC8vDyEhIejo6NSbtPjo0aOws7NrVj9t2rRBXl5eS4YK4Efmejk5Obx69arFbTXEhg0b0KZNGzx79oyn+i9fvsSmTZv+r70zj6sx/f//VSRL+9k67SmpiFG2TLZUKISsNTSZT8jONNSUGFvEt0kjW9OYxhaTXUURMnYhy0iZGGTLmErbOZ1zv35/eHR+jnOqc06F0fV8PM4f576W+7rvU/frvt7X+3q/MX78eLBYLNjZ2WHOnDk4evQo3rx5U2/7u3fvYtCgQejSpYvc3ITbLzyA7eI0WIQelXouvP+xCD0K28Vp2H7hgbKX3CyhwvcJ8epNFTafuY95Sdcx5dfLmJd0HZvP3JfKwP4+J0+eBI/HQ2xsrNSDvKCgANbW1oiIiFD4AV9UVCRJHspiseDg4ICQkBBkZWXV+oCXh1gshpWVFS5cuKBwm3eprKyEpqamSm3fZ968eYiIiJB8f/LkCdq1a4dOnTrBwcEBO3bsUOraACAxMRFWVlZ49eqV3PLGFr0a4uPjYWRkpHA2e3mIRCL89ttvsLCwwNChQ3Ht2jX4+flJJUZ+H4FAADabjYKCAqXP16FDB9y7d0/l8dYQHx+PESNGNLif+s5hamqK/Pz8WuuUlpbi8OHDmD17Njp27Ag2m40JEyYgISFBqZfFsrIyhISEgM1mIyYmps6/QVVejCl1Q4XvM+Cvv/5C586d8c0330hl937x4gUcHR0RFBRU69t8bYhEIpw/fx5hYWHo1q0b9PX1MW7cOPz6668KZaOOiorC5MmTlb6WGjQ1NVFZWalye+DtNRgZGeHPP/+UHFuyZAmmTZsGhmGQmpqKfv36wcLCAnFxcaioqKi3z0uXLoHNZuP27dtyy7Ozs8HlcnHgwIEGjb029uzZAy6Xi3PnzinVjmEYHDp0CJ07d0afPn1w5swZSdmjR4+gra0NIyOjWu/5jBkzsGLFCqXH6+DggJycHKXbvY+TkxNSU1Mb3E9tJCQkwMTERGZGLRKJcPHiRSxfvhx9+/aFlpYWXF1dERkZiezsbIjFYqXOU5OB3szMDL6+vnj69KnCbVV5MabIhwrfZ8KbN28watQoODs749mzZ5LjJSUlGDhwIMaMGSMlispSWFiIhIQE+Pj4QFdXFz169MCSJUtw6dIluf/8RUVF0NPTq3VWVB88Hk/qOlTh1KlT6Nq1q+R7RUUFuFwu7t69K1Xv3LlzGDFiBHg8HlauXIl///1Xbn+FhYUwNjaudSbX1KJXQ1paGthsNtLT0xWqf/r0aTg7O6Nz5844fPiwXAtAeHg4TE1NERUVJbeP8+fPw9bWVmnzcPfu3XHp0iWl2rzP1atXYW5urvTLm6L88ssvMDExkcxMCwoKsGXLFvj4+EBfXx+dO3fG/PnzkZaWhrKyMpXPk5+fj6FDh8LOzg6ZmZmNNXyKClDh+4wQi8X44YcfYGJigsuXL0uOV1ZWwsfHB66urigtLW3weQQCATIzMxEcHAx7e3twOBxMnjwZSUlJeP36taTepEmTsHbtWpXO0bFjRxmBUpZp06Zh9erVku/x8fHw8vKqtf7t27cxefJkGBgY4LvvvkNhYaGkrLKyEj179sTy5cvltv1QolfD2bNnweFwsG/fvlrrXLt2DUOGDIGlpSW2b99ep3C8efMGbDYbenp6Ur9hDQzDoH379rh69apS43RxcUFWVpZSbd4nMDAQK1eubFAftbFt2zbw+XzExcUhKCgI1tbW4HK58PPzQ2JiotTfgKpUVFQgIiICLBYLUVFREAgEjTBySkOgwvcZcuDAAbDZbGzfvl1yTCQSYdq0aXByclLIVKkMBQUFiIuLg5eXF7S1teHi4oJVq1bht99+g5WVldLmIADo1auXymuEACAUCsFms/HgwQMAbx/cdnZ2Mo5A8nj48CHmzJkDfX19BAYG4t69e/D398fYsWPlzng+tOi9e15DQ0Ns27ZN6nheXh7Gjx8PQ0NDbNiwQeEH7c8//wwej4fg4GC55REREZg3b55SYxw0aJDCM1N5lJSUQE9Pr8Gz/3eprq7GuXPn4O3tDQ0NDbRt2xbu7u5Yu3Ytbty4odLfa20cPXoU7du3x5gxYxrkMEZpXKjwfabcunUL7du3R3BwsORNn2EYLF68GB06dJAIQmNTUVGBtLQ0zJo1CxYWFtDQ0MDQoUNx4MABpWabgwcPRlpamsrjSE1NhbOzs+R7WloaunbtqpSp7uXLl4iIiEC7du2gp6cn1+uuRvT279+v8lgbQm5uLszMzBATE4PCwkJMmzYNLBYLK1asUMir8F1EIhHs7OygpaWFv//+W6b83r174PF4SjkDeXl54ciRI0qN4102btyIMWPGqNweePt3n5+fj40bN2LkyJHQ09ODmZkZ2rVrh59//lmhtV1lefDgAby9vdGhQwccP3680funNAwqfJ8xr169wqBBgzB48GAp81VsbCyMjY1x8+bNJj0/wzD44Ycf0LlzZ7i5uUFLSwtubm6Ijo5Gbm5unSI0fvx47Nq1S+VzT5o0CevXr5d8d3d3R2JiotL9HD9+HDweD+Hh4TA2NoaHhwcyMzPBMMxHF70abty4AX19fbRu3RrBwcEqr6sCQEZGBvT09PDVV1/JLe/ZsyeOHTumcH+jR4/G77//rtJYGIZBly5dkJGRoXTb169fIzk5GVOnToWlpSX4fD78/f2xY8cObNiwQcbpqbGoqqrCihUrJC8fDVlXpzQdVPg+c6qrqzFv3jx06NBB6h99165d4HK5cmcxjUnN/qtHjx6htLQUBw4cQGBgIIyNjdG+fXvMnj0baWlpMm/d06ZNw8aNG1U6Z0VFhZR57ObNm+Dz+UqvreTl5YHL5Uo8IAUCARISEtCxY0d06tQJurq6SE5OVmmMjUFZWRlWrlwJNpuNSZMmwd7eHnPnzm2wqW7w4MHQ0tKS+2IUGxtbqyjKw9fXFzt27FBpHBcuXIC1tbVC1yMUCpGVlYXw8HD06tUL2traGDJkCKKjo3H79m3JS9aOHTvA5/Nx584dlcZUF+np6bCxscGIESOazKJCaRyo8DUTtm3bBg6Hg8OHD0uOHTt2DGw2u0GmKEWYOXMmFi9eLHWMYRjk5ORg1apVcHFxgba2Nry8vBAXF4cHDx5g0aJFWLVqlUrnS05Ohqurq+R7QECA0s4RJSUlsLOzw6ZNm2TKLl++DF1dXVhZWaFjx4745ZdfPqjDgkAgwIYNG8Dn8zFu3DiJN+K///6LPn364Ouvv1Z6b+K73L17F+3atYObm5tM2YsXL6Crq6uwGXXKlCn4+eefVRqHv79/rV6mDMMgNzcXsbGxGD58OHR0dODo6IiQkBCcPHlS7kxr586dTSJ6jx8/xtixY2Fpadnk/0uUxoEKXzPiwoULMDIywsqVKyVvwBcvXgSPx1PJDKgot2/fhqGhIYRCYa11Xr9+jaSkJEyePBkcDgdcLhc9evRAZmam0qIyZswYxMfHA3gbBUbZbRUikQjDhg3D9OnTZcquXbsGHo+Hffv2gWEYnDx5Eu7u7jAxMUF0dLTS62rKIBaLsWPHDlhaWmLw4MHIzs6WqVNWVgYPDw+MGjWqQWa2oKAg6Ojo4NSpUzJlnp6eCs/igoKC6o0gJI/Xr19DV1cXL1++lBwrKipCUlISvvnmG5iamsLExARTpkzB7t27perJY9euXeDz+bXuv1QFoVCIqKgosFgsRERENMlaIaVpoMLXzHjy5Al69uyJcePGSfYk/fnnnzA1NcW6deua7Lz9+vXD3r17FaorFouxaNEiODo6okePHtDV1cXo0aORkJBQ74bf0tJS6Ojo4J9//gEALF68GEFBQUqNNTQ0FP369ZMR3HdF732uXr2KsWPHgs1mIyIiAkVFRUqdsy4YhsGRI0fg4OCA3r17yxWjd6mqqoKPjw/c3d1VFuKioiJoa2vDwcFBZi12165dGDJkiEL9zJ8/H//3f/+n9PljYmIwbtw4ZGZmIjQ0FE5OTtDR0cGwYcOwfv163L17V2FHpd27d8PQ0BC3bt1Sehy1cerUKdjb22PIkCF1RnqhfJpQ4WuGVFZWYvLkyfjiiy8kcRQfPXoEW1tbLFy4sEExLGtj9+7dGDhwoML1k5KSMG7cOADA8+fP8euvv2LcuHHQ09NDt27dEBYWhvPnz8vsTdu+fbtkr15FRQU4HI5SIbN2794NCwsLmRlEXaL3Lvfu3UNgYCD09fUxd+5cud6RypCVlYUvv/wSnTp1wsGDBxX+baqrqxEQEIDevXvL3ZenCGvWrIGurq7MC0t5eTn09PTw/PnzevsICQlR2MzMMAxu376N6OhotGvXDm3btkXPnj0RFhaGM2fOqGROTkpKgqGhYaM5cj179gx+fn4wNTWVzPop/z2o8DVTGIbBjz/+CENDQ4nzxqtXr9CrVy8EBAQ0aI1IHgKBADweT2FPumPHjsHDw0PmeHV1NbKyshASEgIHBwewWCyJA0VRURG8vLwkZrgtW7Zg+PDhCo8xOzsbbDZbJhbmtWvXwOVy6xW9dyksLERwcDD09fXh7++v9LrSjRs34OnpCXNzcyQmJqoUtUQsFmP+/Pno0qWLSvvgqqqqYGhoCGNjYxkz9eTJkxETE1NvH0uXLpWKlfo+L168wM6dO/H111/DyMgI5ubmGDZsGIyNjRvknQoAe/fuhaGhYaOETKuurkZMTAzYbDYWLVrUoAgulI8PFb5mTnp6OrhcrsSD8s2bNxg8eDBGjBjR6GsW33//PebMmaNQ3YsXL6Jnz5711nv06BG2bNkCb29vaGlpoUWLFggPD8eVK1dga2tbr1mwhufPn8PMzEzG9b5mpqeq9+br16+xYsUKcLlceHt717spPz8/HxMnTpQEHm+oOzzDMFi2bBmsra1VypLw+++/Q0tLC7GxsVLH09PT0b1793rbR0ZGYuHChZLvlZWVyMjIwMKFC/HFF19AV1cX3t7eiIuLQ15eHhiGga+vr0KiWt+4eTxegwJ613Du3Dl07doVrq6uTbIFgvLhocJHQX5+Puzt7TFt2jQIBAIIBAJMnDgRffv2rTVupSo8fPgQBgYGCr0t5+bmwsbGRqn+4+Li0K9fP8ybNw9GRkZo2bIlAgICkJycjOLi4lrbCQQCfPnllzKepw0VvXcpLy/Hhg0bYG5ujv79+yMtLU3KTFZYWIjp06eDxWJh+fLlje4ks379epiamir94GYYBl27doWOjo5UAAKRSAQ+n19vWLno6Gj4+vpi3bp18PDwgJaWFpydnbFkyRL88ccfMjPJoqIi6OrqqmyeBd569TaG6L18+RIBAQEwMjLC7t27qVnzM4IKHwXAW6cQb29vuLi44Pnz5xCLxZg9eza6dOmiVAT5+hg+fLjE47Iunj9/Di6Xq1TfAwcOlJgjBw0ahHXr1iE2NlayL23AgAGIioqS2tfFMAwCAwPh7e0ttV+sMUXvXYRCIXbs2IHOnTuja9euiI+Px8KFC2FgYIBvv/22UZ1i3icxMRGGhoZyvUHr4tKlS2jdujVCQ0Olji9YsADh4eEy9Z8+fYrffvsNX331FXR0dKCjo4Pp06dj//799b5IrV27Fv7+/kqN71327dsHHo+H69evq9yHSCTCpk2bwOFwMH/+fJSUlKjcF+XThAofRYJYLMbixYthZmaG7OxsMAyDFStWoH379o3muZaamgpHR8d6354rKyvRqlUrhd+ynz59Cj09PVRWVuLGjRswMjKScoYoKyvDkSNHEBQUBDMzM5ibmyMoKAjTp0+HnZ2d1Gzm+vXrTSJ671JWVgZ/f3+0bNkS2traWLlyZYPTMCnC/v37weFwpNISKYK3tzfatGkjtVZ47do1WFhYoKysDMeOHcOCBQvg4OAAPT09jB49Gps3b8bq1asVFjKxWIwOHTrg/PnzSo2thv3794PL5eLatWsqtQfe7tHs3r07XFxcGmVtkPJpQoWPIsPvv/8ONpuN3bt3A3jrJMLn8xv0QKlBLBbD0tJSoVQ1rVu3Rnl5uUL9xsTESPL/+fv7IzIysta6Nd6DU6dOlQQpHjx4MGJjY3H48OEmFT2hUIiNGzfCyMgIY8eORW5uLs6ePQsvLy8YGhpi9erVdZplG4OMjAyw2WykpKQo3Obvv/+GpqYmJk2aBLFYjGvXriEyMhLt2rVDmzZt4OLigmXLluHChQtSjlG7du3ChAkTFDrHiRMn5G6fUIQDBw6Ay+UqPZut4Z9//sG0adNgaGiIxMREatb8zKHCR5FLTk4OLCwsEBISApFIhOTkZHA4HIWdRepizZo1Cs0CDA0NFU4L07t3b6SlpeHp06fQ19eX7OOrjYKCAvB4PJw4cQLFxcVITk7GiBEjoK6uDj6fj3nz5iEjI6PRYi2KxWLs2rULVlZW8PDwkJveJycnB35+fjAwMEBISEijZiR4nwsXLoDL5SIpKUmh+o8fP4aHhwfU1dVhYGAAGxsbzJo1C5MmTcKUKVNqbbdv3z6MHDlSoXOMHTsWcXFxCtV9l4MHD4LL5SqdMgl4+7skJCSAx+Nh5syZjbqmTfl0ocJHqZWioiIMGDAAnp6eKC4uRmZmZr054BTh5cuX0NXVrVecbG1tFdoGUFBQADabDaFQiLCwMMycObPO+m/evIGDg4NUEOsa8+bevXuRnZ2N5cuXw9nZGTo6OvD29saWLVtUSivDMAxSUlLQtWtX9OzZU6G0SAUFBZg5cyb09PQwffp03L9/X+nzKkJOTg6MjIywZcsWmbKysjKkpKRg7ty5sLOzg4GBAUaPHg1NTU306dNHUu/hw4dgsVi17rFLSUlRaLN7TYQdZWe7hw8fBpfLxZUrV5RqB7z9zZ2dndGrVy+VZ4qU/yZU+Ch1IhQKMWvWLHTs2BG5ubnIzs4Gn8/H1q1bG9Svn59fvRE9nJ2dce7cuXr7ioyMxPTp01FeXg42m428vLxa64rFYowaNQpTpkyRmLPqWtMrKirCjh074OvrCxaLhS5duiAkJARZWVn17nU8e/YsXFxcYGdnhwMHDihtPnvx4gXCwsLAYrEwYcKEBjls1EZ+fj4sLCwQGRmJK1euYOXKlRgwYIDEGWjlypW4cuWKZB/hhg0b0KpVK6ltGf369as1K/3JkycVClywatUq/O9//1Nq7EeOHAGHw5FKuqwIxcXFmD17NrhcLuLj4xs1/x7lvwEVPopCxMfHg8PhIDU1FXl5ebC0tJSK+aks586dqzfy/tChQxVah+rSpQtOnz6NTZs2wdvbu866S5cuRZ8+fSQmTGUcWUQiEc6fP4+wsDB069YN+vr6GDduHBITE6WS++bk5GDYsGEwMzPDtm3bVNp8/i4lJSVYu3YtjIyMMGTIEJw+fbpR1qAePnyI+Ph4DBs2DC1atACbzcacOXOQkpJS63YKkUgEY2Nj2NvbS8awdevWWnPm/fHHH1J5EeUhFothYWGh1Kzt6NGj4HK5Cq0V18AwDLZv3w4+n4/AwMAGb5Cn/HehwkdRmHPnzsHIyAhr1qzBkydP4ODgoHIanJpca3Vl5544cSJ27txZZz937tyBkZERqqurYWNjU6e34r59+2BqaipZO7tx4wZ4PJ7K+eIKCwuRkJAAHx8f6OrqwsHBAQ4ODjAwMMCPP/7Y6LnYqqqqEB8fjw4dOsDZ2RmHDh1S6t6XlJTg0KFDmDVrFmxsbMBmszFx4kRs27YNN27cgJOTE4KCgurt89ixY9DQ0JDkIXz9+jV0dHTkro9dvXoVjo6OdfaXlpYGJycnha8jJSUFHA5HKdG7ffs2+vfvj27duuHixYsKt6N8nlDhoyjFo0eP4OTkhIkTJ6KwsBAuLi7w9fVVKY7ipk2bMGrUqFrLg4KC6nV2WLx4MebPn48jR47Aycmp1pnQzZs3wWazJbOKhoreuzx79gzTpk2Djo4O+vTpg44dO4LD4WDy5MlISkpq0GZseYhEIuzduxeOjo6wt7dHYmKi3MwX1dXVuHDhApYtWwYXFxdoaWlh0KBBWL16Na5duyYjcCUlJejXrx98fX3rzKQBAN27d4ehoaFkNjt69Gi56Ydu3boFe3v7Ovvy9vZW2HSempoKDoejsHiVlpbi22+/BZvNxoYNGxo8+6Z8HlDhoyhNRUUF/Pz84OjoiLy8PAwfPhxDhgxROn5haWkp9PX18fjxY7nloaGhdQY4ZhgGHTp0wOXLlzFw4MBaZ4dFRUWwtLSUlDeW6P37778IDQ2FgYEB5s+fLxXYuqCgAHFxcfDy8oK2tjZcXFwQGRmJnJycRnOVZxgG6enpcHV1hZmZGdavX49bt25h8+bNGD16NPT19eHg4IAFCxbg2LFjCm0NqaiogJeXF4YPH15nyLo7d+6gZcuWklBm+/fvx4ABA2Tq5efnw8rKqtZ+Hj9+DH19fYUi1aSlpYHD4dQb9g14e2/27NkDExMT+Pv7S5miKRQqfBSVYBgGa9euBZ/Px6lTp/D111+jV69eSq+bzJgxo9YgxmvWrMF3331Xa9urV6/CysoK2dnZMDExkTtLEQqFGDBggCReZGOIXnl5OdasWQM2m40pU6bUm4GhoqICaWlpmDVrFiwtLWFsbIzAwEAcPHiwwaHJ/v33X+zfvx8+Pj5o164d1NTU0KVLF2zcuFHliDtCoRATJkzAgAEDpDb2v8/o0aOhpaWFiooKVFVVwcDAQOZePHr0CMbGxrX2sXTpUoXSRh07dgwcDkehze25ublwc3ODg4MDsrKy6q1PaX5Q4aM0iLS0NHC5XGzZsgXfffcd7OzslHL7v3XrFvh8vlzR2rJlCwIDA2ttGxwcjLCwMEyaNAlr1qyRW2fmzJnw9PSESCSSiJ6ieQHfRygUYvPmzTAyMoKPj49KAYtrModHR0fDzc0NWlpacHNzQ3R0NHJzc+udDQqFQvzxxx9YsmQJnJ2doaWlBQ8PD6xbtw45OTn4888/MWXKFOjr62P+/Pm1zqbrQyQSYdq0aejRo0etLzMvX75Eq1at8O233wIApk6ditWrV8vUYbFYcttXV1fDxMSk3piax48fB4fDqdfDt7y8HKGhoWCxWIiOjq7XXEtpvlDhozSYe/fuwdbWFjNmzEBkZCTMzMzqDV78Ln379pU7A9uzZw/Gjh0rt41YLIapqSlOnDgBfX19uetoW7duRceOHVFcXNwg0ROLxdi9ezesra3h5uamtPt8XZSWluLAgQMIDAyEsbExrKysMHv2bKSlpaGiogIMwyAvLw9xcXHw9vaGrq4uvvjiCyxcuBAZGRm1hjl7/PgxFixYAH19fQQEBCj1e9TAMAwWLVoEe3t7PHnyRG6d4OBgtGrVCv/88w+ysrLQqVMnKfEuLS2FlpaW3LaHDh1C79696xxDeno6OBwO/vjjjzrHeeDAAZibm0vWnimUuqDCR2kUiouL4eXlhf79+2P9+vXg8XgKe93t2rULrq6uMsePHz8ONzc3uW3Onj2LTp06ITQ0FLNnz5ZbXpOEVlXRYxgGaWlp+OKLL9C9e3dkZGQo1V5ZGIZBTk4OwsPDYWtrCw0NDbRp0wa6uroYM2YMdu7cqfRa1atXr/DDDz+Aw+Fg1KhRSnlC1hAZGQlLS0v89ddfMmWVlZXQ1tbG2LFjIRaLYW5uLjWDEwgEaNmypdx+PT098euvv9Z63oyMDHA4HJw9e7bWOvfv34enpydsbW0VCg5AoQBU+CiNiEgkwvfffw8LCwtJ0s7jx4/X266qqgpcLldmVnLp0qVac77NnDkTERERYLPZMpFN/v77b/D5fKSlpakseufOnUO/fv1ga2vb5Jm2BQIBzpw5g7CwMPTs2RPa2toYOnQoVq5ciXXr1mHSpEngcDiwt7dHcHAwMjMzlTbjlZWVSVITubq6Ij09Xalr2rRpE4yNjXHr1i2Zsi1btqBFixb466+/8P333yM4OFhSxjAM1NTUZLwpayK+1OZAc+LECXA4nFrX6CorK7F06VKwWCysXr1aJa9iSvOFCh+l0UlKSgKbzcayZcvA4XAkwa7rIjQ0FHPnzpU6lpeXB2tra5m61dXV4HK5WLp0qcx2iPLycnTr1g1r165FTk4ODA0NsWfPHoXHfuvWLYwYMQKmpqb45ZdfGj0TPfBWDO7evYv169dj2LBh0NHRgZOTE0JDQ5GZmSl3/59YLMalS5ewZMkS9OjRA7q6uvDx8UFCQoJSTixCoRCJiYmwt7eHo6Mj9u7dq7CL/65du+TO5BmGgYmJCZydnSX7Kt/tU16w8bCwMJnfu4aTJ0+CzWbXuiczJSUF7du3x+jRo+t1LKJQ5EGFj9IkXL9+Hebm5ggMDISRkRF++umnOus/ePAABgYGUg/Ily9fgs1my9Styf5tbW0tZQZjGAbjx4/HV199hRs3biglegUFBZg0aRK4XC6io6MbPUVQUVERdu/ejSlTpsDExASmpqb45ptvkJSUpFIOvufPn+PXX3/FuHHjoKenh27duiE8PBznz59XSMjEYrFkjc3a2hpbt25VaMN9TZiw982KJ0+ehLq6Os6fPw9HR0ecOHFCUqanpycVl1UoFILP58t1DqqJB3v69GmZsocPH2LkyJGwtrZGWlpavWOlUGqDCh+lyXjx4gX69u2LQYMGoX379oiIiKjTvObl5YWEhATJ95r1offbBAQEICAgAD169JAqW7VqFbp3745Lly4pLHrPnz/HrFmzYGBggCVLljRa0tGqqipkZmYiJCQEjo6O0NHRwfDhwxEbG6uQ96YyVFdXIysrCyEhIXBwcACLxYKvry927txZ7/YShmFw5swZDB06FHw+H1FRUfXeg9OnT4PD4cjE53RycoK1tTWio6Px9ddfS47zeDypWWlycjL69u0r0++pU6fAZrNlMoAIBAKsWrUKLBYLy5Yt+yB5CymfN1T4KE2KQCBAUFAQbGxsYG9vj+nTp9c6I0lJSZEJXdW2bVupjfFVVVXQ19dH7969pUyohw8fhpGREdLT08Hj8eoVveLiYoSFhcHAwADz5s2T2nyuCjU5/qKjozF06FBoa2ujV69eCA8PR1ZW1gd1rX/06BG2bNkCb29v6OjowNnZGcuXL0d2dnad4ciuX7+OiRMngsViISwsrE5HmitXroDH42H79u2SY/n5+VBXV8fmzZuhp6cnmb2bm5ujoKBAUs/d3V0m2ECNmGZmZkodz8jIQMeOHTFs2DC5zjUUiipQ4aN8EDZv3gwOh4OuXbtizJgxcs1qIpEIFhYWUtsFjIyMpFzpDx48iG7dusHU1FQiJnfu3AGHw8H27dthaGhYZ465iooKrF27FhwOBwEBAXj48KHK1/T8+XPs2LED/v7+MDIygoWFBaZOnYrk5ORGD1OmKlVVVUhPT8e8efNgY2MDQ0NDTJkyBcnJybWmALp//z6mT58OfX19zJw5U0q03uXOnTswMTHBhg0bJMdGjhwJFosFNzc3/Lx9Dzadvg9L3x8wbkMm5iZdw/Lki+CYtpf6/c+cOSNjPn3y5AnGjRsHCwsLHDp0qJHuBoXyFip8lA9GVlYWDA0N4eDggIEDB8qNChIZGYmAgADJd3t7e9y+fVvyfcKECejZsyfWrl0L4G2AZGtrayxbtqxO0auursbWrVthbGyMUaNGKZTn730qKiqQnp6O7777Dl27doWenh5GjhyJjRs3Ij8//z+RtTs/Px+xsbEYPHiwJPVQVFQU7ty5IzP+Z8+eISQkBAYGBvDz88PNmzdl+isoKICVlRVWrFgBhmFQXFyMNia26DorDhYLD8ImPBXmIUcln/aLDsFy0SFM3X4FNx79i6ysLLDZbMmaoFAoxLp168BisRAeHq5QmDUKRVnUAIBQKB+IR48ekZEjR5KysjKipaVFjh07RrhcrqT85cuXxMbGhhQUFBADAwPy5ZdfkqioKPLll1+S8vJywufzSYsWLciDBw+IlpYW8fT0JDwej5w4cYLExMSQ8ePHS52PYRiSnJxMFi9eTIyNjUlkZCTp1auXQmMFQG7evEkyMjJIeno6uXDhAunSpQvx8PAg7u7upGfPnqRly5aNen8+JOXl5eTUqVMkNTWVpKSkEDU1NeLp6Uk8PT2Jq6sradu2LSGEkJKSErJ582YSExNDnJycSEhICHFxcZH08+zZM+Lh4UGGDBlCuoyeSZYeuklEUCNq6uq1nltNjRANdULeZCWS7RFTiZubG8nKyiIzZswgxsbG5KeffiI2NjZNfg8ozRMqfJQPTkVFBfnmm29IVlYW0dTUJJmZmcTCwkJS7ufnR+wdexFWdy+yafchYtq+I7E2NyKCFwXk2KYfiPdgVxITE0MWLFhALly4QB48eEDWr18vJXoASHp6Ovn++++JmpoaiYyMJG5ubkRNTa3OsT179kwidCdOnCDa2trE3d2deHh4kIEDBxJdXd2mui0fFQDkzz//JKmpqSQ1NZVcvXqVuLi4SITQysqKVFVVkcTERBIVFUX4fD4JCQkhXl5eRE1Njbx+/Zr0/184KbcZTBg1xV8GWqkTMre/Gbm4PYqcPn2a/Pjjj8THx6fe34lCaQhU+CgfBQAkKiqKREZGEg0NDZKZmUkcHBxIzuNismzfJZL9tJJoamoSgYiRtFFjqgnDgPS1MiD25AnZvCqUCAQCEhsbKyV6Fy9eJKGhoeTp06dk5cqVdT5IKyoqSFZWFklPTycZGRmksLCQuLq6SmZ1lpaWTX4vPkVKSkrIiRMnSEpKCklLSyM6OjrEy8uLeHp6EmdnZ3L06FESGRlJxGIxCQkJIXZfDiG+CZdJ1Tu/FyGEiCvfkH9S15Oqh9eJehsdot/fn7TrNECqDqoFxF39NomJWEC0tLQ+4FVSmitU+CgflZSUFOLr60sAkG83HSRJ94SkSiQmdf1VqhFCmGoBEVzcTdbPHiMRvTt37pCwsDCSnZ1Nli5dSvz9/WVMkQzDkBs3bkhmdZcvXybdunWTCF337t1JixYtmvCK/3vU3LOa2eCdO3fIwIEDydChQ0nbtm1JQkICeWjqTohJV/L21/n/FB2KIgQgLM85RPiigLxM/oEYfrWWtOKYS+qoEUIGd+KRzV91/7AXRmm2UOGjfHRyc3OJe9Ayou7kQ9Q0WivcTkMNZMmIzsTFkJClS5eStLQ0smjRIjJjxgzSuvX/7+fJkycSoTt58iQxMDCQCN2AAQOItrZ2U1zWZ8urV6/I8ePHSWpqKjl+/DjhW9qQskEhBGrSLwyMsIo8jplAjP4XRzQMjN+2PfJ/pIU2i+gP+FqqrmZLdXJ+kSthaWl+qMugNGP+uyvzlM8GQTtD0s5lkoyZrDT7CCm/dZIIix6Sdnb9CXvYfKnyaqiRJQdvktIDy0jQeE+Sl5dHdHV1SVlZGUlJSZGYL1++fEnc3NyIu7s7WbNmDTEzM/uQl/fZwWaziZ+fH/Hz8yNisZiE7zxN9t4tJ+L36oleFxI1dXWJ6BFCiAbXkgge3ZLpU40QknztCZnWz6ppB0+hECp8lE+AuNP3iUDMyBxvqcUiun3Gk8oH1wiqhXLbioka8fouhgzvqkk2bNhAMjIySHZ2NunRowdxd3cn27dvJ926dSPqdXgYUuoHABGLxUQoFEo+AoGACIVC8ryqBRETWfMwU11J1DTbSh1T12xLGGGlTN0qEUNyn71psvFTKO9ChY/yUXlVJiBn8orkrum17diHEEKI4Pl9Iq5+Jb8DNXVy6l4RubJxNfHo34csWrSI9OvXj7Rr164JR914ACDV1dVSglLXp0ZsGvJRtQ91dXXSqlUrmQ/pN50QfieZa1PXaEMgkBY5CCqIeqs2cu9FaVV1k9xjCuV9qPBRPirJ2U8a3EdrTU0yJ2aXlJmMYZgGC8SHEJvq6mqioaEhV1Dq+2hqatZa1rZtW6Knp9fgfmo+GhoatTr9zNtznRy88VTmeEsDYwJGTKpfF0rMncKXD4jGO44t76LTWqPBfwsUiiJQ4aN8VHKfl0ptWVAFgRhkeewvJMR7o0RQRCKR0g93RT46OjqN0k/NeDQ0NP7ze9ZsDXWIZsvnMr+jeqvWpG1HZ1J8didhDZ1DhC8LSMX9S8Twq7UyfbRuqU5s+dTJiPJhoMJH+aiUVokapZ8BHkPJT/HBEmFp2bLlf15Q/iuMcTIhP57Ik1tm4DGD/JO6njz5yY+ot9EhLI8ZUlsZagAhZIyjSROPlEJ5CxU+ykdFp3Xj/AlydLWIvr5+o/RFUQ62libpb8MhGXdfyKzVtmijTbg+4XW2V1MjZGBHDt3KQPlgUFc3ykflrZlM/p8hGDGBSEgIIyYEDIFISMC87zRPzWSfAjMHWJPWLVXb+N+6ZQsyY4B1I4+IQqkdKnyUj8oYp9rNWyXnksijdaNJ6cVkUn7nFHm0bjQpOZckU4+ayT4+XU31SJinLWmjodwjpY2GOgnztCVdTPSaZmAUihxo5BbKR2fq9qtyzWSKoKZGyGB7Gu7qU2HHxYdkZWpu/WHn1N7O9MI8bclXvS0+2PgoFEKo8FE+AXIeF5MJ8RdJZbWsGbM+2mi0IHum9qYzhk+Im0+KycbT98mpe0VEjRCpiDytW6oTkLdrejMGWNPfjfJRoMJH+SR4O1O4SyqrFd/a8NZMZkdnDJ8o/5QJSPK1JyT32RtSWlVNdFprEFu+NhnjaEIdWSgfFSp8lE8GaiajUCgfAip8lE8KaiajUChNDRU+yicJNZNRKJSmggofhUKhUJoVdB8fhUKhUJoVVPgoFAqF0qygwkehUCiUZgUVPgqFQqE0K6jwUSgUCqVZQYWPQqFQKM0KKnwUCoVCaVZQ4aNQKBRKs4IKH4VCoVCaFVT4KBQKhdKsoMJHoVAolGYFFT4KhUKhNCuo8FEoFAqlWUGFj0KhUCjNCip8FAqFQmlWUOGjUCgUSrOCCh+FQqFQmhVU+CgUCoXSrKDCR6FQKJRmBRU+CoVCoTQrqPBRKBQKpVnx/wB9GasjM5+9qAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nx.draw(new_G,with_labels=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "86986435", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(G.edges())" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "6d179a5d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(new_G.edges())" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "ae57d41d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{0: array([-7.20718069e-17, 2.20929258e-16]),\n", + " 1: array([-1. , 0.76536686]),\n", + " 2: array([-0.41421356, -0.76536686]),\n", + " 3: array([ 0.41421356, -0.76536686]),\n", + " 4: array([1. , 0.76536686])}" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nx.spectral_layout(G)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c21c34b0", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:root] *", + "language": "python", + "name": "conda-root-py" + }, + "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.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 6c125687792e228591520a565b979197f397baab Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 15:31:12 -0400 Subject: [PATCH 15/22] Updated global rewiring class to have full and step rewires. Also updated dictionary names for verbose and corrected probability issue. --- netrw/rewire/global_rewiring.py | 26 ++++++++++++++++---------- 1 file changed, 16 insertions(+), 10 deletions(-) diff --git a/netrw/rewire/global_rewiring.py b/netrw/rewire/global_rewiring.py index 8c5fe97..e32fd2b 100644 --- a/netrw/rewire/global_rewiring.py +++ b/netrw/rewire/global_rewiring.py @@ -9,15 +9,22 @@ class GlobalRewiring(BaseRewirer): Rewire a network where a random edge is chosen and rewired with probability p. """ - def global_edge_rewiring( + def full_rewire( self, G, p, timesteps=-1, tries=100, copy_graph=True, verbose=False + ): + """ + Run a single step of the `global_edge_rewiring` function. + """ + return step_rewire(G, p, timesteps, tries, copy_graph, verbose) + + + def step_rewire( + self, G, p, timesteps=1, tries=100, copy_graph=True, verbose=False ): """ Generate a Watts-Strogatz network with n nodes where each node is connected to its k-nearest neighbors and each edge is rewired with probability p. - This is done with networkx standard implementation. - Parameters: G (networkx) p (float) - probability of edge rewiring @@ -25,7 +32,6 @@ def global_edge_rewiring( tries (int) - number of attempts to find a new edge. copy_network (bool) - indicator of whether to rewire network copy verbose (bool) - indicator to return edges changed at each timestep - Returns: G (networkx) prev_edges (dict) - edges deleted at each timestep @@ -44,17 +50,17 @@ def global_edge_rewiring( # If verbose save edge changes if verbose: - prev_edges = {} - new_edges = {} + removed_edges = {} + added_edges = {} # Give every edge opportunity to change if timesteps == -1: - timesteps = len(list(G.edges())) + timesteps = len(list(G.edges()))*10 # Rewire at each timestep for t in range(timesteps): # Decide whether to rewire - if p < random.random(): + if p > random.random(): # Attempt to rewire valid = False for _ in range(tries): @@ -90,8 +96,8 @@ def global_edge_rewiring( else: # Update dictionaries if verbose if verbose: - prev_edges[t] = [edge] - new_edges[t] = [new_edge] + removed_edges[t] = [edge] + added_edges[t] = [new_edge] # Update network G.remove_edge(edge[0], edge[1]) From 7f22f8690d3d11f70af84e8b2b2a5df939014dbe Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 15:31:42 -0400 Subject: [PATCH 16/22] deleted notebook --- netrw/rewire/Untitled.ipynb | 185 ------------------------------------ 1 file changed, 185 deletions(-) delete mode 100644 netrw/rewire/Untitled.ipynb diff --git a/netrw/rewire/Untitled.ipynb b/netrw/rewire/Untitled.ipynb deleted file mode 100644 index c701925..0000000 --- a/netrw/rewire/Untitled.ipynb +++ /dev/null @@ -1,185 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "ae7c3349", - "metadata": {}, - "outputs": [], - "source": [ - "from global_rewiring import GlobalRewiring\n", - "import networkx as nx\n", - "import random" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "167a0bf4", - "metadata": {}, - "outputs": [], - "source": [ - "G = nx.DiGraph()\n", - "G.add_edges_from([[0,1],[1,2],[2,3],[3,4],[4,0],[2,0],[3,0]])" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "d7e5d455", - "metadata": {}, - "outputs": [], - "source": [ - "obj = GlobalRewiring()" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "9871a78e", - "metadata": {}, - "outputs": [], - "source": [ - "new_G = obj.global_edge_rewiring(G,p=.3,timesteps=100)" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "78ef21f4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "networkx.classes.digraph.DiGraph" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "type(new_G)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "11d3093e", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "nx.draw(new_G,with_labels=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "86986435", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "7" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(G.edges())" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "6d179a5d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "7" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(new_G.edges())" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "ae57d41d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{0: array([-7.20718069e-17, 2.20929258e-16]),\n", - " 1: array([-1. , 0.76536686]),\n", - " 2: array([-0.41421356, -0.76536686]),\n", - " 3: array([ 0.41421356, -0.76536686]),\n", - " 4: array([1. , 0.76536686])}" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "nx.spectral_layout(G)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c21c34b0", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [conda env:root] *", - "language": "python", - "name": "conda-root-py" - }, - "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.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 1776e433c8874d473fb55fabbd2ba7b46b17b09a Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 15:32:48 -0400 Subject: [PATCH 17/22] reformatted correclty --- netrw/rewire/global_rewiring.py | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/netrw/rewire/global_rewiring.py b/netrw/rewire/global_rewiring.py index e32fd2b..1ee208e 100644 --- a/netrw/rewire/global_rewiring.py +++ b/netrw/rewire/global_rewiring.py @@ -17,10 +17,7 @@ def full_rewire( """ return step_rewire(G, p, timesteps, tries, copy_graph, verbose) - - def step_rewire( - self, G, p, timesteps=1, tries=100, copy_graph=True, verbose=False - ): + def step_rewire(self, G, p, timesteps=1, tries=100, copy_graph=True, verbose=False): """ Generate a Watts-Strogatz network with n nodes where each node is connected to its k-nearest neighbors and each edge is rewired with probability p. @@ -55,7 +52,7 @@ def step_rewire( # Give every edge opportunity to change if timesteps == -1: - timesteps = len(list(G.edges()))*10 + timesteps = len(list(G.edges())) * 10 # Rewire at each timestep for t in range(timesteps): From 365abf2ea1a8ddb361cf322a2824d428921f7687 Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Tue, 19 Jul 2022 15:47:53 -0400 Subject: [PATCH 18/22] revised comments --- netrw/rewire/global_rewiring.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/netrw/rewire/global_rewiring.py b/netrw/rewire/global_rewiring.py index 1ee208e..bbec43f 100644 --- a/netrw/rewire/global_rewiring.py +++ b/netrw/rewire/global_rewiring.py @@ -13,7 +13,7 @@ def full_rewire( self, G, p, timesteps=-1, tries=100, copy_graph=True, verbose=False ): """ - Run a single step of the `global_edge_rewiring` function. + Run a full rewire of the global edge rewiring. """ return step_rewire(G, p, timesteps, tries, copy_graph, verbose) From bfa90fa16b3b0647c56db3ca0e5799bab463fead Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Wed, 20 Jul 2022 11:23:58 -0400 Subject: [PATCH 19/22] updates --- .github/workflows/python-ci.yml | 4 +- .gitignore | 2 + netrw/rewire/__init__.py | 3 +- netrw/rewire/base.py | 37 +++--- .../visualize_example_full_rewire.py | 107 ++++++++++++++++++ tests/temp.txt | 0 tests/test_rewire.py | 17 --- 7 files changed, 134 insertions(+), 36 deletions(-) create mode 100644 netrw/visualization/visualize_example_full_rewire.py create mode 100644 tests/temp.txt delete mode 100644 tests/test_rewire.py diff --git a/.github/workflows/python-ci.yml b/.github/workflows/python-ci.yml index 73cb7af..1ce0f2a 100644 --- a/.github/workflows/python-ci.yml +++ b/.github/workflows/python-ci.yml @@ -2,9 +2,9 @@ name: build on: push: - branches: [ main ] + branches: [ none ] pull_request: - branches: [ main ] + branches: [ none ] jobs: build: diff --git a/.gitignore b/.gitignore index 8ba67bc..2e8ea65 100644 --- a/.gitignore +++ b/.gitignore @@ -129,3 +129,5 @@ dmypy.json .pyre/ **/.DS_Store + +.idea/** diff --git a/netrw/rewire/__init__.py b/netrw/rewire/__init__.py index a2ec0cb..81238b2 100644 --- a/netrw/rewire/__init__.py +++ b/netrw/rewire/__init__.py @@ -1,6 +1,7 @@ from .base import BaseRewirer -from .algebraic_connectivity import AlgebraicConnectivity from .global_rewiring import GlobalRewiring from .local_edge_rewire import LocalEdgeRewiring +# from .algebraic_connectivity import AlgebraicConnectivity + __all__ = [] diff --git a/netrw/rewire/base.py b/netrw/rewire/base.py index 1439fe5..8837467 100644 --- a/netrw/rewire/base.py +++ b/netrw/rewire/base.py @@ -1,16 +1,21 @@ -class BaseRewirer: - """ - Base class for rewiring algorithms. - - All rewiring algorithms should inherit from this class. - - """ - - def __init__(self): - return - - def __call__(self, *args, **kwargs): - return self.rewire(*args, **kwargs) - - def rewire(self, G, **kwargs): - return G +class BaseRewirer: + """ + Base class for rewiring algorithms. + + All rewiring algorithms should inherit from this class. + + """ + + def __init__(self): + return + + def __call__(self, *args, **kwargs): + return self.full_rewire(*args, **kwargs) + + # For all rewiring, whether the algorithm is iterative or not. "full" refers to rewiring until an end condition. + def full_rewire(self, G, **kwargs): + raise NotImplementedError + + # For rewiring algorithms that can implemented iteratively. Iterative algorithms should also implement full_rewire. + def step_rewire(self, G, **kwargs): + raise NotImplementedError diff --git a/netrw/visualization/visualize_example_full_rewire.py b/netrw/visualization/visualize_example_full_rewire.py new file mode 100644 index 0000000..5e58b4e --- /dev/null +++ b/netrw/visualization/visualize_example_full_rewire.py @@ -0,0 +1,107 @@ +import matplotlib.pyplot as plt +plt.rcParams['figure.facecolor'] = 'white' +plt.rcParams['axes.facecolor'] = 'white' +plt.rcParams['savefig.facecolor'] = 'white' +plt.rc('axes', axisbelow=True) + +def visualize_example_full_rewire(RewiringTechnique=LocalEdgeRewiring, + rewiring_technique_label='Local edge rewire', + list_of_graphs=[], + timesteps=100, + save_fig=False, + save_fig_folder='', + save_fig_filename=''): + """ + This is a useful function for visualizing outputs from repeated runs of + `step_rewire`. Users can use this to get a sense of what is happening + structurally to the graph as the algorithm progresses. + + Parameters + ---------- + RewiringTechnique (netrw.rewire method) + Feed in the name of the rewiring technique to look at. + rewiring_technique_label (str) + Label of the technique (for a title in the plot) + list_of_graphs (list of nx.Graph objects) + List of graphs to visualize repeated `step_rewire` iterations. + Recommended number = 2-6 graphs, otherwise the plot might get crazy. + If no list of graphs are input, the function defaults to six relatively + diverse networks to test it on. + timesteps (int) + Number of timesteps to iterate `step_rewire` + save_fig (bool) + If False, the function just shows the matplotlib figure + save_fig_folder (str) + If the user wants to specify the specific output folder. + save_fig_filename (str) + If the user wants to name the saved figure something different than + just the name of the rewiring technique. Additionally, if the filetype + is not specified, it defaults to .png + + Returns + ------- + Either a saved image or a plt.show() instance. + + """ + + if list_of_graphs == []: + list_of_graphs = [nx.karate_club_graph(), + nx.ring_of_cliques(4, 16), + nx.random_geometric_graph(50, 0.2), + nx.erdos_renyi_graph(50, 0.05), + nx.erdos_renyi_graph(50, 0.30), + nx.barabasi_albert_graph(50, 2), + ] + + # example params for node sizes, edge widths, etc. + ns = 100; lw = 2; ew = 2.5; n_ec = '.3' + + # fig width and height + base_width = 5; base_height = 5 + + fig, ax = plt.subplots(len(list_of_graphs),2, + figsize=(base_width*2, + base_height*len(list_of_graphs)), + dpi=100) + + ax[(0,0)].text(1.1, 1.2, "Method: "+rewiring_technique_label, + ha='center', va='center', transform=ax[(0,0)].transAxes, + fontsize='xx-large') + + for ix,G0 in enumerate(list_of_graphs): + + pos = nx.kamada_kawai_layout(G0) + G = G0.copy() + + for _ in range(timesteps): + G = RewiringTechnique().step_rewire(G) + + # draw original network + nx.draw_networkx_nodes(G0, pos, ax=ax[(ix,0)], node_size=ns, + node_color='w', edgecolors=n_ec, linewidths=lw) + nx.draw_networkx_edges(G0, pos, ax=ax[(ix,0)], edge_color='.5', + width=ew, alpha=0.35) + + # draw rewired network + nx.draw_networkx_nodes(G, pos, ax=ax[(ix,1)], node_size=ns, + node_color='w', edgecolors=n_ec, linewidths=lw) + nx.draw_networkx_edges(G, pos, ax=ax[(ix,1)], edge_color='.5', + width=ew, alpha=0.35) + + ax[(ix,0)].set_title('Original network') + ax[(ix,1)].set_title('Rewired network (n=%i timesteps)'%timesteps) + + if save_fig: + if save_fig_filename=='': + save_fig_filename = rewiring_technique_label.lower().replace(' ','_') + + if save_fig_filename[-4:] != '.png' and save_fig_filename[-4:] != '.pdf': + save_fig_filename = save_fig_filename+'.png' + + fn = save_fig_folder + save_fig_filename + print(fn) + plt.savefig(fn, dpi=300, bbox_inches='tight') + plt.close() + + else: + plt.show() diff --git a/tests/temp.txt b/tests/temp.txt new file mode 100644 index 0000000..e69de29 diff --git a/tests/test_rewire.py b/tests/test_rewire.py deleted file mode 100644 index 502d5f3..0000000 --- a/tests/test_rewire.py +++ /dev/null @@ -1,17 +0,0 @@ -import networkx as nx -from netrw import rewire -from netrw.rewire import BaseRewirer - - -def test_same_return_type(): - """The graph and the rewired graph should be of the same type (Graph, DiGraph).""" - G = nx.fast_gnp_random_graph(50, 0.1, directed=True) - H = nx.Graph(G) - - for label, obj in rewire.__dict__.items(): - if isinstance(obj, type) and BaseRewirer in obj.__bases__: - G_rewired = obj().rewire(G, copy_graph=True) - H_rewired = obj().rewire(H, copy_graph=True) - - assert isinstance(G_rewired, type(G)) - assert isinstance(H_rewired, type(H)) From 49a7ab8b7d80d6e1995d84031718a2e67847155b Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Wed, 20 Jul 2022 11:48:37 -0400 Subject: [PATCH 20/22] robust branch --- netrw/rewire/__init__.py | 1 + netrw/rewire/robust_rewiring.py | 84 +++++++++++++++++++++++++++++++++ 2 files changed, 85 insertions(+) create mode 100644 netrw/rewire/robust_rewiring.py diff --git a/netrw/rewire/__init__.py b/netrw/rewire/__init__.py index 81238b2..0056cf9 100644 --- a/netrw/rewire/__init__.py +++ b/netrw/rewire/__init__.py @@ -1,6 +1,7 @@ from .base import BaseRewirer from .global_rewiring import GlobalRewiring from .local_edge_rewire import LocalEdgeRewiring +from .robust_rewiring import RobustRewirer # from .algebraic_connectivity import AlgebraicConnectivity diff --git a/netrw/rewire/robust_rewiring.py b/netrw/rewire/robust_rewiring.py new file mode 100644 index 0000000..39b5bd8 --- /dev/null +++ b/netrw/rewire/robust_rewiring.py @@ -0,0 +1,84 @@ +import networkx as nx +import numpy as np +from operator import itemgetter +import random +import copy +from .base import BaseRewirer +​ + +class RobustRewirer(BaseRewirer): + """ + Increases network robustness by building triangles around high degree nodes following algorithm described in: + Louzada, V. H. P., Daolio, F., Herrmann, H. J., & Tomassini, M. (2013). Smart rewiring for network robustness. Journal of Complex Networks, 1(2), 150–159. https://doi.org/10.1093/comnet/cnt010 + + * full_rewire rewires the graph N times + """ + def step_rewire(self,G,copy_graph=False,timesteps=1,directed=False,verbose=False): + + if copy_graph: + G = copy.deepcopy(G) + if nx.is_directed(G) and directed is True: + warnings.warn( + "This algorithm is designed for undirected graphs. The graph input is directed and will be formatted to an undirected graph.", + SyntaxWarning, + ) + G = nx.to_undirected(G) + if verbose: + removed_edges = {} + added_edges = {} + + for t in range(timesteps): +​ + A = nx.adjacency_matrix(G) + degree_list = G.degree +​ + neighbors = [] + for i in range(len(degree_list)): + sorted_degrees = sorted(list(degree_list(np.nonzero(A[i,:])[1])),key=itemgetter(1)) + if len(sorted_degrees) > 1: + if sorted_degrees[-2][1] > 1 and sorted_degrees[-1][1] > 1: + neighbors.append(i) +​ + index_i = neighbors[random.randint(0,len(neighbors)-1)] + sorted_degrees_i = sorted(list(degree_list(np.nonzero(A[index_i,:])[1])),key=itemgetter(1)) +​ + min_degree = sorted_degrees_i[0][1] + max_degree = sorted_degrees_i[-1][1] +​ + j = [] + k = [] +​ + for item in sorted_degrees_i: + if item[1] == min_degree: + j.append(item[0]) + if item[1] == max_degree: + k.append(item[0]) +​ + index_j = j[random.randint(0,len(j)-1)] + index_k = k[random.randint(0,len(k)-1)] +​ + m = sorted(list(degree_list(np.nonzero(A[index_j,:])[1])),key=itemgetter(1)) + n = sorted(list(degree_list(np.nonzero(A[index_k,:])[1])),key=itemgetter(1)) +​ + index_m = m[random.randint(0,len(m)-1)][0] + index_n = n[random.randint(0,len(n)-1)][0] +​ + if len(np.unique([index_i,index_j,index_k,index_m,index_n])) == 5: + G.remove_edge(index_j,index_m) + G.remove_edge(index_k,index_n) + G.add_edge(index_k,index_j) + G.add_edge(index_m,index_n) +​ + G_out = G +​ + if verbose: + return G, removed_edges, added_edges + else: + return G + + def full_rewire(self,G,copy_graph=False,timesteps=1,directed=False,verbose=False): + if timesteps == -1: + timesteps = int(len(G.nodes())) + G = self.step_rewire(G,copy_graph,timesteps,directed,verbose) + return G +​ From 0abeb0128eb6bffd166f2fcccf3ef4dc13a79d91 Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Wed, 20 Jul 2022 11:57:42 -0400 Subject: [PATCH 21/22] robust rewiring --- netrw/rewire/robust_rewiring.py | 62 ++++++++++++++++----------------- 1 file changed, 31 insertions(+), 31 deletions(-) diff --git a/netrw/rewire/robust_rewiring.py b/netrw/rewire/robust_rewiring.py index 39b5bd8..57e07bf 100644 --- a/netrw/rewire/robust_rewiring.py +++ b/netrw/rewire/robust_rewiring.py @@ -4,8 +4,8 @@ import random import copy from .base import BaseRewirer -​ +# In[14]: class RobustRewirer(BaseRewirer): """ Increases network robustness by building triangles around high degree nodes following algorithm described in: @@ -13,7 +13,10 @@ class RobustRewirer(BaseRewirer): * full_rewire rewires the graph N times """ - def step_rewire(self,G,copy_graph=False,timesteps=1,directed=False,verbose=False): + + def step_rewire( + self, G, copy_graph=False, timesteps=1, directed=False, verbose=False + ): if copy_graph: G = copy.deepcopy(G) @@ -28,57 +31,54 @@ def step_rewire(self,G,copy_graph=False,timesteps=1,directed=False,verbose=False added_edges = {} for t in range(timesteps): -​ A = nx.adjacency_matrix(G) degree_list = G.degree -​ neighbors = [] for i in range(len(degree_list)): - sorted_degrees = sorted(list(degree_list(np.nonzero(A[i,:])[1])),key=itemgetter(1)) + sorted_degrees = sorted( + list(degree_list(np.nonzero(A[i, :])[1])), key=itemgetter(1) + ) if len(sorted_degrees) > 1: if sorted_degrees[-2][1] > 1 and sorted_degrees[-1][1] > 1: neighbors.append(i) -​ - index_i = neighbors[random.randint(0,len(neighbors)-1)] - sorted_degrees_i = sorted(list(degree_list(np.nonzero(A[index_i,:])[1])),key=itemgetter(1)) -​ + index_i = neighbors[random.randint(0, len(neighbors) - 1)] + sorted_degrees_i = sorted( + list(degree_list(np.nonzero(A[index_i, :])[1])), key=itemgetter(1) + ) min_degree = sorted_degrees_i[0][1] max_degree = sorted_degrees_i[-1][1] -​ j = [] k = [] -​ for item in sorted_degrees_i: if item[1] == min_degree: j.append(item[0]) if item[1] == max_degree: k.append(item[0]) -​ - index_j = j[random.randint(0,len(j)-1)] - index_k = k[random.randint(0,len(k)-1)] -​ - m = sorted(list(degree_list(np.nonzero(A[index_j,:])[1])),key=itemgetter(1)) - n = sorted(list(degree_list(np.nonzero(A[index_k,:])[1])),key=itemgetter(1)) -​ - index_m = m[random.randint(0,len(m)-1)][0] - index_n = n[random.randint(0,len(n)-1)][0] -​ - if len(np.unique([index_i,index_j,index_k,index_m,index_n])) == 5: - G.remove_edge(index_j,index_m) - G.remove_edge(index_k,index_n) - G.add_edge(index_k,index_j) - G.add_edge(index_m,index_n) -​ + index_j = j[random.randint(0, len(j) - 1)] + index_k = k[random.randint(0, len(k) - 1)] + m = sorted( + list(degree_list(np.nonzero(A[index_j, :])[1])), key=itemgetter(1) + ) + n = sorted( + list(degree_list(np.nonzero(A[index_k, :])[1])), key=itemgetter(1) + ) + index_m = m[random.randint(0, len(m) - 1)][0] + index_n = n[random.randint(0, len(n) - 1)][0] + if len(np.unique([index_i, index_j, index_k, index_m, index_n])) == 5: + G.remove_edge(index_j, index_m) + G.remove_edge(index_k, index_n) + G.add_edge(index_k, index_j) + G.add_edge(index_m, index_n) G_out = G -​ if verbose: return G, removed_edges, added_edges else: return G - def full_rewire(self,G,copy_graph=False,timesteps=1,directed=False,verbose=False): + def full_rewire( + self, G, copy_graph=False, timesteps=-1, directed=False, verbose=False + ): if timesteps == -1: timesteps = int(len(G.nodes())) - G = self.step_rewire(G,copy_graph,timesteps,directed,verbose) + G = self.step_rewire(G, copy_graph, timesteps, directed, verbose) return G -​ From c39fd0e56c5550af6091805b62073786f781f0ed Mon Sep 17 00:00:00 2001 From: Cory Glover Date: Wed, 20 Jul 2022 13:48:49 -0400 Subject: [PATCH 22/22] robust updat --- netrw/rewire/robust_rewiring.py | 65 +++++++++++++++++---------------- 1 file changed, 33 insertions(+), 32 deletions(-) diff --git a/netrw/rewire/robust_rewiring.py b/netrw/rewire/robust_rewiring.py index 57e07bf..e01b41a 100644 --- a/netrw/rewire/robust_rewiring.py +++ b/netrw/rewire/robust_rewiring.py @@ -1,11 +1,15 @@ + import networkx as nx import numpy as np from operator import itemgetter import random import copy from .base import BaseRewirer - +​ +​ # In[14]: +​ +​ class RobustRewirer(BaseRewirer): """ Increases network robustness by building triangles around high degree nodes following algorithm described in: @@ -13,10 +17,7 @@ class RobustRewirer(BaseRewirer): * full_rewire rewires the graph N times """ - - def step_rewire( - self, G, copy_graph=False, timesteps=1, directed=False, verbose=False - ): + def step_rewire(self,G,copy_graph=False,timesteps=1,directed=False,verbose=False): if copy_graph: G = copy.deepcopy(G) @@ -31,54 +32,54 @@ def step_rewire( added_edges = {} for t in range(timesteps): +​ A = nx.adjacency_matrix(G) degree_list = G.degree +​ neighbors = [] for i in range(len(degree_list)): - sorted_degrees = sorted( - list(degree_list(np.nonzero(A[i, :])[1])), key=itemgetter(1) - ) + sorted_degrees = sorted(list(degree_list(np.nonzero(A[i,:])[1])),key=itemgetter(1)) if len(sorted_degrees) > 1: if sorted_degrees[-2][1] > 1 and sorted_degrees[-1][1] > 1: neighbors.append(i) - index_i = neighbors[random.randint(0, len(neighbors) - 1)] - sorted_degrees_i = sorted( - list(degree_list(np.nonzero(A[index_i, :])[1])), key=itemgetter(1) - ) +​ + index_i = neighbors[random.randint(0,len(neighbors)-1)] + sorted_degrees_i = sorted(list(degree_list(np.nonzero(A[index_i,:])[1])),key=itemgetter(1)) +​ min_degree = sorted_degrees_i[0][1] max_degree = sorted_degrees_i[-1][1] +​ j = [] k = [] +​ for item in sorted_degrees_i: if item[1] == min_degree: j.append(item[0]) if item[1] == max_degree: k.append(item[0]) - index_j = j[random.randint(0, len(j) - 1)] - index_k = k[random.randint(0, len(k) - 1)] - m = sorted( - list(degree_list(np.nonzero(A[index_j, :])[1])), key=itemgetter(1) - ) - n = sorted( - list(degree_list(np.nonzero(A[index_k, :])[1])), key=itemgetter(1) - ) - index_m = m[random.randint(0, len(m) - 1)][0] - index_n = n[random.randint(0, len(n) - 1)][0] - if len(np.unique([index_i, index_j, index_k, index_m, index_n])) == 5: - G.remove_edge(index_j, index_m) - G.remove_edge(index_k, index_n) - G.add_edge(index_k, index_j) - G.add_edge(index_m, index_n) - G_out = G +​ + index_j = j[random.randint(0,len(j)-1)] + index_k = k[random.randint(0,len(k)-1)] +​ + m = sorted(list(degree_list(np.nonzero(A[index_j,:])[1])),key=itemgetter(1)) + n = sorted(list(degree_list(np.nonzero(A[index_k,:])[1])),key=itemgetter(1)) +​ + index_m = m[random.randint(0,len(m)-1)][0] + index_n = n[random.randint(0,len(n)-1)][0] +​ + if len(np.unique([index_i,index_j,index_k,index_m,index_n])) == 5: + G.remove_edge(index_j,index_m) + G.remove_edge(index_k,index_n) + G.add_edge(index_k,index_j) + G.add_edge(index_m,index_n) +​ if verbose: return G, removed_edges, added_edges else: return G - def full_rewire( - self, G, copy_graph=False, timesteps=-1, directed=False, verbose=False - ): + def full_rewire(self,G,copy_graph=False,timesteps=-1,directed=False,verbose=False): if timesteps == -1: timesteps = int(len(G.nodes())) - G = self.step_rewire(G, copy_graph, timesteps, directed, verbose) + G = self.step_rewire(G,copy_graph,timesteps,directed,verbose) return G