From b29d8f9cbb757d058ef47f0569273156bbdbe63e Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Tue, 22 Aug 2023 14:38:31 +0200 Subject: [PATCH 01/26] refact: initial rewrite of draw_hyperedges with collections --- xgi/drawing/draw.py | 63 +++++++++++++++++++++++---------------------- 1 file changed, 32 insertions(+), 31 deletions(-) diff --git a/xgi/drawing/draw.py b/xgi/drawing/draw.py index 04c92db0b..969eebe04 100644 --- a/xgi/drawing/draw.py +++ b/xgi/drawing/draw.py @@ -510,38 +510,39 @@ def draw_hyperedges( edge_fc = _color_arg_to_dict(edge_fc, H.edges, settings["edge_fc_cmap"]) - # Looping over the hyperedges of different order (reversed) -- nodes will be plotted - # separately - for id, he in H.edges.members(dtype=dict).items(): + dyads = H.edges.filterby("order", 1) + edges = H.edges.filterby("order", (2, max_order), "between") + + # convert pos to format convenient for scatter + dyad_pos = np.asarray([(pos[e[0]], pos[e[1]]) for e in dyads]) + + # plot dyads + dyad_collection = LineCollection( + dyad_pos, + colors=dyad_color, + linewidths=dyad_lw, + antialiaseds=(1,), + linestyle=dyad_style, + ) + + dyad_collection.set_cmap(dyad_color_cmap) + dyad_collection.set_clim(dyad_vmin, dyad_vmax) + dyad_collection.set_zorder(max_order - 1) # edges go behind nodes + ax.add_collection(dyad_collection) + + # plot other hyperedges + patches = [] + for he in edges: d = len(he) - 1 - if d > max_order: - continue - if d == 1: - # Drawing the edges - he = list(he) - x_coords = [pos[he[0]][0], pos[he[1]][0]] - y_coords = [pos[he[0]][1], pos[he[1]][1]] - line = plt.Line2D( - x_coords, - y_coords, - color=dyad_color[id], - lw=dyad_lw[id], - zorder=max_order - 1, - ) - ax.add_line(line) - else: - # Hyperedges of order d (d=2: triangles, etc.) - # Filling the polygon - coordinates = [[pos[n][0], pos[n][1]] for n in he] - # Sorting the points counterclockwise (needed to have the correct filling) - sorted_coordinates = _CCW_sort(coordinates) - obj = plt.Polygon( - sorted_coordinates, - facecolor=edge_fc[id], - alpha=0.4, - zorder=max_order - d, - ) - ax.add_patch(obj) + coordinates = [[pos[n][0], pos[n][1]] for n in he] + # Sorting the points counterclockwise (needed to have the correct filling) + sorted_coordinates = _CCW_sort(coordinates) + patch = plt.Polygon(sorted_coordinates, zorder=max_order - d) + patches.append(patch) + + p = PatchCollection(patches, alpha=0.4, facecolors=edge_fc, cmap=edge_fc_cmap) + p.set_clim(edge_vmin, edge_vmax) + ax.add_collection(p) if hyperedge_labels: # Get all valid keywords by inspecting the signatures of draw_node_labels From 4caf84a8a4e37e3baaf1cd0f2b668d6b152c0dff Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Tue, 22 Aug 2023 15:51:34 +0200 Subject: [PATCH 02/26] updated parameter handling --- xgi/drawing/draw.py | 69 +++++++++++++++++++++++++++------------------ 1 file changed, 42 insertions(+), 27 deletions(-) diff --git a/xgi/drawing/draw.py b/xgi/drawing/draw.py index 969eebe04..dfc32474c 100644 --- a/xgi/drawing/draw.py +++ b/xgi/drawing/draw.py @@ -7,7 +7,7 @@ import numpy as np from matplotlib import cm from matplotlib.patches import FancyArrow -from mpl_toolkits.mplot3d.art3d import Line3DCollection, Poly3DCollection +from mpl_toolkits.mplot3d.art3d import Line3DCollection, LineCollection, PatchCollection, Poly3DCollection from networkx import spring_layout from scipy.spatial import ConvexHull @@ -421,10 +421,18 @@ def draw_hyperedges( ax=None, dyad_color="black", dyad_lw=1.5, + dyad_style="solid", + dyad_color_cmap="Greys", + dyad_vmin=None, + dyad_vmax=None, edge_fc=None, + edge_fc_cmap="Blues", + edge_vmin=None, + edge_vmax=None, max_order=None, - settings=None, + params=dict(), hyperedge_labels=False, + rescale_sizes=True, **kwargs, ): """Draw hyperedges. @@ -485,36 +493,42 @@ def draw_hyperedges( """ + settings = { + "min_dyad_lw": 2.0, + "max_dyad_lw": 10.0, + } + + settings.update(params) + settings.update(kwargs) + ax, pos = _draw_init(H, ax, pos) + # filter edge sizes if max_order is None: max_order = max_edge_order(H) + dyads = H.edges.filterby("order", 1) + edges = H.edges.filterby("order", (2, max_order), "between") - if edge_fc is None: - edge_fc = H.edges.size - - if settings is None: - settings = { - "min_dyad_lw": 2.0, - "max_dyad_lw": 10.0, - "edge_fc_cmap": cm.Blues, - "dyad_color_cmap": cm.Greys, - } - - settings.update(kwargs) + if edge_fc is None: # color is proportional to size + edge_fc = edges.size - dyad_color = _color_arg_to_dict(dyad_color, H.edges, settings["dyad_color_cmap"]) - dyad_lw = _scalar_arg_to_dict( - dyad_lw, H.edges, settings["min_dyad_lw"], settings["max_dyad_lw"] - ) + # convert all formats to ndarray + dyad_color = _draw_arg_to_arr(dyad_color) + dyad_lw = _draw_arg_to_arr(dyad_lw) + edge_fc = _draw_arg_to_arr(edge_fc) - edge_fc = _color_arg_to_dict(edge_fc, H.edges, settings["edge_fc_cmap"]) + # check validity of input values + if np.any(dyad_lw < 0): + raise ValueError("dyad_lw cannot contain negative values.") - dyads = H.edges.filterby("order", 1) - edges = H.edges.filterby("order", (2, max_order), "between") + # interpolate if needed + if rescale_sizes and isinstance(dyad_lw, np.ndarray): + dyad_lw = _interp_draw_arg( + dyad_lw, settings["min_dyad_lw"], settings["max_dyad_lw"] + ) - # convert pos to format convenient for scatter - dyad_pos = np.asarray([(pos[e[0]], pos[e[1]]) for e in dyads]) + # convert dyad pos to format convenient for scatter + dyad_pos = np.asarray([(pos[list(e)[0]], pos[list(e)[1]]) for e in dyads.members()]) # plot dyads dyad_collection = LineCollection( @@ -532,17 +546,18 @@ def draw_hyperedges( # plot other hyperedges patches = [] - for he in edges: + for he in edges.members(): d = len(he) - 1 + he = list(he) coordinates = [[pos[n][0], pos[n][1]] for n in he] # Sorting the points counterclockwise (needed to have the correct filling) sorted_coordinates = _CCW_sort(coordinates) patch = plt.Polygon(sorted_coordinates, zorder=max_order - d) patches.append(patch) - p = PatchCollection(patches, alpha=0.4, facecolors=edge_fc, cmap=edge_fc_cmap) - p.set_clim(edge_vmin, edge_vmax) - ax.add_collection(p) + edge_collection = PatchCollection(patches, alpha=0.4, facecolors=edge_fc, cmap=edge_fc_cmap) + edge_collection.set_clim(edge_vmin, edge_vmax) + ax.add_collection(edge_collection) if hyperedge_labels: # Get all valid keywords by inspecting the signatures of draw_node_labels From 2fc3b07da8c41c7f13e216ed181e710d0d597622 Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Tue, 22 Aug 2023 18:51:26 +0200 Subject: [PATCH 03/26] attempt at handling color args --- xgi/drawing/draw.py | 11 ++++++++--- xgi/drawing/draw_utils.py | 32 +++++++++++++++++++++++++++++++- 2 files changed, 39 insertions(+), 4 deletions(-) diff --git a/xgi/drawing/draw.py b/xgi/drawing/draw.py index dfc32474c..f6d1ee715 100644 --- a/xgi/drawing/draw.py +++ b/xgi/drawing/draw.py @@ -19,6 +19,7 @@ _CCW_sort, _color_arg_to_dict, _draw_init, + _parse_color_arg, _draw_arg_to_arr, _interp_draw_arg, _scalar_arg_to_dict, @@ -513,10 +514,13 @@ def draw_hyperedges( edge_fc = edges.size # convert all formats to ndarray - dyad_color = _draw_arg_to_arr(dyad_color) dyad_lw = _draw_arg_to_arr(dyad_lw) edge_fc = _draw_arg_to_arr(edge_fc) + # parse colors + dyad_color = _parse_color_arg(dyad_color, dyad_color_cmap, dyad_vmin, dyad_vmax) + edge_fc = _parse_color_arg(edge_fc, edge_fc_cmap, edge_vmin, edge_vmax) + # check validity of input values if np.any(dyad_lw < 0): raise ValueError("dyad_lw cannot contain negative values.") @@ -555,7 +559,8 @@ def draw_hyperedges( patch = plt.Polygon(sorted_coordinates, zorder=max_order - d) patches.append(patch) - edge_collection = PatchCollection(patches, alpha=0.4, facecolors=edge_fc, cmap=edge_fc_cmap) + edge_collection = PatchCollection(patches, alpha=0.4, facecolors=edge_fc) + edge_collection.set_cmap(edge_fc_cmap) edge_collection.set_clim(edge_vmin, edge_vmax) ax.add_collection(edge_collection) @@ -573,7 +578,7 @@ def draw_hyperedges( # compute axis limits _update_lims(pos, ax) - return ax + return ax, dyad_collection, edge_collection def draw_simplices( diff --git a/xgi/drawing/draw_utils.py b/xgi/drawing/draw_utils.py index a5282fc44..e4c07f784 100644 --- a/xgi/drawing/draw_utils.py +++ b/xgi/drawing/draw_utils.py @@ -1,7 +1,9 @@ """Draw hypergraphs and simplicial complexes with matplotlib.""" from collections.abc import Iterable +from numbers import Number +import matplotlib as mpl import matplotlib.pyplot as plt import numpy as np from matplotlib.colors import LinearSegmentedColormap, ListedColormap @@ -76,6 +78,34 @@ def _update_lims(pos, ax): ax.autoscale_view() +def _parse_color_arg(colors, cmap, vmin, vmax): + + # Check if edge_color is an array of floats and map to edge_cmap. + # This is the only case handled differently from matplotlib + + if isinstance(colors, IDStat): + colors = colors.asnumpy() + elif isinstance(colors, dict): + values = list(colors.values()) + colors = np.array(values) + + is_arr_float = (np.iterable(colors) and np.alltrue([isinstance(c, Number) for c in colors])) + + if is_arr_float: + if cmap is not None: + if not isinstance(cmap, mpl.colors.Colormap): + cmap = plt.get_cmap(cmap) # get cmap object from str name + else: + cmap = plt.get_cmap() + if vmin is None: + vmin = min(colors) + if vmax is None: + vmax = max(colors) + normalize_color = mpl.colors.Normalize(vmin=vmin, vmax=vmax) + colors = [cmap(normalize_color(c)) for c in colors] + return colors + + def _draw_arg_to_arr(arg): """Convert drawing arguments to a matplotlib-compliant format. @@ -90,7 +120,7 @@ def _draw_arg_to_arr(arg): Returns ------- arg : ndarray - Drawing argument in matplotlib-comliant form (scalar or array) + Drawing argument in matplotlib-compliant form (scalar or array) """ if isinstance(arg, IDStat): arg = arg.asnumpy() From c85c22b8006d3abe53145cfd45516c14ef9bc4f3 Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Thu, 24 Aug 2023 11:53:22 +0200 Subject: [PATCH 04/26] fix: alpha --- xgi/drawing/draw.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/xgi/drawing/draw.py b/xgi/drawing/draw.py index f6d1ee715..a0f1aad67 100644 --- a/xgi/drawing/draw.py +++ b/xgi/drawing/draw.py @@ -430,6 +430,7 @@ def draw_hyperedges( edge_fc_cmap="Blues", edge_vmin=None, edge_vmax=None, + alpha=0.4, max_order=None, params=dict(), hyperedge_labels=False, @@ -470,12 +471,10 @@ def draw_hyperedges( hyperedge_labels : bool or dict, optional If True, draw ids on the hyperedges. If a dict, must contain (edge_id: label) pairs. By default, None. - settings : dict + params : dict Default parameters. Keys that may be useful to override default settings: * min_dyad_lw * max_dyad_lw - * dyad_color_cmap - * edge_fc_cmap kwargs : optional keywords See `draw_hyperedge_labels` for a description of optional keywords. @@ -559,7 +558,7 @@ def draw_hyperedges( patch = plt.Polygon(sorted_coordinates, zorder=max_order - d) patches.append(patch) - edge_collection = PatchCollection(patches, alpha=0.4, facecolors=edge_fc) + edge_collection = PatchCollection(patches, alpha=alpha, facecolors=edge_fc) edge_collection.set_cmap(edge_fc_cmap) edge_collection.set_clim(edge_vmin, edge_vmax) ax.add_collection(edge_collection) From bdf7a48da1ac678c05feda3902dc5fb8343b1851 Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Thu, 24 Aug 2023 21:55:53 +0200 Subject: [PATCH 05/26] feature: finished functionality rewrite of drawing hyperedges. style: isort and black --- tests/drawing/test_draw_utils.py | 2 +- tutorials/XGI in 1 minute.ipynb | 8 ++-- tutorials/XGI in 15 minutes.ipynb | 30 ++++++++----- tutorials/XGI in 5 minutes.ipynb | 24 +++++++---- xgi/drawing/draw.py | 72 ++++++++++++++++++++++--------- xgi/drawing/draw_utils.py | 63 +++++++++++++++++---------- 6 files changed, 133 insertions(+), 66 deletions(-) diff --git a/tests/drawing/test_draw_utils.py b/tests/drawing/test_draw_utils.py index 6077ed8aa..9e3658161 100644 --- a/tests/drawing/test_draw_utils.py +++ b/tests/drawing/test_draw_utils.py @@ -6,9 +6,9 @@ from xgi.drawing.draw import ( _CCW_sort, _color_arg_to_dict, + _draw_arg_to_arr, _interp_draw_arg, _scalar_arg_to_dict, - _draw_arg_to_arr, ) diff --git a/tutorials/XGI in 1 minute.ipynb b/tutorials/XGI in 1 minute.ipynb index 6230ed611..55157e1bc 100644 --- a/tutorials/XGI in 1 minute.ipynb +++ b/tutorials/XGI in 1 minute.ipynb @@ -39,7 +39,7 @@ "metadata": {}, "outputs": [], "source": [ - "hyperedges = [[1,2,3],[3,4],[4,5,6,7]]\n", + "hyperedges = [[1, 2, 3], [3, 4], [4, 5, 6, 7]]\n", "H = xgi.Hypergraph(hyperedges)" ] }, @@ -60,7 +60,7 @@ "outputs": [], "source": [ "H.add_node(8)\n", - "H.add_edge([7,8])" + "H.add_edge([7, 8])" ] }, { @@ -77,8 +77,8 @@ "metadata": {}, "outputs": [], "source": [ - "H.add_nodes_from([9,10])\n", - "H.add_edges_from([[1,10], [8,9,10]])" + "H.add_nodes_from([9, 10])\n", + "H.add_edges_from([[1, 10], [8, 9, 10]])" ] }, { diff --git a/tutorials/XGI in 15 minutes.ipynb b/tutorials/XGI in 15 minutes.ipynb index 3d668139a..e3b75b25a 100644 --- a/tutorials/XGI in 15 minutes.ipynb +++ b/tutorials/XGI in 15 minutes.ipynb @@ -219,7 +219,7 @@ "isolated_nodes = H_enron.nodes.isolates()\n", "print(\"Number of isolated nodes: \", len(isolated_nodes))\n", "duplicated_edges = H_enron.edges.duplicates()\n", - "print(\"Number of duplicated edges: \", len(duplicated_edges))\n" + "print(\"Number of duplicated edges: \", len(duplicated_edges))" ] }, { @@ -276,7 +276,7 @@ } ], "source": [ - "len(H_enron.nodes) == len(H_enron_cleaned.nodes)+len(isolated_nodes)" + "len(H_enron.nodes) == len(H_enron_cleaned.nodes) + len(isolated_nodes)" ] }, { @@ -296,7 +296,7 @@ } ], "source": [ - "len(H_enron.edges) == len(H_enron_cleaned.edges)+len(duplicated_edges)" + "len(H_enron.edges) == len(H_enron_cleaned.edges) + len(duplicated_edges)" ] }, { @@ -459,9 +459,12 @@ "source": [ "list_of_edges_sizes = H_enron_cleaned.edges.size.aslist()\n", "ax = plt.subplot(111)\n", - "ax.hist(list_of_edges_sizes, bins=range(min(list_of_edges_sizes), max(list_of_edges_sizes) + 1, 1))\n", - "ax.set_xlabel('Edge size')\n", - "ax.set_ylabel('Frequency')" + "ax.hist(\n", + " list_of_edges_sizes,\n", + " bins=range(min(list_of_edges_sizes), max(list_of_edges_sizes) + 1, 1),\n", + ")\n", + "ax.set_xlabel(\"Edge size\")\n", + "ax.set_ylabel(\"Frequency\")" ] }, { @@ -501,9 +504,12 @@ "source": [ "list_of_nodes_degrees = H_enron_cleaned.nodes.degree.aslist()\n", "ax = plt.subplot(111)\n", - "ax.hist(list_of_nodes_degrees, bins=range(min(list_of_nodes_degrees), max(list_of_nodes_degrees) + 1, 1))\n", - "ax.set_xlabel('Degree')\n", - "ax.set_ylabel('Frequency')" + "ax.hist(\n", + " list_of_nodes_degrees,\n", + " bins=range(min(list_of_nodes_degrees), max(list_of_nodes_degrees) + 1, 1),\n", + ")\n", + "ax.set_xlabel(\"Degree\")\n", + "ax.set_ylabel(\"Frequency\")" ] }, { @@ -628,7 +634,9 @@ ], "source": [ "print(\"The density of the hypergraph is:\", xgi.density(H_enron_cleaned))\n", - "print(\"The assortativity of the hypergraph is:\", xgi.degree_assortativity(H_enron_cleaned))" + "print(\n", + " \"The assortativity of the hypergraph is:\", xgi.degree_assortativity(H_enron_cleaned)\n", + ")" ] }, { @@ -681,7 +689,7 @@ } ], "source": [ - "nodes_degree_2 = H_enron_cleaned.nodes.filterby('degree', 20)\n", + "nodes_degree_2 = H_enron_cleaned.nodes.filterby(\"degree\", 20)\n", "print(nodes_degree_2)" ] }, diff --git a/tutorials/XGI in 5 minutes.ipynb b/tutorials/XGI in 5 minutes.ipynb index a071907d1..8f0af9dfb 100644 --- a/tutorials/XGI in 5 minutes.ipynb +++ b/tutorials/XGI in 5 minutes.ipynb @@ -148,7 +148,7 @@ ], "source": [ "pos = xgi.barycenter_spring_layout(H, seed=1)\n", - "xgi.draw(H, pos=pos)\n" + "xgi.draw(H, pos=pos)" ] }, { @@ -227,7 +227,7 @@ } ], "source": [ - "xgi.draw(H, dyad_color='tab:red',edge_fc='tab:orange', pos=pos)" + "xgi.draw(H, dyad_color=\"tab:red\", edge_fc=\"tab:orange\", pos=pos)" ] }, { @@ -389,10 +389,14 @@ ], "source": [ "list_of_orders = H_new.edges.order.aslist()\n", - "plt.hist(list_of_orders, bins=range(min(list_of_orders), max(list_of_orders) + 2, 1), align='left')\n", + "plt.hist(\n", + " list_of_orders,\n", + " bins=range(min(list_of_orders), max(list_of_orders) + 2, 1),\n", + " align=\"left\",\n", + ")\n", "plt.xticks(range(min(list_of_orders), max(list_of_orders) + 1, 1))\n", - "plt.xlabel('Order')\n", - "plt.ylabel('Number of edges')\n" + "plt.xlabel(\"Order\")\n", + "plt.ylabel(\"Number of edges\")" ] }, { @@ -433,10 +437,14 @@ ], "source": [ "nodes_degrees_list = H_new.nodes.degree.aslist()\n", - "plt.hist(nodes_degrees_list, bins=range(min(nodes_degrees_list), max(nodes_degrees_list) + 1, 1), align='left')\n", + "plt.hist(\n", + " nodes_degrees_list,\n", + " bins=range(min(nodes_degrees_list), max(nodes_degrees_list) + 1, 1),\n", + " align=\"left\",\n", + ")\n", "plt.xticks(range(min(nodes_degrees_list), max(nodes_degrees_list) + 1, 5))\n", - "plt.xlabel('Node degree')\n", - "plt.ylabel('Number of nodes')" + "plt.xlabel(\"Node degree\")\n", + "plt.ylabel(\"Number of nodes\")" ] }, { diff --git a/xgi/drawing/draw.py b/xgi/drawing/draw.py index a0f1aad67..c208f26cd 100644 --- a/xgi/drawing/draw.py +++ b/xgi/drawing/draw.py @@ -7,7 +7,12 @@ import numpy as np from matplotlib import cm from matplotlib.patches import FancyArrow -from mpl_toolkits.mplot3d.art3d import Line3DCollection, LineCollection, PatchCollection, Poly3DCollection +from mpl_toolkits.mplot3d.art3d import ( + Line3DCollection, + LineCollection, + PatchCollection, + Poly3DCollection, +) from networkx import spring_layout from scipy.spatial import ConvexHull @@ -18,10 +23,10 @@ from .draw_utils import ( _CCW_sort, _color_arg_to_dict, - _draw_init, - _parse_color_arg, _draw_arg_to_arr, + _draw_init, _interp_draw_arg, + _parse_color_arg, _scalar_arg_to_dict, _update_lims, ) @@ -509,16 +514,18 @@ def draw_hyperedges( dyads = H.edges.filterby("order", 1) edges = H.edges.filterby("order", (2, max_order), "between") - if edge_fc is None: # color is proportional to size + if edge_fc is None: # color is proportional to size edge_fc = edges.size # convert all formats to ndarray dyad_lw = _draw_arg_to_arr(dyad_lw) edge_fc = _draw_arg_to_arr(edge_fc) - # parse colors - dyad_color = _parse_color_arg(dyad_color, dyad_color_cmap, dyad_vmin, dyad_vmax) - edge_fc = _parse_color_arg(edge_fc, edge_fc_cmap, edge_vmin, edge_vmax) + # parse colors + dyad_color, dyad_c_mapped = _parse_color_arg( + dyad_color, dyad_color_cmap, list(dyads) + ) + edge_fc, edge_c_mapped = _parse_color_arg(edge_fc, edge_fc_cmap, list(edges)) # check validity of input values if np.any(dyad_lw < 0): @@ -533,21 +540,39 @@ def draw_hyperedges( # convert dyad pos to format convenient for scatter dyad_pos = np.asarray([(pos[list(e)[0]], pos[list(e)[1]]) for e in dyads.members()]) - # plot dyads + # plot dyads + if dyad_c_mapped: + dyad_c_arr = dyad_color + dyad_colors = None + else: + dyad_c_arr = None + dyad_colors = dyad_color + dyad_collection = LineCollection( - dyad_pos, - colors=dyad_color, - linewidths=dyad_lw, - antialiaseds=(1,), - linestyle=dyad_style, - ) + dyad_pos, + colors=dyad_colors, + array=dyad_c_arr, # colors if mapped, ie arr of floats + linewidths=dyad_lw, + antialiaseds=(1,), + linestyle=dyad_style, + cmap=dyad_color_cmap, + zorder=max_order - 1, + ) - dyad_collection.set_cmap(dyad_color_cmap) - dyad_collection.set_clim(dyad_vmin, dyad_vmax) - dyad_collection.set_zorder(max_order - 1) # edges go behind nodes + # dyad_collection.set_cmap(dyad_color_cmap) + if dyad_c_mapped: + dyad_collection.set_clim(dyad_vmin, dyad_vmax) + # dyad_collection.set_zorder(max_order - 1) # edges go behind nodes ax.add_collection(dyad_collection) # plot other hyperedges + if edge_c_mapped: + edge_fc_arr = edge_fc + edge_fc_colors = None + else: + edge_fc_arr = None + edge_fc_colors = edge_fc + patches = [] for he in edges.members(): d = len(he) - 1 @@ -558,9 +583,16 @@ def draw_hyperedges( patch = plt.Polygon(sorted_coordinates, zorder=max_order - d) patches.append(patch) - edge_collection = PatchCollection(patches, alpha=alpha, facecolors=edge_fc) - edge_collection.set_cmap(edge_fc_cmap) - edge_collection.set_clim(edge_vmin, edge_vmax) + edge_collection = PatchCollection( + patches, + facecolors=edge_fc_colors, + array=edge_fc_arr, + cmap=edge_fc_cmap, + alpha=alpha, + ) + # edge_collection.set_cmap(edge_fc_cmap) + if edge_c_mapped: + edge_collection.set_clim(edge_vmin, edge_vmax) ax.add_collection(edge_collection) if hyperedge_labels: diff --git a/xgi/drawing/draw_utils.py b/xgi/drawing/draw_utils.py index e4c07f784..d1edcd5b1 100644 --- a/xgi/drawing/draw_utils.py +++ b/xgi/drawing/draw_utils.py @@ -6,11 +6,16 @@ import matplotlib as mpl import matplotlib.pyplot as plt import numpy as np -from matplotlib.colors import LinearSegmentedColormap, ListedColormap +from matplotlib.colors import ( + LinearSegmentedColormap, + ListedColormap, + is_color_like, + to_rgba_array, +) from numpy import ndarray from ..exception import XGIError -from ..stats import IDStat +from ..stats import EdgeStat, IDStat, NodeStat from .layout import barycenter_spring_layout @@ -78,39 +83,53 @@ def _update_lims(pos, ax): ax.autoscale_view() -def _parse_color_arg(colors, cmap, vmin, vmax): +def _parse_color_arg(colors, cmap, ids, id_kind="edges"): # Check if edge_color is an array of floats and map to edge_cmap. # This is the only case handled differently from matplotlib + if id_kind=="edges" and isinstance(colors, NodeStat): + raise TypeError("The color argument for edges cannot be a NodeStat") + elif id_kind=="nodes" and isinstance(colors, Edgestat): + raise TypeError("The color argument for nodes cannot be an EdgeStat") + + + # When drawing hyperedges we need to separate dyads and other hyperedges. + # But the user can input and IDstat or dict that represent all hyperedges. + # So we need to filter these cases. + xsize = len(ids) + if isinstance(colors, IDStat): - colors = colors.asnumpy() - elif isinstance(colors, dict): + colors = colors.asdict() + if isinstance(colors, dict): + if ids is not None: # filter if needed + colors = {key: val for key, val in colors.items() if key in ids} values = list(colors.values()) colors = np.array(values) - is_arr_float = (np.iterable(colors) and np.alltrue([isinstance(c, Number) for c in colors])) + try: # see if the input format is compatible with PatchCollection's facecolor + colors = to_rgba_array(colors) + colors_are_mapped = False + except: + try: # in case of array of floats (can be fed to PatchCollection with some care) + colors = np.asanyarray(colors, dtype=float) + colors_are_mapped = True + except: + raise ValueError("Invalud input format for colors.") + + if not is_color_like(colors) and len(colors) != xsize: + raise ValueError( + f"The input color argument must be a single color or its length must match the number of plotted elements ({xsize})." + ) - if is_arr_float: - if cmap is not None: - if not isinstance(cmap, mpl.colors.Colormap): - cmap = plt.get_cmap(cmap) # get cmap object from str name - else: - cmap = plt.get_cmap() - if vmin is None: - vmin = min(colors) - if vmax is None: - vmax = max(colors) - normalize_color = mpl.colors.Normalize(vmin=vmin, vmax=vmax) - colors = [cmap(normalize_color(c)) for c in colors] - return colors + return colors, colors_are_mapped def _draw_arg_to_arr(arg): - """Convert drawing arguments to a matplotlib-compliant format. + """Convert drawing arguments to a matplotlib-compliant format. - IDStat, dict, and list are converted to ndarray. - Scalar values are untouched. + IDStat, dict, and list are converted to ndarray. + Scalar values are untouched. Parameters ---------- From 2c05a58055231aa0e4613f8e4a9df013e4e09df3 Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Thu, 24 Aug 2023 23:56:35 +0200 Subject: [PATCH 06/26] tuto: new on drawing edges --- In Depth 2 - Drawing hyperedges.ipynb | 477 ++++++++++++++++++++++++++ xgi/drawing/draw.py | 111 +++--- xgi/drawing/draw_utils.py | 5 +- 3 files changed, 540 insertions(+), 53 deletions(-) create mode 100644 In Depth 2 - Drawing hyperedges.ipynb diff --git a/In Depth 2 - Drawing hyperedges.ipynb b/In Depth 2 - Drawing hyperedges.ipynb new file mode 100644 index 000000000..873fb09e2 --- /dev/null +++ b/In Depth 2 - Drawing hyperedges.ipynb @@ -0,0 +1,477 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e6d0469d", + "metadata": {}, + "source": [ + "# In Depth 2 - Drawing hyperedges" + ] + }, + { + "cell_type": "markdown", + "id": "fe24ae6c", + "metadata": {}, + "source": [ + "Here we show the fuctionalities and parameters of `xgi.draw_hyperedges()`. It is similar to the [networkx](https://networkx.org/documentation/stable/reference/drawing.html) corresponding function (+ some bonus) and heavily relies on [matplotlib](https://matplotlib.org/)'s Collection plotting." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "30c5cf3c", + "metadata": {}, + "outputs": [], + "source": [ + "import xgi\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "id": "d84c18f4", + "metadata": {}, + "source": [ + "Les us first create a small toy hypergraph containing edges of different sizes." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4b40a720", + "metadata": {}, + "outputs": [], + "source": [ + "edges = [[1, 2, 3], [3, 4, 5], [3, 6], [6, 7, 8, 9], [1, 4, 10, 11, 12], [1, 4], [2, 5]]\n", + "H = xgi.Hypergraph(edges)\n", + "\n", + "pos = xgi.barycenter_spring_layout(H, seed=42) # fix position" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "4b5ab06f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(,\n", + " (,\n", + " ,\n", + " ))" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "xgi.draw(H, pos=pos)" + ] + }, + { + "cell_type": "markdown", + "id": "05f4c555", + "metadata": {}, + "source": [ + "## Basics" + ] + }, + { + "cell_type": "markdown", + "id": "610dbcb4", + "metadata": {}, + "source": [ + "Let's jump right into how `xgi.draw_nodes()` works. By default, it gives:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "75025a15", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(,\n", + " (,\n", + " ))" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAkx0lEQVR4nO3deWyd9b3n8c+xj9dsjgNJTPZk2CmUpQyUrZSGkoRQDSqVqFQqJGgrlvtPp/91dP9A/esyuroDqE2pUFu1EtPSuaIaeqeLBKUjgqYEajsLcUK8xLF9vNvn+OzneeYP24md2PF2nuf3PM/v/ZJIHB/sfM+B5Pc5398Wc13XFQAAsFaF6QIAAIBZhAEAACxHGAAAwHKEAQAALEcYAADAcoQBAAAsRxgAAMByhAEAACxHGAAAwHKEAQAALEcYAADAcoQBAAAsRxgAAMByhAEAACxHGAAAwHKEAQAALEcYAADAcoQBAAAsRxgAAMByhAEAACxHGAAAwHKEAQAALEcYAADAcoQBAAAsRxgAAMByhAEAACxHGAAAwHKEAQAALEcYAADAcoQBAAAsRxgAAMByhAEAACxHGAAAwHKEAQAALEcYAADAcoQBAAAsRxgAAMByhAEAACxHGAAAwHJx0wUACIeXXnpJTU1N2rFjh3bs2KHt27ertrbWdFkAyiDmuq5ruggAwTY2Nq6GhnWXfH7z5s3asWOHdu7ceT4kzPx49erVBqoFsFSEAQCX5bjSwOCQ/vm//VBdXZ3q6OhQZ2en0un0gl/b2Ng4b1DYuXOnGhoaFIvFfHgWAC6HMABgTq47GQRm/gVRGZNiMcl1XQ0NDamz80I4uPjj0dHRBX+PNWvWXLazsHHjRsIC4APCAIBLzBUEJKkiNvnPYoyNjc0ZEqZ/PTAwsOD3qKur0/bt2+cNDE1NTaqsrFz6EwQwC2EAwHnuVABwLvO3wnR3YKXS6bS6urrm7Sz09PRoob+e4vH4+bBwcWDYsWOHtm3bpqqqqpUXC0QcYQCApPm7ARdbSndgJfL5vM6ePTtnUOjo6FB3d7eKxeLla62o0FVXXTVvZ2H79u2qq6vz/skAAUcYALDoIDCtXN2BlSiVSurp6ZlzCmL641wut+D32bRp06yQ8LWvfU333HOPD88ACA7CAGCxxUwLzCUmqTLgR5Y5jqP+/v7LrltIpVKXfN2//dv/0D/904sGKgbMIQwAllpqN+BiQegOrITruhoZGTkfDDo6OtXR2aknn3xSd/3nO02XB/iKMABYaKVBQApHd2CxHPdCd8SvNRFAkHAcMWCR5U4LzPm9pr5fuLsDKw9FQBREJNcDWMj0wFeOIDCtnN/LbwQB4AI6A4AFvBr4prsMYWqrl7M7AkQFYQCIMD8GvunfIwzTBXQDgLkRBoCI8mvgc6f+CXIWoBsAXB5hAIggv98BB7k7QDcAWBhhAIgQU++Ag9odKPeCSSCqCANARJh+Bxyk7oDp1wIIG7YWAhEQhMFvujtgWhBeCyBs6AwAIRa0hXGOOzlVYKI7ELTXAggTwgAQUkF9B2xi7UBQXwsgLAgDQAgFefDzsztANwAoD8IAECJhGfz86A4EORABYUMYAEIiTIOfl90BrwNRADZDAL5jNwEQAmEKAtO8GKy9uGwJAJ0BINDCMi0wl3Jfcey4F14PAOVFGAACKozdgIs5rlS5wjAQhdcBCDqmCYAAisoAON0dWPbXR+R1AIKOzgAQIGGeFpjPcroDUXwdgCAjDAABEdV3wUtdOxDV1wEIMsIAEABRHwAdd3JO8nKBgG4AYA5hADDIlgFwoSuOox6GgKAjDACG2DYAznfFMecGAOYRBgADbBwAL+4O2BaGgCAjDAA+smVaYD4zDw0iCADBQRgAfMI74cnXoGS6CACXIAwAPrBxWuAS7oxthvLnimMAi0MYADxk+7SApAshwHQdAOZFGAA8wrSA5g0C7tQPdAeAYCAMAB5gWoAbBoEwIQwAZcS0gBY9LUB3AAgOwgBQJkwLXLihcLGvweVOJQTgH8IAUAbWTwusYJHgUi4xAuANwgCwAkwLaMW7BegOAOYRBoBlsn5aoIxbBukOAGYRBoBlYFqgvGcH0B0AzCIMAEtg/bSAhwcI0R0AzCEMAIvEtIC3Jwmy1RAwhzAALILt0wIcIAREG2EAuAymBfy9V4DuAGAGYQCYB9MCXDAE2IIwAMzB6mkBwyGA7gDgP8IAMAPdALoBgI0IA8AUq4NAwEIA3QHAX4QBQEwLBCkIAPAfYQBWs7oboGBvGaQ7APiHMABrWR0E6AYAmIEwACvZPC3gTj3vMDx9ugOAPwgDsArdgPA9dy4xArxXYboAwC8EgfA+dzeshQMhQWcAVrB2WiDkIWAa3QHAW4QBRBrdgOg8d644BrxDGEBkWRsEIhYCptEdALzDmgFEkuNKJYJA5LB2APAGnQFEirXdAAX7AKFyYash4A3CACLD2iAQ8W6A3wgasBFhAJHAbgF70B0Ayo8wgFCjGwAAK8cCQoQWQcBerlhMCJQTYQChk0wm7dwt4E4FIFn2vAF4jjCAUGnv6FJjY6MefPBL+u8v/4tOnDgh14a3iHQDLkF3ACifmGvF36QIM9d1da5/VG3tCf3mN7/RoX/951mP79q1S/v2H9CBA4/q/gceUG1traFKvWHDlsHliqn8CwnjvEWChQgDCKxUOqe2joTaOhOaSOfOf34g0aOWIx+o5ePDOnn0ExWLhfOP1dfX6ytf2at9+w9o3/792rJli4nSy4NuwKKUOxAQBmAjwgACpVRy1NkzpLaOfp3rH1nw389m0jrRekStHx9Wy8eHNTo8OOvxW2+9dSoYHNAXvvAFVVZWelV6eREEFo0wAKwcYQCBMDw2oZPtCX3W1a9cobis7+G6rs62n1LzkQ/U+vFhtZ+evZ7gyiuv1COP7NP+A49q78MPa926deUqv3wIActSzkBAGICNCAMwJl8o6rOuAbV19mtwJFn27z8+NqLWTz5U65HDOtb8/5RJT5x/LB6P695779X+A49q3/4DuvbaaxUzfYoNQWBFKggDwLIRBuC7nv5RnersV3v3oEqO48vvWSwWdfrTFrUcOayWIx+or6dr1uN79uzR/v0HtP/Ao7rv/vtVU1PjS12SCAFlUo7uQExSJWEAFiIMwBfpTF5tnQm1dSSUnMiaLkeJ3u7JdQZHDqvt+D9mLUJctWqVvrJ3rw7sf1T79u/X5qYm7wohCJTVSrsDhAHYijAAzziOo7N9IzrZnlB3YiSw5wFkM2kdb/lILR9/oNYjhzU2Ojzr8dtuu00HpqYTbr/jDlVUlGG0IAR4YqXdAcIAbEUYQNmNJtNTiwEHlMnlTZezJI7jqKv9lFo//kDNRw6r4/SJWY9v3LhR+/fv1779B7R378Nas3bt0n8TgoCnVtIdIAzAVoQBlEWhUFL7uUGdbE+of3jcdDllMzY6rKOffKiWIx/oWPPflc2kzz9WVVWl++67TwcOPKr9Bw7o6quvWXCAn/7Txh8676ykO0AYgK0IA1iRxNC4TnX060z3gArFkulyPFUsFHTqRLNaps40SPScnfX41Vdfrf37D+jAgQO67/77VVVVfWHQpxvgq+V2BwgDsBVhAEuWyeZ1umtAJzsSGkumF/6CiEr0nj2/O6HtRLNKxQvnI6xZs0Z79+7V97//X3XXXXfbd6mSYcvtDhAGYCvCABbFdV2d7RvRqc6EunpG5Lj+bAkMi0x6Qsdb/q6WI4fV+smHGp9ahPjv//57HXzs4PkgMPNPG3/wvLWcQEAYgK0IA7is8VRGbZ39OtXZr3Qmt/AXQI7jqPPMSbV+/KH+9V9+pF3bNkuafcse4cB7hAFg8QgDuESxWFJnz7BOdvSpd2DMdDmh9tV7b9TWTesv+fzMmwgv/vj8v+N5ddG31EBAGICt4qYLQHAMjqR0siOhM2cHlF/m/QCYzXHmHtJjscmBZ/IXMwLBjI9jIhwA8AdhwHK5fEGnuwbU1pHQ8NjEwl+AJVls322ucCBJ7jzhgGCwOO7UD6avnQCCjjBgIdd11TMwprb2hDp7hny7H8BG7jIXWk4PXrGpH+YKB5Pff+rnlRQJwHqEAYuk0jmd6uxXW0dCqbT5+wFsMN80wVItFA6kuRcogu4AsBiEgYgrlRx19Q7rZHtC5/pHTJdjHa+W5y4mHDisNwCwSISBiBoem1Bbx+T9ANl8YeEvgCf8Oo/h4nAgSRUXTSfYHA7oDgCXRxiIkHyhqDNnB9XWmdDAcNJ0OVD5pgmW4+JFiYQDAPMhDERA3+C42jr61N49pGIp2vcDhI3JMHCxucKBdGGtQdTDAd0BYH6EgZBKZ/I61TW5GHA8lTFdDuYR5EH14qkFG8LB9BZNALMRBkLEcRyd7RtVW0efzvaNiMMjg88J0bbNhcLBrC2N/pdXNi7dAeAShIEQGEtm1NaZ0OnOfqWzedPlYAmCNE2wVPPuWFC4wwHdAeBShIGAKhZLaj83qJPtCSWGxk2Xg2UK0yC5kLl2LMwMBI4TnnBAdwCYjTAQMP3DSbW1J3Sme0CFIosBwy7MnYHFmLkosaJy7nAQxFeA7gAwG2EgALK5gk539etkR0Kj42nT5aCMwrRmoBzmCgfS5OAbtHBAdwC4gDBgiOu66k6M6lRHQp09w74dTgN/OZYv8pw5tRC0cMBWQ+ACwoDPkhNZtXUkdKqrXxPpnOly4DHLs8Al5gsHzowFibxkgP8IAz4olRx1nBtSW2dCPf2jpsuBj2ybJliq6XBQOWNBonQhHEiSl68g3QFgEmHAQ0OjKZ3sSOhM14ByhaLpcmCA7dMES3VxOJBmH4Dkut6GA8BWhIEyyxeK+qxrQCc7EhoaTZkuB4aRBVYuFvM2HNAdAAgDZeG6rnoHxtTWkVDHuSGVaA1jihvxrYUmzBUOptcbOC5rDoDlIAyswEQmp1Odk/cDJCeypstBALFLxHux2IzpBS0vHNAdgO0IA0vkOI66eod1sj2hc/2j3A+Ay4r6oUNBVI5wANiGMLBII+NptXVM3g+QzRdMl4OQICuat1A4kC5saeS/F2xFGLiMQqGkM92TiwEHhpOmy0EIMU0QPBeHA2nyACTHdfXuu+/q/b++q5deeslYfYAJMZc+9yX6Bsd1qiOhM92DKpa4HwDLt72pUXu/eIPpMrAIvb292rZtm0qlkpqbm3XzzTebLgnwTYXpAoIik82r5WS33vrTx3rnry1q60wQBLBiRO3waGpq0uOPPy5JeuWVVwxXA/jL6s6A4zjqToyqrSOhs70jtHRRdls2rtcj991ougws0t/+9jfdf//9qqurU3d3txobG02XBPjCys7AeCqjvx/t0P/8j4/05w+Oq7NniCAAT/D/Vbjce++9uuWWW5TJZPTGG2+YLgfwjTVhoFgs6XRnv975a6t++8cjajnZrXQ2b7osRBxbC8MlFovpxRdflCS99tprKjFVCEtEfppgYDipts5+nTk7oDz3A8BnGxvX6uCDLEQLk3Q6ra1bt2pkZERvv/22HnvsMdMlAZ6LZGcgmyvo2Oke/a8/f6Lfv9usT8/0EgRgBBcVhU99fb2eeeYZSSwkhD0i2Rn44B+f6cRnvabLANS4bpX+y1duNV0Glqijo0N79uyR4zg6fvy4rr/+etMlAZ6KZGfg7lt2a8+2K02XAbC1MKR27typgwcPSppcOwBEXSTDQCwW0/13XK0dV20wXQosxzRBeL3wwguSpF/84hcaHx83XA3grUiGAUmqqKjQg3deq62b1psuBRZzuM46tB566CFdf/31SqVS+vnPf266HMBTkQ0DklRZWaGH7rpOTVeuM10KLEVnILxisdj57sCrr75KsEOkRToMSFI8Xqm9d9+gjY1rTZcCC5EFwu2pp57S2rVrderUKf35z382XQ7gmciHAUmqqqrUV++9QRsaVpsuBZZxOXQo1FavXq2nn35aEtsMEW1WhAFJqq6K65F7b1TD2nrTpcAitJbD77nnnpMk/eEPf9Bnn31muBrAG9aEAUmqranSvntv0trVdaZLgSXoC4TfNddco0ceeUSu67LNEJFlVRiQpPq6au277yatqq8xXQoswN0E0TB9X8Ebb7yhiYkJw9UA5WddGJCk1fU12n/fTaqvrTZdCiKOMBANjzzyiPbs2aOxsTH96le/Ml0OUHZWhgFJWru6Tvvuv0m11VWmS0GEcYVxNFRUVOj555+XNLmQMIKnuMNy1oYBSWpYU69H7rtRNVVx06Ugwhg4ouHpp59WfX29jh07pvfee890OUBZWR0GJGlDw2o9fO+NqopXmi4FEUUYiIaGhgY99dRTkthmiOixPgxI0sbGNXr4nhsVryQQoPxYNxAd0ycSvv322+rq6jJcDVA+hIEpm69Yq4fuvk4VMV4SlBdHEkfHjTfeqC9/+ctyHEc//vGPTZcDlA0j3wxbN63Xl+8iEKC86AxEy3R34PXXX1cmkzFcDVAejHoX2XFVo7505zWKxWKmS0FEsGYgWg4ePKjt27draGhIb775pulygLIgDMxh19YrdN/t/8l0GYgIpgmiJR6Pnz+imG2GiArCwDyu3rFJX/z8HtNlIAKYJoieZ555RrW1tfrkk090+PBh0+UAK0YYuIzr9zTpzs/tMl0GQo53jtGzYcMGPfnkk5LYZohoIAws4HPXbNFtN+wwXQZCjGmCaJq+r+Ctt95ST0+P4WqAlSEMLMKt12/TzdduNV0GQoppgmi69dZbdc8996hYLOrQoUOmywFWhDCwSF+4aadu2HOV6TIQQoSB6JruDhw6dEj5fN5wNcDyEQaW4K5bdunanZtNl4GQYc1AdD3++ONqampSIpHQW2+9ZbocYNkIA0sQi8V0z217tGfblaZLQYiwZiC6qqqq9L3vfU8SCwkRboSBJYrFYrr/jqu146oNpktBSDBNEG3f+c53VFVVpQ8//FAfffSR6XKAZSEMLENFRYUevPNabd203nQpCAGmCaJt8+bN+sY3viFJevXVVw1XAywPYWCZKisr9NBd16npynWmS0HAMU0QfdMLCd98800NDAwYrgZYOsLACsTjldp79w3a2LjWdCkIMKYJou/OO+/UHXfcoVwup9dff910OcCSxVx6mCuWLxT1h/ePamg0ZboUGFBdFVd1VVw11XHVVleppjqu6uq4aqsnP7dzyxVaXV9jukx47Je//KW+/e1va+vWrWpvb1c8HjddErBohIEyyeYKeuf9Vo2Op02XgmWqildODeKTA3pNVVw1NRc+rq2Jq7pq8te1NVOPV8dVUUGDDVIul9O2bds0MDCg3/72t/r6179uuiRg0QgDZZTO5PXO+60aT3HHuUnxyslBfXoAr6mOq2ZqgD8/0M/43PSgXlnJoI6V+eEPf6gf/ehHeuCBB/Tee++ZLgdYNMJAmaXSOf3vv7ZoIp0zXUroVVZUzB60pwbz6vMfXzrQV1dVKh6vNF06LNXd3a2dO3eqVCqpublZN998s+mSgEUhDHhgPJXRO39tVTrL8aSSVBGbGtRrpt+tV6mmampeferjC+/WJwf32uo4gzpC6YknntBbb72lZ599Vj/96U9NlwMsCmHAI6PJtN55r1XZfMF0KWUTi8UuzKNPL5irmVw8Nz2o19ZUzWjRT36uqopBHfZ4//339cADD6iurk7d3d1qbGw0XRKwIMKAh4ZGU/qP948qVyiaLmWW6UG9uvqiFfDTA/j5xXMzBvWpxwFcnuu6+vznP6+Wlha9/PLL+v73v2+6JGBBhAGP9Q8n9X/+dlSFYsmT719dNbu1vpg59uqquGKxmCf1AJB+9rOf6dlnn9WuXbt06tQpVVbSHUOwEQZ80Dc4rj/+32MqluYPBAvtVZ8e1C+eY2dQB4InnU5r69atGhkZ0e9//3sdPHjQdEnAZREGfNI3OK6B4SR71QFL/OAHP9DLL7+svXv36k9/+pPpcoDLIgwAgAfa29u1Z88eua6rEydO6LrrrjNdEjAv3o4CgAd27dp1fnrgtddeM1wNcHl0BgDAI3/5y1+0d+9erV69WufOndPatVxqhmCiMwAAHnnooYd03XXXKZVK6Re/+IXpcoB5EQYAwCOxWEwvvPCCJOnVV1+V4ziGKwLmxjQBAHgomUxqy5YtSiaT+uMf/6iHH37YdEnAJegMAICH1qxZo6efflqS9MorrxiuBpgbnQEA8FhbW5uuvfZaxWIxnT59Wrt37zZdEjALnQEA8Ng111yjr371q3Jdl22GCCQ6AwDgg3feeUePPvqoGhoa1N3drVWrVpkuCTiPzgAA+GDfvn3as2ePRkdH9etf/9p0OcAshAEA8EFFRYWef/55SZMLCWnKIkiYJgAAn4yOjmrLli1Kp9N699139aUvfcl0SYAkOgMA4JuGhgZ961vfksQ2QwQLnQEA8NHRo0f1uc99ThUVFWpvb9f27dtNlwTQGQAAP91000168MEH5TiOfvKTn5guB5BEGAAA303fV/D6668rm80argYgDACA7x577DFt27ZNg4ODevPNN02XAxAGAMBv8Xhczz33nCS2GSIYWEAIAAYMDg5q69atyuVy+uCDD3T33XebLgkWozMAAAZcccUV+uY3vymJbYYwj84AABjy8ccf6/bbb1c8HldXV5eamppMlwRL0RkAAENuu+02ffGLX1SxWNShQ4dMlwOLEQYAwKAXX3xRknTo0CHl83nD1cBWhAEAMOjxxx9XU1OT+vr69Lvf/c50ObAUYQAADKqurtZ3v/tdSSwkhDksIAQAw/r6+rR9+3YVCgV99NFHuv32202XBMvQGQAAwzZv3qwnnnhCEt0BmEEYAIAAePHFF7Vz507dcuutpkuBhZgmAIAAcF1X6XxRnw5kdMOmVaqrqjRdEixCZwAAAiAWi6noSplCSS29SY1ni6ZLgkUIAwAQENmCI0kqlFwd7UupP8W5A/AHYQAAAiJXcs5/7Liu2gYm1DWSMVgRbEEYAICAyBWdSz7XNZrVyYEJOSzvgocIAwAQENPTBBcbSOXV2ptSoTT348BKEQYAICDm6gxMS+aKau5JKp0v+VgRbEEYAIAAcFz3smFAkrJFR829SY1mCj5VBVsQBgAgAPIlV4tZFVByXB3rS6kvmfO8JtiDMAAAAZAtLL7970o6PZhW+3BGnBuHciAMAEAALDRFMJdzY1l92j+hkkMgwMoQBgAgAJYTBiRpKF1Qa29y2V8PSIQBAAiE7AoG81S+pObepFI5jjDG8hAGACAAVvrOPl901NKb0lCanQZYOsIAAATASjoD0xzX1YlESufGsmWoCDYhDACAYY7rKl/GOf/24YxOD6Y5whiLRhgAAMPyRWdRZwwsRV8yp+OJCRXZaYBFIAwAgGHlmCKYy2imoJbe5JLOMICdCAMAYJiX2wLTUzsNxrPsNMD8CAMAYJhXnYFphZKro30pDaTynv4+CC/CAAAY5seBQY7r6uTAhLpGM57/XggfwgAAGOZ1Z2CmrpGs2gYm2GmAWQgDAGCYn2FAkvpTeR3tS6lQ4ghjTCIMAIBB5T5jYLHGs0U19yaVzrPTAIQBADDK5AVD2YKj5t6kRjMcYWw7wgAAGGT6tsGS4+pYIqW+ZM5oHTCLMAAABvm9XmAuriudHkyrfTgjl4WFViIMAIBBpjsDM50by+rT/gmVOMLYOoQBADAoCJ2BmYbSBbX2Jo0saoQ5hAEAMChInYFpqXxJ/+hNKpXjCGNbEAYAwKBsIXhhQJq8SbGlN6XhNDsNbEAYAABDHNdVPsAH/ziuqxOJlHrGs6ZLgccIAwBgSBCnCC7mSjozlNHpwTRHGEcYYQAADAna4sHL6UvmdDwxoSI7DSKJMAAAhuQCul5gPqOZglp6k8oWOMI4aggDAGBImDoD09L5kpp7U0qy0yBSCAMAYEguwIsHL6dQctTam9JAKm+6FJQJYQAADAnqtsLFcFxXJwcm1DWaMV0KyoAwAACGhGE3wUK6RrJqG5hgp0HIEQYAwICSE+wzBpaiP5XX0b6UChF5PjYiDACAAVHoCsw0ni2quTepdJ6dBmFEGAAAA8K6ePBysgVHzb1JjWY4wjhsCAMAYECYFw9eTslxdSyRUiKZM10KloAwAAAGRG2aYCbXlU4NptUxnJHLwsJQIAwAgAFhPHBoqbrHsvp0YEIljjAOPMIAABgQ5c7ATEMTBbX2JZW35PmGFWEAAAywoTMwLZUrqbk3qRRHGAcWYQAAfFZyXOv25OeKjlr7UhpOs9MgiAgDAOAzW6YILlZyXJ1IpNQznjVdCi5CGAAAn9kaBiTJlXRmKKPPhtIcYRwghAEA8JlN6wXm0zue04nEhIrsNAgEwgAA+IwwMGkkU1BLb5LXIwAIAwDgM5unCS6WzpfU3JNUkp0GRhEGAMBn2SKX+cxUKDlq7U1pcCJvuhRrEQYAwGd0Bi7luK4+7Z/Q2VF2GphAGAAAH02eMcCiufl0jmTUNjDBTgOfEQYAwEd0BRbWn8rrWF/KuoOZTCIMAICPWDm/OGPZopp7k8oUWF/hB8IAAPiIMLB42YKj5p6kRjMcYew1wgAA+IhpgqUpOq6OJVJKJHOmS4k0wgAA+IhthUvnutKpwbQ6hjNyWVjoCcIAAPgoV6AzsFzdY1mdHEirxBHGZUcYAAAf5VghvyKDE3m19iWVZ7qlrAgDAOATzhgoj1SupObepCbyTLmUC2EAAHzCToLyyRUdtfQmNZJmp0E5EAYAwCeEgfIqOa6OJ1LqGWenwUoRBgDAJzl2EpSdK+nMUFpnhtIcYbwChAEA8EmWnQSe6RnP6UT/BDsNlokwAAA+4cAhb42kC2ruTTIdswyEAQDwCWHAe+l8Sc09SSVzRdOlhAphAAB8wjtWfxRKjlp7UxqcyJsuJTQIAwDgg6Ljqsh8tm8c19Wn/RM6O5o1XUooEAYAwAdZruI1onMko1ODE+w0WABhAAB8wHoBcxLJvI71pVTgKOh5EQYAwAfcSWDWWLaolt6UMnRo5kQYAAAfcMaAeZnC5E6DsSxHGF+MMAAAPmCaIBiKjqujfSklkhxhPBNhAAB8wLbC4HBd6dRgWp0jGbksLJREGAAAXxAGgufsaFYnB9IcYSzCAAB4rlByGHACanAir6N9KeUtX+BJGAAAj7FeINiSuaKae5KayNu704AwAAAeIwwEX67oqKU3qZG0nTsNCAMA4DHWC4RDyXF1PJFS77h9Ow0IAwDgMToD4eFK+mworTNDaat2GhAGAMBjdAbCp2c8p+P9E9Ys/CQMAIDHCAPhNJIuqLk3acV/P8IAAHiMaYLwSudLaulJKpkrmi7FU4QBAPAQZwyEX77kqLU3pcGJvOlSPEMYAAAP0RWIBsd19Wn/hLrHsqZL8QRhAAA8ZMN8s006hjM6M5Q2XUbZEQYAwEN0BqJl4+pqbV1Xa7qMsoubLgAAoozOQDSsqq7U7g31WlcbzWEzms8KAAKCMBBu8YqYdqyv06Y11aqIxUyX4xnCAAB4iGmC8Nq8pkY71teqqjL6M+qEAQDwULZAGAibNTVx7d5QpzU19gyR9jxTAPBZoeTIseh8+7CrqqzQzvW12ri6WrEITwnMhTAAAB5hvUA4xCQ1ra3R9vV1ilfYFQKmEQYAwCOsFwi+dbVx7d5Qr1XVlaZLMYowAAAeoTMQXNXxCu1urNMVq6pNlxIIhAEA8AiLB4MnFpO2rqvV1nW1qrR0SmAuhAEA8AjTBMGyvr5KuxvrVFdl95TAXAgDAOARpgmCobaqQrsb69VYX2W6lMAiDACAR+gMmFURi2lbQ622rKuJ9OmB5UAYAAAP5DljwKgrVlVrZ2OdauPRPz2wHAgDAOABugJm1FdXandjnRrqmBJYCsIAAHiAnQT+qqyIaXtDrZrWMiWwHIQBAPAAiwf9s3F1tXaur1M1UwLLRhgAAA8wTeC91dWV2r2hXmtrGcpWilcQADxAZ8A78YqYdq6v06Y19l0o5BXCAAB4gM5A+cUkbVpTox3ra1VVyZRAOREGAMADhIHyWlMT154NdVpdw7DlBV5VACizfJEzBsqlurJCOxvrtHE1Fwp5iTAAAGXGeoGVi8Wkq9bWaltDreJcKOQ5wgAAlJnjuqqrqlS+5Kjk0CFYqoa6uHY31qu+mguF/BJzXXpZAOAVx3WVL7kqlBwVpn4+/2vHVb44+fP04zariVdoV2OdrljFlIDfCAMAEBCO66pYcidDwlzhYfrXU+EhKn97V8Ri2rKuRlvX1aqSKQEjCAMAEFLnA4Iz+fOcHQjHUb7oBnZBY2N9lXY11qmuiikBkwgDAGCBknPp1MSF7sPsDkTRh3UOdVWTFwqtr+dCoSAgDAAAZnHcCwFhsuMwva5h7mmLpQwiFbGYtjXUass6LhQKEsIAAGDZXNdVcSoo5KeCQnFqaqLgzA4Oa2ri2tVYpxouFAocwgAAAJYjngEAYDnCAAAAliMMAABgOcIAAACWIwwAAGA5wgAAAJYjDAAAYDnCAAAAliMMAABgOcIAAACWIwwAAGA5wgAAAJYjDAAAYDnCAAAAliMMAABgOcIAAACWIwwAAGA5wgAAAJYjDAAAYDnCAAAAliMMAABgOcIAAACWIwwAAGA5wgAAAJYjDAAAYDnCAAAAliMMAABgOcIAAACWIwwAAGA5wgAAAJYjDAAAYDnCAAAAliMMAABgOcIAAACWIwwAAGA5wgAAAJYjDAAAYDnCAAAAliMMAABgOcIAAACWIwwAAGC5/w8O2bnbkHMFRQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "xgi.draw_hyperedges(H, pos=pos)" + ] + }, + { + "cell_type": "markdown", + "id": "fda9915d", + "metadata": {}, + "source": [ + "Notice that this function returns a tuple `(ax, collections)` where `collections` is a tuple `(dyad_collection, edge_collection)`. The collections can be used to plot colorbars as we will see later." + ] + }, + { + "cell_type": "markdown", + "id": "49af5d85", + "metadata": {}, + "source": [ + "The color, linewidth, transparancy, and style of the hyperedges can all be customised, for example with single values:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c1b3d3a1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(,\n", + " (,\n", + " ))" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "xgi.draw_hyperedges(H, pos=pos, dyad_color=\"r\", dyad_lw=2, dyad_style=\"--\", edge_fc=\"g\", alpha=0.3)" + ] + }, + { + "cell_type": "markdown", + "id": "459442b1", + "metadata": {}, + "source": [ + "Or with multiple values:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "a48f696f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(,\n", + " (,\n", + " ))" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "xgi.draw_hyperedges(\n", + " H,\n", + " pos=pos,\n", + " dyad_color=[\"r\", \"b\", \"orange\"],\n", + " dyad_lw=[1, 2, 5],\n", + " edge_fc=[\"g\", \"grey\", \"purple\", \"coral\"],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "692f6eac", + "metadata": {}, + "source": [ + "## Arrays of floats and colormaps" + ] + }, + { + "cell_type": "markdown", + "id": "053f097c", + "metadata": {}, + "source": [ + "In XGI, you can easily color hyperedges according to an EdgeStat, or just an array or a dict with float values:" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "bfab69e9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAf8AAAGTCAYAAAAmxxufAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABT1ElEQVR4nO3de3wU5b0/8M/mtrnuEsBkkxAwkJBwC1fFRCy2BALlUFKtFmpPUFGPHOwPai0ePHJRoAGsx0s5JyCiqC0nLShYrVwiGiiHAOESDXcCgSSQC0SSTQK57vz+CLuw5LY7O7szu/N5+5pX3dnZ2WfXwmef7/PMMxpBEAQQERGRanjJ3QAiIiJyLYY/ERGRyjD8iYiIVIbhT0REpDIMfyIiIpVh+BMREakMw5+IiEhlGP5EREQqw/AnIiJSGYY/ERGRyjD8iYg82NKlS6HRaKy2hISELl+zefNmJCQkwN/fH8OGDcNXX31l9bwgCFi8eDEiIiIQEBCAlJQUnDt3zpkfQ5FWrlwJjUaD+fPnd3lcd9+nHBj+REQebsiQISgrK7Ns+/bt6/TY/fv3Y+bMmZg9ezaOHTuGtLQ0pKWl4fjx45ZjVq9ejXfffRdr167FwYMHERQUhNTUVDQ0NLji4yhCXl4e1q1bh8TExC6Ps+X7lIOGN/YhIvJcS5cuxbZt25Cfn2/T8b/85S9RX1+PL7/80rLvgQcewIgRI7B27VoIgoDIyEj87ne/w0svvQQAqKmpQXh4ODZu3IgZM2Y442MoSl1dHUaNGoX/+Z//wfLlyzFixAi8/fbbHR7b3fcpFx/Z3pmISEUaGhrQ1NQkybkEQYBGo7Hap9VqodVqOzz+3LlziIyMhL+/P5KSkpCRkYG+fft2eGxubi5efPFFq32pqanYtm0bAKCoqAjl5eVISUmxPK/X6zF27Fjk5ua6NPyl+k7t/T7nzp2LqVOnIiUlBcuXL+/y3N19n3Jh+BMROVlDQwMMEVGoqf5BkvMFBwejrq7Oat+SJUuwdOnSdseOHTsWGzduRHx8PMrKyvDaa6/hoYcewvHjxxESEtLu+PLycoSHh1vtCw8PR3l5ueV5877OjnGFhoYGBAQESHIue77PrKwsHD16FHl5eTadu7vvUy4MfyIiJ2tqakJN9Q9Yve4zBAQEOXSumzfrseDfHkFJSQl0Op1lf2e91ClTplj+PTExEWPHjkW/fv3wt7/9DbNnz3aoLXKSqooCtJXxbfk+S0pKMG/ePGRnZ8Pf31+y95cDw5+IyEUCAoIQEOhY+JvpdDqrsLJVjx49MHDgQBQWFnb4vMFgQEVFhdW+iooKGAwGy/PmfREREVbHjBgxwu72SOHukr09zNPebPk+jxw5gsrKSowaNcqyr7W1FXv37sWaNWvQ2NgIb29vq9d0933KhbP9iYhcRaORZnNAXV0dzp8/bxXcd0pKSsLu3but9mVnZyMpKQkAEBMTA4PBYHWM0WjEwYMHLce40t2XMYrZbDVhwgQUFBQgPz/fso0ZMwZPPPEE8vPz2wU/0P33KRf2/ImIPNhLL72EadOmoV+/frhy5QqWLFkCb29vzJw5EwCQnp6OqKgoZGRkAADmzZuH8ePH480338TUqVORlZWFw4cP47333gMAy3Xty5cvR1xcHGJiYrBo0SJERkYiLS3N5Z/P3gDviK0XvYWEhGDo0KFW+4KCgtCrVy/Lfnu/T7kw/ImIPFhpaSlmzpyJqqoq3HPPPRg3bhwOHDiAe+65BwBQXFwML6/bReDk5GRs2rQJr776Kl555RXExcVh27ZtVqG3YMEC1NfX47nnnkN1dTXGjRuHHTt2uP04uBTEfJ9y4HX+REROZjQaodfr8adPsh0e8795ox6/+deJqKmpETXm7ynM36mPj4/DY/4tLS2q+z7Z8ycichUJxuwdfr2HkaLsr0ac8EdERKQy7PkTEZHbYs9fHIY/EZGrsOwvOYa/OAx/IiJyWwx/cTjmT0REpDLs+RMRuRR7qVJiz18chj8Rkato4Hj2M+eseHl5SbK2v9qw7E9ERKQy7PkTEbkMu/5SY9lfHIY/EZGr8FI/yTH8xWHZn4iISGXY8yciIrfFnr84DH8iIpfhmL/UGP7isOxPRESkMuz5ExG5Cif8SY49f3EY/kRErsKqv+Q0Gg28vMQXsU0mk4StcR8MfyIil2H6S83Rnr9aqwYc8yciIlIZ9vyJiFyGPX+psecvDsOfiMhVmP2SY/iLw7I/ERGRyrDnT0TkMuz6S409f3EY/uSWTCaTQ5f3EMmC2S85hr84DH9yS2+88Qb+9Kc/YeTIkVZbv379VPuHmYjIVgx/cjuCABw9dgyXL1/G5cuX8eWXX1qeCw0NxYgRIzBixAjLD4KEhAT4+PD/6qQE7PpLzcvLi1VAEfg3IrkVQQBMArB23Xq8MPcF5Ocfw7FjbduJEydw/fp1fPvtt/j2228tr/H398ewYcOsKgTDhg1DYGCgjJ+EiKTAsr84DH9yG+bgFwCEhIRg3LhxeOihcZbnm5qacOLECeTn51t+EOTn56Ourg55eXnIy8uzHOvl5YWEhASMHDnSqkrQs2dPGT4ZEZFraQRBEORuBJEtTLfC30wDwLubap/JZML58+ctPwbMW2VlZYfH9+3bt908gj59+qi2d0DSMBqN0Ov1+NOW/QgIDHboXDdv1OE3v0hGTU0NdDqdRC10P+bvNDIy0uG1/a9cuaK675M9f3ILdwc/0FYBEISub3Lm5eWFuLg4xMXF4fHHH297nSCgrKzMqjpw7NgxXLhwAcXFxSguLsbnn39uOUevXr3aVQgGDhwIb29vJ3xS8mwc85cay/7iMPxJ8YQOgt/yHOz/q1Cj0SAyMhKRkZGYOnWqZX91dTW+++47qwrByZMnUVVVha+//hpff/215djAwEAkJiZaVQiGDh0Kf39/+z8gqYs6s8ZpGP7iMPxJ0QQBaO1iYEoQk/6d6NGjB8aPH4/x48db9jU0NOD48eNWVYLvvvsON27cwIEDB3DgwAHLsSEhIbh+/TorAkSkeAx/UqyuevyWY9B96d8R/v7+GDNmDMaMGWPZ19rainPnzrWbR9C/f38GP3WDZX+psecvDsOfFOnOmf3dHgvX/nXo7e2NhIQEJCQkYObMmQCAVpOAmhqjC1tB7onhLzVe5y8OvzFSHHuC33y8nNraqoFer5e3IURENmL4k+IIsD34LcfL9APAlqEJIguNRJtIK1euhEajwfz58zs95uGHH7aU0u/c7pwc++STT7Z7fvLkyeIb5oCO2mrvpkYs+5OidHRJny1cXfoHup+MSNSefGX/vLw8rFu3DomJiV0e99lnn6GpqcnyuKqqCsOHD8djjz1mddzkyZPx4YcfWh5rtVpR7XIUx/zFYfiTYjjSi5Zy1r+t78ceP7mLuro6PPHEE1i/fj2WL1/e5bF3r3KZlZWFwMDAduGv1WphMBgkbyu5Bsv+pAiO9qJdWfq3d04CkYVGI82GthXu7twaGxs7fdu5c+di6tSpSElJsbvJGzZswIwZMxAUFGS1PycnB2FhYYiPj8ecOXNQVVVl97mlwLK/OOz5k+yk6kW7ovPP4CeliI6Otnq8ZMkSLF26tN1xWVlZOHr0qNW9LWx16NAhHD9+HBs2bLDaP3nyZDzyyCOIiYnB+fPn8corr2DKlCnIzc2V5XJXtQa4Ixj+JCspw9TZpX8GPylJSUmJ1Vr0HY25l5SUYN68ecjOzha1+uSGDRswbNgw3H///Vb7Z8yYYfn3YcOGITExEQMGDEBOTg4mTJhg9/uQ67HsT7KROkydWfpn8JPS6HQ6q62j8D9y5AgqKysxatQo+Pj4wMfHB3v27MG7774LHx8ftLa2dnr++vp6ZGVlYfbs2d22pX///ujduzcKCwsd+kximK/zd2RTI/b8STb2XtJn6zml7vwz+EkqUowx2/P6CRMmoKCgwGrfU089hYSEBLz88stdlug3b96MxsZG/PrXv+72fUpLS1FVVYWIiAib2yYVzvYXh+FPshB7SV93nFH6d8aPFCJXCAkJwdChQ632BQUFoVevXpb96enpiIqKQkZGhtVxGzZsQFpaGnr16mW1v66uDq+99hoeffRRGAwGnD9/HgsWLEBsbCxSU1Od+4E6wPAXh+FPLufMy+SkXuvfWT9SiJSiuLi4Xen7zJkz2LdvH3bt2tXueG9vb3z//ff46KOPUF1djcjISEyaNAnLli2T7Vp/sh/Dn1zKFQvjSNX5Z/CT5BSwtH9OTk6XjwEgPj4eQicTaAICArBz507HGiEhR8ftO/ucno7hTy7jqoVxpCj9M/jJORSQ/h6GZX9x1DnNkVzOlZPmHJ31z9X7iMjTsedPTifHbHmxnX+u10/OxH6/9Fj2F4fhT04nx2x5MaV/Bj85HdNfciz7i8OyPzmVXGPn9pb+WeonIjVh+JPTyB2otr41F/Ehcl+uvrFPZmYmEhMTLSsrJiUlYfv27Z0ev3HjxnbvJ2apZamx7E9OoYQSui2lfwY/uZKrV/hTA1eP+ffp0wcrV65EXFwcBEHARx99hOnTp+PYsWMYMmRIh6/R6XQ4c+aM5bES/hsy/Elycvf4Le1A1wv+MPiJyF7Tpk2zerxixQpkZmbiwIEDnYa/RqOBwWBwRfNsxrI/SUppgdpZO5TWTiISR6qyv9FotNoaGxu7fe/W1lZkZWWhvr4eSUlJnR5XV1eHfv36ITo6GtOnT8eJEyck+/xiMfxJMkoM1I4qekpsJ6mJxsGN7iTVXf2io6Oh1+st2933OrhTQUEBgoODodVq8fzzz2Pr1q0YPHhwh8fGx8fjgw8+wOeff44///nPMJlMSE5ORmlpqVO+D1ux7E+SUeINcDoq/SuxnaQOGo3j951QwHCxokh1qV9JSQl0Op1lf1f3KYiPj0d+fj5qamqwZcsWzJo1C3v27OnwB0BSUpJVVSA5ORmDBg3CunXrsGzZMtHtdhTDnySh5OVw75z3p+R2EpF8zLP3beHn54fY2FgAwOjRo5GXl4d33nkH69at6/a1vr6+GDlyJAoLCx1qr6NY9ieHKWWCX2fMpX8GP5Hn0Wg0DpX8pZh5bzKZbJojALTNEygoKEBERITD7+sI9vzJIUq4pK87AoBWE0v9pABc4U9yrl7hb+HChZgyZQr69u2L2tpabNq0CTk5OZY7HaanpyMqKsoyZ+D111/HAw88gNjYWFRXV+ONN97ApUuX8Mwzz4husxQY/iSa0nv8FgJgAsdKichxlZWVSE9PR1lZGfR6PRITE7Fz505MnDgRAFBcXGy17sD169fx7LPPory8HKGhoRg9ejT279/f6QRBV2H4kyhuM2P+VvAD7DCR/DS3/nH0HHSbq3v+GzZs6PL5nJwcq8dvvfUW3nrrLXub5XQMf7KbOwX/nW3sasEfInJPjq7w58hr3Zk6PzU5xC0ulRPcpJ1ERDJgz5/s4hYz5jsJfhF3+SWSFif8SY639BWH4U82c4sJft30+Fn6J3kx/aXGsr846vzUZDd3uKSPpX4iItuw50/d8oQe/x2Hsd9EsuHyvtJj2V8chj91yV1m9tvT42fpn8hzMPzFYfhTp9wm+N2gjUQAr/N3Bo75i6POT002cYfxczHBr/TPRETkbOz5U4fc4ZI+R3r8LP2TLDjZX3Is+4vD8Kd23GmCHxGpG8v+4qjzU1On3OWSPlP3R3V3CiIi1WLPnyzU1uNn6Z9cjtf6SY5lf3EY/gTATWb2cxEf8gDqjBrnYfiLw7I/qTb4BbR9diIitWHPn5Tfm2aPn4g6odFoHJq0p9aeP8Nf5RR/SR+DnzwJL/WTHMv+4rDsr2KKn+DnguBn6Z+I1Ig9f5Vyh0v62OMnT8PlfaXH6/zFUeenVjnF9/jB9frJQ2kk2kRauXIlNBoN5s+f3+kxGzdutJTSzZu/v7/VMYIgYPHixYiIiEBAQABSUlJw7tw58Q1zwN1tFbOpEcNfZdxhZr+rg5+lf3Id+dI/Ly8P69atQ2JiYrfH6nQ6lJWVWbZLly5ZPb969Wq8++67WLt2LQ4ePIigoCCkpqaioaFBVNscYe75O7KpkTo/tUox+InUqa6uDk888QTWr1+P0NDQbo/XaDQwGAyWLTw83PKcIAh4++238eqrr2L69OlITEzExx9/jCtXrmDbtm1O/BQkJYa/iih+DJ3BT2Qzo9FotTU2NnZ67Ny5czF16lSkpKTYdO66ujr069cP0dHRmD59Ok6cOGF5rqioCOXl5Vbn0uv1GDt2LHJzc8V/IJFY9heH4a8S7nBJn6Pr9Tv49iz9k9OZV/d1dAOA6Oho6PV6y5aRkdHhe2ZlZeHo0aOdPn+3+Ph4fPDBB/j888/x5z//GSaTCcnJySgtLQUAlJeXA4BVNcD82PycKzH8xeFsfxVQ/AQ/mYOfyB2VlJRAp9NZHmu12g6PmTdvHrKzs9tN2utMUlISkpKSLI+Tk5MxaNAgrFu3DsuWLXO84aQIDH8Pp/hL+jyo1K/SDgTJRKfTWYV/R44cOYLKykqMGjXKsq+1tRV79+7FmjVr0NjYCG9v7y7P4evri5EjR6KwsBAAYDAYAAAVFRWIiIiwHFdRUYERI0aI/DTicZEfcVj292Du0ONX0jwElv7J2aQs+9tiwoQJKCgoQH5+vmUbM2YMnnjiCeTn53cb/EDbj4WCggJL0MfExMBgMGD37t2WY4xGIw4ePGhVMXAVlv3FYc/fQyl+Zr/Cgp/IE4WEhGDo0KFW+4KCgtCrVy/L/vT0dERFRVnmBLz++ut44IEHEBsbi+rqarzxxhu4dOkSnnnmGQCwrBOwfPlyxMXFISYmBosWLUJkZCTS0tJc+vlIPIa/B2LwiyeAS6eTMylvcf/i4mKra92vX7+OZ599FuXl5QgNDcXo0aOxf/9+DB482HLMggULUF9fj+eeew7V1dUYN24cduzYYfO8Aimx7C+ORhBY6PQ0ip7Zr+DgN9NA3Pi9l6ZtI7qb0WiEXq/Hhq9PIDAoxKFz3aivxeyUIaipqel2zN+Tmb/Tn//85/D19RV9nubmZmzdulV13yfH/D0Mg5+IiLrDsr8HUfoEP3cJfpb+yVnsnbDX2TnoNpb9xWH4ewilX9Lnbsv2CgL/kiVyBwx/cRj+HqDsag166gOh9fNtm+insKBVWnuI5KKB45eW8Za+1nhLX3HU+ak9xI2bTcg5dAZf557EpSs/wGQywUsDeHsB3hpllK7dNfjdsc1ERLZiz98NmUwmnLpQjqMni9HU3AIA+OeRczhy8hKGxEYiIcYAP18feGtkvuzPTYPfjKV/IuVj2V8chr+bKb9mxP5j53HdWN/uuRs3m5BXcBHfnS5BQowBQ2KjEBjgd+tHgAABGtdNCOR6/UTtcMKfc6g1wB3B8HcTNxuakHf8Is5dquz22KbmVnx/9jKOF15BbN8wDIuLQg9d4K3lRVzwI8DNe/xmnPVPRJ6K4a9wgiDg9IVyHD5xyVLit5XJJODsxQqcvViBvhE9MWxgFAy99ZYfAYBG+isEPOxafpb+iZSNZX9xGP4KVvlDLfYfO4+q6jqHz1Vc9gOKy35AWK8QJA7sg36RvQAAPlLOC/Cw4CeSGsv+0mP4i8PwV6CGxmYcPn4JZy6WS37uyqpafJ17CvqQAAyLi0Js3zB4e3tZJgcKYsfqPTT4WfonIk/E8FcQQWgr0x8+fgkNTc1Ofa+a2pvYd7Sw7QqBAZFI6B8BrZ9PW8/EHOS2VgM8NPjNWPon6Sjvxj7ujj1/cRj+CnHteh3255/H1R9qXfq+NxuacfjEJXx3phTxMQYMiY1EcKAWGgDCrX5vl0MCHh78RKRsDH9xGP4ya2xqxuETxTh9oUzWdjS3tOL4ucs4WXgF/aPvQeLAKITqgwAAXrd+BHRUDVBD8LP0T0SehuEvo3OXKnDo+4tOL/HbwyQIKCyuRGFxJfoYQpE4sA8i7tEDuBWAd0wQlG3xIBmw9E9S4IQ/6bHnLw7DXwY/1NRj/7HzqKgyyt2ULpWWX0dp+XX0Dg1G4sA+uDeq160/aLd+CAi4NTxARCQPhr84DH8XampuwdGTxTh5vgyC4D6Ree16Hb45eBohQf4YNjAKvXsEo1doCLw0t0vi7rqGv61Y+icpOBpU5nPQbQx/cRj+LnK++CoOFRThRkOT3E0Rrba+AfuPnYcGwFOPPAgvL40l9C3brV8AnvhDgKV/IvIUDH8nu268gdz88yi7WiN3UyTTFvKC9RCAeZ0Aze0qgKdXA4hIfuz5i8Pwd5Lm5lYcO12CE+euwCR43i1uOhq1MP8QEO7ePKQawNI/kfIw/MXxkrsBnqio9Bq2ZB9FwdlSjwx+AF3OWdBoAC8N4O0FeN/6X69b+9z9j5kbTdUgIifIzMxEYmIidDoddDodkpKSsH379i5fs3nzZiQkJMDf3x/Dhg3DV1995aLWdo7hL6Hq2hvY8c8T+Obgady42Sh3c5zKZGMKdvRDwFsjzTpnRO7GfKmfoxvdZu75O7LZo0+fPli5ciWOHDmCw4cP4yc/+QmmT5+OEydOdHj8/v37MXPmTMyePRvHjh1DWloa0tLScPz4cSk+vmgs+0ugpaUV+WdKUXDmssf29KVw57CAxk3nBrD0T6Qsri77T5s2zerxihUrkJmZiQMHDmDIkCHtjn/nnXcwefJk/P73vwcALFu2DNnZ2VizZg3Wrl0rut2OYvg76NKVKuR+dwH1Nzy7p383k0l8XHc2SdDkJnMDOOufyPMYjdbrrmi1Wmi12i5f09rais2bN6O+vh5JSUkdHpObm4sXX3zRal9qaiq2bdvmUHsdxfAXyVh3Ewe+K0JJ+Q9yN0UWUq1TcOcPAa87KgFqWj2Q1IMr/ElPqp5/dHS01f4lS5Zg6dKlHb6moKAASUlJaGhoQHBwMLZu3YrBgwd3eGx5eTnCw8Ot9oWHh6O8XPq7ttqD4W+nlpZWfH/2Mr4/U4pWk3pL/M6Y+NbRsIASqwEs/ZN4vKuf1KQK/5KSEuh0Osv+rnr98fHxyM/PR01NDbZs2YJZs2Zhz549nf4AUCKGvx2Ky37Age8uoLa+Qe6myE5wYhy7QzWApX8iz2KevW8LPz8/xMbGAgBGjx6NvLw8vPPOO1i3bl27Yw0GAyoqKqz2VVRUwGAwON5oB3C2vw1q6xvwde4pZO8/yeC/xVWXvN15tYDPrc0L7PsQURtXz/bviMlkQmNjx/O+kpKSsHv3bqt92dnZnc4RcBX2/LvQ2mpCwbnL+O50KVpaW+VujqLIcW8Cc0VA4yV/NYClfxKDY/7Sc/Vs/4ULF2LKlCno27cvamtrsWnTJuTk5GDnzp0AgPT0dERFRSEjIwMAMG/ePIwfPx5vvvkmpk6diqysLBw+fBjvvfee6DZLgeHfidKK68jNvwBj3U25m6JIct6YqKNhAZPp9oqCrsLSP5H8XB3+lZWVSE9PR1lZGfR6PRITE7Fz505MnDgRAFBcXAwvr9tF9eTkZGzatAmvvvoqXnnlFcTFxWHbtm0YOnSo6DZLgeF/l/qbjTj4XRGKLl+TuymKppSV7sw/BLy8b68XYDIB6p2KSUTOtGHDhi6fz8nJabfvsccew2OPPeakFonD8L/FZDLh+LkrOHaqhCV+Gzhzwp9Ydw4LeMH51QCW/slevKWv9Li2vzgMfwBXKquxP/8CampvyN0Ut+HIIj/O1lk1wBk/BFj6J5KfWgPcEaoO/xs3m3CooAjnS67K3RS3I+eYvz3u/iFgEm79r9wNIyKSkSrD32Qy4eT5Mhw9WYzmFpb4xXCT7Lei0bTdVEgQpBsWYOmfSF4s+4ujuvAvv2bE/mPncd1YL3dT3Jq79Pw7InU1gKV/shUv9ZMew18c1Szyc7OhCXsPn8U/9nzP4JeA+0a/NY15ASFvwPeO2w0TeaKVK1dCo9Fg/vz5nR6zfv16PPTQQwgNDUVoaChSUlJw6NAhq2OefPLJdgvlTJ482cmtJyl5fM9fEASculCOIycuoam5Re7meAx37vl3xjws4GVnNYClf3IHeXl5WLduHRITE7s8LicnBzNnzkRycjL8/f2xatUqTJo0CSdOnEBUVJTluMmTJ+PDDz+0PO7uDnjOwp6/OB4d/pU/1GL/sfOoqq6TuykexwOz38L8IwC4PSzQ3UqCAn8BkA3kutSvrq4OTzzxBNavX4/ly5d3eexf/vIXq8fvv/8+Pv30U+zevRvp6emW/VqtVvb16QGGv1geWfZvaGzGviOF+OLb7xj8TuKJPf+OmIcFfL0BHw2HBUg5jEaj1dbZ2vIAMHfuXEydOhUpKSl2v8+NGzfQ3NyMnj17Wu3PyclBWFgY4uPjMWfOHFRVVdl9bpKPR/X8BUHAmaIKHD5+EY0s8TuVWsL/TuYVO706qAao79sgudl6//msrCwcPXoUeXl5ot7n5ZdfRmRkpNUPh8mTJ+ORRx5BTEwMzp8/j1deeQVTpkxBbm4uvL29Rb2PWOz5i+Mx4X/1h1rsz7+Aa9dr5W6KKphUGP5m5mEBb9y+XNA8R6C5pRm+vr5yN5EUSgPHK0fm19ty//mSkhLMmzcP2dnZ8Pf3t/u9Vq5ciaysLOTk5Fi9fsaMGZZ/HzZsGBITEzFgwADk5ORgwoQJdr+PI7y8vKzW0hfzejVy+/BvbGrG4RPFOH2hTO6mkAqZ/944mpeHv//97xg6dCh++ctfytsoUi4J09+W+88fOXIElZWVGDVqlGVfa2sr9u7dizVr1qCxsbHTnvof//hHrFy5El9//XW3kwT79++P3r17o7Cw0OXhz56/OG4b/oIg4NylSuQVXERDU7PczVEdJS/vKwdfX19cu3YNJ0+elLspRBYTJkxAQUGB1b6nnnoKCQkJePnllzsN/tWrV2PFihXYuXMnxowZ0+37lJaWoqqqChEREZK0m5zPLcO/qroO+49dQOUPRrmboloqrvp3aODAgfDy8kJlZSWqqqrQq1cvuZtECqS59Y+j57BVSEhIu1vHBgUFoVevXpb9d99/ftWqVVi8eDE2bdqEe++9F+Xl5QCA4OBgBAcHo66uDq+99hoeffRRGAwGnD9/HgsWLEBsbCxSU1Md+mxisOcvjlsNdjQ1tyA3/wI+/+Y7Br/smP53CgwMxL333gsAOHXqlLyNIeXSSLRJqLi4GGVlt4dNMzMz0dTUhF/84heIiIiwbH/84x8BAN7e3vj+++/xs5/9DAMHDsTs2bMxevRo/POf/5TlWv+7FxsSs6mR2/T8Cy9V4lDBRdxsbJK7KQR1zvbvzqBBg3DhwgWcOnUK48aNk7s5RB26+37zdz++ePFil68PCAjAzp07pW0UuZzie/4/1NTjH3sKsOfwWQa/gjD72xs0aBAA4MyZMzCZeN9Aak+BHX+3x56/OIrt+Tc3t+LoqWKcKLzCXqYC8b9Je/feey/8/f1RX1+P4uJiyzAAETkPx/zFUWTPv6q6Dlt2HcHxc5cZMgrF/yzteXt7Iz4+HgDH/YlI2RQZ/rqgAGi81PlrzF3wR1nHzKV/hj91hiV/abHsL44iw9/X1xtJw/vL3QzqgsDZ/h0yh/+FCxfQ0NAgc2tIcTjoLzmGvziKDH8A6BfZC9GGnt0fSLLgIj8du+eee9CrVy+0trbi3LlzcjeHFEYj0T90G8NfHMWGPwAkjegPHxffJILIERqNBoMHDwbA0j8RKZeiwz8kyB8jBkV3fyC5HHv+nUtISADA8KcOsOwvOfb8xVF0+APAsLhI6EMC5W4G3YXR37n4+HhoNBqUl5fjhx9+kLs5pCDMfukx/MVRfPh7eXkheQQn/ykNZ/t3LigoCP369QMAnD59WubWEBG1p/jwB4DIsB6I7RsmdzPoDgz/rnHcn8g1NBoNvLy8RG/s+Svc/cPuhZ+vYhckVB1mf9fuvN6fS/2SmRQlarWGVWf4fYrjNuEf4O+HMUP6yd0MuoU9/67FxMRYlvotKSmRuzlERFbcJvwBIKG/Aff0DJG7GQRO+OuOt7c3Bg4cCIDj/kTOxJ6/OG4V/hqNBskjBqj2P5aSsOffPXPp/+TJkzK3hJRCo5Fmo9sY/uK4VfgDQO/QYAzqHyF3M1SP2d+9O5f6bWxslLk1RES3uV34A8DoIX0R6O8ndzNUjZPYuhcWFoaePXuipaWFS/0SOQl7/uK4Zfj7+fpgbGKM3M1QNXb8u6fRaHiXP7LCRX6kx/AXxy3DHwD6R9+DqLBQuZuhWhzztw3Dn+7E8Jcew18ctw1/oO3GP95ebv0R3Baz3zYJCQnQaDQoKytDdXW13M0hIgLg5uGvDwlAYnwfuZuhSuz52yYoKAh9+/YFwN4/gdP9O9Ha2or8/Hxcv37d7teqtefvaGfCrcMfAIbH90FIkL/czVAdhr/tWPonsjZ//nxs2LABQFvwjx8/HqNGjUJ0dDRycnLsOpcawn/VqlX461//ann8+OOPo1evXoiKisJ3330n6pxuH/7e3l5IHjlA7maoDrPfdneu88+rJIiALVu2YPjw4QCAL774AkVFRTh9+jR++9vf4j//8z9lbp3yrF27FtHRbbe3z87ORnZ2NrZv344pU6bg97//vahzun34A0Cf8FDERPWWuxmqInC+v81iYmKg1WpRV1eHy5cvy90ckpEGElT95f4QErh27RoMBgMA4KuvvsJjjz2GgQMH4umnn0ZBQYFd51JDz7+8vNwS/l9++SUef/xxTJo0CQsWLEBeXp6oc3pE+APAA8P7w9fHW+5mqAZ7/rbz8fGxLPXL0r+6cbZ/m/DwcJw8eRKtra3YsWMHJk6cCAC4ceMGvL3t+3vckTv6mTelCw0NtdwjZMeOHUhJSQHQNvza2toq6pzK/9Q2Cgzww2je+MdlBBPT3x4JCQkAGP5EAPDUU0/h8ccfx9ChQ6HRaCxhdvDgQcufFbrtkUcewa9+9StMnDgRVVVVmDJlCgDg2LFjiI2NFXVOj7pH7qD+Bpy9WIEfaurlbgqRFfO4f2FhIZqamuDnxxUq1csT+u6OWbp0KYYOHYqSkhI89thj0Gq1ANpuiPUf//Efdp3L0dK9O5T933rrLdx7770oKSnB6tWrERwcDAAoKyvDv//7v4s6p0eFv5eXFx4cFYsvvhU3+5FsZxI4cc0e4eHhCA0NxfXr11FYWGj5MUCkVr/4xS8AAA0NDZZ9s2bNsvs8agh/X19fvPTSS+32//a3vxV9To8KfwAI6xmC+BgDzhSVy90Uj8Yxf/uYl/rdv38/Tp06xfAnVWttbcUf/vAHrF27FhUVFTh79iz69++PRYsW4d5778Xs2bPlbqLs/v73v9t87M9+9jO7z+9x4Q8A9w3th0uXq9DQ1Cx3UzwWr/O3353hT+okxRo9btBR7daKFSvw0UcfYfXq1Xj22Wct+4cOHYq3337brvD31J5/Wlqa1WONRmP19+6d7RYz6c9jJvzdSevni/sT75W7GR6N2W8/81K/ly9fRk1NjdzNIRlwtn+bjz/+GO+99x6eeOIJq9n9w4cPx+nTp+06l6de6mcymSzbrl27MGLECGzfvh3V1dWorq7GV199hVGjRmHHjh2izu+RPX8AiOsXjrMXK1F+jX/JOgN7/vYLDg5GdHQ0iouLcfr0aYwdO1buJpGrSZHeyswqu1y+fLnDWeomkwnNzfZVbD2153+n+fPnY+3atRg3bpxlX2pqKgIDA/Hcc8+JqiZ6ZM/fLHnkAHhpPPojysbHh9+rGOalfk+ePClzS4jkM3jwYPzzn/9st3/Lli0YOXKkDC1StvPnz6NHjx7t9uv1ely8eFHUOT225w8AobpADB0Yie/PlMrdFLfi7+eLoEAtggO1CAzwQ3CAFkEBWgQFahEU4IegAD+3WBhDiQYNGoSdO3fi9OnTEATBLXodRFJbvHgxZs2ahcuXL8NkMuGzzz7DmTNn8PHHH+PLL7+0+3ye/ufovvvuw4svvohPPvkE4eHhAICKigr8/ve/x/333y/qnB4d/gAwMiEa50uuov5Go9xNUQStr8+tEL8d5sEBt0L+1n5vbwa7s/Tv3x9+fn4wGo24fPky+vThXSnVRHPrH0fP4e6mT5+OL774Aq+//jqCgoKwePFijBo1Cl988YVltT9bqaHs/8EHH+DnP/85+vbta1nmt6SkBHFxcdi2bZuoc3p8+Pv4eCNp+AB8nev5ZVY/X592PfXgQD8EBtwOeR8ugSwrX19fDBw4EMePH8epU6cY/uRSK1euxMKFCzFv3jy8/fbbnR63efNmLFq0CBcvXkRcXBxWrVqFn/70p5bnBUHAkiVLsH79elRXV+PBBx9EZmYm4uLibG7LQw89hOzsbEc+jiwyMjLw2Wef4fTp0wgICEBycjJWrVqF+Pj4Tl+zceNGPPXUU1b7tFqt1RoHXYmNjcX333+P7Oxsy4TIQYMGISUlRfSPF48PfwDoF9kT/SJ74dKVKrmbIpqPt3dbmN8KcktP3dyLD/CDn68q/nO6vYSEBEv429vLIfcm56V+eXl5WLduHRITE7s8bv/+/Zg5cyYyMjLwL//yL9i0aRPS0tJw9OhRDB06FACwevVqvPvuu/joo48QExODRYsWITU1FSdPnoS/v2tvse7qnv+ePXswd+5c3HfffWhpacErr7yCSZMm4eTJkwgKCur0dTqdDmfOnBH9vhqNBpMmTcKkSZPsel1nVJMWDwzvj8sV1WgReRMEZ/L28rKEeds4u/auUrwftH6+cjeTJHLnUr/Nzc3w9eV/W3Kuuro6PPHEE1i/fj2WL1/e5bHvvPMOJk+ebLlV7LJly5CdnY01a9Zg7dq1EAQBb7/9Nl599VVMnz4dQNule+Hh4di2bRtmzJjRbXtCQ0M7DD+NRgN/f3/ExsbiySefbNdb7oirw//uS+s2btyIsLAwHDlyBD/60Y+6fB/znQzFqK+vx549e1BcXIympiar5/7f//t/dp9PNeEfHKjFyEHRyDt+0aXv66Xxsgrx2z31W6X4QC38tfzLX00MBgN69OiB6upqFBYWWq4AILKH0Wi0eqzVai1r5N9t7ty5mDp1KlJSUroN/9zcXLz44otW+1JTUy1jy0VFRSgvL7fcjAdom3U+duxY5Obm2hT+ixcvxooVKzBlyhTLhLVDhw5hx44dmDt3LoqKijBnzhy0tLRYLQLkTPZ8n3cyr9nRs2fPLo+rq6tDv379YDKZMGrUKPzhD3/AkCFDbGrbsWPH8NOf/hQ3btxAfX09evbsiWvXriEwMBBhYWEM/+4MjYvEueJKVBtvSHI+jUaDwAA/BPnfMTPe3Hv390NQgBYB/r5uMaGEXMe81G9ubi5OnTrF8FcRKS/zN0/8MluyZAmWLl3a7visrCwcPXrU5vu+l5eXW2aUm4WHh6O8vNzyvHlfZ8d0Z9++fVi+fDmef/55q/3r1q3Drl278OmnnyIxMRHvvvtut+Hv6G15za+19fu8k8lkwvz58/Hggw9ahkQ6Eh8fjw8++ACJiYmoqanBH//4RyQnJ+PEiRM2zfv57W9/i2nTpmHt2rXQ6/U4cOAAfH198etf/xrz5s3r/kN2QFXh7+XlhQdHxuIfe7636fhAfz/LOHtgQFuY3x5n90Ogvx+DnUS5M/xJRSQc9C8pKYFOp7Ps7qiXWlJSgnnz5iE7O9vlY/Fd2blzJ1atWtVu/4QJE/C73/0OAPDTn/7Upjv8SVX2t+X7vNvcuXNx/Phx7Nu3r8vjkpKSkJSUZHmcnJyMQYMGYd26dVi2bFm375Ofn49169bBy8sL3t7eaGxsRP/+/bF69WrMmjULjzzySLfnuJuqwh8ADL11GNgvHCXl160ubzOX4AMDzD13X17LTk5jnhlcWloKo9Fo9ZcOkS10Ol23/785cuQIKisrMWrUKMu+1tZW7N27F2vWrEFjY6PV8rpA27BURUWF1b6KigrLeLX5fysqKhAREWF1zIgRI2xqe8+ePfHFF1+0uyvdF198YSmf19fXIyQkxKbzScGW7/NOL7zwAr788kvs3bvX7qt2fH19MXLkSBQWFtp8vDmPwsLCUFxcjEGDBkGv16OkpMSu9zZTXfgDwENjbL8chcgZdDodoqOjUVJSgtOnT4teqIPci6tX950wYQIKCgqs9j311FNISEjAyy+/3C74gbZe6u7duzF//nzLvuzsbEvPNSYmBgaDAbt377aEvdFoxMGDBzFnzhyb2rVo0SLMmTMH3377reX/+3l5efjqq6+wdu1ay3uOHz++23O5esKfIAj4zW9+g61btyInJwcxMTF2v2draysKCgqsLp/sysiRI5GXl4e4uDiMHz8eixcvxrVr1/DJJ590OdzQFVWGP5ESDBo0CCUlJTh16hTDXyVcHf4hISHtwiEoKAi9evWy7E9PT0dUVBQyMjIAAPPmzcP48ePx5ptvYurUqcjKysLhw4fx3nvvtb2/RoP58+dj+fLliIuLs1zqFxkZ2e5OdJ159tlnMXjwYKxZswafffYZgLZq2J49e5CcnAwAlvJ/d1wd/nPnzsWmTZvw+eefIyQkxDLPQa/XIyAgAED77/T111/HAw88gNjYWFRXV+ONN97ApUuX8Mwzz9j0nn/4wx9QW1sLoO2OiOnp6ZgzZw7i4uLwwQcf2NV+M4Y/kUwGDRqEXbt24dSpU1zqVy0UeGOf4uJiqyHO5ORkbNq0Ca+++ipeeeUVyypyd/6IWLBgAerr6/Hcc8+huroa48aNw44dO+yaV/Dggw/iwQcfdLj9Uk34s1VmZiYA4OGHH7ba/+GHH+LJJ58E0P47vX79Op599lmUl5cjNDQUo0ePxv79+y2X/XZnzJgxln8PCwsTfSe/O2kE3p6NSBbNzc343e9+h+bmZrz66quIioqSu0nkJEajEXq9HtkFlxAU4tj8jvpaIyYO64eamhq3mity96V0XbHlc5m/0z/96U+WHrcYN2/exG9+8xtFf59LlizB008/jX79+kl2Ts5oI5KJr6+vZTlUe+9hTu5JI9Hmjnr06IHQ0FCbNnuYy/6ObEr3+eefY8CAAZgwYQI2bdqExkbH71XD8CeSEW/xqzIqTv9vv/0W33zzDb755ht88MEHCAsLw4IFC7B161Zs3boVCxYsQHh4uN1j2GoI//z8fOTl5WHIkCGYN28eDAYD5syZY/PaDR3hmD+RjMzhf+7cOS71Sx7tzpn7r7/+Ov7rv/4LM2fOtOz72c9+hmHDhuG9997DrFmz5Giioo0cORIjR47Em2++iS+++AIffvghHnzwQSQkJGD27Nl48sknodfrbT4fe/5EMoqMjIRer0dzczPOnz8vd3PIyVTc8beSm5trNYnNbMyYMTh06JBd51JDz/9OgiCgubkZTU1NEAQBoaGhWLNmDaKjo/HXv/7V5vMw/IlkpNFokJCQAABc7U8l1B78QNtSuuvXr2+3//3332+3zG531BL+R44cwQsvvICIiAj89re/xciRI3Hq1Cns2bMH586dw4oVK+xa459lfyKZDR48GAcPHsSpU6fw85//XO7mEDndW2+9hUcffRTbt2/H2LFjAbTd2Ofs2bOW6/7ptmHDhuHUqVNITU3Fhg0bMG3atHYLNM2cOdOudf4Z/kQyM/f8S0pKUFtb69IlTYnk8NOf/hTnzp1DZmampeI1bdo0PP/883b3/F19nb8cHn/8cTz99NNdXg7cu3dvmEwmm8/J8CeSmU6nQ58+fVBaWorTp0/jvvvuk7tJ5CRSlJndpUzdnaKiIly8eBFlZWXYsmULoqKi8MknnyAmJgbjxo2z+TyuXuHPVe6+rfKbb77Z6bH/9V//Zff5Gf5ECjBo0CCUlpbi1KlTDH/yeJ9++in+9V//FU888QSOHTtmuW69pqYGf/jDH/DVV1/J3EL5HTt2zOrx0aNH0dLSYrkp2NmzZ+Ht7Y3Ro0eLOr/y6x1EKmC+5M+81C95Js72b7N8+XKsXbsW69evt7q89cEHH8TRo0ftPp8nTvb79ttvLdu0adMwfvx4lJaW4ujRozh69ChKSkrw4x//GFOnThV1foY/kQIMGDAAvr6+qK6uttwohDwQ0x8AcObMGfzoRz9qt1+v16O6utquc6lhtv+bb76JjIwMq9UPQ0NDsXz58i6HA7rC8CdSAD8/P8TGxgLgJX+ejNnfxmAwdHgv+3379qF///52ncs84c+RTemMRiOuXr3abv/Vq1ctd/uzl/I/NZFK3Fn6J/Jkzz77LObNm4eDBw9Co9HgypUr+Mtf/oKXXnoJc+bMkbt5ivPzn/8cTz31FD777DOUlpaitLQUn376KWbPno1HHnlE1Dk54Y9IIczhf/bsWS7166Gk6Ll7Qs//P/7jP2AymTBhwgTcuHEDP/rRj6DVavHSSy/hN7/5jV3n8tTZ/ndau3YtXnrpJfzqV79Cc3MzAMDHxwezZ8/GG2+8IeqcDH8ihYiKioJOp4PRaERRUREGDhwod5NIakx/AG2B+5//+Z/4/e9/j8LCQtTV1WHw4MEIDg4WdS5PD//AwED8z//8D9544w3LMuADBgxAUFCQ6HMy/IkUwrzU76FDh3Dq1CmGP3k8Pz8/DB48WO5muI2goCAkJiZKci6O+RMpiPkvQo77eyaNRP/QbWqY7e8M7PkTKYh5qd/i4mLU1dWJKoOScrHqLz01lP2dgT1/IgXR6/WIioqCIAg4c+aM3M0hIg/F8CdSGHPv/+TJkzK3hCTHC/0lp4br/J1BnZ+aSMHuHPfnUr+ehdkvPY75i8PwJ1KY2NhY+Pj44Pr166ioqJC7OUTkgRj+RArj5+eHAQMGAOCsf0/Dnr/02PMXh+FPpEC85M9DMf0lx/AXh+FPpEDmpX4LCwvR2toqc2tIKsx+6XHCnzi8zp9IgaKiovDcc8/hnugYeHt7y90cIvIw6vzJQ6RwXl5eSBw+AiX1wM1m9vw9hUYjzUa3sewvDsOfSKGaTQJaTQLOVNbDxEv+iDrE8BeH4U+kUC2tJgBAXVMrin64KXNriMiTcMyfSKGaTbd7+2XGRuj9fdA7yE/GFpGjpLgxD2/sY41r+4vD8CdSqOZW61L/uWs3EOTnjQBfTgAkMmP4i8OyP5FCNd8q+5u1mgSc5vg/EUmAPX8ihWoxtQ/5+qZWXKi6idjegTK0iBwlxWx9lXZUO6XRaBy6Vl+tPX+GP5FCNbV23MMvr22Ezt8HYcEc/3c3UizSo86o6hzL/uKw7E+kUC13lf3vdL7qBq//JyLRGP5ECtXcQdnfrNUk4FRlPVq7OIYUSIb1fTMzM5GYmAidTgedToekpCRs37690+MffvjhDq+Fnzp1quWYJ598st3zkydPtq9hEuF1/uKw7E+kUHfP9r/bjaZWXPjhJuI4/u825LjUr0+fPli5ciXi4uIgCAI++ugjTJ8+HceOHcOQIUPaHf/ZZ5+hqanJ8riqqgrDhw/HY489ZnXc5MmT8eGHH1oea7VaOz+JNFj2F4fhT6RQLabOy/5mFbVt1/9z/J86M23aNKvHK1asQGZmJg4cONBh+Pfs2dPqcVZWFgIDA9uFv1arhcFgkL7BdnL05jxqvbGPOj81kcIJgtBtz9+s8NoN3Gji+L/aGI1Gq62xsbHb17S2tiIrKwv19fVISkqy6X02bNiAGTNmICgoyGp/Tk4OwsLCEB8fjzlz5qCqqkrU5yB5MPyJFKijy/w6YxIEnL7K8X93IOWQf3R0NPR6vWXLyMjo9H0LCgoQHBwMrVaL559/Hlu3bsXgwYO7be+hQ4dw/PhxPPPMM1b7J0+ejI8//hi7d+/GqlWrsGfPHkyZMkWW209zzF8clv2JFMjWXr8Zx//dg5TX+ZeUlECn01n2dzXmHh8fj/z8fNTU1GDLli2YNWsW9uzZ0+0PgA0bNmDYsGG4//77rfbPmDHD8u/Dhg1DYmIiBgwYgJycHEyYMEHEpyJXY8+fSIGabRjvv1tFbSMq65q6P5A8gnn2vnnrKvz9/PwQGxuL0aNHIyMjA8OHD8c777zT5fnr6+uRlZWF2bNnd9uW/v37o3fv3igsLLT7c5A82PMnUiB7e/5mhdduINjPG4F+XP+fOmcymbqdI7B582Y0Njbi17/+dbfnKy0tRVVVFSIiIqRqos04218chj+RAokNf/P4//CIEHh7qfMvNSWTY4W/hQsXYsqUKejbty9qa2uxadMm5OTkYOfOnQCA9PR0REVFtZszsGHDBqSlpaFXr15W++vq6vDaa6/h0UcfhcFgwPnz57FgwQLExsYiNTXVkY8mCsNfHIY/kQKJKfub3WhqxfmqGxh4T1D3B5PHq6ysRHp6OsrKyqDX65GYmIidO3di4sSJAIDi4uJ2l7udOXMG+/btw65du9qdz9vbG99//z0++ugjVFdXIzIyEpMmTcKyZctku9af7MfwJ1KgFpE9f7PKuibo/X0QHsK/jNVuw4YNXT6fk5PTbl98fDyETu4eGRAQYKkaKAF7/uIw/IkUqKulfW11vuomQrQ+HP9XEglm+/POPtYY/uJwtj+RAokd87+TSeD6/0TUMYY/kQI1d3FHP3vcbG4b/yelkOHOPh6Oi/yIw7I/kQJJUfY3q6xrgs7fBwaO/8tOjtn+no5lf3HY8ydSIEcn/N3tQtVN1HP9f/JAru75Z2Rk4L777kNISAjCwsKQlpaGM2fOdPu6zZs3IyEhAf7+/hg2bBi++uorsR9ZEgx/IoVpNQkwdTLTWiyTIOA0x/+JHLZnzx7MnTsXBw4cQHZ2NpqbmzFp0iTU19d3+pr9+/dj5syZmD17No4dO4a0tDSkpaXh+PHjLmy5NY3Q2fUcRCSLm82tOFJqdMq57wn2Qzyv/3c5o9EIvV6P/AtXEBKi6/4FXaitNWJE/0jU1NRYre2vNubvdNeuXe3uOGiP+vp6TJo0SfT3efXqVYSFhWHPnj340Y9+1OExv/zlL1FfX48vv/zSsu+BBx7AiBEjsHbtWtFtdwR7/kQKY88d/ex1ta4J5bXd3/qVnMR8Zx9HN7KQquwv5hbJAFBTUwMA6NmzZ6fH5ObmIiUlxWpfamoqcnNzRX5qxzH8iRRGisv8unKh6ibqGluc+h5E7saeWySbmUwmzJ8/Hw8++CCGDh3a6XHl5eUIDw+32hceHo7y8nKH2y0WZ/sTKYxUl/l1xiQIOHP1BoZHhsCH6/+7FGf7S0+q2f723CLZbO7cuTh+/Dj27dsn+v3lwvAnUhhnlv3Nbja3ovDaDSSEcfyf3JtU4W++NbKtXnjhBXz55ZfYu3cv+vTp0+WxBoMBFRUVVvsqKipgMBjsb7BEWPYnUpgmJ5f9za7VN6HMyPF/InsIgoAXXngBW7duxTfffIOYmJhuX5OUlITdu3db7cvOzkZSUpKzmtkt9vyJFKbFgTv62avoh5sI0XojWMu/ClyBZX/ncOVCPXPnzsWmTZvw+eefIyQkxDJur9frERAQAKD9bZLnzZuH8ePH480338TUqVORlZWFw4cP47333nNZu+/Gnj+Rwjh7wt+dTIKA01frXTLUQLdwZV9JuXqRn8zMTNTU1ODhhx9GRESEZfvrX/9qOaa4uBhlZWWWx8nJydi0aRPee+89DB8+HFu2bMG2bdu6nCTobPy5T6Qwrgx/AGhoNnH8n8hGtiyN09Ftkh977DE89thjTmiROAx/IoVpdmHZ3+xafROuGH0QqeP6/87Esr/0uLa/OAx/IoVxdc/frOiHG9Bx/J/cDMNfHI75EymISRBkW39fEMDxfyfTSPQPkaMY/kQKIvXd/OzV0GzCuWud36CEiDwDw59IQZoV0Ouuqm/GFWOD3M0gsomrZ/t7Cg7uESmIs5f2tVXb9f8+COH4v6Q44U96HPMXhz1/IgWRa7Lf3QQBOFNZr5gfI0QkLYY/kYIooexv1tDSdv0/ScjRBX640E87LPuLw5oekYK0KKynXXWjGZdrGhCl95e7KR6BZX/psewvDnv+RAriqpv62OPi9ZuobWyRuxlEJCGGP5GCKPEae0EATnP8XyKs+0uNZX9xGP5ECqLUgG1sMeEcx/8dptFIs9FtDH9xGP5ECqKkCX93++HW+D8RuT9O+CNSELlX+OvOxett1//r/PlXBykDJ/yJw54/kYLIcUc/ewgCcOYqx//F4oi/9Fj2F4fhT6QQza0m2HCrcNk1tphw9toNm+5rTkTKxPAnUgglzvTvzPUbzbhsbJS7GUQkEgfuiBRCKUv72urSrfX/9Rz/txkX+ZEex/zFYc+fSCHcbRxdAMf/7cdRf6lxzF8chj+RQij5Mr/ONLWYcPYqx/+J3A3Dn0gh3K3sb3b9ZjNKazj+bws5FvnJzMxEYmIidDoddDodkpKSsH379k6P37hxY7uesb+/9b0dBEHA4sWLERERgYCAAKSkpODcuXNivhKHsecvDsOfSCHcacLf3Yqv30RNA9f/V6I+ffpg5cqVOHLkCA4fPoyf/OQnmD59Ok6cONHpa3Q6HcrKyizbpUuXrJ5fvXo13n33XaxduxYHDx5EUFAQUlNT0dDg+kWgGP7icKYOkUK489i5AOBMZT1GRIXAz5t9CiWZNm2a1eMVK1YgMzMTBw4cwJAhQzp8jUajgcFg6PA5QRDw9ttv49VXX8X06dMBAB9//DHCw8Oxbds2zJgxQ9oPQE7BP6VECuGuZX+zplaO/3dHyul+RqPRamts7H7opbW1FVlZWaivr0dSUlKnx9XV1aFfv36Ijo5uVyUoKipCeXk5UlJSLPv0ej3Gjh2L3NxcW78KybDnLw7Dn0ghlL66ny2qOf7vMtHR0dDr9ZYtIyOj02MLCgoQHBwMrVaL559/Hlu3bsXgwYM7PDY+Ph4ffPABPv/8c/z5z3+GyWRCcnIySktLAQDl5eUAgPDwcKvXhYeHW55zJYa/OCz7EymE0tf1t1Xx9ZsI0XqjR4Cv3E3xaCUlJdDpdJbHWq2202Pj4+ORn5+PmpoabNmyBbNmzcKePXs6/AGQlJRkVRVITk7GoEGDsG7dOixbtkzaD0GyYc+fSCGaPCT8BQBnr95AkxvPYXAaCev+5tn75q2r8Pfz80NsbCxGjx6NjIwMDB8+HO+8845NTfb19cXIkSNRWFgIAJa5ABUVFVbHVVRUdDpPgJSH4U+kAK0mASYPGitvG/+v5/j/XTQS/eMok8lk0xwBoG2eQEFBASIiIgAAMTExMBgM2L17t+UYo9GIgwcPdjmPwJlY8rcfy/5ECuCOC/x0p/pmC0pqGtC3R4DcTVG1hQsXYsqUKejbty9qa2uxadMm5OTkYOfOnQCA9PR0REVFWeYMvP7663jggQcQGxuL6upqvPHGG7h06RKeeeYZAG1BO3/+fCxfvhxxcXGIiYnBokWLEBkZibS0NJd/Pi7vKw7Dn0gBWjy0RF58vQE6rQ/H/2VUWVmJ9PR0lJWVQa/XIzExETt37sTEiRMBAMXFxfDyul0Evn79Op599lmUl5cjNDQUo0ePxv79+63mByxYsAD19fV47rnnUF1djXHjxmHHjh3tFgMi5dIIrMsRye76zWacKK+TuxlO4evthZGRIfDzUe8oo9FohF6vR2HJVYTcMUlPjFqjEbHR96CmpsZqwp/amL/TY8eOISQkRPR5amtrMXLkSNV9n+r900ikIO5+jX9XmltNOMPxf3ISXuonDsOfSAFaPOAa/67UNLSguNr1S78SUcc45k+kAJ7c8zcrqW6A3l/d4/9S3JBXnf3UznHCnzjs+RMpgBrCHwDOXL2BphbPrnJ0Scr1fQkAy/5iMfyJFMATlva1hXn835PWNCByRwx/IgVQS88faBv/L1Hp+D87/qQUHPMnUgA1hT/QNv6v8/dBqIrH/0kaHPMXhz1/IgXw9Nn+HTl7tR6Nah7/J5IRw59IZoIgqK7nD7RVOzj+T47ihD9xGP5EMmvxwHX9bWVsaEHxdRWN/3PQnxSCY/5EMlNjr/9OpTVt1/+HBnr++D+v85cex/zFYc+fSGZqucyvK2ev1aOB4/9ELsPwJ5KZ2nv+wK3x/0qO/5P9OOYvDsOfSGYtDH8AQG1jCy55/Pg/B/2lxvAXh+FPJLMmlv0tLtc04IcbzXI3g8jjMfyJZMaev7WzVz17/J99flIChj+RzJpVfKlfR1pMHP8n27HsLw7Dn0hmnPDXnjrG/4nkw+v8iWTW0uq5JW5HXK5pW/+/lydd/88L/SXH6/zFYc+fSGZNLPt36pyHj/+T41j2F4fhTyQzTvjrHMf/SWn27t2LadOmITIyEhqNBtu2bevy+JycnA5/cJSXl7umwZ1g+BPJqNUkMNi6UdvYgos/3JS7GZLgVf7ur76+HsOHD8d///d/2/W6M2fOoKyszLKFhYU5qYW24Zg/kYyaOd5vkyvGRuj9fdAryE/uppDCuHrMf8qUKZgyZYrd7xMWFoYePXrY/TpnYc+fSEa8zM9212+2yN0Ex7HrLzmpxvyNRqPV1tjYKGk7R4wYgYiICEycOBH/93//J+m5xWD4E8mIl/nZJlKnxYBeAXI3gzxYdHQ09Hq9ZcvIyJDkvBEREVi7di0+/fRTfPrpp4iOjsbDDz+Mo0ePSnJ+sVj2J5IRy/7d6xvqj749PCP4Nbf+cfQcJL2SkhLodDrLY61WK8l54+PjER8fb3mcnJyM8+fP46233sInn3wiyXuIwfAnklELy/5d6t8rEJE6af4SJs8k1Zi/TqezCn9nuv/++7Fv3z6XvFdnGP5EMmLZv2MaDRDXOwhhwZzgR54nPz8fERERsraB4U8ko2be0a8dL40GCWFB6OlJK/uR07h6tn9dXR0KCwstj4uKipCfn4+ePXuib9++WLhwIS5fvoyPP/4YAPD2228jJiYGQ4YMQUNDA95//31888032LVrl+g2S4HhTyQj9vyteXtpMDg8GHp//tVEtnF1+B8+fBg//vGPLY9ffPFFAMCsWbOwceNGlJWVobi42PJ8U1MTfve73+Hy5csIDAxEYmIivv76a6tzyEEjCFxhhEgu312pRW2jB1zCJgFfby8MNQQjyM9b7qZIzmg0Qq/X41JZlcPjykajEf0ieqGmpsZlY9RKZP5Oi4qKEBISIvo8tbW1iImJUd33yZ/XRDLihL82/j5eGGIIRoCv5wX/nXhfH1IKhj+RjJp4qR8C/bwxNDwYfj4qWHaE6e8Uar05jyMY/kQyMQkCWlXe8w/R+mBweBB8vVUQ/EQKwvAnkona7+bXI8AXg8KC4O2lnl4bO/7Sc/WEP0/Bn9tEMlHzuv69g/wwOFxdwS+XzMxMJCYmWhaxSUpKwvbt2zs9fv369XjooYcQGhqK0NBQpKSk4NChQ1bHPPnkk+3Wx588ebKzPwpJiOFPJBO1Lu1rCNEi/p5AeKm0x+Vqffr0wcqVK3HkyBEcPnwYP/nJTzB9+nScOHGiw+NzcnIwc+ZMfPvtt8jNzUV0dDQmTZqEy5cvWx03efJkq1vU/u///q8rPk47Ut3YR21Y9ieSiRpn+kf38Ee/UM9Yp99dTJs2zerxihUrkJmZiQMHDmDIkCHtjv/LX/5i9fj999/Hp59+it27dyM9Pd2yX6vVwmAwOKfR5HTs+RPJpEllY/4xPQMY/BLe0lfMLWhbW1uRlZWF+vp6JCUl2dTkGzduoLm5GT179rTan5OTg7CwMMTHx2POnDmoqqqy6XxSY89fHIY/kUxaVFL21wCI6x2IKL2/3E2RnYTZb9ctaAsKChAcHAytVovnn38eW7duxeDBg21q88svv4zIyEikpKRY9k2ePBkff/wxdu/ejVWrVmHPnj2YMmUKWltb7fg2SE4s+xPJRA0T/rw0GsTfE4heQbxBj9TsuQVtfHw88vPzUVNTgy1btmDWrFnYs2dPtz8AVq5ciaysLOTk5MDf//aPtxkzZlj+fdiwYUhMTMSAAQOQk5ODCRMmOPCpyFXY8yeSiaev69+2Tn8Qg99JzLP3zVtX4e/n54fY2FiMHj0aGRkZGD58ON55550uz//HP/4RK1euxK5du5CYmNjlsf3790fv3r2tbnjjKiz7i8OeP5FMPHm2v6+3BkPCgxGs5V8x1pRxpb/JZOpyjsDq1auxYsUK7Ny5E2PGjOn2fKWlpaiqqpL9NrVkO/7JJJKJp5b9tT5eGBIejEAPvEGPO1q4cCGmTJmCvn37ora2Fps2bUJOTg527twJAEhPT0dUVJRlzsCqVauwePFibNq0Cffeey/Ky8sBAMHBwQgODkZdXR1ee+01PProozAYDDh//jwWLFiA2NhYpKamyvY5yT4MfyKZeOIKfwG+3hhiCIa/GtbpF0GOfn9lZSXS09NRVlYGvV6PxMRE7Ny5ExMnTgQAFBcXw8vr9n+vzMxMNDU14Re/+IXVeZYsWYKlS5fC29sb33//PT766CNUV1cjMjISkyZNwrJly7ocenAWrvAnDsOfSCbNJs8q+wdrvTEkPJjr9CvMhg0bunw+JyfH6vHFixe7PD4gIMBSNSD3xfAnkkGLSYDgQR1/vb8PBocHc7leIjfB8CeSgQbAwHuC0NDcioYWE242m9DQ0uqWVwD0CvRFfFgQl+u1hTLm+3kUlv3FYfgTycDbS4Ow4PaXwLWYhLt+EJgsjxtblDdMEB7ihwG9uE4/kbth+BMpiI+XBsFaHwR3MG/KJAhouPWD4OatHwTmxw0trS4fRojS+yOmp8qX67UTO/7SY89fHIY/kZvw0mgQ6Od96xI6X6vnTIKAphZTu4rBzVs/EEwS/zLoFxqA6B5crpfIXTH8iTyAl0YDf19v+Pt6o0cHnfGmFtOtHwLWcwwamk12310wtlcgDDrXX9JFRNJh+BOpgJ+PF/x8vKD3b/9HvrnVZBlCuHnrB4H5cdMdqxBqNED8PUHozeV6RdNo2jZHz0G3sewvDsOfSOV8vb3g6+2FkA46860mwTKE4OvtBV0HPx6IyP3wTzIRdcrbS4MgP28EcaleiXDKHykDw5+IiNwWy/7icB1OIiIilWH4ExERqQzL/kRELsIRf+mx7C8Oe/5EREQqw/AnIiJSGZb9iYhchXV/UgiGPxGRizD7pccxf3FY9iciIlIZhj8REZHKsOxPRERui2V/cdjzJyIiUhn2/ImIXIS39CWlYPgTEZHbYtlfHJb9iYiIVIbhT0REpDIs+xMRuYjm1j+OnoNuY9lfHPb8iYiIVIbhT0REpDIs+xMRkdti2V8chj8Rkavwzj6kECz7ExERqQx7/kRELsKOv/RY9heHPX8iIiKVYfgTERGpDMv+REQuwrK/9Fj2F4fhT0TkKkx/UgiW/YmIPFhmZiYSExOh0+mg0+mQlJSE7du3d/mazZs3IyEhAf7+/hg2bBi++uorq+cFQcDixYsRERGBgIAApKSk4Ny5c878GIqxd+9eTJs2DZGRkdBoNNi2bVu3r8nJycGoUaOg1WoRGxuLjRs3Or2d3WH4ExG5jEaizXZ9+vTBypUrceTIERw+fBg/+clPMH36dJw4caLD4/fv34+ZM2di9uzZOHbsGNLS0pCWlobjx49bjlm9ejXeffddrF27FgcPHkRQUBBSU1PR0NBgV9ukYC77O7LZo76+HsOHD8d///d/23R8UVERpk6dih//+MfIz8/H/Pnz8cwzz2Dnzp1iPq50BCIicqqamhoBgFB1vUZobhUc2qqut52rpqZGdHtCQ0OF999/v8PnHn/8cWHq1KlW+8aOHSv827/9myAIgmAymQSDwSC88cYbluerq6sFrVYr/O///q/oNtnL/J068j04eh4AwtatW7s8ZsGCBcKQIUOs9v3yl78UUlNT7X4/KXHMn4jIRYxGo2TnuPtcWq0WWq22y9e2trZi8+bNqK+vR1JSUofH5Obm4sUXX7Tal5qaailvFxUVoby8HCkpKZbn9Xo9xo4di9zcXMyYMcPej+QQR79TR75PW+Tm5lp9V0Db9zl//nyHz+0Ihj8RkZP5+fnBYDAgpl+0JOcLDg5GdLT1uZYsWYKlS5d2eHxBQQGSkpLQ0NCA4OBgbN26FYMHD+7w2PLycoSHh1vtCw8PR3l5ueV5877OjnEF83d69/cghr3fpz06+z6NRiNu3ryJgIAAh99DDIY/EZGT+fv7o6ioCE1NTZKcTxCEdmPVXfVS4+PjkZ+fj5qaGmzZsgWzZs3Cnj17Ov0B4A6k/E7t/T49AcOfiMgF/P394e/vL8t7+/n5ITY2FgAwevRo5OXl4Z133sG6devaHWswGFBRUWG1r6KiAgaDwfK8eV9ERITVMSNGjHDSJ+iYnN+prTr7PnU6nWy9foCz/YmIVMdkMqGxsbHD55KSkrB7926rfdnZ2ZY5AjExMTAYDFbHGI1GHDx4sNN5BGrW3fcpF/b8iYg82MKFCzFlyhT07dsXtbW12LRpE3JyciyXmqWnpyMqKgoZGRkAgHnz5mH8+PF48803MXXqVGRlZeHw4cN47733ALRdWjd//nwsX74ccXFxiImJwaJFixAZGYm0tDS5PqbL1NXVobCw0PK4qKgI+fn56NmzJ/r27YuFCxfi8uXL+PjjjwEAzz//PNasWYMFCxbg6aefxjfffIO//e1v+Mc//iHXR2gj67UGRETkVE8//bTQr18/wc/PT7jnnnuECRMmCLt27bI8P378eGHWrFlWr/nb3/4mDBw4UPDz8xOGDBki/OMf/7B63mQyCYsWLRLCw8MFrVYrTJgwQThz5owrPo7svv32WwFAu838Hc6aNUsYP358u9eMGDFC8PPzE/r37y98+OGHLm/33TSCIAiy/vogIiIil+KYPxERkcow/ImIiFSG4U9ERKQyDH8iIiKVYfgTERGpDMOfiIhIZRj+REREKsPwJyIiUhmGPxERkcow/ImIiFSG4U9ERKQy/x+4y3o+n77hNAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax, (dyad_collection, edge_collection) = xgi.draw_hyperedges(\n", + " H,\n", + " pos=pos,\n", + " dyad_color=[3, 1, 4],\n", + " edge_fc=H.edges.size,\n", + ")\n", + "\n", + "plt.colorbar(dyad_collection, label=\"dyads\")\n", + "plt.colorbar(edge_collection, label=\"edges\")" + ] + }, + { + "cell_type": "markdown", + "id": "c452196b", + "metadata": {}, + "source": [ + "By default, the colormaps used are \"Blues\" and \"Greys\". These can be changed:" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "7400903b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax, (dyad_collection, edge_collection) = xgi.draw_hyperedges(\n", + " H,\n", + " pos=pos,\n", + " dyad_color=[3, 1, 4],\n", + " edge_fc=H.edges.size,\n", + " dyad_color_cmap=\"viridis\",\n", + " edge_fc_cmap=\"tab10\"\n", + ")\n", + "\n", + "plt.colorbar(dyad_collection, label=\"dyads\")\n", + "plt.colorbar(edge_collection, label=\"edges\")" + ] + }, + { + "cell_type": "markdown", + "id": "d2e165ab", + "metadata": {}, + "source": [ + "You can specify a `vmin` and `vmax` for the dyad and edge colors:" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "e089d4be", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax, (dyad_collection, edge_collection) = xgi.draw_hyperedges(\n", + " H,\n", + " pos=pos,\n", + " dyad_color=[3, 1, 4],\n", + " edge_fc=H.edges.size,\n", + " dyad_vmin=1.5,\n", + " edge_vmax=4.5\n", + ")\n", + "\n", + "plt.colorbar(dyad_collection, label=\"dyads\")\n", + "plt.colorbar(edge_collection, label=\"edges\")" + ] + }, + { + "cell_type": "markdown", + "id": "81df5a5f", + "metadata": {}, + "source": [ + "## Combine with nodes" + ] + }, + { + "cell_type": "markdown", + "id": "b8ffdbfa", + "metadata": {}, + "source": [ + "This can be either via `xgi.draw()`:" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "bf32fddc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax, collections = xgi.draw(\n", + " H,\n", + " pos=pos,\n", + " node_fc=H.nodes.degree,\n", + " dyad_color=[3, 1, 4],\n", + " edge_fc=H.edges.size,\n", + ")\n", + "\n", + "(node_collection, dyad_collection, edge_collection) = collections\n", + "plt.colorbar(node_collection, label=\"nodes\")\n", + "plt.colorbar(dyad_collection, label=\"dyads\")\n", + "plt.colorbar(edge_collection, label=\"edges\")\n", + "\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "785a23b5", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv_xgi", + "language": "python", + "name": "venv_xgi" + }, + "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.13" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/xgi/drawing/draw.py b/xgi/drawing/draw.py index c208f26cd..6307e8e0c 100644 --- a/xgi/drawing/draw.py +++ b/xgi/drawing/draw.py @@ -49,17 +49,26 @@ def draw( H, pos=None, ax=None, - dyad_color="black", - dyad_lw=1.5, - edge_fc=None, node_fc="white", node_ec="black", node_lw=1, node_size=15, node_shape="o", max_order=None, + dyad_color="black", + dyad_lw=1.5, + dyad_style="solid", + dyad_color_cmap="Greys", + dyad_vmin=None, + dyad_vmax=None, + edge_fc=None, + edge_fc_cmap="Blues", + edge_vmin=None, + edge_vmax=None, + alpha=0.4, node_labels=False, hyperedge_labels=False, + rescale_sizes=True, aspect="equal", **kwargs, ): @@ -75,24 +84,6 @@ def draw( the positions. ax : matplotlib.pyplot.axes, optional Axis to draw on. If None (default), get the current axes. - dyad_color : str, dict, iterable, or EdgeStat, optional - Color of the dyadic links. If str, use the same color for all edges. If a dict, - must contain (edge_id: color_str) pairs. If iterable, assume the colors are - specified in the same order as the edges are found in H.edges. If EdgeStat, use - a colormap (specified with dyad_color_cmap) associated to it. By default, - "black". - dyad_lw : int, float, dict, iterable, or EdgeStat, optional - Line width of edges of order 1 (dyadic links). If int or float, use the same - width for all edges. If a dict, must contain (edge_id: width) pairs. If - iterable, assume the widths are specified in the same order as the edges are - found in H.edges. If EdgeStat, use a monotonic linear interpolation defined - between min_dyad_lw and max_dyad_lw. By default, 1.5. - edge_fc : str, dict, iterable, or EdgeStat, optional - Color of the hyperedges. If str, use the same color for all nodes. If a dict, - must contain (edge_id: color_str) pairs. If other iterable, assume the colors - are specified in the same order as the hyperedges are found in H.edges. If - EdgeStat, use the colormap specified with edge_fc_cmap. If None (default), use - the H.edges.size. node_fc : str, dict, iterable, or NodeStat, optional Color of the nodes. If str, use the same color for all nodes. If a dict, must contain (node_id: color_str) pairs. If other iterable, assume the colors are @@ -120,6 +111,24 @@ def draw( marker. Default is "o". max_order : int, optional Maximum of hyperedges to plot. If None (default), plots all orders. + dyad_color : str, dict, iterable, or EdgeStat, optional + Color of the dyadic links. If str, use the same color for all edges. If a dict, + must contain (edge_id: color_str) pairs. If iterable, assume the colors are + specified in the same order as the edges are found in H.edges. If EdgeStat, use + a colormap (specified with dyad_color_cmap) associated to it. By default, + "black". + dyad_lw : int, float, dict, iterable, or EdgeStat, optional + Line width of edges of order 1 (dyadic links). If int or float, use the same + width for all edges. If a dict, must contain (edge_id: width) pairs. If + iterable, assume the widths are specified in the same order as the edges are + found in H.edges. If EdgeStat, use a monotonic linear interpolation defined + between min_dyad_lw and max_dyad_lw. By default, 1.5. + edge_fc : str, dict, iterable, or EdgeStat, optional + Color of the hyperedges. If str, use the same color for all nodes. If a dict, + must contain (edge_id: color_str) pairs. If other iterable, assume the colors + are specified in the same order as the hyperedges are found in H.edges. If + EdgeStat, use the colormap specified with edge_fc_cmap. If None (default), use + the H.edges.size. node_labels : bool or dict, optional If True, draw ids on the nodes. If a dict, must contain (node_id: label) pairs. By default, False. @@ -166,21 +175,14 @@ def draw( settings = { "min_node_size": 5, "max_node_size": 30, - "min_dyad_lw": 2.0, - "max_dyad_lw": 10.0, + "min_dyad_lw": 1, + "max_dyad_lw": 10, "min_node_lw": 0, "max_node_lw": 5, - "node_fc_cmap": cm.Reds, - "node_ec_cmap": cm.Greys, - "edge_fc_cmap": cm.Blues, - "dyad_color_cmap": cm.Greys, } settings.update(kwargs) - if edge_fc is None: - edge_fc = H.edges.size - ax, pos = _draw_init(H, ax, pos) if not max_order: @@ -200,16 +202,25 @@ def draw( **kwargs, ) elif isinstance(H, Hypergraph): - draw_hyperedges( - H, - pos, - ax, - dyad_color, - dyad_lw, - edge_fc, - max_order, - settings, - hyperedge_labels, + + ax, (dyad_collection, edge_collection) = draw_hyperedges( + H=H, + pos=pos, + ax=ax, + dyad_color=dyad_color, + dyad_lw=dyad_lw, + dyad_style=dyad_style, + dyad_color_cmap=dyad_color_cmap, + dyad_vmin=dyad_vmin, + dyad_vmax=dyad_vmax, + alpha=alpha, + edge_fc=edge_fc, + edge_fc_cmap=edge_fc_cmap, + edge_vmin=edge_vmin, + edge_vmax=edge_vmax, + max_order=max_order, + hyperedge_labels=hyperedge_labels, + rescale_sizes=rescale_sizes, **kwargs, ) else: @@ -235,7 +246,7 @@ def draw( ax.set_aspect(aspect, "datalim") - return ax, node_collection + return ax, (node_collection, dyad_collection, edge_collection) def draw_nodes( @@ -262,12 +273,12 @@ def draw_nodes( ---------- H : Hypergraph or SimplicialComplex Higher-order network to plot. - ax : matplotlib.pyplot.axes, optional - Axis to draw on. If None (default), get the current axes. pos : dict, optional If passed, this dictionary of positions node_id:(x,y) is used for placing the 0-simplices. If None (default), use the `barycenter_spring_layout` to compute the positions. + ax : matplotlib.pyplot.axes, optional + Axis to draw on. If None (default), get the current axes. node_fc : str, iterable, or NodeStat, optional Color of the nodes. If str, use the same color for all nodes. If other iterable, or NodeStat, assume the colors are specified in the same order as the nodes are @@ -306,7 +317,7 @@ def draw_nodes( If `node_size` (`node_lw`) is a single value, `interpolate_sizes` is ignored for it. By default, True. params : dict - Default parameters used if `interpolate_sizes` is True. + Default parameters used if `rescale_sizes` is True. Keys to override default settings: * "min_node_size" (default: 5) * "max_node_size" (default: 30) @@ -447,12 +458,13 @@ def draw_hyperedges( Parameters ---------- H : Hypergraph - ax : matplotlib.pyplot.axes, optional - Axis to draw on. If None (default), get the current axes. + Hypergraph to plot pos : dict, optional If passed, this dictionary of positions node_id:(x,y) is used for placing the 0-simplices. If None (default), use the `barycenter_spring_layout` to compute the positions. + ax : matplotlib.pyplot.axes, optional + Axis to draw on. If None (default), get the current axes. dyad_color : str, dict, iterable, or EdgeStat, optional Color of the dyadic links. If str, use the same color for all edges. If a dict, must contain (edge_id: color_str) pairs. If iterable, assume the colors are @@ -499,8 +511,8 @@ def draw_hyperedges( """ settings = { - "min_dyad_lw": 2.0, - "max_dyad_lw": 10.0, + "min_dyad_lw": 1, + "max_dyad_lw": 10, } settings.update(params) @@ -519,7 +531,6 @@ def draw_hyperedges( # convert all formats to ndarray dyad_lw = _draw_arg_to_arr(dyad_lw) - edge_fc = _draw_arg_to_arr(edge_fc) # parse colors dyad_color, dyad_c_mapped = _parse_color_arg( @@ -609,7 +620,7 @@ def draw_hyperedges( # compute axis limits _update_lims(pos, ax) - return ax, dyad_collection, edge_collection + return ax, (dyad_collection, edge_collection) def draw_simplices( diff --git a/xgi/drawing/draw_utils.py b/xgi/drawing/draw_utils.py index d1edcd5b1..18b0a5dfb 100644 --- a/xgi/drawing/draw_utils.py +++ b/xgi/drawing/draw_utils.py @@ -88,12 +88,11 @@ def _parse_color_arg(colors, cmap, ids, id_kind="edges"): # Check if edge_color is an array of floats and map to edge_cmap. # This is the only case handled differently from matplotlib - if id_kind=="edges" and isinstance(colors, NodeStat): + if id_kind == "edges" and isinstance(colors, NodeStat): raise TypeError("The color argument for edges cannot be a NodeStat") - elif id_kind=="nodes" and isinstance(colors, Edgestat): + elif id_kind == "nodes" and isinstance(colors, Edgestat): raise TypeError("The color argument for nodes cannot be an EdgeStat") - # When drawing hyperedges we need to separate dyads and other hyperedges. # But the user can input and IDstat or dict that represent all hyperedges. # So we need to filter these cases. From 7923adb696138b2ace54e46647f968703b0bc2dc Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Fri, 25 Aug 2023 19:08:55 +0200 Subject: [PATCH 07/26] updated docstrings --- In Depth 2 - Drawing hyperedges.ipynb | 130 +++++++++++++++++++------- xgi/drawing/draw.py | 95 ++++++++++++++----- xgi/drawing/draw_utils.py | 52 ++++++++++- 3 files changed, 215 insertions(+), 62 deletions(-) diff --git a/In Depth 2 - Drawing hyperedges.ipynb b/In Depth 2 - Drawing hyperedges.ipynb index 873fb09e2..8df2aab6a 100644 --- a/In Depth 2 - Drawing hyperedges.ipynb +++ b/In Depth 2 - Drawing hyperedges.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "e6d0469d", + "id": "e1c5005b", "metadata": {}, "source": [ "# In Depth 2 - Drawing hyperedges" @@ -10,7 +10,7 @@ }, { "cell_type": "markdown", - "id": "fe24ae6c", + "id": "ea8aad6a", "metadata": {}, "source": [ "Here we show the fuctionalities and parameters of `xgi.draw_hyperedges()`. It is similar to the [networkx](https://networkx.org/documentation/stable/reference/drawing.html) corresponding function (+ some bonus) and heavily relies on [matplotlib](https://matplotlib.org/)'s Collection plotting." @@ -19,7 +19,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "30c5cf3c", + "id": "b762703f", "metadata": {}, "outputs": [], "source": [ @@ -30,7 +30,7 @@ }, { "cell_type": "markdown", - "id": "d84c18f4", + "id": "f252027f", "metadata": {}, "source": [ "Les us first create a small toy hypergraph containing edges of different sizes." @@ -39,7 +39,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "4b40a720", + "id": "0a032899", "metadata": {}, "outputs": [], "source": [ @@ -52,7 +52,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "4b5ab06f", + "id": "444f90d3", "metadata": {}, "outputs": [ { @@ -85,7 +85,7 @@ }, { "cell_type": "markdown", - "id": "05f4c555", + "id": "1c5336d3", "metadata": {}, "source": [ "## Basics" @@ -93,7 +93,7 @@ }, { "cell_type": "markdown", - "id": "610dbcb4", + "id": "c8baf790", "metadata": {}, "source": [ "Let's jump right into how `xgi.draw_nodes()` works. By default, it gives:" @@ -102,7 +102,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "75025a15", + "id": "95737dd8", "metadata": {}, "outputs": [ { @@ -134,7 +134,7 @@ }, { "cell_type": "markdown", - "id": "fda9915d", + "id": "12d7fa53", "metadata": {}, "source": [ "Notice that this function returns a tuple `(ax, collections)` where `collections` is a tuple `(dyad_collection, edge_collection)`. The collections can be used to plot colorbars as we will see later." @@ -142,7 +142,7 @@ }, { "cell_type": "markdown", - "id": "49af5d85", + "id": "4e879854", "metadata": {}, "source": [ "The color, linewidth, transparancy, and style of the hyperedges can all be customised, for example with single values:" @@ -151,7 +151,7 @@ { "cell_type": "code", "execution_count": 11, - "id": "c1b3d3a1", + "id": "b4ed641d", "metadata": {}, "outputs": [ { @@ -178,12 +178,14 @@ } ], "source": [ - "xgi.draw_hyperedges(H, pos=pos, dyad_color=\"r\", dyad_lw=2, dyad_style=\"--\", edge_fc=\"g\", alpha=0.3)" + "xgi.draw_hyperedges(\n", + " H, pos=pos, dyad_color=\"r\", dyad_lw=2, dyad_style=\"--\", edge_fc=\"g\", alpha=0.3\n", + ")" ] }, { "cell_type": "markdown", - "id": "459442b1", + "id": "7eb2b443", "metadata": {}, "source": [ "Or with multiple values:" @@ -192,7 +194,7 @@ { "cell_type": "code", "execution_count": 21, - "id": "a48f696f", + "id": "4505c0aa", "metadata": {}, "outputs": [ { @@ -230,7 +232,7 @@ }, { "cell_type": "markdown", - "id": "692f6eac", + "id": "310d67df", "metadata": {}, "source": [ "## Arrays of floats and colormaps" @@ -238,7 +240,7 @@ }, { "cell_type": "markdown", - "id": "053f097c", + "id": "92d32d0d", "metadata": {}, "source": [ "In XGI, you can easily color hyperedges according to an EdgeStat, or just an array or a dict with float values:" @@ -247,7 +249,7 @@ { "cell_type": "code", "execution_count": 29, - "id": "bfab69e9", + "id": "f5631114", "metadata": {}, "outputs": [ { @@ -285,7 +287,7 @@ }, { "cell_type": "markdown", - "id": "c452196b", + "id": "56966a12", "metadata": {}, "source": [ "By default, the colormaps used are \"Blues\" and \"Greys\". These can be changed:" @@ -294,7 +296,7 @@ { "cell_type": "code", "execution_count": 32, - "id": "7400903b", + "id": "a253c2e4", "metadata": {}, "outputs": [ { @@ -325,7 +327,7 @@ " dyad_color=[3, 1, 4],\n", " edge_fc=H.edges.size,\n", " dyad_color_cmap=\"viridis\",\n", - " edge_fc_cmap=\"tab10\"\n", + " edge_fc_cmap=\"tab10\",\n", ")\n", "\n", "plt.colorbar(dyad_collection, label=\"dyads\")\n", @@ -334,7 +336,7 @@ }, { "cell_type": "markdown", - "id": "d2e165ab", + "id": "5cbde978", "metadata": {}, "source": [ "You can specify a `vmin` and `vmax` for the dyad and edge colors:" @@ -343,7 +345,7 @@ { "cell_type": "code", "execution_count": 37, - "id": "e089d4be", + "id": "1548e22b", "metadata": {}, "outputs": [ { @@ -369,12 +371,7 @@ ], "source": [ "ax, (dyad_collection, edge_collection) = xgi.draw_hyperedges(\n", - " H,\n", - " pos=pos,\n", - " dyad_color=[3, 1, 4],\n", - " edge_fc=H.edges.size,\n", - " dyad_vmin=1.5,\n", - " edge_vmax=4.5\n", + " H, pos=pos, dyad_color=[3, 1, 4], edge_fc=H.edges.size, dyad_vmin=1.5, edge_vmax=4.5\n", ")\n", "\n", "plt.colorbar(dyad_collection, label=\"dyads\")\n", @@ -383,7 +380,7 @@ }, { "cell_type": "markdown", - "id": "81df5a5f", + "id": "a1424b04", "metadata": {}, "source": [ "## Combine with nodes" @@ -391,7 +388,7 @@ }, { "cell_type": "markdown", - "id": "b8ffdbfa", + "id": "c2b1f9ec", "metadata": {}, "source": [ "This can be either via `xgi.draw()`:" @@ -400,7 +397,7 @@ { "cell_type": "code", "execution_count": 48, - "id": "bf32fddc", + "id": "8eeba210", "metadata": {}, "outputs": [ { @@ -434,10 +431,77 @@ { "cell_type": "code", "execution_count": null, - "id": "785a23b5", + "id": "f3ad618c", "metadata": {}, "outputs": [], "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0b1dd42f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "d677fbc5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{0: {1, 2, 3},\n", + " 1: {3, 4, 5},\n", + " 2: {3, 6},\n", + " 3: {6, 7, 8, 9},\n", + " 4: {1, 4, 10, 11, 12},\n", + " 5: {1, 4},\n", + " 6: {2, 5}}" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "H.edges.members(dtype=dict)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "4615bc2b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1: {0, 4, 5},\n", + " 2: {0, 6},\n", + " 3: {0, 1, 2},\n", + " 4: {1, 4, 5},\n", + " 5: {1, 6},\n", + " 6: {2, 3},\n", + " 7: {3},\n", + " 8: {3},\n", + " 9: {3},\n", + " 10: {4},\n", + " 11: {4},\n", + " 12: {4}}" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "H.nodes.memberships()" + ] } ], "metadata": { diff --git a/xgi/drawing/draw.py b/xgi/drawing/draw.py index 6307e8e0c..2cb2dee5b 100644 --- a/xgi/drawing/draw.py +++ b/xgi/drawing/draw.py @@ -123,12 +123,32 @@ def draw( iterable, assume the widths are specified in the same order as the edges are found in H.edges. If EdgeStat, use a monotonic linear interpolation defined between min_dyad_lw and max_dyad_lw. By default, 1.5. - edge_fc : str, dict, iterable, or EdgeStat, optional - Color of the hyperedges. If str, use the same color for all nodes. If a dict, - must contain (edge_id: color_str) pairs. If other iterable, assume the colors - are specified in the same order as the hyperedges are found in H.edges. If - EdgeStat, use the colormap specified with edge_fc_cmap. If None (default), use - the H.edges.size. + dyad_style : str or list of strings, optional + Line style of the dyads, e.g. ‘-’, ‘–’, ‘-.’, ‘:’ or words like ‘solid’ or ‘dashed’. + See matplotlib's documentation for all accepted values. By default, "solid". + dyad_color_cmap: matplotlib colormap + Colormap used to map the dyad colors. By default, "Greys". + dyad_vmin, dyad_vmax : float, optional + Minimum and maximum for dyad colormap scaling. By default, None. + edge_fc : color or list of colors or array-like or dict or EdgeStat, optional + Color of the hyperedges. The accepted formats are the same as + matplotlib's scatter, with the addition of dict and IDStat. + Those with colors: + * single color as a string + * single color as 3- or 4-tuple + * list of colors of length len(ids) + * dict of colors containing the `ids` as keys + Those with numerical values (will be mapped to colors): + * array of floats + * dict of floats containing the `ids` as keys + * IDStat containing the `ids` as keys + If None (default), color by edge size. + edge_fc_cmap: matplotlib colormap + Colormap used to map the edge colors. By default, "Blues". + edge_vmin, edge_vmax : float, optional + Minimum and maximum for edge colormap scaling. By default, None. + alpha : float, optional + The edge transparency. By default, 0.4. node_labels : bool or dict, optional If True, draw ids on the nodes. If a dict, must contain (node_id: label) pairs. By default, False. @@ -142,18 +162,19 @@ def draw( directly to matplotlib's `ax.set_aspect()`. Default is `equal`. See full description at https://matplotlib.org/stable/api/_as_gen/matplotlib.axes.Axes.set_aspect.html + rescale_sizes: bool, optional + If True, linearly interpolate `node_size`, `node_lw` and `dyad_lw` + between min/max values that can be changed in the other argument `params`. + If those are single values, `interpolate_sizes` is ignored + for it. By default, True. **kwargs : optional args Alternate default values. Values that can be overwritten are the following: - * min_node_size - * max_node_size - * min_node_lw - * max_node_lw - * min_dyad_lw - * max_dyad_lw - * node_fc_cmap - * node_ec_cmap - * dyad_color_cmap - * edge_fc_cmap + * "min_node_size" (default: 5) + * "max_node_size" (default: 30) + * "min_node_lw" (default: 0) + * "max_node_lw" (default: 5) + * "min_dyad_lw" (default: 1) + * "max_dyad_lw" (default: 10) Examples -------- @@ -238,6 +259,7 @@ def draw( zorder=max_order, params=settings, node_labels=node_labels, + rescale_sizes=rescale_sizes, **kwargs, ) @@ -477,21 +499,46 @@ def draw_hyperedges( iterable, assume the widths are specified in the same order as the edges are found in H.edges. If EdgeStat, use a monotonic linear interpolation defined between min_dyad_lw and max_dyad_lw. By default, 1.5. - edge_fc : str, dict, iterable, or EdgeStat, optional - Color of the hyperedges. If str, use the same color for all nodes. If a dict, - must contain (edge_id: color_str) pairs. If other iterable, assume the colors - are specified in the same order as the hyperedges are found in H.edges. If - EdgeStat, use the colormap specified with edge_fc_cmap. If None (default), color - by edge size. + dyad_style : str or list of strings, optional + Line style of the dyads, e.g. ‘-’, ‘–’, ‘-.’, ‘:’ or words like ‘solid’ or ‘dashed’. + See matplotlib's documentation for all accepted values. By default, "solid". + dyad_color_cmap: matplotlib colormap + Colormap used to map the dyad colors. By default, "Greys". + dyad_vmin, dyad_vmax : float, optional + Minimum and maximum for dyad colormap scaling. By default, None. + edge_fc : color or list of colors or array-like or dict or EdgeStat, optional + Color of the hyperedges. The accepted formats are the same as + matplotlib's scatter, with the addition of dict and IDStat. + Those with colors: + * single color as a string + * single color as 3- or 4-tuple + * list of colors of length len(ids) + * dict of colors containing the `ids` as keys + Those with numerical values (will be mapped to colors): + * array of floats + * dict of floats containing the `ids` as keys + * IDStat containing the `ids` as keys + If None (default), color by edge size. + edge_fc_cmap: matplotlib colormap + Colormap used to map the edge colors. By default, "Blues". + edge_vmin, edge_vmax : float, optional + Minimum and maximum for edge colormap scaling. By default, None. + alpha : float, optional + The edge transparency. By default, 0.4. max_order : int, optional Maximum of hyperedges to plot. By default, None. hyperedge_labels : bool or dict, optional If True, draw ids on the hyperedges. If a dict, must contain (edge_id: label) pairs. By default, None. + rescale_sizes: bool, optional + If True, linearly interpolate `dyad_lw` and between min/max values + (1/10) that can be changed in the other argument `params`. + If `dyad_lw` is a single value, `interpolate_sizes` is ignored + for it. By default, True. params : dict Default parameters. Keys that may be useful to override default settings: - * min_dyad_lw - * max_dyad_lw + * "min_dyad_lw" (default: 1) + * "max_dyad_lw" (default: 10) kwargs : optional keywords See `draw_hyperedge_labels` for a description of optional keywords. diff --git a/xgi/drawing/draw_utils.py b/xgi/drawing/draw_utils.py index 18b0a5dfb..c9ae6b12c 100644 --- a/xgi/drawing/draw_utils.py +++ b/xgi/drawing/draw_utils.py @@ -84,18 +84,60 @@ def _update_lims(pos, ax): def _parse_color_arg(colors, cmap, ids, id_kind="edges"): + """ + Parse and process color arguments for plotting. + + This function is needed to handle the input formats not naturally + handled by matploltib's Collections: IDStat, dict, and arrays of + floats. All those are converted to arrays of floats and. + + Parameters: + ----------- + colors : color or list of colors or array-like or dict or IDStat + The color(s) to use. The accepted formats are the same as + matplotlib's scatter, with the addition of dict and IDStat. + Those with colors: + * single color as a string + * single color as 3- or 4-tuple + * list of colors of length len(ids) + * dict of colors containing the `ids` as keys + Those with numerical values (will be mapped to colors): + * array of floats + * dict of floats containing the `ids` as keys + * IDStat containing the `ids` as keys + cmap : matplotlib colormap or None + The colormap to use for mapping numerical values to colors. + ids : array-like or None + The IDs of the elements being plotted. + id_kind : str, optional + The kind of element IDs, "edges" (default) or "nodes". + + Returns: + -------- + colors : single color or ndarray + Processed color values for plotting. + colors_are_mapped : bool + True if the colors are mapped and need special handling. This + is used in draw_hyperedges to deal with Collections. + + Raises: + ------- + TypeError + If color argument is inappropriate for the provided id_kind. + ValueError + If color argument has an invalid format or length. - # Check if edge_color is an array of floats and map to edge_cmap. - # This is the only case handled differently from matplotlib + Notes: + ------ + This function processes the color argument to ensure compatibility with + PatchCollection's facecolor/array and checks for correct input format and length. + """ if id_kind == "edges" and isinstance(colors, NodeStat): raise TypeError("The color argument for edges cannot be a NodeStat") elif id_kind == "nodes" and isinstance(colors, Edgestat): raise TypeError("The color argument for nodes cannot be an EdgeStat") - # When drawing hyperedges we need to separate dyads and other hyperedges. - # But the user can input and IDstat or dict that represent all hyperedges. - # So we need to filter these cases. xsize = len(ids) if isinstance(colors, IDStat): From f8e9b06404346d6265e3be19c1bf8cdc1c78d6f5 Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Fri, 25 Aug 2023 22:25:41 +0200 Subject: [PATCH 08/26] fix: tests --- tests/drawing/test_draw.py | 23 ++++++++++++++++------- 1 file changed, 16 insertions(+), 7 deletions(-) diff --git a/tests/drawing/test_draw.py b/tests/drawing/test_draw.py index dce7c71fb..56e5a27a4 100644 --- a/tests/drawing/test_draw.py +++ b/tests/drawing/test_draw.py @@ -10,13 +10,18 @@ def test_draw(edgelist8): H = xgi.Hypergraph(edgelist8) fig, ax = plt.subplots() - ax, node_collection = xgi.draw(H, ax=ax) + ax, collections = xgi.draw(H, ax=ax) + + (node_collection, dyad_collection, edge_collection) = collections # number of elements - assert len(ax.lines) == len(H.edges.filterby("size", 2)) # dyads - assert len(ax.patches) == len(H.edges.filterby("size", 2, mode="gt")) # hyperedges + assert len(ax.lines) == 0 + assert len(ax.patches) == 0 offsets = node_collection.get_offsets() assert offsets.shape[0] == H.num_nodes # nodes + assert len(ax.collections) == 3 + assert len(dyad_collection.get_paths()) == 3 # dyads + assert len(edge_collection.get_paths()) == 6 # other hyperedges # zorder for line in ax.lines: # dyads @@ -198,12 +203,16 @@ def test_draw_hyperedges(edgelist8): H = xgi.Hypergraph(edgelist8) fig, ax = plt.subplots() - ax = xgi.draw_hyperedges(H, ax=ax) + ax, collections = xgi.draw_hyperedges(H, ax=ax) + + (dyad_collection, edge_collection) = collections # number of elements - assert len(ax.lines) == len(H.edges.filterby("size", 2)) # dyads - assert len(ax.patches) == len(H.edges.filterby("size", 2, mode="gt")) # hyperedges - assert len(ax.collections) == 0 # nodes + assert len(ax.lines) == 0 + assert len(ax.patches) == 0 + assert len(ax.collections) == 2 + assert len(dyad_collection.get_paths()) == 3 # dyads + assert len(edge_collection.get_paths()) == 6 # other hyperedges # zorder for line in ax.lines: # dyads From 99dbfc222156655d732bb486803d2b4d6961888d Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Fri, 25 Aug 2023 23:00:53 +0200 Subject: [PATCH 09/26] fix: tests and compatbility with draw simplices --- In Depth 2 - Drawing hyperedges.ipynb | 541 --------------------- tests/drawing/test_draw.py | 10 +- tutorials/In Depth 1 - Drawing nodes.ipynb | 41 +- tutorials/Tutorial 5 - Plotting.ipynb | 111 +++-- xgi/drawing/draw.py | 24 +- 5 files changed, 116 insertions(+), 611 deletions(-) delete mode 100644 In Depth 2 - Drawing hyperedges.ipynb diff --git a/In Depth 2 - Drawing hyperedges.ipynb b/In Depth 2 - Drawing hyperedges.ipynb deleted file mode 100644 index 8df2aab6a..000000000 --- a/In Depth 2 - Drawing hyperedges.ipynb +++ /dev/null @@ -1,541 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "e1c5005b", - "metadata": {}, - "source": [ - "# In Depth 2 - Drawing hyperedges" - ] - }, - { - "cell_type": "markdown", - "id": "ea8aad6a", - "metadata": {}, - "source": [ - "Here we show the fuctionalities and parameters of `xgi.draw_hyperedges()`. It is similar to the [networkx](https://networkx.org/documentation/stable/reference/drawing.html) corresponding function (+ some bonus) and heavily relies on [matplotlib](https://matplotlib.org/)'s Collection plotting." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "b762703f", - "metadata": {}, - "outputs": [], - "source": [ - "import xgi\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "id": "f252027f", - "metadata": {}, - "source": [ - "Les us first create a small toy hypergraph containing edges of different sizes." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "0a032899", - "metadata": {}, - "outputs": [], - "source": [ - "edges = [[1, 2, 3], [3, 4, 5], [3, 6], [6, 7, 8, 9], [1, 4, 10, 11, 12], [1, 4], [2, 5]]\n", - "H = xgi.Hypergraph(edges)\n", - "\n", - "pos = xgi.barycenter_spring_layout(H, seed=42) # fix position" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "444f90d3", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(,\n", - " (,\n", - " ,\n", - " ))" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "xgi.draw(H, pos=pos)" - ] - }, - { - "cell_type": "markdown", - "id": "1c5336d3", - "metadata": {}, - "source": [ - "## Basics" - ] - }, - { - "cell_type": "markdown", - "id": "c8baf790", - "metadata": {}, - "source": [ - "Let's jump right into how `xgi.draw_nodes()` works. By default, it gives:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "95737dd8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(,\n", - " (,\n", - " ))" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAkx0lEQVR4nO3deWyd9b3n8c+xj9dsjgNJTPZk2CmUpQyUrZSGkoRQDSqVqFQqJGgrlvtPp/91dP9A/esyuroDqE2pUFu1EtPSuaIaeqeLBKUjgqYEajsLcUK8xLF9vNvn+OzneeYP24md2PF2nuf3PM/v/ZJIHB/sfM+B5Pc5398Wc13XFQAAsFaF6QIAAIBZhAEAACxHGAAAwHKEAQAALEcYAADAcoQBAAAsRxgAAMByhAEAACxHGAAAwHKEAQAALEcYAADAcoQBAAAsRxgAAMByhAEAACxHGAAAwHKEAQAALEcYAADAcoQBAAAsRxgAAMByhAEAACxHGAAAwHKEAQAALEcYAADAcoQBAAAsRxgAAMByhAEAACxHGAAAwHKEAQAALEcYAADAcoQBAAAsRxgAAMByhAEAACxHGAAAwHKEAQAALEcYAADAcoQBAAAsRxgAAMByhAEAACxHGAAAwHJx0wUACIeXXnpJTU1N2rFjh3bs2KHt27ertrbWdFkAyiDmuq5ruggAwTY2Nq6GhnWXfH7z5s3asWOHdu7ceT4kzPx49erVBqoFsFSEAQCX5bjSwOCQ/vm//VBdXZ3q6OhQZ2en0un0gl/b2Ng4b1DYuXOnGhoaFIvFfHgWAC6HMABgTq47GQRm/gVRGZNiMcl1XQ0NDamz80I4uPjj0dHRBX+PNWvWXLazsHHjRsIC4APCAIBLzBUEJKkiNvnPYoyNjc0ZEqZ/PTAwsOD3qKur0/bt2+cNDE1NTaqsrFz6EwQwC2EAwHnuVABwLvO3wnR3YKXS6bS6urrm7Sz09PRoob+e4vH4+bBwcWDYsWOHtm3bpqqqqpUXC0QcYQCApPm7ARdbSndgJfL5vM6ePTtnUOjo6FB3d7eKxeLla62o0FVXXTVvZ2H79u2qq6vz/skAAUcYALDoIDCtXN2BlSiVSurp6ZlzCmL641wut+D32bRp06yQ8LWvfU333HOPD88ACA7CAGCxxUwLzCUmqTLgR5Y5jqP+/v7LrltIpVKXfN2//dv/0D/904sGKgbMIQwAllpqN+BiQegOrITruhoZGTkfDDo6OtXR2aknn3xSd/3nO02XB/iKMABYaKVBQApHd2CxHPdCd8SvNRFAkHAcMWCR5U4LzPm9pr5fuLsDKw9FQBREJNcDWMj0wFeOIDCtnN/LbwQB4AI6A4AFvBr4prsMYWqrl7M7AkQFYQCIMD8GvunfIwzTBXQDgLkRBoCI8mvgc6f+CXIWoBsAXB5hAIggv98BB7k7QDcAWBhhAIgQU++Ag9odKPeCSSCqCANARJh+Bxyk7oDp1wIIG7YWAhEQhMFvujtgWhBeCyBs6AwAIRa0hXGOOzlVYKI7ELTXAggTwgAQUkF9B2xi7UBQXwsgLAgDQAgFefDzsztANwAoD8IAECJhGfz86A4EORABYUMYAEIiTIOfl90BrwNRADZDAL5jNwEQAmEKAtO8GKy9uGwJAJ0BINDCMi0wl3Jfcey4F14PAOVFGAACKozdgIs5rlS5wjAQhdcBCDqmCYAAisoAON0dWPbXR+R1AIKOzgAQIGGeFpjPcroDUXwdgCAjDAABEdV3wUtdOxDV1wEIMsIAEABRHwAdd3JO8nKBgG4AYA5hADDIlgFwoSuOox6GgKAjDACG2DYAznfFMecGAOYRBgADbBwAL+4O2BaGgCAjDAA+smVaYD4zDw0iCADBQRgAfMI74cnXoGS6CACXIAwAPrBxWuAS7oxthvLnimMAi0MYADxk+7SApAshwHQdAOZFGAA8wrSA5g0C7tQPdAeAYCAMAB5gWoAbBoEwIQwAZcS0gBY9LUB3AAgOwgBQJkwLXLihcLGvweVOJQTgH8IAUAbWTwusYJHgUi4xAuANwgCwAkwLaMW7BegOAOYRBoBlsn5aoIxbBukOAGYRBoBlYFqgvGcH0B0AzCIMAEtg/bSAhwcI0R0AzCEMAIvEtIC3Jwmy1RAwhzAALILt0wIcIAREG2EAuAymBfy9V4DuAGAGYQCYB9MCXDAE2IIwAMzB6mkBwyGA7gDgP8IAMAPdALoBgI0IA8AUq4NAwEIA3QHAX4QBQEwLBCkIAPAfYQBWs7oboGBvGaQ7APiHMABrWR0E6AYAmIEwACvZPC3gTj3vMDx9ugOAPwgDsArdgPA9dy4xArxXYboAwC8EgfA+dzeshQMhQWcAVrB2WiDkIWAa3QHAW4QBRBrdgOg8d644BrxDGEBkWRsEIhYCptEdALzDmgFEkuNKJYJA5LB2APAGnQFEirXdAAX7AKFyYash4A3CACLD2iAQ8W6A3wgasBFhAJHAbgF70B0Ayo8wgFCjGwAAK8cCQoQWQcBerlhMCJQTYQChk0wm7dwt4E4FIFn2vAF4jjCAUGnv6FJjY6MefPBL+u8v/4tOnDgh14a3iHQDLkF3ACifmGvF36QIM9d1da5/VG3tCf3mN7/RoX/951mP79q1S/v2H9CBA4/q/gceUG1traFKvWHDlsHliqn8CwnjvEWChQgDCKxUOqe2joTaOhOaSOfOf34g0aOWIx+o5ePDOnn0ExWLhfOP1dfX6ytf2at9+w9o3/792rJli4nSy4NuwKKUOxAQBmAjwgACpVRy1NkzpLaOfp3rH1nw389m0jrRekStHx9Wy8eHNTo8OOvxW2+9dSoYHNAXvvAFVVZWelV6eREEFo0wAKwcYQCBMDw2oZPtCX3W1a9cobis7+G6rs62n1LzkQ/U+vFhtZ+evZ7gyiuv1COP7NP+A49q78MPa926deUqv3wIActSzkBAGICNCAMwJl8o6rOuAbV19mtwJFn27z8+NqLWTz5U65HDOtb8/5RJT5x/LB6P695779X+A49q3/4DuvbaaxUzfYoNQWBFKggDwLIRBuC7nv5RnersV3v3oEqO48vvWSwWdfrTFrUcOayWIx+or6dr1uN79uzR/v0HtP/Ao7rv/vtVU1PjS12SCAFlUo7uQExSJWEAFiIMwBfpTF5tnQm1dSSUnMiaLkeJ3u7JdQZHDqvt+D9mLUJctWqVvrJ3rw7sf1T79u/X5qYm7wohCJTVSrsDhAHYijAAzziOo7N9IzrZnlB3YiSw5wFkM2kdb/lILR9/oNYjhzU2Ojzr8dtuu00HpqYTbr/jDlVUlGG0IAR4YqXdAcIAbEUYQNmNJtNTiwEHlMnlTZezJI7jqKv9lFo//kDNRw6r4/SJWY9v3LhR+/fv1779B7R378Nas3bt0n8TgoCnVtIdIAzAVoQBlEWhUFL7uUGdbE+of3jcdDllMzY6rKOffKiWIx/oWPPflc2kzz9WVVWl++67TwcOPKr9Bw7o6quvWXCAn/7Txh8676ykO0AYgK0IA1iRxNC4TnX060z3gArFkulyPFUsFHTqRLNaps40SPScnfX41Vdfrf37D+jAgQO67/77VVVVfWHQpxvgq+V2BwgDsBVhAEuWyeZ1umtAJzsSGkumF/6CiEr0nj2/O6HtRLNKxQvnI6xZs0Z79+7V97//X3XXXXfbd6mSYcvtDhAGYCvCABbFdV2d7RvRqc6EunpG5Lj+bAkMi0x6Qsdb/q6WI4fV+smHGp9ahPjv//57HXzs4PkgMPNPG3/wvLWcQEAYgK0IA7is8VRGbZ39OtXZr3Qmt/AXQI7jqPPMSbV+/KH+9V9+pF3bNkuafcse4cB7hAFg8QgDuESxWFJnz7BOdvSpd2DMdDmh9tV7b9TWTesv+fzMmwgv/vj8v+N5ddG31EBAGICt4qYLQHAMjqR0siOhM2cHlF/m/QCYzXHmHtJjscmBZ/IXMwLBjI9jIhwA8AdhwHK5fEGnuwbU1pHQ8NjEwl+AJVls322ucCBJ7jzhgGCwOO7UD6avnQCCjjBgIdd11TMwprb2hDp7hny7H8BG7jIXWk4PXrGpH+YKB5Pff+rnlRQJwHqEAYuk0jmd6uxXW0dCqbT5+wFsMN80wVItFA6kuRcogu4AsBiEgYgrlRx19Q7rZHtC5/pHTJdjHa+W5y4mHDisNwCwSISBiBoem1Bbx+T9ANl8YeEvgCf8Oo/h4nAgSRUXTSfYHA7oDgCXRxiIkHyhqDNnB9XWmdDAcNJ0OVD5pgmW4+JFiYQDAPMhDERA3+C42jr61N49pGIp2vcDhI3JMHCxucKBdGGtQdTDAd0BYH6EgZBKZ/I61TW5GHA8lTFdDuYR5EH14qkFG8LB9BZNALMRBkLEcRyd7RtVW0efzvaNiMMjg88J0bbNhcLBrC2N/pdXNi7dAeAShIEQGEtm1NaZ0OnOfqWzedPlYAmCNE2wVPPuWFC4wwHdAeBShIGAKhZLaj83qJPtCSWGxk2Xg2UK0yC5kLl2LMwMBI4TnnBAdwCYjTAQMP3DSbW1J3Sme0CFIosBwy7MnYHFmLkosaJy7nAQxFeA7gAwG2EgALK5gk539etkR0Kj42nT5aCMwrRmoBzmCgfS5OAbtHBAdwC4gDBgiOu66k6M6lRHQp09w74dTgN/OZYv8pw5tRC0cMBWQ+ACwoDPkhNZtXUkdKqrXxPpnOly4DHLs8Al5gsHzowFibxkgP8IAz4olRx1nBtSW2dCPf2jpsuBj2ybJliq6XBQOWNBonQhHEiSl68g3QFgEmHAQ0OjKZ3sSOhM14ByhaLpcmCA7dMES3VxOJBmH4Dkut6GA8BWhIEyyxeK+qxrQCc7EhoaTZkuB4aRBVYuFvM2HNAdAAgDZeG6rnoHxtTWkVDHuSGVaA1jihvxrYUmzBUOptcbOC5rDoDlIAyswEQmp1Odk/cDJCeypstBALFLxHux2IzpBS0vHNAdgO0IA0vkOI66eod1sj2hc/2j3A+Ay4r6oUNBVI5wANiGMLBII+NptXVM3g+QzRdMl4OQICuat1A4kC5saeS/F2xFGLiMQqGkM92TiwEHhpOmy0EIMU0QPBeHA2nyACTHdfXuu+/q/b++q5deeslYfYAJMZc+9yX6Bsd1qiOhM92DKpa4HwDLt72pUXu/eIPpMrAIvb292rZtm0qlkpqbm3XzzTebLgnwTYXpAoIik82r5WS33vrTx3rnry1q60wQBLBiRO3waGpq0uOPPy5JeuWVVwxXA/jL6s6A4zjqToyqrSOhs70jtHRRdls2rtcj991ougws0t/+9jfdf//9qqurU3d3txobG02XBPjCys7AeCqjvx/t0P/8j4/05w+Oq7NniCAAT/D/Vbjce++9uuWWW5TJZPTGG2+YLgfwjTVhoFgs6XRnv975a6t++8cjajnZrXQ2b7osRBxbC8MlFovpxRdflCS99tprKjFVCEtEfppgYDipts5+nTk7oDz3A8BnGxvX6uCDLEQLk3Q6ra1bt2pkZERvv/22HnvsMdMlAZ6LZGcgmyvo2Oke/a8/f6Lfv9usT8/0EgRgBBcVhU99fb2eeeYZSSwkhD0i2Rn44B+f6cRnvabLANS4bpX+y1duNV0Glqijo0N79uyR4zg6fvy4rr/+etMlAZ6KZGfg7lt2a8+2K02XAbC1MKR27typgwcPSppcOwBEXSTDQCwW0/13XK0dV20wXQosxzRBeL3wwguSpF/84hcaHx83XA3grUiGAUmqqKjQg3deq62b1psuBRZzuM46tB566CFdf/31SqVS+vnPf266HMBTkQ0DklRZWaGH7rpOTVeuM10KLEVnILxisdj57sCrr75KsEOkRToMSFI8Xqm9d9+gjY1rTZcCC5EFwu2pp57S2rVrderUKf35z382XQ7gmciHAUmqqqrUV++9QRsaVpsuBZZxOXQo1FavXq2nn35aEtsMEW1WhAFJqq6K65F7b1TD2nrTpcAitJbD77nnnpMk/eEPf9Bnn31muBrAG9aEAUmqranSvntv0trVdaZLgSXoC4TfNddco0ceeUSu67LNEJFlVRiQpPq6au277yatqq8xXQoswN0E0TB9X8Ebb7yhiYkJw9UA5WddGJCk1fU12n/fTaqvrTZdCiKOMBANjzzyiPbs2aOxsTH96le/Ml0OUHZWhgFJWru6Tvvuv0m11VWmS0GEcYVxNFRUVOj555+XNLmQMIKnuMNy1oYBSWpYU69H7rtRNVVx06Ugwhg4ouHpp59WfX29jh07pvfee890OUBZWR0GJGlDw2o9fO+NqopXmi4FEUUYiIaGhgY99dRTkthmiOixPgxI0sbGNXr4nhsVryQQoPxYNxAd0ycSvv322+rq6jJcDVA+hIEpm69Yq4fuvk4VMV4SlBdHEkfHjTfeqC9/+ctyHEc//vGPTZcDlA0j3wxbN63Xl+8iEKC86AxEy3R34PXXX1cmkzFcDVAejHoX2XFVo7505zWKxWKmS0FEsGYgWg4ePKjt27draGhIb775pulygLIgDMxh19YrdN/t/8l0GYgIpgmiJR6Pnz+imG2GiArCwDyu3rFJX/z8HtNlIAKYJoieZ555RrW1tfrkk090+PBh0+UAK0YYuIzr9zTpzs/tMl0GQo53jtGzYcMGPfnkk5LYZohoIAws4HPXbNFtN+wwXQZCjGmCaJq+r+Ctt95ST0+P4WqAlSEMLMKt12/TzdduNV0GQoppgmi69dZbdc8996hYLOrQoUOmywFWhDCwSF+4aadu2HOV6TIQQoSB6JruDhw6dEj5fN5wNcDyEQaW4K5bdunanZtNl4GQYc1AdD3++ONqampSIpHQW2+9ZbocYNkIA0sQi8V0z217tGfblaZLQYiwZiC6qqqq9L3vfU8SCwkRboSBJYrFYrr/jqu146oNpktBSDBNEG3f+c53VFVVpQ8//FAfffSR6XKAZSEMLENFRYUevPNabd203nQpCAGmCaJt8+bN+sY3viFJevXVVw1XAywPYWCZKisr9NBd16npynWmS0HAMU0QfdMLCd98800NDAwYrgZYOsLACsTjldp79w3a2LjWdCkIMKYJou/OO+/UHXfcoVwup9dff910OcCSxVx6mCuWLxT1h/ePamg0ZboUGFBdFVd1VVw11XHVVleppjqu6uq4aqsnP7dzyxVaXV9jukx47Je//KW+/e1va+vWrWpvb1c8HjddErBohIEyyeYKeuf9Vo2Op02XgmWqildODeKTA3pNVVw1NRc+rq2Jq7pq8te1NVOPV8dVUUGDDVIul9O2bds0MDCg3/72t/r6179uuiRg0QgDZZTO5PXO+60aT3HHuUnxyslBfXoAr6mOq2ZqgD8/0M/43PSgXlnJoI6V+eEPf6gf/ehHeuCBB/Tee++ZLgdYNMJAmaXSOf3vv7ZoIp0zXUroVVZUzB60pwbz6vMfXzrQV1dVKh6vNF06LNXd3a2dO3eqVCqpublZN998s+mSgEUhDHhgPJXRO39tVTrL8aSSVBGbGtRrpt+tV6mmampeferjC+/WJwf32uo4gzpC6YknntBbb72lZ599Vj/96U9NlwMsCmHAI6PJtN55r1XZfMF0KWUTi8UuzKNPL5irmVw8Nz2o19ZUzWjRT36uqopBHfZ4//339cADD6iurk7d3d1qbGw0XRKwIMKAh4ZGU/qP948qVyiaLmWW6UG9uvqiFfDTA/j5xXMzBvWpxwFcnuu6+vznP6+Wlha9/PLL+v73v2+6JGBBhAGP9Q8n9X/+dlSFYsmT719dNbu1vpg59uqquGKxmCf1AJB+9rOf6dlnn9WuXbt06tQpVVbSHUOwEQZ80Dc4rj/+32MqluYPBAvtVZ8e1C+eY2dQB4InnU5r69atGhkZ0e9//3sdPHjQdEnAZREGfNI3OK6B4SR71QFL/OAHP9DLL7+svXv36k9/+pPpcoDLIgwAgAfa29u1Z88eua6rEydO6LrrrjNdEjAv3o4CgAd27dp1fnrgtddeM1wNcHl0BgDAI3/5y1+0d+9erV69WufOndPatVxqhmCiMwAAHnnooYd03XXXKZVK6Re/+IXpcoB5EQYAwCOxWEwvvPCCJOnVV1+V4ziGKwLmxjQBAHgomUxqy5YtSiaT+uMf/6iHH37YdEnAJegMAICH1qxZo6efflqS9MorrxiuBpgbnQEA8FhbW5uuvfZaxWIxnT59Wrt37zZdEjALnQEA8Ng111yjr371q3Jdl22GCCQ6AwDgg3feeUePPvqoGhoa1N3drVWrVpkuCTiPzgAA+GDfvn3as2ePRkdH9etf/9p0OcAshAEA8EFFRYWef/55SZMLCWnKIkiYJgAAn4yOjmrLli1Kp9N699139aUvfcl0SYAkOgMA4JuGhgZ961vfksQ2QwQLnQEA8NHRo0f1uc99ThUVFWpvb9f27dtNlwTQGQAAP91000168MEH5TiOfvKTn5guB5BEGAAA303fV/D6668rm80argYgDACA7x577DFt27ZNg4ODevPNN02XAxAGAMBv8Xhczz33nCS2GSIYWEAIAAYMDg5q69atyuVy+uCDD3T33XebLgkWozMAAAZcccUV+uY3vymJbYYwj84AABjy8ccf6/bbb1c8HldXV5eamppMlwRL0RkAAENuu+02ffGLX1SxWNShQ4dMlwOLEQYAwKAXX3xRknTo0CHl83nD1cBWhAEAMOjxxx9XU1OT+vr69Lvf/c50ObAUYQAADKqurtZ3v/tdSSwkhDksIAQAw/r6+rR9+3YVCgV99NFHuv32202XBMvQGQAAwzZv3qwnnnhCEt0BmEEYAIAAePHFF7Vz507dcuutpkuBhZgmAIAAcF1X6XxRnw5kdMOmVaqrqjRdEixCZwAAAiAWi6noSplCSS29SY1ni6ZLgkUIAwAQENmCI0kqlFwd7UupP8W5A/AHYQAAAiJXcs5/7Liu2gYm1DWSMVgRbEEYAICAyBWdSz7XNZrVyYEJOSzvgocIAwAQENPTBBcbSOXV2ptSoTT348BKEQYAICDm6gxMS+aKau5JKp0v+VgRbEEYAIAAcFz3smFAkrJFR829SY1mCj5VBVsQBgAgAPIlV4tZFVByXB3rS6kvmfO8JtiDMAAAAZAtLL7970o6PZhW+3BGnBuHciAMAEAALDRFMJdzY1l92j+hkkMgwMoQBgAgAJYTBiRpKF1Qa29y2V8PSIQBAAiE7AoG81S+pObepFI5jjDG8hAGACAAVvrOPl901NKb0lCanQZYOsIAAATASjoD0xzX1YlESufGsmWoCDYhDACAYY7rKl/GOf/24YxOD6Y5whiLRhgAAMPyRWdRZwwsRV8yp+OJCRXZaYBFIAwAgGHlmCKYy2imoJbe5JLOMICdCAMAYJiX2wLTUzsNxrPsNMD8CAMAYJhXnYFphZKro30pDaTynv4+CC/CAAAY5seBQY7r6uTAhLpGM57/XggfwgAAGOZ1Z2CmrpGs2gYm2GmAWQgDAGCYn2FAkvpTeR3tS6lQ4ghjTCIMAIBB5T5jYLHGs0U19yaVzrPTAIQBADDK5AVD2YKj5t6kRjMcYWw7wgAAGGT6tsGS4+pYIqW+ZM5oHTCLMAAABvm9XmAuriudHkyrfTgjl4WFViIMAIBBpjsDM50by+rT/gmVOMLYOoQBADAoCJ2BmYbSBbX2Jo0saoQ5hAEAMChInYFpqXxJ/+hNKpXjCGNbEAYAwKBsIXhhQJq8SbGlN6XhNDsNbEAYAABDHNdVPsAH/ziuqxOJlHrGs6ZLgccIAwBgSBCnCC7mSjozlNHpwTRHGEcYYQAADAna4sHL6UvmdDwxoSI7DSKJMAAAhuQCul5gPqOZglp6k8oWOMI4aggDAGBImDoD09L5kpp7U0qy0yBSCAMAYEguwIsHL6dQctTam9JAKm+6FJQJYQAADAnqtsLFcFxXJwcm1DWaMV0KyoAwAACGhGE3wUK6RrJqG5hgp0HIEQYAwICSE+wzBpaiP5XX0b6UChF5PjYiDACAAVHoCsw0ni2quTepdJ6dBmFEGAAAA8K6ePBysgVHzb1JjWY4wjhsCAMAYECYFw9eTslxdSyRUiKZM10KloAwAAAGRG2aYCbXlU4NptUxnJHLwsJQIAwAgAFhPHBoqbrHsvp0YEIljjAOPMIAABgQ5c7ATEMTBbX2JZW35PmGFWEAAAywoTMwLZUrqbk3qRRHGAcWYQAAfFZyXOv25OeKjlr7UhpOs9MgiAgDAOAzW6YILlZyXJ1IpNQznjVdCi5CGAAAn9kaBiTJlXRmKKPPhtIcYRwghAEA8JlN6wXm0zue04nEhIrsNAgEwgAA+IwwMGkkU1BLb5LXIwAIAwDgM5unCS6WzpfU3JNUkp0GRhEGAMBn2SKX+cxUKDlq7U1pcCJvuhRrEQYAwGd0Bi7luK4+7Z/Q2VF2GphAGAAAH02eMcCiufl0jmTUNjDBTgOfEQYAwEd0BRbWn8rrWF/KuoOZTCIMAICPWDm/OGPZopp7k8oUWF/hB8IAAPiIMLB42YKj5p6kRjMcYew1wgAA+IhpgqUpOq6OJVJKJHOmS4k0wgAA+IhthUvnutKpwbQ6hjNyWVjoCcIAAPgoV6AzsFzdY1mdHEirxBHGZUcYAAAf5VghvyKDE3m19iWVZ7qlrAgDAOATzhgoj1SupObepCbyTLmUC2EAAHzCToLyyRUdtfQmNZJmp0E5EAYAwCeEgfIqOa6OJ1LqGWenwUoRBgDAJzl2EpSdK+nMUFpnhtIcYbwChAEA8EmWnQSe6RnP6UT/BDsNlokwAAA+4cAhb42kC2ruTTIdswyEAQDwCWHAe+l8Sc09SSVzRdOlhAphAAB8wjtWfxRKjlp7UxqcyJsuJTQIAwDgg6Ljqsh8tm8c19Wn/RM6O5o1XUooEAYAwAdZruI1onMko1ODE+w0WABhAAB8wHoBcxLJvI71pVTgKOh5EQYAwAfcSWDWWLaolt6UMnRo5kQYAAAfcMaAeZnC5E6DsSxHGF+MMAAAPmCaIBiKjqujfSklkhxhPBNhAAB8wLbC4HBd6dRgWp0jGbksLJREGAAAXxAGgufsaFYnB9IcYSzCAAB4rlByGHACanAir6N9KeUtX+BJGAAAj7FeINiSuaKae5KayNu704AwAAAeIwwEX67oqKU3qZG0nTsNCAMA4DHWC4RDyXF1PJFS77h9Ow0IAwDgMToD4eFK+mworTNDaat2GhAGAMBjdAbCp2c8p+P9E9Ys/CQMAIDHCAPhNJIuqLk3acV/P8IAAHiMaYLwSudLaulJKpkrmi7FU4QBAPAQZwyEX77kqLU3pcGJvOlSPEMYAAAP0RWIBsd19Wn/hLrHsqZL8QRhAAA8ZMN8s006hjM6M5Q2XUbZEQYAwEN0BqJl4+pqbV1Xa7qMsoubLgAAoozOQDSsqq7U7g31WlcbzWEzms8KAAKCMBBu8YqYdqyv06Y11aqIxUyX4xnCAAB4iGmC8Nq8pkY71teqqjL6M+qEAQDwULZAGAibNTVx7d5QpzU19gyR9jxTAPBZoeTIseh8+7CrqqzQzvW12ri6WrEITwnMhTAAAB5hvUA4xCQ1ra3R9vV1ilfYFQKmEQYAwCOsFwi+dbVx7d5Qr1XVlaZLMYowAAAeoTMQXNXxCu1urNMVq6pNlxIIhAEA8AiLB4MnFpO2rqvV1nW1qrR0SmAuhAEA8AjTBMGyvr5KuxvrVFdl95TAXAgDAOARpgmCobaqQrsb69VYX2W6lMAiDACAR+gMmFURi2lbQ622rKuJ9OmB5UAYAAAP5DljwKgrVlVrZ2OdauPRPz2wHAgDAOABugJm1FdXandjnRrqmBJYCsIAAHiAnQT+qqyIaXtDrZrWMiWwHIQBAPAAiwf9s3F1tXaur1M1UwLLRhgAAA8wTeC91dWV2r2hXmtrGcpWilcQADxAZ8A78YqYdq6v06Y19l0o5BXCAAB4gM5A+cUkbVpTox3ra1VVyZRAOREGAMADhIHyWlMT154NdVpdw7DlBV5VACizfJEzBsqlurJCOxvrtHE1Fwp5iTAAAGXGeoGVi8Wkq9bWaltDreJcKOQ5wgAAlJnjuqqrqlS+5Kjk0CFYqoa6uHY31qu+mguF/BJzXXpZAOAVx3WVL7kqlBwVpn4+/2vHVb44+fP04zariVdoV2OdrljFlIDfCAMAEBCO66pYcidDwlzhYfrXU+EhKn97V8Ri2rKuRlvX1aqSKQEjCAMAEFLnA4Iz+fOcHQjHUb7oBnZBY2N9lXY11qmuiikBkwgDAGCBknPp1MSF7sPsDkTRh3UOdVWTFwqtr+dCoSAgDAAAZnHcCwFhsuMwva5h7mmLpQwiFbGYtjXUass6LhQKEsIAAGDZXNdVcSoo5KeCQnFqaqLgzA4Oa2ri2tVYpxouFAocwgAAAJYjngEAYDnCAAAAliMMAABgOcIAAACWIwwAAGA5wgAAAJYjDAAAYDnCAAAAliMMAABgOcIAAACWIwwAAGA5wgAAAJYjDAAAYDnCAAAAliMMAABgOcIAAACWIwwAAGA5wgAAAJYjDAAAYDnCAAAAliMMAABgOcIAAACWIwwAAGA5wgAAAJYjDAAAYDnCAAAAliMMAABgOcIAAACWIwwAAGA5wgAAAJYjDAAAYDnCAAAAliMMAABgOcIAAACWIwwAAGA5wgAAAJYjDAAAYDnCAAAAliMMAABgOcIAAACWIwwAAGC5/w8O2bnbkHMFRQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "xgi.draw_hyperedges(H, pos=pos)" - ] - }, - { - "cell_type": "markdown", - "id": "12d7fa53", - "metadata": {}, - "source": [ - "Notice that this function returns a tuple `(ax, collections)` where `collections` is a tuple `(dyad_collection, edge_collection)`. The collections can be used to plot colorbars as we will see later." - ] - }, - { - "cell_type": "markdown", - "id": "4e879854", - "metadata": {}, - "source": [ - "The color, linewidth, transparancy, and style of the hyperedges can all be customised, for example with single values:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "b4ed641d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(,\n", - " (,\n", - " ))" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAuD0lEQVR4nO3da2ybeWLf+x9J3SVblmRLtkcee2yPZzz2jDO7M50xspud3WwyWRQo2qBp0E2aAk3Rbpps+uK86JvTAsXJiyA5aNDsIpcGTXtO8yJtNnlTJChOc7a78XXG9/tdF1IkRYkU73c+z9MXXMtjj2RLMsk/yf/3AximJerhzx6M+NP/9vg8z/MEAACs5TcdAAAAmEUZAADAcpQBAAAsRxkAAMBylAEAACxHGQAAwHKUAQAALEcZAADAcpQBAAAsRxkAAMBylAEAACxHGQAAwHKUAQAALEcZAADAcpQBAAAsRxkAAMBylAEAACxHGQAAwHKUAQAALEcZAADAcpQBAAAsRxkAAMBylAEAACxHGQAAwHKUAQAALEcZAADAcpQBAAAsRxkAAMBylAEAACxHGQAAwHKUAQAALEcZAADAcpQBAAAsRxkAAMBylAEAACxHGQAAwHKUAQAALEcZAADAcpQBAAAs12M6AIAO4XmSz/fkz7duSUtL0oED0vS01NtrLBqAl0MZAPBCqcKKRvq3qSfwmTf8P/xD6TvfqT/2+6W9e+vFYP/+J7/v3y+98Ub9dwBtizIA4LlmkjO6HbupI7ve1JGJI08+MT//5LHrSgsL9V+nTz99gb//96U/+7OnP/abvylt2/Z0adi2rWl/BwDPRxkAsKaqU9WVxSuK5WKSz6dHK490YMcB9QX66k/45jel11+X5ubqxWBuTorHP3+hAwee/rPrSv/m30jV6tMfHxt7uhzs3y/97M8yqgC0gM/zPM90CADtJVlM6lL0korV4lMfPzh2UMcmj63/hfm8FAw+KQjz89JHH0kff/zkOeFwfY3BRnz/+9JXv/rkz+fOSb/xG0+XhsePp6aeXtMAYMMYGQCwyvM8zSRndCd+R2v9nDCXmtPBsYMa7B1c+wLDw9LRo/Vf6xkfl/76r58uDI9HFhYWJMd58txnRwVu3pT+6q/Wvm5//5OC8Oab0u/+7rN/OcoCsA7KAABJUsWp6Ori1fq0wDpcz9X9xH2d2H1i6y80OCj95E+u/blaTYpEnpSDffue/nwwuP51y2Xp/v36r1Do85//B/9Aunjx8wscHz/et0/q69viXwrobEwTANBKcUWXIpdUqpVe+Fyfz6ePDnykkb6RFiR7huvWtzN+dp3CZ0cW5ufrUxUffyz9j//x9Ne++6509er61/b5pD17pH/1r6Rf//Xm/R2ANsTIAGAxz/P0KPlId+N315wWWO9r7sbv6r297zU53Rr8fmn37vqvDz9cK5y0slIvBM8aG6v/SibXvrbnSZGIqk5VnJgA21AGAEtVnIquRK9oKb+06a+NZqNKlVLaMbCj8cFehs8nTUzUfz3r+9+v/57JfH40YX5e7tysarOPlJoa1WRLQwPmMU0AWGgz0wLr2TW8Sx9Or/HTeQcKZ8K6sXRDVaeqd6be0f4dbGeEXRgZACzieZ4erjzUvcS9DU8LrGc5v6x4Ia6dQzsblK71qk5V12PXFclGVj/mY8cBLMSNigBLlGtlfRL+ZFPrA17kzvKdhlzHhOX8sn4w94OnigBgK0YGAAskCgldjl5+qWmBtaRKKS3mFrV7ZHdDr9tMjuvoTvyOZpOza37eJ0YGYB/KANDFPM/Tg5UHup+437DRgGfdjd/V1PBURwyvp0tpXY5eVq6SMx0FaCuUAaBLlWtlXVm8ouX8clNfJ1vOaiGzoH2j+178ZEM2s1aiE0oN0GiUAaALxQtxXY5eVrlWbsnr3Uvc0yvbX5Hf137LkPKVvK4sXlGyuM75As9gmgA2ogwAXeTxtMC9+L2Wvm6xWtR8al6vjb3W0td9kWA6qJtLN+W4zoufDFiMMgB0iXKtrMvRy4oX1riNcAvcT9zXvtF96vGb/7ZSrpV1LXbtufdZAPCE+f9rAby05fyyrixeadm0wFoqTkWzyVm9PvG6sQyStJhb1LXFa6o4lS19PWsGYCPKANDBPM/T/cR93U/cNx1FkvRw5aH279ivvkDr7/5Xc2u6tXRLwfRz7my4AawZgI0oA0CHKtVKuhy9rEQhYTrKqppb08OVh3pr11stfd2V4oquRK+oUC209HWBbkEZADrQcn5Zl6OXtzwU3kyzyVkdHDuogZ6Bpr+W67m6n7ivhysPG3aOAtMEsBFlAOggnufpXuKeHiQemI6yLtdzdS9+Tyd2n2jq6+QqOV2OXla6lG7q6wA2oAwAHaJUK+lS5JJWiiumo7xQKBPS4fHDGu4bbvi1Pc/TXGpOt5dvy/Xchl+fNQOwEWUA6ABL+SVdiV5py2mBtXiep7vxu/ri3i829LqlWklXF682/VRFwDaUAaCNPX5Tfbjy0HSUTYtkIzpcOqzRgdGGXe967LqqTrUh11sPawZgI8oA0KaK1aIuRy93xLTAeu7G7+qD6Q9e6hpVp6obSzcUzoQblArAsygDQBuK5WK6snil6T8FN9tSfkmJQkITQxNb+vp4Ia4r0SsNv/Xy87BmADZqv7uKABZzPVe3l2/r0/CnHV8EHrsTv7Ppr3E9V7eWbulc6FxLiwBgK0YGgDZRrBZ1KXppw3fX6xTJYlKxXExTI1Mben6mnNHl6GVly9kmJ1sbawZgI8oA0Aa6ZVpgPXfidzQ5PPncN1rP8/Qo+Uj34veasmVwo5gmgI0oA4BBrufqzvIdzSRnTEdpqmw5q3A2rOnt02t+vlAt6Er0SkcvlgQ6GWUAMKRQLehy9HLXTQus5178nvZu2yu/7+mlSqF0SDeXbqrm1gwlexrTBLARZQAwYDG3qKuLV7t2WmAthWpBwXRQB3YckFS/5fG1xWtazC2aDQaAMgC0ki3TAuu5n7ivfdv3KV6I61rsmsq1sulIn8OaAdiIMgC0SKFa0KXIJaVKKdNRjClUC/qrB39lOgaAZ1AGgBaIZqO6Frtm1bTAs3KVnB4lH6nm1nRi6oR6/O357Yc1A7BRe/7fCHSJx4cIzSZnTUcxxvVcRbIRRXNReZ4nqV6O9o3uM5wMwGOUAaBJ8pW8LkUvKV1Km45iTLFW1ExyRvlK/qmPL+YXNTUypb5An6Fk62PNAGxEGQCaIJqN6uri1bbZLmdCLB9TKB1a8wAhz/MUzob12o7XDCR7PqYJYCPKANBAj8/Un0vNmY5iTMWpaCY1o0wp89znxfNx7RnZo4GegRYlA7AeygDQIEwLSCvFFc2mZuW4zguf68lTOBPWofFDLUgG4HkoA0ADRLIRXVu8Zu20QM2taT49r0QhsamvSxQT2lPdo6HeoSYl2zzWDMBGlAHgJbieq5tLNzWfmjcdxZhMOaOZ5IwqTmVLXx/KhPTGxBsNTrV1rBmAjSgDwBblK3ldjFxUpvz8ufFu5XquFrILWsy+3HHC6VJa2XJW2/q3NSgZgM2iDABbEM6EdT123dppgUK1oJnkjArVQkOuF8qE9NautxpyrZfFNAFsRBkANsFxHd1cuqlgOmg6ihGe52kxv6iFzMLqAUKNkKvklCwlNTYw1rBrAtg4ygCwQblKTpcil6ydFig7Zc0kZ5QtZ5ty/XAmrB39O4zP2Zt+fcAEygCwAQuZBV2PXd/QlrluFC/ENZ+al+M17+9fqBa0UlzRxNBE014DwNooA8Bz2D4tUHWrmkvNKVlMtuT1FrILGhsck9/nb8nrrYU1A7ARZQBYR66S08XIxaYNi7e7dDmtmeRMS++0WK6VFS/ENTk82bLXfBbTBLARZQBYQygd0o2lG1ZOCzieo1A6pKX8kpHXD2fDmhicUMAfMPL6gI0oA8BnOK6jG0s3FEqHTEcxIlfN6dHKI5VrZWMZqk5VsXxMe7ftNZYBsA1lAPiRbDmrS9FLVk4LeJ6nSC6iSDbS0C2DWxXNRTU5PKkef+u/RbFmADaiDACye1qgVCtpJjmjXCVnOsoqx3W0mFvU9Pbplr82awZgI8oArFZza7oRu6GFzILpKEYs5ZcUTAfleq7pKJ+zmFvU5PCk+gJ9pqMAXY8yAGtlyhldilxqq5+IW6XqVDWbmlWqlDIdZV2u5yqSjejAjgMtfV2mCWAjygCsFEwHdSN2oy1/Im62ZCmp2eRsR9xXYTm/rD0je9Tf0286CtDVKAOwSs2t6XrsusKZsOkoLed4juZT84oX4qajbJgnTwvZBR0aO9Sy12TNAGxEGYA1MuWMLkYuKl/Jm47SctlKVjMrMyo75rYMblWikNCekT0a6h0yHQXoWpQBWGE+Na+bSzetmxZwPVfhbFjRbNR0lJeykFnQkYkjLXkt1gzARpQBdDWbpwWK1aIeJR+pUC2YjvLSUqWUsuWstvVva/prMU0AG1EG0LXSpbQuRS9ZNy3geZ5i+ZhCmVBbHCDUKAvZBR3tP2o6BtCVKAPoSnOpOd1aumXdtEDZKWs2OatMOWM6SsNly1mlSintGNhhOgrQdSgD6CpVp6rrseuKZCOmo7RcopDQXHquq09RXMgsaLR/tKlD+awZgI0oA+gatk4L1Nya5tPzShQSpqM0XaFa0EppRRODE017DdYMwEaUAXSF2eSsbi/ftm5aIF1OayY5o6pTNR2lZRYyCxobGJPf5zcdBegalAF0tKpT1bXYtY7fOrdZjudoIbOgWC5mOkrLlWtlxQtxTQ5Pmo4CdA3KADpWqpTSpcilrtg6txn5al6PVh6pVCuZjmJMOBvWxOCEAv5AQ6/LFAFsRRlA5/mv/1WzH76p2+UFq6YFPM9TNBdVOBvuqi2DW1F1qlrKL2nPtj0NvS6LB2ErJt3QUcrBWXnf/KbuR+y6yVDZKetO/I4WMgvWF4HHIrlIR9xsCegEjAyg7Xmep3ghrmA6qN7/8v9o+sQRBSZ3a8QfkOd5KtQKeuP//s8aXIwr9tH7Wv7SF1QdHTEdu2GWC8sKpoJyvO7dMrgVjutoMbeo6e3TDbsm0wSwFWUAbatYLSqYDiqUCalYLUqShr/4lrIH9qpYK64+b1vviF7973+j/sVlTf/3H8oN+JV8903FPnpfsa+8r9zhfVIHfpOvOlXNpeaULCVNR2lbi7lFTQ1PqTfQazoK0NF8HmOOaCOu52oxt6hgOqjl/PKGvmYwvKSv/J1vqzdfXPPzhb2Tin30npY+el/xD96W29/XyMhNkSqlNJuatWrL4FZNDU9p/479DblWj79H33j9Gw25FtBJKANoC5lyRsF0UAuZhS29AfoqVY1fvq2pH1zU1A8uamRu7RsTXfrT31Hkxw69bNymcTxHwVRQy4WNFSHUh/bfmXxH/T39L30tygBsRRmAMVWnqkg2omA6qFQp1dBrD89FNPnDC5r64UVNXLglf7Wm6ug2PbhzWqPDE3I8RyvFFfm/9+cauHVfS195T8l3XpcCjd2qthm5Sk6Pko9UrpWNZehUE0MTOjT28iWvN9Crnzn8Mw1IBHQWygBaLlFIKJgOKpKNtGRHQCBX0K6zV9WXzCj48/Vv9L2BXu0a2qVjv/R/aOD//6EkqTq+Q8s/8Z6iP/Gulr70rmrbW7MI0fVcRbIRRXNRdgq8hOOTxzXUO/RS16AMwFaUAbREqVZSKB1SKBNqm3sH+MsV/czf+qYC5crnPucFAsr9rROKfPldRb7yBeUOTjdlEWKxVtSj5CMVKnYdnNQMYwNjen3i9Ze6Rl+gTx8f/rhBiYDOQRlA07ieq6X8koLpoJbyS235U2//0oomT13S1A8uateZq+oprL0Icfm7v6W5v/uREsVEQxb1eZ5X/7fJBNvy36VTvbXrLY30bX1EhzIAW1EG0HC5Sm51MWAnzX/7K1WNX7ylqR9e1OQPLmhk/sn9DkLXT2vizXc12DOoTDmjzKenVP3krOZOvqX8rtFNvU7FqWgmNaNMKdPov4L1tvVv09GdR7f89f09/frpQz/dwERAZ6AMoCFqbk2RbEShdEgrxRXTcRpieDasqR9e1MijkK7/X78mqf5mMzU8pQO/8V0N/u7vSZJqJ95R+utfVvQr7yp4ZEqO1v9fKlFMaC41J8flAKFmeWPiDY0ObK6gPTbQM6CfOvRTDU4EtD/KAF5KsphcXQxo09GwX/3Gr2hk9vPbF73JSZV/6mta+dqHCn1wVPHeqlzPVc2taT49r0QhYSCtXYZ6h3R88viWvpYyAFtRBrBp5VpZC5kFBdNB5So503Faz/O048YDTf7goqZ+cEE7bj9a+3k9PXJ/+7d0/xe/obOhs1rOLytfyct7zsgBGuPw+GGND45v+usoA7AVZQAb4nle/Yz8dFCLuUUWvX1Gfyyhqb+5pMkfXtSus1fVU3hya+Hl7/2/unxiUhWnvmPBcR1lK9n6uoNyxrrbL7fKQM+A3p58e9P3GhjsHdTXD369SamA9kUZwHMVqoX6/QHSIZVqpRd/geX8laomPr2pyR9e1M5Prqty7rQmxl5RtpLVSnFFK8UVJQqJ1X/LmltTtlwvB9lKlnLQQK/teE27hndt6muGeof0kwd/skmJgPZFGcDnPL4bXDAdVLwQNx2no304/eGab0iFakGJQqJeDoqJ1bMXqk5VmUpmtSBQwLauN9CrE1Mn5Pdt/E7tlAHYirsWYlW6lFYwHVQ4G+YGOQ2y3vqAod4hDY0Oad/oPkn1Q5k+O3KQKde3HVacymoxyJQzKjuds1XTtKpT1VJ+SbtHdm/4a7iFMWxFGbBc1amuLgZ8/AaExtnoccsDPQPau22v9m7bK6n+32W1HBQTSpVS8jxP5Vq5Xgwq9XJAaXu+SDaiXUO7FPCbu+cE0AkoAxbyPE/xQlyhTEjRbLQl9wew1VZn4XoDvZoamdLUyJSk+tRNspRcHTlIlpJyXEelWqm+3uBHowdVl3LwWTW3pmguqunt0xt6vk+MDMBOlAGLFKtFhTIhhdIhFqq1SKO2EQb8Ae0c2qmdQzulifqIQ7qUXh05WCmuqOpUVagWVhcjZsoZDjeSFMvFNDU8pd5Ar+koQNuiDHQ513NXFwMu55dNx7FOs9bn+n1+jQ2OaWxwTId0SJ7nre5YeLwwsVgtqlgrrq43yJazcjz7yoHjOYrmonp19NUXPpc1A7AVZaBLZcvZ1fsDPN7jjtZr1RSMz+fT9v7t2t6/XQd2HJAk5Sv5p9Yd5Mo55av51XKQq+SsmSKK5eujA/09/c99HtMEsBVloIvU3JrCmbCC6aBSpZTpOFDjpgm2YrhvWMN9w+vuWEiVUspX8qvTCtlKtmsPk/I8T+FsWAfHDpqOArQlykAXWCmurN4fgDni9tJOb64v2rGwUlx5ahtjtx2dnCgktHtkt4Z6h0xHAdoOZaBDlWtlhTIhBdPB1QNr0H7aeRj+RTsW4oW40qX0U0cnd3I58FQfHXh9/PV1n8OaAdiKMtBBPM9TLB9TKB1SLB9rq586sbZOevN80Y6FpfzSU6MHnbgjJVlMKlfJaaRvZM3Ps2YAtqIMdIB8JV+/P0AmpHKNE+g6SScXthftWIjlYlouLK/uVCjWiqYjb8hCZkFv7nzTdAygrVAG2pTjOopkIwqmg1oprpiOgy1q52mCzXrejoVEMaHF3KIWs4urJyS2a3F9PO2xvX/75z7HNAFsRRloM8licnUxYM2tmY6Dl9RJ0wRb8bwdC5FMROFsePXNt522uIbSIR2bPGY6BtA2KANtoOJUVu8PkC1nTcdBA3XyNMFWfHbHwvHJ40/tWAhn69teM6WM8aOT89X6iMb44PhTH2fNAGxFGTDE8zwtF5YVTAcVy8W6ajgZT3T7yMCLfHbHwtFdR5/asRBK13fDJEtJZcvZlo+ELWQWNDYwxtQAIMpAyxWqBYXSIYUyIRWrnbHgCltHyXvaZ3csHJk4srpjIVFIKJgJaj41r2QxqUyl+fdVKNVKihfi2jW8a/VjFAPYijLQAq7nKpqNKpgOKl6Im46DFrJtmmCzPrtj4fDE4dUdC4lCQsF0UHOpOS0XlpUtZ5tSrMLZsCaGJuT3+Rt+baCTUAaaKFPOrN4fgPvO28n2aYLN+uyOhdfGXtNX9BXlK3nFC3HNp+c1l5pTLBdr2NHJFaeipfySdo/srr8+awZgKcpAg1Wd6upCqXQpbToODGOa4OU93rGwf8d+/cT+n1gd3p9NzmouNadINqJ8Nb/lchDJRrRraJcC/gDTBLAWZaABPM9Tolgf1oxmo7wBYBXTBI030DOg6e3Tmt4+rS/v/7KqTlXL+WXNpurlYCG7oHx54/dVqLk1LeYW9cr2V5qcHGhflIGXUKqVVldEd+LRrGg+pgmarzfQq73b92rv9r368Vd/XI7raLmwrNnkrGaTs1rILrxwy+5iblGTw5NME8BalIFNcj1XsVxMwXRQy4VlfvLDczFK1HoBf0C7R3Zr98hundx3Uq7nKp6PayY5o9nUrEKZ0OfKgeM5iuaijA7AWpSBDcqWs6uLAdvpJDW0N8qieX6fX5Mjk5ocmdSH+z6U53mKF35UDpKzCmbqh33F8jGVnfY8QhloNp/Hd6t11dza6v0BksWk6TjoQHu27dF7e98zHQMvkCgk9CjxUDvOXdGRP/3/pN/6LenwYdOxgJZhZGANK8WV1fsDNPvgE3Q3unZnmBia0MR/+Z70rV+pf2D/ful3fsdsKKCFGBn4kXKtvHp/gFwlZzoOusTk8KQ+mP7AdAxsRCIhTU9LpZK0fbsUDksjI6ZTAS1h9bFbnucplovpQviC/ufM/9Tt5dsUATQUuwk6yMSE9Au/UH+cyUh/8idm8wAtZOXIQL6SVygTUigdUqlWMh0HXWzn0E6d3HfSdAxs1NWr0rvv1h8fOybduCFxEBEsYM2aAcetbx0KpoNKFBKm48ASbC3sMD/2Y9KXviSdPi3duiX9r/8lfe1rplMBTdf1ZSBVSimYDiqcCbf8FqkA0wQd6NvfrpcBSfrOdygDsEJXThNUnIrCmfr9ATLljOk4sNiOgR368v4vm46BzahWpQMHpEhE8vulmZn67gKgi3XlAsJ78Xu6uXSTIgDjmCboQL290re+VX/sutLv/77ZPEALdGUZOD55nGNF0RaYJuhQ/+yfSX199cfXrpnNArRAV64Z8Pl8enf3u3JcR4u5RdNxYLEunIWzw9SU9O//fX1nwQecE4Hu15VrBh5zPVcXwhe0lF8yHQWWGu4b1tdeYwEagPbWldMEj/l9fr239z3tHNppOgosxZoBAJ2gq8uAVL+d6fuvvK+xwTHTUWChLh54s4vnSffumU4BNE3XlwFJ6vH36INXPtDowKjpKLAMCwi7wH/7b9IXviAdP17fbgh0ISvKgCT1Bnr14fSH2ta/zXQUWIRpgi5w40b9mOJaTfqDPzCdBmgKa8qAJPUF+nRy+qSG+4ZNR4ElmCboAt/6lhQI1B//4R9K5bLZPEATWFUGJKm/p18np09qsHfQdBRYgGmCLvDKK9LP/mz98dKS9L3vmc0DNIF1ZUCSBnsHdXL6pAZ6BkxHQZdjZKBLfPvbTx5/5zvmcgBNYmUZkOr7v0/uO6m+QJ/pKOhirBnoEl/6knTiRP3xJ59IFy6YzQM0mLVlQJJG+kZ0ct9J9QZ6TUdBF2N0oAv4fIwOoKt19QmEG5UqpXQudI5bHKMp/vaRvy2/z+re3R0KBWl6Wkom6/ctCIWkyUnTqYCG4DuU6reZ/WD6AwX8AdNR0IXo211iaEj6p/+0/rhSkf7oj8zmARqIMvAj44Pjen/v+/wEh4Zj3UAX+Rf/oj4q8HM/J33966bTAA3DNMEzYrmYLkQu8NMcGubjwx+zULWbJJPSGMebo7vwY/Azpkam9IU9X5DP5zMdBV2CYtllKALoQpSBNezdtlcnpk6YjoEuwcFDANodZWAd+0b36Z2pd0zHQBdgzUCXKpelP/kT6bd/23QS4KX1mA7Qzvbv2C/Hc3Rr6ZbpKOhgTBN0IdeV3n5bevBAGhyUfvmXpfFx06mALWNk4AUOjh3UGzvfMB0DHYxpgi7k90vf+Eb9cbEo/cf/aDYP8JIoAxtwZOKIDo8fNh0DHYppgi71q7/65PHv/Z7kOOayAC+JMrBBR3cd1Wtjr5mOgQ7ENEGXOnJE+vjj+uO5Oekv/9JoHOBlUAY24diuY3p19FXTMdBhmCboYtyvAF2CMrAJPp9P70y9o1e2v2I6CjoI0wRd7BvfkA4dqj/+67+W7twxmwfYIsrAJvl8Pr27+13tHtltOgo6BNMEXczvf3rtwHe/ay4L8BI4jniLXM/VhfAFLeWXTEdBmzu576R2Du00HQPNkkpJr7xSv6vh8LAUDkujo6ZTAZvCyMAW+X1+vbf3Pb7J44Xo211uxw7pH/2j+uNiUfqbvzEaB9gKDh16CQF/QO+/8r7OL5xXspg0HQdtijUDFvj1X6+Xgl/5FWn/ftNpgE1jmqABqk5V5xbOKV1Km44CA3r8PeoL9Kk30Ku+QF/9sb939WN7RvZosHfQdEwAWBdloEEqTkVnQ2eVLWdNR8EW9fh7Vt/QP/tmvtYb/OM/9wZ65fcx2wags1EGGqhcK+tM6IzylbzpKFYL+AOrb9zPvnk/7w2eN3U0TLVaXz+wfbvpJMCGUAYarFgt6kzojIrVoukoHc/v86/5Zv68N/hef68C/oDp6LBVKlU/fOgP/kD6+Z+X/t2/M50I2BDKQBPkK3mdDZ1VqVYyHaUt+H3+5755r/cGz5s6Ok48Lk1P129vPDoqLSxIIyOmUwEvRBloklwlpzPBM6o4FdNRGsbn8234p/PPPqfHz6YVWOSf/BPpP/2n+uPf/33pW98ymwfYAMpAE2XKGZ0NnVXVqZqO8pTHb+qbHX7vDfSajg60v8uXpS9+sf742DHpxg3J5zObCXgBykCTpUopnQudU82tNeX6Wxl+7/H3yMc3J6B5fvzHpbNn64+//33pq181mwd4AcpAC6wUV3R+4bwcd/37nb9or/pab/C9/l7e1IF29Kd/Kv3Df1h//Pf+nvQXf2E2D/AClIEWWSmuKFVKsVcdsEG1Wj+JMBqt38xoZoaTCdHWeAdqkfHBcR0cO6h9o/s0NTKl8cFxjfSNqL+nnyIAdJve3icLB123vpAQaGOMDABAMywuSq++Wh8lmJiQQiFpkGOp0Z74kRQAmmH3bunnfq5+3sAv/ZJU4twRtC9GBgCgWaJRads2Dh5C26MMAABgOaYJAACwHGUAAFohHpd+8zelSMR0EuBzODQeAJrtz/9c+oVfqN/AqFiU/u2/NZ0IeAprBgCg2RYWpAMHJMeRpqakYFDq6zOdCljFNAEANNv0dP1YYkmKxaQ/+zOzeYBnUAYAoBW+/e0nj7/7XXM5gDUwTQAAreB50okT9VsaS9KFC9J775nNBPwIIwMA0Ao+39OjA9/5jrkswDMYGQCAVikU6usHksn6AsJQSJqcNJ0KYGQAAFpmaEj65V+uP65UpD/6I7N5gB9hZAAAWmlmRjp8uL6G4M03pdu361MIgEGUAQBotX/5L+uF4B//Y2n7dtNpAMoAAAC2Y80AAACWowwAgGmViukEsBxlAABMuXlT+uf/XHrlFWllxXQaWIwyAACm/If/UP8Vj0t//Mem08BiLCAEAFPu35feeKP++MAB6eFDKRAwGgl2YmQAAEw5ckT6+OP647k56S//0mgc2IsyAAAm/dqvPXnM3QxhCNMEAGCS49RHCGZm6n++c6d+MiHQQowMAIBJgYD0q7/65M+MDsAARgYAwLRksn43w0JBGhmRwmGOKUZLMTIAAKaNjUm/+IvyDhyQ86//T8nPt2a0FiMDANAOMhkV+/w6H72gD6Y/0FDvkOlEsAj1EwDawfbtKrhl5So5nZo/pZUiJxKidSgDANAmirWiJKniVHQudE7hTNhwItiCMgAAbaJQLaw+dj1Xl6OXdT9x32Ai2IIyAABt4rNl4LF78Xu6HL0s13MNJIItKAMA0CbWKgOSFM6EdS50ThWHWx2jOSgDANAmitXiup9bKa7o1Pwp5Sq5FiaCLSgDANAGPM9bXUC4nkK1oNPB01rOL7coFWxBGQCANlCqlbSRY1+qTlWfhD9RMB1sQSrYgjIAAG1gvfUCa/E8T9cWr+n28u0NFQjgRSgDANAGNlMGHnu08kgXIxfluE4TEsEmlAEAaANbKQOStJhb1JnQGZVqpQYngk0oAwDQBl60ePB50qW0Ts2fUrqUbmAi2IQyAABtYKsjA4+VaiWdCZ1RLBdrUCLYhDIAAG3gZcuAJDmuo0/Dn2omOdOARLAJZQAADHM9t6Fz/reWbul67DpHGGPDKAMAYNhGzxjYjPnUvD4Nf6qqU23oddGdKAMAYFgjpgjWspxf1pnQmaZdH92DMgAAhjXzzTpbzurU/Ckli8mmvQY6H2UAAAx73g2KGqHiVHQ2dFbhTLipr4PORRkAAMNaMYzveq4uRy/rfuJ+018LnYcyAACGtXJO/178nq5Er7DTAE+hDACAYa1e4LeQWdC50DlVnEpLXxftizIAAAY1+oyBjVoprujU/CnlKrmWvzbaD2UAAAxq9uLB5ylUCzodPK14IW4sA9oDZQAADHqZGxQ1QtWp6vzCeQXTQaM5YBZlAAAMaocDgTzP07XFa7q9fLvhJyGiM1AGAMCgdigDjz1aeaSLkYtyXMd0FLQYZQAADGqnMiBJi7lFnQmdMbKoEeZQBgDAIJMLCNeTLqV1av6UMuWM6ShoEcoAABjUbiMDj5VqJZ0OnlYsFzMdBS1AGQAAQ0ydMbBRjuvoQuSCZpIzpqOgySgDAGBIO04RPMvzPN1auqUbsRvsNOhilAEAMKRdpwjWMpea0yfhT1R1qqajoAkoAwBgSCeVAUlazi/rTOhMx+XGi1EGAMAQ06cPbkW2nNXp4Gkli0nTUdBAlAEAMKRTf8Iu18o6GzqrSDZiOgoahDIAAIZ0ahmQ6jshLkUu6UHigekoaADKAAAY0sll4LG78bu6Er0i13NNR8FLoAwAgAGO66hcK5uO0RALmQWdC51TxamYjoItogwAgAGduHjweVaKKzodPK1cJWc6CraAMgAABnTCgUObla/kdTp4WvFC3HQUbBJlAAAM6Ib1AmupOlWdXzivYDpoOgo2gTIAAAZ0axmQ6kcYX1u8pjvLdzjCuENQBgDAgG4uA489XHmoS9FLclzHdBS8AGUAAAzotgWE64lmozobOtvWd2cEZQAAjLBhZOCxVCml08HTypQzpqNgHZQBAGixbjpjYKOK1aLOBM8olouZjoI1UAYAoMVsmSJ4Vs2t6ULkgmaTs6aj4BmUAQBoMZumCJ7leZ5uLt3UjdgNdhq0EcoAALSYzWXgsbnUnD4Nf6qaWzMdBaIMAEDLUQbqlvJLOh083ZWnMXYaygAAtBhvfk9ky1mdCp5Sspg0HcVqlAEAaDFGBp5WrpV1NnRWkWzEdBRrUQYAoMUoA5/neq4uRS7pQeKB6ShWogwAQAvV3JoqTsV0jLZ1N35XVxevyvVc01GsQhkAgBZivcCLhdIhnV84T2lqIcoAALQQUwQbkygkdDp4WvlK3nQUK1AGAKCFbD19cCvylbxOBU8pUUiYjtL1KAMA0EKMDGxO1anq/MJ5hdIh01G6GmUAAFqIMrB5rufq6uJV3Y3f5QjjJqEMAEALUQa27kHigS5FL8lxHdNRug5lAABaiN0ELyeajeps6Kx1t4BuNsoAALQIZww0RqqU0qngKWXKGdNRugZlAABahCmCxilWizoTPKOl/JLpKF2BMgAALcIUQWPV3Jo+DX+q2eSs6SgdjzIAAC3CyEDjeZ6nm0s3dXPpJjsNXgJlAABahDLQPLPJWX0a/lQ1t2Y6SkeiDABAi1AGmmspv6QzwTNMx2wBZQAAWoSjiJsvU87oVPCUUqWU6SgdhTIAAC3CyEBrlGtlnQ2dVTQbNR2lY1AGAKAFqk5VVadqOoY1HNfRxchFPVx5aDpKR6AMAEALMEVgxp3lO7q6eFWu55qO0tYoAwDQAkwRmBNKh3R+4TwjM89BGQCAFqAMmJUoJHQqeEr5St50lLZEGQCAFmC7m3n5Sl6ngqeUKCRMR2k7lAEAaAFGBtpD1anq/MJ5hdIh01HaCmUAAFqAMtA+XM/V1cWruhu/yxHGP0IZAIAWYDdB+3mQeKDL0ctyXMd0FOMoAwDQZJwx0L4i2YjOLZxTuVY2HcUoygAANBlTBO0tWUzqVPCUsuWs6SjGUAYAoMmYImh/xWpRp4OntZRfMh3FCMoAADQZIwOdoebW9Gn4U82l5kxHaTnKAAA0GWWgc3iepxuxG7q1dMuqnQaUAQBoMspA55lJzuhC5IJqbs10lJagDABAk3H6YGeK5WI6EzxjxX8/ygAANBkjA50rU87oVPCUUqWU6ShNRRkAgCaqOlVrhpq7VblW1tnQWUWzUdNRmoYyAABNxKhAd3BcRxcjF/Vw5aHpKE1BGQCAJqIMdJc7y3d0a+mW6RgNRxkAgCaiDHSX6e3TOjR+yHSMhusxHQAAuhmnD3aH7f3b9fbU2xofHDcdpSkoAwDQRIwMdLbeQK/e3Pmm9o/ul8/nMx2naSgDANBElIHOtX/Hfr258031BfpMR2k6ygAANBFloPOMDY7p+ORx7RjYYTpKy1AGAKBJKk5FjuuYjoEN6u/p19GdRzW9fbqrpwTWQhkAgCZhVKAz+Hw+vbbjNR2ZOKLeQK/pOEZQBgCgSSgD7W/n0E4dnzyubf3bTEcxijIAAE1iww1uOtVAz4COTR7T3m17TUdpC5QBAGgSRgbaj9/n16HxQ3p9/HUF/AHTcdoGZQAAmoQy0F6mRqZ0bNcxDfcNm47SdigDANAklIH2MNw3rGO7jmlqZMp0lLZFGQCAJuEoYrMC/oBeH39dh8YPye/jVjzPQxkAgCYo18qcMWDQ3m179dautzTYO2g6SkegDABAEzBFYMa2/m06PnlcO4d2mo7SUSgDANAETBG0Vo+/R2/sfEMHdhxgSmALKAMA0ASMDLTOvtF9OrrzqPp7+k1H6ViUAQBoAspA840OjOrtybc1NjhmOkrHowwAQBNQBpqnN9CrozuP6tXRV627oVCzUAYAoAk4irjxfD6f9o/u1xs731BfoM90nK5CGQCAJmBkoLHGB8d1fPK4RgdGTUfpSpQBAGiwcq0s13NNx+gK/T39emvXW5rePm06SlejDABAgzEq8PJ8Pp8Ojh3UkYkj6vHzVtVs/AsDQIPV3JqG+4ZVrpVVc2um43ScXcO7dHzyuEb6RkxHsYbP8zzPdAgA6Fau56pcK6vslJ/6veJU1vyYzQZ7B3Vs1zHt2bbHdBTrUAYAoE14nve5klBxKuuWiW5Zl+D3+XV4/LAOjx9WwB8wHcdKlAEA6FBVp/q5krBegWjXmybtHtmtY5PHNNQ7ZDqK1SgDAGABx3U2NOJQdsqqOtWm5xnuG9bxyeOaHJ5s+mvhxSgDAICnuJ67ZllY72ObeRsJ+AM6MnFEB8cOckOhNkIZAABsmed5qrrVDRWH8cFxvbXrLQ30DJiOjWdQBgAAsBxjNAAAWI4yAACA5SgDAABYjjIAAIDlKAMAAFiOMgAAgOUoAwAAWI4yAACA5SgDAABYjjIAAIDlKAMAAFiOMgAAgOUoAwAAWI4yAACA5SgDAABYjjIAAIDlKAMAAFiOMgAAgOUoAwAAWI4yAACA5SgDAABYjjIAAIDlKAMAAFiOMgAAgOUoAwAAWI4yAACA5SgDAABYjjIAAIDlKAMAAFiOMgAAgOUoAwAAWI4yAACA5SgDAABYjjIAAIDlKAMAAFiOMgAAgOUoAwAAWI4yAACA5SgDAABYjjIAAIDlKAMAAFjufwNuUDOHCyb6YAAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "xgi.draw_hyperedges(\n", - " H, pos=pos, dyad_color=\"r\", dyad_lw=2, dyad_style=\"--\", edge_fc=\"g\", alpha=0.3\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "7eb2b443", - "metadata": {}, - "source": [ - "Or with multiple values:" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "4505c0aa", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(,\n", - " (,\n", - " ))" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "xgi.draw_hyperedges(\n", - " H,\n", - " pos=pos,\n", - " dyad_color=[\"r\", \"b\", \"orange\"],\n", - " dyad_lw=[1, 2, 5],\n", - " edge_fc=[\"g\", \"grey\", \"purple\", \"coral\"],\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "310d67df", - "metadata": {}, - "source": [ - "## Arrays of floats and colormaps" - ] - }, - { - "cell_type": "markdown", - "id": "92d32d0d", - "metadata": {}, - "source": [ - "In XGI, you can easily color hyperedges according to an EdgeStat, or just an array or a dict with float values:" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "f5631114", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ax, (dyad_collection, edge_collection) = xgi.draw_hyperedges(\n", - " H,\n", - " pos=pos,\n", - " dyad_color=[3, 1, 4],\n", - " edge_fc=H.edges.size,\n", - ")\n", - "\n", - "plt.colorbar(dyad_collection, label=\"dyads\")\n", - "plt.colorbar(edge_collection, label=\"edges\")" - ] - }, - { - "cell_type": "markdown", - "id": "56966a12", - "metadata": {}, - "source": [ - "By default, the colormaps used are \"Blues\" and \"Greys\". These can be changed:" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "a253c2e4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAf8AAAGTCAYAAAAmxxufAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABb3klEQVR4nO3deXxU9b038M/Jvs6QgMkkIUAgIaxhFQguqEQWKYXWWqH2ARX1kUtvoVbxYhWtQEGs1+WxF1BRxJabVhSslkWKJpayhSUSFgPBQAJkErLNZGaSmcnMef4IGTNknfWcmfm8X6/zqnPmnDO/M2XyPb/vbxNEURRBREREASNI6gIQERGRdzH4ExERBRgGfyIiogDD4E9ERBRgGPyJiIgCDIM/ERFRgGHwJyIiCjAM/kRERAGGwZ+IiCjAMPgTEREFGAZ/IiI/9tJLL0EQBLttyJAhXZ7z8ccfY8iQIYiIiMDIkSOxa9cuu/dFUcTKlSuRlJSEyMhI5OTk4MKFC568DVlat24dBEHAsmXLujyuu+9TCgz+RER+bvjw4aioqLBtBw4c6PTYgwcPYv78+Vi0aBFOnjyJuXPnYu7cuTh9+rTtmPXr1+Ott97Cxo0bceTIEURHR2P69Oloamryxu3IQkFBATZt2oSsrKwuj+vJ9ykFgQv7EBH5r5deegk7d+5EYWFhj45/8MEHodfr8cUXX9j2TZo0CaNHj8bGjRshiiKSk5Px29/+Fk8//TQAQKPRIDExEVu2bMG8efM8cRuyotPpMHbsWPzP//wPVq9ejdGjR+ONN97o8Njuvk+phEj2yUREAaSpqQkmk8kt1xJFEYIg2O0LDw9HeHh4h8dfuHABycnJiIiIQHZ2NtauXYt+/fp1eOyhQ4fw1FNP2e2bPn06du7cCQAoLS2FWq1GTk6O7X2lUomJEyfi0KFDXg3+7vpOHf0+lyxZglmzZiEnJwerV6/u8trdfZ9SYfAnIvKwpqYmqPr3h6aqyi3Xi4mJgU6ns9v34osv4qWXXmp37MSJE7FlyxZkZmaioqICv//973HHHXfg9OnTiI2NbXe8Wq1GYmKi3b7ExESo1Wrb+637OjvGG5qampDWPwbqKovL13Lk+8zNzcWJEydQUFDQo2t3931KhcGfiMjDTCYTNFVVeKPgW0R2EHAd0djQgGW3jkJ5eTkUCoVtf2e11JkzZ9r+OysrCxMnTkT//v3xt7/9DYsWLXKpLFIymUxQV1lQerw/FLHOd1/TNliRNu5yj77P8vJyLF26FPv27UNERITTnykHDP5ERF4SGRvrcvBvpVAo7IJVT/Xq1QuDBw9GSUlJh++rVCpUVlba7ausrIRKpbK937ovKSnJ7pjRo0c7XB5XKWKDXAr+tuv04Ps8fvw4qqqqMHbsWNs+i8WCb775Bm+//TaMRiOCg4Ptzunu+5QKe/sTEQUQnU6Hixcv2gXutrKzs7F//367ffv27UN2djYAIC0tDSqVyu4YrVaLI0eO2I7xJotodXnrqalTp6KoqAiFhYW2bfz48XjooYdQWFjYLvAD3X+fUmHNn4jIjz399NOYPXs2+vfvj2vXruHFF19EcHAw5s+fDwBYsGABUlJSsHbtWgDA0qVLMWXKFLz22muYNWsWcnNzcezYMbzzzjsAYBvXvnr1amRkZCAtLQ0vvPACkpOTMXfuXK/fnxUirHB+0Joj58bGxmLEiBF2+6Kjo9G7d2/bfke/T6kw+BMR+bErV65g/vz5qKmpwS233ILbb78dhw8fxi233AIAKCsrQ1DQD0ngyZMnY9u2bXj++efx3HPPISMjAzt37rQLesuXL4der8cTTzyB+vp63H777dizZ4/Pt4O7gzPfpxQ4zp+IyMO0Wi2USiU2ffe9Wzr8/d8hA6HRaJxq8/cXrd/pteK+Lnf4S868EnDfJ2v+RETksyyiCIsLdVhXzvVl7PBHREQUYFjzJyIin+XNDn/+hMGfiIh8lhUiLAz+DmPwJyIin8Wav3PY5k9ERBRgWPMnIiKfxd7+zmHwJyIin2W9sblyfiBi2p+IiCjAsOZPREQ+y+Jib39XzvVlDP5EROSzLGLL5sr5gYhpfyIiogDDmj8REfksdvhzDoM/ERH5LCsEWCC4dH4gYtqfiIgowLDmT0REPssqtmyunB+IGPyJiMhnWVxM+7tyri9j8CciIp/F4O8ctvkTEREFGNb8iYjIZ1lFAVbRhd7+Lpzryxj8iYjIZzHt7xym/YmIiAIMa/5EROSzLAiCxYV6rMWNZfElDP7kk0TRCkFg4ooo0IkutvmLbPMn8iH692A1fASEDgNChkEIHQqEDAOCUyAIgfljJiLqKQZ/8jl6YzOM2m/RK6gSMFYCxq9/WJFbUEIMHQqEDIFw48EAIQMhCPynTuSP2OHPOfyLSD7FbLEi//x1GE2/xo+HP4wgyzmIzecA81mguQQQNYDpMGA6/MMDAcIhhg6+kSG48UAQOhiCECnhnRCRO1jEIFhEF9r8Ob0vkbxZrSL+XVKNeoMZQCQqGlPRN+5W23O7KJpaHgDM5yA2n73xQPAdIOoBcxFgLoLY2Hq1IIghA9s0GQwFQodBCOolyb0REXkTgz/5jBNldbhW32R7XVZjQN+4KNtrQQhr6QMQOgwC7gfQ0jEQljLAfPbGA8E5oPksYK1peVBoLoHY9HfbNcSgZCB0aJsMwTAgSMV+BEQyZYUAqwu9/a0IzKo/gz/5hGJ1A85X6uz2XalvRLPFipDgzn/4ghAEhAwAQgZAwH0AAFEUAWvVjczAOYitDwSWcsB6DTBeg2jc3+YivSCGDgNCbjwUhA4FgtMgCMGeuFUicgDb/J3D4E+yd6XOgOOX69rtb7aIqNA0ITU+qoOzOicIAhCc2LLh7h+aDazalmYC81mINx4MWvoR1AOmg4DpYJuOhZEQQzJ/aDYIHQaEDIYghLtwp+Tv7hS/Qqzo2L/XmzWIBjeVxj+43ubPmj+R7NTqTThYUtPp+2W1BoeDf2eEIAUQNgEIm9CmH4ERaD5/44Hg3I0Hgu8AsREwFwLmwh/6EQjRQMIxZgSISPYY/Em2DKZm5J+vQrO18yfzq3Xdp/5dIQjhQOhIIHRkmwcCC2C5ZN+x0HwWRjEFkQz8RF7V0ubvwsI+TPsTyYfZYkV+8XU0mqxdHtdsFXGtvgn9erun9t8TghAMhAwCQgZBwI8AABfUWlyoUuM+ldeKQUQArC5O7xuoHf44PyrJjii2DOmrM5h7dPzlWr2HS9S1shoDCi7XwyLGSFoOIqKeYvAn2bl5SF93rtU3wmzpOkPgKRWaRhy8WC3JZxM5at26dRAEAcuWLev0mLvuuguCILTbZs2aZTvm4Ycfbvf+jBkzvHAH7bV2+HNlC0RM+5OsFKsbUKzWdX9gGxZrS9v/gD7RHipVx6p1RvzrfDVauyRwKgCSs4KCAmzatAlZWVldHvfpp5/CZDLZXtfU1GDUqFF44IEH7I6bMWMGPvjgA9vr8HBpRrpYEcRx/k4IzEcekqWr9Y04UdZ+SF9PlNV6d/iTxmBGXvH1LjsjEsmFTqfDQw89hHfffRdxcXFdHhsfHw+VSmXb9u3bh6ioqHbBPzw83O647q5L8sLgT7JQpzfh3xeq4eyQ22v1jTA1eyf1rzc24+viKq99HlFHtFqt3WY0Gjs9dsmSJZg1axZycnIc/pzNmzdj3rx5iI62z6zl5eUhISEBmZmZWLx4MWpqOh+S60kWUXB5C0QM/iS5liF9rtWirWLLZECe1mS24OviKhhMlnbvCQE6ZIikkZqaCqVSadvWrl3b4XG5ubk4ceJEp+935ejRozh9+jQee+wxu/0zZszA1q1bsX//frzyyivIz8/HzJkzYbG0/114muVGb39XtkDENn+SlNlixTfnr3cYTB1VVmvAwFs81+PebLEir/g6tI3NHb7PNn/ypvLycigUCtvrjtrcy8vLsXTpUuzbtw8REREOf8bmzZsxcuRITJgwwW7/vHnzbP89cuRIZGVlYdCgQcjLy8PUqVMd/hzyvsB85CFZEEURBy/WoFbfsyF93VFrmmBs9kzNw2IV8c3566jVm7o/mMgLFAqF3dZR8D9+/DiqqqowduxYhISEICQkBPn5+XjrrbcQEhLSZU1dr9cjNzcXixYt6rYsAwcORJ8+fVBSUuLSPTnDKga5vAUi1vxJMifK6nC1rrH7A3uoJfXfiEFurv23PKRUo1LbeZsqkRxNnToVRUVFdvseeeQRDBkyBM8++yyCgzufkfLjjz+G0WjEL3/5y24/58qVK6ipqUFSUpLLZXaUq6l7S4D29mfwJ0mcr3R8SF9PlNUY3B78Cy7Voby2+4cUZv1JbmJjYzFixAi7fdHR0ejdu7dt/4IFC5CSktKuT8DmzZsxd+5c9O7d226/TqfD73//e9x///1QqVS4ePEili9fjvT0dEyfPt2zN9QBK+BSp71A7bbL4E9ed7W+scNV+txBrW1Ck9mCiFD3zLH/bXk9Sqrc/5BCJBdlZWUICrKvORcXF+PAgQP48ssv2x0fHByMU6dO4cMPP0R9fT2Sk5Mxbdo0rFq1SrKx/uQ4Bn/yqjq9Cf8ucX5IX3fEG6n/9ATXa//fqbU4c03b4+PZ4Y98QV5eXpevASAzMxNiJz/SyMhI7N271wMlc47rk/ywzZ/IoxpNlpYhfRbPtrGV1epdDv6l1XqcuFzvngIRkce4OkVvoE7vG5h3TV7XbLEi/3zH4+PdrVJrRJPZ+c+5Wt+Iw987M2EJq/5E5BsY/MnjRFHEv904pK/7zwPKnZzut6qhCQcuXPdYswQRuZcVgstbIGLanzzuRFm9W4f09cTlGgMyEmMdOqfeYEJ+8XU4u0Ag2/yJvI9pf+cE5l2T11yobECxusHrn1vVYESjA00MDU1mfF1cBbOH+yMQEckBgz95zLX6Rhzz0JC+nujpSn+NJgu+Lr6ORlOgjvgl8l3entt/w4YNyMrKss2smJ2djd27d3d6/JYtWyAIgt3mzFTL7sa0P3lEvcGEAx4c0tcTZbUGZKq6Tv2bmq3IK66Crqnj+fodwaw/kfdZRQFWVyb5cfDcvn37Yt26dcjIyIAoivjwww8xZ84cnDx5EsOHD+/wHIVCgeLiYttrQQZthAz+5HaNJkvLWvcSp9CvNxihNzYjOrzjf+YtIxCuo87gno6IcvhBE5FnzZ492+71mjVrsGHDBhw+fLjT4C8IAlQqlTeK12NM+5NbeXNIX0+Ud7LMr9XaMgLhegPn6yfyZVYXU/6tk/xotVq7zWjs/m+DxWJBbm4u9Ho9srOzOz1Op9Ohf//+SE1NxZw5c3DmzBm33b+zGPzJbdy9Sp87XK5pH/xFUcSR0lqvj0AgIvdz16p+qampUCqVtu3mtQ7aKioqQkxMDMLDw/Hkk09ix44dGDZsWIfHZmZm4v3338dnn32GP//5z7BarZg8eTKuXLnike+jp5j2J7c5WV6PKzILqDU6E3TGZsS0Sf2fLK9HabXe7Z/FpD+R91kgwOLCr6/13PLycigUCtv+rtYpyMzMRGFhITQaDbZv346FCxciPz+/wweA7Oxsu6zA5MmTMXToUGzatAmrVq1yutyuYvAnt7hQ2YDvKrw/pK8nymoMGJbc8qM+c00j23ISkXRae+/3RFhYGNLT0wEA48aNQ0FBAd58801s2rSp23NDQ0MxZswYlJSUuFReVzHtTy6Tekhfd8pqW2r5JVU6fFuu8djnsL8fkfe5K+3vUhms1h71EQBa+gkUFRUhKSnJ5c91BWv+5BI5DOnrTq3ejO8qtDhZXi91UYjIzSyAi2l/x6xYsQIzZ85Ev3790NDQgG3btiEvL8+20uGCBQuQkpJi6zPw8ssvY9KkSUhPT0d9fT1effVVXL58GY899pjTZXYHBn9ymrdW6XOVtsmMXUUVUCkjPfo5rPkT+b+qqiosWLAAFRUVUCqVyMrKwt69e3HvvfcCAMrKyhAU9EM2oa6uDo8//jjUajXi4uIwbtw4HDx4sNMOgt7C4E9OaR0jrzfKY0hfZ/SmZpyvbEBESLDHgz8ReZ+rqXtHz928eXOX7+fl5dm9fv311/H66687WiyPY/Anh/0wpM8kdVG61GS2oFjdAKsVMJgsaDRZEBkW7LHPE9jfn8jruLCPcwLzrsklchzSdzOTxYJitdauSaLWIO+HFSIib2HwJ4eUVMl3SF8rs8WKYrUOxmb7vghyz1QQkeNECLC6sIkBmrFj2p96rELTiIJL8h3SB7QMuTlf2dDhcr6Nnk79B+bfECJJMe3vnMC8a3JYvcGEf12Q95A+URRxoUrXZSfEGj3n8iciYs2fuuULQ/pEiPi+Wg9NY9dL89bqTegbF+WRMrDiT91RqwdBp4tx6Ro6nc5NpfEP3l7S118w+FOXfGVIX1mNATW67tv0m8xWGEzNiArjP30if9C6Op8r5wci/gWkTomiiEPfy39I39W6RlRqe57Or9WbPBL8Bc7yQ+R1rPk7JzAfeahHCsvrUV4r7yF9ldomXK13rIw1Mn+YISLyNNb8qUMlVTqck/mQvhqdEZdrDA6fZzRboTc2Izrcvf/8A7P+QCQtK4JgdaEe68q5vozBn9ppGdJXK3UxulTfaML31Xqnz6/Vm9we/InI+yyiAIsLqXtXzvVlgfnIQ53SGMw4IPMhfQ1NZpRU6lwqoyf6MbDJn4h8Bas+ZNNktiDvfBXMMh7S12iy4EKVDlYXi2hstkJnbEYMa/9EPo0d/pzDv3wEwDeG9BmbLSiu1LptvoFavcmtwZ8L+xB5n+jiqn4iZ/ijQNU6pK8n4+Sl0jJffwNMze7LStTqTRDl3L5BROQhrPkTvr2ikfWQvuYb8/U3ma1uva7pRuo/NiLUrdclIu+xQIDFhaybK+f6Mgb/AFdSpcPZa1qpi9EpqyiipJv5+l1Rqze5Lfizwx+R91lF19rtXe0/5KuY9g9gak2TrIf0iaKIi1U6aLuZr98VTP0TUSBizT9AaQxm/OvCdVkP6btUo0edwezRzzBbRDQYm6FwQ+2fFX8i77O62OHPlXN9WWDedYDzhSF95XUGXG/wTgfEWhl3dCRyp3Xr1kEQBCxbtqzTY7Zs2QJBEOy2iIgIu2NEUcTKlSuRlJSEyMhI5OTk4MKFCx4ufcesEFzeAhGDf4DxhSF9FZpGVNQ3ee3z6gxuSv0H5t8Q8hEFBQXYtGkTsrKyuj1WoVCgoqLCtl2+fNnu/fXr1+Ott97Cxo0bceTIEURHR2P69OloavLe77ZV6wx/rmyBiME/gIiiiMPf18p6SF+1rsnrIw/MFhENTZ7rV0AkNZ1Oh4ceegjvvvsu4uLiuj1eEASoVCrblpiYaHtPFEW88cYbeP755zFnzhxkZWVh69atuHbtGnbu3OnBuyB3YvAPIN9e0aCs1vGFcLylzmBCabU05XPHSn+c5Ie8SavV2m1GY+fLWi9ZsgSzZs1CTk5Oj66t0+nQv39/pKamYs6cOThz5oztvdLSUqjVartrKZVKTJw4EYcOHXL+hpzU2ubvyhaIAvOuA9DF6/Ie0tfQZMbFKtfm63dFncEEq5x7PxLdJDU1FUql0ratXbu2w+Nyc3Nx4sSJTt+/WWZmJt5//3189tln+POf/wyr1YrJkyfjypUrAAC1Wg0AdtmA1tet73mTFYJtil+ntgB9aGdv/wCg1jShoFS+Q/oMpmacr2yQdLxt843UvzKSE/6QbygvL4dCobC9Dg8P7/CYpUuXYt++fe067XUmOzsb2dnZtteTJ0/G0KFDsWnTJqxatcr1gpMssObv5zSNLUP65DqRRZPZgmJ1AyzunbzPKTX6ztOmPcFJfsibFAqF3dZR8D9+/DiqqqowduxYhISEICQkBPn5+XjrrbcQEhICi6X7jr+hoaEYM2YMSkpKAAAqlQoAUFlZaXdcZWWl7T1vEl3s6S8GaM2fwd+PNZktyCuW75C+lvn6tbIpX73e7FLqPzD/hJCcTZ06FUVFRSgsLLRt48ePx0MPPYTCwkIEBwd3ew2LxYKioiIkJSUBANLS0qBSqbB//37bMVqtFkeOHLHLGHiLSyl/F1cE9GVM+/spuQ/pa7a2LNRjdONCPa5qtorQNprRKypM6qIQuUVsbCxGjBhhty86Ohq9e/e27V+wYAFSUlJsfQJefvllTJo0Cenp6aivr8err76Ky5cv47HHHgMA2zwBq1evRkZGBtLS0vDCCy8gOTkZc+fO9er9kfMY/P2Q3If0Wa1WXKjUwWCS34NJrd7E4E8BpaysDEFBPySB6+rq8Pjjj0OtViMuLg7jxo3DwYMHMWzYMNsxy5cvh16vxxNPPIH6+nrcfvvt2LNnT4/7FbgTZ/hzjiByYnO/8215Pc7ItGe/KIq4UNWAeoM8x9UHBwkY068XgpxowE9PiMGEtHgPlIp8nVarhVKpxNdff42YmBiXrqXT6XD33XdDo9HYdfgLNK3f6ZwvH0VotPMP7Ga9CZ9Nez/gvs/AfOTxYxev6+Qb+CHi+2q9bAM/AFisIjSNnl1PgIhIakz7+5FKrbyH9JXVGmTbFNFWrd6EOCdS/+ztT+R9rs7Pz3H+5NPy/34Mp+uNiMtMlbooHbpW34hKjWtD6byl3mCCxSoiOCgw/ygQ+RJXe+yztz/5rGv6Jvy//9wMTXk1VGMHYcRDd6Nv9hAIMqmKVjU04Uqdd+frd4XF2jI/QryD7Yjy+LaJAguDv3MY/H2YwWLFCa0e31XUos+kdGgraqE+cRHqExcRN0iFEb+4G2n3jkZwqHT/N9fqTbgk0Xz9rqjVmxwO/kREvoId/nyQVRRxTteIv1fVobTRiPBe0bjt9YX46cHVGPZ/cxAaE4G6i2r8a9X/4tMH1uL0/+bDrPf+UpvaRjMuXtd5/XPdoTX17wiZJFqIAgon+XEOg7+PqTKa8Y/rGhzT6mG+aZRmdHIcxr9wP+4/sgZjV8xFZIICusp6FLz1d3z8k9U4vuEfMFR7ZySA3mjG+aoGyRbqcZVVBHv9E/kABn/nMO3vIxpvpPi/b+y+01yYMgojlkzH0MfuwfefHsXZTf+EpkSNU1u/wpncbzBk1q3IfPBOKPsneKasZguKK3WwymC+flfU6I1M/RORX2LwlzlRFHHeYMTJDmr63QkOD0XG/NuQ/mA2rvyzCKc37MP1gos4s+MQzu48jMH3ZCHjwTtwy8g0t5XX2GzBebUWzTKZr98VGoPZwV7/gVmDIJKSCNeG6/n+XyrnMPjL2HWTGUc1etSaXZsURwgKQuq0UUidNgpVBRdxZuM+lO/9FsX7W7aBt6Zj2C/uQp8JmRCCnG8JMlusKK6U13z9rrCKLW3/vWPar5bWEbb5E3kfe/s7h8FfhposVpxsMKDE4P5Oegm3DkLCrYOgKVHjzKZ/4vtPjuD7ghJ8X1CC5MHJGL/wHsTfMRKCgyMELFYrzlc2oMnk47n+m9Tqex78iYh8BYO/jIiiiBKDEScbDDB6uMFcma7C5Fd/idFPz8Z373+N4o++wbXz1/D33/0Z8UlxuO2Re5A8YzxMod23eVtFESVVOtmuIOiK+kYzmq1WhLiQESEiz2HN3zkM/jJRY2rGUY0O1S6m+B0VlajE2BVzMeJX03Fh279x7r2vUFtRh8//8Ami/t8u3P3w3ch84HZowsLR0cg3ESK+v66HplG+8/W7QhSBer0ZfWK7r/0H5p8QcsRgazIUlliXrqG1NripNP6Bwd85rM5IzGi14ki9Druq670e+NsKi43E8P+bg5/8+2Xc9sZC9MpMgqGhEf/4f7vw5j0voPRPnyHRoIMi0v558XKNAbV6+c/X74pag3/fHxEFHtb8JXTR0ITjWs+n+B0RHBaCQT+bhIH3T8TVr87gzIYvUXn4Ar766Bt89dE3mDhrLO79j5kISU/Boe9rUKX1jfn6XaFpNKPZYkVIcNfPynKZTpkokLDm7xwGfwnUmZtxVKNHlUm+k8gIgoC+U0eg79QRqD55CWc27sPlXSdx5B8ncOQfJ7D0k2dxS2IfBAlBqGpoQpNZPg8w7iaKQJ3BjFt6kPonIu8SRQGiCwHclXN9GYO/F5msVpxqaMR3+iaIPjS6tM+YAZiy6XFoS6tw9p1/ovZUGbLuHIrSGgPCQoKgUkZA22TG9QYj6vSmDvsG+LpavbHb4B+Yf0KIpMUlfZ3D4O8lpQYjjmv1aJRRit9RirQETFr7C1gtVqTGR6Ff72g0mS0ordajtFoPRUQozPFW1OhMfpcN0DY2w2yxIrSb1D8RkS9g8Pew+hsp/koZp/gdFRQcBBEtNd2I0GAMTVJgaJICtXoTSqt1KK02QKWMQEOTGVV+kg0QAdQZTEiIjej0GDb5E3kf2/ydw+DvIWariKIGA87pm2D1oRR/T3V0R/HRYYiPjsfo1Dhcq2/E99V6KCIbYW62olpvQpXWt7MBtfqugz8ReR/b/J3DHKYHXG404u9VdTijb/TLwA+gy9X6goMEpMZHYcrgW/CTMSm4NS0eQ1SxyOrbC0OTYtE7Jgw9ni5fRhpupP6JKHBt2LABWVlZUCgUUCgUyM7Oxu7du7s85+OPP8aQIUMQERGBkSNHYteuXV4qbedY83cjjbkZBVoDKoz+Py7cakv8d62zZgGDsRnVehOuNxjRaPKNmQFFtNT+ExUd1/6FAO04RCQlb6f9+/bti3Xr1iEjIwOiKOLDDz/EnDlzcPLkSQwfPrzd8QcPHsT8+fOxdu1a/OhHP8K2bdswd+5cnDhxAiNGjHC63K4SRNFXV1yXj2ariCJdI87q/Lemf7MHVfEIc3LKW4tVtDULXKtvhLbRd/oGxEaEYGiSosP3svoqMSJF6eUSkS/QarVQKpW4ur8YimgXZ/jTNyBlaiY0Gg0Uio7/LQaC1u903Ce/QUi088Nwm/VGHL//dZe+z/j4eLz66qtYtGhRu/cefPBB6PV6fPHFF7Z9kyZNwujRo7Fx40any+0q1vxdVNZoxDGtAXqLb9Re3cWVIN3aLJAaH2U3WqC6wSj7bEBDUzNMzVaEhbDFjMifaLVau9fh4eEID+/6ocJiseDjjz+GXq9HdnZ2h8ccOnQITz31lN2+6dOnY+fOnS6V11UM/k5qaLagQKPH1QBI8XfEXRX0zpoFanRGXG8wolaG2YBagwmqTlL/RORdootp/9YOf6mpqXb7X3zxRbz00ksdnlNUVITs7Gw0NTUhJiYGO3bswLBhwzo8Vq1WIzEx0W5fYmIi1Gq102V2BwZ/BzVbRZzRN+JMQyMsAZLi74gn7ryj0QJlNXpc18krG1CnZ/AnkgsRXXdA7sn5AFBeXm6X9u+q1p+ZmYnCwkJoNBps374dCxcuRH5+fqcPAHLE4O+AK00mHNPo0RBgKf6OeHKGQvtmgXhbs0B5rUEW2YCGpmYYmy0IDwmWrhBE5Fatvfd7IiwsDOnp6QCAcePGoaCgAG+++SY2bdrU7liVSoXKykq7fZWVlVCpVK4X2gUM/j2ga7bgmFaP8qbATPF3yEvBt6NmgQuVOlzTNEmaDajTm6FS2gd/TvJD5H1WCC6NtHHH9L5WqxVGY8eLnGVnZ2P//v1YtmyZbd++ffs67SPgLQz+XbCIIs7qGlGka4SFgyLsSPFtdNQsUKzWokrr/WxArd4IlZKpfyKpeXuSnxUrVmDmzJno168fGhoasG3bNuTl5WHv3r0AgAULFiAlJQVr164FACxduhRTpkzBa6+9hlmzZiE3NxfHjh3DO++843SZ3YHBvxPXmkw4yhR/p6R8FGrbLDAxraVZ4EJlAy5e16PKS9kAndECo9mC8NAfav8c50/kfVZRgODFcf5VVVVYsGABKioqoFQqkZWVhb179+Lee+8FAJSVlSGozTDoyZMnY9u2bXj++efx3HPPISMjAzt37pR0jD/A4N+O3mLBcY0Bl5v8f516V8glD9JRs8CpKxpcrWv0eDag1mBCkjLScx9ARLKzefPmLt/Py8trt++BBx7AAw884KESOYfB/warKOKcvgnfNhiY4u8BOc4NdXOzQLFai9PXtKjUeiYbUKOzD/5s8yfyPlF0sbe//P6UeQWDPwC10YwjGh20zUzx95ScZ7hv2yxwW/otuFSjx6kr9bhQpUOtzn3ZAIPJgiazBRGh7PVPJBUu7OOcgA7+BosVJ7R6lDYyxe8oX3lYjgyzbxY4X6nFscv1uFrX6JZsQK3ehOReTP0TkW8JyOBvFUUU65tQ2GBAc6DmfFzki19bfHQYJg3sg1sH9Ma1+kacLKtD0VUNalzIBrQN/kz7E3kfa/7OCbjgX2U044hGj/rmZqmL4tN8MPbbtG0WuHeYCheqGlBwqRYXq/QwOJgNMJgsaDRZEBnG1D+RFLzd299fBMzqJI0WK/5d14C9NRoGfjfw5Ax/3hQZFoysvr2w6PaBeHp6JmaPSkJSrwgEOfD3oNbQMvkTh/qR3K1btw6CINhNOHOzd999F3fccQfi4uIQFxeHnJwcHD161O6Yhx9+GIIg2G0zZszwcOnJnfy+5i+KIooNTSjUGmD2xVw1eU18dBimDk3EXZkJuFyjx6Hva3D2mhZ6Y9fZgFq9CSls9yeZKygowKZNm5CVldXlcXl5eZg/fz4mT56MiIgIvPLKK5g2bRrOnDmDlJQU23EzZszABx98YHvd3Qp4nsLe/s7x6+B/3WTGUY0etWbW9N3Nn38wwUECBt4Sg4G3xKDRZEFheR2Oltbico2hw74BjTdS/2zzJ7nS6XR46KGH8O6772L16tVdHvuXv/zF7vV7772HTz75BPv378eCBQts+8PDwyWfnx5oDf6utPm7sTA+xC/T/k0WKw7V67CnWsPA7yGB8nuJDAtG9qA+WJozGM/OHIIpg/tAEdn+mblGzxEj5F1ardZu62xueQBYsmQJZs2ahZycHIc/x2AwwGw2Iz4+3m5/Xl4eEhISkJmZicWLF6Ompsbha5N0/KrmL4oiLhiMOKk1wCTKeSS67wuU4N9WoiICPxnbFz8enYIz1zQ4dLEG5ysbYLG2pP5Z8Sdv6un687m5uThx4gQKCgqc+pxnn30WycnJdg8OM2bMwE9/+lOkpaXh4sWLeO655zBz5kwcOnQIwcHe7fzK3v7O8ZvgX21qxlGNDjWs6XuFNVBzZWhpFsjq2wtZfXtBYzDjcGkNjl2qhbbJDJO1GWFBfvOzIhnryfrz5eXlWLp0Kfbt24eICMcXolq3bh1yc3ORl5dnd/68efNs/z1y5EhkZWVh0KBByMvLw9SpUx3+HFeIcK0yEqh/yXw+7W+0WnGkXofd1fUM/OR1yqhQTB+uwvgxZqy6tBlvfrdL6iJRgGhdf7516yj4Hz9+HFVVVRg7dixCQkIQEhKC/Px8vPXWWwgJCYGli4XL/vjHP2LdunX48ssvu+0kOHDgQPTp0wclJSUu35ejWmv+rmyByGerKKIo4mKjESe0BhitTPF7G79xe2HBIbjWWIcj1d7/40fUmalTp6KoqMhu3yOPPIIhQ4bg2Wef7TRFv379eqxZswZ79+7F+PHju/2cK1euoKamBklJSW4pN3meTwb/WnMzjtbrcd1slrooAStQU2WdGR8/EMFCEMoM1ahorENSZJzURSJCbGxsu6Vjo6Oj0bt3b9v+m9eff+WVV7By5Ups27YNAwYMgFqtBgDExMQgJiYGOp0Ov//973H//fdDpVLh4sWLWL58OdLT0zF9+nTv3iDAvL+TfCrtb7JaUaDRY9d1DQO/xOS4qp+UYkMjMVzZFwBY+yefUlZWhoqKCtvrDRs2wGQy4Wc/+xmSkpJs2x//+EcAQHBwME6dOoUf//jHGDx4MBYtWoRx48bhX//6lzRj/V1N+TPtL2/fG4w4rtWjiSl+WWDob29C73Scqi/DkZoLmJt6q9TFIerQzevN3/z60qVLXZ4fGRmJvXv3urdQ5HWyr/nXmZvxZbUG/65vYOAnWZvUJwMAUFBzERYONSXyitYZ/lzZApFsa/5mq4hTDQac0zf5zTzy/oT/j7Q3TNkX0SHh0JobUay9hmE3mgGIyHM4zt85sgz+teZmfFWjRSNr+rIVqE/LXQkJCsb4+EHIrzqLI9UlDP7UzqWGIsRYo126hk6vd1NpKJDJMu0fGxyMIE6ULmuM/R2b2CcdAHCk+oLEJSEKEK2d9lzZApAsg39okIDxiiipi0FdYFNMxyb2bmn3P1VfBkMz5/sn8jS2+TtHlsEfAPpFhiMlPEzqYlAnOlrdjoC+UfFIjoxDs2jBidpSqYtD5P9EN2wBSLbBHwAmKKMRzPQ/+RBBEDDxRq//IzVM/RORPMk6+MeEBCMrJlLqYlAH2BWzcxN7t7T7H+VkP0Qex7n9nSPr4A8Aw2IioQjx7hKR1D22+XdufO9BCIKAUv11VDbWS10cIv/HlL/DZB/8gwQBE5UxUheDbhKonWR6QhEaaRvmd6SGtX8ikh/ZB38AUIWHIi1SgjmjiZzUOuSPqX8iz2La3zk+EfwBYJwiGqHs/CcbrPh37YdOfyWwcqpfIs9hb3+n+EzwjwwOwhiFazNjkfsE6O+lx0YoUxEdHA6N2YBibUX3JxAReZHPBH8AGBwVjj6hspyROOBwSd+uhQQFY1zvgQCAo2z3J/IgwQ1b4PGp4C8IAiYoYyAE6P9ZcsLQ373WIX+HOdUvkecw7e8Unwr+ANA7LASZ0RFSFyPgBejvxSETbrT7n6q7jMZmk8SlISL6gc8FfwAYFRuJyCCfLLrf4PS+3esX1RtJEb1gFi04Wcepfok8gjV/p/hkBA0LCsJ4JTv/SSlAfy8OEQQBE/q0pv7Z7k/kEVzVzyk+GfwBYEBkOJK48I9kOMNfz7QO+TvKef6JPIKr+jnHZ4M/cGPhH3b+k0aA/mAcdWv8IAgQ8L2uClVNGqmLQ0QEwMeDvyIkGMNjufCPFBj7e0YZFoWhyhQAwNGaixKXhkieLBYLCgsLUVdX5/jJAdrmX19f79L5Ph38AWBETCRig7nwj7f56O9FEq1D/o5wyB8RAGDZsmXYvHkzgJbAP2XKFIwdOxapqanIy8tz7GIB0Ob/yiuv4K9//avt9c9//nP07t0bKSkp+Pbbb526ps8H/2BBwAR2/vM6Bv+e+6Hdn1P9EgHA9u3bMWrUKADA559/jtLSUnz33Xf4zW9+g9/97ncSl05+Nm7ciNTUVADAvn37sG/fPuzevRszZ87EM88849Q1fT74A0ByRBj6R3DhH2/iDH89N7JXKiKDw1Bn0qOkQS11cYgkV11dDZVKBQDYtWsXHnjgAQwePBiPPvooioqKHLqWILq+yZ1arbYF/y+++AI///nPMW3aNCxfvhwFBQVOXdMvgj8AjFdGI4QL/3iND/xeZCM0KATj4lum+uWQPyIgMTERZ8+ehcViwZ49e3DvvfcCAAwGA4IdbcYNgDb/uLg4lJeXAwD27NmDnJwcAC2VMIvF4tQ1/Sb4RwUHYXRslNTFCBhMXjumtd2f8/wTAY888gh+/vOfY8SIERAEwRbMjhw5giFDhkhcOvn56U9/il/84he49957UVNTg5kzZwIATp48ifT0dKeu6Ver5GRGR+CiwYi65mapi0JkZ+KNyX4K6y6hyWJCRDDnqKDA9dJLL2HEiBEoLy/HAw88gPDwlmbb4OBg/Nd//ZdjF3O1054PdPh7/fXXMWDAAJSXl2P9+vWIiYkBAFRUVOA//uM/nLqmXwX/IEHAxF7R2FPN8dSeZmWbv0P6R9+CxAglKps0OFl7Cdm3DJa6SESS+tnPfgYAaGpqsu1buHCh4xdyNXXvA3/KQkND8fTTT7fb/5vf/Mbpa/pV8AeAW8JCkREVgQuGpu4PJqf5wO9FVgRBwITe6fj86nEcrSlh8KeAZrFY8Ic//AEbN25EZWUlzp8/j4EDB+KFF17AgAEDsGjRIqmLKLm///3vPT72xz/+scPX97vgDwBjFFEoazLBaGXLNMnHpD4Z+PzqcRxhpz8KcGvWrMGHH36I9evX4/HHH7ftHzFiBN544w3Hgr+f1vznzp1r91oQBLtRVkKbDu7OdPrzmw5/bYUHBWGcgp3/PIlZf8fd2rtlqt8SnRrVTVqpi0Mkma1bt+Kdd97BQw89ZNe7f9SoUfjuu+8cu5if9va3Wq227csvv8To0aOxe/du1NfXo76+Hrt27cLYsWOxZ88ep67vlzV/ABgU1dL5r9JklroofkmmvxdZ6xUWjUxFMr7TXsXRmou4L2WM1EUiksTVq1c77KVutVphNjv4NzsAOvwtW7YMGzduxO23327bN336dERFReGJJ57AuXPnHL6mX9b8W01QRiOIC/94RDC/VqdMutHr/whX+aMANmzYMPzrX/9qt3/79u0YM4YPxTe7ePEievXq1W6/UqnEpUuXnLqm39b8AaBXaAiGxkTgjK5R6qL4lPCgIEQHt2xRQUGIDglu+d/gIETd2II4oZJTJvROx5bv83GkugSiKNq12xEFipUrV2LhwoW4evUqrFYrPv30UxQXF2Pr1q344osvHLqWq7P0+cIMf7feeiueeuopfPTRR0hMTAQAVFZW4plnnsGECROcuqZfB38AyIqJwqVGE/ROzoLkb8KEH4L4D/8bbPc6mAHJY7Li+iMiOBS1Jh1KdGpkxCZJXSQir5szZw4+//xzvPzyy4iOjsbKlSsxduxYfP7557bZ/nrMTzv8tfX+++/jJz/5Cfr162eb5re8vBwZGRnYuXOnU9f067Q/AIQECbg1QBb+CRUEKENCkBwehvSoCIyKjcLkXjHI6a3Aj2/phfmq3ngwKR4/SuiFe3orMLFXDEbGRmFgVDhU4aGIDQlm4PewsDZT/bLXP3nbunXrIAgCli1b1uVxH3/8MYYMGYKIiAiMHDkSu3btsntfFEWsXLkSSUlJiIyMRE5ODi5ccKwp64477sC+fftQVVUFg8GAAwcOYNq0aY7ektetXbsWt956K2JjY5GQkIC5c+eiuLi4y3O2bNkCQRDstoiIiB5/Znp6Ok6dOoXPP/8cv/71r/HrX/8aX3zxBYqKijjDX1dSI8KQGhGG8iaT1EVxWrAg3EjFt6TgW2vqbVPxYUF+/yznFyb0Tse/rxfjSHUJfpl2h9TFoQBRUFCATZs2ISsrq8vjDh48iPnz52Pt2rX40Y9+hG3btmHu3Lk4ceIERowYAQBYv3493nrrLXz44YdIS0vDCy+8gOnTp+Ps2bMOBTVflJ+fjyVLluDWW29Fc3MznnvuOUybNg1nz55FdHTnFU2FQmH3kOBok58gCJg2bZrbHpACIvgDwK2KaFwzmmGR4Ri1YAi2AN4SzIPbpebDGdj9xg9T/ZbCaDEjPDhU4hKRv9PpdHjooYfw7rvvYvXq1V0e++abb2LGjBm2pWJXrVqFffv24e2338bGjRshiiLeeOMNPP/885gzZw6AlqF7iYmJ2LlzJ+bNm9dteeLi4joMfq014vT0dDz88MN45JFHur2WABfb/B08/uahdVu2bEFCQgKOHz+OO++8s/PPEQTbSobO0Ov1yM/PR1lZGUwm+4rsr3/9a4evFzDBPzokGKNio3BCq/fq5wbdCOxta+hRbWrw0cFBiAhmYA8kadEJSAhXoMqoxbd1lzGhj3NpOwpsWq39XBHh4eG2OfJvtmTJEsyaNQs5OTndBv9Dhw7hqaeests3ffp0W9tyaWkp1Gq1bTEeoKXX+cSJE3Ho0KEeBf+VK1dizZo1mDlzpq3D2tGjR7Fnzx4sWbIEpaWlWLx4MZqbm+0mAfIkR77PtjSalunk4+PjuzxOp9Ohf//+sFqtGDt2LP7whz9g+PDhPSrbyZMncd9998FgMECv1yM+Ph7V1dWIiopCQkICg393ht5Y+EfjpoV/hNYa+0094Vtr71HBQYgMEtijm+wIgoAJfdLxxdUTOFxzgcE/gASHD0dweKxr12huAABbx69WL774Il566aV2x+fm5uLEiRM9XvddrVbbepS3SkxMhFqttr3fuq+zY7pz4MABrF69Gk8++aTd/k2bNuHLL7/EJ598gqysLLz11lvdB383jfPv6ffZltVqxbJly3DbbbfZmkQ6kpmZiffffx9ZWVnQaDT44x//iMmTJ+PMmTPo27dvt0X8zW9+g9mzZ2Pjxo1QKpU4fPgwQkND8ctf/hJLly7t/h47EFDBP0gQMEkZjb01PVv4J9I25C34psAeZAv6DOzkjIm9M/DF1RMtnf4ypS4N+aLy8nIoFArb645qqeXl5Vi6dCn27dsnq7b4vXv34pVXXmm3f+rUqfjtb38LALjvvvt6tsKfm3r79+T7vNmSJUtw+vRpHDhwoMvjsrOzkZ2dbXs9efJkDB06FJs2bcKqVau6/ZzCwkJs2rQJQUFBCA4OhtFoxMCBA7F+/XosXLgQP/3pT7u9xs0CKvgDQEJ4KAZFRuCq0dSm01yboW43An4kx7KTB93aexAA4EJDBWqMDejtYm2QAo9CobALVh05fvw4qqqqMHbsWNs+i8WCb775Bm+//TaMRqPd9LoAoFKpUFlZabevsrLS1l7d+r+VlZVISkqyO2b06NE9Knt8fDw+//zzdqvSff7557b0uV6vR2ys934XPfk+2/rVr36FL774At98802Pau9thYaGYsyYMSgp6dmIn9DQUATd6PeVkJCAsrIyDB06FEqlEuXl5Q59dquAC/4AMDkuRuoiUICLD49BpiIZxdprKKi5iBnJo6UuEvmhqVOnoqioyG7fI488giFDhuDZZ59tF/iBllrq/v377YYD7tu3z1ZzTUtLg0qlwv79+23BXqvV4siRI1i8eHGPyvXCCy9g8eLF+Prrr21t/gUFBdi1axc2btxo+8wpU6Z0fzEvj/MXRRH/+Z//iR07diAvLw9paWkOf6TFYkFRURHuu+++Hh0/ZswYFBQUICMjA1OmTMHKlStRXV2Njz76qMvmhq4EZPAnkoOJvdNRrL2GI9UlDP7kEbGxse2CQ3R0NHr37m3bv2DBAqSkpGDt2rUAgKVLl2LKlCl47bXXMGvWLOTm5uLYsWN45513AMA2T8Dq1auRkZFhG+qXnJzcbiW6zjz++OMYNmwY3n77bXz66acAWtrF8/PzMXnyZACwpf+74+0Z/pYsWYJt27bhs88+Q2xsrK2fg1KpRGRkJID23+nLL7+MSZMmIT09HfX19Xj11Vdx+fJlPPbYYz36zD/84Q9oaGjp67FmzRosWLAAixcvRkZGBt5//33HbuAGBn8iiUzok46tpd/gSM0FTvVLkikrK7OllIGW9uht27bh+eefx3PPPWebRa7tQ8Ty5cuh1+vxxBNPoL6+Hrfffjv27NnjUL+C2267DbfddpvrN+Dlmv+GDRsAAHfddZfd/g8++AAPP/wwgPbfaV1dHR5//HGo1WrExcVh3LhxOHjwIIYNG9ajzxw/frztvxMSEpxeya8tQRRlOPCdKAAYLWbk7F8No9WM/73t1xgU6/wYYJI3rVbb0kt79znERLvWjq3TN2DSzKHQaDQOtVFL7eahdF3pyX21fqcDVq9BkAudGa1NTbj0/O9k/X2++OKLePTRR9G/f3+3XZMDzIkkEh4cirHxLe2FR2o41S/5t169eiEuLq5Hm0NEN2wy99lnn2HQoEGYOnUqtm3bBqPR6PI1GfyJJDSh940lfjnPP/m5r7/+Gl999RW++uorvP/++0hISMDy5cuxY8cO7NixA8uXL0diYqLDbditbf6ubHJXWFiIgoICDB8+HEuXLoVKpcLixYt7PHdDR9jmTyShSX3S8WYxcKKWU/2Sf2vbc//ll1/Gf//3f2P+/Pm2fT/+8Y8xcuRIvPPOO1i4cKEURZS1MWPGYMyYMXjttdfw+eef44MPPsBtt92GIUOGYNGiRXj44YehVCp7fD3W/IkkNDAmEX3CY2G0mnGqvkzq4hB5xaFDh+w6sbUaP348jh496tjFWmf4c2XzIaIowmw2w2QyQRRFxMXF4e2330Zqair++te/9vg6DP5EEhIEoU3q37ElUYl8VWpqKt599912+99777120+x2KwDa/IGWCZt+9atfISkpCb/5zW8wZswYnDt3Dvn5+bhw4QLWrFnj0Bz/TPsTSWxSnwzsunYSR9npjwLE66+/jvvvvx+7d+/GxIkTAbQs7HP+/HnbuH/6wciRI3Hu3DlMnz4dmzdvxuzZs9tN0DR//nyH5vln8CeSWOtUv99pr6HOpENcGGegJP9233334cKFC9iwYQPOnTsHAJg9ezaefPJJh2v+3p7kRwo///nP8eijjyIlJaXTY/r06QOr1drjazL4E0msd3gsMmKTcKGhAkerL2J68iipi0TkcaWlpbh06RIqKiqwfft2pKSk4KOPPkJaWhpuv/32nl/Iy5P8eMvNyyq/9tprnR773//93w5fn8GfSAYm9klvCf41JQz+5Pc++eQT/J//83/w0EMP4eTJk7Zx6xqNBn/4wx+wa9cuiUsovZMnT9q9PnHiBJqbm5GZ2bIM6Pnz5xEcHIxx48Y5dX12+COSgYltOv1x0k3yd6tXr8bGjRvx7rvvIjT0h+Gtt912G06cOOHYxVwd4y/Tn9vXX39t22bPno0pU6bgypUrOHHiBE6cOIHy8nLcfffdmDVrllPXZ/AnkoFRcQMQHhSCKqMWl/TXpS4OkUcVFxfjzjvvbLdfqVSivr7esYsFQG//1157DWvXrrWb/TAuLg6rV6/usjmgKwz+RDIQERyK0XEDAHDIH/k/lUrV4Vr2Bw4cwMCBAx27WAAEf61Wi+vX21cKrl+/blvtz1EM/kQyMbFPBgDO80/+7/HHH8fSpUtx5MgRCIKAa9eu4S9/+QuefvppLF68WOriyc5PfvITPPLII/j0009x5coVXLlyBZ988gkWLVqEn/70p05dkx3+iGRiYp90oBg4Xvs9TNZmhAXx50n+6b/+679gtVoxdepUGAwG3HnnnQgPD8fTTz+N//zP/3ToWoEw1G/jxo14+umn8Ytf/AJmsxkAEBISgkWLFuHVV1916pr860IkE+kxKsSHxaDWpENRXRnG9XYw/UnkIwRBwO9+9zs888wzKCkpgU6nw7BhwxATwzkuOhIVFYX/+Z//wauvvoqLFy8CAAYNGoTo6Ginr8ngTyQTgiBgYp907L5WiCM1JQz+5PfCwsIwbNgwqYvhM6Kjo5GVleWWa7HNn0hGJva+0e7PTn9EPRMAHf48gcGfSEYmtJnqt95kkLg0RPLnyhh/V/sL+DIGfyIZ6ROhQHqMCiJEFLDXPxF5CIM/kcxM6HNjtj8Gf6KeYcrfYQz+RDLDqX6JHMA2f6cw+BPJzJj4AQgLCkFlkwZl+mqpi0NEfojBn0hmIoLDMCquPwDgcA17/RN1hR3+nMPgTyRDrUP+jlaz3Z+oS0z7O4XBn0iGJt7o9Hey7hKarRaJS0MkX6z5O4cz/BHJUEasCq+M/gUyoEBIULDUxSEiP8OaP5EMBQlBmHLLUNR/dx5GAyf7IeoU0/5OYfAnkqlmswnW5maUFRXCytQ/UccY/J3C4E8kU80mEwCgsUGLivPFEpeGiPwJgz+RTFlurNsNADVXylBfqZawNETyxA5/zmGHPyKZajYZ7V5fOVuEyFgFwqOiJCoRuUpVcRgKF///07IPiD1XU/cBGvxZ8yeSqeY2NX8AsFosuFx0ku3/ROQyBn8imbLcaPNvq6mhAdfOfydBaYhkih3+nMLgTyRTzR0EfwCovVKOOvU1L5eGSJ7Y5u8cBn8imWo2dxz8AeDquTMwGvReLA0R+RMGfyKZurnNvy2rxYLLp07CamH7P3Vtw4YNyMrKgkKhgEKhQHZ2Nnbv3t3p8XfddRcEQWi3zZo1y3bMww8/3O79GTNmeON22mPa3yns7U8kU5Yuav4A0KTT4VrxOfQdNsJLJSJf1LdvX6xbtw4ZGRkQRREffvgh5syZg5MnT2L48OHtjv/0009hatPkVFNTg1GjRuGBBx6wO27GjBn44IMPbK/Dw8M9dxNdcDV1H6hpfwZ/IpnqrM2/rdprVxAdH484VbIXSkS+aPbs2Xav16xZgw0bNuDw4cMdBv/4+Hi717m5uYiKimoX/MPDw6FSqdxfYEdxqJ9TmPYnkiFRFO0m+enKlXOn0aTXebhEJDdardZuMxqN3Z5jsViQm5sLvV6P7OzsHn3O5s2bMW/ePERHR9vtz8vLQ0JCAjIzM7F48WLU1NQ4dR8kDQZ/IhnqaeAHANFibZn/n+3/ASU1NRVKpdK2rV27ttNji4qKEBMTg/DwcDz55JPYsWMHhg0b1u1nHD16FKdPn8Zjjz1mt3/GjBnYunUr9u/fj1deeQX5+fmYOXMmLFL8G2Sbv1OY9ieSoZ6k/Nti+3/gKS8vh0KhsL3uqs09MzMThYWF0Gg02L59OxYuXIj8/PxuHwA2b96MkSNHYsKECXb7582bZ/vvkSNHIisrC4MGDUJeXh6mTp3q5B05R7ixuXJ+IGLNn0iGuhrm15naa1dQV3HVA6UhOWrtvd+6dRX8w8LCkJ6ejnHjxmHt2rUYNWoU3nzzzS6vr9frkZubi0WLFnVbloEDB6JPnz4oKSlx+D5IGgz+RDLUXU//zlz57gyadGz/p65ZrdZu+wh8/PHHMBqN+OUvf9nt9a5cuYKamhokJSW5q4g9x7S/Uxj8iWTI0bR/K9FixWW2/1MbK1aswDfffINLly6hqKgIK1asQF5eHh566CEAwIIFC7BixYp2523evBlz585F79697fbrdDo888wzOHz4MC5duoT9+/djzpw5SE9Px/Tp071yT21xhj/nsM2fSIacDf4AYNTrcPW7M0gdnuXGEpGvqqqqwoIFC1BRUQGlUomsrCzs3bsX9957LwCgrKwMQUH29cDi4mIcOHAAX375ZbvrBQcH49SpU/jwww9RX1+P5ORkTJs2DatWrZJsrD85jsGfSIa6mt2vJ+oqriE6rjfik1PcVCLyVZs3b+7y/by8vHb7MjMzIYodV4kjIyOxd+9edxTNPTjO3ylM+xPJkLNt/m1dLWb7PwUItvc7jMGfSIac6e1/s5b2/5OwNDe7oURE5E8Y/IlkyJU2/7aMej2ufnfWLdcikiN2+HMOgz+RDFncFPwBoF59DTVXy912PSJZ4VA/pzD4E8mQqx3+bnat+BwadQ1uvSaRHHi75r927VrceuutiI2NRUJCAubOnYvi4uJuz/v4448xZMgQREREYOTIkdi1a5eTd+weDP5EMmNpboZotbr1mqK1Zf5/tv8TuSY/Px9LlizB4cOHsW/fPpjNZkybNg16vb7Tcw4ePIj58+dj0aJFOHnyJObOnYu5c+fi9OnTXiy5PQ71I5IZd7X336yl/f8M+o0Y5ZHrE0nCy0P99uzZY/d6y5YtSEhIwPHjx3HnnXd2eM6bb76JGTNm4JlnngEArFq1Cvv27cPbb7+NjRs3OlVsV7HmTyQz7hjm15l6dQXb/8mvuCvt78wSyQCg0WgAAPHx8Z0ec+jQIeTk5Njtmz59Og4dOuTcTbsBgz+RzLhjmF9XrhWfQ2OD1qOfQeRrHFkiuZXVasWyZctw2223YcSIzlfUVKvVSExMtNuXmJgItVrtcrmdxbQ/kcw0m9zb2e9morVl/v+MCdkIDgn16GcReZyb0v6OLJHcasmSJTh9+jQOHDjgQgGkweBPJDOeTPu3MhkMuHLuDPqPHO3xzyLyKDcF/9alkXvqV7/6Fb744gt888036Nu3b5fHqlQqVFZW2u2rrKyESqVyuLjuwrQ/kcx4qsPfzTSVatRcKfPKZxH5C1EU8atf/Qo7duzAV199hbS0tG7Pyc7Oxv79++327du3D9nZ2Z4qZrdY8yeSGU+3+bd17fx3iFQoEaVQeu0zidzJ1Vn6HD13yZIl2LZtGz777DPExsba2u2VSiUiIyMBtCyTnJKSYus3sHTpUkyZMgWvvfYaZs2ahdzcXBw7dgzvvPOO8wV3EWv+RDLjztn9uvPD+H/P9jMg8hgvz/C3YcMGaDQa3HXXXUhKSrJtf/3rX23HlJWVoaKiwvZ68uTJ2LZtG9555x2MGjUK27dvx86dO7vsJOhprPkTyYzZizV/ADA1NuLK2TPonzXaq59L5Is6W+q4rY6WSX7ggQfwwAMPeKBEzmHNn0hmvFnzb6WpUqO6/LLXP5fIVYIourwFIgZ/Iplx97z+PXXt/HcwaDWSfDaR07iwj1MY/IlkRLRaYZVq/n1RZPs/+Rwu6escBn8iGfFmT/+OmBobUX5WusVGiMg7GPyJZESqlH9b2qpKVJddkroYRD3DtL9TGPyJZESKzn4duXahmO3/5BOY9ncOh/oRyYi3ZvfrlijemP9/MkJCOf+/u+SNEhAVI7h0DYPOtfOJANb8iWRF6jb/tsyNjbhytkjqYhB1jWl/pzD4E8mIRQZt/m1pr1fhOtv/ScaY9ncOgz+RjJhNRqmL0E7FhWIYNPVSF4OI3IjBn0hGLCZ51fwB2Nr/5TASgagdpv2dwuBPJCNyavNvy9zUhCtnTkldDKIOMeXvOAZ/IhmxyDT4A4C2+jquXy6VuhhE5AYM/kQyIvfUekXJeejr66QuBtEPRNH1LQAx+BPJiGzG+XdGFFF2+lv5l5MCBnv7O4fBn0gmms1mn6iFmJuaUH62qEfrmhN5HDv8OYXBn0gm5Nzef7MGtv8T+TQGfyKZ8LVUuvoi2/9JeoLV9S0QMfgTyYSvBX+IQFlRoe+Vm/wL0/5OYfAnkgm5jvHvitloRPmZU2z/J/IxDP5EMiG3ef17qqGmmu3/MrZhwwZkZWVBoVBAoVAgOzsbu3fv7vT4LVu2QBAEuy0iIsLuGFEUsXLlSiQlJSEyMhI5OTm4cOGCp2+lQ+zt7xwGfyKZ8OX0Odv/5atv375Yt24djh8/jmPHjuGee+7BnDlzcObMmU7PUSgUqKiosG2XL1+2e3/9+vV46623sHHjRhw5cgTR0dGYPn06mpqaPH077XGcv1MY/Ilkwpd6+7cjApeLCmW5MFGgmz17Nu677z5kZGRg8ODBWLNmDWJiYnD48OFOzxEEASqVyrYlJiba3hNFEW+88Qaef/55zJkzB1lZWdi6dSuuXbuGnTt3euGOyB0Y/Ilkwpdr/gDQzPZ/r9JqtXab0dj9g5fFYkFubi70ej2ys7M7PU6n06F///5ITU1tlyUoLS2FWq1GTk6ObZ9SqcTEiRNx6NAh127KCUz7O4fBn0gmfLHD3810NTWouvS91MUICKmpqVAqlbZt7dq1nR5bVFSEmJgYhIeH48knn8SOHTswbNiwDo/NzMzE+++/j88++wx//vOfYbVaMXnyZFy5cgUAoFarAcAuG9D6uvU9r2Jvf6eESF0AImoh93n9e6ry+wuIVvZCTHxvqYvi18rLy6FQKGyvw8PDOz02MzMThYWF0Gg02L59OxYuXIj8/PwOHwCys7PtsgKTJ0/G0KFDsWnTJqxatcq9N0GSYc2fSCaa/aW9XATKzpxi+7+Htfbeb926Cv5hYWFIT0/HuHHjsHbtWowaNQpvvvlmjz4nNDQUY8aMQUlJCQBApVIBACorK+2Oq6ystL3nTUz7O4fBn0gGrBYLRIv/TDXWbDSi/DTb/+XKarX2qI8A0NJPoKioCElJSQCAtLQ0qFQq7N+/33aMVqvFkSNHuuxH4DHs7e8Upv2JZMAf2vtvpqutQVXpRSQOTJe6KAFtxYoVmDlzJvr164eGhgZs27YNeXl52Lt3LwBgwYIFSElJsfUZePnllzFp0iSkp6ejvr4er776Ki5fvozHHnsMQMtIgGXLlmH16tXIyMhAWloaXnjhBSQnJ2Pu3Llevz9Xa++BWvNn8CeSAV/v6d+Zyu9LEN0rju3/EqqqqsKCBQtQUVEBpVKJrKws7N27F/feey8AoKysDEFBPySB6+rq8Pjjj0OtViMuLg7jxo3DwYMH7foHLF++HHq9Hk888QTq6+tx++23Y8+ePe0mAyL5EkTm5Ygk11BTjdKTx6QuhkeEhIUhY+JkhIYHbmDQarVQKpXYcnwLomKiXLqWQWfAw+MehkajsevwF2hav9PsGS8jJNT5f1vN5iYc2rMy4L5PtvkTyYA/pv1bNZtMKGP7P3kIO/w5h8GfSAYsfpr2b6Wvq0Xl9yVSF4OIbmDwJ5IBf23zb6uq9CIaaqulLgb5G6vo+haAGPyJZMCf0/5tlZ8+BbNRgsVfyH9xhj+nMPgTyYC/zO7XnZb2/28hWv1nTgMiX8TgTyQDgZD2b6Wvq0Nl6UWpi0F+QoCLHf6kvgGJMPgTyYBPL+frhKrSi2ioYfs/uQFn+HMKgz+RDARSzb9V2elvYW5i+z+RFBj8iSQmiiIsAdLm35bFbMZltv+TizjO3zkM/kQSC8TA38pQXwf19xekLgb5Mvb2dwqDP5HEAmWYX2euXyqFtvq61MUgHyWIostbIGLwJ5JYILb336z8zCmYmhqlLgZRwOCqfkQSC7Se/h2xmM0oK/oWg8ZNgBDkv3WSn2j1ULjYx0Gra8TD7imOf7De2Fw5PwD576+MyEc0mwK3zb8tg6Ye6ots/yfHMO3vHAZ/Iok1m4xSF0E2rl8uhba6SupiEPk9Bn8iiQXK1L49VX6miO3/1HPs7e8UBn8iibHN315r+z/H/1OPcIY/pzD4E0ks0If6dcSgqUdFyXmpi0Hktxj8iSRmYYe/DlWXXYL2Otv/qWuc4c85DP5EEmOHv86Vn2X7P3WDaX+nMPgTSYwd/jpnMZtxuaiQ7f8kG9988w1mz56N5ORkCIKAnTt3dnl8Xl4eBEFot6nVau8UuBMM/kQSsjQ3M7B1o1GjQUVJsdTFIJkSrK5vjtDr9Rg1ahT+9Kc/OXRecXExKioqbFtCQoJjH+xmnOGPSELs6d8z1WWXEd0rHsqERKmLQnLjaurewXNnzpyJmTNnOvwxCQkJ6NWrl8PneQpr/kQSYsq/5xpqq6UuAsmRm8b5a7Vau81odG9fnNGjRyMpKQn33nsv/v3vf7v12s5g8CeSEDv79Uzv1P5IyRwmdTHIj6WmpkKpVNq2tWvXuuW6SUlJ2LhxIz755BN88sknSE1NxV133YUTJ0645frOYtqfSEKc1797iQPTkTgwXepikEy5Oj9/67nl5eVQKBS2/eHh4S6XDQAyMzORmZlpez158mRcvHgRr7/+Oj766CO3fIYzGPyJJMQ2/64lZw5Fn9T+UheD5MxNbf4KhcIu+HvShAkTcODAAa98VmcY/IkkxNn9OiEISB0+EnGqZKlLQuR2hYWFSEpKkrQMDP5EEmo2MfjfTAgOQv+Ro6HoI+1QKPIRIgBXRss6mDTQ6XQoKSmxvS4tLUVhYSHi4+PRr18/rFixAlevXsXWrVsBAG+88QbS0tIwfPhwNDU14b333sNXX32FL7/80oVCu47Bn0hCFgZ/O0EhIUgbPQ7RveKkLgr5CHe1+ffUsWPHcPfdd9teP/XUUwCAhQsXYsuWLaioqEBZWZntfZPJhN/+9re4evUqoqKikJWVhX/+859215ACgz+RhDjU7wchYWFIG3srImNipS4KUafuuusuiF08MGzZssXu9fLly7F8+XIPl8pxDP5EEmKbf4vQyEgMHHMrwqOipC4K+RoRLnb4c1tJfAqDP5GE2OYPRMTEIG3MeISGR0hdFPJFXp7hz18w+BNJRLRaYW1ulroYkopS9sKA0eMQEhoqdVGIAgqDP5FEAj3lH9O7NwZkjUVQcLDURSFfZgUguHh+AOL0vkQSCeTOfspEFdJGjWPg94INGzYgKyvLNolNdnY2du/e3enx7777Lu644w7ExcUhLi4OOTk5OHr0qN0xDz/8cLslamfMmOHpW+lQa29/V7ZAxOBPJJFAHeYXn9IX/UaMghDEPz/e0LdvX6xbtw7Hjx/HsWPHcM8992DOnDk4c+ZMh8fn5eVh/vz5+Prrr3Ho0CGkpqZi2rRpuHr1qt1xM2bMsFui9n//93+9cTvttbb5u7IFIKb9iSQSiDX/hAEDoUofLHUxAsrs2bPtXq9ZswYbNmzA4cOHMXz48HbH/+Uvf7F7/d577+GTTz7B/v37sWDBAtv+8PBwqFQqzxSaPI6P3kQSCbQV/ZIGD2HgdyNnlqC1WCzIzc2FXq9HdnZ2jz7HYDDAbDYjPj7ebn9eXh4SEhKQmZmJxYsXo6amxqn7cBlr/k5h8CeSiCVQav4C0HfYSNzSb4DUJfErjixBW1RUhJiYGISHh+PJJ5/Ejh07MGxYz5ZIfvbZZ5GcnIycnBzbvhkzZmDr1q3Yv38/XnnlFeTn52PmzJmwWCwu35fDGPydwrQ/kUQCYYy/EBSEfiNGQZmQKHVR/I4jS9BmZmaisLAQGo0G27dvx8KFC5Gfn9/tA8C6deuQm5uLvLw8RET8MA/DvHnzbP89cuRIZGVlYdCgQcjLy8PUqVNduCvyFtb8iSTi78E/KDgYaaPHMfB7SGvv/datq+AfFhaG9PR0jBs3DmvXrsWoUaPw5ptvdnn9P/7xj1i3bh2+/PJLZGVldXnswIED0adPH7sFb7zG6oYtALHmTyQRfx7nHxwairQx4xGlUEpdFOqA1Wrtso/A+vXrsWbNGuzduxfjx4/v9npXrlxBTU2NJMvUenthH3/B4E8kEYufBv/QiAikjRmPiOgYqYtCAFasWIGZM2eiX79+aGhowLZt25CXl4e9e/cCABYsWICUlBRbn4FXXnkFK1euxLZt2zBgwACo1WoAQExMDGJiYqDT6fD73/8e999/P1QqFS5evIjly5cjPT0d06dPl+w+yTEM/kQS8cehfuHR0UgbMx5hEZFSF4VuqKqqwoIFC1BRUQGlUomsrCzs3bsX9957LwCgrKwMQW3mXNiwYQNMJhN+9rOf2V3nxRdfxEsvvYTg4GCcOnUKH374Ierr65GcnIxp06Zh1apVXTY9eAzn9ncKgz+RRPytzT9SoUDa6PEICQuTuijUxubNm7t8Py8vz+71pUuXujw+MjLSljWQBasICC4EcCuDPxF5iaXZ7Fc1jui4eAwYNRbBIfyTQuQL+EslkoAgBCF1+EiYGhthNBhgajTAaND75Nh/xS0J6DdyFIKCOE8/SYBpf6cw+BNJICg4GHFJKe32W5rNNx4GGmFqNMBkMMDY2PJwYG5qkqCkXYtLTkHfIcM5Tz9JyNWJehj8iUhiwSGhiFIoOxwiZ7VabA8FRkPLg4GpsfXhoNHrNZg+/QYgefAQr36mr/ubdQqiLLEuXcNgbXBTafwEa/5OYfAn8hFBQcGIiI7pcAidaLXCbGxqeRAwGGxNCa0PB6LFvTOZqNIHI2HAQLdek4i8h8GfyA8IQUEIi4xCWGQUEN/+fbOxqV3/AtONjIGj/QxShgxH776pbio5kYusIlxK3bO3PxH5q9DwCISGRyC6V1y795rN5h/6F9x4KDDeaF5objsLnCCg34hR6JXIZVxJRkRry+bK+QGIwZ8owIWEhiIktJN+BhaLrSkhJCysw4cHIvI9DP5E1Kmg4GBExsQiMsa1TmpEHsMOf05h8CciIt/FNn+ncHAuERFRgGHNn4iIfBfT/k5h8CciIt8lwsXg77aS+BSm/YmIiAIMa/5EROS7mPZ3CoM/ERH5LqsVgAsT9Vg5yQ8REZFvYc3fKWzzJyIiCjCs+RMRke9izd8pDP5EROS7OMOfU5j2JyIiCjCs+RMRkc8SRStEF5bldeVcX8bgT0REvksUXUvdB2ibP9P+REREAYY1fyIi8l2iix3+ArTmz+BPRES+y2oFBBfa7QO0zZ9pfyIiogDDmj8REfkupv2dwuBPREQ+S7RaIbqQ9udQPyIiIl/Dmr9T2OZPREQUYFjzJyIi32UVAYE1f0cx+BMRke8SRQCuDPULzODPtD8REVGAYc2fiIh8lmgVIbqQ9hcDtObP4E9ERL5LtMK1tH9gDvVj2p+IyI9t2LABWVlZUCgUUCgUyM7Oxu7du7s85+OPP8aQIUMQERGBkSNHYteuXXbvi6KIlStXIikpCZGRkcjJycGFCxc8eRuy8c0332D27NlITk6GIAjYuXNnt+fk5eVh7NixCA8PR3p6OrZs2eLxcnaHwZ+IyI/17dsX69atw/Hjx3Hs2DHcc889mDNnDs6cOdPh8QcPHsT8+fOxaNEinDx5EnPnzsXcuXNx+vRp2zHr16/HW2+9hY0bN+LIkSOIjo7G9OnT0dTU5K3bshGtosubI/R6PUaNGoU//elPPTq+tLQUs2bNwt13343CwkIsW7YMjz32GPbu3evM7bqNIAZqgwcRkZdotVoolUq8u/80oqJjXbqWQd+Ax6eOgEajgUKhcOoa8fHxePXVV7Fo0aJ27z344IPQ6/X44osvbPsmTZqE0aNHY+PGjRBFEcnJyfjtb3+Lp59+GgCg0WiQmJiILVu2YN68ec7dmINav9O7MAchQqjT12kWzcjDZ059n4IgYMeOHZg7d26nxzz77LP4xz/+YffwNG/ePNTX12PPnj3OFttlbPMnIvKSRr3ObdfQarV2+8PDwxEeHt7luRaLBR9//DH0ej2ys7M7PObQoUN46qmn7PZNnz7dlt4uLS2FWq1GTk6O7X2lUomJEyfi0KFDXgv+rZphdmmCv2aYATj3ffbEoUOH7L4roOX7XLZsmcvXdgWDPxGRh4WFhUGlUuHXP57kluvFxMQgNTXVbt+LL76Il156qcPji4qKkJ2djaamJsTExGDHjh0YNmxYh8eq1WokJiba7UtMTIRarba937qvs2O8ofU7PaDe1f3B3XD0+3REZ9+nVqtFY2MjIiMjXf4MZzD4ExF5WEREBEpLS2EymdxyPVEUIQiC3b6uaqmZmZkoLCyERqPB9u3bsXDhQuTn53f6AOAL3PmdOvp9+gMGfyIiL4iIiEBERIQknx0WFob09HQAwLhx41BQUIA333wTmzZtanesSqVCZWWl3b7KykqoVCrb+637kpKS7I4ZPXq0h+6gY1J+pz3V2fepUCgkq/UD7O1PRBRwrFYrjEZjh+9lZ2dj//79dvv27dtn6yOQlpYGlUpld4xWq8WRI0c67UcQyLr7PqXCmj8RkR9bsWIFZs6ciX79+qGhoQHbtm1DXl6ebajZggULkJKSgrVr1wIAli5diilTpuC1117DrFmzkJubi2PHjuGdd94B0NLDfdmyZVi9ejUyMjKQlpaGF154AcnJyV32evcXOp0OJSUlttelpaUoLCxEfHw8+vXrhxUrVuDq1avYunUrAODJJ5/E22+/jeXLl+PRRx/FV199hb/97W/4xz/+IdUttBCJiMhvPfroo2L//v3FsLAw8ZZbbhGnTp0qfvnll7b3p0yZIi5cuNDunL/97W/i4MGDxbCwMHH48OHiP/7xD7v3rVar+MILL4iJiYlieHi4OHXqVLG4uNgbtyO5r7/+WkTL+AK7rfU7XLhwoThlypR254wePVoMCwsTBw4cKH7wwQdeL/fNOM6fiIgowLDNn4iIKMAw+BMREQUYBn8iIqIAw+BPREQUYBj8iYiIAgyDPxERUYBh8CciIgowDP5EREQBhsGfiIgowDD4ExERBRgGfyIiogDz/wEVs9U0rPNUUQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ax, (dyad_collection, edge_collection) = xgi.draw_hyperedges(\n", - " H,\n", - " pos=pos,\n", - " dyad_color=[3, 1, 4],\n", - " edge_fc=H.edges.size,\n", - " dyad_color_cmap=\"viridis\",\n", - " edge_fc_cmap=\"tab10\",\n", - ")\n", - "\n", - "plt.colorbar(dyad_collection, label=\"dyads\")\n", - "plt.colorbar(edge_collection, label=\"edges\")" - ] - }, - { - "cell_type": "markdown", - "id": "5cbde978", - "metadata": {}, - "source": [ - "You can specify a `vmin` and `vmax` for the dyad and edge colors:" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "1548e22b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 37, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ax, (dyad_collection, edge_collection) = xgi.draw_hyperedges(\n", - " H, pos=pos, dyad_color=[3, 1, 4], edge_fc=H.edges.size, dyad_vmin=1.5, edge_vmax=4.5\n", - ")\n", - "\n", - "plt.colorbar(dyad_collection, label=\"dyads\")\n", - "plt.colorbar(edge_collection, label=\"edges\")" - ] - }, - { - "cell_type": "markdown", - "id": "a1424b04", - "metadata": {}, - "source": [ - "## Combine with nodes" - ] - }, - { - "cell_type": "markdown", - "id": "c2b1f9ec", - "metadata": {}, - "source": [ - "This can be either via `xgi.draw()`:" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "id": "8eeba210", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ax, collections = xgi.draw(\n", - " H,\n", - " pos=pos,\n", - " node_fc=H.nodes.degree,\n", - " dyad_color=[3, 1, 4],\n", - " edge_fc=H.edges.size,\n", - ")\n", - "\n", - "(node_collection, dyad_collection, edge_collection) = collections\n", - "plt.colorbar(node_collection, label=\"nodes\")\n", - "plt.colorbar(dyad_collection, label=\"dyads\")\n", - "plt.colorbar(edge_collection, label=\"edges\")\n", - "\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f3ad618c", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0b1dd42f", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 50, - "id": "d677fbc5", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{0: {1, 2, 3},\n", - " 1: {3, 4, 5},\n", - " 2: {3, 6},\n", - " 3: {6, 7, 8, 9},\n", - " 4: {1, 4, 10, 11, 12},\n", - " 5: {1, 4},\n", - " 6: {2, 5}}" - ] - }, - "execution_count": 50, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "H.edges.members(dtype=dict)" - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "id": "4615bc2b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{1: {0, 4, 5},\n", - " 2: {0, 6},\n", - " 3: {0, 1, 2},\n", - " 4: {1, 4, 5},\n", - " 5: {1, 6},\n", - " 6: {2, 3},\n", - " 7: {3},\n", - " 8: {3},\n", - " 9: {3},\n", - " 10: {4},\n", - " 11: {4},\n", - " 12: {4}}" - ] - }, - "execution_count": 55, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "H.nodes.memberships()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "venv_xgi", - "language": "python", - "name": "venv_xgi" - }, - "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.13" - }, - "toc": { - "base_numbering": 1, - "nav_menu": {}, - "number_sections": true, - "sideBar": true, - "skip_h1_title": false, - "title_cell": "Table of Contents", - "title_sidebar": "Contents", - "toc_cell": false, - "toc_position": {}, - "toc_section_display": true, - "toc_window_display": false - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tests/drawing/test_draw.py b/tests/drawing/test_draw.py index 56e5a27a4..9dc5a8199 100644 --- a/tests/drawing/test_draw.py +++ b/tests/drawing/test_draw.py @@ -20,8 +20,8 @@ def test_draw(edgelist8): offsets = node_collection.get_offsets() assert offsets.shape[0] == H.num_nodes # nodes assert len(ax.collections) == 3 - assert len(dyad_collection.get_paths()) == 3 # dyads - assert len(edge_collection.get_paths()) == 6 # other hyperedges + assert len(dyad_collection.get_paths()) == 3 # dyads + assert len(edge_collection.get_paths()) == 6 # other hyperedges # zorder for line in ax.lines: # dyads @@ -208,11 +208,11 @@ def test_draw_hyperedges(edgelist8): (dyad_collection, edge_collection) = collections # number of elements - assert len(ax.lines) == 0 + assert len(ax.lines) == 0 assert len(ax.patches) == 0 assert len(ax.collections) == 2 - assert len(dyad_collection.get_paths()) == 3 # dyads - assert len(edge_collection.get_paths()) == 6 # other hyperedges + assert len(dyad_collection.get_paths()) == 3 # dyads + assert len(edge_collection.get_paths()) == 6 # other hyperedges # zorder for line in ax.lines: # dyads diff --git a/tutorials/In Depth 1 - Drawing nodes.ipynb b/tutorials/In Depth 1 - Drawing nodes.ipynb index 43995572b..51dc21801 100644 --- a/tutorials/In Depth 1 - Drawing nodes.ipynb +++ b/tutorials/In Depth 1 - Drawing nodes.ipynb @@ -55,7 +55,10 @@ { "data": { "text/plain": [ - "(, )" + "(,\n", + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 3, @@ -64,7 +67,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -321,7 +324,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 10, @@ -365,23 +368,23 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "06cc1283", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 11, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -391,7 +394,9 @@ } ], "source": [ - "ax, node_collection = xgi.draw(H, pos=pos, node_fc=H.nodes.degree())\n", + "ax, collections = xgi.draw(H, pos=pos, node_fc=H.nodes.degree())\n", + "\n", + "(node_collection, _, _) = collections\n", "\n", "plt.colorbar(node_collection, label=\"Node Degree\", shrink=0.8, ticks=[1, 2, 3])" ] @@ -406,23 +411,23 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "id": "823b1252", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 12, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAe4AAAGFCAYAAAA7JBDPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABZ7ElEQVR4nO3dd3xT9f4G8OdkNN0tpZQNAqXsvYeAggNEBNELsocICHoFB+JPAVFQwS0iMhQRQZQp4ADZe5c9yyjQFkpXmraZ5/z+KOUWKNCTnjQ5yfO+r7z0luTbT6Xtk+8WJEmSQERERKqgcXcBREREVHgMbiIiIhVhcBMREakIg5uIiEhFGNxEREQqwuAmIiJSEQY3ERGRijC4iYiIVITBTUREpCIMbiIiIhVhcBMREakIg5uIiEhFGNxEREQqwuAmIiJSEQY3ERGRijC4iYiIVITBTUREpCIMbiIiIhVhcBMREakIg5uIiEhFGNxEREQqwuAmIiJSEQY3ERGRijC4iYiIVITBTUREpCIMbiIiIhVhcBMREakIg5uIiEhFGNxEREQqonN3AeRd4uLisGPHDhw6dAgpKSnQarWoWrUqmjRpgnbt2iE4ONjdJRIRqZogSZLk7iJI/f766y98+umn2LhxIwAgulpVlCldGna7HafPnkNaWhpCQkIwYMAAjB8/HuXLl3dzxURE6sShciqStLQ09OvXD126dEFOlgkL581GesIlnD1yENvW/4Vdm9Yj5fJ5nI7dj1dHDsdvvy1BnTp1MH/+fHeXTkSkSuxxk9OSkpLQsWNHJCQk4OvpH6PfC70gCMJ9X5OWlo4x48bjp18W4+2338bUqVMf+BoiIvofznGTU8xmMzp37oz0tDTs3rQeNWKqF+p1JUqEY/7s79CgXl2Mffv/UKpUKYwdO9bF1RIReQ8GNznl/fffx4kTJ7B3y4ZCh3Z+Y14ZhYTEJIwfPx5PPPEE6tSp44IqiYi8D4fKSba4uDjExMRg8nvv4P/eesPpdsxmMxq1bocKFSth/fr1ClZIROS9uDiNZJs1axbCwsIw9pVRRWrH398f7771Bv7991+cOnVKoeqIiLwbg5tkW7RoEfr3/g8CAgKK3NZzPZ5BiRIlsHjxYgUqIyLyfgxukiUhIQEJCQno0K6tIu0ZDAa0bNYU+/fvV6Q9IiJvx+AmWU6cOAEAqF+3rmJt1q9bB8ePH1esPSIib8bgJlnMZjMAIDgoSLE2g4ODkJOTo1h7RETejMFNsgQGBgIAjJmZirWZmWlCkIJvBIiIlPLdd9+hfv36CA0NRWhoKFq1aoW//vrLrTUxuEmWvP3Wh48eU6zN2CNHUVfBoXciIqVUqFABH3/8MQ4cOID9+/fj0UcfxTPPPOPW6T0GN8lSunRpVKxYEZu2blOkvZycHOzZfwDNmjVTpD0iIiU9/fTT6NKlC6pXr46YmBhMmTIFwcHB2L17t9tq4slpJFv//v0xY8YMfPLBpCJf07lk6XJkZGSgT58+ClXn3SRJwt69e7FmzRrs378fFy5cgMPhQEREBBo3boy2bdvi2WefVWSrHpGnM5vNsFqtsl8nSdJddyQYDAYYDIb7vs7hcOD3339HVlYWWrVqJfvzKoUnp5Fs8fHxiI6Oxrix/8UHE951up2srCzUb9EGtWrXwZo1axSs0DutW7cO48ePx8GDB1GqVCSaNW6MGtWjodPpkHTtGg4ePoLjJ06iRIkSGD16NN555x34+/u7u2wilzCbzSgZEIhsyI+w4OBgmEym2z42ceJETJo0qcDnHz16FK1atYLZbEZwcDAWLVqELl26OFO2Ihjc5JTJkydj8uTJ2LHhH7Ro1tSpNl5+7XXMX7gIR44cQXR0tMIVeg+z2YxXX3kFc+bORfuH2+Ct1/6LJx7rCK1We9dz485fwMzZczHj+zmoWrUqfv31VzRo0MANVRO5ltFoRFhYGPoiCH4o/A2DVkj4BVm4fPkyQkNDb338fj1uq9WK+Ph4ZGRkYOnSpZg7dy62bNmC2rVrF/nrcAaDm5xis9nQvn17nD17Buv/WIGGDeoX+rWSJOGDj6dh4ocfYdasWRg+fLgLK1U3s9mMbt26Ydu2bfhy2kd4acigQl2Deuz4CfR/cTjOX7yE9evXo3nz5sVQLVHxyQvuoQiWHdzzYEJGRsZtwS1Hp06dUK1aNXz//fdOvb6ouDiNnKLX67FmzRo89FAVtH2sM779fg5EUXzg665du46eL/THxA8/wtSpUxnaD/DyyJHYtm0b/lz+G4YPHVzou8vr1qmNLf+sRZ1aNfHUU08hKSnJxZUSuYcGAjSCjIeMkL8XURRhsVgUqN45DG5yWkREBDZt2oSBAwZg9Ng30aBFW3w3Zx6uXL2K/AM5NpsNBw7F4tU33kJMw6bYunsPFv76G8aPH+/G6j3fn3/+iR/nz8eMz6fhkfbtZL8+NDQUq5YsgiAAI0eOBAfXyBtpnHjIMX78eGzduhUXL17E0aNHMX78eGzevBl9+/ZV7GuQi0PlpIjt27fj888/x6pVqyCKIqJKlUJUVCnY7Q5cuHgRFosFJUuVwnN9BmDQiNGIjCyFyiUCoNfyvWNBJElCvXr1UDaqFNatXlHonnZBlixdjt4Dh2Dnzp1uXQlLpKS8ofIRQggMMn4+LJKEWVJmoYfKhw4dig0bNiAxMRFhYWGoX78+xo0bh8cee6wo5RcJg5sUdfx8PLZs34mTR48gPS0VGq0WFSs/hDr1G6Jeoybw8/O79Vx/nRYVw/2LFEreauvWrWjfvj3+XbMKHR9pX6S2RFFEdL1GaNP2Yfz8888KVUjkXnnB/bITwT1TRnB7Iu7jJkUFl4hEp85d0alz1wc+12x3ICXbhsggvwc+19esWrUKFStUwKMd5A+R30mj0WBQvz747OtvIYoiNBqOcpD3yJu7LvTzATixg8yj8CeYFGNziLDYH7xALb/UbCuyrQ4XVaRe+/fvR4tmTRQbjWjRtCmMRiPi4uIUaY/IU7h6jtsTecPXQB4iy8kATso0wyGq/C2wwuLi4lAzprpi7dWqGXOrXSJSNwY3KSbLanfqdXZRwrVM922t8ER2u/229QBF5af3u9UukTfRCPIfasfgJkWIklSkIW+T1Y70HJuCFalbeHg4km/cUKy968nJt9ol8ia+OFTOxWmkiGyro8jrPZKzLAjQa2HQecOPVtE0atQIB2OPKNbewdjDEAQB9esX/oQ7IjUQBEHWWhAv6HB7xZsP8gDODpPnJ0lAktEMkTsU0aZNG+zdfwDXrycr0t6f69ajXr16qt3+QnQvvtjj9oavgTyAswvT7mRxiLiRJf+aPm/zwgsvQKvVYu5PC4rc1tWEBKz4Yw1efPFFBSoj8iyc4yZygtnmgF3BVeHpOTaYLL69iKpkyZIYNHAgPvn8K1y+cqVIbY0Z9w7CwsIwYMAAhaoj8hwC5PW2vSC3GdxUdEr1tvO7lmmB3SFvT7i3+ejjjxESEoKBw0bCanVuFGL+z7/g9+UrMWPGDISFhSlcIRG5A4ObisykwPz2nRyShKRMi09fjBEeHo6FCxdix+49eLZPf5hMJlmvX/DLYrw46lUMGTwYvXr1clGVRO4l62YwmaeseSoGNxWJ3YnT0gor2+ZAmo9vEWvbrh1mL1yCjVu2oX6LNtiwacsD38xcv56MvoOHYeBLIzGgf398P3s2z4Mnr+WLi9O4HYyKxOTi40pTsqwI0GsRoNe69PN4Irso4kq6Ga06dMKqjTvxzmsvo1PXZ9CkUUMM6NMbLZo1RY3q0dDpdLh2PRkHDsVi9Z9/4bflKxEYGIgFCxagX79+DG3yanIXnHlDcPN2MCqSqxk5Lpnjzk+v1aBSeAC03rActJAcooQr6Tmw5JvnF0URWzesw6If52DH5o0FnoJWvXp1vPTSSxg8eDBKlixZnCUTFau828EmGcLhL+PNqVmSMMmSztvByDcV9bS0wrI5RCSbLCgT6u/yz+UJHKKEKxm3hzaQe8tXh8eeRIfHnoTFbMbpk8dhTkmEFhIiIiLQqFEjREVFualqIvfQQIBGxlpxb+hxM7jJaUqcllZYRosdgWYbQv31xfQZ3eNWaD9g3YDB3x/1GzVB1YhA6LTe8KuIyDm+OFTO4CanuXqI/E7XTRb467Xw89KgcogSrhYitPPzpekDooLIXXDmDb89vOFrIDdR4phTOcSbR6J647KMvNA2ywltmWc0E5F3YHCTU5Q+La3Qn9cuIsXLjkQVRQlXM8yyQhsAdOxtE/nkkaccKienFPcweX6pOTYE+mkR6Kf+b19RlHDVaIbZLv+/J4fJifKOPJVzO5j6R+zY4yanFPcw+Z2SMi1wuKHHryRRyg3tHJtzb4IY3ES+2eNmcJNsdocoe1hX8RpECUmZZrfWUBSiJCEhw/nQBjhUTgT45slp3vA1UDFz5zB5fllWB9Jy1DffnRfa2UUIbYA9biLAN3vc6p8kpGLniktFnHXDZEWgXguDTh1HooqShERj0UMbYI+bCHDmABb1/9ywx02yiJKkSOgoRQKQaLRAVMEWsbzQVmrEgj1uIt/E4CZZsq0OeFpGWh0ikk2ePWQuSRKSjBZFpxm03MNN5JND5QxuksVT5rfvlGG2IdPiOUP4+UmShESjRfEpBg6VE+VuB5P7UDvOcZMs7t4Gdj/XMy3w12mg96AjUSVJQmKm8qENcKicCPDNs8q94WugYuKu09IKyyFJSMq0eMyRqNLNekwuGAngcadEufIWp8l5qB2DmwrNU4fJ88uxOZCabXN3GZAkCdcyLS4bvmdvmyiXL85xc6icCs2Th8nzS8m2ItBPiwC9e7aI5YW20YVz7pzfJsqVe+SpvOerHXvcVCiecFqaHIlGs1uORJUkCddNrg1tgD1uojy+uDiNwU2FooZh8vzsooRrJkuxfs7c0LYiw+z6kQkGN5Hv4lA5FYonnZZWWCaLHRlmG8L89cXy+XJDu3jm1zlUTpRLIwjQyFioycVp5BM87bQ0Oa6bLLAWwxD/dZOl2EIbYI+bKA+HyokK4ImnpRWWJAGJmWaXHomabLIgPad4V7Lz1DSiXAxuogKobX77Tha7iJQs1xyJmmyyIK2YQxvgUDlRHl8Mbs5x0wOpZRvY/aTl2BDop0WQn3Lf8jfcFNoAh8qJ8ggyDyMSvCC62eOm+zLbPfu0NDmSMi2wi8rMd9/IsiLVTaENMLiJ8vhij5vBTfeVZVH3MHl+DjH3hq6iHomakmVFarb7biPTylxFS0TehcFN9+UNw+T5ZdscRVpIlpJtRYobQxtgb5soP40TD7XjHDfdk9pOSyusG1lWBOi18Jd5JGpqttVli9zkYHAT/Y8g5D4K/XzXlVJsvOHNB7mI2leT34sEIDHTAlHG3H1athU3PCC0AQY3UX6CE/9TOwY33ZO3BjcA2BwirmcV7kjUtBwrkj0ktAFuBSPKj4vTiG4SJQlZNu+a376T0WxH5gPOFU/PsSHZ5DmhDbDHTZSfLwY357ipQDk29Z6WJsc1kwX+eg302rvfw6bn2HC9mC8qKQwdV5QT3aKBvDu2NV7we409biqQyYu2gd2PKElILGCLWIaHhjbAHjdRfpzjJrrJ27aB3Y/Z7kBK9v+2iGWYbcV+JagcDG4i38ahcrqLN52WVlip2VYE6rWwiyKuZXpuaANcnEZ0J1/7iWBw01286bQ0OS6kZkGr8fxTydjjJvof2fu4veDHh0PldBdfGibPY7aJSM22wfiAVebupuFxp0S34apy8nl20TtPS7sfs11Ehjl3jttiF5FtdSDQT96pasWFvW2i22kgQCMjjuU811Oxx0238eZDVwpisYsw3nF2uclih93hmW9eOL9NdDtf7HEzuOk2vjS/bbGLyMix4c5leBKADLO9yLeIuQJ73ES3y5vjlvNQOwY33eILp6XluVdo57GLkkfuZefhK0TE4KZbfOW0tAeFdp5smwMWu2eFN3vcRLfjUDn5NE/sYSrNWsjQzmM02+HwoD3tDG6i2/HkNPJp3r4NzGoXkW4ufGgDgCgBRrPNY+a7uTiN6HYaQf5D7RjcBACwePlpabdC24kv0eqQkG3zjNEI9riJbsehcvJZJi/eBmZzOB/aeUwWB2wesEWMPW6i2zG4yWdlWbxzmNzmEJGWU7TQzpNhtkN085A5e9xEt+McN/kkbz0tTcnQBgCHKCHTjUei5s7Pqf+XDhEVDY88Ja88LU3p0M5jtovwszkQoC/+I1G1Gr7PJrqTL14ywuAmrzstzeYQke6C0M6TabFDr9UU+3yz1ht+4xApTAN5Q8fe8PbXG74GKgJvOy0tL7RduUBectMWMS5MI7qbLy5OY4/bx3nTaWn2YgjtPDaHBJPVgRBD8f0IcWEaUQEEAYKPjZWzx+3jvGWY3O6QkFZMoZ0n2+qApRgX9bHHTXQ3X+xxM7h9nMkLTkvLDW1rsYZ2HqPZVmxbxNjjJrobg5t8ijeclmZ3SEh3U2gDeUeiFs+bH/a4ie4m3Bwql/NQOwa3D1P7aWl2MTe0HW5+72Gxi8guhv+W7HETEcDFaV4tOzsbS5Yswfr167Fn1y4kJV2DBAlRpUqhWYsWaNiyLTr3eB7BIaHuLlU2hyghPdv9oZ3HZLFDrxWg17ruvTCDm+huci8O8YYfI0HylGuPSDE2mw3Tp0/HJx9/jMzMTJTR+qGkQ0LIzQEWE0SkaAUkiTYYDP7o/9JIjH5jPAz+/m6uvHAcooQ0DwrtPDqNgIhAvcuG4qJLBkHjDb91iBRgNBoRFhaGbeUqIljG4UQmUcTDCZeRkZGB0FD1dVoA9ri9zsWLF/Fs9+6IPXIEdSQd6iEIoY4CvqkdQBb0OGa2Yd43X2Ld6lX4dsGviK5Rs/iLlsFTQxvIHbrPtNgR6q9XvG1BAEObqAC+eHIa57i9yIULF9C6ZUtcOH4C3aUAtIE/Qu/zVxwEDVrAgGclf2TGx6PPU51w+sTxYqxYHoeYu+XLE0M7T45NhNkFV4DqvOG3DZEL5AW3nIfaMbi9hMViQdcuTyEnJRVd7X6IQuHP0o6AFk87DPDLysZLvXvAlGl0YaXOEfNCWwWr4I0Wu+J1cn6bqGBcVU6q9eGHH+LU6VPoZNcjyIm/VgMEdHL4IfX6dUx7/z0XVOg8NYU2kHskaobCR6LqeMEIUYHY4yZVSktLw/Rp09BA0qOkjJ72nUKhQRNRh99//hFXL8crWKHzRCk3tNW239zmkBS9dY09biLKw+D2AvPnz4fdZkddFH1RVC3ooddosGTBDwpUVjSiJCEtW32hnSfL6oDVocyRqAxuooJxqJxUac2aNagALQIV+OvUQ8BDDgGb//lTgcqcp9ae9p2MZrsiR6Ly1DSignGonFRHkiQc2LcfpSTlvhtLQYtzZ8/AYjYr1qYct0Lbk5ePF5JDlJCpwJGo7HETFUwjCLIfasfgVjmTyYSMTCPCFPyrDIMGDocD15MSFWuzsERJQrqXhHYes11EThG3iLHHTVQwX+xx8wAWlRPF3DlUJb8X89rKa7u45IW2zYtCO0/mzSNRnV0drvWG3zZELiBA3ry14AX3g7HHrXJBQUHw0+uRDeXCLq+t8IgIxdp8EEmSkJ5j98rQBm5uEcuxO71FjEPlRAUTNPIfascet8rpdDrUq1sXyYeOKtZmMhyoVKECGlYtD4tdhMUhwmq/+XCI932L4HA4cOHcWVxLTIAkSYiMKo1qMTWg1997xfv/Qrt4e/jFzS5KMFkdCDHI+7ETwOAmuie5K8W9YPSKwe0FHunYETOPHoXDLkFbxGEgCRLitRK6d+wIvVYDvVaD4Px/LkmwOkRYboa4xS7CbLVj44b1WPzDHOzathnmOxa1+en90KRlK/QZPAyPPvkUdDrdbe2l59gV2zbl6bKtDvhpNTDoCv+2n6FNRPl5waABvfjii8i22xGHoq9evgwHMhx2nDhxArt27brrzwVBgEGnRai/HpFBBhgTLuKFLo/ipRd64timjWhgFtEVAeiDIPRBELohAE1sAi7u3IVXhvRDt3YtcDT2IADfC+08RrO8U+C4MI3o3nxxcRqD2wvUqFEDXZ/qir1aO8xFmOu2QcIOwQoBwL59+9C6dWt07twZe/fuLfD5v/32Gxo2aIBzhw7jaQSgh90PDWFAeegQAg1CoEFZ6FAffujmMOBZBCLzwgX858lHsOjHOT4Z2gAgSrnnmRd2vps9bqJ7yw1jOQewuLviomNwe4G4hHQ80f91OPR+2CJYcP9Z6IJJkLADFmRrNRgzZQ7aPv4sNBot/v77b7Ro0QJPP/00Dhw4cOv5K1aswAu9e6OyHXjWYUA56B64WrMUtOjmMKC2qMX748biz98WINighb9OA53GG9Z6Fp7VLiK7kFvE2OMmujdf7HELkpI3IVCxysiyYOfxBCSkZAEADu/Zgm8nv4qHJC06wAB9IaPQAQnbYcEp2DDk9Slo3bEbAOB64mWsWTwLuzaugXRza9gzzzyDESNG4PnnnkNUthWdJIPs7RXSzc93RithxcYdiKlVO/fjkgSHKMF+x0Mtl4vIJQAoEaiHXnv3+2dJknDj+nWYzTkoGxGKWlUqesVRjURKMRqNCAsLw9Fa1RCiLfwdDZkOB+qdjENGRgZCQ0NdWKHrMLhVyOEQcfj8DRw+fx13brU+tHMD5nzyFvwdItqIelSE9p7BKkFCEhzYprHDCBED/jsJbR7rftfzkq5cxJrF32PPlj9vBXigoMF/pEAYnOwnOyBhhdaCMrVrY9m/2+4bSuKdge6QYBdFeEOeazUCIgL10AgCLGYz/lq1HKt+X4xjhw7CmO961YjwcDRv0QL9BwxAz549YTAY3Fg1kfvlBfex2vKDu+4JBjcVo6s3TNh5IgHGLOs9n3M98TJ+/Oz/cPbEIZTQ6lHNIaAUtAjJPaoAmRBxAw6c10i4IdpQqUoNDHljKipUibnv5068fB6/zfkUR/dvwyPwR0wRLzW5AjvWIgc/r/wLzVu3lf16UcoL8dwgzwt2tX1HG3QCtv25Eh+OfwPp6WmooNGjjCigJDTQQYANElIgIkkj4apoQ1RkKcyc9R169uzp7tKJ3CYvuI/XiZYd3HWOn1N1cHM7mEpkm23YezoJcQkZD3xuVNmKeGv6Tzh9dD82rV6MEwd3Ijsn67bn+PsHoEb95ujXtTdqN24NTSFO9CpbsSrKVKyCcwd3oppY9G+d8tAiQuuHJQt+cCq4NYIAP50APwDId53p/3rn4q1gd4iSgkfUKMdiMWPi6Jex6a8/EC3o8SSCECbe/XdRBQBEIA167EtJx3PPPYf+/fph7rx58PPzK/a6ich9GNweTpIknLqciv2nr8FqL/wKbEEQULN+M9Ss3yx3vvTaVaSnXIckSQgrEYlSZSsWKqzvdObIPlQQhSLvFwdyjx6s6JCwb8e2IreVn1YjQKsRYMi39tIT589tViveHT4AB3ZsxmPwR1XpwSMYJaDFY5IGZ6HF4kWLYDQasXTZstv2xhP5ErkLzrxhqQh/2j1YijEHO44nIDk9p0jtCIKAUmUqoFSZCkVqR3Q4cPXSWTRH4YelHiQSWhy+loS01BSUiCipWLt3EgQBOq0A3R2lS9LdYW53FM/8+fxvPsX+7ZvxpGRABRk/igIExEAPgyjgj9WrMW3aNLzzzjsurJTIczG4ySPY7A4cOHsdJy6leNR8rdmcDbvdjkAFv20Cb/bc09NSXRrc9yIIAvRaAfo7At3V8+dnjh/BL7O+RBNJJyu086sMHRpIekycOBHdu3dH7dq1lSmOSEUEjQBBxpZJQcErkN2Fwe1hLiZlYNfJRGQrcIez0jSa3HRT8siUvLZKBBoQ5q+DQ7y5ilySIEqAKOb+e3Er1Pz5zRXuzsyf/zLrK4QJWjRA0eanm8IP52HB9OnT8eOPPxapLSI1Yo+b3CYz24pdJxJwOdnk7lLuyeAfgKCgEGRkWRRrMwMidFot6sdUhb+/f4HPkfJCXJJubg3L9++SBFH835YxUcLN0P/f/xcVDP57zp/f1kO///x52o1kbP17DVqIuiKvFdBCQE27gMWLFuGLL75AeHh4kdojUhuNIEAjI43lPNdTMbjdTBQlHL1wA7Fx12H38CstBUHAQzF1cT12P5Raon0dDtSqWeueoZ33ebUCnA65/MF/Z7jn9uiR799v7+k7pAcPjwuCAJ0g4M57Q+41f354/244RAeq4t5fsxxVocdeaxZ2796NJ598UpE2idRCDT3u9PR0LF26FHFxcXjzzTcRERGBgwcPonTp0ihfvrzs9hjcbpSUmoUdxxOQblKuB+tq9Vu0x6+HdiMLIoKKeGKuDRIuaSW80f0ZhaorWP7gv3MuuzDygt9xj3C/axQg379rBOmuz3n1zHEE6/QIsitz4nAoBARodThw4ACDm3xO3hnkcp5fnI4cOYJOnTohLCwMFy9exLBhwxAREYHly5cjPj4eCxYskN0mg9sNzFY79p1Owpkr6e4uRbZWHbth2bzPcdRmRcsi9hhPwgabKOGll15SqDrXuK3H70Twi7d697nhn52ejBAFrwkQICBEo0ViYqJibRKRMsaOHYtBgwZh2rRpCAkJufXxLl26oE+fPk61yUtGitnZq2lYtu2sKkMbAAKDQtCl90s4AjuSUbhLMgqSAREHNHaMGDkClSpVUrBCz6MRBOg0GvjpNAjQa6GXccqTHDzLnHyRAJmXjBRzffv27cPw4cPv+nj58uWRlJTkVJsM7mKSlmnG2j3nsfXIVZitzgeeJ3jy+SGoWKU61musyHRijXkORPyrtaJchfL45JNPXFChZytXrhwyIUKps9wkSDCKDpQrV06R9ojURN6VnvKG1ZVgMBhgNBrv+viZM2dQqlQpp9pkcLuY3SFi3+kkrNx5Dkmp2e4uRxE6nR6j3/8WfiUj8YfWgkQUfuvaDTiwRmuFFBqCv/75B8HBwS6s1DM1btwYJrsNWQoFdwYkmB12NGnSRJH2iFRF7pWexdzl7tatGyZPngybzZZbriAgPj4e48aNc/q+AQa3C8Vfz8SybWdx5PyNu27xUruIyDJ4+7OFKB1dC38gB1tgRtp9hs6NELELZqwQclCuRgx27t6FmjVrFmPFnuPhhx+GXqdDnIw3PPcTBxsC/P3RsmVLRdojUhNP73F/9tlnMJlMiIqKQk5ODtq3b4/o6GiEhIRgypQpTrXJxWkukGW2Yc/JRFxIunt4xJuUiCyNcZ/+jA2rF+HPxd/jVGYGonR+iLBLN28iA0yQkKIVcN1hRUhICCa8/jrGjx/v0xdjREZG4j+9emHtkt9Q1y4VaS+3DRJO6yT0HzBAtTcdERWFoMl9yHl+cQoLC8P69euxfft2HDlyBCaTCY0bN0anTp2cbpPXeipIFCWcjE/FgbPXYJNxIYhXEO0wpJ3Apk0bsHf3biQkJECSJERFRaF5y5Z45JFH0KtXLwQGBrq7Uo9w7NgxNGrUCPXsGjSH83dr74QZZ/wEHD12DNWrV1ewQiLPlnetZ3yr2gi98xKC+73O7kClXSfccq2n2WyGwWAocq+fPW6FXE/Pxs7jCUgxmt1diltUq1ASHZ7qg379nNve4Gvq1q2LiRMnYuKECYiStHjIiR/FONhwDDZ8+tFnDG0iDyWKIqZMmYJZs2bh2rVrOHPmDKpWrYr33nsPDz30EIYOHSq7Tc5xF5HV5sCO4wlYveu8z4Y2AFQvX8LdJajO22+/je7du+NfwYJTsBV6lbkECcdhxUbBghf69MFrr73m2kKJPJlGkP8oRh9++CHmz5+PadOm3TZFWLduXcydO9epNhncRXA+MR3Ltp3FqfhUd5fiVkEBepQrGeTuMlRHp9Ph1yVLMGDQQGyBGf9oLLjxgL3xyXBgLczYDgtKRkZi7ty5Tt2rTuQ1ZG3ilnk+qgIWLFiA2bNno2/fvtDmO8OhQYMGOHXqlFNt8ifeCcZsC/7edxGbYq8g2+J5t3gVt+rlw3n4h5P0ej1++OEHrFq1CvbSkViGbKzUWrALZpyBDRdgwxnYclfkay1YjmwI5aIQHByM5ORkfPDBB+7+EojcytNXlV+9ehXR0dF3fVwUxVtbxORicMvgcIg4dO46lm87h6s3PPcWr+JWvXy4u0tQvW7duuFifDyWL1+ONs90RUrZSGyCGetgxiaYkVY+Cu16dMMff/yBi/HxmD9/PgDg448/xpYtW9xbPJE7efhQee3atbFt27a7Pr506VI0atTIqTa5OK2QElJM2HE8AcYsq7tL8ShlIgIRGuj8qmj6H51Ohx49eqBHjx4AgKysLOTk5CAgIABBQbdPRfTs2RNDhw7FvHnz0L9/fxw+fBglSnCdAfkgD78ebMKECRg4cCCuXr0KURSxfPlynD59GgsWLMCaNWucapM97gfIsdix5fBl/LX3IkO7AFyU5jpBQUGIjIy8K7TzfPnll4iOjsbly5cxYsQIcGcn+SJBI8h+FKdnnnkGq1evxr///ougoCBMmDABJ0+exOrVq/HYY4851SZ73PcgSRJOX07DvtNJsPranuxC0mkFVCnDQz/cJTg4GL/88gtat26N3377DU899RQGDBjg7rKIipcH97jtdjumTp2KIUOGYP369Yq1yx53AVKMOVi9+zx2HE9gaN9HlTJh0Ms4+ICU17x5c7z//vsAgFGjRiEuLs7NFRFRHp1Oh2nTpsFuV3YRM4M7H5vdgT2nErFqZxyS03PcXY7Hq16Bw+Se4O2330bbtm1hMpnQr18/xX9JEHkyQZA5VF7Mc9wdO3ZUfAEph8pvunTNiJ0nEpBt5i+9wggJ9EOZEjy+1BNotVosXLgQ9evXx+7du/Hhhx9i0qRJ7i6LqHh48FA5AHTu3Blvv/02jh49iiZNmty1ZqVbt26y2/T5s8pNOVbsOpGI+OuZ7i5FVRpXj0Kj6Ch3l0H5LF68GH369IFGo8G2bdvQunVrd5dE5DJ5Z5VffaIJQvWF74MabXaU/+dAsZ1Vfr8DkgRBgMNx/0OXCmyzKAWpmShKOHI+Gcu2nWVoO4F7tz3PCy+8gH79+kEURfTt2xdGo3ffTkcEeP4BLKIo3vPhTGgDKhgqT0lJwcqVK7F//36cPHkSOTk5CA4ORr169dC8eXN069YNwcHBstpMSs3CzhMJSMu0uKhq71auZBCCA3z3Wk5PNmPGDGzfvh0XL17E6NGjsWDBAneXRORacg9VKebtYK7gsUPlCQkJ+L//+z8sXrwYNpsNtWrWQL3atREUFIgMoxGxR47iXNx5hIaGYsiQIZg0aRLCwsLu26bZasf+M9dw+nJaMX0V3ql9/QqIZo/bY+3YsQPt2rWDKIpYvHgxevfu7e6SiBSXN1Se8FRz2UPl5dbuLbah8q+//rrAjwuCAH9/f0RHR6Ndu3a3nWP+IB4Z3IsWLcKoUaPgbzBgzOiXMbh/X5QqFXnX8y7Fx2P2Dz/hm1mzERYWhvnz56Njx44Ftnn2ahr2nkqC2erc0ATl0us06PNoTei0PjvLogoTJ07E5MmTERYWhiNHjqBSpUruLolIUWoJ7ipVqiA5ORnZ2dm3TjdMS0tDYGAggoODcf36dVStWhWbNm1CxYoVC9Wmx/32/eyzz9C3b1889cTjOL5/N94a+98CQxsAKleqhCmT3sOxfTtRs3o0nnzySSxduvS256SbLFi75zy2HrnK0FZA1bJhDG0VeO+999CyZUtkZGSgf//+Ts+lEXk6QSP/UZymTp2KZs2a4ezZs0hJSUFKSgrOnDmDFi1a4KuvvkJ8fDzKlCmDMWPGFLpNj+pxL1u2DM899xzGvzEWUya9J2sRgd1ux8BhI/H7ipXYvn07Gjdpiti4ZBy9kAyRZ6gopmvLqijNbWCqEBcXh4YNG8JkMmHq1KkYP368u0siUkxejzuxWwvZPe6yf+wpth53tWrVsGzZMjRs2PC2jx86dAg9e/bE+fPnsXPnTvTs2ROJiYmFatNjuk7Xr1/HiBEj0LN7N9mhDeSeUDN/9kw0qFcX/foPwK8bjuNwHENbSaFBfgxtFalWrRq++eYbALkXHezbt8/NFREpz9PPKk9MTCzwUCS73Y6kpCQAQLly5ZCZWfjdTR4T3FOnToXD4cDMLz5zerm+Xq/H/O9n4sL5OPy5YpHCFVIMLxRRnYEDB+L555+H3W5H3759YTLxOlryMnkHsMh5FKNHHnkEw4cPx6FDh2597NChQxg5ciQeffRRAMDRo0dRpUqVQrfpEcGdlZWF+fPnY/iQQYiKKlWkturUroXuT3fFlj9/421JChIEcCW5CgmCgFmzZqFChQo4e/asrHk0IlXw8Pu4582bh4iICDRp0gQGgwEGgwFNmzZFREQE5s2bByD3wqDPPvus0G16xD7ujRs3IiMjA0MG9FOkvaED+mHpiueQEB+H8pWjFWnT15UrGYwgf727yyAnREREYMGCBejYsSPmzp2Lzp0749lnn3V3WUSKkHuoSnEfwFKmTBmsX78ep06dwpkzZwAANWrUQI0aNW4955FHHpHVpkf0uPfv349SpSIRXa2qIu21atEMAHDp3AlF2iMgpkK4u0ugInjkkUfw1ltvAQCGDRuGq1evurkiIoV4eI87T9WqVVGjRg106dLlttB2hkcE95kzZ1C7Zg3F3gmFhYWhXLlyuH71kiLt+To/nQaVo3jvttpNnjwZjRs3RmpqKgYOHAiRKzeJXC47OxtDhw5FYGAg6tSpg/j4eADAK6+8go8//tipNj0iuG02Gwx+BkXb9DcYYLfbFG3TV1UtFw4t926rnp+fHxYtWoSAgABs2LABX3zxhbtLIlKA3IVpxdvjHj9+PA4fPozNmzfD39//1sc7deqEJUuWONWmR/w2Dg0NRWqacseQSpKE1LQ0+AfKO8OcCsZhcu9Ro0YNfPnllwByf6HExsa6tR6iovL0S0ZWrlyJGTNmoG3btrd97jp16iAuLs6pNj0iuBs0aICjx0/AZlOmh3wpPh7p6emoWKVo8wgEhAcbUCqMe7e9ybBhw/DMM8/AZrOhT58+yM7OdndJRM7z8Dnu5ORkREXdfQVyVlaW028iPCK4W7VqBYvFgq3bdyrS3j//boQgCHgopo4i7fmymArcu+1tBEHA3LlzUaZMGZw8efLWojUiNfL0HnfTpk2xdu3a2+oFgLlz56JVq1ZOtekR28GaNWuG2rVrY+acuej4SPsitSVJEr6dPQ8NmrdHWImCzzinwhEEoFrZ+9+4RuoUGRmJn376CU888QS+/fZbPPnkk+jatau7yyKSz8Ov9Zw6dSo6d+6MEydOwG6346uvvsKJEyewc+dObNmyxak2PaLHLQgCXnvtNSxftRpbtm0vUls/LVyEo8eOoeMzyuwJ92UVIoMRyL3bXuvxxx+/dSDLkCFDcO3aNTdXROQEDz85rW3btoiNjYXdbke9evWwbt06REVFYdeuXWjSpIlTbXrMJSOiKKJDhw64cjke+7ZuQsmSEbLbOBd3Hk3adkDdZh0w5PUpLqjSt3RsVBEPlWGP25uZzWY0b94cR48eRefOnbF27dpiH0okckbeJSPJ/R9FqJ+MS0asdpT6eWOxXTLiCh7R4wYAjUaD+fPnw5SVjcee7o5r167Lev2Zs+fwaJduCAoriV4vcc6uqPz9tKjEvdtez9/fH4sWLYLBYMBff/2Fb7/91t0lEcni6ktGPvroIzRr1gwhISGIiopC9+7dcfr06UK/PiMjA0uXLsWnn36Kzz77DCtWrIDRaJT7Zd7GY4IbyD1ZZsOGDUhIuoZ6LVpj2cpVDzxv3OFwYObsuWjUuh0cGj+MmTIbQSHsJRZV1bLh0LjphCEqXnXr1sX06dMBAG+88QaOHz/u5oqIZHDxUPmWLVswatQo7N69G+vXr4fNZsPjjz+OrKysB7524cKFqFy5Mv7zn//grbfewptvvomePXuicuXKTu/hBjxoqDy/pKQkjBw5EitXrkS9OnUwbPAAtGvTGrVr1YRer4fZbMaRY8excfNWfP/DfFy8dAntu/wHzw8ZC//AIHeX7xWeaV0NkWEB7i6DiokkSejSpQv+/vtv1K9fH3v27LntsAgiT5M3VH5jSCeE+hV+LY7RakPkD/86PVSet71ry5YtaNeu3T2fd/DgQbRo0QJ9+/bFmDFjULNmTUiShBMnTuDLL7/Er7/+in379qFBgwaya/DI4AZyf5Fs2LAB3377Lf744w+IogiNRgM/Pz9YLBZIkgSDwYD2j3VFs07PoUpMXXeX7DUiQv3Row0vZ/E1SUlJqF+/PpKTkzFmzBh8/vnn7i6J6J7ygjtl6GOyg7vkvPW4fPnybcGdd3PXg5w7dw7Vq1fH0aNHUbfuvXNn8ODBMJlM+P333wv88+eeew6hoaH44YcfCl17Ho8N7vxMJhNiY2Nx8uRJmM1mBAUFoV69eqhXrx5Ss+z4a+9Fd5foVVrUKoO6D3ErnS9as2YNnn76aQDAP//8g8cff9zNFREV7FZwD3tcfnDPWXfXxydOnIhJkybd97WiKKJbt25IT0/H9u333wEVExODmTNnolOnTgX++b///ouXX3751o1hcnjEPu4HCQ4ORtu2bdG2bdu7/qysQUJwgB6mHJ5LrgSNBoguF+7uMshNunbtipdffhkzZ87EwIEDcfToUURG8k0ceTC589Y3n1tQj/tBRo0ahWPHjj0wtAEgISEBMTEx9/zzmJgYp2/p86jFac4QBIGneymoYqkQ+MvYWkHeZ/r06ahVqxaSkpLw4osvPnCBKJEahYaG3vZ4UHCPHj0aa9aswaZNm1ChQoUHtp+dnX3fdSIGgwFms1l23YBKetwPUr18OA6elbd9jApWnW+CfF5gYCAWLVqE5s2bY9WqVZg7dy6GDRvm7rKICuZkj7uwJEnCK6+8ghUrVmDz5s2oUqVKoV/7zz//ICys4F1O6enpsurIzyuCOzjADxVKBeNKssndpahagEGLipEh7i6DPEDDhg3x0Ucf4Y033sBrr72Gdu3aoUYNXtpDnkjuFi95wT1q1CgsWrQIq1atQkhICJKSkgAAYWFhCAi4/86bgQMH3r8SNV8yooSY8uwpFlW1cty7Tf8zZswYdOzYEdnZ2ejbty+sVqu7SyK6m0Yj/yHDd999h4yMDHTo0AFly5a99XjQPmxRFB/4cDgczn3JTr3KA1UuHQp/P627y1C16nzzQ/loNBr89NNPiIiIwIEDBzBx4kR3l0R0NxcfwCJJUoGPQYMGuebrKQSvCW6NRkA1roZ2WmRYACJCeOAG3a58+fKYM2cOAOCTTz7B5s2b3VsQ0Z08/JIRV/Ca4AZ4d3RRVC8f7u4SyEM9++yzGDp0KCRJQv/+/ZGWlubukoj+h8GtbhEh/igVzmM65dJogGrleL473duXX36J6OhoXLlyBcOHD+cWMfIcLp7j9kTq/wruwEVq8lWOCoVB7xUbDMhFgoODsWjRIuh0Ovz+++9YsGCBu0si8lleF9xVy4ZBp1X/UEhx4t5tKoxmzZrh/fffB5B7GEVcXJybKyKCKobK09PTMXfuXIwfPx6pqakAci8h8dmT0+7kp9eiShkO+xZWoEGHCpHB7i6DVGLcuHF4+OGHYTKZ0LdvX9hsPGqY3MzDg/vIkSOIiYnBJ598gk8//fTWwSvLly/H+PHjnWrT64IbYA9Sjujy4U4fAkC+R6vV4ueff0ZYWBj27NmDDz/80N0lka/z8OAeO3YsBg0ahLNnz952BGqXLl2wdetWp9r0yuAuGxGE0CA/d5ehCty7TXJVrlwZs2bNAgB8+OGH2LFjh5srIp/m4YvT9u3bh+HDh9/18fLly986hU0urwxugIvUCqNUeADCgx98Iw7RnXr37o3+/ftDFEX069cPRqPR3SWRr/LwHrfBYCjw5+PMmTMoVaqUU216bXBXLx/uDdv1XIpvbqgoZsyYgSpVquDixYsYPXq0u8shXyVAZnAXb3ndunXD5MmTb60HEQQB8fHxGDduHHr27OlUm14b3IH+ei66ug+tRkDVslzER84LDQ3FwoULodFo8PPPP2Px4sUAclfQzp49G4MHD0aj+vVRtXIl1Iiuhq5PPYVJkybh8OHDbq6cqPh89tlnMJlMiIqKQk5ODtq3b4/o6GiEhIRgypQpTrUpSF58ksKla0b8ezDe3WV4pGrlwtChQUV3l0FeYNKkSXj//fcRGhqKHj164PfflsBisaJBqXA0ighCSX89rKKEk2lZ2HfDiNRsM9q0aoXpn32GVq1aubt8Uimj0YiwsDCkvNULoYbCr2kyWqwoOW0JMjIyEBoa6sIKb7d9+3YcOXIEJpMJjRs3RqdOnZxuy6uDWxQl/Lr5FHIszt3A4s2ebPYQynNEghRgt9tRv359nD11CgadBm80rIqhtSqibNDdZ9/bHCJWX7yGaYcv4lByBt544w1MnToVWi0vCCJ58oI79e0XZAd3xMeLiz24leTVx2XlXTxy7EKKu0vxKEEBepQrGeTuMshLrFu3DnHnzqJVmRKY37EBKoXc+9hhvVaDZ6uVRbcqpfHF4Qt479NPcTk+Hj8vXMjwJie59j5uZ3z99deFfu6rr74qu32vDm4AqFEhgsF9h+rcu00KOXXqFHo++yw6V4zEok4N4act3LIZnUaDNxtVQ7XQQLywZAmqVqvGPeHkHLkrxYvhd98XX3xx2/9PTk5GdnY2wsPDAeSuAwkMDERUVJRTwe21i9PyhAcbEMWLR27Dm8BICQ6HA4MG9EelIAN+7tig0KGd37PVymJis+r4+OOPsH//fhdUSV7PA7eDXbhw4dZjypQpaNiwIU6ePInU1FSkpqbi5MmTaNy4MT744AOn2vf64AaAGhUj3F2CxyhdIhChgdy7TUW3fPly7Nm3H7Pb1UaAzvlh7jcbVkXtiFCMHzdOwerIZ3j4ASzvvfcevvnmG9SoUePWx2rUqIEvvvgC7777rlNt+kRwVykTyotHbuKd5aSUmTNmoG35SLQpW7Q3xnqtBmPrVca/GzfizJkzClVHPsMDe9z5JSYmwm633/Vxh8OBa9euOdWmTwS3XqflnmUAOq2AKmXUuYqSPEtGRgY2b92K/tXLKtLec9XKINBPj9WrVyvSHpGn6NixI4YPH46DBw/e+tiBAwcwcuRIp7eE+URwA0BMBQ6XVykTBn0RhjSJ8uT9EmpZOlyR9vx1WjSIDMWBAwcUaY98iIf3uH/44QeUKVMGTZs2hcFggMFgQPPmzVG6dGnMnTvXqTa9flV5ntIlAhEW7IcMk9XdpbhNNBelkULOnz8PAKgRrtxZADVDA3CcQ+UklweuKs+vVKlS+PPPP3HmzBmcPHkSgiCgZs2aiImJcbpNnwluIHdr2N5Tzt3GonbBAXqUjeDebVKG3W6HRhCg1Sj3S1Cv0cBu5/3eJJPcBWfFvDgtT0xMDKpXrw4ARd6O61PBXa1sGH5bvR5H923HpXMnkJacBEBCcGgEKkbXQo26TVGncWtovPAgiOrlS3DvNimmRIkSECUJKWYrSvorc4VustmKEqVLKtIW+RAP73EDwIIFCzB9+nScPXsWQG6Iv/nmm+jfv79T7flMcK9duxYTJkzAwYMHUaJECTRp2AAtH2kNjUaDKwkJ2L/jb/z9+w8oVbocHu85GO27/AcaN70zcwXu3SYlNWzYEABwKDkDnSo6dzXhnQ6mmvD8s00UaYt8iIcH9+eff4733nsPo0ePRps2bQDknls+YsQI3LhxA2PGjJHdptcHd1ZWFl5++WUsWLAAj7Zvh7XLfsMTj3Us8HjFfQcO4uuZs7Bw5hTs3/YPhr7xESJKlXFD1coqWzIIIYHK9IqIACA6OhqlSpbE2kvJigT38dRMXEo3oXXr1gpURz7Fw4fKv/nmG3z33XcYMGDArY9169YNderUwaRJk5wKbu/pUhbAZDLh8ccfx/Lly/HjrG/x79pV6PLk4/c8E7lZk8b4ed5sbPprNbLTkvDJmwOQnHSlmKtWHu/dJqVpNBoMHTYMP59NhMl29x5VuWYdu4TSpSLx1FNPKVAdkedITEws8A1p69atkZiY6FSbXhvckiShf//+OHr0KP5dsxKD+vct9Bxvh3YPY9emdQgP9sfXE1+GxZzj4mpdR6/T4CHu3SYXGDlyJCwSMGFP0VaCx94wYu6pK3j1tTHw8+PIEMkkQOZ2sOItLzo6Gr/99ttdH1+yZMmtxWpyee1Q+S+//IKVK1di+eKf0aJZU9mvL1+uHNYu+w0NWj6MlQu+Qa+X3nJBla5XtWwYdE6cIU30IJUqVcLUjz7C66+/jscrRuLJylGy28iw2DBo01HUqlkLb7zxhguqJK/n4XPc77//Pnr16oWtW7femuPesWMHNmzYUGCgF4ZX/ka32WwYN24c/tOzB3p0e9rpdmrEVMfkd8djwx+/IOVagoIVFp/ocuHuLoG82KuvvoquXbrgP+tj8eel67JeeyPHii5/HsAls4jXp82CQ/C+3RxUDDz8AJaePXtiz549iIyMxMqVK7Fy5UpERkZi79696NGjh1NtCpIkSQrX6XbLli3Dc889h9hd29Cgfr0itWUymVAuuhYe7twLzw76r0IVFo/QID883875Tf5EhWE2m9G713+w6o/VGF6nEj5sUQPhBv09ny9JEpafT8IrO07BqjNgwqzFqF6nIQw6DZpUCkfJIA6X04MZjUaEhYUh9ZNRCA0o/MVJxhwLIsZ9i4yMDISGqnMa0St73CtWrEDjhg2KHNoAEBwcjN7PPYvY3RsVqKx4cQsYFQd/f38sX7ESM2bMwM/nr6Pyws0Ysfkolscl4oIxG5lWO27kWLEtIRXTD8Wh9pLt6L3uEKo1b4evV2xB9ToNAQAWu4hdF9Jw/kaWe78gUhcP73G7glfOce/fvx+dOrRTrL2WzZpi7vwFMGdnwT/QM04fE0URp4/sxfFDuxB/7gQyUq9DkoCwEpGoWK0WajZojufbDXF3meQjNBoNRo0ahWeffRZz587FvDmzMW/dobueZzAY0LzDExjSaxDqNGl514JRSZJwPDETGTl21CsfCp2CJ7ORl/LQOW6NRvPABdGCIBR4c9iDeF1wS5KEc+fO4dURwxRrs3atmpAkCclJV1Cxao0Hv8CFJEnCns1rsXbx90i8chFly5ZFs8aNULV1IwiCgEuXr2Dfvo1Yt/wnrPphGsaPH49hw4Z51WEy5LnKli2L9957D++99x4SExMRGxuLjIwM6PV6xMTEIMO/DNLMjge2cyU9B0azHc0qhyPQj3PfdB+CJvch5/nFYMWKFff8s127duHrr7+GKIpOte2Vwe1wOBTdVmK42ZbDiXdGSjJlZmD+5+8ids9mdH+6K17/8Tu0aXV3rwXIPUzmq29nYcSIEViyZAkWLlyIcuXKuaFq8lVly5ZF2bK3X/t5+poJaWZToV5vNNuw9VwKGlcMQ1RI4ecwiTzBM888c9fHTp8+jbfffhurV69G3759MXnyZKfa9rpumEajQUhICG7cSFGszRspqQCAgOAQxdqUKzMjDZ+OG4z4s0ewcskvWPHrQrRt3eqeQzHNmjTGwh9m4981q3Dm9Gm0bdsWV66o/zAZUrcSgfdetFYQm0PEnotpOHu9cGFPPkgjyH8Us4SEBAwbNgz16tWD3W5HbGwsfvrpJ1SuXNmp9rwuuIHcc5QPHTmiWHsHYw8jODgYfZ5qg6YxpVGtXBhKhBiK7eQ8URQxa+pYWExp2L7+LzzTtfCnS3V8pD12bvwHosOBp556Clar715rSu4XEaiH4MQJGKeumbDvUjpsDueGFsmL5Q2Vy3kUk4yMDIwbNw7R0dE4fvw4NmzYgNWrV6Nu3bpFatfrhsqB3KPk5s2bC4vFAoOh6ENsf//7L1q2bImHyoTd9nFRlJCeZUFaphmpmebcf5osyMpR9mrCjX8swumj+7Hln7WoVVP+HHulihWxaskvaPrwI/jggw/wwQcfKFofUWHptBqE+OtgNMv/GUkymrE9zo6mlcIR4u+Vv7rIGR66OG3atGn45JNPUKZMGSxevLjAoXNneeU+7tOnT6NmzZr4ee736PdCryK1dfzESdRt1gqLFy9G7969C/Uaq82RG+QmM1Izc4M9LdMMq11+b8Gck423BnTEoL698e0Xn8p+fX4TP5yKjz/7EpcvX0ZUlPxTroiUcOSqEZdSs51+vU4joGGFMJQN81ewKlKbW/u4v35T/j7uV6e7fB+3RqNBQEAAOnXqdM/7MQBg+fLlstv2yuAGgKeeegrHjh7F0b07nP7LkSQJjz/dA6fPxeHcuXNFXvBmyrH+L8hNub30jCwL7rewcMtfv+OXbz/E+eOxqFypUpE+f2pqGspXr4UJEyZg/PjxRWqLyFlX0nNw6HJGkdupXioINUoH8555H3UruL95S35wvzLN5cE9aNCgQn1v/vjjj7Lb9trxphkzZqBevXoYPfZN/DRnllM/3F99+x3+3bQZf//9tyKr1IMD/BAc4IdKUf9b5Pag4fbYXRvxSPt2RQ5tAIiIKIFnunbBypUrGdzkNhEKXTF7NjkL6Tl2NK4YBj+dVy7XocLw0O1g8+fPd1nbXhvcVapUwffff49+/fohODgYX3/6CXS6wn25kiTh+3k/Yuzb/4fXX38dTzzxhMvq1GgERIT4IyLEH9XyfdxqcyDFmINxF0+j+4uDFPt8rZo3w8rVa2Gz2aDXy1vhS6SEQD8tDDotLPYH7+d+kGSTBdvOpaBp5XCEBfD7mXyDV79N7du3L+bMmYPv5/2I1o8+jmPHTzzwNUlJ1/B8v4EY+d+xGD1qFKZNm1YMld7NT69FiAFIuZGMmjHKnTdeq0YNWCwWJCSo89IU8g4RQcqFbLbNgR3nU3ElXb3X71IRePi1nq7g1cENAC+++CJ27NiBzKxs1GveGk8+0xM/L/oVp06fgd1uhyiKiL98GSv+WI3+Q19C5Vr1sGX7TixZsgRff/ONW08cs9lyh8uVPEzGz09/W9tE7hAhcz/3gzhECYcuZ+BYghGidy7boXvRaOQ/VM5rh8rza9myJQ4dOoQlS5Zg5syZGDBsRIHPq1atGqZMmYIhQ4YgIiKimKu8W3BwMHQ6HZJv3FCszeSbB9OEh4cr1iaRXErNc9/pQko2jGY7mlQKg0HHo1J9goduB3MlnwhuIPcGo4EDB2LgwIFITU3FwYMHcfnyZYiiiKioKDRu3BjlypXzqBWqer0ederUwcHYw4q1eeBQLCpUqIDIyEjF2iSSKzRAB61GgENUvneckmXFlrOpaFY5DCVc9AaBPIiHLk5zJZ8J7vwiIiLQqVMnd5dRKK1bt8aa1avhcDjuuxewMCRJwp//rEfr1q0Vqo7IORpBQHiAHilZrjnJz2J3YMf5NNQrF4LKEYEu+RzkIQSZx5h6UOfMWep/6+Hlhg4distXrmD1n38Vua0du3bj6PHjePHFFxWojKholJ7nvpMkSThy1YjDVzJc0rMnD+HBR566ivq/Ai/XpEkTtGvXDm+9OxE5Oc6vmrXZbHjtrfGoW7cuOnbsqGCFRM4prmHs+LQc7Dyfimxr0befkQeStaJc5ny4h2Jwq8Ds2bNx+cpVjBn3Dpw96G7SlI9x6PAR/PDDD7ybmzyC3JvCiiI9x4Zt51Jww8RLdkj9+BtcBWrUqIEZM2bg+3k/4vW3/w8OR+F7DpIk4YOPp2Hq9M/w0UcfoVmzZi6slKjw/HQahBiKb5mN1SFi94U0xCVnFdvnpGLgg0PlPrk4TY2GDh0Ks9mMV155Bbv27sO8md+gdq2a933N+QsX8dLo/2LD5i2YPHky3nzzzWKqlqhwSgTqkWmxF9vnkyDhRFIm0nNsaFAhDDo33M1MCpN7x7YX/J2r/62HDxk1ahS2b9+O1PQM1GnaEk8+0xPzf/4Fx0+cRHZ2NsxmM06fOYtffv0N3Xv1QfX6jXEm7jzWrVuH9957z6O2uhEBQESQe7ZrJWSYsT0uBVnF+KaBXMQH57jZ41aZ1q1b4/Dhw7cOkxk8YlSBz2vQoAFmzpyJfv36ISgoqJirJCqc4pznvlOm2Y6t51LRuGIYSocW/nYp8jDcx01qkP8wmYyMDBw6dAhXr16FJEkoU6YMGjdu7BEnvxE9SLBBBz+tBlaH/LvqlWAXRey9lIYapYNRvVQQR6XUyAeHyhncKhcWFoYOHTq4uwwip0UE+SHJaHZrDaevmZCebUOjimHQa9XfI/MpgiCzx63+4OZ3KBG5lTuHy/O7lmnBtnOpyDRz3ps8G4ObiNzKU4IbALKsdmyLS0FChntHAEgGH1ycxuAmIrcKD9B71NyyQ5RwID4dJxIzeUWoGvjgPm71fwVEpGpaTe6FI54m7kYW9lxMg8XunoVzVEh5i9PkPFSOwU1EbudJw+X53TBZse1cCtJzbO4uhe6FPW4iouLn6pvCiiLH5sCOuFRcTnP+kh9yIR+c4+Z2MCJyu4ggzw1uABAlCbFXMpCWbUPdciHQeMEvf6+h0eQ+5Dxf5dT/FRCR6hl0WgT6eX4/4lJqNnaeT4PZxitCyX0Y3ETkETx5uDy/tGwrtp5LRUoWrwj1DHKHydU/WsLgJiKP4OnD5flZ7A7supCGCynZ7i6FuDiNiMg9PHVl+b1IkoRjCUYcupwBu8j93m7DxWlERO4RYtBBp9HALqpr3/SV9BxkWuxoWikcgX5ad5fje7g4jYjIPQRBUM08950ycmzYdi4FySaLu0vxPT7Y42ZwE5HHKKGiee47WR0i9lxIx7nkLHeX4lvybgcr9IPBTUSkmIhAP3eXUCQSJJxMysT+S+mwu+mOcZ/DHjcRkfuEB+oheMF2nUSjGdvjUmGy8IpQUh6Dm4g8hk4jIDTAO9bMZlrs2HYuFUlGXhHqUtwORkTkXmpdoFYQuyhi36V0nLpmgsQrQl2Dt4MREblXCZXPcxfk7HUT9l5Mh5VXhCqPPW4iIvdS0wlqclw3WbAtLhVGM68IVRQXpxERuVeAXosAvXceZJJttWN7XCqupPOKUMWwx01E5H5qO/5UDoco4dDlDBxPyITIee8iEwRB9kPtGNxE5HEigrxvnvtO51OysPtCGix2XhFK8jC4icjjeHOPO7+UrNwrQtOyeUWo0zhUTkTkfqH+Omi9YNtOYZhtDuw4n4ZLqbwi1CkMbiIi99MIgs/0uoHcK0KPXDXiyFUjHLwiVB5B5h5uL5jj9o4jiojI65QI9MMNk28NIV9KzUZGjg1NK4fLWllvt9tx+fJlWK1WhISEoGzZsl6xCKtQ5Pai2eMmInINbzpBTY70m1eEpmTd/01LWloavvjiC7Rp0wahoaGoWrUqatasifLlyyMqKgpdu3bF0qVLYbN5+b5xH9zHzR43EXkkXxoqv5PFLmLX+TTULhuMqpFBt/2Zw+HAl19+iQkTJsBms+HpLk/iwwn/h7q1a8Pf34C09HTEHjmK9Rs34/nnn0elSpUwe/ZsPPHEE276alws71pPOc9XOUHiAbpE5KE2n72BTLNv37BVPjwA9cuHQqcRkJKSgu7du2PHjh3478sj8PbrY1C6dNQ9X3vk6DG88c57WL9xE/776qv4/IsvoNF4x0Cr0WhEWFgY0rYsR2hw0INfkPc6UxZKtH8WGRkZCA0NdWGFrsMeNxF5rIhAP58P7qvpOcg02xEdKqHrk4/hypXL2LruT7Rt3eqBr61fry7++WM5vv1+Dl59Yxyys7Px/ezZvjP/7aUY3ETksSIC9biU6u4q3M9otqHfay/j4sUL2LbuL9StU7vQrxUEAaNHvITgoCAMHjEKrVq3xuDBg11YbTHj4jQiIs/hy/Pc+e3Z9A82/7kCMz6bLiu08xvUvy8G9n0Br732GhITExWu0I14rScRkecIMuhg0PHX1NJ5X+OR9u3Qp9fzRWrni08+giRJmDlzpkKVeQAewEJE5FkivPB+bjnOnzqG00cO4rVRI4o8N12iRDgG9OmNOXPmwG73krUDPrgdjMFNRB7N14fLj+zdjoCAAHR54nFF2nuuezdcu3YNJ0+eVKQ9t2OPm4jIs0QE+XZwx508ivp160KnU2YtceOGDSAIAg4ePKhIe27HHjcRkWcJC9BD4wW/bJ2VfiMZlStVUKy90NBQlCgRjqSkJMXapOLF4CYij6YRBIQH+G6vWxAEKH1OlihK3rOXm0PlRESex5eHy0uWLovzFy4p1l5aWjrS09NRvnx5xdp0K41G/kPl1P8VEJHX8+UFatVq1cPR48dhsVgUaW//wUMAgCZNmijSnrsJgiD7oXYMbiLyeCV8eEtYw1btYLVasXzVakXaW/z7UlSqVAkxMTGKtOd2eZeMFPrB4CYicjmDToNgg2+e0FyhSnXUb94GX8z4DqIoFqmtxMQkLP59GUaMGOE1l41wVTkRkYfy5eHyXsPHYt+BA5g5e67TbUiShBH/HYPQ0FAMHz5cwercTe7CNPXHnvq/AiLyCb4c3PWatUaXXoPw1rsTsX3nLqfamP7F1/hj7V+YNWsWIiIiFK7QjdjjJiLyTL5+9Ong1ycgum4jPNH9OSxf9UehX2e1WvHOxMkY995EvPvuu+jRo4cLq6TiwOAmIlUINmih1/ruryyDfwAmzPgZDVq2R88+A9BrwGAcP3HvY0tFUcQ/6zegebuOmPbFV/j4448xefLkYqy4mPjgdjDfXO1BRKojCAJKBOpxPVOZbVFqZAgIxNufz8WWP5fjx8/ex2/LVqBVi+Zo3aI56tauhcDAQKSmpeHQ4SPYsHkL4s5fQJMmTbB37140btzY3eW7htzhby8YKhckpY/kISJykbPXs3DqWqa7y/AIZYO0iNu3Eb///jv279+PS5dyD2nRarWoXbs2WrRogcGDB6NVq1ZesXf5TkajEWFhYUg/uhOhIcGFf12mCeH1WiMjIwOhoaEurNB12OMmItXw5RPU7lSjXAk07dULvXr1AgCYzWZYrVYEBARAr/eh/04+2ONmcBORaoQF6F1ydrfaRIUYEOJ/+69vf39/+Pv7u6kidxJuPuQ8X93UP0tPRD5DpxEQ5s/+RrXIIHeX4Dm4HYyIyLP5+rawsAA9IoN9+7+Br2NwE5Gq+Po8d9XIQHeX4Fl8sMfNMSciUhVfPkHNX69FuTBfnMe+H9+b42ZwE5Gq+Ou1CNRrkW1zuLuUYle1ZCA0XtBjVJQPrirnUDkRqU6JIN+b49VpBFSKCHB3GZ5HcOKhcgxuIlKdCB8cLq8UEejTR77em+8lN4fKiUh1fG2BmgABVUpyUVqBfHConMFNRKoTYtBBp9HALoruLqVYlAv3R6Cf1t1leCYBMoPbZZUUG467EJHq5F044iu4BYzyY3ATkSr5ynB5ySA/hAf4xtfqHM5xExGpgq/0uHm86QNwjpuISB1KBOghQIAE771wJNigQ1SI7219k8f3DmDhUDkRqZJOq7nrhixvUzUy0Cvv0laUDx55yuAmItXy5nlug06DCuE8cOWBGNxEROrhzfPcD5UMhFaj/pBxPd9bnMbgJiLV8tYrPrUaAZUjuAWMCubdE0RE5NUC/bTw12th9rILRyqEB8CgY7+qMARBkLUOwBvWDPA7g4hUzRuHy3ngigyc4yYiUhdvu3CkTKg/gg0cDC0835vj5ncHEamat81zs7ctl9xeNIObiMitQgN00GoEOET1H8QSHqBHSR+8a7xIfPDkNA6VE5GqaQTBa87yrlaKx5vKx6FyIiLViQjUIyXL6u4y7slqMWPHutU4uHMzzp84ghvXEiBJEsIjIlGlZj3Ua94GXbr/B2VCS7u7VPXxwR63IEmS+seXiMinXTNasPdSmrvLuIvD4cAfC+dg+bxvkJGeimZNmqB508aoVuUhCIKAK1cTsP9QLHbs2g2dXo9RL7+MyZMnIzCQ89wPYjQaERYWhoxLZxEaGiLjdZkIq1wdGRkZCA0NdWGFrsMeNxGpniduCUu5lohpb7yEU0cOYMSLQzBm9MuoHl2twOcmJV3DrHk/4JPPv8LKlSuxdOlSNGzYsHgLVivfu2OEc9xEpH5+Og1CPGgL1Y2kBIwf3B2ZKYnYtv4vzPzys3uGNgCUKVMak/5vPA7v3o6wkGB06NABBw4cKMaK1cz35rgZ3ETkFTyl1+2w2/Hx2KHQQ8SOf/9Gm1YtC/3amOrR2Pz3GtSMqY6nn34aqampLqzUS/AAFiIidYoI8oMlJxuXz5/BxTMncSMpdwFYcVvx03c4d+IIlv7yEypVrCj79SEhIVi2aAGys7Px2muvKV+gt/HB4PacsSUiIidcvnwZs2fPxoqVK3HyxAmIonjrz8LCI1CzYTN06vECmrbrBK1W69JacrKzsHTu13h15HA0b9rE6XbKlyuH6VMm46XR/8U777yDmjVrKlilt/G9SW72uIlIlbKzszFmzBg89NBD+Oqrr9C8UQN899Xn2PLPWuzatB5//L4YY0a9BHvGdUz57yC80qM9Thza69KatqxdBnNONsa88nKR2xrQpzciI0viu+++U6AyLyZAZo/b3QUXHbeDEZHqxMXFoUuXLoiPj8ekd97Gyy8NRUjIvbcE7TtwEK+8Pg579+9Hn1Fv4j/DXnPJLVEfvjoIQVIONv75hyLtjR77JtZt3IwzZ84o0p43ubUd7OoFWdu6jEYjwspXkbUdbOvWrZg+fToOHDiAxMRErFixAt27d3ey8qJjj5uIVOXixYto3749IImI3bUN415/7b6hDQDNmjTGjg1/Y+I74/DLjGlYNHO6S2o7f/IIWhRhiPxOzZs0xtmzZ5GRkaFYm16nGOa4s7Ky0KBBA3z77bcu+ALk4xw3EamGw+FAnz59oNdpsfmvNShbtkyhX6vVajHxnbfhp/fDO5Mmo2aDpmjS9lFFa7txLRHR1aoo1mbeFrL4+HjUq1dPsXa9i+vnuDt37ozOnTvLfp2rMLiJSDW++eYb7N69G9vW/yUrtPN7+40x2Lh1G2ZOfhMzVm5FQKAy54NLNxfFaTXKLYDLW0yXf8Ed3c5oMsnqRRtNptx/Go23fdxgMMBgMCham6swuIlIFWw2G6ZPn44hA/rJ2ht9J0EQMPubLxBdrzG2rF2GJ58fUOTa/LQahPkHIDgkFIlJ14rcXp6ExEQAQKlSpRRr01v4+fmhTJkyqBhTR/Zrg4ODUfGOrXoTJ07EpEmTFKrOtRjcRKQKa9asQUJCAl4dObzIbVV56CF07fIk/vn950IHt59WgyCDDkF+WgQZtAj00yLYT4dAPy38dLnLhZo2aYwDsbFFri/PgUOxKF26NMqWLatYm97C398fFy5cgNUq/3IZSZLuWpyolt42wOAmIpXYvHkzoqtVRf16dRVp7/nuz+CPF4fDZMxAcGgYAMCg0yDoZhgHG7QIMuT+e5CfFnrtg9fytmvXDl9++SWysrIQFFS0IXhJkrBy9Z94+OGHXbIC3hv4+/vD39/f3WUUO64qJyJVOHjwIJo2aqRYe00aNQQAaFMuoF10SXSuHYXHa0WhTbUINKoYhupRwSgX5o/wAH2hQhsAhgwZApPJhJ8XLylyfVu378CxEycwfHjRRxjIuzC4iUgVrl27hgrlyynWXsUK5QEAjqw0hAXooStkON9P5cqV0bt3b7w7+UNcu3bd6XYsFgtGj30LjRs3xqOPKrfynZxjMpkQGxuL2JvTIBcuXEBsbCzi4+PdUg+Dm4hUQRAERc8ez1uprdEo+2vwyy+/hEajxcCXRjo9//r6+Hdx+uxZ/Pjjj4rXR/Lt378fjRo1QqObIz5jx45Fo0aNMGHCBLfUw+8IIlKFChUqIO7CBcXaizt/4Va7SipVqhQWLVqETVu34bm+A+7adnQ/NpsNr735Nr79fg6++eYb1K9fX9HayDkdOnSAJEl3PebPn++WehjcRKQKTZo0wf6DsYr1uvcfioVGo0HDhg0VaS+/Tp06YdWqVdi0dTvqNmuN1X/+9cC92Lv37kPzdo/i29lzMXPmTM5t0z3xrHIiUoUNGzagU6dO2LruTzzcpnWR23ukc1c4JAFbt25VoLqCXbx4ES+++CI2bNiA6tHV8MLzPdGsSWNUq1IFGo0Gl69cxYFDsVi26g/sO3AQ9erVw/z589G4cWOX1UTqx+AmIlUQRRG1atVCrZhorFyyqEhtHTwUiyZtO2Dx4sXo3bu3QhUWTJIk7NixAzNnzsS6deuQkpJy258HBwejXbt2GDFiBLp06eLyq0dJ/RjcRKQaixYtQt++fbFs0QI8+0w3p9qw2Wxo3u5R2EUJBw4cgJ+fn8JV3pskSbh06RKuXLkCURQRFRWFmJgYLkAjWRjcRKQakiShR48e2Lp1K7b+sxZ169SW9XpRFDHyv2Mx76efsXv3bjRt2tRFlRK5Dt/mEZFqCIKA+fPno1KlSujQuSv+3bi50K81Go0Y8OIIzP5hPubMmcPQJtVicBORqoSHh2Pjxo1o2LARHnu6O158+RWcOXvuns+3WCxYtOR31GveBivXrMWiRYswePDgYqyYSFkcKiciVRJFEbNmzcKECROQkpKCtq1boUXTJqhVMwZ6nR7JN27gYOwR/Lt5M65fT0bnzp0xc+ZMPPTQQ+4unahIGNxEpGpmsxm//fYbVq1ahQMHDuDSpUsAci+gaNSoEVq3bo2hQ4eiVq1abq6USBkMbiLyKna7HQ6HA35+frxVi7wSg5uIiEhFuDiNiIhIRRjcREREKsLgJiIiUhEGNxERkYowuImIiFSEwU1ERKQiDG4iIiIVYXATERGpCIObiIhIRRjcREREKsLgJiIiUhEGNxERkYowuImIiFSEwU1ERKQiDG4iIiIVYXATERGpCIObiIhIRRjcREREKsLgJiIiUhEGNxERkYowuImIiFSEwU1ERKQiDG4iIiIVYXATERGpCIObiIhIRRjcREREKsLgJiIiUhEGNxERkYowuImIiFTk/wH9KUkRIr5vLAAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -465,7 +470,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "id": "389fd7d7", "metadata": {}, "outputs": [ @@ -501,7 +506,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "id": "ad1e2012", "metadata": {}, "outputs": [ @@ -530,14 +535,6 @@ "plt.show()" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "8cee5ca9", - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "code", "execution_count": null, diff --git a/tutorials/Tutorial 5 - Plotting.ipynb b/tutorials/Tutorial 5 - Plotting.ipynb index cd2c9c3a0..336eb1b2b 100644 --- a/tutorials/Tutorial 5 - Plotting.ipynb +++ b/tutorials/Tutorial 5 - Plotting.ipynb @@ -89,7 +89,10 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 4, @@ -98,7 +101,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAyaUlEQVR4nO3de3Cb933n+w8IUhZ4kXOpc7FrybIl6PLQjpgIDGgmpbMrOztHccVUPDPt2d1YexotFYtsffaPJm3OzG5np61n9+xsGjFyNHQS0j2z6ZQ+ktxwziSBsi2b0gD5KCLj4CKDsi6U5Vh2JFsCAZACwWf/UKjIlsQbHuJ5QLxfM/zHEn78QQn5fPD9/X7fn8eyLEsAAKBsVTg9AQAA4CzCAAAAZY4wAABAmSMMAABQ5ggDAACUOcIAAABljjAAAECZIwwAAFDmCAMAAJQ5wgAAAGWOMAAAQJkjDAAAUOYIAwAAlDnCAAAAZY4wAABAmSMMAABQ5ggDAACUOcIAAABljjAAAECZIwwAAFDmCAMAAJQ5wgAAAGWOMAAAQJkjDAAAUOYIAwAAlDnCAAAAZY4wAABAmSMMAABQ5ggDAACUuUqnJwCUKsuyNDIyItM0FYvFlM1m5fP5ZBiGAoGAGhoa5PF4nJ4mAMzLY1mW5fQkgFKSy+XU3d2trq4uJRIJeb1e+f1+1dXVKZVKKZlMKp/Pa8uWLero6NDevXtVVVXl9LQB4I5YJgAWIRqNKhgMqrOzU4ZhKBQKKZVKKR6Pa2hoSPF4XKlUSqFQSIZhqLOzU8FgUNFo1OmpA8AdURkAFmhgYEA7d+7UunXr1Nvbq+3bt8/7GtM0tWfPHo2Pj6u/v18tLS1FmCkALA5hAFiA2YpAU1OTjh49qpqamgW/Np1Oq7W1VZFIROFwWPX19cs4UwBYPMIAMI9cLqdgMKjJyUkNDw8vKgjMSqfTamxslM/nUzgcZg8BAFdhzwAwj+7ubo2Ojqq3t3dJQUCSampq1NPTo5GREXV3d9s8QwAoDJUBYA6WZckwDBmGob6+voLHa2trUyKRUDQa5dghANegMgDMYWRkRIlEQu3t7baM197erng8rtHRUVvGAwA7EAaAOZimKa/Xq+bmZlvGa25ultfrlWmatowHAHYgDABziMVi8vv98vl8toxXXV0tv9+vWCxmy3gAYAfCADCHbDaruro6W8esra1VJpOxdUwAKARhAJiDz+dTKpWydcyJiQlVV1fbOiYAFIIwAMzBMAwlk0lls1lbxstkMkomkzIMw5bxAMAOhAFgDoFAQPl8XoODg7aMNzg4qHw+r0AgYMt4AGAH+gwAc6DPAIByQGUAmINlWfrff/9LOnz4cMHHAU3T1JEjR7R//36CAABXoTIA3IZlWTp74ZKOx87p8rspPfv1ffKtqpBpmgXfTRCJRFRZWbkMswaApSEMoGRZlqWRkRGZpqlYLKZsNiufzyfDMBQIBNTQ0LCkT+Dn33xHP4ud06V3J278twvjp/Xs17+iRx9t0ksvvcSthQBWFMIASk4ul1N3d7e6urqUSCTk9Xrl9/tVV1enVCqlZDKpfD6vLVu2qKOjQ3v37l3QLYEXL13V8eg5vfmrK7f981djI+p69mt64IF16u3tXdAmQNM09dRTT+n8+fPq7+9XS0vLot8vACw39gygpESjUQWDQXV2dsowDIVCIaVSKcXjcQ0NDSkejyuVSikUCskwDHV2dioYDCoajd5xzMtX0vrxYFz9//jKHYOAJG0yGvS1v3hO2WuWgsGgdu/erWPHjt1y7DCTySgUCmn37t0KBoPKXrP09b86pE9u/7Rt/w4AYCcqAygZAwMD2rlzp9atu/7JfPv27fO+xjRN7dmzR+Pj47d8Mr86kdWJ+LheO//2ouYxPT2tnx77gf7hR4f1xvmz8nq92rBho2prazUxMaFTp8aUz+d139r1euyJL+qzO55UZWWl7q6r1pOPPay7Vs1fpQCAYiIMoCTMVgSampp09OjRgtbsH3zIrxOJcY2dfUsz1syS52RZls6fGdOZ107qjfNndG1qUqvuWq1771+v9Q9t1v3rN96yZ+Hj99ytf/UZQxUVFOUAuAdhAK6Xy+UUDAY1OTmp4eHhgnbzWx6v/sN/7JLHwYfxxnUf0e9s9zv2/QHg/fh4Atfr7u7W6Oioent7lxQEJKmmpkY9PT16NRHTP/74JZtnuDhj597SSOK8o3MAgJtRGYCr2d0BcPfu3Ro6PqL/9N96HW/881hgkx5ae4+jcwAAicoAXG5kZESJRELt7e22jLdv3z5dGD+j82fGbBmvEP90fExv/uqq09MAAMIA3M00TXm9XjU3N9syXnNzs7xer868dtKW8QoxY83o2MtxXUnZcyMiACwVYQCuFovF5Pf75fP5bBmvurpaGzZs1Bvnz9gyXqGmctP60WBMk1M5p6cCoIwRBuBq2WxWdXV1to5ZW1ura1OTto5ZiFR6UsfCCeXzSz/mCACFIAzA1Xw+n1KplK1jTkxMaNVdq20ds1AXL13VPx0fE/t5ATiBMABXMwxDyWTylpa/S5XJZHTq1JjuvX+9LePZ6fTrb+tn8XGnpwGgDBEG4GqBQED5fF6Dg4O2jDc4OKh8Pq/1D222ZTy7/fzkeSXPXnR6GgDKDGEArtbQ0KAtW7bo0KFDtoz37W9/W/etXa/712+0ZbzlMHjiNV14612npwGgjBAG4Goej0cdHR06fPiwTNMsaCzTNHX06FE99sQXHW84NJcZa0b/M3JS71zNOD0VAGWCDoRwPbvuJggEAspes/Snf/mcvN7KZZipvWqq79LvPvYJVftWOT0VACsclQG4XlVVlXp7ezU+Pq7W1lal0+lFvT6dTmvXrl06e/ac/t3+Py2JICBJ6cyUQuGEpqfzTk8FwApHGEBJqK+vV39/vyKRiBobGxe8ZGCapgKBgF5+OayOrz2r+9Y+uMwztdev3knpH80kRw4BLCvCAEpGS0uLwuGwfD6fgsGg2tradOzYsVuOHWYyGYVCIe3evVvBYFDZa5a+9hfPaZPR4NDMC3PujUsa/sVZp6cBYAVjzwBKTi6XU3d3t7q6upRIJOT1erVhw0bV1tZqYmJCp06NKZ/P67616/XYE1/UZ3c8qcrK0lgamMuj2x7Sloc+7vQ0AKxAhAGULMuy9K3vvqhh09Qb58/o2tSkVt21Wvfev17rH9qs+9dvdPWpgcXyeDza0bRFaz/+IaenAmCFIQygpP2/fx/RVG7a6WkUTVWlVztbHtaHP1Dr9FQArCDsGUDJmshMlVUQkKTcdF4/fjmhdHbK6akAWEEIAyhZl96dcHoKjshkp/TjwbhyOY4cArAHYQAl6+13yjMMSNLlK2n9w/Crmpnh2mMAhSMMoGRdKuMwIEnn37ys8M/POD0NACsAYQAl69K7i+tEuBKdPP1LRccuOD0NACWOMICSlMleU3bqmtPTcIWhV87o3BuXnJ4GgBJGGEBJ+lWZbh68k38cTurtyymnpwGgRBEGUJJYIniv6XxeoZcTSqUnnZ4KgBJEGEBJKtdjhXPJTl3Tj1+O61qZ9V4AUDjCAEpSOR8rnMu7VzP6SeQkRw4BLArtiOFqlmVpZGREpmkqFospm82qqmqVJvLVemDDZq1d719R9w/Yxb/uo/rs9o1OTwNAiSj9q9ywIt3uZkK/36+6ujqlUiklk0nl83nde/8D+tznf2/F3Exol+S5i1pT59MnNv2201MBUAJYJoDrRKNRBYNBdXZ2yjAMhUIhpVIpxeNxDQ0NKR6PK5VKKRQKqanxU/r+d7+hZ7++TxfGTzs9dVc5Hj2r0+ffdnoaAEoAywRwlYGBAe3cuVPr1q1Tb2+vtm/fPu9rTNPUU089pbNnz6nja89qk9FQhJmWBm9Fhf7VZ+v1sd9a4/RUALgYYQCuMVsRaGpq0tGjR1VTU7Pg16bTae3atUsvvxzW1/7iOd239sFlnGlpWb2qSk9+7hGtqfU5PRUALkUYgCvkcjkFg0FNTk5qeHh4UUFgVjqdViAQUPaapa/9xXPsIbjJmlqfnnzsEa2+q8rpqQBwIfYMwBW6u7s1Ojqq3t7eJQUBSaqpqVFvb6/GzyT102M/sHmGpe3qRFbHwgnl8xw5BHArKgNwnGVZMgxDhmGor6+v4PF2796toeMj+k//rZdjh+/z0P336LHGTU5PA4DLUBmA40ZGRpRIJNTe3m7LePv27dOF8TM6f2bMlvFWktfOv62fxc45PQ0ALsOiKhxnmqa8Xq+am5ttGa+5uVler1dnXjuptQ/6bRlzJRk9eV5raldr47qPvue/367Bk8/nk2EYCgQCamhooNICrFCEATguFovJ7/fL57Nnt3t1dbU2bNioN86fsWW8leiff/aaanx36d6PfGDeBk8HDx5UPp/Xli1b1NHRob1796qqio2IwErCMgEcl81mVVdXZ+uYtbW1ujbFDX53MmPN6CeRk3p5yFxwgyfDMNTZ2algMKhoNOr0WwBgI8IAHOfz+ZRKpWwdc2JiQqvuWm3rmCvNL0ZN/cvPPabJyUkNDQ2pr69PO3bsuKVC4/P5tGPHDvX19SkSiWhyclJNTU0aGBhwZuIAbEcYgOMMw1AymVQ2m7VlvEwmo1OnxnTv/ettGW8lujB+Wgf+6qtqfrRJw8PDC+r0KEmBQEDDw8MKBoP6whe+QIUAWCEIA3BcIBBQPp/X4OCgLeMNDg4qn89r/UObbRlvpZmentb3vvWXWr/+Ab300kuL7utQU1Ojo0ePau3atdqzZ49yudwyzRRAsRAG4LiGhgZt2bJFhw4dsmW8Q4cOaevWrfryv23VA/d9WBUe/m9+s58e+4HGz4zphRdeKKjBU09Pj0ZGRtTd3W3zDAEUG02H4AoHDx5UZ2enIpGIAoHAkscxzesb4g4cOKCnn35akpSdvKbkubf06pk3lUqX96ZCy7L0H//Dl9TU+Cm9+OKLBY/X1tamRCKhaDTKsUNxPBOlizAAV7DrboLGxkb5fD5FIpFb7iawLEu/fPuKXj1zUWcvXNKMVX6tec+dflX/+U++rFAopB07dhQ8XigU0hNPPKETJ06ooaF8b4uc73hmMpnkeCZcjfopXKGqqur6vQLj42ptbVU6nV7U69PptFpbWzU+Pq6enp7bXlLk8Xh070c+oM99epP+YGdAjQ+v19111Xa9hZJw9tTJZWnwZJqmLeOVotnbNjmeiVJGGIBr1NfXq7+/X5FIRI2NjQt+wJimqcbGRkUiEfX396u+vn7e16y+q0oP++9T2xOf1M6WR7Rh7UfkrVj5Pw4Xzp/Rhg0bbW3w5Pf7FYvFbBmv1AwMDNyoaHE8E6Vs5f/2Q0lpaWlROByWz+dTMBhUW1ubjh07dsuxw0wmo1AopLa2NgWDQfl8PoXDYbW0tCz6e37st9aoJeDXH+wMKPiJB/XBNUvbVFcKctemlqXBUzqdkWVJ5bToGI1GtXPnTjU1cTwTpY89A3ClO63B1tbWamJi4sYa7NatW7V//37b12AvXrqq5JmLOv36rzSdz9s2rtP+x3e+oQunYzp5MmHbmFu3btW/3PG4/vs3/lqSdPP2uPfvlZvrz0qJ3XtcwuEwewjgKMIAXM2yLI2Ojt7YnZ3JZFRdXX1jd/a2bduWdXf2tdy0Xht/WyfPvKnLVxa3j8GNBn78kv7Hd/67UqmULUsFmUxGa9as0YGug9r77//9ol9/p3Dw/v9F3RYcZk+/DA0NLbgicDu3O/0COIEwACzQ25dTevXMRb12/u2SrRYs12mC4ePLe5rATdUGy7JkGIYMw1BfX1/B43E8E27AngFgge75UJ0+86kN+j92Nuozn9yg3/qgvWvvxbB2vV/33v+Avv3tb9sy3myDp23bttky3p1YN33NWO/9yt/8NfPer5v/nnXTVyFGRkaUSCTU3t5uwzuT2tvbFY/HNTo6ast4wFIQBoBFqqryatP6j2nXv/iEdv2Lbdr84Me1qqo0bgP3eDz63Od/T0eOHCn4OKBpmjpy5Ij2Pb3fNZ9oLd05ONwcGqYXGBpuFxxM0+R4JlYclgkAG0xP53X69V/p1TMX9dblq05PZ07T09N69uv75FtVIdM0C9r8ttrn0+DLtzZ4WkneH3Oe+eM/0k9+ckzxeNy277F161Y9/vjj+uu//mvbxgQWg8oAYIPKSq/8D3xUT37uEX1xR4O2PnSva6sFlZWV+nf7/0xnz57Trl27Cmrw9J3v3r7B00ry/mpDJptdluOZmUzG1jGBxSAMADb70N01atr2oP7gfwuoZbtfH/3wGqendIv71j6ojq89q3/+50F98pOfXFKDp5f+fmENnlYan8+nVCpl65gTExOqri6vbphwF8IAsEwqK73asO4j+sJjj2j3E59U/cb7tHqVe86SP+SvV+3dH9Rrr722qAZPq30+/XQwrN9ZQoOnlWDrVkPJZPKWf6elymQySiaTMgzDlvGApVjZ9T3AJT5QV61PP7Je2411OvfGJZ0886Z++fYVR+f0k///RV1665e655579Cd/8if67ne/q8cff3zOBk/f+OYBffnL5X3JzvZAQPl8XoODg7YczxwcHFQ+ny/otk6gUGwgBBxyJZVV8txFjZ19S9mpa7aObVmWxs8kdfbUSV04f0a5a1OqWnWX7rt/vR7YsFlr7v6Q/u8//teamszqe9/7nvbs2TNvg6eHH9nmvu4/DrAsS594mD4DWFkIA4DDZmZmNP7Lyzp5+qIuvPVOQWNNT0/rp8d+oH/40WG9cf6svF6vNmzYeOMq3VOnxpTP51VTu0bpiatqbGxUOBxWxQIuabJ+fSwP0nPPHdQzf9SpSCRS0Cd6OhDCLQgDgIuk0pN69exFjZ29qMzk4qoFF8ZP63vf+kuNnxnTF7/4Re3bt0/Nzc3vaTuczWY1ODio5557TkeOHNHmzZv1d3/3dwvaCGjNnsNf9LtaeXK5nJofDWrKprsJIpGVfTwT7kcYAFxoZmZG5998R6+euajzb16e9++/GhvRgb/6qtavf0AvvPDCgvrlm6apPXv2aHx8XP39/Qu68XG2MQ+u31r42eYmBYNBHT16dFGBYPZ4ZiQSUTgcLstTGXAXwgDgchOZKSXPXtSrZy8qk5265c8vjJ/WX/3ZPjU3P6qXXnppWR9KLBW81z8NDGjX735Ba9euVU9Pz4KWDJYSwoDlRhgASoRlWTr/5jtKnr2o8V9elmVZtnYTXOhVuvkZlgpuFo1G9eX/c49GRkbuuDyTyWQ0ODioQ4cO6ciRI2poaFBPTw8VAbgGYQAoQZnsNSXPXdQ3D3Sp99v/T1Gv0mWp4Fb56Zy+83y3urq6lEgk5jyeuX//fu3dW97HM+E+hAGgRDl1lS5LBe/lkVThuX7qcr7jmdu2beP4IFyJMACUqBMnTuhTn/qUQqGQLc1vQqGQnnjiCZ04cUINDQ1z/l2WCn7D66H9Akof7YiBEuXkVbo8/K7ziH8LrAyEAaBExWIx+f3+92xUK0R1dbX8fr9isdi8f5fn33UV/ENghSAMACUq6+BVuh4PgaCC5QGsIIQBoEQ5fZVuuT8Iy/ztY4UhDAAlyjCcvUq3nB+GVAWw0hAGgBIVuOkqXTss9irdcl0q8Kg83zdWNo4WAiXKqT4D751D+fUcqPCwcRArD5UBoER5PB51dHTo8OHDCzoOOBfTNHXkyBHt379/0U1xyum5ONtgCFhpqAwAJSyXyykYDGrSwat0y6k9MQ2GsFJRGQBKWFVVlXp7ezU+Pq7W1lal0+lFvX721sLx8XE9/90eeSoqtdiPB+XybKTBEFYywgBQ4urr69Xf369IJKLGxsYFLxmYpqnGxkZFIhG99Pf9qq+vl6Xrn/IXEwjKZSMhywNYyQgDwArQ0tKicDgsn8+nYDCotrY2HTt27JZjh5lMRqFQSG1tbQoGg/L5fPrpYFi/09Jy4+9Yur4pcDGl/5X+iZmjhFjp2DMArCC5XE7d3Qu/SvfLX94rb2XVHS8duvlGvrms5FMFC/03AEoZYQBYgRZzle58D/KFPgxX6k2GHCVEOSAMAFjQiYAKz9yb6FbiqQKqAigX7BkAsKCuerMP+zt9fFiJz0uCAMoFYQCAPAsshc912mClnSrgKCHKCWEAgKTFBYL8HaoEK+nhyT4BlBPCAIAbFnMJz+2WDVbK85PlAZQbwgCAGxZaHZj1/p4EK2GpgFsJUY4IAwDeYykP9JurBKVeXvdQFUAZIgwAuEVFgYGgVJ+lVAVQrhZ3PRmAsjBbHVhsFxJLpd14iL0CKFdUBgDc1lKqA7Os2Y2FJZQMOEqIckYYAHBHS13/93huqhKUSCAo9b0OQCEIAwDuaLGnC97zWv26SZEWv9xQbCwPoNwRBgDMqZDlglmW3L1sQA5AuSMMAJjXUqoD7/+k7dZlA6oCAGEAwAIsdbng/S95z7KBC0IBRwmB6wgDABbEzgenW6oENBgCriMMAFiQpVQH5nrQOh0IqAoAv0EYALBgSwoEc/yZk8sG7BUAfoMwAGBRluMTdbGrBDQYAt6LMABgURZbHVjoQ7eYPQloMAS8F2EAwKItOhAsYuzl7knA8gBwK8IAgCVZzg14y7VswKZB4PYIAwCWZDHVgdlbEBdjOZYNOEoI3B5hAMCSFXJ3wULZtWxAVQC4M8IAgIIU4yFrx7IBewWAOyMMACjIQqsDS1kquFkhywYcJQTmRhgAULBiLBfMWsqyAUcJgbkRBgDYYiHLBXZ9Ol/MsgHLA8D8CAMAbLHg5QKbvt9CWxmTA4D5EQYA2KbQfQFLMVeVgKoAsDCEAQC2qpgnECzHw/l2gYCjhMDCEQYA2GohjX2W4yH9/mUDGgwBC0cYAGC7+aoDy2m2SkAOABaOMABgWcy1mbAYn9jzljRTpCuRgVJHGACwLOY7XbCceWA2bMz8OhAU41pkoJQRBgAsGyeWC97//QgEwPwIAwCW1Z2qA8txDPFObYctsWwAzKXS6QkAWNk8nuufOtzwIJ6tECy0/4BlWRoZGZFpmorFYspms/L5fDIMQ4FAQA0NDfJwZAErgMeyKJ4BWF7WbKn+Nv/drl9Ai7mMyKO5A0Eul1N3d7e6urqUSCTk9Xrl9/tVV1enVCqlZDKpfD6vLVu2qKOjQ3v37lVVVZVN7wQoPpYJACy7O20mdKJjoTT3skE0GlUwGFRnZ6cMw1AoFFIqlVI8HtfQ0JDi8bhSqZRCoZAMw1BnZ6eCwaCi0WjR3wdgFyoDAIpm5jYPYDuqA4VcUXxzlWBgYEA7d+7UunXr1Nvbq+3bt8/7etM0tWfPHo2Pj6u/v18tLS1LmwjgIMIAgKK503JBofsJCr2i2CMpHouqqSmopqYmHT16VDU1NQt+fTqdVmtrqyKRiMLhsOrr6wubEFBkhAEARWVZ10v07/9vS/1FVEhVYFYul1Pzo0FNTU5qeHh4UUFgVjqdVmNjo3w+n8LhMHsIUFLYMwCgqBZ61fGCxpI93Qyff75bPx8dVW9v75KCgCTV1NSop6dHIyMj6u7uLnxSQBFRGQBQdLdbLljKUoEdYcCyLH3iYUOGYaivr6+wwSS1tbUpkUgoGo1y7BAlg8oAgKK7XXVgsY9Nu6oCIyMjSiQSam9vL3wwSe3t7YrH4xodHbVlPKAYCAMAHGHnckEhjpumvF6vmpubbRmvublZXq9XpmnaMh5QDHQgBOAYz6+/LF0PBzMzlkZHRnT8uKl4PKbJbFarfT5t3Wpo+/aAtv26459dVQFJisdj8vv98vl8toxXXV0tv9+vWCxmy3hAMRAGADhmtlXx5LWcnn++Wwe/1aWTt+n4d+i5g8rn89q8ZYu+8rS9Hf+y2azq6upsGWtWbW2tMpmMrWMCy4llAgCOisWi+syjQT3zR52qn6fjX71h6P/64041P2pfxz+fz6dUKmXLWLMmJiZUXV1t65jAciIMAHDMwMCAgsGgJicnNTQ0pL6+Pu3YseOWkr3P59OOHTvU19enSCSiqclJfba5Sf80MFDwHLZuNZRMJpXNZgseS5IymYySyaQMw7BlPKAYCAMAHBGNRrVz5041NTVpeHh4Qa1/JSkQCGh4eFjBYFC7fvcLBVUIPJIaGwPK5/MaHBxc8jg3GxwcVD6fVyAQsGU8oBjoMwCg6HK53I2KQKEd/1b7fPrnwYV1/JvdeDi799Djud5nwDDoM4DyRmUAQNF1d3dr1KaOf6MjI3r++dt3/Ju9hKjCI3k9krfiN5cSzT6nPR6POjo6dPjw4YKPA5qmqSNHjmj//v0EAZQUKgMAimq5PomPvhJ9z7HDxRw/tLNS4fP5FIlEVFnJYS2UDioDAIpquTr+/eLno7d8+l+oqqoq9fb2anx8XK2trUqn04uaw+ythePj4+rp6SEIoOQQBgAUlblMHf+OHzcLakRUX1+v/v5+RSIRNTY2LnjJwDRNNTY2KhKJqL+/n+uLUZIIAwCKKhZzb8e/lpYWhcNh+Xw+BYNBtbW16dixY7ccO8xkMgqFQmpra1MwGLxxbXFLS0vBcwCcQC0LQFG5veNffX29wuGwuru71dXVpccff/xGR8Ta2lpNTEwomUwqn89r69atOnDggK0dEQEnEAYAFFUpdPyrqqrS008/ra985SsaHR2VaZqKxWLKZDKqrq7WM888o0AgoG3btnFqACsCYQBAURmGoYMHDyqbzdqyVDDb8e+ZZ54pfHLv4/F41NDQoIaGBtvHBtyEPQMAiioQoOMf4Db0GQBQVHT8A9yHygCAoqLjH+A+VAYAFB0d/wB3oTIAoOjo+Ae4C2EAgCPo+Ae4B2EAgGPo+Ae4A3sGADgul8upu7tbBw4c0MmTJ1VRUaFNmzbdtuPf/v376fgH2IwwAMA1BgcH9ZnPfEZr1qzRU089pWw2q+rqahmGQcc/YBmx6waAa8zuG2hpadE3v/lNh2cDlA/2DABwjdkw0NjY6PBMgPJCGADgGsPDw5JEa2GgyNgzAMAVLl++rA9/+MOSpEuXLulDH/qQwzMCygeVAQCucPz4cUnSQw89RBAAiowwAMAV2C8AOIcwAMAV2C8AOIcwAMBxlmXdCANUBoDiYwMhAMe9/vrruv/+++X1enX16lVVV1c7PSWgrFAZAOC42f0C9fX1BAHAAYQBAI5jvwDgLMIAAMdxkgBwFmEAgKNmZmZuhAEqA4AzCAMAHDU2NqarV6/K5/PJMAynpwOUJcIAAEfN7hdoaGhQVVWVw7MByhNhAICj2C8AOI8wAMBR7BcAnEfTIQCOuXbtmtasWaOpqSmNjY1pw4YNTk8JKEtUBgA4JhqNampqSh/84Af10EMPOT0doGwRBgA45uZmQx6Px+HZAOWLMADAMewXANyBMADAMdxUCLgDGwgBOGJiYkJ33323ZmZm9MYbb+jjH/+401MCyhaVAQCOOHHihGZmZvTbv/3bBAHAYYQBAI5gvwDgHoQBAI5gvwDgHoQBAI6gMgC4BxsIARTd22+/rY985COSpHfffVd33323wzMCyhuVAQBFd/z4cUnSpk2bCAKACxAGABQd+wUAdyEMACg69gsA7kIYAFBUlmVRGQBchg2EAIrq3LlzeuCBB1RZWalUKqXVq1c7PSWg7FEZAFBUs1WBRx55hCAAuARhAEBRze4XYIkAcA/CAICimq0MsHkQcA/CAICiyefz+tnPfiaJygDgJpVOTwDAymVZlkZGRmSapmKxmN544w1NTExo1apVymazsixLHo/H6WkCZY/TBABsl8vl1N3dra6uLiUSCXm9Xvn9ftXU1Oidd97R2bNnlc/ntWXLFnV0dGjv3r2qqqpyetpA2WKZAICtotGogsGgOjs7ZRiGQqGQUqmU4vG4TNPUqVOnlEqlFAqFZBiGOjs7FQwGFY1GnZ46ULaoDACwzcDAgHbu3Kl169apt7dX27dvn/c1pmlqz549Gh8fV39/v1paWoowUwA3IwwAsMVsRaCpqUlHjx5VTU3Ngl+bTqfV2tqqSCSicDis+vr6ZZwpgPcjDAAoWC6XUzAY1OTkpIaHhxcVBGal02k1NjbK5/MpHA6zhwAoIvYMAChYd3e3RkdH1dvbu6QgIEk1NTXq6enRyMiIuru7bZ4hgLlQGQBQEMuyZBiGDMNQX19fweO1tbUpkUgoGo1y7BAoEioDAAoyMjKiRCKh9vZ2W8Zrb29XPB7X6OioLeMBmB9hAEBBTNOU1+tVc3OzLeM1NzfL6/XeuMMAwPIjDAAoSCwWk9/vl8/ns2W86upq+f1+xWIxW8YDMD/CAICCZLNZ1dXV2TpmbW2tMpmMrWMCuDPCAICC+Hw+pVIpW8ecmJhQdXW1rWMCuDPCAICCGIahZDKpbDZry3iZTEbJZFKGYdgyHoD5EQYAFCQQCCifz2twcNCW8QYHB5XP5xUIBGwZD8D86DMAoCD0GQBKH5UBAAW5nMnpyX/9hzp8+HDBxwFN09SRI0e0f/9+ggBQRFQGACxJ+lpepy9ldGVyWtO5nPbtfkIVMzmZNtxNEIlEVFlZuQyzBnA7VAYALMq1/IxO/Sqj0QtXdWVyWpJUWVWlP/uv39K5c+PatatV6XR6UWPO3lo4Pj6unp4eggBQZIQBAAsyY1l6/cqkfvb6Vb2ZmtL7S4oPbtqqZ5//vsKRiAKNjQteMjBNU42NjYpEIurv7+f6YsABhAEA8/pV+ppOXLiqs5ezys/ceWWx4dPNeu7FH8ryrlIwGNTutjYdO3bslmOHmUxGoVBIbW1tCgaDN64tbmlpWe63AuA22DMA4I4mpqZ15nL2xnLAQk3ncvrB376gw3/zvM6eelVer1d+v1+1tbWamJhQMplUPp/X1q1btX//fu3du1dVVVXL9C4AzIcwAOAW16ZndO7dSV1MTRU0jmVZGov/Qqeio0r/8rQymYyqq6tlGIYCgYC2bdvGqQHABQgDAG6YsSxduDKl169MzrkcsFi1q7zadt8a28YDYC+27AKQdH1fwNnLWU1Oz9g+dqWX7UmAmxEGgDI3MTWt05ezurrIfQGLUeVlKQBwM8IAUKauTc/o7DtZvTVxbdm/V2UFYQBwM8IAUGbyM5YuXJ3U6+9OaaZIW4aqCAOAqxEGgDLy9sQ1nX0nq6ll2Bcwl0qWCQBXIwwAZSA1Na3Tl7JKTS3fvoC5VFawgRBwM8IA4BKWZWlkZESmaSoWiymbzcrn8904k9/Q0LDoM/lT0zM6V6R9AXNhAyHgbvQZAByWy+XU3d2trq4uJRKJG9366urqlEqlbnTr27Jlizo6OhbUrS8/Y+nClUm9fqV4+wLm8ol761R3F589ALeidgc4KBqNKhgMqrOzU4ZhKBQKKZVKKR6Pa2hoSPF4XKlUSqFQSIZhqLOzU8FgUNFo9LbjWZaltyau6WcXrmr83UlXBAGJDYSA21EZABwyMDCgnTt3at26dert7dX27dvnfY1pmtqzZ4/Gx8fV39//not9nN4XMJfgug9wvBBwMcIA4IDZikBTU5OOHj2qmpqaBb82nU6rtbVVkUhE4XBYGzZv1bl3snrb4X0Bd+LxSM0PfNDpaQCYA2EAKLJcLqdgMKjJyUkNDw8vKgjMSqfTamxslHfVXer6ux+potK96/FV3gp9eu3dTk8DwBzYMwAUWXd3t0ZHR9Xb27ukICBJNTU16unpUeyVn+ul7/faPEN7cZIAcD8qA0ARWZYlwzBkGIb6+voKHm93W5tGXomp94eDrr0KeM3qSj3y8TqnpwFgDlQGgCIaGRlRIpFQe3u7LePta2/XmbGTGov/wpbxlgMnCQD3IwwARWSaprxer5qbm20Zr7m5WV6vVydfOWHLeMuB64sB9+OnFCiiWCwmv98vn89ny3jV1dXauNGvM2MnbRlvOXCkEHA/wgBQRNlsVnV19q6f19bWajKbtXVMO7GBEHA/wgBQRD6fT6lUytYxJyYmtNqmSsNyoDIAuB9hACgiwzCUTCaVtemTfCaT0dhYUus3brZlvOXABkLA/QgDQBEFAgHl83kNDg7aMt7g4KDy+bw2P/JJW8ZbDmwgBNyPn1KgiBoaGrRlyxYdOnTIlvG+feiQ1m/crI1bH7ZlvOVAZQBwP8IAUEQej0cdHR06fPiwTNMsaCzTNHX0yBF98d/8oWsbDklSJRsIAdejAyFQZHbdTRBobJTlXaXn/r8fq9LFdxM8+sAHVOHisAKAygBQdFVVVert7dX4+LhaW1uVTqcX9fp0Oq1du1p17ty4/vS/dLk6CHgrPAQBoAQQBgAH1NfXq7+/X5FIRI2NjQteMjBNU4HGRoUjET37/Pf14KatyzzTwrBfACgNhAHAIS0tLQqHw/L5fAoGg2pra9OxY8duOXaYyWQUCoW0u61NwWDw+tLAiz9Uw6ftaWm8nNgvAJQG9gwADsvlcuru7lZXV5cSiYS8Xq/8fr9qamo1MTGhsbGk8vm81m/crC/+mz/Uk7//JVVWVTk97QX5gK9K9R+rdXoaAOZBGABcwrIsjY6OyjRNxWIxvXn5qmYqV2n9xs3a/MgntXHrw64+NXA799Su0qZ7Fr9BEkBxEQYAlzpzOasLVyadnkZB7l1zlx78cLXT0wAwD/YMAC61Enr6r4T3AJQDwgDgUiuhiy+tiIHSwE8q4FLeEtsfcDtUBoDSQBgAXGolPEirOFoIlATCAOBS3pUQBlbAewDKAWEAcKmVUBlYCe8BKAeEAcClVkRlgA2EQEngJxVwqVL/VO3xrIxAA5QDwgDgUqX+IK2q4NcLUCr4aQVcqsJT2tf/ckkRUDoIA4CLlfKSOycJgNJRwr9qgJWvlJcKSn3PA1BOCAOAi1WW9DIBv16AUsFPK+BipVwZYJkAKB2EAcDFSrnUzgZCoHQQBgAXozIAoBgIA4CLlXRloITnDpQbwgDgYqVcGWADIVA6+GkFXKyUwwDLBEDpIAwALlbaRwtLd+5AuSEMAC5WypUB9gwApYMwALhYqT5QvRWlfa8CUG4IA4CLlWploIolAqCkEAYAFyvVMFCqFQ2gXBEGABcr1TBQVcGvFqCU8BMLuFipfsLmJAFQWggDgIuV6jOVHgNAaSEMAC7m8XhKcqmAygBQWiqdngCAW1mWpZGREZmmqf8ZOaFMNqu7Vvu0fuNmbX6kQX7jEXlcfHSvkj0DQEnxWJZlOT0JANflcjl1d3erq6tLiURCXq9XG/1+1dXWKZVKaWwsqXw+rwc2bNLv/dsv68nf/5Iqq6qcnvYtNt1To3tqVzk9DQALRHwHXCIajSoYDKqzs1OGYSgUCimVSikRj2t4eEiJRFypVEqhUEif2vawvvHnX9W+3U/o9Ktxp6d+C5YJgNJCZQBwgYGBAe3cuVPr1q1Tb2+vtm/fPu9rTNPUU3v26Ny5cT37/PfV8OnmIsx0YbbdW6fau1iFBEoFYQBw2GxFoKmpSUePHlVNTc2CX5tOp7VrV6vCkYiee/GHenDT1mWc6cJtv/9ura6k8AiUCsIA4KBcLqdgMKjJyUkNDw8vKgjMSqfTCjQ2yvKu0nMv/sgVewia1n2gJE9BAOWK6A44qLu7W6Ojo+rt7V1SEJCkmpoa9fb0KBl7RT/42xdsnuHieTyl2zkRKFdUBgCHWJYlwzBkGIb6+voKHm93W5tGXomp94eDjh47XOWtUOPaux37/gAWj8oA4JCRkRElEgm1t7fbMt6+9nadGTupsfgvbBlvqThJAJQewgDgENM05fV61dxszymA5uZmeb1enXzlhC3jLRWtiIHSQxgAHBKLxeT3++Xz+WwZr7q6Whs3+nVm7KQt4y0VlQGg9HAQGHBINptVXV2drWPW1tZqMpu1dcz5WJalZOwVnXxlRGfGTqoif00f+2CdDMNQIBBQQ0ODq1snAyAMAI7x+XxKpVK2jjkxMaHVNlUa5jOdy+kHf/uCDv/N8zp76tXrrZM3+lW3pk7RVEoHDx5UPp/Xli1b1NHRob1796rKBcceAdyKZQLAIYZhKJlMKmvTJ/lMJqOxsaTWb9xsy3hzOf1qXPt2P6Fv/PlX9altD/+mdXIiruGhIcXjv2mdbBiGOjs7FQwGFY1Gl31uABaPMAA4JBAIKJ/Pa3Bw0JbxBgcHlc/n1brjs3rww9X6rZpVqlqG9fuRoUHt2/15VczkNDQ0pBf7+rRjx45b9j74fD7t2LFDfX19ikQimpycVFNTkwYGBmyfE4DC0GcAcIjdfQba2tqUSCQUjUbfs0afuZbXlclpXZmc1tXJaV3Lzyz5e1yvCHxejzY16aWXFt86ubW1VZFIROFwWPX19UueBwB7EQYABx08eFCdnZ2KRCIKBAJLHsc0TQWDQR04cEBPP/30nH83cy2vq5PTujI1rSvZhYeD6VxO+3Y/oYqZnMwCWic3NjbK5/MpHA6zhwBwCcIA4CC77iaYfcBGIhFVVi5uX3A2l79RNXh3clrXpm8fDo78zXf0jT//qoaGhhZ0q+KdLCa4ACgOwgDgsGg0qqamJgWDwSXdWmh36T2b+3Xl4NdfU9MzsixLX/r8o/rUtof14jIuaQBwBhsIAYfV19erv79fkUhEjY2NMk1zQa8zTVONjY2KRCLq7++3bQ3eV+XVR+vukv+eGgXuv1vb779bkxeSOnvqVe2zqXVye3u74vG4RkdHbRkPQGEIA4ALtLS0KBwOy+fzKRgMqq2tTceOHbvl2GEmk1EoFFJbW5uCweCNtfeWlpZlm9vqygqdjv98WVonLzT4AFheNB0CXKK+vl7hcFjd3d3q6urS448/Lq/XK7/fr9raWk1MTCiZTCqfz2vr1q06cOBA0Rr5LEfrZL/fr1gsZst4AApDGABcpKqqSk8//bS+8pWvaHR0VKZpKhaLKZPJqLq6Ws8884wCgYC2bdtW1LX25WqdnMlkbB0TwNIQBgAX8ng8amhoUENDg9NTkbR8rZOrq6ttHRPA0rBnAMC8lqN1cjKZlGEYtowHoDCEAQDzWq7WyYU0WgJgH/oMAJhXsVonA3AGlQEA8/J4POro6NDhw4cLPg5omqaOHDmi/fv3EwQAl6AyAGBB3NA6GcDyoDIAYEGqqqrU29ur8fFxtba2Kp1OL+r1s62Tx8fH1dPTQxAAXIQwAGDB3NY6GYA9CAMAFsXNrZMBLA17BgAsSS6Xu9E6OZFIzNk6ef/+/UVrnQxg8QgDAApiWdZtWycbhuFI62QAi0cYAACgzLFnAACAMkcYAACgzBEGAAAoc4QBAADKHGEAAIAyRxgAAKDMEQYAAChzhAEAAMocYQAAgDJHGAAAoMwRBgAAKHOEAQAAyhxhAACAMkcYAACgzBEGAAAoc4QBAADKHGEAAIAyRxgAAKDMEQYAAChzhAEAAMocYQAAgDJHGAAAoMwRBgAAKHOEAQAAyhxhAACAMkcYAACgzBEGAAAoc4QBAADKHGEAAIAy978A7sVZ/TWnCjIAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -130,7 +133,10 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 5, @@ -139,7 +145,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -163,7 +169,10 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 6, @@ -172,7 +181,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -202,7 +211,10 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 7, @@ -211,7 +223,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA6BklEQVR4nO3dfXRT550v+q8s23jLNrR5DwkYCCjBcoidIFWO2rppHKcnkOKA1109d800NAkxie2zemfWnHY6M7d37l1tc29nOjmBkjhOUisz93Q65mASPG1aM7f16VIke6dICZINMmAjAuEtEJAt2Zalff8wcgADtuUt7y09389arKy66PFjA95fPS+/n0FRFAVEREQkrBytJ0BERETaYhggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCy9V6AjQziqLA6/VClmUEAgFEo1FIkgSLxQKr1YqKigoYDAatp0lERBnIoCiKovUk6PpisRhaWlqwfft29PX1wWg0wmw2o7i4GOFwGMFgEPF4HKtXr0ZjYyO2bNmCvLw8radNREQZhNsEOub3+2G329HU1ASLxYLOzk6Ew2H09vaiu7sbvb29CIfD6OzshMViQVNTE+x2O/x+v9ZTJyKiDMKVAZ3q6urCunXrUFJSAqfTibVr1077GlmWsXnzZoRCIXR0dKCqqmoeZkpERJmOYUCHkisClZWV2L17NwoLC2f82uHhYdTW1sLj8cDtdqOsrCyNMyUiomzAMKAzsVgMdrsdIyMj6OnpmVUQSBoeHobNZoMkSXC73TxDQEREN8QzAzrT0tICn88Hp9OZUhAAgMLCQrS2tsLr9aKlpUXlGRIRUbbhyoCOKIoCi8UCi8WCtra2OY9XV1eHvr4++P1+XjskIqLr4sqAjni9XvT19aG+vl6V8err69Hb2wufz6fKeERElJ0YBnRElmUYjUY4HA5VxnM4HDAajZBlWZXxiIgoOzEM6EggEIDZbIYkSaqMZzKZYDabEQgEVBmPiIiyE8OAjkSjURQXF6s6ZlFRESKRiKpjEhFRdmEY0BFJkhAOh1Udc2hoCCaTSdUxiYgouzAM6IjFYkEwGEQ0GlVlvEgkgmAwCIvFosp4RESUnRgGdKS8ogLxeBwul0uV8VwuF+LxOKxWqyrjERFRdmIY0IGTZy/if34QRN/xcSxesgyvvfaaKuM2NzejtLQU5eXlqoxHRETZKVfrCWhNURR4vV7IsoxAIIBoNApJkmCxWGC1WlFRUZGWgj2R6BgOhU4jePQ0LoQ/P+D3yOMb8cu3XoYsy3N6Ry/LMtrb27Ft2zYWHCIiohsStgJhLBZDS0sLtm/fjr6+PhiNRpjNZhQXFyMcDiMYDCIej2P16tVobGzEli1b5lzjP5FI4NjJzxAcPIljJ8/jWt/68fFxvPQ3WyHl50CW5Tn3JvB4PMjNFT7zERHRDQi5TZDsCtjU1ASLxYLOzk6Ew2H09vaiu7sbvb29CIfD6OzshMViQVNTE+x2O/x+f0qf70I4Ctk/iF/95gPsdfci9Mm5awYBAMjNzcV3Gn6AwcGj2LBhA4aHh2f1uZJdC0OhEFpbWxkEiIhoWsKtDHR1dWHdunUoKSmB0+nE2rVrp32NLMvYvHkzQqEQOjo6UFVVNe1rxsfjGDh+FgcHTuHUpxdnPc+DAS+2v/R9LFs2Mc+ZbBmkMk8iIiKhwkByRaCyshK7d++e1RJ88h23x+OB2+1GWVnZNX/f6XNhBAdP4cixM4iNx+c03+OhI/jFz3+C0EAQtbW1eOGFF+BwOK6oUBiJROByufDaa69h9+7duH/NA/iXf377uvMjIiK6mjBhIBaLwW63Y2RkBD09PXPei3e73ZNnCEZGYxOHAQdP4/zF2S3rT2d8fBx/3LsHv//tLpw4Ngij0YiVK1ehqKgIQ0NDOHSoH/F4HHctXY6v1TyF2rpvYeNjDyEnR8gdICIiSoEwYWDHjh1oampCd3f3jLYGrkeWZdjtdrzyyivYUPe/IjhwCkdPnENCSag426kURcGxgX4MHD6AE8cGMDY6gvwFBVi8ZDmW33MflixfNXlrwP7AClhWLk7rfIiIKHsIEQYURYHFYoHFYkFbW9ucx9u0qQ7yn7z43/+hVZfX9vJyjdhU8yAKpQVaT4WIiDKAEEfNvV4v+vr68Morr6gy3tat9dhVU4NjA/1YusKsyphqio3H0f3hAL5uv0/rqRARzQutasZkCyHCgCzLMBqNcDgcqozncDhgNBoxcPiALsMAAAwcP4tjJ89jyR1f1HoqRERpM13NmB07dqheMyYbCXHKLBAIwGw2X3EKfy5MJhNWrlyFE8cGVBkvXd73Hsb4HG80EBHp1XzXjMlmQoSBaDSK4uJiVccsKirC2OiIqmOqbSgyAt/Bj7WeBhGR6rq6uiZviHV3d6OtrQ3V1dVT3vRJkoTq6mq0tbXB4/FgZGQElZWV6Orq0mjm+iREGJAkCeFwWNUxh4aGkL+gQNUx02H/weP47LLeB0REmc7v92PdunWorKxET0/PjG+IWa1W9PT0wG63Y/369VwhuIwQYcBisSAYDCIajaoyXiQSwaFD/Vi8ZLkq46VTQknAte+w1tMgIlJFLBbD008/jZKSklkXjwOAwsJC7N69G0uXLsXmzZsRi8XSNNPMIkQYsFqtiMfjcLlcqozncrkQj8ex/J7MOK1/8uwF9B89pfU0iIjmrKWlBT6fD06nM6XiccBEIGhtbYXX60VLS4vKM8xMrDOQgk2bNqH7Ay/+j390ZsxVlYL8PNQ9/iAW5PMULRFlJrV/ltfV1aGvrw9+vz9jfpanixBXCw0GAxobG9HU1ARZlmfU9Od6ZFnG7t278Z+f+W5G/eUZGYtB3n8UX35opdZTISIViHivXu2aMfX19aipqYHP50NFRYUqY2YqIVYGAPV6E1itVkTHFPz1j1+F0Zh5WWr919bg9psXaj0NIkrRdPfqg8Fg1t6rb25uRkNDA8LhsCpXxSORCBYuXIgdO3bg+eefV2GGmUuIMwMAkJeXB6fTiVAohNraWgwPz66h0PDwMDZs2IDBwaP4TsNfZ2QQAADXvsNIJNLbR4GI0kP0e/XpqBljNpsRCARUGS+TCRMGAKCsrAwdHR3weDyw2WyQZXlGr0tuLbz/vhuN338Jdy1dkeaZps/5i8MIHPpE62kQ0SzxXn36asZEIrx+LVQYAICqqiq43W5IkgS73Y66ujrs3bt3yrXDSCSCzs5ObNq0CXa7HdExBd//0au415L5+0r7ekMYioxqPQ0imiHR7tWPJxQMj8VxLhLDJxdHMXguigOnhzGcMOJiGmrGmEwmVcfMRMKcGbhact/tH3/2Mo4c7ofRaMTKlatQVFSEoaEhHDrUj3g8jruWLsfXap7CV6qfRG5uZm4NXEvJ4ptRXbla62kQ0TTUOu9ks9kgSRLcbremZwgURcFYXMHoeGLiV3zivyPJ/z2eQDxx7cfSO/+9Ff/0w7/imYE0yJ6n2yzl5eXhxRdfxF33PYx9f9qHgcMHcOLYAMZGR/CF2wtg+9qTWH7PfViyfFXWncgFgKMnPsXRE5+iZPHNWk+FiG4gea++u7t7zvfq7XY7Wlpa8OKLL6o8y8/FE8oVD/kpv+IJpPoW9L41FZM1Y6qrq+c812TNmLncMMsWwq4MAMBQZBS/+s3Mzg1ko0LTAmyqfhB5eUatp0JE16DHe/Wxa7yTv/zBH4un75GiKAq+/fjDeKj8fuzUyfcjWwi7MgBMvDsW2XBkFN4Dx2C7f5nWUyGia5jve/UJRcHYpYf7SCz5kFeueGef0PD9o8FgwMY/fw4v//33VKkZ097ejm3btgkfBADBVwZ+/T/345MzF7SehqZyDDnY8OgDuGlRasuPRJQ+6bpX/9OXt+Fb335myrv7sXH9Xzsej8WwdVMNchIxyCqcofB4PFl1HixVwt0mSBoZjeHk2YtaT0NzCSWB972HIXAmJNKtdNyrX7XKjPf/5MPhTyM4fmEEZ4fHEB4dz4ggAAC5eXn4wU9/jqNHQ9iwIbWaMbW1tQiFQmhtbWUQuETYMHD0xKd8AF5y6tOLCA6ykRGR3qTrXv2ISh1ctbLi3lK89MYv4fZ4YJ1lzRibzQaPx4OOjg6UlZWleaaZQ+AwcE7rKeiKvH8QI6Ns5UmkJ5IkIZyGe/UFKq00aKniSw68uvM9KMZ82O12bJqmZkxdXR3sdvvk9cqqqiqNZq5PQoaBsdg4jp/6TOtp6MpobBw9+we0ngYRXcZisSAYDE55wKUqEomgvz+I5asyo/36dFbcW4pXd/4W3/3h/419H/rx2GOPobi4GKtXl8JqtWH16lIsXLgQNTU12Lc/gP/2yitwu91cEbgGITdLPj55HgklM/bH5lP/0dNYVXI77rx1kdZTISJMVBBMx736+9Y8qMLs9CE3Lw9P/fmzqP2zZ9Dfux8HPtqHgf4DGIlGUSBJePLPt+C+NQ9iVen9uOeWwqxp2qQ2IW8T/H+eAxg4flbraejSomITNlaXIydHyEUjIl1Ru87Apro6eD8KwPmeS8jrdAV5OXjoroVCfu3TEe4n/vh4HMdOntd6Grp1IRzB/v4TWk+DiDBxr76xsRG7du2a8SG565FlGbvb2/HUnz0r7MNwJJbAuQjPRl2LcCsDR0+cw153r9bT0DVjTg42PlaBhUWZf8iIKNOp1ZvAarNBMebj1f/xO6Gv0y0qyMX9d6p7QyMbCLcycPQEtwemE08k4PYd0XoaRISJPipOpxOhUAi1tandq9+woRZHj4bw1//PdqGDAABcGBnH0Oi41tPQHaHCQCKRQIhXCmfk41PnMchzFUS6UFZWho6ODng8Hthmea/earPB7fHgpTd+iRX3lqZ5ppnh+EW2cL+aUGHgk7MXMRpjIpwpt+8IYrG41tMgIgBVVVVwu92QJAl2ux1109yr33TpXr1izMerO99DxZccGs1cf84Oj2E0Qyouzhehzgy4vIdx4MgnWk8jo1hWLob9gRVaT4OILonFYmhpacE//bdtOBQ8AKPRiFWrzCgqKsLQ0BD6+4OIx+NYvuo+PPVnz+LJb30bubxON8Xdiwqw7Caei0oSJgwoioJ//bWMyMiY1lPJKAaDAd985AHc8sUiradCRJckFAWeo5/hgP+jKffql6+6b/Jevai3BmbCmGOAbckiGHP4PQIECgOnPr2Ijj98pPU0MtItXyzGNx9Zwx8sRDpxdngMB07P7iAhTbXiZhMWL1yg9TR0QZgzA4PHP9V6Chnr7PkwDhw5qfU0iOiSM0Nc4VTDiYsjbFh3iTBh4OgJhoG5+CBwFJEofwARaS0WT+BclIVz1DASS+BclIfKAUHCwKefDSE8PKL1NDLaGBsZEenCp5EY+GZWPScu8NkACBIGuEWgjsPHzuD46c+0ngaR0LhFoC4WIZogRBg4ykJDqnnfexjxOO/nEmlhZDyBCyN8cKmNRYgECAMXwlGcv8hTt2q5OBTFhwc/1noaREI6O8xVgXRgESIgK4pUK4oCr9cLWZYRCAQQjUYhSRIsFgsW3boUilLEa3Eq+vDAx7hnya1YVMyCHUTz6TS3CNJCUYBPLo4KXYQoo+sMJCtxbd++HX19fTAajTCbzSguLkY4HEYwOFGJa/GSZXjk8Y34SvWTwjfpUMvi276A//SVMq2nQSSM4bE4vMcvaj2NrCV6EaKM3Sbw+/2w2+1oamqCxWJBZ2cnwuEwent70d3djd7eXoTDYXR2dqLS9hB++dbLeOlvtuJ4iN341HDi9Gc4HDqj9TSIhMGDg+kVTyg4JfD3OCPDQFdX12R/7+7ubrS1taG6uhqSdOUSjyRJqK6uxs6dO+HxeCDl5+Clv3kBBwNejWaeXbo/GsAYGz8RpZ2iKDjD8wJpJ3IRoowLA36/H+vWrUNlZSV6enqwdu3aGb3OarVClmU8/HAltr/0fa4QqCA6OgbZf1TraRBlvYuj48IfcJsPIhchyqgzA7FYbHJFoKenB4WFhbMeY3h4GFarFdExBd//0as8Q6CCJx95ALfdVKz1NIiyVv/ZCE6Fef1tPiwqyMX9d4r38yyjVgZaWlrg8/ngdDpTCgIAUFhYCKfTidBAEH/cu0flGYrpfe9hJBJ810KUDglF4ZXCeSRqEaKMCQOKomD79u3YuHHjjLcGrsdqtaK2thZ/+F27sPtDavr0syH0sZERUVqcj8QQT/Dn1Hw6IWARoowJA16vF319faivr1dlvK1bt+J4aADHBvpVGU90fwocxXBUvH9AROl2mqsC8+6MgEWIMiYMyLIMo9EIh8OhyngOhwNGoxEDhw+oMp7oYuNxdH/IRkZEahpPKDgfEW/JWmvJIkQiyZgwEAgEYDabp1wfTJXJZMLKlatw4hgfYGoZOH4WoU/YB4JILZ8OjyHBrUxNnAyPCrU9kzFhIBqNorhY3ROeRUVFGBtl+0o1uX1HMD4e13oaRFmB5Ye1M55QhPr+Z0wYkCQJ4XBY1TGHhoaQv6BA1TFFNxQZgY+NjIjmbJQdCjV3XKAiRBkTBiwWC4LBIKLRqCrjRSIRHDrUj8VLlqsyHn1u/8HjOH8xovU0iDIarxNqT6QiRBkTBqxWK+LxOFwulyrjuVwuxONxLL/nPlXGo88llATe9x7WehpEGU2kJWo9O3FBjK3kjCm/V1FRgdWrV6O5uRnV1dVzHu+1117DXUuXY8nyVSrMjq528uwF9B89hVUlt2s9FaKMExmLY3iMZ2/0IFmEqDDfCK/XC1mWEQgEEI1GIUkSLBYLrFYrKioqYDBkbsfDjCpHvGPHDjQ1NcHj8cBqtaY8jizLsNvt+M/PfBePfOMpFWdIlyvIz8OmmgdRsCBP66kQZZTBc1F8LMg7Ur0bj8Xw+/b/F23OFvT19cFoNMJsNqO4uBjhcBjBYBDxeByrV69GY2MjtmzZgry8zPuZl1FhQK3eBDabDQsWFOCnP/9nDJ7gVbh0unfZHfjyQyu1ngZRxlAUBR98fFG4ojd6dORgL378Vw3o792PjRs3or6+Hg6H44or7tFoFC6XC83Nzdi1axfKy8vhdDpRVlam4cxnL2PODABAXl7eRF+BUAi1tbUYHh6e1euHh4dRW1uLUCiEt9924tHKUqyrWoMvLkytzwFN7+DgSZw8e1HraRBljIujcQYBHfB2u7B10+PIScTQ3d2NtrY2VFdXT6l1I0kSqqur0dbWBo/Hg5GREVRWVqKrq0ujmacmo8IAAJSVlaGjowMejwc2mw2yLM/odbIsw2azwePxoKOjYzK13XHLQtQ++gAqy+9Bfl7GHKHIKGxkRDRzZ3hwUHNHDvbie89+Cw9XVkLu6ZlxPxyr1Yqenh7Y7XasX78efr8/zTNVT8aFAQCoqqqC2+2GJEmw2+2oq6vD3r17p1w7jEQi6OzsRF1dHex2OyRJgtvtRlVV1RW/LycnB6X33Im6mgdx77I75vNLEcL5i8Pw95/QehpEuscOhdobj8Xw479qwLJlJXjnnd2z3o4uLCzE7t27sXTpUmzevBmxWCxNM1VXRp0ZuFosFkNLSwu2b99+xcGOoqIiDA0NTR7sKC0tRUNDw4wPdpw+F4bbdwRnz6tb5EhkuUYjNtU8iCLTAq2nQqRbn0Zi6Ds1pPU0hNb+z2/i5b//Hrq7u+fUITd5UH3btm148cUXVZxhemR0GEhSFAU+n2/yykckEoHJZJq88lFeXj7rKx+KoiA4eAof+I9iZCwzkp3elSy+GdWVq7WeBpFuHTg9zJUBDSmKgm8//jAeKr8fO9va5jxeXV0d+vr64Pf7dX/tMCvCQDqNjsXwp94QDhw5KUxZynSqrlyNksU3az0NIt0ZTyjoCV1gYyINHfR/iOe++Qg6OztVqWfT2dmJmpoa7Nu3DxUVFSrMMH0y8szAfFqQn4eHy+/Bhq8/gNtvXqj1dDKe+8MjiMVYTIXoauxQqL0DH3lhNBrhcDhUGc/hcMBoNM74oLuWGAZm6OYvFGH919agaq0ZpoJ8raeTsYYjo/AeOKb1NIh05wy3BzQ30H8Aq1aZp1wfTJXJZILZbEYgEFBlvHRiGJillSW3YVPNgyhbdRdyDPz2pcLffxznLsyuRgRRNhsbT+AzQRri6NnoSBTFxcWqjllUVIRIRP+N2/g0S0F+Xi6+tGY5aqvLsfi2L2g9nYyjKApc+w7zDAbRJVwV0IcFBRLCYXVvkQ0NDcFkMqk6ZjowDMzBFxea8J++Uoavf+k+FPLK3KycPncRwcFTWk+DSBdYaEgfVt67Gv39wSk1a1IViUQQDAZhsVhUGS+dGAZUsPzuW1D32IN44L4l3DqYBXn/IEZGeW2TxBYZi2OIHQo1kWfMwa1F+Vh5iwkP3b0Q/8vjX0U8HofL5VJlfJfLhXg8PqfGevOFVwtVdnEoCs+HAzh2kg2QZmJVyW346lqz1tMg0szR81Ec+4wdCudDntGARQV5WFSQi0UFuTDlG6/4/xVFgcVigcViQZtgdQb4NlZlC4sk1DhK8djDpSguLNB6OrrXf/Q0Tpz+TOtpEGmGWwTpY8wx4GZTHlbcLKHiroWwLVmE+24rxJ0LF0wJAgBgMBjQ2NiIXbt2zfk6oCzLaG9vR0NDg+6DAMCVgbSKxxP4KHgcHx38GONxLgNez6JiEzZWlyMnJweKosDr9U5Wk4xGo5AkabKaZEVFRUb8wyKaiYsj4/joE5Y9V4sxx4CFBbn4wqV3/oX5xln/vIjFYrDb7RgZGUFPT8+sexMAEx1ybTYbJEmCx+NBbq7+m+AxDMyDocgouj86gsHjn2o9Fd1aY14M+Y/vTekzUVxcjHA4PNlnYvXq1WhsbJxxnwkiPTt0NoKT4VGtp5GxcgwTD/9FBbn4gjTx8M9R4c2C3+9HZWUl7HY7du+eXbOi4eFh1NbWwuPxwO12T3bI1TuGgXn08anz8Hw4gAth/d85nU/HQ0fwi5//GKGBfmzcuBH19fVwOBxXFP6IRqNwuVxobm7Grl27UF5eDqfTmTH/0IiullAUyMcuIBbnj+CZyjEYULzAiEVSLhYV5KF4gToP/2vp6urC+vXrsXTpUrS2ts7oEKAsy9i8eTNCoRA6OjqmdMjVM4aBeZZIJODvPwHfgWOIjXPr4GDAi20/+R6WL1+Gt99+e0ZdwjL5HxxR0rlIDL3sUHhDBgNQvCB38sBf8YJcGHPmb5vQ7/dj8+bN8Hq9eOqpp7B169Ypb1QikcjkG5X29nZUVFSgtbU1496oMAxoZDg6Cnn/IA4fO6P1VDRzPHQEP/nBVjgcD+Odd94RYimOKIkdCqcyAChKPvylXCyc54f/tcRiMbS0tEzZwiwqKsLQ0NDkFmZpaSkaGhoydguTYUBjn5y5ALfvCM5fFKs87/j4OF76m62Q8nMgy/KcD+m43e6M/AdIYoonFHSzQyEAoCjfiEXSxHW/hQW5yNX44X89iqLA5/NNHm6ORCIwmUyTh5vLy8sz+nAzw4AOJBIJ9B05iX29IYzFxKhP/vv32vHLt15Gd3f3jLYGrkeWZdjtdmzbtg0vvviiijMkSp9T4VH0nxXz7JAp3zh52n9hQS7yjLzhrgcMAzoSHRnDnwIhHBw8qfVU0kpRFPzwL76NSttD2Llz55zHy6TCHkQA4D85hM+iYlTflPKMk6f9F/Hhr1v6v/woEKkgH19+aCXMy2+H23cEZ89n5/3j0EAQJ44NYutbLaqMV19fj5qaGvh8PlRUVKgyJlG6jI0ncCGLg0BBXs5klb8vFOQiP5cP/0zAMKBDt91UjG8+sgbBwVP4wH8UI2PZ9YNj8NABGI1GOBwOVcZzOBwwGo2QZZlhgHTvzPAYsmk5dkFuzuRp/0VSHgr48M9IDAM6ZTAYcO/yO7DsrpvxQSCEgwMns6bl7/FjA1i5ctUV13PmwmQywWw2IxAIqDIeUTplervifGPOpXv+E7+kvKllfSnzMAzo3IL8PDgq7sG9yya2Dk6fu6j1lOYsNjaK4uJiVccsKipCJCLmgSzKHJGxOIZGM6u+yHTNfSg7MAxkiFu+WIQnH1mDQ0dPo2f/IKKjmfvuIi9/AU6H1T0PMTQ0BJPJpOqYRGrLhFWB3BzD5D3/RQV5KOTDXwgMAxlmZcltWLr4Jnj7jiFw6ERGbh3ctWQ5un63e7IJ0VxFIhEEg0F897vfnfvkiOZgukZb8VtXaD3FKdRo7kOZj2EgA+Xn5eJLa5bDvOx2uH2H8cmZC1pPaVaWrbwP8XgcLpcL1dXVcx7P5XIhHo/PqHY4UTpcr0pdstHWjh07EI/HsWzlvdj458/hyW99G7kaFclKV3MfymysM5AFBj4+C89HA4hEM6P7WbrqDHy0348cgwH8uUbzye/34+mnn4bP55u20dZrzc1o37ULq0rvxw9++nOsuLc07fObz+Y+lLkYBrLE+HgcvoMfY//B40goCa2nM61kBUKPxzOnd/TJCoQvv7INL7wwUYEwxzBR45w/7yjdurq6sG7dOpSUlMDpdM640dbTmzfj6NEQXnrjl6j4kjpXbJOubu6zsCCXD3+aFsNAlrkQjsLz4RF8fOq81lO5of6+j/Cz/+t/w/Jly7Bv37459SYokCS43vcgN/fKXS8DLgUD/hykNPD7/bDb7aisrEyp5/2GDbVwezx4ded7c1oh0GNzH8o8DANZ6uiJc/B8eARDkRGtpzLFnzxdeOOV/xOxsTHk5uaiqqpqTl0L/+i6cdfC5CoBVwtILbFYDHa7HSMjI+jp6Uk5zFptNijGfLy687ezOkNweXOfRQV8+NPcsVRUlipZfBM2PVaBB0tLYMzRxx+zoij43Z5f4bV//DvExsbwxBNP4N1330V3dzdsNhtkWZ7ROLIsw2azwePxYM+eDtw/TftiBUBCAeLKxH8Zf2muWlpa4PP54HQ6UwoCAFBYWAhnayuCgY+w51/fvuHvNeUbsXjhAqy+vQj2ki+g/K6FWH6ThJtMeQwCpAquDAggPDyCnv0DGDz+qWZziMfH8a+/2Ibfv7cLAPDCCy/glVdeQW5uLvx+PzZv3gyv14unnnoKW7dunXIAKxKJwOVyobm5Ge3t7aioqEBrayvKysqgKJ8/8GcquYUAcLWAZkdRFFgsFlgsFrS1tc15vE11dfB+FIDzPdfklT4296H5xjAgkI9PnYfnwwFcCM9vpb6RaASvv/z3+OhP78NgMOCnP/0p/uIv/uKKu8zXu5pVVFSEoaEhBINBxONxlJaWoqGhAVu2bEHeVcuqCWV2gQDgFgLN3r59+/DQQw+hs7NTlauxnZ2dqKmpwe7/cOFh21osYnMf0gDDgGASiQT8/Sfg7TuG8fjsyqIqioLQQBCDhw7g+LEBxMZGkZe/AHctWY5lK+/D0uXmKcVKPjt3Fq/85L8iNNCPgoIC/Mu//As2bdp0w8/h8/kmi7ZEIhGYTKbJoi3l5eU3LIiSSiBI4i0Emonm5mY0NDQgHA6rVjRr4cKF2LFjB55//nkVZkg0eyw6JJicnBysufdu3LP0Vsj7B3H42JlpXzM+Po4/7t2D3/92F04cG4TRaMTKlatQXFyM0+Ewun63G/F4HIuXLMMjj2/EV6qfRG5uLj4+ehiv/OS/4tzZ07j11lvx7rvvwm633/BzGQwGVFRUpNx9MLn0n0ogSL7GoHC1gK4vEAjAbDaz0RZlFYYBQRVKC/A12724d/kdcPuO4PzF4Wv+vuOhI/jFz3+M0ED/xH7+Wy3XL6jy2mv45Vsvw/X7f8dXHn0Sbf+8AyPRCO699178+te/xooV81OKdS6BAJg4f6Aol8IAGAroStFolI22KOtwY0pwd966CLWPPgD7AyuQn3dlNjwY8OInP9gKKT8H3d3d2LlzJ6qrq6e8I5IkCdXV1di5cyc8Hg8K8gz472/+E0aiEVRVVeH999+ftyCQlGP4PBSkircQ6FokSUKYjbYoyzAMEHJycmBZuRh1NQ/CXHI7gIkVgW0/+R4cjochy/KMKqsBgNVqxQcffICvfvWryM/Px89+9jPcdNNN6Zz+dakRCJKSoSCeYDAQncViQTAYRDQaVWW8ZKMti8WiynhEqWAYoElSQT6+snYVvvHlUrz92ktYvnzZrIsBARP3p/fs2YOVK1fi+eefRywWS9OMp5djAIwqLvEnVwsSXC0Q0sjICM6cOTPZaEsNbLRFesAwQFO88z/+FQOHDuLtt9+eU0GV1tZWeL1etLS0qDzD2TGoHAiAK7cQ4gmGgmx34MAB/OVf/iXuvvtu/N3f/R2MRiNeffVVVcZubm5GaWkpysvLVRmPKBW8WkhXULugSrKjoN/v17xHupJ8N5+m8VmzILuMjo5i165daG5uRldX1+THlyxZgjVr1uA3v/mNao22tm3bhhdffFGNaROlhGGArpCugir79u1L+bqgmtIdCACGgkwXDAbx+uuvo7W1FZ9+OlG1MycnB+vWrUN9fT2+8Y1vIJFIqNKbwGazQZIkeDxTG20RzSf+7aMryLIMo9EIh0OdtqoOhwNGoxGyLOsiDBgME3tj6QwEyauJwETNAnZO1L/R0VG0t7ejubkZf/jDHyY/fvfdd+O5557Ds88+i7vvvnvy40ajEU6nE5WVlaitrU2pa2FtbS1CoRDcbjeDAGmOfwPpCiIUVJmPQJCkYOJcAQsZ6VN/f//kKsDZs2cBTKwCPPHEE5OrANd7UJeVlaGjowPr16+HzWZDa2vrjLYMZFnG5s2bEQqF0NHRccOOm0TzhQcI6QqiFFQxGD4vPzwfeAtBP8bGxvCrX/0Kjz76KMxmM/7hH/4BZ8+exV133YUf/vCHGBwcxJ49e7B+/fpp37FXVVXB7XZDkiTY7XbU1dVh7969U64dRiIRdHZ2oq6uDna7HZIkwe12o6qqKp1fKtGMcWWArpCugiqSZJqo6qejd8XzuUKQxC0E7Rw6dGhyFeDMmYky3AaDAU888QSef/55PPHEEykt15eVlcHtdk822nrsscdu2Ghr27Zt12y0RaQlHiCkK6SrCcu27Tuw5VITlsuXypPPQS0fiPNxqPBGeOAwfcbGxrB79268/vrr+I//+I/Jjy9evHjyLMDSpUtV+3xzbbRFpBWuDNAVrFbrZEEVNW4TJAuqrL1sL/Xyd8eXf1CrkKDFCsHl2AtBfYcPH0ZLSwt+8Ytf4PTp0wAmVgG+8Y1voL6+HuvWrUvLob25Ntoi0gpXBugK6aoz4PsotToDV4eCdIYErVcILmcAtxBma2xsDO+++y6am5uxd+/eyY/feeedePbZZ/Hcc8+hpKREwxkS6RdXBugKBoMBjY2NaGpqgizLcy6o0t7ejpdf2Zby0mjywXx1ZDUk991VDAlarxBcjrcQZu7IkSOTqwCnTp0CMPH3+PHHH0d9ff2MDgISiY4rAzRFLBZTraBKgSTB9f78FVRRYyVBUT4//a8nOQwFk2Kx2OQqQGdn5+TH77jjjslVgGXLlmk3QaIMwzBA1+T3+1FZWQm73Z5yQRWPx4M/uty6uEedSkhIXgPUm+QWAiBeMBgYGEBLSwveeuutK1YBampqJlcBeEqfaPYYBui6urq6sH79eixdujSlgirvvNuBr+r8HvV0IUGvgQAQ5xZCLBbDnj17JlcBkj+y7rjjDjzzzDN47rnnsHz5co1nSZTZWHSIrivVgioFkoQ/uty6DwLApZP8+PyhH7+sE2E8MfF7DLi0daCzUHB558RsLGQ0ODiIv/3bv8XSpUuxadMm/O53v4OiKKipqcHOnTsRCoXwox/9iEGASAVcGaBpxWKxyYIqfX19NyyosvXFBjz3XPYVVFGuOlR49RtxvbwzT9cWgqIo8Hq9k/fno9EoJEmavD9fUVGhyv35WCyGjo4OvP766/jtb387uQpw22234ZlnnsGWLVuwYsWKOX8eIroSwwDN2I0Kqjz4kBUPZHlBlasDwbXoJSSotYVwvSBYXFyMcDg8GQRXr16NxsbGlCvrHT16FG+88QbefPNNfPLJJ5Mff+yxx/D888/jm9/8JvLz81P/QojohhgGSBXxhPbX8ebDTALBtWgZElK9heD3+/H000/D5/Nh48aNqK+vh8PhuKIyZTQahcvlQnNzM3bt2oXy8nI4nc4ZHRodHx/Hv//7v6O5uRnvvffeFasA3/nOd7Blyxbcc889s5s0EaWEYYBUoeeDdqpTgIRKQ81nSJjNakFXVxfWrVuHkpISOJ1OrF27dtrxr+7Gd70mPKFQaHIV4MSJE5Mff/TRR1FfX48NGzZwFYBonjEMkCqUSwfZhKFiILiWdIaE6UKB3++H3W5HZWXlnK6Vut2fXysdHx/Hr3/9azQ3N+M3v/nN5CrArbfeOrkKsHLlShW+OiJKBcMAqUaUrYJJaQ4E16J2SLh6C0HNglOSJOHf/u3f4HQ68eabb+L48eOTv+frX//65CrAggUL5vZFENGcsUYnqcZgyL7rbTdkAHKUz68nzocp/Z2SZZmv+vhMQ0JyaydZ9vj111vg8/nQ3d2dUhAAgMLCQrS2tsJut2PlypWTqwC33HLL5CrAqlWrUhqbiNKDKwOkGuG2CpLmORDMxuWZYLqAoCgKHrhfvSZVGzduxJ49e/DlL38Z9fX1eOqpp7gKQKRTDAOkGmHDAKDrQHC1660i7Nu3D1+yPoTOzk5V2ld3dnaipqYG+/btY0tfIp1jBUJSTfJQmpCSe+9az2MGlKt+JW+CfCDLMBqNcDgcqnweh8MBo9EIWZZVGY+I0odhgFSVxTWHppdBgeBaAr0BmM3mK+oIzIXJZILZbEYgEFBlPCJKH4YBUlWmPghVk8GBYCQaRXFxsapjFhUVIRKJqDomEamPYYBUJfRWQVKGBoICSUI4HFZ1zKGhIZhMJlXHJCL1MQyQ6oTeKkjKwEBQWmpBMBic0pUyVZFIBMFgEBaLRZXxiCh9GAZIdZn0AEyrDAsEa9daEY/H4XK5VBnP5XIhHo/DarWqMh4RpQ+vFpLqhL5ieC0Zcu1QURSUr7GgTKU6A3V1dejr64Pf78/qbpZE2YArA6Q6nhu4SoasEBgMBrzwYiN27do15+uAsiyjvb0dDQ0NDAJEGYArA5QWQnUxnIVUWyDPl1gshq847BhVqTeBx+NBbi6rnhPpHVcGKC34XvDa9L5qkpeXhzffciIUCqG2thbDw8Ozen2ya2EoFEJrayuDAFGGYBigtND7Q09Lev7eGADcf38Z3nm3Ax6PBzabbcZbBrIsw2azwePxoKOjY7J9MRHpH8MAkQb0GAgub2X81aoq/NHlRoEkwW63o66uDnv37p1y7TASiaCzsxN1dXWw2+2QJAlutxtVVVXz/wUQUcp4ZoDShucGpqeHMwTJUHKtc36xWAxvvNGCV3++HX19fTAajTCbzSgqKsLQ0BCCwSDi8ThKS0vR0NCALVu2IC8vb17nT0RzxzBAacMrhjOjZSC4fDXgRhRFgc/nwweyjL7eAKLRCEwmEywWC6xWK8rLy3lrgCiDMQxQWsUT2r/zzQgKkJjnTznTIHA1o4FVJomyDc8MUFrxoTFDhvn9x5hqEEj1dUSkbwwDlFZ8bszCpUCQ7u8ZH+hEdDWGASI9SWO1wuS4DAJEdDWGAUorPV6h0700BIJkCGAQIKJrYRigtOMDKAUqBgI1VwP4Z0mUnRgGKO34/EiRCoGA2wJENBMMA5R23CqYgzkEAgYBIpophgGaF3wozcEsA4EBQE6azgfwj5EoOzEM0LzgQ2SOZhgIuBpARKlgGCDKFNMEAgYBIkoVwwDNC54bUMl1AsF8BQGGDaLsxDBA84YPEpVcFgjms5AQ//iIsleu1hMgcfBhoiLDRMMggG2iiWjuGAZo3hgMgEHDdr3Z4lq3BRgIiGguuE1AlEGuFQRyDBO/0v65ubRDlLUYBmhe8YGSuhvVD5ivQEBE2YnbBDSv+LxKTY5h+oOCOTxDQEQp4soAzSteMZy95Lv+mayqcIWAiFLBMEDzjlsFM2PAxI2B2T7ccy67aaD2fIgoOzEM0LzjQ2V6c+0vYEhTICCi7MQwQKQzajUaYiAgopliGKB5x3MD15djAIw56m2lJAOBGsNxe4coezEMkCb4YJkqXYf/DIbPbyOkPIZqsyEiPWIYIE3w4fK5VA8KzupzqBAIiCh7MQyQJrhVMEGt8wEz+lwMBER0HSw6RJoxGABF4AI5MykkpDaDYeIdQGKaHhGKosDr9eIDWUZvbwAj0ShMJgkWiwVWqxUVFRUwcK+HKGsYFEXkH8ekJUUB4oL+7dO6OJCiXDsQxGIxvPFGC179+Xb09fXBaDTCbDajuLgY4XAYwWAQ8Xgcq1evRmNjI7Zs2YK8vDxNvgYiUg+3CYjmWbrPB8zEtbYM/H4/HA/b8d3/0gSLxYLOzk6Ew2H09vaiu7sbvb29CIfD6OzshMViQVNTE+x2O/x+v2ZfBxGpgysDpKl4QpyWxvN5PmCmkisEXV1d+OaT61BSUgKn04m1a9dO+1pZlrF582aEQiF0dHSgqqpqHmZMROnAMECaSihiNNbRYxBI2r/fj8pKOyorK7F7924UFhbO+LXDw8Oora2Fx+OB2+1GWVlZGmdKROnCMECaEuHcgBYHBWcqFovBbrdjZGQEPT09swoCScPDw7DZbJAkCW63m2cIiDIQzwyQprL9iuFsOg5qoaWlBT6fD06nM6UgAACFhYVobW2F1+tFS0uLyjMkovnAlQHSXDaeG9DztkCSoiiwWCywWCxoa2ub83h1dXXo6+uD3+/ntUOiDMOVAdJctj03MiEIAIDX60VfXx/q6+tVGa++vh69vb3w+XyqjEdE84dhgDSn82fmrGRKEAAmbgMYjUY4HA5VxnM4HDAajZBlWZXxiGj+MAyQ5rLl3IDezwdcLRAIwGw2Q5IkVcYzmUwwm80IBAKqjEdE84dhgHQhUx6g15NpQQAAotEoiouLVR2zqKgIkUhE1TGJKP3Ym4B0IYOeoVfIpG2Bq0mShHA4rOqYQ0NDMJlMqo5JROnHlQGiFGVyEAAAi8WCYDCIaDSqyniRSATBYBAWi0WV8Yho/jAMkC5k2rmBTNwWuJrVakU8HofL5VJlPJfLhXg8DqvVqsp4RDR/WGeAdCNTShNr3XFQLawzQERJXBkg3ciEx4ceOg6qxWAwoLGxEbt27ZrzdUBZltHe3o6GhgYGAaIMxJUB0hW9ViPM9PMB16N2bwKPx4PcXJ5LJso0XBkgXdHjwzZbgwAA5OXlwel0IhQKoba2FsPDw7N6fbJrYSgUQmtrK4MAUYZiGCBd0dvzNhsOCk6nrKwMHR0d8Hg8sNlsM94ykGUZNpsNHo8HHR0dbF9MlMEYBoiuQ4QgkFRVVQW32w1JkmC321FXV4e9e/dOuXYYiUTQ2dmJuro62O32ybbFVVVVGs2ciNTAMwOkO1qfG8jmbYHpxGIxtLS0YPv27ejr64PRaITZbEZRURGGhoYQDAYRj8dRWlqKhoYGbNmyBXl5eVpPm4jmiGGAdEfLK4YiB4HLKYoCn88HWZYRCAQQiURgMplgsVhgtVpRXl7OWwNEWYRhgHRHUYC4Bn8rGQSISFQ8M0C6o0U1QpHOBxARXY33gEh42VJRkIgoVVwZIF2aj3foBmRXRUEiolQxDJAupfv5zPMBRESfYxggXUrnuQEGASKiK/HMAOmWwTBxs0BNPB9ARDQVwwDpltrPbCNXA4iIrolhgLIetwWIiG6MZwZIt9Q4N8AgQEQ0Pa4MkG4pigKv14ueHhm9vQFEo1FIkoTSUgvWWq2oqKi4YUncnEthgkGAiOjGWI6YdOd6zXKKi4sRDocnm+WsXr0aLzQ04rnnpjbL4UFBIqKZ4zYB6Yrf74fdbkdTUxMsFgs6OzsRDofR29uL7u5u9Pb2IhwOo7OzExaLBd/9L01wPGyH3+8HwEJCRESp4MoA6UZXVxfWrVuHkpISOJ1OrF27dtrXyLKMzZs3IxQK4Z13O/DI16q4LUBENEsMA6QLyRWByspK7N69G4WFhTN+7fDwMGpra+HxeOB2u1FWVpbGmRIRZR+GAdJcLBaD3W7HyMgIenp6ZhUEkoaHh2Gz2SBJEtxu95QzBEREdH08M0Caa2lpgc/ng9PpTCkIAEBhYSFaW1vh9XrR0tKi8gyJiLIbVwZIU4qiwGKxwGKxoK2tbc7j1dXVoa+vD36//4bXDomI6HNcGSBNeb1e9PX1ob6+XpXx6uvr0dvbC5/Pp8p4REQiYBggTcmyDKPRCIfDocp4DocDRqMRsiyrMh4RkQgYBkhTgUAAZrMZkiSpMp7JZILZbEYgEFBlPCIiETAMkKai0SiKi4tVHbOoqAiRSETVMYmIshnDAGlKkiSEw2FVxxwaGoLJZFJ1TCKibMYwQJqyWCwIBoOIRqOqjBeJRBAMBmGxWFQZj4hIBAwDpCmr1Yp4PA6Xy6XKeC6XC/F4HFarVZXxiIhEwDoDpCnWGSAi0h5XBkhTBoMBjY2N2LVr15yvA8qyjPb2djQ0NDAIEBHNAlcGSHNq9ybweDzIzc1Nw0yJiLITVwZIc3l5eXA6nQiFQqitrcXw8PCsXp/sWhgKhdDa2sogQEQ0SwwDpAtlZWXo6OiAx+OBzWab8ZaBLMuw2WzweDzo6Ohg+2IiohQwDJBuVFVVwe12Q5Ik2O121NXVYe/evVOuHUYiEXR2dqKurg52u32ybXFVVZVGMyciymw8M0C6E4vF0NLSgu3bt6Ovrw9GoxFmsxlFRUUYGhpCMBhEPB5HaWkpGhoasGXLFuTl5Wk9bSKijMUwQLqlKAp8Ph9kWUYgEEAkEoHJZILFYoHVakV5eTlvDRARqYBhgIiISHA8M0BERCQ4hgEiIiLBMQwQEREJjmGAiIhIcAwDREREgmMYICIiEhzDABERkeAYBoiIiATHMEBERCQ4hgEiIiLBMQwQEREJjmGAiIhIcAwDREREgmMYICIiEhzDABERkeAYBoiIiATHMEBERCQ4hgEiIiLBMQwQEREJjmGAiIhIcAwDREREgmMYICIiEhzDABERkeAYBoiIiATHMEBERCQ4hgEiIiLBMQwQEREJjmGAiIhIcAwDREREgmMYICIiEhzDABERkeAYBoiIiATHMEBERCQ4hgEiIiLBMQwQEREJjmGAiIhIcAwDREREgmMYICIiEhzDABERkeAYBoiIiATHMEBERCQ4hgEiIiLBMQwQEREJjmGAiIhIcAwDREREgmMYICIiEhzDABERkeAYBoiIiATHMEBERCQ4hgEiIiLBMQwQEREJjmGAiIhIcAwDREREgmMYICIiEhzDABERkeAYBoiIiATHMEBERCQ4hgEiIiLBMQwQEREJjmGAiIhIcAwDREREgmMYICIiEhzDABERkeAYBoiIiATHMEBERCQ4hgEiIiLBMQwQEREJjmGAiIhIcAwDREREgmMYICIiEhzDABERkeAYBoiIiAT3/wNMkBtij1Sp0QAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -244,7 +256,10 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 8, @@ -253,7 +268,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -285,7 +300,10 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 9, @@ -294,7 +312,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -332,7 +350,10 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 10, @@ -341,7 +362,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -351,19 +372,17 @@ } ], "source": [ - "plt.figure(figsize=(10, 4))\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4))\n", "\n", "# Sequential colormap\n", "cmap = plt.cm.Paired\n", "\n", - "ax = plt.subplot(1, 2, 1)\n", - "xgi.draw(H, pos, ax=ax, edge_fc_cmap=cmap)\n", + "xgi.draw(H, pos, ax=ax1, edge_fc_cmap=cmap)\n", "\n", "# Qualitative colormap\n", "cmap = plt.cm.Purples\n", "\n", - "ax = plt.subplot(1, 2, 2)\n", - "xgi.draw(H, pos, ax=ax, edge_fc_cmap=cmap)" + "xgi.draw(H, pos, ax=ax2, edge_fc_cmap=cmap)" ] }, { @@ -383,7 +402,10 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 11, @@ -392,7 +414,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -459,7 +481,10 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 13, @@ -468,7 +493,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -533,7 +558,8 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (, None, None))" ] }, "execution_count": 16, @@ -542,7 +568,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -606,7 +632,10 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 19, @@ -615,7 +644,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -647,7 +676,10 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 20, @@ -656,7 +688,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -695,7 +727,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -727,9 +759,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "venv_xgi", "language": "python", - "name": "python3" + "name": "venv_xgi" }, "language_info": { "codemirror_mode": { @@ -741,7 +773,20 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.0" + "version": "3.9.13" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false } }, "nbformat": 4, diff --git a/xgi/drawing/draw.py b/xgi/drawing/draw.py index 2cb2dee5b..cc357ba3c 100644 --- a/xgi/drawing/draw.py +++ b/xgi/drawing/draw.py @@ -200,6 +200,8 @@ def draw( "max_dyad_lw": 10, "min_node_lw": 0, "max_node_lw": 5, + "edge_fc_cmap": cm.Blues, # for compatibility with simplices until update + "dyad_color_cmap": cm.Greys, # for compatibility with simplices until update } settings.update(kwargs) @@ -210,18 +212,20 @@ def draw( max_order = max_edge_order(H) if isinstance(H, SimplicialComplex): - draw_simplices( - H, - pos, - ax, - dyad_color, - dyad_lw, - edge_fc, - max_order, - settings, - hyperedge_labels, + ax = draw_simplices( + SC=H, + pos=pos, + ax=ax, + dyad_color=dyad_color, + dyad_lw=dyad_lw, + edge_fc=edge_fc, + max_order=max_order, + settings=settings, + hyperedge_labels=hyperedge_labels, **kwargs, ) + dyad_collection = None # for compatibility with simplices until update + edge_collection = None # for compatibility with simplices until update elif isinstance(H, Hypergraph): ax, (dyad_collection, edge_collection) = draw_hyperedges( From 349177de811a457b80b5ad248d7f5f4d839b8979 Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Mon, 28 Aug 2023 11:53:08 +0200 Subject: [PATCH 10/26] fix: notebooks and order of nodes in lshift --- tutorials/quickstart.ipynb | 98 ++++++++++++++++++++++---------------- xgi/core/hypergraph.py | 7 +-- 2 files changed, 62 insertions(+), 43 deletions(-) diff --git a/tutorials/quickstart.ipynb b/tutorials/quickstart.ipynb index b692197cd..a27e8f5d9 100644 --- a/tutorials/quickstart.ipynb +++ b/tutorials/quickstart.ipynb @@ -1,7 +1,6 @@ { "cells": [ { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -37,7 +36,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -52,7 +50,7 @@ { "data": { "text/plain": [ - "'0.7.2'" + "'0.7.3'" ] }, "execution_count": 2, @@ -146,9 +144,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "{1: {'a'}, 2: {1, 'a'}, 0: {1}, 3: {0, 1}, 4: {0}, 9: set(), 10: set()}\n", + "{1: {'a'}, 2: {'a', 1}, 0: {1}, 3: {0, 1}, 4: {0}, 9: set(), 10: set()}\n", "[{1, 2}, {3, 4}, {0, 2, 3}]\n", - "{1, 'a'}\n", + "{'a', 1}\n", "{1, 2}\n" ] } @@ -168,7 +166,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -185,7 +182,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -332,7 +328,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -340,7 +335,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -356,7 +350,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -374,7 +368,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -390,7 +383,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -405,7 +398,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -422,7 +414,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 14, @@ -431,7 +423,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -446,7 +438,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -462,7 +453,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -477,7 +468,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -549,7 +539,10 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 18, @@ -558,7 +551,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -572,7 +565,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -587,7 +579,10 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 19, @@ -596,7 +591,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -624,7 +619,10 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 20, @@ -633,7 +631,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAACdt0lEQVR4nOzdd3hU1dbA4d8500t6BZLQi1RpAioiFuwdsXe84lXxqhfrtWNXrJ+IXrhWVOyCWAAbVem9h/ReJslk+sz5/phkIKTNZCah7fd5fJTMmT07ATnr7L32WpKiKAqCIAiCIByz5EM9AUEQBEEQDi0RDAiCIAjCMU4EA4IgCIJwjBPBgCAIgiAc40QwIAiCIAjHOBEMCIIgCMIxTgQDgiAIgnCME8GAIAiCIBzjRDAgCIIgCMc4EQwIgiAIwjFOBAOCIAiCcIwTwYAgCIIgHONEMCAIgiAIxzgRDAiCIAjCMU4EA4IgCIJwjBPBgCAIgiAc40QwIAiCIAjHOBEMCIIgCMIxTgQDgiAIgnCME8GAIAiCIBzjRDAgCIIgCMc4EQwIgiAIwjFOBAOCIAiCcIwTwYAgCIIgHONEMCAIgiAIxzgRDAiCIAjCMU4EA4IgCIJwjBPBgCAIgiAc40QwIAiCIAjHOPWhnoBwZLBYLPz555+sXbuWnJwcfD4fSUlJDB06lLFjx5KRkXGopygIgiC0kaQoinKoJyEcvvbu3cvzzz/PJ598gt1uJzExkd69eyPLMgUFBezbtw9Jkjj77LN54IEHGDdu3KGesiAIghAisU0gNElRFN58800GDx7MwoULefjhh8nMzKSkpIQVK1awbNkyMjMzKSsr47///S9FRUWceuqpTJkyBavVeqinLwiCIIRArAwIjfh8Pm6//Xbeffdd7rjjDp5//nnMZnOr73nnnXe4//77GTBgAD///DOxsbEdM2FBEAQhLCIYEBr5z3/+w7PPPsucOXO48cYbQ3rvunXrOPPMMxk4cCC//vorKpWqfSYpCIIgRIzYJhAaWLlyJc899xzPPPNMyIEAwLBhw/j2229ZunQpM2bMiPwEBUEQhIgTKwNCgKIojBgxArVazYoVK8J6qr/vvvt4++23ycnJISkpKYKzFARBECJNrAwIAatWrWLdunU8+eSTYS/vP/zwwwDMmTMnElMTBEEQ2pEIBoSAuXPn0rVrVyZMmBD2WAkJCUycOJGPP/44AjMTBEEQ2pMIBoSA1atXM3bsWGQ5Mn8sxo0bx7Zt26itrY3IeIIgCEL7EMGAELBt2zYGDx4csfEGDx6Mz+dj165dERtTEARBiDwRDAgBdru91XoCoagfy263R2xMQRAEIfJEMCAEGI1GqqurIzZeTU1NYFxBEATh8CWCASFg4MCBbNy4MWLjbdiwAZVKRd++fSM2piAIghB5IhgQAkaOHMmff/6J1+uNyHi//fYbgwYNwmAwRGQ8QRAEoX2IYEAIuPbaa8nPz2fhwoVhj1VSUsLXX3/NddddF4GZCYIgCO1JVCAUGhgzZgx2u53Vq1ej0WjaPM4///lPPvzwQ3JycoiPj4/gDAVBEIRIEysDQgNvv/02W7du5amnnmrzGL/88gszZ87khRdeEIGAIAjCEUAEA0IDQ4cO5amnnmL69Om8+eabIb9/+fLlTJw4kbPPPpvbb7+9HWYoCIIgRJoIBoRGHnzwQf79738zdepUrr/+eiorK1t9j8fj4fnnn+e0007j+EED+OKLLyJWyVAQBEFoXyJnQGiSoih89NFH3H333ciyzM0338x1111H//79UavVgWuys7P59ttvefvtt9m7dy+3Xn4+99w0iYwRp2NISD3E34UgCIIQDBEMCC0qKChgxowZzJkzh8rKSnQ6Henp6ej1egoLCykvL0ej0TBx4kTuvvMOOrmK8Hm9yCoVKcPGo4sWOQOCIAiHOxEMCEGx2+388MMPXH755UiSxD//+U+Sk5MZNmwYo0ePJjExEYCqrG1U7t0CgEqjJXXE6WiMUYdy6oIgCEIrRDAgBO3vv/9m1KhRpKenk5OT0+Q1is9L/qqf8Nj9nQrVBhOpw09DrROFhwRBEA5XIsNLCFpeXh4AXbp0afYaSVYR3/v4wK899lpKNi7F53G19/QEQRCENhLBgBC0/Px8oOVgAMCY1AVDfHLg164aC6WbV6D4IlPmWBAEQYgsEQwIQasPBtLS0lq9Nq738UjS/l/bK0oo2/Y3YldKEATh8COCASFowWwT1NOaYzF36dXga7XFuVTu3tAeUxMEQRDCIIIBIWjBbhPUi+0xEFmjbfC16tzdVGXviPjcBEEQhLYTwYAQtFC2CcB/tDCux8BGX6/cswlrYVYkpyYIgiCEQQQDQlAURQlpm6CeuXMPtOaYRl8v37Eae3lhxOYnCIIgtJ0IBoSgWCwW7HY7AJ07dw76fZIsE99naKOvKz6F0s0rcFaVR2yOgiAIQtuIYEAISv0WQUJCAgZDaAWE9HHJGJMbryb4vF5KNi7FbauJyBwFQRCEthHBgBCUtmwRHCi+1/FITXQx9LpdFG/4E4/THtb8BEEQhLYTwYAQlFBPEhxMbTAR07Vfk6+JKoWCIAiHlggGhKCEepKgKdFd+zXbo8BVY6Fk03JRpVAQBOEQEMGAEJRwtwkAZJWa2F6Dm33dUVlK2da/RJVCQRCEDiaCASEokVgZADCndkUfm9js67UleaJKoSAIQgcTwYAQlEisDNSL6934qOGBqnN3U5W1PezPEQRBEIIjggEhKOEmEB5IFx1HVOfuLV5TuXcz1sJ9YX+WIAiC0DoRDAitcjgclJf7iwOFu01QL7bnIGS1psVryreLKoWCIAgdQQQDQqvqVwUMBgOxsbERGVOl1RPTvX+L1ygKokqhIAhCBxDBgNCqA7cIJEmK2LjRab3RmKJavEZUKRQEQWh/IhgQWhWpkwQHk2SZ+N7Ht3qdqFIoCILQvkQwILQqkicJDmZI6IQxsVOr14kqhYIgCO1HBANCqyJ5kqApcb2PR5Jb334QVQoFQRDahwgGhFa11zZBPY0xiqi03kFdK6oUCoIgRJ4IBoRWtec2Qb3Y7v1RaXVBXSuqFAqCIESWCAaEVrX3NgGArNYS17P5vgUHE1UKBUEQIkcEA0KLvF4vhYX+wj/ttU1Qz9SpG9qo2KCvF1UKBUEQIkMEA0KLSkpK8Hg8yLJMSkpKu36WJEnE9x0W0nvKt6/GVlbQTjMSBEE4NohgQGhR/RZBp06dUKvV7f55+phETKkZQV+vKFC2ZaWoUigIghAGEQwILeqI5MGDxfUcjKxSBX19oEphbXU7zkoQBOHoJYIBoUUdkTx4MLXeSEy340J6j6hSKAiC0HYiGBBa1N41BpoTld4HtcEU0ns8DhslG/4UVQoFQRBCJIIBoUWHYpsAQFapies1JOT3uaxVlGwUVQoFQRBC0f4ZYcIR7VBsE9QzJadRE5eEvaKEVRu3suD3lWzevY892fk4nE5MRgN9u6UzpG9PLj3zFAb07g6Aw+KvUpg4cExEuywKgiAcrUQwILToUG0T1NtUZOXOO6axOyuXXj17cvLYsdz4j0GYTCaqqqrYsGEDP/3+O3O+XsjIQcfx1F03069HBrUleci71pMQ4lFFQRCEY5EIBoRmKYpyyLYJvF4v9913H6+//jqnnDKWWXM+4NRTT23ySd/j8bBgwQL+88gjXPjPh3hg8tXcMvE8avL2oNbpienWv0PnLgiCcKSRFNHxRWhGVVUVsbGxANTW1mI0Gjvkc71eL9dffz2ff/45M2bM4M4770SWW09vcTqd/Oc//+Hll1/m7usm8q8bLgcg8biRmDt3b+9pC4IgHLHEyoDQrPotgri4uA4LBABeeOEFPvvsMz7//HMmTpwY9Pt0Oh0vvfQSiYmJPPjgg/Tpns65p4ymfMdqZK0OY2Lndpy1IAjCkUucJhCadSi2CLZu3coTTzzB/fffH1IgcKD777+fSy+5hMfenEO5pTpQpdBRVRbh2QqCIBwdRDAgNOtQnCR4+umnycjI4IknnmjzGJIk8fbMmThdHj787iegvkrhMlGlUBAEoQkiGBCa1dEnCYqLi/nqq6+488470el0YY2VkpLCdddfz2cLf8Xt8QDgq69S6LBFYrqCIAhHDREMCM3q6G2CJUuW4PF4uOaaayIy3rXXXktJeSU7MnMCX/M4bJRsXCqqFAqCIBxABANCszp6ZWDt2rV0796dpKSkiIw3dOhQVCoVm3dlNvi6qFIoCILQkAgGhGZ19MpATk4OvXr1ith4BoOBtC6dyS9pnDjosJRSunUV4mStIAiCCAaEFnR0AqHP5wuqnkAoJFlG8fmafM1Wkk/FznUR/TxBEIQjkQgGhCY5nU5KS0uBjtsmSEpKoqCgIGLjeTweiotLSIiNafaamvy9WPZtjdhnCoIgHIlEMCA0qf6mrNPpiI+P75DPHDZsGNu2bcNmi0y2/44dO7Db7YEGRs2xZG6lJj+zxWsEQRCOZiIYEJp04BZBR3X+O+WUU/B6vcyfPz8i433zzTcY9DoG9Gh9ZaNi5xpspfkR+VxBEIQjjQgGhCYdim6F/fr145RTTuHNN98MO7HP6XTyzsyZnDWsD678XVTn7MRhKcXncTd5vaJAqahSKAjCMUoEA0KTDlW3wgcffJDly5fz4YcfhjXOU089RUlJCZcMTsNVY8FlraK2KJvKvZuozt2Ns6oMn9fT4D2KzyeqFAqCcEwSwYDQpENRithls9JXKuPcEwZw99S72Lq1bYl9ixYt4oUXXuCGk4+jW2IU7toqbKX5uGoqUbwe3LVVWAuzsOzZSE3eHpzVFYGaA6JKoSAIxyIRDAhN6uhtgtKtq9g+9yUq925m2sTTSIkxctr4U/nrr79CGufbb7/lwgsuYGSPFK4+sd/+FxQf7tpqf1BQXYHi9aAoCi6rBWtBJpV7NlJTkImrphK3zUrJxqV43aJKoSAIxwYRDAhN6qhtAoellF3fzCTn96/xOO0ARBn1vH3HRFKidJx00kk89NBDVFZWtjhOfn4+N910E5dccgnjRg7m+RvORq1q4o+3ouC21WAry8dVXY6vrm+B4vPhqq6gJn8vlXs2UrF7A3nL5jebYyAIgnA0kRRRgk1oQrdu3cjOzmbFihWMGTMm4uP7PB6K1v1K8brfG+3d1/N4vXyw6G/++9Mq1Bo1l18+ibFjxzJ48GCMRiNVVVWsX7+eX5cs4fv58zGbjDzyj2uYeNapKB4Xxet/x22ztjwRCdR6ExpTDLJa0+hlfVwSKUNPxZzaFV1sUoedrBAEQehIIhgQGvH5fOj1etxuNzk5OaSnp0d0/JqCfeT8/iWOytKgrq+0uflpeyHzf1/Jnuw8fAdUFNSo1fTv1Y1LzzyFG2+dglxVFFhh8DrtFK3/HW+Q+/9qvQmNuXFQoI9NwpTaFZVOjyk5HWNKOvqYxCC/W0EQhMOfCAaERoqLi0lNTUWSJJxOJxpN4yfmtvC4HOQtm0/FjtWE8qfOlJyOPj4FAJvdwb68QlxuNwa9nu5pndBp/fNT6wzEdDuO8gNKDHvsNRSv/xOvyxH056n0RrSmaGTN/jbKxsTOGBI7B36t1hsxpaRjTM5AFx0X/DcjCIJwGBLBgNDIunXrGD58OJ06dYpYeeDKPRvJXTY/5GN7kiwT12swkqwO6vr4fsOx5u3BZa0KfM1lraRkw9KQ9/9VOgNac0wgKKjfKjiYxmjGlJKBMTkdrbn50seCIAiHq+D+hhWOKZFMHnRZLeT88TVVWTva9H59TGLQgQBATfYOYnsNoXTzisDXtOY4kgadSMnGZSG1LfY67diddlRaPRpzDLXF2UhqNVpzw5UAt82KZd82LPu2oTXHBFYMNEZz0J8lCIJwKIlgQGjA6/WSlZUFhB8MFG9YSuHqX/C6nG0eQxeXHNL1bnstiteDPi6pQU6CLiaRxAGjKN2yCpSmuxg2x+ty4K1wIGt0eJwO4nsPQW2IavJal7UKl7WKyr1b0EXHYUzJwJScjlpvDOkzBUEQOpLYJjjGeb1efvjhBz7//HPWrFnD7t27URQFSZJITk7m4osv5oYbbmD06NFBZ9LbygrJ/u0LbCV5Yc1NGxVLVJdeIb9PY4oi4bgTKFqzpPHcinMo27EawvhTr9IZiO87DEN8atDv0ccmYkxJx5Scjkqrb/uHC4IgtAMRDBzDvvvuO+6++26ys7M5/vjjGTt2LAMHDsRgMFBVVcWGDRtYsmQJWVlZjBgxglmzZjFs2LBmx/N5POSv+pHSzStCWo5vTkxGH9TG6Da9N2nQidhKcqktzm30Wk3+Xip3bwhrbrKswtS5O6bkdLTRcUBwgZIkgT4uGWNyBsbkNFQabVjzEARBiAQRDByDnE4nU6ZM4f333+e8887jiSeeYMSIEU1e6/P5+Pnnn3n44YfZvHkz06dP54EHHmi0SlCVu4vc37/GWV0RkTmq9UZiuvVv8/u1UbEkDTyRgr9+RPE1/iNelb2dqn3bwpkislqDIT4VlcGIIT4VXXQ8SMHX8ZJkCUN8KsbkdIxJXZqscyAIgtARRDBwjHG73Vx66aUsWrSIWbNmcf311we1/O92u3nyySd55plneOihh3j22WcB8Dhqyf3zOyrCfNI+mLlTN3RhnuVPHnIyjopiqnN3N/l6ZV1vgnCotDr0cckgyag0OgwJqehiEkIKCsB/asKQ2AlTcgaGxE7IKpHOIwhCxxHBwDHmwQcfZMaMGcyfP5+zzjor5PfPmDGD++67j3nz5nHaoB7kLZ8f8aY+slpNXM/BId9QD6aLSSB58Mnkr/ih2SqH5TtWU1uUE9bnqPQG9DFJ/j0AQKXRoo9PQR+b1KbvQVapMSR1xpScjiEhFUlWhTU/QRCE1ohg4BiyevVqRo8ezfTp03nooYfaPM7ll1/Or4t+5vMHrycuKvJZ8gcX+AlH6rBTcVaVUbl3S5OvK4qPsq1/YS8Lr56CxmhGG53Q4GuyWhMICtp6Q5fVGozJXTAlZ6CPS0aSRTsRQRAiTwQDx5ALL7yQffv2sX79etTqti9Dl5SU0KN7d64edzy3nXdSBGcIkiT5iwypIrN/bohPJmnwyeSvXIjX2XQVQsXnpXTz8qDLIzdHa45BY45t9HVZpfYHBXFJIdVMOJhKo8WYnI4pJV30SRAEIaLEY8YxIjs7mwULFjB16tSwAgGA5ORkrrv+er5duQWPN7Qz+63RxsRHLBAAsFeU4LZWEdt9YLPXSLKKpEEnoo0Kr6ywy1qFx1bT6Os+rwdbaT6VezZjLytAaWbLojVet4ua/L0Urfud/OULqNi1HmdVeVhzFgRBABEMHDOWLPGfub/iiisiMt7VV19NqaWazMKyiIxXzxCXEtHxAKqytmHu1A2tqfljipKsJnnwyWhMTRcTCpazpgKvs+kcCsXnxVZWQOXeTdhK81C8bW+P7HHaqc7dTeGaJeSt+IHKPZtw1bTc5lkQBKE5Ihg4Rqxdu5Z+/foRHd22c/sHGzp0KJIksT23OCLjAWiMUah0kc9BsJUV4q6tIrbnoBavkzVakgePRRVOtUAFHJZSfO7mGyMpPh/28iIq927GVpyDz+1q++cBHnstVdk7KPh7EfmrfsSSuTXkHhCCIBzbRDBwjMjLy6Nnz54RG89sNpOSnERxZeRuOvr40EoPh6IqazvGpC7oY1s+rqjSGUgZMja8KoEK2CtKW22MpPh82CtLsGRuprYoG5+77WWb67lra7Ds20r+qp8o+PsXqrK247HXhj2uIAhHNxEMHCPqSwxHkizLRCr/VKXRoW0i+S5SakvycNdWE9drSKvXqg1mkgafHF4RIMWHs6I4qPwAm8NJSUEuJTs3YC3aF1K75Za4aixU7t1M3oofKFy9mOqcXRE/BioIwtFBVDY5RiQnJ7N27dqIjed0OiktKyNK1RVndQWSrEJWqZFUKiRZhaRShxR8+FcF2jc7vip7B4n9T8CUnEZtK30TtOYYf6fDTctQvG0rrezzeXFUlvh7GBxwJNDt8fLrhl0sWr+T7bklFFf42y1LkkS31EQGZCRzyfgxnHLySRFrcOSsrsBZXUHF7g3oY5PqOiumo9LqIjK+IAhHNhEMHCOGDRvGBx98gMPhQK8Pv1HO5s2bcbs99E4yN5lBD/6qepJKHQgOZJUKSa4PGOr+LUlIsirsaoPBqC3KIrb7AGJ7DsJWlt9kmeID+TsdjqZsy0oUX+NTE1aHiy155ewqrKS0xg4oxJv09OkUx8C0RGKMOnweNw5LCfq4ZBQkflqznde+/YPyKitjxozmhsmXBPpBWCwWNmzYwKJffuGW5/9L77T5PHbTxYweNQq13hSxn0NFYS7Lli2luLwStTGarn36M/rU04mNb//fA0EQDk8iGDhGnHrqqXg8HubPn8/ll18e9nhffvklZoOOnimxzV6j+HwovpaT4/yBQALWgn3IGi2yWous0dT9W4us1iCFWYkwMB/FvzqQ0G845s49gypFbIhPJeG4EZRtW+0fAMgtr+HTlTtYsi0Ph8tNTHQ03bt1RZJklm/NoXzpNjRqFaf2S+OqMX3pmRKLpaSI5xasYcn6nUy6/HIef+IJ+vdvuveCoij8/vvv3D9tGjc88y6Tz97MHZefgzGxM2qDuU3fu8vtYeGfK/lk/mLWbduFr4ngZujA45h8803cMPk2TFGRSTQVBOHIIIoOHUNOOeUUFEXhzz//DCt/oLa2lq4ZGZzWK4E7JwwNb1ISGBO7ILVQi19WNwwOAkFD4L+DDxgkWaLLmPOQZJn8FQubLVN8MGtBJmU71/HFX7uY/cdWEhITuf2fd3DllVfSs2fPwM9TURRycnL48ssv+b+33iQ3N5crRvVhe2ElO4qq+eDDD5k4cWJQn+nxeHj22Wd5/PHHue70kUy9eBw6czSGhE4hdXPcsGMP016ayZ7sPE4/7TSuvOoqRowYQffu3ZEkiZycHNasWcO8efP46aefSO+UwutPP8KZ51+MISFV9EkQhGOACAaOIT/99BPnnHMO//vf/7jxxhvbPM5dd93Ff9+dxfu3nkmnuLY9qdZT6Q3oY8M/RdAwYGi8unBgwBCd3pv4PkOx7NuKJXNrUON7vT7ufuJ5Fq7axL/+9S+mT5+O0djyfr7L5eLZZ59l+vTpSJLEwoULOfPMM0P+3t58802mTp3K9BvP5+wRxwH+8seGhE5oTDEtvnfugsU8+sZshg0dyuw5cxg8eHCL1+/cuZN/3Horfy5dygO3Xs0/r74MY1IXjCnpGOJTRTlkQThKiWDgGHPDDTfw7bffsnTp0lZvDE35+uuvueyyy7j73JFcOqx72PMxJKQga8LPYQhG/WqCWqcnZdh41AYTZdv+RlEUVGotklrT7IrJ42/O4ZMFi5k7dy6TJk0K6XMXLVrEBRdcwMUXX8ynn37aplWZKyZN4ucff+CLR24kPmp//oBab8KQmIrW3Lh64pc//860l2Zy55138uqrrwZdedLn8/H4448zffp0Hr39em6+7DzAX4fBlNQFU2pXUQ5ZEI4yIhg4xlRXVzN+/HhycnL45ptvOPnkk4N6n6IofPDBB9x6662cOXIQT1x5Gl57DW6rpc1zkTVaDAmd2vz+cBgSOmFM6oLTUoq1KHv/nJrYjlixZTeTn3qTt956izvuuKNNn/fFF18wadIkPvnkE66++uqQ319aWkqP7t256pQhTfaDUOuNGOJT0UbHARL78go5d8oDXHPNtbz33nttunFPmzaNV199lW/fms7A3j0avKbS6vb3SYhJFIGBIBzhRDBwDKqoqODiiy9m2bJl/Otf/+LBBx8kObn5pfrdu3dz/7RpfPvdd0w6ezzT/zUZT3U5tpJcvC4nzqqyNtXb18UmRjRLPhSSrCKu1yAkScaSta3ZJkZen4+J0/9H74FDWLx4SVg3vauuuorFixeTk5ODwWAI+f233347X302l/lP3opa1fRyvUqnxxCfyo1Pv01ptZ1Nmze3up3RHJfLxQkjR+K21bBg5nPNfu9qvRFjchqmlK7oosPr7yAIwqEhgoFjlNfr5dVXX+Wxxx7D4/Fw8cUXc/LJJzNo0CCMRiOVlZVs2LCBxYsXs2TJEpLi43jqrps4e+yowBjOqjKshVkoPh/O6nK8IRS0kWQVxqQucAifKOtbJbusldTk7W3ymmVbM/nXzK9YtWoVo0aNavKaYO3du5devXq1OWfjzz//ZNy4cXz60A307tJ88LY9p4jrXvyIr7/+mksuuSSMGcPvv//O+PHj+eSlRzlxaPPNnuppDCaMKRmYUtLbtYiUIAiRJYKBY1xFRQXvv/8+n332GRs3bsTl2n8U0GwyMrhPDy6bMI7zxo1Gp9U2er+rxoK1YC+KouC21fib5QTxR0obFYPGFBvJbyVkskpNbM9BSLKK6pwduG3WRtc88r8FFDhVbNy0KSJL4RMmTEBRFBYtWhTye61WK9HR0Tx69VlcOKb5PgsvfL6IFXtLyMrODrtDpaIoDBwwgJ6pcbzxyN0hvVdrisaYko4pJQONMbwGUIIgtC9xZugYFx8fz7333su9996Ly+Viz85t5KxajMmgp0tKInIr2ePaqFii0vtQk7fH32hIq8NpKWu5Lr8EGsOhvzn4vB4cllIM8akYk9Koyt7R6JrteSVccuW1EdsTHzduHC+//HKbykObzWYSE+IpKq/E63Yi1xVuOtimrCLOOff8sAMB8FdFPO/885n70Qchv9dVW40r039iQxsVi6luxeBQbQ0JgtA8EQwIAVqtlt49emAsyQjpfRpjFNEZfanJ2w2APiEVV00lniaetAE0BjPIjW9ih4KjohhDXDJqgxltVCyuGkvgNZfbQ05xOUOGtN7PIFhDhgzBYrGQn59PWlpa6ANIEtsyc/lqiRdZkpCQ/JUdVTIqWYVXkdiTX8Ldw4ZFbM7Dhw/npZdewlJtJTa6jUWPaiz+Xgl7NqGLSQiUQ1brQs+dEAQh8kQwIDQQbBGeg6n1Rn9AkLsbr9uJLjoBldaAs6oclIbV7kIpmNPefB43TksZurhkjEldcFstgV0Ol8ffkyAqKnKrGPVj2WyhNwyy2WyUl1ewrNTHsl0FLV7bUkJoqOrHqrK2PRg4kLOqHGdVOZW7N6CLTcKU0hVjUhfRJ0EQDiERDAgNtOVUQD2VVk90175U5+7G67Sj1huRNVr/tkFde16VTh9eN8B2YK8oQhebiEprQBeThMNSCoBW7V+9qKlpuvdCW1it/tWStmT4b9y4EZ/Px6D0RMw6DQrgUxRQ/P9WAI/Xy8acMtzultsnh6J+LFUTWxLhUBRwVJbiqCylYtda9HEp/hWDpC7I6sb5KYIgtB8RDAgNtHVloJ6s1tZtGezBY7ciq9To41NwW6tw11YdlolkXrcLZ3UFuphEDImdcFaXo/h8aDVq0pMT2LRpU8Q+a+PGjcTExNClS5eQ3/vFF18QYzLw6rXj0DRzY1YUhYtfX8COHY3zH9pq+/bt6LQaUhLa79ig4lOwlxdhLy9CktdiSOiEKSUDQ2InUQ5ZEDqA+L9MaCCclYF6skpNdHpvrAWZuKxVSJKENioWjTkalUaLzxP+Z0SavbwQXUwCslqLIT4VW5l/Gf649CR++/XXiH3OH3/8wYgRI0JOHqyqqmLO7NmcN6Rrs4EA+BP++qTEsnLlynCnGrBq1SqO69kNTQQSEoOh+HzYSvOxleYjq1QYEjv7A4OEVKTDJNdEEI42otC40IDi9UZkHElWYe7SE11MQuBrUandiOk2oNV6+oeC1+XEVV0JgD4+BbnuxnfOiP5s3LSJ1atXh/0Ze/fuZdGiRVxzzTUhv/fee+/F43JwyYherV57Up9OLF68mLy8vLZMs4HKykq+/fZbTh8duYTEUPi8XmqLcynZtJzcpd9Ttu1v7OVFTbaUFgSh7UQwIDTg80Zur1mSZEyp3dDHpSDJKrQxCchqDVFpvTAmpx3SgkNNsZcXAoq/IFJCZwBOHNCdtKR4Hn74IcItyfHYY48RHx/PFVdcEdL7PvroI+bMmcPtpw0iObr1XIMJA7ui16h56aWX2jrVgDfeeAOvx80FI/vidTVdpbGj+DxurIVZFG/4k7xl31O+Yw2OypKwf18EQRDBgHCQSK0M1JMkCVNKOkkDRweWeCVJwhCfSkxGP1SawyeD3OO046rrteBPKNShkmUeuPw0Fi9ewjvvvNPmsb/66ivmzp3LrbfeGnTyoKIo/N///R833ngj5x7fnfOH9mj9TYBRp+HGUwfx5ptvsmLFijbPefPmzTzzzHSuPW0EZp8dS+YWavL24LZFLqGyrbxuFzX5mRSt+5285fOp2LXef3JFEIQ2ERUIhQYq926mKmt7RMeUJOhy4nnYy4up2LmmQYFCn9eDrTgHZ3VFRD+zrdR6EzHd/G2CXTWV1OTvxed28twnP/L9+kw+//xzLrvsspDGXLJkCRecfx56FVTWOpkyZQqPPPJIi3UGNm7cyL/vu4/FS5ZwyfDu3HXWcFRBtA+WZBltVBySzsitr31OSa2bP5cupXfv3iHNOS8vj7Enn4zaY+fDf1+DVtMwX0CtN6GPT/Z/lnT4PFOo9UZMKRkYk9NFnwRBCIEIBoQGKnatpzp3d0THNCWnkTToRABqS/Io27oSxdfwj52zqoza4pzDYi84Or13IK+hbOsqbGX5eLw+nv3+b37dmsu9997L008/3WqzIbfbzfPPP8/TTz3F8WmxPHrOAH7aVsj7q/bh9Hg55+xzOHnsWAYNGoTBYMBisbB+/XoW/fILq/76i5QYE1PH9WZktwS0pmgkVctHMtVGEzpzXKCgU0VNLbe9MY9aD/zv/Q8499xzg/r+f//9d6677lp8jlrenXoFqfHN14WQ1Vr0ccnoYhMPu6x/jdFcV/UwA43p8KltIQiHIxEMCA2Ub19NTcG+iI6ZOuI09DGJgV87Kkso2bis0TFGr9OOtWAfHmfoBXkiSWOMIiqtJ9bCLOzlRTgqiv3z8/mY99cu5vy5jeTkZG7/5x1cddVVdOvWLXA6QFEU8vPz+eKLL/i/t94kKyuLy4d04boxvdGoZVCguqaaX3eXMn9bKQXVDrwHbM3EmfT0TY7izONSGdM9MdCdUJIkNKaYJrPpZbUGXXQ8slbf6LXKGhuPfbSQldv2ccWkSfzrnnsYNWpUk6cZ1q9fzxtvvMH777/P0F7pTL/hPFLigjsKKskyuphE9HHJqJqYx6GmNccEVgw0xvALJwnC0UYEA0IDpVtWUlucG7HxdNHxdBp5RqOvO6srKNnwJ163q8HX/cfK8nBUlkRsDqHyeVzIKk0gwdFRWYLXaQ+8nlNezacrdrJkWy5Ot4f4uFi6deuGLEnsy86mvLwClSwztmcilw1MoWeiCUmlQqXV4/O48dV9z//7O4cvNhZwQkYMf+dUEaNX8+n1I1Fp9EhNtCiWZBVaU8z+xEsJtKYY/ypGC8mYiqLw/aotzP75LwrKKumakc7IkSfQo2dPJEkiOzuL1X//zd7MfaQmJXDdqUO5fOzxyHLbEjy1UXHo41P8ZacPQ7roOH9nxeR01Pq2tXcOxa5du/j0009ZvXo1W7duxWazYTAYGDBgACNHjuTqq6+mT58+7T4PQWiJCAaEBko2LsVWVhix8ZIGjsaU0nSvA3dtNcUb/sTTROtjV00l1qLsiNQ9CIXHbsVZXY5Ka0Af5y/D6/O4sZc1Lv9b43CxJbeMnYWVlFsdeFxOahxOlu4pJS3WyJzrxuB12lHqyjHLai2K1xXImXjql52syq7k6qFdmLs+H4NG5qsbTwDwBw9qLRyUJyCrtWiMZlRaA9ro+JCqOXp9PlZtz+LvndnsyCuhtKoWBUgwG+mXnsTY0aOYMH4sztK8QBXGcPjzClLQRsUeVnkFB9LHJvo7KyanR3xFY+fOndx99938/PPPxMTEMGbMGIYMGUJUVBQ1NTVs3LiRVatWYbFYmDBhAq+//jr9+vWL6BwEIViH1yafcMiFW4HwQGqdAWNS80lyGlM0qcNPo3jDH7hrG2aoa6PiiNWbsBbu65jsdcWHs6YCj60W8G9Z+NxOZI0OWa1BYzQ3anEcpdcypndnxvTujKxS4ay2UGm1snRPKXkWGxa7i2itGqVuJcDrsoMkBW6MOZX+1Yau8f7cA4fbF+hmqHi9eLx2ZLXGf8Ov34bwupE1OvTxKSF/iypZ5qQBPThpQNOnEnQxiahVKqSEVBxVZUG1om6Jx1GLtSATWVOXVxBz+OUVOCxlOCxlVO5ajz4uGWNyBsbkNFSa8Mohv/XWW0ybNo309HQ+/PBDLr/8cvT6xsGGw+Hgiy++YPr06Rx//PG8+OKLTJ06NazPFoS2ODzDdeGQieSTeFRaL6RWMuDVeiOpw05DFx3f6DVZoyUqvQ+GxM4Rm1NTfB439oriQCBQz2WtCvy3xtzyUjxIIEGMQUu3BH+L3s0FFmSVJvA2xetB8XhQUHB5fBTV+M/td6+7XgHc3oY3YJ/H7Q9MPG7/qoA5Fp/bhdfRcK6R4K6tQlEUVBpdgxyPcPncLmwleVj2bqa2OBevyxmxsSNFUcBeUUL5jjXkLfuOko1LsRZmtdyKuxlPPPEEd911F7feeisbNmzguuuuazIQANDr9Vx33XVs2LCBKVOmcPfdd/PYY4+F++0IQshEMCA0EKmVAVnlr0AYDJVWR8rQcRiaeNqVJAljYmeiM/q2S/Mar8OGvbwosI/f4LW6mzCAJKvRtNRt8YA4YXAX/5G2TfmV/hhBpT2gfoOC4vWQV2XHp4BZpyLVvL/WgsPTVJ0H/2qC4vMGSjk7qvY3f4oUn8eNt27LRp+QGvGiUIrPi6OyGEvmZmry9+KxN93i+lBTfAq2skLKtv1N7tLvKNm8nNri3KD+3/jss8948sknee6553jjjTeCrilhMBh47bXXeOGFF3j66aeZO3duuN+GIIREBANCA5EqOmRK7RbSUqus1pA8ZCymlPQmX9cYo4jpdhxac2xE5oei4Kqu8O+NK80fZ3QfuDpgim5hpWP/jXNwF/8cN+VZAH9gpPgO+Ln6fORU+J/s02MNqFUy6rpkPaen4VxktQaVzoBUN4bHXoOrthqfx4OjshTFF9mcivqiS5FeHWj0OTWVVGXvoCp7B87qisO2iqDi82Eryad0y0ryln5P6dZV2MoKmjwCW1xczB133MEVV1zBgw8+2KbPu//++7nqqqu48847KSoqCnf6ghA0EQwIDURqZSA6PbQiN+A/npY4YDRRzawo1JcyNiWnh/XUqng92CuKgspF8DhqD1gdkNG0EIzUT2lQ3crAvnIr1XY3Pq+nURCRW+l/As+I9T856tX+1x11wYAkq1DrDMgabYNVB//83bhrq3Bbq7CXFbUYzISqPhiA9lkdOJjHbsVakIklcwuOiuKGQdNhxuf1UFuUQ8nGZeQu/Y6y7Q37JLz88sv4fD7eeuutsD7njTfeAODFF18Me86CECwRDAgNRCJnwJCQ2uYiL5IkkdBvOLHd+zd7jT4+hZiux7Up+9vrtGMvL2xyW6A57trqwH9rDOYGSXA+RSG3vIZVewpYsaeETfmVaFQSGXH+m/zmfAs+j7tRfYAciz9fID3O/z3oNP7XHR4vskaHSqdvdJKg0fficeKwlGItyolYQOB12vHWbT+09+rAgXxuJ7UluVTu2URtSW5gDocrn8eNtWB/n4T8jSuYM3s2t9xyC4mJ4f3MEhMTmTx5Mu+//z4226GtuSEcOw6v1F7hkFJ8vohUAIxOD//MdGyPgcgaLRW7NjT5ulpvJKbbcdQW5wRZk17Bba1qkBQYLI/DisYc4w8CJAlNVCzrtuzk27V7WLG7CKuj8Y0rxuS/ya/JKmFUl27+J2xZBXVPvrlVdcFAlAYFJbAy4JG0gY6JwVFw1VRQ7XFhSOjkP9sf5tO821qFqu5YpT5CJwuCpfi8OCqKcVQUo42OxxCXgtpg6pDPbiuv28XSRT9RUVnJ9ddfH5Exb7jhBl566SVWrlzJ6aefHpExBaElYmVACIjE/rPGFIUhITUCs/EHFYkDRiE1U/xGklWYO3XH3Ll7y33ufV4clSVtCgQAUMBTtzpQUVPLI58s4Z/vL2FXtcK/H3yIX375hdzcXIqLi9m6dSsfffQR51xwMWq1ml92lbJ4V6n/yGDdHD0+hYJqfwCRHqMHnw99Xe1/h6dtwZjHbsVRUYS9vBBvmBUcD9wq6MjVgUbzqK6gKns7Vdk7cNVUHrZ5BQCbd2ViMhkZMGBARMY77rjjMJvNrF27NiLjCUJrxMqAEFCfqR6OSKwKHMic2hWVRkvp5hX4mklu1EUnoNabsBZkNipg5HM7cVaW4gtzL9ptr2FvpYO7Z32HrNEyd+5crrjiCuSDlvKTk5Pp378/1157La+99hr33nsvM+bOZX1+FfeM64EsyxRabHh8Cga1THKUHklWodfU5wy0fZ5umxVJlnFUulFp9Wij4vw5ByGPU4PP6wlshxgSOnXo6sDBPHYrNflWf2BS1wehxeDvEMgrKqFXr16oVJGZlyzL9O7dm8zMzIiMJwitESsDQkC4yVuyRosptWuEZrOfIaETyUPHtVhtT6XVE921X4NiPO7aauwVRWEHAgCZxVX88/++omeffmzZuo2rrrqqUSBwsJSUFD755BPmzp3LsiwLM/7IBOTAFkFarCHwPelUdacJ3OHMVcFdawXFh9flwF5eiLOqPPQ8EEVpkCcha7ToY5PCmFdkeA/IK7CV5oWU99EeJFlGpdWhMZhQVBo0IVSDDIZarW7Qt0IQ2pNYGRACwl0ZiOrco90qzOljEkkdPp7iDX/idTqavEaS5EC9+fIda/DYInOO3e31Mv37v8no1oNFixcTExMT0vuvuuoqVCoVV1xxBYM7RWOx+U8nZMTt73qoq+tF4AgrGABF8eK2WdEYo0CS8NiteBy1aIzRaM3REGRZYLe1qkEhKEN8at0xzEO/VK/4vNjLi7BXFKOr64Og1gefVyCrVEh1lR1llRpZrUFSaQLVHv2/Vjf49/5rtftfOyAYTO+3jD/WfBzR77O4uJiEhISIjikIzRHBgBAQTs6AJEtEpfWK4Gwa05pj6TT8dIrX/47b3nQFPq/Thr2sAI0pBp/Hg8/VdOAQik9X7CS7rJo1P/0WciBQb9KkSfz000/8d+7HDO3sHyM9dn8woK87TWB3hf+06/O68ThrUevrGgUpCu7aKjx2fyJkMEmGrtoqFMUXKJ1cvzpwKBtISbIKWZaRVCqQVMgqFSgKDksJuugEojr3RJ/YCZXan4QpqzX+m/4BN3RJVrdaFbMthg4dyvPPP09JSQnJyclhj1dWVkZOTg5Dhw6NwOwEoXUiGBACwjlWaOygDnBqg4nUEadTvOFPXDWWBq85q8qoLcpGURRklRp9XDLu2mrcVkuTYwXD5fHy9dpMpky5nSFDhoQ195dffpnPPp3L9mL/EvyBKwP1pwnsTjc+r9d/owuD1+VEklWotPs/Q/F5cVVX4LHVoI2KQ6UzNPt+xevBY6/1rzDUacvqgCQRuHFLsgpkGVlWIdX9usE/KhWSJDd+TSXX5Qi0HMA4LKV4XXai60pYd2QfhBNPPBFJkpg/fz633HJL2OPNnz8fSZIYM2ZMBGYnCK0TwYAQEM42QXRa6EWG2kql1ZM67FRKNi7HYSlF8XmpLcnBaWl4xFCSJLTmGFRaPc6q0jZVV1y+q4BKq4077rgj7HnHx8dz9TXX8uEHHwD7Cw4B6OqCAafHh8/lQNYZWq0z0BqPw+Z/mj6ojLPP48ZRWYJKV5dk2ESZZ0mS8DpqMSSkNlhOV1BwlBfW3bgPuKk3+LXc4Gbekdw2K+U711GZuYWoLj2JSuuFuoWgJ1LS0tI499xzefvtt7n55puRwimKpSj83//9H2effTYZGU13/BSESBPBgBDQ1m0CXUwCupiO3duU1VpShp5C4dpfKd24DI/T3uy1Kq0OQ0InnNUVgdr7wdqcW0bP7t0j1lr2ggsuYPbs2ahlidTo/UWTdGr/TbO+HLHX5fQ/ubfhnuK/EckgS3hdTtQGs79hkiyBJPuXyeu6JypeD2pzLIbELqi0uv1P8JKMxmCiy4nnNRg7vu9w8lf+gOI79LkDLfG5XVRlbac6ZwemlK5Ep/dGGxXXrp953333cdppp/Hf//6XW2+9tc3jzJkzh7Vr17J48eIIzk4QWiaCASGgraWII32cMFi2skLctdWo9KYWgwHw7zfrY5Nw22pw1VQGvdS9p6SKEaNOjcBs/YYPHw5AgkmHWqPF5/HnCBxYjti/py2h+Lz+rRf/Wrv/Jl/3j9TU15CazgVQFHQx8c0mD3ocNqwFezHEp/pPY9Rd57bX4q6tblBNUq03Yu7ck5q8PRH7mbQnxadgLczCWpiFPi6J6Iy+GBI6hfXk3pzx48dzyy23cN999zFmzBgGDhwY8hhbt27l3nvv5eabbxbFhoQOJY4WCgFKG7YJ1HojxqQu7TCb5ik+HxW71lO6eQWK14u5UzcM8cEVOtIYozDEp7Z4TPFANQ4PKamRKaIEkFo3VlyUAV1sImqDCbXehNHoXyVw+kClM6DS6f1L7moNar0Jtd7o/7pWj0qjQ1ZrA9nukuzfa28uKdDncbe616/4fNjKCrBkbsFZVYa/oTLYygoaXRvTtV+7JOG1N0dlKSUbl1Hw10/U5O+NWB+OA82YMYPu3btz6qmnhlwwaN26dYwbNw6n08mUKVMiPjdBaMmR93+00G7aUmcgKq1Xh94YPA4bRet+ozp3d4OvG5PTMCalBTWGrNGiT0hFbTC3fq0s4YlAMaZ6brf/WGFSlBFZpfYn+EmgP2iboJ7HXhuRfhFep8O/ItIKn8eNtTCLqqzteGzV2JsIBtR6Y7PNpI4E7toaynesJX/5AiyZW1pdVQqF2WwmLS0Ni8XCqFGjeOKJJ6itbfrkSz2bzcZTTz3FqFGjcLlcOJ1OLrroInbv3t3i+wQhkkQwIATUd+cLlqxSYe7co51m05i9vIjCv39ptheBISEVU2q3oMaSJNmf6xCb2OLZ+9RoPTu2b2/LdJu0c+dOAPqkxgKg0umAAxoVNaozoOC2WyNSitdtq8FjD672gsdhoypnF6VbVvpXFQ4SndH3iFwdOJDX7cKybxv5KxZQtv3vBmWY2+qJJ55g4cKFyLLMDTfcwDPPPEOXLl246667+PLLL9m9ezdFRUXs2bOHr776iqlTp9KlSxeeeuopHnzwQXbs2MGgQYMoLCzktNNOY9++feF/o4IQBJEzIASEujJg6tQdVRvK3YZKURSq9m3Dsm9rq9fqYxORVSqsBZlB3UDVehOyWoezqrTJinZ9U+P4cu1a3G43Gk34Feb++usvAEb19G8XSJLKX2ZX3Vww4P998ditDY75tZWzutx/Bl8TXMdHl7WKnN++IOG4UcT2GBDoFFm/OnDwCs2RSPEpWAuysBZkYYhPITqjD4aETiGPM2/ePJ5++mkA3nvvPW644QYeffRRZs2axccff9xka+O0tDRuu+02brvtNrp37w7A4sWLOfXUU9m+fTvjx4/nzz//FKcKhHYnKYdz9w+hQ5VuXUVtUU7Q13cZc05EblAt8bqclG1dhb2iOKT3uWurqcnfG3SAoygKbqulQRlegD3FFm557xe++uorLr300pDm0JQTTjiBdWvX8vMDl6CpqyWg+Lys2pbJg9+up3uCmVnXjGryvWq9qU1tmw8mybI/iS7Ic/jaqDiiuvREVqmJ6XYcUem9kVVqPA4b+SsXRqTT5eFGa4omKr0P5k5dgzoeuW7dOk4++WTsdjv33XcfL7/8coPX7eWFbPl1PtnlNei69MFo9Dc1Sm0mH6WwsJBx48axe/duevbsyR9//EGXLh2bmyMcW47sdT4hokI5h29M7NTugYCjqozCv38JORAA0Jiiic7og6wK7mlekiS0UXHo45L9y9+Kgs/tpKtZZkCXOF584QV8Yd70li5dyurVq4kzagOBAPhPOhj0/u2ClsoRexy1EUl6U3w+fyVBJbjvx11bheLz4fN6qNy7mYJVP2EtykalMxzRuQMtcdVWU75jDXnL5mPJ3Iq3hUqWRUVFXHTRRdjtds455xxeeOGFRtc4KktJio9l3EljuOCCCzj99NObDQQAOnXqxK+//kr37t3Zu3cvp59+OkVFRRH53gShKSIYEAIUb/A5A1HtfJywOmcXxet+Cyu5S603Ed21L7JGF/R7ZLUGtd6Ix1GL227F53Vz06ju/PX337z55pttnovdbueGG25ApVLRr3N8o9eNRn8BImcrXQs9NitKkDfxlvg8bn8nQlpfGFR8Pty2mv1zcNgo2/oXRWsWo4tJOOJzB1rizyvYSt7yBZRvX92oDbbD4eCSSy4hLy+Pvn378umnnzbZubC+jHMoXSTT0tL49ddfycjIYOfOnZxxxhmUljbO3xCESDh6/y8WQhZsBUKtKRrDAd0BIzsHFyWbl1Oxe0NECtuotHpiuvZtsfQugM/lwGEpwVaWj9tmRaU3odb5b9CD0+K4aEga90+bxs8//xzyHNxuN1dfdRXZ2dl4vV66JzXub2AMYmUA/I2IPPbaiCQUeh123Afd3JrTVElnZ3UlpVtW4bHXtvjkfDRQfD5qCvZR8NfPFG/4E3t5EYqiMGXKFFatWkVsbCzz589vsneFz+vBZfWf5Giq2mNLunXrxq+//kqXLl3YunUrZ555JhUVFRH5ngThQCIYEAKC3V9vr1UBV00lhX8vwlaSH9FxZbWW6Iy+jY8SKj7cdcfn7BXFeB32wIOyJEmodAY0xhgkSeYfJ/dmWFosF15wATNnzgx6yyA/P59zzjmHBQsWBN7TOb7xkUa9xr9/7/B4W73R+zyuiDRgAn+CoNfR8tG3+uuaI6lUVGVtw1acE9Lq0pHKXl5E8YY/efzu2/jggw9QqVTMmzeP3r2bLsnttJQFAttQVgbq9ezZkyVLlpCSksLGjRuZMGECFoslnG9BEBoRwYAQEMx+tEqjxZQa+cxma8E+CtcsabYbYbhklZro9N7+boZuJ67qcmpL8nBVV7Z4pFJWq9GYY9Dp9Dx67kAm9Evmn//8J+NPPZWffvqp2aCgtLSU559/ngH9j2PT2r95/fZLAzWBPN7G76nvWuhTwO1t/anf47SFfBS0OY6qMnxuZ4vX+DwuPM0EDbJaiy4mEXtlCZV7t2CvKAo6H+FI9fvf63nm//4LwKN33MTIXp3xupr+GR54NDPUlYF6ffv2ZcmSJSQmJrJ27VrOOeccampqWn+jIARJHC0UApQgbi5Rab0i2g3O5/VQsWsd1oKsiI3ZJMWHy2rB53Xjrq1p9sbWFEmS0RijkNUapo4/jpN7JvPeik2cc845dEpNYdToMfTv3x+dTkdpaSlr165h9eo1+Hw+Th3ci/9cfRZery9QALDM3lQwsP9n6vB40apbj9M9disaU0z4e/aKP8HNkJiKJDf/e+uyVqHWm5p8zZCQirOuaZStJA9nZSnGpC5ooxvnRxzp9mTnMXX66/h8CleccxrXX3AGlsytVGVtx9ypG9HpfRqUcHYeGAyEcRR3wIABLF68mPHjx7Nq1SrOPfdcfvrpJ0ympn9PBCEUIhgQAlrbJpBkCXMEs8fdthpKN69ocQk6XD63E4elFKelLLDyoY1JAFnGYwvtyUql1SOpNAzvJjM0PY5tRVWs2FvKnnVLWfXnr3h8EBsdRf+e3ejXPZ0tu/cRH2Uk2qhn7e7cwDhb8srQxY7xl/2tCxDUKhm1LOPx+XB6gssHUBQf7rr6A+HW2ld8Xn9AcEBvgoO5rRZI7Nzka7Jaiy42KZAo53U7qSnIRF1RjCklDbWhfU+edBRLtZVbH3uJGpudEQP78dTUWwI/e8XnoyY/k5r8TIyJnYhK74MuJgFn9f4iWeHW5RgyZAiLFi3i9NNPZ9myZVxwwQUsWLAgkIAqCG0lggEB8J+z97VytNCUnBGxdrC1JXmUb/u7XerDg4K7thpHZUmTgYYkSeii45FkOegEunqySoXGFIPXYWNAJ4kBnWKRZBXm1K5ozLFozbFEpfVi+brNXHv/dH5cvY1/XXIq+4r23xA27yvAq9Khj01u0DNAr1VhdfhwS8H/b6l43Xiddn9DozD53C6cVRX+qoxN8DhseN1OVM2czgisDhyQ8+Bx1FKVvRNtVCzGpLSI1Ek4VDxeL3dOf42s/CI6Jycy8/F70Wqa/r2ylRViKysEScJpKUUX7W8UFWxPjJYMHz6cn3/+mTPPPJPffvuNSy65hO+++w69/sj92QqHnsgZEACCqn8ficTBA5sMRToQULxu7BVFWPZuoTp3d6srDlpzbJuWsSVJ8jcYMkQBUqAlMIDLasHrqGXM8QNIT02m1uFi8bqdgWBAr1Xj8njZml2ISmdAH5cceBKv3ypwKypC6V3sddkD3Q/D5XHU4q5t/ufWUvBUvzrQFFeNhap9W+uSDNsjAGx/z7zzEcvXbcao1/He09NIjGt8cuBgttJ8rIVZVO7djL28INhmma0aNWoUCxcuxGQy8csvvzBx4kRcrsj8GRCOTSIYEIDWkwf1sYnoosPrB99ck6FweexWrIX7qNyzCVtJHt5WkuEOpDFGNfsk3BqVRovWHFP3tLv/5m0vL0KWZa449zQAvl25iX1FZQD0SPV/1rq6bQOVVo8h3l/oqD6J0O7xhvwE7bFb29RoqimuGgtep63p11oJsAwJqc1uWSiK4k8yzNyCo6L4iEoy/GzhEt7/5kcAZjx4J/17dgvqffVbUT6PG1tpAUVrFlG+Y22Dug1tdfLJJzN//nz0ej0//PADV155ZaARliCESgQDAtB69cFwVwVaazIUKsXnxVlVRlXWNqqyd+CsKm/z2Xu13lT3hB76vrskq9DFJqE/4InYWVOJ12Vn4oRxyLLEhr357M73BwPDe6cDsG7P/hwCWaNDH5+KQetfGXC6vah0oQUDihK5hkYADktZk6sNblt1i0GHf3UgucWxFa+H2pJcLJlbg+qkeKj9vXk7j70xG4B7bpzEWSefENT7FJ+vYWMoSUJRoCZ/L/krf6Rk47JAjkVbjR8/nu+++w6tVss333zDddddF9Eum8KxQwQDAtBy9UG1wYQxqW110RVFwZK5leINf+JtohFQqLwuB7biHCr3bMJamIXH0fQTbKj8S/Yp0IbMfJVagz4+mej0PoE9YXt5ESmJ8YwfNQyASqt/nqcd7w+qNmYW4D6g2qCs1mAw+PMxHG4PkiSj0gZfORH8N9nmnuhDpig4K0vh4Bu/ojTq33AwQ0JKUAmNXreTmvy9VOfsCLqbYkfLKyrh9idewe3xct64Mdx1TfD9KTyOhsWh5INOatjKCiha9zsFf/+CtTCrzT0eJkyYwNdff41Go+Hzzz/n5ptvxhtCaXFBABEMCHV8LTztRaX1alO2utflpGTDn0F1G2yR4sNlraQmdxeWzC3YK0sitiR+IJVWhyE+JajGNAeSVGokJDSmaGK69UdrjsFVXY7P7eTKc08PXJcUY2Jgt07Emg043R62Zhc2GMeg82eaO7318wk9WdPrckQk6AL/1pHDUsbBG92ttfoNZnXgQG6blarsHVgL9rZa76Aj1dod3PrYS1RU1TCgVzdemnZ7SP8fHLwVIDVRphj82zJl2/4mb8UCqrK2t+n377zzzmPevHmo1Wo++ugj/vGPf4TdS0M4tohgQABAaWZpUVapiercPeTxwmkyVM/ncWEvK8CydzM1eXtxtfJEGgmyWos+IRUphKxvSaUKbDHIag1Rab0xJKVjryjm1BOOJ8rkz/SPMRmQJIlhveq3CvIajGPQ+j/TqzUia3RIsqpNRWoimT/gdTlw1TQsf+u2VrW6HRHs6sCBnNWVWDK3YCvNRfEd2qVun8/HfS+8xY7MHBLjYnj3qWmBZlLB8tgarna01iXS63RQuXcz+cvnU75zHW5baKslF198MXPnzkWWZebMmcOdd94ZsW0j4egnjhYKQPM1Bsydu4d8Q6rO2UXl3o1t7i3gsVXjsJTiqrEckr/MZJUaQ3wKjsoSfK09pUn4C/UcdOMzxKfgddnQ6A30SO/Mxh17sNr9Yw3rlc6vG3axbncuN581OvAefV0wYHd5MMT7jx0qXg+ukE8KKLhtNf6CRGHWHwD/k7uk1qAx+gvp+Lwef8GjFrpW1q8OOCpDCwYVRcFeXozTUo4hsZM/F6OZugft6bUPv+TnZavRatTMevLfdE4OLclUUXx4HA1v5nIzKwMH83m91OTtoSZvD8akLkRn9GmQk9KSyy+/HJfLxXXXXcfMmTPRarW8+uqrjf4cKIpCVlYW69ato6CgAEmS6Ny5M8OHDycjIyMif26EI4sIBgSAZkvbRqU1XW+96TFclG1f3abeAorPi6uqHIelNKxOhZEiySr0cSk4LKUt9gFoqRqjSmvEmNQFk9l/Ey2qrKagvIrhvdMA2JiZj8frRV13k6hfGXC4PSDJ/joEkozHYcMXYs1/xefF66ht3I+hjVw1lcgqTaDhk9ta1WoLa0NCCk5LSZsCOp/XQ21xLo7KEozJaWjN4Z1kCcWC31fy5sdfAfDsPf9gWP/Qk2c9DlujHICWqjs2x1aaj600H110HFHpfTAlp7dacfKaa67B6XRyyy238Prrr6PT6Xj++eeRJInKykree+893nnnHfbt2weAVusP9uuPJvbq1YspU6Zwyy23EBsbG/KchSOT2CYQgKbrDBgTO6MxBnczaWuTIa/TRm1RNpV7NmItzjksAoF6kiyjj0tG1UJBn8DSbzNPUrbiHApK95+gmL9qMz07JRFj1GN3udmes//JuX5lwOF0B8bUxyT6Kya2gdftDOmYZYuU+hMG/rm1ljcAoecONMXrclKTt5fqnJ0hlZBuqy27M5n20tsATL78fC6bMK5N4zRV3bK5nIFgOKsrKdv6F/krfqAqe0erdSVuvvlm3nnnHQBefPFFHn/8cb755hv69evHY489xtixY1mwYAFFRUU4nU6cTicFBQV8//33jBo1iocffpj+/fuzYMGCNs9ZOLKIYEAAmk4gjM4I7oko5CZDig9XdQXVOTux7NvmXw4/TJOdJElCF5PY7BN2/cqA1EyRIKu1lqzs7MCvv1+1FQWFob38qwNrDzhiuH+b4IBVAEnCmNCpzeV8PfbayO2/Kz6clhJQfP5ExSA6JxoSUsLvnYA/Ga8qazvWgn3tlmRYWmHhH4+9jMPpYtzI43lw8jVtHqup/f7WcgaC4XHaqdyzibxl86nYtb7FvILbbruNN954A4Cnn36aSy+9lNGjR5OZmckHH3zAeeedR0rK/lbknTp14oILLuDjjz9m7969DBs2jAsuuIDHHntM5B4cA8Q2wTGquLiYP/74g3Xr1lFYWIizupJYncTAXt05YfBxpHXt5j9734JQmwz53E6cVWX+pfcj6Cy0PyBIQJJVjarztfa0l5lXAEBiYiI+n4/iigrW5loY1jud3zftYd3uXG48cxQABl3dyoDroC0BScKY1Jna4hy8Ia+cKLht1ojlD/g8HhyWUvSxybisFgzxqS1eH+hZEEYi6YGc1eW4airQx6f4Cxy1Yem9yXFdbm57/GUKS8vpkd6ZNx6ZikrVtiBGUXxNHpWUQzyl0hKf10t17m5q8nZjSOpCdEZf9DGN8xruuusuFixYwC+//MIrr7zCPffcE9Sfg7S0NObPn8+LL77Igw8+iMlk4oEHHojY/IXDjwgGjjEbNmzgueee4+uvv8bj8ZCWlka3bt1AUViZk82sz79HpVJxwdkTePSpJIYNG9bkOME3GarrE2ApxW21RKwc66GgjYpFkuUGhXIkVd2pA7npv2B3Z/u3Tfr27M7IMSfx2muv8d3KTUy5dAIzvvqtLm/Ah1olo68rOmQ/OBgA1DqjvyEREp4QawkoPi9eey3qILd8WuN1OnDVVKIxRbcaDIA/mdIZwdUff5JhEU5LGcbEzv4KkmEkGSqKwiOvvcf67buJNpv479P3E21ueydAr8PWZEJuJFYGDqYoYCvJx1aSjy46nuiMvhiTugRWY1auXMmiRYt44oknuPfee0MaW5IkHnjgAaqrq3nkkUc4/fTTGTFiRMS/B+HwILYJjhFut5tHH32UESNGsH79el555RUKCwvJzc1l6dKlLF22jOycXIqKinjttdfYvieTE044gYcffrhRzfPa4lwK/17UYiCgeD04KoqxZNb1Cag5sgOBehpTdIM9/NYyxPdk+48Pdk+J56Ybrgdgycp1pHZKI9pspNbhYmee/6k5kEDoamLVRJLQGKNR6Qyo9aHf1L0eZ1DL+sFy22qwlxc2m3h6oJZ6FoTD5/VgLc7BkrUtqByG5vz3ywV89csfqGSZtx79F93TOoU1r+aW7sPJGQiGs7qC0i0ryV+5kKqcnXhcDiZPnswJJ5zAf/7znzaP+8QTTzBkyBAmT54stguOYiIYOAY4nU4uvfRSnn/+eR577DG2bt3K1KlTSU1t/FSXkpLCnXfeyebNm3nyySd5+eWXueiii3A4HPubDG1Z2WwvA4+jFmvRPir3bqK2JBev6/ApIhMpGoPZf3OTpMAytdTMk+meHP/KQM/0TnSNNzJ69Gg8Xi/f/rqUkYOOA2Bzgb9+wv5goOnkMI3RjCT7KxO2JYfA46iNaHMoZ3U59vLC1i8EDPGpEckdaIrX6fAfxcvdiTfEJMPf/17P8+99AsAjt1/P2OGDw56Px95034H2WBlo8vMdNip3b+Sz159l27ZtvPLKK6jCCEQ0Gg0vvfQSGzdu5I8//ojgTIXDiQgGjgGTJ09m0aJFLFiwgMceewyNpvWCOhqNhkceeYQff/yR33//nRuuu5bCtb822WRof5+A7VRlbcdpKT9sEwIjRa03YohPQW6lP/3uupWB3l3TqM7ZyS033wzA5wt/44RB/QBYtzeP6Iy+gXLEdmczT9uSjLruOJ9Ko6072hdaHoDHZkWJVIMgBaqzdwSV0CerNe2yOnAgV20NlqztWAv3tV4fAv+qzdTpr+PzKVxxzmncePHZYc9BUZRmVwYimTMQjM8XLmbQwIGceOKJYY81fvx4+vXrx5w5cyIwM+FwJIKBo9yXX37Jxx9/zOzZsznrrLNCfv/pp5/OBx98wLwvv+LLb+c3eM3rcmArzaVy7+a6PgHtf/TrcKIxRhOd0Q9ZrWkyKcvpcpNT4N8C6JXRBa/TwXmnnIDZbCYrvxCz0X/zX715B7LORGJGL6CuzkCznxl1QLVDbV0hoOADAkXx4gn21EcQ3HYr1bm7gqp42J6rAwdyVpVj2bcFe1l+s/OyVFu59bGXqLHZGTGwH09NvSUiCZZeZ9P5AtBxKwP11u/Yy1lnnx2R70uSJCZMmMCqVasiMDPhcCSCgaOYy+Vi6tSpXHLJJVx99dVtHmfSpElcMWkST8/8EKfLhctq2d8noLz4iO1PHy5Zo0WtNxKd0ReVvnHCWVZ+IV6fjyiTkeQEf9Ecb1kuV155JQB/b96B2WigptbG9swsjHXBgdOjNPsXuCSr0BxwzFFWq9GYokP6C9/ncbXhVEIzFAVXjQVr4T6g5f3kjlgdCEzL58NWVoglcwtOS2mDuXm8Xu6c/hpZ+UV0Tk5k5uP3otVE5kbd0lG/9s4ZOFC1tZb8opJmE4DbYujQoezevZva2mMr6D9WiGDgKPbNN99QWFjI008/HfbTwZNPPUVZpYWvvvySmrw9HdIn4HAn11VuU2n1JA85Ga05psHr9ScJemV0Cfz8PQ4b11xyHgA/Lf2L4/v5VwP+2rgdo97fttju9hDd9ThU2qbbGKvrygIH5qFS1x0dDP5/Z4/TFlTyX3Bj2XHVWLCVFrR6bUetDtTzedxYi7Kp2rctcCz0mXc+Yvm6zRj1Ot57ehqJcTGtjBK8pooNgT+IC+X3J1xWmz/Yi4+Pj9iYCQn+xNmamqa/R+HIJoKBo9jcuXM56aSTGDBgQNhj9e3bl3HjxrHwr80RmNnRQaXe37hGrTOSOnw8+tj9Z7335uzPFzhQr1gNgwcPxulyo9f7A4q/Nm0LNMJxOJyo9UZiuh2Hromz47JajfqglQhJVtWtEAT/9OlvaBR+/kB922R7eSHO6vIWr+3I1YEDeZx2qnN38/7Hc3n/mx8BmPHgnfTv2a3NY5ZVVrF2605WbdzGtr1ZOF1u3M20Yu7IVQEAjdq/0uF0Ri6Bt36s+vLFwtFF1Bk4iq1Zs4YbbrghYuONGzeOt16bgaI0v4x9LGmQPChJyGotycefQtmWldjKCvevDHTt0uB9Hnst1026lGmbNrE7y3/N35u3o6s7TWBzOP0/Y1mFuVM3NKYoaotyGuxFa0zRjXI06gMCt606qD38+uI4amNUWL+fiteL1+1CpdFSW5iFSqtvFKwcyBCfGtG6A8FavyePZz7y573cedmZnDn6+JDH2J2dx8ff/8KilWspLClr8JpWo+G4jBQuHD2Qs4b3C1SUBJAjVBwpWAmx0ZhNRrZu3cqFF14YkTG3bt1KQkICcXEd1ydC6DhiZeAoZbFYKCgoYPDg8I9K1RsyZAgV1VYs1sOnf8ChpDogGKi/mcoqNUmDTsLcqVugxkCvjLRG7z1n5AB0Oh3ZBUXotBqqamrJLy4FwOvz4TogiVAXnUBMt+Ma3GBljRaVrvE2giTL/i2DIJPVfF53RPIH6lcHFEWhJm9Pi7XzD8XqQEF5FdP++y0er48zhvblhlOH+HNeygqCCpyqrTYefGUWE265j59WrOPKa65j3rx5bN68mZ07d7J8+XJemTGDTr0HMn3uz1z85Gz+2LQn8P6OXhmQZZmBvbuzYvnyiI25YsUKhg8fLh4EjlIiGDhK2e3+v+DN5shUnQMwmfw3I+cRVEq4PcmaA/rbH/AXpCTLxPQeyr78IgB6H7QyAGBS+bjovHMAiIv2HxfctHNv4HXHQcu7Kq2e6K59G1T80xib3uuW6goUyarWj5ACeF32VhvftDrGAQGFz+OmJm9PizfZjswdsDld3PfuN1isdvqmJfPEdecgSVJdkmGBP8mwqozmEiB3Z+dx7m33s3DZ38ycOZPcvDxmzJjB5ZdfzsCBA+nTpw8nnngid955Jz/++CO7d+9m1Mljue/db3hx3mJ8PqVDTxJIKhUqrY5zTxnNjz/9RH5+6F1ED5aVlcWiRYuYOHFiBGYoHI5EMHCUqr9xV1dHLtGvfqzbXvuMf838ile//o2vl21kza4cyqqsx1R1MknyP+Hu/3XD/5X27duHy+3GaDDQObnxvj/ApDNPBqDc4v+5rtmyM9DO2OZovNcrSTLG5DSi0nsjq9SodPpm6xxIkoTaGIWsDm5/158/0PoTcnN8bleDgkYeh78bZXM6anXA51N4/MOF7M4vJSHKyCu3XdJg+R7qkgwLs6jK2o77oMTYrPwirv7308QnpbB58xamTJnS6p55z549mT9/ATNnzuTLZRt5/vNFYZVLDkZ9ACCrVP5tG5eTi08/Gb1OywsvvBD2+M8//zzR0dFhnUoSDm8iZ+AoFR0dTXp6Ohs3bozY/8AbNmxArVaTX15FfnkVy7ZmNnjdpNeSkRRH15R4uqbE7//v5DgMuqMr6UhWaxv+BX/Q0un27dsB6HfccST1P4GKnWsalWMe1iuNnt27s7eur/yfazYGhnlm1kcM79+HwX17cny/3g2a5mhNMai798da4K/t4LQ03LvePyUJtcGM11HbaitjRVFw261ojKEdUzyQ12lHNu6vjOisrkClM2BIaLq8b0fkDry7cDm/bdyNRq3ipVsvJjUuutlrPQ4b1bm70JpjMCaloai1/Ou5N4lLSOTX334jMbHpoK4pkiQxZcoUNBoNkydPZvTQgVx+cfdIfEsBskqNpFKheD34vF683obBXJTJyL+un8izb73FxIkTOeWUU9r0OUuWLGHWrFm89dZbgYcM4egjgoGj2AknnMBvv/0WsfF+/XUJI3qnceOZo8gqriC7pIKckkqyiysoKK+i1uFie24x23Mbd6hLjjXTNTm+LjiIJyPZHyh0io9G1YFHzSKlwRYBcHDhn23btgHQv39/orr0QNZoKdu6EsW3PyLw+nz07tqZ7NxcPB4PTreHXr16ERsbS25FLYtnf4bT6SQtNZlrzj+DGy85B31dUCWrtUSl90ZtNOOusTRbZliSJH8NBElqtTeB4vXgddpR640h/jTqvh+nva4q4n620nxUOj1ac+OkM1mtQR+bjL2iqE2f15pF63bw359WAvDIlRMY3KPxdk1TXNYq3LVVfLp8G5t3ZbJy5cqQAoED3XLLLSz65Ree/eA7zhg/nriYtrWirtcwAPBAKzU+brrkXBatWMNll17K73/8EfLJoo0bNzJp0iROP/10br/99nCmLhzmRDBwFLv22mu55JJLWLduXdjFRzZv3syqVX/x/C0XMqJPBiP6ZDR43eX2kFdmIaekkqySCrKL6wKFkgosVjslFislFiurd+U0eJ9GrSI9MbZRkNA1OZ5YsyGsObeng5fnJbnpYOC44/z9B0zJaag04yjZuAyf18PenHz+/dJMNu7Yw8UXX8ztt9/O2LFj0ev3JwW63W5Wr17Ne++9x6sfzuWLn//g5WlTGNq/j/8zJQljYmd8vYZQuWdjs8WfJEnyJx9KUqvJgl6XHUmlbpAcGSyvy4Gi+BptmVgL9hHTVYdK1zjI0Men4LCURHx1YEduMU985D9CeO1pIzh/9MCQ3u/2ePlg4dJAo59wvPHmm2RkfMu8n37jtitCz+wPBAA+r7/1dwhFvlQqmXcev49rH5jO2JNP5u2ZM7niiitaXf1RFIVPPvmEO++8k549e/LFF18gH4FBuxA8STmWNnqPMR6Ph969e9OnTx9++umnNi//KorCBeefz7rVf7HgubtRHKEVHamqtTcIDrLq/ju3tBKXp/l96hiTga7JcYEVhfpAIT0xNmIV49rKmNgJQ+L+J820k85v8EQ9YsQI1q5dyzfffMPFF18c+LqzuoIfP36XGx6YTmqnzrz/wQeMGTOm1c/bvn07N954IxvWr+fN/9zNhJNGBl5TfF4qd2/CXlmE19Fye2Ov0x5EC2QJrTkGqQ219HWxSU2uLKg0OmK69dvf8vkAtpK8iK4OlFVbueHFjym21HBi/+68OuXSkFefft+4m3+/9y2bNm1i0KBBYc/p+uuv489fl/D7B68FdX2jACBMVTVWHn7tPRb+sYoJEybwr3/9i7POOqvRDd7r9fLjjz/y2muvsWTJEq666ipmzpxJTEzkCjMJhycRDBzlfvzxR84991xmzpzJlClT2jTG7NmzmTx5Mu89fT9njBmOx1GLvawwrLax4F8mL6qoDgQJ2XVbD9kllRRXNh9wyJJEp/joJlcTkmPNHXL0ydypW4OCQOljLwxUDPT5fERFRWGz2di5cyd9+vQJXLdnzx5GjBjB4EGDWPDDD0RHN7+HfTCXy8U1V1/N999/z9yXH2X4gL6B1+xlhdjK8nHbanDVVNJSv2iv24mnmeI49SSVuk35A2qDqclCSeDvuhid3qdRMp3P48aSuTkiqwMut4fbXv+MzVmFdE2J5/37riHK2HQlx5bM+OpXVu4rI3NfVthzAvj666+57LLL+OvzdwKlqQ8W6QDgYJIssarQyQsvz2D9+vVER0czbNgwunXrhqIoZGVlsW7dOmpqahg+fDiPPvooF110UcTnIRyeRDBwDLjjjjuYNWsWc+fOZdKkSSG995tvvmHSpElMnDCO5+79R4PXIhUUNMXudJFTWhnISagPErKLK6h1NH8MTq/V+IOD5Hi6pcSRkbw/YDAbDt7nb7uYjD4NygKnj70IldY/flZWFt27d0er1VJbW4u6rhqcz+dj3LhxFBQUBP4yDpXL5eLUceMozMtm4TsvBKoW+rweKvdsZO2uHP7ensn2rHzKa51IQLxRS5/UWIZ3T2FQeiKSJOF1u5pttVtPpdGhNoR2NFWSZQxJac0GEfrYREyp3Rp9PRKrA4qi8OTHP7Lgr61EGXR8MO06MpLbViDntjc+p8eQE5g374uw5lQvOzubbt26MXv6A5w2ev+WnaxSIanU7RYAHCimaz/ieg1GURT+/vtvlixZwtq1aykqKkKSJFJTUxk+fDhnnHEGI0eObH1A4agicgaOAa+//jpVVVVceeWVLF++nGeffbbVrGCbzcajjz7Kq6++ynnjxvD03bc0ukatNxGV1qtdggKDTkvftBT6pqU0+LqiKJTX1O4PEorrgoSSCvLLLDhcbnbllbArr6TRmAnRproth7qth7rth84JMahVoS0jS+rmcwbqTxL06dMnEAiAvzz0smXL+P3339sUCIC/FOz7H3zAkCFDeO/LBUy99jIURWH+76t486Mv2JtXRGJCAiNGjmRQ164A7NuXyfer1/D+0m30SInjupP6Mf64NDTGqLrGOk0/D3jdTiS1BlWjZMnmKT4fPrcrEBgdzGEpQ6UzoI9r+PsaidyBT35dw4K/tqKSJZ66/lyiDDoKyquwu9zYnW4cdf+2u9wNv+ZyY3e6sLv2X7Mrv4yTzu7c5rkcrHNn/1iV1TWNAwBv2490BkutNxLTvT/gzyEZNWoUo0aNavfPFY4cIhg4BqjVaj788ENGjBjBww8/zLx58/jHP/7BlVdeSd++fQP7hj6fj127djFv3jxmvfMOFRXlPPSPa7j50vMaHG1rNH47BgUHkySJxGgzidFmhvVKb/Cax+slr6yKnJL9QUL9f5fX2CivrqW8upZ1e3IbvE8ly6QlxdYFCPu3HLqmxBFnNjb5lNs4wW7/NQeeJDjQW2+9xYQJExg3blwYPwF/kHH99dfz6TdfceW5p/Hwq++xZOVaLrrwQv770T2MGzeu0Zx9Ph+//vorM2bM4Mmvf+T349KZdu5wTEZ/+eLmAgKPvdZ/8wqhnK7XaWs2GACwleSCSotHrcfucGJzOLA5nFSW2LCUFflvys3etJv+msVqo7zGnwvh9SncM+uboOfbFI1Ggy+CSY31x/5UahU+r7dDAoADxfUagtzBLZSFI4vYJjjG7N27l1deeYWPPvoIq9WK2WwmI8N/MiA3N5eamhqMBj0Xn34yt0w8jx5poT8ddURQEKoam4Oc0sr9KwnFFf5AoaQSp7v55VmzQRcIDDKS4+mWHE/3zskMGn1KYIkeIOPUSwN/2U6ePJnZs2fz+OOP88QTTwCQmZlJz549+fLLL7nsssvC/n7Wrl3LiBEj6JyciMur8N/Zs4Pe3/3iiy/4x623kmRU8cpVY4nSqfDYqhsVjXJ7fTjcXpxe8GiMON1e7G4PDrcHh+vA//bgqH/N5cHhUfDImmZv5A6Xu8WfeSTpNGr0Wg0GrQaD7oB/63UYdToMBj3G+n+MRkwGAyajkU9//J20nn34+eefIzKPzZs3M3jwYD6b8TijBvdv/Q0RZIhPJmXoqR36mcKRRwQDx6iamhr+/vtv1q5dS2FhIYqikJqaSobGzuA+PTAbwz/WdzgGBQfz+RRKLDUHJDBWBoKEwoqqlvLw6JycSI/0znRP68SI086lX79+9OnTh6uuuopVq1bx+eefB3I0Pv/8c6688kpKSkpISgq/8l59kqIsy6xdu7ZBkmIwtm7dytixY/G57KTHmnB4PP4bt9vr/8fjxetr/78aJEnCqNf5b856PXq1jE4FBp0GvVbb4Caur/tvvVbt/7pWgw+FN7/9k9IqK33TknnmlouJjY7CZDJhNBrR6HTIaq3/H40GWa0JapXjtQ++4OMffqW4pARVBPoKzJ49m1tvvZVN3/0vIv9vBUuSJTqfcBYaU9u2pYRjhwgGhAYK1yzBWdVyG9pQeRw27GUFh3VQ0BSHy01eqaVB8mJOSQXZpRaqa1tv7nPmmWcycuRI+vbtyx9//MGPP/5IQUFBxOZ3wgknkJCQwI8//tim9//xxx+ceuqprV6nkiX0alXdTViNXqPGoFGj16rQa+p+fdB/m6KiMZujGt3ID765R8XGE53eO3DCoLmTBZIsI6s1dTd2DbJGg09Scdtzs1ixcQedkxP47q1nSIyPTEe9DTv2cMmdj7BgwQLOO++8sMc7ddw47JZSPp/xRPiTC0FM177E9RrSoZ8pHJlEMCA0UL5jLTX5e1u/sA08Dhv28kL/0bcjmD4+FYc2mn15BWTmFpKZV0CRQ2LXrl3s2bMHt9vd5Pu6du1KVlZWxOZx5plnEhsbyxdftD3j/Y477uB/s9/jkQtOIMaoRa+WUXkc6FSg16jQa1RoDsgX0Zhigtp7lrV6DPEprV4H/oJM0V37odYZUekM1JbkYi8r2H/z1zT9NP/k/73P+9/8iFGv44vXn6J/z25Bf9+tURSFi+54hIROafz6229hHVddvXo1J5xwAm8+cjfnjz8xYnNsjVpnoPPosxv00BCE5oiMEqEBbVRsu42t1huJ6tLziA8K1FodCbHRJMRGM2JgPyRZouv4ywH45ZdfOOuss+jcuTP//ve/2blzJ7t27WL16tXU1IRWrKk1Vqs1kKXeVg888ADvvPMOlbUOxvbzF1FSFAW3rbrJioYemxWNObpRlcGD+VwOUHyotAZkjf9pXmrwZF/3b7UGSZKJ6tKLqC49AIjtMZD8FQvwejzszs5j08697MrKw+Fyoddq6dMtjfySMt7/xr8iMuPBOyMaCIB/++K+Gydx48PPMWfOHG65pfFpmmA4nU5uuulG+vfqzlljw6tkGKq43kNEICAETQQDQgNac2y7f0YgKHDa/DkFR1hQ0LhT4P6nxp07dwIwcuRI7rnnnsDXv/jiCyZNmkRxcTEpKcE9MbfE6/WyadMmLr300rDGycjI4PTTT+fPXZu5cHhPYH8LZI+9Bp+n4SqHonjx2GvrKhT6i+RIsirw7/rCOZKsxtylJ7rohKDmUbFrLRpTFPrYJFCp+WbFZt793wds25OFJEl069aVqKgoampqeO+L+QCoVCpOGzWUM8aMCOtn0JxxJxzPpHNOY+rUu+jXrx8nnXRSSO/3er3cOnkyu3bu5Nv/exaNuuP+utXHJWFKyWj9QkGoI4pNCw1ozB1XdlSt8wcFMd37o42KzF5vRzi4SdGBT8n1NQYOPlZYX9/+999/j8gc1qxZg81mi0hxmJNOOondxXWnCSR/9UGVVo8+PhWtORa1zojaYEZjjEZrjkVjMKMxxWBI7IQ+LhldTIL/68YoVDoDslqLJMu4rFVBz0HxKZRuWs6WDes46aSTuOc/T9HruEEsWLAAi8VCZuY+Nm7cRGbmPqqqqpg/fz5nn302i1euZeK/HmNvTn7YP4d6cqAdsJon77yJQb17cNZZE/j000+DbtNdVlbGxMsu45O5n/DslCsivnLREkmWiO8TXi8S4dgjggGhAVmlRmMMrepcuI60oKBRjQGp9RoDXbt25eSTT2bWrFkRmcM777xDRkYGY8eODXus/v37Y7Ha0PUYhrlTd4xJXTAkpKKPTcLcqTu62CRUGl1dJr4KJAlXTWWrXRDd1ioUJfiz+qvWbeLEsadQWVnJsmXL+O777znvvPMaFWiKjo7m/PPPZ8GCBSxbtgybBy656z+s2bKjTd8/NAwAfF4vXpcTn9eDXqflf888wGknHM/VV1/NxRddxKpVq5oNCmpqapg5cyYD+h/Hr4sX8eLkizj3pPZZuWhOVFpvtB0Y1AtHB7FNIDSiNcfWVabrWPVBweG8fSCrNY1q6x+YXFa/MlDfrfBAd955J1deeSW//PILEyZMaPMctmzZwty5c3nqqacicuxNp/OvdOgSOxGjT6cmZxee+u6GkoQuJgFJlnHXVjd4n9NShiGxU7MNjRSf159jEMSxtj3Zedz8nxcYMWIk38+fT1RUcK1+TzzxRNasXcsF55/PzY+8wDdvTqdnRnCtiiWVf1tD8Xrr2gE3XQjIoNfxxiN3c87Y0Tz/3ieMGTOGfn37MObEkzjuuOPQ6XSUlpaydu1ali39k1qbjdOH9uW+y8aTGG1GisDvUbBUOj2x3Tu2joFwdBCnCYRGqrK2Ubl3y6GexmEZFKj1JmK6NbzRq7Q60sdeRFlZWaCGgNVqbVDy2e1285///IeXX36ZlJQUtmzZQnx8fMif73A4GD16NOXl5ezevbtBy+O2mjNnDpMnT2bnL5+hkfw3cUd5EfaqUn82hAKK4sNZXYH7oKV/lVaPPi65werIgfRxya3uXXu8Xi6b+igu1Py9enXQgcCBampqGDliBAaVwhevPYm6mRuwpFIhqzUoHo8/AAiRz+fjj9Ub+WX5arbs2Ud2fjG1djuyLHN8j86M6J3O+aMHkhq3PwA6uKlVe0ocMApzatcO+Szh6CJWBoRGNB2QRBiMw3GlQKU9OHmQwI2wflWgW7duDQKBvXv3ctVVV7F69WoAqqqqOPvss/npp59CCggcDgeXT5zIli2bufLKqyISCACsW7eOvn370vuMSfg8Lty2Wjx2K9aCTMp3rsVjr8XrcqCLikVWa3BWVyAhAQpetwOXtarZUyguaxWmVvIl5/34K1t272P58uVtCgQAoqKi+N/773PSSScx78ffuPr8MwKvHRwAeMMoBSzLMuNHDWX8qKGBr50w6TZKKyzcc+mpjXppAG1qBd0W+tgkEQgIbSZyBoRGOuJEQSgOp5yCg5MHYX8CYVNbBB999BHHH388q1evJi4ujq+++oqlS5eSmZnJsGHDWLJkSVCfu379ekadcAKLFy9mxIC+bNywIehktpb4fD5+/vlnRo8eDYCs1qKLjsOUkk7K0HH0ufg2kgefRFyvIcT1HkricSOJ7zUEjSkatd6ISqPH67Di87j3HxWUVYGtE5/bicdpa/bzFUXhg+9+4eKLLgrMoa3GjBnDRRdeyEff/wKy7M8BUGtQvF68TkebVgKCERftz7GxWJsuRCV1QE8ASYL4vkNbv1AQmiGCAaERtd7YxPG5Q29/UDAAbXToS+yRoFI3vzJwYPJgdXU11157Lddffz1Wq5WxY8eyceNGLr30UoYNG8ayXxfRKdbMGWecwVlnncW3336LxWJpMGxtbS2LFi3i8okTGTlyJG5bDV+9/hR3XHMpW7ZuZdmyZWF/P4sXL2bPnj3NnqNX602kDD2V2O4D/El2OiPmzj2I7zsUXUwi+vgUDElpqLQ6zJ26Y0rtijGxM7rYJLTmGNR6I16nPXBjPng7YfvebHbty+G2KVPC/l4AbpsyhR2Z2WzbnelPAvQ0XQAqkmKj/asZVbVNJ1R2RM6AP2kwtt0/Rzh6iW0CoUlacwyOytJDPY0mqXUGojr3wJPQyV+8qLqiwz5bbqIbn3RQMKDT6Rg6dCiZmZnIsszjjz/OI488Ekj283lcmK0FfPLSf/ju1+V8+N3PXHLJJQB07ZpBTEwMttpaMvdl4fP56NU1jUdvv56rzjsDrUaNz+ejb/cM7r3nHlauWtWgTXIoXC4X//73vxkxYkSLZ+glWSa2xwD0cUmUbf0Lj9OO1hxHVFpvavL3oPh8KD4ftrJ8YjL6grnhM4Y2Ko6kgWPw2Gtw263+bQenDY/Dzua9fyDLMieffHKbvoeDjR07FlmW2bRzb4cd56tfGahqpkR1e3cLVGl1xPYY0K6fIRz9RDAgNElrjj1sg4F6hyIoaHLF5KBg4IUXXsDr9ZKRkcHcuXMb3WjLtq/2twaWZS45YyyXnDGWvbkFbNyxh537crA5nOi0GiZffCaD+vTguB5dG5xYkGWZ5++7jcumPsqTTz7J008/3abv5eGHH2b79u38tXJlUOV29XHJdDphAuXbV2MrK0BjiiY6vQ/Vubv9JwfstdhK8zEmN2wt7aqpRFKpMCR04uAWPfkffkefPn0wGo1t+h4OZjKZ6NWrJ7uyclu/OEJio+pXBprZJmjnnIG4XoORm1qxEoQQiGBAaFJ7liWOtAODAkd5Ic52DAqa+ktXkmR27txJfr6/8I3X62XSpEnMmjWL2NjYBtdW5+3GVtK4QE7P9M70TA++tPDx/Xpx342TmD59OiaTiQceeCDo+vmKovDkk0/yyiuv8Ojt15NQk0XZdh9RXXqha2X7RaXVkTzkZKpzd1G5ZyNqg5mYrn2pzt2Fz+PBXlGM2mhGa26Y21GStZvdRZWsX7+eyspK1Go1PXv2pLCwsM1Jg82JiorC7nBFdMyWxLWwTSBJUrsGA/rYRMydurfb+MKxQwQDQpOOxP1Htc6AuXMPDHUrBZEOCmSVusm/2H9Z9hf/evoKwP+X/3//+19uuummRjdnZ3Ullbs3RGw+t191MU63m4ceeog//viDWbNmkZHR8jG+ffv2cevkySz59Vem3XwlN192HorPh7UgC2tBFtqoWKLTemNMSW9xeTs6vQ+6mCTKtq70/zqjHzW5u/C6XVgLsojpZkCl1bN19z7mfL2QH/5YhdPlQq/Xk5CQgNvtpqSkBACj0cgbb7zB5MmTI7JCYLVa0WeEX/I5WHEx/mDA0sTKQHsmD0oSxPcRSYNCZIgEQqFJGlM0ktz2Tm2HkqouKIjtPqDVJ91QHLxF4HS5ePzNOdz078epqvKfvx81ahQ333xzo0DA53FRtmUFii9yZT0kSeKeGyYx55kHWb9mNT179uSKSZP46quvyM7ORlEUFEVh3759fPHFF0y87DJ69+7N9q2b+fCFR/jn1Zc0GtNVY6Fs+2ryls2nYtf6RoWGDqSLjqPTyDMxd+qGSqsnOqMfKp0exeelLGsnz876iAvveJh1u7J58qmn2Lx5MzU1NeTl5VFcXEx5eTkLFy7k3HPP5b777mPIkCFhJ0Xa7Xb27NlL765pYY0TipZyBtozGDB36XXIT9cIRw+xMiA0SZJVaIzRIdWXP9yoIrxSoDrgWOHu7Dzumv46O/flADB8+HDWrl3bbK+A8u1rcNtrw/r85owfNZRFs1/my1/+YO6CxcxrpqVxn+4ZPPbPG7hswjhMhpZrFPg8bqpzd1Oduxt9XBJRXXphTOqCJDd8fpDVGhL7n4A+PoWKHWuJyehL3s7N3DnjQ3bkFfPss89y3333NZnkGB8fzznnnMM555zDzp07uemmmxg3bhyzZ8/mxhtvbNPPYsWKFXi9Xgb37dGm97dF/WmCJlcG2mmLQKXREtdzYLuMLRybRDAgNEtrjj2ig4F6kQoKZI0WRVF4+9NvePWDL/D5FHRaLVqthu3btyPLMtu2bePvv/8ONCYCqMnbQ21JXqS+nSZFmYzcdMk53HTJOZSUV7J5dyYl5RYkCVIS4hnYpztJcbFtGttRWYqjshSVTk9U5x6YO/dArW+4nG9O7YouOp6CDUu5993vyK2oYdmy5UE3Uurbty9Lly7l9ttv5+abbyYmJiZwwiIUs955h15d0xjQq+P20VtaGWivkwRxvYaIpEEhokQwIDRLExULRdmHehoR0zAoKMJZXR7S+3fll3L71GcpKqvAaDRy0kknMXz4cGJjY7Hb7WzZsoUVK1YwatQoRowYwWuvvcbIwf2piGCeQDCSE+I4PWF4xMf1Oh1Y9m2jKmsbhsQuRHXpiT4+JbAlojFG8cHiNazfvps///wz5I6KKpWKd955h7KyMiZPnsyJJ54YUrvndevW8fU33/Do7dcHnUwZCS0mELZDjQFddDymTt0iPq5wbBPBgNCsIzGJMBj+oKA7hoTUoIOCmfOX8sHi1SQmJfHuu+9y9dVXNyg5XM/r9fLjjz8yffp0xo4dy21XX8q/r5+ISnX0pOcoCthK87GV5qMxmDCn9cKc2o3cgkKmT5/OAw88wIknntimsWVZZtasWQwYMID777+fDz74IKj32Ww2brzhBvp2T+eq885o/Q0RVL9NYLU78Xh9qA/4vZbkyP8VG993eIcGO8Kx4ej5G0qIuKM1GKhXHxTE9hiILjqhyWs8Xh93v/0ls39exRVXXsmOHTu49dZbmwwEwP90e/7557N8+XJeeOEF3v30G6a9NBOfL/hWvkcSt72Wyt0byVs+nxnTH8doNPLwww+HNWZSUhIPPPAAn332WeDEQUtsNhuXXnope/bs4aVpt6PVdOwzTkzU/j8L1baGWwWRXhmI6tITXbRIGhQiTwQDQrNUWh0qXWSa4RzOVFr9/qAgZn9QUFBexdXPv8/ybfu4++67+eijj4iJCa5PvEqlYtq0acydO5fvfl3G/839pr2mf1jweb18/u18brjhhmYDpVDcdNNNAHz++ectXrdhwwbGjB7Nn3/8wbtP3tdhVQcPpFapAgHBwVsFkcwZUGm0xPYcFLHxBOFAIhgQWnS0rw4cSKXVY+7kDwp+257HVc+9T05pFSeddBIzZsxo09LsFVdcwQMPPMCbH3/Njsycdpj14aGgpJyS8kpOP/30iIwXHx/P4MGDmT9/Pi5XwwJCLpeLP/74g6uvuirQs+HL157k5OGDI/LZbVGfN3Bws6JIrgzE9hyM6jDsGSIcHUTOgNAirTkWe3nRoZ5Gh6m1O3jyrf/xxc+/A6BWq3n//feR5bbHzY8//jhfffklr3/0JTMfvzdCMz281B+xPP744yM25ogRI5g9ezZRUVH069cXszmKmppqduzYidvtpntaZx669WquvfCsDt8aOFhsVNMnCiKVM6CLjsPcWVQaFNqPCAaEFh1JZYnDtWV3JlOfeYN9eYUAxMfGMOGss+nVq1dY4+p0OqbefTd33303haXldEpqOj/hSGaz+5fHDy6/HI7Y2FgSYmOYcsUF7MrKxeF00T2+E5eNG8ngvj0Z0rdnWEFaJMU1U2tAjtDKgEgaFNqbCAaEFh0L2wQ+n485Xy/kxf/Oxe3xkpoYz/23XMW9L/wf111/fUQ+45prruGuu+5i6ZpNTDpnfETGPJxotRrAXwEwOjo6ImPabDbMRj03XHx2RMZrT7HN1BqIRAXCqM7dI1pJUxCacniE1cJhS20wN6o6dzQprbRw8yMv8Mw7H+H2eJlw0kgWznoRtdr/RDdq1KiIfE5sbCx9+/Zh8+7MiIx3OKmoquaHP/w9CrZs2RKxcbds3hxS86ZDqblaA+FWIJQ1WmJ7HrpcCOHYIVYGhBZJsozWHIOzuvJQTyXi/li9gfteeJtySxU6rYZHb7+Bq88/A0mSyC0sIT4ujoSEyC3p9+3bj/zCoyeJ0Oly8+F3P/Hmx19TU2tDpVKxdOnSiCQROhwOVq9ezW2Tzo/ATNtffbOiSK8MxPUYiEqra/1CQQiTCAaEVmnNsUdVMOB0uXlpzqfM/vIHAPp2z+CNR6bSp1t64Bqvz9dkPf1wqNVqvMqRX29AURR+XvY3z7/3CdkFxQAc17MryfFxzJk9m0cffRRVmHvl8+bNo8Zq5dxTRkdiyu2uqZwBSVaFtc+vjYrF3KVn2HMThGCIYEBoleYoSiLcm1vA3c+8ztY9WQBcf9FZPPSPa9HrGh7Zio+JpqKyEqfTiU4XmSezosJCEuuyzo9Um3dlMv2dD/l703YAkuJj+fdNV3LZhHFs25vFhf98iP/9739Mnjy5zZ/hcDh47tlnGTtiCN3TOkVq6u2qqZyBcFcFEkTSoNCBRDAgtOpoSCJUFIUvfvqdJ/7vf9gdTuKio3jh31M488QRTV7fv1c3PB4PmzdvZsSIpq8JhdfrZf2GDUybchMqnR6vs3Ed+8NZUVkFL83+lK8X/QmATqvhH5Mu5LYrLgx0QBzUpwcTzxrHfffey5lnnknXrl3b9FmPP/44e/fu5c3/voIk+csfH+6ayhkI5ySBuXO3BgWwBKG9iWBAaJXWHFzVvcNVtbWWR157jwW/+5Pcxhw/gBkP3klqYvMZ2v17dsVkNPDdd99FJBhYsmQJNpuNsy+/lvTRo/HYa3FYSnFWleOsKjtsu0Pa7A7enTefWfO+x+H0F/+5+IyxTLv5SjonJza6/tHbb2DVxu2cfdZZ/Prbb3TqFNqT/dtvv82LL77IA7deTa+0VJBUyGoVPrer9TcfQk2uDLSxxoCs1hDXc0hE5iUIwZIU5UiIu4VDLW/FD3jstYd6GiFbu3Undz/7JvnFpahkmXtvnMRtV1wUVOOgR9+YzaJVG8jOyQl7q+Ciiy5i3759bNy4scmlX5/HhbOqAmdVWd0/5fi83rA+Mxw+n49vFi/lpdmfUlzuzxcZMaAvj9x+Pcf3a7nuQmZeAddMm45aq2f2nDlMmDCh1c+zWq1MmzaNd955h5svPZf/HNR5UNZoUXxelEP4M2lJYWk5J171T1SyzKrX70WSJLRRcUS1Yc8/vu9QotN6t8MsBaF5YmVACIrWHHtEBQNer4//+/Qb3vjwS7w+H+mpybz+yFSGHhf8X7I3XnIO8378jSeffJJnn322zXNZuHAh33//PR9++GGze8CyWoshIRVDQioAis+Hy1qFs7oMp8UfHHgctjbPIRSrNm7jmXc+ZMvufQCkpybz4D+u4Zyxo4Law+6R1pmvXn+KaS/N5KyzzuKiCy/kzrvu4tRTT22UlFlcXMz777/PW2++SXl5OU/edTPXXTih0efUrwyotHq8LjtweO2l128TeH0+ah0uzAZdm/oSaKNiieoskgaFjidWBoSgWDK3Ytm39VBPIygFJWXc+/z/8dembQBcdPrJPD31FqJMxpDH+r+53zDj/Xn88ssvbToyl5uby6hRoxgyZAgLFy4MKyHM47AFVg0cllLcVktE99Oz8ot4/r2P+XnZagCijAbuuOZSbrzkbHTa0GviK4rClz//zuyvfmTnvmwMBj2DBw8hJSUFt8vFli1byM3LQ61Wc+H4E5l63WV07Zza6riSSo0ky4fd1kH/86/H7nDy7eOTSUuKw5CQijEpLaQxUoePRx+b1E4zFITmiZUBIShHSlnin5f9zQOvvENVTS0mg56npt7CpWee0ubxbrviQjZmFXHhhRcyb948zjvvvKDfu3v3bs455xx0Oh2zZ88OOzNcrTei1mdgSskAwOdx46qpPCD3oByfxx3yuFU1Vt78+Gs+/O4n3B4vsixx9Xln8K8bJpEQ2/ZqgpIkcfnZ45l41qls2LGHdVt3sWXPPqpL8lCrVHRPTSA3L48+3dJ45YE7gh5X8XpQvP6umj6PG+UwaQ8dF2XG7nBiqXWQlhR6zoC5UzcRCAiHjAgGhKAc7icK7A4n09/5kLkLFgMwuE8PXn/kbrp1af1JsyVqlYp5cz/m+ltv5/zzz+e2225j+vTpJCY2Tp6r53A4mDlzJo888gjp6eksXryYzp0jX0lPVmvQxyWjj0sG/E/i7toqf2Bg8eceuFvY2nF7PHwyfxGvf/gllhorAONGHs/Dt13boOZCuCRJYuhxvRtt0RSVVTDmytvZvjcbS7U1kIQXLK/LCZKESqvD63JwqLcOYqOjKCgtDyQRhtKxUFZriOslKg0Kh44IBoSgqA0mZLWmTU+e7W17ZjZ3P/MGu7PzAP/T/L03XhGxTnZRcYl8++23vPvuu0ybNo3333+fyy+/nDPOOIOhQ4cSFxeH3W5ny5YtLF++nA8//JCysjKmTp3Ks88+i8lkisg8WiNJElpzLFpzbCBxzeO0B04sOC1luKyV+Lw+fv1rHc/O+pjM3AIAendN45HbrmPcCcd3yFwBUhPj6d01jd3ZeazYsKVtBYYUBa/L6d+fl2V87kP35zPuoBMFoeQMxPYYgEqrb5d5CUIwRDAgBE1rjsFhKTvU0whQFIUPv/uZZ2d9jMvtJik+llceuIOxEexrL6tUgXKwU6ZMYeLEicyZM4f333+fjz/+uNH1nTp14tprr2XKlCn07ds3YvNoK7XOgDo5DVOyf+96/bq13HfvPfz2x1IAEmKjueeGSVxx7mmoI9RhLxQnDx/E7uw8lq7ZFFa1QZ/XC14vKo0Or9cNh2DrIPagWgPB9iXQmmOI6hJeZ0xBCJcIBoSgacyxh00wUFFVzf0vv8OSlWsBOG3UMF6cdntYe9xNUesbPtUnJiZy//33c//991NdXc3mzZupqalBp9PRr1+/kM/Vd5SioiIeffRRZs+ejaIoaLVa/vWvf/Hwww9jVEv+pMQqf+6Bu7amw+Z18rDB/O/rH1m2bhOKooSdV+F1OwGQtTp8bgcoHbd1cHB/gmArEMb3GXpUNwMTjgwiGBCCdrjkDSxft5l7X/g/Ssor0WrUPPiPa7nx4rPbpXSrSt/8CYTo6GhOOumkiH9mJNntdl599VWee+45rFZ/XsCkSZN4/vnn6d69e+A6jSkac2f/r70uZ+DUgrOqDGd1Rbsl6Y0a0h+NWkVeUSnZBcVh53jU87mc/lMHktxhW1sH9ycIJmfAlJoRyPkQhENJBANC0A71iQK3x8Or78/jnc+/R1EUemZ05o1H7qZ/z27t9pkHrwwcKRRF4dNPP+XBBx8kNzcXgJEjR/Lqq6+2GsCotDqMSV0wJnXxj+Xz+U8t1BdEspT5k/ciwGTQM6x/X/7atI1lazdFLBgAULxeFLzIWh2K20V7n6IONWdAVqmJ6yUqDQqHBxEMCEHTmKIPWa347IIi7n72TTbu2APAVeedzqO334BB377tXdWGIy8YWLFiBffeey9//fUXAOnp6Tz//PNceeWVyG1YjpZkGV1MQl2tfH8ehNtmbVAtMZxyyicPH8Rfm7axdO0mrr2w9WqFofK5nEgSdacO7ED7LMnvzxmwgyS1mjMQ02MAap2hXeYiCKESwYAQNFmlRm2M6tA9ZYBvFi/lsTdmY7XZiTabeP7e2zjnlFEd8tnqFrYJDjdZWVk88MADzJs3DwCTycRDDz3EPffcg9EY2e9DYzSjMZoxd+oG1JdTLg8URHJVVwRdTvnk4YN55X+fs3L9Fjxeb7skMioKdacONNBOWwf1KwOWWgdyK4GA1hQtSg4LhxURDAgh0ZpjOywYsNrsPPbGbL5Z7M98HzmoH68+eBddUpo/4x9pR8I2QXV1Nc8++yyvvfYaTqcTSZK4+eabefrppzssodFfTrkThgT/5wXKKdclJTotZXic9ibfO6h3D2KiTFTV1LJp516G9e/TbvP0BygeVFo9vghvHRy4MtBa8mB832EiaVA4rIhgQAiJ1hxLbXFuu3/Oxh17uPvZN8guKEaWJe6+biL/vPqSDj/+1lIC4aHm8XiYPXs2jz76KKWlpQCcdtppzJgxgyFDDu1etCTL6KLj0EXHQV39Io+jtm7loK4gUl05ZZVK5sShA/nxz79YtnZTuwYDdbPbX7BIo8PjckQk+TT+gKOFLW0RmFLSRdKgcNgRwYAQkvZOIvT5fLw7bz6v/O9zPF4vnZMTee2huxg5qF+7fm5TJFk+bPd0f/nlF+677z62bNkCQJ8+fXj55Zc5//zz2+VURSSo9SbUelODcsrOan+nxtPGnsyPf/7F0rWbmXrdxI6ZkKLgdTtRabSB+YSjfmXA4XLj8jW94iCrVCJpUDgsiXUqISSadjxeWFxWwfUPPMML/52Lx+vl3FNGs3DWC4ckEIDDM19g27ZtnHvuuZx11lls2bKFuLg4Xn/9dbZs2cIFF1xw2AYCTZHVGgzxKcR2H8Blt/h7E6zfvhtN596YU7t2WPKmz+PG53H5i0u18edXWmlh+brNgZ//k+9/x9tzv+HPNRuptTsC18V0H3BY/rkSBLEyIIRErTOg0mjxRrhj3JJVa7n/pZlUVNVg0Ot4/I4bmXT2+EN6czuc8gVKS0t54oknmDVrFl6vF7VazV133cV//vMf4uPjD/X0wta9e3d69uzJ3r17Wbs7lwsvvBA4oJxyXTMml7USpZmn7vD4tw4kSULWaPHU/Xdr1m/fzbvz5rNoxRq8Xi+JiYl07tyZPKuPpV/8QHVNDWaTkYtPP5k7b7yKruntvQUiCG0jggEhZNqoWOwVJREZy+ly8dy7n/DBtz8B0L9nN954ZCo9M7pEZPxwHA7HCp1OJ2+++SbTp0+nqsp/fO/iiy/mxRdfpHfvoysbfcKECcycOZNFixYFgoGDyyn7vB5c1RWBgkiOqvKItjJWFAWv24VKo0VBQfF4mrzO4XTx8pzPmPP1Qvr17cvrr7/OJZdc0qAhlc/nY9euXXzyySe8O2sW3/66nJdecnDbbbcdUSs4wrFBUtq7Eodw1KnYvYHqnF1hj7M7O4+pz7zOjswcAG6+9Fzun3w1Oq0m7LEjIa7nQGK69T8kn60oCl999RX3338/+/btA2Do0KHMmDGDU0899ZDMqb198803XHrppfTt25cdO3YE9R5FUfDYavxJidX+gkhumzVCM1KQ604dHFhcw2qzc8t/XmDjzkymT5/OPffcg6qVxNbq6mr+/e9/895773HHHXfw5ptvioBAOKyIlQEhZOGWJVYUhU9/WMLTMz/A4XSREBvNS9P+yfhRQyMzwQhRHaJtgtWrV3PvvfeybNkywN/86Nlnn+W6665r9aZzJBs/fjyyLLNz505ycnLIyMho9T2SJKExRaMxRRPVpQdwYDnlupLKbS6nLPkLFskSskaHx+lAURT++dSr7NiXx2+//caYMWOCGik6Opp3332XkSNH8o9//IOEhASefPLJNsxJENqHCAaEkOTm5vLHkiUs/fE7LNVWJEmiS0oig/r0YOSg4zAZWm7Daqm28tCMWfy07G/AX3BmxgN3kBQf2wGzD01HJ3rl5eXx0EMPBbohGgwGpk2bxrRp0zCbzR06l0MhNjaWE044gVWrVrFo0SJuueWWNo3TuJyyF2dNZaDegdNSGlLOi+Lzt0lWabX878sfWLpmI4sWLQo6EDjQrbfeSnFxMY8//jjnnnsuo0Z1TPEsQWiN2CYQgvLHH3/w0ksvsXDhQhRFISM9jdROnfB5vezZsxdLVVUgUWrKFRc1WRjor03buOe5tygsLUejVvHvm69i8sTz2lQityOknXR+hwQEVquVF198kZdffhm73V+Y57rrruOZZ54hPT293T//cPLYY4/x9NNPc8UVV/DZZ5+12+f4yymX+oODqnJctdWtvsdSbeXEq+/gxptu4u23327zZ3s8HsaMGYPP52PNmjViu0A4LIhgQGjR/7d352FRnucawO+ZARRBkEUQkSWejCTKYliUIBKNcQmNJiVW0hOTuh2kRFMUgsbEaMUmQS8raUGkam2jRj0ejKDGggSsirgAEYipIsYlRooREAcGZLb+wcHEohWYD2e+mfv3L34PD9fFcvu+z/e+TU1NSExMRGZmJkaOHIkFCxbg5ZdfhrPzj3/sdTodLl68iO3btyNz40Yolc1YFjMTr0U+D4lEArVGgz9sy0L6Z3uh1erg7e6GP7z3NvyGDTXgV/afSaQSeI6b3qu/qDUaDT799FO89957qKmpAQCEh4dj/fr1CA4O7rXPa8yOHz+OsWPHwtnZGbW1tY8tKGpUbffd1Pig45Q3/98BrNmyC9evX4eLi36HBh06dAiRkZEoLi5GaGioXrWIhMAwQA/V0NCASZMm4R//+AfWrl2L+fPnP/KXc2NjIxISErBlyxbMjnoRs3/+IhZ9nIbSc+0Dh9MnP4eVC+Y8cjvB0CytbeAe9rNeq19YWIjFixfj7NmzAIChQ4dizZo1iIqKMuv/KapUKjg5OUGhUKC0tBSBgYEG6aP9OOXb925pbG28hci5izB8ZBB27/5fvetrtVoMHToUL730EtLS0gTomEg/nBmgB1Kr1Zg6dSouX76M48ePY+TIkV16zt7eHps3b0ZQUBDi4uKwY38+2lQq9O9njdXx/4Npz//n63ONRW+9VlhVVYWkpCRkZ2cDaB8sW758ORYuXIg+fXr3BkYxsLS0xLhx47B//37k5eUZLAy0H6fsiD52joDHMLS2tuL8t9cQF58oSH2pVIqxY8fizJkzgtQj0pdxbtaSwa1duxbFxcXIycnpchD4qV//+tdYvnw5VGo1fJ7wwMHMNaIJAoDwdxLU19dj0aJFGDFiBLKzsyGTyRAXF4fq6mokJiYyCPzExIkTAQCHDx82cCc/qqqqglqtFvTOh4CAAJw7d06wekT6YBigTmpqarBy5UokJiYiLCysx3WWL18OP19f2PTrBw83cV3MItTpgyqVCp988gmefPJJpKamQq1WIzIyEhUVFUhPT8fAgQMF+TymZNKkSQDa5weUSqWBu2nXMdjZv39/wWr279/faL4+IoYB6mTz5s2wsLDAu+++q1cdS0tL/HbVKpSdu4CvL34rUHePh75vEeh0OuTk5MDX1xfx8fFoaGjAiBEjkJubi4MHD2L4cMMcZiQGw4YNg4eHB9ra2nDs2DFDtwOg/TVPAFAohLu+u6mp6V5dIkPjzAB1smPHDkRHR2PAgAF613rppZfgNmgQsguK4Cs3zrcHvqm+glMV36Cy6lvUNyogkUjwX0/7YvSYsZg4cSK8vb27Ve/s2bNISEhAQUEBAMDFxQXJycmYM2cOLCz4I/coEokEEydOxJ///Gfk5eVh8uTJhm4JcrkcFhYWqKio0Gu17KfKy8vh6+srSC0ifXFlgO7T2NiICxcu4LnnnhOknoWFBcaEj0Fl1WVB6gkp9/hp/Hzh+/hZ7BKkbNmF642tcPIYigGDvXCq9CvExsbem/g+ffr0I+vV1NRg3rx5CAwMREFBAfr06YOlS5fi4sWLiImJYRDoBmObG7C2toafnx+OHDkiSD2tVoujR48iJCREkHpE+mIYoPt0nAnv7+8vWM2AgJG4ePW6YPX0dftOE95KXo/Ylevg5OaB7OxsKBQKnD59GllZWfj8889RWVmJxsZGbNq0CdeuXcOzzz6LJUuWQKXqfOd9S0sLVq9eDblcji1btkCn0yE6Ohrnz5/HRx99BDs7OwN8leL2wgsvQCKRoLKyEv/85z8N3Q4A4PXXX8fnn3+Omzf1v6QrLy8PV69exeuvvy5AZ0T6Yxig+3QMSgn5B8zW1hYtrXcFq6ePWw2NiE74LU5WXMDOnTtxOD8f06ZNg6Vl58uRbG1tMXfuXJSVlWH16tVYv349Xn31VbS1tR9lq9VqsWPHDvj4+GD58uVobm7G6NGjceLECezatavb2wv0I2dnZzzzTPtdFfn5+Qbupt3s2bNhYWGBVatW6VVHrVbjgw8+QGBgIA8cIqPBMED36RhounPn0cezdpVCoYB1X8O/OqdSqzFv+RrcUd5F0YkTeO2117p0wE/HMGVOTg5yc3MRGxuLoqIiPPvss5g5cya+++47eHp64rPPPkNxcXGPzqynzoxtq8DR0REfffQR0tPT8eWXX/a4TkpKCkpLS5Genm7WB0yRcWEYoPs8/fTTkEgkKC8vF6xmeXk5/AIC4BY8Ac7DQ2Dv/TRsXIbAytYe0sd4C1/Gzn34+uJl5Ozfj6eeeqrbz0+ZMgUZGRnYunUrwsPDcfr0adja2uLDDz/E+fPn8ctf/pK/3AX00zBgLAelLliwAC+88AKioqJw8uTJbj+/ZcsWvP/++1i2bBlXBcio8Dhi6mT48OEYNWoU/vKXv+hdS6VSwcPDA2+++SbWrFnT6eM6nQ6au0qolE1QKxVQKRVQtzRB1XwH6tZmCPXd+UPDbYT/9wIkJCbiww8/7HEdnU6HyZMno7CwELNmzUJycjIGDRokTJN0n9bWVjg4OKC1tRWVlZVGM3mvUCgQGRmJkpIS/O53v8NvfvObR14trVAo8M477yAzMxNxcXFIS0tjcCSjwpUB6mTmzJnYvXs3Ghoa9K6Vk5OD2trahw5KSSQSWPS1gbWjK/oPeRKOw56BS8BYuIf9DJ7jpsM9dApc/MfAQR6A/oOfQN8BAyHr0/17DXZ/UQCZhQzvvPOOXl+PRCLBqlWroFarERUVxSDQi/r27XvvrRZj2SoA2g8LysvLQ2xsLBITE+Hv748NGzZ0GnTU6XSoqqrCihUrIJfLsX37dmzYsIFBgIwSVwaok9raWnh5eSEuLg6///3ve1zn7t27CA4OhoODA44ePSpgh4BWrWpfTWhRQNWsgKpF8f8rC03QqjtP/EfOX4LgsLH49NNP9f7cOp0Ofn5+CAkJwdatW/WuRw+3bt06JCYm4sUXX8QXX3xh6HY6OXnyJNauXYvs7GxoNBoMHjwY7u7u0Gq1qK6uRmNjI2xtbfHGG28gKSmJQ6VktPjiM3Xi6uqK5ORkLFmyBC+//HKPzxxYsWIFLly4gJKSEoE7BKQWluhj54A+dg6dPqZpa4VK2R4S1C0K3KmvQ9WV7xCfFC7I55ZIJAgPD0dRUZEg9ejhOuYGjhw5grt37xrdHQ6hoaHIyspCTU0NTpw4gbKyMty8eRNSqRRRUVEICgpCWFiYoMcYE/UGrgzQA2k0GkyYMAEVFRXIzc3t9uEon3zyCeLj45GSkoKkpKRe6rJrKisr4e/vj+PHj2PMGGEuS0pLS8OiRYseeO4ACUen08HNzQ21tbUoKCjA+PHjDd0SkUnizAA9kEwmQ3Z2Np566ilERERg/fr10Gg0j3yuvr4eb7zxBuLj45GUlKT3Hr0QOs4FEPIceGtra6jVami1WsFqUmcdRxMDxjU3QGRqGAbooezt7ZGfn4+YmBgsXrwY/v7+SE9Px/fff3/fq14ajQaVlZVISkqCXC7HgQMH8Ne//hUff/yxUQxK2draAgBu374tWM3bt2+jX79+kEr5I9TbGAaIeh+3CahLiouLsW7dOuzbtw8ajQaurq5wc3ODRqPBpUuXoFQq4eDggNmzZyMhIQGDBw82dMv3qNVq2NnZYfXq1Vi8eLEgNWfOnIlLly6huLhYkHr0cDdu3IC7uzskEgl++OEHODk5GbolIpPDMEDdUltbi+LiYpSVleHWrVuQSqXw9vZGUFAQQkNDjfZK1oiICNjY2ODQoUN611Kr1fDy8sIvfvELpKam6t8cPZKvry/OnTuH3bt3Y8aMGYZuh8jk8G0C6hZXV1e88soreOWVVwzdSrfMmjUL8+bNw7fffouhQ/W7Snn//v24ceMGZs2aJUxz9EgTJ07EuXPncPjwYYYBol7AlQEyC0qlEt7e3oiIiMCePXt6PMvQ2tqKwMBAODs7C352Aj3coUOHEBkZCS8vL1y+fNkoZlGITAmnn8gs9OvXD2lpacjKysL27dt7XOfdd9/FpUuXkJGRIWB39CgRERGwsrLC1atXUV1dbeh2iEwOwwCZjRkzZuBXv/oV5s6di71793brWZ1Oh+TkZKSmpmLt2rUYMWJEL3VJD2JjY4OwsDAAQF5enoG7ITI9DANkVjZt2oSoqCi8+uqrWLBgAZqamh75zPfff4+pU6figw8+QHJyMt5+++3H0Cn9O75iSNR7ODNAZker1SI9PR1Lly6FtbU15syZg6ioKAQEBNx7G+L27dsoKSnBjh07sGvXLgwYMAB/+tOfMHXqVAN3b75KSkoQEhICOzs71NXVwcKC889EQmEYILN15coV/PGPf8TWrVvR0NAAmUwGJycnaLVa3Lp1CwDg5eWF2NhYzJ8/Hw4One9BoMdHo9HAxcUF9fX1KCoqurdtQET6Yxggs9fW1obKykqUlZWhtrYWUqkUnp6eCAoKgo+PD08ZNCIzZszAnj17sGLFCqxcudLQ7RCZDIYBIhKNTZs2ISYmBmFhYbw1kkhADANEJBpXrlzBE088AZlMhrq6Otjb2xu6JSKTwPVPIhINb29vyOVyaDQaHDlyxNDtEJkMhgEiEhW+YkgkPIYBIhKVjjDAw4eIhMOZASISlcbGRjg5OUGj0eDKlSvw8vIydEtEoseVASISFXt7e4wePRoAtwqIhMIwQESiw7kBImExDBCR6HSEgfz8fGg0GgN3QyR+DANEJDqjRo1C//79UV9fj6+++srQ7RCJHsMAEYmOpaUlnn/+eQDcKiASAsMAEYkS5waIhMNXC4lIlKqqquDj4wMrKyvU19fDxsbG0C0RiRZXBohIlORyOTw9PdHW1oajR48auh0iUWMYICJRkkgk3CogEgjDABGJ1qRJkwAwDBDpizMDRCRadXV1GDhwIHQ6HW7cuAE3NzdDt0QkSlwZICLRcnJyQmBgIACuDhDpg2GAiESNcwNE+mMYICJR65gbyM/PB3c9iXqGMwNEJGp3796Fo6MjlEolKioq4OfnZ+iWiESHKwNEJGp9+vRBREQEAG4VEPUUwwARiV7H3EBeXp6BOyESJ24TEJHoVVZWwt/fH9bW1qivr0ffvn0N3RKRqHBlgIhEz9fXF4MGDUJLSwtOnDhh6HaIRIdhgIhEj0cTE+mHYYCITALnBoh6jjMDRGQSampqMHjwYEgkEty8eRPOzs6GbolINLgyQEQmwc3NDX5+ftDpdPjyyy8N3Q6RqDAMEJHJ4NwAUc8wDBCRyfhpGOAOKFHXcWaAiEyGUqmEg4MD2tracP78efj4+Bi6JSJR4MoAEZmMfv36YcyYMQC4VUDUHQwDRGRSOm4xZBgg6jqGASIyKR1zA4WFhVCpVAbuhkgcGAaIyKQ888wzcHJygkKhwKlTpwzdDpEoMAwQkUmRSqWYMGECAG4VEHUVwwARmRzODRB1D18tJCKTc+3aNXh5eUEmk6Gurg729vaGbonIqHFlgIhMjqenJ4YNGwaNRoPCwkJDt0Nk9BgGiMgk8RZDoq5jGCAik8S5AaKu48wAEZmkO3fuwNHRERqNBhUVFZDJZNBqtXB2dsagQYMM3R6RUbEwdANERL2hpqYGLi4uuHXrFvz9/e/7mJubGyIiIhATE4Px48dDIpEYqEsi48CVASIyKfX19YiPj8e2bdvg6OiI6OhojBo1CnK5HFKpFDU1NSgtLcW+ffvwzTffIDg4GFu3boWvr6+hWycyGIYBIjIZpaWlmDp1KpRKJdasWYM333wTffv2feC/1el0KCgowMKFC1FdXY0NGzZg3rx5j7ljIuPAMEBEJuHs2bMYN24cfHx8sHfvXri7u3fpudbWVsTHxyMzMxOZmZmIiYnp5U6JjA/DABGJXnNzMwICAmBvb4/CwkLY2dl163mdToe33noLmzZtwpkzZzBy5MjeaZTISDEMEJHoJSQkYMOGDSgvL8ewYcN6VKOtrQ3BwcGQSqUoLS2FTCYTuEsi48VzBohI1BoaGpCRkYGlS5f2OAgAgJWVFTIyMlBeXo7c3FwBOyQyfgwDRCRq27Ztg1qtRmxsrN61wsLCEBgYiI0bNwrQGZF4MAwQkagdOXIE4eHhcHV11buWRCLB9OnT8fe//x1arVaA7ojEgWGAiEStrKwMwcHBgtULCgrCnTt3cOnSJcFqEhk7hgEiErXa2loMGTJEsHoeHh736hKZC4YBIhI1iUQCIV+K6tgekEr565HMB7/biUjUhgwZIuiSfkctIVcbiIwdwwARiVpQUBDOnDkjWL2SkhI4Ozvf2y4gMgcMA0QkapMnT8apU6cEWR3QarXYuXMnJk2axJsMyawwDBCRqM2YMQMDBgxAamqq3rUOHDiA6upqxMXF6d8YkYjwOGIiEr2UlBQsW7YMRUVFCA0N7VGNxsZG+Pr6wsfHB4cPH+bKAJkVhgEiEj21Wo2wsDDcvHkTx44d6/Z+f1tbG6ZPn47CwkJ8/fXX8PLy6qVOiYwTtwmISPQsLCyQlZUFAIiIiEBJSUmXn62trcW0adPwt7/9DXv27GEQILPEMEBEJsHDwwPHjh2Do6MjQkNDkZiYiOvXrz/03zc3N2Pjxo0YMWIESktLcfDgQUyZMuUxdkxkPLhNQEQmRaVSISUlBSkpKWhpacH48eMREhICuVwOmUyGGzduoLS0FHl5eWhqakJ0dDRSU1Ph4uJi6NaJDIZhgIhMkkKhwPbt23Ho0CGUlJSgpqYGAGBra4ugoCBERERg7ty53BYgAsMAEZkJlUoFrVYLKysrvilA9G8YBoiIiMwcBwiJiIjMHMMAERGRmWMYICIiMnMMA0RERGaOYYCIiMjMMQwQERGZOYYBIiIiM8cwQEREZOYYBoiIiMwcwwAREZGZYxggIiIycwwDREREZo5hgIiIyMwxDBAREZk5hgEiIiIzxzBARERk5hgGiIiIzBzDABERkZljGCAiIjJzDANERERmjmGAiIjIzDEMEBERmTmGASIiIjPHMEBERGTmGAaIiIjMHMMAERGRmWMYICIiMnMMA0RERGaOYYCIiMjM/Qs2n9VPKcVzVgAAAABJRU5ErkJggg==", + "image/png": "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\n", "text/plain": [ "
" ] @@ -664,7 +662,10 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 21, @@ -673,7 +674,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABscElEQVR4nO3deXxU9b038M+ZmUwmmSSELYGETUBMUBYZEglqbbXIomILtlVbobY19nluWwmIT6+3161X7RIN97Z9WqXLE1q1WokaFQi44MYgIQHZEpAdQjaWJCSTyWRmzvPHLJnJnNnPmZkkn/frhYYzZ37nl4Wc7/kt368giqIIIiIiGrJU8e4AERERxReDASIioiGOwQAREdEQx2CAiIhoiGMwQERENMQxGCAiIhriGAwQERENcQwGiIiIhjgGA0REREMcgwEiIqIhjsEAERHREMdggIiIaIhjMEBERDTEMRggIiIa4hgMEBERDXEMBoiIiIY4BgNERERDHIMBIiKiIY7BABER0RDHYICIiGiIYzBAREQ0xDEYICIiGuIYDBAREQ1xDAaIiIiGOAYDREREQxyDASIioiGOwQAREdEQx2CAiIhoiGMwQEFZrVZUVFSguLgYBoMBer0eKpUKer0eBoMBxcXFqKiogNVqjXdXiYgoAoIoimK8O0GJyWazoaysDGVlZTh37lzQ83NycrB69WqsWrUKarU6Bj0kIiI5MBggSfX19VixYgWqq6vDfm9hYSHKy8uRl5enQM+IiEhuDAbIh9FoxOLFi9He3h5xG5mZmdi8eTPmzZsnY8+IiEgJDAbIS319PYqKitDW1hZ1W5mZmTAajRwhICJKcFxASG42mw0rVqyQJRAAgLa2NqxcuRI2m02W9oiISBkMBsitrKwsojUCgezatQvr1q2TtU0iIpIXpwkIgGP74MSJE0PaNRCu3NxcnDx5EhqNRva2iYgoehwZIABAZWWlIoEAADQ0NKCyslKRtomIKHoMBggAsGXLFkXbr6qqUrR9IiKKHIMBAgDU1NQM6PaJiChyXDNAAAC9Xg+TyaRY+6mpqejq6lKsfSIiihyDAQIAqFQqKPmjoFKpuMWQiChBcZqAAAApKSmKtq/T6RRtn4iIIsdggABA8SyB+fn5irZPRESRYzBAAACDwTCg2yciosgxGCAAwKJFixRtf+HChYq2T0REkeMCQgLADIREREMZRwYIAKDRaFBSUqJI2yUlJQwEiIgSGEcGyM1ms6GoqEjWYkWFhYXYsWMH1Gq1bG0SEZG8ODJAbmq1Ghs2bEBmZqYs7WVmZqK8vJyBABFRgmMwQF7y8vKwadOmqAOCzMxMbN68WfEti0REFD0GA+SjqKgIRqMRBQUFEb2/sLAQRqMR8+bNk7lnRESkBAYDJCkvLw9GoxGlpaXIzc0N6T25ubkoLS3Fjh073CMCot2uZDeJiEgGXEBIQVmtVlRWVqKqqgo1NTWoq6uD2WyGTqdDfn4+DAYDFi5ciKVLl3rtGrjc0ooTn+9G3i03QZuaGsfPgIiIAmEwQLITRRGnqmtx5ov9gCgibdRIzLh9ETRabby7RkREEjhNQEH19vaGdb4gCLjc2go448zO8xdQt+0D2Fm1kIgoIXFkgILaunUrnnrqKcydOxcGgwHjxo2DVqvFtGnTMHr0aMn3dF28iNqNle6AAABGT7kCV918EwRBiFXXiYgoBEwLR0GdOXMGn332GT777DOv49XV1X6DAf2IERg7PQ+NB+vcx1qPnYA2NQWTi65TtL9ERBQeThNQUA0NDZLHg+0ymDj3WmiSvdcJNOw/hLNf7Jetb0REFD0GAxSUVDCgVquRlZUV8H1JycmYWOBbuvjE57vR/OVR2fpHRETRYTBAQZ09e9bnWE5OTkhphsfkTUPqiOE+x7/86DNcPOPbLhERxR6DAQpKamQg1EREKpUKU+b7rhEQ7XbUbfsQHS2tUfePiIiiw2CAgoomGACAzJyxGHnFRJ/jdqsVh7ZsQ3d7e1T9IyKi6DAYoIDMZjPOnz/vc3zcuHFhtTN5XgFUEtMKveYeHNi0FRaTKeI+EhFRdBgMUEDnzp2TPB7OyAAA6NLTMW7WNZKvmS934sDmbbBaLGH3j4iIosdggALyt60w3JEBABg3eya0eukaBV0XLuLQ1veZpZCIKA4YDFBAUjsJgPBHBgBArdHgiuvm+n29/VwTDn/4MZgUk4gothgMUECRJhzyJ2vqFGSMyfb7+vnjJ3HcuCuitomIKDIMBiggOUcGXKS2Gno6d+AQzuzdF3H7REQUHgYDFJDUyMDIkSOh0+kibjNt1EiMyZsW8JyTu2rQfOTLiK9BREShYzBAAUWbY8CfiQVzoNZqA55zhFkKiYhigsEABSQ1TRDJToL+tCkpmDBnVuCTRJFZComIYoDBAPllt9vR2Njoc1yOkQEAyLlmOlIyhwXuA7MUEhEpjsEA+dXS0gKr1epzXI6RAcBRt2ByUWHQ85ilkIhIWQwGyC8ldhL0N2L8OIyYEDy4YJZCIiLlMBggv+TOMeDP5KJCCKrgP4rMUkhEpAwGA+SXnKmIA0kZNgw51+SHdC6zFBIRyY/BAPkVi2kClwlzZiMpJbTcBcxSSEQkLwYD5JfUyEBKSgoyMzNlv5ZGq8WkQv91C/pjlkIiIvkwGCC//OUYEARBketlT5uKtFEjQz6fWQqJiOTBYID8Uir7oD+CIGDK9fPCes+Rjz7DxdNnFOoREdHQwGCAJImiKDkyoGQwAAAZ2VkYPXVy6G8QRdS9t51ZComIoqCJdwcoMXV0dKCrq8vnuNw7CaRccd1cXDh5GnZnwiNBEJCenYW00SORNmokkvV6CCoVRLsdPV1d6Dx/AWdq9+KKeQVIVWA9AxHRYMdggCTFKseAlGS9HuOvnYnGg/UYm38VxuRPgzY11e/52VdOBQBYurth6+2FOilJ8T4SEQ0mDAZIUqxyDPgzbuY1GDfzGqjU6pDfo01JAeCY4lBqkSMR0WDENQMkKZY5BqSo1Gp3IGC1WlFRUYHi4mIYDAbo9XqoVCro9XoYDAYUFxejoqLCXUeBgQARUXg4MkCS4jlN4GKz2VBWVoaysjKcO3fO53WTyYTa2lrU1tZi/fr1yMnJwerVq7Fq1SqowxhRICIa6jgyQJKkggG1Wo0xY8bE5Pr19fUoKirC2rVrJQMBKefOncPDDz+M+fPno76+XuEeEhENHgwGSJLUNMGYMWNi8sRtNBoxb948VFdXR/T+Xbt2oaioCDt37pS5Z0REgxODAZIU64RDLvX19ViyZAna29ujaqetrQ2LFy/mCAERUQgYDJAkf6mIlWSz2bBixQq0tbXJ0l5bWxtWrlwJG0seExEFxGCAfPT09KC11Tejn9IjA2VlZRFPDfiza9curFu3TtY2iYgGGwYD5KOxsVHyuJLBgNVqRVlZmSJtl5WVubcdina7ItcgIhrIGAyQD385BpScJqisrAx510C4GhoaUFlZCQAQVCpYursVuQ4R0UDFYIB8xCPHwJYtWxRrGwCqqqrcHzcfPgqrxaLo9YiIBhIGA+QjHqmIa2pqFGu7f/tafQoOVb0POxcWEhEBYDBAEuKRiljpLYB1dXXuj5P1erQ3NqH+g48giqKi1yUiGggYDJAPqZGB4cOHI8VZCEgJ3QrP45vNZvfHgsrxY3/hxCkc+4yJiYiIGAyQD6lgQOkcA0oGGgCg0+ncH3vuKGg8VI/TtXsVvTYRUaJjMEA+pKYJlM4xkJeXp2j7+fn57o97urq8Xju1ew+a6o8oen0iokTGYIC82O12yS1+SgcDBoMhZu13tl7wef3LT3bgwqnTivaBiChRMRggL62trejt7fU5rvQ0waJFixRtf+HChe6PO1vP+54giqh/bzs6mlsU7QcRUSJiMEBe4pFjAACWLl2KnJwcRdrOzc3F0qVLAQCWLhMuNzcBdjvQbyeB3WbDwS3bYJKpNgIR0UDBYIC8xCsY0Gg0KCkpUaTtkpISaDQaAEDDgYMQbXZAtAN2m/NPX2Bg7bHgwKatPusKiIgGMwYD5CUeqYhdSkpKUFBQIGubhYWFWLVqFQDA1tuL6pdeReuxE7D29DhOEMV+gYGInsudOLB5G3pd5xARDXIMBshLzEcG7HbA5lijoFarsWHDBmRmZsrSdGZmJsrLy6FWqwEAeyoq0XnhItoam3By9x60HD2OXo/8A47AwBEUmM6fx6HN22B3FjgiIhrMGAyQF6lgQKfTYcSIEfJeyG4HrBag1wxYex1P5XBsMdy0aVPUAUFmZiY2b97s3rLYeuwE9r+z2f26KIpob2rGqZq9aD5y1Ld4kSiio7ER9e99ANHaK7nGgIhosGAwQF785RgQBEG+i9itgLUHsHk8dVst7pttUVERjEZjxFMGhYWFMBqNmDdvHgCgu70dH/3hBcnyxaIooqOlFadrvkDT4S/RYzJ5vX7hxCkc+9To6LOt19FnkWWQiWhwEUQmZycPn3/+OaxWKywWC86ePYva2lpYrVb87ne/i75x15SA3U+BIEEAknSO/wOw2WxYt24dysrK/E5feMrNzUVJSQlWrVrlnhqw22yoerYUjXWHQ+5m2sgRGD4+F7q0NPexiYbZmDBnVr/+qgCVyvF/IqIBjMEAxYbN6nj6D0YQAI0WUKndh6xWKyorK1FVVYWamhrU1dXBbDZDp9MhPz8fBoMBCxcuxNKlS927BgA4nuBtVlw4dQabny2DpdskcUH/9MOHY8SEXOjS0wEAV944H2PyrvTTb5Wjz3KOoBARxQiDAVJWsNEAf9QaQJ0U2c1VFB3X8xjObz78JapKfwerJYSApJ/UYcMwYsI4pGQOw/QFX8PIieMDnC30jRYwMCCiAYLBwBDneuresmULampqUF9fj+7ubqSkpCAvLw8GgwGLFi3yfeoOqfFe906ByAiAJin0J27XNkHA8f9+P9pn9u7H+//zAuy2yHYIpGSkY+Skibjuu9/CsDHZIbyDgQERDQwMBoYom82GsrIylJWVSdYi6C8nJwerV6/2mo/3y7VTINqFdoLgMV0gOP4uCM6PAYhw/Ed0/oHHj7JKLTkacXxnNT76018RzY+9fvhwzP/B9zB+5tVhvIuBARElLgYDQ1B9fT1WrFiB6urqsN9bWFiI8vJy6SqDdrtz1b1Me/OjWZyn0jhHB3wDkrr3P4JxwytRdU2j1eKqr92IyfMKMOqKieHtthAEZ1DAwICIEgODgSHGaDRi8eLFaG9vj7gN1x5+19Y9AM7tgr0y7sUXgGAjEEHfr/E7TbH3rU2oraiMon1Am5qKcTOvRtqokRg/ewZGT7kCKlWYwQsDAyJKAAwGhpD6+noUFRWhTYZCPJmZmTAajX0jBFaLfCMCQN+2vWgEGB0AgF0v/wsHqt6P6hIpGenIuWY6VCoVdBnpGD9rBrKmTQk/KACcgYHaYzqEiCg2GAwMETabDUVFRRFNDfhTWFiIHTt2ONYQiCJgMcNr3j4asmzTCzw6AACfrN+ALz/dEdVV0kaOwJi8ae6pguQ0PcbNvAZj8q6EKtLRDc/RAgYGRKQwZksZIsrKymQNBABg165dWLduneMvgvPGKwfZhsydCwtV/m/I1//we77JhMLUeeEiWo+dcP+9p7MLx3Z8jup/bsTZfQdhi6S+gWj3znrIdMhEpCCODAwBVqsVEydODGnXQLhyc3Nx8uRJx7ZDUQQs3cHfFIycyXsEwTFdEGB0wGq1Yttzv0fjofqoLjViwjiMnOCbgyBJp0PujOkYO/0qaLTaqK7RN33CEQMikg9HBoaAyspKRQIBwFHYqLLSuRDPtRguGnIPi7u2HAYYHdBoNFhQ8r8x6oqJUV3q4umzaG9q9jneazbjZHUtdr2yEadq9kZXGtmZVZF1EohITgwGhoAtW7Yo2n5VVVXfX6Jd9KfE067d5gxS/Let0Wqx6JGHkJkzNqpLtRw9gc4LFyVfs1ksOF37BXb/swLn6r6E1WpzBCkqjWOKRaVxjooE7qubKzBwLd5kYEBEEWIwMATU1NTErv1oRgbkGFmQEsLoAODYKrjo/zyEtFEjo7kYmuq/RHdHh2/7+lRMLDDAcPe3kDPjamh0Kc5gQNU3/K9SOwIDTZIjHXOQPvdd1iMwsNu4voCIwsI1A0OAXq+HyRRekZ5wpKamoqury/EXuw3ojXAYXI7thIHaVmscuRCC7HjoaGnFu7/8reQN3d2cWo2sqZMx6opJGHnFROhHDIdKo4HdakXXxUu4eOosVGoVzO1tEEVg/LWzMGHunMh2F0jUWggNsx4SUWgYDAwBKpUqqvS7obRvszlT/0YTDChd9U+dBEAMKR/CxTNnsfnZMvS4ghyn1OGZuOrmr+Kqr30FqcMzg7ZjMZkgiiKS9Xr3sYjrQbie/iPhmn5gUEBEEhgMDAExHRmw2YBes+PjsFL0Kjgq4HkNtSbk+fXmL4+h6rf/A2tPDwSVCjPvWILZ37wD6qSkiC5vt9tRVlaG559/PvJ6EKIrmAnxny1LKxNRCLhmYAiQrCMgo/z8/L6/uKoFiqJzb7znH9H3j0ssblauPoQ4D5995RTc/JMHkJmbizue/AUM317mDgSsVisqKipQXFwMg8EAvV4PlUoFvV4Pg8GA4uJiVFRUwOqRY0ClUuGmm25CampqSNc/d+4cHn74YcyfPx/19c5tj+Hkc1A7FyY6v7aR9JmIhgaODAwBxcXFWL9+vaLtv/DCC46/WHrCL1ssCB6jAs6KhJ6r6eUMFMIcHQAE2OyAWusIAuSo9tjc3Ixbb70V+/btC7nbPvUgAk4ZCF5BgKIVKoloUGAwMARUVFRg+fLlirW/ceNGLFu2zPGXHpNjRCAcKmdZ4kC8AoIoAwa1c5g/lKBFneRuW85qjy0tLbj++utx9OjRkNvwqQfhL6BRqM9ENHgxGBgCYpeB0A6Yw1ybIEC+7YShBgyu0QG7zfHHH7XG3Tclqj1WV1ejqKiob/FlCDzrQYiiCKF/QKNwn4locOKagSFAo9GgpKREkbZLSkr6VrxHMtcsd7ZB9x+7Y4TCdcO325w5/m2OEQFXueX+axnc/VK5b6r19fVYsmRJVDdVAGhra8PixYvd8/8FBQV45JFHwmrDsx6EIAhoOnIcF06diVmfAbBOAtEgxJGBISImVQvNJoRdtVDpHQT+CIJjIaFdosSxIABJOkAQFP+69fT0YPLkyWGN2niOxli6TNj1j5cxLGcsrrltMQTnNk/Fv9e2XtZJIBpEODIwRKjVamzYsAGZmZmytJeZmYny8vK+BWZWC8IOBOJ5A3GNBEj1QdW3+E7pao/JyckoLi4O6/2e9SC0+lSkZ2Vh2NixEJyBVUwqVKrUrJNANIhwZGCIMRqNWLJkCdra2iJuw2ce2W5zVCsM9ycplIWDSnI92fYfHdCmAIIQs7UWjY2NmDBhQlhb+jx3cBzbsRPjZ82EVp8a2wqV/hZgur6uSqSWJiJF8F/rEFNUVASj0YiCgoKI3l9YWAij0eixxU10jAqEm91OiHMgAHjkHfAoDOTxecSq2uPYsWNx3XXXhfV+z3oQaWOyodU7chfEtEKlv++fu05CL+skEA0QDAaGoLy8PBiNRpSWliI3Nzek9+Tm5qK0tBQ7duzo22rmyobnegJ0lR8O5R6fKFPMrhuVytkhjzUMsaz2OHfu3LDeW1dX5/64wyPfQEwrVAYN/kTvBZsMDIgSVoipzGiwUavVWLNmDR566CFUVlaiqqoKNTU1qKurg9lshk6nQ35+PgwGAxYuXBg4T757MZ7N8bEIQBD9Txv03/IXT6IdEJ3VEgXRa2g7ltUeDQZDWO81m83uj4cNGybZphK8K1QKYUwNOQMD2MACSkSJh2sGKDyBKui5XvP8u9SPV7zXCvTnmuMWRcc+fWe64ljWdPjwww9x8803R/TeS5cuYfjw4QBiXaHSDtijTF3sKlvNwIAorjgyQKFx790PkCDHc5W510p9j1GCRBoVcHGPDnj3q7u7W9HLej7da7XasN7rWQ+it7dvIV8s+yzLt1EUAdE5YsDAgChuuGaAvPVP2ONaCGbrDRwIuLh/oQt9f4fnOoIE/SUvekUrAICUlBRFL6nT6dwfWyyWsN7rOa3gmVgoln0Oe/dIMKLHGgNbL5MbEcUQgwHy5loLYLd6TAdEkD+gf0Dg+nuiPvG5RjM8PtdYVns8e/ZsWO9duHCh++Pezk73xzGtUCl7NODZtOj4GXTlMGBgQKQoBgOkjP4BAeCYQlCpEzgg8F7jEO6ivnB5th/Owr/c3FwsXboUAGDp6oLO1Dd0H8s+x+zmLNoZGBApjMEAKUdyhMBjXjjRuKZInBYtWqTo5Tyf7nfv3h3y+zzrQTQeqsfl5hb3a7Hsc1xuyAwMiBTB3QTkLVglv0hJpf7tv/sgEQgqICk5YTMQetYIsNtsqP77y+jtNqNwxb3Q6vWJkYEwHpj1kCgq/JdD3pSKDTVa95Y9N9fug0SaNvAYHYhVtccXX3wxpECgfz2I09U1sHSZINrtaDpUH9M+w271WGeRANxZDy2sk0AUAY4MkDclfpEKKsf+fcD/3nTXDoZE4DE6kChVC/vXg7jc3IK9G99034y1+lQUrPguVLGqWmgxw72AMJEXhwqqxAs4iRIQRwZIeZ5lilUqR1XA/hLpl7bH9IXS1R6ffPLJoIFA/3oQFpMJ9dvedwcCKZkZyPvqDVA5gyzFK1TaeuG1k8CVfyIR0w2L9rinQ7ZaraioqEBxcTEMBgP0ej1UKhX0ej0MBgOKi4tRUVERVqEqIrlxZIC8yT4yIACaJN/DnumMvY6LCTD87Lx2ks49taFEtcfq6moUFRXBZpNeN5Gbm4uSkhKsWrXKfSO2mEzYX/kuTBcuQlCpMOHaGRg382qoXDfqpGRF+wy7DejtCfwmqZ0kCSU26ZBtNhvKyspQVlYW0hqOnJwcrF692uv7TRQrDAbIm61X3huxazuhlECL0OI1beDaXijA0e8knfuGUV9fjxUrVkQ0/F5YWIjy8nJ3HgCz2Yynn34amzdvDrkeROuxE6j+xytIGzUCmTljcOX185AyLMP7QoKgWJ8hikCvOfSfD/fUQYJOIQBQKjCQ9etOFAMMBsib3MGAOinwL9mAAUEsRwmcQYDnpVTOJ1yPm6vNZsO6detQVlaGhoaGoK1KPd2Hy9bbiz0b38L+tzdDpVZhxpIFmPPN2/2/oV9AIEufww0EfPqUwOsKXGRKh2w0GrF48WKvzJDh8hmRIVIYgwHyZu03HxyNQKMCnlylkKWu63pSV3R1uAjYJa4toO/G0G83hNVqjajaY9fFSzDbbRg5alTQXpkuXcLh9z/C4Q+2w3SpDRlZozHqiolQJyUh72s3YvSUSf7fLGOfYbc5VunL8asi4acQnCIMDOrr61FUVBTV1IxLZmYmjEYjRwgoJhgMkDdreDnyAwo2KuDJlX7W34+jUjkJ/FVWdPGssKjSONY/RHAjs1mt2PP6G9hX+S5WvfkaZs6Zg7lz58JgMGDcuHHQarWwWCw4e/Ysjh+qw9xkPVqOHodosyFJp0PW1CuQOmyYu9CTSq3GzNtvRfroIEGFWhPe98GTa9RGam1HtAZKUAA4+6oOOrKh+C4OIgUxGCBvcgUDntsJQxWoPLLrddmmDSSmBaS4Rgdc77ELgDbZOc8c/EZms9lw6IsvcLLibbQeO45L3SY8/NbrAd+TnZ6BZ277JgRBwPBxuRg+Lgcqzx0ZzstqU1Nx7TeWQJuaGvyTUGscf0K5+bq+znKNBgTs2kBYV+DBc7SgX39LS0uxdu1a2S9ZWlqKNWvWyN4ukScGA+RNrmAgmqfRQAEB4ExBG820gZ9pAX9cowNRPGXbenuxt+ItvPrievz2g60Bz81MScH/ve9HyJpyBbSpAaoQCkB61ijMWHIr1JoQAy/PTH2en4dnoOU6HusMkQNhXYEnj+2wMcv8SKQQ5hkg+UXzC11w3nQDpZVVqUJbiyBFDDMQcElKdszBOz+vcPeOq5OSYPjOXfjx79Zh6tSpAS/VK4oYN2N64EAAAETgcvN5fPmJESGv8/DM1Nfb0/fHlbnPcy9+rG/M7nwF8d5aGiKPwKmyslKRQAAAGhoaUFlZqUjbRC4MBqiPXL+ABRnmN9WawDf8sFMZu6YFwi3HrAK0Ke6+2Gw2lJaWYuLEiVi+fDnWr1+P2tpamEwmiKIIk8mE2tparF+/HsuXL8fEiRPx3HPPuXMJTJ6ej08//RQzZ870e8me3vBy/rcePYEze/Y7Pkc5Fn96fo3ikes/kZMYefL42duyZYuil6qqqlK0fSIGAyQ/lUw/VsF2I7gCgqDXizQQEIBknfuG6Fopvnbt2pCfAs+dO4eHH34Y8+fPR329o35AdnY2tm3b5neEwGqzweonEZE/J3fvxYWTZ5yjHtHeQD2DgTgO27umKVzTRokWGHh8XcIpQR0JpdsnYjBA8op0+D5Qe1Lpiz0FTGXsnBaI5D6i7QsEXOmAI10pvmvXLhQVFWHnzp0AgKysLLz88st+V4mbLeGv3Ti8/VN0Xbzk/HztiDgo6B84xbsSoCg6a1ok2hRC38+bK9BTSl1dnaLtEzEYIHkpceNQhbAzwXNfuEuk6wMAxxZCZ2BTX1+PJUuWRJVEBgDa2tqwePFi942joKAAjzzyiOS5ZkuQlL8SbL1WHHpvO3rNZkccEFVQkCCjA/0l0roCjy9Jd3e3opcym82Ktk/EYIA8RPnLVcl946FsVRQ8UstGNazsTNgDxxqBFStWyJJEBnAEBCtXrnSvIXj88ceRk5Pjc153T2S7OsyXu1D3/sewu1I5u4OCMKcP+n/t4j060J9s6wqEvmDHvW1Q1TdF5RqZcm3NVCf1/fH4mqSkBFnsGSWdTqdo+0QJ9i+cBjS5pwj6E1SOX8KBiK5th4LXk1tYPBILlZWVyZpEBnBMGaxbtw4AkJycjOLiYp9zeiKYJnBpb2rBsR27vA+6R0lCDAp8pgoSaHQA/fISeNax8LqR+7mJa7QefzyOqz3O9woGPIIEQZD8WiidJTA/P1/R9okYDFCfqB6wYpRNThCcAYHEteyeN4UoEtk493NbrVaUlZVF3NVAysrK3NsOi4uLffaQd0cwTeCp6fBRNByUmMeOZJTAJerRAY/vieDnidz9ZN7/6VztcbNWO/70v2EDffknvPIp+L+Jy8VgMCjSbqzaJ2IwQPKQawdBKFy5CFwBgb9ERZHcAFw3EMRu7/jYsWNx3XXXeb0ezciAy/HPa3DprET/Q11P4B4ZcN7EXTfocG7ink/bkjdx5428/5/+N/Bwvod2W18a5RitK1i0aJGi7S9cuFDR9okYDJCHKObYYz2n7BkQBFtM5r6hhNJu31RHLPeOz5071+u1bosZUa/hEEXUbf8E3R0d7vu5449HCmD3/V7iJq5S9Q2lazyG2MO5iceTaPcICpQth7106VLJtR9yyM3NxdKlSxVpm8iFwQBFT+m1Av64UuiGdJMPsTCOxwhHLPeO9x8Gdm8tFML94/00bbNYcfC9j2DttUoPmXvOu3tmHnTxWUgYh8AvWq6si7ZexXYhaDQalJSUyN4uAJSUlDAVMSlugP2rpoQU6ydAV8ljuxV9mQhD/FEONkrg8bnEcu/4uHHjvF7rsfSir5PhRAO+uts6UPeBxw4Df6S27Uk9Uccr+IuWqzKmrVeR7IYlJSUoKCiQtc3CwkKsWrVK1jaJpDAYoD6R/HIMKyWwDFyBQP+blMdcf1DuxYWSL7o/iuXeca1W6/Vat2tkQHT/JyptZxtxcldtaCe7Vud7Lsj0NBBHB/pTYF2BWq3Ghg0bkJmZKUt7mZmZKC8vZ/liiokB/i+a4i6WNwW7cw7Y383RNW8dCr/TBn1tx3LvuKXfgkFzj8duApkCgoYDdWg6cjTEs51TMHardEAwUEcH+pNhXUFvby8OHz4MwLHFcNOmTVEHBJmZmdi8ebN7y2JTU1NU7REFw2CAIher7YTuHPXW0PoUzs6G/tMGHk+Jsdw7fvbsWa/XzL0ylZLu5+inn6O9qSX0N4giYLP4PkEPhtEBT/3XFYThoYcewu23346WFsfXtaioCEajMeIpg8LCQnf6awBobm7GjTfeiD/84Q8RtUcUikH0r5liLhZPh655XnsYhXtcK+NDPt9j2sDjRhDLveP9Fyua+2cglGl0QLTbUffedpg7u8J4k9j3BO051z5YRgc8uX7erKGtK/jjH/+IP/7xjzh69CgWLFjgDgjy8vJgNBpRWlqK3NzckC6dm5uL0tJS7Nixwx2INjc3Y8GCBTh69Ch+8pOfYP369dF9fkR+MBggD2HcbGKxdcx1A4pkTte1sDCc811pjJ1iuXd89+7dXq9JFiqSKSDoNffg4NYPYAu1VLJnNkLXXLsrOBtMowNeRO/PVeJncPv27fjZz37m/vu+fftw/fXXu7+XarUaa9aswcmTJ7Fx40YUFxfDYDAgNTUVKpUKqampMBgMKC4uxsaNG3Hy5EmsWbPGvUaguroaN9xwA/bv3+++xoMPPojy8nKFP3caigRRjHe1D0oY4dx4VRplEw258s5HyzXFEKKeri6o04ZBo9XCarVi4sSJiiQeys3NxcmTJ6HRaNDU1ITx48e7MxICwIK5hfjPlfdLv1lw/ycqIyeOR/7Xb4IQSlAnuUDTmYhIju/TQOBRHfP48eMoKCjAxYsXfU5LT09HfX19VHkHjEYjbrzxRncNC08qlQovvfQS7r777ojbJ+pvsIb1FImQw0JBuUBAFL2fPKPl3noY+IbXdq4Jh977CLv++QbOfeF4EovV3vGXNmzwCgSAUKoWRh/DXzh1BqdrvwjtZMkg0SPz41B4pnCOVHVcuoClS5dKBgIA8Le//c07EIjga1NUVIRf//rXkq/Z7XZ873vfw8aNG8Nul8gfBgMUPsUCgSimBQLxs3PAarGg4WAddr/+FvZv2oYLJ08DoojGg4dgdz6RKb133G6z4dWXX/E5R3KawEXGL8/pPfvReuxk8BMDfk8EmSoIJj6bzYbvrViJgwcPSr7++OOPY/ny5d4HRdGxBiHMHQtr1qzB008/7bcfd999tzulNVG0GAyQhxB/kSsxT2y3OX5ZKsUjIOi8cBFffroTn7/8Oo4bd6O7rcPrVEuXCaerHQv6lN47frq6Bh0ST5gBgwFAtvUDAHDk4x243Ho++In+bvSu9SPuXR+Dd6TgF489jrffeVfyteXLl+Oxxx7zfcFVAyKCEZRHH31Uuk04Cml961vfUjxtNg0NDAYoPHJvJ3RnE1R23tlus6Hl2AnsfbsKe958F031X8Ju9X/NM7V7cbmlFYBye8cbT53Cmdq90CUn+5wbfJoAsgUEdpsNh7Zth8VkCnK9QPUfPH6VeGYyHERefuWf+NVvfiv52uxZs1D+l/VQSd3wvf4e/r+dJ554Aj//+c8lX7NYLPjGN76B999/P+x2iTwxGKDwyLmdzF82QRmZL1/GiV212PXy6zj84SeOG7ygCv47WRRRv/U9WEyOLIRK7B3/7eNPAKIIXb/sg0AIIwPenY2oT54spm4c3LYdNmug0ZkQikF5nW4HbBLVJAeg6urd+GHxg5KvZWVl4a2K16HX6z2SGHnWQYju+yMIAp555hm/61d6enpwxx134OOPP47qOjS0MRggh1CGL+UcFQiWTTAKoiji4pkGHKx6H9X/rMDZL/aj1yP1L4CQPhdzewcOVL7jDgjk3ju+Zft2AIguGJDxy9fZegFffrIzwLXE0EcH+t7kTGs8cNcTnDt3Dncuv8srfbRLUlISKl57FRMmTPB+wZ2vwOI9bRLhPx9BEPDcc8/h3/7t3yRf7+7uxpIlS7Bjx47ILkBDHkthUejkWDjomldW4Gmx12xG8+GjaKw/AnPH5eBvcGUetPu/SXVduIgvKt5E3q1fR3rWaPfe8YceegiVlZWoqqpCTU0N6urqYDabodPpkJ+fD4PBgIULF2Lp0qVeFeeqq6tx77334ujRo1CrVDBZeqDT+k4TdPeEME3gIgIQRMix3bD12AnoR2Ri/KxrAl1M+iXPtQM+bxMB0RZ69cgE0d3djW8s/xYaGxslX//TH36P66+f778BV8ImEc6tiYgqIPif//kf9PT04M9//rPP611dXVi8eDHee+892Re90uDHPAPk4NrS55fgqGkf9TWskHs0oKOlFY11h3H+2En3LoAwOxYwIAAACALGz5mNCQUGqCIoHNPT04Mnn3wSv/nNb7z2jpf+5CF88sUevPWJ9xBvkkaD98t+F95FZMo/AADTF3wVIyeOl7hGkGROoeZ18CylnKBEUcT3VnwfL//zn5Kvr/rZT1H2XGngRvqPiKjUfX8i/Nztdjvuv/9+bNiwQfL1zMxMfPDBB7j22msjap+GJo4MUGiiXStgt4dWWyBENqsVrcdOoPHQYXSevxBlawKgEgIveBNFnKnZg+b6wxhz9XSMnZ4HrV4ftOVz587hxRdfxPr16yWTF+398ojkyECv1QqrzQZN2IGHPCMEh7d/ill3LIJ+xPB+zTunCvzdyAKNDni14/m0nJizlb8pfc5vILDw1gX47a9/FbgBqWkVQXCuK7A7v1bqsD9/lUqFv/71r+jt7cUrr/huS21ra8OCBQvw4YcfYsaMGWG1TUMXRwbIwVWoxR91UmRPMq5hUpl2C3S3d6Dx0GE0HTkKW1iL7EIU4gp4QaVCenYW0kaPRu6M6dBlpMNxE3bcAN546y0893wZPv/8c5+EQp6uvmIy5ublo3yz73a1Tb99Hmm6MCsnyjg6oEtPw+w7FyPJo7oigODlosPM+ugOxhIotfHb77yDO5fdBalfj9OmXYnPP/s0+O4Sqa+DWur5S+j7mobxb8xqteLuu+/2m3woKysLH330keIFt2hwSJx/fZS4Ih3SjKTIkAS73Y7zJ09j/+Zt2P3aG2g4cEiZQAAI+SlNtNvR0diEc/v2w3K53VnYxuqufHflpAn47LPPAgYCAFB/6qTfevXh7Shwdcz9n6iZL3ei7v2PYe8fIAV7fgh7+D+xFhkePHgI9963UjIQGDZsGCorNoa2zTTkzyV4HQQpGo0GL7/8Mu644w7J11taWnDzzTfjyy+/DLEfNJQxGCCHgAnmIvgxkSGboMVkwunaL1D9z42o2/Yh2s7KXyNAUpjDtro0j+kC55z6NdfMwOxZM4O+12a349LlDsnXzBZLZA/5MgYE7Y3NOPbZ5/3aD7KrAIjwZ8aVtCh+QcGFCxewdNkydHZ2+rymUqnw6sv/wFVXXRViaxJTBMG4goL+JaP90Gq1+Ne//uW3qFZjYyMWLFjgN3UykQuDAXIQBGfxIbXzF7nzF1ckK7+jzCbY3tiE+g8+xq5XNuJUzV5YuoIkw1GCKoRcBABUajW0qamS77/x+utDulTTBek1Dz290Y5+yHNDbTp8FA0H68J7UzSLA+OUybC3txd3feceHD9+QvL10l//CgtvvTW0xkIJmAK+3yNfQZCdN8nJyaioqMAtt9zi89rUqVPx+uuvY8SIEe5jVqsVFRUV7iqKer0eKpUKer3eXUWxoqIi6KgWDS5cQEgOkkljwvxl5poWiOCXoK23F81fHkdj3WGYLl4K+/2KEFQA7AHvqclpEoGA08hRo0K6TENri+Txbkuv83sihn9fl2cdodvxnTVIHTYMw8c5C/AEWkToIqgc2wkjFeNFhg+VrMb2jz6SfO3+lSux6qGfSb6mKPcOnMDrClJSUvDWW29hyZIl7uRDM2fOxLZt25CVlQXAUc+grKwMZWVlkotZTSYTamtrUVtbi/Xr1yMnJwerV6/GqlWr/E5l0eDBkQHyL5ynuwinBbouXsLRT3fi85f+hWOf7UycQMAlSLbC5PQ0v68dO3Y8pEs0tLZKHjdberxHacIl43QBRBF1H3yM7nbnlEYoeSLk2joYg0yGf/zTC/jjCy9Kvja/qAh//MPvQiv17CL7iEbwdQV6vR7vvPMOioqKMHXqVK9AoL6+HkVFRVi7dm3IJbnPnTuHhx9+GPPnz0d9fb2snw0lHo4MDEFWqxWVlZXYsmULampqUF9fj+7ubqSkpCAvLw8GgwGLFi3ySZjjl2ueN0R2ux0XTpxCY91htDc2R/GZxEiAEQJdgO2FdSH+ArX52cHgXkCoUjlvACE1503GhEQ2Sy8Obv0As+9cAo1WG5vRATdnLghBlD1p0faPPsLPSlZLvjZ+/HhU/OtVJEvUjwhM6pslV/ZOGwCbc8TEe3Fveno6Nm/ejHPnzrkDAaPRiMWLF6O9vT2iy+3atQtFRUXYvHmzO502DT7cWjiEBBsm7C/oMGGY2QTNnZ1orv8SjfVfore7O9zux5/EPPDEubMxYfYMn6Fsu92OjBGj0NXVFfHlHrv/R/h6QaHHtQNPWQQk45bDzHFjcfWtN0Ol1oQ2fG+3y/9UL1Mmw+PHj6Og6HrJBXapqan47KPtmD17VniN+ttaqdR0hysRlMSiTdeIQFtbW9SXyczMhNFo5FbFQYrTBEOE7MOEIRYZEkURl86ew6FtH6L6nxU4vWffwAwEAMlhb52faYIzZ85EFQgA/SoXCgIAQdZ1AJFqO9uIk7tqEXJkokSWQRkWGXZ0dGDpsuV+V9pv+Ntfww8EAlHqe+f6t2jt9fp62Gw2rFixQpZAAHAkM1q5cqVXBk0aPBgMDAGuannV1dURvd81TLhzp2cRm8DV2Hp7etCw/xBq/vUmDmzehgsnTyfEHvKoCc4EOU7JfqYJQp0iCMQnz0A0AYGc6wcANByoQ1P9kRALXCmYUCjCcsk2mw3fW/l9HDx4SPL1x//zF1i+7JsR9ileP+fOf5PO4KusrCzif/P+7Nq1C+vWrZO1TUoMDAYGufr6eixZsiTi+UKXtrY2LF68uG+EQJDOQtd5/gKOfPwZdr38Oo7vrO5bcDao9AUEunTpYODQoTC34kkw90gFA87rJ0BAcPSzXWhvagrtZKVrELiCghCnI/7z8Sfw9ju+WR8BYPmyb+KxX/xHNJ3xczwGwzrOf5NWqxVlZWWKXKKsrIzbDgchBgODmOLDhM56BTarFc1HjmLvW5uw54130Hz4KOyD/peFAEHjJ8cAgLr6w1FfodsiUbkwgQIC0W5H3bbtMF8OtUKkwr9uxNAyGb78yj/x7K9/I/na7FmzUP7Xv0AV6dx+tPkFotI3jVVZWRnydGC4GhoaUFlZqUjbFD8MBgYxxYcJBQGXzjVj18uv48hHn+Fyi/QWucEqOS0NgmSueeBQne/IQFJSeJt3eqTSEXs9Ycd/DUFvtxkHqz6ArTdQxUunWFUoDJDJsLp6N35Y/KDk27KysvBWxevQBy1AJfSt5FdpHPUGXAm7/CzkiwmPr++WLVsUvVRVVZWi7VPsMRgYpGI1TKgfORK2qDPlDUzJaXqPldx9v4hFUZQMBqZMmRJW+5IjA0C/ACCCgEDm6QLTpTYc3v6pZC5/L7EYHfDUb5HhuXPncOfyu2A2m31OTUpKQsVrr2LChAn+21OpHQW7NEnOAEDdlwhI5QwO1BpAqwO0KY5zYxmtefwM1tTUKHoppdun2GMwMEjFaphQq09FunM/81Dj3kkgCM5qdI5fxs3NzZJTMzd/7WthZXKTHBkAJG6ocQ4IRDsunDyNU7v3BD83VqMDnkQ7uru68I3ld6GxsVHylD/94fe4/vr50u8XVI4bezgFuwTBETRodX2VChX/3PvaVzpJUJ1EsEsDG4OBQSqWw4RpWaMVvVai0qV5bCv0CAikRgUAoMBgwB233xZy+33piCX4HI5jQOBs4sze/Wg5GiTrYqxHB+AYqfnRj/8XqndLP82u+tlP8YP7vy/9ZrVzGsD5fQg7r78gABotkBRu0qIIeHz/uxXevis1ukIDGzMQDlKxHCZMCzEH/2CTnNZvbtkZEPhbPDg9Px+jR4/Cm295L77SaDSYN28e5s6dizlz5mDcuHHQarVITkrC+OEj0Nl6Hp0trbjc3AzRLvZdy2dYXnBmG0SY93j5Chl8+fEOpAzLQProAD8TgiDnLEVQv3nuebz86muSry28dQF+++tfSbwieAUBUef1d60lsFmh2Cfv8W1MSUmByaRcgS+dTqdY2xQfDAYGqVgOE2r1/ov1DGaSCYcEAYfqpL/2+fl5MKTOQW5uLhoaGpCTk4MHH3wQDzzwAMaOHev3OtlXTgUAWLpMaKyrQ9OhekclR0GqgJGzsJHzf0HJFQc4UxPbbTYc2voBrv3m7X53WrhHBxSsNeDy9rub8O//+bjka9OuvBL//PsGaKSmbjwCgfr6eqxYsSKsxbiuhF2vvfYaysvLHVn7XKNHthAWW0ak7xuel5eH2tpaha4D5OfnK9Y2xQeDgUEqlsOEdadO4p7Hf4EJ2dkYnz0G47OyMCF7DMZnZ2NkxrDwCrwMIP6KFElNE4wbNw7p6ekAgB/94H702ux47LHHwsp5r9WnYuJcA8ZfOxund9fiTO1ePzfUSAKCaKOCvvdbTN04uPVDzLx9IdT+alvEYHTg4KFDuHfl/ZILG4cNG4bKja8hc1iGY5GhK7Wx4D0iIHtef3dAoMDWW4/P02AwKBoMGAwGxdqm+GAwMEjFcpiwx2JBQ2sLGlpbYDyw3+u8VJ0O47OyMT47G+Ozsj0ChmykhF38JYEIQr8n374bqdTiqun5ffnc//3R/0Cyx9cv3MJRKrUak64rwMgrJqF+63swSyZ2inFA0O+tna3n8eUnO5D3ta9In6/w6MCFCxewdPm30dnZ6fOaSqXCq/8ox1XTpvUdFO2A6AoEHGsa5E7Y5c7r70rYJePn3nWpDZdbL2LMdMfP2aJFi7B+/XrZ2u9v4cKFirVN8cFgYJCK5TDh2bNn/Z5nMptx+PQpHD59yue10ZmZGJ89BhOysjEu2xEoTMgeg+wRI6GOQf36aCTrUyUT01y4cAHNzb6VGKfn58M1D52skWceOj1rNGYtuxMHKt9F1wWp/PphBgQAops38H5v69ET0A8fjvGzZ0ifrtDoQG9vL+6653s4fuKE5Oulv3oGCxcskH6zc+W/Ugm7duzY0beGwBZdMGBqa0fr8VM4f/I0TG3tEAQBIyZNgDY1FUuXLkVOTo4iO4pyc3OxdOlS2dul+GIwMEjFcpgw0sWKrW1taG1rQ+1h7zn2JI0GuaNHY3zWGOdIQrb742Fp0kPzseavQJG/LVfXzStSZB5am5qKa5beji8q3kTP5U6kZ2chLWs00kaPQrJeD0GthmizoaerC50t59HZ0oLLzS0QpXL5Rz1T4FvS+GR1LVIyh2HUJIn9+wqNDqx6+BFs//hjydfuX3EfVv30J9Jv9Pj+KJmwa82aNX35KcIo/Q04AoDzJ06j9cQpmNq8RyxEUURT3RFMMMyGRqNBSUkJ1q5dK+enAAAoKSkJrbQ5DSgsYTxIVVRUYPny5Yq1v3HjRixbtgwAcMMNN+Czzz5T7FqeMvR653TDGPf0w4TsMcgdPRrapKSY9AEAsqZNwVU33dB3QJ0ECALWr1+P4uJir3M1Gg0uXrzoXjMQ7Tw04Cgn61lfvqerCwIAbdDseYClqwuNB+vQdLAOFqnKitGUO5YYLVFpNJh95xLoRwz3Pd9fud8I/Wn9n/G/fvqQ5Gvz583DB1Wb/K/T0KYAggCr1YqJEycq9lR98uRJx81UFENaTOgOAE6ehulSW8BztampKLjnLqjUathsNhQVFcka1BQWFvaNbtCgwmBgkIrVL7T2i5dw353fwMnGBpxubka7xBxtLKgEAdkjRnqtSXB9PDozU/ZFjBOunYmJc6/tO+AMBkpKSnyquj366KN4+umnASRWfXm7zYbTu2pwpnaP7zbFSAMClSD5Pl16GmZ/4zYkSW1Js9tlGR3Y/tHHWHDbHZJFdMaPG4fqzz5Gdna29JsFlSNBEGIbSMPaC6m5knACgP7GXzsTkwocI3eJ9PNGiY1jPYNUrIYJ244fx9p7v+d+raOrC2damnG6uQlnm5tx2vlxQ0sLLAoWL7KLIhovnEfjhfP4/NBBr9d0Wq3XIsbx2c7ph6xs6FNSIrqev50E/acJcnJy8NhjjwFQfh5aFEVs3rwZb775ZugLEYsKMXLKJNRXvQ+zz0hFBPMGElMFAGC+3IlD2z7EjNsW+q61kGHtwPHjJ7D8nu9KBgKpqamo3PgasrKy0N3dja6uLnR1mdBlcv6/qwtZY3MwfcZMALFJ2OUOBjzyRUQTAHg6s3c/Rk6aiPTRo5CXl4dNmzZhyZIlUf3cuUaiGAgMXhwZGMSUHia022yofvlVWDolhpr798VuR8ulizjT7AgOzrQ0uz9uuXRJtv6Fa0RGhnsbpHv6ITsbY0eOkt5/7jTjtluRmeORG8A5MjBhwgScOXPGffjJJ590BwOlpaWKBGelpaWOeWjn9Z544omA5/skxAFgMZlw4K130XXhQt+JEY8O+F/8OSbvSlx5o0TaX+fogN1ud96svW/YJpMJXSaT5I38YtslvPra67jk52Y3bFgGbDY7TCYT7FJrJQBs2LAB9913H4DYrLfZvXs3AMBqNuPc/oNRBwD96TIyMOvOJdA6g91I1qi4FBYW9uVKoEGLwcAgp+Qw4cldNTizd5+zbKs94tKtZksPzra04HRzM844AwXXx11xSnuqVqkcixj7TTlMyM5GZlo6Cu5ejpSMdI83JOFyZycyMjLchzQaDU6fPo2xY8fGbNqmsbEREyZMCKnefP9f8hZTN77Y+Kb3CIFEQGC12dDd0wOzpQfmHgu6LT0wWyww9/Sg22KBudfiddzzXLOlB0JqCmwqlePG7nFT7+rqilua2w8++ABf+9rXAAB6vV7Rbbmpqanocq7VaDvXiP3vKDMSoR8xHNfcttAdENhsNqxbtw5lZWVoaGgI+v7c3FyUlJR4BY00eDEYGAKMRqNsw4SuBWuXW1qx9613vQOAKIOC/kRRxKXLlx0jCc3N7umHM83NOHe+FTY/T3lKS0tJwfRrrsZV067CtGlX4qpp03BV/nS0d3TgK1/p21d/ww034JNPPgGQuAs6+39fjxw6hB/ftwJd3d19N3f3Td3xsdUm34K/RPHpp5/i+uuvB+DIQ6Dkr0WVSgWb82vY3tSMfZWbFLuWLiMDebfc5JUe2pXXoqqqCjU1Nairq4PZbIZOp0N+fj4MBgMWLlzonk6ioYHf6SGgqKgIRqNRtmFCi6kb9R98LLHoTAAEtWxBgSAIGJGRgREZGZh95TSv16w2KxrPX8Dp5iacbm7G2Za+6YeLHVJJeOTT2d2NXdW7sat6d8Dz5s6d6/44lvPQc+fODTkY6J8QZ9r06Zi38FY8++yzSnY34Vg8KkTGMmGX5BZPGZk7OnCyugYzlvQlCdJoNFi2bFnfugUiMBgYMvLy8mA0GqMeJrSYurF/UxXMgW64MgcFUjRqjWOePzsb1/d7rbPbhDPNLd5TDi2OEYWeXqXywvuaM2eO++NYFo4KN1Vs/4WIjz/+OMrLyxUrgR0Kf8WbLBYLzp49i9raWuzevRs7d+4MaUokGM/EWbFM2NUjtbVTRoJKhSnzr1P0GjQ4MBgYQtRqNdasWYOHHnooomHCyy2tqP/g48CBgKcYBAVS0lJSkT9pEvInTfI6brfb0drWhjMtTc41CX1TD80XL8o+NDxu3Dj3x7EsHOV53VB5JsRJTk5GcXFx0IWISgi1eJNrsV9jYyNefPFFvPjii+7g5YorJmH0qNHQ6/XQ61Md/0/1+Fivhz7V8XGq8//5V1/tbjuWCbs6Wy8EODN6uTOmIzUzU9Fr0ODANQMUlN1mw+mavTjzxf7obugxDgrC0dPbi4bWFueWyBacdo4knG5uwuUIh4zjNQ/92Wef4YYbbgjyDl+RLkQMqX+CAF1yMnRaLVKSk6HT9n2cOWoUxkwYj+V33YXb77gjonnqnp4ePPXUU5h6xSTc//2VEfRQADSOpFWxXN/xxVvvoqO5RZHraPWpmPvtZVDHMBkXDVwcGSC/erpMaKo/jKa6I7DIMYcap5GCUCQnJWFyTi4m5+R6HRdFEe1dnR5bIltw0WrBqcZzOHr0GHoDTDvEax7a87rhaGhoQGVlJZYtW4axY8firjuW4tAXX/TdxLXJ0CVrodMmO2/oro8d/9clO89xfazTOT/WQZukcSZ+cv7x2KCgGzYMs++8DUkpkRdvSk5OdiR2Eu0RVgQU3TkSYpXX32Iy4XJLq+zXcJk8r4CBAIWMwQB5sZjNOFP7BTpbz+NyS6syT7MJHBT0JwgCMtPSkZmWjhlTpgIArlm8AMPH5cBqteLUqVM4fOQIPvz4U5SWlnq9N17z0IEKRwXjuRDxv0pW49wX+31P8txuKHgd9H5dUAXMOQD0bX9zBQLRFm+CoHLkfLBZEXYmI9EOCOqYJexqrDus2GjRsJwxGD1lsiJt0+CU2KXhKObUGg3OHTiEjuYWRYe1AfQVa1GpJbPWJSpXkSKNRoMpU6ZgyeLFXosFXTxv/krXf5ejcFT/96ZljXY/yHv9AZzfO1VfOV5B6PvjPinwz48uI8NrH7wrJ8batWtDfip3FW+aP39+37oMQXBXHwyL3eYOTEtKSlBQUBB+GwEUFhZi1apVzkvZ0FR3RNb2XQSVClOun6dI2zR4MRggL2qNBinDMoKfKKcBFhQkp/kWA5KqVujKMgc46ssrybO+vOd1w+X5eSSnpXl8T/r9EUUEffIWRb+jPoIgIO+Wm9yBgNFoxLx58yLOlrlr1y4UFRVh586drguEFRCY2tpxes9+NBw4BMCx2HbDhg3IlGnxXWZmJsrLy927ck7X7JVn6k1CzjX50A+XKApFFACnCciHfuQIdLcru1df0gCYPtCmpkAlkY3t0KFDPsf2798PURQhxHAeurGxEZ9//nnEbXlmABRcQ/yCCoDd995vF52FiQLwU95g3OwZ7kQ49fX1WLJkSVRVHAHfnAnuUQs/RZC62zvQevyUdypgQUDGmGxF8/pfbml1LMZVgDY1BRPmzFakbRrcODJAPvQjR8S3Awk8UpCcJl2gSCoYmDJlCj7++GMAfYWjlOA5D/3iiy9GtQPAcyFiyrB0TLh2BkZNmoCUzEzpG3/QaoO+r2tTU903LKWKN7l2VkDlHbh1t3fg9N4DqHnjXeze+DZO7dnnXRNAFFH//kewdHcD6EvYFemUQWFhoXvUAwiQsEsmV8wrgEarVaRtGty4tZB8XDx9Bge3vBfvbvRJoJGC0VOuQN7NX/E61tvbi9SMTJ+b8OjRo5GUlITjx48jOTlZ8cJRPT09mDx5clSjD55FdGC3A9Ye54iACLvNBlNbG7ouXoLpUgdMbZfQdbENPV0m5+iBH/2G6ycarsUEw2wAsSne1GsyofFQPVpPnAq5GJASef1dCbtMF5UpzDVs7BjMvGOxIm3T4MdggHz0dHVh10uvxbsbvhIgKBg3awauKPReLFhXV4fpM2f7fc+jjz7q2PYGZQtHPfroo1GnES4uLsYLL7zQd0AU+1bmu9YJ2J3fB+e8gdVigan9MkyX2tF1qQ1dF9tgamtHr2vKwWOERxAEFH7329CmpsaseJPFZMKul14Le0GsnHn9w07YFS5BwJzlS6EfEedRPRqwGAyQJGP5S7D2RLZfXXFxDAqmXD8POdOv8jpW8cabWP7t7/h9j1qtxs6dO921CpQoHFVdXY2ioqK+4fEIeSbEcXN9ve0ebTtLDnuc5Fjv4fF3S3e3M0Boh10QoFJrkDpiOIbn5gAAWltbsWXLFtlTC0t9LhEn9xEEjJ81AxMMsyXXigTjSNi1B2e+OKDoz2vONdOZdpiiwjUDJCnu6wYCieOaAte2Qk+HJHYSeLLZbLjnnnvQ0uK4Gck9D93c3Ix777036kDAcyGiF9fX23O437WtsO8kd9IeqFSASg2tPg2ZEyYgd/YsjJ89C7kzrnYHAoBjGuW+++5DWVkZPvnkE5w+fRpPPPEEcnJyIIeqqir3x2keT/dhEUWc2bsP1a+8jlM1e0LeAdDT1YVT1TWofumfOLNnn6KBQFKKDhPnXqtY+zQ0cDcBSUobOQLt55ri3Y3A4rD7oH8wIIoiKt58M+j7RFFEc3MzsrKyAMhXOKq5uRkLFizA0aNHw/9k+vFciCjJldDHbnV8rVUqx0yBu/Ke6E7c40g4FF6wNnbsWDz++OP4+c9/jqeeegq//vWvowpwvHImjB4ZcTuAI1vg6Zq9OFP7BdKzRiNt9Ch0CiIumru9CijV1NTgK1OvQlZSEkS78+dRFf6IQjiuuG4uFw1S1DhNQJKaj3yJI9s/jXc3whODoGD+/d+FWqMBIOByVxeqa2ogCKqAFfXuu+8+/OEPf0B6ejqavzyK1MxMWeahq6urce+998oSCHguRAyJ3dY3bSDa+wICQQA0yV6ZB8NNLeyye/du3HPPPRF/fqmpqehyVgVsO9eI/e/IW0a6+tBBrPnv53yOP/Pj/40bPNeQRJIAKUQZY7Ixa+kSxdqnoYPBAEnqvHABezZWxrsbkVEoKEgdMRyGb32zL+NeEE1NTWhpacHMmTMBAJ3nL2Dvm+9AFMWo5qEBx3x7fn4+LlyIvupd/4WIl1vPI3V4pjPoCcCzDoDra56kc39tgqUW7s8ntTAcIx+33nor9u3bF/bn5Vm8qb2pGfsqN4XdRiCHT5/CA08/6XP85/etxJIij8LaSgUDgoBrl92BtJHRjXoQAVwzQH6kZmb2JZ0ZaOReUyAIGD9nNq6965thtTlmzBh3IGCzWlH3/naIdnsU89AmxzY+OObb33777agz5EklxNn75jv4/B+v4tiOz2EKtMjRNW3gCo48AgG5UgtnZ2dj27ZtmDp1atifm2fOBNEeLB9C+IbpfTNRAkB7Z5fH35Rb0zJ2eh4DAZIN1wyQJJVajZTMYYrtiY4JGdYU6IZlIO/rNyM9a7T7WCTD3mqNBnk334T69z9yby+TmodOGz0SyXo9BJUKot2Onq4udLZecBeOSk5Px6w7l0CbkuJeiLhixYqIchcUFhaivLzcHQh4JsSxWSw4d+AQzh04hGE5YzB2eh5GTpoIVf8A0ZX217V4EI7dEosXL444o6ArtbBrt0RWVhZefvnlsHdLeBZv6unqCnBmZDL00gmoOro6Zb9Wf0m6ZEwq8K2HQRQpThOQX4c//BgtXx6LdzfkE2ZQoB85AtfcscQr8Uy0w94WUzcObKpCVxRBVrwS4mhTUzAmbxrG5F+FZD9PxYmUR8EzZ8KxHZ/j3AHfLJHREEURC37yICz9tkPecf2NWPvd+xx/cY1SyezKm27AmKuulL1dGroYDJBfZ/cdwImd8mXLSxghBAW6YRmY9c2lXhX1ZHsC7+7GF29tiioBTVwT4ggCRk4cj7HT85CZmwPBY41AImVYlCXPQBDL/s9qnO8X+Hxl9rX4r+L/5fiLAsFAetZozLrzNvfXnUgOA3RSmGIhoXMNRCPImgJBJSDv6zcrVlFPm5LiSGkcxS9zc0cH9r75Dk7uqoHdOXSu0WiwbNkyvPDCC9i9eze6urpgs9nQ1dWF3bt344UXXsCyZcvcgYDdZsPJXTXY+9a74QUmoogLJ0/jwKatOHewL8dCWVmZrIEA4PjarVu3DgCQnJyM4uLikN7nmTPBYjLhckurrP1ykZoqaO9Udppg6g1FDARIdgwGyK+0wRoMuPgJCnJmzXSvEZC7op5rYVx61miMnzUjqjajWYh4qmYPql95HWf2Rp4QRxAEjJ48CYBjVKKsrCyidoIpKytzZyYsLi4OnAvByTNnQmPd4bBTEYdqmEQw0NGl3ALCsdPzkDaKiwZJflxASH4l6XTQpqbAYuqOd1eU5bHQ8HJvD8YpXFHPNew9wTAbzUeORl3XPpKFiHLcHNOzs6BNTQUAVFZWKlJjAAAaGhpQWVmJZcuWYezYsbjuuuvw2Wef+T2/sLAQq1atAuAY/WiqO6JIvwAgI8137US7QgsIk3TJmMhFg6QQBgMUkH7kCFhMwRelDQaffLEX6gk5WOLM5qbksPeaNWugUqsxJn8aTtfslaVtURTR0dyiyNy4FM+sflu2yJvQp7+qqir3/P/cuXP9BgOZmZkoLy93L4w8XbM36mArEKlpgo6uLoiiKPtQ/qTCuUhKTpa1TSIXThNQQIN23YCHHosFz7/8dzy+/o9YsXIlgNgNe4/Nv2rAzv96Dld7pv5Vgmf7BoNB8hypnAlnvtivaL+kpgmsNhu6e3qcf5Pne5s2ehSyuXuAFMRggAIa7OsGjjecRfGzv8SbH32IefPmYezYsQBiM+wNANrUVK8cBgOJ5/ZC11oIpdR5FIMaN26cz+v9izd55kxQ0rA06VwD7qkCmeI8LhokpTEYoIAG68iAKIqo+PB9FD/zFE6cc0yDuEoMA7EZ9naJuKJevHncnLq7lV1XYjab3R9rPYry5ObmorS0FDt27PBKnrR/U1VUWzdDleEvGJBxR8GYvGleW0iJlMA1AxSQLiMDKrXavX1tMGjv7MSvNvwVn32x1+v4nDl9i7NiOewdbUW9WBNFEZ/srYX66mmYP3YMACAlJQUmBefmPVMLu7YYypIzIUr+UhJ3yJTxUJOsxaRC6WkRIjkxGKCAVCoVUkcMR2fr+Xh3RRa1h+vwX39d75MoBvAefo7lsLe/bH6J6PDpU/i//3oVe47UY8P86zD/ekdBnry8PNTW1ip2Xc/UwnPnzvUaxQEcuwZO1+x1rBGIYR41fymJ5dpRMLHAgCSPQIhIKQwGKKi0kSMGfDBgtVnxt7ffwj+2bPK7rc5z+DmWw94DoSDU+bZLWP9mBbbs3OH++tXW1uK++xxpdw0Gg6LBgL9Fgz1dJjTVH0ZT3RFFdw3442/NQIerWFEU8/xpo0ZibP5VEb+fKBwMBiiogb5u4FxrC576y4s4dOJ4wPMyPZ7yYjnsrURFPbl09/Tg1W1VeLlqE8wWi9dru3fvdn+8aNEirF+/XrF+LFy40P3xxTNncelMg6w5EyKl5MjAFC4apBhiMEBBDeRgYNuunXjupQ0weTyJ9zc8PQOPfv+HGOUxXB/LYW8lKupFy263Y+vnRqx/swKtbdLFi3bu3InGxkaMHTsWS5cuRU5OjiI7MPqnFj605b24BgCe0lJToRIE2Pv1x7FmIPIbefZVVyJjgO4yoYEp8ccnKe70I4bHuwthM5m78fTf/oxf/uXFgIHAdVdfg7899iSuu2YGOs9fcB/3NywtF8/2LV2JleFx75HDePDZX+KZ//cXv4EA4MjF8NLf/w7AURehpKREkf7EKrVwJNQqFdJT/WQhjDAWUGu1uOK6ucFPJJIRRwYoKI1WC116GsyXla/TLof6kyfw5F9eQEOL/0x8GrUaP172Ldx189ehcs7Zd7b2BQOxHPYeP3sGxk6/CpdbWtHR1OzMItgKe7/SuEpraG3BHzf+Cx/vCb6TIjlJi3tuXYS5I8fAbrNBpVajpKQEr732muxVC2OVWjhSGWl6n2mBaLYWTiqYw0WDFHMMBigk+pEjEj4YsNvteHVbFV58swI2u/+tkOOzs/HYj36MqyZM9Dp+ubkFFpMJ2tTUmA17u2i0Wgwfl4vh43Ldn4vp4iVHYOAMEHo6lZlOuGwyYcOmt7Hxg/dgDWEL6cJ5RXjgG8uRNXwEYLPhdO1eTCowQK1WY8OGDSgqKpKlnoNUamERiTMq4OJYN9DsdSzSrYX6kSMwhosGKQ4YDFBI9CNH4MLJ0/Huhl/n29vwzN/+gt11BwOet+T6G/Czb9+LVIknL1EU0VR3BBMMs93D3mvXrpW9r57D3v6oVCqkjRqJtFEjkXO1Y31BT1eXMzBwjCB0XrgY1TY6q82Kyo8/wt/efiukBW8zp07DT771HeRNusLr+Jm9+zFy0kSkjx6FvLw8bNq0CUuWLIkqIPCbWlgUodJooFKrYO2xBGklNoJXLgzdlOvnuUeqiGKJwQCFJJEXERr378Oz5X9B2+XLfs/R61Lw8PdW4paCwoBtNdYdxrjZM2Iy7B2uZL0eo6dMxugpkwEAtt5eXG497zW1YLMEv0GKooidB/bhD6+/htNNjUHPzxk1Gj9e/i3cdK1BenW7KKL+/Y8w684l0KakoKioCEajEStWrIjoa1dYWIjy8nKvjIKeqYXtVivsVkCj08He2xv3hFhSWQgdwVV4iwaypk3FsDHZMvWKKDwMBigkiVijwNLbiz9V/Auvf/BewPOunjwFj/3wQYwdFTylq8Vkitmwd7TUSUnIzBmLzBxHPQVRFGG6dMk9ctDR3AJzh3eAdKzhLP7wr1eDjqAAQFpKClbcdgeWffUWaJOSAp5r7ujAgXercM1tC6FNSUFeXh6MRiPWrVuHsrIyNDQEr3yZm5uLkpISrFq1yv01CpRa2Go2A4KApBQdLN1mucoAhE0q10B3Tw96rVYkeeSuCISLBineBDGRluZSQtvx/14K6ckzFk42nsNTf34BR8+e8XuOShBw35LbsfK2pdCEcwMWBMz+xu3ufPBGo1G2YW9XIZ1YsZhM6GhuwfG6Ovzmv/8bb2zb6rMNrj+1SoWlX/kq7r99KTLTM8K6ni4jA3m33OSVS99qtaKyshJVVVWoqalBXV0dzGYzdDod8vPzYTAYok4trNKooVKr4zJ18I/N7+LFNzf6HK/41XMYNTy0nTiT51+H3Gumy901opBxZIBCph8xHB1NzcFPVJAoinjn04/xP6++gp5e/7/4Rw8fjv/8QTFmT4tgMZbCw96xZFepsP6fr+CZZ55BZwgr3OddMxP/+65vY9LYnIiuZ+7owN4338H4WTMwwTAbKrUaGo0Gy5Ytw7Jly0LrcwSphe1WG+xWG5JSdLD2WGKayCnDTzrp9s7OkIKB1BHDMXZ67H82iDwxGKCQ6UeOiGswcLmrC7/9Rzm21+4OeN5XrjXgkftW+s0OFwrXsPeM2xcjSZcs27B3rIiiiFdffRU///nPcerUqaDn5105DWuLH8TMCZPQ3dYe7cVxZu8+NB85ijH50zA2/ypoU1ODvu3cuXPY+vY7yNcPizi1cG9339RBb7f//BJy8le5sCPELIRTuWiQEgCDAQpZPNcN7Dt6BE/9+UW0XLro95zkJC1+8u27sfTGm2RJ49p18RJOfF6NaTfdAABQq9VYs2YNHnrooYiGvWNl586dKCkpwc6dO4Oem5WVhV/+8pf4wQ9+4O5rr9nsXJDYgo6mFnS2no9okZ7FZHI84dd+gfSs0UgbPQppo0ciWa+HoFKh7vgxfHnsGGpqarB79258/vnnSNEmo/K5/4Y6mpujKKK32+zYdaBSwarw1JbUbgIgtJTEo6dOxjBn5UeieGIwQCGLx44Cq82GDZvexoZ33w441z05dxye+NGDmJSTK+v1VRJP9OEOe8fKqVOn8O///u945ZVXgp6bnJyMkpIS/Pu//zsyMrzXBSTpdBg5cQJGTpwAwJHzoPP8hb5dC03NYT11i6LoDi48/eH1V/HqtiqvY5etVhw+dRLTr5gccvv+2K1W2AHFpw78jwwE3l6oTkrC5HkFSnSJKGwMBihkqcMzHVXYYrTmtOnCefzyLy9i/7GjAc9b/rVb8OPl30ZykBXvkdClRz7VECuXL1/Gs88+i+effx49PT1Bz//Od76DX/3qV5g0aVJI7atUKmRkjfbKld/d0eEeOehoboHpov+0xf4U5F/tEwwAwO66g7IEAy59UwcpsJhMshf/8Vu5MEgwMMEwO6TpE6JYYDBAIVNrNEgZlhH9nHIIttfsxm/+8f/QGWDueJg+DT9f+QNcP2u2Yv1ITpNeHJYIbDYb/vrXv+IXv/gFWgKkXna57rrrUFZWhqKioqivnZKRgZSMDGRfORUAYLVY0NHcgsvNLWhvasbllvNB0ynPvPJKJGk06O133u66Q1ix5I6o++hFFNHb3Q21NgmCoJJ1V0wk0wSpwzORw90DlEAYDFBY0kaOUDQY6O7pwe9eewXvfPpxwPMMefn4j/t/hFGZyhZRSk5PV7T9SL333ntYvXo19u/fH/TcCRMm4Fe/+hXuvvtuxUriarRajBg/DiPGjwPQl065vanZHSBYurwDO502GTOmXInaw3Vexw8cOwqT2SyZJTJa9l4rRFGENjUF1p4eiPboR7m0SUm45eabMWPmTMyZMwfjxo2DVqtFmi4FYzIy0Hn+AjpbL+Byc4u7yBIzDVKiYTBAYdGPHIHWYycUafvLM6fx5J9fCJgVT61S40d3fhP33LooJr9MdQk2MlBXV4e1a9fi3XffDXpuWloaHn30UaxatQopKSkx6F0fz3TKcD4Bmzs7nYGBYwSh88JFFEy/2icYsNps+OLLwyiaMUuRvgmC4LXrwGLqjihI0qamYmz+VRiTPw3vPfB9v+e5Rk8sJhMa6w6jt7vbnSiKKFEwGKCwKLGIUBRF/Ov9bXjhjdd9how95Ywajcd+9KCs88mBqNTqhJnTPX/+PJ588kn88Y9/hC3Iyn6VSoUf/vCHeOqppzBmTOKsVNelpUGXluaVTtk2fixeeON1n3OrDx1ULBhwc+46SEpOBoDQdx0IAsbPnoEJc2ZLLjD1R5uaiomGaxOqBDORC4MBCovc2wsvdXTg2fK/YueBfQHPu/W6IpTc8z3oY/iEmwjrBXp6evD73/8ev/zlL9HeHnx65pZbbsHzzz+PmTNnxqB30VEnJeErty7AqFGjcP78ea/X9h47GrOy2VaLpW/qwNwT8GYdKMPili1bUFNTg/r6enR3dyPFmZbZYDBg0aJF7q2mSk3VEEWD6YgpbCera5CSOcy9X1y029HT1SU5NxrIrkMH8Mzf/oyLAdLNpiQnY829K3DrvOgXvYUrc1wOZixZGPPrAo7RkjfeeAOPPPIIjh07FvT8q666Cs899xyWLFky4G42d999N1599VWf42fPnsXo4cM9yji3ovP8BUWzCwoqARptMizdvlMH+hHD3bUXAMcCzrKyMpSVlYVU6jonJwerV6+OSxIqomAYDJDsXHOjTXVHJDPJ9VqtWP9mBf65bUvAdvImXYHHf/QgckdnKdXVgMbkX4Urb5wf8+vW1NRg9erV+PjjwIsoAWDEiBF48skn8eCDDyJJga2VsfCXv/wFP/rRj3yO/+1vf8P3v/99r2M2qxWdrec9AoQWReoRqJ0Fhly7DnQZGe701ABQX18/INNTE/nDYIAUY7fZcLp2L87s7csxf6a5GU/9+U84fNp/ilxBEHDPrYvww6XfRFIcMvi5TCyYgwnXKjxv7aGhoQGPPvooNmzYEPTcpKQk/PSnP8UvfvELDA+xGE6iOn36NCZOnOhz/N5778VLL70U8L2iKKK7vd2d76CjqRnd7cELG4Wib9eBBbPuvM2rcNXixYtDmrbxJ16Fq4j8YTBAIQt3btTlcut51L23HW9u3YJ1r/wD3QES44wcNgy/uP8BGPLjvwf7qpu/gqypUxS/TldXF37729/iN7/5Dbq7u4Oev2zZMvz617/G1KlTFe9brOTl5eHw4cNex7KystDY2Bj2rpFes9m9pbGjuTXidMou4+fMwqS5cwA4RgTkLGltNBo5QkAJgcEABSXH3OilCxfx1Zu/hn37/C8UnD9jFn6+8v6wy+YqZebSJRg2Jlux9u12O/7+97/j0UcfDenrOmfOHDz//PO46aabFOtTvPz0pz/F73//e5/je/fuxaxZ0Y3O2G02Rzpl19RCUzN6zcEzNQKOHQAF99wFlVoNm82GoqKiiKYG/CksLMSOHTu4hoDijlkvKCDXk9DatWtDumEBjupzDz/8MObPn4/6+noAwPCRI7Bt2zbJp1mtRoOH7v4unv23nyVMIAAom4r4o48+QkFBAb7//e8H/brm5OSgvLwc1dXVgzIQAIAFCxZIHt+2bVvUbavUamRkZ2HczGsw/dZbMG/FvZh793JM++oNGJM3zZFm24+x+Ve5tw+WlZXJGggAwK5du7Bu3TpZ2ySKBEcGyC8l5karq6tRVFTk3is/cexYPPGjH2PKuPGy9FkugkqF63+4QvaV+UePHsUjjzyCN954I+i5qampeOSRR/Dwww9Dr4//NkcldXR0YOTIkbD2yzOxYMECbN26VfHr9/b0OKcVHH8ut5yHaLOh8LvfhjY1FVarFRMnTgw5IA5Hbm4uTp48GZcKl0QuDAZIkpJzo48++iieffZZLP3KV/GTb30HOm1y1NeQmy4jHQV33yVbe5cuXcJ//dd/4Xe/+x16e3uDnr9y5Uo8/fTTyM2VtwpjIrvxxhvx6aefeh3T6XS4dOkSdAqkJg7EbrfD3NGB1MxMAEBFRQWWL1+u2PU2btyYcFUwaWhhKEo+bDYbVqxYIUsgAABtbW1YuXKle2708ccfR7ZdwJzJ8V8AJwgC0rOzkDbakTrXlTtBnSTPP43e3l688MILeOKJJ3DhwoWg53/lK1/B888/D4PBIMv1B5IFCxb4BANmsxmffvopvv71r8e0LyqVyh0IAMCWLYG3wUarqqqKwQDFFdcMkA+l50aTk5PxjW/J99QdCVdq2MLvfhuzli7BlKLrkH3lVGTmjMWwMdlIGzkyqvZFUcQ777yDGTNm4Kc//WnQQGDKlCmoqKjA9u3bh2QgACi7biBaNTU1A7p9omA4TUBeYjU3ajGZsOul12Kfpz3CvPLh2LdvH9asWYP33nsv6LnDhg3DY489hn/7t39DcnLiTZfEktVqxahRo3zWqMyePRt79uyJU68c9Ho9TAHKaUcrNTUVXV1dirVPFAxHBshLZWWlIoEA4EiqU1lZCcDxZJ6eNVqR6/ijy8jA7G/cjkkFBncgYLVaUVFRgeLiYhgMBuj1eqhUKuj1ehgMBhQXF6OiosJnYZuUpqYmPPDAA7j22muDBgJqtRo/+clPcPToUaxevXrIBwIAoNFocPPNN/sc37t3L1paWuLQoz6h5H+IhtlsVrR9omAYDJCXWMyNuqR5FHtRmn7EcMy6c4k7i5zNZkNpaSkmTpyI5cuXY/369aitrYXJZIIoijCZTKitrcX69euxfPlyTJw4Ec8995xkxcDu7m4888wzuPLKK/HnP/8Z9iC582+77TYcOHAAv/vd7zBqVOy+BgOBv6mC999/P8Y98aZ0CehYL5Ak6o/BAHmJ5dxo2ujo5uVDpcvI8CowI1fuBMDxRLdo0SL8x3/8Bzo7A1fYmzFjBrZu3Yp33nmHWef8SNR1A0p/v/Lz8xVtnygYBgPkxfNGp4S6ujr3x8kx2DsvCALybrnJHQgYjUbMmzcv4gWSu3btQlFREXbu3AnA8URXWloaMINcVlYWXnzxRezZs8fvzY4cpkyZgkmTJvkc37ZtW+zXl3hQelHnUF00SomDwQB5ieXcqBBmzvlIjJs9wz01UF9fjyVLlkSVRAlwbJVcvHixO3AqKCjAI4884nNecnIyHn30URw9ehQPPPAAU86GQBAE3HrrrT7Hz549q3igGsiiRYsUbX/hwviUyiZyYTBAXmI5N6pkXXrAsUhxwpzZAJTLneBaQ/D4448jJyfH/fo999yDw4cP4+mnn0Z6eros1xwqEnGqYOnSpV7fXznl5uZi6dKlirRNFCoGA+QllnOjtl4rVAqmYI1lXvnk5GQUFxejqKgIRqMRL7/8smRZXgru5ptvlkwDHc9gQKPRoKSkRJG2S0pKmIqY4o55BshLcXEx1q9fr2j7L7zwgvvvoiiip6sL3e0d6G7vgLm9Hd3tHTC1tcN8uROI8MdTEISY55Xv7u6GTqeTvZ7BUFRYWOgTvKWlpeHixYtISkqKS59YtZAGM4aj5GXRokWKBgP950YFQYAuLQ26tDQMz/UehnXlh3cFCt1t7c6P22ExBV7bkJ6dBW1qKoDY5E5YtmyZ4lMsQ8mCBQt8brqdnZ3YuXMnbrzxxrj0Sa1WY8OGDbLW7CgvL2cgQAmBwQB5cc2NKvUUHc7cqCs/vGeOeBdbb687MDC5gwTHH5vF4rVtkXnlB55bb70VzzzzjM/xrVu3xi0YABzTaJs2bcKSJUuiCghc1Ty5xZQSBacJyEdpaSnWrl2rSLtr1qyRvd3+LM4dEa7thAaDAbW1tYpdz2AwYPfu3Yq1PxRZLBaMGDHCJ0Xvdddd597WGU/19fVYsWJFRFMGhYWFKC8vZyBACYXBAPkYbHOjzCs/MN12223YtGmT1zGVSoXz589j+PDhcepVH5vNhnXr1qGsrAwNDQ1Bz8/NzUVJSQlWrVrFqQFKOAwGSJIrS59cc6NGozFuT0IqlUrRhDUqlUoyTTFFZ926dZIr+Ddu3JhQ0zJWqxWVlZWoqqpCTU0N6urqYDabodPpkJ+fD4PBgIULF2Lp0qXcNUAJi8EA+WU0GmWbG503b558HQsTRwYGpoMHD+Kaa67xOf7ggw/iT3/6Uxx6RDR4Mc8A+eXaM19QUBDR+wsLC93pf+OJeeUHpunTp0sm+ol3nQKiwYjBAAWUl5cHo9GI0tJS5ObmhvSe3NxclJaWYseOHQmxSIp55QcmQRAksxEeP34cx48fj0OPiAYvBgMUlFqtxpo1a3Dy5Els3LgRxcXFMBgMSE1NdWz/S02FwWBAcXExNm7ciJMnT2LNmjUJs0iKeeUHrkRMTUw0GHHNAA16scpASPJrbm7GmDFjfI4vX74cr7/+ehx6RDQ4cWSABj3mlR+4srOzMWvWLJ/j77//PndwEMmIwQANCSUlJREvhPSnsLAQq1atkrVN8iU1VdDW1sZET0QyYjBAQ4Irr3ymRGrjSDCvfOxw3QCR8hgM0JDhyisfbUDAvPKxdeONNyI5OdnnOIMBIvkwGKAhZbDkThhKUlJScMMNN/gc37FjBy5fvhyHHhENPgwGaMgZDLkThppbb73V55jVasVHH30Uh94QDT7cWkhDGvPKDwx79uzBnDlzfI7/7Gc/w3//93/HoUdEgwuDASJKeHa7HWPGjEFra6vX8fz8fBw6dChOvSIaPDhNQEQJT6VS4ZZbbvE5XldXh7Nnz8ahR0SDC4MBIhoQpNYNANxVQCQHBgNENCAw3wCRcrhmgIgGjPz8fNTX13sdGz16NJqamqBS8dmGKFL810NEA4bU6EBrayv27dsXh94QDR4MBohowOBUAZEyGAwQ0YDx1a9+VTLfw9atW+PQG6LBg8EAEQ0Y6enpKCoq8jn+ySefoLu7Ow49IhocGAwQ0YAiNVXQ09ODTz/9NA69IRocGAwQ0YDCdQNE8uPWQiIaUKxWK0aNGoX29nav47NmzcLevXvj0ymiAY4jA0Q0oGg0GsnUxF988QWam5vj0COigY/BABENOP6mCt5///0Y94RocGAwQEQDDtcNEMmLawaIaECaPHkyTpw44XUsNzcXZ86cgSAIceoV0cDEkQEiGpCkqhg2NDSgrq4uDr0hGtgYDBDRgMSpAiL5MBggogHp5ptvlqxUyGCAKHwMBohoQBo+fDjmzp3rc3z79u2wWCxx6BHRwMVggIgGLKmpgq6uLhiNxjj0hmjgYjBARAOW1CJCgFMFROFiMEBEA9a8efOg1+t9jjMYIAoPgwEiGrC0Wi2++tWv+hzfvXs3Ll26FPsOEQ1QDAaIaECTWjdgt9vxwQcfxKE3RAMTgwEiGtD85RvYunVrjHtCNHAxHTERDWiiKGL8+PFoaGjwOn7FFVfg+PHjceoV0cDCkQEiGtAEQZAcHThx4gSOHTsWhx4RDTwMBohowGNqYqLoMBggogHv61//uuRxBgNEoeGaASIaFK699lrs3bvX69iwYcNw/vx5aDSa+HSKaIDgyAARDQpSUwXt7e3YvXt3HHpDNLAwGCCiQYHrBogix2CAiAaFG264AcnJyT7HGQwQBcdggIgGhZSUFNx4440+x41GIy5fvhyHHhENHAwGiGjQkKpiaLVasX379th3hmgAYTBARIMG1w0QRYZbC4lo0LDb7RgzZgxaW1u9jufl5aGuri5OvSJKfNx8S0SDhkqlwte//nW88sor0Gg0mDdvHubOnYs5c+bAbDZDp9PFu4tECYnBABENKt/4xjeQl5eHBx54AGPHjo13d4gGBE4TENGgIooiBEGIdzeIBhQuICSiQcUVCFitVlRUVKC4uBgGgwF6vR4qlQp6vR4GgwHFxcWoqKiA1WqNc4+J4o8jA0Q0qNhsNpSVlaGsrAznzp0Len5OTg5Wr16NVatWQa1Wx6CHRImHwQARDRr19fVYsWIFqqurw35vYWEhysvLkZeXp0DPiBIbgwEiGhSMRiMWL16M9vb2iNvIzMzE5s2bMW/ePBl7RpT4GAwQ0YBXX1+PoqIitLW1Rd1WZmYmjEYjRwhoSOECQiIa0Gw2G1asWCFLIAAAbW1tWLlyJWw2myztEQ0EDAaIaEArKyuLaI1AILt27cK6detkbZMokXGagIgGLKvViokTJ4a0ayBcubm5OHnyJDQa5majwY8jA0Q0YFVWVioSCABAQ0MDKisrFWmbKNEwGCCiAWvLli2Ktl9VVaVo+0SJgsEAEQ1YNTU1A7p9okTBNQNENGDp9XqYTCbF2k9NTUVXV5di7RMlCgYDRDRgqVQqKPkrTKVScYshDQmcJiCiASslJUXR9nU6naLtEyUKBgNENGApnSUwPz9f0faJEgWDASIasAwGw4BunyhRMBggogFr0aJFira/cOFCRdsnShRcQEhEAxYzEBLJgyMDRDRgaTQalJSUKNJ2SUkJAwEaMjgyQEQDms1mQ1FRkazFigoLC7Fjxw6o1WrZ2iRKZBwZIKIBTa1WY8OGDcjMzJSlvczMTJSXlzMQoCGFwQARDXh5eXnYtGlT1AFBZmYmNm/erPiWRaJEw2CAiAaFoqIiGI1GFBQURPT+wsJCGI1GzJs3T+aeESU+BgNENGjk5eXBaDSitLQUubm5Ib0nNzcXpaWl2LFjB0cEaMjiAkIiGpSsVisqKytRVVWFmpoa1NXVwWw2Q6fTIT8/HwaDAQsXLsTSpUu5a4CGPAYDREREQxynCYiIiIY4BgNERERDHIMBIiKiIY7BABER0RDHYICIiGiIYzBAREQ0xDEYICIiGuIYDBAREQ1xDAaIiIiGOAYDREREQxyDASIioiGOwQAREdEQx2CAiIhoiGMwQERENMQxGCAiIhriGAwQERENcQwGiIiIhjgGA0REREMcgwEiIqIhjsEAERHREMdggIiIaIhjMEBERDTEMRggIiIa4hgMEBERDXEMBoiIiIY4BgNERERDHIMBIiKiIY7BABER0RD3/wElTBIxixsxogAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -725,7 +726,8 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (, None, None))" ] }, "execution_count": 22, @@ -734,7 +736,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABKpUlEQVR4nO3deVTU9f7H8ecwIAyLS5tZbomSMFSYgmNUtKhdt0Qi7VreyFJMwZbbvu/br251XZK4Fbhh7hatWGZGoJNCBaKoqZiWlrkAAwrD/P7wys3cWIZt5vU4p3NP+P2+v+/pnOu8+Hw/i8HhcDgQERERt+XR1A2IiIhI01IYEBERcXMKAyIiIm5OYUBERMTNKQyIiIi4OYUBERERN6cwICIi4uYUBkRERNycwoCIiIibUxgQERFxcwoDIiIibk5hQERExM0pDIiIiLg5hQERERE3pzAgIiLi5hQGRERE3JzCgIiIiJtTGBAREXFzCgMiIiJuTmFARETEzSkMiIiIuDmFARERETenMCAiIuLmFAZERETcnMKAiIiIm1MYEBERcXMKAyIiIm5OYUBERMTNKQyIiIi4Oc+mbkCaL4fDQU5ODlarlfz8fMrKyjCZTJjNZsLDw+nVqxcGg6Gp2xQRkXoyOBwOR1M3Ic1LRUUFycnJTJ06lYKCAoxGI0FBQQQEBFBcXExhYSF2u53g4GASEhIYN24cXl5eTd22iIjUkV4TyDHy8vKwWCwkJiZiNpvJyMiguLiY9evXs3r1atavX09xcTEZGRmYzWYSExOxWCzk5eU1desiIlJHGhmQaitXrmTIkCF06dKF1NRU+vTpc9p7rFYrcXFxFBUVkZ6eTlRUVCN0KiIizqQwIMD/RgT69evH0qVL8fPzq/G9paWlREdHk52dTVZWFqGhoQ3YqYiIOJvCgFBRUYHFYqG8vJw1a9bUKggcVVpaSkREBCaTiaysLM0hEBFpQTRnQEhOTiY3N5fU1NQ6BQEAPz8/UlJSyMnJITk52ckdiohIQ9LIgJtzOByYzWbMZjMLFiyod73Y2FgKCgrIy8trkGWHWu4oIuJ8CgNubt26dfTu3ZuMjAz69+9f73oZGRkMHDiQdevW0atXLyd0eISWO4qINBy9JnBzVqsVo9FIZGSkU+pFRkZiNBqxWq1OqQda7igi0tAUBtxcfn4+QUFBmEwmp9Tz9fUlKCiI/Px8p9RbuXJl9eTG1atXs2DBAvr3739cvyaTif79+7NgwQKys7MpLy+nX79+rFy50il9iIi4MoUBN1dWVkZAQIBTa/r7+2Oz2epdJy8vjyFDhtCvXz/WrFlTo30PAMLDw1mzZg0Wi4WhQ4dqhEBE5DQ0Z8DNTZ48meXLl7N+/Xqn1ezRowcOh4O///3vhIaGYjabCQoKolWrVjWuoeWOIiKNR2HAzSUlJTFp0iSKi4ud8qrAZrMREBBAVVXVMT/39PQkKCioOhyYzWZCQ0MJDAzE0/P487KmT59OYmIiq1evrvGIwIlYrVYsFgtTpkxh4sSJda4jIuLKFAbcXEOtJoi+9U5sJQcp2ryRoi0bsZUUn/B6b29vevbsWR0OzGYzISEhXH/99S1muaOISEunMODmnL3PwA03xPLd93lMWbyi+ovX4XCwd/cvbN+8gaIthRRt3kDRlo0Ubd7IofKyk9Zq7ssdRURchcKAVA/JZ2dnEx4eXuc6R4fkxz/0PINvijvt9VVVVezZ9TM7tmz8b1DYyPbNG9m+aQM4qigpKXHaq4vWrVszffp0xo8fX+96IiKuRmFAnDZZLzw8gkoPT16Z9RHGE8wDqKmkFx5hc04WGzYU1LnGX4WEhDBgwADefPNNp9UUEXEVWlooeHl5kZqaSlFREdHR0ZSWltbq/tLSUoYPj2Zb0XYmP/NmvYIAQMXhQ7Ru3TyXO4qIuCKFAQEgNDSU9PR0srOziYiIqPEOglarld69e/NtVhaPT5lJlx49691LKx8TB4tL6l3nz0pKSvD19XVqTRERV6EwINWioqLIysrCZDJhsViIjY1l+fLllJUdO8nPZrORkZHBDTfcQN++fdm8eTPXRt9EaJ/LnNJH58AgNm8qPO65dWWz2SgsLMRsNjulnoiIq1EYkGOEhoaSlZXFlClTyMrKYsCAAfj7+9MzOIQ+4eH0DA6hdevWDBw4kO++z+fqobHY7XY+XTCLos0bndJDD3MYdrudzMxMp9TLzMzEbrfXa3KkiIgr0wRCOalRo0Yxf/58wqMGcO75nTlUXoa3j4lO3S+khzmMbj1DAXg28R989/VygkJ78fLMD+o9Z+Dw4UOMu64PV0ddyaJFi+r9ObTPgIjIqSkMyAk5HA7at2/Pb7/9xovvLcHc23LSa/fu/oWEmKsoLT5I3D2PE3Nb3Xf625SXy7+fuIftmzdgMBhYvXq1U5Y7agdCEZGTUxiQE8rLy+Oiiy6ilY8PaZkb8fI69bkCGUvSmPLkvXi18ubNBcvpeEH3Wj3vUHkZc6f9H8tmJVFVVUXrtmfgFxBAW38/rNb6n02QnZ19wm2PRUREcwbkJL788ksAzJf2PW0QAOgffRO9LruKisOH+PeT92K322v8rLzvspgcey1LUt+iqqqKqCExTF/2NY+8kcK2ou0MH1635Y7R0dEUFRWRkpKiICAicgoKA3JCX3zxBQAXR1xRo+sNBgMJT/4fJj9/NuRaSZ/7zmnvsZWWMOP5h3lkbAy/FG3lzHM68PiUmfzzxWm0bncmXXr05PEpM/k2O4vw8Notd4yIiCA7O5v09HRCQ0NrdJ+IiLtSGJDjVFZW8tVXXwFwcd/IGt93doeO3Hbv4wDMmvIiu4q2nvTadZkrSIy5io/fTwFg4A03M3XJV4RHDTjmutA+l/HKzHQqPTyxWCzccJrljrGxsVgslupji6Oiomrcv4iIu9KcATnO0d+s/QJaM/vr9RiNxhrf63A4eHzcSH5Y8w2hffrx3H8W4uHxv8xZfGAf7/zfU3z5wXwA2p/fmYSnXuOSvpefsm5lRQWfL5rDx/Peo+inQoxGI917BGHy8aa4uJht27Zht9sJCQlh0qRJjBs3Di8vr7r9BxARcTN6kSrHOTpfILRPv1oFAfjv64KnXmPyDVeT910Wn86fWX1oUdYXHzPj+YfZ9/seDAYDQ0ffzpjEh/Gpwc6Anl5eDL4pjkGjbuWnDXlsys9lx+aNrPhoMSUH9pGQkMDYsWMJCwvT8kERkVpSGJDjHA0DF0ec+rf1kzm3Y2f+cfejvP3io6S8/izdLwpjyXvTyfz8QwA6XtCdxKf/RXBY7ZcMGgwGAoMvIjD4IgD2/PIzq1d8RnBwsI4nFhGpI4UBOcbhw4dZtWoVUPcwADB4VByZn39I/tpsHhwzDHtlJR5GIzfcNolR8ffQytvHKf2e06EjANu3b3dKPRERd6QwIMdYvXo1ZWVltGl3Jp27X1jnOn/s+RXDf+cK2CsrOfPc83jszZTq3+id5ezzFAZEROpLYUCOUb2ksO/ldXr37nA4+GzRbFL+9Sy2kmI8PIxUVdmxFR+kdbsznN2uRgZERJxASwvlGPWZL/DLjm08dseNTH/mAWwlxVx4cW/emP85PS/pQ1lpCdOevh9nL17RyICISP0pDEi10tJSsrOzgSMjAzVlt9tZNiuJxBuu5kdrJt4+Jm6//2leSl1G16AQJj/zL7xaebMuc0X1kkJnOToy8Msvv3Do0CGn1hYRcRcKA1ItMzOTiooKzu5wPud27FKje4q2bOShW4fzzv89xeHyci6OuJwpi1cwfMz46mWJHS/oweiJ9wPwn1eeZO+eX53Wc+t2Z9LK58hkxB07djitroiIO9GcATflcDjIycnBarWSn59PWVkZOTk5AHQNCjnt/ZUVFSx6byrvJ71BZcVhfP0DuO3eJxh4w80nnGsQ/Y94vl2ezqa8XN569kEe/XeKU/YDMBgMnNOhIz9v3cz27dvp3r12BySJiIhGBtxORUUF06dPx2w207t3byZNmsTy5cv54YcfOHjwIB4eHlhXZpA44io+npdCZUXFcTW2FPzIP28ezJypr1BZcZg+V/Zn6uKvuC72lpN+wRs9PZn89Ot4enqxZuXnrPx4sdM+09maRCgiUi8KA24kLy8Pi8VCYmIiZrOZjIwMiouLWb9+PatXr6awsJCSkhIyMjIIv/Ri3n7pUR4YM5TtmzYAcPhQOTPffIF/jh7E1g15BLRtx70vTuXxKTM569zzTvv8Lj16MmrCPQAkv/Q4+37f45TP1f78ToDCgIhIXSkMuImVK1disVgoLy9n9erVLFiwgP79+2MymY65zmQy0b9/fxYuWEB2djZejkoe+MdQPpr3HnePHMDCd6ZQZbdz+XXXM23J11w15IZaDfffcFsC3XqGUnxgHzOef9gpqws0MiAiUj8KA24gLy+PIUOG0K9fP9asWUOfPn1qdF94eDhW6xr69e3Lf15+nJ+3bqbdWefwyBvv8sD/JdH2zLNq3Yunlxd3PfsGRk9Psr74uHqL4vrQXgMiIvWjMODiKioquPXWW+nSpQtLly7Fz8+vVvf7+fnxwQcfEBgYSNszzuTNhcuxXDOoXj1dcKGZG2+fDMCMFx7mwB+/16ue9hoQEakfhQEXl5ycTG5uLqmpqbUOAkf5+fkxe/ZsDu7fx7eff+SUvm4cfxddegRzcN8fvP3SY/WqdXRkYMeOHdjtdme0JyLiVhQGXJjD4WDq1KnExMTU+NXAyYSHhxMdPYKP309xynt+L69W3PXs63gYjaz6dBlZX3xc51rtzm6P0dOTyspKdu3aVe/eRETcjcKAC8vJyaGgoID4+Hin1JswIZ6iLRv5aUOeU+p1D7mEmLiJALz13EMc3P9HneoYjUbOan9kNYNeFYiI1J7CgAuzWq0YjUYiIyOdUi8yMhKj0cim/Fyn1AO4acK9dOrWg/17f+M/rzxR5zrnaN6AiEidKQy4sPz8fIKCgo5bPlhXvr6+dO8RxI7NG51SD6CVtw+Tn3kDDw8PvkpfhHVlRp3qaHmhiEjdKQy4sLKyMgICApxa09/fj0PlZU6teeHFlzJ8zJFXGdOefYCSgwdqXUPLC0VE6k5hwIWZTCaKi4udWrOkpBRvH+eMNPzZ6En3c36XQP7Y8yvvvPpUre/X8kIRkbpTGHBhZrOZwsJCysqc85u8zWZj86ZCOnW/0Cn1/szbx0TiM//CYDDwxdJ5rP3my1rdr5EBEZG6UxhwYeHh4djtdjIzM51SLzMzE7vdTg9zmFPq/VVIrwiGjr4dgGlP34+tpOajGn8eGXDG0kcREXeiMODCevXqRXBwMElJSU6p99Zbb9H2jDOrZ+43hDGJD3Nuxy78vnsX7/3rmRrfd/Z/D0oqKyvj99/rt6OhiIi7URhwYQaDgYSEBBYvXozVaq1XLavVytKlS9n/x14mDIvko3nvYa+sdFKn/+Pj60vi0/8C4LOFs/k+e1WN7vNq5c0Z55wL6FWBiEhtKQy4uHHjxhEWFkZcXBylpaV1qlFaWkpcXBw9evQgODiY4v37SHrhESbfeC3rMlc4uWO4KPwyBo+KA2DKU/+kzFazvjVvQESkbhQGXJyXlxepqakUFRURHR1d60BQWlpKdHQ0RUVFLFq0iB9++IHp06dz5plnsmNLIU/dOZqnJ97Mjp8Kndr3rfc8xjnndWTPrh3MfPOFGt2jvQZEROpGYcANhIaGkp6eTnZ2NhERETV+ZWC1WomIiCA7O5v09HRCQ0Px9PTkzjvvZPPmzdx77714eXmx9psvSbzhGt5+6bE6byn8VyZfPxKeeg2Aj9LeJe+7rNPeo10IRUTqRmHATURFRZGVlYXJZMJisRAbG8vy5cuPW3Zos9nIyMggNjYWi8WCyWQiKyuLqKioY65r27Ytr732Gvn5+QwfPpwqu530ue8wYWgkH875D5UVFfXuOcxyJQNvuBmAfz95L4fKbKe8/ujIwLZt2+r9bBERd2JwaB2WW6moqCA5OZmpU6dSUFCA0WgkKCgIf39/SkpKKCwsxG63ExISwqRJkxg3bhxeXl6nrfvFF19wzz338OOPPwJwftdAxt73FH2uuBaDwVDnfkuLD5IYczW/797F8DHjuf3+p0967XervuCZSbdwySWXkJubW+dnioi4G4UBN+VwOMjNzcVqtZKfn4/NZsPX1xez2Ux4eDhhYWG1/hK32+288847PPbYY/z2228A9Lositvve5rO9dioaO2qL3h60i0YDAZeSl1GcFj4Ca8r2ryRhJiraNu2Lfv27avz80RE3I3CgDjdgQMHeOGFF3jjjTc4fPgwHh4eXBc7htET76PNGWfVqeYbj93Flx/M5/yugbwxP+OEWyKX2UoZZele3UPr1q3r9TlERNyF5gyI07Vp04aXX36Z9evXExMTQ1VVFZ/MT2XCsEiWzpxBRcXhWte844GnOePs9uzctoW0t1474TUmXz8C2rQDNIlQRKQ2FAakwQQGBrJo0SJWrFhBWFgYpcUHeffVp0kYcRXZKz6t1bbB/q3bcudjLwOwNPUtCn/MOeF1Z3c4H1AYEBGpDYUBaXBXXXUV3333He+88w7t27fnl6KtvHDXbTw+biRbC9fXuE7fq68javAIqqqqePOJu6k4fOi4a7S8UESk9hQGpFEYjUbGjh3Lpk2bePjhh/H29uaHNd9wz8gBTHvmfvbvrdl5AuMeeo42Z5zFji2FvJ/0+nF/ro2HRERqT2FAGlVAQAAvvPACGzZsYOTIkVRVVfHZwtnED+3HonennfC3/T9r3fYM7nz0RQAWvjuVLet/OObPNTIgIlJ7CgPSJLp27cr777/PqlWr6N27N2WlJaS+8RyToqP4NiP9lPMJLhswlMiBw6iy23nziXuOmZCokQERkdpTGJAmdfnll7NmzRpSUlLo0KEDv/68nZf+OY5HxsawpeDHk94X//ALtG53BtsK17PwP1OAI3snHD5UDsCPP/7IuHHjmDx5MklJSaxbt65WExZFRNyJ9hmQZqOkpIRXXnmF//u//6O8vByDwcC10TdxS8KDnHF2++Ou//qTpbz64J14GI3E3DaJNV9+StFPhXh4eHDBBRdw5plnUlxcXL2rYnBwMAkJCTXeVVFExF0oDEizU1RUxMMPP8zcuXOBI/sH3HB7IsPHjD9msyGHw8Hj424kf202DoeDETExTIiPJzIyEpPpf9eVlZWRmZlJUlISixcvJiwsjNTUVEJDQxv9s4mINEcKA9JsZWVlcc8997B69WrgyOTAuHseJ3LgMAwGA3nffcszk8bQuVNH5syZQ58+fU5b02q1EhcXR1FREenp6ccdwCQi4o4UBqRZq6qqIi0tjQcffJCdO3cCENwrnCF/H8u0p+7jsn79WLZsKX5+fjWuWVpaSnR0NNnZ2WRlZWmEQETcnsKAtAilpaW8+uqrvPLKK9hsNoxGI92792Dt2u9qFQT+XC8iIqL6iGbNIRARd6bVBNIi+Pn58eSTT7Jx40YiIiKoqqpi9uxZdQoCR+ulpKSQk5NDcnKyk7sVEWlZNDIgLYrD4cBsNhMSEsLChQvrXS82NpaCggLy8vJqfWSziIir0MiAtCg5OTkUFBQwYcIEp9SLj49n/fr15ObmOqWeiEhLpDAgLYrVasVoNBIZGemUepGRkRiNRqxWq1PqiYi0RAoD0qLk5+cTFBR0zD4C9eHr60tQUBD5+flOqSci0hIpDEiLUlZWRkBAgFNr+vv7Y7PZnFpTRKQlURiQFsVkMlFcXOzUmiUlJfj6+jq1pohIS6IwIC2K2WymsLCQsrIyp9Sz2WwUFhZiNpudUk9EpCVSGJAWJTw8HLvdTmZmplPqZWZmYrfbCQ8Pd0o9EZGWSPsMSItydJ8Bs9nMggUL6l1P+wyIiGhkQFoYg8FAQkICixcvrvdyQKvVypIlS5g0aZKCgIi4NY0MSItTUVGBxWKhvLycNWvW1PtsguzsbDw9PRugUxGRlkEjA9LieHl5kZqaSlFREdHR0ZSWltbq/qOnFhYVFZGSkqIgICJuT2FAWqTQ0FDS09PJzs4mIiKixq8MrFYrl156KZmZmaSnp+v4YhERFAakBYuKiiIrKwuTyYTFYiE2Npbly5cft+zQZrORkZFBbGwsFouFLVu24Ovrq+WEIiL/pTkD0uJVVFSQnJzM1KlTKSgowGg0EhQUhL+/PyUlJRQWFmK32wkJCWH8+PEkJSVRUFDADTfcwIIFCzR5UETcnsKAuAyHw0Fubi5Wq5X8/HxsNlv1CEB4eDhhYWEYDAbWrl2LxWKhsrKSWbNmccsttzR16yIiTUphQNzSs88+yxNPPEGbNm348ccf6dSpU1O3JCLSZBQGxC1VVlYSGRnJmjVruPbaa/n888/x8NAUGhFxT/rbT9ySp6cnM2fOxGQy8cUXXzB9+vSmbklEpMkoDIjbuvDCC3nllVcAeOCBB9i4cWMTdyQi0jT0mkDcWlVVFddddx3Lly8nIiKCzMxMbUIkIm5HIwPi1jw8PHj33Xdp06YNa9as4cUXX2zqlkREGp1GBkSA2bNnM2bMGDw9PcnOzqZ3795N3ZKISKNRGBDhyB4FI0eOZOHChQQHB7N27VpMJlNTtyUi0ij0mkCEI0cjv/XWW7Rv356CggIee+yxpm5JRKTRaGRA5E/S09MZNmwYBoOBL7/8kquuuqqpWxIRaXAaGRD5k6FDh3LHHXfgcDiIi4vj4MGDTd2SiEiD08iAyF8UFxdz8cUXs23bNm677Tbefffdpm5JRKRBaWRA5C8CAgKYOXMmBoOB9957j2XLljV1SyIiDUphQOQErrjiCu677z4Axo0bx549e5q4IxGRhqPXBCInUV5eTnh4OHl5eYwYMYJFixZhMBiaui0REafTyIDISfj4+DBr1iy8vLxYsmQJs2bNauqWREQahMKAyCmEhYXx1FNPAZCYmEhRUVHTNiQi0gD0mkDkNCorK7niiivIzs7m6quvZvny5Xh4KEeLiOvQ32gip+Hp6cnMmTPx9fVlxYoVTJkypalbEhFxKo0MiNTQW2+9xcSJE/Hx8WHdunUEBwc3dUsiIk6hMCBSQw6Hg0GDBvHZZ5/Rp08fvv32W7y8vJq6LRGRetNrApEaMhgMvPPOO7Rt25bvvvuOF154oalbEhFxCo0MiNRSWloao0ePxmg0kp2dTZ8+fZq6JRGRelEYEKklh8PBTTfdxPz58+nZsyfr1q3DZDI1dVsiInWm1wQitWQwGJg+fTodOnRgw4YNPPzww03dkohIvWhkQKSOPvnkEwYPHgzAF198wTXXXNPEHYmI1I1GBkTqaNCgQcTHxwMQFxfHgQMHmrgjEZG60ciASD2UlJRwySWX8NNPP3HrrbeSkpLS1C2JiNSaRgZE6sHf35+ZM2fi4eFBamoqS5YsaeqWRERqTWFApJ4iIyN54IEHAIiPj2fPnj1N3JGISO3oNYGIExw6dIiIiAh++OEHrr/+epYuXYrBYGjqtkREakQjAyJO4O3tzaxZs/Dy8uKDDz7Q3AERaVEUBkSc5OKLL+bZZ58F4K677mLbtm1N25CISA3pNYGIE9ntdq688kq+/fZboqKi+PLLL/HwUOYWkeZNf0uJOJHRaGTmzJn4+fmxcuVK3nzzzaZuSUTktDQyINIA3n77beLj4/H29mbdunWEhIQ0dUsiIielMCDSABwOB0OGDOGTTz7h0ksvJSsri1atWjV1WyIiJ6TXBCINwGAw8M4773DGGWewbt06nnvuuaZuSUTkpDQyINKA5s+fz6hRozAajWRmZtK3b9+mbklE5DgKAyINbPTo0aSlpREUFEROTg6+vr5N3ZKIyDH0mkCkgU2bNo3zzjuPwsJCHnrooaZuR0TkOBoZEGkEn3/+Oddddx0AGRkZ9O/fv4k7EhH5H40MiDSCgQMHMnHiRABuu+029u/f37QNiYj8iUYGRBpJaWkpYWFhbN68mVtuuYVZs2Y1dUsiIoBGBkQajZ+fHzNnzsTDw4PZs2ezcOHCpm5JRARQGBBpVP369aueRDhhwgR+/fXXJu5IRESvCUQa3eHDh+nbty+5ubkMHTqUDz74AIPB0NRtiYgb08iASCNr1aoVs2bNolWrVqSnp/Puu+82dUsi4uYUBkSaQGhoKM8//zwAd999Nz/99FMTdyQi7kyvCUSaiN1u5+qrr2bVqlVcccUVrFixAqPR2NRtiYgb0siASBMxGo2kpqbi7+/PqlWreP3115u6JRFxUxoZEGli77zzDnfccQetWrVi7dq1hIaGNnVLIuJmFAZEmpjD4eD6668nPT2dsLAwVq9eTatWrZq6LRFxI3pNINLEDAYDycnJnHnmmeTm5vLMM880dUsi4mY0MiDSTCxatIjY2Fg8PDz45ptv6NevX1O3JCJuQmFApBkZM2YMs2fPpnv37uTm5uLn59fULYmIG9BrApFmZMqUKXTs2JHNmzfzwAMPNHU7IuImNDIg0swsX76cAQMGAPDpp59y3XXXNXFHIuLqNDIg0sz079+fxMREAMaOHcu+ffuauCMRcXUaGRBphmw2G7169aKwsJDRo0czZ86cpm5JRFyYRgZEmiFfX19mzZqF0Whk7ty5zJ8/v6lbEhEXpjAg0kxFRETwyCOPAHDnnXeya9euJu5IRFyVXhOINGMVFRVYLBbWrVvHoEGD+OijjzAYDE3dloi4GI0MiDRjXl5ezJo1C29vbz755BOSk5ObuiURcUEKAyLNXEhICC+++CIA9957L1u2bGnijkTE1eg1gUgLUFVVxTXXXMPKlSuJjIxk5cqVGI3Gpm5LRFyERgZEWgAPDw9SUlIICAggMzOTV199talbEhEXopEBkRbkvffeY+zYsXh5efHdd99x8cUX43A4yMnJwWq1kp+fT1lZGSaTCbPZTHh4OL169dKkQxE5JYUBkRbE4XAwYsQIli1bxkUXXcQdd9zBjBkzKCgowGg0EhQUREBAAMXFxRQWFmK32wkODiYhIYFx48bh5eXV1B9BRJohhQGRFmbPnj307NmTgwcP4nA4iImJIT4+nsjISEwmU/V1ZWVlZGZmkpSUxOLFiwkLCyM1NZXQ0NAm7F5EmiOFAZEWZuXKlQwaNIhOnToxZ84c+vTpc9p7rFYrcXFxFBUVkZ6eTlRUVCN0KiIthcKASAuSl5eHxWKhX79+LF26FD8/vxrfW1paSnR0NNnZ2WRlZWmEQESqKQyItBBHdyMsLy9nzZo1tQoCR5WWlhIREYHJZCIrK0tzCEQE0NJCkRYjOTmZ3NxcUlNT6xQEAPz8/EhJSSEnJ0e7GYpINY0MiLQADocDs9mM2WxmwYIF9a4XGxtLQUEBeXl5WnYoIhoZEGkJcnJyKCgoID4+3in14uPjWb9+Pbm5uU6pJyItm8KASAtgtVoxGo1ERkY6pV5kZCRGoxGr1eqUeiLSsikMiLQA+fn5BAUFHbOPQH34+voSFBREfn6+U+qJSMumMCDSApSVlREQEODUmv7+/thsNqfWFJGWSWFApAUwmUwUFxc7tWZJSQm+vr5OrSkiLZPCgEgLYDabKSwspKyszCn1bDYbhYWFmM1mp9QTkZZNYUCkBQgPD8dut5OZmemUepmZmdjtdsLDw51ST0RaNu0zINICaJ8BEWlIGhkQaQEMBgMJCQksXry43ssBrVYrS5YsYdKkSQoCIgJoZECkxXD22QTZ2dl4eno2QKci0tJoZECkhfDy8iI1NZWioiKio6MpLS2t1f2lpaUMGzaM7du3k5KSoiAgItUUBkRakNDQUNLT08nOziYiIqLGrwysViu9e/fm66+/pm3btrRv376BOxWRlkRhQKSFiYqKIisrC5PJhMViITY2luXLlx+37NBms5GRkUFsbCwWiwWDpxdnnn0OO3fuZNiwYdpwSESqac6ASAtVUVFBcnIyU6dOpaCgAKPRSFBQEL6+vuzfv59t27Zht9vpfmFPRt82npFj4tixfSt/H9Kf/fv2cf3117N48WKMRmNTfxQRaWIKAyItnMPhIDc3F6vVSn5+PoWFhXz66aecc24HkuYsIDj04mNWDaxdnUVc7DAOHzrEnXfeybRp07SqQMTNKQyIuJjCwkIuvPBCfH39WLf1lxN+0X/24TLuumMMDoeDl156iQcffLAJOhWR5kJzBkRcTOfOnQGw2UrZ98feE15z3bDhPPLcywA89NBDzJkzp9H6E5HmR2FAxMX4+Phw3nnnAbBzR9FJr/vHuDsZe2ciALfddhtffvllo/QnIs2PwoCIC+ratSsAPxdtP+V19z/5HIOGx1BRUcGIESP48ccfG6E7EWluFAZEXNDRMLDzNGHAw8ODl6ckEd4vkoMHDzJo0CB+/vnnRuhQRJoThQERF3TBBRcAp35NcJS3jw9TU+YSGHQhO3fuZNCgQRw4cKChWxSRZkRhQMQF1fQ1wVFt251Bctpizj6nPXl5eYwYMYLDhw83YIci0pwoDIi4oOrXBDtqFgYAzu/UmbfTFuHr58+KFSsYO3YsVVVVDdShiDQnCgMiLujPrwlqs5VIyEWXMOXd2Xh6ejJnzhweffTRhmpRRJoRhQERF9SpUycMBgPlZWXs/e23Wt17+dXX8uy/pgDw0ksvMX369IZoUUSaEYUBERfUqlUrzj//fKB2rwqOirnpFiY/+BgAiYmJLFu2zKn9iUjzojAg4qJqs6LgRCbe+wA33nIrVVVV/P3vfyc7O9uZ7YlIM6IwIOKi/reiYFud7jcYDDz1yhtE9R9IWVkZw4YNY9OmTc5rUESaDYUBERf1vzBQt5EBAE9PT15/OxXzJb34/fffGTRoEHv27HFShyLSXCgMiLio+r4mOMrP35+35yykY+eubNmyhaFDh1JaWuqMFkWkmVAYEHFR9X1N8GdnnXMOyfMW0bZdO6xWKzfddBOVlZX1risizYPCgIiLOhoGdv28wymbB3XrHsRbs+bj7eNDeno6CQkJtdrDQESaL4UBERfVqVMnjEYjhw8d4vffnPOe/9IIC69O/w8Gg4GkpCReeuklp9QVkaalMCDiojw9PenYsSMAP2/f5rS6A4cO59HnXwHgkUceYdasWU6rLSJNQ2FAxIX974yC+k0i/Ksxd0xg7MTJAIwdO5bly5c7tb6INC6FAREX9r8VBbXfhfB07n/iWQZH30BlZSUxMTF8//33Tn+GiDQOhQERF1bbo4xrw8PDg5enJBFx2eUUFxczePBgduzY4fTniEjDUxgQcWHVrwnqsfHQqbTy9mZqyly6X9iTXbt2MWjQIPbv398gzxKRhqMwIOLCnLXx0Km0aduO5LTFnN3+XPLz8xkxYgSHDh1qsOeJiPMpDIi4sP/tNVCE3W5vsOec17ETyXMX4ecfwFdffUVcXJxT9jYQkcahMCDiws4//3w8PT2pqKjgt92/Nuizgi+6mCnvzsbT05N58+bx8MMPN+jzRMR5FAZEXJjRaKRz585Aw0wi/KvIq67h+denAfDKK68wderUBn+miNSfwoCIi2vIFQUnEj1qNHc//AQAkydPZsmSJY3yXBGpO4UBERfXUBsPncqEu+9j1JjbcDgcjB49mqysrEZ7tojUnsKAiItryI2HTsZgMPDEy//iqgHXUV5ezrBhwygsLGy054tI7SgMiLi4xn5NcJSnpyevv51KaNil7N27l7/97W/s3r27UXsQkZpRGBBxcQ298dCp+Pr5kTR7AZ26XMDWrVsZOnQopaWljd6HiJyawoCIizv6muDXXT9TWVnZ6M8/65xzSJ63iLZnnMF3333HqFGjmqQPETk5hQERF9ehQwe8vLyorKxk9y+7mqSHCwJ7MGPWfLx9fPjoo4+YOHEiDoejSXoRkeMpDIi4OA8PD7p06QI07oqCv+oV3pd/zXgXg8FAcnIyL7zwQpP1IiLHUhgQcQPVKwoaeRLhX/UfPIzHX3gVgMcee4yZM2c2aT8icoRnUzcgIg3L4XDg7+8PwNz3klm7JgsfHxPdLwzmol6XEnLRJRgMhkbr5+bbx7Nr5w7+M/UNbr/9djp06MCAAQMa7fkicjyDQy/uRFxSRUUFycnJTJ06lYKCAjw8PAgMDKRtu3YUFxezqbAQu91OYNCF3Dw2npFj4vDy8mqU3qqqqrh/4h2kL15AQEAAq1at4pJLLmmUZ4vI8fSaQMQF5eXlYbFYSExMxGw2k5GRQUlJCYWFhaxZvZqC9espLi4mIyODXhdfxHOP3MeoQddQWLC+Ufrz8PDgxTffIiLyCoqLixk8eDBFTbD0UUSO0MiAiItZuXIlQ4YMoUuXLqSmptKnT5/T3mO1WomLi2N7UREzZi8g4rLLG6FTOHhgP6OHDWTThgJCQkL45ptvaNeuXaM8W0T+R2FAxIUcHRHo168fS5cuxc/Pr8b3lpaWMjw6muzsbOZ99AVBwSEN2On//LLzZ0YOuoY9v/5CVFQUn332Gd7e3o3ybBE5QmFAxEVUVFRgsVgoLy9nzZo1tQoCR5WWlhIREYGHlzfzPv6i0eYQbMjPY/SwgZSWFHPTTTcxZ84cPDz0FlOksej/bSIuIjk5mdzcXFJTU+sUBAD8/PxISUlh/Y/fM39WinMbPIWe5lCmpczF09OTefPm8dBDDzXas0VEIwMiLsHhcGA2mzGbzSxYsKDe9WJjY/k+L5/0r9c06rLDpfPTeDBhPAD//ve/SUxMbLRni7gzjQyIuICcnBwKCgqIj493Sr34+Hg2b9xAQd4PTqlXU9Ej/869jz4JwF133cWSJUsa9fki7kphQMQFWK1WjEYjkZGRTqkXGRmJ0Wjkx5y1TqlXG+Mn/5Obbr0dh8PB6NGj+fbbbxu9BxF3ozAg4gLy8/MJCgrCZDI5pZ6vry89goLYtHGDU+rVhsFg4PEXX+Xq6wZRXl7OsGHD2LhxY6P3IeJOFAZEXEBZWRkBAQFOrenv7095mc2pNWvK09OTf814j4sv7cMff/zBoEGD2L17d5P0IuIOFAZEXIDJZKK4uNipNUtKSvAx+Tq1Zm34+vkxY9Z8OnftxtatWxkyZAglJSVN1o+IK1MYEHEBZrOZwsJCysrKnFLPZrNRuHEjO3cUUbT1J6fUrIszzz6b/8xbTLszz2Tt2rWMGjWKysrKJutHxFUpDIi4gPDwcOx2O5mZmU6pl5mZSVVVFV9++hED+l7CjX+7mpSkaezZ/atT6tdGl26BJM1egI/JxMcff8zEiRPRimgR59I+AyIuoCH2GcjOziY4OJgvv/ySqqoq4Mjkvr6XX8nQEbEMHDqcNm0b7xyBLz79iIS40VRVVfHss8/y2GOPNdqzRVydwoCIi5g+fTqJiYlkZ2cTHh5e5zpWqxWLxcKUKVOYOHEiu3fvZv78+aSlpZGVlVV9nZeXF1dcO4ChI27k6oGD8K3jroe1Mfe9//D0g/cA8N577xEXF9fgzxRxBwoDIi7CmWcTmEwmsrOz8fT0PObPt27dyrx580hLS+PHH3+s/rmvrx/X/G0IQ2NiibzqWlq1alXvz3Myrz33JG//+194enry0UcfMXDgwAZ7loi7UBgQcSF5eXn069cPi8VSp1MLo/97amFWVhahoaGnfVZaWhppaWls3bq1+udt27XjuqHRDIm5kfB+kU4/cKiqqor7J44jffF8/P39WbVqFWFhYU59hoi7URgQcTErV65k6NChdO7cmZSUlBq9MrBarcTFxVFUVER6ejpRUVE1fp7D4WD16tWkpaXx/vvvH7MfQPsO5zF4eAxDYm4k9JJeTjvn4PChQ9zx9xhWf/M1HTp0ICsriy5dujiltog7UhgQcUF5eXnExcWRk5PDiBEjmDBhApGRkcfsUGiz2cjMzCQpKYklS5bQq1cvUlJSTjsicCp2u50VK1aQlpbGokWLOHDgQPWfde0WyJARNzIkJpbAHhfW6/MBHDywn5uvv47CgvUEBweTmZlJu3aNN6FRxJUoDIi4qIqKCpKTk5k6dSoFBQUYjUaCgoLw9/enpKSEwsJC7HY7ISEhTJo0iXHjxuHl5eW05x86dIhPP/2UuXPn8uGHHx6zB0LIRZcwZEQsQ0bE0uH8jnV+xi87f2bU4GvZ/csurrzySj777DN8fHyc0b6IW1EYEHFxDoeD3NxcrFYr+fn52Gw2fH19MZvNhIeHExYW1uDHFBcXF7Ns2TLS0tL4/PPPj9k4qI/lMoaMuJG/DRvOGWedXevaG9fnM3rYQEqKDzJy5EjS0tKq5yk4HA5ycnKqP3tZWRkmk6n6s/fq5bxXFyItmcKAiDSq33//nYULF5KWlsbXX39d/XOj0UjkVdcyZEQs/QcPxd+/5mctZK1aybibRlBRUcE///lPXnzxxROOigQEBFBcXFw9KhIcHExCQoLTR0VEWhqFARFpMjt27OD9998nLS2NdevWVf/c28eHqwcOYuiIWK68diDeNRj6/2Dh+9w/8Q4AOnXqxM6dO4mJiSE+Pv64+RJlZWXV8yUWL15MWFgYqamp9ZovIdKSKQyISLOwcePG6qWKhYWF1T/3D2jNwKHXM3TEjfS9/Mrj9j74s8f/mcjCOTPp3r07c+bMoU+fPqd9bn1WUoi4CoUBEWlWjr7nnzt3LvPmzWPnzp3Vf3bmWWczOPoGhoyIJaxPxDHv+wsL1jNq8DVY+vblgw8+aNA9FkRcjcKAiDRbVVVVfPPNN8ydO5eFCxeyd+/e6j87v3MXho6IZciIG+nWI4hRg67BUXnYKbsvZmVlaQ6BuBWFARFpESoqKsjIyGDu3LksXbqU0tLS6j87u3179v72G6tXr67Rq4GT+eu5DCLuQmFARFocm81Geno6c+fO5eOPP6aqqorhw4ezaNGieteOjY2loKCAvLw8LTsUt6EwICIt2sqVK7nqqqvIyMigf//+9a6XkZHBwIEDWbduHb169XJChyLNn3NPEBERaWQbNmw4skdBZKRT6kVGRmI0GrFarU6pJ9ISKAyISIuWn59PUFDQMfsI1Ievry9BQUHk5+c7pZ5IS6AwICItWllZGQEBNd+tsCb8/Pyw2WxOrSnSnJ189w4RkRbAZDJRXFzs1Jr79u1j3rx5HDx4kMsuu4x+/foRFhZGq1atnPockeZCEwhFpEVLSkpi0qRJFBcXO+VVgc1mIyAggKqqqmN+7uPjQ+/evenXr1/1Px06dKj385xBBzJJfSkMiEiLtm7dOnr37u301QRjEp+g+MA+fir4np82/kDJwf3HXdulSxcsFkt1OGjs0YOTHVOtA5mkthQGRKRFczgcmM1mzGYzCxYsqHe9mJgYMrOtPP+fj6t/m3Y4HOzeuZ0tG77np4Lv2bLhe3Zu34yjCUcP8vLyuPXWW8nNzdWBTFJvCgMi0uJNnz6dxMREsrOzCQ8Pr3Mdq9VK3759cTgcRA0eScytk/ELaHPCa8ttpWwt/JEt/w0HP234gdLiA8dd16VLF/r161c99+CSSy6p92/nK1euZMiQIXTp0oXU1FQdyCT1pjAgIi1eRUUFFouF8vLyep1N0Cc8nF2/7Obg/j8ACGh7BjeNe4CIqwaf9p37kdGDbdXhYEvB9+zavpm//hVrMpno06fPMaMH7du3r3GfeXl51a8mli5dqgOZxCkUBkTEJeTl5dGvXz8sFkudviSHDx/Ot1nZPPTqLEqK9zNr6rP8umMrAMFhfbl54mOc27FrrXoqs5WwdeOxowe2koPHXXfBBRccM/fgZKMHzgo9OpBJ/kphQERcxsqVKxk6dCidO3cmJSWlRq8MrFYrt9xyC0U7fibxqalceNGReyorKvh00Xt8NO9tKg4fwtPTi8GjxjHoxrF4tfKuU39VVVXVowc/HR09KNpS49GDo69DdCCTOJvCgIi4lLy8POLi4sjJyWHEiBFMmDDhuIl1NpuNzMxM3nrrLZYuXYqHhwcRUYO4/b4Xj6u355cdzJn+PPlrMwFof14Xbp70KCG9+jmlX1tpMVs3/lgdDn7a+AO2kuP3TejatSsHDhzgmmuuYeHChfV+rg5kkj9TGBARl3OyJXf+/v6UlJRUL7k799xz+fXXXwEweHjw+Jvz6BwYfFw9h8PBd6s+Y97br3Dgj98A6HvVYEaOu5827c5yau9VVVX8+vO26nCwZcP3/PKn0QMdyCQNQWFARFyWw+EgNze3ejMem82Gr69v9WY83bt3p1u3bvz+++8AXBB0EQ+/NgsPo/GE9WylxSydNZUVH6bhcDgw+QVwQ9zdXDkoFg+Phtvd3VZazLJZ0/jqo3lO3VypdevWTJ8+nfHjxzuhS2nJFAZExK298sorPPjggxgMBhwOB7dMepyrhow85T3bCvOZOfVpijYXANCt58WMSXiCTt0ubLA+5854kZ2F69hQUOC0miEhIQwYMIA333zTaTWlZdJBRSLi1iZNmsTZZ59dPQy/KOUNDvzx+ynv6Rpk5rHX07gp/iF8TH78tOEHnp08ivn/eZXysoY54Kji0CGnH8jk7++vA5kEUBgQETfn5+fHAw88AICnpxdlpcXM/8//nfY+D6OR/sNv5tmkZfS5fCBVVXY+X5zK4/HXk/PtF07v08vb2+kHMpWUlODr6+vUmtIyKQyIiNu78847Oeecc6isrMBgMLD6q49Zn5NVo3vbndWeCY+8xuSnp3HWueez7/fdTHvubqY+k8je3buc1uP5nQPZvGkTZWVlTqlns9koLCzEbDY7pZ60bAoDIuL2/jw64O1z5DflOdOep+LwoRrXuDj8Sp6evoTBo8Zh9PQkN/srHp8QzacL36OysqLePXYNCsVut5OZmVnvWgCZmZnY7fZ6bd8srkMTCEVEOPKbcrdu3di9ezcmP3/KSku4/uaJXH/znbWutatoC7OmPMOm/HUAnN+1B2MSnqB7SFid+3M4HDx55wj6hfdi4cL6H8ikfQbkzzQyICIC+Pr68uCDDwJgNB7Zovfj95P59edtta51XudAHnglhbi7n8G/dVt2btvES/eNYea/n6LkBIcZ1YTBYODqoTexZMlirFZrnWocZbVaWbJkCZMmTVIQEEAjAyIi1crKyujWrRu//vor53UOZFfRFoLD+nLv88l1/tIsPrCPRe+9zjefLwEgoM0ZjLzjPizXDK11zS8+mMv85FcIDAxk3bp19T6bIDs7G09Pz1rXENejkQERkf8ymUzVowOlJQfxauVNQe5q1nz1cZ1rBrRpR9zdz/DAy+9xXudAig/8wTuvPcJrD9/Brz9vrVENh8PB4tR/kzbjRex2O1u3bmP48OGUlpbWqpejpxYWFRWRkpKiICDVNDIgIvInZWVlBAYG8ssvvxBmuYrc7K8IaHsGzyV9gF9Am3rVrqyo4PMlqaSnJXH4UDmenl787caxDB55B628fU58T2UFM//9FN8u/wCA4bdMpEdoH6Y9k0jXLp1JTU2t8YFMcXFxFBUVkZ6eTlRUVL0+i7gWjQyIiPyJyWTioYceAmD75gLO7diV4v1/sGTmlHrX9vTyYvDIO3j6rSWE9rmcysoK0tOSeHJiDPnrvj3u+nJbKVOeTuTb5R/g4WHk1rueZtjoO+l5cTgPvTqLskoPLBYLMTExLF++/LhlhzabjYyMDGJiYrBYLNXHFisIyF9pZEBE5C/Ky8sJDAxk165d9I++heVLZ2MwGHj4tdl063mxU57hcDhYl7mctKSX2L93DwARUYMYOe5+2p5xNgf++J03n5pI0eYCWnmbmPDwq1wcceUxNSorK/hwzlt8uvBd7HY7RqOR7j16VB/ItHnTJux2O56engwePJiFCxfi5eXllP7FtSgMiIicwNSpU0lMTKTdWe258OJwsr9Mp1O3C3nszXkYjc57115mK2HZrGl88eFcHFVVmHz96R99C99+8QF7d+/Cv3U7Jj89jW4XXnTC+z9blMKCd14jMCSMy669nl3bt3D4UDmtvH04r0sgB/b9zgezp3PBBRewefPmBj1QSVouhQERkRMoLy+ne/fu7Ny5kxtuu5tPFryLreQgI8fdz8AR/3D687Ztymf21GfZtim/+mdtz2rP/S+9S/vzOp/0vtceGUdBbjY3xT9E/+E3H/fnh8rLuG/MtZSVFvP5558zYMAAp/cuLZ8ioojICfj4+PDwww8D8OUHcxlx62QAls2ayh+//er053XtYWbITfEY/zTD/8De31iRnka57cSrBg6V29iUtxaA0N6RJ7zG28dEv2uGAvD22287uWtxFQoDIiIncccdd9CxY0f27d1Dlb2SwOAwDpWXMS/pZac/6+tPFzL9+buxV1Zy4cXhXBrZH4ejiuVLZ/N4/PWszVzOXwdyN/7wHZWVFZx17vm0P7/LSWtf+bdYAJYuXcru3bud3ru0fAoDIiIn4e3tzSOPPALAJwve5e/xD2E0erLu2+V8v3qlU57hcDhYNnsaM//9NI6qKi4fOIJ7nkti4qOvc/ezMzj73CNh5K3n72HKUwn8vntn9b15a78BILT35afcwKjjBUF063kxlZWVpKSkOKVvcS0KAyIipzB27Fg6derE/r172LIhlwEjxgAw960XOFRuq1dtu72S1Def4sO5MwAY+vd4br3raTw9j8z4D+0dydNvLWHoTeMxenryg/VrnpgQzScL3qGysoK8tUcOLTJfetlpn3V0dCA5OZmqqqp69S2uR2FAROQU/jw68PH8d7juhts44+wO7N2ziw/Tkupc91C5janPTOabzxdj8PBgTOITRI9JOO43/FbePkT/I5Gnpi0i6KI+HD5UzqL33uCJCdHs2VWE0ehJ8CV9T/u88Cuvw+Trz5YtW1ixYkWd+xbXpDAgInIaY8eOpXPnzhz44zdWr/iI0ROPhIOMxTPZuW1Tresd3L+X/3vodn60rqKVtw+THnuDqEE3nvKeDp26cf9L7zL2n8/j37ode3YVAeDfum2Njkj29vHFcvUQQBMJ5XhaWigiUgNvv/028fHxtGl3Fi+++wnJrzxITtaX9DBfyv0vv1fj9fu7dxXxxuMT+O2XHfi3bkviU1MJ7HlJrXopObifZxJvrF7V4N+6LTfe/k8u6z/8lHMHdvy0kacTYvH09OSTTz5hy5Yt5OfnU1ZWhslkwmw2Ex4eTq9evXSaoZtRGBARqYHDhw8TFBTE9u3bGTX+AS69rD+PjR9GxeFD9LykL2ef2xEvb2/O7xxI16BQOgcGH/eFurUwj38/OYniA39w1rnnc/czMzi3Y9da91JRcZi7Rl7O4UNlnNOhE3t+2QFAUGhvbkl4gvM6dzvhfZWVFTx6x1D2791dvWNhUFAQAQEBFBcXU1hYiN1uJzg4mISEBMaNG6cdC92EwoCISA0lJyczfvx4fEx+nHHWOezasRUPDw+6detG27btKC4prt4C+LzOgVw99Cau+NsNeHp68YP1a2a8cB+HD5XRuXswdz01nTZnnFWnPgpys3ntkXG0aXcWL6V8xvKls/lw7lscPlSO0dOTv91wG0NuGn/M4Uc7t23ivdcfo2jLBqKjo7nzzjuJjIzEZDJVX1NWVkZmZiZJSUksXryYsLAwUlNTCQ0Nrfd/O2neFAZERGooJyeHyMhIysvLiYmJYcKECSf9Qp0xI4klSxbTObAnl/S9mg/nzqCqyo65dyR3PvwaPr5+de5jwTv/4rNF73FZ/+GMvfc5AH7fvZO5b73ID2uOLHk8+9yO3DzxUUL7XM7GH61MeSqBC7p2YebMmfTp0+e0z9Aph+5FYUBEpAZWrlzJkCFD6Ny5c62+UMf84x/VowX9rr2eW+96qnrpYF09OTGGnds2Mf7B/yMi6m/VP3c4HORkfUnaWy+w77+HH5kvvYzN63O4PPIyli1bhp9fzUNIaWkp0dHRZGdnk5WVpRECF6YwICJyGnl5eVgsFvr168fSpUtr/YU6bNgwvsnM5NHX0+h4QVC9etn3+27u/0d/DB4evD53Jf6t2x53TbmtlGWzp5GxbDZGDw8CAwNZt25drfr+c/8RERHVxx9rDoFr0tJCEZFTqKio4NZbb6VLly61DgIAfn5+fPjhh3QPDCTljSdqtAzwVPLXfQvABUGhJwwCAD6+fowa/wCDYsdS5XAwZ86cOgUBONJ/SkoKOTk5JCcn17VtaeYUBkRETiE5OZnc3FxSU1Pr9YWamppK0ZYCVn26qF795H13ZAti86UnPpjoKIfDwfervyJmREyNXmmcSnh4OCNGjGDatGnHnY8grkFhQETkJBwOB1OnTiUmxjlfqNHR0Xz10bw6f6Ha7ZWsz80CILTPqcNA0ZYCdhVtYcKE+Do966/i4+NZv349ubm5TqknzYvCgIjISeTk5FBQUEB8vHO+UCdMmMDO7VvY8dOGOt2/dWMetpJifP1bc0GPU0/m21aYh9FoJDLy1KGhpiIjIzEajVitVqfUk+bF8/SXiIi4J6vV2iBfqJkZS/njt1+prDhMZWUFlRVH/zn673/93yP/bC38EThyXsG/n07A/ud7Kw8fU6Pk4H4uuOCCY5Y91oevry9BQUHk5+c7pZ40LwoDIiInkZ+fT1BQkFO/ULt27coXH8zliw/m1rnO/r172P/fpYOnEhAQUOdnnIi/vz82W/1OapTmSWFAROQkysrKnP6FGhDQGr+AtrQ/rzOeXl4YPb3w8mqF0csLT08vPL1a/fd///TvXl7Y7XY+fv/IbP4bbrub1m3PxNPT68h91ff8797PF89k/69bnNp7SUkJvr6+Tq0pzYPCgIjISZhMJoqLi51as6y8DMvVQ/j7hIdqdd/qrz4GoFO3Cxl04+2nvf7Ci3oz95vPqg8hqi+bzUZhYSF33313vWtJ86MJhCIiJ2E2myksLKSsrMwp9Ww2G5s3beK8LoG1vjdvbeaRnnrXbP5C16BQ7HY7mZmZtX7WiWRmZmK32wkPD3dKPWleFAZERE4iPDy8Qb5QLwiq3ba+VVVV5K870kNo78trdE/nwGDO6xzIjBlJte7zRJKSkggJCSEsLMwp9aR5URgQETmJXr16ERwcTFKSc75QZ8yYwfldAunUrWet7vt560YO7tuLt8mX7sFhNbrHYDBw9dCbWLJkcb2XA1qtVpYsWcKkSZOOO5ZZXIPCgIjISRgMBhISEli82DlfqEuXLuWqITfV+gs177sjowLBl0TgWYuzAfpccR0+Jj9uueUWSktLa/XMo0pLS4mLi6NXr16MHz++TjWk+VMYEBE5hXHjxhEWFkZcXFy9vlBvueUWvFq1wnLN0Frfn7f2v1sQ1/AVAcD+P37jX4+Ow1ZazJYtWxg+fHit+z96amFRUREpKSl4emrOuatSGBAROQUvL68j5woUFREdHV2nL9Trhw9ny5YtHCov57NFKbW631ZazJaC7wEIvfSyGt2ze1cRL903hh0/baR9+/bMmDGD1atXExERUeMRDqvVSkREBNnZ2aSnp+v4YhenMCAichqhoaGkp6eTnZ1d6y/USy+9lJVfraT/iH8A8MmCd/hlx081fvaG79dgt1fS/vyunN2h02mv37Ypn5f+OYbff91JYGAgmZmZ3HHHHWRlZWEymbBYLMTGxrJ8+fLjVknYbDYyMjKIjY3FYrFUH1scFRVV436lZVIYEBGpgaioqDp9of7888/Y7ZVszs8htHck9spKZk97rsaHFeWvPbqK4PRLCtfnZPF/D42l+MAf9OrVi8zMTAIDjyxjDA0NJSsriylTprB+/XoGDBhAQEAAISEhREREEBISQuvWrRk4cCAFBQVMmTKFrKwsjQi4CYND51GKiNRYRUUFycnJTJ06lYKCAoxGI0FBQfj7+1NSUkJhYSF2u52QkBAmTZrEFVdcwRVXXMGBAwe4NLI/ed99w+FD5dz+zxfod+2wUz7L4XDw0G1/Y++eXdz19HQuCr/ipNeuWfkp77z2MPbKSq655hqWLFlC69atT1o3NzcXq9VKfn4+NpsNX19fzGYz4eHhhIWFadWAm1EYEBGpg9p8oX7++ecMHjwYu93ORX0u58fvviGgzRk8+/YH+Ae0OekzftnxE4/HD8fTqxVvvv8N3j4n3knwiw/mMC/pZRwOByNHjmTmzJl4e3s3yOcW16QwICLSCKZMmcLkyZMBOOPsc/njt1+5clAs/0h88qT3ZCydxftvv4L50su457nj9zpwOBwsnTmFj/57ZkFCQgJvvvkmHh56Ayy1o3UiIiKNICEhgby8PN5++22KD+wD4OtPFnLZtcMJDL6Eoi0FbCvMY2fRFioOHcLL25uC3NUAhJxgFYHdXsmsKc/yzeeLAXjuued45JFHNLwvdaKRARGRRlJRUcHAgQP56quv8Pbx5VC5jTZnnI2ffwC7in7CaDTSvUcPAgICKD5YzKZNhVRVVdH+vE70j/4HV/ztBjw9vTh8qJy3X76f3Oyv8PDwYMaMGYwbN66pP560YAoDIiKNaO/evfTt25ctW7ZgNBqpqqoiJiaGCRMmEBkZecwJg2VlZWRmZjJjRhJLliymc2BPRo1/iMUpb7Apfx0+Pj6kpaURHR3ddB9IXILCgIhII5s5cyZjx44lMDCQOXPm0KdPn9PeY7Va+cett7J50yYqKytp06YNH374IVdccfIVBiI1pTAgItKI8vLysFgsWCwWli1bhp+fX43vLS0tZdiwYaxatYr333+fmJiYBuxU3InCgIhII6moqMBisVBeXs6aNWtqFQSOKi0tJSIionp3QK9aHFwkcjJafyIi0kiSk5PJzc0lNTW1TkEAwM/Pj5SUFHJyckhOTnZyh+KuNDIgItIIHA4HZrMZs9nMggUL6l0vNjaWgoIC8vLytJxQ6k0jAyIijSAnJ4eCggLi4+OdUi8+Pp7169eTm5vrlHri3hQGREQagdVqxWg0Ehl5+gOHaiIyMhKj0VjjExRFTkVhQESkEeTn5xMUFHTMPgL14evrS1BQEPn5+U6pJ+5NYUBEpBGUlZUREBDg1Jr+/v7YbDan1hT3pDAgItIITCYTxcXFTq1ZUlKCr6+vU2uKe1IYEBFpBGazmcLCQsrKypxSz2azUVhYiNlsdko9cW8KAyIijSA8PBy73U5mZqZT6mVmZmK32wkPD3dKPXFv2mdARKQRaJ8Bac40MiAi0ggMBgMJCQksXry43ssBrVYrS5YsYdKkSQoC4hQaGRARaSTOPpsgOzsbT0/PBuhU3I1GBkREGomXlxepqakUFRURHR1NaWlpre4vLS0lOjqaoqIiUlJSFATEaRQGREQaUWhoKOnp6WRnZxMREVHjVwZWq5WIiAiys7NJT08nNDS0gTsVd6IwICLSyKKiosjKysJkMmGxWIiNjWX58uXHLTu02WxkZGQQGxuLxWKpPrY4KiqqiToXV6U5AyIiTaSiooLk5GSmTp1KQUEBRqORoKAg/P39KSkpobCwELvdTkhICJMmTWLcuHF4eXk1ddvighQGRESamMPhIDc3F6vVSn5+PjabDV9fX8xmM+Hh4YSFhWnVgDQohQERERE3pzkDIiIibk5hQERExM0pDIiIiLg5hQERERE3pzAgIiLi5hQGRERE3JzCgIiIiJtTGBAREXFzCgMiIiJuTmFARETEzSkMiIiIuDmFARERETenMCAiIuLmFAZERETcnMKAiIiIm1MYEBERcXMKAyIiIm5OYUBERMTNKQyIiIi4OYUBERERN6cwICIi4uYUBkRERNycwoCIiIibUxgQERFxcwoDIiIibk5hQERExM0pDIiIiLg5hQERERE3pzAgIiLi5v4fNQ9YHJKyXgkAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -780,7 +782,10 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 24, @@ -789,7 +794,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxoAAAMWCAYAAAB2gvApAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzddZxUZfvH8c+Z2O4mlu7uUEpAERQUbEVFBEF47JafgV3YIgaoWBiESKOS0t3du8R2Tc85vz9md9nZme0hvd6v1/PInjnnzFnYON9z3/d1KZqmaQghhBBCCCGED+ku9AUIIYQQQgghLj8SNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XMSNIQQQgghhBA+J0FDCCGEEEII4XOGC30BQogLS9M0srOzsVqtBAYGEhoaeqEvSQghhBCXAQkaQvwHpaSk8O233/LXX3+xceNG0tLSCl9LSEigffv29O/fn6FDhxIeHn4Br1QIcTnKyMjgxx9/ZO3ataSnp6MoCjExMXTv3p3bb7+d4ODgC32JQggfUDRN0y70RQghzo+0tDSeffZZpk6dis1mK3P/4OBgRo0axfjx4wkJCTkPVyiEuJzt3LmTDz74gJ9++gmz2ex1n7CwMO69914effRR6tWrd56vUAjhSxI0hPiPmDNnDvfffz9nzpyp8LF169Zl6tSpdOvW7RxcmRDiv2Dy5MmMHj0ah8NRrv0DAwP5+eefueGGG87xlQkhzhVZDC7Ef8BXX33FoEGDKhUyAA4fPkyfPn34448/fHxlQoj/go8//pgRI0aUO2QAmM1mBg8ezLRp087hlQkhziUZ0RDiMjd9+nRuueUWvH2rBxiN9GxenzZ1axIRHEBqdh6bDp1gxe6DOJyqx/5+fn4sXryYHj16nI9LF0JcBubOncvAgQM9fgbVjI9l2OABtG3aCFVVWbttF9/9MZ+U9Ey3/fz8/Fi2bBldunQ5j1cthPAFCRpCXMaSk5Np3rw5mZmZbtuNej3PDunL//p3JzrUc9FlcnoW783+h0/mrfC4Oahduzbbt2+X6lRCiDKpqkqTJk3Yv39/4TZ/Pz8+fv5Rht14LQaDe00aq83GJz9M57kPv0BVzz7s6NatGytWrDhv1y2E8A0JGkJcxm6++WamT5/utq16ZDhzxj1Aq9rVyzx++a6DDHlnMpl57os2H3roIT7++GOfXqsQ4vKzePFirrnmGrdtcye9y7XdOpd63Hd/zGf4uDfdtm3bto2WLVv6/BqFEOeOrNEQ4jK1f/9+j5AR6Gdk4YsPlitkAPRoVp9Zz4xApyhu27/66ivS09N9dq1CiMvTxIkT3T6+9dreZYYMgHtv6E+PDq1LPZcQ4uInQUOIy9QXX3zhse21O6+jac34Cp2nW9N6PHp9L7dtFouF7777riqXJ4S4zNlsNubOneu2bcwdg8t9/OjbbnT7eObMmb64LCHEeSRBQ4jL1Lx589w+jg4NZtTVV1TqXE/ecBV+Br3btuI3EEIIUVRqaip2u73w47CQYLq1a1Xu4wdd5V5O+/Tp0zidTp9dnxDi3JOgIcRlKCcnhz179rhtG9ypJQF+xkqdLy48lL6tGrtt27Rpk9dKVkIIAWAymdw+jggNQSk2DbM0gQH++Bndf2aV1ORPCHFxkqAhxGVo//79HiGgff3EKp2z+PEZGRmcPn26SucUQly+wsPD3T4+nZaBrcgIR1lS0jPd9tfr9QQHe1bJE0JcvCRoCHEZKv4kEVyjElURGxbisU2eLgohShIVFUVEREThx1abjRmLl5f7+B/nLHL7uF69ehUaERFCXHgSNIS4DPn7+3tsyzZbqnROb8f7+flV6ZxCiMuXXq/nrrvuctv28Q+/lWvKpcPh4LOfZrhtu+eee3x6fUKIc0+ChhCXobp163ps23I4qUrn3Frs+MDAQOLjK1bBSlwa0tLSeO+99+jVqxcNGjQgLi6OWrVq0bZtW0aNGsX69esv9CWKS8SDDz7o9vHabbt49fNvSw0bqqry8BsfcehEcuE2g8HAiBEjztl1CiHODWnYJ8Rlqnbt2hw7dqzw43rx0ez5+Hl0uoo/X8izWKk16mWyTGdHNbp27cqqVat8cq3i4rB582Y++ugjpk2bhtVqLXXfDh06MGbMGIYOHYrRWLkiA+Lyp2kaXa/swdrVK92233FdX8Y9cA9N69dx275p115e+nQK85avdt//jjv46aefzvXlCiF8TIKGEJep4cOH880337ht+/WJYQzp0rqEI0r2ybzlPPaNew37cePG8dprr1XpGsXFQdM0Xn75ZV599dUKVxJr3749s2fPpnr18jWBFP8dqVlmVu1KZtv2nbz5xFBMuTke+3Rr14q2TRuiahprt+5iw849HvvUqFGDdevWydeYEJcgCRpCXKbWrFlD165d3bYlRISy9f1niA4tf+WWw6fTaPvku+Razj7hVhSFQ4cOUadOHV9drrhAVFVl5MiRTJkypdLnSExM5J9//qFBgwY+vDJxqbI7nGzcf4ZdR9MouMPYt2MjH700BqvZs1BFaWJjY/nrr79o1ar8/TeEEBcPWaMhxGWqc+fOdOnSxW3bqcwcrnv9S9Jz8sp1juOpGVz3+hduIQOg9ZV9ySJU+mhcBp577rkqhQyA48eP079/f1JSUnx0VeJSdeRUFr+v2M/OI2dDBkCjFu155p3viImvUe5ztWjRgtWrV0vIEOISJiMaQlzGtm7dSocOHXA4HG7ba0SF8+mIm7m+Q3Ov5SKdTpWfVm7k8W9mkZHn/gTSPzCYxz6dRURsNcKDDFzZIIYWtaKk7OQlaM6cOQwcOLDE19s1qsstV3WlbrU4sk0mlmzayfRla7HZHV73HzhwILNnzz5XlysuYjkmG6t3JXM8JbfU/ex2GxtXLmLJnGkc3L3V6z59+/ZlzJgxDBw4EIPBcC4uVwhxnkjQEOIy9+abb/L88897fa1x9Thu7NyKtnVrEB4USFpOHhsPHWf66q0cS83weswtj7xO+z43uG2LCDJwZcMYmidK4LiUXHHFFaxevdpje5sGdfjkseF0ad7Q498zJTObN3+Yyce/zfd6zm3bttGyZctzcr3i4qOqGtsPp7L5wBmcavlvJ4L8DbSMc7Bu3TrGjBmD1WrlrbfeYsiQITRs2PAcXrEQ4nySoCHEZU7TNB566CE+++yzKp+r39CHuerWB0p8PTLIwJUNY2mWGCmB4yK3efNm2rVr57G9a4tGLHjveYIDA0o9/os/FjP2/cke2x988EEmTpzos+sUF6+T6Xn8uzOJrFxbhY9tnBhJtxauaVRRUVFkZGSwe/dumjRp4uvLFEJcQLJGQ4jLnKIofPLJJ7z22mvo9fpKncPP35+7Hn+11JABkGFyMGfrSb5eso9dxzJkDcdF7PPPP/fYZtDr+eGFh8oMGQCjbriaAV3bemz//vvvyc7O9sk1iouTxeZg+bYTzFt7uFIhA6BWXFjhnwumRxWf4imEuPRJ0BDiP0BRFMaNG8fcf1bQuEWbCh/fsFkrho8ejZ9f+YJKep6DP7cmM3nJPvackMBxsVFVlV9//dVj+009O1M7Ibbc53ns1us9tuXm5jJ37twqXZ+4OGmaxt7j6fy+fD/7kzIrfR6DXqF69NnKdwVBw+l0VvUShRAXGQkaQvxHWBwqYbWb8tUff/PNjPnccccdxMXFed03NqEa1906lDe++AGjnx87N69nw/K/aZoYhVKBnxppeQ7+2CyB42KTmppKVlaWx/Z7+ves0Hl6tW1GrfgYj+0HDx6s9LVdDKxWK7t372bVqlWsXr2aPXv2YLfbL/RlXVDpORbmrj3Myh3JWO1VCwQ1YkIw6M/+IJERDSEuX1LOQYj/iENpJpyqhqIoXH9Nb4YNvhZN0zhx4gSHDh3CYrGg9/MnLziB6Nj4wuNuHjaKn7/8hIlvvci381bSoHok+094XyhekoLAEbM/he6N4mhUI8LHn52oiIwM7/9+rerXqtB5FEWhZb1aHDudWq7zX+wOHTrEpEmTmDJlCmlpaW6vxcfHM3LkSB544AESExMv0BWefw6nyqb9Z9h5NBVV9c05E2ND3T4umNIpQUOIy4+MaAjxH5CaZyPd5Hoia9QrRAUZAdeNYmJiIj179qRfv3706dWTmCIhA+DuMY8THhnF0QP7+HPaVOIiAkmILn/DP7fryLUzc1MSU5bsY39yZpU+J1F5JS3UVytQNajwGC+jVJdaIYBTp04xaNAgGjRowLvvvktaWhp6vY6Y8FCiw0PR6RROnz7Na6+9Rp06dbjttttIT0+/0Jd9zh09k83vK/az/bDvQga4r88AGdEQ4nImQUOIy5xD1TiUZi78OC7EH10JN4KKouBncP+xEBoWzn2PPAPAlI/eIi8nm3oJ4YQG+1X6mlJy7czYmMQ3S/ax/2Rmpc8jKicyMtLr9o17D1XoPE6nyuZ9h8t9/ovR3r176dKlC3/++SeaptGleUO+GzeWrPnfcmr2V5ye/RWZ87/lq6dH0a5R3cL1LVdccQVHjx690Jd/TuSabfy16Sh/bTxGntm3U8ZiIwIJ9HefTCFrNIS4fEnQEOIydyTdjM159nFkQmjpAcFP7/lj4YY7hlGrXkMy01L5/vMPURRoUjMSP2PVfoScybUzY0MS3y7dxwEJHOdNTEwMsbGei76/mbekQudZsG4Lp9IzPbY3bdq0spd2XiUnJ3P11Vdz9OhRqsdEsuKzV1g58VXuuqY7Af5nv0+CAvy577qrWPvlGyx8fxwx4aHs3buXfv36XVYjGwU9Maav2M/R0znn5D1qxYV6bJOpU0JcviRoCHEZy7Y4OJVjLfw4PMBAoLH0ylH+Bs8fCwajkQeffRmA36Z8zqmk4/gZ9TSuWbHF4SU5nWNn+oYkvlu6n4MnpTTquaYoCnfddZfH9jmrNrHryIlynUPTNN77+U+P7VFRUfTv37/K13g+DB06lOPHj1MzNoqVE1+la4tGpe6vKAp92rdk+WfjC8PGiBEjztPVnlunM0zMWnWAdXtO4XCeu6INxadNgUydEuJyJkFDiMuUqmkcSDO5bYsP9S/zOG9BA+DKPtfStks3bDYrX777KgBhwX7UTQiv+sXmO5Vj4/cNx5m6bD+HTkngOJdGjx7tsU3TNO54+UNSM0v/u9c0jfHf/M6Krbs9Xhs+fDiBgYE+u85zZcuWLSxZsgRFUZj5xlNeq2eVpFFidX599XEAZs2axaFDFZtydjGx2h2s3JHEnDWHyCjyUOJcCA40EhXq2aNFgoYQly8JGkJcppKyrJhsZ+c8G3QKMcHGMo/zN5S8fmPs86+iKAqLZ//Orq0bAagWFUxcpG9vLE9m2/h9/XG+X76fI6clcJwLjRs3pm/fvh7bdx4+QedRzzN96RocDs8583uOJnHn+I947bvpXs/rLcBcjAoaFvbr1Jq2jepW+PgerZvSpXlDNE3jiy++8PXlnRcHkjL5ffl+9h4/P1XCvE2bAlmjIcTlTMrbCnEZMtudHM+0uG2LC/ErcRF4Ud7WaBRo3KI1/QbfxoIZ0/js9Rf49Je5KIpC/WoR5FkcPl04qgHJWTZ+XXec6uF+dGscT514z2kXovJefPFF/vrrL4/tR0+lcttLH1IjNoohPTpRp1oc2XlmlmzewfItnqMYBe6++27q169/Li/ZJ7Kysvjhhx8AGH3j1ZU+z4M3XsOanfuZPHky48ePJyCg7I7qF4PMXCurdiVzMi3vvL5vSUFD1mgIcflSNOmgJcRlwWq1sn37dnbs2MH+5DScOiO16jWkQbMWBAWH0K5GGEHl6OydY3WwNbnkhaBnTiZxZ59OWC1mXpv4HT2vHQiAxeZk68EUHE4f1sEsQlGgepgf3ZvEU9vLPG9RORMmTODJJ5+s8nnatWvHsmXLCAkJ8cFVnVtLliyhd+/exISHkjTzC/SlhOvSWKw2YgeOwGy1sWnTJtq2bevjKz3Lbrezd+9e0tLScDqdBAcH07hxYyIiIsp9DodTZeuhFLYdSvFpudryMBp03NW7ide/6549e7J8+XJ+/fVXbrnllvN7YUKIc0pGNIS4xK1atYrPPvuM6dOnY7V6zrHW6XRc0asPzzz2MAMGDECnK/2myr+Mm664ajW4feRYvvvkPT5/+2Wu6N0Po58fAX56GiVGsOtoums4wsc0DZKybPyy7jg1w/zo1jSeWrESOKrqwbEPs3rrQaZ//3mlz9GiRQvmzp17SYQMoLBSVLXoyEqHDIAAfz9iwkM5fibtnFSfOnr0KF9//TWLFi1i69atXr+/69evT9euXRk2bBi9e/cusYfJidQcVu08SY7J5vPrLI+aMSEl/l3L1CkhLl+yRkOIS1RaWhp33nknV155JT/99BNWq5UAo5EO9WvRt1UjujauQ2igP6qqsvKfxQwcOJDevXtz8ODBUs9r1CuUNcPqzgceJio2nqSjh5nx/deF2yNDAs75aIOmwfEsG9PWHufnFQc4nnJuynD+F5gsduatP0z/O8Zw90MvYvQru1hAca06dmf2vMUkJCScgys8NwpuaPVlhO7yKDiHL2+Sd+/ezY033ki9evV47bXXWLdundeQAXDw4EF++OEH+vbtS9OmTfn+++8pOlHBZLHzz+ZjLFx/9IKFDIDEEqZNgUydEuJyJiMaQlyCduzYQb9+/UhOTgZgcOdWjO53JT2a1sdoODs9SlVVNh9O4svFq5i6bD3Lli2jdevWTJ8+nX79+nk9t6Io+Ol1WB0lz60ICg5hxOPP8c5zj/Ldp+/R/6Y7CItwNWmrGRtCjtlGeralxON9QdPgWKaVaWuPUTPcn+5N4qkZW/LNjHBXEDKycl03nz3730KL9t1YNv83ViyYTk5W2U/o6zdrw0Mvf8b6Q9lUT4jB33hp/EopaCh4JjMLTdMq3cnc6VRJzcpxO2dVOBwOJkyYwEsvvVRisCjN3r17ueeee5g2bRqTJk0i2xnExv2nsZfyvXw+KAoklvK9KVWnhLh8yYiGEJeY/fv307t3b5KTk0mMjmDhiw/y25P30adlI7eQAa5pU+3rJ/LF6NtY99bjtK1bg7y8PAYNGsSSJSU3ZyupxG1RA26+i3qNm5GTlcm3n7zr9lrDGhEEBpS9HsQX1PzA8fPaY0xbeYCkVBnhKEvxkFEgOq4aQ+59mHemLmbk02/TudcAGrVoT2K9xtRr0oqWHboTGHR2etSh3Vs5neR6Ur5s6wkulSV/rVq1wmAwkJyawb/b91b6PPPXbibXbCEoKIgmTZpU6Zry8vK47rrrePbZZysVMoqaN28ezVu25qdZiy54yACIiwgiwK/kECpBQ4jLlwQNIS4hDoeDO++8k5SUFBpVi2XVm4/Sp2XpTcYKtKxdnaWvPESv5g2w2WzceeedJc4rL0/Q0Ov1jH3+FQBm/jCZE0fO9hIw6HU0SYxGr6/ck+LKUDU4mmHlpzXH+OVfCRwlMVnszF3nGTKKMhr96NxrACOffpun3/mWlz79neff/5FHXplI1z6uxf9RsQlomsaimd8BcDwlly0HU87L51BV8fHxDB48GIBJsxZV+jyTZi0G4K677iI0tPKjaWazmQEDBrBokfdrMep09K1XnWe7t+LrG67k28HdefvqDtzeoi7VQryXls7JymDC8yM4tHd7pa/LV0qqNlVA1mgIcfmSoCHEJeSDDz5gw4YNBPoZmf3cSKpFVqxZXnCAP9OfGk5idASnTp3iiSee8LpfaSVui+rUvTede/bBYbcz6e2X3V4L8jfQsEbVp5NUlKrBkXRX4Pht1UGS03LP+zVcrPLyQ0Z2XuXn6rfu3AsAq9kMwKq/ZpOVkQrApv1nOHEJBLykpCSaNWsGwPRlazl2OrXC59h9JImF67YCMGbMmCpdzz333MPy5cs9tgcZ9Iy/qi1HHr+FBfdcw2t92jGsbUOGtq7PE1e24Iebe3LosVv47daraBnn+b1mNZv4+KWxZKZf2ADorRt4UbJGQ4jLlwQNIS4RNpuNCRMmAPDK7QNoUC22UucJDw7k81G3AvD999+TlJTksU9JTfu8GfvcK+h0OpYtnMPWdavdXosOC6Bm7IWpRKRqcCjNwk+rj/D7qoOc/I8HjjyLnblrqxYyABq37EhAYDB5uVlUr90Ah93Gkj9/Lnx96ZYTF3TRcUk0TWPu3LkMGDCAxMRExo8fD4Dd4WTw8++SnWcq97lSM7MZMu5dNE2jW7dutGnTpsLXk5uby5dffkmDBg34/fffve4T7Gck3Wwly1LK6JNex+BmtVn7wPWM69Ha832yM/j+k1cu2LS20CA/IkJKLzIgU6eEuHxJ0BDiEjF79mxOnz5NeFAAo665okrn6temCa1rV8fpdDJ58mSP18sqcVtU3UZNuf62uwH47I0XUIsV6K8VH1bmjca55NQUDqZZ+HH1EaavOsip9PPbpOxikGu2MXftYZ8EAIPRSIv2VwKQUKMOAP/MmYbF7LpRt9qd/L35GM5z1E+lMg4fPkzfvn25/vrrmT9/vsdN99YDR+nzyCskpZS9AP5Q8ml6PfQy+0+cIjY2lu+++65C16JpGj///DN169Zl1KhRpVaBSzFZ+GjNLpp9OpMH/1xFdimBw8+gZ3zvtky+4UqP17auXcr65QsqdJ2+Uta0KZCgIcTlTIKGEJeIf/75B4CburQmyN+vSudSFIWhPTu6nbcov3Ks0Sjq/kefIzA4hN3bNvH3nzPc3wtolBiJfzmaBZ5LTk3hQJqFH1YdZsaqQ/+ZwJFrtjFv3RGfjjK07tILgNPJR4mrXgtTbjYrF80sfD0t28Lq3Sd99n5VMX36dFq2bOn167yozfuP0OiORxj+5kTW7T7g9pqmaazctoe7xn9M87sfZ8+xZGJiYpg3bx716tUr97VYLBbuuOMO7rzzTlJTKzZd66uN+2j7+R9sOZlW6n73tm3IM91aemyf9+vXF2RUozxBo2DqlKzREOLyc2nUIhRCsHHjRgA6Nqjlk/MVnGfTpk2oqurWyK88i8GLioqNY+joR/hqwut88e4r9Oh3Hf4BZxepGvU6miRGse1wCtoFftDt1BT2p5k5vOow9aKDuaJJPPGRQRf2os6RcxEyAFp27IFOpyfpyH5uvPt/zPr+UxbPnMpV19+GXu/6tbL3eAax4YE0Tozy6XtXxI8//sg999zjMcpWICLQn1Y149AB646exGSzM3XBcqYuWE79GvHERYajaRqn0jI5cursOofWrdvw+++/0aBBg3Jfi9Vq5YYbbvC64LtZzXh6NW9Is8QE/Ax6jqVmsP7AMf7evg9HkZGho1l59Pl2AX8Nu5a21aJLfK8Xe7Xhz73H2ZWSWbjtxOF9HNi1hYbNz1338uL8DDoSIoPL3E9GNIS4fEnQEOISUdAzo35C5dZmFNcgIQaAnJwc8vLy3KrmGHWupn0VeQB66/AH+eOnbzidfILfvvmCoQ8+6vZ6SKCRBtUj2X8iwxeXX2UOTWFfqolD/x6ifowrcMRFXD6Bo2C6VK7Z7vNzh4SG06B5W/Zt34DR35/Q8CjSziSzYcUiOvcaULjf6l0niQ4LJCbce2Wkc2nZsmXce++9HiFDpyjc3bk5o3u0pUOthMIeGqqq8deew7yzeB3L9h3jYNJpDiad9jjv8Eef5Ylnn6dBfMWqTD322GMeIaNd3ZpMuO9GujWp57WXx8mMLN6e+TefLVhZOBqRZbUz6Me/2DrmRqKCvE9J9Dfoeb5HK4ZOd19gvuqvP85r0EiMC0WnK3u9lwQNIS5fMnVKiEtEwY1GeX5xl0fR8xSfUqEoSoXWaQAEBAYx8skXAPj+8/fJSPWsdBMXEUi16LKfcJ5PDk1hb4qJH1Ye4o+1hzmTWf5FwRerHNO5CxkFCqpP7djwL70H3g7Awunfun0tOVWNvzcfw2I7vzeQubm5DBs2zGMqTpP4KP59aiiT7x5Ax9rV3G7udTqFa5rV469HbufQa6P56JY+1InyrJY0fepXHDx2kgxT+f9u//77bz7//HO3bQ9f14N/33iU7k3rl9gwsFpkOB8OH8LCFx4kLDCgcPvJXDOPLVhb6nsOblqbmGJB5NCereW+Zl8orUlfUVLeVojLlwQNIS4RsbGukYxj5ViwWh5HzrjOExgYSHCw581/RadPAVxzwy00btEGU24uUz562+s+dRPCCQ2u2hqTc8GuKew54wocsy/hwJFjsjF33bkNGQBt8oPGvh0b6HzV9fj5B3Ds4G72bHW/Ac4121l6npv5vfTSSxw5csRtW4daCax8cigda1cr8/jEyDDG9mrPthfup0+T2m6vZaWn8clr4ziYbkItx+ekaRqPPvqo27YRfbow4d4bPRpslqR3y4bMenYEuiKB5Mdth9iQVPI6D3+DnitrxbttSz5+CKvFXK73rCpFodwV56S8rRCXLwkaQlwi2rdvD8CGA8d9cr6Nh1znadOmTeEv+qIquiAcXJ3Ix457FYA/p33HkQOeXZcVBZrUjMTPeHH++LFrCrvzA8efaw+TknXpBI5sk5W56w6Td45DBkB8jdokJNbF6XBwdP9Oul3jaoC3YPq3Hvsmpeay6cCZc35NAFlZWXzxxRdu2yKDApg5eggRQQElHOVdkJ+R30bcSK1I95GNv+fM4OjRY5zIspR5jhUrVrBjx47Cj+vFRzNh2I0ljmKUpEez+jwx6Cq3bZPW7yn1mOLrODRVJeWkb35+lCUhKhh/Y/lmZ8vUKSEuXxfnb3ohRCGz3UlytoW6rVxVomas3YrNXvVfyL/8uxmA7t27e329olOnCrTtfCXdrh6A0+lk4psved3Hz6incWIUykX8E8iuKew6Y+KHFYeYcwkEjmyTlXnrjpyXkFGgYFRjy9qlXD34HhSdjp0b/+X4Ic+AueVACsfOnPtmflOnTiUvz72i2ISbelMtvHL9XMIC/Zl4xzVu21RV5fO3xzPpy8lM+OBDpkyZwsKFC8nJ8fz8pk6d6vbxs4P7EhxQuXLPzwzu61Zx7pcdh7E6Sp5uFOtlDYfNWnY48oXyVJsqIEFDiMvXRfxrXoj/JlXTyDDbOZRmYuOJbDaeyOZQmpmOvQcQFBLGqcwcpv27qUrvsW7/UVbuPgTAiBEjvO5TmRGNAg8+8zJ6g4HVSxax4d9lXvcJC/KjbkLFOptfCDZNYWd+4Ji7/gipWedn6klFZJuszF17fkYyimrd2fWEffv65UTGxNP+yqsB11oNb5ZtPU62yXpOr+n3GTPdPq4REcKdHZtV6Zz9mtWldY04t21//zmdN595iCcff4z777+fa6+9lmrVqjF69Gi2bt1Kbm4u+/fvdyur62fQc9uVlV+MHREcyOBOZ0vXmh1OdpwpubiCXfWc2qXzMnp5LlQkaEh5WyEuXxI0hLgIWBwqp7Kt7Dqdy5qjWew8lUtythWz/ewvXqvOn15DhgLw1NTZnM6s3NNhq93ByM+nATBo0CAaNmzodb/KrNEoUKteA268azjgauJX0g1Etahg4iLPf0WiyrBpCjtO5fHDioPMu4gCR0HIMFnO/9Pg+k1aERIWiSk3hwO7tnDtTfcBsH75AtJTTnnsb3Oo/L35uFvJVl/RNI1jGSY25ZeBLnBHx2YYKjk6V+BMjglbOW6C8/Ly+OKLL2jTpg2hoaE0atSIw4cPF77eqnb1So9mFOjcqI7bx1tOlrxma39alse2kLCIKr1/eYSH+BFWQkUsb2REQ4jLlwQNIS4AVdPIsjg4km5mU1I2G45ncSDNRLrJ7nWBqd2pkm6yM2jEY8Ql1iEtJ4+b3p1Cjrli0yAcTicjJv7MzuOum0CbzYbZ7P2G2V9ftepWwx56ipDQMA7s3sGCGdNK3K9+tQiCA41Veq/zyaopbD+Vxw8rDzJ/wxHSsi9c4MjKszJ3zYUJGeB6Ot6qk2vq3da1S6nTqDlNWnXC6XSweNb3Xo9Jz7awameyT6/D7lTZdSaPNdv2kpuT7fZap3Is/i7NvtPpXPneD+w+VXqjvPKoG1dy74vyqhfvfo40c8kjRBuS3a85KCSM6LjqVb6GstSK9azWVRoJGkJcviRoCHGe2Jwqp3Os7DmTx9pjWWw/mcOJLAsmW9lPSlPy7Gga+AcEMuqVT/ALCGTNviP0fulTdp/wrPXvzcmMLAa/PZmfV56ddrVgwQJatGjBoUOHPPavyogGQERUNPf87wkAvprwOmaT907cOp1C01pRGKr4fuebVVXYdtI1wrHgAgSOzFwr89YexmS9sDdnBdOntqxZgqZp9LtpGADLF/yOKTfb6zH7kzLZc8w31dNyrA62JOeQYbKTnek5jah+bGSlz52cmUO/T37hiJeRgcpwltA4sCrn0JWwqPxQeg7rTriXmK7doGmFF6FXRkWmTYEEDSEuZ5fWb3YhLiGappFjdXAsw8zW5BzWHctif6qJ1DwbTi9zp0uSY3W4hZF6zdvy6PvfEhAUzObDSXR4+j2e/O4PDpz07FsBcDozhzemL6bVY+8wf/NudDodj7z4JvWbNAfg0KFDNG/enNmzZ7sdZ9TrSryJKa+b7nmAaom1STtzimlffVrifv5GPY1qRsC5vwfyOYuqsDU/cCzceJT0nHO/2DYz18r8dRc+ZAA0b3cFBoORlJPHOXn8MC06dKNG7QZYzSaWzvu1xONW706ucgnh5GwL207mYHW4br69ldCt7JewqmrcPnk2xzN8t4B9X7L379GK2JvsXr0rPth7Ja3P1++h+N9Gi/bdqvz+ZQnw0xMfWbHGl7JGQ4jLl3QGF8KHHKpGptlOuslOhtmBvYpz0Z2qRmqe5wLflp268dXsJbzzzENs37iWD+cs5cM5S2mQEEObujWICAokz2pj+9GT7DpxqnA6VmLdBjz3zie0bN+ZG+8azptP/49Ff/yGxWLhhhtu4Mknn+TNN98sfMLoZ1Cw2Cvf/8DP35/RT7/ISw/dz09ffsLA2+8hJt77VJbIkABqx4Vx9LT3p+AXO4uqsCU5lz2ncmiSEErHRvFEhVasnGppNE3jwIEDLFu5mjl/rSInNwe9Tk9kbAK1GzSlTsPm+Aec/87mAYFBNGnTmR0bVrJ17RKq16pHv5vvY8qEcfz9x49cPfgejEbPvimqCv9sOc6NV9QnwK9iv4ocqsb+1DzSin1vBId6Ttk5mp5Nq2ILuctj7s6DrDqUVOo+zRvUpVGdRPYfPc6O/YdL3Rdg14lTpOXkER1a+aaV/+52f5921T2nY207lc6na3e7bTMY/bii7w2Vft/ySowNrfCoiYxoCHH5kqAhRBXl2Zykm+xkmu1kWxweTxGrIs1k9xj9UBRICPMnIKoBn0ybw5K5s5jx/dds37iWA6dSOXDKs4lXnYaNufGu4Vx/61D8A1yLrw1GIy988AVNW7fn41efQ9M03nvvPVatWsWMGTOIj4/HX6/DYq9aWLpqwI389s0kdmxaz9fvv8Gzb39S4r41Y0PItdhIK0d/gotVQeDYeyqHpgmhtK9i4DCZTEydOpWJEyeyffv2Evfz8w+gU88B9B54B7XqN6n0+1VG68692LFhJVvWLKX/LffTqUd/Zn77ERlpZ1jzzxy69xvi9bg8s50lW45zbcc65b45zbU62JOS5/XrskbtugQEBmExnx0p2XD0JANbNqjw5zRp+eYSX+vfvQtvPjaKlo3qF27bsf8Qz74/ifkr1pR4nKppfPPPWp68oXeFrwcgOT2LuZt2Fn4cGeBHkxj3ym3ZFhvDZq7AXmyKVaee1xIaXvlpZOVV3m7gRUnQEOLypWjns12rEJcBp6qRaXGQYbKTYbYXTtvwNZPdSXKW50LPuBA/wgI8nxGcSjrOnm2bObR3F2azCT8/f2rVb0jjFq2pXb9RqTdym1av4NmRdxauo4iNjWXGjBnENW7LmVxblT+XHZvW8eDN16IoClPmLKNB0xYl7utUVbYeSsFsufSnUShAgE6jabVQOjSMJ7KCgeOff/7h/vvv9+hyXZarrr+dm+57jIDA8zPCkZ56iqfvuRpFUXj/p6WEhkexcPq3/DZ5AgmJdXnl81nodCXP1G1dP5YOjeJLfL3AyWwrh9JNlPZba8wt/dm+8Wx38oZxkex8YQQ6Xfmfsh9MyaDxy195fe22/n348Z0XvX4/aZrGXU+/wi/z/y7x3NGhwWx7/xniIzxvyJ1OlQVbdvPV4tVsOnSCjDxXYIoMDqJDg0SyTRaW7jxQuP8jXZox4dpOhR+nm6zc8PPfrD7uPr3KPzCYlyfOJLaE0URf0engrt5N8TNWrITup59+ykMPPcQtt9zCr7+WPN1OCHHpkTUaQpRDQdO8HadyWXMsk92nczmVYz1nIUPVNFK83OCHBxq8hgyAhBqJ9Oo/iOGPPsvY515h5BPj6HfjrdRp0LjMp8Xtunbnm7nLqV67DgApKSn07NmT77/8zOu894pq0a4Tva8fjKZpfPbGC6WeU6/T0SQxGn0Vq15dDDTArCpsTsrlh+UH+HvzMTLKsYZD0zRefvll+vTpU+GQAbBkzjRefejW89YFOiomgVoNmqJpGtvWLQegR/+bCQwK4dTxw2xbv7zU47ceTCl1ypxT1dhzJo+Daa6QoWoaVodKrtVBusnO6RwrJ7IsHE4306ize/fs/WcymLvjQAln9u7P7d739zMa+fDZh0v8flIUhQ+ffRg/Y8lV1NJy8hj+2U/YizTas9kdTJi9hCYPv84Nb33NnI07Sc7IwmyzY7bZSc7IYvb6HW4hQwFGdzw7cjV333HafP6HR8gAuO7+p1Ciq5OnUmpIq6pqUSEVDhkgIxpCXM4kaAjhRUlN8zLN9nP6i7qAa32H+xsFGnXEBJ27MrA1atdlyuyldO7RB3B1P37t/57hhbH3kZdT9XUTo556EaOfHxv+XcaapX+Vum+Qv4GGNc79NI/zRQNMqsLGEzmFgSMzt+SypOPGjWP8+PElvl49MpyODWrRslY1/Azeb+xOJx/lnaeHkXq69HUGvtKmoPrU2qUABAaF0HPALQAs/P2bMo9fvu0EWXln/06cqkaezcnxTAt/H0hj1+lckvLDxKE0M8czLZzKsZFuspNjdWKxqzhVje4Db0NvcP8+eeiXv8gqpQxscYdTvVeZGtCjC3HRpX9dxkVHMqBHl1L3WbhlDze/N4X0nDwy88wMeP0Lnvl+NofPnK3E1aJuItd0as3VHVvRrE5Nj3PUCg/Gqap8v+UAV349lxt++pvkHM/F9c279KHj1TcBrtCboSrYztHPsIpWmyogQUOIy5es0RAin8Whkpk/HSrD7PDaz+J8sDlUMot1eDboFRJC/c95acrg0DDenjyNL999lZ++/BiAZQtmc3D3Dl6fNJV6jSvfYbl6Ym1uHjaKn7/8hM/efIGO3a8qvMHwJjosgJqxIZxIya30e15sCgNHUg67krNpXiOMdg3iiQg529zsl19+4c033/Q4Ni48hIev68nQHh2oGR1RuN1md7B01wE+nbeCeZt2uR2TkXaGz159lHEf/oTBcG57lbTu3JPZP05k58ZV2G1WjH7+9L1hKItnfc/+nZs4uGcr9Zu0djtG08AJODUw2VR+X3uU9o0TsKkaNodKtsWRX9q5/N+LYdGxtO97A+sW/F647URmDndN+ZPpD9yIv7HsX3vZFu+hpH2zxuW6hvbNGjPr7xWl7jN34y6aP/oWgX5GjqW6yvIGBfhzZ98rGXXD1bRtVNdt/417D/HFH4v5+a9/MVttHM3Ko8Vns8q8lowzyVhNuQQEu0KAqkG2U8FP0QjWgS8HDiVoCCGKkxEN8Z9VUtO8tBKa5p0PmqZxJs/mNmqiKFAt1B99BeaYV4Ver+fBZ1/m/96fVPhk+MTRQzwwuC8LZ1Vt/vTdYx4nPDKKowf2MecX7w3diqoVH+Z2E3650DRX4NhwIocfl+/nny2uEY7Tp08zduxYj/2HdG7F9g+e5dnBfd1CBoCf0cA1rZsw+7mR/PbkfYQHua8DOX5oD/N++fpcfjoA1KrflMjoOGxWM7u3utZIRETH0bnXdQDM//1bTCrkqpDlhHSnQppTIdOpkKMqmFSF1Dw7mw6lYrGrnM61cSbXVu6QoQG5ZjvHzmRz5R0PExQe5fb6gl2HuPbTXzlajp4Y/iWMEp1KK1/vj5L2i6rhHh5SsnMLQ0bjWtXZ+u27THrqAY+QAdC+cT2+fHoUW755h4Y1E8q8hmZXXEtQWATJh3bzzfgHsVncRztsmkKGU8Hko+lUkaH+hAR6VhcrDylvK8TlS4KG+E+xV6Fp3vmQnT8FpKi4EL8qN8+rjH433son0+YQFhULgNVi4bXHRzPhhSexWcs/DaWo0LBw7nvkGQAmf/hmmVOyFKBxYiT+fhWf930p0DTIdZ4NHGMef560NPduznf37MC0x+8tV0nUwZ1bsejFMYQEuIezeb9+TU6WbxrkeaNpoKLQIn/61IY1ywrDROcb7wNg6+q/OXbiGBZVwa4plNRK5lSmme0nMsmpQLdzk9XBiZQcTmfk4XCoBIdHMWD0Cx77rThwgtavT+HlOStJyvTeHyM118TBlEyvr81ZuqrMm2Gn08mcpau8vpadepqERq09mnvUSYjln49epG61ssvw1q+RwD8fv0St+Bivr4dEJdD/0Q/oes84rn3kA/yDQjm6ZwtTX38Yu83z+9akKmT6YDpVrbiKdQMvSkY0hLh8SdAQl7XiTfPWVrJp3vngUDXS8twXgEcEGgj1v3AzHFu268j47+dRu0mrwm2zfpzC/267jlNJlVtofMMdw6hVryGZaan8MOmjMvc36HU0rRWFchn/tNI0SM8zM6/YiFHDarF8NvKWUis2Fde+fiLv3DPIbZvDbmPloplVvkanBjYNzF5GJjKcCg06uoLGjrVLsamuaTrxtRrQpEMPNE1jxazvSn0Pe/65T2WasNjKvum02p0kp+VxMi0Xm909ADTpejW973nM45hcq53X5q+i7v9Nou3r33Df1Lk89tvfjPh+Pp3e+o6az01kyb5jXt/vaPIpvv9zUanX9P2fiziafMrraw6riVP7trr+MouEja+fHU18VEQZn+1Z1aIj+fLpUW7bohIb0m3o09z08g9Ub9IBgMgaDbjmf+9i9A/kwNY1/PDWYzgdnn15nPnTqXKclBgAy1LZaVMgQUOIy9ll/Ktb/Fc5VI3UPBv7UvJYdzybrck5HMu0kHMRdFEuTWqeze2XfJCfnuhzuPi7vGITqvP8l9PpfM3ZZl+7t23i/oG9WLus9EXd3hiMRh589mUAfp3yOaeTTpR5THCAkQbVL5/F4d7sXrcUi8l9Pcobd11PkH/Fp6OM7NuV5onu02tW//1nmceVJ0xkOxXyVMXryET9Vp3wCwwiO/0MSQfPrhfpMcQ1qrHx71nkZqYVf1s0wKKBVTu74VSGqcSHAXanyulMEydScjBbPW+cC1wx5H6uuf8ZFC9BTdU0tien8P3anXyydCPfrtnOpuOncailV5J79M2PmLtstdfX5i5bzaNveg/PobHVuPbx96nXqS86g1/hfKXmdWvSs03F1z71ad+CxrWqA6DTG7j24Qk07jYQg5/7aFZcveZcPfZt9EY/9m5YzndvPYXF6r1ktTV/OpW5gtOpAv31xIYHVvhzKFAwdUqChhCXHwka4rKQZ3NyIsvC9pM5rD2ayZ4zeZzJtVW5M/f5kmdzkms9+0TWqFeID/E754u/y8OgU/ALCGTUq59y04PPFG7PzszgqeG3MfmDNys8t/rKPtfStks3bFYLX7z3armOiYsIpFp05TsqX+wO7d7i9nFCRCgDOzSv1LkURWFE365u25KPHcRsyvUIE3kqZDsho5xhojQGox8N21wBwO51Swq3123egZoNW+Cw21g192e3Y1TApIGj2Hs4nSqnM/LcGmA6NY3ULDPHzmSTayq9v4urDC60u/5uhjxbcpPIisrJMzFo7DP0uHssn/00nb9Wb2DizzPocfdYBo19hpw8z8pPAC2vvpVa7XrRZ8wbdLjp7GjE6BuuqdT3uaIojLqhLwCq08GRzctK3Ldao7b0Hf0GOr2Bfev+4sf3x5GcmoPF7nljrwF5qkKm6hphKo9acWFV+llVMKIhazSEuPxI0BCXJKeqkWaycyDVxPrjWWxOyuZIupksH3fmPh9UTSOlyJQpRYGE87j4uyyG/OtQFIXr73uIh96djH9+IzhN0/j2k3d5avitZKZ7PqkuiaIojH3+VRRFYfEfv7F766ZyHVc3IZzQ4MotOL2YWewOju1zrxjVtXFdDPrKr03p3rS+x7ZdB/Z6hAmzqmDTFJw++sZp1sk1fWpXfplbcP179xwyHIA1834uXJhs1yh1MbLZ6iA924KmaWTkWjh6OttVArfY/gWhwqG5zmnTwArYAAdwYq+ry3dEQi1iazcs1+cREV/DY3SgqH83b+fhNz6i38jHeej1D/l3cyld24NCadBjEFr+jbQlJ7PwtT4dSm5eWZa+Hc5OaczLSCl135rNO3PViPEoOj37V89n8XfvcuxMNslpuZi8jAo5NYUsp0KuWvZ0qsp0Ay9Kpk4JcfmS8rbikmG2O8kw20k3Oci2XLjys76WbrLjKHKXF3+BFn+XxKDX4SpC6tKuZz/GTf6Dj58YTmp+Q7j1K5Zw/8BevPLZNzRv06Fc523cojX9Bt/GghnT+OyNF/hk2pwyn4oqCjSpGcnWQynY7OdmtMpmNbP930Uc2LqG7LQzWE256I1+BIWGU61uE9r2vI7Ymp5VgSrLYneQnJaLOTfTbXvDarFVOm+j6p7H52Rleu7oY407dEfR6Th5eA+ZKSeJiHV1o27epQ/RCYmknTrO+r9m0f66Oz1GMYrTgJNpuaRkmzDmT3/SNNd2DddoSMF/S2K3mtm68DcA+t7/FHU79CZp7xaSdm/i9MFdZJ0+gdNuQ280YspKJ+tMMm2vvYU+D45n5/L5zJ/wRBX/RqDHyP8jIDwKLf+G3m7OK3wtPLjy3duLHms3l10Guk7bHvS49zmWffs6u5fNwOAfQMfBo8mz2gnwMxAZ4k9wgBGFs9+HFlXBqkCwohHg5ceSXqdQIyak0p8DSNAQ4nImQUN4ZTabWbhwIUlJSZjNZiIiImjTpg3t27c/b9N5CsrPZphcfS3M9stvWN3qUMksUl0nMshIyAVc/O2NwcvISmKDprzw7RwmPvsAeze7SpmeOZnE/267jofGvc7gu+8v19fJyCfGsWTeH2xdv5rlC+fQ89qBZR7jZ9TTODGKHUdS0XyYNVKTj7Fm/i9s/Hsm5lzv1bB2r1vKP79MokHrLnTpfxtNO1+FXl/5f6+CkOFUNZ+3bPb6t38ewnlIeBS1m7ThyK5N7F6/jK4DbgdAp9fT7cZ7+WPSa6yY9R0t+92KrpS/O4vdSZ7FjkPVUGwKYcH+6BSl1FDhza5lc7DkZhEeX5OmXftgtqtUb9ya6o1dPT38jHp0ej2apvHDc8PIOpNMXOP2WJ0qDa7sxxUpJ1k19b3K/nVwxT1PUr9rPzSniqLXozmdGPzPrmcwlbBeojzyLGe7zBc9Z2kadO6Hw2bl3x/fZfuinzAGBNF2wL1YbA5OpjvwN+qJCA4gJMiILv+rSNMgV1OwaBohOjAU+eKqHh2c/zCi8mSNhhCXr4vrjkZccAcPHmTSpElMmTKF9HTPcpjt27dnzJgx3H777QQFVf5JXEmsDjU/WFzYpnnng6ZpnMm1FU4DCfLTExV48X1LegsaAGGR0Tz56c/8+N6LLJ35AwAOu50PXn6a7RvX8tQbHxAUXPqTzrhqNbh9xBi++3QCk94ezxW9+2H0K3tqVFiQH3UTwjmUXHZPhLKoTieLfvyE5TO+QVXLF2YPbF3Dga1rqFa3CXc+9W6lRjjcQgbgHxIBHD37HidLnwpTln1ejk+ICCdSr50dCdDcRwW0/I9VFNeoQf7XZl52BjtW/cWJAztIPX4Qh82C0T+IuDqNSGzYkuZdehc2hANo2qmXK2isXVIYNABa9b6BxT99RuaZJHavXkzzbv0LXysYqbA5VUw2Bw4V0OkKq42ZrA4C/Y3FK8OWStM0Nv7p6tfScdBQHJrnwZqmYXGoOFSNrJSTAARFucrMOh0qra67B7/gcFZ8/SpOe/lDgd7oR68HXqBB90FoBV9XOgWc4BccUbjfpr2HylXW1ptNew8X/jkgNKLkHYtp0n0QDquZtb9/yqbZX2P0C6BF39sAVyWv05l5pOfoiAjxJyzID13+P4JDU8h0QqBOI0hxjTBWpqytpmmsXr2amTNnsmHDBjZu3AjAzp07iY6OpnXr1nTo0IEhQ4bQuXPni2KtmhCici6e+Rnigvv8889p3Lgx7733XmHIiI+Ook6NBELzh+g3btzI/fffT6tWrdi3b1+V37N407z1F0HTvPMly+LA6nA9n/W7iBZ/F1dS0ADX4t97nn2ToU+95lbZ568/pzNqyNUcPVj218idDzxMVEwcJ44eYuYPk8t9XdWigomLrHylGwC7zcqPbz/O0t+/LnfIKOrk4T18/sxQju7eXKHjzDYHSUVCBkB0YgO3fVbvO4KzCsUMVu4+5LGtVv0m6BUwKuCnQIAOgnQQrINQHYTpIUIPUXqNaL2GLuMUf3z4HG8O683sSa9i2ruGK2L09K8XScdIjfRtS/n94//jzft688ek18jLzgRcQQPg4PZ1WE15hVWlNL9AOgy4w/X5zfwGh6oVrqkwaxpZVgfZVodrSlWxLzuHqmGp4KjmkS2rSD9xCL/AYDpceyt2x9nj1fz1HGYn2FUNh0MlN9VVljYkJgGnQ8U10KTRuOcgbnl3Os2uvhVjQOkPWIwBQbTqdxt3vT/TFTKcKk6Hht2hYrM7sagaAbG1Cvef9MfiCn1ORRU9tnarbhU6tkXf22g3aAQAa3//lD0rZru9bneqpGSZOXI6h/RcC84iw4dmVSFDVbCqkFiBsraapvHTTz/Rpk0brrzySt577z2WLl1KTs7Znibp6eksWbKEd999l65du9K+fXt+/fXXCnWHF0JcPC6+x6fignjnnXd45hlXRaHIsFCGDe7PqFtvoGHtRMBVDWT+irV8/stMFq5cx8GDB7niiitYuXIlTZo0qdB72Z0qGWYH6SY7mWbX1Ij/GrtTJc3kmq+tu8gWfxdXWtAA10LfPrcMo1rtBkx8fhR52VkoOh1H9u9l5I19efatj+h93eASjw8KCeX+x5/j3ecf49tP3uXaIbcTFlG+Urb1q0WQZ3GQZy65xGlJVKeTaROeYeeavyt8bFGmnCymvDya0W9NpVrdxmXub7Y5SE7PRS32dR9bpxkwvfDjkxnZzNu0i4EdK75YWNM0Jv+9xm1bQmJdgoLLf1O4Zskcfpr4OiFGHa/f0Z9hV3Xy2jQwOT2Lr/9ezUdzZ7N71SKGPvIqLTp2J656bc4kH+XIln+p1/VqnJprlKRN/ztYNWMKpw7u4tD2dSS27IzV7sTucJZZyMHucKJXXNOdyqNgNKNV3yEYA4Jx2OyommvFUcFts6KCEyeW3EwcNtdUpIDw2MKQUSA8oRbd7x9H5zseYf/KeZzYvgpzRgo2cx7GwGCCo+Ko3foKGnUbgCEgGJtTxeFUcXhUdlLIPnWk8KMlm3ay+0gSTevUKNfnVGD7wWOs3LYHgNhGHQiOrtjxAG3634PDambbwh/596f3MPj506BzP7d9nKpKWraZjBwL4cH+RAT7Y9DrXKNhAX4czrRSP1pHYBn/JklJSTzwwAPMmzevQte4efNmbrvtNn788UcmTZpEtWrVKvx5CiEuHEWTxwT/eTNnzmTIkCEAXNm2JTM/eYPoiPAS91/47zpufewFck1m6tSpw5YtWwgPL3l/TdPItbkWcmeYHBd9P4vzITnbWtiNvFqYP8EXeefrQ2mmcpU4PX38MB8/OZzkw/tRFKXwRu2WYaN48NnxJU6LcjqdDL+uB4f27ebW4Q/y0P+9Xu5rs9qdbDmYgsNRsaf/i378lH9+mVShY0oTFh3PY5/MJDCk5KkkZpud5PQ8j5ABYLOYmPbsYOyWs+VRm9SIY8M7TxLgV7F+Kt/8s5aRn09z2zb43oe57raR5Tp+0Yzv+PXr97ije3s+Hj6EyJCyp0mezMhi5Oe/smjrHoY+9hrHD+1lyczvaHXVIAY98obbvvO/eI2N86dRu/UV9Hv8I9fXiQKFwxiKUuRD5ezoRv72IH8D+jLWBaQdP8g3D98AisLDUxZjCK+GE60wYGgqqKqKolNAp5B6eA+/PHEzAWFRDPtqaelP0POneRmNuvyKVxpakX9Tp6q6ygg7nG7n0TRwOFUWv/UAKQe2Fm7v0aYp8999Hv9y/jtbrDb6PfE6/27fC0Cne8bTqENP/Cvxc0TTNFZP+5Ddy2ag6PT0HjmeOm17lri/TlEIDfIjIsSf+tUiqBUXik5RqBnuT82IAHReRmU3b95Mv379SEkpeTpggNH13NNbyd0C8fHxLFq0iFatWpW4jxDi4iJTp/7jNE3jhRdeAKB14wbMnfRuqSEDoN+VnZj+0evo9XqOHDnClClTPPbx2jQv4+Jvmnc+5FodhSEjKsh40YcMKHtUo0B8Yl3GTf6DVlf2drvB+u3bL3j4zoGcOZnk9Ti9Xs+Y518BYMb3X3PiiOe0n5L4G/U0rhlZwupn77JST7H096/L3K9do7oMvaY7A7q2JSy49Gla2WmnWTq95KlfZpud5DTvIQPALyCIhl2uddu2J+kMD0+eXqFpI1uPJPH4t+5dwA0GI92uKXlUqaiN//7Fr1+/x9M39mHqQ3eVK2QAVIsM549n7ufunh344YP/IyDG1Uxu/4blqM6z3/eqptHq2jtRFB1Ht64i7dh+1wsFi0I0DVQVTVXRnCqa04nmyP+f3YFqd2A2WTFoGn6AMf9/BkCf/z8dsGmOa91Q/U69MUbXwF4kZDidGg5Vzf/Y9YWTm5Y/bSo6Hq3Y2Iqmaaiqhqrmj1JoKpriKrOtqu4hQ1W1/E9B9fh3c6oq1twsUg+6l8JdvmU3t730ISaLtcy/51yThVte/KAwZIRVq0d8k05u08IqQlEUut72CA279kdTnSz5+mWO71hT4v6qppGVZ+XY6WzScyzkWVzTXI9lWtiUlE2GyX10cceOHfTp08cjZPgZ9NzVsRmzRg8h6c2x5H74OLkfPs6JN8Ywc/QQbu/QFGOxMHn69Gl69+7N7t27K/W5CiHOPwka/3ErV65k586dALzz5JjCtRhl6du1Azdf0wtwre1QVRXTJd4073xwqhopea5fxMH+eiIvwsXf3lSkqkxQSBiPvPcN/YeOLtym1xvYsWk99w+6ig3/em8s1rlHHzr16I3DbmfSO+MrdH0RIf7Uji//otS1C393u/ktblj/XuyYOoF1X73Jt+PGMvutZzgxYxJfPv0A8VElB/H1i6Zjt3neLBaGjDICQ+v+d+MX5D69aco/a7n7ox/IzDOX8VnB3I07uXr8RHLM7tfQa8gwgiNiyjw+JyudHz8dzw2dWvH6nddVeM2QXq/jy1G30alhbdb9+T0BIWGYczI5sWcrGq5pY+k5FgzhCdTp4Oq3sW3BDxV6D3B9H+WYrKCAPv9/hvy1J0YFbNmZ7Fzq6oTe8YZ7UJ0aOkBTNex2Z/6Ig5YfBFzDE9lnCoJGAqqzSKhwqq5AoWmoGuh0OnQ6HYpCkXO4aJpW+G+sFvu553S6RjmSt69C01QKVrkbg1xft3NWbaTzA8/z9Z9/k2e2UFyuycJXs/+i86jnmb/GtSbIPzSKTve+gqLTY6vCz1lFp6Pb3c9Qt0NvVKeDv78Yx8m9pa870ut15JntbDmQwq6jaWTn2bDYVXaezmX3mVwsDhWTycTgwYPJyMhwO/baZvXY9/IDfDfseq5v2YD4sLNT8hLCQxjYsgE/3DeQvS8/QN8mddyOTUtLY8iQIVgsnn9HQoiLjwSN/7jPP/8cgEZ1EunduV2Fjn3w9hsB2L9/P59P+5NNl3DTvPMlzWTHqWr4GXQX7eJvb8o7olFAp9dz68P/x4iXPsRg9MPpdGD08yczLZUn7r2JqZ9NQFU9b4zGPvcKOp2OZQv+ZNv6kp+qelMzJoTo8IAy93PY7axf9HuJr3/7/Bi+fnY0TWq7z3kPCvBn+HW92TzlHZrUqu71WFNOJtv/Xei2rbwhAyAoPIautz3isX3av5to9djbvP/nElKy3PslOJ0qy3Ye4OZ3p3DDW1+TnuvemTqhdkN63fYgmU6FbKdnB+6i5v06GcVhY+LImyv9tanX65gy5nayU08REef6O9y99h8ycixkm2yFC+Bb978bgANrFpKbdrrC72NzqB5rc5wqWFVYt+g3HDYLsXWbUqdVZ5yait3uxO5w3ewXNOLQVA3VqWF3OMnJrzgVGBmHzWbHZnPgtDtxOlz/U50qKKCh5R9XrJOdRuHn5iw2uqCqWuGuSdtW5u+vYvAPpNv/PiAwwlV1avfRJEa/9xW1bh7DyLcn8dLkX3lx8i+MeGsStW5+kAcnfM3eY8kABEXGc8XIdwjKP9bp1KpUvVin09Prvheo1epKnHYbiyY+w5lDO0vcPzjg7DSvjBwr2w+nsu1wKuk5FtLy7Gw6kc0jTz7DgQMH3I4bf303/hxzEzUjy14vVCsqjPn/u4Vx/d273O/Zs4eXXnqpgp+hEOJCkKDxH7dmjetm7s7rrkanq9iXQ7d2rahdPQGALRvX+fzaLjdmu5NsiwOdAtVC/bzOZb5YVXah+pXX3cyzk34jPDoOu82Kwc8fVVX5asLrPDvyTrIz3Z901mvcjOtuHQrAp2/8n9cwUpqGNSIIDCh9Ktru9UvJyUj1+trtfa5gaL8epR4fFxnON8+PLfH1tQt+K/yzqQIho0D1Jh3xD/K8CUvOyOLpqbOpNuIFGo59lV4vfkKXZz8g8t7n6PPyZ8xa59mZOjQyhruf/wiD0bU2xqYpHoFDza/6lGkys2rxTEb06Ux8RNU6PTeqHsfNXVtjSj8DwL51Sz1GNmPrNaNa43ZoTic7Fk/zdpoymax2zDYnDhXMKpgBi8PO1vk/A9Dhhnsw2xxY8/dRNfeRCodTxeZ0ommQkz91Kjg6vrBhncbZEQudXucKJ04Nh82B5iiY3uVEczqx2ew47A7sVjs2iw1HflBx2BzYbA5UpxOHzcbJItOSYuq1JKZOE3o+/jk12l5VWLktK9fEN/OW8vrUGbwxdSbfzl9Kdv6IlqLTU6N1L7qN+YjQuLPVqwDszqr1GtLpDVw1cjzVm7THYTWz8NMnSTu+3+u+wf6e60ly8mzsPprO5gNn2LJtJ5Mnfeb2+qO9OzCu/xUVCrGKojD++u6M7en+IGzChAkcOXKk3OcRQlwYEjT+4wqGtKvFlj2tojhFUageGw2cn47DlzJV00jJtUF+hanic48vdsYqVMSq37I9L347h9pNWuKwWVEUHXqDgdVLFjFi0FXs3b7Fbf/7H3uOwOAQdm/dxD9z3NcaqKrK0YP7WDLvD+b++gNzfvmef+bO5OCeXTgcDvQ6HU0So9HrS77eQ9tKDsVP3jGoXJ9Tx6b16dmmmdfXju3dit1qwWSzc7KCIcOal83Cjx/HasoptYzq4TPprNx9iA0Hj5XY8C0yrgYPvPEt0dXO3oyqgAPIVRVOOhSS7AqpDoVsp8LO7RvJy83hvt6dy329pbnvqs5kZ6ah6PRknTpK5smjHvu0GuAa1dizdBY2U9mdrT3oFHIdKmbO9q7fv3oxeelnCAyPplbHq8k12/OnP6luIwua5v7nvII1GlEJbut99Ho9eoO+cD+Hw4GG5tbPw+FUXf/OGtit9sIRD4fDgdlix2a1Y7XYSd65Abs5F53BdZMeUac5DocDVRdM0xufovm9n1C9880oBs+iCf6h0TTuew9XP/sD7e94noDQKI99HGW1Wi8Hg9Gfvg++SXz9lthMuSz4+HEyTx5x20enKAT6lxzoTRYHP0/5ym1aWbOEaF4fVHqIL81bN/akUdzZanROp5Mvvvii0ucTQpwfl8YEcXHO+OVXAbI7Kl4eFMBqdx1n9PP32TVdjjLNDmxOjehgI0GXwOLv4io6daq4qPjqPPflDKa8+gTrFs/G6VAJDA7l5IljPHjLtTz60lsMvP1eFEUhOjaeu0Y9zNfvv8EX775C56v6svrvRcz7/Sd2bd2IOc/7Dal/QCBNWrbhmsG30v6qgRxJ8T6HOzvDe+WbhjUTaNOwTrk/p1uu6sKyLbs8tmuqysblC7Hpg13z8HWKq+GZToeiKCg6vft/FR2KTofDamb5d2+SkXyIgNAIeo98lbzMM6yfPhFTVlq5rwugcbeBXDvsCSLjYrAVKedaPPM4ATuuXwTH9+8kPCSYxtUr1zyuuE4NaqEoCuEJtchMPsyxLSuIqFbbbZ/EVlcQWaMeGUmH2L10Bq0H3ONxHlNWGubMNBx2C6Bg8PMnODqBwMhoFJ2r6pPZ6sSgV1BVlY2zvwOg2dW3ouoMeCuXVjRkkF/GNi9/9CU4Ot71xF0DnUFX+PRdUzWcRUYMCoKGqmqFU6aKl7J1TdU6+/4nd65yHaszAHai67YEDYz+Bk6fSMOuBRLadABp+9djTT9KbMfbCa7eDJ1fMIagcGIiQrBYddjSslF0imutSJH/KqpKkFHnujhFqVCBhKKM/oFc8793mP/Bo6Qe28v8Dx/juic/JSzWNRUuyN9Q2MTPG6fDzsa/3R8SvDKwO/7Gyt9yBPoZefn6btw55c/CbZMnT+a1114r7CwuhLj4SND4j0tISODMmTNs2LG3wsfm5JnYd+Q4AFExsb6+tIteRmoKc379gSXzZpF6+hRmUx5BwSFEx8XT+7rBXHfrUCKjY7A5VDLMdkL89UQGVqxM6cWiqkEDXEFg9GufUbN+E2ZMegdzXg4hEVHkZqbz7rjH2b5pPU+88i4BgUHcdv8YZv04hVNJxxnSpTkWs6nM81stZrauX83W9asJCX2JXjfeSaeBw/ErNjJgLeHJeeNaFetDUNr+sz4ZV6FzFWfJyWTe+w9V+vj9axZycN3i/BtQff7NaJGAUyz06PR6cjPSaF0jxmfrhkIC/akZG40zIpbM5MMc3bycVv2Huu2jKAqtrh3KssmvsGPRNFpcfTvpJw5wfNsqUg7vJvXIHkyZ3oNhSEw1Yuo2JaZuM2q170VUYn3O7N9KysGd6I1+NOt7i9cKX24jGaqKqikoOgVTumudSHB0gmsaaZF7V9WpekzjU1DQNAqnhKlO1W0BuMOpur2/pmmc2uEKGk6bGUWnJ6pOUwD8/Iw484sTaJqGLTt/GleNlvhHnO0bYbU7CFAMHgvNC5gVhQhDsXyRHzoUxVXGt/DPXrYXPdAvMIR+D09g3vsPk5F8iPkfPMp1T35KSFS82/oMb04fO4g5N7vw4+rhIVzfskEpR5TPja0bERcaxJkc18+DlJQU9u7dS7Nm3kcXhRAXngSN/7hbb72Vbdu28cuCv3nvqbFEhpd/bvYPfy4i12RGp9Mx8u7bCI0IINPsINd6eS8GP7hnFz9O+pAl8//AYXcfCbKYTaSnnmH/ru1M+egtevW/gWuGPkiN+k2IC/HeQ+JS4KtmgoqiMHD4w1Sv25CvXn6E3Mx0gsMjMeVksWD6z+zfuY1XP/sWU15u4Zqh8oSM4nJzspnz/STW/j2PIQ+9St3m7QtfM/p7XzB+JjOrQu+RUsr+4fG1UPR6V5lWTUVTtfz/qu7/1Vw3p3ZLHlp+Z3KdwYiC4upUrrmOqyjVYaMyNYgCjL4ZzSjgbzCgj3Gt4zq9fxuW3EwCQiLc9qnftR/rfp+IKTOVX5+7hdzUk+U6d27qSXJTT3Jk/T9s+PVT4hu3Q80fma1/RX8Cw6PcOq9D8ZDhWgTubzRgyc7AabeBohAcHYdOr3MFC801RcdreWEF7Pb8v2XNfTRDVTUcxcJA7pnj5KUmoej0aKqT8BoNMPi7QrDD4SQkLARTrhWHKQPNYQVFj1+Y+wMcm0MloJQfI6qmYbM78S/aPC+/ZLAGhfPLSv35XBA4FAU/nT/XjHqLeZ88Rk5qkmtk49GPCE2oj07xOlgEQNIB90XkPRsmVqhyXUn8DHq61a/JjC37Crdt3LhRgoYQFzEJGv9x999/Py+//DJmi5Wvp//JU8PvLNdxdruDz6e5hsYHDRpEi4b1AKgd6XrCl2VxkGl2kGmxY7FXvuzixWb5wjmMf/QBbNaz03KCA/1pWa8WoUGB5JjMbD90jDyzFbvNxuI/fmPZgj954cMvSex3/QW88qrR65RSbywqqv1V/YmrWZuPnhxO2skT+AUEYjAYObhnJ8MGdMdht7tutIsJNuhpGxtGu9hwqgX5o6Bwxmxlc2o2G1OyyLa5T11JST7Gl88PY8Dwp+h+g2taTlBohNdr2rT3MGcysoiLLL2PTIEFa7eU+NrApyfhX44u3A67lcUTnyN593qMAcH0f/QDYvOfchfS6Vw3iwUVj9CKBBYNTXO6/qs6WTPtIw6uWUhiqyu54u4n0VQVP72OEH9dfi8IZ5HQ43TbtnrGZNLOeF/4WxmappGem0edqHiiEhuSfnw/x7euouGVA9z22f/vPOxm1yhTeUOGN6f3bir8c3Sthh7hQNXOVmXSNA27w5F/P62Ql+4aQQgMjy5cOE9Bwz0vt+UK4HCoha857I7Cu3cNzWtJ71P506YCwqIxZ54hut7ZpnM2qx2DUU9IWBCnk1036X5hcflTrM6y5TcALG3UyWx1uAeNispfa0L+ZxcYGEa/kW8y//MnyT5znEWfPknnD6YSEhpeuLtK/tQ8XD8jsk4dcztlq5q+C7Cta8a5BY3iVa2EEBcXCRr/cQkJCdx8881MmzaNFz7+mnbNGtOnS/tSj1FVlQdfeY+dBw4DMHasewUeo15HTLAfMcGuX9gWu5PM/OCRZbFjd16a4x1L5s3ipYfuL7yBaVanJqNvvJqh13QnrEj/kaxcEz8sWs6kWYvZfTQJm9XCS2OH8cqn39Dz2oEX6vKrzKDXYatg9+3SJDZsxovfzuWzZx5g35a12DATEh5JblaGx76tokP5X8s63NagOkEl3ERZnU5mHjrNZ9uPsOZ0ZuF2TdOYO/kdnHYbvW4eQc0Gzdn49yyP4x1OJ1/9+Tfj7hlS5rWnZGbz6z+rvb4WGlO9XCHD6bDzz5cvkrx7PQb/QPr97x1i6zXPn9KUP8++giNJra+7h4NrFnJixxp0OgMhsfEABAf6Eehf+o/7lKP7WPz1Siw2e4U7kXuTlJ5FenYO7Ws1QlNV0o/v5+jm5dTr2h9V1chOPcnqqW9xctfaKr9Xcau/f4/TB7bT9d5nCAiNdDXRK3hR0wqDQcH9ekF53ZDo+Px9Sg4Z+S/jzP85oDk1t6lMxddlFDi1c3X+27v2ja7XsvBcNptrJCY0PJgT+dOm/MKreZxDUzUcTg2joeSvC1dnbd+umQuJjKPfA28x//MnSEs+xIcvjOaJN74iMCgERTnbKBHIT2HufVzCA3x3PeGB7ueyWstuciiEuHAurdI34pyYMGECiYmJ2B0Orn/waSb+PAOTl4ZRAAePJXHr4y/yzcx5ADzwwAP06dOn1PMHGPUkhPrTJC6YTonhtKkeSp2oQCICDZdMidfdWzfx2uMPFt5AvHjfzWz99l3GDO7nFjIAwkOCGDvkWrZ99x7/d+9NgCucvfLYKI8KS5cSX6zTKC4sMpqnPvuZnje6RtKKh4wAvY53r2jKupu7cV/TxBJDBoC/Xs/tDauzfHBXvuzVkjA/9xvrBVM/ZNOS2bTs1g+9wfuN9Fs/zGLf8eRSr1nTNB7+cAoWm/cCCg27Xut1e1Gq08HSyeM5vn0VeqM//R6ZQLUWHdH5GVGMBtDrKhwyAKITG1KtSXs01cnuJdMLt+dY7NjLKBVco3EbHE4n/+zwzajGwi17UBSFyFpNqdbiCgCOb19Nbq6Jg+uX8OfLQ0sNGXE6PT38AxgZHMYb4dG8HxHD+xExvBYexX3BoVzhF0BkKSW5D61eyPSnbyZ55wa3uOBwON0WxSt6BVPG2fUZWn4J3JIWUmvq2X4ZaGAvMn2y+LqMAjZTDmmHXOWHLVmu0srR9VoAYLfZC0dDFJ0CZteaFL8Iz6ABrlGN0lhsVStxW5KwmOpcM/JNgkMjOLJvBx+/NBarxfu0xsJRoXy5JVRGq4xcq/v3XUFBEyHExUmChqB69eosXLiQGjVqYLPbeej1D0nsM4Qn3vmU6YuXMm/5ar77Yz4DRj9F4+vuZOZfywFo1KgRn332WYVroof4G6gZHkCLhFA61wqnRUIINcMDCLmIqzF99f7r2PI7Pr8y4jZeHFZ2QzNFUXh5+C28eN/NANisFr5+/41zfq3nyrkIGuC6Kbl57HMEFhsFqBbkz+qbruTR1nUrtEZEURTua5rIxlu60TDcPQT+8cUbOO02WnXr5/VYs9XGVQ+P548V670+lU5OTeeWF97ntyXemwkqOj2NrvQyaqXoUPR6dEYjGPQs//5Njmxehs5g5JpH3qV6sw7l/vzK0vzqWwHYvXQmDpvrgYGmaeTk2UottRtftzHV6zXh84X/VvkaNE1j4sJVVG/eBX1wJGE1GhEYHo3Dambr7C9Y+eU47JY8j+MMwNUBgUyMjGVGTAJvRsQwLCSMngGBdPYPoLN/AFcFBDEiJJx3I2OYHVON9yNi6OYf4PWXmSU7nYXvjuX4ZtfPLIfdURgEFAUMfq7qSXn5IxrBUfFoha97/5pzamphBnE4zk6Z8rYuo8DpXWvQVCeBkfkjTDE1CAhzlQa3Fbtxtma5po95G9EAsNrsZB7fSfLWhRxbO51ja2dwcusispJ2o2ln+4OcCwm16vP4618QGBzK/p2b+OzVR7HbPUNEbLx7oYTtyd4X9FfGtqQzbh/XrVvXZ+cWQvieTJ0SADRt2pS1a9cyatQo5s2bR2Z2Lh9O/ZUPp/7qsW9wcDB5eXns27ePP//8k8GDB1f6ffU6hYhAIxGBRiCwcH1HhtlBltmOxYdTdSrr+OGDrF+xBIArWzbmuaE3Vuj4F+69iUXrtrJm537WLv+bpKOHqVH70vvleK6CBsC0D1/BnJdT+HFMgB+LB3WmcWRIpc9ZJyyIxYO60GPmKo7lum64raZcpn/6Mr1vG8XmpXO8Hnc6PYub/m8CTWpV57Y+V9KiXiJpWTksXr+NP1ZuwFFKU7SAkDBUpwNFr/c6/UlTVVZ8+yYH1yxC0evpO/YtarboUunP0ZvabboTEl2N3LSTHFy7mMbdXcHH7lTJNdsJC/L+BFhRFDoMvJvZH41j0dY9XNO6SaWv4ftl69l6+Djdx7i6nCs6HdVbduPgyj/Y+5f35nw9/QN5LDSC2AqUKtUpSmEAOeFw8E5OBhtt7lNpVLuNJR8/xVWPfEB8044A6HU69EZ94dSpokGjgLeg4XTmdxZX8ruK5/980jQNWyk39wXTpgIjYjBnnC6cNqWqGg67+9eTKcVVyc+/2IiGw5JD1v6VZO1dgj3Xe8PJwMhqJLS8mqgrriUqyrPPRlVFhwZSu1ozHhk/kQ/+7wF2bV7NF28+yejnJ2AoMkpYu0Fzt+NWHDiBqmroqvgzxKmq/HvwhNu29u1Ln+orhLiwZERDFKpRowZz5sxh//79PPXUU1SvXr3wl63RaKRTp05MmTKFM2fO8OSTTwIwfPhwjh71bMRVWQXrOxrGBNEhMZz2NcOoHx1EdLDxnN7oluaPn74p/PPYIf0qXP5TURTGDHY9Qdc0jT9+/taXl3fenKu//+TD+/l37m9u2z7v2aJKIaNAjZAAvu3Txm3bvk0rUZ0OGrXrVuqxe44lM/6b37jlhfcZ/d5XTF+2ttSQAWDOzmD6+KFs/2saKqp7yNA0/v3+Hfat+BNFp6fP6Nep3bZ7pT+3kuj0Bpr1cY2i7Vz8i9vIjNnmcJtak3HqODuWz+Pvbyfw5yf/x5Ht6wiJjOGO979j9d4j3qstleHAyRQe+WYWNdv2IbJWK0w5Jhx2B8Ex1b3uH67oGB8exevhURUKGcXVNBj4MCKGJ0MjCCz2Pao67Cz95Ekykw5iMOjRF5uCl1vYFTzh7MZiX+5Fm/0pgKNI4QG7U/VsUlJwnNPB6d2uKWLO/BBUsBDcVmz6nd2ciy0vE4Comq5ysJqmkrp5Fod+fYLUjb+VGDIAzBknObx8KnPeG8aOpb9V6t+vNJGhrvURDZq14X8vfoLB6MeWNUuYMmEcapHvjRp1G+IfeHY08UhaFov3HKny+8/bcZCkzLPlqSMiIqTilBAXOQkawkP9+vV55513SEpKwm63k5eXh9VqZe3atdx3330EBQXx+uuv07lzZzIzM7n99tvd5in7UqBRT7Uwf5rGhdC5Vjitq4dSOzKQ8AAD52t5x8JZrlGd+KhwbuzeqVLnuKlnZ2LySwcvnOk5SnQpOFdBY8n0qW4f31K/GjfWSyhh74rrXj2KMS3cG8Wtmf8LtzzyGlHxNX32Pu0Hj6Ja0/Y4bVbW/vIxf7wynNQjewBXyFjz8wfsXjIDFIVeI1+ibsfePnvv4hr3GITez5+0Y/s4tW+L22uZOSa2/PMHU566g89G92fW+0+zetY3bP17Ftv++YPcjFSyTBa6/99HtH3yXb75Zy3WYo3oSrI36Qx9XvkcJTiKFgMfBFxP/m15eRxYPtNj/+p6PV9GxdE3IMgn/Tt0isLgoBA+i4wlolhDOafNwtpvXgXt7A2xprma8BV0BQ+OOlsdqej1uK3LIH+heP5NfEnrMgqkH96B3ZyLX3A42addD2UKRjSKT5sypeaPZoTFEB4bhU7ROLn8S9K2zkZTy/dvAK7yxhvmTWbV9I+8Vm+rDL1eISL47ELspm06M2bcB+j1BtYtm8/UT14p7DVitmk07XS12/Ev/bmiSlO67E4n4+e6T+u79957MRhkYoYQFzMJGqJUer2eoCDPmwA/Pz+mTZtGeHg4a9as4YUXXjjn16IoCqH+BhIjAmhZLZQutSJonhBCjfAAgs/R+g6r1UJmmusJYq82zfGrZGdbfz8jvdq6phOkp5z26L9xKTgXQcNqMfPv3N/dtj3fvuqNvYp7pl199EW+hneu+su1luPlSYRFx5dyZPl0GDKadjfcz3VPT6TH/S/gHxxG6tE9zHrlPtb8/BFrf/mYHYtcU4Z63DeOBuVYMF4VASHhNOzaH3CNahRIO7qPGS/fw5yPx5G8f3uZ59lx7CQjP59Gh6feY93+kkcunU6ViQtW0uGZ98kzhHLFg+/jHxyOX4AfQWFB7F40BVN+CdkC8To9n0TGUvMc3Cg2NvrxSVQsocV+bqUd2c2Oea5gqzpVnHYnmqqSl98t3m1EA1dTPjRwFOlloqlnG/M51bLXQ5zMb9IXWasJmsOOX3A4IXGJOJ1Oj8Z7BUEjKCYRgNR1U8k5vM7jnHq9jms6teZ/Q65l7OB+9G7fwmtQ279uAetmT/LJyEZkSIDHe7Tq1IORT7+FotOxctEMJn/0Ghv2nWLb4VRqt+/vtu+GY6d4a5H3tU3l8eq8VWw54b4+Y/To0ZU+nxDi/JCgISqtTp06TJ48GYC3336bBQsWnNf31+sUIgON1I0KpG2NMDrVCqdRbDDxoX74G3zzpZ2Xfba7bXhIUCl7li28SHWqvNycUva8OBn0vg8ah3dudlub0a1aJC2iy980sryqBwdwQ92zgcLpdJB6eCuxNerw4Ls/klC3cusRdHoD3e8bR9tBwwFXGG7cfSA3v/EL9Ttfg6Y62b7wR7Yv+BGAK+9+msY9BlX9EyqH5n1di8KPbFpGdspJdi6Zxczx95J+vOJVpXYnnebKcR/y9NQ/Cqttmaw2Vu09zBvTF1P3wfE8PHk6NTr15+pnJxNbqw7hceEEhQWReXwX+5a4h0kD8E5ENAn6c/c0up7ByGvh0R7bt8z4gvRjB3DkV28yZ6WhOR0oio6giBj3nRVXmChatspmPdvB21u/jOIK+mf4Bbv6TkTXa4miKB6jGQB5Ka71B8ExNTmxdjYpO5e5vR4c6M//3XsTh375lHnvPseHjwzjo0fvY9H7/8f+nz/iqTsH4V+sNPGeVX9yYMOiMq+zLFGhno0uVU2jXuse9LvnGQDWLv6NVbNdvxMiE+rQoMM1bvu/PGclX67YUuH3/mzpJt5Y4F5OetSoUTRpUvl1REKI80OChqiSm266iTFjxgBwzz33kJxcemnQc8lPryMuxI+GMcF0zF/fUS86iOggY6U7WwcEBhb+2WSpWr32PMvZksFFz3up0ClKZSqulurIHven6gNq+7YzdVH9a7t3WU46vAe7Xo8xKoH73vmZa+5/hshqtcp1Lr3Bj4ZXXseQV3+kSc8bPF4PCo+m94Ov0aibe5PG0we2Y8nJrPTnUB6qqmF3qATF1yG+cTs01cmyb15n1XdvFHYfrwxNg/f/XErIXU/jf9sThA19hh7/9zHjf11AckY2ja66ma7DniMoIgKDvwGjnxGjv5Htc77xONd9wWE0MJ77sqQd/AMYHBjstk11OgpHNQBMGa6n5EGRseiKBZ+CBnQF7DYHBanD7nAPIN7knDlO7pnjKDo9NpProUXh+gyr51SoghGNwKjqHF3pvm6pekwkqye9zsvDb6FGrOdC7zrV4nhz1J2s+OyVwmmaBbb+/TNaGeWNS6MoZ9dngKsp4JHT2WzYd5pdx9JJaNaTLoP/B8C2f6ax7R/X6F3HgQ8QFO4e3sZMW8R9U+eSYfJeQr2otFwzd3/zJ4/89pfb9riEGrz86qVbwU+I/xKZ3CiqbMKECfz7779s3bqVoUOHsnjxYvRVWNTpK4FGPYFGPdXD/FE1jTybkwyznSyzg2yro6S1m+7nCA7BPyAQq8XMlv1HyuzKWxJN09iy/4jrnEHB+AdcekEDfN+072ixoNEutnxduSuj+LkP7tzGoFHBHE/JBaORTgPvpuN1d3F42xo2LfiVw9vWYjUVGXlSFKISG9Dwiv406nY9ASERpb7fjsW/sG+lq7JVfINWnD64nQOr53N8+yq63vEYDa7oX+V1Caqq4VRdfR9U9WwTuQKNet3C6b2bOLXLc/oNQJC/H7df2ZZeLRrSqHosCgr7T6awfNcBfl65iRyz93Bdr8cQoms3IbxGfdKP7Gb9T+9was969Ea92/d+9qljJG13fxLdyGBkaDkaGvrKmJBwVlstnCoSso6uW0zbWx4mOCyyyEJw9yl0muberk9TVRx2B3q9gt2plloquEDBaEZMg9ZkHN0NuEY07DaH1+lMplTXiIbNlIk9f1E4gEGv58+3n6VZnbLXFLVrVJeZbzxF97EvFm7LTT9F0r6N1GzSsczjvQkN8kOnKJzOMHEm00RWnufXRZOu1+OwWdgw92s2LfgWg18AzbrdSK+h41j05bM47GeP+X7tTv7cdoB7urTg9g7NaFUjloD8aakWu4OtJ84wbcNuvluznWyLe/lc/8AgRj77Hn9vO033lkZqxZ2/ryUhRMVJ0BBVFhAQwK+//kq7du1YsmQJr7/+Oi+++GLZB55Huvz1HaH+BohwLezMsjjINNvJtDgwldDkSlEUrux7Lf/MmcmOw8f5d/teurWq+HD9si272HPMNdrTpdfVZex98TLoFHzXeguy0tzr6zeKCC5hz6prEuFexSo7IxWDXkd8ZBAn03NdnaJ1Ouq1uYJ6ba5w9Z7IySUtLQ2d0Q//8Eh0Oj2oKloZU2Z2L5nB6h8nANB20P10GDKKM4d2suKb10k/foClX73M/lXz6Xbvs4TF1Sj1XAVUVcOpubpQewsV3sQ1aY+i03sdybjvqs68c88gIotNCWxfP5Hbu7XjraGDeP7HOUxa5NlXI2nrCtoOeZDAkDCia9Vl8+8fk33yKKkHtxPfqM3Zv4e/f/c49r7gMAznsVFnkE7HXcGhTCgykuS0Wzm0ai6tBgwtUtq2yPoMzTWSUTQIWvOnOmkahYuey1JQ1jayVlNS9m1Cb/QnomZDzGbPaVNOhw1zputaMg5ucXtt6DXdad2gtscxJenaohGDe3Ri5vKzAXPP6jmVChoWmwO9TmH93tNlrkdp0fNm7FYzW//6kXWzJ2HwC6BRp2vpO/xV/v72ZezWsw3+Ms1WPl6ykY+XbMSg01E9PAQNjZNZeThK+PsNDArh4fETqduoBRabk8Ubj9KsdjSdGsej18sEDSEuRvKdKXyiUaNGTJo0CYDx48ezbNmyMo64sPQ6haggI/Wig2hXI4xOia71HXEhfvgV+4U1eOj9hX+eNKtyc50nzVpc+Oc1y/7iy/deIy3ldOUu/gLy9YJwp8N9+oh/KZ2eq8pY7NoLFuQH+RuICvUcYbLaVSyqnqDIOAJCIlwhA6CMa9y3cg4rv3sLgFb9h9J+8AMAxNVrzuCXptLx5rHojf4k7VzL7/93O9vm/4DqdP97UFXX/H+r3YHZ4iDXbMdkdWC1ObE7tXKFDICDy2d5DRkTH7iFr8bc7hEyigoLCuDTkTfz7f/u9Bh5MWWcZu/f09D76QkMDaduZ1d43rfsjyKfg5P9y/90Oy5Op+cKf8+5/udav4Agj5K3h1bOBvBacapgtKLg83bYHWiqhoaGs5yVk2ymHNIObgPA4O/6+oqs3RRFb8DupYqXOS0JNBW9fyDZSXvdXht9Y8UfThQ/5sSedVjNuSXs7c7pVMnMtXL8TA4nUnMx2xzlrhjV5uqhNO9xEwCrpn/Eoc1LSKjfiuse+oiYWt4f0jhUlWMZ2RzPyCkxZNRv2oZxH/5Mw+Zt3bbvOprGn2sOeR1lEUJceBI0hM8MHTqUYcOGoaoqd955JykpvusGe675GVzrOxrFBtOpVjjtaoRRLzqQqCAj7TpfQd1Grl+Qvy1dw8J1Wyt07nlrNjNjuauOvtHohzkvl+8nvs8t3Vvz1rMPc+TA3jLOcPHwddAw+LnP089z+KYUpzfmYlO+FL2RjFwr2SYrfgYdBoMOu6riVFXMVgfZJmvJU/BLeCJ/cM0ilk9+DXAtxu5060NuN+k6g4E219/LTa/+6FYKd+b4YSQf2OkZKhzlDxXF2R129i2b4bH94et68MDVV5T7PEN7duTZwX09tu9bNrMwIDXMX6dyeM0i7BbXU+vsk0ex5ma6HTMwMPi8jmYUCNbp6BfgHqqykg9jy8shLz1/RCO/4pRabMoUaPlrM8DpLP+/xZk969BUJ6HxtcnNX+QdXa+V10XgcHbalH+Y+1qiOgmxdGhSv9zvW6B3uxZEhRUZxdM0TJkl/0zWNA2Txc6pjDyOnM4mNduM1eHEaNDhZyj/VFhFUehw3Qgad7kONI0Vv7zLsZ2riYhLZMCYCXQaNJrgiNiyT5QvOq46dz74HM+88y0JNet43Sct28Ksfw+wPymj3OcVQpwfEjSET3366ac0adKE5ORk7r333nJPMbjYBPnpqR4WQLP4ELrUjuD5554HXE/6bnvxAxav31au8yxav5U7Xv6wsM7+c+9+yuuTvqdF+07YbTbm/voDd1/TlWdG3MHmtf/6vMGWr/k6aETHuzdx25l+7qpxbS927uCoONKzzaRkmjmVnofN7iQnz8apDBPJ6XnkmO3kme3kWeyYrQ5sdicOh6ucqUN1LQZ2OF3BRFU1Dq1fwpIvX0LTVJr0vJGudz3hMRJQMFIREF2D3o98TOe7n8cvKJT0Y/uY9/r9bPj9ExxWc5U+T6eqYrM7ObV3s0dJ2WqRYbx2x3UVPuf/3XwNdePcFyCbM1NJ2uZag5DQpB1h8YnYLSYOr3Ut3E09vNvjPJ38/D22nS8dvLx32tE9bms0NE3zWLtVMPrgVF0BpLzrak7tcE2bim/eldQDrocTgZFxpBzYTvrBzZzZ9S8nNy/m+Jo/OLLsZ46vcY2w2E3ZbufxtvC7PBRFoWaxY22WPI/97A6V9BwLR8/kkJyeR67Z7ha0QgKMHseU57273DiW+u36oKkqS394g6R9G9Hp9DTrdiP3vfITY//vQ5q38wy8Op2eGnUacuXVN/K/lz7hzcnz6D3wTnRlrPtzODWWb0ti2dbj2M/hAwshRMXIGg3hU8HBwfz666906tSJ+fPn8/777xd2Eb9U6RSFEcPuZs+OrUyYMIFcs4WBz7zNyIF9GHXD1bSol+hxzPaDx/jij8V8NefvwqkWd416hKsHuTo297jmOrZvXMsvX3/G8kVzWfXPQlb9s5AmLdty+8ix9Lx20EXZiMqXQUN1OomMq+a2bVlSGtfXqXpfC282pWS5fVytfnO3j3WKgr9RT2bu2SkYWv7/OTUNxami6XWg5Zc2tZ+9mUnesYoVk8ahqU7qdL6WNrc+QZ7FkX/j6rp5VV23qSicHRCp02UACc26sHn6Rxzb8Dd7/vqZ45uX0fHOJ6nWrHOFPj9V1XCoZ5vHpR3a4bHPiL5dCfKveLUnf6OBUddcybM/uE+FOr1vK7Xa9URRFBr2GMTG3z5j//I/aNRzkEfQ0AMNjBW/afWVpl6qXKUc3o0p3VV1Kjgqwa3ClOqwY8nLwZSZiSk7C6spD4clD81uxm7Jw2ExefzXYcnDnv/fnDPHADjwzy8UlKfa8st7ZV5n0UXgAFZb5XvuWIodq9O7/v7V/NGLbJMNk5fqV0UFBVTu55Ci03HlLY/jsFs5un0l/3z3CteMeJ34ui2oHhNGXIM+pKeeYuemVbTq1IP7HnsNRVEICAzGUIWvkwPJWZzJMnNV60Riwi/NohtCXE4U7WJ/hCouSV9++SWjRo3CYDCwYsUKunTpcqEvqcpUVeWJJ57gww8/dNvevXVTrmjRiNCgQHJMZv7dvpeV2/a47dOsTXs+/30hOi/z+48fPsivUz5n3u8/YbO6Sj5Wq1mLW4c/yIBb7iIoOMTjmAvF5lQ5llF2WcrSZGeksWL2NJbO+IHUk8c9Xr+qRjSjm9diYJ14jD5c4Hn1H2tZmpxW+PGot76iQYdehaMVZpuDbJMNh1PF4qU4gMFoQFekP4vNYgMNTu5ex/KJz6A6bNRs15uOd/8f6Cpede3UzjVs+e19zBmuqTy1OlxDqyH/IyA0AhRXQIGzIUVBAQXQNByq5tGdeu3kF0jettxt24rXHqFr4zoVvjaAbUeTaffku27barTsyrXPTgQgL+000x7pD5rGzRNmseqbN0nesbZw3/oGI1N90ByxsjRN47qUk2QVab4XHFOdvFRXkYbIxIY47VZs5jzs5jyctqp9nXtjDAxF7x+E3i8Qg38Qev+C/waRumc1dlM2MY27kLr3bGO7oAB/Ts76guDAiq1tScvKofrgUW5rSq5//CsIjCHHbHPrdF4SvU6hbkLVKsE5HXaWTH2FE3vWY/QPov/ot7j+6l7odArff/IKy+b/xoBbRzBk2CNVep/idDro1Lgazet49lIRQpw/F98jU3FZGDlyJP/88w+//PILt99+O5s3byYyMvJCX1aV6HQ6PvjgA5o3b8748eM5ccI1p3rF1t2s2Oo5TQQgLCKK7Mx0dm/dxNZ1q2jbpZvHPol16/PEq+8x/NFnmfXjFGZ8/zUnTxzjo1eeY/KHb3HjXcO56d6RxMQleHmH86sqIxoWUx7TPhzPv3N/x2EvuXbVkqQ0liSlUT3Yn5c7NuK+pp4jRhW1OyPXLWQEBAXTunN3AoNdTzyzTFaSUnIJ8jdidzhRVbAVm35R8ExGU8G1LFghefcG/v38WVSHjWotu9F+6LhKhQyAhOZd6NvgW3bNncLB5dM5tmERp3avpeWNY0js2M/rlB2nqhWWYS3+qrf5+C1qVf5rqFnNeBRFcZveZ8o4+x7B0fHUbNmVE9tWsW/ZbGxm92k6sZX8e/EVRVGI1evJKrJWpyBkAGSU0MhQb/RD7x+MISAIY0AQxoBgDAHBGAOC8v9b8Jrrv4aAYE5s/IukzUtIaHEF/qFRHF09h7rdbqRu35Fep0dqqpPT25YAUK/3PWQc2YYzv0KTyWLl57/+ZcTAPhX6fL+dv9QtZPgFR5DhCEapwKLpyo5mFKU3GOl19//x15QXOXVwK4u+GkfbRt+QWLcxyccOAlC9dsXXoJRFVWHN7pMkpebQo1VNAvzkdkeIC0G+88Q5oSgKX375JevXr+fQoUOMGDGC33//vcp9Ay4GI0aMYNiwYcyZM4eJEyeyePFij32uueYaxowZQ/8BAxg+YiQ/Tv2O1x4fzTdzlxMW6X3OdWR0DPc9/DR3PvAQC2b8wrSvP+PEkYP88PkH/DL5M6654RZuGzGWug0vXDdcnaKg1ynlehpaVFZaCh8+di9H9rivbTHo9dSMjSLQ34+MnDxOpWcWvpacZ+WBpdvZm5nHm10aV/prR9M0XljrvuC+S7/BBOaPFGWbbKRmmvE36vE36gEj4SEaadlmzFaHay2GquIEt4XMaUd2suqLZ3DarcQ37UzHYS95NHyrKIN/EK2G/I/E9n3YNO1dspMPsvHHNzm+YTFtbn2C4BjXmhZV1TwWLRf9s+p0kJea5HF+/ypMx9PrdOh1Co4iC6I1TXUbSWnQYxAntq1i/4o/CQh1f7DgdxF86xefkBMcnUBe2in8QyPo/sB4jIEhGAOD0fsFoTMGYPAPAr2BvFzXupmCr/+y7PrzSwAS21/N/vzmdZF1WpS4BsuSlYLqsKHTGwmKqUG11n04se7sNLVPps9n+HVXeR0R9cbucPD5TPcKefEteqNUsKpbsL9vproZjP70GfYyi75+npSju3l/3AM8/fY3JB09AED1Wg188j7eHE/JZebKA/RsXZPq0RfP6LAQ/xWyGFycM2FhYfzyyy8YjUZmzJjB559/fqEvyWcMBgM33ngjixYtIi0tjV27drFu3Tp2795NWloaCxcu5IYbbsDPaGTSZ5/SqFEjzpxK5ovxT9AkNoiEUH8Cjd6f8PoHBHLDncP48a+1vPHFD7Rs39m1cPy3H7mn3xU8Nfw2Nq9ZecEWjld0VMOcl8uEh+9yCxm14mN4beTtHP39Mw788gnbp07gxMxJrJ70OsP69yLA7+wNzoQth3hp3b5KX++0/cn8cdi9lPCBbetJO5VEtslKSqYJDVeJTYvNSa7ZTnaea1qUU3U1aDTodegVBZ3O1R09/chuln70GA6rmdiG7eg8/FX0Bt91uo6s3ZSrnvySZtc/gM7ox5m9G/j7rWHs/ftnbDY7To/KSGc5LCbWf/28x6JigKOpla/Kk5ye5VHi1BgYnN892zV1q0abnvgFh2POSMFpc39ybrsIJukWX+3gnx+GwqvVoUarbsQ3bktkYkMCI+PxCw6D/OCoyw+Y5fnKz01NIuf0URSdnqi6Lcg84RopCaneuMRjCjuCR9dA0emp2dF9wf7OwycY99W0cry7K1g/9vF3HDlVZERL0ZHQomIjIjoFgiqxELwkRv9AbvrfOyTWa0JOZjrvPTscU242ik5HtcS6Pnsfb0xWB/PXHWHj/tMeUwyFEOeWBA1xTnXo0IF33nkHgMcee4wtW7Zc2As6B6KiomjatCkdO3akSZMmREW5j1iEhIQwbdo0/Pz8mD37D36dOpkGMUG0rxlGh8RwGsYEERPsh1Hvfhuj0+nofvUAJv42n89/X0DPaweiKAprli7m4TsHMfKGPvz153QcjtIXc/paeZ7oFjX5lcc4vn9X4cdP3TmI/T9/zLNDbyQ+KsJt345N6/P1s6PZP+1jt5Keb246yG8HTlb4WjecyWTs8p3u12/048TBvbw4tB9LFiwgI9dKapaZtGwLWSYreVY7NocTDQjMn26h5C/i1usUspIPsuSDR7Cbc4mp34orHngT/TmopqTTG2h89V30eeYbYhq2w2m3smv2JFZ8+CCZx72XRLbmpLN64mOk7F2P4mWq0uq9hyt9PWv2HfHYFlmzgau/hOYaUdEb/ah3RX8AbMWCTpqXfh7nk6ZpnteQv14jKCoeDdBUDYfdCZrmtjBcl79WqDyDaqd2uCpxRddvRe6ZY6CpBEUloA8seepoXooraATHJhLgpyc2sS4xDdz7Rbz702we/nAKJkvJU59yTGZGvDWJSX+4j7JG1+uAf2jF1ir4+xkKA5av1K4Zx+Ovf0G1xHpkZbimMsbEVcd4nqqRbTmQwrx1h8k1+7LtqBCiNBI0xDn3yCOPMGjQIGw2G7fddhs5OeeuhOnFqm3btrz99tsAPP7442zb5nq6H2DQER/qT5O4YDolhtOmeih1owKJCDS6/ZJv0a4Tr038jp/+Xs/goffjHxDI3h1bGP/ISO64qj2/fTMJU+75+Xst3viuNEkH97JxyfzCj8fdM4Q3R91ZZhffatGR/PXBC7RtWKdw2xsbD1RoFGdpUhrX/rmOnCLN0cJiq3H3u78QV68ZpuxMZr39P1b/Pgmn0/tNsE6nEODnumHX0MhMPszid8Zizcsipl4L+jz2AUEhIfj76TEadOj1Op9OD9Q0jYCo6nQe/R6tb38GY2Ao2Un7WfnhGHb9MdGtFG5uygn+/eh/ZJ3Yh19wOA2uvtvjfFP+Weuxrby+WbLOY1tUnWYeIysNerh6aliKdOIGOOSwY72AtUdSVCcZxcpt64yuG9yCruAOp4qqqhR/6K3oClfgl6mgG3i15leQdmg7ABF1WpR6jDm/h0ZEQi2Mej0KCi0HjcUQEOy238SZi6h98xie/Ox7th08isVqw2y1sWnfYR758Btq3TSG7xa4N0vVB4SSeOVdZV94McE+HM0AMBp0RIcGEhoexRNvfEVwWAQA2VnpZGemlX6wD53OMDHr34McPe054ieE8D0JGuKcUxSFKVOmULNmTfbt28eDDz540feLOBceeeQRBgwYgNVq5fbbb8dkMrm9rigKIf4GaoQH0CIhhC61w2mREELN8ABC/F03uzXr1OPxV97l95XbuP+x54iIjuFU0nE+fvV5burWiknvvELqmVPe3t5nKjKi8c+MqYV/7ti0Pi8Pv6Xcx4YEBTBt/KOFN+470nP491TZU39MdiePr9zFNbPXkmU7GzL0BiP9H36D8Or1uP6FyTTtfRNoGptmfcWC9x/1uDEuYNDrMBp05Jw+waJ3xmDJySCqdmOufuJjAoLDANeIh16nw6jXudZ6VDF4aGg4VRVHkd4NiZ2updez31G9bW/QVA4t+41l7w7nzJ51ZBzdzaqP/4cp/SRB0dXp9uhnNOlzK3qj+5PilbsPMXv99gpfz+Kte1mw2b3ggaLXU7Ntd499o2o1Iqp2Y4o3pHDiChsXyl6753vn5i8Gt5tyMWWn43A4C/tlFKXPX9uglJE07OZcUg9sASChSNAIq9nU6/56RSHQz4A53bWeJjSuVuFroXG16HT3S+gM7jf8GTl5fPjrXNoNf4aQa+4h9Jp76DTyOT6buZAck3sPFsXgT40+D6MPrngvjmAfLAQvKj4iCF3+z46I6DiatXFVIrSaTXzwf6PIy8kq7XCfstqd/LXpGKt2JZe707sQonKkvK04b1auXEmvXr1wOp1MmTKF++6770Jf0nmXkpJCq1atOHXqFA888ABffPFFuY+1O1WyLA4yzQ4yLXYsdhWrxczCmb8w7euJHD/sWlhpMBq55oZbuH3EWOo28n6DUxU5Vgenc8qeemDOy+Xx6ztgycsF4NvnxzC0X48Kv9/AZ95m/prNAFxbK5bZAzp43LxrmsaBLBPf7jnON7tPkGLxvL5+Y1+lSc9BmIv0v9i3Yg4rpryB02YhJDqBPmPfJK5ec49jc1KSmf3GKEwZp4moWZ9+z0zCPziMU3s3kbRtDelH95KZdACbORc0DUNAEBHV6xFZqzFxDduS0KwjKHpUzbWQu7Qfu878hd6lOb1rDTumf1hYClfR6dBUlYjExnT733sER7o6L6/99lWOrJrrdmxceAgrX3+EevExpb5HgeOpGXQb9xFJ6e43grU79qXn/972esyexb+w7od3/p+98w6Pquq6+O9OTe+NNEIIvffem4gKiHQREJFiwS5YECyvomJBEASkCFKkK6DSkR5K6L0kkN7rTKbd+/0xySTDTBoEUb+s5wnDnHvOnTPtzlln772WTftEFzdGFZCzvxvfZGeyTptbah+/Oi2J6DqQwCadrGpuJFFEq9GhKCMSFxe1l8hlM3DxC6XH1KVsnfoYJr2W1pPm4exX3dJPLhNQKeQo5DIkSeKPj57CoMmhy8vzcQ+0VmBKi75A5PLpGLQVi1jKHd0J7vkKDt7VUSnluDuXPz1JpZQR6lu571OL2v6WVESAT19/mhuXzuDo7II2L5fwOo157ZOFODg5l3KWyoeXmwPdmoTg4fLwzCSrUIX/MqqIRhX+Vvzvf//j3XffxcnJiePHj1O/fv2HPaW/Hbt376ZXr15IksS6det46qmn7uk8WoOJLK2RzHwj6Xk69u/8nTWL5nL2RJEGf9suPRk2/kWat+tUaSk9GoOJ+KyyJTJP7N3OvLefB8Db3ZWYdfNwuAezuG1HTtF/atGi1V0pp7mfBwFOagQBUrR6TqVkkZZfwm65IIAk4VezAf3eWYjSwdrEK/32NXZ++yZZibeRyRW0G/Ea9boPsrxeuelJbP10IjkpcbgFVKfn699y59R+ruzZQHbS7XI9BydPP2p27E/troNQObkiSWYyUZx4FJeqLQ+MOi0nlrxP6rWT5qcpV9B8+BvU7NTfMvfshGj+/GgU4l2RhCAvd356+Wm6NChd7efIlWhGfbuC6JR0q3ZBJqffjBXmyIUd6HKz+OXl3kgm6/qhQLmctd4BlZ77Xxa0ksiAlARyy/lz5x4cQevR7+FVvVDhTUKTm18m0Tix8hPuHN9BRPdhBDfrxr7ZE1A6utLhzZ8RBBlymQyVQmZ1Hl1uBn9+PBQEgX4f/mqJQkmS2UXeaBTJy0wm5sAvJJ3bh0lfunO8TOmIW0QHvBv1Q+Fk9sCQyQS83cpvXufpqsbbtfLM7jxc1DQMKyK2kiTx8uD2aDW5THr3a36aM4O8nCxqN2rJlJnfo3b4e432FHKBdvUDqR1ctgS7KIrs2bOHNWvWEBsbS05ODs7Ozvj7+zNw4ECeeOKfabZahSo8LFQRjSr8rRBFkUceeYSdO3fSsGFDIiMjcXT8/+feOm3aND777DM8PDw4ffo01atXL3tQKZAkiTy9iQytkb8OHWLx3Dns//M3y8557YZNGP7ci3Tt+8R9ue6CObISUw7Tvt3rlrHyi/cAeKx9CzZ/+uY9PZ5Wp8e19zP3NDasWQfaDHqeLbNeIT8ng+otutLrlS+Q3VUordfksG/hTKKP7wEgot0jdBwzDYM2j62fTSQr8TauvkG0Gf4KkWu/KzfBuBuO7t60Gvk2QY06FLRIGE0SRpNYQD4oF9mQJIlrO37i6p/LAFA6uWLQmHe8/eu1ouXIt3HxCwbg4u/LObfJvuLb8I7NmdC7A21qVUepML8mRpOJEzfusHDHYVb+dcJudKXR4+No9tTku2dllt0tcCc/9MN73Dmxy2bslx7etFP/vd/537R5fJZdMcUtQSan0cBJ1O09EkEQyNfmIysldUoSTWx/byD6vCw6vfQtmbHXOLdpLt61W9Ns5AxUShkKO/KyaTfPcmjhGzh5BdDjreWYTAUEw05Kjz4/j/io3SSf3Y02LRbRYCb8cqUDjj4hONfogFuNNpbak+LwcnOwpICVhSAfF6vow/2iboiXlUt3ekoib43uhVyuYN7GSGJvXeXLaePI1+bRsEUHXpg+B6UdJ/cHjZqB7rSvH4jKjiJgdnY2S5YsYf78+Vy9WrIKXlBQEM8//zwTJ07Ez8/vQU63ClX4V6CKaFThb0dSUhJNmjQhKSmpwulD/xUYDAY6duxIZGQkHTp0YN++fZW6C2YSJc5cusI3X3/Dup9/Ij/fvAvqHxjM4LETeXzoKJxcXO/p3KIkcTOt9F1VgG3L57J+3mcAjOjVkZ/ee/GeHg9A3X1EhXKp/cPr07L/aOp2ehSDUST6/Em2fToRk0FPo74jaff06zZjJEni3PaVHFszB0k04R5QHUkSyU66g7OXPzVaduf8zjU2tQf3gohOA2g6eAom5CWer0TiIZo4v/Fbog+bfRbq9xtL/X7PcnXXai789iMmgw65Uk2Dx5+jTq/hABz47nUSL5ZcCO6gVFIzwBuZIHA9MRWtvuRaCr/azej11vfIlSqzcaHJXE9yt2xo4oVj7P/W1u25oVLF956+yP+mqIZOkhidlsSdYtEVhUzGjpeH4uGk5npyBpExCaw9cYk7GbbpSfUfHUujARPQ6/TYVIkXQ9rNc/z17YsoHV149JMtHF/+IfFn9lO3z7PU7jasxHHRx7ZydtMcfGq3ovGID0r9eBnvIiAqmQQCyOTmzYPUxAz0OvvvnZuTCnU5yENluIEXh0oho2Ud6yjW+RMH+Wb6JKqFhPPRD1sAuHbhFF+/NxG9Tkuz9j2YOO1L5PfpS3MvcHVS0a1pML7uTpa2ixcv8uijjxITE1Pu83h5ebFlyxY6drQ1aa1CFf4/oYpoVOGhYNeuXfTu3RtJklizZg1Dhw592FP623Hz5k2aNm1KTk4O06dPZ+bMmQ/kcdLS0pg773vmzp1LakoyAC6ubvQfMZanxjyPj3+1Cp/zVrq2TNO+4hGNxzu0YNP/KieiIVeqMN3lLC5XKPEJq01ArcY06PoE1Wo1RBAE9AYT+QU1GTeO/MnuudMA6DD6bRr0tv+ZS7h8il3fvoU225wupHJyJax5F64e3Gq3v4+Tml41g2hezZvqHs4ICMTnaDiVkMauG/HE5Wjsjgtq1o1Wz7xvV4b2bkiYvRwk0cCxJdOJP3sIQZDRfMQbRHR50tIvJ/kOJ1bOIvnyCQA8QmrT6pl3cAuozoF5b1ra7xW+tZrQ/dVvUTg4IZps1ZmKQ6/JYds7T6LX2C7eX3JxZ5jzvRHdimJuTiarNda1GSNa1eenMY9ZtRlNIutOXea19XtIybV+z5oPf53wjgMx3eUWn5scS9LlY2TcvkLy5Uh0ORnI1Y64+oeSkxCNyaCjxcj3CWpkWzQvIWEyiZz/bQG3j24hpO0AIvo8V+pz0RlMliilIAgFBpNFMOiNpCSk2xuKo0qBi1PZUQI3JxV+Hk5l9isvgn1dCfO3rvf4c+Ny1i3+khYdezHpna8s7RejjjDngxcwGg206daPca//r9wmhZUJmQxa1g6gYZg3p0+fpnv37mRmZlqO1woOYEL/XnRv0RBXJ0fytDqOXrjKgs07OX092tJPrVazZcsW+vTp87c/hypU4Z+CKqJRhYeG999/n48//hhXV1eioqKoWbNm2YP+Y1i9ejUjRoxAJpOxZ88eunTp8sAeKz8/nxUrVjB79myuXDH7MBQWjg8dN5nwOuWvl7mTmY/OWHqE4cSebcybOgEAP093otfNQ6Ws+A7ljuNnePSNTwvmq+LTrVEkx8WSl5uD3mBCoXLA3T8Uk1KJJIEIyAWsSEYhorYs4fgvcxEEGX1e/5pQO6pJek0uv308nrQY+14VhQjzcGFmt2Y81SAMtcI+WTCaRLZdvcOMvac5l2ybuhPeaSBNnnql1MeRK2QolQp0eVns/+510m5eQK5U0/75jwhu2tniYVEISZKIPrKN07/MQa/JRhBk1Oo5lPp9x3Dpj5+4snPVPUVlanUfTOMnJyNXqhGE0hd/SZdPcHTxdPKz7S96VcAyb3+qKypXQvVunNfrmJSRQvFPqlwmEPn2aJoE209rScnRMOzHLey/dseqPbBJZ8LaPYZPreYkX47kxv4NpFw9WfYkBAH/Oq0J7/gkvhHNMIkSRpMJg0lEkuDMyumk3zhFncdfIrB5yQtSUZTQFyM6MkGwm+KTlZ5DXo5txFEul+Hl6lDmdKt5OVeqtG3L2v443BVJWfr1+xzauZnHR0yi/9PWKXinj+1j/sevYjIZ6dz3KUa9OL1SJaMrArUpmzeff4rEBLOHT5CvFz+8+Ty9WzW2S4AkSeLohWtM+nIR52+ZPz8uLi4cPHiQJk2a/K1zr0IV/imoIhpVeGgwGo10796dAwcO0KJFCw4dOoRa/f9P+ePZZ59l6dKlBAUFcebMGby9K2asVVGIosjWrVv58ssvOXDggKW9a4/ejHj+Req16kBZhgEJ2Try9KUbsGlys3n10RboC9K2fp7+MkN7tK/wfJ9890t+PWjeiW/ZvR8vfGadameSJHR6Eyl5eowmkXyjiMFgRKuzNTKUJIm/Fn/ElX2bUagdeWL6EnzCigqaDfkats96kaSrp1G7uONfuym3T+23Oc/4FrX5oncrXNTlW5DpjSY+2n+GTw+ctTnWfuLn+NdrY9OuUMpRKBUIgkBuShx7v5lCTtIdVM5udHlpNr4RjW2em/nWTDzys9OJ+uUbbkfuAMDJO4CWI99G6eTKuU3zSb5SjkUy4BPRhEb9n8e3trWBXElk487JPRxdPB3RVLqRZLBcwXxPX7zkZUd07gWxRiOTMpJJv8s7Y2qftnz8ROnqZxq9gd5z1nL0VrzNMUGusClyLy8CGncl4hFzgXghDn8zFl1WCs3Gfo5HaMlkX280WaWnyQqUq+6GJEokxach2kk19HF3LHXRLhOgRoB7pS3sPV0daFDd9nr2ySsjuHX1HBPfmU3Ljr1tjkfu/4NFn7+FJEn0GjCKIePffChkY9Hnb3Ns33YAalTzY++cDwj2K/v6nJWr4ZE3PuH4pRsAtGvXjsOHDz/QuVahCv9UVPloVOGhQaFQsGrVKry9vTl58iRTp0592FN6KJgzZw61a9cmLi6OcePGPXCPEZlMxhNPPMFff/3F0aNHeeqpp5DJZOzbvYPnhz7By4N6cmnfb/g5yXFS2V8EKsrhpeHk4ka7vkVpPfM2/Vnh5xaTmMLWw0UL4u5P2RaFywUBJ7UCZwclro4qlHI5CpkMV0cVzmoFjkoFaoW5TS6T0WnsNIIatMao0/LHly+Tm2aWiDXq8/lz9iskXT2NysmVvm9+Z/FZKI4PujZl/uPty00yAFQKOR/1aM6iJzrYHIta8wWG/DzzHUFAqVLg6KRGqVIiCALpMZfZ8elz5CTdwdm7Gr2mLrIhGeahAoIgIJMJyGUCTu5edBj/IZ1f+gonrwA0aYn8NedVru35hXbjP6LvzNXU7zfWxu5a6eyGd0RzwrsPp8Nri+j6xnwbkgHYfS+Tr0Zx9McPyiQZALEmIy9lpJBSglni/SDGaOCljBQbktEw0If3+5ZNdp1USlaMeQxnle17fK8kAyDx7D4iv3+BnATzAtSo16LLSgHA2Se4xHGSJNnUwJT0DRRkAu6eLnaPGcqoc3JUKSp1QR/gaZuCJYoi8bfNUtyBofZVz1p3eYTRU8yppDs3r2DLynmVNqfyIisjlRMHzSRdqZCz9fOp5SIZAO4uTmz59C18PcwpY0eOHCEqKuqBzbUKVfgno4poVOGhIjg4mGXLlgHwzTff8Ouvvz7cCT0EuLi4sGbNGlQqFVu2bGH+fPsKQQ8Cbdq0Yd26dVy9epUXX3wRJycnoqKieP7Z0fRs1ZB9axdTz0NGbV9n/FxUqBTmS0Z5iAZA90FFxODwuSt8vqr8769Wp2fEzDmWBVa1sAjqtih5kagQQKMzotcbEDGvn+VyGUqlDLVKjpODAhdHJe6uzjzx1ld4BYejyUjhz9lT0OVksuPr14m/eAKlgzOPvj2X7JQ40m9fs3qMEY3Cea/LvadAjG1ei7c6NrJ+npkpRB/+DZVaiaOTGoVSYVn8J1w4yq7PJ5GfnY5HSC16TVuEe7Wwcj1WIfEIbtKBfh+uok7PYQiCjNuRO/j9g2Gk3bpA7WLu4TK1Iz0+/o0eMzbRasIX1O77HK7VwjEYjCVkWlnnbIlGI8eWzLSR0lUplUwY0p/v3n3FZhEbbTIyPj2ZI7qyxQXKA0mS2KnVMCE9mWTRmsCoFHJ+HPUo6nKm79Xw8eDtPm0rZV7Foc9NJ2r5NHLir6NNMxv1KZ3cUTqV7Fthrx6qNELg6OyAyg4RNpSR7ujkWHkpUyqlHE87qVrpKQno8rXIFQr8AkNKHN+x90BGTDLXVG1d/QO/r/vRbj9Jkoi/fYPDu39l/ZKv+Hnex6xZOItdW37m2oUoDPqypbjt4eCOTZiMZlI5qEsb6oQGVmi8n6c7z/brZrn/d17Xq1CFfxKqUqeq8I/A66+/zldffYWnpyenT58mNDS07EH/MXzzzTe8+uqrqNVqjh8/TqNGjcoeVMlIS0tj/vz5fPfddyQnmwvH3d3dmTBhAi+//DJBQUFo9CZupmu5lJSL1mirNnQ3vn71Gc4e2mO5P+PZwbz7zJOlLpTSsnIY9N5sDp69bGkbP+Mb2j9asudIQqaW9DwdSGAEFFBqBlhWchw/vz0CTWYaTu5eaLLSUagd6P/OfKrVbc6GD8aQcLloFzLAxZGzkwfg5XR/6X06o4lWP/zGxZRMS5uLbxCPf7IeoVje983D2zm2/GMkkwn/eq3oPPkzlI72d6rLi7RbFzm2/H9kxpoJlHv1+mTFXLR4jTQY9Cohba2LpGUyAWdnh7sDHxYUplDdObGbwwvftToWFhTA7z/MpnaYeUH5wy9bmPzhbLvneczBiRddPXC9x+LfVJOJ2TkZ/KWzlV6WywTWjuvPgKa1K3TO5Jw8qr87v9RIQNNgP0a2bkCr6tWo4eOOJMG1lHQioxNYcfQ8l5Ps16kondwJ6zKca78vwL16Q5qP+azExyheBG4ZLzc7z5cEo95I8l2F4UqlHI9SjPvC/N3K9AopL0J8Xanub0uezkb+xZwZLxBUPYKZ8zeVeZ7f1/3IhqXfADBi0jt0f9yspJav1XBwxyb2bVtDYmx0ieMdnV3p0LM/3Z8YgV+1kolNcUiSxLRn+5KaZCaC+76bQcfGdcsYZYuYxBQihr2MJEk4OTmRnJyMs/Pfa0hYhSo8bFRFNKrwj8Cnn35Kq1atyMjIYMSIERiN956e8G/FlClTePTRR9HpdAwbNgyNxr5a0YOEt7c37733HjExMSxatIg6deqQlZXF559/To0aNRgzZgw3rlwkxENNNTc1NbwcCXZ3wMtZiYNSZncx+vzMOQTWqGW5P2PJOho+8zrfrf+dzJw8q74Xo2OZ8s1SIoa9bEUyeg97rlSSkZGbT05ewc6lYOYXZe2guPsF0f/tbxFkMjRZ6QgyGQOmfUeNxq3QpNyxIhkAr7VvcN8kA0CtkPNuZ+vUp9yUOJIKaiYkSeLC9mUcXTITyWSieps+dJ3y9b2TDEnCZDSh0+pQeYfRfsr31O33PDKFykwyAIXanOISc3CTzYJWFM3qSCVtSUmSeRF+fd8Gq3aZTMav82ZZSAbAhCH9+XaareQtwNZ8DQNTE/giO4MbhpLlda0fW+K8XsdHWekMTk2wSzIUMhk/jX6swiQDwNvZEccSfGdCPd3YOvkpjk8dzas9WtExIpggD1eCPV3pVrs6b/duy7n3x7Fm3BP4utimEBk0WcRGmiWKnb1LTpsq0Um+jBQnhUqBi5v14xpLiWiolbJKIxmCYD9tCiAupiBtqnrpZpGF6Dt4HI8NMxt/rpr/Pw7t3Myl00f5YNJA1vzwWakkA0Cbl8OuLSuZPqE/29cuxlSO1DedVmMhGaH+PnRoZN+YsixUD/C1EBSNRsPNmzfv6TwPEvHx8cycOZOmTZvi5eWFUqnE09OTRo0a8f7773Pnzp2yT1KFKpSCKqJRhX8EVCoVa9aswc3NjUOHDvHBBx887Cn97RAEgaVLlxIQEMDFixd57bXXHtpcHBwceO6557h48SK//vornTt3xmAwsHz5cho3bszg/o9x4uA+kCQclDK8HJUEuztQw8uJam5qPBwVljQrZzcPXp/zM0E1i36sr9yO59XvlhMyaBJNxrxB2+ffoe6IV2g8+g3mbfqTHE1RKk23Qc8wdMr7Jc41Izef9Ox8q+CFAJSeJAKiycTp31cjFeTxS6JIarTZiCvuknWhtEouY3TT8i2MyoOB9arj52ydVpJy7QyiaOLEqi84s9GcZlGvz9O0HzcDeQXVmSRRwmgwotPq0Wp0aLU68644IJMriOgxnC5vLsHJJwgAY34eCAK5SdFk3jyNTLAOBhkMpS/OclPjSb56yqptUK8uNIioYZ6PJHHq4hXmr9nE6cvXCAmwr/iklSQ2a/N4Jj2Jp1MT+TgrnXWaXE7q87lo0HPBoOO4Lp81eTnMyEpjeFoSEzJS+CNfg97O+dwd1WycMJChLeuV96WzwuJDZ8jOt0296VwrhKh3x/JIg/BSI3OCIPBU87qceW8szUJsn3Nh6pSTb8k77SbR/ie5PMmLru7OyIqRB0mS7BoBAjg7VJ5BnqeLQ4meHfG3zfUpQeUkGgD9R71IzwFPA7D0m+nMfmc8acm29VOlwWg0sHH5t3z97gS0d8kd3w1NXpEkc4C3x33VrQR6F7mNZ2RUzDTyQeLy5csMHjyY0NBQZsyYwZkzZ8jIyMBoNJKZmcn58+f5+OOPCQsLY8CAAZw9aytkUYUqlAd/vxvOvxgajYaEhAR0Oh1eXl74+/s/NNm9/yLCw8NZvHgxQ4YM4dNPP6Vr16706tXrYU/rb4Wfnx8rVqygd+/e/PDDD/Tq1YtBgwY9tPnIZDIef/xxHn/8cSIjI/nyyy/ZsGEDO3fsYOeOHdSq34hhz71I934DUCiVyARwVslxLigiN4oSGr0JV4dQpv+4maWfTiNy12+IBQXAWp2eC7di7T62i7sn/Z97lR5Dxpb4PSskGYB9oiFhd0UmiSI7F8zk0l/bkMkV1O/yGOf3bGbf8i9x9w8i8cZFq/7Nq3nj7VS2NGh5oVLI6Vw9gPUXoy1tabcucHD+O8RG7QNBoPnQV6jbs2Sjt7shmkRMJhMmo2jZARdFCbEEp3Fn3yC8w5ugSY1DplAhGs1L9XPrvqLjawtRqB0tL53FP8LO6ymXychLiuZujBn4KDl5Glb+9ifz12zmwvVb5X4uALdMRm6ZjPyef2+RvUfqh7NgRB+CPe/RmFKU+GrXcZv2+gHe/DpxEC4VWJj7uTrz+4tDaPnpcmIzbX1FnEoqBJfs12eUF4WF4Rmp2ZY2g1G0G7moTEnbAK+S04PiYsxpe+WNaICZsA0d/xbXzp8i5vpFm+Mta4YwuH0zWtQMwd/dlTydjnMxCfx5+hKbI89ZkavLZyP5dvpkXv34B9QOtg71CrmAi2PRe1tWamhZKE4U5Q9IYa2i2LZtG0OGDClX1FwURbZs2cIff/zBypUreeqpkiPLVaiCPVTVaJQBSZKIjIzk+++/Z+3ateh0RbtbdevWZfLkyTzzzDO4u1eek+r/d0yaNIkFCxbg5+fHmTNnCAgIeNhT+tsxbdo0PvvsMzw8PDh9+jTVq1d/2FOy4ObNm3zzzTcsWvwj+VrzD5VftcACx/FncHYtuahVbxK5ffsOW9f+xK4NP5OVlmzTp2bD5nR/6hla9XgMpbrkxX16Tj4ZOdapMrrC+uSCOg05thkmkiSxe9H/OP37agSZjH6vfU6d9n3YvfATTv+xBoXKAa+gMJJvFaVuvdC6Lt8+WrmFwZ8fPMc7u4oiJ4WLfZlCSfvnZhLaskeZ5ygkFiaTySpXTJIkTKJ9glEch+dOIf3mWRoOeoWki0dJuXQUALWbD42HvI5v3daWvmq1EqVKYSVrq1TIEeQCNw5u5fCiGVbnfnHkIJZt2k6upnIKvSuC9/u2Z3q/Dve1EfTnxVv0m7fOqk0mCBx682laVa+4ySXAHxdu8tj3623a3UMbEtp+IF4RzS0u3wAmk1hifYhaKS/380tLykSXbyaSapUct7tSABVymY2p3r1CrZTTsrb9TThRFHlxUBv0unw+XvgbAcFh5T7vhVOH+fq9CVZt4f7eLJgwlO6NapUwCmLTMnlx0Xq2nrxg1T54xBg++mw2DmoFjqqCP7UChVyGVqvFycmc+uXv5c7t9fNLrYcpDW0nvMuJy+YozoULF6hfv/x+RQ8C27Zto3///uZrRgUhCAJr165l8ODBD2BmVfivoopolIKcnBxGjhzJb7/9Vmo/Nzc3VqxYwRNPPPE3zey/Da1WS9u2bTl79iw9evTgzz///MfsBP1dMBgMdOzYkcjISDp06MC+fftQKP5ZAcj9F6L5eeliNixfRHqqmTA4u7jyxIgxPDX6efyqBZU63mAwMLRrc1IS4hgy+S3CGrTAKyAQ/5AaZT52Wk4+mTm2+fh6qShlylRwZZMXW+9IksT+5V9yYstyEAT6vvwJDbqav7eiycimT1/i1skDCDI5UjHVoo+6N2daZ1tJ2fvBitPXGbv5oFWb0tGFri99gW/t5vYHSeZ6CZPRhKmEBaipIIpRHuz84El0ORl0fHUBHiF1+Gv282THFSltBTbrQb0nJqF29UQmE3BydgAEFAoZCoWcwvDGrSN/cGDBu/YfpAQEyOS4y2TIBYF8USTOZOTe9IFsserZxxnS4t7SpQoxadWfLDp0xqptYNParBs/4L7O23n2zxy+GWf3mMLBGd96HfBr2BnPsEYYTJT4Xt5tglcajAYTyfFpgDlK6e1mTeDdnVX4uleOG3h1PzdC/OxHkZIT7vDOuEdRKFV8vzESWTmv6/maPKZPGkB6SqKlrUuDCDa/PQ5Xx7IjjZIk8dmmXby/ertV+549e+jWrZvdMY0bN+bcuXMAbP70TR5r36Jccy2Oczdu0+zZtwDw8vIiISEBlaryUtQqisuXL9OiRYsSIxmuzk4E+fkQn5JGdm6e3T5qtZqjR4/StGnTBzjTKvyX8M9aufyDkJeXR8+ePYmMjLS01Q4Po1/Prjg6OHD9Vgyb/9yFXm8gOzubgQMHsmrVKoYOHfoQZ/3fgKOjI2vXrqVFixbs3r2bzz77jHffrdgi5t8OpVLJ6tWradq0KYcOHeKjjz5i5syZD3taVvDz8eGZF15n6HMvsHPzOtYsnkvMjWusXvgdvyyZT8/HBzHsuReJqNfA7niFQkFOpjlneeBTQwisHo7WYEJjMKHR29/JlSSJqOPHOHt4P4k3LpAaewuDTotMrsDNJwD/mg0IqNOEmi27IFeqMYFVus+h1XPNJAPoPfEDC8kAc+3C469/yep3niEl2toVvLwL94rA5pyCjL7vLsIz2JxSIokgYfZPMBpNpZILKH8UoxAGbS66HPPr71xQq1Grz2hOLnkPmUKJaDQSH7WblCuR1Ht8IkEt+yCKEg5qpVXeP4CDm1eZj1dNJudRR2caKVXUUapwu0tdSpIk7hiN/KHT8Fe+lmiTsdTn4q5S4KZScCfXlnAei064b6Jx4naCTdvYdvevBDeufWMboqF290MyGdHnppMQtYOEqB2oXDzxqtsBn/qdcAmsbRUhqGicRqGU4+ruRE6WBlE0K8XJiklUO1VS2pQggF8JReAA8QWF4NVCaliRDLlMwEGtwEEpx7EgwuBQEGFwUMlZvuh7K5IREeBTbpJhnpfAtCd7EZeWxYIdhyzt7733HocOHbI7ZuLEibzwwgsALNi8856Ixg9bdlr+P27cuIdKMgA++OADuySjc8smvD5mOH07tUEulyOKIjuPnGD20jXsPnrCqq9Op+O9995j69atf9e0q/AvR1VEowSMHDmSVatWAVAjNJgfZn1Ij07trC72yalpzJq3iK8XLgPMBc0nTpx4KLKk/0UsX76cMWPGmM3k9u2jU6dOD3tKfztWr17NiBEjkMlk7Nmzhy5dujzsKVlwM01DfHbRHrQoihzZu5M1i+dy+ljRj3erTt0Y/tyLtOzY1er7k5udTd+mYQDsvBCLg6P1AsUgSmj1JrRGkdx8Awe3beD3nxcSZydH+244unnSqOeTNOs/FhdXDwQBjqz7gUOrvgOg+/h3aP7oCLtjc1ITWTypL6ZifhBjm9ViUX9bs737wYy9UXy8v2jH3NUvmCc/N8t9SiYJk2gyuzsXT4lCshAQSTKTFbEgylHRVPLMO1c4+PVE1K6e9Jq5EQCT0cj+WaPRpMUT3m0YKVeOkxNvTvvwqd2CNqOn4hVsjjgJxZa72twM1r/U21JYXxwtVGqGObnQRuWAvAKpTDmiyO/aXFbm5ZImWZ9XIcDKnk0ZFBHI4cQMnt4ZZUU4AtycuPXxJJT3GAk1mEy4vfq1DdlN/eJlPO6zVudacjr1Zi62alM6e9DhteVk3r5A8rm/SL50CKO2qJZD7e6Hd/1O+NTvhJNvdWQyGWplxZ6bJEkkx6VhMom4OassfiIyQaBGgFul1Bt6uzlQL9RsauegklvIQiFxWLVkLnNn/4/+Tw7mh8XLcFTLcVAqUJXyXERRpFatWlaKTXtmvkjn+jUrPL9crY7Gr83idmpRUfbp06dp0sTWGyc7O5ugoCByc3MRBIHd306nc5Pyk9fLMXG0mfAOeVodgiBw/fp1wsPDKzznykJCQgKhoaE2io5Tn3uaj6eMt/v+S5LEpwtX8P531p9XQRC4ceMGNWqUHX3+ryA/P5+zZ8+Snp6OWq2mRo0ahIWFPexp/StQpTplBzdu3GD16tUAhAYFcnDzKnp2bm/zRfTz8Wb2B1P5ZOqrAOj1embPtq8RX4WKY/To0TzzzDOIosjw4cNJTU192FP62zF8+HDGjBmDKIo8/fTTpKWlPewpWVCoKlUImUxGhx59+G71byzctIvu/QYgk8k4fmAvr40exLOPdeHPzb9gLJAuTUkyq8a4uLnbkAwApUzAzUGBKT2eb18ezuKZr5SLZABoszOI3PgjK6b051rkHo5vWWYhGV1Gv14iyQBw9PSjZrveVm0n4yv/s3cq3vq99KlRH0EQkEQJCanA5VuGUEwCSqDQ+VuGXC4gEwSQzDvCigJHcJkg2KhG2UNeslm20rmY4pEgk1G9wwAAki8eof3L86j72PPIlCpSr57kjxkjOb91GWKxxYoomji56msbkuEiCLzr5sm3Hj60VztWiGQAuMpkDHF2Y7VPAP0drYuLjRKM3HWGX28l0T7Ak/0D2xFeTMo1MVvD6uOXKvR4xZGl1dmQjGruzvdNMgBq+njaGF4a8jI5tfRtovevxqjXENJuICFdnsarbgdkSgd0WcnEH9nA2R9f4czil4k9+Aua9IqpLgmCgLuXOaXJYCxipY7q8tV6yOUCDioFbk4qvN0c8PdwQJZzh5TzOzm3bS6HVkxn35JprPnqNY5tmoPm5kEi3DT0bRVGt6YhtKtfjYzEGADatGyGv6cTbk7qUkkGmIlAcZLRrk7YPZEMABdHNS/0td6wWr/etmYGzCnRY8eOBcwL7kHvfsnJK+WTp70Zn8Rjb31Gnta8EdOvX7+HSjIAFi9ebEMyOrdsUiLJgIJI0POj6NOxjVW7JEksWLDggc31n4SbN2/y5ptvEhQURJs2bejbty/du3enRo0adOvWjXXr1mEopxz3/1dURTTs4K233uKLL74AYOXcLxgx8PFS+4uiSP0uj3L1ZjRqtZq4uDi8vb3/jqn+55Gbm0vLli25cuUK/fr147fffvt/p/SVm5tLixYtuHr1KgMGDGDjxo3/iNcgJVfPlRT7ebyFiL8Tw7ql89m6dqVV4fhTYyYQHFaTdyY8TY3adfnpj8N2x0cdPcjU50egybWWo5QJAg2q+dA0xA9PJwf0RhMXElKJupNErq7ki36HES/RbvAEu8dMJhGdwYRRlLh++A/2zHvHckwArrw8iHCve1MwuhuZWh2hX61DU0w2tsWQl2n46KhSRpllayXJnE5lMJoQRRFJlEpRxjFHPiQo8MEoun/lj2Vc27GckDaP0mTom4D5WmbQ5rLno6GY9Pl0eOFrghq1ITc1lhMrPyf5sjmNwjO0Nu2efQ/vGvWJWjeP81uXWj1qU6WKGe7e+FZibdUxXT4zstLJLhbdUMtl7O7fljb+HlzPyqPVuoPkGsy1NW6OKi6+/xwB7hX3H0nKziNo2jyrtupebtz4aOI9z18UJXZcusWCA1FsPXejXGMEuQKvOu1w8gkhN+EGmTdPIZmKPt+ugbXwa9gZ/wadULv5lOuc6cmZGPVGvN0ckcsEgnxc8HV3RKmQoVTIUSpkqBQyFPLi/5chL0h1y8vJKjDKW0tKon3FuOJo1KgRkydPZtSoUXTo0IEzZ86wZcuWctc0/vDDD0ycWPS6f/vskzZkoSKIS8uk+sSiNNRHHnmE33//3W7frKwsGjRoQFxcgQyxg5qPnhvK6Ee64OFqq6yl1elZu/sw7yxcTXJGFgBBQUEcPXqU4OCSvVL+DjRr1ozTp09btW2e+ymPdy07Urvn2El6jXvVqi0iIoJr166VMOK/gfnz5/PSSy+VWTjfsmVLfvvtt/+XwjXlQRXRsIOQkBBiY2Px9fbi9vF9qNVl51V+s2g5r834FIBFixbx3HPPPehp/r/B2bNnad26NTqdjtmzZz9Uf4mHhaioKNq2bYter2fevHlMnjz5YU+JrHwj5xJspTrtITszg80/L2XD8oWWwnGV2gG9Lp/Grdoxb+02mzFnjx/ltdGD0OUXqRa5O6p5uVsLnuvQhCAP20W/zmBkQ9QVvtwVydm4FKtj1Wo3ZuSsVTZjTJKEXm+y2sHWZKby80t9rQrCX2/fkFm9W5br+ZaFOUcv8tofkVZtj89ciVf1MozBJLNcpl1eUZBGVZyMmG+t068KT3R8+UfEntpNvccmUKvHMCSpSIrzwqbviDm0mcAmneg4eVbB6SVijv7O6XVz0OdlIwgyQlv1IOb4Loq7+bVTOfCJhzfqB0CGbxoNvJyRQkax6EkdD2eOD+6Io0LOwgu3eeGv80VzCQ/i9xcGV0iKFuDU7URaz/rJqk2tkJP51Sv3lI61+3IML/+ykysluISXBy6BtanebTT5mYmkXTpI1q0zFrNEEPCo3gD/hp3xq98RtYs5XVCGeVcaAXOUS5AhiSayUrKICDT7Q7SuE1BmVAEKFBj3bWfVgk/Jy8mq8PyDg4NJSkrCYDBw/fp1atYsX1TipZdeYu7cuZb7Bz+ZQtvaYRV+fKu5jJ9OYoHMcFBQELGx9gnTkiVLGDdunE27k4OaET070L1FQ1ydHMnT6jh68RrLf99HRjETUl9fX3bt2kXjxpUrJHEv8Pb2Jj296PPn7OhIxtHt5RJakSSJal36k5KeaWlTq9Xk59vWR/1X8M033/Dqq0Xkytfbi9FDBlKrRnU02ny27drHrgNFG2QREREcPnwYX1/fhzHdfzSqiMZdEEURpVKJKIr079ODTUvmlT0IOHPhMs16DwBg5syZTJ8+/QHO8v8fFixYwKRJk1AqlRw8eJDWrVuXPeg/hsILn1qt5vjx4w+9FijfKHLiTsUWHHqdjp1b1rF68VxirpvN8QRBoFf/wQwf/yIR9RoCkJGWyjOPtCczrShlqVe9MBaN7FsuXwSDycSsHcf4cNshq6Lrx9+YTZ0OfQDzj6fOIKI32t+t2vHNG0Qf32O576iQc2pSf2p5358MaHKulsbfbyZVU1Tf4h1Wn0fe+RGZXGZTaF0IUZQwFYYjKgqpoKZDFC0kZNdn48i8c4U24z4msHEnJCSMJgmVSoE2LY7fPxgGgsCjH6/DxSfQcqr87HTObviO6KN/2jxMM6Wa2Z4+D4RkFOK6Qc8LGSnkFntfX2tSg1nt6yFJEp02HeFYUqblWMvQAH4a8xi1/csuWAezBO3Yn7aTkmtbNHti6miahviXe645+Tre3rSPhQfPlN25HBBkckI6DCa8y1DkpnwSzx8k/uw+MmIuWPXxrdWcoCbdqNagvcX1vTi0uVq81HJ8PRxpWtO+eWJx5Gs1LP3qPU4e2lliHz9nB5yUCnL1BqvP9t2Qy+Xk5eWhVqtL7FMcY8eOZdmyZZb71+e9T5hf+d7LktDyzS85HW2OUri7u5OZmWnTZ/ny5YwdOxZJkhg/fjyXLl3i4MGDNv1KQr169di6detDSZkq9PyKj4+33L7xxhtWO/O1w0K4tPXncp+z5eBxRF2yjmAYDIZ/nBpiZeDQoUN06tQJSZKQy+V8Of1tJo4aZrPpfPn6TZ55+S1OnDFvbvTp04c//vjjYUz5H40qonEXTCaT5Yvz5KO9WL/ou3KNO3/5Ko17mEPB/v7+dOjQgYiICGrWrEnNmjWJiIggODj4/51Ma2VBkiSGDBnC+vXrqVGjBlFRUf/vvEskSeKxxx5j+/bt1K9fn+PHj1u03h8GREnicHTmvY0VRaY9P5LDe6wXq606dmXY+BfZunYle7dvtrSPaFWfJaMetWs0Vho2nLrC8CW/WsiGo5snY77dgsLJHb2pyNjOHuIuRLLtf9apMu1C/Ng9ug8qxb19j0VRYsgve9l8+bZVe8sRU4no+Jhl91kulyOTm+szJBFEqeLF3qVBkiTWvdQdY76Gfh+uxi2gBghmgzfzcdj79RQSLxylTq8RNB38sqVdkkSUSjmHFrxDzPHdlnO6CTJWevvj/Tdc4/7Q5vFRdlFBr0yAAwPb09rfg7XX4nl612mr/g5KBW/0bM2ETk2pVkIq1ZnYZL7aFcnPx0uuA3qrdxv+1798ggy307N5dO4vXC4jiuGrVhLh4oBKkJEvilzJ0ZBpKD1Vw7N6Q9qO/Qilgzl9R5OZTPyZfcSd2UdW/HVLP5lChX/d1gQ16YZ/3TbIlUULJUGbT5Ma3oT6lU6c8zV5fP3+BG5csiZLKrmMp+qHMbxxOK0CffAp5nQfn60hMi6Fn05fZ+vVWBuFtccff5z169eXS4Vp/PjxLF5cVIx87uup1AsuP9mzh/ov/4+rCeaIp4+PDykp1tHPlStX8swzzyBJEi+++CJz5sxBkiR27tzJ999/z9atW82RQjvo2rUrkydPZsCAASiVlWeCCGY1zLsJhL3brKyyN4BcnBxJP1L+iEZglwEkpxd95/7LEY0nn3ySTZvMwhxLv/6U0UMGltg3OyeXjgOGc/6ymYSdPXv2oW8C/tNQRTTsoDDEWDMslCsH/kAmK3txs3LDrzzz8lul9lGpVNSoUcNCPIqTkLCwsHLv8Px/RWZmJs2bN+fWrVs89dRT/PLLL/+IWoW/E8nJyTRp0oTExEQmTJjw0AvyIm9noS9FcrU0vDvxGf7asZURz79EYnws+7Zvsfvj3bJ6AAdff7rCJKMQn+84xjtb9lvuN+w1lPZPv1GQSyIrsWpakiT+nP0Kt6MOWLUPrFednwd1rjDZEEWJKb8fY/7xy1btnqF16DjpWwSZDKVKiUKlQCaTmaVtJXOBtj4vk4TzR0iPuUxm7A2MOg2CXI6Thy9e1evhU7MRfrWbIZTjWgWgzUpj0+uPIggyhszfj9rBEZlcoPjLH3vmIHu+moLS0YUnv96GUuWESRKRCwKG/DzWT3kEk6Fo5/oDNy962ynqfxCQJIm3M9M4pC9a6PSv4c/6R1qgN4mE/rSbtHzbWh2FTEabGoG0CPUnyMMVkyhxPSWd49GJnItPsel/N7ydHbkyY3yZReG307Pp+tUqbmdk2z3eztuVcWEBdPZxo5qDyuo6JkkStzQ6didnsuhWIhez7XseuAdF0H78FxayUYjclDvEndlH3Jm95KYUpQQp1E4ENGhPcJNu+EQ0QynI6FLH18oF+26YTEa+fm8il88cs2p/sl51vn20DdVcy36/b6RnM+HXw+yLTrRqHzlyJCtWrCjzGv7JJ5/w3nvvWe6vfvUZBrdvVubjlgSNTo/HqKkW8tOyZUuOHy9ygF+1ahWjRo1CFEUmTZrEvHnzbOYYExPDBx98wPLly/H19WX48OH4+/szYMCAezLky83NJSEhoUwSkZ1t//NkD46OjgQGBhIYGEi1atXYs2ePjaDKb9/P4tHO7co81/7jp+k+9mWrtpo1a3L9+vUSRvx7ERsbS/Xq1RFFkRaNGxC5fX2Zn9Etf+5m4LNmKeRJkybx/fff/x1T/degimjYwZgxY1i+3Ky1/+fqH+nVuexiqY79h3P4RBSCILBo0SLy8vK4ceMG169f58aNG9y8ebNUZQJBEAgNDbUiH8VvXVwqXtD4X0ShgZ3RaGT+/PmWIkFRFPnrr784dOgQJ0+eJD4+HpPJhLu7O40bN6ZVq1Y8+uij/4koyK5du+jduzeSJLF+/XoGDRr00OZyJj6HHJ2x7I52MOHJXlw8fZJPFqygc+9+JMTeZt2S+WxYsRixIMSvkMk49c4Y6lcrX6GrPRhNIh2/XMmJ2+aFjtLRmZFfb0PpULRIEgQBZDKzEUCx35S8jBTWvfUUeo11LUrrIB+WDOhIXV+Pcs0hNiuP5389xI4b1kpBMoWSR6YtwS2wBoZ8AwadwRxZkMsRFHIyb1/m2t61xJ/5y6pexB5cfIOo1fVJanV7CoWq9IVw8tUodn0+ERffIJ6a/WuBfbpkRTQkUWTz1CfJSbpDm9HTqN19EHK5DJlM4Pz2lUSuLFLYa6ty4EsP77+V+KeYTAxLTSS/IJdMJsD1p7sR4uLIwO0n2Bpj6zpfEbj4BqPJTEY06K3aR7dtyI+jHi1xXKYmn/ZfrOBqcobNsSbuznzXtCbNPct3PZckid3JmUw5c5MYO+lI3jUa0e65WcjktukrkiSRHX+D2DN7iT+zD21WEZFSObsT1Lgz/fsPpH7DFiVupv2+bgkbln5tua+QCSx8ogOjmtSs0HstihKzD59n2q6TVu0///wzI0aUrAAH8Mcff9C3b1/L/XE92vLDxHv3q9p28gL9PyuKkBTfsFm7di0jRoxAFEWef/555s+fX+Jrs3jxYsaPH0+/fv1K9JTIzc0tM/oQHx9PTk75at0AnJycrAhESbdubtaSxTNmzLDxYurepjk7Fn9d5nv5xAtT2bbfWrDj9ddf58svvyz3vP8t+P777y3+KYu+/Jhxw58qc4zRaKRmu17ciU/Az8+PpKSkBz3NfxWqiIYdREZG0qaNWc6tTbMm7F3/Ew4OJUcbirPZvn37sn37dps+JpOJ2NhYK/JReHvjxg1y71LVuRt+fn425KPw/97ef+8P/MPGV199xeuvv45arebQoUMcOHCAefPmlbm74uzszNNPP83UqVP/9frXU6dOZdasWXh4eHDmzBlCQ0MfyjwuJeeSlndv0n6DOjQkOSGeHzbtpH4TsxnW2at3eKlfC0STmbwMaVGXVc+WT52mNGw6fZXBizZb7ncZN53anR4robdQIClrrqCNPrGPnd+8Uazw1gy1XMbzLeswoWWdEglHTGYuC09cYf7xy2TbUcNqM+otwjv0t9RdmEwiOTka8nJyubVnBXeObbEqtC4PXP1DaTv2fXwjSi5AvX5gC5HL/0dQ4/b0erOg0FaSbNKzLu1YxfGfZ+MeWIMBs9Yjl8uQRJENbwwkO7Eo/WuOpw8tipEbvSRxw2jgutFAjigiYZa7ralQEqFU4iBUjrL6rOwMftUWFd++0yKCma1r89Hxa3x44t4UcQS5gtpdB9Ji6BROrP6aq3s32PSZPag7U7rbFwZ49qft/HTsvE37tDrBvFUnGGU5o07FkWs0MfXcLZbZIU91e4+hdvfSF+uSKJJ++xJxZ/YSf3Y/+ryi1BpPH39adX6E1l36Uj2ivuW3JOHOTWa+OBhjAdESgDWDuzKoQViF51+I745e5NViIgienp5cvHixVLWerKwsAgICLGk6TmoVt+ZPx9uO6lN58Nj/FvJHVJH08dq1axkyZAgbNmxg6NChmEwmnn32WRYtWlQiycjJyWHGjBl89dVXdOrUif79+9slEGX9rheHs7NzmeQhMDAQV1fXCv3e600iqXl6zl+N5tG2DW0UlGa88CzvTRxd4jm/WraGN7+03aGvSEH/vwkffPABH374IQBnd/9Kw7q1yzVu0HMvsen3nQiCgNFoLFcmzP8XVBGNEtCxY0eLY2iPju1Y8d3nBPhZqwmIosiaLdt47o33yM837zbt2LGDXr16VeixJEkiOTnZhnwU/r8s/wg3Nzcb8lF4GxgY+J/7wEuSxOOPP862bdtQq9XodObXvo6/FwOa1KZl9QDCfTxQyGQk5+YRdTuJvVdv88fFW0iShLOzM59//jkTJ0781742BoOBjh07EhkZSceOHdm7d+9DKcq727SvvBBFke51/DGZTGw8fB7fgEBuxGdxYPdOfvzgeUu/318cQq96Yfc9T6NJJOSd7y0FvnU696fzs+Vxmzcb5F07tJW/lnxiQzYKEeHlSvNq3lT3cEEQBOKzNZxKSONSSmaJtdshzTrTfcpskMCgN2AwmDCaRPKz0zm04E2y44qIs6eTA8+0bUiPOtVpHuKPr6sTeqOJK0npHI9JYNXxixy4XpQmIwgyWo54g1rdbKNdMpmM0+u/4/z2n6jXezhtRr1Z8FRtiYZek8P6Vx/FmK+hz7T5BDVqS+LlKLZ/+KylT6hcwSpvf0zAQV0+m7S5ROl1lBR/kQENlSoGODrTzcEJ1X1sklw16BmbXrT4DnRWEz2qOz9fjWfsnsKaAoFOL39F4oWjJJw7RG5y2ZKsgiDDJ6IRAXWac2XPepuIFsDkzs34X/8uVopW287foP98W2LyfbOaPFP9/uoKJEli5qXbfHnV2lVckCvo8tI8c51NOSCaTKTeiCLl4gFizx5ApylaDPsHVqdVl0do3eVRtq5eQOT+ItnXl9vW56tH7k+EQ5Ikhv6yj42XYixtb775Jp9//nmp45599lmWLi2SUB7VpSVLXxxZ4cffEnmOQV8ssdz38/Pjzp07bNu2jcGDB2MymRgwYAAvvvgiiYmJJUYg8vJKl/UuDhcXl3ITiMqCKEmkawwk5+rJ0BosexXvTXqG/X/aRl96tmvJG2OH06OtObolSRL7j59m9rI1bP/riE3//2rRc3p6Oi+99JLFrPnMri00qleGEmABnhz3Ipv/2FVFNOygimiUgDt37tC2bVvi482pDkqlkkGP9uKxXt1wdHDg2q0Yfly1jmu3ii6Y7733Hh999FGlzyUrK6tEElKSLF8hHBwcCA8Pt0tCqlevXunFan8Xli5dyrPPmhc7Dar58OWg7vSsW73UnZ7otCw+3n6YZUfPATBixAiWLVv2r30Nbt68SdOmTcnJyWH69Ok2YfG/A3FZ+dxK15bd8S6kpSQxoE09ZDIZuy4ncjs5j8T0PPatX8wfP30DmAMKGV++UmFp0pLQf/4Gtp03+xd4h9bmyQ9X2u8oSUgmE5JJtIomxJw5yIGfPkWXV/48aXuQyRWIJiOCIKP7q18R1LADoiSi1xvJzUjjwJwp5CTeAsypY+/2bccbPVvjqCr9c3rydiITfv6D07FFC+9Wo96mVpcnAfPrqVDIEWQydn/9GndO7aPNM29Tr9dQy/O+m2hISJz4+Qsu7VhLSPPO9Hz9W878upRTa+dY+rzg4k6IXMHXOZkklZHedTc8ZTImu7jT18HpnqOy49KSuFzMxf3G0904kphhKQgPqN+WzlO+shzXa3LJjr+JIV+DIJOhdvHA1T+UzDtXSTh3mITzh8mMLV/ueainGy90bc7TrRvg6eRAnRkLuZNhTUqm1wvlrTqV46EgSRKTo26w4rZ1ZMMrrCEdJ35VwihbCAL4uDnipJDIvBXFxQPbORe5H73OfnFvmIcLZycPwEl1/5sZybla6n23kayCCJ+XlxexsbE4OjqWOObMmTM0b97cqobr++cH83yv9uV+3EuxSXSd/h1pxeRnGzZsiCRJXLhwoZSR9qFUKjEYDISHh9O2bVu7BKJatWqVSiDKQna+keRcPSl5ekx21CNuXb3E+AE90JVQxO3t4U6wvy/xKalWUrbFoVQqOXz4MC1bVo7U98OC0Wjk/PnzHD161PJ35coVqz7zP5vBhFHDyjyXwWCgRtsexCcmExAQQEJCwoOa9r8SVUSjFNy4cYO+ffuWy5Rm5syZvP/++397CpNWq+XWrVt2U7Kio6NtnECLQy6XExoaajclq2bNmg9V0ag0bN26lQEDBmAymXi1Rys+frwTamX5fwD/uHCTUcu2kqHJZ9SoUSxfvvxfm3q2evVqRowYgUwmY8+ePXTpUj5FnMqAJEmcvXqTyEvRGI0G1A6OBIaE4eJWtvzrlfNneO6Jbnj7BTB74xES080//pu+n8mxP9YBUNPHgyszny/tNBXCu1v+YtaOowCond14Zt6uooOiiGQSze7WpVwStdnpHFo1m5jTf93THKrVa0nn8e9zessSruzfgtLBmV7TFuERVBNJkvhr7lvEnTGfO8DNmV8nDaJ5aPlNoAwmE29s2Mu8/acAs9Rp72mL8avZELmioAYF2PT2ILLib9H7re8JbNTWPLgY0ZAAQTBLO2YnRLPhjYEgCAz8fDOn1s0lJrJI5rS1Sk2kvuJRreJor3JgmpsnXvegWPVNTibriu3Kr+vTnLR8AxP3mzcUWo+dTljbR4qNEEr9vitVcvLTk7hz+iCxZw6QePGEVdF7SfB2diQtz5p0t/J0YVfnRhV2RS8N2QYjbfac5o7Wunak80vz8AiqVa5zqJVy3JxVKOUywvzdUQgSDnoNp4/uIXLf75w7cdAqevdln1a80q5BpT2H1/+I5NujRepeq1evZtiwkhd0Wq2W1q1bc/68dUratCd78f5TvVGVcf3/7cR5xn+/htScsiMRbm5uZUYgqlWrxrBhw9i2bdtD983KN5hIztOTnKsn31C6MEeohwMn9v7O4MGDS1TNKgsrV65k5MiKR5MeNhITE61IxfHjx9FobIUWatSoQXR0NJIk0bheHaJ2bi5zfbBx+w6eGm8uln/ppZeYM2dOqf3/v+G/J4BciahZsyZRUVH89NNPzJs3z2bXw8HBgWHDhvHiiy/SokWLhzJHR0dH6tevb1fpwmg0cvv27RKjIYUk5datW+zcaauPXq1atRLrQjw9Pf+Op2eDhIQERo0ahclk4pP+nXm7d9sKn+ORBuHsmjKMnt+uYcWKFXTu3Plfa7A4fPhwduzYwbJly3j66ac5ffr0A3Wlz8vLY9WqVWzcuJETJ07YTesLrh5Og+ateGTgUFp06GL3Ip2aZC7MdvX0sZAMAGMxwQTHStg9LY7iu7FGvY6c5Hgc3TyRUf4Qt6ObFz0nfkLSrfNc2r+JG8d2lllDIQgyQpt2pF73QYQ064ggCLQbM42spFgSL59k/5zX6f3OjyRdPmEhGZ5ODuyaMoy6ARV7L5VyOd8M7oEoScz/KwpJNHF02Uc88dEqEMyLeFE0kZN0BwC3ara1PWaSYd6IEAQB98AaBDVuT9zZw1zZ/Qvp0Zes+t9NMhwVcoY1CqdXzUCaV/Mm1N2cS5+Qq+VUfBp7byWw8uwNq5qVw/p8JmQkM8fTl2p2CptLQ12FdaTnVEoWOcXkYb3D6pmN6kpIe7sboknE0dOfut0H0bDXYCSjjtjzkRxfO5eMUiIdd5MMAZjXLKJSSQaAm1LB7MbhDDlmrV4WfXQrTQe9WsIoa6gLDPoMJhGjSQS5DNROtO32GG27PcY30ydx/oTZM0IhExjdNKJSn8P4FrWtiMbBgwctREOSJDIzMy1pSmfPnmX27NmW7ILi+HTjTjYdO8OUfl0Y3L4ZHs5FURG9wcj+izf4/o+D/HbCmqDI5XK6du3Kvn37MJlMdOvWje+//56QkBCcnctX+1F47fPxuXehinuFUZRIzdOTkqsnK79sMQ6FTKCOrzOeTkpCn3ySdevWMXLkyArJ0yqVSpYtW1Zm8f4/ATqdjqioKCtiERMTY9PPzc2NNm3a0LZtW9q2bUvr1q3x8fFhyJAhrFu3jrOXrrBw5dpSoxoZmVm8N+sby/1JkyY9iKf0r0ZVRKOckCSJkydPcuvWLXQ6HZ6enrRr1w4vr/szDnpYkCSJhIQEuyTk+vXrdg2MisPT07PEupCAgIAHFiHo378/v/76K4Ob12H1uP73da7fzl1n4IKNuLq6cvHiRYKDKye94e9Gbm4uzZs359q1awwYMICNGzdW+uufk5PDhx9+yMKFCysksRhSI4JnXniNPgOHWs1p86plzH7vNeq17sbo94q8ajYv+Jij29cAEOzhSvQnlXfRfnPjXr7efdyqTRBkOLp54ezpi7OnX7E/X5w9fHH28sfJ3dtW1UcmQ6ZSkpkQw6YPRmEskFl18w/B2dMXpaMzXsER+ITXI6BWExydPUAQkAQBEwKiJKHLzWL7x8+SnXgbrxr10WakoM00KwOtGPMYw1tVXCazEDqDkdazfuJCgnkx1Orpt6nT4ynkMhk5KbFsfKM/MqWKUYsPF5PENatOCTIBeTEpYUmUuH3qALu/ehmFozNGrf1dYZkg8Fr7BrzdsRGejqVLdefqDHx37BIf7T9tJY8cKJezwNOvQl4cN40GRqUVqbwMqOFPslbP4cQMFGpHhs7fh0wuh0Kvw4KwjSiZHdOl4iljkoRRb0DtoEIml+Gokls+t3qthuUTuiCZypce1tvfg43t7v09LA2iJNF8VxTX84oWinKlmkemb7DyyigJPu4OludVzcsZFwcVggCeMgmZAG+O6kFGmjk9q1mAF8cn3r8gQ3FIkkS1L9ZYjP28vLyoV6+epQ7iXv0ZIgJ88HN3RaPTcykuCZ3BdhHu5OTE9OnT+eCDD9DpdAwaNIjVq1dXOIU2IiKCGzducODAATp27HhP860IREkiS2skOU9PWp7BxpukJLio5dT1c8FBYb2hcu7cOd599122bt1aqp+QIAj06dOHjz/++KFtqJYGSZK4ffs2R48e5ciRIxw9epSoqCj0euuInyAINGzY0EIq2rZtS926de3WUhw7doz27dsjiiKCIPDJ1Fd56dmncb4ry+P0+UuMeWUqZy+ZU64ef/xxfv311wf3ZP+lqIpolBOCINCyZct/fV5iIQRBsEjkderUyeZ4enq6TQSk8DYhIYGMjAyOHz9upT9eCCcnJ8LDw22iIREREYSEhNxz0fLJkyf59ddf8XZ2ZM6QihXc28PjjSIY3rIeq09c4uuvv2b27NllD/oHwsXFhTVr1tC2bVs2b95scVGvLOzZs4dnn33W7o5QWbhz6zqfvDGZ3b9t5M3/fY1ftSAk4Np1cw2Cm5e1wIJvUJjl/7GZOaTlavF2KTl3uyI4fadoMSpTKM2pQiYjmqxUNFmppNy1U2+BIODk5mVDRJTOrpz7c1UByTDLwzq4etD37bk28rImTT55ufnoTBJObk7IFXLULu70eOVrtn/0LOm3inZ3u9UOZVjLeqU+l+ScPG6nZ6MzmlDIZHg4qanp42nxGlErFcwb1puuX5uLGq/t3UBEl4GIgkh67E3ATIpkMllBNpWAKJkVfos7k4smEVGUCGzUDlf/UHKSbt89FQCCXJ34ZWg32gT72j1+N1zUSqZ1bswTdUMYsnYvV9LM5DXeZOKT7HRme/iUmyx73rVQyNAZiEzOBMArrB4ymbwgTGN+l4SC53d3JEsURYx6a6djUQJ5wTTiL0QimUw4e/njE96Q26f2mlPtSsC4sPKnvFUUMkFgXI0App2PtrSZDDriL58loHYTlOqSF81Khczqtc3Xm3BxMAfmNBIo8jUWkgHQtFrlR0gFQaBZNW92Fsg9p6enW8RXCuHo6IhWa44SeXt7M2TIEOrWrYubmxs///wzu3btsjnv9cRUrieWLJ5Sr149XnrpJV577TV0Oh0DBw68J5IBf19EI09vMtdd5Oor7FkU4Kom3NsRmZ3vUqNGjfj111+JiYlh4cKFbNiwgTt37qDRaHB0dCQ4OJj+/fszceLEf5S6VF5eHidOnLCKViQmJtr08/HxoV27dhZS0bJlS9zKkdYL0KZNG+bOncvkyZORJIl3Pv2KWfMWMWLg49QOD0Oj1bJt1z4On4iyjKlXr57FFqEK1qgiGlWwCy8vL7y8vGjVqpXNsby8PG7evGmXhMTExKDRaDh//rxNPi2AQqEgLCzMbkpWeHg4Dg4l6//Pnz8fgAmdmuJbDqOo8uCdvu1ZfeISS5cu5aOPPvrH1qWUhebNmzNr1ixee+01Xn31VTp27Fgp7qRff/01r732WonHQ9ycqevrjlouJzNfz9mkdLsyrkf37+LZx7vyxZJfUHiHER9nVs5x8/Kz6hdU03oHeO/VGJ5qXve+n0duvp7jMUUFevW6DKDNoBfJz80kNyOZPMtfCpqMFHIzktFkmu+byUgamqy0kskIEggCydfPsea1/tRo1QMXnwCcvfxx9vBF5uCBSXBCJlegzdWiLtjxd/IKpMvkz9jxxWQKNW5f7t7SZpGdnqdlZeQF9l29zcnbicRl2spmOioVNAn2o3VYNYa3qk+HmkE0D/Hn1J0kMuOuk3H7Ct5hdcktIAtu/qFIoohQYA4oK5DzLXw6pmLO6YJMRt1eQzm+8gubxw1ydWLfs32p4VnxotcGfp7sHduXbkt/t5CNY3od2/I1POZYvhQW+V2OizE5WowFIYoabfuUOV4AjCYTkiiZIx9y88ugUCrM/ykgY7dPm40ba7TqRoshr5KZFM+5P9YSf3Y/+ZkJNufs4vtgPXu62Tn/9T3LiDsVAIjIZIBkQjQZEU1GJJMJUTQiSCKIxqJ20YQgmjCZjJiMRkSj9U6wt9ODMZL1KWZ6KJPJWLt2LYGBgbi4uPD+++9bdobHjRvH3LlzrX4bxowZw+bNmxk9enSFIqxjxozh9ddfJz8/nyeeeII1a9bcE8kwGAwW9+0HQTT0JpGUXHPdRZ6+YgILYCaiNb0d8Xct+72rXr06n3zyCZ988glgluIvj1v43wFRFLl27ZoVqTh79qxNfYlCoaBp06ZWxKJGjRr3FdmfNGkSDg4OTJw4Eb1eT1Z2DvOXr7Lbt0OHDmzevPmhpZT/01FFNKpQYTg7O9OoUSO7C1m9Xk9MTIzdlKybN2+i0+ks6Vl3QxAEgoKC7KZkhYeHs3HjRgCe69Ck0p5LvQBvOtcK4a9rd9i7dy/9+vWrtHP/3XjllVfYtWsX27dvZ/jw4URGRt4XcZo9ezZvvPGGTXttbzcmtqrL0IY18L8r2iCKEhdSMll66irLTl+3Ih1Z6WlMGdmf5z5eQk66OUXIzfsuohHRAAdnV/LzzMo9Pxw4XSlEY9Xxi+QWm0tg/VYIMnPalKObF77V7T+GJIrk52aSl5FCbkYSmowUkm9d5NbJvYgmg9lYD8Hs+1GwKNdkpHBhxxrbkwkCahdPHN19cfb2N6dlefji4OGLXKXCpNfh6qDi0QbhliHn41P4ZvcJ1py8RL6dNJDi0BqMHL0Vz9Fb8czZe5KWoQFE+HpyqiCSkx59Af+a9YvqMwJCkUQJvdGATCFHLpchSAACRqPt4qZmx8c4+ct3iMXcuAVg9eCu90QyCuHn4siGYd1pseBXdAU7tvNysujp4Fguvw3jXWkf8QXpRDK5gqyEGM5uWYxC7WBOXTMZEY1Fi2zRaMRk1Fu3mYyIRgNIJiTRZD5mNJB8zSyXG3P6IHHnIzEZjZiMBoz5WTZzquPqiEsFneMrirquTjjIZOQXW3TlJFwlJ+FqpT6O0Y56UeWct2jeKpWKp556ikuXLjFw4ECuXLmCSqVi7ty5jB8/3u749u3bW4p5R44cSUxMDOfPnycvLw+lUkl4eDgtWrSgR48eHDx4kIULFzJt2jREUaRfv3788ssvqFT3pmiXlpYGmH+zKmtxaRILJGnz9GRqDCXKYpcFB6WMur7OuKjvbXn3MElGRkYGkZGRFlJx7NgxMjJsjS+Dg4OtUqCaN29eqmrZvWLs2LH06tWLRYsWsXDhQqvIiSAI9O3bl8mTJ/PII4/8Y8jZPxFVRKMKlQqVSkWtWrWoVctW/UQUReLi4kpMycrOziY2NpbY2Fj27dtn9/zhPh6EepUv/FledI4wE42TJ0/+q4mGIAgsXbqUJk2acOHCBV577TWL421FsW3bNhuSoZbLmNm9Oa+2q4+8BI1wmUygkb8nX/Vtw7TOTXhp21HWX4y2HNfm5bLsw8k4uph3Y++OaChVapp3f4LDv/0MwN6rt9lx6Ra965XPI8AesrU6PvvzqOW+s6cfoU07grF0hSnAioz4VK9DzJmDRG+cj2gy4FujPn1e/QoHFw+0uZloslO5dnA75/8w73r5hDdArlSRl56MJiMZ0WhAl5OOLiedzNgrdh+vWYg/cpkMncHIx38c4fMdR+3KVJYHJ24nWtzQARIvnSSwfivSYsxFxIIgJ/7KKQRJLFhQGzAYjRh1OpBMIIqIJgOiybyglkxGnL38yUksSqGb0q4B7UP9bB67oqjr68GMbs0sztHZksiufG25ohp3S+rqC2swTEYu77C/A3k/yEkq24ejdiWl+5UGhUygposDF7KLlHOcvIMIatoTmVyBTK403yoUKNVqVI4OKNQqnBwdkCsKjhX8ebg6oVarEUUj+1Z+x/WTRapqN9LvT865JFxPKzqvp6cnGzduZPTo0eTm5hIUFMSGDRssxrn2sGLFCoxGI61atWLlyhKkqgvg7OzMwoULEUWRVq1asX79etTqe4/UFKZNeXl53fcCM6tAkja1BEnaisDbSUktX2cUsnvfyf+7YDQauXDhglW04vLlyzb9HBwcaNmypYVUtGnT5m+tpwwODmbmzJm89957XL58mYyMDNRqNdWrVy/VaLIKRagiGlX42yCTyQgJCSEkJISuXbtaHZMkibS0NBvyUXibnGzOGW4afP+LmrvRLMRspHX27NlKP/ffDT8/P1asWEHv3r354Ycf6NWrF4MG2Zq2lYaMjAybXUQ/Zwe2P92rQvnavs4OrBnSle8jL/Hy9mOW9pyMVDQ55kWGu7ft+9mu7zCObFttyX+f8PMfnJw2Bi/nii/ekrPzGPPTNm5nFC1qAmo3JTc9CRcPPzCV/4f98oFfObxqNpIkEtywLT1f/Aylgzli5OTujbO3Hz5h9VE4unJ60w+kRV+mx6tfE9SoHZIokpWYREbCHbSZKeRnp2LQZKDNSiE7IZqMO+Zd6Fq+nlxMSGXEkl85H1+6UWdFcfvEbm6f2G25f27rEs5tXVLKiNKhkst4u+P9p+cV4sU29fj84Dky8s2pO5s0ueUiGpcNeps2QZChcHAyRycM+nIrTiHIUDo6o3J0QeXshqOrO2pXD3KSYkm9dRHvsDo0H/g8akcXZAoFoihwYMnHZMXftDqNg7zsSExlwOEuwu/sFUC9XiVLj7q4OODsooa70s1cHJXIDVpWfzSJuCtnrI6dik+rtPkWQmc0cb6gjgbMaoKF16mIiAjmzp1L8+bNSxwvSRI//vgjQJmKgUeOHGH06NGW+yqV6r5IBtx/fUZqZjaXbt4hKVuDoHDAJ6DafREWAQj1dCTYXf2PlWpPSkqykZe1Z3wYERFhFa1o3LjxP8LrSqlUVko68v9HVBGNKvwjIAgCPj4++Pj40LatrWTtDz/8wMSJE/G+h8VmWfByNuf+5uTYuv/+G9GzZ0/eeustZs2axXPPPUerVq0IDbWVMS0J06ZNszIcclYq+GNUbxoH3JvC2uTW9cg3mnhrxwlLm6kgD9zVy5Zo+AbXoH2/ERz6zbxLeScjh17frmXXK8PwdCq5hqcQV5PS+eHgaTafvkqMnd3YG8d2cOPYDtTObgTVa0XdLgMIiGhS4g+0JEmc+u1HTm83F/rVbt+PDiPfsC74FgSMRhGTJNH4iXHkJMdy49A29s+bxiPvLsIrpBYuPr5IMgeL14FcKcfByYHUm+fZ+cUEwCyR2uWrVWRo7KvuNHJzom+AF808nKnv5oSLQo5JkojR6IjKzONoejZbE9Itu/p3Q5ArkUzmFDInL38USjUyhRJBJkeQKxDk8oKdcDkyuQKhcNdboQRk3DmxE6kggjCofhi+zmW/H+WFo1LBM00jLLKnl40GckQR1zIcdu0Rjd5T5+NXx6yQI0kSBk2uueYmLYm89GS0maloM5PRZKaY/5+RgjY7DSQRgyYHgyaHvLQE7k7aSIu+ws6vX0fp6IyTpx+O7t5kF4vwFEJ3jx4FFcXdj5OXGseNA+txdPfD0cMXRw8/1C6eFmUxBSJivt6c8lfMeyJfm8/2L6fYkAyAuBwNx+NSaRVUebUI26/GYijhNbp+/TqPPPIIjo6OtGrVivbt29OuXTvatWuHr69ZbODIkSNcunQJJyenUv03jh07Rp8+fcjNzaVDhw6cOHGCQ4cOsXfvXrp3737P868o0RBFkT/+3MHylT9z4vhxbl2/aqX05ODoRET9hjRp2Y5HB48kNLz8csJKuYw6vk54OD78xXghdDodp0+ftiIW0dHRNv1cXV2t5GXbtGnzUOSCq/BgUUU0qvCvQKG7qqGCqhvlQWGu8K5du6hduzbBwcGWv6CgIKv7vr6+duXw/mn46KOP2Lt3L5GRkYwcOZK9e/eWS+0rNTWVpUuXWrV91qvlPZOMQrzargF/Xo9j980iAiMIAk6u5hQqSZKIvniK4zvWE33xFOlJcVbjz8QlE/DWd7QLD+L1Xq15tEG4TfrW5cQ0Xt+whz8v3irXnHR52dw8sZubJ3bjGRhOqycnEdLQmuSKJiOHfv6Sq4e3AdCs3xiaPfYsgiAgSVJBIbGI0SgiK8jJFwSBdmPfJS8tkcTLJ9n99Sv0e38Zju4+yBVyTAX1DyaDCdEkonR0sTzetvM37H7G+wV48lrtYFp7utglRIGOatp5uzG5ZjVSdAZ+ikniy6tx5NxVa1FIMlROrjz26WZkMgHRJFoWoiXt/Ot0BuKvXuJ25B+Wtp7h1Up9fe8FPWsGWvkrXDXqaaEqmcyIksSpu8z0mg1+gcCGrRFFCZNJBEFA6eyKs9oJB+8QfEv4/oomI/nZ6WgzzTLD+Zkp5GelkpsSS8xxcyRIoXbCqNNg0OaRpb1FVrz9z9q13HuTZ60ITJLEzTzrx9FkJHJh20KrNkGuwNHdB0d3Xzz8quHi6WcWKfD0w803EGffQCK3LSPmvK2CYCHmR16i1UBbdcJ7xfzj1ikyDg4OvPnmmzg4OHD48GGOHDlCeno6f/31F3/9VZTGVatWLdq3b28x0R08eHCJSkLHjx+nd+/e5OTk0LVrV7Zt28bUqVP57rvv+OCDD+jWrds97/6Xl2iYRJF5Pyxm9uezuB19s8R++VoN509Gcv5kJD//8C2tOnZlwpvTqdOoaannd1UrqOvnjFrx8H6TisvLFv6dOnXKrrxsgwYNbORlq2ob/vuoIhpV+FcgJCQEgKvJ6ZV+7mtJ5n3LQoWL0pzglUqlhXzcTUIK/wICAu5ZwreyoFQqWbVqFc2aNePgwYN8/PHHzJgxo8xxS5YssfqBaBnozYSWde57PoIgsODx9tSZs9Gi/y5JEqlx0eSkJ7J18RfER5dexGqSJA7eiOXgjVj8XJ345InOjGnXCFGS+GbPCab/dgCdnSLmQsgFAVMJNRkZ8TfZMfdNarV/lDZPvYjayRWDTsueRdOJPX8UQZDRfsTr1O1U5CcgmiT0RiMmUUJxl7mgXKGk60ufs/2jZ8lOjGH3N6/xyLQfUKgUFqIBoM/X4+oXjEyhNNdI3EUyvFQKvmoczqAg73IvinzVSl6vHcyQYF9eiLrOnhTbYmWls3lxpsnLRxQlZDIBpVKJXGH7GAa9kbxcHam3rOtKmgdW/s5ji7tS864ZDKUSjUi9jvhivhaOHj40HWBOpZHJBARkGIwmDHpj0Q5ygdRtISRJIi81Hm1WKqJBb67L8fClWp3mqFzcuXVwCzHHd+Mb0Zje0xah1+ZhyE5Dk5lC3NnDXPhjJTK5EtFUJDZwOVtDntGE8wMsCL+So0Vz1+fFp2Yz1C7uaDKTyc80R2kkkxFNeiKa9ETSbp0r17k/GT+Mhb/tIqZAKvbnszd5oU09WlTCe77t6h323CracHBwcOD48eM0bNjQ0iaKIlevXuXIkSMcPnyYw4cPc/HiRZvr87p160hISKB9+/a0b9+eNm3a4ObmxqlTp+jduzfZ2dl07tyZrVu34uTkxNSpU1m4cCEHDx5k9+7d9OzZ856eQ1lEI1dnJOrSdV57cSInDu2v8PmPH9zHqSMHGDFhCmNffgulnaL1QDc1YV72pWsfJPLy8jh58qQVsSgeAS9EYXZC4V+rVq3KLS9bhf8WqohGFf4VaNasGYIgcDo2GaNJtPgFVAZOFiuYBVCr1YSEhODp6YlSqUSr1ZKYmEhiYiIGg4Ho6Gi7YeBCyGQyAgIC7JKQ4iTlfvOEy0LNmjVZsGABI0eO5KOPPqJ79+507ty51DFr1661uv9im/rIKqmwsIanK4/XCWHL5SIvhvXfTCPmqq0McllIztEw/uc/eHX9bhQyGZlanU2fXiE+9K/hT0s/Dxp6uaCWyzGJEtez8jiVksWOO6msv5FAfrHF2rXD20m6dpau4z7g8OqvSI25hFyppttzM6jexGzKJUmg1RnRS0ZUDuYFgD0SoHZ2o+dr35h9MmIu89eC9+g44X9WfUxGExJKlA7O6HIzrY7VdHbgtw71CS1Hupg9hDip2dK+Pu+cj+a7G9YLAW16MmnxcahdzZEqUZQwGvMRBBlKtQJlwQLZaDCRm6cjPT0Xo846nzrYrfKloP1cHFHKZJa0mrwyais2aqxlfpv0t87Xl6z/KWgTyYi5SuzJPaRHXyT99hUMGvtpky6+QZgKnM8D6rVEkkDp4Iza0Rn3wDAy7pgXve5B4WTcLiJiInAwNZs+AQ9O7nKfHQJZp9czeIc1KJqHyYQux0yK0Kajz04hN90s5ZybYU4j0+VZn6d/x1a8NbI/CoWct+ebRRlMksS4zQc5Mv4xHJX3vmxI0+Qz6bcjVm1z5861IhlgvobWrVuXunXrMnbsWMBcO3b06FHmzp3L9u3bEQQBjUbDjh072LFjB2D+HkZERBATE4Ner6d58+Zs3brV4vYdGBjIhAkTmDNnDjNmzKBHjx73FNWwRzT0RpGUPD1JuXpOHj/Om88OISvj3jfGTCYTK77/inMnj/HZwp9xdjUv0mWCQG1fJ3yc700xqyKQJMmuvKzpLtPKQnnZ4sQiPDz8H1svUoW/F1XO4FX416BFixacOnWKTRMG8nhjW1Wre0G+wUjYe/NJzdXSuXNnzp07ZyOnJ5PJaNq0Ke3bt6d+/foEBgai0+ksCllxcXGW/8fHx2M0li5DWghfX99S07SCgoJwcXEp+0RlYOzYsSxbtozg4GDOnDlTopt9fn4+rq6ulvmr5DLSp47A4T4WFndj86UYnlq7t9LOZw/DIqoxvVVtanmUXUiclq9n7tloZkXdwFCsrkGQyZFEE2pnd3q/MAu/cPPiTW80kas1YDJJKJQK1AUeAyoHlWWXXJIovq4l+foZdnw+GdGop06PIUT0es4c1ZBALpeRFX2GgwvfsppXkKOK3Z0aEVwJHgaSJPHa2VssumVNqP0bdqTFmJnF+hWtyQWZgEwuw6g3kpGRi9FoIuX0n9zZVZSWk/L28DIdwO8Fjh/+ZCEazzq7Ms7Fvh/FJYOe8enJlpdaoXZk6NwdqJzM3xmTscgHREJCm6fh9vFd3Ni/kfRbFyo8L5lCSfXWvanVdRA+4Q2QCXDsp0+5tn8zEZ0Hcv2vTVb9+wV4srZt6caL9wpJkmi55zRXcrRW7YVpUg5uPji4eVtuHd298a8WiLOnH04e3iiUast5Nn44msyEohSwv+bNpH3DOugNRtpOeIezN4o2BvrWCmbdkK73dE3I1Orou3Inx+OKRA569uzJjh07KrQgbdOmDZGRkXz++ef06tXLEvE4cuQIN2/apif5+vpa6jzat29PUFAQDRo0ID8/nx07dtCrV8XNX59++ml+/vlnZn3+OWMmTSE5V0+W1ixJe+3iOV4a9hh5uaXX/Pm5OuGkUpKaq7GS3raHxi3bMnv5ejzdXKnn54yT6sFEyjIzM63kZY8ePWpXXjYoKMjKs+JByctW4b+BKqJRhX8NCh2ve9YN44+XhlTKOX86ep5nV2ynccu2fP/LdlxUMjJib3Lx1FGOHD7MwYMH7UYvwsPD6dixo+WvTp06yGQyTCYTycnJNgSk+F9cXBz5+eXL4fbw8CgxRauQjHh4eJT6Q52bm0vz5s25du0aAwYMYOPGjXb7nzhxwsqgsWWgD0eff6xc8ywv4rLzqP7VuhKPuzuqeaZNQ3rVC6NpsB+eTg7k6Q2cjUth39XbLDtyjvgsW7M6AA+VgsXdG9O/RsUlB8+mZTNm9xnOpRUtDgS5gp6vfI9nUE1MooRWZ0BvlECSkAC5UoazqxNI4FhGUfTtE7s5uOAdABr0f4HqrR9HLhcQEDgw/xUyYi5a9d/aoQFdK9HwTS+KdN53lvPFpFABOr22CNfAcAvJKPw1MBpNZKbnkpaejVKhwNXVkfTLB4je9o1lbNSk/jTyr9wd++RcLYFfFkXVXnJxZ5izrUeHXpIYl57EzWKkvk73QbQf9x6ShFV6GkDipRMcWfIRuSlxd5/qnhDasgctR77JgXlvk3L9DO2encG1/RtJvVGkXCcDTvVsRsQDkLrdlZTBgCMlmUeWDbWzG04ePqidXEm8VlQA3rhmKCd/nGW5PkRdvUW7ie9hLLaD3TbYl6UDO1HLu/xpMKfi0xiz6QAXUzItbUqlkpdeeonGjRsTEhJCaGgowcHBpZq2njt3jsaNG6NQKIiLi8PPr0hM4vz583Tp0oX09HSqVatGaGgoUVFRNrUCCoUCb29vkpKSqF27Nrt27bKk5pYHkiTRq88j7N65g3e/mMcjg4ZbjuXlZDPm0U4kxt2xO7ZzrRAmdGxK19qh+LuZN0JEUeJqcjq/nr3ODwei7ApYAAx+egyrly9BXkkRZpPJZCMve+mS7WfKwcGBFi1aWEUr/k552Sr8+1FFNKrwr0FOTg7Vq1cnIyODX57rz5PN7q92ID1PS+OPl5CYncfM736ke7+BlmMC4O6oxMdZiTY9icijRzh48CCHDh3izJkzNs6kXl5edOjQwUI8WrRoUWJqlCRJpKen2yUghf+/c+cOubn2F9R3w8nJqcQUrcK/27dv0759ewwGA99//z2TJk2yOc/GjRutpHDHNI1g8YCO5ZpDeSFJEi4fr7AYsxVCEOCV7q2Y0a8DzuqSUwIMJhPf7T3J9K0HbQzsOlXzYnf/Nvccrs/SGXh8+wmOJBbt4NXs/BS1eo9DbzDZGGjJ5TJc3Z0RZAIOpezsywRzSseF7T9xav1cBEFGq1EfEFC/HVnxN9g/x/q9GBfmz7dNa97TcygNZzJz6bz/rJWib3jHJ2g89E10Or0lEmMSRTLSc8jMyCM5KRMApVKOE1nc2TDNMvbH/h0Y3axyIouF+P1aLI//vMtyf46nj90ajYW5WSzPKyKFSkdnBsxaj5OHv9V305CvIWrdd1zZXTK5BZADIUolDoKACGSaTCSbSndkVrt4YNLrMOq1PPLuMrLib3Fk6UyrPh283fi9Y4NKzaPPM5pou+c0tzTW6YIdJs7G0c0XbXYa+dmp5Gelkp+TRn5WGobcNLQFdSUmOypdhXh1aD++mDzKqm357/sY95m1H4+jQs4bHRryfMs6VHMtOYXuZnoO8yIvMffYpRLro+6Gn58foaGhFvJR/Hbx4sX8+OOPDBo0iPXr11vGXLx4ka5du5KSkkLLli3ZuXMnHh4e6HQ6oqKiLFGPQ4cOWZmuFSIkJMRS59G+fXuaNGliI6mqNZhIztWTkqvn6Ue7cuX8aT5btJoOPYrc579491V+Xb3c5vwBbs7MH967zEi8zmDko98P8/mOY5ZatuL4888/6d27d5mvoT0kJSVx7NgxK3lZe78xNWvWtJGXvVdjwypUAaqIRhX+ZVixYgXPPPMMvi5ORE59hhDPeysuE0WJkUt/Zd2pK7Tq1I3Zy9aXuEAVBPBwMJMOb2cVmtwcjh49ysGDBzl48CBHjx5Fq7VOYVCr1bRu3dpCPNq1a1dhB9niBoYlRUfS08uXA6xSqXBxcSE9PR2ZTMaoUaNo1qyZFRnZv38/I0cWafBPblWXOf1spYbvB4dvJ9N5yXarNieVkg3PD6RXvbByn+d8fAp95/5CQpZ13cCP3RrzTN17323L1Blot+EQ17MKd/4Fmo/7EvdgW1IrCALuni7I5TJLrYa5veAPwaq+RZIkjiz7H9f2b0auVNNq3OfcOf4HcSd/t/RRCAKX+7QgwOHB/LCPPn6FDXFFvghylQOPz/oVpaMLOp0BXb6B9IwcNLk6Yu+kWPkZSpJIzvY3wWReqA5vFM6KQaXX/FQUb/x5nG+OFKU1/eEbaCNvuytfw4ysdCvi13H8B4R3fNxqvpqMFHZ9+QJZcfbVfhqoVQxwc6WJgwN1VCobT4pUo5ELOh1HNVo2ZueQWYpk7ZNf70Ihl/Pb+0+hzbL2nfi0YRgvRQSW8czLj1fO3GDxrSSrNs+QunR6YU6JY7xcHZDLzUppek0ueZkp5mL2S8c5v6sogvThc0N5Z9RAm/FLtu1h4peLEO+STVbIBLrVqEbLQB8a+nngqFSQqzdwNimDyNgUDsQk2RB0pVJplir39ub27dvcuXPHclvo9F0W/Pz8qFOnDqGhoTg5ObFmzRpycnKoW7cu27dvJywszO71XJIkYmJiOHz4MJ9//jlnztjK+QIWad02bdvRoHlrqjdojsK5KMI4uFMTEuPusGDDnzRoZo4CXzl3muf620rmRvh6sGvKcII9bSNzJWHLmWsMXbzFyj0dzB4Tly9fLlOpSa/X28jL3rplq5Dm6upK69atreRlCyWEq1CFykIV0ajCvwqSJPHkk0+yefNmavl58seLQ6juXbEUE5Mo8sKaHSw+dBYXN3eWbTuAf1D5FqeCAJ6OSnycVXg5KVHIBAwGA1FRURbicejQIYvBYHE0bNjQKt0qNDT0vovltFqtXRJSvC0pKYnyfM1lMpnVbvCoJjVZWomSlgDdlv7OgRjrRdKvkwbxaMOK7+Cfj0+h3ecr0BaLbAQ5O3BtZFeU9yEWcDA+ne5bjloWSN61W9N4+HS7fT28XFEo5ajVSgRBKPgr1kEyS7Caax8kjAYj+757jcQLx1C5eCFJIoa8TEv3J4O8+anV/at8lYSDqVk8ctC6PqHDpE8JatoFSYLsbA3paTncuJaA0Y6Cl+bYDxiTzMX7KrmMmNeGVJqXhtZgJHT2LxbDvroKJT96+1v12Z2vYWZWOsVn5ujhw1Nf/Ypc6WCWswXy0hLZ8dkEu6lSfVycec7Tg0bq8pub6USR33PzmJeezm2DbQ1WWPvHafP0W8Sd/ouDC9+1OiYAP7asxZDg+1/AfXEllpmXblu1CTIZnV74zuLPcjfkcgEvV/vvUdLN82z9vCii9tqwx/h80tN2++49dYHxsxYQnZhyj7OHRo0asWzZMrtmfIWR3rvJR+Ht5cuXSUsrn3mgi4tLiVGRwhStzMxMwsPD0Wq1zJo1C4PBYFG5sleXEFIjggbNW9GoeSvmfPQuunwtq/ecIDgsHIBP3nyBPzasthrjoFRwatoYavtXXB782z0neH3DHpv2rVu30q9fP8t9SZK4c+eOjbysTmcd8RIEgfr161tFK+rVq1clL1uFB44qolGFfx3y8vLo06cPhw4dwsvZgTlDejK0Rb1yLRquJqXz3MrfOXwzDhcXF77+aQN1m7Yqc5w9yAQBT0eFhXQU5s5KksT169ctxOPgwYNcvWor3RocHGwhHR06dKBRo0YP5KKv1+tJSEggNjaWCxcu8MYbb5CTk0N4eDj+/v6WIva7lUSaBnhxYuITJZzVDJMociw2lRPxqUQlpJGq0SFJEu4OKhr5e9Ii0IeOoX44KhWcS8qg2fwtVuMndmrK3GH3lgoA9n+Mf+nTnIHhFa/TKI4J+86x5FJhnrVA2ymLcfQoWvTKBAGFXIabpzNqBxXyApUmSTQXHksF5MLe1VWvyWXHp8+RnWC7w7iqdR2eCCy/+3pFIUkStf88SUJ+UfpMvUfH0Kj/82g1egwGExkZuaSn5ZCamoXJaL2jakg6j/bYD5b7r7RrwJd97u37cze+OHiOabtOWu5Pc/O0OIMbJIkVeTksycu22SEH8AmvT49Xv0bl6o0uN5M/PnmO7IRoqz7ecjkz/XzodR8CC1pR5Ku0dFZkZtnMo3b3YXR6+lX2/fA+N47tsDomAB82qM7LEYHI72FzQWsyMf3CbebftJURrd19JHV7j7YzygwntQLnEszcslPiWff+UMv95rVrELno0xLPlavJZ/qStSz+bQ+afFult5Lg4eHBK6+8wrRp0+45Dadnz57s3r2bKVOmMGTIECIjI/nggw/Izs7Gzc2N6tWrk5CQYFGEKguF9R3Jycn4+/vz0iuv4eZbDQdPP/J1emKjb3Lh9AnOn4ok5rp96e3m7TvRtHUHatauz4xXnsNwVz3IZwO68EavNvf0fEVRovNXP3P0VrxV+yOPPMK0adPKlJf19va2kZd1d6+8uq8qVKG8qCIaVfhXIi8vjzFjxljydNuHBzG5SzP6N66Fo8r6R1UUJU7eSWThgdOsOn4RndFEWFgY69ato17jZpxPzMFgur+vgUwQ8HIyp1d5OiptCvaSk5M5dOiQhXicOnXKRp3Kzc2Ndu3aWchH69atcXKqfAnRXbt20bt3byRJYsOGDTz55JOYTCZiY2OpVasWBoNZAUUhE0h9ewQuattFSrpGx8KTV1h44gq370pfuhseDipGN40gR2dgSVSRBr5aIef2J5Pxvo9iWZMoUmv6Qm5nFBVQPlrdly2P3t/i93xaDs1+OWC5H9Z5GLV6PoNCJiCXy5AJAqIooXZxQO2oMkeDKvARykqK48+PRmHMt37trvRpQdADUHIqjqFHL7GtWB1KQMN2tBn/GXq9kZwcLZqC3H9RlEhPyyEzoyiPW5JEcnd/hKQxL+YEYP+zj9I+1NbhvSK4nJJJiwW/Wmp33AQZm3wDcBBkXDXo+SQ7g+tGa2UelbMbbUa9QeTKr9DlZuLo4UO3KbM5t3UZd05aK5s1d3BgXmAAXpVE5A9rNLwQn4jmrp/Pbi/MIrheMzbNGE1uqu3ir62XK981rUm9CkgDH07L5oWoG1zL1doc8wypS4cJswuc2+3Dw0WNsgRDN0mS2DhzFJnF3M2PLPiEVvVKjzBm5uSx4s+/WLvnMKevRZOvt6OaJAggSdSuXZuoqKj7upbdunXLIpd68+ZNTCYTXbt2JTY2loYNG7Jnzx5Lyo9GoyE2Npbbt2+XGB0pT4qWXKHA178a/oHBePr4gQDavDwSY28Tc6N0zx8ANwcVtz+ZjMt9pEFuOXONQQs3ldlPLpfbyMvWrFmzSl62Cv8IVBGNKvxrIUkSv/zyCy+//LIlVUkuE6gf4ENNXw/kMhkpuRpO30kiu2AHVyaTMXHiRGbNmmWRjs3TmyqFbBRCJgh4OyvxcVLi6aS0Wwiq0WiIjIy0EI/Dhw+Tk2Mth6hQKGjRooVV1KOy8menTp3KrFmz8PDw4MyZM4SGhgLQtm1bjh07Zuk3/7F2jL/LsG/9hWhe3HaEVE35dzTBvCgt/gqPbFWf5WPuX9Xq498PM2PrQct9L7WSxLE97/tHttPGwxwtKIb2qtGIts99gUmUECUJkygiSeDs6oirm5PFWbvckCQOLfucmEMbLU0+KgW3+rZ64IuDTy7d5tMrsZb7zj5BdJn6E/laA5l2SKNebyQ1OctCQAyJ59FGFkU1Al2d2De2L+Fe5c9BL47kXC3dlv7OlbQisjjV1YMghYJNmjz267TcncQlkyvo+/5i/Gs3ITsplt2zXyUj9jqCXI50V2SutaMDCwOr4VjR96gMnM3PZ3RsvBXZcHDzYuBHqzHl57L10wloMu3vrvfw8+DZMH86+bjhpbIlCYn5enYnZ7LoViInMuyLQrj6h9Hh+S9ROZdcpyYTwNu9dCJ/ce8Gjqz9xnJ/cLe2rJ7xSqljiiMtK5s6I14hM7do8d64dWf8g6qzc9MKJk+ezLx588p9Pnt4//33+fjjj+nduzcLFiygS5cu3Llzh/r167N3714r9amyYDSJXI9N4vy1W1y/Fc36pT9w8shfuHl4Ehpei5TEeFKTEmwivPagVKlRqVTkazU2/Ue1acDSZ/qVMLL8c/V7a47l96sQvr6+dO7c2Upe9kFsSlWhCpWBKqJRhX898vPzWb9+PYsXL+bYsWN2pWNr1arFsGHDGD9+vF0pw8omG4WQywS8ncw1HR6OihLVZ0wmE+fOnbNKt4qLs80vr127tlWdR0RExD0tTA0GAx07diQyMpKOHTuyd+9eFAoFc+bMYcqUKZZ+DXw9ODnxCRRyGQaTyOStR1gaVbJzekWwaOQjjG3f+L7Pc+hGLF2+WmXVdnVkV2rcp6HcO0cv80VUQSGxIFC3/2vIlUokkxHRZEISjSgVAiqVHEk0IpqMiMaCW5MR0WhANBnN/Y0GRJOp6JjJQGb8LTSpRWkRdVwdOdmj2X3NuTxYcDOBN84WpW2p3bzp8s4a0tNy7CrdFCI3J5/UlCyMRhPaUyswxEZajgW5OvHL0G60qWAdwoXkDIas3WtFMgJkctRAjFj6Qk+uVBPe/hHq9x6Gm38Ie759k7hz1mZwYUolG0KCcalEg8/iOJinYVy8deSieuve9Jz4EbmpcWz/4kVyUuJLGF0wRyc1NV0cUcsENCaRyzkaEvNL91VQu3nTbcoPpZIMAAeVHFen0nfU9dpcVk99EqOuKGLyzctjeHHQI6WOA9AbjAx6bza/H42ytAXXqM2MeRuY88ELnD3+F/PmzWPy5MllnqskGI1GwsLCiIuLY+7cuXzxxRfExMRQt25d9u7dS0BA2WmSkiSRlW8kOVdPap7B6nOenpLMkC7N0OVr+fzHtbTr1guj0Uh6ShJJ8bEkJ8SRFB9LUnwcyQlx3Lp6ibgY27THuzFnSE8md7GtRakoenyzmv3XrOVyV65caSXcUYUq/JNRRTSq8J+CwWDg0qVLlpoDd3d3GjVqVK7c1AdFNgohlwn4OCvxcVLhXgrpAPMP4+3bt62Ix/nztg7afn5+VsSjadOmNrKMJeHGjRs0a9aMnJwcPvjgA2bMmEFWVhaBgYFWqQUf92jOG+0bMnLDfjZcjLE5T5daIYxoVZ+W1asR4euBTBCIzczh5O1ENp2+xuYzVzHZySs69vYztAi9v1oKgNx8PR6vf2PVtuPx1nQL9rE/oJxYfyOB4Tuiyu5YSajt4sipng+eaMy/kcCb56yJRrMXfsRoFEslGgCSKJGenkN63B1ydn8IYlH6n0wQeK19A97u2KhMI79cnYE5xy7y8f4z6E2lu3/fDblSjXtgDdJjLlva/Go1QeXkSuyZosiWAKwKDqK5Y+UUq5eEGckprM6y9j7o+95ygiPqkp+bzZFVX3H98O8ljL53tB33KX61WpTax81Jhboc5m5Hf5nDhT3WEsBvjniCd0YNxNXJfkTkemwiz3/xA3+dtvZeeP1/i6nXtA1Txz5CalIcO3fvoWf3bmXOoSRs27aNxx57DE9PT9zd3YmOjqZ27drs27ePatWqlTpWozeRkqcnOVePzljy52zep9NZs2gu9Ro354dNO0vdvNn12wZmThlP41ZtefvTOSTHx/LNzKk26VRbJg2i3z2IXNyN51b8zrKj56zaSpIor0IV/omoPMvfKlThHwClUknjxo1p3LjiO+XOKjkNA1wfGNkwiRJJOXqScvQo5QJeTip8nZW4OdiSDkEQqF69OtWrV7fsXKWnp3PkyBEL8YiMjCQ5OZmNGzeycaM5BcfJyYk2bdpYiEfbtm1xc7O/61mzZk0WLFjAyJEj+eijj+jevTudO3dm0qRJ7Vb1tQABAABJREFUzJ4929Lvw32nuZCcaUMymgT5sfDpR+yShVp+XtTy82JYy/rcTs9m7E/bbHblXEvxy6gInO3UkOgrUjBRAoLtqSkJMjyCwnFw80YmVyBXKlGo1MjkCmRyBZIoYjLqMRl0GPV6THothnwtBp0GgyYPgzYXk8F+ylmqzoAkSQ88dSrlLhdiQa6yqDWVBUEm4OGmJOn3n6xIBpjVtb48dJ55xy4xtGENekcE0byaN6Hu5oLuhFwtp+LT2HMrgZVnbpBjL6+/HBBFE32nLyf11nmu7l5HdOQukouZzhVirIf7AycZAG/6ePNXnoa4YjVX1/ZvwjvkLRxd3On2/EzSY2+SfvvKfT2Oyj0QmWQgP9us+nRqzWd0nbIABzf74gGCACpl+WpSWg6YQEr0JZJvFm1mfLHqV+Zv2sGoPp0Z0r0dof4+GIwmzt6IYcm2vfwZecZGza7n8EnUa9qGfK2G1CRzRNbLP+wenm0RfvzxRwBEUSQ6OpqIiAj27NlTIskwmERS8gyk5OrJ0dkqhNnDiPEvsXnlEi6dPcWRvTtp371kgYqsDLOkuKe3L6HhEYSGR+DjX82GaFTWHq498i+r5DTAKlThQaKKaFShCsXwoMlGIQwmiaQcHUk5OpRyGd5OSnxdlLipFSUuNL28vOjXr59F2jA/P5+TJ09aFZlnZGSwd+9e9u41F8PKZDKaNGliVecRFBRkOeeIESPYsWMHy5cvZ+TIkRw+fNjGm0NvEll9ztqL4Nn2jZg7tDcqRdkLmVAvN1aMeYzQd+dbtWdqK1bjURLuzl8GcKiEVJm7yZ97tXCyEm6SGXudag18cPULIT87FU1GMpr05DLN0IpDoXZE5eSKJqNIBjndYOSOVkeo04NdHJ+5y1ndwSuohJ62MOnzubHxU/KTrpfYR2s0sez0dZadLrlPeVDT2QG5AFdzrVMhJZORI0s+pNWIN+g44WOaDX2FyOWfERu1z9LHQRCY6FW5ruUlwVkmY4KXJ9OTi2RfoyP/pOnAycgEF9QqBbo8c8Sj4WPjSLoaRcrVU+U7uSDDJbQZHnW64VStHu6ybE6unIpo0KHPy+Lk6k9p99wsZHaK3BVyGeXlrAqVml6TP+X3b14jPbYoNTJXm8/8zTuYv3lHKaPNaNdvBL2Gm1Ok4m/fAMDN05s8sXwRVntITEzkt99+AyArK4vw8HD27t1rdQ0D82I8Q2MgOVdPutZgV+2tNHj6+DJw1DhWL/yOpd/Ool23XiVeh7PSzRK7Hp5FBM/djkfStWRbidx7wdVkW6+kinoyVaEKDxNVRKMKVbgLfxfZKITBJJKYoyMxR4dKLrMYA7qp5aXubjs4ONChQwc6dOjAW2+9hSiKXL582Srd6tatW0RFRREVFcV3330HQFhYmFW61Zw5czh8+DDXrl2jfv36FrdYQRDs7soNbl6HBcMfsTKjKwv+bs44q5TkFdvFPhObROuw0lMfyoPTsUk2beHu918YmXnXzn9WQhHZSrhwlIQLR+2Oc3DzwtnLD2cvP5w8zX/OXv4F931x9vJDoXYmPyuD1S/1tBp7IiP3gRINUZI4lWld8G3QZJF5/QQuIQ0QlCU/tmjQcWPTp+TGWvtweCjlfNowjE8u3yFWWz6iVQiFIBDooKSagwpPlZJG7s4083CmuYcLQY4q4vP1tNp9muy7PD1uHtpG/LmjtBzxKtXb9EGfl2V1vJ+rC+5/oz/AY64uzEpNJa8gkmbUabl9ag81OzyOMTePvHSzG3WtzgOp33cMWSmJZMRcJPPOVTJjr5GXFk9eSiwypRqngHqovUJx8AnDwTcchYM5IikIAmr3ajQaMIUz6z4HIO3WWa7s+ol6fcbazEldzmhGIZSO7rR7/gtOrp5F4qUjZQ8ogEyu4JFnptBpwBhzGAWJ+BgzyQwMjSA21X4xe3kwd+5cizpfWFgYe/fuJTi4yPMoR1dYd6G/72v18PEvsWnFj1w+F8XhPTusHL+LozCi4e5VRDRq1m3Inm2brfrdLUt7L9DqDZyJtfVkatq06X2fuwpV+LtQRTSqUAU7+LvJRiH0JpH4bB3x2TpUChk+Tkp8XVS4qsv+qspkMurXr0/9+vV5/vnnAYiPj7eKeJw+fZro6Giio6NZuXIlYN4dK9why83Nxc3NjY0bN3Lnzh3GjrVewAS6uzB/eJ8KkQwAuUxG0xB/Dt0oUjvafTmG8R2bVug89rDrsnVKl6+Dyn7aUwVxOtU6716QK3Dy8EOQyQqM4CQcPXxpOmAc3qF1cCogEvK7pEYlSUISC7w1CoibKIqoXN1x9g4gLy3R0veXO6k8GXR/tSWlYV9Klk3qVF7CNa5t/B+CTI5zYB1cqzfBLawxTv41EWTmxaqFZNw5jyBXIpmKzjEuLIBR1f0ZHuLH9sR0Ft9K5EBqNoYStpVlQBtvV54LC2BAoDfqUqJPQY5qRlf347sb1gXXju4+aLNSObjgPa79tZnUm9b1S0PdSy+Srmw4y2Q84epqVauRevM8NTs8TnLsTZAkVM5uqF08EAQBN58AnDz9CGraFYDky8c5NP8NnL0Dafr0DFKTMmxcuAs3HdxDWxLe8UluHjSnS17buwbvGo3wq93Sqn9506agoFhao0OucqLVMzNwyL3NtYObOXdoByaj/RQ3J1cP2vYdSus+T+Hha71hUBjRCKxeE02+kYycfDxLMA0sCYmJiXzxxReAOZq7d+9eQkNDyTeKpOSa6y60hrKVocoLT28fnhz1HKsWzmHpt7No37233Y2ezAxzRMPds8iEr27jpjb9fjt3ndRcDT4u977p8cvJy1aGpGCWQY+IiLjnc1ahCn83qohGFapQAh4W2SiE3lhEOtQKGT7OKnycleUiHYUIDAxk8ODBDB48GICcnByOHj1qIR5HjhwhIyPDygk3Ozubt956i86dO+Pr60tKSlFKyMzHOuJxjzvuHWoGWRGNzWeukZCVSzX3ezdQ0xtNLD181vpxqnlWSp3D8eRMy//dq9Wg7/srLOdNvnaagwvfRZuZQtTGH+j+8he4+gYiSRKiKFqIRVkIadaFy7vWWu5vT0znjkZHiNOD8dJYeCvR6r5MqaZa026kXT9DfkYCubEXyY29SMKh1cgdXHANaYhzSAMyrxwiL+4yMqUDao8AtCnRgLngelwNs5GhQibwRKA3TwR6ozOJXMjWcDYrj2yDERFwVchp6O5MIzcnnMqRcleIcTUCbIhGnZ5DQJI499sSki6esDrmJAg0VD9YLxJ7aO3oaEU00m9fBiQyC4wD3QKqWz4/CrkMUZIsZEKQm7/TomhCoVLg4+9pQzbkBR9p0SRSo/NIMmOvkh59HpA4teYzukxZgKO7maTK5YKNl09pyMrTYyq4xqmUcnzDG9CiTTsee+5tFr//HInRRfUH3tVC6T50Ik069UVxt/BEwXQLIxpB1c0L4ri03AoRjeTkZNq1a4der0cQBHbv2YujdzXOJeSQlV++uot7wfDnX2LTyh+5cv40h/f8SYcetspbWem2EY3GLdvi4upGbk7R+683mpi14xhfPHlvhfD5BiOf7zxm096vX7+qGo0q/KtQ9WmtQhVKQSHZUMofbIFuWdAZReKy8jkTn8OJ2Cyi07XklrPQsThcXV3p1asXM2fO5PXXX7d4iSgUCpo2bWpx7T116hTffPONFcnwcFQzrGW9e34OY9o2srpvFEWmbtp3z+cD+HznMRKzrVOBnq1nK19cUaTl6/n9dtFz96nZyIq8+EY0oedbi/AMqU1+dga/fzqBC3+uxWQ0IZrEcheC1uk+yOq+CHx46fZ9z98ejqZlsy3BOt87pM2jNBn6Jt3fXUm715YS0vN5PGq1Qa52wpSfS+a1o8Tt+ZG8uMuAgEtIQ/LTi2SX23i52k31UstlNPd0YUyYPy/XCuKVWkGMqxFAGy/XCpEMgAgXR5p7OFu1JV09g4O7N/X6jLQsrgtRV62+J/ft+8Xd5CYr/hZ6XT65ieb308WvOlIxJxmlQmb5TMkKiIZkMn+nFSoFPgGeyIpFe4RixEGnNdB8+DuoXMyRSL0mm5Or/4dY4OVQkbSpXK0eQzFFJkeVAr3BhCiJGPU60hLM8xcEgUeeeYU3FmyjRfcnbEkGRT45ccVSpwBiU8qfPpWamkrPnj2Jjo4GoM9jA9C4h3ItVfNASQaAh5c3Tz4zHoAl386y+z3Oyiis0SiKaDg4OtHj8UE2fb/dc8Jqc6UimP7bAa4k2dZn3I9UcBWq8DBQRTSqUIUy8E8hG4XIN4jEZuVzOj6Hk7HZxGRoydOXP4UgPz+fKVOm0K9fP1JSUmjcuDFnzpwhKiqKa9eu8X/snWWUFNfWhp+qdht3x93dLUDcCEmIEiPuduPuQtxDSEhCEiKEBAvuLgMMDuPu0i71/eixnu6BmQGS3O/WsxYL+lTV6epq4by19363ppm7wWM7J/l1XW8NnaPDmNgtxWfsu237+XH7gcAHnIQt6Xm8tHijz1j7ID2TEk+9qeHsAzn1XaoBkgdOwulwYrfasVZbsVRZUKiDmfDAR6QMnoTkdrP5m1fZ9PWrzaaaBCIkrh3RXX0tSudmF7Mo33+BcSpY3W5u33WUpsumlOEXIooioigSFpdClwmX0emS/9D3rq/pdMULaEIbp8RIVB3f7pM21T+k7dGo1tCvyfPk793A5q9eZN+fs7BW+jbF63aa3MxaS6JKiaGRGJA8bqpLCqgu9Kb2GaOSfBb0AgKqWiEhNBEaAEqVN7JRJzZ8AhQSeCQtg655CgTv9rKMfRxcNhugRSYNAFa7C6u94bdDrHWqkoD9Ozby/v2X47R7i/EvvuNpxl5280mjhRZzNeUl3rqp+GSvvWtBmblFzmalpaWMn3AWe/c22LlePP22k9oun06uvPlOdAYjh/elsn65vy1xZX3qlDei4XK5+O3bWaxY6N/B2yNJXPLpr+zMKvDb1hySJDFzxTbeXrHNb9ugQYMYMWJEi+eSkfk3IAsNGZkW8G8TG3VYnW6yK2zsyq1iZ24VWRVWLCcQHWlpaQwePJj33nsPgHvvvZctW7bQvXt3LBYLN998M3Z7YDeofonRp3y+r1w0BmWTsP/0bxby047WiY0Nx3I478N5OJssXl4d1rVVKSOBKLDYeW3XsfrHokJFVXEhdosdl8OFx9PwnCqtjpG3Pk//y+4EQeDwql/46/U7sVa1XCj0n3I7Te2B7th1lCM11maOaB0eSeLuXcc50sS9KX7AREwxKT5japWC0DAjoiBRtP137OX5iEo1naY8QYdLHiOonW+fjz5NIg1nir6tEDR/ZxF4YwRBIEj0fW6n3VYvNEzRyXg8Eq5Gn1lRFFAqxHrXKE+TJoVKlYLI6FAUCtEvXcZhcxAc35We599aP3Z09Y8UH9qKSnny/9odLjc1Vl9RrFErAYk9f33Pdy/cgbmqIaWy35iWdbnOy/R+d0LCo9AbvbUybo9Efrl/1/k6nG4P+zPzGTl2PHv3pKI3eLvMt+vcle59BzZ73JkgJCycKbVRja+aRDUkSfJJndqydgU3nj+at59+iJrKCkwhYX7zlZltjH77e95avtXnvQ9EYZWZK774nYd/XeW3TalU8umnn55x+2sZmdONLDRkZFrIv1Vs1GFxuMkqt7GzVnRkV9jqiyUlSeLjjz9m4MCB7N27l8jISBYuXMg777yDVqvF5XJx2WWXsWzZsmbnjzyFosY6+iZG89jZQ33GnG4PV836gxu+WUhRdfOLEYBqm53Hf1/DuJlz/exxr+gYyyXtT60BoCRJ3LlmH+WNCqY9bifbv3uBtR/cRdGhbfULj7pUFgGBXudPZ8K9b6PSGSg6vIuFz11PaWbL+iZEdepDl3GX+4yVOFyctz6Ng9WWZo5qGS6PxJ27jvFDTrHPuMYURo+L7wp4jIibjEUzqTy2HaFWZAS1H0Bwh4GEdh3ps29kgB4mZ4LmnscQoDHgP/ntbPofquR2UVPkTZ0xxSQD4HJ7cDcSq0qFiLLWQKBxRKMOhUpBREwoygDiwVxlpt3wi4nv01AHsP2H16gp83dia4zbLVFl9ncIU3ocrPr8Gbb9+jGS5KHroDEAGEPCUWtb9v2vLwRP8m1Wl9vEfcojSZSYHewvrGFFWhaXnn8uB/ftITQ8kqg4r33t+Zdf+48srOuiGkf272XdskWUlxTz1/x5fP/Zezgc3t+dZ+66kYemTyX98EEMQSFc8/CLvP77Jtp17ek3n83p4tHfVtPpmU95cfFG1h3NptJqx+Fyk1tRzR97jnDznMV0ePpTft192O94gCeeeIJ+/c58Q08ZmdONXAwuI9MKDGoFPaKNpBXW/CMF4i3F4nCT6bCSWW7FWVPBK4/ew7LFfwJw9tln89VXXxET07Aof/nll1m82DdNQCkKuBoVozrcp8fh5fGzh7E0LZ2tmb4FvnO2pPHjjoNM6duZid3a0TcxilC9lhq7k725Raw5nM332/dTHaBvhlGl4I3hba8fAa/IeGbrYRZkNCzSwlJ6Et6uF8c3zKcy9wibv3qCsJSedJ00nejO/eqPA0joO5LznprNyvcepKogi8Uv3cSIm56m3ZDmm3/V0X/KHeTs2YC5pCGfO8/mYMzqPbzYM4WbUqJP2Ek+EAeqLNy+6yjby/3z43tNfQC1IQhJknA7bDgtVdhrqrHXlHF4yVdUZh9EEBWEdRpE6YF1FO5chMtWg72i5SkgZ5KHr7qQF266AqVSwSMffcvbP/5Zv83qaVnzwTOBRfJ9bru5Eo/biahSow+Nqh93ujwISqHeva2uNsoTQGgAKJQKwiJDsFaZ8TS6K+52unHYHPSZch+V+cepKcrEaa1m1RfPcN6DH9TXfjSmzmGqaTaSrSyXtXOeoyI/A1GhZNgV95IUH8PBbWsIi0nwm6c56uszkgMLjWq7i8JqryWtyyNRU1XFA9dP4dC+3QSHhXP/s6/x9N03olSpmHTx5X7z/x0Eh4Yx5bpb+Pbjmbz66N3YLBacTXrkHNizE0EQ6DpwBDc//TZhMXGE61W88cX33Hn5uRTm+ddmZJdX8+yf6/3GT8aVV17JU0891ebXIyPzTyILDRmZVmLUKP8rxAbA9g1rePHB2yktKkClVnPv489xzz33ENLIASY1NZUXXnjB5ziDUsGrw7pw97r99WMH8ktPyzmpFAqmDermJzTAm84xd/sB5raybqPG6ea65al8N7EvUW1wbHK4PTy2+SDv7cmoH1OotQy86j9og6JoP+ISjq75ifRNCyjL2MfGzx4iqvMA+lx8K9GdGrrQB8elcN5Ts1n7yRPk7t3E2o+foDz7CP0uvR3hBE4xar2ekbe9ypr37sHWKO3K7PZwf+px5uWUcH+nOCZFh5600DnDbOPz9AI+Pp4fsEO6LjSagws/Z++8t3BYqgPeRQdvjUHpgQ0nfK5yx5ktzm14Ht8Un2E9OqOsrUNIiPJNVzniaF0vj9NFictFeZPUmOydKwAwhMfVWwXX4XR7UIsiAkJDMbgnsJiXJInqgmNUZB2g5HgaNcWZuO0WJMmDqFRjiownvF1PLGV5eFxOio6nsX3+Zwye0qRwWPJ1mKojP20Du396A6fdgj44nPEzXiC6Qy8y1/8MQHhMyw0WGhynOtWPuSXIrbSzMb0MT6OYk7m6ioduuIwDqTsJDg3jnTnz+eOHrwEYPek8QsICdz0/01RXVZK2y1sjYa6q5MKRA7n+nLGkxESiVikprzazZMtuPv9jBQe2refpq87i8Zmf03H8RNAlsHDZSq6+9AIOHTq1bvAA06dP5/PPP0fxD6UEysicKrLQkJFpA/92seF0OPhy5it8/9l7SJJEcodOPPPuF3Tq3ovMCjuZFXZMGiURBiW33npbfVOsOn6c3J9RsWHcu34/dWvV09GAqo6d2SdO7WgpCpW6vhv36rxS+vy4jndHdWdqh9gWp1zsLK7kppV72FdW7TPudtjZ+/v7JPafRGTnwfQ4bwYdRk3h8Mrvydy2mKLDO1j2+gzie4+k/2W3E5bUGQC1wcT4+2ey6+eP2LfoG/b+OZvy7KOMuvUF1PrAtQaCKBDbqSvj7pnJqnfvx1btW+OxsbSKjaVVJOs1TIoOpV+IgR5BeoxKBU6PRJbFzq6KGjaXVbO6uNKv6Lsx1nL/ay8olAiCiMflAARCkrpiiEpEqTOh0ptwoQGVHrfNTPbyz+qPS600c8VpKL4/GamVvil1nRMbitT7dWrnsy3NbkeSpL895SYtQG1TzjZvR+3qggyWPDOVuD5jaDfyIkxRiUiShNPlQa0UfYrBvS3vvLjsFgpSV5K7fRGW4ubdyGwBIk17l80lplMfkno3FA9XN3GYkjxuDi77hiOr5gIQ3bEP4295Dn2wd4Ffkp8N0KqIRl3qVGxSB2wesEvglLzvRUGFlagQbwqWpaaah268nLRd2wkKCWXmnN9IbNeev36fB3jTpv4JKspKufeqCzl++AD3XHYO919xHolR/r1thvboxBPXXcL8tdt48KM5PH3rVTz51ifMuOEa4oI6sW3bNh599FE+/vjjNp1HSEgI7777Ltde+8+kj8nInC5koSEj00bqxMa+ghqfFKN/muz0Yzx/3wwO7t0FwEXTpnPXky+i1fnmWFfbXWzevIktW3w7XN/eM5nJSd7FY+/woPrGdam5RezMKqB/0qnVQVRa7fy6qyEPWVQqSejUm6wDO1s8R2RiJ/qecwP6oHD++vQxrLUL8xKbg6uX7eblHUe5rUcyl7SPITpAhKPa4WJlbgmf7MtieY6va5EgipiiE6nKzyQ/bQv5aVtQ6YzE9RpN4oBJ9LroLjqOnsrRNXPJ3LqU3D3ryd2znpTBZ9H34lsJik3G7XTQdcJUVDojqfM/Jyd1PfMfu4z2w89FEATs5ioc5iqfv+01lbjsJy4Az7TY+Ty9belLSq0Rl60GlSGYXlMfwBgeh0ofhEKrZ+9Pb5GfuhpBoaTftU+jD4uhIvsw1QXp2MoLvf1BUKEwRYFCCbVRkJ0B0rLOBLsadTM36rR+QqNxF/syt4ccl4vEAParZ5LdtsAmCnVYK4o4tmYex9bMI6rrIHpddAdBce1xuqX6iIbH7UKlUmB3uChKW8eRxZ/gtPg2jlQI0NWkJ0arRgRq3G4OVFmoCNC8bsWnT3LR418SFt8eq92FrZFRhMNSxY4fXqX4sLcPSY/xUxk85Q6fdKuyAm/6T1h0yyIalupKKsu89UDa+I7UeHwXyBU1dqJC9FjMNTxy05Xs27EVY1Awb3/zK5269+Kv+fOoqaokJj6RASPGtOg5Tyd2u43HZlzN8cMH+PyRW7nhvBP3wFAplUwdP4xhPTsz+cGXefnhOxjdqz1x48djMpn46KOPuPLKK3n11VdZsmRJi2yvTSYT1113HY8//jhxcXGn66XJyPxjyEJDRuYUMGqU9Iz5d4gNSZJY9PP3vPvcf7BazASFhPLoK+8yevL5zR7z27ezfB5H6dS8PLRL/eNrOsf7dMh+delmfrrl4lM6zw9W78DcKBWm/cCzGHfDEygthexdvYCMtB3kZxz2sYkVRJG4pA506NqHERMvon3XPhRXWjmeX8G5d77N+h/fpDC9oTt0WlkNd69L4+51acQbtPQIM2JUKXG4PRytNHOowhzwrr8+LJoRNz5DXM9BVOZncmTtfI5vXIK1soTMrYvI3LoItSGE4Nj2GCPjiO89ktKM/VgrS8jYupyMrcu9dqOSf52AtbKUtMVzTn6BBAGV1oAgijgs1fgl07eRyY99yeoPHsJcnM3xlXMZdsc7iEolu75/hfzU1SAqiOjUnz0/vIbLduKi/Do2lVaRb7UTG6Ao+3SRbbGzrVG0qV/ndj4OTEa9lh4pCexLz64f+7WqmnvD/R2AzhRuSeL3quqT71hL0cFtrDoyg65nX0+nCdPqLWoBBHsN+395h6L9DWlrQUoFVydFcVlCBL2D9eiapNFIkkS6xc6qogq+SC9gb5XXRMDjdvH7yzcx5pYXMaX0r9+/Mu8Y2759DktZAQqVhuFXPUznYZP9zrOitpD9ZBENtwQuILPWcSo4IgZtgOhdeY0di8XMozdPI3XbJoymIGZ+8ytdevYB4M+fvN+Pc6de/Y80pfttzpfs27mVV2+7+qQiozEJUeEseuM/DLvtSW655RaOHDlSf/6jR49m9OjRHDt2jB9//JGtW7eyc+dOcnNz8Xg8aDQaOnfuzIABAxg1ahRTp07FZDKdqZcoI/O3I0gt7SwlIyPTLDV21z8qNqqrKnnziftZuXA+AP2GjuTJtz4mKja+2WMcdjvn9G2Hw95ge/pY/w48P6RBaJTbnSR/swJro3SLH266kMv6d23Tee7LK2bwa9/gcDXcWQ2OTmL4tPtJ6DKADjFBGFQKcDmpLinA5XKgUKoICYtEo9X5zWd3ujiaW0FZlZUDGxewc8lsXA6b334tQR8ahdYUitNmxmGuxm6pOrVFviCgMQajNYWi0uioKsz2CgcgrudQkvqPQWMMRqUzogsKRWsKRlDqEBXa+nqOmtJ8jqz+hSNrfqlPEWsp0V0GEttrGLt/fh+NMYRL31hIeUEmK964DaelitjeoxGUavJ2Lm/7awRiNCp+HNqVAaFnZnH0/P4sXj/cUFj75p3Xct/lvlarr8z5jae+aOiwHqlQsLJdMuq/KeVkVY2Z2/LbFmmK6NiXAdc8wdJnpwJgjEqkpsgrmjSiwBNdE5nRPhZjC3tjSJLEhtIqHtiTzv6qOtcygX5THyJxwESydy4n9dd38Lgc6MNiGT79WZI7d/ebx+N2Mfvus5A8bh77agXB4b721p5aceGSvI0mAXYs/YnFHz9P5/4jufHZT/zmdNit/PLm/aRuWY/BaOLtOb/SvY+3j0xOxnGmjR+IIAjMW5dKdFzL07VOBzarlakjexGsETn8/XsoFK0XOm//+CePfPQtixYt4pxzzjnp/h6PR+7yLfP/HlloyMicJv4psbFn22aev38GhXk5KJRKbr7/cabNuPukxYMHUncy45KzfMaOXD2WlCDfFKvntx3mhe1H6x8bNSoW33U5w9o3L2ICkV1exfiZc0kvrawfE0QRqdYlKK5Tf4ZdeAtnjR2GKsAdW4fdhrmmEnN1Jebqqtq/vX+KiksoKinFUlVGRVE25vLCZh18WotSo0OtD0JtMKHUGnA7bFjLi33qKBQqDTHdBhKe0pWCAzsoOrIbAFGppuuEy+h53vWodUa2zHmdI2t/B6DDiHMZev1jqDQ6FLWLSLfbjd3sn4Lz57PTqC7MIrJjHxzWGqryM/wKh5UaHUq1DrfTjrNJREKlN9Fl7GUk9B2Nubqa9R890GwReFtQCHB/p3ge65KIpg0LtOYosTsZsGIXpbVF5zqNmqxfPiLU5Hu3vLCsgpSpd+JsJGBfjIpkanDQaTuX5vBIEtfm5LHd1iBwx8aF8cHonpTYHOwuqWJzYQW/pxf4CPbGhCR0piLH19Z0YKiRT/t3pIupbbbSdreH1w7l8MbhnProXWTHARQf3QFAVJdB9L/iP0REhKNR+/9WVJfk8dOTV6BQqXlh3nZEUUSSwA04a/9uytLPX2bbwu8Zfcl0zr3hIZ9tTruNr1+8i6Opm9EZjLz99c/07D+4fvunb7zAtx/PZOiYs3jjq5/a9JrbgiRJrPtrIW8/8zClRYW8cutVPHzVhW2aq7SymuSpd3LWxEn88ccfp/lMZWT+O5FTp2RkThN/dxqVy+Xi6/ff4JsP38Lj8RCf3I6n3/ms/g7hyTi0L9XncZxB4ycyAP7TvyO/pxeyp9R7N77G7mTy+z8x87Lx3Di8d4sKFZcdyODmbxeRW9GQ069Uaxl4/i1k7dtI/pFd5B3ZyS9v3c6y2THEJSTjdjl9xISrFR23AyGICkSFEqVai9YYhD4kEnVwLMbwCNSGINT6IDSGINSGIPTB3giD2hCEQqXGaXP65lcLYKso4sj6P0jftBhzaT65ezaQu2cDpuhEOo6+kPLsY5Smp7F/6fccXv0b3SZeSf/L7ya8XVe2zHmTYxsWUZGXzln3z8RYe7dYFEWfegOAyrzjVBdmISpVjL7jddQ6Iy6HHXt1MSvffZCaYu/dfpfd2myNh9NSzb5FX7Fv0VeEt+uBPiwWc3F2wH3rCNWo6B8ZRLxBiyAIFFvt7CquIt/iL4TcErx5OJctZdX8NKQbJtXpcch5aE96vcgAmHbWCD+RARAdFsKUMUP4YUVDp/jXSkoZbdATrTyz/83NrazyERkAD/frQJdQI12AEbFh3NnLGx2ctT+bF3ccoaZJPUVTkXF2dChzBnf2S5FqDRqFyNPdk+gepOemHYdxS9SLjM4TrqHLhGtQKEQ0zbxX1SVe84fgyDgkQcQmeaMXJ6Ioy3tDIiqpo8+402Fnzsv3cjR1Mxqtnje/+slHZLhcLhb9/D0A511+TZteb1s4sn8v77/4BLs2ey1nVUoF088d2+b5woNNXD5uKHMWLqSgoMDHQlxG5n8VWWjIyJxG/i6xkZ+TxfP3z2Dfjq0AnD1lGvc/8yp6Y8vTVzKP+Vov9osIDrifWiEy56y+jJ2/ub6RncXh5Nbvl/Ldtv3cP34g5/bsgKJJCoAkSWxKz+OD1Tv4acdBv3ldDhubf33fb7yqtICq0sBpKAqFEr0pCIMpGIMx2Pu3KRiDKQidMRjREIxCUFPjUqLSmtDovX9UWj1irb2owmSo7+pWZXEgqtUIooClvIjyrEMUHtyOq9Y6VKFSowsKIyS+E8HxHVHrvddXEASCYhIYcNnt9LngZoqP7+HYhj/J3LaC6sJsqguzQRAIS+qMw1JDTUkee//8ikMr59Hj7GsYd8+bbPjiWUrTD7Dg6WuYcN+bRHfqgyAIiEoRd6OFaNbO1QDEdBuMWuddZLsdVnbP/6xeZLSG0vS0ZreZVEqu6RLPzd0T6RVmCigiM6oszD6Ywxf7syi0+qZzrSup4pJN+/l9eHcMLUz1aY4fsov5ObehUN+o0/LEdZc2u//DV13EvNWbcddazFZ7PDxZWMxncTFnzLUn2+nkzRJf2+eBUcGclejvUhSqUfFgv/Zc1jGWm1fuYXVeYLvokeFBfDu4C9rTFBm6LCECp8fDLTu9IkAXGk3ncdMQRBGtWtlsh8OqEq/9tDEyHmsLf8pKaoVGdKNmfS6ng29fvY/Duzag0uiY/uxHdO832Oe4zauXUVZcSEh4BCMmnN3KV9h6SosL+fytl1g07zskSUKl0WAICiXOoCQy5NSiYEN7dOabJWvJycmRhYaMDLLQkJE57ZxpsbH8j19484kHMNdUYzCaeOjFtznrwimtnsdq9k2vCeTOVEf3MBOLLxjMeX9updTWEFlYeySbtUeyCdZp6JcYTafIUERBILuiip1ZhRRUNV9UrNYZMYREotF5xYBab8LjdlOcuZ+qklwAVGoNQ8efz1kXXUN4VBwara7ZRWOl25vCYxTBbHNyOLccs9U/CiK53Qi1i2BL0XH2r/mdvH0bsFeXN3+xagmKSSZl8GQ6jr4IlcbbgE2pURHfcxCx3QYw5JqHydy+kmMbFlJwYDtlWd471QqVBoVajcNcza5fP0FjCqHz2EvI3rWWitzjLHrxFkbc8Didx16MUqn0ERrZu1YBkNhvLAAlx/ex7pPH/CxwT5Up7WN4b1SPk/YhSQnS8+zgzjzSrwNPbT3E+3syfArrN5dVc+vOo8wZ1LnNC/w/8kq5bedRn7HXbr+a5JjmrXT7dEzm0asv4uVvfqsfW2ux8HpJKY9EhJ92sVHmdjMjNx9Lo+iTWhT5fGzvEzZXTDbpWHT+IK5bsZufj/kK6mClglkDO502kVHHtKQoVhVX8n12MdbyQo6s+ZEuE67xCo0mCAoRQaGgpsx7bqaIeDySdNKGkZaqcsyV3s9kVIJXaLicTr577QEObV+HSq1l+tMf0q77QCrNDsKDGnr5LPzpWwDOvvRKVLXNC88EdruNn778mDkfz8Rq9kZXh0y6iKl3Pc7b916Dyb8MrNUE6b2TVFZWnmRPGZn/DWShISNzBjgTYsNSU83MZx9lya8/ANBzwGCenvkZsQlJbZuwycLhZOVaAyKD2XDpcG5cuYeNBb6L8kqrndWHs1h9uHmv/6YMvfhO2vcL7OySfzSVHYtnUZJ9iHVLfmHXxpWcf+UMxpx3OSqV/0LEVevVbxC9r8GgVdG3fSRZxdXkFFf71nR7PGTv3cruxd9QdHyf31wnoqogkz0LPmPfwlkkDRxPv0tuJSgmCQEBpVKJoDPQceT5dBx5PjXFeRzbuJBj6xdSXZyL2+lNORIUSuzVFez9cza64HDCkrtQlnmIdZ8/R2nWYQZPu4+6ZgpVBZlU5h1HVChJ6D2SoiO7WfPBQ7gcgVOklKJA7+gwekeHYtKosDhd7CuqILWgDJur+c7ut3ZP4oMxPVt1LfQqBW+N6M75yVFctnQnVY1SnObnlfJzbilTE/zv7J8Il0fi3aO5PH8gi8btac4a2IsZF57V/IG1PHHtpSxYt93HgWpWhbevyKOnUWwUuVzclJvPcaevkH1qYEd6hp88qqhSiHw9oS955i0+36VXe6UQd4YcvF7r1Y6VxRUU2JwcXfMT3cZdjkJRu7IWxXqBUUdVsVfsm6LicLk9qE8SoSqujWaERMWj0elxu5x8//qDHNi6GqVaw/VPfUCHXt5IRkWNvV5olBTms2mVt9/I+WcobUqSJFYtms/Hrz5LQa73s9G+R1+uvP9ZOvUeCIBGp8dsO/nNhpNRY/Wm0RmNgXvmyMj8ryELDRmZM8TpFBv7U3fw/H0zyM1MRxRFrr/rIa676yGUp5B/rtcbfB4Hyr1vSodgAysvGspH+zJ5Y9exFh0DYFIpsLo8uBqt+FWa5m8fxnbsw3l3vUN22gb2Lp9DcV4mP3z2Gst//5aLrr2TIWPP83FrsXhAKUgoG60jBUEgOSqIMJOWw7nlWG0u7JZqtv74Kcd2nJrTksftImPLX2TvXEO/y+6g59lXoVAqUSgVeDwePG4Pxsg4+l1yK/0uuZX8Azs4uv5PMrYtx2Wz1M9jrSzFWlmKSmfEaa1h/9K5lOccY8RNz6PSmcja6Y1mRHcdiK26nLUfPRJQZHQINXHP0O5c06cDwVp/IWZ1upiXlsG7m9JILfRfTM06mM2VneIYGdd6S9hxCREsPG8Qk//YiqWRmLlv9zHGRgYTqWlZP4tdFTXcn3qc7QF6c7x4y5UtEgkatYqvn7yL0Xc+jblRX4uvKio5ZHfwYnQk8afYX2N5jZlnioopcfsKtzFxYTzUr32L51ErRN4b1YOB87z1AZ2MOq5JijqlczsRoWolD3RK4JG96bgdNjI3LyDiwhsQlCKB8qeq64RGZLy3i/lJhYbX2jY6uaNXZLzxMPu3rESpUnP9E+/Tsc/Q+n3La2yAN1Vz8S8/4Ha76TVgCMkdOp+eF9uIA6k7ef/FJ9i7YwsAoVGxTL3rMYZMutjnNyQ4Ipqj2w5httow6LTNTXdS9md40xnltCkZGS+yr5qMzBmkTmwoxbbdSXW73cz5aCZ3TD2H3Mx0ouMSeH/un9x4339OSWQApHT2tajdVVzZooZSClHg7t4pHLtmHD9M6sel7WNIDpBzEKlVMzkxkg9G92DJBYN9RAZARHw7v2MaIwgCST1HctEDn3LVHU8SHBZJSWEuX775OC/cczl7t61DkiRcEjgkAW0zl9ikU9O3fSTO0iPMf2vGCUVGmFLBuGAD10SFMD0qlCsjQhhg1KFtZpHrdtrZPncmi1+6BUu5t1GZKIoolAoUCoW30Z3HQ3SXfoy46Skuf3cJI2c8R2z3QT4RJae1YXGdn7aVxS/fQEXusfq0qYS+Y9j89Yt+blIC8ODwnuy+4yLuHNItoMgA0KmUXNe3I1tmXMArZw1A3SQ1x+mRuGFlKjXOtjlRDY0J5fXhvp+nSpebkatSmZtVRJbF5vfZkiSJTLON77KKmLB2L6NW7wkoMgBuevVjKqpb1tujU0IMidH+kZSNVisXZGXzXUUlNk9g96cTkeN08mBBIXfmF/iJjP6RQfx6zgCUrbQqbdyj5pZ2Z66WpI6rEiPR1773exbPxiO5aa5Io7rYWwweFBnv0028OYqzjgAQkdCeH976D2mblqNQqrj28ffo1G+4z752hxubw4XH42HhPG/a1PlXnN5O4MUFebz44O3MuOQs9u7Yglqr4+IZD/LKz2sZdvalfrayQyddRI3V5mMo0FosNjtz/lrH8OHDSU5OPtWXICPz/wLZ3lZG5m+gLda3Rfm5vPTQHezctA6A8eddzEMvzcQUFLhou7Uc2pfKzRf6pi7tnzaGTiGGZo44MWU2ByU2B5IEwRoV0Tp1/cLp07RM7lrbUISsMwZx1yfLKS0zIzldSO7m03oAjDo1XWL1rPpjLot/noXV7HXA6tJ7EOdcdx+xXfoQJkpNs8Hq2b15FZ+88hCuAL0o4tUqpkeHcml4MEkaVcDFnkuS2GO28m1RBT+XVGAJ8D6aohM557FPMEXGIYgCkkfC7XIHFG+iKGIpL+To+oUcXvM71UX+Rd2CqEDyuBFEBT3Omc6+hV/6bFcIAt9dNobLeqQEftEnYG1GARd8txxzE2Fxe89k3hvVo9XzgVc4TP5jK6tyAxc5h6mVdDLqUIsCdreHozU2yk4gbDoG6Tla1RD96dkukZ9ffJCOCc3fKc4pKuXyZ2aydf/RZvcBCBZFpgSZuDjIREe1GkUzHxyzx8M2q5UfKqtYbbYEbPI4PCaU388dSEgLIzeNuXFlKnMO5SICWecOJiRAzcTp5pYdR5ib7RXFnUacx9hbnvHbx26u4ps7valq0z9ZjVqjQ2ktIe9oGgXH0igvzMFpt+F2OVGq1Kg0OvKO7KWqpICYdl0pSD+IQqnk2sffo+vA0QHPo31cMAWHd3HPVReiNxqZv/kAOn3bfnsaY7NamPv5B3z/6XvYrN7Pz/BzL+OyOx4lNCq22eN0Cg+3T+pPUqiR7V+80ibRN3vRam5+7RO+/fZbrr766ja/BhmZ/0/IQkNG5jQjSRLZ2dnk5ORQU1OD0WgkPj6esOg40grNLRIba5f+yWuP3UtVRTk6vYH7nn2Nc6ZMO613PJ0OB+f174DV0nCn+MG+7Xl1WNua8TWHJEkM/nmDz93bzv1Hcv0zH5FRUIVHkkCSkJxuPE4nuAPfPY0I1tElMRRzVSWL533JigXf1wuH3sPP4vLp9xCT4B8l2bdjA+8/dxdul++iNkSh4MWUGC6LCEbZiuta5XLzRm4xn+SX+i08TdGJXPDMLHTBDXfU61KpGqNQKurfS0mSKDqcysHVv3J841I8Ll8xpNDoEQTBr1v3++cO5fbBbX+v/jyUzcVzV/g+lyBw5JqxJBrbVhW7Pq+Mcb9vbvM5AaSYdHw6theDokIY9/tmUht9bgRB4Nyh/bjt4olMHNgbpVKB2+1hbeoBPpn/F/PXb6t3nQJQG0NwWqr9eo40Ri8IdNVo6KBWoRNFPJJEhdvDfruddKczoLio4/aeybw6tCv6Ntr59v1xLWllNXQz6dg2oV+b5mgtnx3P54E96fWPJ9zxMu0H+9a/lGQc5Ldnr0OtMxLbtT95B3fgtLYsolRHSvcBTLrmLtr1GBjwdyssSMu8mY+x7Pd5XDRtOg+99HbbXlAtHo+HZQt+5rM3nqco3xuN6dRnEFfe/wztu/dt9jhBgEiDmiCtks/feolvPnyLH5+7jyljhzZ7TCAqaywMv/1JSi0OcnJy0GjOTK2NjMx/G7LQkJE5TZSXlzN79mw++eQTDh8+7Le9Q4cOTL/pFgadMxVDcGjAOWxWCx+8+CS/z50NQNde/Xj6nc9IbNch4P6nyqv/uafe8QUgTKPi0NVj23R3tjnW5pUy4fctPmPTHnqdPqPPpajSQmXTBnUeCcnlwuN0+YmOxCgTyVFe+8nSonx++fYjtq1cgOTxIIoKRk66mAuuup3QCG9fiuKCHJ69cwp2q8VnnokhRma2jyNG3fbXubXawp1Hc0m3+wqDyA69OP+ZWYiKhrvTkuSNboB3saxoJt/dZbdydMMiUhfMoqY2dSUQZ7WPY/G1E09ZeN7y+wa+2nXEZ+yJAR15dnDbcuUlSaLfT+tIKwucAnUihseEcluPJC7tEIOmtig532xjyM8bmq0F0ms1WGyBtxmjEhl199soNTrWvHMPVXnHW31OzZFi0vH5uN6MjQ9v8xxWl5uQL5bikbwpTZ8N6HTazu9EbCurZtzavfWPRaWKqS//SFCUtxO33VzFxu/e4ujGxafl+aISOzDs3CvpP/4iNLqGPj12SxUvXTcOh8POZ78tp1uf/m1+jn07t/LeC49zIHUnAOGxCVx+1xMMOuv8E35HlAqBWJMGjdKbRpV57DA3nT8GPG4Wv/UEo/t0a9Hzm602LnniTVbu2MdXX33F9OnT2/xaZGT+vyELDRmZU8RsNvP000/z8ccfY7UGdgNqjEaj4cJp13PzA0/49L04sn8vz917M5nHjiAIAlfNuIeb7n/sjNo9Bkqfur5rAl+M631a5re63Az8aT2HKxvuhhqDw/jPrBUoVSocbjeZhVXNT+CRkJwuPK4G0dElMZTIYD1uCcrdAqVZR1j27bvs3rwaALVGy4QLr2bylOl8/PIDHNqzzff1RYXyervYZtNlWkOx08XlBzLZa/Ft2DboynvpfcF0350lb82NqBBPKhCqCrOZ90Dz3Yl33X4RvaIDi9XWUGy2kfz2TzgaCbpYvYaM68af1M60OR7ffJA3djUs6lNMOsYnRLCruJISmwO724NGIRKpU9MvIpgBUcGMiAmle1hgt6bHNh3kzd2tEwkxPYYx+Ian0BhD6scOLfuOvfM/Q3K3vfFjO5OOW3skc2vPJIyqU0tzyqmx0m6Otwbn8a6JPN418ZTmaynFdiftFvt+J4KiErj0he/J3LGajd+9id18gu9kGzGFRXLpnc/QbdBYADYtnMvvn75Eh649+Grh2jaJ5oLcbD557TlW/PkrAFq9gfOm383kaTej0py4oFuvVhBtVKOorZ/Lz8nigeumkJNxDIUoolQoePfe6Vx39hjUJ3iv92fkcOMrH7P94DGeffZZnnnGPxVNRuZ/GVloyMicAgUFBZx//vns2LGj1cd27NqD12f9SHhUDPO++oRP33gep8NBeFQMT771MQNHjDkDZ+zPPVddWN8Zt44fJ/Xj0g7N5zO3BEmSuGddGp+k+VreTrz6biZccWv94/yyGmpsLVj81YoO3C56JoUjatXYPAImUUIjwpG0nfzy1Tsc3b8LAJVGi9PuKwAuiwjmow7xbV5EB6LE6eLctHSO2xoiGwqVmotfmktIfBMXIsEb0ZBOkj6354/ZbPvhXSLa96YkfS+N/XlHJkWz+sZzTtv5X//rWr7b47uQT5s2ms4hbbPn/PlYPtP+2lX/WKsQqbh5cv2CrrVcsmg7f2YWtWhfQ0Q8I25/leB4/wigIIClvJgtXz1H8aGdDYMt/C/wrIRwFp4/+LR9do5XWejy3WoAnuuexIOdE07LvCej0ukifqG30WdIXDsq8rxpVIbQKMzlJ7/OAhApiBgEEQXgBqolDyVSywrs+4+7kPNvfoTPn7yJ/PRD3PvMq1x2/YxWvQaLuYbvPnmXH774EIfdhiAIjLzgCqbc9gjBESd37grTqwjVKevFzdEDaTx0w1RKiwqIjkvg0Vfe4YPn/8PxY0eJDgvhpvPHccO540iKikAUBWqsNpZuSeXj+X+xZvd+BEHg3Xff5e67727V65CR+V9AtreVkWkj5eXljB8/ngMHDrTp+KMH07jzivOIiU+sX+iPPOscHn31PULC2p6S0VoefOFNbjxvDA5HQwrKtctT0SkVnJPcNrtNSZJ4asthP5ERldiBMZfe4DMWYtS2TGiIAoJGBag4WGohJlKFTimgrl33derRn0ff+JrULav5edZMCnLSfQ5P1qh4s13saRUZABEqJZ90jOfsfenULbXcTgfbfnyfiQ/MbPISRK/YEAU8J3A+St+yDICwdt0pOb7HZ9t5p3lBel7nRD+hsbO4qs1Co3MTMwGb24PZ5SKoDWlqbo/E1qKKE+4T3388kZ36sPvHmVjKClAbmu/srA+NZOz973N09a/s+eUD3E47So2OxEETqS7KpuTwLkKTuxHVYySHFn3uc2yMXntaPzuaRq5Htmbqks4E9kafu6S+I3FYzVjKi04oMjqJSvoo1SQrlCSKyoAubBbJQ5bbTabHxQ6Xnaxm6mJ2rlrAwR3rsFSVo1SpmXTR1Bafu8fjYfEvc/nszRcpKy4EoOuAYUy7/1mSOp/cxEAhCkQb1ejVDamLu7Zs4PEZV1NTXUX7zt14c/Y8RvTqxIwpZ/P999/z4Ycf8vI3v9U3glQqFLhqzStMJhN33XUXd9xxB926tSzNSkbmfw1ZaMjItAFJkrj88svbLDLqyM/OJD87E5Vawz1PvcxFV00/4xaXTUnu0JmbH3ycj15pCPk7PB4uWbyD//TvwOMDOvrZoZ6IAoudu9bu4/f0Qr9tE668HWWThns6tRKdWonV0XJrVY9CQYnZQaRJTYUgohYkNAIoBYG+Q8dRWVbCnA+e9znm3fbxGBVtK9o9Gf2Neu6Ki+C9vJL6sawdq/n2tnEo1VqCohIIb9eNuB6DSOw7AlGhRBRFPJKHptXGVUW5lKTvRxBE9CH+Nq39406vCO0f6z/fvtJqaGPJgCaAxavD3bbA+eKsIoqs/k5hAAgiSB7COw0kbtBksrYupyx9L0fX/E73829EFMWALmSCINBp3BSiuw1k61cvUJaxn/T1CzDFeO1IIzv2pvOkqzm++kecloYUomNVFv/JToEInQqVKOD0SBw1205+wGniaE3Dc9mqyrFWBnYJ0wBDVRpGK7XEK06+VNALIl2VIl1RMVmtI8PtYo3TxjaXnabfbEuVt5dLUpc+6Ewtc9HbvXUj77/4BIf3pQIQlZDMFfc8Rb8xk1v0m6lVikSb1Kga/ZatWfIHz983A4fDTp9Bw3jls+/o2z6OKKMaUHPLLbdw8803s3nzZhYsWEBpaSl2u53Q0FB69OjBtGnT5MZ8MjInQRYaMjJt4LfffmP58lNr+taYWx98nIuvvuHkO54hrrjpTg6k7mTVot/rx9ySxEs7jvJ7eiH/6d+BS9rHnFBwlNocfH0wh9d2HqPMHjhC8dtHz2EICvFp3gUQYtRgLWu50BCUSpxuD2UVFrRhBtySgBVQCBJqJFYvnuez/9mhJkYGn7p15ol4MD6S2YVlVDW6O22vrsAOmEsLyD+wnX2L5mAIi6LbxCvode7VKDU6JElqSKWSIH2zN5oR3aUfosJ/AZUUfHoXNkkBrkt1G/tpNHesVtn6lk2SJPFOanqz2wVRRHJ7sJZ7BW3isAsoS99L+sYFJI25ElHhdfZSKEREUUSpFBBFEbE2hSsoJpnxj3zC/oWz2b9oNtUFmQAUHd6FYtk3iErfCExqSRUuj6fVvTKaQ6NQ0CPMxO6SKnZXtL54vq3savRch9f/GXCfHgoV12gMhIptF+YpCiUpCiNne3R8Y6vhmMf/c5FxYBfrVixn/KRJzc6Tl5XBR68+w5olfwCgM5i48Ob7mDB1Oip1y5ydgrVKwg0qn4jU79/P5u2nH8Lj8TBy4rk8++7ndIkLIzbId05BEBg2bBjDhg1r0XPJyMj4IgsNGZk28OGHH55w+6UTxzDt3LPo0bEdB9Mz+WHRCn5asrLZ/betWsJVt96D+xQ7iLcVURR56u1PcblcrPtroc+2fWXVXLN8N1E6NWclRtA/IpguIQbUCpEap5u9pVXsKK7kr+wS7CdIATGFR1NdWsisZ2/j0jufYeBZl9RvM2hVqBQKnCfppwEg1Do2SR4PFoeTkkobkcFeO1a3JJCeeZTsY76RppuiW9/xurUYFCLTIkP4tKDshPuZy4rY/uP7HF49n9G3PU9st/71qVRul5uMbV7L2ahOfaguzPY7/nSX1QWa7VSCavvKqn0eh6iVGE7SVToQsw/msCYv8LXUBEdir/T2gjCXeDtYx/QexYHfQ7BXllC8fxOR3QZjqyrDXlWKvboMR3Up9kaP7dW1/66p8KnTqMg+TEW2v2ucxeVmXV4Z4xL8o0xtpX9kMLtLqjhSY6PQ5iC6mYaLp5NNpdXNbtMicLlGzzCl5rRFVqNFBQ/qgljltDHfYaHxLQiP28XL999I3Nw/6Nrb197XXF3FNx++zbzZn+B0OBBEkbGXXMPFMx4kKLRlUT1BgCijGpPG1wFu9vtvMOudVwG44MrreOD5N2kXYSQhuO0dwWVkZAIjF4PLyLSSAwcO0L1794DbjHodf378OqMG9PHbtjk1jXNve5jK6sB3Lzds2YYQ3fEfExsALpeLT157lp9mfXxaFrQ6g4mY5Pak709l0k2PkHt4H2nrFgEw7vIZTLr67voFTaXZRlHlyV27RK0aEPA4nFCbbx4VrCPY4F0kbF36M79++Gz9/olqFTv6dTrttRmBOGixMXLPsZYfIAikDJ6AMSya6uI8KguyqMg58fFLr5vEhPZxp3imDRwpraLb+7/6jP2nfwdeGNKlTfPdvXafT23O+Phwll44pFVz7C2tYuz8zVQFSKdTag30v/4Zdnz1NG6HDVGlIXn4RThqyik7vgdreWF9s8OWIogiolKN29GQVqTQ6HDbfT+PU9rH8MPkttuwNmXe0XyuWuYtnH+2exIPneGC8CK7gy5LduAM8N0OEUTu0ZmIE8/c/cfjbicfWKtp2vowIbk9Xy1ai1anx+12s/CnOXz+9stUlHpTEXsMGc2V9z1NQoeW941RKQRiGlnXgtf17Z1nH2X+d7MAuP7uh7jpvseIC9bSIVzf3FQyMjKngBzRkJFpJXPnzm1228v3zQgoMgCG9unB6w/ewa3Pvh5w+2/zfuSZF19hb0HNPyY2lEoldz3xIqMmnserj95NTuap9R549JOfmfP64wC079CeoRddR0hMAhvmfcaqnz6jrCCHy+55AZVag0mvprTajvsERdKCQgHUOgU12q+40opSqcCgUZF7LM3nmCFB+r9FZAB00WkIUSioaEFkBgBJImNL4BQ8lc6A1hhCdXGuz/iOvNLTKjR2NqorqaNnM1azJ8Ph9vDb8QKfsf6Rretkv7O4kgsWbgsoMgBcNjNbP32k/rHHaSd9zU8++9SJDEGhQhMUhtYUhiYo3PvvoAg0QWFoTGFoa8fUhmDSfvuArE0LiB8wkdKju7HVRkwaMz+9kN0lVfSNaL7gvDWclxyJUhBwSRJfphdwf6f402K73BzfZBYFFBnBgsCDuiAiTyFVqiW0V6h4QBfE29YqH7GRk3mcz958keHjJ/PBS09y7KD3OxyT3IEr732a3iPGtyrCYtAoiDKofZzO7HYbL9x/K2uW/IEgCNz3zGtcet3NRBnVtA9rW4NKGRmZkyMLDRmZVrJ79+6A48EmIzdeev4Jj73uosk88e6nlJRX+m1LTU3FqFHSK8b4j4oNgD6DhzF7yXqW/vYj87+dxZH9e09+UC19R03kwI4N2C0WlCoVFSXeHPrwqFgSIoOYcO19hMYksuij50hdu4iK4nyue+I9DEGhBBvUlFU3XxhbnzbVZCEvAYXlZhIiTOQ2SZvqY/j70iEEQaC3Qcvaqoa+IQaNGrO9mYLmhgPpc8F0MnespiI3nSHT7qXPBdNx2Sx8ddMopEbWoX8eyuaRkb1O2zn/eTjHb6y14qCO+ekFFDYp3h4c3bK5nG4Pr+86xks7juI8yWdfodKiMgRhq2hwSorqMZzonqPI2vg7ldkHSRh6AT0uvRdBEBA4eTpYnTgxRCbQ/eK7SPvtPfJ2+nZOd0sSN61MZdOUEa0ySGiO9/dm4Kpd+GdbHXx0LJ+7O54+EdmYfKuDd47k+o1rgHu1Z15k1JGgUHKHzsTb1ioa31KY99UnzPvqEwAMQcFcdMsDjJtyHUplK9zKBAjXqwjV+R5TU1XFY7deze4tG1Cp1Tz19ieMO/diwg0qOkbo/3YDDhmZ/yVOT1WbjMz/EOXl5QHHR/bvjU574uJEtUrFmEH9Am4rK/Pmoxs1SnrGGNvcd+B0odFoufDK6/nyj9V89ttybnvkGcadexEJye0xmoLQaHWYgkNo16UHXQcOByClWx/ufesrQiNiAKgqK6ai1oYyNCoGlUIkLtxAv4mXMu2ZT9HoTWQe2MVHD19NSV4mwQZNs9EHQaGoXy1KLv+IgdsjkVdqprrM9050F93fm3fdRe/7Gbhq1AAyP3mGV645n8igZgq5JYmM7auoyPUWP3cafR6CKKLS6ons4GvbuTG7iD0nqQNpKUU1Vn5Oy/AZizNo6BDc+jQSs9PF01v8axuuWbabG1aksj6vDFuT902SJI5UmHllx1G6fL+aZ7cdaVZkCKLIsBkvc+Gbf3HB239x1tNzvc5TtRQf2IwmKIyOk64DoCB1FR5n4K7hgaiPgogKVDojfa96nF5TH/Tbb09pNXevSzvl1MJl2cU8t823K/tz+7M4XH3y9MHWIkkS9+w+RoXT/3tzidpAXAtcpU4nHRUqzlYFjiJMmDqdV39Zz8QrbmqVyFCIAvFBGj+RUVJUwN3Tzmf3lg3ojUbemPUT4869mBCdii6Rhr8t2ikj87+KHNGQkWklzS0wWvr/VXP/sTWe11QrNvb9w5EN8N6l79anP936BM5Nr3G4WbpoEQe3b6wfM4WGU5B1nOLcLNwub/lncHgkABqVgrgwA/QZwvTXvuWHF+6gND+LDx++iusefw9TQlcqzf4RgIZoRvOpVU63G4fD91jt3yzY9E1ciWxOJ/HhITx80QRuGDeEmz6ay8Id+/2Oq8zLACC6c18ModHeQVGk2/gpFB31jSg9uHQbS6+dVO+g1FYeW74DZ5NUtZu6JbZp8fXklsMBLWAdHolvD+fy7eFclKJAlxADoRoVdreHwxVmKltoazzg6kdJHDC2/rFarUQfEomlvJCYHkMpSNvM7m9fYMS9H6ALi8Valk/+7lUkDD7H22XuJDQWGnUkDDyHvT+/7dfUb9aBbNySxAejeqBtQ6H7b8cLuG75bj9RZfN4uH7bIZaM6knwKXYeb8x7R/NYXOh/g6SzQsloVcucm04356h17HY7yGtSS9Nr+DiMwa3req9VicSYNCibfB+y04/x4PVTyM/JIiwiije++onOPXoTpFXSLUoWGTIyfwdyRENGppWEhgb+T3DDzr3YHSdOkXE6XazdnhpwW3Cwb4qJ6V8S2TgZKlGot5ms68RtCvG6PBXleC1Dg8IifPpnaNVKYsIMRCZ14IbXvyOuUy+s1ZV88dTNZG5fQVMEhdgQzXCfeGEqNFnot7GFQ5tpmgOvatS7IyLIyM8P3cikPs0XtbYbcpbP4w4jzkap9o3KrErP58Otp9bDZcHBLL7efdRnTCEI3NQtqdVzfbIvkw/2Zpx0P5dHIq2shvX55WwrqmyxyNAGR5A4YLzfuD7cGzlLGjSRiA69cVlr2P7F46QMPRuA3C1/otdr0GjVqFRKFLWWt4GQagVXndDwuF3s+fnNZjuHf30wh0Hz1rOlsKJFrwGg3O7khhWpXL50p1+TPkXt53ZvlYWLN+6nzNGCJpYt4MNjeTyRluk3rgCu1Rj/scW2ShC4TuMf4Vv18zetmidEpyQ+yF9kHNyzizsuP4f8nCzik9vx0bzFdO7RG6NaQffof//vqozM/xdkoSEj00p69QqcH19eVc03C5ae8NgfFq+gsDRw2svatWs5++yzmTlzJvv370eSpP8KsaFSiKi03oWwo05o1NpPlhZ6c8JDIqL9jtNrVESHGDCGRHDti7PoOmwibpeTX959nLSlc3wiPIKy9u6uJMFJIjwqrW/aT/5pWrC1lKbPZ9T53jFWKRV8cceVBOsDp3QFRSV4X6ckgQRH1y/C5fCvW3lw6TZ+2Nu2Yv2Vx/O5+uc1fuO390wm3tjyVDOXx8OL249w97q0k+98CtgqS9jwyWP10bE6DLVCw1pZwvDbX8EQEYe5JI+ig9sQFCrKsw5SmX0QtUqBRqtCp1djMGoxGHXo9NpaAaJCoVA0imiIWMsL2fzRfeRuWwKAyhCMLiLR77wOVpgZ+etGzv5jC78dL6AqwGfN5fGws7iSu9fuo/2clXx72L9OQiEKvH7dhXSI9n5vtpXXMHbNXjaUVPnt21IqHC5u23mER5sRgP2U6r+tLqM5UhRKOjdJ29qzcSXFuVnNHNGAKECMSU2EQe0nHretW8U9V11IRWkJnXv24aOfFhOf3A6dSkGPGKOfKJGRkTlzyEJDRqaVTJs2rdltj771MTv3Hwq4bc+hYzzw2vvNHut2u1m6dCkPPPAAPXr0IDk5mVtuuYWlf8wnQev614oNUQBdrdBwOuoiGt4FU2WJt1g3NDIm4LFGnYrIEB0qjY4pD7/F0IunA7D5t89Y9/XL3oWlKJ6wNqMpoXHtfR6nmk9/zvuJSG3S5blnYqzfPnFhwdwycXjA4yvzM7HXVFKec4xN377F2s+9Hc6VGt+cdo8kce0va3lgyVYsLYwMON0eXl6bynnfLsPa5FoqBYHx8WEtrj3YXVLFqN82+dUZAD61E20lpttA2o28oHY6kaKD29n+zcu1jT9EQEAf5v1cWcoK0JpCGXnn6yi1BkqP70MfFgXAsTW/+s0tCKBQCKhUCjRaJTq9mrpAmK00l/Uzb6Ui80B9076oboMZPOMNtOH+YgNgRU4ply/dSfiXy+j+/WrO/XMrFyzcxvBfNhD25V8M+XkDn6RlUROgRkIUBIxaDQ/Ons+xwoYu3cfNNs5ev48HU4+Ta215rYnD4+GnnGIGrdzNt1neeqVATlZjVP+OnhFNz0OSJNYu+OGEx6iVIgnBWowa//Sy5Qt+4ZGbr8RqMTNg+Bje++53wiKj0CpFesYYfTqDy8jInHnkGg0ZmVbSq1cvRo0axbp16/y2VVbXMOjyW7j2wslcdd5EenRsx4HjmfywaDlf/bao2TkHDRrE7NmzWbp0KUuWLGHNmjVkZ2fzxRdf8MUXX6BQKBg4aDC9h49j4KhxdOnZF4Xin70b2RidzrsIdjaJaFSVe61TQyL9Ixp1BOk1uD1QVmXlrOkPERqTyJLPXubI5iXUlBcx8e7X0Ki9aWVN3aYCEZ7UmYxdDXfrd5ubd7E63VS53By3+abPDegQeHE6dVhf3vzdv4nj1h/eZcv3M/3GXXZ/wSQB723ez4KDWdw5uBvT+3UkVOefc292OJm7N533N+8nrbgi4Pm4JIlLl+ykR5iRm7snMSYujG6hxvpO2B5J4lilhU0F5Xx1MJv1+YFNEbpNupIu46ew98+vSd+8FI+rdRGliA496TZxGilDJ1OZn0n6+j+8ndMFkcwtS9GFRNJnyl2AgCHCK+IspV7DgeC49gy75QXWffAQ5lpb4Kzty+kz9R40hhNb0tal5B1f9xsAYSnd0AaHk5e6nrCEDkTEJzL0znfY8+MblB3a3Ow8RyotHKn0r1VpDo8kUWkJ/BmVgE/TC/gio4DzYsK4LCGC/iFGkvW+DfWqnC5SK82sKqrk68xCCu0N17xnmIkqh5OsmobniBMVdDyD/TJaQ1+FmiBBoKqRwD28a0uz+xs1CqKM6oApX/O++oT3XvDaaY8/72KeePNj1BoNaoVIjxijT08NGRmZv4d/xy+NjMx/GXfeeWdAoVHHnAVLmXOSNKqm83Xv3p3u3btz//33Y7VaWbt2LUuWLGHp0qUcOHCALZs3sWXzJj5/+2WCQkIZNHIcg0ePZ/CocURE+981/zvR6+uEhvfOqynUW6NhrvLa+IY0E9GoI9SowSNJVFTbGHD2FYRExfPLGw+Sf2gnC166hcn3z8QUfuI56ohI9q1/2FZtIdvuIFFz5rsuzy/1tS3WqlR0Twh83r2SYlEqRFxNcvWlJsXZ+tBIYrsOwBAaidNm5fDaBbhdvmImo6KGh//axqPLttM9Mpje0WEEaVRYnC72FVWwt7Dcr+i7OdLKarh/vbdYXacUidF5F7UlNkezvS3qiOzQi/hew1CqNYy67TkGX/MAR9f9Sd7ezZSmH8BWHViciEoV7YedTdcJVxDWrlv9eEhcCjE9BlOQtpXYnsPI37uRg0u/RRcaRefxl2MI837uzWUFCLVRlNgeQ+k79R52//QOAB6ng4yNC+kysflIpKWskOKjDbVTncZfTu8pd7Li1ZsBCIprh6gQCI+NYdBNL5K/exUH5r+P09L21KbW4JZgQX4ZC/K9aZdhKiVRWhUKQaDG5SbLYvfr8K4SBR7p14E7eyYT97Vv3VNPhepfY+mqEAS6K9RsdjVEbbIO78Pj8SA2qrcSBIjQqwjW+TtRSZLEp2+8wHefvAPAlOtncM9TLyOKIkpRoGeMEZ3q33NjRkbmfwlZaMjItIGpU6fy4YcfnlBstJTBgwdz9dVX+4zpdDomT57M5MmTAcjKymLp0qUsXbqU5cuXU1lRzoo/f2XFn960kA5de9SKjvH0HjgUtebvdZLR10Y0HHabt7akNnXKZvZ2QQ89QUSjjnCTFo9Hospsp0P/kVz3yjfMff4OKvIz+P2FG5l4xytEtetx0nliOvZGrTfisHif2wN8U1jOE0knP4dTQZIkvmri7DO5b1dUzbgSqVVKdGoV1U3SYgzhMVjKipAkD90mXMbIGx5rWBS6PXQaPInlHz+OpdK/0Z5HkthXVMG+oooWnbNRoyLCqCOjNPCC2erykN4Ku9XiY3tZ/ta9AIgqNUHRiQTHphCW0o12w85BYzCRnbqBwyvm1R8TktiJSY9+hCEkArfb7U3dEuqMogS6jJ9KQdpWyjIO0OP8m0n78wt2/TgTXXAEwfEdALCUFiBJkvc6CQKdxk+lujCTY2u80YnDK36k84Qr/IwCAPL2bmDrVy/gtFQD0HHcZfS74j48HjdVBbVmBjHtvK9JENBoVMT1G09k18Hkbl9KxrpfsJUXtvganQyjUqSLUY9OIeLweDhQbaHa5SsSy5wuypyBRV+iUcuM7knc0C2RaL2GNbmlfvsk/UuiGXUkiQoax4hsFjOFWceJTekIgFIUiDGp0QYQCy6Xi9cfu5fFv3gbqc546Cmuuf0+BEFAIQr0iDGiV8siQ0bmn+Lf9WsjI/NfgiiK/PzzzwwfPpxjx461eZ6kpCTmz5+PUnnir2JSUhK33HILt9xyCy6Xi1XrNjB3/kI2r17Bwb27OHYwjWMH05j72ftodXr6DR3J4NHjGTJ6Agkp7c/43UuDvqEA2+V01KdO1aVShUS0MBoRrMMjSdRYHEQld+GKl7/l91fvpjTjIIvevocx05+k3YBxJ5xDqdbSaeg5pK1sWMx+U1TOHXHhhJ7kOp8KqyvN7G2SAnPb5BHN7l9lsfmJDABzqbezdtdxlzBy+n983zuFSGS77lz69Dds/uldjm5pedSsKWd3b88nV00myqTn7RXbeH/VDgqrzSc/sBkEUSSx/1iqC7OpLMjE43RQkXOMipzmvx/aoDA6DD+X8qyjuJ1O1EHheJrYhEX3GIYuJBJrRTHasFhSRlxExobf2fzlswy77VUAXHYLtuoKNMY65zaBflfcT3VBJkWHdmItLyJ7x0qSB01CQgIkPG4Xe+d/yqG/vgNAqdHjslsIb98TAHNJPh6nA1Gprk/RAlBrVDidLlQ6IymjppA84hI2vns71XlHUWqNuGw1tddDgTYolKDYdoQkdiZ9w584zP6NOgE6GbXcnBLDWdEhdDLqfNKCJEki1+pgQX4pX6QXcLim+VTAuZP6cnG7mPp0N/B2Wm9K8t/cN+NkJAU4n4yDe4hN6Yiu1ro2UI2azWrhmbtvYuPKpYiiyMMvzeT8K64FvKKwe7QBU4A6DhkZmb8P+RsoI9NGoqKiWLVqFeeccw5paa133enSpQuLFy8mNrZ1aU9KpZKJ48YwdPgI9hXUUFpSwvYNq9mydiVb166krLiQTav+YtOqvwCITUxm8KjxDBkzgQHDRqE3mlp9ridD38hByWm31dvbumvz3kOjWiY0BCAqRI/HI1FhdRIaFcvFT3/JsvceJWv3elZ+/jSDSm6j16SrTiieuo6+2EdolLrcPJ5RwMcdE9rw6k5OtdvNA8fzfMY6xUYyoVenZo/ZetTfcrSOLmMvZtSNTwS8Ay8oFGgMJsbc8CSdhp3N7sVzyD+0s1Xn+9BZg3nl4jH11/A/k4fywIRB/J56hK8372Nzei4VrShABm/KV1hSZ8be/QYejxtzaQFVeRlU5nv/VOVnUJpxwKfWxFZVxo4f361/rNTqMUUnERSTjCkmmaCYFEwxyaQMO5cDi78mc+MCht3+NtbKEgr3bWDrl0+j0gfhtFRRnpdNcIIWb4aYNwLQ55pnWfXyVbisNez47nUiuw5DodZgrShk2+znKTvu7U/SYcxlVOYepeTobgRBgSRBVZ63eaIpJtmnt4YAqNUq7LV1EIIo0mHC1eye8xwKpZKBNz3Lzh9m4jBXYq+pJLr7YCqyjwQUGXFaNW/3ac+5MaHNN6oUBBL0Gu7oEMcdHeLYXVHDPbuPsbPCXxS+suMYZydFYWz0uclqIkw0QMRpKNY/nSQEiLCUFuQRqlcRplMG/K5Xlpfxn1umsW/nNtQaLc+9/yUjzzoH8KZZdY0yEKxtRVdxGRmZM4IsNGRkToHExEQ2bNjAI488wqxZs3C5Tu7+o1AouO6663jzzTcJCwtr83PXN/UDzrpgCmddMAVJkjh2cD9b1q5g69qV7N2xmfzsTH7//it+//4rFEolPfsPZsjoCQwePZ5O3Xv55EG3Fb3Gm8cvSRKORkKjjkD2ts0hAOFBWqqdHjwuN3qDkYn3vMHm72eStvwntv32CVUleQy/8n7EZu7MhsQkkdJvjE9R+LySSs4PC+K8sBMXBbcWSZJ4KrOA7CbWpg9fNP6E13b2yq0Bx6M692H0TU8GFBkAokqJ2+WiJPMQB9f/QcHh3fXb1DojolKF3VzpV+vRmG+27OO20f1ICW/o3aJWKpg6oCtTB3RFkiTSSyvZl1tMlc2By+Pm/dU7Sc0panZOgL1/fEW7YedgikrAFBmPKTKe+D4jkCSJvX/MorCRIApL6UZs98FeEVKQQXVhDi6bhfLMg5RnHvSduHZhXHI0lb3z3iSqy0DMxbnUFGYg1H4GrOWFBCd0QoD6egWVzkC/q59k2xf/wWmtYcusp0kefgG7576K01yFUmug9xUPE9tnDBvfvwcAm8NNdbWV4gyvm5Y+MhGLxY4gCN50LtH7t83mAAkEUSC00xC0wZHYKovxuN1MfuZbts95hfy9G9nzy4cBr9UVCRG81bs9IerW/TfcN8TIytG9mXkkl+cPZPnUZuwprebxzYd4b1RDimFTdzGtIPxr6jPq0IDP++YdcxKuDywUCvNyeHD6ZWQePYwxKJjXvphL74FDoXaeLpEGwpo5VkZG5u9FFhoyMqdIcHAwn376Kc899xxffPEFn376KTk5OX77xcbGMmPGDG655Rbi4+NPy3M37SAuCAIdu/WgY7ceXH3rPVjMNezavIGt67zRjpyMY6Ru3Ujq1o189uYLhIZHMmhUbVH5yHGERkS26TyUChGVRovDZsVpt6OK0KLR6rDbrCiUSowhrRNUVpdEsEFNRY0dQSVhVygYfs1DBEUnsun7tzm0bgE1pfmMv+V51Dr/pl8Aw668j7xDO3HU5t4D3HY0h3ldkxkaZGjT6wzEzLwSvm1SEzGhV2duGD+k2WM2H87gp427Am4bd+tzzYoMSZLI3reZ1AVf+UQx4rsPpvekacR2GeBdRHokts//jNS/vg04T1G1hfEz5/LDzRcxOMU/oiYIAu0jQmgfEUJRtZmb5iw+ociIaN8dtc5IXtpWtn77OuPvf7d+MSt5POz48V32L/Gei6BQIrldBEUnMeCKe+rncLuc1BTlUJp9jKr8TKoKMqgqyKQ6PwOnreHufcbmxcDihmtSGzU7suxbzCW5GCISMUQloAuLRVQoiOw6mKC4jlTlHaVo/yaK9m8CIDihE/2vewZDRHzteXoX5ApRRABqCr0RJ0NUMu5mutFXNeqEHt3/HDJXfcOhFT8R0XMs/a5/nuDVP3Hwz8/8jru7Qywv90xp84JfKQo83CWBZIOGm7cfofHZfbwvk0vbxzA2vjZ9sYngVLSkTfrfjCAIKIDGt2kET2CHufTDB3johqkU5ecRGRPLW7N/pl3nBgOBjhF6Igxn3vhBRkamZchCQ0bmNBETE8OTTz7J448/zqFDh8jJyaG6uhqTyURcXBzdunU7LdGDpjQVG43RG4yMmDCZERO8ReV5WRneFKt1K9mxcS3lpcX8Nf8n/pr/EwCde/Zh8KjxDB49nl79B6NUtfyuoLpWaNQ17dMZg7DbrBiCQlv1ul0eCbvLg4BAiFGD1WLHrlJidbjoOfEKTBGxrPz4SXL3b+PPN+5k0l2vYwwL0BAwOIJhV9zHmq9eqB+zeiQuP5jJpx0TOOcUIxsuSeLl7CLey/MtyjZqNXx2+xXNLiLzyiq59t05eAL0q0joNZTgGP/O3G6Xk2Mbl5C6cA7lOd5u3oKooP2gCfSaOI3whI6+B4gCPSddwYF183FYawKeR1Z5FSPf/JZbRvThzrH96R4b4bO9tMbK15v38vqyLZTUnLggfMClMwiJbce8R6aQm7qB7J2rSRowDo/LycZZL3B8w8L6fdsNO4fj6/+g6XpXoVQRHNcOQ2Siz+dYkiRsVWVkbl5M6i8fICiURHbqR01xNpbaehaAypxDVOY09LARFEoMEfEYo5LQBIVBo8y2iC4DGXTTSyiUDQvSOutkQVQgCFBT5BUaxuhkv7vtAFqtGovFjqu2N0b8kHPIXjeXyuxDVGQeICS5G5U5/j1GpiZEnJLIaMzlCZEU251+TfluX7OXvVeORimKaJvYYLv8Xsk/jyRJNI0FawIYWuzdsYVHb55GdWUFyR068dbsX4iOb0iHbBemI9r09xphyMjInBhZaMjInGZEUaRbt25069bt5DufJk4kNhoTl5TCJdfcyCXX3IjT4WDfrm1sXbuSLWtXcCRtD4f3pXJ4XyrffjwTvdFI/2Gj6+s74hKTT3gOak1d0z5vbr+m1olKb2rdgt7iaLiTqVaIhIcbcbs8WGutVZP7jeb8xz9l6cwHKM87zoJXZzDpzteJSO7iN1eHwRPJO7SDIxsbephYPBLXHs7mqsgQXkiOIbgZV6gTccBi465juX7N+QTgs9uuIDkycARn5d4j3PTh92SXVgTc3vNsX/cxh6WaAyt/Zd+SuZjLvREFlVZP1zEX033MpQEFVh1aYwhDr7iXtbNfanYfjyTx6frdfLp+N3HBRrrHRqBWiqSXVHKwsJSW9O5rN2QiSf3HIooCfS6Yzq75X7DtuzeJ7tSHDV8+T87uBme2dsPOJiyxE8eh2YW2IAo+3d8FQUAXHE6XiVdxbN18aopySBo4gQ6jL8Zlt7H1m1fI3uYtiteFRKHSB1FTnI3HaaemMLM+MtGYkkPb2fje3YQkd8MYlYQ+MhG30/teCgoFkseDudDbndoYnYIgNOgiCeqvi8moo7zcK+QMwRHE9BlH3o6/yNgwny7BEeSn+nZfj9Wqebv36TVnuL19LIvyy1lT0lADcrTSwqLMYi5sF42xiVNTjSThlCRU/6L0qaoAHzRtI4MJgA0rlvDM3Tdht1np0W8gr33xA8GhDd+zpBAt8cH/jiaEMjIyDchCQ0bm/wktFRt1qNRq+g0ZQb8hI7j14acoKy5i6/pVbF27km3rV1FRWsL6ZYtYv8y7SE9I6VDvZNVv6Ah0et/0ozpL3Tqnqbq7xRqt74LhRLhroxl16JQiSoVIUnQQVVYHVrtXbESmdOPip79i6cwHKMs5ysK37mLsTc+Q3Gekz3welxOdKfCi//viCpZX1HBjdCjXRoUSrT559GaP2cqswjJ+Kq7EEWBxJAGfLduIxeFgUMckIkxGSqvNbD+WxXdrd7Bi7+Fm504ZNJ7EPt5u4TWlhexb+j0HVv6GszYioQ+JoOfZV9Ft/BQ0eiPumpM3hes4ZDJHt68hb9/6k+6bV1lDXmXg6Edz6EMiGDb9P3gkCY9bot/FN3Nk/SJqSvL44+mrsZQXIYgKJI8bXUgkg699lGPrFtQefQKhEXBcpOOYS9k97z2OrvmV9qMuQqnRkjxoQr3QsFYUEdtvHCPu+xhLWQGHl3xJ/u7V3uNrU7bqqMw5TGWO//uR9tv7GKOSvMJDEHE7bLicdpQqTf1Z163RNRolWq0ah92JQimSPOJi8nb8RX7qatTGYJB805be6NWO0FbWZJwMURD4sF8H+i7fhavRZ/KTtEwubBdN11Df1EIPkOdx/6ucpzI9/rVtKR0b+uEsnPcdbzx+H263m6FjJ/L8B7N8fn/igjQkher+lnOVkZFpHf+eXxoZGZlTprViozFhkVGcfckVnH3JFXg8Ho6k7alPs9q3cys5GcfIyTjGr998jkqtpteAoQwZM57BoybQoWt3NFrfpn116VJKdcvzpS1Od31ihyhQ38lXpRBpFxPMwayy+pQjY3gMFzzxGcs/fIzcfVtY/snjDLnsbnpOmApATVkhyz58lLLc5u1Vi5wuXs0p5s3cYkYHGeln1NLHoCNeo0KJgM3j4YjNQarZypZqC3ta0GV8ddpRVqcdbfFrBtAFhTHyhscozz5K6qI5HN24pH5RHBrfnt7nXUvH4eegUDW6lqIIJ2nCJwgCQ67+D6s/foTyrP2tOqeTodYbmfTwB+iCGoScoNLQf8oM1n76LJbyIhRqLW6H95qNuOlpNIYgb58Mmo9oNOe+BJAy/Dz2zv+UiuzDlKanEdG+J/pwb41JnT3t8VU/olBpKDmyi/J0r6tU8vALaTfmcta8dh2Sx4M2NApbeRFqQwghSV0xl+ZhLvJGMCwluVhKvF3FkTxsevc2EAR0oTEYoxIxRCVijErCGJnk/bcxiBrJgyhASFIXQpK6UZF1gOwti33PXa/hwri2mz+ciBSDloviwvilUc+MZdklZFZb6R8Z7Ld/psf1rxIaWQGERpeefZAkiW8/fofP3vSmP549ZRqPvvyOT0pntElD+/CW38yQkZH5e/n3/NLIyMicFk5FbNQhiiJdevWlS6++XHfnA5irq9ixaR1b165k69oV5OdksXPTWnZuWsvHrz5LeFQMToe3W3VlmbdmwVO7CG5pfYbbI2FrFM3QKkWfxWiIQUNkiI6iCmv9YlWtM3L2fTPZ8O0bHFz9G1vmvUd1SS5dR1/M0vcerE83aowCaFpm6pJgZWUNK1t5R/90oNIZGHDJDNZ88gzZezbWj8d2G0Cf864jsc+IgMXhokqJx+7wG2+KRqtn6I0vsW3Oc5Qc231azlkbFMbkRz8gPMU3Xa2yIJOdvzYUP9cVWHcedykJfUeAJLWgFFmgSfZUPRpDMIkDJ5CxaRFHV/9CRPueGGo7xrvsFrqdeyMHFs3iyF/fAF7x0Wvqg8T3Hw9AdI8RFOxdR0SHfhQd2oqjtlP56Ie+YPVr07GW5tH53JspP76X4oNbUOmDkCQPLmsN1rJ8rGX5FB/0dQtT6UzoIxMxRXuFR0hKDyqyDuC2+0acbkyJPqGIOlVuaRfjIzQANhWUM6V9DBqFiL1RQXum2wX/IlOmTLev0AgKj0ZjCuG9Fx7j59nez9PVt97LrY887fObEGFQ0zFcjmTIyPybkYWGjMz/Q06H2GiMwRTE6EnnMXrSeV7no/RjbF23ki1rVrB7ywZKixqKcj975m6W//gFFSXebsmek9x1r8PidPvUBATqAhwVYsDudFNZ46htvAaiUsnI6/9DUFQCW396n/2rfuHQuj9wu3wX4SGCyENBIfRUaXijqpwNjpNHJ840CpUGQ0gk67/2Np4TBJGUgePoc/51RHXsdcJjBaUCWtDqQhQFVFoDQ298mfT18zjw1xw87pPbMDeHLiSSC56bg6mJZXFJ+gGWvn4ntqpyjBGxmEsL8bicaEyhDJp2f+1JN15oN7/oFkQB3IE/tx3HXErGpkVkb19Bv8vvQ2MMRqU14LSZsVf5LrR7TLmXuFqRAZA84iIK9q6jYO86+t/wAts+f5SiA5vZ9uXjuGpT1NwOmzdaBCSPuIQOE6/FYa7AWpRNTXEWNUVZmIuyqSnKxlpegNNaTWXWfipPEjE6Kyr0hNtPlWHhQegVIpZGgmJncSVXdoqjT3gQWxs5o+1yObhCklD/C+o0qjweDrh9raHj2nfl+ftmsPEvb5rdXU+8yBU33eGzT6heRedI/b/OqldGRsYXWWjIyPw/5XSLjToEQSCpfUeS2nfksutnYLfb2LttM689di8FudkgSRxP212/f3raLj78zwx6Dh1Dz6FjCY/xt/b1SL7RDLVCQBkgV9+oU6HXqpA8UGWx16dZCYJAn3OvRR8SwerPnvUTGcPUWp4IDiW0tvHa66ERHHE6+M1q5i+bBWtLqp5riRYVXKQz4EFilrmalsmowLiddiryM1CoNXQZeQG9zr6KoCivi47kciMoxCaL80aItdtOcu6i4I0QBJn0DL3oRroOO4ttv3xM1p4NJz02EGHx7TGFR/mM5aVtY/nb9+O0mQlP6UrPc65lzcdPeDdKHiSfWoXa1ClRQBS9p9D0NERBwN2MO1JYux6EJHamIvsw6Rv/pOukq9GGROIsMHN8/e8A6MNjsZTmk/bb+wQndCIoph0AER37oQuPx1qay76f367vNVJyaHv9/MeWN1gCF+5bhzEmmageI9B16E1Yh94+5+J22jEX5+CsKqCytjmhuSiLqtxjNPap0ogC3YLO7J13hSDQO9jA5rIGO+ddxVUAnJcS5SM0LEhsd9kZrvrni6c3uux+jlOl+Vkc3JaOQqnk8dc/ZNLFU322B2uVdI00nNEIkYyMzOlBFhoyMv+POVNiozEajZaBI8fSsVtPCnKzueyuxwgKjWD2S4/g8bjxeDxsX7mI7Su9ReVx7TrRc+hYeg4dQ5d+Q1BrdVgcJ49mgPceeIhBg9vlQUJNlcVXUJRkHKCpEelErY4ng8JQNlmUdFKpeUSl5k5jMNscdg46HRxyOTjmcmL2SLjw3vENFUW6KNV0UanorlLTR6VBUTtXilLFM5VlfqlYJ0IQxfoFrtYUQvcJU+kxYSpaU4jvjpKE5HKDICAoFAEDAIJKidSkUWBTggxq1KqGNLSw+A5Mvv9titMPMP+56YCEqFThcfnPI4gK2g+dTFSHHmya8wYAuWlbOLj8R7pNuhJJgoxtK1j1wWN4XE5iuw9i1C3P8Mdz0wFQ603YayrZ/esnDLr6Iew1lVTme12gqgqzOb5pKabIeEKTOqJQaes/A80VhINXVHYceynb57zKsTW/ERzfHnOxt6ZCVKoYPP0p4vqMZs3Muyk9vpetnz3KiHs+RBscQebmhTiqvVGP+jqME1Cdf5zdc55HExxBt/NvJbbvOJ876AqVhqC4Dhi79ATAXGNDkiR2znmegkaOUx2MOlRnwNq6KV1NOh+hUVTb3f2Grgm8sP0Irka/AWuctn9caHgkibXOJs5tokhxTjpqrY6XP5nDkNHjfbYbNQq6RxtRnOAzIiMj8+9BFhoyMv/P+TvEBoBa6120qDVaBk04n1kvPAhAUGg446dOZ++m1RxP20Ve+hHy0o/w19zPUWk0dOk3lJT+I+k8cDRRyR1RiAIaRfOLiCC9mrJqGzq1Eo8kUWP1LpALDu9m37IfffYdqdEGFBmNMYgiY7U6xmpbf8d5nFaPU4Lnqsp8xmM69SY6uSMl+Tnk7d9ee0ff242hTmQk9B7GxDtfQ6k5yWJPkpBcLu8Ct4ngEJVK3M0IDZVCJDJEj1IhklVU1TCdx4OgECk6theQiGjXnYufm82+5b+w+ZvX0AaFY6suB8nD+Pveol2/UaT9NRdoEEkbZr9GZUE2wbEpbJz9KpLkIWXQeMbc8TJrP30aa0UJIXHtGHTVfSx78172L51LxpblWCqK68+j+EgqxUdSa+dVEJrYifbDJtNh1IVojCH4V9I0kDx4MrvnvU9NcQ5r372/fjxl2HkkD54EEoy883VWvn4r1YVZbP74QTSmMMqOp574WjeDvbKE3d+9RH7qanpe9kDt+XlpXIOk0aiw2RyIou9/rbq/QWQAaBW+z2OrTaOKNWi5pF0M847l12/L9LjZ7XLQV/nPNbfb4LJT1sSZS/J4MASFMv2Zj+g6wNdFTq9W0EMWGTIy/1XIQkNG5n+Av0Ns1PXRcNhsVBQX1o/bLGYuuvl+Lrr5fsxVFezftp69m1azb/Mayovy2bd5Dfs2rwFeIjgqlu5DxtBv+Fh6DB6F3uTvmCMKAsF6DRU1NgwabxpVtdnKmi9f8MnBiRQVJxUZp4NJOj27nXZ+tzZ0ry44sofIhPbk7t/W6JwkwlO6Up59FI/bxeCpd51cZDRCkiRoKjgUIoG6yYUYtYSbNIiCiKtJjYxUW5B9dOMSADqPPBdRocRh9vZh8LidIHlIGXwWib1HIIoCWTvXAtBp5PkcXuvNm9+35Pv6ObuMu5ThNz5OxpblpG/+C0FU0PfSW0lrtE9jkeH32jxuyjIPUpZ5kJ2/fEzn0RfR86JbUWqNAROonFYzKq0eV23H8LB2PShLT8PVqABbYwxm9D0zWfbyjZiLszEXZ5/o8raIwn0bqM4/zuAZb9S7XYmNFvdKlQLRISA2cXRytLBO6VRxNPluqxstyG/tkeQjNAC+t9fQSRGCQfh7hFBjSj1ufrab/caDwqK45aVZRManUF5jI7i2y7dWJdIz2ohK8fefq4yMTNuRhYaMzP8IZ1psaBo17KsoaSgOd9ht2K0WNDo9hqAQBk04n0ETzkeSJHKPH2bL2hUc2raO9NQtVBbls+mPH9j0xw8IokiHnv3pOXQMvYaNJaVrb8TaLsfBBjUVZhtI3rqNQ5uWUlXou5B8NCgE0990J/lOYzCb7TYKPQ134feuml//b1GpIjKlG7rgcEozDhIUnUhY027eLaSp4BCUSiSnN8tdo1IQFaJHq2r4aVeIgq8W8XioKMik6Pg+b2rUMG/X+OLjaQA4zFWodEYGXfUgClHEYakm7+BOAPpeeAOVBZkUHm6IDKj1JrpPugJbZRkbZ78CQEy3Aaz95KmA6Vgnw+N0cHDFPLJ2rmHwdY8R23OYt46jdnvhgW1s/vIZbHVRJEGg3bDzKEtPw1xau5CufcEejxs/FXaKWErz2fLpwwy54x20wRGIooDH7aGmOIeyjAOUZRyg+PB2n2PSLTY8knTGawqO1fimIYVpG6IVo+PCGB0Xxtq8huhblSTxo93MjVrTGT2vpkiSxBy72c/LQKs3ctdbPxBUWwNUUWOHaFArvSJDrZRFhozMfxuy0JCR+R/iTIoNTW3qlNNuo7zYKzQEQUCSJKrLS9HofL3uBUEgLLEjo6a2Y9TUm3HYrGTv20bGzvXs3bya/IyjHN2znaN7tjP/s7cwBIXQY8hoeg0bS48hozHpgqiurdFIW/Gzz9wTtTqGaf4+20uD6HW0eriiNOB2j8tJ4dE99Y8dlhoOrPqVjsPORq0zBDzmZNQJDiQQJImwYB2hRi1Ck2IOAQGFQsTVyI3oWG00I6HnEPTB4QAUH0ur3z7oynswhEaiEAUy9mxCcrsIjk0hKCoeZaPrqtabcFiqWfDM9YTGt8NeU4lKZyQ/zdcCti1YyotY/e799L3sLrqffS1ut4t9f8wibeEskCSC4zsgKtWUZx6gLPOA95jSWoErgdvpZOMnj+MwV53gWbwoRIH4YBMSEjkV1SetkbeW5bPts4eJ7D4cc/5RKrIO1jdWDESNy8ORGitdTGeu34MkSeyu8D2HcruT41UW2gd53Zk+HduL/j+tw9rIeGGry0FHp43Rf2O9xkKnlYNNnKZEhcJHZACYrU4kj0TPaGOzdVsyMjL/bmShISPzP8aZEhv1qVP2htQplVqDw26jqqKUiLhEn/0lScLibIgAqLU6+o8cz7CxZzENKC3IZd/m1ezdtJr92zZgrqpg67IFbF3mTd2J79CVpF7DCItPISvN9w7yNP3fe4cWvM5WyQqlX0+AQNiqy9nwzWts+/kjhlxxN11GX9Rmm06NRkXHMA0qtQqLJATsP6EQBVy1l1qSJI5s8gqNTiPOBcBcXlwfIYjs0JOu46egUIgIAmTWpk0l9h7G0rfvJ3fvZupCBrHdBuBy2Mjdu5mSdO9iv7kFt1IUOKt9HIMTIukeGYJGqaDCamd3QRnrMwvZkR9YpO3++QOcVjMlx/ZSeND7PrcfeSF9r7ifvNR1bP7iafL2bADAWlmCy2lHoVCxf9FsKnObb5yoEAWuHNCNG4b3ZkhKLLrazvA1Ngcb03P5csMeft19qFnRYS7Kqm/yB6BQqQlO6ERYSjc0QRGk/f6Jz/5rS6rOqNDYU2mm0uVb13KgvIau361mYmIE4+Mj6B8ZxH292/HKTt8mlnPtZtQIDK3tfn4mWe6w8qfD6jd+/s3/ISI+xWdMAEKV3toMGRmZ/05koSEj8z+ISaOkR7SRtMLTJzbqIhouh70+oqExGHHYbVSX+y8ibS6Pz6JYIQqoGxWBh8fEM+biqxlz8dW4XS6Op+2qFx4ZB/aQe+wguccO+s3bXaWmi+rvL3AVBIFL9Ebeqa5o8TEOSzXrvnqZ49tWMPqGJzDWNp9r6fOZtEq0GhWiQkIrgkaSsElgbSI4lKKIvba4uig9jeriXJQaHckDxwGQ9ldDEf3Im55GEEUEQcTjcZGd6l3E56ZtoTznOEq1lqHXPsD6Wa+QuWM1E+9/k/z925vtzaESRR4c0ZM7B3clNsBC+9rav3fmlfLy2lTmH8zy2ydt4Vfe16HRMeDqR0gZeg4A8f3GoDGFYq8uQ1Qo8bhdWMuLAIGDS75p9tp1jwln9vXn0T/J/3obtWomdWvHpG7tWHc0mxu/WUR6aWXAeQRRQa9L7iC62wCCY9sj1NZmSB43h5d9h9PS4AA1K72Am1Oiz1jfhy8zCgOOS8Bf2SX8lV3S7LESMNteg1nyMF6lPSPn6JEk/nRYWeT0FxkAnfuP8BsLUkiUVVqAM9NRXUZG5swjCw0Zmf9RgrSnV2yoNd67oS6HHXOVd2FmMAVTXVZCdbmvK5M3muFbINu0E3hjFEolnfoMolOfQVxy68NUV5Sxf+s6dq1fyfblC3A3qgW4QHvm7hqfjHO0et6vrvDxS7rIZOSYw8khhx1nM5c5d98Wfn5yGmfd+SoJPYec9Hk0KgUmnQpFbQ1KYVkJJfu3k3l0P5lH91OYm4HdZkWSQKlWYwyLISShExHJXcg7sAOAlAHjUGl1OKzmeqERmtCR4Pj2gPducv7hPdhrKhEEkfKc42gMQUx++H2iO/em8Mhejqz9gzWfPtesyOgZFcKcKWPoFX3yZnX948L5+crxzNuXzowFG6lu4qYliArG3Pc+ER161o8pVRraj7yQA4u/9loAu12YSwvI37epvit5UwYkRbP07isI0Z88VWhUx0TWP3QN49+Zy6HCMr/tkseN5HERmtDZtxJEVJA0eDLHVjek9O2tsrC+tIpREf4GB6dKid3Jj9nNF9u3lHkOC/vdTq7RGOp7zpwOCj1uvrHVcMzTfLRPbPJ8QQoJlQC5Jc2npMnIyPz7kSurZGT+h6kTG6fDLlJTaw/bOKJhCvXm/1c3qV2wuTw+4kbAKzRaiikkjCGTLuLW595B1cS5qaf6zKd/NIdRFGmnVPmMnWsy8ktSAjs7tOe9mGiG6gLXjjitZpa+8wAZO1Y3O3+d41aIQYMoCGTs3covrz/IqzdO5LPXHmbpL19xMHUL5SWFWGqqsJqrqC4vIf/YPg6s+Y1137zKsW3LANCFRuGwOdj600c4a92bUkacj8Ppxu324PJ4OLTa2wBPkjwYwqI4/5lZRHbqjUeCfpfehlBbLB6I/rHhrLrhnBaJjMZM7dmOZddPxqT2vY6Sx036hgV++3cYfTEIAm6Ht7S4piiHjI1/BpzbqFHx080Xt0hk1BEdZOCHmy5q1u3o+Nr5eBq5StV9qjuMudRv3/tTj9dbzp5OHtmbjvk0zZvmdvK8pZL1ThvuNjR0bIxDkljmsPKipeKEIgNA06hWySRKqGt/kix2F2XVtmaOkpGR+bcjCw0Zmf9xTpfYaIhoNNRohEZEA/ikTgWKZqiVYpuevygnA5u5YaGrRSBZ8c8Gars2ERr7bN4FsFoQmGwy8nVCHL8nJdBb4y+IPC4nKz5+gtzGxdSShMcjoVKIGHUqJCD9QCqfP3A53z51Iwc2Lm02onAi9i6czQ/3ncP+2h4ZAJEdetWeiETx8TSOrPMu7HUhEVzw3NeEJXWq7xvhdtoJ2EUQCNao+G3aeEJ1bRN9A+Mj+PJi/1SajE2LsFX5ilZDeCxxvYbXPy45mtpsAfjjZw8nObz1EYVe8ZHcPXZAwG3m0nwq87w1D42X5UGxKUR1G+Sz78FqKy8FSA07FX7PK+WnnObTotqCFYlv7WYet5Tzh91CeTPRoeYo9rj5xW7mMXM5vzgsnMx7zBQWiSEoBACjKKFpsjLJKQ4sZmVkZP79yKlTMjIypyWNSlPrRuS026go8QqNsOh4AGoqGtJO7G7J7zl0bbStLMg67vO4g0pV37X7n6KzSg22hn4O6U7/ZVZXjYa5ifHMKq/gvdIyn4WYx+Vk2fuPcs5TczCERSMIoFUrcLo92Cpr2LVgFrsXft1salBrsFWXNzwQRUISOiKKkJu2mZXvPlTfXPD8Z2dhiozz7icAkoe1nzzd7Dm8dfZg4oPa5qZVx6XdU5jaI4V5aRn1Yx63i+Pr/6D7udMBr2g1l+YTFNu+viA8c+vSgPNplApuGt67zedzx5j+vL1iW8BtWduWYykrxF5Tib2mEofZ+0eSJBAEn/4uM4/kkaTXcku7ltfjNMfG0ipu2XHEb1zV7WJUiUPwOC2481Nxlx3FU7Tfbz9BE4SkUIElcCF+pSSx0GllsdNKiqgkSaEkSVSQJCrRCwIKBNxI1EgSWR4XWW4XmR4XWR73CU2FR8SEsqGg4bOnN4UAYBC9tUZNyS2poXf7yBNeCxkZmX8nstCQkZEBTl1s1BWD2yw1uJxe29nIeK/TVHUjoWFx+C5OFaKA6gSdwE+E2+6bUhHyDzQea0pwk94dtmaupVIQmBEWSneNhjvzC7A1Wow6bWa2fvcaE++biVbt/Zm21VSw9O0HKDq+L+B8akFgkElHX4OOXgYtEUrvcdVuD2kWG6lmK1uqLVQ1k2IjCCI1xbnUFGSw/rOn66MkMV0HEBKT7LNv6h9fUXxsHyqtHmcjUQWQFGzg2j4dmrs8reKJ0X18hAbA0TW/4nY6KMvYT3nmQew1Fb4HNZPuMyAphnBj2y2PU8KD6RwVyuGicr9th5bO4VAr5ro/9TgldicPd05A2cZI4m+5Jdy68yiWJu+nIqYPqvbjEAQBhdqAouNZuEuTsRXtx5vE4EHQhWIafhcKUzTV277CZSlFEdcfd97OgM/lAY57XBw/SfrTyYjVa/hoTE9mpqb7jBfnHKc67zgRSe0CHldQbsbl9qCUm/XJyPzXIQsNGRmZetoqNtxuN+Wl3vSN8uIiAAxBIYQ0SZ2yuzy4AkQzWutyIwgQolMR2uT252koNTllmpbQuk6S5z7SoOfD2Bhuy8v3iWwU7N9CxqaFdB1zEdaqcv589TYq8tL9jk9Qq7gxOpSrokKJUAX+Sb8gPAgAi9vD/NJKvigsY4/ZV6RJbhdLX7oRt8M7rjWFYqsuJ2XQOJ/9SjMOsvNnr3VrpzEXsn/pDz7bb+zfub5I/VTpGR3KsMQoNmUX1Y9Zy4vYv3BW/WNRoSQ4oSMuu5XqgkwCtkoHesWd+h3xXvFRAYWGQq0lKDYFtSEYjTEYtSEYtTEYjSEYpdbAgaXfUpPvG3176WA2SwrK+ah/B3q0IvpTZHfw0J50fs31j0II2mA0vab6fZ88lTl1/0LUhWEafR8Kvbd+SrJ4v7ea+AG4tSbsx9e0+FxaikIQuLZLPK8P70ZGlcWnaSCAx+3mh3ef4tE3vqlPzfPZ7oH8MjOJkX+/bbWMjMypIQsNGRkZH1oqNkoK8/njxzlsW7eKI/v3YrN672wX5ecCYK6q4JvXHvPum5+Nx+32q80QBNCqWrcoNagVRBhUqBQimiZ1Ds5TLF49HTianIOmBepnpEHP3eFhvF3quwDb+tP7dB44hqVv3eMnMkTgzthwHk2MQtvChb1eIXJVVCjTIkOYU1TO01mF1DS6I14nMhIHjidnl3fBmTxgbMN2p4NVHz6Bx+0iZfAEn+Z9dYxJOfWUoKbzNRYaAIaIOHQhkYhKNZLHjdNa3aguI/BnoC4ydCrom5kjuttght/+qs+Y5JawO5w4HS4GtxvA5o8fwFLg279iR0UNQ1emMik6hJvbxTA2Mhidwt/tyeWR2FVRw6yMQubllGDzBIhKqQ1oh9yJoAnyPQ9HFY4jf3kfKNQYR95TLzIAPGavYNEERaKKSqHo+FpOVzf1OIOGm7slcWO3ROKNWpxuD7eu3htw32MHUtm5cTkDR04KuD2nuEYWGjIy/4XIQkNGRsaPE4mNnIzjfPbmC6xd+idu94nrBCpLi+v/fviS4Qy/9AaGX3IditqCbY1CRGxhNEOlEIgwqDE0at5lCvF1NMo7yfn8HTQ9h6AWioCbQkNYVmNmr91eP2Y3V/HXh49RnOmbmBOlUvJN50QGtrEBnCAIXBcdxvgQI9MPZ7O7SXSjIvMQktvt7QYe3dBoccfPH1OefRRtUCgjb36SDV++7Dd335jT2/OgX4D5zCV5mEvyWjVPfuWp26TmVjTTjLCR81mdwHA4XN5S+drPd1Bsez+hAd4l/dLCCpYWVqAQoJtJT7cgPQaFiMMjcdxsI7XSjPUErlKCNgTt0DsRjdG+czuqsW36EJxeVzF1u9EoDA2RHclpRXJ4X5M6KAKFWo8uaSDWrIZaFK1C5LzkKI5UmtlfXuMXkWyMWhTpFW6if2QQExMjOT85yset64XtR9hV0nyn9tV//tis0MgtrQZimz1WRkbm34ksNGRkZALSVGx4PB5++fozPn3jBey2hqZbeqWC/pFB9I8MJsmoQykK1Dhd7CutZkdxJUcqvZGOsoJc/vzoRVJX/sHUR14nOqVTi6IZogChehUhWqVfSkjHrj18Hme7XZg9HgynKXWnLRxyOXwedwvgLhUIpSDwYnQkF2Xl+Ixn79/h8zhGpeSPHu1opz31poQJGjW/dUvh8oOZbKtpeE+ri71RqeQBYxAFEESBgkO72bNgNgBjZjyDITgcV5P6DKUoYNL4um6dKoGcqyI69CayywA0hiBvipIxBI0xiLXvP4ijJnBzve2ZBUiS1OZmdG6Ph13ZgZviGSITfAQGUC8ySg5tI+3nt7BVnrzPhVuCfVUW9lVZTrpvHYqo7mj6XI2gaXK331GDbdOHeKrzQVCA5EYR4ltr464tAhfURhRqr2gN6jcVe8F+PA6vOLG5PWwrqmDphUNIMGjZU1rN8SoLVpcbh8eDRiGiVyroFGygR5gJdTN1FO+kpvt1JG/KwT1bKcjJICYhxW9bZY2DGqsDo+7vb8YpIyPTdmShISMj0yxBWiXdo43szCji8duns3n1svptPcNM3NErmWmd4jA2UxsAsLe0ik/TsphzKBeLy032wVTeu/UCrn7yHcaec+EJn9+kURBuUDdbMJuXnenzWAIOu5z0+wd7aRxq4jLVU9vyc+mq0TBYp2WrNXDfAK0gMK9b8mkRGXWYlArmdk1mwt5jZNp9z93tsLNvyVxqygrZv2wekuRBawpl4zdvsOL9x3DZfbs8uz0Sbo/ntNVoANgDRKmSh5zt7Z/RhKCYFEqOpgac53hJBVsy8hnaLq5N57E47TjllsDviyGmA9WNhJogCEgeD4cXfkbG2p/a9HwtxV16FHd5OsqYBkctwWnGsvkDPNV5XmcpjxucZkRDuI8jscfsrc9QGiPqxxTaIMKGXEPJuk/rx7JqbIz+dRMfjunJJe1jGBwd0uLzq3I4eWTjQb48kO0zHh+kJzeAoNq/a2NAoQFe96kuiXKXcBmZ/yZkCwcZGZkTopacPH3rVfUiQ6sQeWN4N7ZPHckt3ZNOKDIAeoUH8cHonuy+YhRj47y54S6ng2+eu4uty/4IeIxGKRIfrCHapGlWZLhcLl79zz1+45vt/1xzr+MuJ0WNLF8VQBd160TBtODm+zw8lhhFt1Y0m2spIUoF77aP9xtP++sHNsx+ldQFX+G0elNsbNXlVBfl+okM8Aq9QydIjWkLB4v9IxQaU4h3wdzkjyH8xPUhLy3e6LWcbSVuj4dXlm5udnvRwe0NpyEISB43+35+86QiQ8DrUnZKHgZuB/Yds3DleNOdBKcZy6YP8VTlIWhM6AbfWp86JeojfA8NIDQAYnqPwRDT0Wes2Obg8qU7mfbXTnYGeE+aYnW5+eZgDn1/XOcnMkK1av68eiID48L9jss44m/DW4fcJVxG5r8POaIhIyNzQm666SbWr/UWBicZtfx5/mC6hRpbPU+7ID1LLxzMKzuO8uy2I0geD589fTdh0XF07O1thiaKAuF6FUEaRbMpLpXlZaxftoi5n39A5rHDftv/tJq5yRiE+h/op/GrxXch1FerbXGhdh0TDHoUQNP7+P0NOm6L9V+YnS5GBhuYHhXK7KauSo36QPQ8exrxPQajCwlHFxxG5o41bPz6DZ/dt+UW0z0q5LSd17Zc/5Sj0OQuAffVh51YaCxOO87sTXu5oZX9NGau2MaW9OZrQrI2/EZQfCcSBk1GkiT2//YuedsD9/MACFcomBpk4orgIOJUKspcbnbZbKTZ7aTZ7BS73TgkDypBIEgUCVcoKXA5SbXZCWgwK3mw7/4WQfLgyFiLpyoHQW1CP/wekLy1HYJKj6DyLd6vc5xSGBqEhiCA0ahDVAcWtD8fK+DnYwUMigrmrIQI+kcG0yFYj0oUqXS42FNaxfaiSuYfL6DM7t9DJlynYdG1E+kVHcqg+Ei25/m6Z2UfP9jsdcstqTml9DcZGZm/H1loyMjINMu8efOYO9fbOTreoGXFRUNJCWpbATKAKAg8MbATaoXI45sP4Xa7+PKFB3ju2yVEBpsI06sCdggvKy5i3bJFrFmygJ2b1vkUoYdGRFJdWYGrNmWpQvKwymZlsq7t59kWzB4PS5rULFwZHNTM3s2jEUUSVEoynb5LynvjI854M8J74iL4uqjc13OoVmQYwmMYOPUONIYgEEBAIKZrf785vttznOv7dTot51NhtfPnYd+aFbUhuFlBoa+NaKj0QTgtgSMrd/zwFyatmsv6dz3p80uSxJcb9/DY781bvsb0GUtB6mrSfnkbQ0QclTmHydmysNn9rwoO4qGIcJ86ojClgglGAxOMJ7a5TXc4eKywmF22QFE7CVvqd4C35sI06h6UQXHY87ypZKIhAoUoolaIXu0IYPW6nGmCo1ArFUgSGIxalEoRt+3E3bi3FVWyrejkkY3GDIqP4OtLRtE5whu16xrhH72rqapo9niHy0NxpZWokL/3uy0jI9N2ZKEhIyMTkNLSUu644w7Am+Ixd1K/UxIZjXm4Xwd2FFXyy/ECCjKPsfKb97jrsed89ikpzGfN0j9ZvXgBe7ZtwtPI0lNvNGGpqaZLz758Nn85M595hPnfNfRW+MpcxVitDs3feOfzW0s11kZpOaEKkbONrY/8AGiaNB6MVSuZHHrmrT2TtGomhhj5K4C7krm0gD9fuIXzn/wcjTEICYnw5M7oQyOxlDdEHVam57O3sJxe0aF+c7SWL3cewdJEcMX2Gt7sHe261CmVztCs0HC6PVz55QL6LNlEu4gQBEFArRBJCgumf2I0Q9rFkRQWREZpJY/8uopfd/tHzeoITuxKryseQ/K4Kdy7jh1fPYnHaQ+4b5hC5O2YaIbp2/4daqdW811CHLPKK3irtCywCa0gYhx+J8ogby2KVFvwrTBEIAjeBpkIoFUpKatNndIHR6NRed3cQsOMqJQKb/OK04RWqeCZsX25f1gPn6Z7GqW/la/bfeKmgDnFNbLQkJH5L0IWGjIyMgH5+OOPKSnxLkTu69OOYTGnvnBszHujerAmr4wSm4Pfvvmc6++4H0tNDauXLGD1kgXs27HVZ/9uvfsz5uwL0Gh1vPv8f1CqVDz59seIosjFV9/oIzSy3S4+r6nkLlPIaT3n5jjgdPCd2fcO8NSgINRt7CBoabLIuzg8GOXfJJqmRIQEFBoAJRkHWfLmvVzw1OeICiWiqKTb+Cns+OUTn/1mLNjAuhvPPaVOzunl1Ty/erffeMexlzZ7TF2kw1FTgSm2HdX5/g0O60jNLSY1QFoWQKhe22zhdx2CQkWvyx9GoVLS68pHsZTmU513NOC+kQoF3yTE0b6V9TqBUAgCt4SFEqtS8nBBEX5yQPLgKkxDFZoENNRhiHXpUbViQyFIOGu821Qmr+WtUqVAXesaJqr8z/WKnimAwK/7M3G2QIgkBRuYMbALN/brRFSAruzFZv9rrG4mZauO3JJq+neKOulzy8jI/DuQhYaMjIwfLpeLTz/1us6YVEqeGnh6UmEaE6XX8Ei/9jyy6SAOu43p546qb/ZXR88Bgxkz+QLGnH0BsQlJVFdVcs3EoQBcc9t9pHT05up36Nqdsy+9kiW/NnSp/sFSw2iNjt5n2IHKLkm8VFnmU1MRrlBwQ2hIm+aTJIniJk5L/Qz+i7QzRT/jiRd6BQd3sufPb+h70Y0AdJswhV2/f4nH1ZCPvy23hGdW7eKlswa06RwsDhfX/boOc5NoRmhyV8JSujd7XJ3QcNmtdBw7hV1z32zT859MZAD0uvg2gmJT8EigVOuI7Ts2oNDQCwKz4mNPi8hozPkmE9VuD88Wl/htsx5cjDpxEApDRL2zVONCcI1KidtSBh43iAqUeq+Tk6GRGNCFxlKT72tHW2S2s+z6yZSYbWzKKWZnXgm7C8oos9pxuj1olQrah5oYEBfBgLhwBsSFn9CBbFe+f3fzyNjEAHs2UFxpxeF0o1b5R0NkZGT+fchCQ0bm/9g76/i4qrwPP3fc4q5NJUndjZYatFC8gru7uyyysCzuizsUpzi0tFCjUHdv4+4yGZd73z8mNpmZWFN2X7jP55Mmc86558pM0vM9P5MJYPny5ZSU+Hzjz8tKJqwPqioH48LBqTyw8SAOr0hVeSmCIDBywlHMPOFUZhx/MnGJ/qlIX3/yYeqqK0kfkMn5197i13fj/f9m09pV1FZVAD4f9HsaanklOo5+qr6t7dCCR5J4oLGW/A7uHg/FxxIdpMJzdyj3eHB2yIw0ytj3maZC0V+rIUKpoLGTAnGbvniF/hOPJSKpH8boeMbOv5zNX7zqN+aJtb4K0A8fM6ZH6W7rbE7O/HxlQDVwQVAw/pzbOg0EVmm0aEyRuCwNhCdloNDoEF19n4Usa845ZM85G1EEu82FJHkp3bws6Ng7YmPI6mYtlZ5ydkQ4q202Vlo7pImVvDjzVmMYsbDVoqE0+hIJaFRKlAoBZ5PPmqM2xSIofHEbhnZCIyxpENV71/pNu7Gkmianm1ijjlOy0zglu3NR0Bkuj5ffCgPrkvTLDC0kwRcyVFZrISMxdHY2GRmZ/x1koSEjIxPA77//3vrzuVmBaU/7ihidhhP7xfNVnk8cfLhsHf0GZgWMkySJDWt+5duP3wXg2FMW8MNnH1JfW019TTV1NdXU11QhdXDnaJBEbqiv5vmoOAb0sdhwShIPNdaytkM63eOMRo7rZWwGQFMQl5TUPi6C1xmCIJCiVdNoa4s1mD24H7/sb6tZInrc7PxpEdMuuw+A0addRv6mFdQW+Fcwf2LtLtYUVvLGqVMYEhfZ6XklSeL7A8Vc+8M6KiyBqXOHzj2PuEEj8YoSktT2jBrL8ijdtpq6wv3UF+7HZWkAYPWz1/f01rvF4BMvZcSplyEIAkolGIxaineux1pVFDB2kl7Xq4QA3UUQBP4ZH8eWwmLMHT43zsL16AafhNgco6EwxqIQBDQqn+hzW1qEhs9tSmfQITS7+nlcdtz2wGBwq9vDRztzuXpC14H0XfH1vkKqg1iO+meN6PLYkhpZaMjI/H9BFhoyMjIBbN68GfBVeh4Te+QWSgDj4yNahcYX776OKSycupoq6mtrqK+ppr62irqa6tasUgDvvvBEt+evFUWurqvixrBITtIZ+iQ1Zp7Hzb8a6zjg8U/faRIEHk6IO6y5PUEifP+s+IwWlB0qO5wyYhD5NY3k1jS0th367QcmnH0jWkMYSpWa2Tc+ybcPXoSjqcHv2HXFVYx8+RuOH5TCBaMGMiEljv5RJgRBwO0V2V1Vz9rCSt7eepDdVf7HthCfOYoxC69BBJQK8LiheNsKclZ+SfWh7T26N5NWzfkTh3H8sAGMSU0gyqDF4nSzs7SaFQcKeW/dLqotwStz95u2kGGnXOb3GVIooGRD8Howt8fGoDjC712CSsVFkRG8VOefllhy23AW/A6iBwQFCn0UKpXQeu2uZouGpjk+w2DQUJe7lYqdK6ne90fIoPbHf9vJOSMGEHEYRSPtbk/Q+Bu9MYzh46Z2eXyJXE9DRub/DbLQkJGRCWDPnj0ADIkyoQuSGaYvaS9kWiwWIREEklP7EZuQSFRsHFExcUTHxhEVG090bByRMbFERsfyzvOP8esPX7ceZpUkHjPXs9Jh547wSBKVvfvT55YkPrY18a7FTGCFAHguKYGoXrpMtSAEySVkF0VMhzlvT3B02B0P12u5dfYErvu0rTK822GjaPsf9J80x1d7ISGduXe9zJLHr8Vp8U97KgFLc0pZmuOLwdGplOhUSiwuNx6x6wJ6A48+CZVWh8flxlxVzvr3HqHqwNYe39cVU0fx+PyZROj9XZmMWg1zwo3MGZLBQydN5YllG/j30nV4OjyH4vU/MGT2mYQnpLVW2Ba9Hip2/U5Hhmu1jNT9OS5vZ0SE82pdfUCNDXfZdgAU+iiUKiVKRdtnyN0sNFCqqNnyOfn5G3FZ6toOFhStNTjaU2K2cevSjbx12tRei/Z//LqVA7WBWcGmzjkNra7reCSr3U2DxUmk6cjGX8nIyBw+stCQkZEJoKnJ5zYRexi7lt0lpt05BmQPZdxR09oJhzjcTicP33olbpeLB559nTmnnd7lnPc/9wY6g5EfP1/k177e5eDMmgpmaPUsMJgYrdZ0a7FU6fXwrd3K93YrdSGy7ZwZHsZ0Y+d1ELrDbqcroO2Q3cWYIFl7jgQuUaSwQ6G1OJOBqQNTuPmLX3G3i90o2PQr0f2HYoiKQ6lSE9lvCHPve5s1L99NfUnwDEwADo8Xh6djScJAotMyqSs+xLbFr5Ex6XgKN61k46InglYl7wyVQsGiS07uVu0MrVrFAydNZfaQDE5++QvMjrb3Q3Q72bzoMWbd+nLr56axLA+vO/A9O+sIukx1JEGlYpbRyHKr1a/d21QO+NymVM31MwDc1nrsVYcAaNjbJh5V+jAShk0HhYLSjcGtNADvb88hOczAw8eM6bHYePaP3bywPrD6t1Kl4phTzu32PKU1FlloyMj8P0AWGjIyMgH8mZV32+9nH3vyfC687ra2Pkni5vPn4Xa5mDj9GGafurBbcyqVSu567AX6DczkrWf+jcvV5gbiBVY47axw2klSKBmi1jBYrWGQSo1JIaBAwClJFHk8HPC4OOB2ccDjDkwj2o5+KhX3xcV2MqL7fNcU6Bu/w2r/04TGPrsTV4dg9LHpCYTptIxIjmNrcVsAb/76n8lf76uArYuIwRidgCEqnris0WjDo6ncvzkgbqY76MKjOerie0gdM53v7juLxrICfn32JqoObg86PiNMz1mDkukfrue6NbvxdjCSvHz2nG6JjPZMGZDC4qvmc9yLn9H+cdQc2k5N3m7iBvliCeoLDwQ9frz+zwvgbzlfR6EhuX2CTGWKBY8TW9EO6go3YCvfR+tvnqAkNnsSiaOOISZzHE5LPRtevKK5T0HiyFlU7Pg14HyP/baT/TWNvHzS5KCpaztSb3dyy5KNLNqZG7T/5LOvIr6LjFPtKa1pYlhGTLfHy8jI/HeQhYaMjEwA4eHhNDQ0UGUL7qfdl7Q/h8HkX5RuyeJP2LruN7Q6Pbc98kyPBJAgCJxzxQ0cNes4HrntOg7uCnS1KRe9lDeLjt4Sr1Twdmoyuh5kVgrFPqeTTfbAANmNTTYuTog+7Pm7w8Ym//iE1Mgw4sN8lprshGg/oaFQqkEhILpdOBprcTTWUpsfuFvdXaJSBzHkuDMZePRJqHVGJEli8oV38fPj1wQVGdmRRh4/ajAnpMejVAg8vOlggMg4cfgALp0yslfXMyurHzfMHMeLK7f4teeuWtwqNBqKAwv6GRUCGeo/L4AfYJgu9O6+p76Qym/vRPIGWl6GnP8MiQMGAeC01LPlzVuQRC8IAiPPfZDogWNwNlZTX7Az4Niv9xWyuqCCK8dnc/nYTDKCFJUsNVt5Z+shXtu0n8ogdTMA0gcN4YQzL+vurQJQXmfF6xVRHkatFhkZmSOPLDRkZGQCGDFiBEVFRexrsGBzezEcwZz122rafLUHDh7W+nN9bQ0v//t+AC656S6S0/r1av6MQdl8+P1yXnv2OT59+wXs1kCLQW/JUKt5KyWJtD5YVHokiX9UBi8g932dmcc8XiKOcLyMJEksqvIPKp6YkdT6c8cCfFpTJMfe9QY6gwFrXRXW+ipsdZXYGnzf7fVV2OqqsNZVInoCF7kdqS/JYeuXr3FgxdcYouMxxiSiUCjxBUT4K4hbR/XnoYlZ6Ns9ky9yygPmfPjkaYdlobt37lG8/tt2nO1cvUq3r0b0eFAoVdgbA2tBZGo0RzwIvCPZndTp8DT4UlWrTPFEDJqCNiadsl9fRKk1EZ3sK+xnrytn2/v34rb64msGHX85MYN8dVDGnn036968HVttWcDcdXYnj/+2k8d/20lquIGRCdGEa9VY3R52VdZTEKL4YwuRMfFcc++zqHqYFc7jlahssJEc0/sMbzIyMkceWWjIyMgEMH78eH788UdECbZUNzIt+cjtpm+sbGj9OWtoW2rLl/99P+aGegYNGc5Zl15zWOfIjAvDpPK0iozUjExKC3P90qT2lAsiI7g1JhpDH1gyAN6qb2C3M7gFyS5KfFrdwFVJR9ZVZKPFzp4OVqzzJraJv7JG/0WjvbGaH+6djyk+jYTB40kYPJ7Usceg7VCRXZIknJYGVj93Iw0lvtiAmAHDMcWn+sRIfTX2+kq8bhcOcx0Ocx21BftCXufL04dz5bB0vzazy83+Bn/XoXHpCYxOS+j2/Qcj1mRg3qhMPtuyv7XN63ZSXXiIyNRMPM7AXXpjH30mekJn59SmjiUsezb6+IEYtGqaCn0WGk14HBqdhqbyHHZ89BBuawMA4WlDSJ14KuCzDBojY5hy+ROse+surEHERgslZhsl5uAZu4Jec0QsN/zzNeISU7t9THtKayyy0JCR+R9HFhoyMjIBTJs2rfXnDw6UHDGhUWFz8nOxbxc/c+gIjGG+ANpNv63k568/QxAE7vj3c6gOw2IQpVfz9isv8NKzjwNw1pV3MmfeBdhtFopy97H5t2VsX7+S+prA4mEdUQInmExcFBXRpxmF1lht/Ke2rtMxL5TVcEZsBNHqI/Nn2ytJPFzk/wzSosI4afhAwCcWthYFf0aWqmIsVcXkrvFl+opMzSR+yHgSBk8gLnMUap0RXVgUY8+5jRVPXQ1ARMpAxp9/V+sckiThspqx1Vdir6/G3lBF6fY1VOzZ4Heu+8cPChAZADtqAi1VUwf2bgEbbJ72QgOgNn8v+rgMRCkwa1aQpiNOZ5I5avx5KLTGVstOS8YpfVQSdXnb2f3Zo3hdbe6D2Sdd2zpWo1QAAoaoBI6+5nl2LH6Oin3rDvt6w6ITmXv1Uzg1vY9tKqmxMCH7sC9FRkbmCCILDRkZmQBmzZrFwIEDyc3N5dNDZTxx1GCij0AGqnf2FeNuTm96ytkXAeB02HnmgdsBWHDhFQwdNa7X8wvA8s/f44477gDgulvvZszs8wDQG0xkj5hA9ogJnHftfdTVVLBnyx8U5uylOO8AxXn7cXXYrVYDCyPC+lxk3FBeEZAu15QwAEtlXuvrKreHewoqeD2zbxbPHXmjopYNHeIzrjh6dKu71IoDRdQHKbAWjIaSQzSUHOLg8k9AUBCR3J/EYZNJGn4UhuhEbHUVVB/c5neMIAhoTRFoTRFEpWUhiSIHln/qN2ZsXDj3jhsU9JyV9kBr0NCkvgnQDzaP0+xzMVOqAz8L9WLXGbX6mgZviHMq1QgaAwBCc07elmJ9AiI7P3oISfSg1BjwumwkjTkOU0L/1sNVqjZLidYUyYQLH6Jw83L2/vQ6niBF/bpCodIgelwISjWGiFiqGmwkxRgJ0/f870ud2YHd6UGvlZcyMjL/q8hRVDIyMgEoFAquucbnruTwity3IXhmncOh2GLnme2+hbTeaOL4eWcA8N5LT1NamE98UjJX3nbfYZ3j9x8/55abbgDgnnvu4enHHkGlDO47Hx2byLTjF3D+df/gnmc+5B8vfBYwxgFcWVbOm3X1eA9z29ojSbxeV8+1ZeU4Osyl1BgYfNKtRKQN92tfXNvIp9UNh3XeYGy12Hm0qMqvLTUyjOtmjG19/eLKzQHHTb3xP0y66imGnHoNaROPJzItC6FjjRJJpLE0lwPLPmLVs9djq/MVZ2yqLGLvkvfxhojdqDqwBUtVsV/bf6YPRxXCRShYPQ5tH8W0BJunvnAPexY/R33BnoC+HKcLVzfqg/Qle0O43Sn1kQExKi0WjdqD65FED2EpWXhdNpRqHf1nnd92rEIREGvidXsJTxvPhEv/w6A5V2FKGNCt6zPEpDFw1qWMu+g5BKUac3Ux9eX5ABRUBNbU6C6lcvE+GZn/aeRtABkZmaBcccUVPPfcc5SWlvLW3mIWDkhkdtrhVb1uQZIkrl61C7PLV2Ls3CtvwGAKI3f/Xj558yUAbn7oyYAsVD1h5Y9f89BN1wJw00038eijjyIIApmpUewr7NxNCSAxJXjwuVuCp2vrWG618nB8HIO1Pc/lv8/p5B+V1UFjMgSliiEn34IuPJbM2VeybdGdeN1tloSbckvRCgLzYyN6fN5g7LDaOXt/YYDYef28ua2F7b7adoAfd/unJY3NGkdUhi9+Iy57PAAGgxZJFGmqKqKhJIfGkhxq8nbRUJKD2xa4+737m9fZ/c3rqPUmwhLTicscS8LQCUSlZVK4cZnf2EkJkUyIjwx5H8YgYqC80RpkZM+pNAfOU7N/Q5CRPtzAQZeL4Z1kguprdjuCCw1VeFswvyD4fvfs1fmtbUnj5lJ3yBezkT51IdqwNjdJjcpfZHjcHprqfe+jUq0lcdgsEofNwtlUi6UyD0tVHs6mWkSvL1BeY4rCFN8fU/wAdBHxrfNEZ4ymNncTudtWEp08gEark1qznZjwnqdwLq1pYlBKZI+Pk5GR+XOQhYaMjExQwsPDefPNNznxxBMBOP+X7fx62mSGRfd+8Q++hc7d6/azrLgG8MVmnH/1zYiiyFP33YzX42H6cSczbc6JvT7H2l+W8PAtVyGKYqtgatnVHZ4Rw/6iui796BVKJUqVCq+nY71lHzscTk4rKmGSXse5EREcYzSiUYTONOQSJX6xWvmksZGNQVLYAggKFYNPvJnIdF9QvC4inoxp55O74q3WMV7gypwSDjmc3JIch7qTc3aGJEl8WdvInfnlNHn9PfwvnTKC44f63Gd2l1Vz9Sc/Bxzff9qCwHt0utHqtUQkDyAieQDShNmtfU6rmYaSHHZ8+RINRf4WMrfdQl3+Xury93Jg2aKWh+E35qLBnbuMZUcFFkvcVlzR6THdZUtxYGxKeNpgYjPHojZEcOCHVwP619psf6rQWGsLnqJZFd4WDC9JXip+fx/R5RNOqZNPQ22MxGmuRhsWQ9qU+a1jBfBLHev1eGmqa0IK8oujDYtBGxZDzKAJ3brWuOyp1OZuIm/7asafeCmCIJBfYSYqTNfjbF2ltRYkSfpTa//IyMh0H9l1SkZGJiQnnHACV1/tC96tdbiZ/e0G1lfUd3FUaNxekVt/38ezO3w7qlqdnnufegWVWs23H73Lnm2bMZhM3PzQ470+x8bfVvDA9Zfg8Xg4//zzefXVV/0WIeEGLRkJ3avarFb7FophEaGD4TfYHdxUUcnY3DwWFJXwQGU1r9XV83Z9A6/V1XN/ZRULiooZm5vHLRWVIUWGUmMgZfbNGNJG+7UnjjiWxJFz/Nok4MmSao7bncd2S89rgJQ53Vx4sJhrckoDRMbRA1N5/gyfQFi6J49jn/+Uug71D+KHHkX80KMC5vV4RcTm+Tpm9NIaw0nIHktMf58VJLr5uyEmkfSJczDGJiO0Fxcdjp+cENnpPQ2KMBLWIVD+5735WINUWu8JkiTx9bZA18GxFz1C5tzL6DdtIWpD4Ofps0bzYbvXdZf9TidbHcE/VyqjzwopelxUr3kVc85aX4egIH3K6RSt/QKA/sdc6BdvolIqWmM6RK+Iuc4cVGT0hqj+Y1Cqddgbqyg+tBsAh8tDeW3PLVB2p5e6pu7FDsnIyPz5yEJDRkamU1588UVOO+00AGocLmZ+s55/rD+AM1TwaQh21Jg56qs/+M+uAgDUGg2PvvYBg4YMo7qijNee+icAV93+AHGJyb261u0b/+Deqy7A7XKxcOFC3n33XZTKQJea4f27FySs1viExqChYwAwRoVOleoG9jidfGY281xtHU/W1PJcbR2fm5vY43QFBHu3Jzwlm3FXvYgxeSgWmwunu82KIggCA2ddQvzQmQHH7bI5mL07j5P35PN1TSOWTt4TlyiyptHCJQeLGbPtIEvqA12ZjhqQwrfXLORQVT0XvfcDJ7/yJbVWfyGj1ocx8oxbQ+4gu1zubqUNjhvky0Zlq60gacRUTnr0Sxa8tILpt7xE6oS5fmO1SgVDojpPY6oQBGam+AtCs8PF++t3d3ktnbF8fwH7K/1d7Yzx6WjDohAAhUIgacwxAceVeTystHY/1evh8HFD6BgHpSkW0WWlbvUL2Ep2gOD7fdBHJVC45lO8ThumpIEkjprld5y62RVNFJtFRh/GnCjVWqIH+tztDmz5tVXAFFc34fb2POV0SbUcpyEj87+KLDRkZGQ6Ra1W88UXX3D++b4gUa8k8cS2XIZ8vJrHt+RQ2Un1cEmSWF1ayznLtjLpy9/Z0Vycz2gK48m3P2PS9GMBeOGfd2OzWBg2ZjynnXdJr65zz/bN3HnZ2Tgddk488UQ+/vhjVKrg3qHxkQYSogxdztkiNFL7ZwGgD4tiysKb0Oj7Jnd/S+C01+PGEBmHRutL42u2uXC1KxAnCAoy51xJ6oR5QOACf32TjStySui/aT9TduRwdU4J9xWU84+CCm7KLeXYXblkbNrPgn2FfF9nJpgcGZwQQ0Z0BNOeXsS4x97jo02BFb4VKg3jL30EXURwoSZJ4HZ78Ho6W5T6+pRaHdnH+zKA7f72DTwuFy6PgCF5KCkT/d3morTqkEHg7bl8aGDa27u+XsUba7ez8mBht7NmtWBzubnh0+UB7WmTT/YFPDS/FelHnRL0+CdqarCLva/V0h12ORx8aQ4tNASFmppfn8FVk4tCrSdu9AkAqI2RlG1ZAsCg4y7zsyYpBAGlQkAURZrqmlqtVH1JXPYUAKoOrKO6OZbG4xUprup5JqvSWlloyMj8ryLHaMjIyHSJWq3mgw8+YO7cudxwww3U19dTbHFw/8aDPLDxINmRRsbERZARpketUGB2e9hVa2ZbtZk6p/9e/shJR/PAM6+QkOzzuf9t+U+s/vkHlCoVdzz6fFALRFcc2ruL2y8+A7vVwoyZs1i8eDGaTiolA4zoH0tlfVHn990sNJLTfZl1aksOMeDKx+k/agZ521ey/4/vqa8o6PH1aqPSiBxyDPHZ49n38d1YK/Mo2/ozkVkzcTndIIHZ6iLCqEXdnF5UEBSkTjoTIW4wFb+9g7upKmBeCThod3IwSKrXrthfWcv+ysAq1y2odEYmXPovYgaOCtovSW3uUk6XG4MqxPNv1iACAlnHnkXOysVYa8rY98uX9DvaFyPQ0VrSHZcdUZJQ4AsKt7YTaXa3h2s/aQssHxgbyckjB3HV0aPJSgjtEucVRa5YtITcmga/dqVGR8r44/3knikhg/DULMwlB/3GFrk9PFtbx31xh5dmN1QMgkuUuKeyKqhwbKF+/TuI9noUugiSZ98CtT4Lj9NcgySJxGZPIipjpN8xapUCSZJoqmvC6zkyqXoj00ei0plw2xopOrCNiLFT0KqVVNRZSYo29ihlbWW9FY9XDKhcLyMj899HFhoyMjLdQhAEzjvvPI455hgeeeQRPvzwQywWCxKwv8EaUJU54HiFAkkUOef2R4mK97lG2SxNPP/QnQCcffn1DBw8tMfXlX9oP7dcuACLuZGxE4/ih++/Q9eNOhfp8WGEGzWYraF9+NXNYsVgCicqJp762iqqiw6QNGgU2ZNPImvSiVQX7aP80DZqSg5RW5qDrbEmYB6VIQpdTAba2H4Yk4ehix2AIAh4BIGMmeeR8/Mb5K34kInNu7zgW1yabU4ijFpUSt/Cz2x3YYjPIuO0f1K78wca9q9qDew9ksRkjmHUWXdiiE4M2t9eZACIXi9ej4RSFbg4lpqVhgS4RRUDjj2fvV+/QO4vi0gZfzwqnQGVzj+wu8bhxu7xog+RrvaHgkru/GMfhxq7dlXKrWnghRWbeWHFZk4YNoAXzpzNgNhIvzFVTVau/GgpP+zKDTg+c+6lqJstWgrBJwARfNaeYHzY0MgEvY7jTN2zgpW53fxksbDD7mSP00mlx4MHUAvQT61mmFbLWL2OE4xGnq6t45CrM6c8EO31KMMSiJlxA4a4FBoLVwLgbKxGUCgZODvQgqhSKI6oyABQKFXEDppExe5fqd7/B9UDRpMaF4YoSRRUNjIkPabbc4kilNVaSY8/vEQVMjIyfY8sNGRkZHpEUlISr7zyCo8//jjPvf423/7wMwX7d1JfVe43Tq3RMCBrKINHjmHEsafx2v03UlNWRFNDHVVWFynhWt589lGqystI6defS268o8fXUlKQxy0XLKCxrpbBI8ewdMmPmLq5oBMEgREZsfy+pyzkmJZgcLfbRebwcWxcvYTK/F0kDRrVOkd8v6HE92sTSE5bE5amJsprG2mweUCpQ6kNzIgEIIoSkdmzMG5fhrWygILVi4gZf57PqtHc32h1EmnSYrG78Ta7sChUWuLGLiRm5CmY8zdQue5DEINnxwpy490uXR2ePIiM6aeTNn4OQgjXpY4iowWn04VBFZh1qcXX3+Xy4HZ7SJ10IgW/fYmtppSCNV8y6LgLMcSmoFCpET2+5+CVJHbUmJmcGOU3V4PTzU1r9/DxweDvoUmjIkavRZSg3GILqLWxZE8eqx99l8fnzeCa6WNosDt5f/0uHv95PTVBg+wFUpvdugRAQIEgQFNFAQ0FwWNBJODWikqeTxSYbQr+OQDY6XDwal09q6y2oFW+3RLkuNzkuNx822ThYWo6tWS0oDTFE3vsHSi1JkxhBirq2jJxJY8/EUOsfzYvpULA2mjB4+7m5+kwiM2eQsXuX6nJ2YjNfikNVg2RRi21ZgeNVp/I7i6lNRZZaMjI/A8iCw0ZGZleER4ezrR5F9Jv5pkAmOtrcTTVE69XoNXpSUxJa7UIFDc4CI+O8QmN+locbpFNGzey+P03Abj9kWfQ6nqWQ7+itJibz59HbVUFA7KH8tnX3xMXHdX1ge0YlBLJlkOVOFzBl2wt1+9xOdsJjc6Di7WGMLSGMAyR8ewqqGkVB6GwWhxkzr2a7e/fTdmWn4nKngmatpoDoihR1WBHKQh09J5RqDTo4wb6RIagRBMeh6uxAkGpJmbAKLSGMJRqDfqoBIo2/4y9vpKI1Gwai/cTkTYUld6IpSIft90CkohSZ8QY35/wlExSx0wjIm0wgiAgteYf8ieUyPBdt4jHI7ZWlhZFCafTJy58+GZUKFVkzr2UHYseIX/N56RNOQWtKYqwpIE0Fu9vnW9NWZ2f0Ci3Ojjhh43sqfP3z5+YEsvl47I4Oj2BQdHhKJrT/zrcHnZW1rPkUAlvbz1EWXMVdJvLzY2f/8K/lvxBg82BK9T7JShAEmko3EN8c90QqfnJHFj6LgBKjR6vK1CguCW4sbyCG2KiuTwqEnW7N9IhijxfW8d7DY30JNw6pMhovs7WcZYqGja8T8TYszAMTMJa7XMXVKp1ZMw42/9YCRxmG/Qw0UNviUgZgsYYhctaT33hDlTqCZh0alRKBfkVjYwaENfttLWltU1AUpfjZGRk/lxkoSEjI9MrvKJEhaUtFiA8Kob+qYlE6dUBY9VKBWGRPleIpoZaPB43zz9wG5Ikcdy8Mxl/9Mwenbumspybz59HZVkJ6QMyeeXjbxjev+eZqlRKBUPSY9iWExjvAG0xGm6Xi6xhvirZ1YX7WguSdYZeqyLSqKHW3HkAsihKqKMGkDBiJpW7VlG0+h2SZt/ZGpzrlSQcTjeCQoFBqwpY8FtLdwGgUKlxNVag0ocx+sJHSczIbq1J4HE5OPCLrz6FuSwHgKwTr8aU6Is9ESUJl7ttcalQKoiIbL/7LiGKtC7aoXOR0YLT6Uah0HQQGD7aLyATR0wnvznGIe/Xjxhy2vVEZgzzExpv7yvm9jEDUAgCdQ4Xc7/fyN76NpGRGR3O66dOYXpGcPcunVrFxNQ4JqbGce/0Uby6aT/3/bIFe7N7UFVTaLcrfXQSEamZVOxcQ+3BzcRnj8fjtFOxay3F63+gvtma4XXZERRKJDFwoe4Fnq+tY7nFwr/i4xmq01Ll8XB5aTkHXIeXgtePYNal8l1U/bQHRdnsViGUNvV0NAb/oo+N9U0YFBCgaI8QgkJBbNZkyrYtofrAH8QMHE91o52kaCMWu5vqRjvxkV0nbQBotLiw2F2Y9J3HZsnIyPy5yJFTMjIyvaLM7MTVLruQIEB4iABOtUIgLKpZaNTXsfyTtyg+tBdTRBTX3/evHp23vraGmy+YT2lhPklp/Xjuw68Yl92vx4W+WhjaLxpliKJ3LRYNt9tJUvpAjGEReNxOaktzujW3TqsmzND1wsditjLg2ItRavQ0lR7EVuirOi0BDpcXCZ+FwO70BOx6W4q2AyC6Haj0YYy58FGiUgb5PQ9zeS5IIiqdEcnrwRCbhjGhf9skHSZ1u70EJkuSEJtdj7ojMrxeicZ6K7U1Tf4io8Vtq931CQoFWSdcDkDRuu+x1ZaRMv54v/nyzDa+za9EkiSuWrXLT2ScP3IgW64+NaTI6IhaqeDGyUPZes1pDO6iwrohNpXsky4nbuhkACp2rWH7x4/x60Ons/PTx1tFhkpvYsQZtzLn4a8ZeebtIefb43Qxv7iEs4tLWFBU0rciozMkkYptbUHx/aYu9OturGtCcnv+NJHRQlz2VADq8rbgdTuwOtxYHT6XucJKM94eZO2S09zKyPzvIVs0ZGRkekVBvf8OsEmjDL1gVwqERfoy/FQWF7Bx+bcAnHXT/SiMkd0+Z1NjA7deuIDCnIPEJyXz/KJvGNS/H7HG3u9i6jQqMlOj2F9UF9Cn1viCyt0uJwqFgsxhY9i+fhWV+buJSx/c5dyK5vklCSz20AtKUZTwCEYyZpxD7vJ3qNjwGRlJo3AJGsR2Cy2vKGJ3eTBofH+63ZY67JW+YnIKjZHhZ9xNXf4Oitd+jrk8B2dTPZIotqbRFb2+BX/88OkhXVK8ooQkSXjcHjQBwrFNbITC65WwWhzYmjNfqVwetLr2Vq7gx8dmjSMmcyy1h7Zy6Of3GHXuvURmDPeLfbh57R7qHC6+yW+r1H3x6EG8cepUP2tLd8mMCefXi+cy690lHKwNniLWVlPC9g8faV2A2+sqsdf5zq+LSsTZUIUkiUy45BFiBo0GIH3ySUiil12Lnw8ZD7PNETozWIReywUTh3Hs4H6MSInHpFVTa7WzrbiSH3blsnjbgV7Vm2jPlrdvY9jpd2OISaapwYK1yU50WNdJFPoaU8JAdBHxOBqrqMvbSlz2FKob7ei1KpxuL2U1VtK6GXtRWmthcHroTGIyMjJ/PrJFQ0ZGpseIkkR5o/9CKVwXet9CrWyzaOxavxKX08HgcVOYetIZ1Fpd3Vo0WZvM3Hbx6eTs2010bDzPffgNyWn96B/ds9iOYAzPCJ7hptWi0bzrnDlsHACVebu6NW/LYl6vVWHQBbqUtcfSaCVlwikYYtPw2M1Ubf0aT5Dn4vX6xIbXaaXo5yda201JmexY9AC5y96mYs9abHUVeN1ORK+71V1GdPves5r9f1CXuy1gblFsSyXrdge6/0gSiM1fgdclYW60U13d2CoyADxeL452IquzVLVZJ14BQPn2FZjLchkw8yy//jKrk5vWttX3GJkQxSsnH9UrkdFCgknPJ2fMRNVujsgBYxl20VPEDp2GqqVmSofrVqg1CPgsO2HJA4nqP8KvP+2oU0gYfnSPrkUQ4OZjxlP06DU8f+ZsThmZSUZMBLEmA9kJMZw9fiiLLjmF3Iev4tSRg0LOMz02nCFh+k7/g7dU5LHh5avZv+QdGmvrUasUKP8L6WEFQSA2y5dtrfrA74CvnkZds8thSU2Tn1tfZ5TVWLoUwjIyMn8ustCQkZHpMVUWFzZ32yJYo1KgV4euf9E+RqOxpgqVRstFdz+OIAiIElRbO0/R6bDbuOvyc9i3YyvhkVE89+FXpA8YRLxJQ1gP8u2HIsKopV9C4K5pa9Ypl2/Rkzm8WWgU7EHqjktHu/WvUafutDaAKErY7W4yT7gKAPPBFbgbSoKOddmaKFr6FJ6m6ubzKDAXbg8aGxAMS0U+Oxbdz/7vXsTj9FmmJBHEdu5Qng6pTSXJ3xbRsp4LJTDaY7U6Ag0ZQSwqEalZJI6aCZLEwSVvET9sCokjZ/iNcTaLLwF467Sj0YRIedsTRiVGc8+0tloSDXnb2PP+HdTs/Q2P3YKgUBGbPYHwlEzAFw8jul3Y630ZnJrKcln+4AI2v/cgBb9/g6WqiANL3qVy128AmOIDCwl2RKdW8d01p/P0wmMwaju30CVHhrH4yvk8MX9m0P5Su4s3x2byxIj+zIqLIEod4nMniZRv/Iq8r+7DXrK9W/VKjgQt7lP1BdvxOHzuTw1WJ063F68oUVQVuiBhe1wekerGYNnCZGRk/lvIQkNGRqbHFNb5/2ce0Yk1A3wpMzXatlSVp1xyI4n9BrS+trm8NDmDp9N0Oh3ce9X57Ni0DqMpjGffX8yA7KEoBIF+UYdvzWhheEZgUbX2weAA6QMHo9HqcdktNFQWdjlnx7gRk16DThP6WVkarURljCJm8BSQJBq3fhqw+BOdVmpXPY+rfbHBLuIlQlG+bRnb3rsHl7URb4c52sdVdBQZ4LOsNDbYOhUY7cfaHa62ySBEHitfnQpBoaRm/0bqcncwdP6NaIK4152UlcbY5O7XWuiKmyYPxdC6IPddozEhg4xpCxh70YMMPfUahpziE4EqndFXHbz5Z5XWgNtmpmLnGnYvfoFVj19E7i8fApA0ehbjr3ickWfdiS4yPuC8Lbx7wYmcMGxAyP6OCILAbbMnctvsiQF9uVYHR6/eyR278llZ3Uh9F6lqvbY6cpc+z95vHsdeX97p2COBMTYNQ0wakuilJmdja3tVg08EV9TbsNg734xooaSm55XFZWRkjhyy0JCRkekRkiRRYm5bWAqCLz6jMwRgw7JvAFAqVZx44TUBY6qt7oA6Bx63mwevv5RNa1ehNxh56t3PyR4xGoDUSC1aVd/9CUuMNhIX6S9cVK2uU83xBio1A4f4amh0leYWCLqUNunVaENYf0RRoq7eQr9jLkGh1uKqzsFetKmt32mhZtXzuBuKQdG5uMtMiuPUCcNZOHkU4wemhdz5t1TksvPjB/C6/LNjSZKExyMFiAyvV8TcaKO62ozV7upuSQ5slg5WjRDeTsbYFFInnQTAwZ/eRGuKYNzFDyN0KIh3xfis7p24m0TqtZw9vL9fm7WygILfvmLLu/ez5qlL2fTWvSAIuCwNlG39FYDRZ93BSY99z/SbX2boSZdjiPFPsVq+fSWrHj2XnF8/IjZrPEp1YG2IM8cN5oxxXcf8BOPhk49mSGIfCC5BoL5wB1sX3UHB75/idXeeLa2viWsuVllzcF1rm9PtpaE5s11BZWO35imtkQPCZWT+l5CFhoyMTI+ot3uwtLM+hGlVIYPAW9i24Xe2rm7OeKMQUKoC4xVEUaKmXZVur9fLI7dexe+/LkWj1fHYGx8xYtwkwOeqlRLe94GrI/v7WzXaF+xrIWu4L81tt4RGkMciCAJhBg3qIAt/l1ekvq4JTXgsKVNOB8C8fTGi24G3WWR4GooR1PqgBfrUSiW3njKLnJfvZ9+L9/LVnZfx2W0Xs/7xW6l851+8fMXpJEcFZlmyVuRRsubDgHa3292qDdoLDFv7mAu6V//PK4rY7c52Fhr/hyPgq7StECBrzgUo1ToaivZRuft3YgaOYMhJl7eOVQgCM7uZYaonzOrfeR0G0eNqvVmvy45abyI2cwwKpYqY/sMRFEpstT6LQNqkkxh47LlEpg8BQYGtppSSjT/hdQdafx48aWqvr1mrVnHP8ZM7HWPSqEgy6YnUdeKSJUmodGFIXg8lm75h6we3UXNow5/mTtUiNBqKd+OyNrS21zU58HhFGixO6pq6Fj81jXacf0KxQRkZme4hZ52SkZHpEfl1dr+FZVduUy6nk6fvu7X1tdftxmm3oTMEVkm2OL1YNB4MagWP330jK378BpVazaOvvs+4KdNbx2VE6bsUN72hX0I4YQYNTTbfQrrF3avFogGQOdxXrK0yfzeSJHVaUCxUnyAIRBg1NFideDw+lyWvJOFy+dLXNpltJE+cR+X2X3E1VtC47XOclQcQbbWg1AZ1lRqUGMsXt1/CiH7B64mE6XVcddxUzpwyhitf+4yvN+z066/auoTowUcTljoE8K2nXS4vKrXYnEUqdNYsqfmfrjKjWq2OltEIgs95Ktgx2vBoMqYvJPfXjziw5C0Sh09FaGfBGRwbgVHTeXB9b+ipK5bbbmHV05cz7py7aCzLZc/3r/uu78TLGDT7fL9xtbk7yF31OfV5/s99yoAUshMOzyKxcEw21322nCaH/3t0/4xRXDh6EBmRptbPYpnZxuayGj7ZlcfX+wr9rIgeRxO6iARErxtnUy37f3yOyPQRDJh5CYbontep6Qm6iARMCQOxVOZSc2g9yaPnAr7EE9WNNpKiTRRUNBJp0naaylqSoKzGSv+kztMWy8jI/DnIFg0ZGZkeUdLYtquoVSm6dF9a9OpzFOUdIio2vjXmoam+NuT4KouLZx+4g6WLP0GpVPLQC28xeeac1v4wrYo4Y98vMsG3+G2fgaotGLxNaAzIHoFSpcJmrsVSV9HlfJ31RRi0KJUKv3oZAOYGK16njYh036Lfnv+HT2QAeJ1IHv9dcaNWwxtXnxVSZLQnymTg01su4pTxwwP6ytcvBlpEhoeystoAC0YourJsCAgggdfTFszdmTAZMPMs1MZwrFXFlGxaisdhbe1LCuu72Jz2pIR1rzhcexwN1fz+6u3s/vZVAAafcKmfyABQ600kDp+KMSbw/TlqQErvLrYdWrWKsWkJAe1xRh39o8L8PofJ4QZOHZzOJ2fMJOem0zk1O83/fhor0YbFkjphHoJSTUPRLrYtuoOCtR8HuNf1NS1B4S3Zp1qwOjxYHW5sTg+V9aELK7ZQWiu7T8nI/K8gCw0ZGZluY3a4aXS0uSV0Zc0oyDnAh68+B8C1//g34dE+16SmhuBCQ5IkPn7+Eb79+F0EQeDep15hxtxT/Mb0j9Z3uoA/XLJSo9A1x5yoO8RoAGi0OjIyhwFQkd95mtuurlKhEIg0anF7vK31MiSPi7qtX7DlP5dRvWtlt67Z6nRxzEMvc/pT71Ba29DleKVSwZvXnEVcuMmvvTFvG5bqUsor6snLq6CqshGpB+lC24sNn5AQUAgCSoWAQuETFh5P8+en0/dQQGsMI7N5wX7w5/e6nVHrcAh2pxF6LfpQWZs6ED1gBFH9hlK5Zx1l21dRsnkZhet+IP+3r8hZ8Ulrcb/2ZCf0Td2HYPPU2joP0k+NMLL47GN4/ZQpKNu9H03lB1Go1Iy94Cmi+o9BEr2UbP6OLR/cSvXBdUfMnSo2azIg0FR+CEdjlV9fdaMdUfJloAqW9rk9JXKchozM/wyy65SMjEy3KWpwtOapVwhg0oYOAhdFkafvuxWP281Rs47jmBNPY9FrL1BbUUpTfWBxPIBv3nyGnz/yuZ/c+PAzHDfvDL/+WKOm03odfYFKqWBwejTbc6pRaQItGuBLc5u7bwdV+bvJHH9cyLm6o4dcHi8qhQKXIOKsyad+w7t4myq7PjAI32zcxao9Obx02ULOmTau07Gx4SZuPnkG9338Y7tWidwNK1APmNXa4nS40BkCA5g7InT4Hqq2RdeLVKH12H5TTiN/zWLs9ZU0lh5qHVFq7npXuzeUmq1+r/c9cDmZCdFIkkR+bSNrDhXz5u872JBfFvT4urxdrHstdFXwYPS2on1HlIrAfUOxG4JAEAQuG5dFmFbNeV+ubhVbxRu+ImbgBIaddhe1eVvIW/U+TnMVB356gYq0Xxg461IM0YdvjWmP1hRNROpQGkv2UHNwHakTTmvt83hFas0O4iL0lFQ3kZEY2jXKanfTYHESaer6cysjI3NkkYWGjIxMtymqb3OdCNOpOl0k/fjFInZsWofeYOTWh59CrVK2VgcPZtH48f2X+e6t5wE497Z/Mv6Es/CKUmsshkIQyOiD4nzdYWh6DLvyaoIGgwNkDRvH0i/eoSKv84DwriwvXlHEYnejUAhI1fuoWfUyeLuXxjMUDVY7F7y4iILqOu5ZMKfTsRfOnNBBaIC3oYj2jmn2EEJDEr1IHhd43IheN6LXieRxI3rcSF4XUst3rxvR40L0+L7ba4oBqNq3EUdjNV63q7nfhdftQmr+3vLa6/E9+8rdbe40B2oaaXK6CdP2rQvd1vK2z2WsSc+g+CjA9z4OiI1kQGwkFx81gq+2HeC6T5dTbQkUPAqVhrCk/ijVWpRqDQqVBqVai0KtoT5/N9aaUr/xhXXdy6bUFQW1gfOEd1GPoz1nDu/PuuIqXtqwD/C9v0Xrv2TIybcSM2AckekjKN38HSWbvqWxeA/bFt1J8pgTSJu0EJWm734v47Kn0Fiyh+oDf/gJDYBGq5Nwg4ayWiuJ0cZOU0WX1lhkoSEj8z+ALDRkZGS6hdXpoc7WtgiO6KT4XG11Ja889iAAl91yD4kpPj/wiBbXqQ4xGr989g5fvvwYAKdfdzdzzroMjyhRZ3MTZ/ItllIitOj6MJ1tZ+i1KgalRLI5iOsUwKChoxEEgabaMmxNdRjCgru/dKozJIlGqwtJkrBVHKB85X+CZpLqLfd/8hN6jZqbT54ZckxSVATpsVEU1dS3tnmrduPY8AqS1w1eN6V4qVCIiG4XoteN5PF95zBdmepytwWtTt4dJGBVQQWndIgvOFxW5LXVkBiXnhhSKC4Yk834fknMfuFT8moa/PpEj4v0SSeSMeXUgGy+ub9+xN4f3/Ibv7mw8zif7iCKEluKAucZnhDVo3n+dexYvt1fRFGjz7JTm7sZZ1Mt2rAYlCoN6ZNPJ37IdPJWv09d3hZKt/xA9f7f6T/tfGKzp/SJS2PMoInkrnwHa00htrrSAKtJVYONtLgwCivNZKeFdjsrqWliWEbf1VmRkZHpHbLQkJGR6RYlZmdrhhqdWoGmk0X/S4/ch8XcSPbw0Sy86MrW9sho33/87YXGmm8/4aNnHgDg1Mtu4qSLrm/ta3R4MGqVROrUpEb0fTrbzhieERtQsK8Fgymc1P5ZFOcdoCp/NxkjpwebImRROoAmuwuvV8TrtFC2+jWkECJDrVRw+phsThuVyZi0BGJNBqxOFztKq/llfwEfrN9NvS14kO6dH3zHlOz+TMzsF/I6UmMi/YQGHife6v2tL0WgK/kjKFUISg0KlRqFUo2g8u3kCyo1CqUGhVqNQqVBodRgKT+Eq7GSsLRhxA0a6dv1V2tQanQoVZoAK4BSpaGhaB97v3sV33Ld9xl8Y/OBPhUa9XYnn+7Ob309Z0hGp+PTo8P54drTGfvYezg6pFMtWPsNA48+DUEQWl3FlAoF0f0Ca2X8sr+ASrOVhPDALGzd5dcDhVQ1BVpXxib1LP7DqFFz/aQh3Llss69BEqncu5r0SQtax+gi4hl66h3U5W8jb9V7OBorObD0Jcp3+dypjLGH956o9WFE9htJff42qg/8Tr+jzvTrb19bIynGRbghuNWmos6K1yuiVMqhqDIy/01koSEjI9MtiurbqoF3FgS+ftVyfv3hKxQKBXf8+zlUqraxUTEtweC+GI11S7/mvX/fCcDx517JvCsD/durLS5GJJiOSDrbzog0aUlt3hF2B6l9kDl8HMV5B6jI60RohLhkp8uDw+WzCFRt/ASvPbj7zPFD+/PauceTFhXu1x6h15IcGcYJwwbw8MlHc//3v/HSqi0BWZ9ESeKylz9h05O3oQuRDtbh6uCqpTGhHTYfQaFCUKoRlGqS0xJRabQ+4aDS+ISEsvlnpQpB0VXBRl8wOEDud89S11hJZOZEUqefgcmkRRAUnVp/YgYMp3L3Wmrz2oLvlx4qYVNpDRNSAiu694Zn/9iDw+N7T3RqFRdOCszK1ZGshGj+efLR3PX1Kr/2pop86vJ3EzNgROsuv1qtIDFzJEqNzi97k9sr8vyKzTw2b0avrluSJJ5aviGgfWxSDDGGnovzi0dncu8vW1o3FZrKDgQdF91/DJFpwyjZ8gMlm77BXLqPbR/dRfLouaRPPh2VtucZvFqIy57aLDT+IH3yGQGWkromBya9mvyKRkYNiAs6h8crUVFvIyXWFLRfRkbmz0GW+jIyMl3i8IhUW30LUqVCwBiiErjdZuWZ+31i4YxLriZ7+Ci//siYZotGQx1bVi7hrX/ejCRJzFpwAWfddH9Q1wuFIGDzdJ5l5kgxJMOXMtTjCkzvmjWs68J9we7HK4o02X3P0lFTgDl3XcAYgLuOm8wP154eIDI6YtRqePb0Y/ni8nmoggQE7yut5K1fg5/D4/Wyt8Q/8FwZnoQ2bSKalLGoE0egihuMMnoAhsSB6GPT0UYmojFFo9KHoVBruxQZABISbYmC2gr22W3OTutvKARQKQVUSiXDTr26w5xw+TdrcXoOPxvV1rJanlzbJmLOnTCEaGP34g6unjaa8CCF8KoObG79WakQEBBQ64xkTAxMHvDsrxvZXFge0N4d3l23ixUHCgParxjXu8rp0QYtw+PbXK4sVfkhA/gVKg3pkxYw9sJniBk4ASSRsm0/seX9W6ja91uvs1PFDBiPQqXB0VCBtSo/oL+ltkaTzUV1Y+jEAHKVcBmZ/z6y0JCRkemSskYHrubFfphWGTII/J0XnqCitJjElDQuvfnugP6YGN/uY2VxHq/edy2i18vUk87g/DsfDenfHWtUU2520uT886v9tlg0XEHqB2QO82V1qq/Ix2kPvqAJuKV2cRkA9ftXBD3u3AlD+dep03rk8z5vdBbPn3Fs0L5Xl/4edNG3em8uDre/RUMZEej64nB0XUejayS87VLlCoKAUhBw2AOtRQpBQKUUUCoUre5nMf2Hkzjcv4L2nuoGrvzu99ZMaL2hzGzj7C9W4W1+PtFGHY+cEtxCFQyjVsO8UYGL+obiNktAe2tc5oyFAWO9osSC17/mUFXwbGyhWL6vgBs+Wx7QHqXTcO7IAT2aqz1jktpiG9x2Mx5HU6fjdeFxDDnlNobNuwddZCJuWyMHf36ZXV/+E2t1oAjqCqVGR3R/n5DvWFOjBavDg8XupqDCHPL9L6np/LplZGSOPLLQkJGR6ZKihraFdii3qYN7dvLFO76iZbc+/DQGY6DLQkysz82lojAfr8fNhNmncMl9T6EIshMPYNQq0at9O+YHq23dStfZl+h0PteTjjEa4AtsT0juB5JEVcGeoMd3jNFosrvxNm/ti247TfnrA46JDzPwwpmzexVYe9W00czMSg9oP1BWxZq9uQHtL/24JqBNGR24QHV0o2Bfd2l5DwVBQFD4slqJoohAi8BQtFoAOjLs5CtA8P+sfLQzjwu+WoPF2fNsXfuqGzjmvSXk1bctSF88c3a34yUOVNbyzC8b2V1WHdBXfWgbOasXY62vRJR86VndXhFTYn8GTp8fML6s0cLUpxfx6ea9XVoC3F4vjy75g1Nf/TKoRefJ4yYcVuX0mA5ZxrxBXAeDEZUxirHnP0W/KWejUGkxl+5n28f3kLvqPb+Ci90hNnsKQHPdjuAWzRqzHbvLQ1ldcKFf3+TE5ji8LG4yMjKHhyw0ZGRkOsXtFals8i00DBol6iDBlV6vl6fuvQWv18sxJ83jqFnB06rWVrbUH5AYPW0OVz78IkpVcOEiCBBraFss2d1eihuObGXijrQIDY8r+EIrc3jn7lPtw0qcbg8OV5tVpqloB5I30Epz9bQxRPXCtx58i/e7j58ctG/l7kN+r79av4MftvgLJEEbjiphWMCxDoc7eDW73tBOaAAIkoDL4WonMEITmTyA/pPmAqDStD2jz3bnM/rVb1mWU9otdx2nx8tTa3cx/rXvyKlrExk3zhrHWeOGdHn8z3vzOe7Fzxj28Nvc9fUqthYH1j3xuhzs+upFlv3zbNa+fg9VubsRRQmVRs3YM2/AGJsUcEyd1cH57/7AtGc+YtGGPZQ1tF2bJEnkVNXz/IpNjHjkbR78YS3uIIXrjh+UwsVjBnV5D53h6WAhUHTDPa51rEpN2sR5PneqzEkgiZRvX8qWD26lcu/qkKKhI9EZo1Fq9LgsdZhLg8eJtNTWKKm24A7hQidXCZeR+e8iB4PLyMh0SqXFhd3tWxyEhyjQ99UHb7J/1zZMYeHc+MBjQccc2LWdp+69pfX1FQ+9gEoVetc1QqcOEDUlDQ5iDGpMnaTW7UtaLRpun7tTRytD5vBxrF32deg4jebhXlGkqV1qYLe1nqqNHwc95LyJQw/rmo/J6kdShJHyRv8d5C25xa0/rz9YwGWvfBJwrLrfVARF4LOVJAmXy4OmD5+7JEkoFQrUKgVet68yeijLFoIv+5ZKqWTkqZdTuPkXPC4HYXEpNFX76lIUNFg4cdFyRidGc9nYLI7ul8CQ2AhUzZ+hJqeb7RV1LDlUwjtbD1LToWr2dTPG8vSCYzq1JNVZ7dzyxa98tGlvD25UpHzXWsp3/0727LMZNe9q1Doj0699kuVPXh10p399fhnrm4sCxpr0mLQa6qx2zF24sA2OjeC9+T1zuQtGXp257YUgMCAtEZtHgdnm6rIqdwu68FiGnHQL9YU7yVv1Hvb6Mg4te5WKXb8ycNalmOIzOj1eodIQM2giVXtXU33wDyJSgwvAltoaRVVNDEyODOgvrbGQmdKzNL8yMjJ9hyw0ZGRkOqWwzpdtKlQQeGVpCW8+8ygA19z9EDFxCQFj8g7s5daLFmKzNNGSotRhs2AICx7orFQIRBsCRYgEHKqxMSo5rM8qKndGi9AAECQPCP7X1BIQXltyCI/L4bfLDs279pKEuV1chttaR/HSJxGdgTut0UYdA2IjD+uaFQqBcemJ/LDL31Vqb0kFHq+X539YzYOfLcHZISWrYIhBOygwxkMQfPfhcrnR6TWtr32PX2h9TUs7ga8RBARBQIGAutkVzmDUYYowoFIoUCgEVCoVWp267aStFwAqQdHqMRWZnMaQ2WewZ+lHqLQ6smfO48Cqb1qHb6+o44affC5pWqWCaL0WryRRbXUENcqE6TQ8tWAWl00Z2ekC/UBlLSe89AVF9eaQY1QKRXPge5AzSRIHln9C5b5NzLrlRYzxGUy99hn+eO1O3LbQc9ZY7NRY7CH7WxgaF8nSC44jznj4aaC3lLWln46IS0OnN6ADokxarA4PZpsTWzdjpqL6jWTM+U9Stu0nijYspqn8INs/uYekkXPod9SZqHShs0LFZU+hau9qag6tZ8CMi1Aogy9ZqhqsaNVKkqKNGHT+v6OlNZagmwQyMjJ/DrLQkJGRCYlXlChvdpsK16kC/rOWJInnHroTu83KiHGTOPmsCwPmKMrL4ZYLFmBuqGfwyDGUFhbQ1FjP5pVLyBg8gtSB2RjCIvyOiTaoCZXN1uryUtroJC3yyNfV0OvbMg/1jzeQX+Pv7x2bmEpUTDz1tVVUFx0gaZB/li0FAhaHu3UXuEVkuJuqEJQaJK//DnW/6PA+WRBlREcEtFU2WBhwzSOU1QdLpSuQMfd6wtLSm2Mn2gmIZvQ6DWERvU9ZCqAUFK2B0UqVEpVK6YvNUAiIoogkgdDujVc0X4OERIvHjQSMOPliDq7+hvqSXIafeBFp445h86fP01Ca53c+p1ekvItF+keXnMyJwzt3NcqpqufY5z+lwuxvfdColJw5djALx2YzPj2RpAgTkiRRVGdmc2EFn2zey3c7c/xiixpKclj+5NVMv/ElovsNYdbtb7D148epydne+cPrhItHD+KZuROJCJL9qqdsLq2htF1NjpjUtmcjCAImvRqTXo3b48Vsc2G2uYILq3YolCpSx59KXPZU8n9bRM3BdZTvWEb1wXVkHH0uCUNnIAiB1qzItOGo9eG47WYai3cTlTE66PxOt0iDxUFBpZmh/fyL9DlcXmrNDmIj+q56uYyMTPeRYzRkZGRCklNaxf69ezi0czOVOXuoqfKvPrx66ff8/utSVGo1d/z7uQDXl7LiQm4+/zTqaqrQG4zkHdhLU6OvONwnzz7IY1cu4Lpjh3H3wml89dpT1FaWoVEpCO+kTgdAUYMdm+vw05p2hUqlar2njDgDHT17BEEgc7gv+1Qw9ymr04W9eefXJzKewN1UhdoUiz4hM2C8x9s3gRAeMdC9xeF2hxAZ0O/4q4kaMBKVWolS5bMwdBQ8bnfvn7cggEqp6BDHLSBJIIrg9kh4vCIOpwtRlBBFCUmSECWf2G3/hSShNUUy/MSLANj21WskDh7Hqf/6lOPufBV9RM/qaizZE5g+tT1Ot4eFb3wdIDJOHTmI3Iev4r2LTuKUEYNIijA136tAv5gIFo7N5ssr57P7/suYOjDV71hLZRGb3n8YSZIwxiRx9HXPMXLBjaj1Pa/5MDQugrfmHd0nIgPgtU37/V4PHT89aNE7tUpJTLiefgnhJEQa0Gu63rfUhsUw+MSbGL7wH+ijU/DYm8hZ/jo7P3sAS2VewHhBoSQ20xdzVH3gj07nrmtyUtVgo94SGMclp7mVkfnvIQsNGRkZPxwOB4sWLWLq1KkMTk/k/nNm8+/L53HVvGOYP3ko5xwzgU/efImyokKe/6cvhe15V99E/0z/qsdV5aVctWAO1RW++gB2mxWXM3hQdWVxPt+/8wJ3nDaZT5/5B3Zr5wsDSfK5UPU2T393EQSh1X1KkDwMCuIDntlaT2OXX7vL46W20bfocVtqm0VGNeqwONLm3oXaGFi1Oae6vts+8J2xr6K260GAoNLQ/6SbiBsZPHi/PR6vF6mrNLJSu6/25wFEUWy2Wvg6JQkkSUTC9+UVRVyu5liNDtaU9rQIvyHHnY0+IgZLTRkHV32FIAgkZI3G7fTtxs+88Tlm3fg8065+nOnXPsns218jbeysgPneW7eL3Or6gPYWHv7pD/aU1/i1PbVgFouvnN8qLjojKyGaFTefzU3HjPdrrz64hYJ13+Nx2slZ9QUHli/CHSJNcgsCkB2mJ67don5vdSPf7Ot5CtlgbC2r5cMdbS53EVGxnHzSqUzMTiArPZqYSEOA6FAIAmEGDSmxJtLiwogwaLp0a4xMG86Y854gY9r5KNU6mipy2P7JfeT8+hZuh/8zaMk+VZu7Ca8ndIxKS22NggpzwN8FOc2tjMx/D1loyMjIAL7MUU8//TRpaWlccMEF/PFH8B3EkoJcXnnsQc45Zjy1VRWkpPfngmtv9RtTXlzIBccdRUNtTdA5QiGJIt9/9A4XnziNA7t3dDq2yemhzNy9tJuHQ4vQcDgcDM8I3C3ParZoVBfuQ2zOIiVJEpX1VkTAbakJFBmmGLTRgfUq7G4P20oCMxj1BIfbEzQLUkfCUgYz7KJniB3WRUXqduLB5fY0C4QQXwQmpwpccrZknQpyKknC6/GGrOCnVAitXWqtnlGnXQHAzu/ewW23Ulu4H4/DhsYQRmL2eBKHTCB11DRSRkwlbuAIso85M2BOu9vDZR8uwRUka1FBbSNP/+Jfdfv+E6dwy7ETeuTiplQoeHrBLC6ePMKvfefil1j60Jns/vYVnE11GKITGX3WbQw77dqAOcJVSpYdPZwtx47hiZH9/fqu/WEdVd2I4+gMh9vDZd+sba0nAjDzpDNRqdUoFQriw/UMSY3yiY604KJDq1YSF2kgIyGcuAg9WnXobFUKpYrUcScz9qJnicueCkhU7PqFLe/dQsWuX1uzU4UnZ6ENi8HrslNfsL3Te7A6PFTW26hs8C/iV9VgC5mVSkZG5sgiCw0ZGRmsVivz58/njjvuoKame+JAFH3/cbvdLmqr2ha2VeVlXDh3KrZOrBKRRj3xEaaQO5/lxYXceO4p7Nm+OWh/C4X1DuyH4dLTHdoLjagwHalx/rvYSekDMZjC8bid1JbmAL78/k63iNNc7YvJsNSgDov3s2ToYjKCnu+d33ce1vV+vmU/TaGyEwkKojInMvjMBxh63mPoYlIQRd9ucItYEDt+0fbVlfuULxCcVnXR+ro9IaxQguBz2XK6PK21Rvz7fbEc7cmcfhrhCek4murZs/QjKvZtAiA+awxCkAxWsQNGEJU+OKB9bW4J5737PXaXfwzOa79t84s/GN8vkfvmTgl6/V0hCALPnXEM/aLbEiCIHhdumxlDTDKjzrqDY+79kJRxJxAxcFLA8WaPl9PX72NpRR1npMQyI7YtDqfK6uCkRcuptfUu/bPD7eGsL1axq6rNspOQksHxCy8JGKtUKIiPaBYdWT7RER2hR9FOdCgUAhFGLWlxYaTGmghrTiIQDK0pmuwTbmDE6Q9giEnD42gi59c32fHp/TRV5CIICmKzmmtqhCje154as52Cika/z5AoQlldz+p4yMjI9A2y0JCR+ZvjdDo59dRT+f7773t1fFV5KTecfRJV5aU0NTZy8YlH47DbAsZNzOzHu9efS9HrD1Hz3r8pe+sR6j94jF8fuo6LZ01Eo/Lf/bRZLNx56VlUlZeGPLcoSeQcYReq9kIDYER/f6uGQqEgq109DYvdRaPVhaOxij1fPdJOZNzp5y6li81AqQvMuvX+ht3sLe+ZJagFq9PFv5YEt0Qlz76OMTcuYtD8uwnLGI3YHGAt4TNFBLNGdMTtCp5pqKPA8GvrQOs5WjsFBIXCb6zT4QoQJMFEqUKlYszCawDY8/NHlOxaB0BC9rjg1ykIjD3rdoQgdSG+3n6Q8Y+/z285vjTAHq/Ie+v83eEenzezNV1ubwjTaXnwpKP92nSR8cy8+wNSJ8ylyeKirt6CVxk8cLnR4+X09fu5ZlsO/x7eD5Oq7Vq2VdQx/e2f2FgSWDywM3Jqzcz5YBk/HixpbRMEgUtueQSNtvOEC0qlT3QMTYtmYmYCmWlRRIfr/ESHTqMiIcpARnw4seG6oHV4ACJShzL63MfoP/1ClBo9lspcdnz6Dw798gZR/XxJFurztuJxBv5taY/HK1JeZ6OkQ1yGHKchI/PfQRYaMjJ/c2644QZWrFhxWHNUlZdx52Vnc+X82TQ1Nvj1mXRa3rr2bH5/9CYumDGB5HYZkYw6LTOGDeKta89h85O3M26Af9CsuaGep+69pVMh0ejwUNnUd5WrwefCU1paynfffYfV6tsJfeedd/jwww+prygk0uifQjNzmG9hW5G3i6pGO47GKnZ9+TBOczXq8ISgMRmCQkVk1vSAc7s8Xi794Cdsrp5VNJYkidsWryCvpiGgTxWbhSNsKMUlDVRVNGCzOkMZFjqlo0UjmMBo7QvlWdR6YgFoDjzvMMTjFXF7xNaxiiDWjBb6TTiWmP5D8DhsVB/yWYNCCQ2AqPQsso+7IGjfgco6Zj33CUc9+SF3f7PKL63skMQYZmQGurv1lDPHDSa6XQpaR0MVNnMD9XUWXM3VzdVqLUJzKlddeKC73qKiamb/tpuJUWEo2z2WA7Vmjn77J276aT05taFT5gKUN9n458ptjHn1W9YVV/n1nXP1PQwaOrpH96VSKUiIMDA0PcYnOlL9RYdSqSDSpCM9PozkGCMmnTrgfVcoVaSMPZFxFz1H3JBpgETl7hXs//E51IZwRK+burzOrZzgq62RW96As1kYe9xuvv7qG26//XZmzZpFv379SEhIID09nRkzZnDrrbeyePFinCFiyGRkZHqPIB3paEoZGZn/WbZs2cL48eO7HthLTDotyx64homZ/bo13uZ0ccpjb7J6T45f+6OvfsD0408OeZxSITAmJRyd6vD2Tmpqanj33Xd54403yMnJCTkuLDyc8dNOYOZJZ5GSkUnegV38+5ZzUemMjDr7UXYv/hfOphp0kYkkz7kDlSHKZ0GQfIJAanZVclvrKP3uPhADLQWzstL57PLTiDZ2nZbT7fVy19ereHHllqD9pklXoknukHpXocBg0mI06tHrNXQ3BD02NgyVUhlUXLTO3Unf5nf+QdXedYw443b6HXVSyHFKpQKdXotSwJcGt5M5y/duZNmT1wGgMUWw4MkfQ8ZQuL0iHrebNS/eRF2HAP7OuH7GWJ4/c3a3x3fG/Ne+4vtdbZ+voef8k4gM3/ujVipRKgV+f+YCXJZ6Jl3yKHt+fB1LVVGPz3N0egITU2MZmRBNmEaF3eNlb3UDm0trWJFfHlABHODsK+9i9rzze39zHXB7ROosDmoa7TRanYjtzunxiq0pcoMlQWgs3U/uynew1bTde1hiJqPOfqTL82rVCoYmG8jf+D1rln6Jub7rBAlxcXFcfvnl3HbbbcTExHQ5XkZGpmvkOhoyMn9j/vOf/3Taf/TYkVxw6lxGDx5Efmk5i5et4oufV3Z7/hcvW9BtkQFg0Gr45JYLGXnLE9Q0tflUf/n+G50KDa8okVtjY1hiz9ODAng8Hp555hn++c9/Yrd3HVTbZDaz8sfPWPnjZ4ycPJu5596ESq3F47Cy4/OH8Nga0EQkkjr3TmySAULFTGgjCBt+Mk07vwnoWnmwiJH/eodnFh7DwjHZQV12JEliXX4ZN3/+S8gAcHXiCNRJIwPaRVGkqdFGQ70VpVLAaDIQFq5HGyJNaovhwuvxolJ1EuTbVYy0FDoYvD1er4jX60WhUnZZcC1p6ERMcSlYqktRa/UoFIqQVjABX9rUjMkn9EhojEqN7/bYrhidFu8nNOx1ZUT2H41aqUCjVqJRKdHoTbgs9ShVaqZf/xL7lr5L/h/f9Og8a4sqWVvUveQCkTHxXHjjg4ycEGhlOxzUKgUJkQYSIg3+osPiRKVUEB2mC1kIMCJlMGPOfYzyncsp/P1TvG4HTRWHOLDkJQbMuAi1IXjBT4Dyg1v4/bU3cTTVdftaq6ureeyxx3jnnXd47bXXmDdv3uHcuoyMDLLQkJH521JbW8unn34atE+hUPDB4//gnBPbdnDHDx/MGcfP4s7LzuWkq++kqi50SlCAo7IzuGDGhB5fV3xEGI+ccyLXvPFFa9u29WspKcgjNWNAyOPq7W6qLC7iTT2rJ1BYWMiZZ57Jxo0be3ytADvX/8L+nRtRmWLw1Jf5REZ4ImnH34lSF4lgd/viIEJgyp6Do2QH7rrAeg4VZivnvfs9d329ipNHDGRseiKxRj0Wp4sdpdX8ur+A7SVVQWZtRqXDOOacLjMkeTwi9fUW6ustqNVKwsINhIXp0WjVrQKjxYLhcnkJ5brflcgQUHRqCQm4LpcHjVrZGpAdyn0KQGPwiUxrbQX1pYeITA5ehK/lUXjdPvEXkZaFtboUj6PzYOEoQ98ViOw4l+Rxo9Oo0KmVrYJSrQ8DwGW3oNLoGXHqtSQPP5pd37+CuTyw5kRvUanUTJlzGgsvvhljh8KZfU1H0VHb5KDW7BMdoQoBCgolyaPnEps5ma0f3I7HaaH6wO/UFWyn35QzSRoxxy/wX5IkCv/4jJJN3/T6OisrK5k/fz633HILTz/9dEB9IBkZme4jCw0Zmb8pixcvbg1w7sjNF5zhJzLaM3ZoNq88cBun3/yPTue/9vije13l+rzp47l70fc0tsuis3Pz+k6FBkBerY1InQpNswuVy+3F5vRgd3lwNH+3uzzYnb6vvLwc7r3ufOqqK0LOGaHXEmPUY3e7KW8Mvhh12cxg8/nEK9Q60ubeicoQ6esU6DTKWlAoiZ56JTUrnsZrDe7eUdLQxGu/be/03oOh0IUhaMM6GRF4cW63l/raJurrmtBp1a2iQ9WcqtTtCR4Q3qXIEJoDvlssDd35bEgSoldEoexcbHicDhpK2uo/7Pj6VWZc90zw62hWOu5mYRGRPJDJlz3KoV8+pHDjz3hdwf30exoz0xm2DkH1er0Wk05FexXWUrzPbW+rAREzYCTTb3iFkt2bKN2ylJqcDUje4O9HZyiVKpL7DWLijLkcfdx8wiICa7ocadQqBYlRBhKjDLg8InVNDmrMdswWJzHhSqLCdFjtbsw2F3aXB40xktQJp1Kw9mMUai1ep5W8le9SuXslA2ddQnhyNpIkUbD2I0q3/BD0nEMTYzh2cAajUuOJ0Gsx253sKK1i1cEidpYGBtE/99xzuFwuXnrppV7/LZOR+bsjCw0Zmb8p27ZtC9quUCi49eKzOj123rHTGJSeQk5R6IxQs0dm9/raDFoNR2X3Z+m2fa1tB3bv4ITTz/UFCru9uLwiHo+IyyPi8nhxe7y4PSJ786oxCCIOp8cvNWlHmhrr+NdNFwYVGUMSY7hq2mhOHD6Q/jERrYuMGouNtTklvPX7TpbuDbGrLChQ6nu2M6w0RBEz61ZqV72A19KJhaLbE/qsOqKlGmfB7+j6Tws+rsPaSRBaArx9HS6Xh9oaM7U1ZrQ6NWFhesLCDT5t0u7YzkWG4CcO2nRG5ws3RfMYt8uDVu8TOaHERtWhHYheD/qIGByWBsp2r6fy4FYSssYiSRJNlUXU5O+hvugAdcUHcTQ14DD7RF3l3g0olCriBw6j/1EnUFtwgOqcHVQf3IrL2lZJfVdZ7zKBBWNXqf97HBadSMc3o01otGVLkpCwNFgwxWeSfUImgzxXYa0uxFKVh7W6EK/ThiR6UWm0hEXFMnbUaOLjY/C63Xi9HpQqNVGxCaT1z0Kt0fbZ/RwumgDRYafG7EClUBBm0OB0ezFbnbiyp1Kw9mNEt5N+U86iZMsPWKsL2Pn5g8QPmY4xvn9QkTExI4kn5s/k6IGpQT93kiSxPr+Me75ZzdrcEr++l19+meHDh3P11VcfqduXkflLIwsNGZm/KbW1wXfPR2YNJCkuMNNNewRBYM6UCSGFRkJEGHHdqJrcGcPSEv2ExqGcfNbtLUPqRtRymEJC24W3w0ev/JvaqjK/Nr1axaOnTef6GeOC7pzHmgzMG53FvNFZrDlUzOWLlgRkeRJdNhx1heib62QICJ26TrWgMsYQN+duGrd9jr1gfZfjQ84T3R/j2AtwV+3DtvML7Hu+R5M8BoU28P1oTTArCCjoPA7C6XDjdLipqTYjCBARYUSr06BShj5GQIEQ8D60zzoVmpbnL4q+In5KVWixUd5cPyN5+GRUWj0HVnzJ9sUvM3DaPHLWfE198YHQ99VUR8Ef31Pwhy+9syk+jayZC8maMY+Vz9/UOq7jArS3iKLEH3n+vzeRqVkB4zTNrlPthYal3oKnnTVEqdIQnpRJeFJmwPEqhYAxKQJ9hJ6EKAMRRi2B+b3+9/CJDiOJUUZcbi+1Fge1jXZ0GiUx4QPISRtCXfE+FCoN4y96joLfP6Fyz0qq9q2BfWsC5nvwpKncO/colJ24PwmCwFEDUlhx8zk88+tG7vlmtV//7bffzty5c8nIyOjr25WR+csjOx7KyPxNCRUsq1F3b/9BqwkdC9GxJkZv0Kn9U8h6PJ5uiQwAiyTQiTGDrX/8yubffvZri9RrWXnLOdw4a3ynsQAtTM9MY9PdF3HUgJSAvuoNn7S96MHaTqExEDXpYqKnX49CH9X9AwGFPgrDyDMIm34ryrAEtP2noQxPQXJbse8NXiNFqRBQKYXmitvdv1Bzo52mJjt1tWYaG6w4HO6AdLmCIpjIaD+gk3sR/K/H4/Z3D/KKkl/2oop9vmxbSUMnMPLkS1AoVdQV7WfTR493KjKCYakqZuvnz7P65Tv86m2syytlTx9YNX7el09xfZs7lD4yAV14YIYjtaFFaPjGNtU34XZ2330rzKBBkqC6wc7u/Fq2HKykqNqM091zV6v/Fhq1kqQoI8MzYpmQlUhmWhQjp8wBoDF3PdExsWQddxWjznoEVRAh/cT8mdx/4tRORUZ7FAqBO+ZM4qWz5vi1W61Wbr311sO+HxmZvyOy0JCR+ZsSGRkZtH3bvkM0mJuC9rVn1cbgrlcAlY1NuA5zQVNc4x9snrdrEx88eiNL33+OrSu/o+TQbpxBCgOCzz3HGkKUSJLEdx+9EtD+xZXzGN8vqUfXGKHX8v01C0mL8o+DsFcdwt1UgySJ4HUjiT2rXq5LGo46wnct6pj+qCJSCLZqVxhj0aSOwzTpSiKO+ye6gTMRmscJCiWGUWcC4Cz4HU+9L0WoAKiUCrRqJSolSG47osOM5LZ3u/Chw+HyiQF87lVNZhs11Y2YG224nB4EoZO985asUyFGCEDHBFstVo32tIgNl81Cbf5eAEyxyax5/X7ELuIWtIJAmFKBrhNxJbpdAe/bP39c2+m8XeEVRR7+0b+6dfr444OObe861dTQM5EBPqHRHofLS1FlE5sOVLKnoIbqRhui2N2kxv99WkTHqactQFAoqCs9RLzWRv+EcJKSU/C6/bPFnTBsALce2/NkFABXTxvNgtH+VqZvvvmGgoKC3l6+jMzfFtl1Skbmb8rw4cODtrs9Hl777FvuviJ0Lv3ftuxg+/5DIftdHi/bC0p7lNq2I5ty/OsGOO1W9m5Ywd4N/uMi45KITxtIfNoA4lMH+L6nDYSwCLSShKbDWjJ33w5K8g/6tV03Yyyzsnp3rZEGHa+fN5cT//OFX3v+dw8guduC2QWVFlVECprofqijM9CljEKhDpHJSHTjqvY938gJF4AxEY/biWirRxLdCIISQReBQmPo9NrUsYPQpE3AVbwJ247PiT7mdiRrFbbCDbhq83DXF/lfo8aEIjINVfRA1GmTUOgjg87rdrmDxnJ7XF6sHjs2qx2NRo1Wp0atVnewXnQuZpSK4BUAPS5Pq/tUC15Ronz/ViRJRB8Zyy/P3oTHGZieOFGt4ozYCCaEGRhl1JOsUbVaTKrdHnZY7Gy12vmyppG8UKmIga+2H+TTzXs5e/zQTu8hFE//spFNheWtrwWFkn4TTwg6tkVo2M0NuB09Exl6japTq2K9xUm9xYlaqSA2Uk9CpAGTvmfZ2v5bhEfGMGTUJPZuW0dj7nrmnH45X2351k8UKhUC/zlrTq8DuAVB4MUzZ/PD7lxczQJXkiTeeust/vWvf/XJfcjI/F2QhYaMzN+UhQsXctttt+H1Bu62P/Lae0wfP4opY0YE9JVWVnP5/Y93Of+i1Zt7LTQ25RSxr9Q///+Jl9yOSq2hqjiXqpI8qopysTTW0VBdTkN1OQe3+u82myJjiE8bQHr6AJLTB5CUNpCk9AFsXL3Eb5xKoeCe4yf36jpbOG5Ifyb3T2Z9flvMR/sFPIDkceKuzcNd6wsiF1Q6DBmTMWTOQB3eZkkREPDWHkLyulEaopAMCYiihKDUoAxL6PG1mYbPp758J576fOqWPYKnKXSGLcllwVu1D2/VPpwHfkKVOBLtkFNQmtpqSCgVAl6PiNcromw2PQiC4FfhW5LA6XTjdLoRBAGtVo1Gq0atUbUrDB64CGwJAA+GKPnHarTQ4jZlb6ylo//WCIOO21LjOD4yDHUId7g4tYrZUWHMjgrj9pQ4fjNbeb60ht/MwTOMXb5oKbEmA7MHZwTtD8WiDXv4x3f+MQQDpy0M6jYFbTEaLlvX1sWOdLRmhMLtFSmvtVJea8WoV5MQaSAuUo9aefiuj0eSiTNOYO+2dWxcvYSTzr6S4v3+hSpPHZlJv5jDS9WbGGHi9DHZfLxpb2vb8uXLZaEhI9NDZKEhI/M3o76+nqKiIhoaGjj66KNZvXp1wBiH08W0C67jglOP56J5JzBmcCYFZRV8vmQFL370JXZH8BSg7Xl35QZuOnkGAxM7DyzviCRJPPSZvxgIi4plysnnoeoQt2E1N1BdkkdVcV6r+KgqyaOhuhxLQy2Whlrydm3yO6ZjTvyTRgwk8TAD1wEumzLST2h0heRxYM1ZhTVnNcbsYwkffiqCSoNGraCqeCcA6oRhncaadIZCAKVCgUJvQh2Zhqsmp1OREXiBIp7y7Xgq96AdcjKaATNRKpWtQsDhcGM0ahEERYCrk980koTD4fK5WykEvK3pcYMIjS5iY9wuD0qVwu/Yku1rWk7U2qYWBG5PiePG5NiQAiMYCkFgRoSJ6eFGPqyq54GiSiwdKlY73B5OeeVL7jthCncdN6nLRbnV6eK+b9fwn9Vb/dpN8elkz74w5HEe0fffs8fZeX2PYPdg0qm7HtjxOu1u8uyNFFQ2Eh3mCyCPNP1vBpCPnXIsi/7zCGVFuRTnHaAoZ59f/6kjg9dQ6Smnjcz0Exo7duzA7Xb7rHQyMjLdQhYaMjJ/A7xeLz/++COvvPIKy5Yt67Yv/off/cyH3/3c9cAg2F1uLn35Y5Y9cC3abgaYA7y27Hd+3r7fr23CnIUBIgPAGB6JcehYMoaO9Wt32m1Ul+RRWZxLdXEedSW5VBbnU1leFOCXflT/5B7cVWiCBYWn6TUk6jR4JIlim5MaV7DYAQnrgV9wlO0ifupluKMycJTvAUAV33MXHYXCZ6VRCAKiy0LNmv/grivo8TytiG6ce77GW19A2PiLQOl7H1wOF+Fh+m6Vw2idSpRan7/V6sBmdaDVqlGqlAEB4MGQJAmvW0TZXNPDXFmMpdo/G1S0Ssmng/sx1qTvwU36IwgCFyZEMz3CxBn7Csl3+rtTub0iD/2wlo827uHqaWM4Y2w2yZFtcTqSJJFf28gnm/byxtrtlDZY/I5X60yMP/c+lOrglger2YqEr6+rQoIdMenV3UpmEApRhJpGOzWNdjRqJQlRBuIj9eg1/zuLa4MpnBETprFt3Qp+W7oYh93/GY1NS+yT84xN97cgOp1O8vLyyM7ufepuGZm/G7LQkJH5CyNJEq+99hqPP/44RUVFXR9wGCQkpzJqwlEs+7YtVuH3/fmc/tQ7fHjTBUQaO1/4SZLE68v+4Ka3v/JrV6k1aPVGKgoPEZ82sFtVerV6A6mZw0nN9MWhKASIUkg01FZyx4X+hQiHJPXM4hKKrPhoVAoFnnZC5t7BaVzQz7dYkSSJUruL9XVNLCqq4peqBr/jvU2VVCx/ivAxZ+K1VIOgRB3X/QWNUuHLHtWaFtZtp3b1i7jrg7/vo1LimZGVxojkOExaDfU2B9tLKlm+r4D82saA8Z6ybVg2S5gmXoZSqcTr8fZIZHREkiTsNid2mxO1SonRoEXQqbt8f91uD0q1z6qx4T1/N5ZIpZJvhmYwtI+qeGfoNHw3LIOT9+RTGCQY+1BVPbctXsFti1eQFGEkPToCUZTIq2mg1hoYKwKgMYQz+dJ/E57YP2i/1WzFaXOi0hkBn0VDkjpPPdyesD6MtXC5vRRXNVFc1USESUtCpIGYcF23szgdSSbOOIFt61awbcOKgL6kCGOfnCMxPHAei8USZKSMjEwoZKEhI/MXxeVycfnll/Phhx8e8XMZTWE8+fanxCWlsHX9Wmoq2wJel2zbx8hbnuCx80/mjKNGB02fuzWvmAc/XcKSbfsC+jxuF0vef5Yl7z+L3hRORrMFo//QcSQPHBrU0tERUQKrBIogbi7aPkjFCz63H7XSX2h42hmOBEEg1aDldIOW01NjybHYuXd3AT9VtGXXkrxuGrd8DIAqZiBCqGDxdigVAkqlgKLDQrRx88dBRca0Qak8Nm8mkzKSgi5eRVFi6d487vxqJfsr6/z63GXbcR1aTsTwE3H1slK2FCTrlACt7lVKlQKNRo1aE3xnXpIkPG4vlXvXU31ou1/fW5mpfSYyWkjSqPk4O51jduXh7MQSWN5oDVk5vgVdRBxTr3oaY3Tw7Ga2JhtOm88tUaVrdueTRLwuOypt54H/4KtBodcemf/WGy1OGi1OlEqBuAg9CVHGPhU1PWXkxBlodXoaagILXLo8PcvyFgqXNzArl0olL5tkZHqC/BsjI/MXxOv1cs455/DVV191PfgwiYyJ5Ym3PmFAts/N558vvc2tFy7E6Wjb0S2rb+Silz7i9ve/Zerg/gxLS0KjVlJUXc/GQ4XsKioPOvfwo+aQmJFJwd6tFO7fgd1iZt/GVezbuAoAtUZHWvZI+g8bS8bQcaRnj0KrD74gc4gC2iCLtcoQQb89pdHuxN4hpa+xk+CFQSY9n00azKfF1dy6M5+mlsVR82JWGdV5IL2vBoYiqFXBXrINe9GmgPYn5s/klmMmdOpao1AInDh8IMdk9+O2L1fw+trtfv3WfT9iSB2FOjIFt9uDugducUHvQ/CvHO71iNg9PkuHSqVErVWjaZclCsDt9rLnp/f85rkwPoqZkYcfaxOMbIOOu1LjeLi43aJWEAKCz0OhMUTgsjXiaKpDCpJ8AXwiw2FtSyCgVGkQlGokrxuP09otofFnLPy9XomKOhsVdTYMOhUJkUbiIvV9UjunJ2h1ekZPnsWGVT8F9O2rrO2TuKt9FYFFTRMT+8YtS0bm74IsNGRk/oLcfffdIUXGxKGDOOuYKfRPisfpcrNhXw6Lfl5DTWPPs9tMmnEstz78NMlpbYvikeMn89Q7n3H3ledi6+BmUG228M3GXXyzcVeXc5983uVMOfNGFM11IbweN2V5+8nfs4WCvVsp2LsVW1MDebs2krdrIwAKhZLkgUPIGDqOjKFjyBg6FlNEdOucHq2R6LhE6qrbgqK3Fldy3sRhPb73jmwtDgy0HhLe+eJQEATOSY9ncLiBU3/fS307oeKpPoAkia11MaC5xoRS0VxgL/ickujFvO2LgPaXz57DVdPGdO9mAJ1axX/OnoNaqfAPZBa9mLd/SczMm3A53D0XGi2L8+YbUHUixjweLx6PF7sVVGpls6VDRWPJQWpy2z5DsSol/0zveUaunnBtciyLaxvZ02xxQJJInXQaLms9TWU52OvaJQIQFJjiUnE01uBx2ojKGIbk9VB1YCO7f3iNyZf4u3zZLXY/kdGCSmvEbWvwxWmEx3V6fQLdzzbVV9gcHvIrGimsaiTKpCM+ykC0SdfrtLI9ZeKME9mw6icUCoVf7NW6vLJep6tuz/p8/wruycnJJCQc2c+ZjMxfDVloyMj8xdi3bx9PP/10QPukoZm8cNPFjB880K/9jGOO4tErzubDn9dwxyuLaLIF9y1vQW80MXf+Wcw775JWK0ZHxkw+mne+X81jd93Ajo1/9Oj6I6KiueWfT3LsyQuoarBxqKQBAKVKTVrWCNKyRjB9/sWIokh1ST4Fe7e0io+G6nJKDu2m5NBu1n77PgBxqf3pP3QcGcPG0n/YeFIGDvUTGj/szOGp+bMOK4AW4PudOX6vtQqBwWHdC0geE2li8VFDOP633bibF+LehiKceWt8RfjwCQyVQuiy0rijbBdem7/L08Ix2T0SGS0IgsCTC2bxW04JO0rbdvOdlfvwmCtwhOkxdvMeJUnC1VSDtzmLkrOxGkF0Iyi699+Qx+3F4/aCFQ6u9BfRF8RHEXaEd9RVgsAViTHcnNcmKCxV+Yy/+HH0GiVetwOPwwaCgFpnQqnW0FB6iN9euYnKvX8weM5FVOdsperARir3byBh8CQA7FY7dkvw3zmVrlloOLuOCzBo1Z2KtiOJKEKt2UGt2YFGrWx2rTJg0B7ZAPJpM2fx/vORmBsb/No/WL+Lu4+bfFi/05Ik8d46/w2RCRN6VwBQRubvjCw0ZGT+Yrz66qsBbXMnjWbxv25DGyJzjFaj5vJTjmXCkEEcc9M/abT4V9y+7NZ7yRiYRXRcPNnDR6HVdb24TOnXnxc//o5fvlvM4g/eYO/2LZ2Oj4yJ5eQzL+DMS68hKsYXoB0facDtESmoMAeMVygUJKQPJCF9IJPm+ipgN1SXN4uOLeTv2UpVcS7VJflUl+SzcdmXAOiM/lW8c2saWLI3j5OGDww4R3cx2528v363X9vUmHDUPQianRgdxt2DU3lkX3Frm33/EsIGTUOp0nQpMFqw5f3m91qjUvLCGcd2+zo6olEpeeHM2cx87mO/dmveWvSxqZ0eK3rd1B3cQM3uVTSVHcJjawsyL1r1AcWrF2GITyd64FhSxp2APkTsQkeq97dVbVQAFyZEdf+GDoMFMRE8UFiBudl3v6FgNxpcCIIBlUaPSuP/exGZksmQ4y5m75K3OLTqU9LGzqZo01J2f/8qsYPG4HaK2JtCC3uVtjkgvBuZp8IM/xtZoVxuL6U1FkprLIQbNMRHGYiL0PdJALlJryYl1kRKjImkGCM6jYrlZ57Bm2++6Tcup7qBz7fu63VhRYDvduawu6zGr+3cc8/t9XwyMn9XZKEhI/MXwmKx8P777/u1xUSE8fGDN4YUGe0ZNagfL9x4MRf/+xW/9uryUi6+/vYeX49CoeC4eWdw3LwzyDuwl52bN3Bwzw6qK8oRRS+msHAGDh7G4JFjGD1xKhqtNmCOlFgTbo9IaU3Xu7qRcUmMmXkyY2aeDIDVXE/B3m0U7PVZPEpz9+GwBrqI3frFr8zMTMOo7Z3ryV1fr6LR7l9b5LL+PfflvjUzhW9Ka9ll9gk9yWWhacObhA+YjCY6A2VYHBKCL02sRECqXkkUcVX5V2xfODrrsP3Vpw5MYXRqPNtL2qwarqqDuF2eoBmRJEmiavsyin/7FLe1vuN07caJWCsLsFYWUPzHV8RkTSTzhKvQR4Z2T3E21eKytFlsRhv1pPXyfespBqWCYyNNfF3bLHwlkcbyPGIyhoc8ZuC006k6tIWanG00lBxCa4rCWlvGwZVfkDAieFXwFtpnnuoMpULA2IvaGUcas82F2eYiv7yR2Ag98ZEGIoyBv+Oh0KgUJMeaSI4xkhJrItzgf6zX66Vfv+AuUjd9/iszM9N79dmvsdi47tNlfm2JiYnMm1zHxC4AAE/qSURBVDevx3PJyPzdkYWGjMxfiM8//xyz2X/3/8pTZxNu7DqQtIWzj53KfW9+Sml122Ju2TdfcP19/0Jv6H3ayAHZQ0O6WnVFRmI4bq+XqvrO3bo6YgyPYtjkYxg2+RgAXA4bRQd2suS9ZynNbSvElVvTwDWfLOO9C0/qsbvFZ5v38ebvO/za0vQaTkqMDnFEaNQKBbdkpnDpljaxYCvdha3U58KhUOvQxmSgi8lAF+v7rjTFIkkCoiThrCtB8vrXfDh5xOEXLxMEX4B4e6HhbixF8rpxOd1odW0Lfae5hpwfXsBc2HUcTkdqD26kIX8nA4+7jORxc4P6+jeV+buojTL1bZaprhhl1LcJDaCx5FCnQkNQKBhzxh2seuEqzOW5xA+eSNX+jeSu+ZTI/pPQmkJ/Trpr0QjTa/60uIje4BUlKuttVNbb0GlUJEYZiIs0oFX7u7spFJAQZSQ5xkhyjIm4CH3I+9qxYwfnn38+u3fvDtpfa7VzyqtfsuT6M4k1df/vX4PNwSmvLKaiQ5KIe+65B43mv5dlS0bm/yuy0JCR+Quxbt26gLYrTumZ24xKpeSSE2fxr/cXt7Y57DbyDuxl2Jj/no/yoOQoPF6JOnNg0Gx30egMDBo1mUseeo3nrjsNq7ltt/3jTXsRJYlXzj6OcH3Xu66SJPHab9u5+YtfAvqeGTnAF0/RC05LjiF2V75fcT9tTAauhlJEtwN7xX7sFW0FDRUaQ6vwkMTAjEZj0vomeHVsx3lEL15rLU5HdKvQsNeWsveTB3A1BWbriQ8zMKFfEoMTY9ColFQ3WdlWXMn2kiq87cqfe90ODv74Mvb6cgbOviRgoems9w/QHdVFfZa+puP5zJUFXR6jj4hl9IJb2LToYar2b0QfnYq9roSCtR+TPff6kMe1pLjtKkbjzw4CPxwcLg8FlWYKq8xEmbRkpUYxakA8KXEmkqKN3YozWb58OQsWLOiypsW24iomP/khb54/t1vB4WtzSrjioyUcqvK3wk2dOpXrrruuy+NlZGQCkYWGjMxfiNpa/wVeWnwM6Qk9L0g3dURgobgfv/iInH17UGs0aLRaNBotGq0WdfP3jq/VGi3a5u8qtfqwd1wFAbJTo9hbVEujxdX1AZ1giohm3jX389ETt/q1f7p5H3/klvLYvBksGJOFOkjdDUmS2FRYwQPf/8Yv+wsC+s9Ji+PEpJ5bM1rQKhWcmBjNB0Vt1oO4sQswJA3B2VCGs7YAR00BjtoCnHXFiC4btvK92Mr3Bp0vLqz7u7mdEWweQXTjdnlQCALOplr2fvpggMg4akAKdx03iROGDQjqp19S38Qba7fz/IrN2NrV5ij+4yuUGj39Z5wD+ILh1Wqoz/e3HsUfZnrdnpKg8T+f19U9K1vS8KNJHXs8JVt/xm03AwLV+9eSNHIO4cnBCzN2x6KhUysDLAP/y2jVSiKMWqJMWiKMWlRKJbnlDSCAUacmOqxzC9WGDRs47bTTsNu799wLahuZ88JnnDJiEFdOG82MzDQM7dxI7S43a3NLeWPtdr7ZcTAgY3F0dDTvvfceyiB/C2RkZLpGFhoyMn8hnE7/OAGDrvv+0F0d9/2nH/A9H/RqPkEQ0Gh1zSJFh6b5eyjREkq8aLQ6lCo1NRYPXpSo1RqUag1qjRalSoNaE+K1WotKo0GhbKvHMGLqccw64wpWfuEfSFpUb+a8d78ncbGR2YMzGJOWQIxRj93tZndZDWs7ZGBqz8QoE8+NGtCrZ9SeMVEmP6HhqC3EmDIcXXQauug0IjKnASB5PTgbSnHU5OOoLcRatgePxT+A1dGhtkdv6VgjBECv06JEQq1SsO+n/+Ayt51brVTw5PxZXDdjbKfuaKlRYTx8yjQumjyciz/4iXV5bRaLgtUfk5w9hrgBQync8AP7ln+Cs8l/t1n5J3sMdVxuikGsSMFwOVykHXUOtfk7sdeXow2Pw2muJnflu4w+598IQURYd2I0/tetGUqFQIRRS6TJ9xUsE5XD5WVPQS17CmqJjdCTlRrJwKRINB0ElNlsZsGCBd0WGe35flcO3+/KQakQyIqPJlyvpcnu5EBVnZ9FrT2RkZEsXbqUQYMO3/1QRubviiw0ZGT+QkRERPi9LqmuxesVUfYw7WVxZU1A25jJRxMWHonL6cDlcuFyOXA5nbhdztbvznavPe623WlJknA67M1F/BoD5v6zEAQBlVrbLEY0KFRqDGGR2JoaAsZWmK0s2riHRRv3dGvuqTHhfD55MKY+SLM6MsI/FsZlrgw6TlCq0MX0QxfjcwuxVR6keMnjfmP2lNeQ1AfFy/aUBX4mVPpIRK9I2ZZl1OW21dpQKxV8fdUC5g7rvugaGBfFshvOZMEbX7N8X4GvUZLYvOhhJAncNl9chEpn8KWRbcbm7V7RvL7C2iEAX6nqeqHvcrqwNFhQqnVkz72BHZ/dj9NcjUKlwVpdQOWeFSSOmB1wnErb7DoVwqIhCGD6L1bnDoYg+MRPpFFLpFGLyaAJqFrfGTWNdmoa7WzYV0FGYjiZKVEkxxgRBIHXXnuNsrKykMcKgsCE4YOJCDOxetN2XO7A6vVeUQpaiK8jQ4cO5bPPPmP48NDxNzIyMl0jCw0Zmb8Q6enpfq+tdidLN27npKPG9mieL1etD2i7/V/Pkj6g+zt7oij6RIfLhcvpwN383eVsJ1KcTlzNwsTlan7drs3d4Xv7sQ6Hg/pGC26nE4/b5ftyOfF4XHhcza/dTryetp14SZJwuxy4XQ66kTG0W6gEgTuyUrgjOxVNH6TwBIjq4A4kebrnKqaLTsOXB7dt8b02p4TZgzMO+5p+zy3xe60yxqDUmZBELwVrPvHre2zejB6JjBb0GjWfXXYaox59h+J6X3Ywl9UnMExxqQw74UIq9m2icNPy1mP22x2cQniPz9Vb9tv8rYa6iM5dE11OF5b6tlgCU8IA+k05i4K1H7fG1BT8/hmxmZNbYzJaaLNoBI9FMOnUKA+z/ktfYNCqiDTpiDRqCDdq+6Seh1eUyC1rJLesEaNezcDEcF555ZWQ4y849Xgeuu5SMlJ8KZKdLhfX/+s53v36J6RuVnAHUKvV3H777Tz44INog2TBk5GR6Rmy0JCR+QuxcOFCnnjiCb+2V79e1iOhUVxVw3e/b/ZrG5A9lLT+PaszoVAo0Or0zTU3Iroc3xusDje78mvwdrKrLYoi3hYh4nbhdjnxul243U68bnfb66Y6dqxdyv7tG5otL52jFODkpGjuzk5jRETvs3EFvWb870ejVhIVpmv2H/f1tY6Q2rdo0EWn4KhrEwXvrdvFP06YcliLv4pGC9/v8s/2pI9JR6lUYC7ehqupzdoxoV8SN8wc1+tzheu1vHLO8ZzyypetbYaoBE58YBFKldpPZADsCFJR+0iyw+r/2YhMyQw51u10+4mMFlLGnUx94Q4ai/egUKrxOJooXP8lA2de3DrG63bibI53cTRWU75jGWpDOMa4DHQRCQiC8F9zm9KoFESYtEQadUSatEc8RsRqd7Pos68pLCwM2n/bxWfz5O3X+rVpNRrefPguHrruUqadfy2F5cGtgi1kZGRw2WWXcfnll5OY2PPU1DIyMsGRhYaMzF+ICRMmMH78eDZvbhMKSzdsZ+mG7cydNLrL4yVJ4vb/fIjYwWd5/vmX/U+mzzTq1AztF8Oegho6eLS0olAoUGh1qLWdB5kKwNRZJ+F1Odj6xy8c2LmZnL3bKC/Oax1jUCo4LiGKiVEmTk+NJbkb2al6Q5XD3+VDbzQSZtDg9Yp4vBJiJzu0CYOPpvCPT1tflzT4gq2vndEzq1Z7Hl26DrfX/wE3FW0j94s7A2IL7pgz8bCLs80d2p8RyXHsKqsGwFZfiau+hMjEAdQXH/Qbu7nJhluUUP9JO/vrm/yLWUalZiEIzWKv3dvidrlpqg+s2QIgCAqyjruWbYvubI2/KN+xjLjBR2OrKaJy9wqaKnNpiUz2OJrIXflO6/EqrZHYQROIOGY+hrTggeR9iVIhEN7sChVp0v5XanZs37AyaHtMZAQP33BZyONSEuJY/OKjjD/j8qD9t912G7fddhtJSd0rFikjI9MzZKEhI/MX49prr+XSSy/1azv7wef54pFbmTNhZMjjPB4vN73wLotXb/BrN5hMHHfa6UfkWvuCcIOG7LRo9hfXIYUQG91BAiwiRGh1TJ51MpNnnYzb7eL6hZNa3a+iNSoWTTzyC7sdjf5+XUlpA0mJaXOrkSQJt1fE65XwiGKrAPF4RTLGzKFo/Rd+qW7v+WY1c4ZkkBnf82xYy/cV8OqabUH7nGb/oPgIvZZTRvZN3Y4LJg3jzq9XtbbVHNqF4PbitDT6AgGaF+E1Hi9L6s2cGnNkrGbt2W6x+1lQ9OHRpGVkBBYs9HjxWL3EJYUjSa2XioTU9nNcGNqFN7H24383N4js+vzBoCmKO+JxWqnYs4of96wiPXs0J110JzFJ6a3n8glRqfl183dafu74GsRmlSRJEqLvR0x6NZFGLREmTWu6Z1HyidxQov5IUlNRGrT9rBOOQdeFi9OYIVmMyBzArkN5AX1RUVGyyJCROYLIQkNG5i/G2WefzUMPPURRUVFrm8Xu4ITb/83CGZO4Zv5xzBg9tHVx1GSz89Gy33jxyyUcLC4PmG/+eZdhMIX9adffG6LDdGSmRHGwOHQV6u7glgQcooSueUNerdaQ0i+Totx9AJTYXVQ6XCTojqzLyuYOO+Gxqf7uOYIgoFEpg/8FjzZSPeVU9q79urXJ6nIz96XPWXbjWQyMi+r2dfyeW8KZb30T0J4x7XwEQaBi90rs7dy0xqYlBE0J3BsmZiT7va4tOojH6VvkRyb2o6G8oLXvncr6P0VovFtZ5/faaTWz7tPnGDz9NKJTml0LvSKizdEcAC34TGUhGDR6OiV7fqdgx2qAbomMjhQd2M6bD17M/Itu5Lj5F/ba8hhm0JASayIlxkhSjBFtF2mDJUlCFCUkaK5UH/i6RfR01i+17285JsjxCm9wF7mxQ7sn/McMzQoqNBob/3vJKWRk/g7IQkNG5i+GXq9n8eLFzJgxA5vN381j8eoNLF69gcToSPolxuFyu9lbWIrTFZidBWD0pKlcevPdf8ZlHzZxEXrcHpH88sNbOFglAY0k0eKJk5E1rFVoAHxeUsMNg5JDHH34NLo9LK1oE0yCQkF0Us8Cq8fMvYjifetpqm0TjoV1ZiY8/j7PLDyGi48a0emC1O318vjP63l0yTo8HbavI9NHkDL2JARBIDJ9JNsW3dHaNzgxpkfX2RlDOsxlN9dha/DFgvQffyx7fv0cl80nyNaarSyrb+K4qCMniPdYHXxe4//ZEr0e9q3+mn2rvyZh4AgGH30qaVmTUKm7J0TrKwqozNt52Nfmcbv44q2nqSzJ5/zrH0DRDdc1nUZJUrSRlFgTyTGmHsd7CIKAsiW38J9QYiImKnjAf1lVdbeOLw2SSQ98fy9lZGSOHLLQkJH5CzJ+/Hi++uor5s+fHzTnfEVdAxV1DZ3OMWTkWP792odo/h9lXkmOMeL2eimp6rxicGdIks+FKrx58TRh2vGsWdIWmPxWfgXXDUzqUcrOnvBJcTXWdvEQKVnjUet6VnRPrdEx7ew7+fn1u/C2y1hldri44qOlPPvrJi6fOoqZWekMTYpBrVRid7nZUVrNsr35vPX7DsoaA5+hzhTFtDNvRRtmxOOVUFj8V5jqPsg2FGour9dDZY6vWF/asEl4HFZ2LW+LRbk1r4y1owYR2QfphTviFiWuzy3F3S42pt/o6QydOZ99a76lcPtvVObuojJ3F1pDOIPGzyF70omEx6WEnLOproJlb96DvenwrHDtWbN0MSqNlnOvviegT6kQSIgykBxjIiXWREy47n8y7ioUCQnBK9x/tXwN917ZuSWnpr6B37bsCNoXal4ZGZm+QRYaMjJ/UY4//nhWrVrF/PnzO809H4zpx53MP559Fb2hb7Mp/Rn0iw/H7RGprLN1PTgELknAKUpoFTB41CQSUzOoKCkAINfq4KOiKi7o1/cLFLPbw/OH/H3RB085pVdzxfcbwqwL72fFBw8jevwtVvsqarlt8QrAtwDVqlTY3e6Aqsjt0RkjOP6KfxMV3+bProiJ9BtTYe6jnMFB5pK8Hlw2C2qdkZi0TMLjU8nd+Au2Rt9OdYXbw815pbydmYayjxfQjxRXssvW5rqj0uiYuPA6wuOSSR48HltdNftXf8PBDUuwNlSzZ81i9qxZTFLmGAZPPom0oZNRKNv+uxVFL2s+eSKkyFArFZw+Jpszxw9hfHoiieFG3F6RveU1rMkp5s21O0LWgljx3cdkDRvL+GnHExOuIznGRHKskcQoY5+knf1vMWPGDD7//POA9u37D/H9qt85ddbRIY99/K1FQWtqAEyfPr3PrlFGRiYQQepJgmkZGZn/dzQ1NfH+++/zyiuvsG/fvpDjlEolR88+gXnnX8a4KdP/X+12dkQCDhTXUdvY+9SnggBRCp8L1S/ffsSnr7cVwotQKdl07Og+zzp1/bZc3itsS8MZFp3EgjvfDlo1urtU5u9mzSdPYG3onotJMKKTBzLzvHsDduhF0cvHDyzE4/I950Fxkex/6Mpen6c9n27ey/nv/tD6OnXYJEr2bCB95FTmXOt7L4p3rWPZy3f6HXdOXCTPD0juE7EhSRJPllTzVKn/szvqrJsZOmuh74Uo4bXaQZIQRS+l+zdxYP2PlBzY3BoFrg+LJmvSCWRNnIsxMo7dqxez+cc3O54OgOmZabx53txOY2kkSeKdP3Zy+1craXIE1liJjo5h+85dpKX8dYKcGxoaSE5ODmqhjQoP48Mn7ueEaZP92r1eL8+9/zl3P/da0FoaRx11FH/88ccRu2YZGRlZaMjI/G2QJInlK1byytsfUlFWTFNjA2q1hrDIKAaPGM0JC88hPim0q8f/N0RRYm9RLY2W7hW7C4ZWkAhTgtvl5J83nEFFcX5r39Ex4XwzZSi6Ptol/qKkhks2+6duPeaiB0kfdtRhz+1yWNn849sc3LiETs0WHVCqNIw85ixGzDrLb0e+PT+9citVBXtbX++6/7KA+IrecP673/Pp5jZhnDRwGOW5e5h1/i2MmnN2a8atX95+hEPrlvgdOzvSxPMDkknU9D4Na5PHy32FFXxc3eDXnpQ9lhNues4n/tqJjIDj6yo4uGEJhzb9jMPim0MQFCRnjaUid6efS1sLl08dyctnH9ft9MD7KmqZ88KnQS1JN998M88991y35vn/whVXXMFbb70Vsn/yqGEsnDOD9OREdh7I4aMfllFQWhFy/Icffsj5559/JC5VRkamGVloyMj8jSgzO8mr7b1L0f83vKLI7vxaLPbgbhPdIVwpoREg9//au+/wqMr0jeP39JmUmTRCIJAQegcpgsqCSrFgYdeCbdW1Yq+r/tbVXVnXta9l17qKqIugruAu2BtYQATpRUSqQIAQID2TmTm/PyIDSSYwSU7693Nde105Z84588JiMnfe93mftcv04O0XyzikOHpc2wS9PrSHYupYF/DOthxdtuhHBQ75dtz5qBM08vw76/TcyvJzs/XDgve0ftHHKimovjYgPrm9uh99sroNHSd3XMJhn7ns02la8uGr4ePrRg3Sk+eOqdM4s/cXKOue58K9O1yeWIVCQZWVlujGJ99W+6yekqSigv2act8kbf1hRZVnJNhseqBTms5O8dWonsYwDH22v0C3btihbZU2SUjq2E2n3vKkXDHxhw0ZhwoGyrRl5Tf6YcEcZR+m8Ht0z0y9f925stawH8h3m3doxKOvK1ip943P59O2bdsUG9v8lj9WZ9WqVRowYICCwZrvzlVZRkaGfvjhB7ndh++vA6BuCBpAK7IyO1/7igONPYwGVRYMacXG3Souqd2HE6tFSvhlCdU7U5/SezMqLnnp543R84O6qX9CzT/QFQeDun/NVj21fnuFXuAxvhSdecuz5R9o64FhGCrYu1N7fv5Rhft2KRgMyO5wKT65nZI7dFNM/JH7bRiGoa2rF2jpx68pd/vBbUPtVqu+vfNiDeiQWuvxnf/Su3rr+x/Cx32PHauV33ysmPgE/fG1ebJarcrfm6OX7r1S2Zt/lCsmXm0zOmvL2qoFv1lup37XNlETUxKUfJgtWwuCQc3ck6eXs3Mr1GMckJLRQyfd+Gh58IoyZFS2b+cWvffsbeHdsg7wOOxade8VykiKvLPSkfzfrLl65ONvq5yfMmWKLr300lo9s6l66KGHdNddddsJz+Fw6OOPP9aoUaNMGhWA6lAMDrQSgZCh/SWtK2RI5YW1fTJTtHzDbvnLat5pLGRIhYYUb5Em/PZ67d2drfmf/S/8+oq8Io2cu1w3dW2va7q0U1oUPTYCIUPvZ+fq3tVb9GNBxTXnrhivxl3xQL2FDKl8a9L4pDTFJ6XV+N5QKKjNy7/S8s+na++Ojb88zyrjl26JgVBIl0ydrbm3XihfLWpYps5fUSFkWKxWeZPLQ0uXfkfLarUqd+c2vXTPFdqTvVXxiSm6/L4XlJKepQ9efUJf//fVCuvxN5b4de/mnbp3805luZ0aEOtWF7dTLqtV/pChraV+LSss0briUlX3r6PXsSfphIvvkM0Vq2AgKH9RUY1DhiS5YuKrhAxJumBo71qHDEm6ZfQQPfHZd1W6t3/++ectLmjccccd2r59u5566qla3W+z2fTqq68SMoAGwowG0ErsKvBr3W7zdgVqbopKA1qxIUeBYO3aGh9YQhUMBvTa05P11Uczq1xjt1h0WrskjWuboKMS4tQz3iPHL+vtd5b4tWRfgb7NLdC0rbu0rbjqGn1PfJLGXfmAEtM61WqM9SkUDGjDks+1/LPpyssp3xnL4YpRz2NPU+dBo/Xhc3eopPBgn4mhme00a9Jv1NYb3UyPYRh6Zf4KTXrjwyrLgOxOlwL+Up1y6W3qOWSkXrr3SuXl7lJS2w66fPILSm6XEb520+rv9daTf9SeHVsqv0WNxcQn6Kwb7lOf4aMllW8QkGA1ZLOUL8vzB0LylwXL/xcIqbQsqLJAUKWBoPxlIfkDQYUO+bP8vGahPplyb5X3+fTm8zSqW0aV8zVxxrNv672VFRvS9e7dW6tWrarTc5siwzD00EMP6e6771aoBm3KfT6fZsyYoZNOOqkeRwfgUAQNoJVYu6tQOYW1L4xuCfKL/Vq5MUc1+GwSZv1lFyqLpfyDzhfvvam3X3pMpSVVd8E5wCLJY7OqLGRU6MEQSYeeR+vYs25SjM+8pndmCAb8+vG7j7XyizdVsLd8RyynJ069R/xavY47IzzzUrZ9qf79RMUlLcmxHv397BM1cUivwxY4/7w3X7e8/almLq1YDB/rTVRZmV/+4vKAbLXZZLFYFQyUKbVjF10x+cXwbMcBoVBIbz52h5Z++UGd/+yx8Qma9PDrapPeSRaL5LMastdwM6uy4C9hJBDUp7Ne1QfTnq7wusUi7X30ZsXVsdv85Dlfa/J7X1c4Z7Va5ff7ZTOpW3tTs2zZMj3++OOaMWOGSktLq70uJSVFl19+uW6++WalpdV8Fg9A7RE0gFYgZBj6dsv+Kr8pbo32FpRozZZcGbUIG26robhDPi/vzv5Zrz51n9YsXVDr8bhi4jX09KvVZdDoJrWlcMBfoh++fV+r5r6torzyng3uuAT1GXmWeg4fX6GJYEKcS307pejD/7yit156rMqzMpO8+u2wvhqW1V690pLltFm1K79IS7bu1HurNui/y3+s8m8zOa2jrn7wVe3YuFZT7rtGFqu1QiF+WlZ3HXfaRRow8hQ5XQe7Oy+cM1XvPP9IlTFYLRYZhqHq/gtw2m3yB6rW8aR27Kwbn3hLKW5njUPGAd5Yp9JT4vTmy0/ryccerPBaUqxbux6+sXYPPsQr81foitffr3I+Pz9fcXFxdX5+U5aTk6OpU6fqiy++UHZ2toqKiuTz+ZSRkaHTTjtNZ599NkXfQCMhaACtwN6iMq3aWftu2S1Nzv5i/bC1dh2ZfTZDjkM+cBqGoY0/rNDnc2bou3kfKFAW/azR0adPUrdhJ8vhbDofgvwlhVo7f7ZWz3snvBQqxpeifsefo25DT5K90litFosGdm2jGFf5VrKf/G+63nrxIQUDta8HSu/SW5fc8095k9roo3//Q5/NeC5cBxKXkKKi/H0KBcuf7471asiYCRp28rlqm+DS3ZeMV5m/4v8HJ/TtppevO19JcTFatnm79uQVqjQQkNNuky/GowGd0hXvdunx2Z/rj9PeU7DSlNdJZ1+mcy67Jerxu522cAfu9smxivOUz1ZMnjxZf/rTnypc63U7lfvYzbX4W6roX18v06RpH1Y5X1RUJI/HE+EOAKh/BA2gFVifU6Ts/OqXFrRGO3ILtWH7/iNfWIntl3X6kSYfCvL3a/3qJdr84ypt/nG19uzarrIyv2w2uzyxcerYuaeKCwu0cO57ateln066uupv3htLSWGe1nz9rtZ8/a78xeWhND6pnfqdcK66DB4tmz3y0p4OKXHqlOYLHxuGtHL9Or315B+1fUP1DSIjsdrsOnHi1Trh7Ctks5cHl0euPjVcb9F7+Ik6//ZH5C8p0qJPZurb999U7s6fw/cnJCVrX27FjtmnD+mrN2+7VI4otyCe+e1ynfvYKxUKym02ux6c8oESUyJ3g7dZLUpLig0Hi6R4d8TZqWeeeUbXXXddlfNb/nqN2ifUrfj/1rc/1VOfL65wLiYmRgUFBU1qpgxA68KuU0ALZxiGcotq30eipWqXFKtAMKQtO6vuAnQ4QUMqMqTYCJ/d4uJ9GjjseA0cdny19z/1p/IPmn0GjajR+9aXovxcrZ73jtbOn6OAv7zexJfaUf1PPE9ZA46X9TDr+10Omzq2qfgB2WKROnburusee0Mrv/lYC96foY0rFx12DDHxPg0ePUHDTz1PyWkdw+fnvjMlHDL6HjtW5//+EdlsdjmcLo36zWX61YRLtWnFfC379G19+8XHVUJGh+QEvXL9BVGHDEn69bD+umn8KD0x+4vwuWAwoC8/fEdnXHhN+Fyy1630lPJZi7YJMbJF0bhx4MCBEc9//dM2nTO4Z9RjjOSbDdsivh8hA0BjYkYDaOHySwNatr1mH6Zbk5927Ff2nprvxpVgq0VhsL9UN00cIX9pif7viRna4fcd+aZ6Urhvt1bOfUvrvv0g3KU6qX0X9T/xPGX2Pa688/UR9OyYpBRf1WU5BSGpJHTwL2ff7h3aum6Ftq1fpbzc3QqFgnK6Y9Q2o4vSu/RWetc+cjgPboVrGIY+nf6sPnnjGUnlDfv+9MZ8WSuNyRfnVM+OSbLbrHr2ofs07fknK7z+yvUX6KJRQ6P/S/lFYUmpOk2arL2FB5tbtm2fobc//EbpyXFqlxwrt7Pmv6crKiqS1+ut0nBudM9MfXjDxBo/74ClW3dqyINTq5y/8cYb9eSTT0a4AwAaBjMaQAu3p5DZjMPp3M6nYDCk3fuq3z0qkvyQlGBVxCVU1Vm3crH8pSVKSE5V5269VLgxR3lFDbsTWN6e7Vrx+Zv6afEn4TqHlIyeGjD6fHXoeXTUvwH3xboihgxJckg6tOVdQpt2SmjTTv2OG3fE54ZCIc1+6SF9879/h8/1PXZslZDRLjlWWWm+8N//1o3rK7yeEOvROcceFdWfpbJYt0u/HTVET703L3xu5/Yt6pnmUkpK7cNhTEyMxowZow8/rFhL8enazfpozUaN65VV42cahqE/vDsv4munn356rcYJAGY58q+sADRre1g2dVgWSd3SE5UQV7PmckHDouIazgevWPSlJKnv4ONksViU7G24It19Ozdr3vSHNfPhK/Tjwg8UCgaU1mWAxl35N42/7u/q2GtY1CHDarGoS/vqP3DXdnemYDCgt5/8YzhkJKSUb0Xatf+w8DUWq9Q1PUGd2/kqhLwfVy2v8Kzh3TvJdZhO4Efyq95dqpxbsmRJrZ93wDXXXBPx/NX//kC78ms+s/bM3CX6aM3GKue7d++uE088scbPAwAzMaMBtGDFZUEVl1XdshMVWSxSr4wkrdiUo4IaBLOikEVOS/RLqFYu+kqS1HdIeX1Gis+jjdk1L0iviT3b1mv5Z9O1eeXX4W7W6T2Gqv/o89S2U59aPbN9cmx4l6lIbBb90m8k+meW+Us17eHbtWbh57JabTpz0t2a9dz9kqTO/Y+WJDkcVvXskCRvbNXC9P17cyscd2/fJvo3j6BH+9Qq53Jycur0TEkaP368unbtqvXrK87AbN2br3FPzdB/rzk7qi7hhmHoha+W6pa3P434+s0331xlFggAGhpBA2jBmM2IntVqUZ/MZC3fmKPikui3Zi0ISb4ollDtzv5Z2T9vktVqU++BwyWVF1N7Y5z1snxq1+bVWv7pdP28dmH4XGbf49TvxPOU0qFbrZ/rjFAAHolDhvyKLoGVFhVq6l9v0IYVC2V3OHXBnY9LhiEjFFKb9Cz5ktsq1uNQr4wkuRyRC7srlxtaonzv6kSa3alJF+rq2O12vfDCCxFnG1Zuz9GAv76sB84cpd8d00/uamZk1u3M1e/f+VxzVv4U8fVhw4bpqquuqvNYAaCuCBpAC8ZuUzVjt1nDYcPvj24mKGBYVGwYijnC59oDsxldeg1QTNzB31gnez2mBQ3DMJT903It/+wN7Vi/VJJksViVNWCU+p04UYlpner8Hllp3qh2WLJbJH8UMxqFefs05b5J+vnHlXJ5YnXxH59Wl35H638vlje269xvqFJ8HnVLT5DVWv1fsjchUSXFB4u312fvPvKbH8b6HVXvT042p2v7CSecoOuvv17/+Mc/qryWX+LXDTM+1p9nf6UzB3TV4Iw0tU+Il78sqFU7cjRv/VZ9sW5Ltc92u92aMmVKi+0GDqB5IWgALZQ/GFJeDX4zj3Iuh019OyVr+YYcBQLR/Qa7KGSRy2LIdpiwseKXoNFvyK8qnE/xuuu8fMowDG1b+52WfzZduzavliRZrDZ1HTxG/U6YKG9K+zo9/wBfrEttfDFHvlDR1Wns37NTL917lXZt/Ukx8Qm67M/PqUO3vpKkn1aUz8QMH3m8enRMPOKzuvXup107Dm7xumDdZpUFgjXa2vZQX67ZUOXcUUfVrrg8kkcffVTr1q3TRx99FPH1PYXFevmbFXr5mxVRP9Nms2n69Onq1auXWcMEgDohaAAtFLMZtedx2tUnM1krN+UoGIyu0CD/MEuoyvylWrus/IPzgfqMA1xOu+JjnMqvxayGEQppy6pvtOzTN5S7vXwZjdXuUPejT1bfUecoLrFqnUFtWS0WdWkX/Y5LR/rhkrN9i/517xXat2u7vMltdcXkF5TasbwAu2B/rrI3rZMkjR47Jqr36z1wsL7+9IPw8Z78Qs1auLxWO0+VlgX02tzvKpzLyMhQ27aRG/bVhsvl0syZMzVx4kTNnj3blOdNnz5dZ555pgmjAwBzUCkGtFDUZ9RNnMehnhlJskT5XTJgWFRSTSYp39a2WL6kNurYuUeV11NquPtUKBjUT99/pnf/Pkmfv3a/crf/JLvTrT4jz9LZd72i4ROuMzVkSOXbyca4qy8Ar8xqkWyWyH8h2zeu1XN3/Vb7dm1XcrsMXfPQa+GQIUlb15R3uO7co7cSk1Oier/Rp/2myrm7p81RYUlp1GM+4K//+Ui78woqnLvwwgtr/JwjiYmJ0axZs/TII4/I5arZrmeHGjRokL777jtNmDDBvMEBgAkIGkALFAwZ2l/Msqm6Soh1qUeHREVbV1wUsijSBEh4t6lftrWtLMXrjur5wUCZ1i38QDMfvUJfTn9Y+3ZukcMdo/6jz9fZ/zdVQ0+7UjFec+oIDuV02JQRRQF4ZZGWT21es0Qv/OEyFezbo3ZZPTTpwVeVmHpwaZcvzqm9G5dJkgYf86uqD6hGemaWho0aXeHchp17NOn5NxUMRl/E/dGytXpoZsWdnKxWa70VV9tsNt1+++1atmyZzj777BrVVnTs2FGPPfaYFixYoH79+tXL+ACgLlg6BbRAe4vLFKrJ3qKoVrLXo67tQ1q/7ch1FIakHXtylL32e+Xvy1UgUCZPTJwWf/OJJKlfpWVTBxxp+VSgrFQ/fvehVn7xlgr3lRcpu2K86jPyN+p5zOlyemJr94eLUlbb6ArAK3NIOnQ+Yd33X+u1B25Smb9Emb2O0qX3/FOeQwrjDzTh+9u3X0uSBh07skbvd9Xt92jRV19U6Lz9xlffq7DUr+evnqg2vrhq7zUMQy9+Ml+3TJmpYKXdpa677jp16tSpRmOpqR49euitt97Stm3bNHXqVM2bN0+LFy+usKWu1WpVr169NGTIEP3617/W+PHjZbfzYxxA02UxKu8JCKDZW7e7ULsKGrbjdEv38+4Cbd6ZF/E1wzC0YeV3WvDeDK1a8Gm443ZlEy6+QcePn6i4+Kq1DttyCqoUhZeVFuuHBXO0cu5/VFKwV5LkiU9S31Fnqfvw8XI4o5sJqQtfrEv9sqJbvlRZwJD2BcunNZZ/9aFmPH6ngoGAug8aoYv+7+9yusqXjFmsUpd2CWqbGKPd2dv1m2P7ymq1avb3PyneW7NO3P/6+wOa+vSjVc6nxMfq2lNG6KKRQ5SVmhyeWcovLtGHS9fqyTlzNf+HTVXu69y5s5YvX67Y2PoNc5EYhqE9e/aosLBQdrtdSUlJ8ngarskjANQVQQNoYUKGoYVb9isQ4j9ts23I3q8dORW7N+/Pyda0R36vzWui6xrtcns08ao7NPLksyucL/UH9N26neVfFxdo7Tf/1eovZ6q0KF+SFJuQqn4nnKuuQ8bJ7qjasK4+WCzSwC6piq1BbcahDEPKDVr07Udva+Yzk2WEQuo/4iSde8uDsjvKn+lwWNWzY5K8MeV/pg9nvan7b52knv2O0ovvRm5GdziBsjLdfc3F+uazD6u9JiU+Vu2TfCos8WvDrj1VenAckJCQoLlz56p///41HgcAgKVTQIuTVxIgZNSTrDSfAoGQdu8rliTt+nmD/nXPlcrbszPqZ5SWFOvVp+5Tzs7t+vXFN4R/s+5y2mUPFmnhx29qzTf/VVlJeU8Ib0q6+p0wUV0GnSirrWG/ZbdLiqt1yJDKg8qXM1/W7CmPS5KOPukcTZj0R1l/qUOI1IRvyfwvJUmDalCfcSi7w6HJ/5yiyTddpXkfRd7NKSe/UDn5hRFfOyA1NVXvv/8+IQMA6oCgAbQwbGtbfyySuqUnKhAMacuWbXr5z5NqFDIO9d6MFxUX79O431yifXt26cN3puqLOW+qzF8iSUpI66T+J56nTv1/Jau14ZuvOR02ZaTWvAD8AMMw9M4rT+r9t16SJI0663KdfPHN4WBVXRO+7w8EjWNrFzQkyeVy6y/PvKJZr7+s5x+5T0WFhw8VlU2YMEHPPvus0tLSaj0GAABLp4AWZ9HW/SqJstEcaicUMnTDxedq+TeRl/aMO+5onTJimOJiY7Rq/UZNm/2xduXurXKdxWLV4BFjtXT+ZwoEygNicno39R99vjJ6D5fF2ngbA/bokKg2CdE156ssFAzq388+oLnvvSlJOvmSW3T8WZeHX89s61WHNlULs7dv3ayJo46SzW7Xe0s2KCa2+uLtaLT3umQvzNETTzyhKVOmaN++fYe9/qSTTtKNN96oU045JeLuYACAmiFoAC1IQWlAS7fnN/YwWrwtG9brwjFHVzk/YlB/vTj5TnXv1LHC+VK/X8/NmKU7HntWgUCwyn2S1K3PII0/7yoFErqpoLhxZ6XqVABeVqaXH79bC+e+L4vFoouuv1d9xp4jSbLZLOreIVFJ8ZGL2Oe8+boevOtG9Rs8TM+89X6txy9JafEudU05GJSKi4v15ZdfavHixVq5cqUKCgrkcDiUkZGhwYMHa8SIEcrMzKzTewIAKmLpFNCC5DbyB9TW4t1pU6qcG9y7hz544TF53FUbr7mcTt3023OVmpyki+6YXOE1i8WqG+59Sv2HjZJUvvtUQfGRt9KtLxaL1LkGHcAPVVpSrGcfuFUrF30lm92uK27/m4aOPFm5QcnhsKl3RtJhm/4tNmHZlCS1jXepS3LF3Zk8Ho/GjRuncePG1enZAIDo0bAPaEFyCwka9S1QVqb33p5W5fxjd14fMWQc6vxTx+jYgX0rnDOMkHJ2bQsfR9u8r77UtgC8qCBPT9wzSSsXfSWny60b7n1aQ0eeLElq63VpYJc2hw0ZhmEcrM8YXvugkRrnVNdkD0ufAKAJIGgALURJIKQCf+RlOTDP1k0/qSCv4oxDr86ZGjEout2JrjznjCrnflq7PPz1geZ9jcFpt9aqAHz/3hw9ctfl+nHV9/LExuuW+19Q31+aE/bplKwT+qXLfoSGf1s2/Kg9u7LldLrUZ9DQWo2/TZxT3VJiCBkA0ESwdApoIdhtqmHk7a1a1P2rwQOi/nA7aujAKucK8ysGlxSvp9ou4fWpU5rviIGgsj07t+vxu6/Szu2bFZ+QpFvvf0EdO/eQ1SqN6JuubumJyisJSPtKDvuc7+d/JUnqO3iYXK6az+okxzoIGQDQxDCjAbQQuY3wwbQ1MlR1/wxbDT6c2yLsJFV5T47kRlg+5Y11KrWGu0zt2LpBD/7+Yu3cvlnJqe111yOvqmPnHopx2XXq0Z3VLT1RkhTrtOlIn/+/nz9PkjS4FvUZyTEO9WgTKyshAwCaFGY0gBagLBjS/pJAYw+jVYj3JlQ5t2DZqqjvnx/h2tg4b4Vj9y/LpxpqVsNikTqnJdTonk0/rtIT91yjgry9SuuYpVv/+oKSUtKU7HVr7ODMCnUeNqtFsU6bCkojL+0LhUJasqB8RuOo4SNqNI7EGId6pBIyAKApYkYDaAH2FgfERtUNo0NWZ3liYiucW7LmRy1e9UNU9//r7f9VOZfZtXeVcyleT5Vz9aVdUpziPNEXgP+w4js9etflKsjbq8yuvXXnw1OVlJKmLu19Om1454jF5PGu6n+vteGHNdq/N1eemFj16j8o6nEkeBzqRcgAgCaLoAG0ANRnNByXy62xZ55d5fydjz2jYPDwxfgffr1Qn8xfVOGczW7X8BNOq3JtQy2fqmkB+LJv5+qJe65RSXGhuvcbotsffEnxvkQN7dFWxw/oWG2Nx+GCxoFlUwOGHiO7I7rA43PbCRkA0MQRNIBmLmQY2kv/jAY14cLLqpz7fOESnXvrvcrZu6/Ka4Zh6M0PPtO5t9xT5bXBx42VL6lqczy30654T/3vPpXZNvoC8AWfz9Y//3KTyvylGjDseN08+Vn5vF6NHZyp/p3bHPbeeJet2tcObGt71DHRLZvyuu3q3TZONishAwCaMmo0gGZuf3FAwRDrphpSt979NOiYX4U/IB8w69Mv9cFX32riKaN10nFHyxcfp5XrNmjqu+9r9U+bIj5r9JkXVvs+yT638ovrr07DG+NUakJ0S7Q++98bmvbsA5Kk4SecpktvmaxEb6zGDc5UQtzh+4dIksdhk91qUaDSv9VAIKCl334tSRp8zMgjPifeRcgAgObCYlTe7gRAs7I+p0jZ+aWNPYxWZ9vmjbr6rHHan7un1s844azLdMFlt1S7I1OJP6BF63bW+vmHY7FIAzqnHrE2wzAMzZn+gma99g9J0olnXKDzrrpTHVO9OmFgB7kc0f++alV2QZXZtzXLvtdVvx6jOK9Psxevl81W/cxHnNOmvu3iZSdkAECzwNIpoBkzDIP6jEaSnpmlh/71huK8vlrdP3j0BI397c0qPsyveupz+VRaUmxUIePNfz0aDhmnXzBJ5199l/p3aaNxgzNrFDKkyMunDswKDRx23GFDRqzTpj5pcYQMAGhGCBpAM1bgD8ofDDX2MFqtPgOH6Nm3P1DHrK5R32O12jTmgut09o1/kdVqVVHIosBhwkayz/yicIfdqsxU72GvCQYDeuWJe/XxzFclSROvukO/vvg6jRrQQcN6tpO1Fh/4491Vg8niA/0zjqm+f0aM06a+aXFy1LCZIACgcVGjATRjewqZzWhsnbr20NT3v9LcD/6nma+/pOWLFkS8zpuQqJN+c4G6HneafG06VnitICT5rIq4hCrF69Gm7Dxzx9zWe9gC8LIyv1586E59/80nslituvSm+zT2tLM1elBGjZv6HSrOWXHGoszv14pF30qSBlUTNDwOQgYANFcEDaAZ28OyqSbB4XRqzBlnacwZZ2nDD6v1/fwvtS83R36/X3HxPmV26abhx4+Ry+1RYUmZVmzMUTB4cBojYFhUbBiKiRA0DiyfMqsovLwAvPqwUFJcpH/+5SatWbpAdrtDV9/1iMaecprGDMqI2B+jJoxgQKsWfaMd23eotKRYObuyVVJcpITkFGV171XlerfDqn5pcXISMgCgWSJoAM1UkT+o4rLD921Aw+vco7c696jagO+AWLdDvTOTtWpTjkKHrHorClnkshiyRQgbZu0+ZbFIndv5ZKmm+rwgf7+euvdabfhhuVxuj66/9ymddupJGtE3PeotcCPZsmWLnn/+ef3rX//Srl27qrxuhEL65L//0aiTT5fTVb6DldtuVd+0eDnthAwAaK7YdQpopn7eX6JNucWNPQzUUm5+idZuzZVxSNiwW4yIS6jM2n2qXVKsurRPiPjavtzd+vvdV2nb5vWKjffppsnPauIZY47YH+NwDMPQn//8Z91///0KhY5cS5Tarr3+8sxUHTV4qPqlxcntqL44HADQ9PGrIqCZoj6jeUuKd6tbemKFcwHDopIIv/pxO+1H3CHqSBx2qzLaRi4A371jqx66/WJt27xevqQ2uvvRqbr6gtPqFDJCoZAuv/xyTZ48OaqQIUm7dmzXjeefoV2rFhAyAKAFIGgAzZA/GFJ+aaCxh4E6auPzKKtdxe1xi0IWBSOEjRRvdI31qtOprTdiQfW2TT/qwd9fot3ZP6tNWgf99Zk3dM0FJysjNb5O73fPPfdoypQpFc6NHj5Eb/39L8qd/55Kl36m9R9M1+QbLleHtgcDTWlJsc4/9xytWLGiTu8PAGh8LJ0CmqHs/FKtzylq7GHAJJt35ennXQXhY4fFkK/SL/SL/QEtruXyqfgYp/pnpVSpzfhp7TI9ee+1KirIU3qnbnr4mdd11phBNe6PUdnq1avVp0+f8LE3LlZvPj5ZY48dGvF6f1mZbnnwaT03Y1b43MiRIzV37tw6jQMA0LiY0QCaIXabalkyU71qm3RwJ6gyw6KSSquNPHVYPtUlQgH46iXz9fgfrlRRQZ469+yvl9+YpfNOGlrnkCFJzz77bIXjmU89UG3IkCSnw6F//PEWnT9+TPjcvHnzmNUAgGaOoAE0M8GQof3FLJtqabq0T6jQnK8wZFGo0nxzbZZPtUuKVVyl7uKLv/5ET/3pOpWWFKvPoGP0zn/naNzw3rVqwldZQUGBpk6dGj7+zdhROv7oo454n8Vi0SO3Xyu7/eBUTuXAAgBoXggaQDOzt7hMIVY8tjgWSd3TE+WLKw8Fhsob+R0q2VezoBGpAPyrj2bqub/dpkCgTEf/apzef2+OBnTrUIeRV/T+++8rPz8/fDxp4oSo723XJkUTRo8MH7/xxhtidS8ANF/00QCamVyWTbVYVqtFvTKStHLjHhUUl8lvWFQaMuT65VdCbodNRbs3auOa77Vn23oV7s+REQrK6Y5TYrsspXTsrvTug2V3ls+MZFYqAP9o5qt688VHJEmjTztb77zxqrxxdSsyr+znn38Of+1yOnXisEE1uv+UXw3X2x9+Lknat2+fiouLFRNT+27kAIDGQ9AAmpGQYRA0Wjib1arenZK1YuNuFZcEVWBYZAsGtfCL2fpk1uva8tOaiPf9vHahJMnpiVPXIWN1zCkXqm1Ce0nl/Szefe0fmj39BUnSuRdfpddfekYOu/lbyBYVHdykwBsXU21zwOokxMdVOC4sLCRoAEAzRdAAmpG8koAClRfuo8Vx2Kzqk5mi5Rt2K3vrFr349D1av+K7qO71Fxdo9ZcztWnJZ7Je+wcNHXmy3njub/p89nRJ0g23/UFPPnJ/jQNAtLzeg0u1cvfny19WJqcj+iL27JzcCsc+n6+aKwEATR1BA2hGmM1oPVwOm2z7N+vpWyequCAv4jUWi0U2q0WBYNWGeEUF+/Xiw3dq9vTntWPLBlksFt3/4GP6wx231Ou4u3XrFv46GAzqnY/n6bxTR0d9/9sffhb+umPHjnI6nYe5GgDQlBE0gGaEbW1bj5/WrtbdV1YNGb07tNWVY4/VCX27qWd6quw2m7L35um79Vv0+rxFmrVwhYKHdOI+EDJeeOkVXfG7i+t93GPGjFH79u21fft2SdIzb7wTddBYtX6jPl+4JHz8u9/9rl7GCABoGOw6BTQTBaUBlQaq/uYaLY+/tFT33XyFCvIPhowYl1NPX3GWlj52h244daT6ZrST3VZeY5GW6NXpQ/tqxm2X6ruHb9NRWekVnmcYhrp06tggY7fb7br66qvDx18vWaHn33z3iPeVlJbq6j89HD622Wy68sor62WMAICGQdAAmgmWTbUerz7zmDauWxs+9nrc+vTP1+mak0bIaj38t+3+me017y83atyAnhXOX3755SouLq6X8VZ25ZVXyu0+2BPkur88rgdffF2lfn/E6zdt26GTr7pN85etCp8766yz1KGDedvuAgAansVgk3KgWVi6LU8F/mBjDwP1rKiwQL8+preKCgrC5/7z+8t05tH9avScguJSDbztYW3afbC4+uWXX26w5Uj//ve/ddFFF1U4l5qUqMt+M14nDh+sWI9bW7N3adqcjzX7i28UOmS5V1ZWlubPn6+2bds2yFgBAPWDoAE0AyWBkBZt3d/Yw0ADeHfaK3r0j7eGjycc3U9v//6yWj3rgyVrdNoDL4SPhwwZou++i273KjM8/fTTuummm2rUdC8zM1Mff/xxhaJyAEDzxNIpoBnILYq85AQtz/zPP6pwfMvpx9f6WScN7Kle6QdnBRYtWqSdO3fW+nk1dcMNN2jmzJlRL4E69dRTtWDBAkIGALQQBA2gGdhTSH1Ga7F2xdLw1ynxsTq2R1atn2WxWHRGpSVXixcvrvXzauPMM8/Uxo0bNXPmTI0dO7bK6z6fTzfddJPWrFmjOXPmKC0trUHHBwCoP2xvCzRxZcGQ8koCjT0MNICignzt2ZUdPh6YlV7nxnqVd6Bau3atTj311Do9s6bsdrsmTJigCRMmKC8vT7t27VJxcbF8Pp/at28vu50fRQDQEvHdHWji9hYHRCFV61BaUlLhODE2ps7PTIj1VDguqfQeDc3r9VboHg4AaLlYOgU0cWxr23o4Xa4Kx/uK6r4d7f7Cis9wVXoPAADqC0EDaMJChqG9xQSN1iImLl5JKanh42WbttVox6ZIlmzcVuG4R48edXoeAADRImgATdi+4oCCIRZOtRYWi0U9+g0MH+/aX6Bvf9xc6+cZhqHZi1ZVODd48OBaPw8AgJogaABNGMumWp9jjq+4M9MTs7+o9bM+XbFOK7fuCB8PHDhQ7dq1q/XzAACoCYIG0EQZhkHQaIXGTThHnpjY8PHb85dpzuJVh7kjsqJSv65/8e0K56699to6jw8AgGgRNIAmqsAflD8YauxhoIHFe3269KprKpy79OlpWlqp1uJwSssCuuDvr2p9dk74XMeOHXXhhReaNk4AAI7EYtS10hBAvdiUW6yf9zfuVqRoWG3inMpM9MgoK9VRRx2lH374IfxavMelxy6ZoN+dOOywvTXWbtupy/75hhZWqu346KOPIjbMAwCgvhA0gCZq8c95Ki4LNvYw0AC8bruykjyKdx1sbbRkyRKNHDlSBQUFFa49KitdV409Vsf37aYubZNltVqVm1+o737aqn/PW6S3vlmqsmDFfzd33nmnHnzwwQb5swAAcABBA2iCivxBfb8tr7GHgXrmdljVKdGjlFhnxNe/+uorjR8/Xnl5kf8tOO02OWw2FZb6q32PG2+8UU888USdO4wDAFBT1GgATVAuvTNaNJvVoqwkjwale6sNGZI0YsQILVq0SMcdd1zE1/2BYLUhw+fz6ZVXXiFkAAAaDUEDaIL2FBI0WiKLRWrvdWlIB6/SfW5ZowgA3bp109y5c/XCCy+oT58+R7w+Pj5e1113nVatWqVLLrmEkAEAaDQsnQKaGH8gpIVb9zf2MGCy5BiHOiV55HHYav0MwzA0f/58zZ07V4sXL9a2bdsUDAbl9Xo1YMAADR06VOPHj1d8fLyJIwcAoHYIGkATk51fqvU5RY09DJgk1mlTVpJHCR5HYw8FAIAGZT/yJQAa0h6a9LUITptVmYlupcY5Wb4EAGiVCBpAExIMGdpfHGjsYaAOrBaLOvhcSve5ZbMSMAAArRdBA2hC9haXKcRqxmarbbxTmQkeOe3sswEAAEEDaEJyWTbVLPl+abgX5+JbKgAAB/BTEWgiQoZB0GhmPA6bOiV5lBxDoTcAAJURNIAmIq8koECIZVPNgcNmUccEj9LinVH1wgAAoDUiaABNBLMZTV95wz23Oia4ZafQGwCAwyJoAE0E29o2bSmxTmUmuuvUcA8AgNaEoAE0AQWlAZUGQo09DEQQ77KrU5JHPjffLgEAqAl+cgJNAMummh6X3arMRI/axDpouAcAQC0QNIAmgGVTTYfNalEHn1vtvS4a7gEAUAcEDaCRlQRCKvQHG3sYrZ5FUtt4lzIS3XLaaLgHAEBdETSARpZb5G/sIbR6CR6HspI8inVS6A0AgFkIGkAj21PIsqnGEuO0KSvRo0Qa7gEAYDqCBtCIyoIh5ZUEGnsYrY7DZlVmglupNNwDAKDeEDSARrS3OCB6gTccq8Wi9l6XOtBwDwCAekfQABrRHuozGkybOKcyEz1y2yn0BgCgIRA0gEYSMgztLWLZVH3zuu3KSvIo3sW3OwAAGhI/eYFGsq84oJDBwqn64rZb1SnJo5RYZ2MPBQCAVomgATQSmvTVD5vVoowEt9p5XRR6AwDQiAgaQCMwDEO5BA1TWSSleV3KSHDLQcM9AAAaHUEDaAT5pUGVBUONPYwWIynGoU6JHsXQcA8AgCaDoAE0AmYzzBHrtCkryaMEDw33AABoaggaQCOgPqNunDarMhPdSo1zykIdBgAATRJBA2hgRf6gisuCjT2MZslqsaiDz6V0n1s2Gu4BANCkETSABsZsRu2k/tJwz0XDPQAAmgWCBtDAqM+oGd8vDffiaLgHAECzwk9uoAH5AyHll9INPBoeh02dkjxKjqHQGwCA5oigATSg3GJmM47EbrUoI9GttHga7gEA0JwRNIAGRH1G9SwWqb3XrQ4+Fw33AABoAQgaQAMJhgztL2bZVCTJseUN9zwOGu4BANBSEDSABrK3uEwhw2jsYTQpcS6bspJi5HPzrQgAgJaGn+5AA2G3qYOcdqs6JXrUJtZBwz0AAFooggbQAEKGQX2GJJvVog4+t9p7XTTcAwCghSNoAA0grySgYKj1LpuySEqNdykzwS0nDfcAAGgVCBpAA2jNy6YSPA5lJXkU66TQGwCA1oSgATSA1rhsKsZpU1aiR4k03AMAoFUiaAD1rKA0oNJAqLGH0WAcNosyEjxqG++k4R4AAK0YQQOoZ61l2ZTVYlF7r0sdEtyyU+gNAECrR9AA6llrWDaVEutUp0S33DTcAwAAvyBoAPWopCyoQn+wsYdRb+JddnVO9ijexbcSAABQEZ8OgHqUW9wyZzPcdqs6JXmUEuts7KEAAIAmiqAB1KM9hS0raNisFnVMKG+4R6E3AAA4HIIGUE/KgiHllQQaeximsEhK87qUkeCWw0bDPQAAcGQEDaCe7C0OqCX0Ak+McSgr0aMYGu4BAIAaIGgA9WRPkb+xh1AnMU6bOid5lOCh4R4AAKg5ggZQD0KGob1FzXPZlNNmVWaiW6lxTlmowwAAALVE0ADqwb7igEJG81o4ZbVYlO5zqYPPLRsN9wAAQB0RNIB60Nya9KXGOZWZ6JHLTqE3AAAwB0EDMJlhGMptJkHD57YrK8mjOBruAQAAk/HpAjBZfmlQZcFQYw/jsNwOq7ISPUqm4R4AAKgnBA3AZE152ZTdalFGoltp8TTcAwAA9YugAZisKS6bslikdvEudaThHgAAaCAEDcBERf6gisuCjT2MCpJjHOqU5JHHQcM9AADQcAgagIma0rKpOKdNWcke+dw03AMAAA2PoAGYqCksm3LareqU6FGbWAcN9wAAQKMhaAAm8QdCyi9tvG7gVotFHRJcSvfScA8AADQ+ggZgksaczWgb71JmgltOGu4BAIAmgqABmGRPccMHjQSPXZ0SabgHAACaHj6dACYIhgzta8Cg4XHYlJXkUVIMhd4AAKBpImgAJthbXCbDqP/3cdgsykjwqG28k4Z7AACgSSNoACao721tLRapvdetjglu2Sn0BgAAzQBBA6ijkGHUayF4SqxTnRLdctNwDwAANCMEDaCO8koCCobMXzcV77IrK8kjr5v/TAEAQPPDJxigjsyezXAdaLgX5zT1uQAAAA2JoAHUkVn1GTarRR18bqX7XBR6AwCAZo+gAdRBQWlApYFQnZ5hUXnDvYxEt5w2Gu4BAICWgaAB1EFdZzMSYxzKSvQoxkmhNwAAaFkIGkAd1LY+I8ZZ3nAv0UPDPQAA0DIRNIBaKikLqtAfrNE9DptVmYlutY1zykIdBgAAaMEIGsAR7Ny5Uy+99JLeeecdZWdnKxQKKTU1VaPGnqyRZ16otukdjvgMq8WidJ9LHXxu2Wi4BwAAWgGLYRjmNwAAWoD8/HzddNNNev3111VWFnmJlNVq1ciTTtOtkx9VYnJKxGtS45zKSPTIbafQGwAAtB4EDSCCnJwcjR07VkuXLo3q+vTMLD3x+iylpXcMn/O6yxvuxbuYOAQAAK0PQQOoxO/36/jjj9f8+fPD5+LjYnXRWWfqhGOPltVq1dfffa+pb85U7r794Wsyu3bX8//5SMlJCeqU6FFKLA33AABA60XQACp5/vnnNWnSpPDxxDNO1fMPT5Y3Pq7CdcXFJbr9Lw/r2anTwudu+7979PBf76PhHgAAaPUIGsAhDMPQwIEDtXz5cknSiccN14dvvCSbLXKfC8MwdMG1t2nGf9+TJLVv316bNm2Sw8G2tQAAoHWjOhU4xLfffhsOGZL0p9uurzZkSJLFYtGfb7s+fLx9+3bNmTOnXscIAADQHBA0gEMsXLgw/HWXThkacfTgI97To2tnHTvkqIjPAAAAaK0IGsAh9u8/WNzdOaND1E31umRmhL/Oy8szfVwAAADNDUEDOERMTEz465zcfVHfl7N3b8RnAAAAtFYEDeAQ3bt3D3+9ZOVq/bhh0xHvycndq0+/OrgV7qHPAAAAaK0IGsAhTj75ZKWlpYWPH3t+yhHvefrl1+T3l3cOj42N1TnnnFNv4wMAAGguCBrAIRwOh6666qrw8Quvz9Azr0yr9vo3//u+Hnjq+fDxRRddJJ/PV69jBAAAaA7oowFUsnv3bvXr1087d+4Mnxs5fIiuveRCnXDcMFktFn29aImef2263v9sXvgar9er77//Xl26dGmMYQMAADQpBA0ggsWLF+vEE0+Megcpt9ut//3vfxozZkw9jwwAAKB5YOkUEMHgwYP19ddfq1u3bke8Nj09XZ9++ikhAwAA4BAEDaAaffv21erVqzVr1iyNGzeuyuvHHXecpk2bpp9++knHHntsI4wQAACg6WLpFBClvLw87dq1S4ZhqE2bNkpISGjsIQEAADRZBA0AAAAApmPpFAAAAADTETQAAAAAmI6gAQAAAMB0BA0AAAAApiNoAAAAADAdQQMAAACA6QgaAAAAAExH0AAAAABgOoIGAAAAANMRNAAAAACYjqABAAAAwHQEDQAAAACmI2gAAAAAMB1BAwAAAIDpCBoAAAAATEfQAAAAAGA6ggYAAAAA0xE0AAAAAJiOoAEAAADAdAQNAAAAAKYjaAAAAAAwHUEDAAAAgOkIGgAAAABMR9AAAAAAYDqCBgAAAADTETQAAAAAmI6gAQAAAMB0BA0AAAAApiNoAAAAADAdQQMAAACA6QgaAAAAAExH0AAAAABgOoIGAAAAANMRNAAAAACYjqABAAAAwHQEDQAAAACmI2gAAAAAMB1BAwAAAIDpCBoAAAAATEfQAAAAAGA6ggYAAAAA0xE0AAAAAJiOoAEAAADAdAQNAAAAAKYjaAAAAAAwHUEDAAAAgOkIGgAAAABMR9AAAAAAYDqCBgAAAADTETQAAAAAmI6gAQAAAMB0BA0AAAAApiNoAAAAADAdQQMAAACA6QgaAAAAAExH0AAAAABgOoIGAAAAANMRNAAAAACYjqABAAAAwHQEDQAAAACmI2gAAAAAMB1BAwAAAIDpCBoAAAAATEfQAAAAAGA6ggYAAAAA0xE0AAAAAJiOoAEAAADAdAQNAAAAAKYjaAAAAAAwHUEDAAAAgOkIGgAAAABMR9AAAAAAYDqCBgAAAADTETQAAAAAmI6gAQAAAMB0BA0AAAAApiNoAAAAADAdQQMAAACA6QgaAAAAAExH0AAAAABgOoIGAAAAANMRNAAAAACYjqABAAAAwHQEDQAAAACmI2gAAAAAMB1BAwAAAIDpCBoAAAAATEfQAAAAAGA6ggYAAAAA0xE0AAAAAJiOoAEAAADAdAQNAAAAAKYjaAAAAAAwHUEDAAAAgOkIGgAAAABMR9AAAAAAYDqCBgAAAADTETQAAAAAmI6gAQAAAMB0BA0AAAAApiNoAAAAADAdQQMAAACA6QgaAAAAAExH0AAAAABgOoIGAAAAANMRNAAAAACYjqABAAAAwHQEDQAAAACmI2gAAAAAMB1BAwAAAIDpCBoAAAAATEfQAAAAAGA6ggYAAAAA0xE0AAAAAJiOoAEAAADAdAQNAAAAAKYjaAAAAAAwHUEDAAAAgOkIGgAAAABMR9AAAAAAYDqCBgAAAADTETQAAAAAmI6gAQAAAMB0BA0AAAAApiNoAAAAADAdQQMAAACA6QgaAAAAAExH0AAAAABgOoIGAAAAANMRNAAAAACYjqABAAAAwHQEDQAAAACmI2gAAAAAMB1BAwAAAIDpCBoAAAAATEfQAAAAAGA6ggYAAAAA0xE0AAAAAJiOoAEAAADAdAQNAAAAAKYjaAAAAAAwHUEDAAAAgOkIGgAAAABMR9AAAAAAYDqCBgAAAADTETQAAAAAmI6gAQAAAMB0BA0AAAAApiNoAAAAADAdQQMAAACA6QgaAAAAAExH0AAAAABgOoIGAAAAANMRNAAAAACYjqABAAAAwHQEDQAAAACmI2gAAAAAMN3/AwU+LHUF671BAAAAAElFTkSuQmCC", + "image/png": "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\n", "text/plain": [ "
" ] @@ -926,7 +931,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 28, @@ -935,7 +940,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1207,7 +1212,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 38, @@ -1216,7 +1221,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1283,7 +1288,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1357,7 +1362,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1384,9 +1389,9 @@ ], "metadata": { "kernelspec": { - "display_name": "hyper", + "display_name": "venv_xgi", "language": "python", - "name": "python3" + "name": "venv_xgi" }, "language_info": { "codemirror_mode": { @@ -1398,7 +1403,20 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.0" + "version": "3.9.13" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false }, "vscode": { "interpreter": { diff --git a/xgi/core/hypergraph.py b/xgi/core/hypergraph.py index a4aa50a7e..4226953fc 100644 --- a/xgi/core/hypergraph.py +++ b/xgi/core/hypergraph.py @@ -273,12 +273,13 @@ def __lshift__(self, H2): [{1, 2}, {2, 3}, {1, 3, 4}] """ tempH = Hypergraph() - tempH.add_edges_from(zip(self._edge.values(), self._edge_attr.values())) + tempH.add_nodes_from(zip(self._node.keys(), self._node_attr.values())) - - tempH.add_edges_from(zip(H2._edge.values(), H2._edge_attr.values())) tempH.add_nodes_from(zip(H2._node.keys(), H2._node_attr.values())) + tempH.add_edges_from(zip(self._edge.values(), self._edge_attr.values())) + tempH.add_edges_from(zip(H2._edge.values(), H2._edge_attr.values())) + tempH._hypergraph = deepcopy(self._hypergraph) tempH._hypergraph.update(deepcopy(H2._hypergraph)) From 7047d495ebf6d1643243be4aeb956d7d433f4076 Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Tue, 29 Aug 2023 15:59:46 +0200 Subject: [PATCH 11/26] added notebook on drawing edges --- .../In Depth 2 - Drawing hyperedges.ipynb | 541 ++++++++++++++++++ 1 file changed, 541 insertions(+) create mode 100644 tutorials/In Depth 2 - Drawing hyperedges.ipynb diff --git a/tutorials/In Depth 2 - Drawing hyperedges.ipynb b/tutorials/In Depth 2 - Drawing hyperedges.ipynb new file mode 100644 index 000000000..8df2aab6a --- /dev/null +++ b/tutorials/In Depth 2 - Drawing hyperedges.ipynb @@ -0,0 +1,541 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e1c5005b", + "metadata": {}, + "source": [ + "# In Depth 2 - Drawing hyperedges" + ] + }, + { + "cell_type": "markdown", + "id": "ea8aad6a", + "metadata": {}, + "source": [ + "Here we show the fuctionalities and parameters of `xgi.draw_hyperedges()`. It is similar to the [networkx](https://networkx.org/documentation/stable/reference/drawing.html) corresponding function (+ some bonus) and heavily relies on [matplotlib](https://matplotlib.org/)'s Collection plotting." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b762703f", + "metadata": {}, + "outputs": [], + "source": [ + "import xgi\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "id": "f252027f", + "metadata": {}, + "source": [ + "Les us first create a small toy hypergraph containing edges of different sizes." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "0a032899", + "metadata": {}, + "outputs": [], + "source": [ + "edges = [[1, 2, 3], [3, 4, 5], [3, 6], [6, 7, 8, 9], [1, 4, 10, 11, 12], [1, 4], [2, 5]]\n", + "H = xgi.Hypergraph(edges)\n", + "\n", + "pos = xgi.barycenter_spring_layout(H, seed=42) # fix position" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "444f90d3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(,\n", + " (,\n", + " ,\n", + " ))" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA21klEQVR4nO3de3Cc5Z0n+m+rJdvdUgvIBRwIvoDdIL0iUQd155UFEakjRObYGQTWVM1WTQbNJkYGSbPsH+eETarO2Z1zOEPtqa3kYGOiErMrMZWdzIrYYlFmEtqzWWHL3dJr3I3TF9M2vrSDIYCN7b5Kre73/GGk+CZb6n6739v3U6WCwt2Pfk3J6m8/l99jkWVZBhEREZlWldoFEBERkboYBoiIiEyOYYCIiMjkGAaIiIhMjmGAiIjI5BgGiIiITI5hgIiIyOQYBoiIiEyOYYCIiMjkGAaIiIhMjmGAiIjI5BgGiIiITI5hgIiIyOQYBoiIiEyOYYCIiMjkGAaIiIhMjmGAiIjI5BgGiIiITI5hgIiIyOQYBoiIiEyOYYCIiMjkGAaIiIhMjmGAiIjI5BgGiIiITI5hgIiIyOQYBoiIiEyOYYCIiMjkGAaIiIhMjmGAiIjI5KrVLoCItEGWZQQCAUiShHA4jEwmA5vNBkEQ4Ha74XK5YLFY1C6TiMrAIsuyrHYRRKSeXC6HoaEh7Ny5E9FoFFarFU6nEw6HA4lEArFYDPl8Hg0NDejv78e2bdtQU1OjdtlEpCAuExCZWCgUgiiKGBgYgCAI8Hq9SCQSiEQimJqaQiQSQSKRgNfrhSAIGBgYgCiKCIVCapdORArizACRSU1MTGDz5s1Yu3YtRkZG0NLSctPnSJKEnp4exONxjI+Po729vQKVElG5MQwQmdD8jEBrayvGxsZQW1u75OemUil0dXXB7/fD5/OhqampjJUSUSUwDBCZTC6XgyiKyGazmJ6eXlYQmJdKpeDxeGCz2eDz+biHgEjnuGeAyGSGhoYQDAYxMjJSVBAAgNraWgwPDyMQCGBoaEjhComo0jgzQGQisixDEAQIgoDR0dGSx+vu7kY0GkUoFOKxQyIdY58BIhMJBAKIRqN46aWXFBmvt7cXnZ2dCAaDcLlcJY/HXgdE6mAYIDIRSZJgtVrR1tamyHhtbW2wWq2QJKmkMHCzXge7du1irwOiMuKeASITCYfDcDqdsNlsioxnt9vhdDoRDoeLHoO9DojUxzBAZCKZTAYOh0PRMevq6pBOp4t67sTExMLJhqmpKYyOjqKjo+OasGKz2dDR0YHR0VH4/X5ks1m0trZiYmJCiZdAZHoMA0QmYrPZkEgkFB3z4sWLKGYfcigUwubNm9Ha2orp6eklNT0CALfbjenpaYiiiC1btnCGgEgBPE1AZCKDg4Po6+tDIpFQZKkgnU7D4XCgUChg7dq1EEVx4cvlcmHlypXXfR57HRBpCzcQEpmI2+1GPp/H5OQkOjo6Sh5vcnIShUIBAHDq1CmcOnUK//iP/wgAWLFiBVwuF0RRxDe/+U2Iooh169bBYrEs9DqYmpoqudeBKIoYGhrCs88+W/LrITIrzgwQmUi5+gwcOHAABw8ehN/vX/j69NNPr3n87bffjm9+85uYnp7GQw89hNdff12xGtjrgKh4DANEJrNr1y4MDAzA7/fD7XYXPY4kSRBFETt27LjmU7ksyzhx4sQV4SAQCGBubm7hMV6vV5HZCa/Xi87OThw6dEiRXgdEZsQwQGQySq/X+/1+VFfffMUxk8kgEAjgJz/5Cfbs2aPovoX6+nrs2rULTz/9dMnjEZkRTxMQmUxNTQ1GRkYQj8fR1dWFVCq1rOfP31oYj8cxPDy8pCAAXDrJsGnTJnzlK1/RXK8DIrNjGCAyoaamJoyPj8Pv98Pj8UCSpCU9T5IkeDwe+P1+jI+PF3V9sdZ6HRARwwCRaX3rW+3YP+nDKpsNoiiiu7sbe/fuRSaTueJx6XQaXq8X3d3dEEVx4Shfe3t7Ud+3HL0Okskk7Ha7omMSmQnDAJFJyQCEpibsn/Thpy/tQCQSwaOPPgqHw4HGxkZ4PB40Njaivr4enZ2diEaj2LFjB3w+X1EzAvMEQUAsFrsmdBQrnU4jFotBEARFxiMyI24gJDIhWQby8tX/TUYwGMRBSUIkEkY6nYbdbkdjo4BvetxwuZoVObp36NAhPPjggzxNQKQhDANEJiPLQEG+NDOwVFWWS1/KfP/y9DpgnwGi4nGZgMhEigkC889TisViQX9/P3bv3r3kjYuLkSQJe/bsQV9fH4MAUQk4M0BkIoXPw0AxrBZAqfdbtXodENH1cWaAyCTkEoIAsPzZhBtRq9cBEV0fwwCRCZQaBObHUFJTUxP++5vq9DogoisxDBAZXLH7BK4ZB8oGAlkGHv5WO/ap0OuAiK7EPQNEBlfKPoGrKXWq4OqAksvl8OqrQ3jl5Z2IRqOwWq1wOp2oq6tDMplELBZDPp9HY2Mj+vr6sG3bNtTU1JReCBEBYBggMrTr9RMohQWAtcT5xBvNVFze6yAaCSOTudTrQBAEuN1uNDcr0+uAiK7EMEBkUEotD1yt1FMFS52pUCJ4ENHS8K8akQGVKwiUSsklCyJSDsMAkQHJKF8QKHZcJU40EFF5MAwQGUy533SLWVhkECDSNoYBIgOpxJvuco8YanXJgoj+iGGAyCAq+aa7nO9RziULIlIGwwCRQVTyTXepMwPcMEikDwwDRAZQ6TX5pSwVcJ8AkX4wDBDpnFpvujf6lgwCRPrCMECkY2puzltsZoAbBon0h2GASMfU3px3vUDAIECkPwwDRDql9lT89b41gwCRPjEMEOmQ2kFgoY7L/10jNRHR8jEMEOmMltbk55cJGASI9K1a7QKIaHnU3idwORlAoaCtmoho+TgzQKQjWvwErpVZCiIqHsMAkU5oMQjIMlBQuwgiKhnDAJEOaGmfwILL6inmJkMi0g6GASId0NyaPGcEiAyFYYBI4zS3PKC1GQoiKhnDAJGGaTUIXF2SlkokouVjGCDSKC3uE7jRcgX3DRDpF8MAkUZpcZ+ApuohIsUwDBBpkBaXB262YVBL5RLR8jAMEGmMFoPAUsvhUgGRPjEMEGmI5vYJLLJhkIiMhWGASEO09sa73Hq0VDsRLR3DAJFGaG15QC5yhoJLBUT6wzBApAFaCwI8OUBkLgwDRCrT6j4BIjIPhgEilWlqn4ACGwY181qIaMkYBohUpLXlAaWCCfcNEOkLwwCRSjQXBDS2PGCxqF0BkXkwDBCpwOj7BDTzuohoSRgGiFSgxX0Cig+rmRdIRDfDMEBUYZpaHmCHQSICwwBRRWkqCKC8QUBDL5OIboJhgKhCtLZPoBIbBrlUQKQPDANEFaKp6XgNhRIiUh/DAFEFaGp5gEGAiK5SrXYBRHokyzICgQAkSUI4HEYmk4HNZoMgCHC73XC5XLB8flBei0GgUuXIANgugEj7LLLMVT2ipcrlchgaGsLOnTsRjUZhtVrhdDrhcDiQSCQQi8WQz+fR0NCA/v5+/OAH22CtrtHMJ3E1GgtZUFwDoSrLpS8iKj8uExAtUSgUgiiKGBgYgCAI8Hq9SCQSiEQimJqaQiQSQSKRgNfrhSAIGBgYQGuriN+FQmqXDkB7HQaJSDs4M0C0BBMTE9i8eTPWrl2LkZERtLS03PQ5kiShp6cH8Xgcb/z3cXyrvb0ClS5CBgrqffeiPuFzZoCochgGiG5ifkagtbUVY2NjqK2tXfJzU6kUurq64Pf7sW/Sh6ampjJWuggNNBYqZqmAYYCochgGiG4gl8tBFEVks1lMT08vKwjMS6VS8Hg8WGWzYf+kDzU1NWWodBEaCAIAwwCR1nHPANENDA0NIRgMYmRkpKggAAC1tbUYHh5GMBDAq68OKVzhjWkhCBCR9nFmgGgRsixDEAQIgoDR0dGSx+vu7kY0GkXwcGjh2GE5aW3D4HI/5XNmgKhyODNAtIhAIIBoNIre3l5Fxuvt7UUkEkEwGFRkvBvSWBAA2JqYSMsYBogWIUkSrFYr2traFBmvra0NVqsVByVJkfEWpcEgQETaxjBAtIhwOAyn0wmbzabIeHa7HU6nE5FIWJHxrksjGwavR4s1EdElDANEi8hkMnA4HIqOWVdXh3Q6reiYl9NqEJjHpQIibWIYIFqEzWZDIpFQdMxkMgm73a7omPO0tmGQiPSDFxURLUIQBOzatWvhEqJSpdNpxGIxDPz1c0t6/PxlSAclCZHIHy9DamwU0HLVZUh62SfAi4uItIlhgGgRbrcb+Xwek5OT6OjoKHm8yclJ5PN5tLjdN3xcLpfDq68O4ZWXr38Z0s9e2bVwGdIzff34wfe3obqSjYxKJMvFXVxEROXDZQKiRbhcLjQ0NGBwcFCR8V555RWsXLkSByb3Y3Z29rqPCYVCaNsk4rm/XtplSM/99QDa2kSENHIZEhHpE8MA0SIsFgv6+/uxe/duSCUeB5QkCWNjY5iZmcFz/+avITTch78fGUE+n194zNsTE3hok4iZbBZTU1MYHR1FR0fHNUsUNpsNHR0dGB0dhd/vx0w2i2891Iq3JyZKqpGIzIsdCIkWIcsyApFT2Pr4d2BbUQVJkoq+m8DtdiMzW8CmR/5X/Gr3a7jw2VkAQENDA/7mb/5v3LtxIx5uay35MqS39/sgqHEZ0jItpbMgOxASVQ7DANF1JFJZvH3wKD769AI+iB/Hiz9+Bps2teKNN95Y9hv1448/jgMHfHj+hVdw15p7MDOTxW9/vRv/vOfnSCUvAgAcDge++tWvlhQ45i9Dent/hS9DKsJSLi5iGCCqHIYBoqvETv4B/nePIzf3xyn898IB7HzxeaxbtxYjIyNw32QTIHBpaeCpp57CyZOn0P/8i7hPcF3x5+lUEm+9+Qv8euy/Ip+fw/T0NFpaWoquW5IkiKKIn/x/O7D9mWeLHqcSGAaItIVhgOhzmews9h86hviH56775x/Ej+O/vPy3iJ+IoaurC8888wza2tquWNNPp9OYnJzEz372M4yNjWHNeif+qu/f4a4191x3TFmW8X889xfYJLrx+uuvl/wauru7EYlGEXi3MpchleJmb/QMA0SVwzBABODUmbPY/84xZGdzN3zc3Nwc9u19E7/9zW6cOX0SVqsVGzZsRF1dHZLJJI4dO4p8Po+71qzHI51P4OGO76K6evETvKeOv4f/63//AbxeryLHF71eLzo7OzElHUKzy3XzJ6joZrMDDANElcMwQKY2m5uD/93jOHrq42U9T5ZlnD5xFCfeP4Izp09gdiaLFStX4c6712P9vffj7vUbl/TJfOKtN/Bf/+4nSCQSijU2qq+vx0s7d+EH254uebxyYhgg0g42HSLTOvPxebz9zlGk0jPLfq7FYsGae5xYc4+zpBo+OH0CGzZs1NdlSAphN0Ii7WAYINPJ5wuQQicRPnZG7VKQm50py2VImTJehqQkdiMk0gaGATKVTz9LYuJgDOcvauPNsmbFSnxchsuQbGW6DImIjIkdCMkUCoUCAtHTePO3hzUTBADgrrvX49ixo8hkMoqMN38ZUmOjoMh4RGQODANkeBcSGYxP/A6HIqdQkAtql3OFdRvuX7gMSQkLlyG13LwPghZw9zKRNjAMkKFF3v8QY/8SxCfnlJ2KV8qa9U7cefc6/OxnP1NkvMHBQTQ2NuIbrmZUWfSxQY/nmYjUxzBAhpTKzODX+8LwBd/H3GWXAWmNxWLBtx97Env27FHkMqQ9e/agr68P1VYLrBbAWgXdhAIiUg/7DJDhvB//BAeC72M2N6d2KUsyNzeHF3+8veTLkDweD2w2G/x+/xWNjmT50nS8LAOFz/+2a+0v/fX6CbDPAFHlcGaADGNmNoffTr2H/ym9p5sgAADV1dX4q74f4eTJU3j88ceRSqWW9fz5Wwvj8TiGh4ev6XhosfzxjbX6spkCLb3P8iMJkboYBsgQTn/0GXZ7Azj++0/ULqUod625B/3Pv4gDB3xwu91LXjKQJAkejwd+vx/j4+NousH1xRbLpS9r1aVQYK3SXiggInUwDJCu5XJ5TAbex1uTYaSzs2qXU5L7BBeef+EVZGZliKKIrVu3Yu/evdccO0yn0/B6veju7oYoirDZbPD5fGhvb1/y97JcNlNgrbr0i4ChgMi8uGeAdOsPZy9iQoohkcqqXYqirncZ0saNG+FwOJBMJhGLxZDP59HY2Ii+vj5s27YNNTU1JX3P+d8Chc/3FajxS+Hq/QHcM0BUOQwDpDuFQgGHoqdx+L3fw8g/vpdfhpQ4+yG+dOsq2O12CIIAt9uN5ubmslxTPL/hMP95S4ZK/R+++uIihgGiymEYIF05dyGFCSmGcxeWt8lO7756x2147KHKdhWcDwWFwuenEcr8/RgGiNTDuwlIF2RZRujoGRwMaa+LYCWoEdkt86cOPt9ZlC9zKOAthkTqYRggzUuksnj74FF89OkFtUsxpflP69XWP/YqKNe+At5iSKQOhgHStNjJP8D/7nHk5rTbRbAStDIbYrEAVgtQddkSglKVybKMYCCAgwclRCJhZDMZ2O22hT0SLperLHskiIhhgDQqk53F/kPHEP/wnNql0HVcvoRgRWlLCLlcDn/36hBe2bUTR6JRWK1WOJ1OOBwOJBIJ7Nq1C/l8Hg0NDejv71fk9AQRXYl9BkhzTp05i93eAIPAZQoFbe7znW9kVG39vGfBMu9BCIdCeLhNxL/9NwNoEgR4vV4kEglEIhFMTU0hEokgkUjA6/VCEAQMDAxAFEWEQqGyvSYiM+JpAtKM2dwc/O8ex9FTH6tdiubc8cV6bHnka2qXsSTz+wpk+cZLCG9PTKDrTzdj7dq1GBkZQUtLy03HliQJPT09iMfjGB8fX1ajJSJaHMMAacKZj8/j7XeOIpWeUbsUTbr9C/X47rf1EQbmyfJlGw6v+rP5GYHW1laMjY0t63Km+bsY/H4/fD7fDVswE9HSMAyQqubm8jgYPoXwsTNql6JpX/6CA3/67a+rXUbR5kNBXr60R+DhNhEz2Symp6dLvqXR5/NxDwFRibhngFTz6WdJjP2PdxkElkDvkX3+gqSaKuC//N0Q3g0GMTIyUlQQAIDa2loMDw8jEAhgaGhI4WqJzIczA7RksiwjEAhAkiSEw2FkMhnYbMs/+lUoFPDuex8gGD2tmSNzWvfFW+vQ9b80q11GyWRZhiAIEAQBo6OjJY/X3d2NaDSKUCjEY4dEJeDRQrqpXC6HoaEh7Ny5E9ESj35dSGQwcTCGT84lKvwq9M0omT0QCCAajeKll15SZLze3l50dnYiGAzC5XIpMiaRGXGZgG4oFApBFEUMDAxAKOHolyzLiLz/Icb+JcggUASDZAFIkgSr1Yq2tjZFxmtra4PVaoUkSYqMR2RWDAO0qImJCYiiiGw2i6mpKYyOjqKjowM2m+2Kx9lsNnR0dGB0dBR+vx/ZbBatra2YmJgAAKQyM/jN/gh8wfcxlzd3J8FiyapcKqy8cDgMp9N5zc9Qsex2O5xOJ8LhsCLjEZkVlwnoukKhEDZv3rzso19utxvT09Po6urCli1b8N92/wqfZlZgNjdX5oqNzSgzA5lMBg6HQ9Ex6+rqkE6nFR2TyGw4M0DXyOVyeOqpp7B27dplnwEHLu30Hhsbw913r8Gzz/QincmWqVLzMMqeAZvNhkRC2WWiZDIJu92u6JhEZsMwQNcYGhpCUIGjXyMjw4ifiGHf3jcVrtB8jBIGBEFALBZDJpNRZLx0Oo1YLAZBEBQZj8isGAboCrIsY+fOnXjyySeX1B72RtxuN7q6uvA/39pjmDcztRjlf5/b7UY+n8fk5KQi401OTiKfz8PtdisyHpFZMQzQFeaPfvX29ioy3vbt2/FB/AROnziqyHhmZZQNhC6XCw0NDRgcHFRkvMHBQTQ2NqK5uVmR8YjMimGArlCuo18n3j+iyHhmZZSZAYvFgv7+fuzevbvk44CSJGHPnj3o6+tjwyGiEjEM0BXKcfRrw4aNOHP6hCLjmZZR0gCAbdu2obm5GT09PUilUkWNkUql0NPTA5fLhaefflrhConMh2GArlCuo1+zMzxRUAoDZQHU1NRgZGQE8XgcXV1dyw4E87cWxuNxDA8Po7qaJ6SJSsUwQFco19GvFStXKTqm2RhtA2ZTUxPGx8fh9/vh8XiWvGQgSRI8Hg/8fj/Gx8d5fTGRQhgG6ArlOPp17NhR3Hn3ekXGMyujhQEAaG9vh8/ng81mgyiK6O7uxt69e6/52Uun0/B6veju7oYoigvXFre3t6tUOZHxMAzQFcp19Gv9vfcrMp5ZGS8KXNLU1ASfz4cdO3YgEong0UcfhcPhQGNjIzweDxobG+FwONDZ2YlwOIwdO3bA5/NxRoBIYbzCmK6g9BWzW7duxdTBAP79fxrhju8S1FRb8ZePt6pdRlnJsoxgMLhwRXY6nYbdbsfPf/5znD17Fv/8z/+M73znO2qXSWRI3HlDV5g/+jUwMABJkkpq5iJJEsbGxvCv/vVzDAIlMkNkt1gscLlc11xFfP78ebz22mvYv38/wwBRmXCZgK6h1NGvp556CmvWO/GtR7+rcIVkJg8//DAAYN++fSpXQmRcDAN0DSWOfj3++OM4efIU/qrv38Fq5QRUqQoFE0wNLGI+DExNTWFmZkblaoiMiWGArquUo19utxsHDvjQ//yLuGvNPWWulIzO6XTi9ttvx8zMDA4ePKh2OUSGxDBAiyr26FdmVsbzL7yC+wTXIiPTchXkgtolqMZiseChhx4CwKUConJhGKAbWsrRr/r6enR2diIajeL//Ju/xfMvvMIZAVIU9w0QlRePFtKSLXb0SxAEuN3uhZvj3vgf7+Ls+aS6xRrQv36yzbSnMt555x20tLTglltuwdmzZ2G1WtUuichQGAZIcR98fB6/3hdSuwzD+asnNqGqypyTeXNzc7jtttuQTCYRDAbx9a9/Xe2SiAzFnL9ZqKzuuv1W3HX7bWqXYThmju3V1dXYtGkTAC4VEJUDwwCVRUvTWrVLMByzT+Jx3wBR+TAMUFl86bY63Hv3l9Uuw1BMngWuCANmD0ZESmMYoLL5RuMaVFn4I6YU2bDXFS2Nx+NBTU0NPvzwQxw/flztcogMhb+pqWzq62y475471C7DMMz+adhmsy3clcGlAiJlMQxQWbnuvxvVPAamCJNnAQDcN0BULjxaSGV3KBJHIBpXuwzdkWUZ8RMxnDx2BB+cPoE1q2+Bo652oa+Dy+UyXd+BX/3qV9iyZQs2btyIWCymdjlEhsEwQGWXy+Xx3359ENnZnNql6MLc3Bz27X0Tv/3Nbpw5fRJWqxUbNmzELbfUI5FIIBaLIZ/Po6GhAf39/di2bRtqamrULrsizp8/jy984QuQZRkffvghVq9erXZJRIbAZQIqu5oaK5ob7la7DF34IH4cL/54O/7hP/8UrZ4H4fV6kUgkcORIFFNTU4hEIkgkEvB6vRAEAQMDAxBFEaGQOZo83XrrrXjggQcAAPv371e5GiLjYBigimi4ZzXq7KvULkPT3gsH8Lc/2g7biipMTU3h9ddfR0dHB2w22xWPs9ls6OjowOjoKPx+P7LZLFpbWzExMaFS5ZXFfQNEymMYoIqoqqpCi8BGRIv5IH4cO/72h2hr2wRJktDS0rKk57ndbkxPT0MURWzZssUUMwQMA0TK454BqhhZljH2L0Gcu5BSuxRNmZubw4s/vjQjIEkSamtrlz1GKpWCx+OBzWaDz+cz9B6CM2fO4K677kJVVRU+++wz1NfXq10Ske5xZoAqxmKxwP3AOrXL0Jx9e99E/MRRvPbaa0UFAQCora3F8PAwAoEAhoaGFK5QW+68807cc889KBQKOHDggNrlEBkCwwBV1FfvuA1f+fItapehGbIs47e/2Y0nnnhiyUsDi3G73XjiiSfw8ssvG75BEZcKiJTFMEAV525ap3YJmhE/EcOZ0yexfft2Rcbr7e1FJBJBMBhUZDytYhggUhbDAFXcl7/gwPq7vqR2GZpw8tgRWK1WtLW1KTJeW1sbrFYrJElSZDytmg8D09PTmJmZUbkaIv2rVrsAMqcHhbU4eeYsCoXCFV32crMzqFmxEnfdvR7rNtyPNeudhu6y98HpE9iwYeM1xweLZbfb4XQ6EQ6HFRlPqzZu3Ijbb78dH3/8MSRJwkMPPaR2SUS6xjBAqrCvqkZY2otf/Hz4ii57DocDHycSmHhrDPl8HnfevQ7ffuxJPNzxXVRXG+/HNTc7A4fDoeiYdXV1SKfTio6pNRaLBQ899BB2796Nffv2MQwQlYjLBFRxoVAIoijip//xb67psidJ0zhyJLrQZa/V8yD+4T//FC/+eDs+iBvr2tpa+0rceks9ksmEouMmk0nY7XZFx9Qi7hsgUg77DFBFTUxMYPPmzVi7di1GRkaWtINekiQ89dRTOHnyFPqffxH3Ca4KVFo628oVqKtdCYd9FepqV6K+dhXqalfBYV+JOvtKVFVVYXBwEH19fUgkEoosFaTTadTX12PXrl14+umnFXgV2vXOO++gpaUF9fX1OHfuHKy8HZOoaAwDVDHzMwKtra0YGxtb1pn6VCqFxx9/HAcO+PD8C6/grjX3lLHSpVlRU406+0o4alct/HPhy74S1dU3f3M6dOgQHnzw0uxIR0dHyTV5vV50dnbi0KFDcLn0EZqKNTc3h9tuuw3JZBKBQADNzc1ql0SkWwwDVBG5XA6iKCKbzWJ6erroLntutxuZWRnPv/BK2fcQWKuq/vhJvnYV6mtXwVG7EnX2S/9cuaL0Ln+yLEMQBAiCgNHR0ZLH6+7uRjQaRSgUMvTGy3mPPfYY3nrrLbz00ksYGBhQuxwi3TLejizSpKGhIQSDQUxNTZXUZW9kZASiKGLf3jfx7e88UVJNFosFtbaVcNSuRH2t7YopfYd9Fey2FSWNv9Qa+vv7MTAwAEmS4Ha7ix5LkiTs2bMHO3bsMEUQAC7tG3jrrbewb98+hgGiEnBmgMpO6U+/W7duxdTBAP79fxq56ZuefdWKa6bx5/+91rYCVVXq76FVatZk/m4Cv99vyJMX1zMxMYFHHnkEq1evxpkzZ0wTgoiUZo7fGKSqQCCAaDSKl156SZHxtm/fjt2dnTh94ig23te4MIV/+ZS+4/NP91ar+m/2N1NTU4ORkRG0traiq6urqP0UXV1diMfj8Pl8pgkCAODxeFBTU4OPPvoI77//PjZs2KB2SUS6ZJ7fGqQaSZLK0mXvjroZ/MWfioqMqbampiaMj49jy5Yt8Hg8GB4eXtKSgSRJ6OnpQTwex/j4OJqamipQrXbYbDa43W4cOHAA+/btYxggKpL2PzaR7oXDYTidTsW77L135Igi42lFe3s7fD4fbDYbRFFEd3c39u7di0wmc8Xj0uk0vF4vuru7IYriwrXF7e3tKlWuLvYbICodwwCVXSaTYZe9JWpqaoLP58OOHTsQiUTw6KOPwuFwoLGxER6PB42Njaivr0dnZyei0Sh27NgBn89nuhmByzEMEJWOywRUdjabDYkEu+wtVU1NDZ599lk888wzCAaDkCQJ4XAY6XQadrsdzz33HNxuN5qbm7lhDpeWjSwWC44dO4aPPvoIq1evVrskIt1hGKCyEwQBu3btQiaTUazLXiwWw3PPPVd6cRpmsVjgcrkM3zyoVLfeeiseeOABHD58GPv27cOf/dmfqV0Ske5wmYDKzu12I5/PY3JyUpHxJicnkc/nSzqTT8bCpQKi0jAMUNm5XC40NDRgcHBQkfEGBwfR2NjI9rO0gGGAqDQMA1R28132du/eDUmSShprvsteX18f18tpwXwYePfdd3HhwgWVqyHSH3YgpIpglz0qt3vvvRfHjx/HP/3TP+FP/uRP1C6HSFc4M0AVMd9lLx6Po6urC6lUalnPv7zL3vDwMIMAXYNLBUTFYxigipnvsuf3++HxeJa8ZCBJEjweD/x+vym77NHSMAwQFY9hgCqKXfaoXObDwPT0NLLZrMrVEOkL9wyQKnK5HIaGhrBz505Eo1FYrVY4nU7U1dUhmUwiFoshn8+jsbERfX192LZtG2pqatQumzRMlmWsXr0aH3/8Md5+++2FcEBEN8cwQKqSZfm6XfYEQWCXPVq27u5u/PKXv8QLL7yAH/3oR2qXQ6Qb3IVFqmKXPVLSww8/jF/+8pfcN0C0TNwzQESGMb80cODAAeTzeZWrIdIPhgEiMoyvf/3rcDgcuHjxIg4fPqx2OUS6wTBARIZhtVqxadMmAMD+/ftVroZIPxgGiMhQ2G+AaPkYBojIUC4PAzwsRbQ0PFpIRIaSyWRQX1+Pubk5fO9738PKlSths9kWjqu6XC4eVyW6CsMAERnC1Y2sqqqqsHHjRtxyyy1IJBILjawaGhrQ39/PRlZEl+EyARHpXigUgiiKGBgYgCAI8Hq9SCaTOHLkCKamphCJRJBIJOD1eiEIAgYGBiCKIkKhkNqlE2kCZwaISNcmJiawefNmrF27FiMjI2hpabnpcyRJQk9PD+LxOMbHx3nnBZkewwAR6db8jEBrayvGxsZQW1u75OfOX4vt9/vh8/l4GyaZGsMAEelSLpeDKIrIZrOYnp5eVhCYl0ql4PF4Fm7F5B4CMivuGSAiXRoaGkIwGMTIyEhRQQAAamtrMTw8jEAggKGhIYUrJNIPzgwQke7IsgxBECAIAkZHR0ser7u7G9FoFKFQiMcOyZQ4M0BEuhMIBBCNRtHb26vIeL29vYhEIggGg4qMR6Q3DANEpDuSJMFqtaKtrU2R8dra2mC1WiFJkiLjEekNwwAR6U44HIbT6YTNZlNkPLvdDqfTiXA4rMh4RHrDMEBEupPJZOBwOBQds66uDul0WtExifSCYYCIdMdmsyGRSCg6ZjKZhN1uV3RMIr1gGCAi3REEAbFYDJlMRpHx0uk0YrEYBEFQZDwivWEYICLdcbvdyOfzmJycVGS8yclJ5PN5uN1uRcYj0hv2GSAi3WGfASJlcWaAiHTHYrGgv78fu3fvLvk4oCRJ2LNnD/r6+hgEyLQ4M0BEuqT03QR+vx/V1dVlqJRI+zgzQES6VFNTg5GREcTjcXR1dSGVSi3r+fO3FsbjcQwPDzMIkKkxDBCRbjU1NWF8fBx+vx8ej2fJSwaSJMHj8cDv92N8fJzXF5PpMQwQka61t7fD5/PBZrNBFEV0d3dj79691xw7TKfT8Hq92NrdDVEUIVtX4O39k2hvb1epciLt4J4BIjKEXC6HoaEh7Ny5E9FoFFarFU6nE7W1dUgmkzh6NIZ8Po/1G+/HE3/xfXz3z/8Sd95WC+eXi7v+mMhIGAaIyFBkWUYwGIQkSTgYPIwPz13EKpsN6zfej/u/9g1sbHzgilMDjXfU4Qv2GhUrJlIfwwARGdaHF2fw/tkb3zewwlqFb3y1HtVVPFZI5sU9A0RkWHOFm3/Wmc0XcOIcLygic2MYICLDyuULS3rcHxKz+CyTK3M1RNrFMEBEhrWUmYF5xz5NL+vxREbCMEBEhrWcN/eZuQJOnlPmFkQivWEYICLDWu4n/Y8SMzjP5QIyIYYBIjKsXH750/7HPk0jz+UCMhmGASIyrGL2AGTnCjj1GZcLyFwYBojIsOYKSztNcLUzF2dwITuncDVE2sUwQESGlC/IKKWlGpcLyEwYBojIkHIlvpFncnnEz2cVqoZI2xgGiMiQ5pbYcOhGzlzIIjHD5QIyPoYBIjIkJRoIyQBin6RR4BUuZHAMA0RkSEp1E8zk8oh/xuUCMjaGASIypLkiegws5oMLWSS5XEAGxjBARIZU6gbCy8kAYp9yuYCMi2GAiAxJ6UuH0rN5nObpAjIohgEiMqRiGw7dyO+5XEAGxTBARIak5J6BebJ8qRkRlwvIaBgGiMiQlF4mmJeczeODCzNlGZtILQwDRGRISm4gvFr8fAbp2XzZxieqNIYBIjKkciwTzJNlIPZpissFZBgMA0RkSOVaJpiXnMnjzEUuF5AxMAwQkeHkC3JFPrXHP8tyuYAMgWGAiAyn3LMC8wqyjKOfpiFzuYB0jmGAiAynUmEAABIzc1wuIN1jGCAiwylHw6EbOfVZFpkclwtIvxgGiMhwynmS4HoKsoxjXC4gHWMYICLDKWePgcVcyM7ho8Rsxb8vkRIYBojIcCq5Z+ByJ85lkOVyAekQwwARGU6llwnmFWQZx86mVfneRKVgGCAiw1FjmWDe+cwcPkrwdAHpC8MAERlOpU8TXO3EuQxm5tStgWg5GAaIyHDUWiaYly9cOl1ApBcMA0RkOGptILzcZ5kc/sDlAtIJhgEiMhwthAEAOH4ug1kuF5AOMAwQkeHkVF4mmJcvyHifpwtIBxgGiMhQCnJlbixcqrPpHD5OshkRaRvDABEZitqbB6/nxLk0ZvNcLiDtYhggIkPRyn6By+XyMo6fzahdBtGiGAaIyFDUbDh0I5+mZvFpissFpE0MA0RkKFqcGZj3/tkMclwuIA1iGCAiQ5nT8JttLl/A8XNcLiDtYRggIkPR8swAAHySnMXZdE7tMoiuwDBARIai9TAAAO9/muZyAWkKwwARGYpWGg7dyGy+gBNcLiANYRggIkPRw8wAAHycnMVnXC4gjWAYICJDUfv64uU4ejatm/BCxsYwQESGosUOhIuZnSvgJJcLSAMYBojIUPT2SfujxAzOZ7hcQOpiGCAiQ9FqB8IbOfZpGnkd1k3GwTBARIZRkGVdvqlm5wo4+RmXC0g9DANEZBh6DALzPrw4gwtZLheQOhgGiMgw9NBj4EaOcrmAVMIwQESGobfNg1fL5go4xeUCUgHDABEZht7DAACcuTiDi9k5tcsgk2EYICLDMEIYALhcQJXHMEBEhqGn7oM3ksnlcfp8Vu0yyEQYBojIMPS+gfByH1zIIjHD5QKqDIYBIjIMoywTAICMS8sFBdk4r4m0i2GAiAzDSGEAANKzXC6gymAYICLDMNIywbzfn88iyeUCKjOGASIyDKNsILwclwuoEhgGiMgwjLZMMC81m8fvL3C5gMqHYYCIDGPOgMsE806fzyI1m1e7DDIohgEiMgRZlg07MwAAsgwc/STF5QIqC4YBIjIEIweBecnZPD64MKN2GWRA1WoXQESkBDOEAeDScsEX7TWwr7ACuDQjEggEIEkSwuEwMpkMbDYbBEGA2+2Gy+WCxWJRuWrSOossc86JiPQvMTOHd88k1C6jIhwrq9HwpZV49dVXsXPnTkSjUVitVjidTjgcDiQSCcRiMeTzeTQ0NKC/vx/btm1DTU2N2qWTRnGZgIgMwcibB6/27uHDaPGIGBgYgCAI8Hq9SCQSiEQimJqaQiQSQSKRgNfrhSAIGBgYgCiKCIVCapdOGsWZASIyhI+Ts4h9klK7jLILTE3ih9//c6xbtxavjYygpaXlps+RJAk9PT2Ix+MYHx9He3t7BSolPWEYICJDOHNxBsfPptUuo6yOvxfB9q2PYVNrK954Ywy1tbVLfm4qlUJXVxf8fj98Ph+amprKWCnpDcMAERlC/LMM4gbu4z+Xy2H71k5UFXKQpqeXFQTmpVIpeDwe2Gw2+Hw+7iGgBdwzQESGYPTTBG/+4jUcjfwOr42MFBUEAKC2thbDw8MIBAIYGhpSuELSM84MEJEhxD5J4ePkrNpllIUsy/jLxzbhweYH8ProaMnjdXd3IxqNIhQK8dghAeDMABEZRM7AMwOx8GGcPPYetvf2KjJeb28vIpEIgsGgIuOR/jEMEJEhGPlo4ZHDAVitVrS1tSkyXltbG6xWKyRJUmQ80j+GASIyBCPvGThx9Ag2bnTCZrMpMp7dbofT6UQ4HFZkPNI/hgEiMoS5QkHtEspmJpuBw+FQdMy6ujqk08Y+iklLxzBARLony7KhlwlWrrIhkVC21XIymYTdbld0TNIvhgEi0r28DBg3CgDrN96Po0djyGQyioyXTqcRi8UgCIIi45H+MQwQke7N5Y27RAAA93/NhXw+j8nJSUXGm5ycRD6fh9vtVmQ80j+GASLSPSNvHgQAp/A1rNtwH342OKjIeIODg2hsbERzc7Mi45H+MQwQke4ZuccAAFgsFjz5vR9gz+7dJR8HlCQJe/bsQV9fHxsO0QJ2ICQi3fskOYv3DH5jodJ3E/j9flRXV5ehUtIjzgwQke4ZfZkAAKpravCj//dlxONxdHV1IZVaXviZv7UwHo9jeHiYQYCuwDBARLqXM3CPgcuJDzZj/M034ff74fF4lrxkIEkSPB4P/H4/xsfHeX0xXYNhgIh0z8g9BuZ90V6DDV+y45FHHoHP54PNZoMoiuju7sbevXuvOXaYTqfh9XrR3d0NURQXri1ub29X6RWQlnHPABHpnpFvLASAW201aLyjFlWXbfjL5XIYGhrCzp07EY1GYbVa4XQ6UVdXh2QyiVgshnw+j8bGRvT19WHbtm2oqalR8VWQljEMEJHuRf6QxLl0Tu0yyqJ+VTWEO+pgrbr+zn9ZlhEMBiFJEsLhMNLpNOx2OwRBgNvtRnNzM08N0E0xDBCR7h3+MIGL2Tm1y1Bc3Qormr7iQPUiQYBIKdxOSkS6IssyAoHAwifhTCaDRN6Ku++9D/d/zQWn8DVDfBK2r7BCWF3HIEAVwZkBItKFxdbIHQ4HLl5M4OjRS2vk6zbchye/9wN898//EtU6XSNfVVOFr612YEU193hTZfAnjYg0LxQKQRRFDAwMQBAEeL1eJBIJRCIRTE1NIRqNIJFIwOv14sHmB/DT//BDbN/aiePvRdQufdlWVFeh6Y46BgGqKM4MEJGmTUxMYPPmzVi7di1GRkbQ0tJy0+dIkoSnenpw6lQcL776D3B9s60ClZauxmrBA6sdsK+wql0KmQzDABFp1vyMQGtrK8bGxpbVgjeVSuHxx7vg8/vxyuu/xj33NZax0tJZqyx4YHUd6lZyKxdVHsMAEWlSLpeDKIrIZrOYLqEXv9vjgWxdgVde/41m9xBUWSxoWl2H+lUMAqQO/uQRkSYNDQ0hGAxiamqqqCAAALW1tRgZHoYoinjzF6/hie99X+EqryTLMmLhwzhyOIATR49gJpvBylU2rN94/6InHaosFjTeUcsgQKrizAARaY4syxAEAYIgYHR0tOTxtnZ3I3A4jJFfT5bl2OFcLoc3f/Eadv/9qzh57D1YrVZs3HjppEMisfhJB4sFuP/2OnzRrs0ZCzIPblclIs0JBAKIRqPo7e1VZLztvb04cfQIjkZ+p8h4lzv+XgTbt3bip//hh3iw+YGFkw7RaATT0zc+6eD8Ui2DAGkCwwARaY4kSbBarWhrU+YUQFtbG6xWK44cPqTIePMCU5PYvvUxVBVymJqawuujo+jo6IDNZrvicTabDR0dHXh9dBR+vx9VhRye/bPvIPKOT9F6iIrFMEBEmhMOh+F0Oq95Uy2W3W7Hxo1OnDh6RJHxgEszAj/8/p9jU2srpOnpJR15BAC32w1pehqtoogtW7YgFAopVhNRsRgGiEhzMpkMHA6HomPW1dUhe9U1v8Way+Xw//xvfVi3bi3eeGN5Rx6BSxsbx8bGsGbNGvT09CCXM+YlS6QfDANEpDk2mw2JRELRMVOpJL50iwNftNfAVmNFKfsI3/zFazga+R1eGxkp6aTD8PAwAoEAhoaGii+GSAEMA0SkOYIgIBaLIaPQJ/l0Oo1YLIbWB7+Ohjvq8OBX69G69lZ84656NNxei7W32XB73Qo4VlYvelXwPFmWsfvvX8UTTz655KWBxbjdbjzxxBN4+eWXwYNdpCYebCUizXG73cjn85icnERHR0fJ401OTiKfz8Ptdi/8tyqLBfYVVthXWPHFqx4/O1dAOpdHOldAJpdHJpdHeraA2XwBsfBhnDz2HoZe2VlyXQDQ29uLzs5OBINBuFwuRcYkWi7ODBCR5rhcLjQ0NGBwcFCR8QYHB9HY2Ijm5uYlPX5FdRVutdXgzvqVuPeLdjStdsCz5haIa29F8lSkLCcdJElSZDyiYjAMEJHmWCwW9Pf3Y/fu3SW/SUqShD179qCvr6/khkPVVRa8Hzui+EkHp9OJcDisyHhExWAYICJN2rZtG5qbm9HT04NUKlXUGKlUCj09PXC5XHj66acVqatcJx3S6bSiYxItB8MAEWlSTU0NRkZGEI/H0dXVtexAkEql0NXVhXg8juHhYVRXK7NFqhwnHZLJJOx2u6JjEi0HwwARaVZTUxPGx8fh9/vh8XiWvGQgSRI8Hg/8fj/Gx8fR1NSkWE3lOukgCIIi4xEVg2GAiDStvb0dPp8PNpsNoiiiu7sbe/fuvebNOJ1Ow+v1oru7G6Iowmazwefzob29XdF6Lj/poITrnXQgqjTeWkhEupDL5TA0NISdO3ciGo3CarXC6XSirq4OyWQSsdilmwEbGxvR19eHbdu2oaZG+UuAlL5Rsbu7G9FoFKFQqCw3KhItBcMAEemKLMsIBoOQJAnhcBjpdBp2ux2CIMDtdqO5ubnsb6q7du3CwMAA/H5/SZ/oJUmCKIrYsWMHnn32WQUrJFoehgEiomXK5XIQRRHZbBbT09NFtSROpVLweDyw2Wzw+/2KbXAkKgb3DBARLZNWTzoQFYthgIioCFo86UBULIYBIqIiae2kA1GxuGeAiKhEWjnpQFQshgEiIoVo4aQDUTEYBoiIiEyOewaIiIhMjmGAiIjI5BgGiIiITI5hgIiIyOQYBoiIiEyOYYCIiMjkGAaIiIhMjmGAiIjI5BgGiIiITI5hgIiIyOQYBoiIiEyOYYCIiMjkGAaIiIhMjmGAiIjI5BgGiIiITI5hgIiIyOQYBoiIiEyOYYCIiMjkGAaIiIhMjmGAiIjI5BgGiIiITI5hgIiIyOQYBoiIiEyOYYCIiMjkGAaIiIhMjmGAiIjI5BgGiIiITI5hgIiIyOQYBoiIiEzu/wecoe3JlGxfFgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "xgi.draw(H, pos=pos)" + ] + }, + { + "cell_type": "markdown", + "id": "1c5336d3", + "metadata": {}, + "source": [ + "## Basics" + ] + }, + { + "cell_type": "markdown", + "id": "c8baf790", + "metadata": {}, + "source": [ + "Let's jump right into how `xgi.draw_nodes()` works. By default, it gives:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "95737dd8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(,\n", + " (,\n", + " ))" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "xgi.draw_hyperedges(H, pos=pos)" + ] + }, + { + "cell_type": "markdown", + "id": "12d7fa53", + "metadata": {}, + "source": [ + "Notice that this function returns a tuple `(ax, collections)` where `collections` is a tuple `(dyad_collection, edge_collection)`. The collections can be used to plot colorbars as we will see later." + ] + }, + { + "cell_type": "markdown", + "id": "4e879854", + "metadata": {}, + "source": [ + "The color, linewidth, transparancy, and style of the hyperedges can all be customised, for example with single values:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b4ed641d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(,\n", + " (,\n", + " ))" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "xgi.draw_hyperedges(\n", + " H, pos=pos, dyad_color=\"r\", dyad_lw=2, dyad_style=\"--\", edge_fc=\"g\", alpha=0.3\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "7eb2b443", + "metadata": {}, + "source": [ + "Or with multiple values:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "4505c0aa", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(,\n", + " (,\n", + " ))" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "xgi.draw_hyperedges(\n", + " H,\n", + " pos=pos,\n", + " dyad_color=[\"r\", \"b\", \"orange\"],\n", + " dyad_lw=[1, 2, 5],\n", + " edge_fc=[\"g\", \"grey\", \"purple\", \"coral\"],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "310d67df", + "metadata": {}, + "source": [ + "## Arrays of floats and colormaps" + ] + }, + { + "cell_type": "markdown", + "id": "92d32d0d", + "metadata": {}, + "source": [ + "In XGI, you can easily color hyperedges according to an EdgeStat, or just an array or a dict with float values:" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "f5631114", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax, (dyad_collection, edge_collection) = xgi.draw_hyperedges(\n", + " H,\n", + " pos=pos,\n", + " dyad_color=[3, 1, 4],\n", + " edge_fc=H.edges.size,\n", + ")\n", + "\n", + "plt.colorbar(dyad_collection, label=\"dyads\")\n", + "plt.colorbar(edge_collection, label=\"edges\")" + ] + }, + { + "cell_type": "markdown", + "id": "56966a12", + "metadata": {}, + "source": [ + "By default, the colormaps used are \"Blues\" and \"Greys\". These can be changed:" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "a253c2e4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax, (dyad_collection, edge_collection) = xgi.draw_hyperedges(\n", + " H,\n", + " pos=pos,\n", + " dyad_color=[3, 1, 4],\n", + " edge_fc=H.edges.size,\n", + " dyad_color_cmap=\"viridis\",\n", + " edge_fc_cmap=\"tab10\",\n", + ")\n", + "\n", + "plt.colorbar(dyad_collection, label=\"dyads\")\n", + "plt.colorbar(edge_collection, label=\"edges\")" + ] + }, + { + "cell_type": "markdown", + "id": "5cbde978", + "metadata": {}, + "source": [ + "You can specify a `vmin` and `vmax` for the dyad and edge colors:" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "1548e22b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax, (dyad_collection, edge_collection) = xgi.draw_hyperedges(\n", + " H, pos=pos, dyad_color=[3, 1, 4], edge_fc=H.edges.size, dyad_vmin=1.5, edge_vmax=4.5\n", + ")\n", + "\n", + "plt.colorbar(dyad_collection, label=\"dyads\")\n", + "plt.colorbar(edge_collection, label=\"edges\")" + ] + }, + { + "cell_type": "markdown", + "id": "a1424b04", + "metadata": {}, + "source": [ + "## Combine with nodes" + ] + }, + { + "cell_type": "markdown", + "id": "c2b1f9ec", + "metadata": {}, + "source": [ + "This can be either via `xgi.draw()`:" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "8eeba210", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax, collections = xgi.draw(\n", + " H,\n", + " pos=pos,\n", + " node_fc=H.nodes.degree,\n", + " dyad_color=[3, 1, 4],\n", + " edge_fc=H.edges.size,\n", + ")\n", + "\n", + "(node_collection, dyad_collection, edge_collection) = collections\n", + "plt.colorbar(node_collection, label=\"nodes\")\n", + "plt.colorbar(dyad_collection, label=\"dyads\")\n", + "plt.colorbar(edge_collection, label=\"edges\")\n", + "\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f3ad618c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0b1dd42f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "d677fbc5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{0: {1, 2, 3},\n", + " 1: {3, 4, 5},\n", + " 2: {3, 6},\n", + " 3: {6, 7, 8, 9},\n", + " 4: {1, 4, 10, 11, 12},\n", + " 5: {1, 4},\n", + " 6: {2, 5}}" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "H.edges.members(dtype=dict)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "4615bc2b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1: {0, 4, 5},\n", + " 2: {0, 6},\n", + " 3: {0, 1, 2},\n", + " 4: {1, 4, 5},\n", + " 5: {1, 6},\n", + " 6: {2, 3},\n", + " 7: {3},\n", + " 8: {3},\n", + " 9: {3},\n", + " 10: {4},\n", + " 11: {4},\n", + " 12: {4}}" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "H.nodes.memberships()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv_xgi", + "language": "python", + "name": "venv_xgi" + }, + "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.13" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 5f20b0d37d8593cab0cd7360337626d4015588d7 Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Mon, 9 Oct 2023 17:15:55 +0200 Subject: [PATCH 12/26] fix: impose zorder edges to be below dyads --- xgi/drawing/draw.py | 1 + 1 file changed, 1 insertion(+) diff --git a/xgi/drawing/draw.py b/xgi/drawing/draw.py index cc357ba3c..392cba0cc 100644 --- a/xgi/drawing/draw.py +++ b/xgi/drawing/draw.py @@ -651,6 +651,7 @@ def draw_hyperedges( array=edge_fc_arr, cmap=edge_fc_cmap, alpha=alpha, + zorder=max_order - 2 # below dyads ) # edge_collection.set_cmap(edge_fc_cmap) if edge_c_mapped: From 30d5c8a0aef5602b8e69286ed51293fb943e890a Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Mon, 9 Oct 2023 18:24:59 +0200 Subject: [PATCH 13/26] reordered edges before plotting to ensure large ones are plotted first (and appear below) --- xgi/drawing/draw.py | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/xgi/drawing/draw.py b/xgi/drawing/draw.py index 392cba0cc..bf52c43e0 100644 --- a/xgi/drawing/draw.py +++ b/xgi/drawing/draw.py @@ -62,7 +62,7 @@ def draw( dyad_vmin=None, dyad_vmax=None, edge_fc=None, - edge_fc_cmap="Blues", + edge_fc_cmap="crest_r", edge_vmin=None, edge_vmax=None, alpha=0.4, @@ -144,7 +144,7 @@ def draw( * IDStat containing the `ids` as keys If None (default), color by edge size. edge_fc_cmap: matplotlib colormap - Colormap used to map the edge colors. By default, "Blues". + Colormap used to map the edge colors. By default, "cres_r". edge_vmin, edge_vmax : float, optional Minimum and maximum for edge colormap scaling. By default, None. alpha : float, optional @@ -200,7 +200,7 @@ def draw( "max_dyad_lw": 10, "min_node_lw": 0, "max_node_lw": 5, - "edge_fc_cmap": cm.Blues, # for compatibility with simplices until update + "edge_fc_cmap": "crest_r", # for compatibility with simplices until update "dyad_color_cmap": cm.Greys, # for compatibility with simplices until update } @@ -469,7 +469,7 @@ def draw_hyperedges( dyad_vmin=None, dyad_vmax=None, edge_fc=None, - edge_fc_cmap="Blues", + edge_fc_cmap="crest_r", edge_vmin=None, edge_vmax=None, alpha=0.4, @@ -524,7 +524,7 @@ def draw_hyperedges( * IDStat containing the `ids` as keys If None (default), color by edge size. edge_fc_cmap: matplotlib colormap - Colormap used to map the edge colors. By default, "Blues". + Colormap used to map the edge colors. By default, "crest_r". edge_vmin, edge_vmax : float, optional Minimum and maximum for edge colormap scaling. By default, None. alpha : float, optional @@ -627,16 +627,19 @@ def draw_hyperedges( # dyad_collection.set_zorder(max_order - 1) # edges go behind nodes ax.add_collection(dyad_collection) + # reorder to plot larger hyperedges first + ids_sorted = np.argsort(edges.size.aslist())[::-1] + # plot other hyperedges if edge_c_mapped: - edge_fc_arr = edge_fc + edge_fc_arr = edge_fc[ids_sorted] edge_fc_colors = None else: edge_fc_arr = None - edge_fc_colors = edge_fc + edge_fc_colors = edge_fc[ids_sorted] if len(edge_fc) > 1 else edge_fc patches = [] - for he in edges.members(): + for he in np.array(edges.members())[ids_sorted]: d = len(he) - 1 he = list(he) coordinates = [[pos[n][0], pos[n][1]] for n in he] From 2e738e8d341cde39c8a39c10f9bf2e03540def07 Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Mon, 9 Oct 2023 18:30:43 +0200 Subject: [PATCH 14/26] fix: import seaborn for cmap crest --- xgi/drawing/draw.py | 1 + 1 file changed, 1 insertion(+) diff --git a/xgi/drawing/draw.py b/xgi/drawing/draw.py index bf52c43e0..b999ab41e 100644 --- a/xgi/drawing/draw.py +++ b/xgi/drawing/draw.py @@ -5,6 +5,7 @@ import matplotlib.pyplot as plt import numpy as np +import seaborn as sb # for cmap "crest" from matplotlib import cm from matplotlib.patches import FancyArrow from mpl_toolkits.mplot3d.art3d import ( From deb5d5126ff371fa460fcae64d6aef2eda97bdac Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Mon, 9 Oct 2023 18:42:09 +0200 Subject: [PATCH 15/26] reran notebooks --- tutorials/Tutorial 5 - Plotting.ipynb | 170 ++++++------------ ...7 - Convex hulls hypergraph plotting.ipynb | 37 ++-- tutorials/XGI in 1 minute.ipynb | 35 ++-- tutorials/XGI in 5 minutes.ipynb | 70 ++++---- xgi/drawing/draw_utils.py | 1 + 5 files changed, 143 insertions(+), 170 deletions(-) diff --git a/tutorials/Tutorial 5 - Plotting.ipynb b/tutorials/Tutorial 5 - Plotting.ipynb index 336eb1b2b..d390c7db9 100644 --- a/tutorials/Tutorial 5 - Plotting.ipynb +++ b/tutorials/Tutorial 5 - Plotting.ipynb @@ -90,9 +90,9 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ,\n", - " ))" + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 4, @@ -101,7 +101,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -134,9 +134,9 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ,\n", - " ))" + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 5, @@ -145,7 +145,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -170,9 +170,9 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ,\n", - " ))" + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 6, @@ -181,7 +181,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -212,9 +212,9 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ,\n", - " ))" + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 7, @@ -223,7 +223,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -257,9 +257,9 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ,\n", - " ))" + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 8, @@ -268,7 +268,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -301,9 +301,9 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ,\n", - " ))" + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 9, @@ -312,7 +312,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxoAAAFICAYAAADXmYiHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABptElEQVR4nO3de1xb150u/EcIARIS4PsdfEM2iDiQRESUaUkb7KS15xjbJOk7bWpOU4ck2J2c9512pu20k6aTNO1MOxPboWZoTiHp6XRCY+NT9zKFpCEpkUBJUByBHOErthMbbGzQFaSt/f5hmxgbzEVb6PZ8P5/5o0FaWhllS/vRWuv3k4miKIKIiIiIiEhCCeGeABERERERxR4GDSIiIiIikhyDBhERERERSY5Bg4iIiIiIJMegQUREREREkmPQICIiIiIiyTFoEBERERGR5Bg0iIiIiIhIcgwaREREREQkOQYNIiIiIiKSHIMGERERERFJjkGDiIiIiIgkx6BBRERERESSY9AgIiIiIiLJMWgQEREREZHkGDSIiIiIiEhyDBpERERERCQ5Bg0iIiIiIpIcgwYREREREUmOQYOIiIiIiCTHoEFERERERJJj0CAiIiIiIskxaBARERERkeQYNIiIiIiISHIMGkREREREJLnEcE+AKBREUURHRwfMZjM6Ozvh8XigVCqh0+mg1+tRUFAAmUwW7mkSERFNGb/jKFrIRFEUwz0JIqn4fD7U1tZi7969sNlskMvl0Gq10Gg0cDgcsNvtEAQBOTk52LlzJ3bs2AGFQhHuaRMREU2I33EUbbh1imKG1WqFwWDArl27oNPp0NTUBIfDga6uLrS1taGrqwsOhwNNTU3Q6XTYtWsXDAYDrFZruKdORER0S/yOo2jEFQ2KCS0tLdi4cSOysrJQX1+Pu+66a8LnmM1mVFRUoKenB4cOHUJJSckMzJSIiGhq+B1H0YpBg6LetV95ioqK0NjYiNTU1Ek/1+VyoaysDCaTCUajEXl5eSGcKRER0dTwO46iGYMGRTWfzweDwQCv14v29vYpfQBf43K5UFhYCKVSCaPRyP2sREQUEWLlO46H1+MXz2hQVKutrYXFYkF9ff20PoABIDU1FXV1dejo6EBtba3EMyQiIpqeaP+O8/l8qK6uhk6nw5133omqqio0Nzfj8OHDaG5uRlVVFe68807odDpUV1fD5/PN6Pwo9LiiQVFLFEXodDrodDo0NDQEPV55eTlsNhusVit/WSEiorCK9u84q9WK7du3w2KxYOvWraisrERxcTGUSuXIYzweD1pbW1FTU4P9+/cjPz8f9fX13OIVQ7iiQVGro6MDNpsNlZWVkoxXWVmJrq4uWCwWScYjIiKarmj+jmtpaRnZ8tXW1oaGhgaUlpaOChkAoFQqUVpaioaGBphMJni9XhQVFaGlpSXkc6SZwaBBUctsNkMul6O4uFiS8YqLiyGXy2E2myUZj4iIaLqi9TvOarVi48aNKCoqQnt7+6QqZAGAXq9He3s7DAYDNm3axLK8MYJBg6JWZ2cntFrtTb+QTJdKpYJWq0VnZ6ck4xEREU1XNH7H+Xw+bN++HVlZWVOukAVcOU/S2NiIzMxMVFRU8MxGDGDQoKjl8Xig0WgkHVOtVsPtdks6JhER0VRF43dctB9eJ+kxaFDUUiqVcDgcko7pdDqhUqkkHZOIiGiqQvEdN+hwoNftxRsfHkXbiVP44OxHONZ3AR8PDGLA44FPEKY9tiiK2Lt3L7Zu3Trp7VLj0ev12LJlC1544QWwZlF0Swz3BIimY9Dhwbx5S2G320fqcQfL7XbDbrfja1+rRCAQQEICczgREYXH2pwcVFdXS/odd7S7G/dsewD9bjcwzsKGQi5HapICyqQkqJKSoEpSQKlQIDUpCcokBVLG6cNx7fD67t27g54rcOXw+oYNG2CxWFBQUCDJmDTzGDQoKni9PvT2DuB872Wc7x2AxzOMpJT5EAQBra2tKC0tDfo1WltbIQgC/EI6Dv72Hcyfl4b589OxYEEG0jTS7JElIqLwiuTmcc6hIZwbcODjgUF4MmaH5DtutU53y8f5BAGXPQIue7xj/j0xIQFKheJKAElKGgkgf/7LX0J2eJ1BI3oxaFBE8vsFXLgwiPO9gzjfexkDAzf/9LJihRbLlq3Avn37JPkQ3rdvH5ZlrsDyFVr4/QI++vgSPvr4EgBAqUzCgvnpWDA/A/PmpUGpTAr69YiIaOb4fD7U1tZi7969sNlskMvl0Gq10Gg0cDgcqK6uhiAIyMnJwc6dO7Fjx46Qd9EWRRH9LjfODQ7i4wEHBr2f3NwvX7MWy1auxL6aGsm+4zJXrcKKNWuDGscfCMAxNATH0NCof/660YTV2dlRdXidQo9BgyKCKIrov+REb+8AensHceHiIAKBW+/LlMlk2HDfVvzif/8bzGYz9Hr9tF/fbDajsbER//Or/2vMX7I8nmGcPNWHk6f6AADp6SosmJ+BBfPTMHduGhIT5dN+bSIiCq0bm8ft3r37ls3jdu3ahRdffDEkzeP8goBehxMfDwzi3KADQ37/mI+TyWS4/8Ev4sUfPyfZd9wj3/yHkK3WDA8NRd3hdQo9dgaPYZG8PAwATqd3ZCtUb+8AfL6pH0Lz+/34x+88iuQkGcxm87SqXLhcLtx1113w+YB/fvY/IJdPLX8nJMgwd04a5s+/stVq9ix12DuLR/p7T0Q0U1paWrBx40ZkZWWhvr5+UgeVzWYzKioq0NPTg0OHDqGkpCSoOXiGffh4YBAfDw7igsMJYZK3Xn6fD9+u+AqSIAb1HafX6+GTyfBs3cuQJ4bmN+YXf/wcjlk6cMRmk2zM3NxcrF+/Hs8//7xkY9LMYtCIQRMtD9vt9hlfHgaAoSEfevsGcf78ZfT2DcDlGpr4SZPQ03MM3/1OJT71qSIcPHhwSh/ELpcLf/3Xf40333wT27b9T5Q/+NWg56NQyK+c7bi61UqtTgl6zMmK1PeeiCgcrFYrDAYDioqKptzXweVyoaysDCaTCUajccorG5fdnivhYmAQlz2eqU59RM/Rbny7Yjs+VWSY1nfc5s2b8bbRhGfr6pG5Onva85jIn37TgJ//6IdwOBySHV5PS0tDdXU1Hn30UQlmSOHAoBFjblwerqysvOXy8P79+5Gfnx+S5WFBCODCRceVQ9znL+PSZZek41+vq7MDP3ruG1i+/MovVpNZYjabzfjK9u04dvToSFOgxx7/Fj53719LOrfU1GTMn3flUPn8eWlITg7NjX0kvfdEROHm8/lgMBjg9XrR3t4+7dWAwsJCKJVKGI3GW/4wIwQC6LtuS5RHwmZzne++gx/+7dexPCtzSt9x27dvx8lTPfjW87uhuzO4krO3IgNwqeckHinbjKamJknOlDQ1NWHDhg147733eBg8ijFoxJBwLw+LoojLl10jqxYXLjogCIFpjzdVPT3H8LMXnsGJE3aUlZXh8ccfv+lG2+12o7W1Ffv27UNjYyOWZa3Al776ON5+8zW80fQHAKEJG9eblZF6JXTMT8fcORrI5cGX0Q33e09EFGmqq6uxa9cutLW1BdXXwWw2w2AwYM+ePXjiiSdG/c3r8+HcoAPnBgbR63DCHwjdd17P0W688NT3cPzIEZRt2YLHH3tswu+4lWvXouqpp0OykiEDME+jxtKMDCzKSEOSXA6dTgedToeGhoagxy8vL4fNZoPVauVW3yjGoBEjwrU87HYP4dz5y1cOcfcNYmhIul9wpsPv9+O15oP403/vx+nTJyCXy7F6dTbU6lQ4nU4cPXoUgiBg8dJl+PRn70Nxyb2QJyZCFEX85le/mLGwcY1cnoC5czQjqx0ZGalT/kAN59YAIqJIJIpiyG56B71enBt04OPLg1f6Ucwgv8+H5gP78cdXfo3Tx49f+Y7LzoZarb7yHdfdDUEQkLlqFe574CGUbtmKRAm3x8oAzFWrsXRWOhalp93UU+NauDOZTEEfXh8v3FF0YdCIATO5POzz+T85Z9E7AIdz7Drb4SaKIk6esOPYMRtOnz6BQdclKJIUWLRkGbJWrMbSzOU33dCHK2xcLzlZMdK/Y+GCDKhUybd8/ExvDSAiigbvvfce7rzzTsm38exteBWLVq2WYIbBEUURJz48gqOdnTh9/BiGvV4kpaRg2cpVWK3TYcWatZKuAsxVp2JpRgYWZ9wcLq4n9XeSyWRCYogOr9PM4LsXA2pra2GxWNDW1jatixoAUlNTUVdXB4PBgNra2pFfEAKBAC5edKK3bwDnzl/GpUsuREM2lclkWLFyDVasXAMAuOg6j4A4dgnB659T/jf/EwDwRtMfsO9nPwSAGQ0bQ0M+nD5zEafPXAQAaNQpI00D589Lg0Ix+pIN5XtPRBStzGZzSJrHfWCxRETQkMlkWLk2ByvX5oTsNeakpmJJRjqWzkq/Zbi4nkKhQH19PYqKilBWVjbtVfaenh4YjUaGjBjAFY0oF4rl4c7OLjQebEZv3wAu9A3CP4PnLEJlMkHjmkhY2RiLTCbDrFmpWLggA/PnpWP27FTcdttt3A9LRHSDr3/962hubkZXV5dkY67NycGqgjvwyDf+XrIxI82cVBWWZKRjSUYGlEnTX91uaWnBpk2bkJmZibq6ukkfXv/yl7+MM2fO4Pe//z3PDcYIRsUo19HRAZvNht27d0syXmVlJTZs2ICDB/80shoQbyJhZWMsoiiiv9+J/n4numxncOqkPSTvvcViYYUPIopqHo8nJM3jhr2RuV04GLNVKiyZlY4lGelQJSVJMmZJSQmMRiMqKipgMBiwZcsWPHaLw+s1NTU4cOAAZDIZVq1ahaKiIknmcT32lwqP4MvdUFiFann42DHpGu5Eo2th4571nwcA7PvZD/H6a78N86xGs9u7QvLem81mScYjIgoXpVIJh8Mh6ZhOpxNJKTPXFymUMpRK5C1ehPty1+KeNauRPX+eZCHjmry8PBiNRuzZswddXV1Yv349NBoNcnNzUVhYiNzcXKSlpWHDhg2w2Wx49tlnkZGRAbvdjmeeeUayefh8PlRXV0On0+HOO+9EVVUVmpubcfjwYTQ3N6Oqqgp33nkndDodqqurR8rdkzS4ohHlOjs7odVqJWmOAwAqlQrZ2dno6zuD2bPVkowZCfxJgwgEpv7h8cgTjyMpORF/OvRb7PvZD5GamozPf2FrCGY4dX19Z5CdnS3pe6/VatHZ2SnJeERE4XLtpvHar9bBcrvdONrdjXu2PSDB7MIjQ5mCJbMysCQjHerkWxcakYpCocATTzyBxx9/HBaLZWQ1we12Q6VS4cknn4Rer0d+fv6VcycrV+LBBx/Es88+i7KysqBX12/sL7V79+5b9pfatWsXXnzxRfaXkhCDRpQLxfKwRqPBnNkq3PvZ2yQdN5xO9ifBHxie1nPvLv5n/PN3NHip9lf4yb8+hZy1S/HII49IPMOp+/WvVEhLS5N0TLVaDfcMl2skIpKaXq+HIAhobW2VpOpUa2srBEHAap1OgtnNnPSUFCy9Fi5SZiZcjEUmk6GgoGDC4PDAAw+gvLwcv/nNb1BRUQGz2Yykaa60XN9f6la9VJRKJUpLS1FaWjrSX6qoqIj9pSTCrVNRLlTLwyqVStIxo5lMJsM/PvP3+MqOvwEAfO1rX8OLL74Ytvm43W788Y9/xDvvvIP+/n5Jx+Z7T0SxoKCgADk5OaipqZFkvH379iFz1SqsWLNWkvFCKS0lBbmLFmB9jhb35mixZuH8sIaMqXrhhRcwd+5cHD58eNpbqKxWKzZu3IiioiK0t7dPumGjXq9He3s7DAYDNm3aBKvVOq3Xp08waEQ5nU4Hu90Oj8cjyXhutxt2ux26KPvVJtTCGTYEQUB7ezueffZZfPazn8WsWbPw+c9/HhaLBcePH+d7T0R0A5lMhp07d2L//v1Bnzszm81obGzEfQ88FLGHhTXJyVi7cD5K12pRmqPF2oULoInS8yTz589HdXU1AODZZ59FR0fHlJ7v8/mwfft2ZGVlTbm8LnCl5HtjYyMyMzNRUVHBMxtBYtCIctcvD0vh2vJwMB09Y9VMhQ1RFHHs2DHs27cP27Ztw9y5c3H33XfjO9/5Dt544w0MDw8jMzMTmzdvRiAQ4HtPRDSGHTt2ID8/HxUVFXC5XNMaw+VyYfv27Vi5di3Wb90m8QyDo05KwpoF83Hv2mysz12D3EULkaaMznBxo2tbqPx+PyoqKjA8PPmtz9f6S9XX1wfdX6qjowO1tbXTGoOuYB+NKBeKPhqx2EvhZP+H0z6jcSNRFPHP3/kRXqr9FQDg5z//edBnNi5evIjXXnsNzc3NaGpqwsmTJ0f9PT09HZ/73OdQWlqK9evXY/XqKw2j+N4TEY2v7d138bmSEhQZDDh48OCUm8dt3rwZbxtNeLauHpmrs0M408lRJyVdLUWbgQyVNIVAIlVvby90Oh0uXLiA733ve/j+978/4XN4TxR5GDRiQHV1NXbt2gWTyRTUr9FmsxkGgwF79uyJue7QUgYNIPiw4fV60draiqamJjQ3N+O9994b1XFdoVCgqKgI69evx/r163HnnXeO2SGV7z0R0djODzrQfrIHlvY2/PBvv47lWZmor6+fdPO47du34+SpHnzr+d3Q3Tm5Pf6hkJqUdLVDd+yHixs1NDTgwQcfRGJiItrb2yc8TP7ee+/hzjvvRFNTkyRFAJqamrBhwwa899577C81TQwaMcDn88FgMMDr9aK9vX1aS4UulwuFhYVQKpUwmUxj3tRGM6mDBjC1sBEIBPD++++PrFi89dZb8N7Q+CkvLw/r169HaWkpPvOZz0Ctnri8MN97IqKbHe29gA/OfoRrNzg9R7vxwlPfw/EjR1C2ZQsev0XzuH379qGxsREr165F1VNPh2UlQ5WkGOnQPTs1vgt0PPDAA/jNb36DdevWTViFqqamBlVVVXA4HJKVNU5LS0N1dTUeffTRoMeLRwwaMcJqtaKoqAgGg2HKh59cLhfKyspgMplgNBpjsnZ0KIIGcOuw0dPTg6amJjQ1NeG1117DhQsXRj138eLFI1uh7r33XixatGhacwj2vd+8eTPa2tpi9r0novgREEW8f/osTly8uSKf3+dD84H9+OMrv8bp48chl8uxOjsbarUaTqcTR7u7IQgCMletwn0PPITSLVuRqFDM2NyVimvhIh2zU1XcqnPVVLZQff3rX0dzczO6uroke/3c3FysX78ezz//vGRjxhMGjRjS0tKCTZs2ITMzE3V1dZNeHq6oqEBPT09M14wOVdAAbg4b99xzD86ePYvu7u5Rj1Or1bjnnntGwkVOTo5kXyTTfe+3b9+OkydPofpndajYHr2NqIiIhvx+tJ/oQZ/TecvHiaKIEx8ewdHOTpw+fgzDXi+SUlKwbOUqrNbpsGLN2hm7yU9RJGJJxpU+F3MYLsY12S1UO3bswOHDh9HW1ibZaxcWFuL222/nofBp4h6JGFJSUgKj0YiKigoYDAZs2bIFj91iebimpgYHDhxAQUEBf82ehuFhHyzvvI/WFhPef++DkX/+xhtvAADkcjkKCwtHzlncfffdUITo17HpvvcrVmjxg2dqkKpeis6u09DlLgvJ/IiIQsnh9cJ47CSck6hOJJPJsHJtDlauzZmBmd0sJTERizPSsXRWOuakpjJcTMJkG/mxt1jk4YpGDPL5fKitrcXevXths9kgl8uh1WpHloftdjsEQUBubi6qqqqwY8eOkN0ARwopVjREUUT3kaNobTGhtcUE89vvwO0e3cMiLV2DwYErH3K7d+/Grl27gnrNqZrKe79jRyWWLLsLwCdfcrk5Sxk2iCiqnBt0wHyyBz5BCPdUxpWcmIjF6WlYOisDc9UMF9MxmS1UPKMReRg0YpgoirBYLDCbzejs7ITb7YZKpYJOp4Ner0d+fn7cfNhNN2icP9eLt68Gi7dbTOjrHX3OYvbcWfjUZwwoLilCcYkBCxcvkLz07XRM9r3/0P4RDn9watRzGTaIKFrceOg7kiTJ5SMrF3PVaiTEyfdtKE20hYpVpyIPgwbFhckGDafThfa33xkJF0c/PDbq7ynKFOgNd6D4niJ86jMGrMnNRkLC6L6XoeizESqCEMCfmt+H0zm6AhbDBhFFsoAownL6LE6Oceg7nBRy+cjKxTwNw0Uo3KoKFftoRB4GDYoL4wUNv9+PDzo68ZcWI95uMcHyzmH4/f6Rv8tkMtyWr8OnPnM3iu8pQsFdtyM5JXnC14umsPHRR/1oNX540z9n2CCiSDTk96PtxClccE6v27fUroWLJRnpmJ+mYbgIsYm2ULG/VGRh0KC4cC1oiKKIE8dOovUNE95+0wTTX8xwOkZXKFm2fCmKS4rwqc/cjaJP342MWenTes1oChtvvtWF870DN/1zhg0iiiSDHi9Mxyd36DuUEhMSroSLWRmYr1FDfsPKNoXWrbZQsb9UZGHQoJjX29uLXx98GW/++S94+00TPj57btTf0zPSUPTpu0e2Q2UuXyrZa0dL2BgYcKPptcMY6+OAYYOIIsG5gUG0n+yBPxAIy+snJiRg0dWViwVpGoaLMLvVFir2FoscDBoUc9xuN956662RLtzvv//+qL8rkhS46+6CK6sWJQbk3rYWcrk8ZPOJlrDRYTmBo8fOjfk3hg0iCqfu3j58cPbjGX/dxIQELEjTYOmsDCxI0yCR4SJiTLSFir3FIgODBkU9QRDQ0dEx0oW7tbUVwzcsq+fkrcWnSu5GcUkR7rq7AEpV8GXvpiIawsbwsB9/+O8ODA/7x/w7wwYRzbSAKKKj5wxO9V+asde8Fi6WZKRjYXoaw0UEm6gKldVqRUVFBTo6OibsL7Vv3z40NjaioKAAdXV1XMmQCIMGRaXjx4+jqakJzc3NeP3119HfP7ryyLJly7B+/XqUlpbi3nvvhTvxUsg6g09WNISNo8fOocNyYty/M2wQ0UwZ8vthOn4KF12hP/Qtl8lGVi4WpmmQGMJVbpLWrbZQAZPvL7UscwU2bnwQP/nXp6BSpYTp3yb2MGhQVOjv78frr78+Ei6OHz8+6u9paWn47Gc/O9KFOzs7e1QpOika9kkh0sNGIBBA02sfYHDQPe5jGDaIKNQGPB6Yjp+CK4SHvhOuhYurKxcKhouoNJlGfsCt+0slJc+DKnUBZDIZtNmLcfu6rBn+t4hdDBoUkYaGhtDa2jpyzuLdd98ddVA5MTERRUVFI6sWer3+llUhIiVoAJEfNs73DuDNt7pu+RiGDSIKlVAe+k6QyTBfo8aSjAwszmC4iBUTbaGaSE/PBbSZuwFcKWu//t51SE9XhWKqcYdBgyJCIBDABx98MHLO4q233oLH4xn1GJ1Oh9LSUqxfvx6f+cxnoNFoJj1+JAUNIPLDxtvGD3H2o1s3wmLYICKp2c/3wfqRtIe+E2QyzNOosSQjHYvT05DEUqUxaaItVLfi8/nxfw+9g0Dgyi3xvLlpuKdEF6qpxhUGDQqb06dPj2yFam5uRl9f36i/L1y4cGTForS0FIsXL572a0Va0AAiO2w4nV78d5Nl5EN3PAwbRCQFIRCA5fRZyQ59y4CRlYtFGWlIZriIeZPdQjWet1ptOHfu8sj/LtSvRlbmPIlnGX8YNGjGDAwM4I033hgJFx9+OLobdWpqKkpKSkbOWeTm5o46ZxGMSAwaQGSHjQ+sPTjy4dkJH8ewQRTfRFFER0fHyN53j8cDpVIJnU4HvV6PgoKCW36We30+tJ04hYuu8c+GTYYMwFy1GktnpWNxRjrDRRwKZgvV8RPn8e57n5z/TElW4P778qFQ8L+jYDBoUMj4fD6YTKaRcxbt7e0QBGHk7wkJCSgsLBxZtTAYDFNa6pyKSA0aQOSGDZ9PwB//uwPeId+Ej2XYIIo/41Xz0Wg0cDgcI9V8cnJysHPnTuzYsQMKhWLUGAMeD4zHT8I9PPHnzHjmqa9ui8pIQ8oN41P8me4WKq/Xh9/+7p1R/2z1qoUoyF8RimnGDQYNkowoiujq6hoJFi0tLXA6naMeo9VqR85Z3HPPPcjIyJiRuUVy0AAiN2ycONmLd949NqnHMmwQxQ+r1Yrt27fDYrFg69atqKysvKk/gcfjQWtrK2pqarB//37k5+ejvr5+pD/BR5cH8M6p09M69D0nNRVLZ6VjSUY6wwWNEswWqjdaOtF3YXDkf8tkMtz72TzMmqUOeuUuXjFoUFA+/vjjkTMWzc3N+Oijj0b9fe7cuSPBorS0FJmZmWGZZ6QHDSAyw4Yoinjt9Q9w6fLk6tgzbBDFvpaWFmzcuBFZWVmor6/HXXfdNeFzbuy4vHBtDjo/Ojel152TqsKSjAwsyUiHMonhgsY33S1U3Uc/huX9k6P+WVpaMo7ajXjhhRemvXIXzxg0aEqcTifefPPNkepQnZ2do/6ekpKCT3/60yPnLNatW4eECOiqGg1BA4jMsHHhogN/fsM66cczbBDFLqvVCoPBgKKiIjQ2NiI1NXXSz3W5XCgrK8PbRiOe+UU9MldnT/ic2SrVyJkLVYi21lJsms4WKrd7CL/7w3sj/7un5xiqX3gGJ0/Yp71yF+8YNOiW/H4/3nnnnZHtUEajET7fJ3tpZTIZ7rjjjpEVi+LiYqSkRF5HzWgJGkBkho229m70nL4w6cczbBDFHp/PB4PBAK/Xi/b29imFjGtcLhf0ej18Mhme+cVLSBzjl99ZKiWWzsrA4vR0pCYzXND0THcL1Wuvf4D+S050dXbguR/+HVasWI6XXnppWit3JSUlwf5rRD0GDRpFFEV0d3ePBIs///nPGBgYGPWY5cuXj6xYfO5zn8OcOXPCNNvJi6agAURe2HC7h/Dff7LAL0x+LzXDBlFsqa6uxq5du9DW1japm67xmM1mGAwGPPLNf8D9Dz4EAMhQKrHk6pkLdXKyVFOmOPfKK6/goYcemtIWqiMfnsXvfv9n/OO3H0Vx8adw8ODBaa3cmUwmGI3GuF/ZYNAg9PX14bXXXhsJFz09PaP+PmvWLHzuc58bWbVYtWpVmGY6fdEWNIDICxtdtjPo7Do9pecwbBDFBlEUodPpoNPp0NDQEPR427Ztw3uHD+MPb/4FS2dlQJ3CcEGhMdUtVBf7B1FYeDeSk2Qwm83TXrkrLCyEUqmE0WiM6zMbLA4chzweD/7yl7+MnLOwWCyj/p6UlITi4uKRQ9x33HEH5HJ5eCYbx2QyGf7xmb8HALxU+yt87WtfA4CwhQ1t9iKcONkLt3to0s/psp0BAIYNoijX0dEBm82G3bt3SzLeY489hg0bNsBz7iOoFy2QZEyisbzwwgt44403cPjwYTzzzDMTbqH6r1//EidP2NHW1jatkAFc6QtWV1cHg8GA2tpaPPHEE9MaJxZwRSMOBAIBdHR0jDTK+8tf/oKhodE3i+vWrRtZsfj0pz897YsrUkXjisY1kbSycfrMRZja7FN+Hlc2iKJbTU0Nqqqq4HA4Rh2EnS632420tDRUV1fj0UcflWCGROOb7BYqqVfuysvLYbPZYLVa47b0LVc0YtSJEydGtkK9/vrruHjx4qi/L1myZOScxb333osFC/iLUqSKpJWNZUvn4OgxDS5ccEzpeVzZIIpunZ2d0Gq1koQMAFCpVNBqtTdVLiQKhQcffBANDQ34zW9+g4qKinG3UEm9cldZWYkNGzbAYrFMqUt5LGHQiBGXLl3C66+/PhIujh0b3WRNo9Hgs5/97MiqxZo1a+I2XUejSAob+euWo/n1D6b8PIYNoujl8Xig0WgkHVOtVsPtdks6JtF4JrOFymw2Qy6Xo7i4WJLXLC4uhlwuh9lsZtCgsUVqJ8ihoSG8/fbbI8Hi3XffReC67qqJiYkwGAwj5yz0en1cH0aKBZESNmbNUmPF8vk4cbJ3ys+dKGxE6vVGFO+USiUcjqmtZE7E6XRCpVJJOibReObPn48XXngBDz30EJ599lmUlZXddPPPlTvpMWiMw+fzoba2Fnv37h2zE2R1dfWMdoIURREffPDByDmLN99886ZfgnJycka2Q5WUlEj+6xOFX6SEjTxdJs6cvQifT5jyc8cKG5F2vRHRaDqdDtXV1SPhP1hutxt2ux1PPvlk8JMjmqSJtlBx5U564W/ZHIGudT7dtWsXdDodmpqa4HA40NXVhba2NnR1dcHhcKCpqQk6nQ67du2CwWCA1Tr57smTcebMGdTV1eFLX/oSFi5ciNtvvx1/93d/hz/+8Y9wu91YsGABvvSlL6Gurg5nzpxBV1cXnn/+eWzatIkhI4ZdCxtf2fE3AICvfe1rePHFF2d0DikpCuSsXTrt519fKjdSrjciGp9er4cgCGhtbZVkvNbWVgiCAL1eL8l4RJP1wgsvYO7cuSNbqK7HlTvpserUDVpaWrBx40ZkZWWhvr5+RjtBDg4O4o033hjZDnXkyJFRf1epVCgpKRk5Z5GXl8dtJJMUzVWnxhPualSBQAB/anofDqd32mO4nGews+p/huV6I6LJYzUeiiVjVaESAgJe+Nke/L9/+3esriYhBo3rXPtltaioCI2NjSHvBOnz+dDW1jYSLNra2iAIn2xFSUhIgF6vHzlnUVRUNGGjGRpbLAYNIPxh4+OPL+Evbx+Z+IFj6Ok5xs6rRFHkWmdwk8kU1ErEtc7ge/bsiev+AhRe5Q+U49XfvApdXi4OvvYbiAkCOt/vRFnpF9HU1ITS0tKgX6OpqQkbNmzAe++9F7eHwRk0rvL5fDAYDPB6vWhvbw9JJ0hRFHHkyJGRcxZvvPHGTUt0q1evHjlncc8992DWrFlB/XvRFbEaNIDwh403/2LD+fOXp/Qcv9+Pf/zOo+y8ShRFpP6eNJlMSEzkUVGaGQExAK/PDY/PBY/PhbMfn8bnP70Fly5ews6/q8Tf/n0VRFHEF/5qC/LX3cGVO4nwCr+qtrYWFotF8k6Q586dw2uvvTYSLs6ePTvqOXPmzEFpaenI/y1fvlyCfxuKJ+E+IJ5/+3L8qel9TOU3i9eaD7LzKlGUUSgUqK+vR1FREcrKyqa98t/T0wOj0ciQQSEliiK8/mvBwgmvzw0Rn3xPzZk3G08992387Y5vYN+/v4jSz38OunU5+PIjX8TT33oOZrM56JW7AwcOYM+ePXEbMgCuaACQfu/ptm3b8NZbb2HBggU3HVhNTk7Gpz/96ZFzFvn5+UhI4Jn8UIvlFY1rwrmyYXn/BLqPnpvUY0VRxN/9v19GYeEd+M1vfhP0a/MXI6KZ1dLSgk2bNiEzMxN1dXWTuhnj2SoKNVEUMeT3wONzwT0SLAITPm/XV/8//PG3TVir0+LVP/0nZDLggfsfhugX0d4e/Ip7vK/c8Q4Xn3SCrKyslGS8xx57DH19fSM3PnfccQe++c1voqmpCZcuXUJTUxO++c1v4o477mDIIMmEsxpVbs4yJCdPbuvSiRN2nD59Ao899pgkr11ZWYmuri5YLBZJxiOiWyspKYHRaIRSqYTBYEB5eTmam5vh8XhGPc7tdqOpqQnl5eUwGAwj2xwZMkgKV1YsPLjk7sNHAydxot+GMwPHcNF9Dh6fc1IhAwCe+tG3MWvOLBzptONn//YfUCgU+PHeH+BUTw82l22Gy+Wa0ryuX7mrq6uL65ABMGgACF0nyB07dqC3txfvvvsufvSjH6G0tFSyJjBEYwlX2EhKSoQud3Llbo8dtYWs8yoRzYy8vDwYjUbs2bMHXV1dWL9+PTQaDXJzc1FYWIjc3FykpaVhw4YNsNls2LNnDws3UNCG/V5c9lzAx4OnrgSLy0dx0X0Obp8DAXHqfZ0AYM68OXjquW8DAPb9+4voPGyDNicbNb/cA5PJhDvvvHPS3y9msxmFhYUwmUw4dOgQ/3sHgwaA0HWCVCqVmDt3riRjEk1WuMLGiuXzkZ4+ca3w06ePY/XqbHZeJYpyCoUCTzzxBDo7O/Hee++huroa69evx+23347169ejuroa7733HqxWK5544gkWbKApGxaGMODpx7nBHpy4aEPP5W5ccH0M1/DgtIPFWL5Qdh/u/+v18Pv9+IevfxfDwz7cXXwXvv8v38HRo0dx9913Y9u2bVy5m4b4Xs+5ip0gKdaE44B4QkIC8m9fjpY3u275uOHhIV5vRDFEJpOhoKAgbst3knR8wvDI4W33sAuC6Jux137qR99G29vvjGyh2vWNx/Hyz/8TgiDg7rvvhtncgf3710Mul2P16mxoNGq4XC7Y7XYIgoDc3Fzs2bMHO3bsYKi+DoMG2AmSYlM4wsb8eelYsmQ2zp7tH/cxSUnJvN6IiAh+wQe3zzlScjacRVuubaG6VoUqMVGB99/9AGq1GgcOHMDRY5dhNLbh2DEbTp8+AVH041OfWoYnn3wSer0e+fn5LEgyBgYNADqdDtXV1fB4PJJ1grTb7XjyySeDnxxREMIRNtblZeHcucsQhLEP4i1bthJNfzrA642IKM74A354rgWLYRd8gaFwT2mUL5Tdhz/83z/hj79twt5/3QcA+Pa3v41FixbB403AipVrsGLlGgCARp2C++/jKt5EeEYDgF6vhyAIaG1tlWS81tZWCIIQVP1lIqnM9JkNtToF2asXjfv3VatzeL0REcUBIeCHc2gAfc6P0HOpGyf7bTjvOI1Bb3/EhYxrnvrRt5GiTIHf70dGRgb+1//6XwCAJYtnj1qxEAJx3x1iUhg0ABQUFCAnJwc1NTWSjFdTU4Pc3Fzk5+dLMh5RsGY6bKxdswQpKUlj/m3FCi2WLVuBffv2SfJavN6IiCKDEBDgGhpEn/Nj9Fzqxol+G845ejDgvYhhwRvu6U2K1zsEwe8HAAwODsJmswEAkpMVmDc3beRxgXFW7Wk0Bg1cuQnbuXMn9u/fH3SJzGudIKuqqrhXjyLKTIYNhUKO2/Iyx53Hhvu24sCBA7zeiIiiWEAU4Bp24ILrHE5fPooT/TZ87DiFAe+FqAkWN/qXp/8dPp8fc+fORSAQQEVFBYaHr5wdWbx41sjjhACDxmSwM/hVPp8PBoMBXq8X7e3t7AQZY+KhM/hkzVQHcVEU8fobVvT3O2/6m9/vxz9+51EkJ8lgNrPzKhFRNAiIAXh97pFzFl6/B0Ds3Ea+Y3oP/89fV0Amk6G5uRkPPfQQLly4gO9973v4/ve/D5fLi73Vv8axozacPXsCixelQ6lUQqfTQa/Xo6CggD963YBB4zpWqxVFRUUwGAxobGyc0s3PtU6QJpOJTYkiEIPGaDMVNi72O/D6n61j/q2n5xi++51KfOpTRTh48CCvNyKiCHOl+7Z7pOSs1+eGGEPB4nqBQADbNvwNrO93YceOHfiP//gPvPLKK3jooYcgl8vxjW98AwcPHoTNZhspcZuengaHwzFS4jYnJwc7d+5kidvrcOvUdfLy8nDo0CGYTCYUFhayEyTFrJnaRjVntgZZmfPG/Ftm5ir8/T/8C95+2wi9Xs/rjYgozERRhNfnxiV3H84OnMDxi104O3Ac/e7z8PhcMRsyAODAf/0W1ve7oNFo8IMf/AAA8OCDD2L9+vUAgB//+MfQ6XRoamqCw+HAkSM2tLW1oaurCw6HA01NTdDpdNi1axcMBgOs1rF/ZIs3DBo3KCkpgdFohFKphMFgQHl5OTtBUkyaqbCRl7cMifKxP2pydQX4wTM1GB4WYTAY2HmViGgGXVmx8OCSuw8fDZzE8f4unBk4hovuc/D4nBARH+cQnE4XfvLPzwMAvvvd72LBggUAgJaWFrz99ttYvXo12tra0NDQgNLS0ptKsyuVSpSWlqKhoQEmkwlerxdFRUVoaWmZ8X+XSMOtU+Pw+Xyora3F3r17P1kmy86GWq2G0+nE0e7ukU6QVVVVXCaLcNw6Nb6Z2EZlO3IG1s7T4/7d7/fjteaD+NN/78fp0ydGlqVHrrejvN6IiIIliiKGhaFPeln4XAiIQrinFXY/+efnse/5F7Fq1Sp0dnYiOTkZVqsVBoMBRUVF3E4fBAaNCXh9Puz9zX4c7ezE6ePHMOz1IiklBSuzs/HVss3sBBklGDRuLdRhw+8X8Kfm9+Fy3bpuuiiKOHnCPtJ5dWjIi+TkFCxbtgJlm+/D/fd/ltcbEdEUDPs/CRZunwsB0R/uKUWU06fO4P7iMgwPDaOxsRGbN2+WvECQ0WiM2x/HWKZlAhecLqxcm4OVa3Nu+tuqtVre9FBMCHUH8cREOdbdlgWjyT7hPK7vvHq9efPn83ojIpqATxiC++pqhWfYBUH0hXtKEe1HT/0Uw0PDuPfee/E//sf/AADU1tbCYrGgra1tWiEDAFJTU1FXVweDwYDa2lo88cQTUk47anBFYwLv9ZzByYv9Y/5t3ZLFWD1/7gzPiKaDKxqTE+qVjTdaOtF3YXBaz1WpkrHx83dINhcioljgE4ZHtkF5fE74AwwWk9XW+g6+XPZVJCQkwGKx4LbbboMoitDpdNDpdGhoaAj6NcrLy2Gz2WC1WuPyxzIeBp9Ar8Mxrb8RRaNQHxDPv335tD9o3e4hOByeiR9IRBTD/AEfHN7L6HWcxcn+D3Hq0ofodZ6BY+gSQ8YUCIKAZ/7xxwCARx99FLfddhsAoKOjAzabDZWVlZK8TmVlJbq6umCxWCQZL9pw69QtOL1DcA+Pf9FecLoQEEUkxGFCpdgVym1UGRmpWLF8Po6fOD+t5/f2DUCjUU78QCKiGCEE/FfPV1w5Z+ETbn3WjSbn1V81wmY9gvT0dDz99NMj/9xsNkMul6O4uFiS1ykuLoZcLofZbEZBQYEkY0YTBo1b6HXc3NH4ev5AAP0uN+aqp7d/jyhShTJs5OmW4fSZC/D5pl7p5Pz5AaxauTDoORARRSohIMB79eC2x+fEsOAN95RijsPhxE9/uAcA8E//9E+YN++Tfk+dnZ3QarU3lbCdLpVKBa1Wi87OTknGizYMGrcwma1RvQ4HgwbFpFCFjeRkBXJzluH9wyen/NzevgEEAgEkJHDXJxHFhoAowOP7pPv2kN8LxHBjvEhQ/dP/wMW+fmi1WlRVVY36m8fjgUajkfT11Go13G63pGNGCwaNcQREEX1O14SP63M4gUUzMCGiMAhV2Fi9agGOnzg/5TMXPp+AS5ddmDNb2i8BIqKZEhAD8PrcIyVnvX4PGCxmzqnjPaiv+SUA4Kc//SmSkpJG/V2pVMIh8Rlcp9MJlUol6ZjRgj8LjuOy2wOfMPHWjn6Xe1KPI4pWoTggnpCQgPx1WdN67vnzA0G9NhHRTAqIAXh8LvS7z+PM5eM4frELHw2ewCVPH7x+NxgyZtZzT/0EPp8f9913H77whS/c9HedTge73Q6PR5riI263G3a7HTqdTpLxog2DxjgmW1FKxNVVDaIYFoqwsXDhLCxaOGvKz+vtZdAgosgliuLVYNGLswMncOKiDWcHjqPf3Quv3wUGi/B5+00Tmv/wZ8jlcvz0pz8dswqiXq+HIAhobW2V5DVbW1shCAL0er0k40UbBo1xTHQQ/HoMGhQPQhE21q3LQkLC1Kq2Xex3TOsgORFRKIiiCK/fg0vuPnw0cBLH+7uuBovz8PicEBEI9xQJgN/vx7Pf/RcAwOOPP47c3NwxH1dQUICcnBzU1NRI8ro1NTXIzc1Ffn6+JONFGwaNMfgFAf2uyR/amUooIYpmUoeNNI0Sq1dN7ZBTICDiwjSb/hERBUsURQz5vbjsuYCPBk/hRL8NZy4fxUX3Obh9Dogig0UkeuWX+/FhVzdmzZqFp556atzHyWQy7Ny5E/v374fZbA7qNc1mMw4cOICqqqq4bNYHsDP4mM4NDOLt4yen9Jz7dWuhuuFAEUUOdgaXlpQdxH0+P/7w3xYMDU2+0VT26kXIv335tF6PiGiqhv1DI4e33T4XAqI/3FOiKRgcGETp3X+NSxcvYffu3di1a9ctH+/z+WAwGOD1etHe3o7U1KlXF3W5XCgsLIRSqYTJZEJiYnzWX+KKxhims0LBVQ2KJ1KubCgUicjLXTal5/T28ZwGEYWOTxjCgLcf5xynceLiEfRctqPP9RGcwwMMGVFo77/W4NLFS8jJycFjjz024ePlcjm+8c1/xokTJ7F582a4XBNXIb2ey+VCWVkZenp6UFdXF7chA2DQGNN0zlzwnAbFGynDxooV85GRMflfjAYG3PB4uEJFRNLwCcMY9F7CeccZnOw/glOX7OhznoVz6DIEcfKrrRR5jh89gZd//p8AgH/7t3+DQqG45eOHhnx48y0b5IkZ+Pt/+Be8/bYRer1+0tuozGYzCgsLYTKZcOjQIeTl5QX97xDN4jdijcPr82HAO/UunL0OJ0RRjNs9eBSfpOqzIZPJkL9uOd54c/KdU3v7BpCVOW/iBxIR3cAf8MEz7Lq6FcrJrbUx7Ll/+gn8fj82btyI++67b9TfRFFER0cHzGYzOjs7MTDowOVLXixYmIlVq3OQk5uPHzxTg5fq/hUGgwFbtmzBY489huLi4lGdw91uN1pbW1FTU4MDBw6goKAARqMx7kMGwKBxk+lugRry+zHg8SJDJU3LeqJoIVXYmDcvDUuXzsGZMxcn9fjeXgYNIpocIeAfCRUenws+YSjcU6IZ8Naf38af//QmEhMT8ZOf/GTkn/t8PtTW1mLv3r2w2WyQy+XQarVIVavhGHTgd79rgCAIWLZsBcof+DKMxrdRV1eHvXv3Yv369SOPV6vVcDqdsNvtEAQBubm52LNnD3bs2DHhykm8YNC4QTBboPqcTgYNiktShY11eZn4+ONLEISJq7acY+M+IhrHlWDxSfftYWHqOxUoul1fznbnzp1Ys2YNAMBqtWL79u2wWCzYunUrdu/efdMKhcfjQWtrK/bt24fn//0ZtLzxO9TX1+Pxxx+HxWIZWQFxu91QqVR48sknodfrkZ+fz50tN2DVqRv83toFr296B70WaNQoXr1S4hmRFFh1amZIUY2qs+s0umxnJvXYDetvR3qaasrzJKLYEhAFeHxXtkJ5hl0YEqTp6kzR6+Wf/yee/tYPMWfOHHR3Xylr29LSgo0bNyIrKwv19fW46667JhzHbDajoqICPT09OHToEEpKSmZg9rGDh8GvM+jxTjtkAMBFlxtCgPWzKX5JcUB8jXYxlMrJlYpml3Ci+BQQA3APO3DBdQ6nLx/D8Ys2fDx4Cpc9FxgyCJcvDWD3j6sBAD/4wQ8wa9YsWK1WbNy4EUVFRWhvb59UyACudApvb2+HwWDApk2bYLVaQzn1mMMVjesc7b2Aw2c/CmqMT69eiXkatUQzIqlwRWNmBbuy0dNzAW3m7gkft2jhLPxV8dppz5OIokNADGDI74F7+MpWKK/fDYC3LzS2p7/1HF7++a+Ql5eHjo4OiKIoaV8Mo9HIMxiTxBWN6/Q6HBExBlG0C3ZlIzNzLubM0Uz4uL6+AQS4ikgUc0RRhMfnQr+7F2cHjuPExS6cHTiOS55eeP0uMGTQeLo/PIZf/eK/AAD//u//jsTERNTW1sJisaC+vn5aIQMAUlNTUVdXh46ODtTW1ko55ZjGFY2rAqKIQ4c74Q/ypmWWSonPrsmWaFYkFa5ohEcwKxv9l5x47fUPJnzcZ0t0mDs3Lah5ElF4iaKIIb/nk3MWPhdE8EcEupkoiug6bMNhSye6jxzDkNeL5JQUZK9dhXX5Ovzkmd14689vY/PmzWhsbIQoitDpdNDpdGhoaAj69cvLy2Gz2WC1WnnwexJYdeqqfpc76JABAJfcHgz7/UiK4y6QRNcEU41q9iw1lmfNw8lTfbd83PneAQYNItzcE8Dj8UCpVEKn00Gv16OgoCBiboxEUcSw4L1actYFr8+FgCiEe1oUwXw+H155+VX88sVf46j9OORyObK12dBoNHA4HPjVL/4LgiBALpcjISEBzz77LACgo6MDNpsNu3fvlmQelZWV2LBhAywWCwoKCiQZM5bxbvgqKbc89TqcWDorQ7LxiKJZMGEjT5eJM2f74fePfwNyvncAutxl0kyWKAqN1xPg2g1YdXU1BEFATk4Odu7cGbYa/8N+L9w+19WSs24ExOkXX6H4Yrd145s7vwub9Qi2bt2Kn71QM25J2p/97GdobGzEww8/jPr6ephMbZDL5SguLpZkLsXFxZDL5TCbzQwak8AzGlcF0z8jlGMRxYLpntlQKpOQs3bJLR/T3++EL4hqcUTRzGq1wmAwYNeuXdDpdGhqaoLD4UBXVxfa2trQ1dUFh8OBpqYm6HQ67Nq1CwaDYUYq5wwLQxjw9OPcYA9OXLSh53I3Lrg+gmt4kCGDJq2t9R088PmHIfpFtLW1oaGhAaWlpaNCBgAolUqUlpbi1VdfhclkgtfrRVFREf7z169i9ersmx4/XSqVClqtFp2dnZKMF+sYNAD4BAH9Lrdk4zFoEN1sumEje/UiqNUp4/5dFEX09g1KNk+iaNHS0jJSSWcyN2ANDQ2jbsBaWloknY9PGMag9xLOO07jRP8R9Fyyo891Fs7hAQgMFjQNdls3Hv3Szqslac1TLkl79913w/j2G9BIXA1UrVbD7ZbuvjGWMWjgSjCQ8kS8c3gYzqEhCUckig3TCRtyeQLW3ZZ1y8ewnwbFm0joCeAP+ODwXsZ5xxmc7P8Qpy59iF7nGTiGLkMI+KY9LhFwZUvgN3d+F8uzsnCw8eCUq0Wlpqbi4MGDSEtLw+XLlyWdm9PphErFZrGTwaCB0KxAcFWDaGzTCRtLFs/G/Hnp4/79PIMGxRGfz4ft27cjKysLjY2N07oBa2xsRGZmJioqKuDzTS4U+AN+OIcG0Os8i1P9dpzsP4LzztNwDF1iVT+S3Csvvwqb9Qjq618KqiRtZWUljh8/Do9HmkaObrcbdrsdOp1OkvFiHYMGrhzejoYxiWLFdMJG/u3Lx62Y43B44HZzFZHiw0z1BBACfjiHBtHn/Ag9l7pxst+Gc44eDHr74QvweqPQEUURv3zx19i6deukV+vG88ADDyAQCKC1tVWSubW2tkIQBOj1eknGi3VxHzTcw8NwhGCbU5/DCbYoIRrfVMNGeroKK1fMH/fvXNWgeCCKIvbu3SvJDZher8eWLVvwwgsvQBRFCAEBruFBXHB9jNOXjuJEvw3nHKcw4L2IYcEr0b8B0cS6Dttw1H4clZWVQY9VUFCArKws/OxnP5NgZkBNTQ1yc3ORn58vyXixLu6DRqhWHoYFAZfd0izTEcWqqYYNXe4yJCWNXZWb5zQoHlzrCSDFDRhwpSdAV1cX/vjWb3Gi34aPB0/hsucChgR+f1H4HLZ0SlaSViaT4cknn8SBAwdgNpuDGstsNuPAgQOoqqqKmJ40kS7ug0Yoz1L0Orl9imgiUwkbyckK5OYsHfNv53sHuIpIMc9sNoekJ8C777wLSFoWhWj6uo8cQ7ZWupK0VVVVUKlU+MpXvgKXyzWtMVwuFyoqKlBQUIBHH31UknnFg7gOGqIohvQsRe8ggwbRZEwlbKxauQAazc1fPkNDPgwMsNwgxbbOzk5otVpJewJka7PRfeSoJOMRSWHI64VGo5FsPIVCgeXLl+P48eMoKyubcthwuVwoKytDT08P6urqkJjIfteTFddBY8DjxZA/dLW9L7pc8AcCIRufKJZMNmwkJCQg//blY47BcxoU6zwej6Q3YMCVngBeD89gUORITkmBw+GQdMxAIIBNmzbBZDKhsLBw0tuozGYzCgsLYTKZcOjQIeTl5Uk6r1gX10GjL8RbmwKiiIvO6S3REcWjyYaNhQsysHjRrJv+OYMGxTqlUin5DZjT6USKcvymmEQzLXvtKnTbuyUvSXvffffBaDRCqVTCYDCgvLwczc3NN72O2+1GU1MTysvLYTAYoFQqYTQaUVJSIsl84klcB43eQWk/rMd8DYm/EIhi3WTDxrrbspCQMPow3sULgxAEriJS7NLpdLDb7ZLegHXbu5G9drUk4xFJYV2+DoIghKQkbV5eHoxGI/bs2YOuri6sX78eGo0Gubm5KCwsRG5uLtLS0rBhwwbYbDbs2bMHRqORKxnTFLebzIRAABddod/PzcZ9RFN3LWwAwEu1v8LXvvY1AMAjjzwy8hiNRonVqxbB3v3RyD/zCwFc7HfcsrkfUTTT6/UjN2ClpaVBj3ftBuy2fDYfo8iRuy4Hq7UrUVNTI8l/5zeWpFUoFHjiiSfw+OOPw2KxwGw2o7OzE263GyqVCk8++ST0ej3y8/NZXSpIcRs0+l3uGTk/cdnjhdfnQ4pCEfLXIoolkwkbuTlL0NPTB+/QJ52Nz58fYNCgmFVQUICcnBwJb8D2IXvNKuTetlaC2RFJQyaT4cuPfBFPf+s5mM3moJrjXStJu2fPnptCg0wmQ0FBAQoKCoKdMo0jbrdOzeSWJq5qEE3PRNuoFIpE6HTLRj2H/TQolslkMuzcuRP79++XqCdAI7701Yf4qy1FnAcf3oa8dTpUVFSwJG0Ui+OgMXM3/zP5WkSxZqKwsWL5fMzKSB353/2XnBgeDl01OaJw27FjB/Lz8yW4AduO3Nty8NBXyiWeIVHwFqYvw/95+Vfo6elhSdooFpdBY9jvx6UZ7Nod6upWRLHuVmFDJpPdVO6W1acolikUCtTX1wd1A7a5bDNO9fTgR3ue5g0YRRQZZFigWYZZqnnIy8vDoUOHWJI2isnEGG6lK4oiOjo6Rg75eDweKJVKLF6xAokLFmPF2rUztly8PkcLTQrLB4bLyf4P4Q8Mh3saFCRRFPHP3/kRXqr9FQDg5z//+ciZDVObHafPXIQoivANXYDT+fGo616n00Gv16OgoIDbRCgmtLS0YNOmTcjMzERdXd2k9rGbzWZUVGzHqZ4e1PxyD+4uvmsGZko0OQmyRCxKy4RSkTrqn1utVlRUVKCjowNbtmzBY489huLi4lGNK91uN1pbW1FTU4MDBw6goKAAdXV1DBlhFpNBw+fzoba2Fnv37oXNZoNcLodWq4VGo4HD4YDdbocgCFi2ciXuf/CLKN2yFYkhPqx9+9LFWDVvbkhfg8bHoBE7xgsbAwNOfOOb38cf//AqTp8+Me51n5OTg507d2LHjh1QsEgDRbmp3YDtw4EDjci9LQc/2vM0tDnZYZw50WgKeTIWp2VBIU8e8+/j3dup1Wo4nc6Rz/jc3FxUVVXxMz5CxFzQsFqt2L59OywWC7Zu3YrKysqbPnQ9Hg9aW1uxr6YGB/bvx4o1a7Hz+08jc3XoPnQXp6fBsHJ5yManW2PQiC03ho3vf//7OHjwICwWy7g3W9eu+5qaGuzfvx/5+fmor6/nr10U9ca6AcvWZo/cgHXbuyEIArLXrMKXvvoQHnx4G2/AKKIoFalYqMmEPGHibXyiKI5ZkvbaqjVL0kaWmAoaLS0t2LhxI7KyslBfX4+77pp4SdhsNmP79u04eaoH33p+N3R3hmYZWSGXY+NtuUjgf/xhwaARe64PGwkJCVizZg1eeumlSV/3FRUV6OnpwaFDh9jtlWLCtRuwt02taO8wwuvxIkWZguy1q3Fbvg65t83cdmGiydIkz8J89RL+txmjYiZoWK1WGAwGFBUVobGxEampqRM/6SqXy4XNmzfjbaMJz9bVh2xloyR7FeaoJz8vkg6DRmz6sMuOrev/BsXFxfjtb3875eu+rKwMJpOJXV8ppjiHBnDO0RPuaRBNaI5qIWap5oV7GhRCMRE0fD4fDAYDvF4v2tvbp3SzcY3L5YJer4dPJsMzv3gpJGc2chctwNqFCyQflybGoBF7fD4fHrj/YYh+Ee3t5mlf94WFhVAqlTAajdxOQjHhsucCLrg+Dvc0iMZ1rbKUOpnNVWNdTJS3ra2thcViQX19/bRuNgAgNTUV9fX1OH7kCJoP7Jd4hlecH2SZWyKpvPLyq7BZj6C+/qWgrvu6ujp0dHSgtrZW4hkShYc/wD4yFLkSZIlYnL6CISNORP2KhiiK0Ol00Ol0aGhoCHq8bdu24Z3338dPX3lV8v2CCTIZNt2Wi0S5XNJxaWJc0YgtoijiC3+1Bfnr7pDkui8vL4fNZoPVauU+YYp65x2n4Ri6HO5pEN1kospSFHuifkWjo6MDNpsNlZWVkoz32GOPoefYMZz48Igk410vIIq44JxeF1ci+kTXYRuO2o9Ldt1XVlaiq6sLFotFkvGIwskf8IV7CkQ3USpSsTR9FUNGnIn6oGE2myGXy1FcXCzJeMXFxZDL5Tja2SnJeDc67+D2KaJgHbZ0huS6n2zXWaJI5he4dYoiiyZ5FhanrYA8gTs64s3EBYsjXGdnJ7Ra7ah6+cFQqVRYnZ2N08ePSTLejfoYNIiC1n3kGLK12ZJe91qtFp0h+oGBaCZxRYMiCStLxbeoX9HweDzQaDSSjqlWqzHs9Uo65jWDXi+8Pn4JEAVjyOsNyXXvdrslHZNopgkBASIC4Z4GEWSQYaEmkyEjzkV90FAqlXA4HJKO6XQ6kZSSIumY12P1KaLgJKekhOS6V6lUko5JNNMErmZQBEiQJWJJ+kpWlqLoDxo6nQ52ux0ej0eS8dxuN452d2PZylWSjDeWPolvkIjiTfbaVei2d0t63dvtduh0OknGIwoXbpuicFPIk7EsYxVSFPzhhmIgaOj1egiCgNbWVknGa21thSAIWB3CG45eJ1c0iIKxLl8Xkuter9dLMh5RuLCHBoWTUqG+WlkqKdxToQgR9UGjoKAAOTk5qKmpkWS8ffv2IXPVKqxYs1aS8cbi9fkxINEvsUTxKHddDlZrV0p23dfU1CA3Nxf5+fmSjEcULlzRoHBJS56NxWnLWVmKRon6oCGTybBz507s378/6NKUZrMZjY2NuO+Bh0LetIvVp4imTyaT4cuPfFGy6/7AgQOoqqpisz6KegwaFA5zVAsxX7OEn6F0k6jvDA4APp8PBoMBXq8X7e3tSE1NnfIYLpcLer0ePpkMz9a9DHliaCv/LkzT4FOrVoT0NegT7Awee3w+Hx64/2GIfhHt7eZpX/eFhYVQKpUwmUxIDPF1TxRqHw2chNvHc4A0M2SQYYFmGQ9907iifkUDABQKBerr69HT04OysjK4XFPrvu1yubB582acPNWDqqeeDnnIAIALThcC0Z/xiMJGoVDgx3t/gFM9Pdhctnla131ZWRl6enpQV1fHkEExgSsaNFPkrCxFkxATQQMA8vLycOjQIZhMJhQWFk56O4XZbIZer8fbRhO+9fxuZK7ODvFMr/AHAuif4o0REY2mzclGzS/3XL3u9VO67gsLC2EymXDo0CHk5eWFeKZEM4OHwWkmKOTJWMrKUjQJMRM0AKCkpARGoxFKpRIGgwHl5eVobm6+qQSm2+1GU1MTtm3bBoPBcHW7VD10d941o/Pt5TkNoqDdXXwXXvn9S0hQJEzqui8vL4fBYIBSqYTRaERJSUmYZk4krYAYQEBk0KDQYmUpmoqYOKNxI5/Ph9raWuzduxc2mw1yuRxarRZqtRpOpxN2ux2CICBz1Src98BDKN2yFYkKxYzPc7ZKhXvWrJ7x141HPKMR+3w+H155+VX88sVf46j9+LjXfW5uLqqqqrBjxw4ownDdE4WKTxjGqUsfhnsaFMPSkmdjnnoxD33TpMVk0LhGFEVYLBaYzWZ0dnbC7XZDpVJhzdq1cGfMxoo1a8N6scgAbFqng0LOUnChxqARP0RRRO/xy+h8/8io616n00Gv1yM/P59fkhSTPD4Xzg4cD/c0KEbNUS3ELNW8cE+DokxMB41b+fOH3bjkDn8vC8OKLCzO4EGqUGPQiC8rZudAnsDD3RRfHEOXcd5xOtzToBjDylIUjJg6ozEV8zXqcE8BAM9pEEktOVHJkEFxyS+w4hRJi5WlKFhxHDQ04Z4CAAYNIqkpFZHxIwLRTBN4EJwklCRPYWUpClrcBo3ZqSokJoT/X985NAT3MLf0EElFxaBBcYorGiQVpUKNJekrWVmKghb+O+0wkSckYE5qZKT03kGuahBJQYYE/vpGcYs9NEgKacmzsThtOeQJLFRDwYvboAEA89O4fYoolqQoVEiQxfXHGsUxdgWnYM1RLcR8zRJW5iPJxPWJyXnqyNhi0ed0QhRFXthEQeK2KYpnDBo0XawsRaES1z/9pStTkJIY/qw15PdjwOMN9zSIop4qiUGD4pMQ8AOIy2r1FCRWlqJQiuugIZPJMI9lboliQoIsEUnylHBPgygsuJpB08HKUhRqcR00AERM0OhzOMI9BaKopkpSc/shxS0GDZoqVpaimRD+fUNhFimN+y44XRACAcgjoOQuUTTi+QyKZ36BFado8tKSZ2OeejF/nKGQi/u7WlVSEjTJyeGeBgRRxEWXK9zTIIpaSkVquKdAFDZc0aDJYmUpmklxHzSAyFnV6OM5DaJpUciTufxPcY1BgyYigwwLNZmYpZoX7qlQHGHQQOSc0zjPxn1E08JtUxTvGDToVlhZisIl7s9oAFeChgzhLwx42ePBkN+P5AgouUsUTZQMGhTnBHYFp3EkyVOwKC2Lq74UFlzRAKCQyzE7NTJKu3H7FNFUyXg+g+IeVzRoLKwsReHGoHFVpGyfYj8NoqlJSVRCniAP9zSIwiYgBhAQhXBPgyJMWspsLE5bzs9HCisGjavmazThngIArmgQTRW3TVG842oG3WiOaiHmq1lZisKPQeOq2akqJEZADwvX8DCcQ0PhngZR1FAlMWhQfPMLDBp0hQwJrCxFESX8d9YRIkEmw1x1ZOzz7mX1KaJJkckSkJIYGeeriMKFKxoEXKsstYKVpSiiMGhcJ2K2TzkZNIgmQ5mYyq0BFPdYcYqS5ClYmrEKKQr+8EKRhXVUrxNJjftEUeQNFNEEuG2KiCsa8U6pUGOhJpOHvikicUXjOmnKFKQowp+9hgUBl9yecE+DKOKxUR8Rg0Y8Y2UpinQMGjdYECnbp1h9iuiW5DIFkhJTwj0NorDzc+tUXGJlKYoGDBo3YD8NoujAbVNEV3BFI76wshRFk/DvE4owkXJO46LLBX8gEBEld4kiEbuBEwGiKPIweByRyxKxKC2Lh74pavAu9gYpCgXSU8K/HSMgirjgdIV7GkQRiysaRIAg+gGI4Z4GzQBWlqJoxKAxhkjZPtXncIR7CkQRKUmegsQERbinQRR2bNYXH5QKNZakr4RCnhTuqRBNCYPGGCJl+xQb9xGNTclqU0QAeBA8HrCyFEUzntEYw1x1KhJkMgTE8C5HD3i98Pp8SFHwl1ui66mSeD6D4o8oiujo6IDZbEZnZyc8Hg8SFDIsXbUQ6/J1yF2XwwpEMWaOaiEPfVNUY9AYQ6Jcjtmpqog4I9HncGLZ7FnhngZRBJHxIDjFFZ/Ph9raWuzduxc2mw1yuRxarRYajQYOhwP2/7BDEASs1q7Elx/5Ih58eBsU/IEqqsmQgAWaZVAnp4V7KkRB4dapcUTM9imWuSUaJSVRhQQZtxBQfLBarTAYDNi1axd0Oh2amprgcDjQ1dWFtrY2dHV1weFwoKmpCfnr7sDT33oOD9z/MOy27nBPnaZJLlNgSfoKhgyKCQwa45gfIY37GDSIRmO1KYoXLS0tMBgM8Hq9aGtrQ0NDA0pLS6FUKkc9TqlUorS0FA0NDTCZTBD9Ih78wlfQ1vpOmGZO03WlstRKVpaimMGgMY4MlRIKefh/NfX4fHB4veGeBlHEUPEgOMUBq9WKjRs3oqioCO3t7bjrrrsm9Ty9Xo/2djMMBgMqv7yLKxtRhJWlKBbJRDHMJ54jmOn4SXw0MBjuaWDdksVYPX9uuKcR1U72fwh/YDjc06AgJcjkWDGbB14ptvl8vpGVjPb2dqSmTv1MksvlQmGhHgmKBLzyh5d4ZiPCpaXMxrzUxfxso5jDFY1biJTtU31Obp8iAq50A+cXMcW62tpaWCwW1NfXTytkAEBqairq6urR9YENr7z8qsQzJCnNUS3EfPUSfrZRTGLQuIVIORDe53CGvdQuUSTgtimKdaIoYu/evdi6deukt0uNR6/XY8uWMvyf//1f4OaFyCNDAhZqsli+lmIag8YtqFOSoUoK/3KzPxDAJZc73NMgCjslD4JTjOvo6IDNZkNlZaUk41VWPobuD4+h64MjkoxH0mBlKYoXDBoTiJTtU6w+RfEuMUGBJHlyuKdBFFJmsxlyuRzFxcWSjFdcXAy5XI4PLJ2SjEfBY2UpiicMGhOIlO1TDBoU71SKyAj9RKHU2dkJrVZ7Uwnb6VKpVMjWZqP7yFFJxqPgsLIUxRt2Bp/AvAgJGv0uF3yCEBEld4nCQZnEbuAU+zweDzQSr6Sr1Wp4PSyTHm6sLEXxiEFjAklyOXqPH4flvXdx+vgxDA8NISk5GctWrsJqXR5WrF07Ix8aIoALThcWpXM/J8UuURTRddiGw5ZOdB85hiGvF8kpKcheuwr3l2zCXXfq+SVNMU2pVMLhcEg6ptPpRIoyRdIxaWrmqBby0DfFJQaNcfh8PtTW1mLv3r2w2WyQy+VYnZ0NjUYDh8OB/254BYIgYNnKlbj/wS+idMtWJIa4Tnmvw8mgQTHJ5/PhlZdfxS9f/DWO2o9DLpcjW/vJ9farX/wXvif8ADk5Odi5cyd27NjBvgAUk3Q6Haqrq+HxeCTZPuV2u9Ft78aXvvagBLOjqZIhAQs0y3jom+IWz2iMwWq1wmAwYNeuXdDpdGhqaoLD4cARmw3m9nYcsdngcDjQ1NSEwjvuwIs/fg7frvgKeo6GtgNr76C0v3IRRQK7rRsP3P8wnv7Wc8hfd8fI9WbrsqG9rR22rk+uN51Oh127dsFgMMBqtYZ76kSS0+v1EAQBra2tkozX2toKQRBwW75OkvFo8lhZioidwW/S0tKCjRs3IisrC/X19ZOqY242m7F9+3acPNWDbz2/G7o7g6t9fiuf1+VAGQEld6MNO4NHprbWd/Dol3ZieVYW6utfmvT1VlFRgZ6eHhw6dAglJSUzMFOimSGKInQ6HXQ6HRoaGoIer7x8Gw5b38fv3trPbYczKEmegkVpWTz0TXGPKxrXsVqt2LhxI4qKitDe3j7pZkl6vR5msxmfKjLgh3/79ZCubLD6FMUKu60bj35p59XrzTyl6629vR0GgwGbNm3iygbFFJlMhp07d2L//v0wm81BjWU2m3HgQCO+9NWHGDJmkEqhYWUpoqu4onGVz+eDwWCA1+tFe3s7UlOnXuHG5XJBr9fDJ5PhmV+8FJIzG8tmZUC/PFPycWMdVzQii8/nwwP3PwzRL6K93Tzt662wsBBKpRJGo5FnNihmSPV9VFioR4IiAQ1/fBmJiTySORNYWYpoNK5oXFVbWwuLxYL6+vppfagDQGpqKurr63H8yBE0H9gv8Qyv6OOKBsWAV15+FTbrEdTXvxTU9VZXV4eOjg7U1tZKPEOi8FEoFKivr0dPTw/Kysrgcrmm9HyXy4XNZZtxqqcHP9rzNEPGDJmbugjz1UsYMoiuwxUNSL8ndtu2bXjn/ffx01deDckHzr1rs5EuUTOneMEVjcghiiK+8FdbkL/uDon2oJfDZrPBarXyC55iSktLCzZt2oTMzEzU1dVBr9dP+JwrZ5i241RPD2p+uQd3F4fuzCBdwcpSROPjigaAjo4O2Gw2VFZWSjLeY489hp5jx3DiwyOSjHcjntOgaNZ12Iaj9uOSXW+VlZXo6uqCxWKRZDyiSFFSUgKj0QilUgmDwYDy8nI0NzfD4/GMepzb7UZTUxPKy7fBYDAgQZGAV37/EkPGDJDLFFiSsZIhg2gcXE/FlV+A5HI5iouLJRmvuLgYcrkcRzs7sXJtjiRjXq/X4UT2fDb+oeh02NIZkuvNbDajoKBAkjGJIkVeXh6MRuNIX6f169dDLpdDq9VCrVbD6XTCbrdDEARkr1mF7/3wH/Dgw9t4ZmkGsLIU0cQYNAB0dnZCq9VK0hwJAFQqFVZnZ+P08WOSjHeji04XhEAA8gQuSFH06T5yDNnabEmvN61Wi87OTknGI4o0CoUCTzzxBB5//HFYLBaYzWZ0dnbC7XZDpVLhySefRO7ta7FgZQa3D84QlUKDBZplkCfIwz0VoojGoAHA4/FAo9FIOqZarcaw1yvpmNf4AwFccrsxV60OyfhEoTTk9YbkenO73ZKOSRRpZDIZCgoKxly5EwJ+nOi3hWFW8YeVpYgmjz+JA1AqlXA4pO267XQ6kZSSIumY1zs/yHMaFJ2SU1JCcr2pVCpJxySKJvKERCQnskhIqLGyFNHUMGgA0Ol0sNvtNx2wmy63242j3d1YtnKVJOONhWVuKVplr12Fbnu3pNeb3W6HTqeTZDyiaKVSSLtSSJ+QIQELNVnIUM4N91SIogqDBq50GhYEAa2trZKM19raCkEQsDqENz6X3G4M+/0hG58oVNbl60JyvU2m9CdRLFMlcTttKLCyFNH0MWgAKCgoQE5ODmpqaiQZb9++fchctQor1qyVZLyxiAD6nFNr4kQUCXLX5WC1dqVk11tNTQ1yc3ORn58vyXhE0SolUYUEGQ8nSylJnoKlGSuRwm1pRNPCoIErB+x27tyJ/fv3w2w2BzWW2WxGY2Mj7nvgoZDv4eT2KYpGMpkMX37ki5JdbwcOHEBVVRX3TFPck8lkUCpSwz2NmKFSaLA0YyXL1xIFgZ3Br/L5fDAYDPB6vWhvb0dq6tQ/rF0uF/R6PXwyGZ6texnyxNAW9VInJWGDLnSrJrGEncEji8/nwwP3PwzRL6K93Tzt662wsBBKpRImkwmJIb7eiKLBgKcffa6z4Z5G1GNlKSJpcEXjKoVCgfr6evT09KCsrAwu19S2JblcLpSVleFkTw+qnno65CEDAJzDw3AN8eaZoo9CocCP9/4g6Outp6cHdXV1DBlEV/GcRvBYWYpIOgwa18nLy8OhQ4dgMplQWFg46W0dZrMZhYWFMJlM+FVDA1Zka0M8009w+xRFK8OdxTh06HdBXW+HDh1CXl5eiGdKFD0U8iQoEpLDPY2oJEMCFrGyFJGkGDRuUFJSAqPRCKVSCYPBgPLycjQ3N99UitPtdqOpqQnl5eUwGAxQKpUwGo0o+/znUbRqOeQz9EvIeYn7ERDNhNmq+ZitWhD09VZSUhKmfwOiyMVVjam7VlkqlZWliCTFMxrj8Pl8qK2txd69e2Gz2SCXy6HVaqFWq+F0OmG32yEIAnJzc1FVVYUdO3ZAoVCMPL/X4YDx2EkIIf5/b3JiIr6Ql8Ml3gnwjEbkuBYyrhfs9UZEn3AND+LjwVPhnkbUSJKnYFFaFg99E4UAg8YERFGExWKB2WxGZ2cn3G43VCoVdDod9Ho98vPzx73Jn6mw8bk12chQsfTerTBoRIaxQsb1grneiOiKgBjA8YtduFIInW5FpdBgYdoylgUmChEGjRCbibChW7wQaxbMD9n4sYBBI/wmChlEJJ2zA8fh8bHX0q2kp8zB3NRF/PGCKIR4RiPE5ms0IT+zwQPhFOkYMohmlkqhCfcUItrc1EWYp2b5WqJQY9CYAaEOGxedLvgDgZCMTRQshgyimccD4WNjZSmimcWgMUNCGTYEUUT/FPsQEM0Ehgyi8EiSp0AuY3+Z67GyFNHMY9CYQaEMG72D3D5FkYUhgyh8ZDIZVzWukyRPwdKMlUhJZOEUopnEoDHDQhU2enlOgyIIQwZR+PGcxhUqhQZLM1ayfC1RGDBohEEowsZljwdDfr9k4xFNF0MGUWRQckUD6SlzsCgti+VricKEQSNMQhE2WH2Kwo0hgyhyJCYkIlkev1uFWFmKKPwYNMJI6rDB7VMUTgwZRJEnHlc1WFmKKHIwaISZlGGj1+GQYEZEU8eQQRSZUpPi65wGK0sRRRYGjQggVdhwD/vg9A5JNCuiyWHIIIpcKYkqyGTx8VWfJE/BsoxVrCxFFEHi49MnCkgVNrh9imYSQwZRZJPJZFAqYn/71LXKUolyRbinQkTXYdCIIFKEDW6fopnCkEEUHVJjPGiwshRR5GLQiDDBho0+pwuiKEo8K6LRGDKIokfsNu6TsbIUUYRj0IhAwYQNnyDgktsTglkRXcGQQRRdFPJkJCbEVrO6K5WlMllZiijCMWhEqGDCBrdPUagwZBBFp1ha1WBlKaLowaARwaYbNnggnEKBIYMoeqkUsVHmlpWliKILg0aEm07Y6He54ReEEM6K4g1DBlF0UypSAUT3OQZWliKKPgwaUWCqYSMgirjgcod4VhQvGDKIop88QY6URFW4pzFtrCxFFJ0YNKLEVMNG7yDPaVDwGDKIYkd0ntNgZSmiaMagEUWmEjb6eE6DgsSQQRRbVEnRdU5DhgQsSmNlKaJoxqARZSYbNga8Xnh9vhmaFcUahgyi2JMsT0GCLDHc05iUkcpSSawsRRTNGDSi0GTDBqtP0XQwZBDFJplMFhXbp1hZiih2yES2kY5avQ4HjMdOQhjjLRRFEd6Pz8J55jQ6Ozvh8XigVCqh0+mg1+tRUFAQV/tdT/Z/CH9gONzTmDGiKKLrsA2HLZ3oPnIMQ14vklNSkL12Fdbl65C7LmfM958hgyi2DXovodd5JtzTGJdKocHCtGU89E0UIxg0otyNYcPv86H5wH788ZVf4/Tx45DL5dBqtdBoNHA4HLDb7RAEATk5Odi5cyd27NgBhSL2SwXGS9Dw+Xx45eVX8csXf42j9ivvf7Y2e+T977Z3QxAErNauxJcf+SIefHjbyPvPkEEU+/wBH072Hwn3NMaUnjIHc1MXxdWPYESxjlunotz126h6jnbj2xVfwYs/fg6Fd9yBpqYmOBwOdHV1oa2tDV1dXXA4HGhqaoJOp8OuXbtgMBhgtVrD/a9BErDbuvHA/Q/j6W89h/x1n7z/ti4b2tvaYeuyjbz/+evuwNPfeg4P3P8w7LZuhgyiOJGYoECSPCXc07gBK0sRxSquaMSIxj/8AX9TXo7lWVl46aWXcNddd034HLPZjIqKCvT09ODQoUMoKSmZgZmGR6yvaLS1voNHv7QTy7OyUF8/lfd/+9X3/3cx/f4T0ScuuM7hsqcv3NMAcKWy1MK0ZTz0TRSjGDRigNVqhcFgQFFRERobG5Gamjrp57pcLpSVlcFkMsFoNCIvLy+EMw2fWA4adls3Hvj8wygqKsLBxoN8/4noltzDTnw0eCLc04BcpsDi9Cwk89A3Ucxi0IhyPp8PBoMBXq8X7e3tU7rJvMblcqGwsBBKpRJGozEmz2zEatDw+Xx44P6HIfpFtLeb+f4T0YQCYgAnLtogIhC2OSTJU7A4bTkS5fy8IYplPKMR5Wpra2GxWFBfXz+tm0wASE1NRV1dHTo6OlBbWyvxDCmUXnn5VdisR1Bf/xLffyKalARZApSK6X1eSEGl0GBpxkqGDKI4wBWNKCaKInQ6HXQ6HRoaGoIer7y8HDabDVarNeYO5MXiioYoivjCX21B/ro7+P4T0ZRc9lzABdfHM/66rCxFFF+4ohHFOjo6YLPZUFlZKcl4lZWV6OrqgsVikWQ8Cq2uwzYctR/n+09EU6ZSaGb4FWWYm7qYlaWI4gyDRhQzm82Qy+UoLi6WZLzi4mLI5XKYzWZJxqPQOmzp5PtPRNOSlJiMxISZ2bokQwIWpWUiQzlnRl6PiCIHg0YU6+zshFarhVIpTcUOlUoFrVaLzs5OScaj0Oo+cgzZ2my+/0Q0Laqk0K9qyBMUWJqxkuVrieIUg0YU83g80Gik/aJQq9Vwu92SjkmhMeT18v0nomlTKdQhHT9ZrsSy9FUsX0sUxxLDPQGaPqVSCYfDIemYTqcTKpVK0jEpNJJTUvj+E9G0KRVqADIA0teEUSWlYaFmKRJkcsnHJqLowRWNKKbT6WC32+HxeCQZz+12w263Q6fTSTIehZZ27Wp027v5/hPRtMgT5EhJlP6HhfSUOVikyWTIICIGjWim1+shCAJaW1slGa+1tRWCIECv10syHklNhuREFWYp52NJ+kp8/p7/wfefiIKiSpJy+xQrSxHRaOyjEcXYR2PyorWPhiIhGcqkVKgUGigVqZAnfPILId9/IgqW1+fGmYFjQY8jkyVgoWYZD30T0Shc0YhiMpkMO3fuxP79+4MuSWo2m3HgwAFUVVXxJjOMEmSJUCelY556CbJmrUHWbC3mq5dAnZw2KmQAfP+JKHjJicqgtzjJExRYms7KUkR0M65oRDmfzweDwQCv14v29nakpqZOeQyXy4XCwkIolUqYTCYkJkZ/jQBRFNHR0QGz2YzOzk70Xj6HpGQFsteuwrp8HXLX5UTEDbUMMqQoUqFSqKFMUiNZnjKlefH9J6JgiKKIprd+jzZzG7qPHMOQ14vklJRJf1Ymy5VYlJaFRPnM9OQgoujCoBEDrFYrioqKYDAY0NjYOKWbTZfLhbKyMphMJhiNRuTl5YVwpqHn8/lQW1uLvXv3wmazQS6XQ6vVQq1Rw+FwoNveDUEQsFq7El9+5It48OFtUChm9gsyWa6EMkkNlUKNFIUKCbLgFhb5/hPRVI31WZmtzYZGo5n0ZyUrSxHRRLh1Kgbk5eXh0KFDMJlMKCwsnPQ2GrPZjMLCQphMJhw6dCjqbzKtVisMBgN27doFnU6HpqYmOBwOdHV1ob2tHbYuGxwOB5qampC/7g48/a3n8MD9D8Nu6w7pvBITkpCWPBsLNZlYMTsHy2atxtzUhVAlqYMOGQDffyKamvE+K21dtkl/VqanzGVlKSKaEINGjCgpKYHRaIRSqYTBYEB5eTmam5tvKn3qdrvR1NSE8vJyGAwGKJVKGI1GlJSUhGnm0mhpaRnZQtTW1oaGhgaUlpbe1DVbqVSitLQUDQ0NMJlMEP0iHvzCV9DW+o5kc0mQyZGalIZ5qYuRNUuL5bPXYL5mCdTJ6ZAnhGZbUry//0Q0OVJ8Vl6pLLUoIrafElFk49apGDPu1iG1Gk6nE3a7HYIgIDc3F1VVVdixY8eMbx2S2rVf54qKiqa1dWhz2WaYTCa88vuXoM3JnsYMZFAqVFAqrmyHSk5Uhu0LOB7ffyKaHCk+K9tMbdxmSUSTxqARo0RRhMViGTkM7Xa7oVKpoNPpoNfrkZ+fHxO/Rkl3GFqPBEUCXvnDS5O68U6Sp0CVpIZSoYZSkSrJFigpxcv7T0STI3XhCKPRyB8piGhCDBoU1aqrq7Fr1y60tbXhrrvumvY4ZrMZBoMB3/vhP+BLX/3iTX+XJyigurpioUxSIzFEW6CIiEJB6s/KPXv24IknnpBwhkQUixg0KGpJ37BuGw5b38fv3tqPhAT5yFYolUKNpMRkCWZMRDTz2NyTiMIlsvZ7EE1BR0cHbDYbKisrJRmvsvIxdH94DBdOOLFydi4Wp2UhQzmHIYOIopr0n5WV6OrqgsVikWQ8IopdDBoUtcxmM+RyOYqLiyUZr7i4GHK5HB9Y+CsdEcWOUH1WTraUNhHFLwYNilqdnZ3QarU3lWWcLpVKBa1Wi87OTknGIyKKBPysJKJwYdCgqOXxeKDRaCQdU61Ww+12SzomEVE48bOSiMKFQYOillKphMPhkHRMp9MJlUol6ZhEROHEz0oiChcGDYpaOp0Odrv9pu7X0+V2u2G326HT6SQZj4goEvCzkojChUGDopZer4cgCGhtbZVkvNbWVgiCAL1eL8l4RESRgJ+VRBQu7KNBUYu14YmIJsbPSiIKF65oUNSSyWTYuXMn9u/fH3SZRbPZjAMHDqCqqopfnEQUU/hZSUThwhUNimo+nw8GgwFerxft7e1ITU2d8hgulwuFhYVQKpUwmUxITEwMwUyJiMKHn5VEFA5c0aCoplAoUF9fj56eHpSVlcHlck3p+S6XC2VlZejp6UFdXR2/OIkoJvGzkojCgUGDol5eXh4OHToEk8mEwsLCSW8NMJvNKCwshMlkwqFDh5CXlxfimRIRhQ8/K4lopjFoUEwoKSmB0WiEUqmEwWBAeXk5mpubbyrn6Ha70dTUhPLychgMBiiVShiNRpSUlIRp5kREM4eflUQ0k3hGg2KKz+dDbW0t9u7dC5vNBrlcDq1WC7VaDafTCbvdDkEQkJubi6qqKuzYsQMKhSLc0yYimlH8rCSimcCgQTFJFEVYLBaYzWZ0dnbC7XZDpVJBp9NBr9cjPz+fFVOIKO7xs5KIQolBg4iIiIiIJMczGkREREREJDkGDSIiIiIikhyDBhERERERSY5Bg4iIiIiIJMegQUREREREkmPQICIiIiIiyTFoEBERERGR5Bg0iIiIiIhIcgwaREREREQkOQYNIiIiIiKSHIMGERERERFJjkGDiIiIiIgkx6BBRERERESSY9AgIiIiIiLJMWgQEREREZHkGDSIiIiIiEhyDBpERERERCQ5Bg0iIiIiIpIcgwYREREREUmOQYOIiIiIiCTHoEFERERERJJj0CAiIiIiIskxaBARERERkeQYNIiIiIiISHL/PzaYh0eTJyIZAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -351,9 +351,9 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ,\n", - " ))" + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 10, @@ -362,7 +362,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -403,9 +403,9 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ,\n", - " ))" + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 11, @@ -414,7 +414,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -482,9 +482,9 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ,\n", - " ))" + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 13, @@ -493,7 +493,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -556,19 +556,22 @@ "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "(,\n", - " (, None, None))" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" + "ename": "XGIError", + "evalue": "Invalid colormap!", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mXGIError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn [16], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m xgi\u001b[38;5;241m.\u001b[39mdraw(SC, pos, node_labels\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n", + "File \u001b[0;32m~/Dropbox (ISI Foundation)/WORK/SCIENCE/xgi/xgi/drawing/draw.py:216\u001b[0m, in \u001b[0;36mdraw\u001b[0;34m(H, pos, ax, node_fc, node_ec, node_lw, node_size, node_shape, max_order, dyad_color, dyad_lw, dyad_style, dyad_color_cmap, dyad_vmin, dyad_vmax, edge_fc, edge_fc_cmap, edge_vmin, edge_vmax, alpha, node_labels, hyperedge_labels, rescale_sizes, aspect, **kwargs)\u001b[0m\n\u001b[1;32m 213\u001b[0m max_order \u001b[38;5;241m=\u001b[39m max_edge_order(H)\n\u001b[1;32m 215\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(H, SimplicialComplex):\n\u001b[0;32m--> 216\u001b[0m ax \u001b[38;5;241m=\u001b[39m \u001b[43mdraw_simplices\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 217\u001b[0m \u001b[43m \u001b[49m\u001b[43mSC\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mH\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 218\u001b[0m \u001b[43m \u001b[49m\u001b[43mpos\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpos\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 219\u001b[0m \u001b[43m \u001b[49m\u001b[43max\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43max\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 220\u001b[0m \u001b[43m \u001b[49m\u001b[43mdyad_color\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdyad_color\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 221\u001b[0m \u001b[43m \u001b[49m\u001b[43mdyad_lw\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdyad_lw\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 222\u001b[0m \u001b[43m \u001b[49m\u001b[43medge_fc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43medge_fc\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 223\u001b[0m \u001b[43m \u001b[49m\u001b[43mmax_order\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmax_order\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 224\u001b[0m \u001b[43m \u001b[49m\u001b[43msettings\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msettings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 225\u001b[0m \u001b[43m \u001b[49m\u001b[43mhyperedge_labels\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhyperedge_labels\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 226\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 227\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 228\u001b[0m dyad_collection \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;66;03m# for compatibility with simplices until update\u001b[39;00m\n\u001b[1;32m 229\u001b[0m edge_collection \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;66;03m# for compatibility with simplices until update\u001b[39;00m\n", + "File \u001b[0;32m~/Dropbox (ISI Foundation)/WORK/SCIENCE/xgi/xgi/drawing/draw.py:790\u001b[0m, in \u001b[0;36mdraw_simplices\u001b[0;34m(SC, pos, ax, dyad_color, dyad_lw, edge_fc, max_order, settings, hyperedge_labels, **kwargs)\u001b[0m\n\u001b[1;32m 782\u001b[0m dyad_color \u001b[38;5;241m=\u001b[39m _color_arg_to_dict(dyad_color, H_\u001b[38;5;241m.\u001b[39medges, settings[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdyad_color_cmap\u001b[39m\u001b[38;5;124m\"\u001b[39m])\n\u001b[1;32m 783\u001b[0m dyad_lw \u001b[38;5;241m=\u001b[39m _scalar_arg_to_dict(\n\u001b[1;32m 784\u001b[0m dyad_lw,\n\u001b[1;32m 785\u001b[0m H_\u001b[38;5;241m.\u001b[39medges,\n\u001b[1;32m 786\u001b[0m settings[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmin_dyad_lw\u001b[39m\u001b[38;5;124m\"\u001b[39m],\n\u001b[1;32m 787\u001b[0m settings[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmax_dyad_lw\u001b[39m\u001b[38;5;124m\"\u001b[39m],\n\u001b[1;32m 788\u001b[0m )\n\u001b[0;32m--> 790\u001b[0m edge_fc \u001b[38;5;241m=\u001b[39m \u001b[43m_color_arg_to_dict\u001b[49m\u001b[43m(\u001b[49m\u001b[43medge_fc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mH_\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43medges\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msettings\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43medge_fc_cmap\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 792\u001b[0m \u001b[38;5;66;03m# Looping over the hyperedges of different order (reversed) -- nodes will be plotted\u001b[39;00m\n\u001b[1;32m 793\u001b[0m \u001b[38;5;66;03m# separately\u001b[39;00m\n\u001b[1;32m 794\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m \u001b[38;5;28mid\u001b[39m, he \u001b[38;5;129;01min\u001b[39;00m H_\u001b[38;5;241m.\u001b[39medges\u001b[38;5;241m.\u001b[39mmembers(dtype\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mdict\u001b[39m)\u001b[38;5;241m.\u001b[39mitems():\n", + "File \u001b[0;32m~/Dropbox (ISI Foundation)/WORK/SCIENCE/xgi/xgi/drawing/draw_utils.py:366\u001b[0m, in \u001b[0;36m_color_arg_to_dict\u001b[0;34m(color_arg, ids, cmap)\u001b[0m\n\u001b[1;32m 364\u001b[0m maxval \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0.9\u001b[39m\n\u001b[1;32m 365\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 366\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m XGIError(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInvalid colormap!\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 368\u001b[0m \u001b[38;5;66;03m# handle the case of IDStat vs iterables\u001b[39;00m\n\u001b[1;32m 369\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(color_arg, IDStat):\n", + "\u001b[0;31mXGIError\u001b[0m: Invalid colormap!" + ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -583,7 +586,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "66cf2c2c", "metadata": {}, "outputs": [], @@ -602,7 +605,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "id": "aadc6917", "metadata": {}, "outputs": [], @@ -625,34 +628,10 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "f840930c", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(,\n", - " (,\n", - " ,\n", - " ))" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.figure(figsize=(10, 10))\n", "ax = plt.subplot(111)\n", @@ -669,34 +648,10 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "id": "03902a8e", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(,\n", - " (,\n", - " ,\n", - " ))" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.figure(figsize=(10, 10))\n", "ax = plt.subplot(111)\n", @@ -721,21 +676,10 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "id": "36596a26", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "centers, heights = xgi.degree_histogram(H)\n", "\n", diff --git a/tutorials/Tutorial 7 - Convex hulls hypergraph plotting.ipynb b/tutorials/Tutorial 7 - Convex hulls hypergraph plotting.ipynb index c296b03ef..b470c80f8 100644 --- a/tutorials/Tutorial 7 - Convex hulls hypergraph plotting.ipynb +++ b/tutorials/Tutorial 7 - Convex hulls hypergraph plotting.ipynb @@ -50,7 +50,7 @@ { "data": { "text/plain": [ - "" + "(, )" ] }, "execution_count": 3, @@ -59,7 +59,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABXwUlEQVR4nO3dd2CV9d3//+d19slOTnbYqGwEUZCqaK2D1llHHXUPqngXb1urtrb99m7v9r5r29vW1vau3b962+WeKDjAwXIBAUKABJKQAdnj7Ou6fn+EKQEZSU6S83r8eVbel3LOeZ3PeH8M27ZtREREJGk5El2AiIiIJJbCgIiISJJTGBAREUlyCgMiIiJJTmFAREQkySkMiIiIJDmFARERkSSnMCAiIpLkFAZERESSnMKAiIhIklMYEBERSXIKAyIiIklOYUBERCTJKQyIiIgkOYUBERGRJKcwICIikuQUBkRERJKcwoCIiEiSUxgQERFJcgoDIiIiSU5hQEREJMkpDIiIiCQ5hQEREZEkpzAgIiKS5BQGREREkpzCgIiISJJTGBAREUlyCgMiIiJJTmFAREQkySkMiIiIJDmFARERkSSnMCAiIpLkFAZERESSnMKAiIhIklMYEBERSXIKAyIiIklOYUBERCTJKQyIiIgkOYUBERGRJKcwICIikuQUBkRERJKcwoCIiEiSUxgQERFJcgoDIiIiSU5hQEREJMkpDIiIiCQ5hQEREZEkpzAgIiKS5BQGREREkpzCgIiISJJTGBAREUlyCgMiIiJJTmFAREQkySkMiIiIJDmFARERkSSnMCAiIpLkFAZERESSnMKAiIhIklMYEBERSXIKAyIiIklOYUBERCTJKQyIiIgkOYUBERGRJKcwICIikuRciS5gKKuqqmJbdQ2RuIVlOLAxADCwcGGTmZrC+PHjSE1NTXClIiKSzAzbtu1EFzHUbN68ma3b64k6PMQcHiwc2MbuIAA2YNg2TjuO14rgd1jMmD5NoUBERBJCYaAXxeNxlq1YSYflIuLwYRsGTtvE7QCfz4fH48E0TcKRCNFoHBMDy3DgsuP4zBBjivM57rjjEn0ZIiKSZBQGeolpmrz93nI6DD8xhxunFSc/N4dAIHDQ51imxdaqbYRiFmDgs0KUZKYwdeqU/itcRESSnsJAL7AsizXry6hqixA3XPidNmNGj8bYNTXwabo6u6iqrcU0XPjNIMcXBTRCICIi/Ua7CY6RZVms3bBxTxAoyExj7Jgxhx0EAFLTUjlu9Cicdpyww09F7Q5CoVAfVi0iIrKXwsAx2D0isK01jOlwM7Iwl7z8vEM+PtjVhWVZB9zndrsZUVwM2ISdflavLe3DykVERPZSGDhKlmXx8boNVLVFMB1uRhQESE9P7/GxZaVreWDBHZw4qoDpows5cVQBDyy4g7LStfs9LjUtlXSfh7jhojViEYlE+uNSREQkyWnNwFGwLIuPStezvSPWPSJQkEtaelqPj33x6X9x313zcKUH8E0+B3d2EbGWOsKli4l3NPHQo49x4WVX7nm8bdtUVNUQjUQYk+1jysTx/XVZIiKSpBQGjpBpmt1BoDOOtWtqIC2t5yBQVrqWy86dg3/CHHLmLsBw7u3xZJtxmhc+QmjDUp5etJTxk/fuIAgGg1Rsb8BrhpgzbcJBRxxERER6g6YJjoBpmny4dj3bO00sw8WooryDBgGAPz/2KK70wAFBAMBwusiZuwBneg5/eezX+92XkpJCZqqPqMPHuk0VKK+JiEhfUhg4TLuDQG2XiWU4GVWcf8iOgZZl8dKzT+GbfM4BQWA3w+nCP/lcXnz2yQO+8AvzcsEwaAzG2LFzZ69ei4iIyL4UBg6DaZp8sGYdtV0mtsP1qUEAIBwKEQ2HcWcXHfJxrqxCouEw4U9sJXS73eRlpRN1eNlQUd3jDgQREZHeoDDwKeLxOO+vLqUuaB12EADw+f14fD5iLXWHfv3Wejw+Hz6//4D7cnNycDkM2k0H26prjvoaREREDkVh4BDi8TirVpdSH7KxHS5GFxeQkpJyWM91OBxccOnlhEsXY5vxHh9jm3FCpYu48NIremxS5HA6KApkEzdclNc0EI1Gj+l6REREeqIwcBDxeJyVH5eyIwy2szsI+FMO/PV+KDfNu4t4RxPNCx85IBDYZpzmV36B2dHMjfPmH/Q1MjIz8HlchHFTvqXyqK5FRETkULS1sAexWIxVq9exMwI4XYwqLsDfwzD+4djdZ8CZnoN/8rm4sgqJt9YTKl2E2dF8QJ+BnuzeaugzQ8yZPvGQOxhERESOlMLAJ8RiMVauLqUxYoDTxeiSQnw+3zG9ZlnpWv7y2K958dkniYbDeHw+Lrz0Cm6cN3+//gKHUrW9lo6uMMUpMHPalCM6+0BERORQFAb2EY1GWbm6lKaoA8PpYlQvBIF9WZZFOBTCn5JyxF/msWiM8m01uK0IM8eNJD/v4GcgiIiIHAmtGdilOwisozHqxHC6GD2sqFeDAHQvKkxJTT2qX/Vuj5vczDSiDi/rt1Rpq6GIiPQahQEgEomw4uNSGqMOHE4nY4YX4/V6E13WAfICgT1bDatqtie6HBERGSKSPgxEIhGWf1xKU8yJ0+lizPBiPB5PosvqkcPpoDCQ1b3VsLpOWw1FRKRXJHUYCIfDLP+4lJa4a8AHgd0yMzPxeVyE8LCpYmuiyxERkSEgacNAdxBY1x0EXN1BwO1xJ7qsT2UYBkW5OZiGk207W+ns7Ex0SSIiMsglZRgIhULdQcB0D6ogsFtqaioZKV4iOtVQRER6QdKFgVAoxPLV3UHA7d4VBNyDJwjsVpSXh20Y7OyK0tjYmOhyRERkEEuqMBAMBlm+eh2tpge32zlogwB0bzXMy0wj5vCyvkJbDUVE5OglTRjoDgLraTU9eNxOxgwvweVyJbqsY5IXCOB0GLTFtdVQRESOXlKEga6uLpatXk+b5cHjcTF6CAQB6N5qWLBnq2G9thqKiMhRGfJhoKOjg2WrN9BuefB6XIweVjwkgsBuWXu2Grq11VBERI7KkA4DHR0drFi7kQ7bg8/rHjIjAvv65FbDrq6uRJckIiKDzJANA+3t7SxbU7YnCIwaVozT6Ux0WX0iNTWVDL+2GoqIyNEZkmGgra2N5aUb6TK8Qz4I7FaU373VcEdnhKampkSXIyIig8iQCwPdQaCcLnz4PW5GDysZ8kEA9p5qGHN4Wbdlm7YaiojIYRtSYaC1tZXlpeUEDR8pHhejhpXgcA6pSzyk/H22GlZv11ZDERE5PEPmm7KlpYUV6zbRZfhI8boZmWRBALq3GubnZHZvNayqJxaLJbokEREZBIbEt2V3ENhMl+Ej1etm5LDipAsCu2VnZeF1Owlqq6GIiBymQf+N2dzczIp1mwk6fKT5PN1BwDHoL+uoGYZBcV4A03CydUeLthqKiMinGtTfmk1NTaxcv2VPEBhRUpTUQWC31NRU0ndtNVy/uTLR5YiIyAA3aL85dzY2snJDdxBI93uTfkTgk4ryc8HhoKEjrFMNRUTkkAblt2ddfT3vl1UQcvjJ8HsZUVKEYRiJLmtA8Xg85KSn6FRDERH5VIMuDHz88Wo+2lRFyOEn0+9huILAQeXndm81bI0Z1NTWJrocEREZoAZVGFi9eg21HRHCTj9eh82wkmIFgUNwOp17txpuq9NWQxER6dGgCQM7duygvq2LsNOPy4ozdtQoBYHDsHurYRduNlduS3Q5IiIyAA2aMLCurJyw04/DNhkzeuRB+whYlkWwq0tz5Lvse6rh1h3NBIPBRJckIiIDzKAIA9u3bydkuDENJ5kpfjwezwGPKStdywML7uDEUQVMH13IiaMKeGDBHZSVrk1AxQNLWlpa91ZDw8uGzRWJLkdERAYYwx4E592+/e57NJMCwIQTjjvg/hef/hf33TUPV3oA3+RzcGcXEWupI1y6mHhHEw89+hgXXnZlf5c9oESjUTZV1eI2w8yeMJpAIJDokkREZIAYFGFg0ZJ36XRn4HPYjB07Zr/7ykrXctm5c/BPmEPO3AUYTtee+2wzTvPCRwhtWMrTi5YyfvKU/i59QKlr2EFzexcBV4zTT56mvgwiIgIMgmkC0zQxDSc2kJGRfsD9f37sUVzpgQOCAIDhdJEzdwHO9Bz+8tiv+6nigSs/N4BDWw1FROQTBnwY6OjowN61ayArM2u/+yzL4qVnn8I3+ZwDgsBuhtOFf/K5vPjskwyCQZA+5XQ6KdBWQxER+YQBHwZisRg2BgY2Tpdzv/vCoRDRcBh3dtEhX8OVVUg0HCYcCvVlqYNCdlYWXpeDLtxs0VZDERFhEIQBv9+PAxsbg9Anvsx9fj8en49YS90hXyPeWo/H58Pn9/dlqYOCYRgU7TrVsFJbDUVEhEEQBlJTUzHs7p4Bra2t+93ncDi44NLLCZcuxjbjPT7fNuOEShdx4aVXqEnRLmlpaaT5PNpqKCIiwCAIA4Zh4MLEsG06uw4c5r9p3l3EO5poXvjIAYHANuM0v/ILzI5mbpw3v79KHhSK8nOxDAd17WGampoSXY6IiCRQz6vuBpiMFB/BcJy44SQWjeH2uPfcN37yFB569DHuu2se9TWl+CefiyurkHhrPaHSRZgdzTz06GNJv63wk7xeL4GMVJrbbdZXVHFadra2GoqIJKlB0WcgHA6zZOVHdLnS8Bomxx93YOOhstK1/OWxX/Pis08SDYfx+HxceOkV3DhvvoLAQZimSfnWaox4lOmjCxheUpLokkREJAEGRRgAWL5iBTtjLmIOD7npKRQWFvT4OMuyCIdC+FNStEbgMDQ1t1DX1EomYc6cOR2Xa1AMFomISC8aNOPCJ8+Ygd8M4rRNmtq72LlzZ4+PczgcpKSmKggcppzs7q2Gnba2GoqIJKtBEwZcLhcnTZlESrwLBxY7WjvYtq0q6RsJHavuUw27txpWNDRpq6GISBIaNGEAICcnh2kTTyA13onTNumIWlRUVROLqpPesUhL37vVsGxLZaLLERGRfjaowgBAXl4ep82cQY4RxmcGCUfilG+rYWdjk0YJjsHurYa1bSGam5sTXY6IiPSjQbOAsCddXV2s21TBjs4oUYcHj8tJSX6A1NTURJc2KHWfathJntvktJOnad2FiEiSGNRhAMC2beobGthQWUOH5cI0nGSm+ijKz9PK+CO071bDk0YXMExbDUVEksKgDwO7xeNxyrdUUrmjhajDh+FwUBjIJDsrS79wj4C2GoqIJJ8hEwZ2a29vp7S8gsawRdzhxu9xUZyfi1+HFB0W27bZtLUaMxZlfH46444fm+iSRESkjw25MADdX2jV27ezYVsdIdxYhpNARioFubk4nINuzWS/6+joYFt9E34ryFkzpihIiYgMcUMyDOwWiUTYsLmCmuYuYk4vTodBcV4O6enpmjo4BNu22VZTSzAUZkRGd38HEREZuoZ0GNitqamJ0s1baYs7iBsu0nweigvy8Hg8iS5twIpEImyqqsVjRjht8liys7MTXZKIiPSRpAgD0H1mQcXWKjbV7iBieLEMBwXZGQRydFrfwdTWN9DS3kW+1+QzM7TVUERkqEqaMLBbMBhkXfkWGjojRB1ePC4nxXk5pKWlJbq0AScej1O+tRqnGeOkMYWUFBcnuiQREekDSRcGoHtOvGHHDtZXVO/pTZCR4qW4IF9b6T6hqamFumZtNRQRGcqSMgzstrs3wdYdLUR29SYoyMkkJ1u9CXbbd6vhhIIMTjhuTKJLEhGRXpbUYWC3T/Ym8HlclOTl4k/RljrQVkMRkaFOYWCX3b0Jynb1JjANJznpKRTk5eJ0OhNdXkLZts3W6u2EwhFGZrqZPnlioksSEZFepDDwCdFolLJNFVQ1dxJzenA6HBTlZpORkZHUUwfaaigiMnQpDBxEc3MzazdV7ulNkOp1U1KYn9S9CWrr6mnpCGqroYjIEKMwcAiWZbG1qprymh2EDQ+2w0leZhq5gZyk7E3QvdWwBqcZZcbYIoqLihJdkoiI9AKFgcMQCoVYV76F+o4wUYcXt9NBSV6AtPTk603Q2NRMfXMbWUaEOadM01ZDEZEhQGHgMNm2zY6dO1m3pSqpexPYtk15ZRVWPMbEwkyOHzs60SWJiMgxUhg4QvF4nM0VW6loaN7bmyA7k5yc5OlN0N7eTlVDMylWiLNOnoLP50t0SSIicgwUBo5SZ2cnazduoTFkEkuy3gT7bjUclelh2uQJiS5JRESOgcLAMbBtm5raWsq21hLc3ZsgzU9Bft6Q700QDofZXF2H14xw2pTjyMrKSnRJIiJylBQGekE0GqVscwXVTZ1Ed/cmCGSTkTm0exPs3mpY4LWYPePEIX2tIiJDmcJAL2ppaWHtpkpaY8ae3gTFBXl4vd5El9YntNVQRGRoUBjoZXt7EzQQNrzYDie5Gank5QaGZG+Cfbcanjlz+pCfHhERGYoUBvpIKBRi/aYt1LUP7d4ElmWxaWu1thqKiAxiCgN9aHdvgvUVVbSbu3oT+L0UFeThdrsTXV6v6d5q2LRrq+FUbTUUERlkFAb6QTweZ0vlNrbUN3X3JjAMCnKyhkxvAtu22VpVQygSZVSWh2mTtNVQRGQwURjoR5/sTeB1OynJzyUlJSXRpR2zUCjElpp6vGaY06Ycr62GIiKDiMJAP7Ntm9q6OtZXbt/Vm8BFTppvSPQm2F5XT6u2GoqIDDoKAwkSjUbZuLmCqqZOog4PTqeDwkAWmZmZg/ZLdN+thicfV0xRYWGiSxKRPhSJRHjggQdY/OZS2oNxYhYYhgOnYTFqWAF33n4zn/3sZynUZ8GApzCQYAf0JvC4KC7MH7S9CXY2NtHQ0k62I8KcU7TVUGQoam5u5oKLLmHrzhCmLxfTk4ltuGH39mnLxrBjGGYIR7SDQLqbicePYvqkEzhl+mSmTp1KYWHhoP3hMxQpDAwAlmWxrbqGjdX1e3oTBDJSyR+EvQksy2JTZTWWGWNSURbHjRmV6JJEpBc99NBD/Px3TxBNHYnpzQTbxmVFSPG6SE/zYzgcBEMRLJw4PSk0t3ViA4ZtYVgxDDOMI9pOTpqbiceP3C8gFBUVKSAkiMLAABIOh1lXvnlvbwKHg+L8HNLT0xNd2hHRVkORoenWW2/jxfc2EEsbBTjI9tvcfvut5OXmHfQ50ViUuro6qqpr2FZTz/a6nTS1dmJh7xMQIjhibWSnuJl4/AimTTx+T0AoKSlRQOgHCgMD0I6dO1m3Zdue3gTpfi/Fg6g3wb5bDcdkeZk6aXyiSxKRY/TXxx/n3h/9lljaaIx4iJuv+xITJhzdNuJYLLZPQKhle0MTjc3tWIBh2xhWdFdAaCc7xcn4sSOYNqk7IJw4dSrDhg1TQOhlCgMDlGmabK7YSkVDM2HDC4ZBQU4mgZzsQfEmCAVDbNnevdXw9KknkJmZmeiSROQoffTRR1x66zfocBXjJsL9X19AZkbvvqdjsRj19fW7AkId2+t30tjSjmkfGBAyfQ4mHDeC6ZOOZ8a0SZw4dSojRowYFJ+NA5XCwADX2dlJafkWdgb39iYozguQmpqa6NI+VU1tHW2dIQp9NqeeNFVvVJFBqLS0lItvvIdWZxEjigPcdsO1+P3+Hh9rWRaxaBi3x9cr651isRgNDfVsq9oVEBp20tjcgWlbGDa7AkIUR6ydDB+MHzN8vxGEkSNH6nPnMCkMDAK7exNsqNxOF25Mw0l2mp+CvFxcLleiyzuoeDxOeWU1TivKyceVaKuhyCBTXl7Ohdd9lUbyKSnI4c7bbsDrOXCnU3XFRhY9+1dWLl1IPBrB5fEyc85czr30eoaPGderNcXjMeobGqiurmHrrhGEnc3tmJaNgY1h7g0I6V6b8WNGMG3ScfsFhMG2MLs/KAwMIrFYjI2bK9jW2E7U4cWxqzdB1gDuTaCthiKD09atW/nCNXdQH8+lMD+b+bfdgN934IjAirde5g8/+xbOtAApU87FnV1ErKWO4NpFmJ1N3Pr1HzHrrC/0aa1xM05D/e6AUMv2+kZ2NLdhmjaGYYMZw7AiOKPtpHlsxo8dzrSJx5PihmHDSrj22mvxeDx9WuNApzAwCLW2trJ2UyUtUYgbLlI8LkoGaG+CvVsNo0wuzmbs6FGJLklEPkVNTQ0XXP0VqiNZ5OZk8tV5N5KScuDUZHXFRn5w91X4J5xJYO4CDOfekUrbjNO08BFCG5bwnV/8o9dHCD6NaZo0NDRQXVPD1uo6aup2sqO59RMBIYoz2oYz1k6GO8r3Hryfa665pl/rHCgUBgYpy7KoqtlOWVUdYcOLZTjIzUwjPxDA4RxYQ2BtbW1U72gmxQxyxkmTB8V6B5FkVV9fzwVX3U5lMJ3srEy+Ou8G0tN63t78x//5NqtWLaPo9sf2CwK72Wacut/NY+bMz3DzPT/o69I/lWma7NjRHRA2bdlGadkmYrYLDAOHGcYVrCXX1cWihS9SXFyc6HL7lcLAIBcOh1m/aQu1baE9vQmK8rJJT0/vt6kDy7IIh0L4/P4e5+Js22bL1iqisTjZBDnztNn9UpeIHJmmpia+8KVb2dzmIyOjOwgcbCeQZVnMv2wmqTOvIOu0g/+abn33b3StfJLfPLNqQE5ntra18sT/PcHW2kYsVwrOaCve9i385bcPc8455yS6vH4zsH5CyhHz+XycNGUSs8aNJMcRxTJjVDU0U7W9jlg01qd/u6x0LQ8suIMTRxUwfXQhJ44q4IEFd1BWuna/xxmGQU5mBpbhoMtyUllZ2ad1iciRa21t5dIvz2Nzm4/UtAzm3/rlQ24JjkXDxKMR3NlFh3xdV1Yh8WiEaCTc2yX3iqzMLObPn89/f//bDMvxYLrTCWdP5IY772XFihWJLq/fKAwMEXl5eZxxyjQmFGTgt4J0BsOUb6thZ2MTfTH48+LT/+Kyc+fw8sLF+E++nNyL7sV/8uW8vHAxl507hxef/td+j8/JycZpx4k5PGyt3t7r9YjI0evo6ODy67/C+kYX/tR05t96DTk5OYd8jtvjw+XxEmupO+Tj4q31uDxePN6B3YnU4XDw7wsWcN7p07ENN5GM47niy7cSi/Xtj6qBQmFgCHE6nZxw3BjmTJ9Ekd/GZUVpaGln89Yqurq6eu3vlJWu5b675uGfMIeC235L1mnXkDrxLLJOu4aC236Lf8Ic7rtr3gEjBH6vB9NwEsPRJwFFRI5cMBjkqhvv5ONaC09KOnfc9KVDthfezeFwMHPOXIJrF2Gb8R4fY5txgmsXMevMzw/IKYKenHfueZw+YwKWy084dRTnzf18okvqFwoDQ1Bqaiqzpk9lxthiMggTj8WorN1BTW0d8XjPb9oj8efHHsWVHiDnE6uHAQyni5y5C3Cm5/CXx3693335ed0fMHHDSUtLyzHXISLHJhwOc+0t81mxNYzbn8kd119BUeGhh/33de6l12N2NtG08JEDAoFtxml65ReYnU2cc8l1vV36MbEsi0g4iGVZPd5/ySWXkO6MEfcFKKtpo7m5uZ8r7H9aQDjE9dSboCAnk+ysrKNK6pZlceKoAvwnX/6pi4ZC7z/Fmm079vs768orcFtRTijI4IQTTjiqaxKRYxeNRrnu1rt4fV0zTl8mX7nhMkaNHHXEr/PJPgOurELirfX92mfgcB1Jc6SWlhZ+9PD/4ox1cP3nTuB/fvbTBFXdPwZu+zrpFW63m8kTxjGstZXSTZU0R01qG1tpbe88qt4E4VCIaDhMxmEsGoqGw4RDIfwpKXtuN7DBMHplhEJEjk48Hue2u77GG6WNOHxZ3HbtxUcVBABmnfUFikeMZfFzj7NiyZN7vmRnnfl5zrnkun7vL3Aw+4aW1JlX7GmOtGrVIpa/+eIBoSU7O5uSvHS27zQoq6xPYOX9QyMDSWR3b4KN1fWE8GAZDgIZqRTk5h52bwKNDIgMbpZlceeCe3nq3Qrw5XDzly5g/Pje+cLefTaBx+sfUGsEjrY5UmNjI//9yz/hDVbx8eK/UTiEW6przUAScTgcjBoxnDNnTGFkphuPFaGpvYvyrVW0t7cf1qI+h8PBBZdeTrh08SEXDYXWLuLCS6/Y7wMhGAxiGwYOTHJzc3vtukTk8Ni2zT33PchT72zB8mZx3WXn91oQgO7PB68vZUAFAYBFz/4VZ1rggCAA3eucAnMX4EwLsPi5x/e7Lzc3lxHFAWLeXB7/2z/7s+R+pzCQhHw+H9MnT+TU8aPIcUSxd/Um2FZTe1i9CW6adxfxjiaaD7JoqPHlnxNt28nUk07e774dO3cC4LJNsrOze++CRORT2bbNN7/zfZ5YXIrlzeGai89hyuRJiS6rz1mWxcqlC0mZcm6PXRKhOxCkTDmXFUteOeBH0ewZU7FcKfzfM68ddMHhUKAwkMRyc3M545RpTCzMwm8F6QpFDqs3wfjJU3jo0ccIbVhK/e/n0fru3+hc9yat7/6N+t/NI7hhCWDzg29+nX/8f3/c87xQJIrTNnFjDbhfDiJD3Q/+6yf84YVVxL0BrrjgTE6aPi3RJfWLY22OdOKJU/G6XNS0Wbz33nt9WWpCKQwkOafTyfFjRzNn+iSKUzjs3gQXXnYlTy9ayoVzzyP0/lM0vfgzQu8/xYWfP48nF77JxVdcjWmafPfeu/nx9x5k+/ZaTMOF24oyanhJP16hiPz04Uf45T/eIu7L5ZLzPsOsU07+9CcNEcfaHMnj9jBlwmhMTxZ/fOKpviw1obSAUPawbZv6hgbWV1TTabsxDSdZqT4K8/NwuQ6+8WT32QT+lL1zhbZt8+jPfswvH/ohALPmnM3XvvufBFxxPnfmGf1yPSICv/7f3/G9Xz9NzF/ABWedwmfPOjPRJfW7Yz1Qqaammp///u+khqspXfI0WVlZ/VB1/9LIgOxhGAZFhYXMOWUaxwVS8Joh2jpDbNpWQ3NLy0GnDhwOBympqfsN/RuGwb/d+wA//tVjuNxuVix9g+/8260UBLRWQKS//OFP/x/fe/RJYv4CzjltelIGATj25kglw4aRn51OyJnNv556pj9K7ncaGZCDamtro3RTBU0RiBsufC4HgayMw17819raSt2ORkrXrOahb95Ne1sbI0aM4KWXXmLy5Ml9XL1Icnvi7//k33/4O2IpJZx5yiQuvGAuBsm7VudYmyMtffsdXlj8HpMCId5+5V8HfdxgpTAgh2RZFtXbt1O2rY6Q4cUyHLisGHm5AQKBQI/P6ezspLaunhgOsMFnhYg2N3Dffd+gvLyc9PR0/vWvf3H++ef389WIJIdnnn2eO7/7SyL+EmZPO4HLLr0oqYPAbtUVG3c1R3rliJsjBUNBvv+T32B0buf1J37GlClT+qnq/qEwIIelq6uLVR+todN2E3N4uvsF2BYObHbPDti2jY2BaTgxAJcVw2eGOG5EMaNHj6a5uZnLLruMJUuW4HQ6+dWvfsUdd9yR0OsSGWpeWfgqt9z3U8L+EmZMGsPVV35RQeATjrY50p8f/wfrN27ihrOP4+GH/rMPK+x/WjMghyU1NZWzTp/NyCwf6fF2fGYQBxYWBnHbQdx2YO365+QzQ6TF2sn3xDlz9imMHj0agJycHF577TVuuOEGTNPkzjvv5N5778U0zURemsiQ8eZbS7jt/p8S9hdz4rjhXHX5pQoCPTja5kifmTUdy+nj+deXEw6HP/0Jg4hGBuSo7Ny5k63bthEMhYlb3ecNOA0Dv9dNUWEhw4YNw+HoOWvats0Pf/hDvvOd7wBw6aWX8vjjj5OamtqflyAypLy3bBlX3fldOr3FTBxTwo3XXYXT4Ux0WUOKbVv8588epbO5gd88eD1XXnF5okvqNQoDkjB/+9vfuPnmm4lEIsyYMYMXXniBoqLDPz5VRLq9//4HXD7vfjpcxRw/spBbbrwW10G67cmxWbjodV5/531mj3Tw0r/+kuhyeo2mCSRhrrnmGl5//XVyc3P54IMPmDVrFmvWrEl0WSKDytq1a/nSVx6gw1XE6GF53Hz9NQoCfejUmTPAcLBqQzVbt25NdDm9RmFAEuq0005j+fLljBs3jurqak4//XQWLlyY6LJEBoWNGzdy+a330uosZFhhLrfd+GXcbneiyxrSsjKzGDu8ANOXx5//7x+JLqfXKAxIwo0dO5Zly5Zx1lln0dHRwYUXXshvfvObRJclMqBVVlZy6Y1302jnUZSXzVdu/jIejyfRZSWF2TOnYTl9/POFN4nHez69dbBRGJABITs7m1dffZUbb7wR0zSZP38+X//617XTQKQH1dXVXHL9v9FgBsgLZHLHrdfh8/k+/YnSKyZNnEiK183OsJs33nwz0eX0CoUBGTA8Hg9/+tOf+M//7N6/+z//8z9cfvnlhzwwSSTZ1NfXc8mX76QmkklOdgbzb72eFH9KostKKi6ni+mTjsN0Z/DH/3s60eX0CoUBGVAMw+DBBx/kb3/7G16vl+eee44zzzyT2traRJcmknCNjY1c8uU72BpMJzM9g/m3XkdaWlqiy0pKn5l1CrbDzZL3y9ixY0eiyzlmCgMyIF199dW88cYb2mkgsktrayuXfvkrbG7zkZ6ezvzbriUzIzPRZSWtgoICSvKziHoDPPGPJxNdzjFTGJAB6zOf+cyenQY1NTWcdtppvPLKK4kuS6Tftbe3c9mX57GhyYU/NZ35t1xLTnZOostKerNnTMVypfJ/z7x60FNdBwuFARnQdu80+OxnP0tnZycXXnghv/71rxNdlki/CQaDXHnjHayuB29KBvNvvprc3NxElyXA9GlTcTudbG2MsmLFikSXc0wUBmTAy87OZuHChdx8881YlsVdd93FPffco50GMuSFw2GuvulO3t8Wxe1P5ys3XE5BQUGiy5JdvF4fk8eNxPRm86cnnkp0OcdEYUAGBY/Hwx/+8Ad+9KMfAfDzn/+cyy67jM7OzgRXJtI3otEoN9z+Vd7d3InTn8m86y5jWMmwRJcln3D6qSdjO9y8svQDOjo6El3OUVMYkEHDMAy++c1v8ve//x2v18vzzz/PnDlztNNAhpx4PM6t8+/hjdImHL4Mbrv2YkaOHJnosqQHI0aMIJCZStCRxdPPPJfoco6awoAMOldddRVvvvkmeXl5fPTRR8yaNYvVq1cnuiyRXmGaJvPvvo9XPqgFXyY3X3UhY8eMTXRZchAGBqeeNAnLlcaf//lioss5agoDMijNnj2b5cuXM378eGpqajj99NN5+eWXE12WyDGxbZt//8aDPP3uFmxvFtdfPpdxJ4xLdFnyKU6ZMQPD4WDdtibKysoSXc5RURiQQWvMmDEsW7aMs88+m87OTi666CJ+9atfJboskaNi2zYPfPs/+Psb67B82VxzyeeYPGlSosuSw5CWlsa40SWY3gB//OvgPLxIYUAGtaysLF555RVuueUWLMviq1/9Knfffbd2GsigYts23/vP/+aPL75P3BvgygvOYvq0aYkuS47AaTOnYzl9PPPqO0QikUSXc8QUBmTQ83g8/P73v+e//uu/AHjkkUe49NJLtdNABo2f/M8j/PrJd4j7crn0vNOYefLJiS5JjtAJJ5xAut9DSzyFl18ZfMewKwzIkGAYBg888AD//Oc/8fl8vPjii8yZM4ft27cnujSRQ3rk0f/lp39ZSNyXx4Vnz+L0z8xOdElyFBwOByefOB7LncGf/z74dhUoDMiQcuWVV/Lmm2+Sn5+/Z6fBxx9/nOiyRHr0+z/+hf/832eI+Qs47/STOGvOGYkuSY7B7Jkng8PB8tKtVFdXJ7qcI2LYg72hskgPKisrueCCC9iwYQOpqan8/e9/58ILLzzkc1atWsW7775HQ2Mz0biJ0+kgI9XPzJNnMHv2bNLT0/upekkG//e3f3LPj35PLKWYs2ZO4cIvnJ/okqQXPPrYn9lWVcXXvjSLB+//eqLLOWwKAzJktba2csUVV/D666/jcDh4+OGHWbBgwX6PCQaDPPqb31BR30rElUbEnY7pcGHjwMDGsC2cVhRPPEia10lBTibFedkML8xjWFEBBQUFZGVlYRhGgq5SBqOnn3mOO//fo0T9xZw2fRyXXnIhBvo3NBR8+PFHPPHsYoa7dvLR0hdwOp2JLumwKAzIkBaLxZg/fz6///3vAfjqV7/Kww8/jNPp5IUXXuDlpSvp8OURcaUDBg47hhMLpwGWbWPhBKeLuL33g9qwTBy2idOK4jZDpDht8rPTKcrNZnhBLsOLu0NCIBAYNB8E0n9eenkht97/MyIpJcycPJYrr7hUQWAIicVi/MdDvyLeUc8/f/ENPnvWWYku6bAoDMiQZ9s2P/nJT7j//vsBuOCCCzj9jDlsajXp8OZjGw5SjSinzJjOiBEjenyNeNyko6ODtrY2mts6aO3ooq0zSGcogrXrMQ7bwmHHcVpxXGYILzHys9IpyMlkWEGA4UX5FBcVkZeXh9vt7qerl4Hk9Tfe5IZ7fkTQV8yJ40dy3VVXYBhaujXUPPnM86z4aB0XTMvhr7/7ZaLLOSwKA5I0nnrqKa677jrC4TDZ+UWcet03yEzzc/rMGYwYMfyoXtOybDo7O2lra6OlrYOWjk5aO4J0BsPEbZvu0YbukQSHFcdlhvFYEXIyUijMyaQkP4cRxfkUFxZSUFCAz+fr3YuWAeOdd9/j6vnfpctXwqSxJdzw5atwOjRyNBTV1dXys98+QUpwG2veepJAIJDokj6VwoAkld/85jd87d5vEA524U/P5D9+83+Mnzqj1/+ObdsEgyHa29tpaW2jub2D1s4QHcEQsdiusQTDxmGZOOw4LjOC2wyRmeLdExKGF+ZRsmtdQlpamtYlDGKrVr3P5fO+Sae7iONHFXHLDdfgcroSXZb0oZ/+6jF21NXyg6+cz/yv3J7ocj6VwoAkDdM0+er936Uqns7bTzxC+846vD4/33jof5l51nn9UoNtQyQSob29jZa2dlraOmjtCNIeDBGKxgEw6F6X4LTju9YlhElzGxTkZFCcl82wwjyG77N40eHQMPNAtmbNGi65+eu0OYsYPSyP22+6TtNEg5xlWcSiYdwe30Hff+++t4xnX32bEZ6dfLj0pQH/PlUYkKTxpz/9mTe3tBDyZDNtdAFP/ua/+XjZUgzD4NZv/AcXffm2Pb++LcsiGg7j8R38zd7botEYHR3ttLa10dzWuWtdQohgJMquGYddIwkmTiuG2wzhd1rkZ6VTlJvFsIJchhflU1hYSG5urhYvDgBlZWVcdP3dNBn5jCjK5Su3XI/H40l0WXKUqis2sujZv7Jy6ULi0Qguj5eZc+Zy7qXXM3zM/gdKBYNdfPfHv8Id2snXvnwWDzzwQIKqPjwKA5I0vnrft2lIGY2HGFddfinxWIzf/te3ePXJxwG44Jpb+NwlV/HiE3/g7VefJxYJ4/b6OOP8i7nk+nmMHpeYQ2PicZPOzr2LF1vau0NCVziMZYO937qEGG4zjJcYgYzU7pCQH2B4UR5FhYXk5+fry6ifVFRUcMG182kw8yjOz+bO227QmpBBbMVbL/OHn30LZ1qAlCnn4s4uItZSR3DtIszOJm79+o+YddYX9nvOt777feK2g+yuDWzeMLCPWVcYkKTQ3t7O13/0S1pShjFxWA6nnHIK0D23/+xf/pc//c/3ux9oGHgy8/FPPmfPmz1Uuph4RxP3/PARzvzCFxN4FfuzLJuurn0WL7Z30doZpKMrtGvxIhi2tWskIY7LiuC2IuSkeikMZHWvSyjK27N4MSUlJcFXNHRUVVVxwTV3sD2aTX5uDnfdfj0pfv33HayqKzbyg7uvwj/hTAJzF2Dss97DNuM0LXyE0IYlfOcX/9hvhOCRX/2SqsYw/pZSass/SETph00rWCQpLF68mIjTj8M2mT79pD23G4bBF2+6Ewz4089+QOrEswh8/u793uyZp15J08JHePjBBYwYe0LCRgg+yeEwSE9PJz09nWHD9t5u2zah0O7Fi+3dixc7gnR0hQnFTdpN2LoDHPU7cKyuw2Wtwh0PkeFzURDIpDgvh5FF+ZQUFZCfn09GRoYWLx6Buro6LrluPtujWQSyM7jz1i8rCAxyi579K860wAFBAMBwugjMXUBddSmLn3ucm+/5wZ77PjN7NlUvvInl9NHS0kJ2dnZ/l37YFAYkKVRVVWE6fRi2ict14Fz6tk1luDPzDggCsPfNXl9dyvOP/467f/Dzfqr66BiGQUpKCikpKRQWFu53XyQSoa2tnda2dlrau/sltHeFaY/GaAe2N8NHjS041jfitD7CY4ZJcbFr8WIOIwpzKSnMp6CggJycnAG/KKq/7dy5k4u/fAfbgulkZaZz563XkZaaluiy5BhYlsXKpQtJnXnFAZ8NuxlOFylTzmXFkie56d+/vyc8T5w4EZ5/E9twsWbNGs4888z+LP2IKAxIUghHIliGD8O2DrjPsizefvV5Uk65/JBvdv+Uc1m68CkWfP/hQftL2ev1kp+fR35+3n63x2Jx2tvbu6cc2jto6QjS1hmkKxylw4aGdihtbcdR3oLTWo/bDONzmORnpVGUm82wggDDCvMoKioiNzcXlyv5PlpaWlq45MvzqGj3k56RwfxbryMzIzPRZckxikXDxKMR3NlFh3ycK6uQeDRCNBLG6/MDYFu7Z+EH/mx88r1jJSl53G4M28bq4ZdsNBzuXix4GG/2WCRMNBzCO8SGfd1uF4FADoFAzn63m6ZJR0fn3pDQ3rmn82KnbdAUtCnbFsKxdRsOa0t350U7Sm5GKoW5WZTkBxixz+JFr9eboCvsW+3t7XzxunlsbPbgT0vnrluuGdBDwnL43B4fLo+XWEvdIR8Xb63H5fHi8e5dJFq6rhQMMOw406dP7+tSj4nCgCSFwsJCXM07iDvTsW17v1/2Hp8Pt9d3WG92t9eHZ1fqTwZOp5OsrEyysjIZuc/ttm3T2dnVvS6hrZ2W9k5aO7vo6IoQtCxaorB5exxHzXYcdhVuM4zLDJOT6qMgsKvzYmEexUXdixdTU1MTdo3HqquriytuuIO19Qa+1HTuuvlqAoHcRJclvcThcDBzzlxWrVpE5qlX9jh6aJtxgmsXMevMz+/32bJs+fLu1zDDZGRk9FvNR0NhQJLC5z73Od5Y+weCnmwqKioZO3bMnvscDgdnnH8x7yxdfMg3e2jtIubMvWTQThH0JsMwSE9PIz09jZKS4j232zZ7Fi+2trfvOcehfffiRQu27QRHw04ca+pxWe/jjodI97l6PBEyMzNzQP/3DofDXHPzfD6ojuL2Z3LHjVeSn1+Q6LKkl5176fUsf/NFmhY+0vNugld+gdnZxDmXXLff8+p3tuLASZr7wOnJgUZhQJJCQUEBqUacNtuktr5hvzAAcMn183jrpacP+WaPdzZz8XUDv61oIhkGpKT4SUnxU1i4/5diJBLtXpfQ3k5Tawdtnd39EjqiMTowqG2x+bipFceGJpzWGjxmCL/TpiAno8cTIRO9eDESiXDdrXfx7uZOXP4svnL95RQXlyS0Jukbw8eM49av/4g//Oxb1FWXkjLl3O41Aq31+/UZ2Hdb4drStcSdftzBer70xQsTWP3hUZ8BSRqvLXqdP79dTmpmDhefd+Cq3iUvP8PDDy7AlZaDf583e2jtIuKdzQOuz8BQEY/vXrzYvmtdQteuxYux7hMhbRsHe0+EdMdDeI04ebsWL3b3S8jfsy6hPxYvxmIxbr7jbhZ+WI/hz2Tel7/ImDFjPv2JMqhVV2xk8XOPs2LJK3s6EM468/Occ8l1B3Qg/NFPHqalI0Rq23q2lX2Y8PD6aRQGJGl0dXVx948epdWbz+Xnnk5a2oFbvio3ruP5x3/H0oXP7elAOGfuJVx83e0Dpr9AsjBNa1fnxe6Q0NzWSXtnkI5wBNOyu89w2NVUybHr2GiPFSWQmUrRrn4Juxcv9uaJkKZpMu/fvs5zy7dh+LK4+ZqLGHf8Cb3y2jI47D6bwOP19ziNtWnTJn77f8/h6armN9+/i8suuywBVR4ZhQFJKg89+gdWNTo4afxoJk8cf9DH7T6bwOvv+c0uiWPbNl1dXbS3d9Dc2r14sa2ri46uMFHTAoxdISGOwzb3nAiZleqlMDuD4vwAI3Y1Vdp9IuThsiyLBV//Jn9/swzbl8ONV3yeSZMm9t3FyqBjmiYPPfJbWpp2csv5E/nJj/4j0SUdFoUBSSpL33mP/31tDWnZ2Vx0zsBtACJHzrYhHA7R3t5BS1v34sX2zi7aukKEYyZgYLD32OjuEyGDpHuc5Gdn7Dk2etg+J0LuGwRt2+a+B7/Hn17+CMuXw5cvPY9pJ05N3AXLgPTW0rd58Y3l5Nn1rHztH2RlZSW6pMOiBYSSVKafOAXfy+/Q3OGjqytIaurQ6heQzAwD/H4/fr+fgoL8/e6LRqO0t3fsORGyrbOTts4QnZF0OoG6NljT0oajrBmnVYrbDJLitMnLzqB412FPb7/9Nk+9sRbLl8NVF35WQUAO0NHZwWtvr8IVaeHBr98waIIAaGRAktB//+r3fNDs5OTxY5k4QXO9ySweN+no2HsiZPex0d1NlXZvBnPYexcvuswQLitKisdLSoofv9ePFenAn5ZNzojJSdl5UfZ64h9P8tG6zUzNj/L6838bVMeI61+uJJ1ZU8ez+vVSKmsbFAaSnMvlJDs7i+zsLEbtc7tl2XR2dnde/Gh1KVU7gnj9frzeHGzDoA0DR9jEEYrhsFx42hrwVm3Bb0cZdeJnSc8pPNiflCFq27ZtfLhhK+5wAz/7/n8PqiAACgOShE46cQr+hctoavMRDIZISUmejoJyeBwOg4yMdFavWcuSD8oxPRlMOi6fMcePw4xHiIeDRCIhQl0dhMNddHlz6DICuOJhutYuJ8tpcvzsSwfdF4IcHdu2ePKFhTjMEJefPY0ZM2YkuqQjNrA3Por0gczMTMYUZIJhU1VTk+hyZIB69bXFPPv6KkxPBuPGDGPChPFgGDjdPrzpOWTkllAwcjwjx81g+MgTSDXiWA4nrSnDqDeyKH3r70QjwURfhvSD5StXUdfYQYbdxPe/fV+iyzkqCgOSlE6dOg6XGaWypj7RpcgA9Jvf/JbXlpViejI5bkQhUyZNOOTj3V4/BcedxIixJ+I1I4Q8WTSlDGPd208Tj0f7qWpJhGAoyMuvL8MZbeUbt19FXl7epz9pAFIYkKQ0Y9pUfLF2drYFCYXCiS5HBpCXXnqJLfUdmJ4sUlw206ZOAQ6v14TD5aJk/CmkO00irlRaU0ooe+fpvi1YEurlhYsIRyIcFzC4/dabEl3OUVMYkKSUnZ3N6Px0wKaqZnuiy5EBIhyOsGTZh5jebAwzwvnnndO9Z/EI5Y+Zhs+KEHZn0OZIY0fFR31QrSRafX09K9ZswhXawUP/72u43e5El3TUFAYkaZ06ZRwuM6KpAtnjj3/4I6YnGxuDz8w6+ZALAG3LIhoOYVs9n0hXfPwM3GaILm+A7ZUb+qpkSRAbm3899zJGPMx5M49jzhlnJLqkY6LdBJK0ZkybyhOvv8+OVi+RSASv15vokiTBttY1YqWU4HGYFBUV9fiYHdvKef+VJ9iw7DXMWASn28uE2edx8uevJX/k3q2qhsNBekYOzV0hQu502ndUkZE/or8uRfrYxx+tZltdM2nxnfz3f/w00eUcM40MSNIKBAKMDKQCUK2pgqRXXl6O5fRh42DKxJ4XDK5/byF/efA6Nq5eQdqsK8i96F7SZl3BxtUr+MuD17H+vYX7PT67+DicVpSQO5P6zav64zKkH0SjUZ5/bSnOaDv/dt1FDBs2LNElHTONDEhSmzX5BDa+V8GW6nqOG6sjaJPZO++8g+1KwbBNRvdwHPGObeW89OvvkjLxTAJzF2A49358Zp56JU0LH+GlX3+X3JIx+40QuOw4cYeXYJd2FQwVry1+k85gmJHpUe7+tzsSXU6v0MiAJLVTTjoRX6yDHS3tRCL6sE5mO3Y2YTncGJg93v/+K0/gSg8cEAQADKeLwNwFuNIDvL/wif3uczqdWA4ncX3cDglNTY28/X4pzkgjP/zmv/Xa0diJpn+dktTy8vIYnu3DsqFmuxoQJbNYfPfJhgeyLYsNy14jZcq5BwSB3Qyni5Qp57LhvdfY98gXl9OFDdg6CntIePK5l7HiEU6fWMjn556f6HJ6jcKAJL2Zk4/HZUWp0K6CpOZ0GkDP57bFohHMWAR3ds+LCndzZRVixiLEo3t7V1iWiQEYOhNu0Fu/YT2bqnbgjTTwkx98a78jrgc7hQFJejN3TRXUN3UQjcYSXY4kSFZ6OoZlYvUwNuD2eHG6vcRa6g75GvHWepxuLy7P3qHjeDyOYZk46HkLogwO8XiMZ15+A0esk9suP5vjjjsu0SX1KoUBSXoFBQWUZHmxsNleq10FyWr6SdMxzBC24aK5uXm/+wyHgwmzzyO4dhG2Ge/x+bYZJ7h2ERM+c95+vxjjOHHacfw63nhQe/Ott2npCFHg7eT+r9+d6HJ6ncKACHDKxLG4rChbqjVVkKxOPfVUnGYIA1i16sBtgCd//lriHU00LXzkgEBgm3GaXvkF8Y4mTp577Z7bgy0NmA4P3lg7gZLj+/oSpI+0tbXxxrKPcIWb+N7XbictLS3RJfU6RVURuqcKnlm2nvomL7FYHLdbb41kYxgGmX4nTWaEzrCbUDiE37f3eOv8kSdwwfzv89Kvv0u0upSUKefiyiok3lpPcO0i4h1NXDD/+/ttK2yq34bh9JASayNvzNxEXJb0gmdeXEg8FuWU0ZlcecVliS6nT2hkQAQoKiqiKM2NZWuqIJndestNOKMt2A4Hixa9fsD9Ez8zlxt/+Djjps2ic8WTNL34MzpXPMm4abO48YePM/Eze7/wm6rKiLr8+KNt5GTlDKnFZslkS8UWSjdV4w7X89MfPDBk/z8atq0lriIATz3/Mv/6cDtFBfmcffqsRJcjCfLLXz3K1iYT05NBpt/Bueec0+PjbMsiFo3g9voO+IIItTdSX1+D04oS6NrGtLOvHbJfIkOZaZn89JHHaGrcyQ2fO56HH/phokvqMxoZENll1klT8cY6qW1qJR7veZGYDH1f/be7SLFacca7aAtZvPTSy1g9HEZkOBx4fP4DvuTNWJiGhu04bJOsYC3jTpmrIDBIvbtsOTtbu8gxWvjuN+9NdDl9SmFAZJeSkhIKUh2YFmyvPfQWMhnavv2t+/HFmnDGOghZLp554WVWLF8BnzKQasaj1FZvAcskJ9bIpJPOJiUj0E9VS2/q7Ork1bdW4ow0881/u57s7OxEl9SnNE0gso9/PvsiT39cR0lhAWedNjPR5UgCmabJT3/2MDu7rO5jjR1uDCuO22lTUlTIqFEjSc/IwOP2AGDFY9RWlROLRck1m5l60hzcvtQEX4Ucrb/982k+LN3E5Nwwb77490MeZz0UaMm0yD5OPWkqL76/ie07PcTjJi7X0P4AkINzOp3cf9+9rFy5kudeXEjE8GG50ojhYev2RrZub8I2wOt2kpHmZ1jAh8PpICu6k+Mnz1QQGMSqq6v4YH0F7nADD33vB0M+CIDCgMh+hg8fTr7PYKtlU19fNySOJpVjM3PmTGbOnMm2bVW88MILtHW24ktJpysco70rjBn3kVeYguF04u+oYdGqCv61eAPpKV7yAlkU5edQUpRPYWEhBfn5eL1D42CbgcyyLGLRMG6PD4fjyGbDbdviyedfxWGGuWTOZE6dlRyLiTVNIPIJf3vqOZ5du4MRxYXMmX1KosuRASwYDPL628toCUbJCNXTVlNJ2ZZqdrZ2YbnTsZwp2E43OFzYGGDbZKT5u0NCXoCSonyKCgvIzy/A4/Ek+nIGveqKjSx69q+sXLqQeDSCy+Nl5py5nHvp9QwfM+6wXmPlqvf550tvkRGtYcUrj1NYWNjHVQ8MGhkQ+YRTT5rKKx89R83OFkzTwunUOls5kGXZrPhwNc1dMQLxJu67/SrGjhkDdHes27RpE+s2lLF2w2bKNm9jS1UtzZ1hgpF0KtuaqdhavSckGLA3JOQHKCnMp6iwkPz8fNxud2IvdJBY8dbL/OFn38KZFiB15hW4s4uItdSxatUilr/5Ird+/UfMOusLh3yNUDjEi4vfxRlt455bLkuaIAAaGRA5gGVZ3PvDX1Bl53DOzCmUlBQnuiQZYGzb5u3lK6msbyUr2si911/I+HGf/suztbWVjRs3sn7DRko3bqFscxVbtm2npSuK5U7DcvqxHW5wuLG7xxLITEshPy+borxchhXlU1hYQG5unkLCPqorNvKDu6/CP+FMAnMX7HfMtG3GaVr4CKENS/jOL/5xyBGCp59/kWUfrGdsWhvvLvxXUo3WaGRA5BMcDgcnjR/F9nVNVFTXKgzIfmwblq/6kMr6VjIijXz1qvMOKwgAZGVlMWvWLGZ9Yh66qamJ8vJy1m3YSGnZFsq2bKOiqo62YJzOSBrtrc1s2rINjF0jCQZkZ6SQF8imuCCXksJ8CosKyc3NxeVMvo/1Rc/+FWda4IAgAGA4XQTmLqCuupTFzz3Ozff8oMfXaGhoYPlHZbhCO/jxjx9IqiAACgMiPZp90lReXf0iNTuaNVUge9g2vP/Rasq3N5IWaeLOyz7LiVOnHPPrBgIBZs+ezezZs/f5WzaNjY2Ul5dTur5sV0iooqK6jo6wTXskndbmJsq3bMM2uj/KnQ7IykglP5BNUUFu98LFgu6QMFRXxFuWxcqlC0mdecUBQWA3w+kiZcq5rFjyJDf9+/cPaAJlY/Pkcy9DPMznTh7N2Z89q+8LH2AUBkR6MHr0aALuODWmzY4dDRQVFSW6JBkA1pSuY/22elIjTdx24Wc4ZcZJffa3DMMgLy+PvLw8TjvttD2327ZNQ0NDd0jYNZJQXlFNZXU9HVGb1nA6Lc1NlG3eiu3YFRIMg+yMVPLzsikuyOseSSgsJCeQg9MxuENCLBomHo3gzj70e9SVVUg8GiEaCePd5wAqgDVr1lJZ20RqbCf//b0f92W5A5bCgEgPuqcKRlO3oZmK6lqFAWHdho18vLmGlGgL1597MqfPPjUhdRiGQWFhIYWFhcyZM2fP7bZtU1dXt2skYSOlGysor6iisqaBrphBSySN5uZGNpRX7g0JDoNAZhr5udkUFeTt2t1QSHZ2zhFvyUsUt8eHy+Ml1nLorqHx1npcHi+eT2ztjMaiPPfqEpyxdu689guMHDmyL8sdsBQGRA7i1OmTea10IdX1zViWjcOh/vLJamP5Ft4v24o/2spVp0/inLPmfPqT+plhGBQXF1NcXMxZZ52153bLsqitraW8vJw168pYt7GC8spqttbsIGQ6aQqn0di4k3UbK/YLCbnZ6RTsWpNQXFxIQUEBOdnZGMbACgkOh4OZc+ayatUiMk+9ssepAtuME1y7iFlnfv6AKYLFr79FR2eI4SkRvrZgfn+VPeAoDIgcxNixY8lxRqk1LXbs2EFhYUGiS5IEqNi6leXrN+OLtXPpKcdxwdxzE13SEXE4HAwbNoxhw4Zx9tln77ndsiyqq6spLy9n7fqNrNtYwaatNVTW7CBiuWgMp7Nzxw7WllVg75pKcDsNAtkZFObmUFSYS0lRIQX5BWRlZ+3aIJkY5156PcvffJGmhY/0vJvglV9gdjZxziXX7fe8puYmlq5cizPSyA++Mx+/3//Jl04a2loocgh/euJfLCxvZ+yIImaf0nfzwzIwVVXX8Nb76/HG2vn8lGKuvfKLQ/4EQtM0qa6upqysjLUbyllfXkl5RQ1VtTuJ4MZypWE7vdiGqzsk2OBxOwhkZVKYl01xYS7FRd0jCZmZmf0WEvbtM5Ay5dzuNQKt9QTXLsLsbOqxz8B//PDHdEZMZo908uK//r8h///2UBQGRA5hw4YN/PCJRZCSzZcuOCepPyySzfbaOt5YuRZ3rIPPjcvlpmuuHDTz6H0hHo+zbds2Nm7cyNoNm1i3cQvllTXU1DcRxYflSsV2erANN7bDgWGDx+0kNyeDgtwcigvzKCkqIL+ggIyMjD4JCdUVG1n83OOsWPLKng6Es878POdcct0B/QUee+x3lNe24encxl9+dj9z587t9XoGE4UBkUMwTZN///7D1Dnz+MLpJ5GXl5fokqQf7Nixg9eWfYwz2snpo9L5yo3XDtmteccqFotRWVlJ2caNlG7Y1D2SUFlDTUMTcYcf05XW3UTJ4cbetd7A53YSyMmkMC+HYYV5FO0aSUhLS+uVkLD7bAKP199jgF+1ahX/fOF1DDNEILKZ8nWrj/lvDnYKAyKf4veP/5PXNndwwqgSZs2YluhypI81NTWx8J0PcESDzCrxctet1+NyaXnVkYpGo1RWVrKhrIy16zexflMlm7dup6ahmbjTj9VDSPB7XOQGMinMDVBSmEfxrpGEtNS0Xqtr2fJlPP3SGwD42spY9OzjTJo0qddef7BSGBD5FGtLS/nxP97CSM3iyi98TlMFQ1hLSysL31mFHQkyPc/Bv8+7Mek60fW1cDhMRUUFZRs37goJW9lUWUPtzlZMVyqWK7X7zIZ9QkKK101eThaF+TkUF+R1r0koLCDFn3LYf9c0TR755S/Z3hLGYcXxtG/moe/czfXXX99XlzqoKAyIfIp4PM7d33+YBlc+F5xxMrm5gUSXJH2go6ODl95agRkJMjnb5N47bsbn03HD/SUUCrF582bKyrrXJKzftJXN22qpa2zFcqV1r0nYdW4DhoENpPq6Q0JBfoDhhfmkpPopKioiL7d7Os+0TJYtW8bSpW/TEjSxnT6c0VY8HZX88sff5fLLL0/sRQ8gCgMih+G3f/kbr1cGGTd6GDNPOjHR5Ugv6+oK8vJb7xENhxiXFuX++TeTknL4vzql7wSDQTZt2sSGXSFhw+ZtbN66nYbmjn1Cgqs7JNAdEgzbBOzukQXDgWHbGPEu3KE68n1RXn/tFa3/+QSFAZHDsHrNGh7619s4UzO54gvnoJmCoSMUCvHKW+8RDIYY6wvyzbtuJj09PdFlyafo7OzcJyRsZsPmraz6eB1x3NhOP7bhwLCiOMwwjngXJTl+Hvn5/+x3/oPspVUxIodhwvjxZPIqO6JpNDc3EwjkJLok6QWRSIRXlyynKxhmpLuT++64SUFgkEhLS2P69OlMnz59z222bbNy5UrefvttWltbGTZsGF/84hcpKFDDsE+jkQGRw/TrPz3BW9tCTBgzjJOna6pgsItGY7y65F1aO4KUONr49vwbCAS0HkSSU/J20BA5QqdOm4DbDLOtrhFF6MEtHo/z+tvLaOkIUWC38MC8axUEJKkpDIgcpkkTJ5Jud9EZidPa2procuQomabJG+8sZ2d7F7lmE/fd+iUNI0vSUxgQOUxer5dJo4tw2CaVVdWJLkeOgmXZLHlvJfXNneTEmvjGzZczfPjwRJclknAKAyJHYPa0ibjNMFtrd2qqYJCxbZt3VqykurGdzFgjX7v+YsaMHp3oskQGBIUBkSMwedIkUq1OOsJR2traEl2OHCbbhuWrPqSyvpWMSCMLrprLuBNOSHRZIgOGwoDIEfD5fEwcWYjDtjRVMEjYNqz68GPKtzeSFmnizss+y9QpkxNdlsiAojAgcoRmT5uAa9dUgQx8q9eWsqGqgdRIE7dfdBqnzDgp0SWJDDgKAyJHaOrkyaSaHbSHorS1tSe6HDmE0vUbWb1lOynRZm447xROO3VWoksSGZAUBkSOkN/vZ8KIAhy2ybbqmkSXIwexsXwLH2zcij/aytVnTOFzZ56R6JJEBiyFAZGjMPvECbjMCJXbdyS6FOnBlsqtLF+3GV+0jS/OPI4vnH9OoksSGdAUBkSOwtQpk0mJt9MaDNPR0ZHocmQfVdXVvPvxRnyxDr5w4nC+eNEXEl2SyICnMCByFFJTUxk3LA/DttlapamCgWJ7bR1LPtiAJ9bJ2ePzuPrySzB0xKTIp1IYEDlKp544HrcZYWutpgoGgoaGHby5qhR3rJMzxmZx0zVX4nDoI07kcOidInKUpp84FX+8jebOEJ2dXYkuJ6k1NjaxeMXHOKOdzCzxc/v1VysIiBwBvVtEjlJaWhonlORiYFOlXQUJ09LSyqJlH2JEQ0wvcDP/lutwOp2JLktkUFEYEDkGp04djyseoaK2IdGlJKWOjg5efed9rEiIydk2C267HrfbneiyRAYdhQGRYzD9xCn44+00twUJBoOJLiepdHUFWbh0JWY0xPj0GF/7yo14vd5ElyUyKCkMiByDjIwMjivKBsNmm3YV9JtQKMTCJcuIhEOM9Ye4944b8fv9iS5LZNBSGBA5RrOmjMNlRqncrqmC/hCJRHh1yTKCoTAjPZ184ys3kJaWluiyRAY1hQGRYzRj2lR8sTYa27oIBkOJLmdIi0ZjvLZ0GR3BMMOc7Txwxw1kZWUluiyRQU9hQOQYZWVlMSY/EwybqprtiS5nyIrH4yx+exktHUEKaeX+edeSk5OT6LJEhgSFAZFecOrUXVMFNXVH9DzLsggHg1iW1UeVDQ2mafL628tpbO8iz2rhvlu/REFBQaLLEhkyXIkuQGQomDFtKk8sXsXONi/hcASf79Cr2is3ruO5vz7G268+TywSxu31ccb5F3PJ9fMYPW5SP1U9OFiWzZL3VtDQ2kkg3sy9N1/GsGHDEl2WyJCikQGRXpCTk8OovHSAT50qWPLyM9xz9VzeWbqElFMuJ/eie0k55XLeWbqEe66ey5KXn+mPkgcF27Z5e/kqqhs7yIo18rXrL2bM6NGJLktkyDFs27YTXYTIUPDKotf5yztbyM0NcP5Zp/X4mMqN67jn6rn4J8whMHcBhnPv4Jxtxmla+AihDUt5+O8Lk36EwLZtlq38gE21TWREG7nn6rlMmZzc/01E+opGBkR6ySnTT8QXa2NHayeRSKTHxzz318dwpQcOCAIAhtNFYO4CXGk5PP/47/qj5AHLtmHVh6vZVNtEWqSRuy47W0FApA8pDIj0ktzcXEbkpGLZNtU9TBVYlsXbrz6Pf/I5BwSB3QynC/+Uc1m68DmSedDu4zWlbKhqIDXSxLyLTmfGSdMTXZLIkKYwINKLZk0+HpcZpaKHXQXRcLh7sWB20SFfw5VVSCwSJhpOzp4FpevLWFOxnZRoMzedP5PPnDor0SWJDHkKAyK96JSTTsQX66ChuYNoNLrffR6fD7fXR6zl0NsP4631uL0+PL7ka6+7sXwzH2zchj/ayjVzpvLZOacnuiSRpKAwINKL8vPzKUhzYtnw0cer97vP4XBwxvkXEypdjG3Ge3y+bcYJrV3EnLmXYBhGf5Q8YGyuqGT5ui34om1cNut4Pn/e5xJdkkjSUBgQ6WUZLhOXFWVL1YEjAJdcP494RxNNCx85IBDYZpymV35BvLOZi6+7vb/KHRC2VlXz3upyfLEOLpg2gksv/HyiSxJJKtpaKNLLFi9ezONvfESnL5+Z40cwYcKE/e5f8vIzPPxg964B/5RzcWUVEm+tJ7R2EfHOZu754SOc+YUvJqj6/re9tpY3VpbijnZwzoQ8brrmyqQbFRFJNIUBkV5m2zZfve/b7EwdjcOOc/Vll+Bw7P/lVrlxHc8//juWLnxuTwfCOXMv4eLrbk+q/gL1DTtYvHw1rmgHc8ZkcvsN1+BwaMBSpL8pDIj0gVdffZV/vPUR7f4iMhxRvnjJRT0+zrIsouEwXr8/6X4NNzY28ep7H+CIdDF7eArzb7kOp9OZ6LJEkpIiuEgfOP/88xnmi+GPttJueXj2+Rd77BvgcDjwpaQMiiDQm4cqtbS0sOi9DzGiQaYXuLjjpmsVBEQSSCMDIn3Esizue/C7NDjzCHmycJtBTjtlBiNHjkh0aUektw9Vam/v4OUlKzAjQabm2Hz9jpvweg99sJOI9C2FAZE+FIvF+I///BHbYyl0eXKwHU48VoQJx41m8uRJA/7X8J7FjukB/JPPwZ1dRKyljlDpYuIdTUe82LGzs4uXlywjFg4xPj3K/fNvwe9Pvn4KIgONwoBIP/j73//Bkg9K6fLmEHGlYzrcuBwGxYFMRg0rpKS4CI/Hk+gy99PbhyqFQiFefvM9QqEgx/lDfPOuW0hLS+vLSxCRw6QwINJPotEoTzzxBBsqqumyPbTbHqKuNOIONw4gLyudUSX5DC8pITU1JdHl8vNv3807S5dQeNtvezxLwTbj1P9uHmec9Vnu/sHPD/lakUiEV958l46uEKO9nXxr/k1kZmb2UeUicqQUBkQSwLIsampqeH/1Oj4sq6CmJUjEnUHc6cHGICvVz6iiXEYMKyErK4v+Xl9oWRZXzhpLyimXk3XaNQd9XOu7fyO46imeXFlx0EWQ0WiMhW+9S1tnkOHONh6cfyM5OTl9VbqIHIWej04TkT7lcDgYMWIEI0aM4LKLoLGxkQ/XlPL+uk1sqWsmGM9gTWcXH2+uIcXjYkRhgJElReTn5x/Qs6AvHM2hSl7/gaMZ8XicxW8vo7UzSBEt3D/vegUBkQFIYUBkAMjNzeW8s8/ivLPPorOzk7Wl61hZWk7ZtjraYymUbw1TVtWAx2lQkpfNyJJCiouKcLv75i3cG4cqmabJ628vp7G9i3y7hftvv5r8/Pw+qVdEjo3CgMgAk5aWxuxTZzH71FlEo1HKNm5k1Zoy1myuojnkoro2wtb6JgxjPQXZaYwqLmT4sOJeXZW/+1Cld5YuJvPUKw+6ZuBghypZls1b766gobWTQLyJe2+5gpKSkl6rT0R6l9YMiAwSlmWxdetWVq1ex0dlldR1xIi40zGdHrAhO8PPyMJ8Rg4vJiMj85jXGXzqboJXfkGo7O0DdhPYts3SZavY2tBCTmwn995wCSccf/yxFSMifUphQGSQamho4MM1paxat4mtOzoIu9KJOT3YhpM0n4sRBbmMGl5Mbm7uUXc4PNJDlWzb5r2VH7C5tonMaCP3XPN5Jk+a2FuXLCJ9RGFAZAhob29n9dpSVpWWU1a9gy4jlZjTh+Vw4XU6KMnPZvSwQgoLi3C5jqzR0eEeqmTbsOrDj9lQ1UB6tJEFV5zD9Gkn9valikgfUBgQGWIikQjrN2xg5ZoySrfU0GJ6iLn8mA4PTgcU5mQyuiSfkuISfL7DbwP8aYcqvf7WUmpaQqRGGrnj4jOYPWtmb16WiPQhhQGRIcw0TSorK1n5cSkfbdzKjqBFxJXWvc4AyM1IZWRRPiOGl5CefnTdAC3L5pnnXqATL6nRZq7/3Emc89kze/MyRKSPKQyIJAnbtqmrq+OD1aW8v34LVU2dhN3pxB1ebMMgw+9lRGH3OoOcnJzDWmdQU1PD28vfJ+r0kxJt4YS0KN9+4L5+uBoR6U0KAyJJqqWlhdVr17Fy7UbKtzcScqV3rzMwnPjcDnLT/aR6PUyePHG/MwTi8TirV69hy7YqwngxsEmNNDLSH+P/fftbg+I4ZhHZn8KAiBAKhVi3fj0r12xkXeV22mwfMacf0+HCwMZhmUD3R4VlOLENBw7LxBvvJC3SxFknT+aqq76U2IsQkaOmMCAi+4nH42zcuJF/PPsi9e0RYk4/MacP23CCbeGyonjMEB4zxMRRxdx22614vYe/EFFEBh6FARE5qHg8zsqVK9mwYQOhUAiPx0NJSQmnn366Th0UGUIUBkRERJKcI9EFiIiISGIpDIiIiCQ5hQEREZEkpzAgIiKS5BQGREREkpzCgIiISJJTGBAREUlyCgMiIiJJTmFAREQkySkMiIiIJDmFARERkSSnMCAiIpLkFAZERESSnMKAiIhIklMYEBERSXIKAyIiIklOYUBERCTJKQyIiIgkOYUBERGRJKcwICIikuQUBkRERJKcwoCIiEiSUxgQERFJcgoDIiIiSU5hQEREJMkpDIiIiCQ5hQEREZEkpzAgIiKS5BQGREREkpzCgIiISJJTGBAREUlyCgMiIiJJTmFAREQkySkMiIiIJDmFARERkSSnMCAiIpLkFAZERESSnMKAiIhIklMYEBERSXIKAyIiIklOYUBERCTJKQyIiIgkOYUBERGRJKcwICIikuQUBkRERJKcwoCIiEiSUxgQERFJcgoDIiIiSU5hQEREJMkpDIiIiCQ5hQEREZEkpzAgIiKS5BQGREREkpzCgIiISJJTGBAREUlyCgMiIiJJTmFAREQkySkMiIiIJDmFARERkSSnMCAiIpLkFAZERESSnMKAiIhIklMYEBERSXIKAyIiIknu/werH2+g0kOBBQAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -87,7 +87,7 @@ { "data": { "text/plain": [ - "" + "(, )" ] }, "execution_count": 4, @@ -96,7 +96,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -126,7 +126,7 @@ { "data": { "text/plain": [ - "" + "(, )" ] }, "execution_count": 5, @@ -135,7 +135,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -163,7 +163,7 @@ { "data": { "text/plain": [ - "" + "(, )" ] }, "execution_count": 6, @@ -172,7 +172,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABG2UlEQVR4nO3deWBU5b0+8Oec2ZcsM5PMkrCqyE4AQXADXFDqBkUtRAVFLW4t4rXazdv21tbe9tYWaW/ba1t3Ra0/t6pEcUFUEAExEAhJyL6TTDLJ7Ns5vz/CKjskOZk5z+fPMCRPlAkP73m/7yvIsiyDiIiIVEtUOgAREREpi2WAiIhI5VgGiIiIVI5lgIiISOVYBoiIiFSOZYCIiEjlWAaIiIhUjmWAiIhI5VgGiIiIVI5lgIiISOVYBoiIiFSOZYCIiEjlWAaIiIhUjmWAiIhI5VgGiIiIVI5lgIiISOVYBoiIiFSOZYCIiEjlWAaIiIhUjmWAiIhI5VgGiIiIVI5lgIiISOVYBoiIiFSOZYCIiEjlWAaIiIhUjmWAiIhI5VgGiIiIVI5lgIiISOVYBoiIiFSOZYCIiEjlWAaIiIhUjmWAiIhI5VgGiIiIVI5lgIiISOVYBoiIiFSOZYCIiEjlWAaIiIhUjmWAiIhI5VgGiIiIVI5lgIiISOVYBoiIiFSOZYCIiEjlWAaIiIhUjmWAiIhI5VgGiIiIVI5lgIiISOVYBoiIiFSOZYCIiEjlWAaIiIhUjmWAiIhI5VgGiIiIVI5lgIiISOVYBoiIiFSOZYCIiEjlWAaIiIhUjmWAiIhI5VgGiIiIVI5lgIiISOVYBoiIiFSOZYCIiEjlWAaIiIhUjmWAiIhI5VgGiIiIVI5lgIiISOVYBoiIiFSOZYCIiEjlWAaIiIhUjmWAiIhI5VgGiIiIVI5lgIiISOVYBvqRJEkIBoOQJEnpKERERPuxDPSD4uJiLFmyBGaLFVarFWaLFUuWLEFxcbHS0YiIiCDIsiwrHSKdrVq1CosWL4bW6oBx3GXQ2TyIdzYjsuMDJPxePPfssygsLFQ6JhERqRjLQB8qLi7GOVOmwDhqBhxzlkHQaPf/mpxMoKNoJcK71mHL5s0oKChQMCkREakZHxP0oRUrVkBrdRxWBABA0Ghhn7MMWqsdK1asUCYgERERuDLQZyRJgtligXHKdci+4OiPAXyfr0Jk82sIh4IQBKEfExIREfXgykAfaW5uRjQSgc7mOebrtNluRCNhhMPhfkpGRER0KJaBPuDz+bCtqgE6vQHxzuZjvjbha4HBaILJZOqndERERIdiGehlnZ2d+KKkAmGNGbMu/xbCJR9ATiaO+Fo5mUB4+xoULlzARwRERKQYloFe1NHRgY07diMkGmE16nHP/T9A0u9FR9HKwwqBnEzAu/pxJAJeLOBoIRERKUh7/JfQifB6vdhUWrW/CAzJ90AcnI/f/e8TeOjepWhpKIFp3Gxos91I+FoQLlmDhL8Dy/7z19BabYjH49DpdEp/G0REpEKcJugF7V4vNn+zCIgHFl12lWzHM0/8BW+/8SpikQj0RiOunnc9Fi+9G1pLFhLxOEbmWjHq7LMU/C6IiEitWAZOU1t7OzbvqkJYNCHDZMCQfM9Rn/9LkoRIOAyT2bz/NQF/ADUtbTBJYcycPA5ms7k/4xMREXHPwOnY09aGzbuqERZNyDxOEQAAURRhtlgOeY01wwqrUY+oYMCuyur+iE1ERHQIloFT1LpnDzaX1SAsGpFlNmDwcYrAsXicOZAEEU1dYXR0dPRyUiIiomNjGTgFLa2t2FJWg4hoRLbFiEF5p14EAMBgMMCRaUFc1GNHZS345IaIiPoTy8BJam5pwZbyWkQ0JmRbjMj3uHvljABnjgOiKKIzKqOxqakXkhIREZ0YloGT0NTcjK8q6hHVmGGzmnqtCACARqOB05aFhKhDWW0TEokjH1RERETU21gGTlBTczO27m5AVGOE3WpEntvV66cG2m3Z0Gs1CMg6VFbX9urnJiIiOhqWgRPQ0NSErbsbe4pAhhmePigCACAIAvJy7EgKWlS1enl5ERER9QuWgeOob2xEcWUTopqeTX4el7NP7xGwWC2wGnWICgaU7q7qs69DRES0D8vAMdQ1NKC4qnl/EXA7c/v8QiFBEA6MGvo4akhERH2PZeAoaurqsa2mBTGNATlZ1n4pAvsYDAbYM8yIi3qUVnHUkIiI+hbLwBHU1NWjpK4VMdGA3CwrXLk5/X7FsDPHAUEU0BGR0dTc3K9fm4iI1IVl4Buqamr3FgEjnNkZcCpQBABAq9XCZctGXNRhV00jRw2JiKjPsAwcZHdVDXY2tCEmGuGyKVcE9rHbD4waVtXUKZaDiIjSG8sAAFmWUVFZjV1N7YiJBrhsGcjNcSgdq2czYY4NSUGLypZ2jhoSEVGfUH0ZkGUZFVXVKGv2IiYa4LZnDYgisI/VaoXFoOWthkRE1GdUXQZkWUZ5ZRXKmjsREw3w2LOR47ArHesQgiAgz5ULSRDR2BlCZ2en0pGIiCjNqLYMyLKMsopKlLf4EBf18Diy4XDYlI51RAaDAXarCXFRj52VNRw1JCKiXqXKMiDLMnZV7EbFnm7ERT3ycrLhsA/MIrCPMzcHgihy1JCIiHqd6sqALMsoLa/A7j1+xEUd8nKyYbcN7CIA9IwaOm2ZiPNWQyIi6mWqKgOyLGNHWTkq2wKIizrk59pSogjs47DboNOI8EtajhoSEVGvUU0ZkGUZJbvKUNUeRFzUYVCuHbbsbKVjnZRvjhpGIhGlIxERURpQRRmQZRnbS8tQ3RFGQtRhsNOO7OwspWOdkoyMjP2jhrzVkIiIekPalwFJkrBt5y7UdIaRELQY7HIgKys1iwBw+Kihz+dTOhIREaW4tC4D+4pArS+CpKjFEJcDWZmZSsc6bYeMGu7mqCEREZ2etC0DkiSheEcp6rqiSIo6DHHlIDMNisA++0YNvREJzS0tSschIqIUlnZlQJIk+P1+fLV9B+q7Y3uLgAMZGRlKR+tVB48a8lZDIiI6HWlTBoqLi7FkyRKYLVZkZmbi/HOnYsWj/4VoR2vaFYF9Dh41rK6tVzoOERGlKEFOgwfOq1atwqLFi6HNcMA49jLobB7EO5sRLvkASb8Xv/vfJ3D1/BuUjtknuru7UdfqhVkKY9aUCTAajUpHIiKiFJPyZaC4uBjnTJkC06gZsM9ZBkGj3f9rcjKBjqKVCJeuw2tr1mHUuPEKJu0bsiyjpq4B4WgMw7L0mDhutNKRiIgoxaT8Y4IVK1ZAm+E4rAgAgKDRwj5nGTQZdjzzxF8USti3BEGAZ/+oYZCjhkREdNJSugxIkoRVL70M49jLDisC+wgaLUzjZuPtN15N2xE8o9EIm9WEGEcNiYjoFKR0GQiHw4hGwtDZPMd8nTbbjVgkgkg43E/J+p/roFHDltZWpeMQEVEKSekyYDKZYDCaEO889pW+CV8L9EYjjCZTPyXrf1qtFrnZGYiLOpRWNyCZTCodiYiIUkRKlwFRFFG4cAEiOz6AnDzynL2cTCBcsgZXz7segiD0c8L+5bDboBM5akhERCcnpcsAACxfvhwJvxcdRSsPKwRyMoGO1Y8j6e/ALUvvUShh/xFFEZ5cG5KCBrub9vBWQyIiOiEpP1oIHHTOgNUO47jZ0Ga7kfC1ILx9DRIBL37y69/jxluWQKPRKB21zx08ajg824CCsaOUjkRERANcWpQBoOe8gRUrVmDVSy8jGgnDYDRhzpw5uPTa6zFo5HhoRAGeHBsyMzPT/nFBOBxGZUMLDMkILpxwdkrf0khERH0vbcrAPpIkIRwOw2w2QxAEdHR0oGR3DXxxAQlBC4tBh3y3E3q9XumofaqxuQU+fwhuo4zpkyekfQEiIqJTl3Zl4EgkSUJNXT3KG/YgIughiRo4s6zIcdghiim/beKIEokEyqvroZFimHJWPjxut9KRiIhogFJFGdgnHA5jR3klWvwRxEQDdBoR+bkOWDOsSkfrE23tXrR2dsMmRjFj6iRV7JkgIqKTp6oyAPRssNvT1oYdlXXwS1okBQ0yzQbkuZzQao98imGqkiQJFdX1kJJxjMvLxpnDhykdiYiIBiDVlYF9EokEdlfVoKq1A1HRCEEU4bJlwW7PTqvn6wffanjx1AIYDAalIxER0QCj2jKwTyAQwPaySrSHk4iLOhj1WuTn5sBkTo/TCmVZRnVdAyLRGM7INmACRw2JiOgbVF8GgJ6/MBuamrCrpgkh6JAUNLBbTXA5c9PiOXs4FEZlYysMyTBHDYmI6DAsAweJxWLYtbsK9d4AYho9NKIIj8OGzKzUP5ugoakZXYEwRw2JiOgwLANH0NnZie0V1YecTZDnyk3p5+2JRAJl1fXQSjFMHTEIbpdL6UhERDRAsAwcxYGzCVoREQyQRQ1yMi3IzXGk7NkEHDUkIqIjYRk4jnA4jJ0VlWjuTv2zCQ6MGsYwPt+OM4YNVToSERENACwDJ2Df2QQ7q+rQndx7NoHJAI8rFzqdTul4J6Wrqwv1ezo4akhERPuxDJyERCKByupaVLZ4e84mEAS47NkpdTbBgVHDKM60GTF+DEcNiYjUjmXgFHzzbAKDToN8Zw7MZrPS0U5IKBRC1d5Rw4sKRiEzM1PpSEREpCCWgVMkyzKampuxs7px79kEWtitxpQ5m6C+qRndgTA8JhnTJnHUkIhIzVgGTlMsFkPZ7irUeQOIiXpoNCLcjmxkZWUN6L9g4/E4ymsaoJNimMJRQyIiVWMZ6CWHnU2g1yLP7RzQG/T2tLVjj88PuxjDRVMnpsSKBhER9T6WgV4kSRJq6xtQVt+y/2wCR6YFzgF6NoEkSSivrgOScYzjqCERkWqxDPSBSCSCHeW7D5xNIIrIc9qRkZGhdLTDdPm6UN/WAYscwawpEwb0SgYREfUNloE+tKetDTsqa/efTZBhMiBvgJ1NIMsyquoaEItGcQZHDYmIVIlloI8lk0nsrqpBVWsHIoIBEAS47Flw2G0DZoPhwaOGMyaOHpArGERE1HdYBvpJMBjE9rLdaAsdOJsgL9cBi8WidDQAHDUkIlIzloF+tO9sgtKaJgTlnkcHNqsJrtwcaLVaRbMdGDWMYurZQ+ByOhXNQ0RE/YdlQAHxeBxlu6tQ296NmGiAuPdsgmyFzyY4eNRwxrmTBuQEBBER9T6WAQX5fD5sr6hGZwxICFqY9VrkK3g2gZSUUF7TM2o4fpADw4cOUSQHERH1L5YBhUmShLqGRuyqa0ZEMEASRORkWeF0OCBq+v9f5gePGl48tQB6vb7fMxARUf9iGRggIpEIdlZUoqkrrOjZBLIso7KuAfFoFGfaTRg3emS/fn0iIup/LAMDTHt7O0p216IrqUFS0CLDpEeeMxc6ff+dTbBv1NCYDGPGpDGwWq399rWJiKj/sQwMQMlkEpXVtahsaUdEMCpyNkFdYxP8wQjyzMC5E8dz1JCIKI2xDAxgB84mSCAu6mHQishz5vTL2QQHjxqeO3IonLm5ff41iYhIGSwDA5wsy2huaUFpdQMCsg5JQYNsixFuZ26fn03QuqcNbV0BjhoSEaU5loEUcaSzCVz2LNiys/tsCf/gUcMJg3MwbMjgPvk6RESkLJaBFOPz+VBSUYWOmNAvZxP4fD40tHVy1JCIKI2xDKSgfWcTlNW3IAw9JEGEI9MCV05Or59NcPCo4VkOM8aOOrtXPz8RESmPZSCFRaNR7KyoRKMvhJhogFYUkJfbczZBbz46CAaDqG7aw1FDIqI0xTKQBg6cTSAiKehgNeqQ73L26tkEHDUkIkpfLANpIplMoqqmDrub2/afTeC0ZSLHYe+Vv7jjsTjKahugl6KYNnIocjlqSESUNlgG0kwwGERJeSX2BOO9fjbBvlFDhyaGi6Zy1JCIKF2wDKQhWZbR0tqKnVX1vXo2AUcNiYjSE8tAGovH4yivrEZNmw8x0dgrZxN0+nxobOuEVY5gFkcNiYjSAsuACnR1daGkogreKJAQtDDptchz5sBkMp305+KoIREdjSRJCIfDMJlMfIyYYvh/SwWysrJw3uQCFAzJgUWOIBqNobKhBc2teyAlpZP6XIIgwJNjR1LQoLbNh2Aw2EepiShVFBcXY8mSJTBbrLBarTBbrFiyZAmKi4uVjkYniCsDKnPw2QRx0QDNKZ5NUNfQBH8ognyLgKkF4zhqSKRSq1atwqLFi6HNcMA49jLobB7EO5sR2fEBEn4vnnv2WRQWFiodk46DZUClvF4vtlfUnPLZBAePGk4fNQw5OTl9nJiIBpri4mKcM2UKjKNmwDFnGQTNgQ3KcjIBb9FKRErXYcuWzSgoKFAwKR0Py4CKne7ZBC172uDtCsDOUUMiVVqyZAlWvbkartv/75AisI+cTKDxb7cj02zCnKvnYvL4kZg6aQLGjx8Pu92uQGI6GpYBQigU6jmbIBBDTNRDr9Ug3+k47tkE+0YNpXgUI51WjBwxgoWASCUkSYLZYoVxynxkX3D0xwC+z1eha/3LyJ60ACLiEBMRiPEuuGwWjD17GCaPH4kpE8dj/PjxXGFU0KkPnVPaMJvNmFowDi2trSitboA/rkV10x5kWYzwHONsgvLSHfi/P/0Ra955C/FYFAajCYULF2D58uVcEiRKc6FQCNFIGBk2zzFfp812A1ICl884B02tHWja046OrizUxwU0lHTj/W2fQ3jmQ2jiXXBmmzFmxLC9Kwg9BYGnnfYPrgzQIRKJRM/ZBHs6ERWNEEQRbsfhZxO8/dq/8NC9S6HJcMA0jpuGiNRElmX86OFf4Hf//Wtknb/wuCsDwS9fxV9f37T/Z0gkEkFTcxNq6xtQ29CCppZ2dHbvnUySJQhSDEIyAk2sG7lZRowZMQyTxp29vyC4XK7++DZVhWWAjmj/2QQRGQlRd8jZBLtKtmP+7BkwjZ4B+xE2DXUUrUR41zps2cxNQ0Tp6JeP/g5/enkdupt2QYp1I2/p34+6Z6D570tx7rnnY8n9jxzzc0ajETQ1NaO2vgF1Dc1obG1HR1cQkAFAgiDFISTD0MS64cg0YMxZQ/c+YhiHCRMmwO129803qxIsA3RUsiyjvrERpbXNCEMHSdDAkWnBikf+E6vf/xCuO46+aaj1H0tROO9KPPXUUwokJ6K+8vs/rsRvny5CwujERRMG452nfgPT6JlHniZY/TjCu9bhPx9/GYPPGHnSXysai6KpqWlvQWhBY0s7OroDgAQcXBDEWDccGfqeFYSxZ2PqpAMF4UiboXk40uFYBui4otEoSndXoaEjiKigQ+Gl02A+9/rjLg1GNr+GcCjIMwiI0sRf/vZ3/OIvryFucuHKWVNxyayZ2Lj2XfzzsZ9AY3XAPH42tNluJHwtCG1fg2TAi9sfeBTTZl3ZaxlisRiamppQt+8RQ2sb2rsCkGVAkPcVhAjEWDfsVh3GjBi6vyBoNBq88MILeOnlVxCNhLnP6SAsA3TCvF4vNm0vxbcuvgg51/wAljGzjvrawI6P4X37MQSDQZjN5v4LSUR94smnn8WPHnsBcbMHl50/EXMuv2z/r9VXleGDN5/Hxk9WIxGLQqs3YNrMb+GyuTef0orAyYrFY2hubt5fEBqb2+D1+SHhQEGIte9GoO4raKwOWAuu4D6nb2AZoJMSj8dhzciEaep1XBkgUokXX3oFy3/9d8TN+ZgxdSyuuWoOBBx5+T0ei0BvMCn+vo/H4/sLwo5tW7Hp7SdgGTMLjm9xn9OR8GEJnRSdTocbCxciUvIB5GTiiK+RkwmEt69B4cIFiv9AIKLT8/obb+E/Hu0pAucVjDhqEQAAURRhMJoHxPtep9NhyJAhuPCC86ELN0OXmXNYEQAAQaOFfc4yaK12rFixQpmwAwDLAJ205cuXIxHwoqNo5WGFQE4m0P7uCsS62jBt2jSFEhJRbyh6733c87M/IWrKxzljz8D8edcctQgMVJIk4ct1RTCPn33EDc9ATyEwjpuNVS+9DLUulvPQITppBQUFeO7ZZ7Fo8WK0NpTAOO7ApqFIyRrEutoAyPje974HURSxdOlSpSMT0Un6eO0nuP2h/0HElIcJIwdjwXXzIAip9+/HeCyCRCwK3QkcjhSNhBEOh1W5zyn1/s/SgFBYWIgtmzejcN6ViGx+Dd63H0Nk82sonHclNm7ciJtvvhnJZBJ33nknHnzwQUjSyV2VTETK2fDFF1i8/FcIGfMw5ox83LTg+pQdwdPpjdDqDYh3Nh/zdQlfCwxGE0wmUz8lG1i4gZBO276ZXbP5wLNCWZbxyCOP4Oc//zkA4Nvf/jaef/55VTZuolSyZctXmP/dh+DX5mHEUDduu+VGaI+yvJ4qnvzDw9i0aQM8333i6IcjPXEHbpp/tWrPRknNqkcDiiiKsFgsh2waEgQBP/vZz/DCCy9Ar9fj9ddfx6xZs9DS0qJgUiI6lu3bt+OGpT+EX5uHYfm5WLKoMOWLAADMnrcIyYAX3qPtc1r9OOL+Dtx7770KJVQeVwaoz3322WeYN28evF4vhgwZgnfeeQfjxo1TOhYRHaSsrAzXLFqGdjgxyO3AXbcvgkFvUDpWrznW4Ujx7nZkDC7AK0/8BnOuuELpqIpgGaB+sXv3blx11VUoLy9HRkYG/vWvf+EKlb7piAaa6upqXFl4N1qTOfA4bbj7jsUwGdPv2fnRDkfSZA/F9uo2XDYmA6888zelYyqCZYD6TUdHB+bPn49PPvkEGo0Gf/7zn3HXXXcpHYtI1RoaGnDlgqVoiNmQa8/G95YuhtlsUTpWn/rm4Uh72vbgd//7DAzBOnz9wSpVXnrEPQPUb+x2O95//30sXrwYyWQSd999N37wgx8gmUwqHY1IlVpaWnDtjXehIZYNe3Ym7r7j5rQvAsDhhyM5c50Y5LIjbsjBCy/9S+F0ymAZoH6l1+vx9NNP45FHeq4zfeyxx3D99dcjGAwqnIxIXdrb2zH3prtQE8pAVkYm7rnjZmRYM5SOpZjzp0yApDXjhdffV+XBQywD1O8EQcDDDz+MF198EQaDAW+88QZmzpyJ5uZjzwETUe/w+XyYd9Od2N1lhNWagXvuuBFZmVlKx1JUQcEE6LUi6juT2LBhg9Jx+h3LACmmsLAQH374IXJycrBlyxZMmzYN27ZtUzoWUVrr7u7G/JuWotSrhcmSgXtvvxF2m13pWIoz6A0Yd/ZwJA3ZePKFV5WO0+9YBkhRF1xwAb744guMHDkS9fX1uPDCC1FUVKR0LKK0FAqF8J1b7kJxC6A3Z+DuJQuQk5OjdKwB48LzpkAW9Sj6dCu6urqUjtOvWAZIcWeeeSY2bNiAWbNmwe/34+qrr8Zf//pXpWMRpZVIJILCJXdjU20MOlMG7lp8Pdwu9e2aP5bBgwcjJ8uCiNaG//f6m0rH6VcsAzQg2Gw2vPfee7jllluQTCZxzz334IEHHuCkAVEviMViWPzd7+OzigA0piwsvXk+BuUPUjrWgCNAwPRzxkHSWvH0K28rHadfsQzQgKHX6/HUU0/hV7/6FQDgD3/4A6677jpOGhCdhkQigdvvuR8flbRDNGTijhuvxdChQ5WONWBNPWcyBFHErnofduzYoXScfsMyQAOKIAj46U9/ilWrVsFgMODNN9/EzJkz0dTUpHQ0opSTTCZxz30PYfWWRsCYjVsXXI0zzzhT6VgDmsViwagz8pE02PHU868oHaffsAzQgLRw4UJ89NFHnDQgOkWyLGP5gz/Fa59XQjbYsGj+HIwaOVLpWCnhgnMnQ9IY8fr7nyESiSgdp1+wDNCAdf755++fNGhoaMAFF1yA1atXKx2LaMCTZRk/evi/8NJHOyAZbFh47aUYN26s0rFSxogRI5Bp1qNLsuKdd9XxM4dlgAa0fZMGF198MQKBAK6++mr85S9/UToW0YAlyzJ+8av/xpNvb0bC4MANV83C5EkTlY6VUkRRxJSC0ZB0mXjqJXVMFbAM0IBns9lQVFSEJUuWQJIk3Hvvvbj//vs5aUB0BP/zh5X4y6ufImHMwbzLL8C5U6coHSklnXfuFEDQ4MsddaitrVU6Tp9jGaCUoNfr8c9//hOPPvooAGDFihWYP38+AoGAwsmIBo4//eX/8PtnipAwOnHVxefiwvPPUzpSyrLZbBien4OkKRfPrUr/y4tYBihlCIKAH//4x3jppZdgMBjw1ltvYcaMGZw0IALwjyefwSN/fQ1xkwuzL5iMi2fOUDpSyjtv6kRIGhNeeuvDtF+JZBmglLNgwQJ8/PHHyM3NxdatWzFt2jQUFxcrHYtIMS++9Ap+8scXEDd7MPPccbh89sVKR0oL48eNhVGvQWtQg4/XrlU6Tp9iGaCUdN555+GLL77AqFGj0NDQgAsvvBDvvvuu0rGI+t1rr7+J/3j0H4ib83D+xJG4+sorIEBQOlZa0Gp1mDTmLCT1WXjqxdeVjtOnWAYoZZ1xxhnYsGEDLrnkEgQCAVxzzTX485//rHQson7z7uoi3POzPyFqysOUcWfi2/OuZhHoZRdMnwpZ1OLjL3egvb1d6Th9hmWAUlp2djZWr16N2267DZIk4fvf/z7uu+++tH++R/TRx2vx3R89hqg5HwWjhmDBdXNZBPqA2+2GJycLUZ0Dq15O36uNWQYo5en1evzjH//Ab37zGwDAypUrMW/ePE4aUNr6fP16LF7+K4SMeRh7Zj5u/M51EAT+OO8r502ZAElnwfOvvQdZlpWO0yf4p4fSgiAI+NGPfoRXXnkFRqMRb7/9NmbMmIHGxkaloxH1qk2bNqPw3p8hZMjD2UNcWHTjd6ARNUrHSmuTJ06ETiOiui2MLVu2KB2nT7AMUFq54YYb8PHHH8PpdO6fNPj666+VjkXUK7Zt24YFd/8EAZ0Hwwc5sWRRIbQardKx0p7RaMTYEUOR0Nvwz+fS8/IilgFKO9OnT8cXX3yB0aNHo7GxERdeeCHefltdd5NT+ikrK8N1tz8In+jCYHcO7rjlRuh0OqVjqcYF086BrDFg9Seb0/IRJMsApaXhw4dj/fr1uPTSSxEMBjF37lysXLlS6VhEp6SqqgrzbrkPXjjhybVh6ZKboNfrlY6lKsOGD4M904SAkIXX33hL6Ti9jmWA0ta+SYM77rgDkiThvvvuw7JlyzhpQCmlrq4Ocxd9D61JB5w5Wbjr9pthNBqVjqU6AgRMmzQWki4Dz/wr/VYaWQYorel0OjzxxBP47W9/CwD405/+hLlz58Lv9yucjOj4mpubMffme9AYy4bDlom7b7sZZpNZ6Viqde6UyRBEAdsq96CsrEzpOL2KZYDSniAIeOihh/Dqq6/CaDTinXfewUUXXYSGhgaloxEdVVtbG+bedBdqQxnIzszA3bffDKvVqnQsVcvIyMTZw/KQNObg6RfSayMhywCpxnXXXYe1a9fC6XSiuLgY06ZNw1dffaV0LKLDdHZ2Yt5Nd6Ky24SMjAzcc/vNyMrMUjoWATh/6iRIGiNeK/oUsVhM6Ti9hmWAVGXatGnYuHEjxowZg6amJlx00UX497//rXQsov26u7vx7ZuXYleHDiZrBu69/UbYbDalY9FeI0eNhNmoRXtYi3dXFykdp9ewDJDqDBs2DOvXr8fs2bMRCoUwd+5cPP7444ecLCZJEoLBICRJUjApqU0wGMQNi+/E9hYBBnMm7rl1IRyOHKVj0V71VWV4ZsXP0bL+WXSUrMZ1112HJUuWpMWtqSwDpEpZWVl45513sHTpUsiyjOXLl2PZsmXYsmULlixZArPFCqvVCrPFmjZvdhrYIpEICpfcg831cehMGbhr8fVwuVxKx6K9Nq59F4/ctwCbNm1AxvTvIOeaHyDjvAVY9cZqnDNlClatWqV0xNMiyOl60DLRCZBlGY899hgefPDBng8IAnQZOTBPuBw6mwfxzmaES9Yg6e/As88+gxtvvFHZwJSWotEobr79Xny0sxNaUzbuWnwdhgwZonQs2qu+qgyP3LcAptEz4ZizDMJBpz7KyQQ6ilYivGsdtmzejIKCAgWTnjqWASIAjz32GH7wgwdhGTsLjm/dd9ib3Vu0EqGda3Hn/T/GxAnjMNiVg8F5LrhcLjgcDmg0PBueTk0ikcCtdy5D0VctEExZWHrTt3HGGWcoHYsO8uQfHsamTRvg+e4Th/xs2EdOJtD6j6UonHclnnrqKQUSnj4eak0EoKSkBNpMx2FFAAAEjRaOOcsQrduO1R9+Am/GGRCrqqCRyqFNhmFAHM7sDLjsWRjkcmCwx4k8jwe5ubk8LpaOKZlM4q5lD6Loq2bAmI0lC65mERhgJEnCl+uKYDn3+iMWAaDnZ4Rx3GyseullPPnkkxCE1LtKmmWAVE+SJKx66WVYpsw/5pvdMuFyNH75KsY/+At0+YPwBcIIhCIIyjI6w0B5QwxifQNEqQbaZAR6KQp7phnu/SUhF3luN1wuF0+QI0iShOUP/hRvrK+CbLRj8XVzMPLskUrHom+IxyJIxKLQ2TzHfJ02241oJIxwOAyzOfUOhmIZINULh8OIRsLIOIE3eyIWxeizhsOw9xQ4WZYRDIbg93ej09eNjm4/fIEw/MEwwgkJXTGgulWC2NwCcWsDtMkodMkwsswGuO1ZyHfaMdidi3xPzyMHq9Wakv+qoJMjyzJ++PB/YdVHOyEZ7bhx3mUYN3as0rHoCHR6I7R6A+Kdzcd8XcLXAoPRBJPJ1E/JehfLAKmeyWSCwWg6oTe7zmCE3njgzS4IAqxWC6xWCzyeA2VClnt2h/v93ejs6kZnlx8+fwhdwTC64wl0y0CDF/iqzQuxpBUa6SvokmFYdSJc9kzk5dowyJ2LwXtLQnZ2NkSRwz/pQJZl/OyXj+Lpd7YgacrBgqsuxqQU3XSmBqIo4twZc7Bp0xpkTb/hqHsGIiVrULhwQcqWeZYBUj1RFFG4cAFWvbka8jHe7OHtazBjztwTerMLAmAyGWEyGeF0Og/5tVgsDr+/G76uLnR0BeDzB9AVCCMQjcMPoKUL2NbZDbGsExppB3TJEEwaGc7sDHhysjHIlYPBHifcbjdycnK4eTHF/Pb3K/C319YjYczF/CsuxNQp5ygdiY5j9rxF+OLjt+EtWnnkaYLVjyMR6MDy5cuVC3maOE1ABKC4uBjnTJkC46gZR3yze1c/jvCuT/HHl4owfGTfLOcmEkkEAn50dXXB6/PD5w+iKxBCIBKFLAMyBIhyEqKchEaKQ5uMwIA4cjLNcOfYMMjZsy/B43bD6XTyitsB6PE//xW/euItJEwuXH3JNMyacZHSkegEbVz7Lv752E8gWuywTLi857GhrwWRkjVIBDrw3LPPorCwUOmYp4xlgGivVatWYdGixRAs2bBMuGL/mz28vefNfv+vV2Lmld/u91ySJCMYDMDn69r7uCEAXyAEfzCCxN63ryBL0MhJiFICWikKnRSB3WKE25Hdsy/Bk4t8jwculytln2mmur//82n8dMVLiJvduOLCyZh92SVKR6KTVLlrGx7/3X8htKcKkBIwGE0oXLgAy5cvT9nzBfZhGSA6SHFxMW6/615s3bwJUiIGncGIGXPm4tqbv9tnKwKnSpZlhEJhdHfv3ZfQ3bMvwR8MI5aQAAEAZIhSz2qCVopAl4gg06iFy5GF/Fw7hnicyPe44HQ6kZmZmbLPOwe65158CQ/85knEzXm4ePoEXDXncqUj0Sl489/v4rPNJRhm6sQHrz8Dm82WNu8ZlgGib/jk08/x1/eLYbZYMO/Ky1PuzS7LPSfadXd3w7e/JATRFQwjHEsA6OkJwv6SEIUuGYFZC7jtmfDk2jHEnYN8txMulwt2u52bF0/D/3vtDdzz8/9FzJyPCyaPwrxrr4KA1PozRT1XSv/+r89CDLbg+ccewOWzL1M6Uq/iBkKib5hUMB7m1Z/DHzWn5MywIABGowFGYy6cztxDfi0eT6C7uxtdXV3o7Paj0x9EVyCMYCQGvwy0dgPbfd0QyzuhkXZCl4zAKCb2bl607T9Uad/mRa2WP0KO5e13VuPevUXg3PFnsQikKBkyXn1zNaR4BBcXDE67IgCwDBAdJjMzE2d5bNjaKaO2rgGjR52tdKReo9Np4XDY4XDYD/l4MpmE3x84UBK6Az2bF8NRBGXAGwJ21YYh1tRClCqhS4ahl2PIybTAnZN92OZFg8Gg0Hc4cHzw4UdY+uPHEDXnY+Koobhh/rUsAilqR8lOVDbsgTnehv955DdKx+kTLANERzBt/Ehs/7gU1Y2taVUGjkaj0SA7OwvZ2VkYetDHezYvBtHd3Y0OXxc6u4PoCgbhD0YRlCR0xoDdjQmIDY0Q5TrokhFok/s2L2Yhz2nHEHcu8jw9Jy9aLBbFvsf+9Olnn+PW/3gUYVM+xp01CIXfmQ9B4KOWVBSPx/HG6o8gxv1Y+p3ZGDZsmNKR+gT3DBAdgc/nw/2/ewIBgxPXz5kJs5k78A8myz0nN3Z3d6GzqxsdXQF0BYLoDkYQSyQho2dfgiglDuxLSISRYdTCZc9CXq4Ng925GLT3UKWsrKyU25txNF9+uQnX3/kT+HV5GDXcgyWLCnkWRAorWvMhPvj8K+Rr9mDjmlfTttByZYDoCLKzs3GGMwvbumXUNTRi1NlnKR1pQBEEwGw2wWw2we12H/JrBzYv+tHR5UdXoOe8hO5YAn4ATZ3A114fxFIvNNI26JNhmLWA09azL2GwO2f/yYsOhyOlNi8WFxdjwd0/QUDnwZmDc3HLTQtYBFJYZ2cn1n7xNbQRL375i7vStggAXBkgOqo1H63Fk5+UwWa341uX8HCY05VI7Nu82DPh0NEdRHcghGAkDgkAZBkiJIhSAho5AV0iDIOQQG62FXk5tp5HDns3LzqdzgG3ebG0tBTXLL4PHYILQ/JycOdti6DX8eCnVPbkcy+itKIG5w3V4u1/PZM2q1dHMrDeTUQDyJRJBXjxg01o6zIgEonCaOSmuNOh1Wpht9tht9sx/KCPJ5PS3pMXe+5w6OgOoDsQgj8SRUCS0REGyusiEGvrIUrV0CbD0EuxvScvZiMv144hnlzkeTxwOp2K3AhZWVmJb996PzrgQp7ThqW33sQikOIqKiqws7IJhsge/P6RP6V1EQBYBoiOymazYVhuBkr8QG19A0aOOFPpSGlJoxGRlZWFrKwsDDno4z03QgbR3e1Hh6+7Z8IhGIQ/GEEoKcEXByqbkhAbmyFubYAuuQHaZAQ2iwEuWybynA4M9TiRd9CNkH2htrYWcxd9H3skB5w52bjztpthMPCK6lSWTCbx6ttrICaCWHTNBRg9erTSkfocHxMQHUPRmg/x9GeVcDgcmHPxBUrHIey7ETKM7m7/3s2LfnQHeg5VisSTAAQI+09eTEAjxaBPhGA1aI64eTE7O/uU/9XX1NSEqxYuRW04Ew5bNr63dDGslr4pHdR/1q77FG9/9AVy5WZ8+f4ryM7OVjpSn+PKANExTJlUgJc+/gptXQZEo1HOzw8APTdC9twb73IdeiNkNBqD3+/ffyNkV6DnRkh/NAN+AM0+oLijC+KuDmik7dAlwzBr5AObF105GJx3YPPisTb/tbS04OqFd6AmmAWbLRP33H4zi0Aa8Af8eP/TTdBGO/HTB25RRREAWAaIjiknJwdD7BaUhmTUNzTirDPPUDoSHYPBoIfB4EBOjuOQj/dsXvT3nJfQ1XM8sy8QQjAcRQDAngCw0x+CWFUFjVQObTIMA+LIzbLC7cjef/Kix+1Gc3Mz/vCHP+ClV/4FOZmAoNHirAsuQ1d7MzIzM5X5xqnXvPXOe4hHYyjIN+HmGxcqHaff8DEB0XG8U7QGz22oRm6uA5fP5KOCdCJJMgKBvScvdvXsS/AFwgiE9t0IeeDaaFFKoH7benz+7xehsTpgmXA5dDYP4p3NCG1fg2TAi9sfeBTTZl2p9LdFp6i2thZ/eupf0IUaUfTMbzF58mSlI/UbrgwQHcfUyQX417ptaO3QIxaLQa/nLvF0IYoCMjMzkJmZgcGDD3z8wI2QXej0daOj24/KslJ8/u9VMI+ZBcecZRA0B358Zk2/Ad6ilfjnYz9B3pAzMfiMkQp8N3Q6ZFnCq/8ugpgM47pLJqqqCABA6pzmQaQQp9OJQTYDJBmob2hUOg71A0EQYLGY4fF4MGb0SFw4bQo6yzdDtNgOKwIAIGi0cMxZBo3VgQ/efF6h1HQ6vvhyE5rb/ciUvfjlww8pHaffsQwQnYBzx46AVoqhqqFF6SikAEmS8Ol7b8FacMVhRWAfQaOFefxsbPxkNfj0NbWEwiG8++EGaGI+PPjdBcjNzT3+b0ozLANEJ+DcyQUwxP1o6ehGLBZXOg71s1gkgng0Ap3Nc8zXabPdSMSiiEUj/ZSMesO7RWsQiUZxlkPAd2+/Vek4imAZIDoBbrcb+Vl6SDLQ2NSkdBzqZ3qjETqDEfHO5mO+LuFrgVZnAHhDYcpobmnGxm0V0Ib34Hc//w/odDqlIymCGwiJTtC5Y89C1eZ6VNU3Y/iwocf/DZQ2RFHERVdci8/WfYCs6Tcc8VGBnEwgUPweNFmD8PBvViLTakKuIxsepwP5bic8HjecuU7V/mUzEMmQ8a83V0NIRHDFtLMw4yL13kHCMkB0gqZOmoDXN5Si2WtAPJ6ATse3j5rMXbQUa995Dd6ilYdtIpSTCXhXPw4p0IFBQ0YgHKhFMGqF3+dFZXUdIOogQ4YgCMiymuF0ZMPjzMEgjxNutws5ObksCQr4emsx6po7YE204Te/+L3ScRTFn2ZEJygvLw9uqwZVcRlNTU0YOnTI8X8TpY3hI8fixvsexgsrHkG0bhssE67o2SPga0GkZA0SgQ688MLzKCwshNfrRXl5OXaUlqFkVyV2Vdaiqq4ZXaEEAhEruju9qKiqBQQtZAgQBMCWaYbTYUeey4E8txNujxs5OTnQHmXDIp2eaCyKt97/BJpYN7538zUYNGiQ0pEUxUOHiE7Cq2++g1e3NiHP5cTFF05TOg71o5q6eqzbshOhhlIEKjZh4xcbEI2EYTCaULhwAZYvX46CgoKj/n5ZltHe3o7y8nKU7Ny1tyTUoaq+Gf6IDFlnhaQxQhZ1kIWeAqARgexMC5wOGzyuHOR7nHC7ekrCsY5KpuP797tFWLdxG4YaO7Dh/VcVue1yIGHlJDoJ0yZPwFtflqPJa0AikYRWyx/IatDY1IR1X+2EPh7AlbMm45a/PQoACIfDMJvNJ3TRkSAIyM3NRW5uLi644MBJlrIso7W1tack7F1JKK+qR1VdMwJxwBfJQGeHF7t210AW95YEQYA9y4rcHBvyXDnIdzvhdrthd9ihEfln8ni83nZ8tnkHNJE2/Pq/7lN9EQBYBohOyqBBg+AyC6hOymhubsbgwepeWlSDltY9+HjTDujjQcw4Mxu3LLweotgzLWCxWE778wuCALfbDbfbjRkzZuz/uCz3/BnrWUkoQ0lZFcqr6lDd0IpgXEBH1Aqvtw2l5VUHSoIowJFlhTPHhjxXLvI9LrjdLths9v2ZCXj1zXchJaKYOdaDb825Quk4AwIfExCdpJdf/zdeL27BII8LM88/V+k41Ifa29vx3udfQYwFMX2QCffevkjx5XlJktDU1ISysjJs31mGHWVVKK+uR03DHoSTGkg6K2SNAbKgPaQk5Ngy4HL0rCTk5bnhcrlgt9kgqGwMcmfpTjz58rswhevx6etP4Mwzz1Q60oDAlQGikzR98gS8s2U3GtoMSCaTiv/lQH2js7MTa9ZvhRAPYZJLi7uX3DQg/l+LoohBgwZh0KBBuPTSS/d/XJIk1NfXo7y8fH9JqKhpQHXDHkQlLdojGWjbswfbd1VB3vsoQacR4bBlwJ1jh8edg3yPGy6nC9m2bAg4/qOPVJNIxPH6ux9BjAdw+3WXsAgchCsDRCdJlmX84NcrUCvZcOnU8Rg0KF/pSNTLurv9ePeTjUhGQxhvk/CDu5fAYDAoHeuUJJNJ1NXV9awklJZjZ3k1yqsaUNfUhih0kLQHryRoABnQ60Q4srPgzrUhz5OLfHfPSkJmVmZKl4Q1H3yE9z7bAo/Yii/XvAqr1ap0pAGDZYDoFLz46ht4s6QNQ/I8mHHeFKXjUC8KBIJ495MNiEfCGGWN4Yf33gaTyaR0rF6XSCRQW1uLsrIybNtZjp3lVSivbkBDixcxGPaWBD1kQQdZECEA0Os1yLFlwpVjR567Z0+C0+VCZubAKgmSJCEei0CnN+7fK9HV1YX/XvkPyME2/O/DS/CdG65TOOXAwjJAdAqqqqrw8yf/jYTJhgVXXQaNRl3PXdNVKBTG6rXrEQ6HcJYpjB/fe5vq/vUYj8dRXV2NXWVlKCmt6FlJqG5AQ6sXCdGEpNbac4iSeKAkGHRa5Nh7VhLy3bnweHpWEqxWa7+WhPqqMqx54zl8ua4IiVgUWr0B586Yg9nzFuHDDVuxo6waU/OBotefP6EJEDVhGSA6BZIk4YFfrUA9HJg9bTzy8vKUjkSnKRqN4t2PP0cgGMYwvR8/vXcJsrKylI41YESj0f0lYfvOCuysqMbumkY0tHYgqTm8JACASa9FjiML7hwH8t25PRsXna5emcL4po1r38U/H/sJNFYHzONnQ2fzIN7ZjND2NUj4vTANPx9Wkw4frnoc48aN6/Wvn+pYBohO0XOvvI63d3oxbJAbF07jo4JUFovFUbT2c3QFQhis6cJP77kFdrtd6VgpIRKJoKqqCrvKyrBtRzlKK2pQUdOIpjYfkloLJK0FELWHlASzQYdcezbcTjvyXLnI87jhcrtgNplPKUN9VRkeuW8BTKNnHuWo6JUI7lyLmxYvwfNP/6NXvu90w2kColN03uTxeH/bO6jf0wFJkiGKXHZMRYlEAh98ugG+QAgedOKHSxexCJwEo9GIMWPGYMyYMZj/7QMfD4fD2L17N3btKsP20grsrKjB7tomNLf7EAtbUR/woa6hERC1gCBChgyLUb+3JDgwyO2EZ++eBJPx2Hs21rzxHDRWx2FFAAAEjRaOby1DpK4YcjzcF/8J0gJXBohOkSRJuP+RP6JRcODy6RPh8biVjkQnKZlM4oN1G9Dq88MpdeAn312I/HxOh/SlUCiEiooKlO4tCaW7a7G7phGtHX5IWiskraXnfARRB0CADCDDbECOI+vADZBuN5xOJ4xGIyRJwj3zz4Xl3OuRfUHhUb+u7/NViGx+DeFQkPsFjoArA0SnSBRFTDp7KFrKfKiub2IZSDGSJGPt5xvR6gvAkfDiB7ddzyLQD8xmMwoKClBQUICFB308EAgcVBJ2Y2dFDSprG9HmCyIcsaK2uxM1tT0rCbIgALKMTKsJ9iwzErEodDbPMb+uNtuNaCS8/whpOhTLANFpmD5pHD7Y+T7qWr2YzkcFKUOWZXz6xSY0eP2wx9vxH4vnYviwYUrHUjWr1YpJkyZh0qRJh3y8q6sLFRUV2Lm3JOzaXYvKuiZ4u8IIRTPg9xkBUYt4Z/MxP3/C1wKD0ZSWY6K9gWWA6DSMGDECds07aEpIaGvbA5fLpXQkOg5ZlvH5xi2oae1EVqwdywqvxNkjRigdi44iKysLU6ZMwZQph27S9fl8KCsrw87SMvz+sd0o3/YesqbfcNieAaBnE2GkZA0KFy7gI4Kj4HA00WnQaDQoGDEYopRAVV2T0nHoOGQZ2PRVMSqbvbBG23HvdZdi3NgxSseiU5CdnY1p06Zhya2L8eLzz0AO+dBRtBJyMnHI6+RkAh2rH0ci0IHly5crEzYFcGWA6DSdN2kcPt71Iepa2zFdlvkvjwFs67btKK1rhSXajjuvvQiTJ01UOhL1goKCAjz37LNYtHgxWhtKYBw3G9psNxK+FkRK1iAR6MBzzz6LgoICpaMOWFwZIDpNZ599NrLFCCJxCe3t7UrHoaPYvqMU26uaYIl14NYrpuG8abxxMp0UFhZiy+bNKJx3JSKbX4P37ccQ2fwaCudd2fPxwqNPGhBHC4l6xd+fexlrKgM4e1g+pp0zUek49A2lZRX4cmcVTDEfbpo1HnMuu0TpSNSHJEnaPzXAlboTw5UBol4wfdJY6JJh1LW0g/16YNldWYUvd1bBGOvCddPPZhFQAVEUYbFYWAROAssAUS8YPWoUshBCKJZER0eH0nFor5q6eqzfXgFj3I+rJw3B3KvmKB2JaEBiGSDqBVqtFhPOHNQzVVDboHQcAtDQ2IR1X+2EPhbAZWNcWDB/Lv+lSHQULANEvaTnUUEEtc3t4JMCZbW0tuLjTSXQx4OYeZYNixdcxyJAdAwsA0S9ZMzo0chEEMFYHJ2dfFSglPb2dnzwRTG08SCmD7bg9psXQBT5o47oWPgOIeoler0e487IhyhLqK7jowIldHZ24v31X0GMhzDZrcNdt94IjUajdCyiAY9lgKgXnTdxDHTJMGqa2/iooJ91d/vx3mdbIMfCmGAHvn/7Iuh0OqVjEaUElgGiXjR2zBhYpSACkQS6unxKx1GNQCCAok83IhkLYXRmAsuX3gKDwaB0LKKUwTJA1IsMBgPGDfdAlJOcKugnoVAY763biFgkjDNNETxw5y28mY7oJLEMEPWy6RPHQJeM8FFBP4hEonhv3QaEwhEMN4Tw0F23wGq1Kh2LKOWwDBD1svFjx8IiBRAIR9Hd3aV0nLQVi8Xw/ifrEQhFMFjbjYfuXISsrCylYxGlJJYBol5mNBoxeogLgiyhhlMFfSIeT+CDTzegKxiGR/Dhh0tvgt1uVzoWUcpiGSDqA+dNHA1tMorqpj1KR0k7iUQSH322Ae3dIeTKnXjo9gVwOp1KxyJKaSwDRH1gwrhxsCT96ArF0N3tVzpO2kgmJXyyfiNafUE4El48tOR65OfnKx2LKOWxDBD1AbPZjFGDnRDkJB8V9BJJkvHpF5vQ4O2GLd6OBxbPw9ChQ5WORZQWWAaI+sj0glHQJaOo4aOC0ybLMtZ/uQV1ezqRFfPivsKrMOKss5SORZQ2WAaI+sjECeNhTvrRGQzD7w8oHSdlyTLw5ZavUdnshTXqxfeuvwxjx4xWOhZRWmEZIOojFosFZ+c5IMgyauv5qOBUbd22Hbvq98Aa9eLOuTMwaWKB0pGI0g7LAFEfml4wGrpkFNWNrUpHSUnbSkqxvaoJllgHlnxrOqafO1XpSERpiWWAqA9NKhgPU6ILHYEwgsGQ0nFSSmlZBbZW1MEU68SNsyZi5oXnKx2JKG2xDBD1oYyMDIzIc0CAjFpOFZyw3ZVV+HJnFUwxH64/bxSuuOxipSMRpTWWAaI+Nn3CqL0HEPFRwYmoqa3D+u27YYx34+rJw3HtlVcoHYko7bEMEPWxSQXjYYr74e0KIhQKKx1nQKtvaMS6raXQx/y4fKwH3/n2NRAEQelYRGmPZYCoj2VlZeFMVxYgyKhr4KOCo2luacXazTugjwcxa4QNN39nPosAUT9hGSDqB9MmjIQ2GUNVfYvSUQaktrZ2fLixGNp4EOcNseK2mxZAFPnjiai/8N1G1A/OmTgBxng32rtDCIf5qOBgXm8H1mzYCjEewjkePe669UZoNBqlYxGpCssAUT+w2WwY7swAIKOuoVHpOANGV1c31qzfAjkWwgSHgO/fvgharVbpWESqwzJA1E+mjx/ZM1XQwEcFABAIBPDeZ18iGQtjTFYS9y+9BXq9XulYRKrEMkDUT6ZMKoAh3o09vgCi0SgAQJIkREIhSJKkcLr+FQqFUbRuI2KRMEZYYnjgzltgNBqVjkWkWlyPI+ondrsdw3Ks2BEAvvh0LbaufRefvvcW4tEIdAYjLrriWsxdtBTDR45VOmqfikSieG/dBkTCEQw3hPDgnUtgsViUjkWkaoIsy7LSIYjUYvWaD/HLv63Cxjeehi4zB6Zxl0Fn8yDe2YxwyQdI+L24/9crMfPKbysdtU/EYjEUffw5ugIhDNH68dN7b4HNZlM6FpHqsQwQ9aOPP/4Yl152GcxjZsExZxkEzYHFOTmZgLdoJcKl6/DHl4rSboUgHk9gzbrP4e0KwiP48PDdi5Cbm6t0LCIC9wwQ9atnn30W2gzHYUUAAASNFo45y6C12vHW839XKGHfSCSS+OizDWjvDiFX7sQP71jIIkA0gLAMEPUTSZKw6qWXYR5/+WFFYB9Bo4Vp/GysK3oT6bJol0xKWLt+I1p9QTgSXjy05Hrk5eUpHYuIDsIyQNRPwuEwopEwdDbPMV+nzXYjHo0gFkn9w4kkScanX2xCY3s3bPF2PLB4HoYOHap0LCL6BpYBon5iMplgMJoQ72w+5usSvhboDEbojaZ+StY3ZFnG+i83o25PJ7Lj7Vh+41UYcdZZSscioiNgGSDqJ6IoonDhAkR2fAA5mTjia+RkAqHt7+OC2al9W58sAxs3f43K5g5Yo15874bLMWb0aKVjEdFRsAwQ9aPly5cj4feio2jlYYVATibgXf04Ev4OaAePxzsffoodO3fB7/crlPbUyDLwVfE2lDXsgTXqxV3zZmJiwQSlYxHRMXC0kKifrVq1CosWL4bWaodx3Gxos91I+FoQKVmDuN+LeQsXI3PIaER0GUiIBsiCiAyTHkPdDgwdlA+Hwz6gVw22lZRia0UdLLEO3DZnGmZeeL7SkYjoOFgGiBRQXFyMFStWYNVLLyMaCcNgNKFw4QIsX74cBQUF8Pl8+HpbCTaVlKO8sR0hjRVx0QBJ1MKoEzHIacewfA9cLhe02oFzw9/OXeXYVFoNc6wTN18yEZdfMkvpSER0AlgGiBQkSRLC4TDMZvNR/7UfDoexY+dOfLmtDDuqG9ElGxDXmJEUtdCKItz2TAwf5EZ+Xh4MBuUu+qnYXYX12ytgivlww/mjcO2VVyiWhYhODssAUQpJJBLYvXs3Nm0rxdflNWiLADGtBQlBD1EUkJNpxtA8F4YMyoPVau3Vry1JEmKRCPRGI0Tx0O1GNbW1WLe1DIZYF66dPAw3zLt6QD/KIKJDsQwQpShZltHQ0IAtxSXYUlqF+s4QorpMJDQGyACyzAYMcedi2OA82Gx2nOrfzdVlO/Dmc08c9VKl+oZGfLy5BPqYH3PGenDzgvksAkQphmWAKE14vV5s3VaCzTsqsLu5AyFNBhIaAyRBA5Neg8FOB4YNcsPpdEGjObFBok/efR1//OkyaDMcR7xUacmDv0S3OQ+6eBAXj7DhtpsWHLZqQEQDH8sAURoKBoPYvmMHNm0vw86aZvhhRlxjQlLUQKcRkefIxvBBLng8edDrdUf8HNVlO3D/wjkwjZ5x1EuVQjs/wRW3/xBXTxuJu269CRrNwNnMSEQnjmWAKM3F43GUlZVh07ZSFFfUoSOu6dlnIOohQobTloFh+S4Mzs+D2Wze//tWPHwfPlv3Cdx3/N8R71KQkwk0PfFdTBpzNtZ/uhZa7ZHvWyCigY9lgEhFJElCXV0dNn1dgq92VaO5O4aILgNJjQ6QBdgyTBjizsXgfA++e8VkmKdeh+wLCo/6+Xyfr0Jk82sIh4LcJ0CUwljliVREFEUMGzYMw4YNww0A9uzZg63bSrBpx25UtfoQSGZgmz+IzTt392wWPIFLlaKR8P7xSCJKTSwDRCrmdDpxxWWX4IrLLoHf70fx9p6DjnbV7oGo1Z/QpUoGowkmU2pfqkSkdiwDRAQAyMjIwIXnn4cLzz8P0WgUzSUbUPTJGmRNv+GoewYiJWtQuHABHxEQpTjOABHRYQwGAx755S8hBTuOeqlSx+rHkQh0YPny5cqEJKJeww2ERHRUx7pUKRHowHPPPovCwqNvMCSi1MAyQETHdLxLlYgo9bEMENEJOZFLlYgoNbEMEBERqRw3EBIREakcywAREZHKsQwQERGpHMsAERGRyrEMEBERqRzLABERkcqxDBAREakcywAREZHKsQwQERGpHMsAERGRyrEMEBERqRzLABERkcqxDBAREakcywAREZHKsQwQERGpHMsAERGRyrEMEBERqRzLABERkcqxDBAREakcywAREZHKsQwQERGpHMsAERGRyrEMEBERqRzLABERkcqxDBAREakcywAREZHKsQwQERGpHMsAERGRyrEMEBERqRzLABERkcqxDBAREakcywAREZHKsQwQERGpHMsAERGRyrEMEBERqRzLABERkcqxDBAREakcywAREZHKsQwQERGpHMsAERGRyrEMEBERqRzLABERkcqxDBAREakcywAREZHKsQwQERGpHMsAERGRyrEMEBERqRzLABERkcqxDBAREakcywAREZHKsQwQERGpHMsAERGRyrEMEBERqRzLABERkcqxDBAREakcywAREZHKsQwQERGpHMsAERGRyrEMEBERqRzLABERkcqxDBAREakcywAREZHKsQwQERGpHMsAERGRyrEMEBERqRzLABERkcqxDBAREakcywAREZHKsQwQERGpHMsAERGRyv1/HebaFFTt6jwAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -200,7 +200,7 @@ { "data": { "text/plain": [ - "" + "(, )" ] }, "execution_count": 7, @@ -209,7 +209,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAADW9ElEQVR4nOzddXhUxxrA4d/uxt1DCCFYggR3h6ABghRI0ALFtTgUKRRKseLFpUDx4O5e3N3dibtsds/9I81eQoSNA5n3efa53Jxz5swmac63M998I5MkSUIQBEEQhBxLnt0dEARBEAQhe4lgQBAEQRByOBEMCIIgCEIOJ4IBQRAEQcjhRDAgCIIgCDmcCAYEQRAEIYcTwYAgCIIg5HAiGBAEQRCEHE4EA4IgCIKQw4lgQBAEQRByOBEMCIIgCEIOJ4IBQRAEQcjhRDAgCIIgCDmcCAYEQRAEIYcTwYAgCIIg5HAiGBAEQRCEHE4EA4IgCIKQw4lgQBAEQRByOBEMCIIgCEIOJ4IBQRAEQcjhRDAgCIIgCDmcCAYEQRAEIYcTwYAgCIIg5HAiGBAEQRCEHE4EA4IgCIKQw4lgQBAEQRByOBEMCIIgCEIOJ4IBQRAEQcjhRDAgCIIgCDmcCAYEQRAEIYcTwYAgCIIg5HAiGBAEQRCEHE4EA4IgCIKQw4lgQBAEQRByOBEMCNkqPDycoKAgJEnK7q4IgiDkWCIYELKcUqlk2bJllCxVGhMTEywtLcmdx4lJkyYRGBiY3d0TBEHIcWSS+EgmZKGoqCiaNW/O4cOHMS5UEQPXasgUukS9uEbkvZM4Ozlx4vgxnJycsrurgiAIOYYIBoQs1b9/fxYvXY51y18xzFc6wTFl0Hv8N43GrWBeLl+6iEwmy55OCoIg5DAiGBCyTGBgIA65HTEo3xKLau2SPCfy2VU++ozj9OnTVK9ePYt7KAiCkDOJnAEhy+zatYvoqEhMS3kke45BvtIYWDmwcePGLOyZIAhCzqaT3R0Qvg9hYWG8efMm0evt27cJ/j8KXRQmlsm2I5PJkZva4u/vn4W9FwRByNlEMCCkKDY2lg8fPqT4gH/z5g2hoaHaNahSEhvih46ZTZKHJbUKVfAH7OxqZ9ybEARBEFIkgoEcSpIkQkJCUnzAv337lvfv36NWq7Vq09TUFEdHx0Sv3Llz4+joiJmZGWXLlyf0+n4sa/6YZBuRT68QHfSB9u3bZ+TbFQRBEFIggoHvkFKp5N27dyk+5N+8eUN4eLhW7SkUChwcHBI93D9/4Juamn6xrf59+zJz1iz0HVwwcqmc4FiM7wsC9s+lSrVqVKxYMU3vXRAEQUg9EQx8QyRJIjAwMMUH/Js3b/j48aPWFf0sLCySfcDHf93Ozg6FQpEh7+GPP/7g8ZMnbN82CSPnEui7VEWmo0fU0ytEPDoPQK0aNcSyQkEQhCwklhZ+JaKjozWf5pMbun/79i2RkZFataerq0vu3LmT/RQf/7/GxsaZ/M4SU6lUbN26lb/mL+Ds2TOoVSqQK5BJaiRJQi6Xc+TIEdzd3bO8b4IgCDnRdxMMvHz5kqVLl3Lu/HnUajXlypalV69euLi4ZGu/JEnC39//iwl4fn5+WrdpZWWV7AM+/mVjY4Nc/vWvHJUkCbVaTfny5bl+/TqVK1fm/Pnz2Nvbc+3aNRwcHLK7i4IgCN+9bz4YkCSJqVOnMnbsWOR6hujlLQUyOcpXN1FGhDB06FCmT5+eKQ/GyMhIzYM9qQd8/NdjYmK0ak9PTy/FB7yjoyMODg4YGhpm+HvJbrNnz2bIkCFUqFCByMhIbt++Ta1atThy5Ag6OmI2SxAEITN988HAX3/9xc8//4xZFW/MK3sh14t7UKqV0YRe3UPQyVX8OnYsEydO1LpNtVqNr6/vFxPwAgICtG7T1tY2xXl5R0dHrK2tc+xc+fv373F0dEStVnPgwAFat25NWFgYo0eP5o8//sju7gmCIHzXvulgIDIyEofcjqjyVcK6Yf8kzwk6tYbIqzt5++Y11tbWhIeHfzEB7927dyiVSq36YGBgkOIDPv7TvL6+fka+9e9So0aNOHDgAL/++itubm60bdsWgL1799K4ceNs7p0gCML365sef92+fTvBQYHkrtgy2XNMyzcj5MIW3NzciIqKIjg4WKu2ZTIZdnZ2Xxy2t7CwyLGf5jPajz/+yIEDB1i7di1Pnjzh9OnTLFiwgB9//JFr166RN2/e7O6iIAjCd+mbDgYePXqEvpk1upa5kz1HYWSOwtKBDx9ea75mbGz8xTXzDg4O6OrqZsXbEP7TokULTExMePbsGWfOnGHmzJlcuHCBy5cv4+3tzalTp9DT08vubgqCIHx3vulgQF9fH1VMFJJahUye9Dp4SZKQq2Jo3bo1EyZM0FTCE5/mvz5GRka0bt2aVatWsWbNGqpXr46Pjw9ly5blwoULjBgxgjlz5mR3NwVBEL47X//asxTUq1eP2KhwIp9cTvac6Df3iQn6SLdu3ShWrBjm5uYiEPiK/fhjXJniTZs2ERUVRf78+Vm9ejUAc+fOZcuWLdnZPUEQhO/SNx0MlC9fnvIVKhJ6+h9UkYk3ylHHRBF8fDn5ChSkQYMG2dBDIbVq166Nk5MTwcHB7NmzB4BmzZoxfPhwALp27crjx4+zs4uCIAjfnW86GABY889qDFVh+K4dQui1fajCAlFFBBN26yjvVg8i6t0jpk+d8k0U4BFALpfToUMHANasWaP5+h9//EH16tUJDQ2ldevWWldiFARBEL7sm15aGO/x48cMGTqUvXv2JNhhz8DQkKjISEqUKMGFCxe+y2I936O7d+/i5uaGjo4Ob9++xdbWFoA3b95QpkwZfH196d69O8uWLcvmngqCIHwfvouPy4UKFWLXzp08f/6cbdu2MWTIEACc8uTBzs6OW7duMWjQoOztpKC1YsWKUbZsWWJjY9m0aZPm646Ojqxfvx6ZTMby5cv5559/srGXgiAI34/vYmTgc8HBwdjY2BAbG8vq1avp0qULkiSxYcMGTSEb4es2d+5cBg0aRMWKFblw4UKCYxMmTOC3337DyMiIixcv4ubmlk29FARB+D58FyMDnzM3N6dmzZoABAQEMGbMGAB69OjBo0ePsrNrgpbatWuHQqHg4sWLPHjwIMGxsWPHUq9ePSIiIjRliwVBEIS0+y6DAYCmTZsCsGfPHsaPH0+NGjUICwvD29ubqKiobO6d8CV2dnY0bNgQSJhICKBQKFi3bh25c+fm/v379OrVi+9wgEsQBCHLfLfBgKenJwAnT54kPDycDRs2YGNjw/Xr1xk6dGg2907QRqdOnQBYu3ZtgsRQiAsWNm3ahEKhYP369SxZsiQ7uigIgvBd+G6DgUKFClGkSBFiY2M5ePAgjo6Omk+YCxcuFMVrvgHNmjXDzMyMFy9e8O+//yY6Xr16daZMmQLAwIEDuXr1alZ3URAE4bvw3QYD8P+pgt27dwPg4eHByJEjAejWrRtPnjzJtr4JX2ZoaEjr1q0Bkl05MGzYMJo1a0ZMTFzJ6aCgoCzsoSAIwvfhu1xNEO/06dPUrFkTKysrPn78iEKhQKlUUrt2bc6ePUu5cuU4c+aM2F74K3bixAnc3d0xMzPj/fv3SdaKCAwMpGzZsjx//pwWLVqwbds2UXJaEAQhFb7rkYEqVapgaWlJQEAA586dA0BXV5eNGzdiZWXFlStXGDFiRDb3UkhJzZo1yZs3LyEhIZoRns9ZWlqyefNm9PT02LFjB7Nnz87iXgqCIHzbvutgQEdHh8aNGwMkeJA4OTlpNr+ZN28e27dvz5b+CV8ml8vp2LEjkHhVwafKly+vCQJGjhzJ2bNns6R/giAI34PvOhiAhEsMP+Xp6alZVdC1a1eeP3+e1V0TtBS/k+H+/fv5+PFjsuf16dOHtm3bEhsbi7e3N76+vlnVRUEQhG/adx8MNGzYEB0dHe7evcvTp08THJsyZQqVKlUiKCiINm3aEBMTk029FFJSpEgRKlSogEqlYuPGjcmeJ5PJWLp0KYULF+bNmzf8+OOPiZYkCoIgCIl998GAhYUFNWrUAEg05xyfP2BhYcHFixcZPXp0dnRR0EL86EBKUwUApqambN68GUNDQw4ePMgff/yRFd0TBEH4pn33wQAkXmL4qXz58rFy5UoAZs6cmWg6Qfg6tG3bFh0dHS5fvsy9e/dSPLdEiRIsXLgQgPHjx3P06NGs6KIgCMI3K0cFAydPniQkJCTR8RYtWjBw4EAAOnfuzKtXr7K0f8KX2dra4uHhAXx5dACgS5cudO3aFUmSaN++PW/fvs3sLgqCIHyzckQwUKhQIQoXLqypRpiU6dOnU758eQICAmjbti1KpTKLeyl8SXx54nXr1mmVCzB//nxKlizJx48fadeuHbGxsZndRUEQhG9SjggGIOWpAgA9PT02bdqEmZkZZ8+e5ddff83K7glaaNq0Kebm5rx8+ZJTp0598XxDQ0M2b96Mqakpp06dEj9TQRCEZOS4YGDfvn2oVKokzylQoAArVqwAYNq0aezfvz/L+id8mYGBAV5eXkDy5Yk/5+rqqvmZTp06VeSECIIgJOG7Lkf8qdjYWOzs7AgMDOTff/+lWrVqyZ7br18/Fi5cqNnl0NHRMQt7KqQkvsS0qakp79+/x8jISKvrfv75Z/766y8sLS25du0azs7OmdxTQRCEb0eOGRnQ0dGhUaNGQPJTBfFmzpxJ6dKl8fPzE3PNX5lq1aqRL18+QkND2bVrl9bX/fnnn1SoUIHAwEC8vb1FTQlBEIRP5JhgAL6cNxDPwMAAHx8fTExMOH36NL/99lsW9E7QhrbliT+nr6/P5s2bsbS05OLFiwwbNiyzuigIgvDNyTHTBBC3u52trS0qlYonT55QoECBFM/fuHEj7dq1QyaTcfDgQerXr59FPRVS8vDhQwoXLoxCoeDNmzfY29trfe2ePXs0QaGPj48mB0EQBCEny1EjA5aWlppqhNokkrVt25aePXsiSRIdO3bk3bt3md1FQQuurq5UqlQJlUrFhg0bUnWtp6cnI0eOBKBbt248fPgwM7ooCILwTclRwQBoP1UQb86cOZq16h06dEh2JYKQtbQtT5yUSZMmUaNGDUJDQ/Hy8iIyMjKjuycIgvBNybHBQHLVCD9naGiIj48PxsbGHD9+nEmTJmV2FwUttGnTBh0dHa5evcqdO3dSda2Ojg4bN27Ezs6OmzdvMmDAgEzqpSAIwrchxwUDLi4uuLq6olQqOXTokFbXFC5cmMWLFwMwYcIEjh8/npldFLRgY2NDkyZNgLSNDuTOnZv169cjk8lYsWIFq1evzuguCoIgfDNyXDAAqZ8qAOjYsWOCWvcfPnzIrO4JWoqfKtC2PPHn6taty4QJEwDo06cPt2/fztD+CYIgfCty1GqCeCdPnqR27drY2Njw/v17FAqFVtdFRERQsWJF7ty5Q/369Tlw4AByeY6Mp74K0dHR5MqVi6CgII4ePUqdOnVS3YZaraZRo0YcOnSIwoULc+nSJUxNTTOht4IgCF+vHPkkq1q1KhYWFvj5+XHhwgWtrzMyMsLHxwdDQ0MOHz7MlClTMrGXwpfo6+vj7e0NaF+e+HNyuZy1a9fi6OjIgwcPNKtHBEEQcpIcGQzo6upqXY3wc8WKFWPBggUAjBs3TqsNc4TME7+T4datW4mIiEhTG7a2tvj4+GgSC+PzQwRBEHKKHBkMQNryBuJ16dKFH3/8EbVaTbt27fD19c3o7glaqlq1KgUKFCAsLIwdO3akq52pU6cCMGjQIC5fvpxBPRQEQfj65dhgwMPDA4VCwZ07d3j27FmqrpXJZCxcuJAiRYrw9u1bOnXqlKYENiH9ZDKZpjxxWqcK4g0ZMoQWLVoQExODl5cXgYGBGdFFQRCEr16ODQYsLS2pXr06oF01ws+ZmJjg4+ODgYEBBw4c4M8//8zoLgpaig8GDh8+nK4qkTKZjJUrV5I/f36eP39Oly5dRP6AIAg5Qo4NBiB9UwUAJUqUYN68eQCMGTOGs2fPZljfBO25uLhQpUoV1Gp1qssTf87CwoLNmzejp6fHrl27mDlzZgb1UhAE4eslggHgxIkTWlUjTEr37t1p164dKpWKtm3b4u/vn5FdFLSUnvLEnytXrhxz584F4JdffuHMmTPpblMQBOFrlqODAVdXV1xcXFAqlRw+fDhNbchkMpYsWYKLiwuvXr3ip59+EkPL2cDb2xtdXV2uX7/OrVu30t1er169aN++PSqVijZt2ogkUUEQvms5OhiA9E8VAJiamuLj44O+vj67d+9m9uzZGdU9QUvW1tZ4enoCGTM6EB/kFSlShDdv3ohNqgRB+K6JYOC/YGDv3r3p+mNfunRpTRAwcuTIVBUzEjLGp+WJM+LBbWJiwpYtWzRFpv744490tykIgvA1ypHliD+lVCqxs7MjKCiIM2fOULVq1TS3JUkSbdq0YfPmzTg7O3Pt2jUsLS0zsLdCSqKjo3FwcCAwMJBDhw5Rv379DGn3n3/+oXPnzshkMg4dOkS9evUypF1BEISvRY4fGdDV1cXDwwNI2xLDT8lkMpYtW0aBAgV48eKFZmMjIWvo6+vTpk0bIGOmCuJ16tSJ7t27azapevPmTYa1LQiC8DXI8cEAZEzeQDxzc3N8fHzQ09Njx44d/PXXX+luU9BefHnibdu2ER4enmHtzps3j1KlSuHr60vbtm2JjY3NsLYFQRCymwgG+H81wtu3b/P8+fN0t1euXDlmzJgBwLBhw0Rp2yxUuXJlChUqRHh4ONu3b8+wdg0NDdm8eTOmpqb8+++/jBkzJsPaFgRByG4iGACsrKyoVq0akP6pgnj9+/fnhx9+QKlU0qZNG4KDgzOkXSFlGVme+HMuLi6sXLkSgOnTp2fISJIgCMLXQAQD/8nIqQKIeyitWLGCfPny8fTpU82cs5D54lcVHD16lLdv32Zo261atWLgwIEAdO7cOUNGkgRBELKbCAb+82k1wtDQ0Axp09LSko0bN6Kjo8OWLVvE1rhZpECBAlSrVg21Ws369eszvP3p06dTqVIlAgMD8fLyIjo6OsPvIQiCkJVEMPCfwoUL4+LiQkxMDIcOHcqwditVqsS0adMAGDx4MNevX8+wtoXkxY8OZPRUAYCenh4+Pj5YWVlx+fJlhg0bluH3EARByEoiGPhEfAW7jMobiDd48GCaNm1KdHQ03t7eGTbyICTP29sbPT09bt26xY0bNzK8/bx582qWL86fP59NmzZl+D0EQRCyiggGPpFR1Qg/J5PJWLVqFU5OTjx69IhevXqJ/IFMZmlpqfl5ZmTNgU81btyYUaNGAXEbVj148CBT7iMIgpDZRDDwierVq2Nubo6vry8XL17M0LatrKzYuHEjCoWCDRs2sHz58gxtX0js0/LEmVUXYOLEidSqVYuwsDC8vLyIiIjIlPsIgiBkJhEMfCIjqxEmpWrVqkyePBmAn3/+mZs3b2b4PYT/a9SoEdbW1rx//56jR49myj10dHTYsGED9vb23Lp1i/79+2fKfQRBEDKTCAY+k9FLDD83bNgwGjVqRFRUFN7e3oSFhWXKfYS4RL+2bdsCmTdVAODg4MCGDRuQy+WsXLlSU4tAEAThW5HjNyr6XEBAALa2tqjVap4/f46zs3OG38PPz4/SpUvz5s0bfvzxR1avXo1MJsvw+whw4cIFKleujJGREe/fv8fU1DTT7vXHH38wduxYDAwMuHDhAiVLlsy0ewmCIGQkMTLwmU+rEWbW6ICNjQ0bNmxAoVCwZs0aVq1alSn3EaBixYq4uLgQERHBtm3bMvVeo0aNwsPDg6ioKLy8vAgJCcnU+wmCIGQUEQwkIX6qIDPyBuLVqFGDiRMnAtCvXz/u3LmTaffKyWQymSaRMDOnCgDkcjlr1qwhT548PHz4kJ49e4pVI4IgfBPENEES7t+/T9GiRdHT08PPzy/ThpbVajWNGjXi0KFDFCtWjIsXL2JsbJwp98rJnj17RoECBZDJZLx8+ZI8efJk6v3OnTtHzZo1iY2NZf78+fTr1y9T7ycIgpBeYmQgCYULF6ZQoULExMRw+PDhTLtP/CfJXLlycffuXQYMGJBp98rJ8ufPT40aNZAkKVPKE3+uSpUqTJ8+HYgrOHXp0qVMv6cgCEJ6iGAgCTKZLNOqEX7Ozs6O9evXazLRM3soO6f6tDxxVgyGDRo0iJYtW6JUKvHy8iIwMDDT7ykIgpBWIhhIxqfVCNVqdabey93dnXHjxgHQp08f7t+/n6n3y4m8vLzQ19fnzp07WbI/hEwm4++//6ZAgQK8ePGCzp07Z/rvkSAIQlqJYCAZNWrUwMzMjI8fP2Z4NcKkjB07ljp16hAeHo63tzeRkZGZfs+cxMLCgmbNmgGZn0gYz9zcnC1btqCvr8/u3buZMWNGltxXEAQhtUQwkIxPqxFm1hLDTykUCtatW4ednR23bt1i0KBBmX7PnCZ+qmD9+vWZVp74c2XKlGHevHkAjB49mtOnT2fJfQVBEFJDBAMpyIolhp/KlSsX69atQyaTsXTpUjZu3Jgl980pPDw8sLGx4cOHD5maGPq5Hj160KFDB1QqFW3btuXjx49Zdm9BEARtiGAgBY0aNUIul3Pz5k1evHiRJfesV68eY8aMAeIeIo8ePQLiliFGR0dnSR++V7q6urRr1w7IuqkCiMsfWLx4MUWLFuXt27eawEAQBOFrIYKBFFhbW2uqEWbV6ADA+PHjqVmzJmFhYXh4eODh0QhdPT0MDAyws8/F2LFjeffuXZb153sSP1WwY8eOLK0QaGJiwpYtWzAyMuLIkSP8/vvvWXZvQRCELxFFh75g+vTpjBw5koYNG3LgwIEsu+/r169xdXUlMjISfbv8GBWvh9zQhJh3D4m8exxzE2OOHT0i6t+nkiRJFC1alAcPHvD333/z008/Zen9165dy48//ohMJmPz5s28evWKCxcuIEkSZcqU4aeffsLOzi5L+yQIgiCCgS+4d+8exYoVQ09PD39/f0xMTLLkvn///TfdunXDsm4PTMs1S7CRkSoiGP8t4zEngsePHoqqhak0efJkxowZg7u7O8eOHcvy+/fq1YulS5eCTI5cLsfAsQjI5ES/fYAcid9/n8iIESPE5lWCIGQZMU3wBUWKFKFgwYKZXo3wU5IkMWXadIwLV8OsfPNEDwWFkTmWTUfy/v07kWSYBh06dADgxIkTvHr1KsvvX6FCBQBMSjUgd5+V2Labim3byTj0WYVhGU9++eUXZs+eneX9EgQh5xIjA1oYNGgQc+fO5aeffuLvv//O9Ptdv36dMmXKYNdmEob5Sid73kefX8klC6FXzx4oFIpUv+RyeZquS8v1X9un3Nq1a3Py5EmmTJnCL7/8kmX3jYmJIbdjHqLsimHtOSzJ70vAkSWo7h/j3du3mJmZZVnfBEHIuXSyuwPfgqZNmzJ37lxNNUK5PHMHVHx9fQHQtXRI8Twdy9w8u34zSx9maSWTybI1GEnqWoA///wTX19fdHR0suT+p06dwt/PF4dm3skGSGYVW/H22j7Wr19P7969s/LHJAhCDiWCAS18Wo3w0qVLVKpUKVPvZ21tDYAy6D065vbJnqcMfAdSXIlbXV1dbGxssLa2xsrKCnNzc2QyGSqVKtmXWq1O8fiXXp9e/6VSu5IkERsbm2XFfrQVEBDArFmzsvSeckMz9Gydkz2uY2aDoa0Td+/ezcJeCYKQk4lgQAt6enp4eHjg4+PD7t27Mz0YKF26NAUKufDhxgEMnUsleY4y6D1Rz67h4lKI169fExkZybt37zRLDuVyOSVKlKBq1apUqVKFqlWrarbxzQySJKU6uMjIYCQtr61bt3L37l3KlStHrVq1suT+vr6+BIZGIklqZLLkR5hioiK4d+8e/v7+muBQEAQhs4icAS2tWbOGTp06UbJkSW7cuJHp91u2bBk9e/bEqkFfTMs0TnBMFRnCh02/ohP6ng/v32FgYMCNGzc4e/Ys586d4+zZs7x8+TJRm3Z2dlSpUkUTHJQvXx5DQ8NMfy9fq7179+Lp6YmtrS1v3rxBV1c30+959OhR6tWrh5337xjmL5PkOdHvH/N+9SAAdHR0qFevHt7e3rRo0QJLS8tM76MgCDmPCAa05O/vj52dHWq1mhcvXpA3b95MvZ8kSQwaNIh58+ahl6sQJiXqITcwJfrdQ8JvHUYdEwWSmv79+zNv3rxEn/jfvHnDuXPnNMHB1atXiYmJSXCOjo4OZcqUSTB64OTklKnv62uiVCrJkycPHz9+ZM+ePTRp0iRT73fq1Cl69uzJg4eP0LXNR64O05HrGSQ4R1Ip8dvyG4rAF+R3zsvNmzc1x3R1dWnQoAHe3t40b94cc3PzTO2vIAg5iCRorXr16hIgLViwIEvup1arpb/++ktCJpOAuJdMLjk7O0uzZ8+WZP99ffjw4ZJarU6xrcjISOnMmTPSjBkzpJYtW0q5cuX6f5ufvBwdHSUvLy9p1qxZ0vnz56Xo6Ogsea/ZZeDAgRIgtWnTJtPuERAQIHXv3l3zPbayspL09A0kg1wFJZsWo6S8w3ZIeYfvlGxbj5cM8xSVdHX1pKNHj0qSJEn379+XJk6cKBUvXjzBz0lPT09q1qyZtHbtWik4ODjT+i4IQs4ggoFUmDp1qgRIHh4eWXbPP//8U3PPy5cvax4EYWFh0pIlSzQPh3HjxqWqXbVaLT179kxat26d1L9/f6ls2bKSQqFIFBzo6+tL1apVk4YPHy5t27ZNevfuXSa90+wR/z01MDCQgoKCMrRttVotbdy4UbK3t9d8P3v27CkFBARIV69elcpXqPBJkBcX2JUqXUY6ffp0ku3duXNHGj9+vFSkSJFEP6MffvhB2rBhgxQaGpqh70EQhJxBBAOpcOfOHc3DOKv+6NavX18CpDlz5khqtVrKmzevBEj79u2TJEmS5s6dq3koTJkyJV33CgsLk44fPy5NnjxZ8vT0lKytrZMcPcifP7/UoUMHaf78+dLVq1clpVKZEW81W6jVaqlo0aISIC1fvjzD2n3+/LnUuHFjzfesSJEi0qlTpxKcc/DgQQmQbGxspCVLlkgXL1784ghPfJ9v3bol/frrr5Krq2uCn42BgYHUqlUrycfHRwoLC8uw9yMIwvdNBAOpoFarpQIFCkiAtH379ky/X0REhKSvry8B0t27dyVJkqQePXpIgDRw4EDNefEjFoA0e/bsDLu/Wq2WHjx4IK1atUrq2bOnVLx4cc3UxKcvY2Njyd3dXRozZoy0Z88eyc/PL8P6kBWmTJkiAVKtWrXS3ZZSqZRmzpwpGRkZaQLH3377TYqKikp07m+//SYBUocOHdJ8P7VaLV2/fl0aPXq0VLBgwQQ/FyMjI8nb21vaunWrFBERkZ63JQjCd04EA6kUP8fctWvXTL/XgQMHJEBycnLSfGLcsmWL5pPmp+IfLIC0aNGiTOtTUFCQdPDgQem3336TGjRoIJmZmSU5elC4cGHpp59+kpYuXSrdvn1bUqlUmdan9Hr58qUmyHn+/Hma27l8+bJUtmxZzfegZs2a0r1795I938PDQwKkv/76K833/JRarZauXLkijRw5UsqfP3+igK1du3bS9u3bpcjIyAy5nyAI3w8RDKTS4cOHJUCyt7fP9AfckCFDJEDq1q2b5muBgYGauf0XL15ovq5Wq6WRI0dq/vivXLkyU/sWT6VSSbdu3ZKWLl0qdenSRSpcuHCSwYG5ubnUsGFDacKECdKhQ4e+uqQ3d3d3CZAmTZqU6mtDQ0OlIUOGSHK5XAIkCwsLafny5Sn+fqhUKsnCwkICpMuXL6en60lSq9XSxYsXpWHDhmmmluJfpqamUseOHaVdu3YlOWIhCELOI4KBVIqOjtZ8Gr5w4UKm3is+g3zTpk0Jvl61alUJkJYuXZrg62q1Wvr5558lQJLL5dKGDRsytX/J8fPzk/bs2SONHj1aql27tmbI/NOXTCaTSpQoIfXq1UtatWqV9PDhQ63myzPL33//rRnRSE0/9u7dKzk7O2veV9u2bbVKsrx7964ESIaGhlJMTEx6uv5FarVaOnfunDR48GApT548iYK0zp07S3v37v3uV44IgpA8EQykgZeXlwRIY8eOzbR7vH79WvPQ9Pf3T3AsfkqgdevWia5Tq9VSz549JUBSKBTStm3bMq2P2lIqldKVK1ek+fPnS+3bt080hB3/srGxkZo2bSpNnjxZOnHihBQeHp5lfQwODpYMDQ0lQLp48eIXz3/37p3Upk0bTd+dnZ01SZ3aiA8+atSokZ5up5pKpZLOnDkj/fzzz5KDg0OC77+lpaXUtWtX6cCBA5keoAiC8HURwUAarF69Om4ZWKlSmXaPlStXSoBUsWLFRMfOnTunGY5OKpNfpVJJnTp1kgBJV1dX2rt3b6b1M63evXsnbdu2TRo2bJhUrVo1TaLkpy8dHR2pXLly0oABA6T169dLz58/z9TRg3bt2kmANGDAgGTPUalU0rJlyzRD/HK5XBo6dGiqM/fjE0FHjBiR3m6nmUqlkk6dOiX1798/wfJHQLK2tpZ69OghHT58+JteLSIIgnZEMJAGvr6+mvnhly9fZso94h9MSY0+xMbGSpaWlhIgnT17NsnrlUql5O3trVmHfuTIkUzpZ0aJioqSzp8/L82aNUtq3bq1lDt37iRHDxwcHKRWrVpJM2bMkM6ePZuhc9779u3TjFAk9cn43r17Uo0aNTR9KVu2rHTlypU03atEiRIS8FWM3EhS3O/U8ePHpT59+ki2trYJvue2trZS7969pWPHjkmxsbHZ3VVBEDKBCAbSqFq1ahIgLVy4MMPbVqlUko2NjQQkWpseL36qYvz48cm2ExMTIzVv3lwzN51cW18jtVotvXjxQtq4caP0888/SxUqVJB0dHQSBQd6enpSlSpVpKFDh0pbtmyR3r59m+Z7KpVKzSfk0aNHS+vXr5fOnTsnRUZGSuPHj5f09PQ0S/ZmzZqV5k/MwcHBmtUL6elvZlEqldKRI0eknj17Jqo1YW9vL/Xr1086efKkCAwE4TsigoE0il/b36hRowxvO74qnqmpabJzt8uXL5cAqXLlyim2FRUVpVnCZmJiIp0/fz7D+5tVwsPDpVOnTklTp06VmjdvnugT7Kfz9+3atZPmzZsnXb58Wev576CgoLikzc9qKejpG2j+3bhx43QtP5QkSTpy5Iimn1+7mJgY6eDBg1K3bt00o1GfjtIMGDBA+vfff7/qpaOCIHyZCAbS6Pbt25oh+Iyu9DZ58mQJkJo3b57sOS9fvtTMWQcEBKTYXkREhFSnTh1NnsHVq1cztL/ZRa1WS48fP5b++ecfqXfv3lKpUqU00zefvgwNDaVatWpJo0aNknbt2iX5+vomais4OFgqUbKUpGNoIlnU+FFy7LNSchq8RbJrM0kyyF9OAqTu3btnSM7C77//rll58C2Jjo6W9u3bJ3Xp0kUyNzdP8D12dHSUBg0aJJ09ezZbV4UIgpA2YtfCNJIkiYIFC/Ls2TN27NhB8+bNM6xtd3d3Tpw4wYIFC+jbt2+y5xUrVox79+6xefNmWrdunWKb4eHhNGzYkDNnzmBtbc2JEycoXrx4hvX5axEaGsrFixc12zmfO3eOoKCgROe5uLgk2K1x+fLlLFy6Atv209CzzZfgXEmSCDyyhPAb+3n+7Fm6d3b09PRk7969zJkzh4EDB6arrewSHR3N4cOH8fHxYceOHYSGhmqO5c2bFy8vL7y9valQoUKiHTUFQfj6iGAgHQYOHMi8efPo1q0by5cvz5A2w8LCsLKyQqlU8vjxYwoWLJjsuYMHD2bOnDl0796dZcuWfbHtkJAQ6tWrx6VLl7C3t+fUqVO4urpmSL+/Vmq1mgcPHmiCg7Nnz3Lv3r3EJ8rlmFVshWWtzkm3ExPJu0WdGTl0MJMmTUpzfyRJwtbWFn9/fy5cuEDFihXT3NbXIioqikOHDrFp0yZ27dpFWFiY5li+fPnw9vbG29ubsmXLisBAEL5SIhhIh8OHD9OgQQOsrKwYNmwYb968ITY2Fjs7O2rUqEGdOnVQKBSpanPPnj00bdqUAgUK8OTJkxTPPXDgAI0aNcLJyYkXL15o9Yc2ICCAOnXqcOPGDRwdHTl16hQFChRIVR+/dX5+fhw5coQTJ05w6dIlbt26hVKpxKHr/ESjAp/y3f0nRY0iuHzpYprv/ejRI1xdXdHX1yckJAQ9Pb00t/U1ioyM5MCBA2zatIndu3cTERGhOVawYEFNYFCqVCkRGAjCV0QEA2ng5+fHwIGDOHPpBi+f3EVSqzEvWAldE9u4E9SxyFWRyFWRmBso6PajNw3quePm5oaOjk6Kbf/888/89ddf9O7dm0WLFqV4bkREBFZWVkRHR3P37l2KFi2qVf99fX2pXbs2d+/exdnZmVOnTpE3b16trv1axcbG4uvry4cPH/jw4QMfP37U/Pvz/+/r60tsbGyiNnL3Wo6uRa5k7+F/cD5hNw/jUrAAxYoVo1ixYhQtWpRixYpRpEgRjI2Nv9jPf/75h86dO1O1alXOnDmTrvf8tYuIiGDfvn34+PiwZ88eIiMjNcdcXV01gUHx4sVFYCAI2UwEA6kQFBREY89mPPONItbQHpWuKWFPzqIMfIGBQ3EMc/83By+TI8kUIJMhk9TIVNHIlaGYKKIpUTg/1SqUpFa1SpQuXRoDA4ME9yhcuDAPHz5k+/bttGjR4ot9ql+/PkeOHEn1/PP79++pWbMmjx49olChQpw8eZLcuXOn5tuR6aKiohI91JN70Pv7+5PaX2V9fX2io6M1/9+6yRBMitdJ8lxJkni7vDexAW+Sbc/Z2VkTJMQHCkWLFsXCwkJzTp8+fVi8eDFDhw5lxowZqervtywsLIy9e/fi4+PDvn37iIqK0hwrUqQI3t7etGnThmLFimVjLwUh5xLBgJZmzZrFjEX/EGPsjErfApk6Fn1ZLObyUB5c2I9TgSKMn79Zc35wcDBnz53FPyCIsGgVr99+JEqpQiZJyNTRyJXh6KvDKFrQkSpli1OrWkVsbW0pVaoUCoUCf39/zM3Nv9ivGTNmMHz4cBo1asS+fftS9Z5evXpFzZo1ef78OUWLFuXEiRPY2dml+nujLUmSCAsLS/ah/vnXQkJCUtW+XC7H1tYWe3t77OzssLe3T/CK/9rt27cZN24cL168AKBt27a8fvOWyw9fY9dxJjId3URtRzy+iO/Wifj4+GBtbc3du3c1r3v37vHx48dk+5U7d27NCML27dt5/fo1y5cvp1u3bqn7Bn4nQkND2b17Nz4+Puzfv5+YmBjNMTc3N01gULhw4WzspSDkLCIY0MJPP3Vl3/kHKE3yAXJsTGT07dMbU1MzQoMDGNK+NpIkMX31Yaxskx5mliQ1Hz585PHTpzx6+pIXbz4SFhn9X3AQgyw2kpiPdwl995jceZxYtHABlStV+uLD+datW5QsWRJDQ0MCAgISjTR8ybNnz6hZsyavX7+mZMmSHD9+HCsrK62vlySJgICAFIflP/3ap0PF2tDV1U32of7516ytrVPM0Xj//j2DBg1i06ZNQNwn+UWLFtGoUSMOHjyIR6PGGOQvg3XDfuiYxX3fJbWKiIfn8N87GzMTQ169fImpqWmitv38/Lh37x737t1LECS8fv062f7Y2NgkmGqI/3fu3LlzzLB5cHAwu3btwsfHh4MHD6JUKjXHSpYsqZlKcHFxycZeCsL3TwQDXzBixEhW7zmL0iQ/sthIunTwSjSUOWXojzy5d53WXYdSpY4npuaWyL+QOCgR9xB9+vQZD5++4Pmr97y+uv+/KYcSGNsXRBETRB5bUyqWLkqtKuWoXKkizs7OCR4UkiSRJ08e3r59y+HDh6lXr16q3+PDhw+pVasW79+/p3z58hw4cAClUqnVp/ePHz8mOf+eEmNj4y9+eo9/mZubp/vBqFar+fvvvxk+fDhBQUHI5XIGDx7MhAkTMDY2Jioqinr16nHmzBnkCh0ktRo9JzcUhmbEvHtIbIgvMrkCSa2iTp067N27V+ugKzg4mPv373P37l0OHjzIpk2bUCgUqNXqZKc1zMzMEgUJxYoVI2/evMjl8nR9L75mQUFB7NixAx8fHw4fPpzg96pMmTKawCCnJbwKQlYQwUAKbt++TYOWnYkyL4ZcHcnoEYMxN0s4dK9UxrDojyHcvPQvSCoATMytqeXRknotfsTU3FKre6lUsQxqW5PI8FAqNe9NULQOHwNCkACZOhaZKgpFTDA2JjpUKFWYGpXKUK1KJQoXLky3bt1YtWoVw4YN488//0yy/ejo6BQ/vT958oQrV66gUqnS9L2ysLDQ6tO7vb29Vol2GeX+/fv07NmT06dPA1C2bFmWLVtG2bJlgbhgqmPHjqxfvx5zc3OOHDnC5cuX6dMnrr5DkyaN2bt3LwBGRkZERETQtGlTtm7diq5u4umElEyZMoXRo0fj5eXFqlWrePDgQYJRhLt37/L48eNkfwZGRkYUKVIkUaBQoECBLyamfmsCAgLYsWMHmzZt4ujRowm+J+XLl8fb2xsvLy/y5cuXfZ0UhO+ICAZS4FayDB8U+VHrGNK/WzucnfMlOB4dFcmccX15fPcahi6VMSpSA5lCh6jn14m4cwxzC0tGTv0ba/svJ+Y9uX+DKUM6YmRiypwNp5ErFERGRvL8xXMePXnOk5dvef8xELUkgVoVl3cQGYChPAIThZJ7N69ga2tLnz598PPzS/TgDw4OTvX7j59//9Knd1tbW/T19VPdfmaKjo5mypQpTJkyhZiYGIyMjJg0aRIDBgxI8OAcP348EydOREdHhwMHDlC3bl1iYmI07ycwMJA+ffqwceNGqlatytWrV4mKiqJ9+/b8888/qVo62rx5c3bt2sXMmTMZMmRIsv1+/PhxopyEBw8eJJhb/5Senh6urq6JggQXF5ev7ueSFn5+fmzfvp1NmzZx/Phx1Gq15lilSpU0gUF6i0EJQk4mgoFkBAQE4FbFgyiLotibyBg+bFiic1bP/Y0zx/di6zUBgzxuCY7FBn/Ed+No7K2tGDdv4xeHunevX8TOtQspVbk2rX8aTEiQPyGB/oQGBxAS6E9IkD9BAX74fXxHcIA/keHBqFWpG57X1dVN8CBP6tP7x48f6dWrF2FhYTRo0IBdu3Z9cw+UU6dO0atXL+7fvw9A48aNWbhwIc7OzgnOW7NmDZ06dQJIkNAXFBSEpWXciE50dDTPnj2jWLFiqNVqZs2axYgRI4iNjaVnz54sXrxYq2kMSZKwt7fH19eXs2fPUqVKlVS9p9jYWJ4+fZooJ+HevXsJ1vJ/SqFQULBgwSSXQRoZGaXq/l+Ljx8/sm3bNjZt2sTJkycTTLVUqVKFNm3a0Lp1axwdHbOxl4Lw7RHBQDIGDx7MuqN3idW3Y/yIfpiYmCQ4HhocyLAf62JarQPmlZMuBRz5/DofN42l79g52Dk4xT3g/3vIx/07QPO1N88fo4pVJtlOSnR09dE3MiEyLAS1SonC1B5dUzvkCh0Uchm6slgK5ctD1QqlaVinBpUrV06w1C0p//77Lw0bNiQiIoJmzZqxZcuWVA+JZ4fAwEBGjhypqcZob2/PvHnz8PLySvTAPnXqFPXq1UOpVDJy5EimTp2qOfb27VscHR1RKBQolUpkMhldu3Zl5cqV1K9fnx49etC2bVvUajXDhg1j+vTpXwwInj59SsGCBdHV1SUkJCTViZ7JUavVvHz5MsFUQ/wrudUYMpmMfPnyJUpcLFq0qFYrWL4W79+/Z+vWrfj4+HD69OkEgUH16tVp06YNrVq1wsHBIRt7KQjfBhEMJKN6jRrcC7cHmZzpk8YlOv7voe2smjuePP3XojBK+g+oJEm8WfQTqlC/VN3b0NgUMwtrzCys/v+/ltb//dsaUwtrzf83MIz7hLd99Tz2blpGycrulG/QnsdPX/L8zQdCw6KQALk6GpkqEkV0EPkdralUuhi1q5ancuVKSf6xPHbsGE2aNCEqKgovLy/Wr1//1c5LS5KEj48PAwcO5MOHDwD06NGDadOmaT7hf+rRo0dUrlyZgIAAWrduzaZNmxIk5j1+/BgXFxdMTU01D9Tnz5/j6uqKUqnkxIkTPHnyRDOS8PvvvzN27NgU+7hu3To6duxIpUqVOH/+fEa99WRJksS7d+8S5STcvXsXP7/kfx8dHR0TJS4WLVoUGxubTO9zerx580YTGHxazEkmk1GzZk28vb1p1aoV9vb22dhLQfh6iWAgGWXLV+SF5IwMmDZpfKLjh7b/w5bVf+E0eEuK7bxfO5zoN/cwMjHHwto24cPdPO6h/vHdK/ZtWoZtrjxMXLwDXb3UD8s/vH2F6SO6YGJmyaz1JzQPt6CgQJ48e8bDJy94/uod/sFhgAyZWok8Ngp5TBC5rY0pX8KVWlXLUbVyJQoUKIBMJuPAgQM0a9YMpVJJx44dWbVqVarLK2e2Fy9e0LdvX02NhSJFirB06VJq1KiR5Pn+/v5UrlyZx48fU7FiRU6cOIGhoWGCc27evEmpUqWwt7fn/fv3mq/37duXRYsWUaNGDU6ePMncuXMZPHgwwBeLPg0YMID58+czaNAgZs+end63nS6+vr6a4ODTIOHt27fJXmNra5vkMkgHB4evbhnkq1ev2LJlCz4+PgkCL7lcTu3atfH29qZly5bY2tpmYy8F4esigoFk1HZ351awFch0mD7p10THzx/fw/I/R+HYZyU6Zkn/UZHUKl4v6IQ6Ii55T9/AkDz5C1OmSh3KVKmDXe68yGQy1vw1kZP7N1O3WQfa9f4lTf2NjVUyqE0NoiLDGTtnI/lc3ZI8Lyw8jOfP4pYzPn35lo/+wailuOBApopGoQzGykhOueIu1KhUmujIcIYOHYpKpaJ79+4sWbLkq1jeFhsby7x58/j111+JiIhAT0+P0aNH88svvySb4xAdHU39+vU5ffo0zs7OXLhwIclPihcuXKBy5crkz5+fp0+far7+5s0bChYsSHR0NAcPHqRBgwb8/vvvjBsXN3K0YsUKunbtmuS9y5cvz5UrV9i4cSNt2rTJgO9AxgsKCtIsg/w0UHj+/Hmy15ibmye5DNLJyemr+D158eIFmzdvxsfHh0uXLmm+rlAoqFOnDt7e3vzwww9YW1tnYy8FIfuJYCAZ48ePZ9G2sygNHRg54CdsbRI+8KMiwhnSsQ4GpZsku9Nd+IMz+O2Ykuw99PQNcCpQmHevnhERFkL/cX9RunLtNPd5/sSfuX7+OD90/pkmbXpodU10dBQvX77k4ZPnPHnxmjcfAlCpQaZWIVNHoVCGQsgrfF/eA0midevW/PPPP4k+TWelq1ev0qNHD65evQpAjRo1WLp0KUWKFEn2GkmS6NSpE2vXrsXMzIyzZ8/i5pZ0wHT8+HHq1KlDsWLFuHPnToJjQ4YMYfbs2VSoUIELFy4AMHz4cGbOnIlcLmfjxo14eXkluCYiIgJzc3NiY2N58eLFN7cPRHh4eIJlkPGBwuPHjxNk9n/KyMhIEyB8vgwyu0aXnj17ho+PDz4+PprfHQAdHR3q1auHt7c3LVq0SHJqSRC+dyIYSEZkZCQFStUgyrIYFnqxjB09OtE5W1fO4cDWlVg3HYFxkeoJjkW/f8zHTWNxLVKcQRMXcv/6Bc4d282DW5cJ8k+6dK2Orh55CxahZMVaFC5RgXyubujqar+r3fG9m1i3YBKuxcsxYvqqVL3feLGxSl6/fsPjJ095/OINr9/5EhWjIsbvMRHPzgJgYuNEleo1qVa+JLWqVaRcuXJJVuXLaGFhYYwfP545c+agVquxsLDgzz//pGvXrl/8FDpx4kTGjx+PQqFg//791K9fP9lz9+7di6enJ+XLl0/waRListnz589PREQEO3fupFmzZkiSRK9evVi2bBm6urrs2LGDxo0ba645ffo0NWvWxMHBgTdv3nx1w+ppFR0dzcOHDxMlLj58+DBBJcFP6evra5ZBfhoouLi4ZOkOjo8fP9YEBjdu3NB8XVdXlwYNGuDt7U3z5s2/qYRKQUgPEQykoHzFyjyPsUeta0qfn7wpkD9h5TOVKpblf47i0qkD6Od2xdC1OjIdXaKfXSXiySWQyWns1ZWWXRLOJUeEh3Ln6lkuntjHnavniIlOukSvQqGDU4HCuJWrhmvxchQsUgoDo+QL9vi+e8Wobo1RKHSYs+k0hkYmyZ6rLbVazfv373ny9CmnD+/i6aX9ABjkLomRQ1HksREolMG4OttTuYwbNauWp3KlShmecLZv3z769u2bYD+B2bNnkytX8rsMxlu/fj0dOnQAYMmSJfTs2TPF8zdv3oy3tzc1a9bk5MmTiY6PHj2aKVOmULJkSa5du4ZcLkelUvHjjz+yYcMGDAwMOHDgALVq1QJg+vTpjBw5kpYtW7J169bUvvVvjlKp5OnTp4lyEu7fv59sOWqFQkGhQoUSJS4WLlw405dBPnjwgM2bN7Np0yZu376t+bqenh4eHh54e3vTtGlTzMzMMrUfgpCdRDCQgrdv31KhVmMiLYphbW7K8EF9Ew1xqtVqblw4wa71i3n19D4gw6lAEfLmd+HMkZ3I5HKG/rGMIqUqJnmP+RMHcP38CcpUrUNMVBSP7lxLNjiQyeTkyedCkVIVcS1ejkJuZRNVOBzdvQkf376k369zKVMl6R340uPIzrVsXDINgPxl66K2KERIWGRcpURVDHJVJIqYIJztLShfqgi1q5anSuVK5MmTJ02fiD98+MCgQYPYuHEjELefwMKFCxN88k7Jv//+qykklFKFxk+tXr2aLl264OHhwf79+xMdDwgIIH/+/ISEhLBp0ya8vb2BuIdgq1at2L17N6amphw9epQKFSrQsmVLtm/fzvTp0xk+fHgq3v33Ra1W8+LFiyRXOISGhiZ5jUwmI3/+/Ekug8yMh/Pdu3c1gcG9e/c0X9fX16dRo0a0adMGT0/PREuNBeFbJ4KBLzhx4gSdB00kRN+JGuXcaN406YdQfEJh0dKVGDp5OQArZ//KmcM7MLO0ZvxfWzC3SvhpOTZWycA21YmOjODXeZtwLhRX2Ob1swfcuXqO6+eP8/zhbVQpFBfKlScfriXK41q8HC5u5TiweQXH926idpM2dOyX8nK3tNq/eQVbV84BoE3PEVSs04xn/+2x8OzlO/yCQv8ro/xfUmJMEPbm+pQvWRhTfSherChdunRJcVj4S/sJaOPx48dUrlwZf39/fvjhB7Zs2aJVUtuiRYvo27dvip/k46cdChcuzO3btzXLLqOiomjSpAnHjh3DysqKEydO0KBBA96/f8/p06epXr16ku3lZJIk8ebNm0QFle7cuUNAQECy1+XJkyfJFQ4ZkQwoSRJ37tzBx8eHTZs28fDhQ80xAwMDmjRpQps2bWjcuHGWltcWhMwiggEt7Nq9l+6j56E0cqCLVyOKJ5F4dnTXOjYsnkr56g3oPXomEFeuePLg9rx58ZjCJSsw9I9lCTYwil8OaGpuxcx1x5N8UCljonl89xp3rp3j5sVTvH3xOMW+mphZEhYSiIm5JSOmrcLBKX+mzFHvWreIXesWAtCx36/UbuKtORYRGcHzZ895+OQ5T1+95YNvECpJ+m+PhRgUMYEoYoLIba7LnFnTEy0D/NJ+AtoICAigSpUqPHz4kPLly3Py5Emth5tnzpzJsGHD6NixI2vWrEnynJCQEAoUKIC/vz+rVq2ic+f/J5GGhYVRv359zp8/j62tLb6+vujo6BASEpKtiZffGkmSEiyD/DRQePfuXbLX2dnZJbnCwd7ePk3/LUiSxM2bNzWBwZMnTzTHjIyM8PT0xNvbm8aNG4ufr/DNEsGAln4ZO4Hle6+jY2zF0L6dsbJMuM1vfDnhmo1a02nA/+sSvH/9jN8HtiU6MgLPtj1p0WmA5lh8oaBKtRvTY8Q0rfoRGhzI/RsXuHvtPLev/Eug34cUzzcxs8SleFlc3Mri6lYOp4KFUSjSXzxIkiS2rprDgc1/A/DT4N+pVr9FkufGKGN49fIV12/d5uqNO0SrFSCTI1eGoRvxlnxWOhw+uA89PT2mTp3K5MmTU9xP4EtiYmJo2LAhJ06cwMnJiQsXLqSqCl38csGePXuyZMmSZM/7888/GTFiBPnz5+f+/fsJRjoCAwOpXbs2N2/eBOK24/00UU1In8DAwERbRt+9e5eXL18me42FhUWixMX4ZZDaBgmSJHHt2jVN8uGzZ880x4yNjWnWrBne3t54eHhkWJVJQcgKIhjQUkxMDI1a/ci1dwpy2dswsE9XdD55qG5cOo0jO9bi4dWV1j8NTnDthRP7WDZ9JDKZjIETF1G8XDUAJg1qx/OHt/lpyCSq1Wue6j5JksTHd6+4e+0cd6+d4971C0RFhKV4jb6hEYWKlo4LDoqXI3/hEmkqchR//41LpnF01zpkcjk9hk+lYq1GX7zu48cPrF23gXcBYUgKfXSiA8D3NiZ6aNa0N27cmAULFqR6VzpJkvjpp59YvXo1pqamnDlzhhIlSqSqjVGjRjF16tQvFgiKiIigQIECfPjwgcWLF9OrV68Exz98+ECRIkUICgrCwsKCBw8eYGdnl6q+CKkTFhamqZXwaaDw9OnTZJdBGhsbJ7kMMn/+/Ckug5QkicuXL2sCg08DEVNTU5o3b463tzcNGjT45vb3EHIeEQykwuvXr6nV4icCFA5UKV2EVi2aaY6tmDmGc0d30eqnwTTySlx4Zs383zm5zwcTM0vGzfdBT8+Awe1qIkkSM9YcxcI6/Q8JlSqWF4/usuOfv7h7XbuStzo6uuRzLa4JDgoWK42RsfbLBCVJYs38iZzavwW5XEHv0TMpW7WuVtcqlUqmTZvC20fXiPGNm/6wsrJi0aJFSe4noI0//viDsWPHolAo2LNnDx4eHqluY+DAgcybN4/Ro0fzxx9/pHjuX3/9xc8//4yjoyOPHz9O9GmwdOnSmhGBUqVKcfz4cbGOPRtERUXx8OHDRMmLDx8+JDY26ZwcfX19ChcunGg0oVChQonyXSRJ4uLFi2zatInNmzfz+vVrzTFzc3NatGiBt7c39erVy9IllIKgLREMpNLBQ4f5ceifKI1y0/GHBpQuVRKAvyYM4MaFE3T6eTw1PRJvXKSMiWbK0B95+eQehYqVoXbjNiyf8QuO+VyYsHBbhvbx+aM7TBrYFn0DI7oPn8KDW5e4e+38F/MNAGRyOXnyucYlJP43vWBumfIyQbVazcrZv3Lu6C4UOjr0+3UuxUpX4erZozy+dw1JrSZPflcq1WqsWRopSRKXTh1k49KphAT6A6BvnR8rU32e3b+epk9SmzZtom3btgAsXLiQPn36pLoNiNvXYPny5UyaNIkxY8akeG50dDQuLi68evUqUUniqKgozMzMUCqV2NjY4OfnR5UqVTh06JDIRv9KKJVKnjx5kign4f79+0RFRSV5jY6ODi4uLokSFwsXLoyhoSFqtZrz58/j4+PD5s2bE5R5trS05IcffsDb25s6deqkuAHYxYsXWbRoEecuXASgcsUK9OnTh0qVKmXsN0EQEMFAmoz/fQoLtl1AYWTF0D6dsLa2YeqwTjy+e43eo2dSvnqDJK/7+O4Vvw/wJjIiDMd8Lrx5/ogGLTvj3T3x9sjpoVarGdrBndDgAEZMW4lrifIABPl/5N71C3HTCtfPExzgm+A6mVyOlMRQqn1uZ1z+Cw5c3cpikyvxMkGVKpZl03/h8umDyBU66BsaERkWgr6NEzK5gijfl+gZGOL10yBKVqjJ2oWTuHUpLkEwl1N+8pepy7330ehEBeBqFsKZ06dS9Z7Pnj1LnTp1iI6OZvDgwcyaNStV13+qQ4cOrF+/nlmzZmn2HkjJsmXL6NmzJ3Z2djx9+lSTXX727FmqVauGnZ0dhw4dwt3dncDAQOrWrcuePXvEnHISVCoVBw8e1BR7KleuHI0aNcryqoUqlYrnz58nmbwYFpb0VJxMJqNAgQIJgoT4aaI9e/awefNmzUZaANbW1rRs2RJvb29q166tyYtRqVT07duXpUuXom9pj17+uP9+Y55dITrwPd26dWPJkiVf3T4hwrdNBANpEBsbS1PvLlx8GYutrS2D+nTl9wFevH35hKGTl1O0dPKR+5UzR1j0x/8fMIMnLcGtbNUM7+Oy6SO5cGIfjdv0oGXnnxMdlySJty+faPINHt66THRUwvoGOrq6xCZRSc7S2i4uOHCLGznI7VwIuVxObKyS6SO68PT+TQwLVsCiVhf0bJ0BiA3xJfjcJsKuH0Cho4sqVomOji6N2/SgkXc3dHX1mPD7JEJVehgE3uXexSNf3Go53tOnT6lUqRJ+fn40a9aMbdu2pesP5Q8//MCOHTuSzANIilKppEiRIjx9+pSpU6cycuRI4P+rEpo3b86OHTu4cOEC9erVIywsjObNm7N58+ZvYmvorHLgwAF69OrN65cv0DeNS9CNDg0gdx4nli5eRJMmTbK5h3H/3bx+/TrJLaMDAwOTvc7JyYmiRYtiamqKn58fN27cICgoSHPcxsaGVq1a0aZNGw4cOMCff87AskEfTEo2QCaP+12W1CrCbh4m8PAihg4ZrFXNDEHQlggG0uj9+/fUat4ZX8meciVcuLTjL4IDfBn3lw95CxZN8doVM0Zz7thuAH5fshMHpwIpnp8WZ4/u4u+ZY3AuVIxf52364vmxSiVP79/4Lzg4z7NHtz8bJZChb2hITHRUotEDIxMzXNzKUqhYGY7sWk+0SS7svCdq/oh9yv/QIsKu76dA4RL8NHhigvceEBDAlDnLUET707R8Lv7+++8v9jswMJCqVaty//59ypYty6lTp9K97tvDw4ODBw/yzz//8OOPP2p1zZo1a+jUqROWlpY8e/YMc3NzvLy82LJlC1OmTOGXX+I2oDpx4gSNGjUiKiqKDh068M8//3wVG/pkt/379+PZtCkGzqUxq9Ye/dyFAYh+95CQM+uJenaVHTt20LRp02zuadIkSeLjx49JFlT6dDTgc4aGhsTGxiYs3yyTY16lDRY1OiR5TdC/64m4tJV3b9+IDZaEDCP+CqVRrly5WDxtNLqR77h8+wlhIXGfCoxNvlzL3DG/q+bfK2aOQamMyfD+uZWJG214+eQeocHJF26Jp6Ori2uJ8rToNIDRs9cxd+Np+o6dQ+0mbbDLnReQiI6M0AQCOjq6mJhZoqOjS0RYCDcunGDrytkE+3/AvFq7JAMBAPMqcfUIylath5VtLmKio1AqY4iNVWJhbo5MFYFaz5QLl699sc8xMTG0bt2a+/fvkydPHnbv3p0hBWAiIiIAUrVmvH379hQtWpTAwEDNCoRz584BUKVKFc15tWvXZsuWLejo6LBu3Tr69etHTo/HVSoV3Xv2wiBfGWxajdMEAgD6Dq7YtPwVgwLl6dGzV7J7HmQ3mUyGvb097u7u9OvXj/nz53Ps2DHevXvHhw8fOHr0KHPnzqVXr17Url2b3LlzA3F7oCT1nkzLJj8KYlq2CSq1mg0bNmTa+xFynvQvOM/B3GvXYtCPV5ix9hiq/zKSjUy/XCL1/o243e709A14/vA2m1fMpH3vURnaN3MrG5wKFObV0wfcvXqOSu6pG2I1MjGjbNW6mpUBfh/ecPfaee5eO8f9GxcICwnSBEAAhsYmgIyo6Gj08yS9GyCAjqk1urbObPl7Jlv+npnseQHEbRojk8mQy+WJXjKZjMjISKKjo5HJZERFRVGxYsUkz40/P7ljn7+uX78OwKRJkzRbNmvTjpVV3ND2H3/8wbVr1zSbEq1atYoNGzYkOLdevXocOHCAxYsXc+XKFWrXro1CodC6j2l5X19rOwcPHuTt61fk6jw0ySBSJldgXr0j71b9zIoVK6hbty5KpVLziomJSfD/U/PKimtTS2FijcLYIvnjRuboW9hr9ukQhIwggoF0GjF0IMf/Pc/hW4BMhlyR8hywUhnDw1uXAWjddQjrF03m2K71uLqVpXyNhhnat2JlqvLq6QPuXDub6mDgczb2jtT0aEVNj1ao1WpePb2vyTd4dOcakeH/JVUpdCGuGHHyjSWz3vtzyS35+pwkSfj5+Wl1bmqktUhQbGwsu3btAuL6tmrVqhTPv3TpUqLdEXMauZEF+rkKJXtcz74AChPrNK8Q+ZrIZDJ0dXUTvPT09NDV1SUkJISg8AgktSrZ0TVJrUIVFZrpGzgJOYsIBtJJoVAwdlh/Du/ejEyhh8/2nXRs64UsmYfh4ztXiYmOwtzKFnfPtgT6fWD/5hWsmjMepwJFsHd0zrC+FS9XlYNbV3Ln6jkkScqwssRyuRznQsVwLlSMRl7diImO4tGdq5w5spOLJ/YR9ewahgXKJXmtMug9Sr//f6IxNjWnaOnKuJWtRpFSFZg2O67Esb3qGccOH0StViNJEmq1WvPau3evZgnfqFGjaNeuXYLjyb0+bye5V69evfDz8+P333+nQIECqWrn1q1brFixArlcjlqtplKlSjRt2jTZ/ly4cIFjx44BcVMIpUqV0qqPaXlfX1M7iWjzuymToVAoMDIySvJBqu0rtedn9D1SSm69cuUK5cuXJ/LJZYxckk5Ejnx6hZiwYDw9Pb/8PRMELYlgIAPEP2Tlcjk37r/E5cIlKldKepfCO1fPAuBWtgoymYwWnfrz+O41Ht25yuIpQxk1cy16+hmz5KyQW1n09A0JDvDl9fOHOOUv/OWL0kBP3wC3slUpVqYKb54/xv/MegzylkCmk7gwS9Cpf0Amx8LalojQYMJDg7l8+mDckkS5ArmxDfrGFlSoVwEHB4dEAcz58+c12foDBgxg8uTJGf5+evfuDUCLFi0oXrx4qq6VJInbt29z4ULcVFC/fv2+mIQ4YcIEfvvtt7hNsTp3pkuXLmnq97fg9evXHDx4kP3793PkyBGCg4MBUIcHEuP7HD3bfEleF+P3ElWoHxs2bNDUkvgelStXjoqVKnPz5N/oObigY5Kw7LkqPJDAo0txLVyEChUqZFMvhe+RSCDMAPFLihxz2aETHcCOg6d5++5tkufeuRqXVBaf4KdQ6NDrlz8xNbfi1dMHbFwyNcP6paurR+GScWuU71w5m2HtJkcmk9FpwK/E+j7n48bRRD6/rkmOi37/GN9tk4i4dwokNUF+H4iJjivqYmhsgpGxKWq1itjQD4S/f8DatWtxdXVl0KBBHDlyhJiYGJ4/f07z5s01OwOmVCo4PeITCNMyDCuTyRg3bpzm/zs7f3mkZ9y4cQwZMgSAbt26sWXLllTf92sVHR3N0aNHGT58OCVKlMDJyYnu3buzdetWgoOD/7+0UiYn6PQ6JCnxqIEkSYT8uw5rG1t++OGHLH4HWW/D+nVY6En4/jOI4LObiPn4jBjf5wSf8+HdygHEBn/k+bOnHD16NLu7KnxHRDCQAeK3WS1atAjuJexRKyNYuX57ogpmwYF+vHp6H4BiZf+fYW5hbUePEVORyWScOrCVc0d3Z1jf3MrG7YNw5+qZDGszJQWLlmbYlOVYyJV83DSWN/Pa8eavDrxfPQj12zsA6OjqUauRFy5uZVEodIgMDyMi/P/72evr6yOXy3n8+DFz586lfv36WFtbU7JkST5+/IibmxsbNmzIlKIrkiSlKxgANImEAOvWrfvi+TKZjBkzZtC9e3fUajXt27fnwIEDabr31+Dx48fMnz8fT09PrKysqFevHjNmzOD27dvI5XJKly5NqVKlkMlkKJVK5HI5deu4E/X4PP67pqP0f6VpS+n/Gr9d0wh/cIYhgwfliBr/BQoU4NLFC3Ro3ZzQcxt4t3IA7/7uT8QFHzq0akbdOu7ExMTQtGlTjh8/nt3dFb4Tos5ABpg9ezZDhgyhXbt2LFiwgFqeHXittMbN1ZnOHdpo8gfOHdvNihmjyVuoKOPm+SRqJ35bYD19Q8bO3UDuvAXT3bd3r57ya6/m6OjoMtfnDPoGWbPFqiRJPLp9hcd3r6OW4soRu5WpwoJJg7h9+V8sbewZO3cj+vqGPLh1mctnj3Lh32OoI4MTtBOfYf95VnalSpXw9PTE09NT82DJCFFRUZolhcHBwZiZfXl1yOfmzp3LoEGDgLjStQ8ePKBAgS/XklCpVHTo0IFNmzZhaGjIgQMHqFmzZqrvn9XCwsI4fvw4Bw8e5MCBAwm2+AVwcHDAw8ODSpUqceXKFVatWqX5ebZu3Zrff/+dIkWKsHnzZnr36UuAvx+GNnkAiPR7ja6ePsqYaBwdHbl8+TK5cuXK8veYXRo2bMihQ4cYMWIEo0aNwsLCgujoaFq2bMm+ffswMjJi37591KpVK7u7KnzjxMhABogfGbCyssLS0pIVcyaiH/We249e8+/Zc5rz7n42RfA5z7Y9KVq6MjHRkSyePJToqIh09y1XnvxY2ToQG6vUrGLICjKZDNcS5WncpjuebXtSulJtdPX06TlyOrny5CPQ7wMLJw1GoatLqUq1sC5UGXO3Jni27siqVavo0KED9vb2qFSqBIFA/GjAhQsX+PXXXylTpgx58+ald+/e7NmzR/OpPq0+vT6te9PH1xdwcXEhNjaWCRMmaHWdQqFgzZo1eHp6EhkZiaenJ5cvZ93PTFuSJHHr1i3+/PNP6tati5WVFc2aNWPBggU8efIEXV1d3N3dmTZtGjdu3ODevXs4OTkxdOhQli1bhlKppH79+ly6dInNmzdTpEgRALy8vHj75jXr16+n949e9P7Ri7Vr1/Lm9SuKFi3KmzdvaNWqFdHR0dn8Hcg68QWLateuranIqa+vz9atW/Hw8CAiIoImTZpw+vTpbOyl8D0QwUAGiM8ZiN+NrkKF8vza1xudaH/2HDnHq1cvUavV3Ln2X/Lgf1sYf06uUNBjxFTMrWx5+/IJa+dPSndBGplMRvFyccFHfPJidjIyNqX/uL8wMjHlyb3rrJ3/O7GxsVy9/RCFMoR+3TvSuXNn1q5dy7t37xLsDaCnp4dKpUrQnkwm4/Xr1yxZsoSmTZtibW2Np6cnixcv5tWrV5/f/ovig4H4zO+0iA8G4vu+du1a7t27p9W1urq6+Pj44O7uTmhoKA0bNuTOnTtp6kdGCggIwMfHh65du5InTx5KlizJiBEjOHbsGEqlkvz589O3b1927tyJv78/x44d4+eff+bo0aMULFiQiRMnEh4eToUKFThy5AiHDh2ifPnyie6jr69Pu3btmDVrFrNmzaJDhw7Y2tqyc+dOLCwsOHv2bI4q1BT/O+zk5JTg6wYGBmzfvp369esTHh5O48aNOXMma6YChe+TCAYywOfBAECfXt1pUDYPUkw4qzfu5MmDm4QE+qNvYEjBoqWSbcvMwppeI6cjk8s5d2w3/x7anu7+xecN3M6ivIEvyZUnH71+mYFMLufM4R1sWD6biOhYbAxiqFunjua87du3M2fOHCBuKiYkJITjx48zevRoTYGhzx8KUVFR7N27lz59+pA3b15Kly7N2LFjOX/+fKJAIinpzRd4+/YtL1++RC6X07FjR1q0aIFarea3337Tug1DQ0N27txJxYoVCQgIoH79+omG3jObSqXi4sWLTJw4kapVq2Jra0ubNm1YuXIlb9++xdDQkMaNGzNv3jwePnzIkydPWLBgAc2aNcPQ0JCVK1fi6urKkCFD8Pf3p3DhwmzdupULFy5Qt652W1x/ysXFhY0bNyKXy1mxYgULFy7MhHf9dYmIiNCMOn4eDEBcQLBz507q1q1LWFgYjRo14vx57bYuF4TPiZyBDNCoUSMOHDjAypUrEywLCw4OpnbTDryIssQ05jUvb5ygZIWa/DxhwRfb3OeznG2r5qKrp8/oWetwKpD2ZYERYSEMbFsDSa1m2qpDWNs5pLmtjHR4xxo2LZ0OyDB1qcHPHRowaXzclsGXLl2iVq1aREZG0rdvX+bPn58oLyAwMJBjx45x+PBhjhw58sUHpq2tLY0bN8bT05MGDRokmQ9w48YNSpcujYODQ4KtZ7W1bds2WrVqRcmSJblx4wa3bt2iVKlSSJLE9evXKVUq+UDwcwEBAdSuXZtbt26RL18+Tp8+TZ48eVLdJ229f/9eM+9/6NAhzYMonpubGx4eHnh4eFC9evVEuy5KksSOHTsYM2aMZiQkT548/Pbbb3Tu3FmzK196zJgxg+HDh6NQKDhy5Ai1a9dOd5tfqwcPHlCkSBFMTEwICQlJNi8mIiICT09Pjh8/jpmZGYcPH6ZixaSXNgtCcsTIQAZIamQAwNzcnFV//YFh9DvePnsAQDEtdyj0aN2VEhVqoIyJZvHkoURGJL1tqjaMTMwoULgE8HVMFcSr17wjFWs3ASTCnpyldrW4IisvXrygadOmREZG0qhRI+bOnZvkH0JLS0tatWrF4sWLefz4MU+fPmXJkiW0bt060c8CwNfXl9WrV+Pl5YW1tTX16tVjzpw5PH78WHNOekcG4j+ZVa5cGYASJUrQpk0bADp16kRDj0YUK1WevIVLk8c17pWvSGncSlegSRNPdu7cqWnLysqKQ4cOUahQIZ4/f079+vXx9fVNfNM0iomJ4cSJE4waNYoyZcrg4OBAly5d2LhxIwEBAZibm9OqVSuWLVvGy5cvuX37NjNmzKBevXqJAoHjx49TuXJlWrZsyb1797CysmLGjBk8fPiQbt26ZUggADB06FA6dOiASqWidevWPH/+PEPa/Rp9OkWQUoKskZERu3fvplatWoSEhNCgQYOvMtdE+LqJYCADJBcMAJQqVYqxfdsQGxqXCGSZK69WbcrlcroNnYyVbS4+vH3B6jnj0zVPmtVLDLUhk8lwLlMHhbEtkjqWAQMG8PLlSzw9Pfnw4QMlSpRg48aNWj9I8ufPT8+ePdm8eTO+vr5cunSJyZMn4+7unmj+PzY2lqNHjzJ48GBcXFwoXLgww4YN4+zZuGApvcmD8ZsTXb58mTv34gLBmzdvcv5ZFO91XQgzK0GERUkiLEoSYlqc9zoFufBWj56jZ+PoWoYOHTvh7+9Prly5OHLkCE5OTty/f5+GDRsm2Po2tZ49e8bixYtp0aIF1tbWuLu7M3XqVM1+DOXLl2fs2LH8+++/+Pn5sWXLFrp3757kMDXEVcxr2LAhderU4eLFixgZGTF27FiePn3K0KFD0/x9TI5MJmPZsmWUK1cOf39/mjdvTnh4eIbe42uRXL5AUoyNjdmzZw81atQgODiY+vXrc/Xq1czuovAdEdMEGcDW1hY/Pz9u3bqVZMW6/fv307hxY+R6RuSu3J7hA7prvbvek/s3mD68CypVLO37jKZO03Zp6uOT+zeYMqQjRiamzN5wCoUi+4tPSkhMmbWQwHfPkb27SEBAADY2Nvj5+ZErVy4uXLhA3rzaBU9fEhERwenTpzVTCl/ad8DKyoq5c+fi4eGBjY2NVvdQKpWYmZkRFRXF9evXGTBwMI/eR6A0yk3oq5vE+D1Bx8we2yK1MDbSR18vrkJjZHQM4RHRxKhlSAp9ZJKEXBmKKcG0bFidHl3aI5fLqVGjBh8/fqRq1aocOnRIq9+hiIgITp48yYEDBzhw4AAPHz5McNzW1paGDRvi4eFB/fr1sbOz0+q9Pnz4kF9//RUfn7glsrq6uvTq1YuxY8dib2+vVRvp8fr1a8qXL8+HDx9o3bo1Pj4+Gba89GsxceJExo8fT7du3Vi+fLlW14SGhtKoUSPOnDmDpaUlR48epUyZMpncU+F7IIKBdJIkCV1dXVQqFa9fv8bR0THROUOGDGH27NnYOORF5ViDQs4O9Oz6IzKZdgMz8XPrCh0dfpmxhvyuqSuRC6BWqRjUriYRYSGMmrmGgkVLp7qNjPb8+XPmr9qCefRL1vw1AXd3d1QqFTo6Opw7dy7JbPOMEr+t7JEjR+J2zUsmP0Amk1G2bFlat26Np6cnbm5uyT50Ll++TIUKFTAzM8PUJg/RJvmJNbBGporBQjeaFxd3oVarGDFtJa4lkn5vd+7eYd/+gwRFqIhWyZCrolBE+1OqoB31qpZm6pTJBAUFUb9+fXbv3p2oCI8kSdy7d08z93/y5MkES/EUCgVVq1bVzP2XLl0auVz7AcI3b94wceJEVqxYgUqlQiaT0aFDByZMmKBVLYWMdObMGdzd3VEqlUyaNIkxY8Zk6f0zW48ePVi+fDm//fYb48eP1/q6kJAQPDw8OHfuHFZWVhw7dixVuSpCziSmCdIpNDRUk6We1DQBwMGDBwEYM2IwRjHvefTKlyNHT2h9j3rNO1Kmal1UsbEsmTKM8NDgL1/0GblCQbHScfPYt7OgNLE2zly4jEwVQ6Na5bl8+bLm+xgbG8v9+/cz9d729va0b9+ev//+m9evX3Pv3j3mzZuX6I+mJElcuXKFUaNGUaJECezt7enevTv79+9PVGEyPl8gWqkm0qIosQZWWOip+H3MUMaMm0gNj1YAbP/nr2SnfNyKuTF86BAmjR1Kz/ZNKexSEJWxI1feyvlzwxmM7Auhq6vL4cOHadu2LbGxsQQHB7Nt2zZ69uyJs7Mzbm5uDBkyhEOHDhEdHY2TkxM9evRg69at+Pv7c+rUKUaPHk3ZsmW1DgQCAgIYOXIkhQoVYunSpahUKjw9Pbl+/Tpr1qzJ8kAAoFq1aixYEJeMO3bsWM1Okd+L169fA9pNE3zKzMyM/fv3a1aj1K1bl1u3bmVGF4XviBgZSKcXL16QL18+9PX1iYyMTPSp8fXr1zg5OSGXy/H19WX/wcMMmroalaEdvTu2oGDB5Ldt/VREWAi//9wG3/evKV25Nv1+nZfqYdFTB7byz7zfKFi0FKNmrk3VtRktOjqK36YvgLD3jOhUlxEjRiBJEnXr1uXo0aPo6+tz6tSpLM+KXrBgAf3796d27drUqlWLvXv3cuXKlSQf3rq6ulSsWJEOHTrQvHlzhg4dysaNGzF0KIaBYxkqlXShdetWmvMD/T4wqltjYpUxNGjZBUmtQq5QULBoaUpVqpXs1E1ISAgXLl7m/LU7BIdHExv4nLDHp0CSMDMzIywsLMFOgPr6+tSqVUvz6b9IkSJpHkIPDw9n3rx5TJs2TbOpULVq1Zg6dSrVq1dPU5sZrX///ixYsABTU1POnz9PsWLFsrtLGaJ48eLcuXOHQ4cOUb9+/VRfHz+CdPnyZWxtbTl+/Dhubm6Z0FPheyBGBtLp0+TBpP7gHj58GIAKFSpgZWVFh3ZtaF3bDVlMKP9s3kNoWGiia5JiZGJG79Ez0dHR5fr5Exza/k+q+1r8v2JHTx/cStPoQka6dv0mSpUaG/0Ixo+PS47s1asXBw8epHnz5kRHR9OiRYs0Le9Lj/jVBHnz5uW3337j0qVLBAUFsXPnTnr16pVgaZ9SqeTMmTP07dsXR0dHNm3aBICkY0TtyiUSBAIAljb2uLqVBZmcQ9tWc+r0MY4fO8DCSYMY3rkhty4lXUXOzMyMyhVKU69sPnKrnhL18hL8F5yEhISgVquxtLKmS5cu7Nu3j4CAAA4ePMjgwYMpWrRomgIBpVLJokWLKFSoEKNHjyY4OJgSJUqwZ88eTp8+/dUEAhBXg6JWrVqEhobSvHlzzX+T37rUJBAmxcLCgkOHDlG2bFl8fX2pU6cOd+/ezcguCt8REQyk06eliJMSP0XQsGFDzddmTZ2Iq7WaiIhI/lm/Jen93ZPgXKgYbXv9AsDWv2fz6M61VPXVyjYXDk4FkNRq7t24kKprM9r5KzeRIvx48/A6ERERNGjQgL/++ktTktfNzY13797RokULIiMjs6xfSS0tNDMzo1mzZpqqhi9fvmTFihU0atQoQRJf/OhB1KvL7Fk6nmkjunD64DaiIuKy3U8d2MLd6+cxdnMnd8+l5Oq+BIeey3HoMg+lhRN/TRygWfqpUsXy6M5Vtq+ex+8/t2FI+9qsmDmau1dOExsdgb6BIRZ2/w9MIvVs2XvpJQtWbuLgocPExMSk6f2r1Wo2bNhA0aJF6du3L+/fvyd//vysXbuW69ev06RJk68uUU9XV5fNmzfj7OzM48ePNdMn37KQkBBCQkIA0lVbwtLSksOHD1O6dGk+fvxInTp1Mn0KTvg2iWmCdNq6dSutW7emWrVq/PvvvwmOqVQq7OzsCAgI4N9//6Vatf+XIX706BF1vfsQqpeHOpVL0tijgVb3kySJZdNHcvHkfiyt7Rg3fzOm5kkHIknZuHQaR3aspUbDVnQe+JvW12Wkj74fmTZvOeG3dxEbHY6bmxtnzpzB3Nxcc87Tp0+pUKECAQEBdOzYkX/++SdLHkIjR45k+vTpDBkyhJkzZ37xfLVazdJlyxk44ldiQj4me56ljT3BQQEYFXPHymNAovciqVX4+oxDJ/gNLsVKc+/GBSLDE44aORUoQvFy1XArV41CRUujo6vLyX2bWTN/IgAGecpg6OCGPCYEa70o2njWomun9uTLl++L70OSJA4cOMCoUaM0Ky3s7OwYN24cPXr0QO+/lQ9fs+vXr1OtWjUiIiIYNmwYf/75Z3Z3Kc3u3LlD8eLFsbCwyJCRDn9/f+rWrcuNGzdwcHDgxIkTuLq6ZkBPhe+FGBlIp5RqDFy7do2AgADMzMwSzX27uLgwa2w/dCM/cOz8TR48fKDV/WQyGZ0GjI/b7Mf/I8tnjNZ6ZAGg+Cf1BrIrDjxz9gLhj08SGx2Ovb09e/fuTRAIQNw2rlu2bEGhULB27VpmzJiRJX1LbdGhe/fuMWXJZmTGcUvyqtZrzsCJi6hYqxGmFv8P0gL9PqBWxWJerX2SQY1MrsCsWjtCg/y4evYIkeGhGJuaU7FWI34aMokZa48xfv5mWv00iCIlK6DzX92EWo298Oo+DICo19fIaxSOgYUdH2UOLNh1g4pNutKszU/s3rM30c6P8c6dO0ft2rVp3LgxN27cwMzMjEmTJvHkyRP69ev3TQQCAKVLl2bVqlVAXKXCtWuzNy8mPdI7RfA5a2trjhw5QokSJXj37h3u7u48evQoQ9oWvg8iGEinlKYJDh06BECdOnWS3PSmdasfaN+wDAplCGu37Cc4RLt5fAMjY3qPmomevgF3rpxh/+YVWvfXpXg5dHT1CPB9z/vXz7S+LqOoVCpO7F5LbPBb9PX12bVrF87Ozkme6+7uzrx584C4T+z79u3L9P6lJhj48OEDbXsOJ1SRC92YIABc3MpSonx1eo6czuz1J5m94RRteo7A1NwSXRtndMySr1mgn8cNma4BbmWrMHrWOmavP0nPkdOpVq85Fla2yV7XsGVnmrbvDcCNk9upXzYvnb08yO/sTKyJE/8+jaXr2CWUrOHJxMnTNQ+aO3fu0KJFC6pWrcqpU6fQ19dn2LBhPH36lDFjxmBiYqLtt+2r4eXlpVli2L1792+2El9GBwMANjY2HD16FDc3N96+fYu7u3uW73khfL1EMJBOKY0MJJUv8Lmpv4+jmL2cqKgIVq3botVmOgB58rvSvs9oAHasmc/9m5e0uk7fwBAXt7IA3MmGJYYbls8m/G1cEtPq1au/uFqgT58+9OrVC0mSaNeunda7/6WVtsFAREQEbbr25220GZZmRsSE+QFQoEjJBOeZmltSv8WPlKlaF4UWy/jkMhnFylSlQJGSyP/brlkbzTr0pV6LjgCsnvsbMYHv6NO9E6N+7kbNyqXQN7fjveTA3G1XKFPXC+cCrpQoUYKdO3fGVbvs1o1Hjx7x559/Ym1trfV9v0YTJ06kadOmmiTU9+/fZ3eXUi0zggGIKzJ19OhRzZbQ7u7uPH36NEPvIXybRDCQTskFA6GhoZrStg0aJJ8PYGBgwD+LZmCu9uXVhwD27j+o9b2rN/iBqvWaI6nVLJs2guAAP62ui19VkNW7GN64cJITu+JWQdSp11BTsz8lMpmMefPmUbNmTUJCQmjWrFmmZovHJyumFAyo1Wp6DhjGrXcSekYmeLqXJyY6CkMjExyckl5vn9+1BFEfnxEb/CHZdqNe3EAVE4mNQ+oTxmQyGW16jKB6gx+Q1GqWTh/B7StnsLKyomljD34d3p9WDSqhCHqM/+NLvHz2CEmSMLOyZ8CgYUycODHDHzzZRS6Xs3btWs0Dr1WrVgkKL30L0lpjQBv29vYcO3aMIkWK8OrVK9zd3b/rPR4E7YhgIJ2SmyY4ceIEsbGxFCxY8IsFWfLly8fc3wahG/GeU5fvcjsV+9d36DsGR+dCBAf6sWz6SNRajCy4/bdZ0sNbl1HGZM0fyZdP7rFk6nCQJAwscrNowTytr9XT02PLli2abPE2bdpkWrZ4/MhASjX1x/8+hQNX3iDTN6Vr22b4v38JQP7CJZIt4lOxlgcGhsYEnV6bZK6GpFISdHotyOSs+HMUezctIyY6KomWkhefT1K+egNUsbEsnDSIh7evEBkRxt4NS1k7cxi+T66CpMbGsRDWpZohL+TBmhPPKNugA16denHo8GGtR6e+ZmZmZuzcuRMLCwvOnj1Lv379si1HJi0ya2QgXq5cuTh27Biurq68fPkSd3d3Xrx4kSn3Er4NIhhIp+RGBrSZIvhUs6ZN6Nq8KoqYYDbsOERAYMCXLyJu2L/36JnoGxhy/+ZFdq1f9MVrHPO5YG5lS0x0FI/uZP5mJoF+H5j3W39ioiPRMctF1Ro1U53JbGtry65duzA2Nubw4cMMHz48U/r6pWmC1WvWsWTrv6j0LfD2rEOB/AV4ei8u+75g0eRLvuobGNGh72jC7xzHb+c0YnyfA3FZ/FGv7/DRZxyxHx7jkCcfMdFRbF89j197NefSqQOpeojJFQq6D59KiQo1iImOYvaYnozs3IDd6xcRHRlBPhc3hvyxlKnLtvPH77/RoUU9nJyciDbKy9F7YXQYNpcyNZsyfebcb3J4/VMuLi5s3LgRuVzOihUrWLhwYXZ3SWuZHQwAODg4cOzYMc2umO7u7pr7CjmPCAbSKbmRgfjkwZSmCD43cdwoSuXRJyYqklXrthCr0u7Tr4NTAToNiKtdvnfjUm5fSXn4XyaT4VY2ble9zN7SOCoygr8mDCDI/yO6xpaY5i3LT22apamtkiVL8s8/cdMMc+bM4e+//87IrgIpBwMnTp7ilz9XoTS0p26VMpQrG7cBzNP7NwEoULhkoms+VaVOU3qOnI7iwz3e/d2f1/M78npeOz6sG4mJMoihk5cyYdF2egyfiqWNPf4f37Jk6nCmDe/M84fajxbJ5XJKV3ZHR1cPpTKGiPBQrO1z03v0TMbM2UCxMnE/ex0dXcqULs2AXj8xsn8XqpYvgY6ZPa9ibZm2/l/K1G9Pu5/6cuz48VStWPmaNGzYkGnTpgEwcOBATpw4kb0d0oIkSZqHcnpqDGjD0dGR48ePU7BgQZ49e4a7u7tmikLIWUQwkE5JjQw8e/aMR48eoaOjg7u7u9Zt6enpsXrRDCzx5a1fMDt3a589X8m9CbUaeyNJEsv/HEWAX8qf6v6/pXHmBQNqlYpl00fy8sk9jEzMMSjkjokikhbNm6a5zZYtWzJhwgQAevfuzZkzGZv3kFww8OjRI7oOnUSUQW5KFnbCo2FdAEKDA/nwNm549fPkwaRUrNWIP/85TJ/RszA10EMdFUazDn2YvGwPhUtUQC6XU8m9CZOW7qZ5x77o6Rvy+O41Jg1qy9+zxhDkn3wtA0mSuHb2KL/1a8WavyYSq4xB8d/2z8qYGJwLJl+N0NbWlh+aeTJ+eH/aNauDo2MeooycOHg7mDaDZlC2djNmzvmLjx+Tv//XaujQoXTo0AGVSkXr1q2/+vnxwMBAze9hZgcD8fc4fvw4+fPn58mTJ9SpUyfLK38K2U8EA+mUVDAQPypQpUoVzMzMUtVenjx5WDh5BLoR7zh3/SHXb9zU+tq2PUeQt2BRwkICWTp1BLGxSa8rByhWpgoymYzXzx4SFOCbqj5qy2f5DG5cOIGunj5FarZGR1efxrXKp3vJ2tixY2ndujVKpZKWLVvy8uXLDOpx0sGAn58f3t0GEySzxSmXJe1at0RG3EM1flQgl1N+jE3NEzeYBB0dXcpVr0+efC4AWNs7Jso10DcwpGn7PkxatosqdeKCp7NHdjG6uyd7NixJlE9w/+YlpgzpyIJJg3j78glGJmZ4dRvKlL8P4OhciJBAP2aO6UGgX/IJjBBXza9c2XIM7NONYX1+pFJZNxSm9ryItmbymlOUrtuGjt37c+rUqW9mtEAmk7Fs2TLKlSuHv78/zZs3Jzw8PLu7laz4UQEbG5sUc1cykpOTE8ePHydfvnw8evQId3d33r17lyX3Fr4OIhhIB5VKRVBQEJBwmiAtUwSfatigPn283VHEBOGz5yj+/tqtEtDV06f36JkYGpnw+O41tq/+K9lzTc0tcS4Ut6FLZowOHNu9gSM744q+dBo4gVeBahTRgXTt0DrdbcvlclatWkWpUqX4+PEjLVq00DzE0+vzYCAqKor23X/mZYQJ5qYmdO/ULkHNiKf34/IFvjRFkBRDY1MAIlPYn8LKJhfdhk1m9Oz1FCxaipjoSHasmc/Ynk25eHI/zx/dYfavvZnxS1eePriJnr4hTdr0YOrf+2nYqgtWNvYM/mMptg5O+L1/w6wxPQkN1i4fJZd9Llq3aMb4Ef1p08Qdh9yORBrlZd+NQFoNmEp59+bMnb8QPz/tfj+zk6GhITt27MDe3p6bN2/SpUuXrzahMCvyBZLi7OzM8ePHyZs3Lw8fPqROnTrffN6IoD0RDKRD/C5u8P+RgdjYWI4ePQqkPRgA+HXUcCrkNyE2Kpy/121Ntnrc5+wcnOgy+HcADm5dyfXzx5M9N35VwZ0v5Bik1s1Lp9iwZCoALTsPRG5si1KlIp+NHhUqVMiQexgbG7Nz505sbW25du0aP/30U4b8cf80GJAkib6DRnLlZTS6Bsb07NImwV4EAE/+GxlIKXkwOUbxwUDElzerKlC4BL/MWEPPkdOxss1FgO97lk4bwaSBbblz5QwKhQ7unm2ZsmIfP3T+GSOT/49IWVjZMnTyMixt7Hn36imzx/YmIly7DbIA9HT1qFChPIP7dmdo745ULF0MhYkDz6KsmPj3MUq5e9G510DOnMm+qpbayJMnD1u3bkVXV5ctW7YwefLk7O5SkrIrGIC4lU3Hjx/HycmJ+/fvU7du3W9yakhIPREMpEP8FIGxsbHm0+LFixcJDg7GysqKcuXKpbltHR0dVi6cgY0ikI/+wWzduUfra8tVq6cpQPP3rDH4fXiT5HnxwcDda+czbMj31dMHLJk6HEmtpnqDH2jk3Y1zV24hj42gfYsGGbq/gLOzM9u2bUNXVxcfH590/3FXq9UJ6gxMnj6L3eefgp4Zndt4Ymdrl/B8lYpnD+P2idcmX+BzhiZxwUCEljtXymQyXIuXo1iZqom+jyUr1qSRdzfMrZKucGhj78jQycswNbfi5ZN7zBvfj+io1I+mOORywKtlc8aP6EfrRrWwd8hNhJEzu6/60qLPJCrV/YEFi5Z+tTsHVqtWjQULFgBx0027du3K5h4llpk1BrRRoEABjh8/jqOjI3fv3qVOnTr4+mbOVKLw9RDBQDoktZIgfoqgXr16KFJRQS4puXLlYvG00ehGvuPy7Sdcvqr9MsDWPw2hQOGSRISFsnjKMJTKxLvYFShaCgNDY8JCAnn5JP2V/YL8PzLvt35ER0ZQpGRFOvb7FT8/P15/CEAvxp/2bdI/RfC56tWra5aMjR07lp07d6a5raio/8/D7ztwkLlrDxGrb03LRjVwLeSS6Pw3Lx8THRmBvqERjnkLpfp+8SMD2nxKDw8NZsvK2Yzu3oR/D21DkiSKlq5EqUq1ALh27hhjezRj17pFREclvctjrjz5GTxpCYbGpjy+e42FkwYn+XuhDT09PSpXqsjQ/j0Z3KMd5UoWRW7qwKNwM8YtO0SJ2q3o3m8I58+f/+pGC3r06EG/fv0A6Nix41e3rW92jgzEK1iwIMePHyd37tzcuXOHunXrfhPTQULaiWAgHVJKHkzPFMGn3GvX4ueOHiiiA9m69wQfP6acABZPR1eXXqNmYGxqzvOHt9m8IvEOfDo6uhQpFVcOOL15A9FREcyb0J9Avw/kcspPnzGz0NHV5dyFS8jUKqqXccHe3j5d90hO9+7dGTBgABD3x/3WrVtpaufTvINRf65CaeRArQpuVE6mZHJ88mB+1xKpKh0cz1CLYCA6KpL9m1cwqlsjDmz+m5joKAoVK8OI6asYOnk5A8bPZ+ycjRQqVoaY6Eh2rVvI2J5NOX98T5KjPXkLFmHQxIXoGxhy5+pZlk4bgUrLJazJcXR0pG3rHxg/vC8tG9bALpcD4QZObLv4nmY9J1ClfksWL12uya/5GsyePZtatWoRGhpKs2bNNIH91+BrCAYgrk7DsWPHyJUrF7du3aJevXr4+/tna5+EzCOCgXSI/wMSHwwEBQVx4cIFIOOCAYBfhg2iqqsFqpgI/l63Teu96q3tHOg2NG7o/Niu9Vw+nbjUsdt/pYnTkzcQt4TwF14+voeJmSUDf1uAsak5KpWKK7cfolCG0LX9D2luXxuzZs2ibt26hIWF0bx58zR9iokPBmQyOdGGjhQrkBvPxskXjXoSX2woDVME8EnOQHhYomOxsUpO7PVhdPcmbF05h4iwUBydCzFg/HxG/rka1+L/n4LK5+rGyD9X0+uXP7G2y02g3weW/zmKqUN/5Ml/CY6fKli0NP3HzUNHR5drZ4+yas74DJkm0tc3oGqVKgwd0JNB3dtSpngRMMnFwxBTxizeT/GaP9Dr5+FcuXIl20cLdHV12bx5M87Ozjx58oS2bdtmWlXL1MqqGgPaKFy4MMePH8fe3p4bN25Qv379rypwEjKOCAbSIX5kIH6a4OjRo6jVaooWLZqhUb1CoWDFghnY6QTiHxSKz7adSGj3x7RkxZp4eHUFYNWc8Xx4m3AZXvH/8gae3LtBZETih5I2Nv89i+vnj6Ojq0f/cfOwdYh77/cf3Cc8KhZr/Wjq1a2bpra1paOjw6ZNmzTFU7y8vLROuoynyZyW6+Bga0HHdq2RyZL/T+Tpg/+KDRVJffIgfDpNEKL5mlqt5uLJ/Yzr3YK1C34nOMAXG3tHug2bzPj5WyhVqVbSWyDLZFSo6cHvS3bSsvNA9A2NePrgJlOGdGTZ9JEE+CbMCi9aujK9Rs1ALldw7uguNiyekmEPaBky8uRxor13S8YN70vzBtWxtnUg3NCZzWff0KjLGKo3bM3yv1cREhLy5QYzia2tLTt27MDIyIjDhw/zyy+/ZFtf4kmSlO05A58rUqQIx44dw87OjmvXrtGgQYOvNidESDsRDKTD59MEGT1F8ClbW1tWzP4Nvci3XL//ggsXtdulEOCHTgNwcStLVGQ4iycPTbBG3dbBCVsHJ1SqWO7fuJjqfp3Y68Ph7XFVAX8a/DuFipXWHDt76TpyVRStG9VMcgvnjGZtbc3OnTsxNTXlxIkTDBo0SOtrY2JiGDp6IgByHV16dG6Lnq5esueHhQbz/lXcFtBpSR4EMDL5/9JCSZK4feUMkwa2Zem0EXx8+xJTCyva9xnF70vjag1oMxWhp29A4zbd+WPZHqo3+AGZTMaFE/sY27MpO9cuSJA0WKZKHboOnYRMJuP4no1sX639fhHaMjQwpHq1qowY1IsBXb0o5eaK2tSBe0HG/DJ/F8VrtqDv4JHcuHEjW0YLSpcuzapVqwCYOXMma9asyfI+fMrX15fo6GhkMhmOjo7Z2pdPFStWjKNHj2JjY8OVK1do2LDhVzXtI6SfCAbS4dMEQkmSNPsRZEYwAFC1ShWGd2uOTnQAOw6c5u077aqEKRQ69Bw5HVNzK149vc/GpdMSHI8fHbibyryB21fOsH5R3DRE8479qFS7seZYaGgIj56/RRHlR6f2XqlqNz3c3NxYt24dMpmMhQsXsnjx4i9eI0kSA4eN5uaLuE+p5ubmmJqmXCzq+YO4vAT73M6Ymifevlob8TkDoSGBzBjVjTm/9ublk3sYGBrT4sf+TFmxnzpN26ObQlCSHAsrW7oMmsjYuRtxLV6OmOgodq9fzJgeTTl3dLdmWqCyuycd+40FYJ/Pcvb5LE/Te/kSGTKc8zrTsW1rxg/rQ9N6VbGwyUWofl42nn5J/Y4jqNWkDStXryEsLG0jVGnl5eXFmDFjgLjkwkuXtA+0M1r8FIG9vT16eqn/uWem4sWLc+zYMaytrbl06RIeHh7ZOrIjZCwRDKTDpyMDjx494sWLF+jp6VGrVq1Mu+fgn/tRu7gdamUEK9dvT5ABnxJLG3u6D5+CTCbj1P4tnDu2W3PMTbOlsfbBwOtnD1k8eShqtYoqdZvh2a5XguMXr1xFUkuULGiX6k2J0qtp06aaZYYDBgzg5MmTKZ4/a+58tpy8j1rHAAAj4y9XSIyfi0/rqABASGBcMlZURDgPbl5CR1ePBi07M+Xv/Xi264WBYfLbKGvLuVAxhk9bSZ/Rs7DJ5UiQ/0dWzBzN5CEdeHz3OgC1GnvTuusQALatmsvxPRvTfd+UGBkaUbNGdX4Z3Ie+nVpSoqgLkokDt/0MGD5nO8VrNGfA0NFpTgRNi4kTJ9K0aVOio6Np0aJFtlXf+1qSB5NTokQJjh49ipWVFRcuXMDDw4PQUO1rVghfLxEMpMOnwUD8FEH16tUTFabJSHK5nKV//YmjfihBIWFs3LpD6/wBt7JV8WzXG4A1f/3O25dPAChSsiIKhQ6+717x8d2Xdy0LDvBj3m/9iYoMx7V4OTr9PD7BPLaExMVrd5Erw+js5ZmGd5l+I0eOpF27dsTGxtKqVSuePXuW5Hnbd+5m2ordxBrYUKFE3PJAPX2DL7YfnzxYIA3Fhvw/vOXvWWOZOaaH5mtV6jRl8vK9eHcfluaRhuTIZDLKVa/P74t30uqnQRgYGvP84W2mDvuRpdNG4P/hLR6tf8KzbU8A1i38g7NHM3/9vQwZBQoUoFN7b8YN60PjupUxt7EnWC8P608+pW77obh7tmXtug0ZVmEyOXK5nLVr11K0aFHevn1Lq1atiI7Omu29P/W15QskpVSpUhw5cgRLS0vOnTtHo0aNREDwHRDBQDp8Ok2QmfkCn7O0tGTFnInoR73n9qPX/Hv2nNbXNm3Xi6KlKxETHcniyUOJjorAwMiYgv/N9X9pVUF0VCR/TRxAgO877HM703fsnETD2C9fvsQ/OBwjKShdmxKlh0wmY8WKFQnq0X8+/Hz58hUGjJuL0siBqqULUyh/PgD09FOuB69Wq3n23zRBalYShAYHsHHpNMb08OTskZ1IajX8F0T90OVnrGxzpeIdpp6unj6NvLrxx7I91GjYCplMxsWT+xnbqxk7/vmLhq27UrdZBwBWzv6Vq2ePZmp/PmVkZIx7zZqMGtKXPj/+QNHChVAZ5+bGRz0GzfChePVmDBn5K/fupb8eRnLMzMzYuXMnFhYWnDt3jn79+mV5HsPXPjIQr0yZMhw+fBgLCwvOnDlDkyZNsnx6R8hYIhhIh/iRARMTE44fjyv727Bh8kvRMlKFCuX5ta83OtH+7DlyjlevtNusJ36/e3MrW96+fMLa+ZOQJIniml0Mkw8G1Go1K2aM5vnD2xibmvPzhAWYmFkkOu/M+SvI1Eoa1yyPqalpmt5fRoivRx+/TrpTp06aufJXr17Rsd9oIvRz4+qcixbNmmgSK780MvDu1VMiI8LQ0zfEMV/iYkSfi4oIZ9e6RfzStRFHdqwlNlZJkZIVGT17PSamFkDK+xNkNHMrGzoP/I1f5/lQuGQFlDHR7Nm4lLE9m+JUsDBV6zVHUqtZOnW4pv5ERHgoty//y7Vzx3jz4nGm9U2GjIIFC/FTx7aMG9obj9oVMbWyJ1A3D6uPPqKW98/Ua96eDZt8NNUiM5KLiwsbN25ELpezYsUKTbXCrPKtBAMA5cqV49ChQ5ibm3P69Gk8PT2/6g2ghJSJYCAd4oOB169fExYWhp2dHSVLpn0OObX69OpOg7J5kGLCWb1xJxGR2g2lmlva0GvkdGRyOeeO7ebfQ9spVjZuj/t7Ny4mu9vh1pVzuHr2CDo6uvT7dS72js6JzomOieb2w+coogPp0r5l2t9cBsmTJw/bt29HT0+P7du3M2HCBEJCQvDu+jMf1dbYWZvTuYM3crmcmOi4h8uXgoH4YkP5XN1QKHSSPU+pjOHIjrX80rURu9YtJDoyAudCxRg8aQlDpyynQOESmhUFqdkrIKPkLViEYVNW0G/sHGwdnAgO8GXV7HG8fvaQwiUrEBurZP7En1nw+0CGdqzLnHF9WPD7QMb3+YFJgztw7/r5TO2fiYkJdd1rM2ZoX3p2aEYR14KojB25+k7BgKnrKV69KcNH/8bDhw8z9L4NGzZk2rS4JNtBgwZpAv2s8C0FAwAVKlTg4MGDmJmZcfLkSZo2bZrpUzpC5hDBQDrETxPcuBE3f1y/fv1EW9FmJplMxsLZU8lrHEFwWATrfbZpnT/gWqI8P3SKq9q3ftFk5DI5puZWREdG8PRe4kI1pw5s4eDWlQB0HjQhQdGbT924cYuYWBXO1npUqlQpje8sY1WuXJmlS5cCcYli9Rs352GALkbGxvTs3BZ9PX0ArUcG/l9sKOl8AbVKxZkjOxnT3ZONS6cRFhKIfW5neo+awZg5G3Ar+/+9BVIqPJQVZDIZZarWZeLiHXh1G4qhkQkvn9zjwc1LmJpboVQquX75LEblW5C7xxLy9F+L7Q+jeR8ey6yxvZMsZJXxfZTj6uJK1x/b8euQnjSoUQETK3sCdPLw96H7VG/Zl4Y/dGTzlq1aJ9R+ydChQ+nQoQMqlQovL69kc04y2tdUcEhblSpV4sCBA5oR0ubNm2fKqI2QuUQwkEYxMTGaIbFz5+Lm7LMiX+Bz5ubmrPrrDwyj33H/2XtOnDqt9bUerbtSokINlDHRLJk6nMIlygNw6d9D+H94qxkhuHP1LGvnTwKgafs+VKmTfB7Aucs3/tuUqH6GbkqUXp07d2bIkLiM+YtnT6OOjaZ7h5aYm5trzokPBvS/NDKgKTaUcBRIkiSunTvGb/1asXLWWAJ832FhbUenn8czYfF2ytdomChYNEyi8FB20NXVo2GrLvyxfA+1Gnkhk8sJDQ5ApqtPrh9nYFG9A7pWjiiMLTByrYpduykYFa7O8pljCAsJyrJ+mpqaUb9eHcYO7Uf3dp64FspPrEkeLr2R0eePfyhRvSmjx0/iyZMn6bqPTCZj2bJlmpyTFi1aZPqcuEql4s2buE3FvpWRgXhVqlThwIEDGBsbc+TIEVq0aJFhgZmQNUQwkEafVuD6dGQgO5QqVYoJA39EJ8qP/ccv8fzFc62uk8vldBs6GSvbXHx4+4LH926ATM7x3RsY+VNDhnSow8o541j0xxDUahWV3JvQrEOfZNvz9fPl1YcAdKP9MmVTovTKX9AVXVNbkFSoXp7BzDhhoqBmZMAg+QTCiPBQ3v23CuPTYODBrUtMGdqRBb8P5O3LJxiZmNG66xAmL99LTY/W6OgkXXRJU4UwC3MGUmJmYc2PA8YxYvpKZHIFZhVbomebL9F5MrkCy7o9UKnUnDmS9s2h0komk1OkcBG6d+7A2ME9qFu9PMYW9vgpHFmy9zZVmvekiVdntu/YmeZVAfE5J/b29ty8eZMuXbpkakLhhw8fiI2NRS6X4+DgkGn3ySzVqlVj//79GBsbc+jQIX744QcREHxDkp/wFFIUHwwYGRkRERFByZIls/U/4G4/deLMhSvsuvyO1Rt3Max/N62WOJqYWdB50ERm/9qHoEA/jIu7Y+RaDZlcQeSzq5w9vh8pNoZ8Lm50GTQxxU/75y5cRqZWUaOsK7lyZW5mfGrtP3CQ3xdtwdClHgbPjxIa8JFFfwxh2JQV6PxXHTEm6ss5A88e3EKSJGxyOWJuacPLJ/fYtmout/9bhaGnb0i9Fh3xaNUFI5OUCxeBdpsVSZKEWq0iVqlEFask9r+XSvnpv2P//+9YJUplTMLjsUpilQn/nbit/9pQxuDv+w5JrcK4WO1k+6UwtsAgX2luXznD/9q76/gojjaA47+zGDHcCe5QLLhDsVLcihWKS3HtC5RibQlWrEkpEty90JYGCgGCQ9HgEgJESIgnZ/P+kbJtigW45BIy38/nCr3dm302XG6fm52Zp2m7z994rinFxdmFZh83okmjBvj7++N78iy37tvid9/MyakryDprCR0/qUffz7tRsGDBt2o7X758bNu2jQYNGrBt2zZmzpzJpEmTUuQ8nt8iyJMnD1pt+vxorlOnDr/88gstWrTg119/pX379mzfvh1bW1trhya9Qfp8x6UBz5OB592+1rhF8G8qlYpFc2dxuVU3bkfFsnbTNvr37v7atfWfO/r7DtQ6W3J0mYVtrn9K8doXroyze2uerBuP0WR65bdbAJPZxNlL19EYIunVpZtFzslSLly4wIAJHugd8lKtbFHqDuzCrJHduXX1PGsWT+OzgRMwGY1ER0UAoE9I4NGDO/9cLP914Tz+97dgh0xOzBzZVZliqFKpKVSiLMVKV0QF/LLp5ySvNxr0/1yI/9Xm81oRf+xcg5/Pnhe2Gwx6TEaD1Qr7qG1fv/CR2s6RqIjHCCGsfltIrVZTunRpSpcuzbNn4Rw/cZpTF64RHG/gxz0X+WmzD9XLFqRv93Y0b9Y02Utk16pViyVLltC/f38mT55MuXLlaN26tcXjTw9rDCRHvXr12Lt3L5988gn79u2jY8eObN26Nc2tqCglpRLWLh+WTv3yyy+0bNkSnU6HwWDgwIEDNG7c2NphcfXqVZp8NowYu3w0rV2Jjxs3fO3+4aFBjOvVFNeGfXGu/PKxAHF3zhK85WsmzFmTpPbAf4+7YvM+cojHXPTdjUqlQq/XJ+uRkJCQ7H3f9nVhYWE8fByEQINGDTY6HSajAX1CPGaz6X1/3Faj1erQ6HRotYkPjVaHVvevv//9/4l/1/7zd53NP695zeujnoXxy6afyN5uMg7FXj4QVAgzgZ59MUUGkzVHHirWaEiFGg0pVqbia2dZpCaT2YT/NX98T5zldkAwmE2oDRFkt0ug86cN+aLHZxQoUCBZbQ0dOpQlS5bg6OjIiRMnKFOmjEVjXbBgASNHjqRTp05s2rTJom1bg4+PDy1btiQ+Pp7WrVuzefNmmRCkYTIZeEc//vgjgwcPBsDOzo7w8HDs7N68cl1qWLt+IyO/X43JPgcDe7SlSOEiL90vIT6O33d4s3udJ/mGbXjlt0AhzAQu+Rw7tRmXzNkwCwFmMyazCZPRiMloICYmOvF+JyKdXmRViQsACYFKrUZnY4OdfSZ0f188VRo1MVERRD37p3yro0tm8hQogrNr1v9cfP/zd+XCq0164dXZcOXccXx/3UbxspVp+/mwN7z++cVamyrfwqcN70JwPOToMguV+sUiSbHXjxOycxZanQ1Gwz9ltR2dM/NRtXpUrNmIMhVroLNJG13EYeFhHPc7zemL14iJN6I2xaGND6Fm+cL069GBJh83fm33vMFg4OOPP+bw4cMUKVKEU6dOKRVLLWH06NHMmzeP0aNHM2fOHIu1a02///47rVq1IiEhgbZt27Jp06ZUKVomvT2ZDLwFIQTr1q1jwQ8LOXvm72ImKhV58+TBx8eHEiVKWDdAIC4ujidPnjBq/CT+OHsHrUZDjYqliY+JJPJZGJHPnhIRHkpk+FPi4xJnQ6hsHCgwcvNr2328ajj6oHcfoa3T6bCxscHGxgZbW1vl8fy5/z5et+1Nj+ev/WrSJB7EOGDWudC4dmU+qlApyTdgVCpmj+tF6JOH6LIXJFOZ+qi0tiQ8uEjcrZPkyleYL79eyNmjB9i/ZTmx0Ykj/lUqFaNm/kSpCtXf+efxnJ/PHpbP/YrSFWswauZP792eJR07sIuV8yfhULo+WRr1Q+OQOPNCCDNxN08Qtm8BpctXYcAED65dOMF5Px/+OnmYmL9vtwDY2tlTtkptKtVoRLmqdZUBk9ZkMpm4fPUKx06c425gCJhNaAwR5LA30rVNY3p17/LKioEhISG4u7tz//59Pv74Y/bt22ex+/udOnViy5YtLFiwgOHDh1ukzbTg119/pXXr1uj1ejp06MD69etlQpAGyWQgmcxmM3379mXlypU4FK6Mfen6aOydSXhyk9gL+9GZ49m/bx9169a1+LETEhIICgoiKCiIJ0+eJPnzv8+9bRUxjUaLyWQi7+BVaJ2yvnQfYTTwcHF3bDUqNFodCfGxGPTvt267SqXC2dmZzJkzkyVLFjJnzvzKx3+3u7i4vHE9B5PJRP6SVYjPXJZM6gSmfj3lhX32bfqZ7asXkrXZMDKVa5zk27Y+5D4hmyYh9LGYDInn6po1B8+eBlO0dEUmzFn9Xuf/3IWTf7L4my8pWLwskxZssEiblhAVEc53o3sQ9Oh+4rgTjQa7QpVR2zpgeOSPPuwRZavUYeDEOUkKKhmNBm5ePsd5Px/O+x0kPDRI2abRain5UTUq1WhIheoNccmSzRqnlsTTp6Ec8zvFmUs3iE0wojbGoksIpXbFovTr0YHGjRqh+U/p6AsXLlCrVi1iY2Mt+i2+Ro0anDhxgq1bt9K+fXuLtJlW7Nu3j7Zt26LX6+nUqRPr1q1Lt4MkP1QyGUimxYsX8+WwYWRtMRLHsknvw5v1cTzdMQNt+H3u3b1D5sxvLjSj1+sJDg5+5UX933++bd1wW1tbcubMiYuLCzfvP8Zsm5lCBd2oXMUd58zZcHbNirNrVlyyZMNsNjOmRyMcKrfBtU73l7YXfdmHp7/MZ7rXLnLnLwwkfujHxUQRHfmMOT8sxRwfSaeGZalY4SPCw8OVR1hYWJL/Dw8Pf+8lS1UqFS4uLq9MFjJnzsylS5fYc/g8Joc8dGzTjBIly5DJ0Rk7B0fUajUGg57R3RuhKVabLB8PfOlx4u6eI3jzFJxds9Kxz2huXDmL76/baNq+Nx37jHqvc3juxuWzzB7Xi5x5CzJz2Z43vyAV6BPimftVX25f+4usOfLw5dTFXDp9hMvn/DDoE8iZpwB1m3WgaOkKr71dIYTg3s0rnD/uwzk/H54E/LNwj0qlonDJj6hUsxEVazYiR27rDpozGg1cunyFYycvcO9RCCphRGOIJLejmW5tPubz7l2SzJDZsmULnTp1AmD16tX06NHjvWPIly8fgYGBnDx5kqpVq753e2nN3r17adeuHQaDgc8++4zVq1fLhCANkclAMpjNZgoXLUaofX6yfTr2pfuYosMJ9OzF1ClTaNmy5Ru/xT9fvTC5dDodOXPmJFeuXEn+fNlzLi4uyof01m07GPzNTxjsc9KxRV2qveRDZuuKefy23ZusLcfgULJOkg/4+IDLBG+ZilqYmea5g0xOLgizGSHMCLNg3fp13Hr0DF3UXXasnE++fPkwm82vfej1eiIiInj27BkRERFEREQQGRmZ5BEVFZXkER0dTXR09HtXklOpVOhsbFGp1STExZKnz4/osr38QiSE4PGy/lStUo3eI6czdUh7Ht69waD/zadyLcsMFn149wZTh7THyTUL89e/vtRyajCbTPz47WjOH/fBwdGJCXPWkqdAYYu0/TjgDuePH+Scnw/3blxOsi1vwWKJiUGNRuQvXMKqMxNCQkM46neKs5duEK83ojbGYaMPpV7lEvTr2ZH69eqh0WiYNGkSM2fOxNbWFl9fX9zd3d/5mEajEVtbW8xmM48ePUqX6wwkx65du+jQoQNGo5Fu3brh7e39Qs+LZB0yGUiG8+fPU6lSJXJ2mYWd26trDwRvn0HcrVMgzMlqV6VSKffSdTodOmWQ2T8PjUaDWq1GpVL9Pd/8n4vqf///ZQ8hBNHRMeiNJoQQ6LQaVCrV39sSL+j/HvCny16QTCXrgEZD3O3TJARcUQbWfYgKjNv92umXwVu/oXi2TPQb+x1fdqqJMJuZs8YH16w5LHL8p8GPGd+rCVqtjh93nbXqRVAIwUav7/HZvQ6tVseoWcteuez0+woLfcIFv4OcO36QG5fOJHkPZsuVl4rVG1KxZiOKlqqA2koXC4PBwMXLlzh28jwPnoShMhvR6CPI6yzo3q4p3bp0ZMCAAezZs4c8efJw5syZd76IP3jwADc3N3Q6HfHx8am6rHlq27FjBx07dsRkMtGzZ09WrFghE4I0QPbRJMPzbnqN8+vvcWqds/994Uxeu0IIZQpcajHoja/fHnKfZ6H/qYD42kQg8eKl0yUmL2q1Wklenv/9VQ9L7POq7WfOnOFZggZUGsqWLoFKpUYgMJtMmE0mwp8+4eHdm5giQ9C65Hzl2ZmjQnEomJu7Ny4jzGayZM9tsUQAUAoVGY0GDPqEN9ZFSEkHdqzGZ/c6AL4YPSvFEgGALNly0fDTrjT8tCvRkc/469Rhzh/34cq544Q+CeTAzjUc2LkGJ9csVKjWgIo1G1KqQvUXymWnJJ1OR+WKlahcsRJBQUEc9TvF+Ss3ua838e1aX+at2EntCkVxc3Pj/v37tG/fnkOHDr3TAjvP1xjImzfvB50IALRt25aNGzfSpUsXVq9erVSI/NDPO62TyUAy5MyZeLEwPA1AlznPK/czhD4gV84cTJwwAZ1OZ7ELmyXaWL9+PUvX7ELvWBCEiVpVytGgYUPUKjUqlRqVWvX3n2pUgEqtTtz29/N+B/ewZtE0ALQ6GxyKNkTjmB1d9H3a1i2Np+ePqfAvkXyzZ89mzurfMTjkpkP/Xsq/4XPxsTGM6tGIqL9+J3Pdl9/vTXh0nYTgu7jXGcNt/7+LE5V6eXGid2Vr54BKrUaYzcTFRFstGTh95Fc2/5w4EK5jn9FUrdcs1Y7t6OxKrcatqdW4NQnxsVw+e5zzx324ePowUc/C8P1tG76/bcPOPhPl3OtQsUYjyrvXwc7hzStsWkrOnDlp3+ZTWn1i4MKFvzh2+gIPgx34wz8G7Aqi0T7Cz8+PPn36sGbNmrfu4Ulv1QrfV4cOHVi3bh1du3Zl1apVaDQafvrpJ5kQWJFMBpKhVKlSfFShIjfP78O+SNWX/qIbnj4k/v5fPAHmz5/PyJEj+eKLL3B0dEz9gF/im2++QaPR8OO6veidCuF3NZALV3+iU4e2lCtb7o2vr9e8IzFx8Wz/eTZGg55I/wNkKViOJrXLp7lEAGD48OEs+HkThkx5+Hn5Cv731cQk2+0cMlG/eQf+2L0euwLlsC9YIcl2Y3QYoXvnorW1p0S5Kvy5L3Hq5X+LE70vtVqNvYMjsdGRxMZEWmWE/Y3LZ1k+5ysAGrbqShMrLi1sa+dA5VqNqVyrMUajgesXT3Pe7yDn/Q4SERbC6SO/cvrIr2i1OkpVrE7FGo2oUL0+zq4vnwljaTqdDnf3Kri7V+HJkyf4+p3iwhU77ISWmBs+rFu3jpt3HzJv9kxq1qyZ7KQgoyUDAJ07d8ZsNtO9e3eWL1+e+Pn0448yIbASOWYgmZ6PHnap2QWXWp8lWYTFGBnC061fY2uIQqtR8/TpUwAyZ87MoEGD+PLLL9PMWv379+9nwLBxxNvnw2ibDaFSoTHHk9XZntKlSlK5cuXEWFUqwsLCOHf2LJcuXyE4LAqj2hZ9+ANibx0BQKvVcvbsWcqXt+wF0lIqu1fjvjE3Zq0jvbp8SpnSSVeMMxj0LJ42nCvnjuNQtGri4EkbO+LvXyT28h+Y9QkIs5HqDVty6fRRYqKe8dW8dRZPCCb0bkZoUCAT5619ZVnklPLowR2+G9OD2OhIKtZsxKCJc612j/51zGYzd29cSkwMjh8kKPCesk2lVlO0VAUq1mxEpZqNyJbz5WsEpBS9Xs/5CxfYtXElwf5HARXOhd0p7paLzzu0oGuXjm9cnGj48OEsXLiQ8ePH891336VO4GnE2rVr6dmzJ0IIBg0axJIlS6y+tHVGJJOBt/D9998zYcIEbLPkxq5kPdT2Tuif3CTu+jFy58qFzx8HKFCgAN7e3sydO5dbt24BYGNjQ8+ePRk9ejQlS5a08lkkfrB+/nkvfPz+wmiXHZNtFoTGDvH8F1B5SyT+v0olUJn0aBKeoY0PJqeTiot/XcBsNqPT6Th27Nh7jaROKQEBAVRr2Ip419KoTHrGjhhM9uzZk+xjNBo4+tsOfPZs4PGDxH8vBycX6jZth1vR0iybPUEZ3KbV2bB46wmlsJGlfDO0IwF3/Bkx7UfKVqlt0bZfJyIslFmjuvE0+BGFS5ZnzLfLrTpmIbmEEDwOuMO54z6cP+7D/VtXk2zPX7gklWo2pGKNRuQtWCzVLixCCBZNH8HFEwdRaW1xLNMcnVqDnfEpTWtXoH/PzlSrVu2l8bRr144dO3awaNEihg4dmirxpiWrV69WqkIOGTKERYsWyYQglclk4C2dOnWKxYuXsGfvXuLi4shfoAAD+vWlT58+SdYXMJlM7Nq1Cw8PD06cOKE836pVK8aOHUutWrXSxJt94cKFrFy9jpDIBExqW4TaBqHSIlQqVGYjarMetTkBZ1sVbT9txvTp09FoNBw8eJAmTZpgMpnQarUcOnSI2rVT70KWXLNmzeKHNb9gcCqCyhRP57afULnyiwPjhBDEREVgMhpxdHFV1tY/uGc963/8FoBc+Qsxw2u3xWP0mPAF1y+epv/42VSt19zi7b9MfFwss8f34sGta+TIU4CJc9fg5GK5pXVT09Pgx3/fSvDhxuWzCPM/s3my586vTFksXLJ8indB6xPimT2uF/duXiFzznxkL9+C4Ih4VGYD2oRwCmW3o1fnT/isUwdcXV2V17m7u3PmzBl27tyZIkWQ0oOVK1fSp08fhBAMGzaMBQsWpInPyIxCJgOp4NixY3h4eLBr1z9136tXr87YsWNp3bp1mplWI4Tg1q1bXLt2DZPJRJEiRShTpswr4zt+/Dj16tXDaDSi0Wj47bffaNSoUSpH/WbDh49g028n0TsVQqg0uNoKBg/sn6x15YUQTBnYhscBd9BqdXy9ZKuy8JKlLJk+nPN+B+kxdDL1WnSyaNsvYzIZWfTNl1w+cxQnlyxMnLfW6ov+WEpURDh/nfyT834HuXLueJKaCS6Zs1GhegMq1mxEyfJVLd7D81xY6BNmDO9CZPhTKtf6mJY9R+Drd4ZL1+9iMJpRG6OxN4XTom4l+n/ehcqVK5M7d26CgoI4e/YslSpVSpG40oPly5fTt29fAEaOHMncuXNlQpBKZDKQiq5fv87cuXNZvXq1snhO0aJFGT16NJ9//jn29vZWjvDtnT59mlq1amEwGFCr1ezZs4cWLVpYO6wXLF++nMnf/oDBsSBGW1dUZjO2Kj1FCubn448bky/fqy+Gz7vxAXLmceOr+evI5ORisdhWzPsfx//YTfveI2jesY/F2n0ZIQSrF36D72/bsLG1Y8x3Kyhc4s0DSNOj+LhYLp89mjgz4dQR4mKjlW32Do6Uc69DpZqNKFulTpIllS3h1tULeEzojclopE2PobT8bABx8XGcPXee46cvEhwejcqkR5sQRpGcdpzwSfyiEBwc/MKtrIzmp59+YsCAAQCMGTOG2bNny4QgFchkwAqCgoJYtGgRS5cuJTw8HIBs2bIxdOhQhgwZQrZs1l+z/W1cunQJd3d3EhISUKlUbN26lXbt2lk7rBdER0fzaes2+Ac8w2ifC5ONM0Kd+O1QLYzkyJ6VzM5OZM3sQrYsrmTLmhkHBztmDG6L2WxSahOUrliD4dOWWqxM70av7/lj11qad+xD+94jLNLmq+zd4MXONYtRqdUMmbSACtUbpOjx0gqjwYD/xVOcP+7DhROHiAgPVbZpdTaUrliDSjUb8VG1+ji5vHk58eTw/W073j98DcCQyT9QsUbiMuYCQcCDAI74neLy9fvoY58ReXEnKpWaAV+OZkDvrnz00UcZ+gL476qw48eP59tvv83QP4/UIJMBK4qOjmbFihXMnz+fe/fuAWBvb0/v3r0ZNWoURYq8vPRwWuTv70+lSpWIi4tDpVKxdu1aunbtau2wXio8PJyRI0fhe/I8sWYdZo09Zq09QuOAUOsQai2oNAiVGmPEE6Kv/47axoECVVvxwG8bZpOB0lUb0aLLAFz/roVg+x5lenetXcqe9T9Sr0UnegydbMEzTerYH7tYOW8SAN2GTKLBJ51T7Fhpmdls5o7/Rc77+XDuuA8hjwOUbSq1mmJlKlGpRmLNhKw53m9Z4PU/zuLgng3Y2jvw1bx15HUrmmR7bFwsv+zYxG9r56G2dcKl7CdoE8IonteZsoVzMmrEMIoXL/5eMaRXS5YsUQZTfvXVV8yYMUMmBClIJgNpgNFoZOvWrXh4eHDu3Dkgcf55u3btGDt2bLopWnLnzh3Kly9PTEwMKpWKn3/+mS+++MLaYb2WEILr168TGBiIyWTi7v0A7j54xP3AJwQ+CeXKxbOEBd7GxjknToVrkBARRPRdPwDsC9XENltRQGBva4OLs8MLPQvJSRYO7FzDpp8SBw/2Hz87Rc7zyrnjLPx6CCaTkWYdv6BD75Epcpz0RghB4L2bfycGB5XbQc8VKFpKSQzyFCjy1hcjo9HA/EkDuH7xNNlz5+d/Czbg+J9bTCcO7eVnj4m4FS+HW9U2XL31AJPJjNoQjTbuMbkymdi2eUO6+nJgKQsXLlTKOU+ZMoVvvvnGyhF9uGQykIYIIfjzzz/x8PBg//79yvN169ZlzJgxfPLJJ2l+QY6AgADKlClDVFQUkJjdP+/uS4/atGnDrl27GDt2LI0bN+bu/QDWrFnLMd8/UanU5CleEYPaAbPWAaGxf6FnIXFp6tcnC/7nfFm7aBplq9RmxDTLL+AUcOc634/9nPi4GKrWa07fsd+l+feRtYQ8efj3WgY+3Lp6nn9/PObM40bFmok1EwoVL5fsn2FURDgzhnfhafCjl95i2rf5Z7av+oEajVrRZ/RMYmNj2LNvP2f+uo7Q2KLRR2ATfZ9hfToxYcIEi59zWjd//nxGjUqsEvrNN98wZcqL5cil9yeTgTTq8uXLzJkzh/Xr12MwGIDElRBHjx5N9+7d32n989Ty5MkTSpUqpdR0mDNnDqNHj7ZuUO9ACEGuXLkIDg7m2LFj1KxZE0jsZu7YsSPbt28nZ86cHDx4EJVKRUBAwAs9C4+CnxIVq39tsqAPv0/srcPYu+aiQrMv3rpn4XXCQp4wa1Q3nj0NpkR5d0ZM90zV9f3Ts8hnT7lw4k8u+B3k6nk/jEaDss01a47EmQk1GlKivDta7etnJgTcuc63o3ugT4ijSbvP6dR3jLJt3ZIZHPplEy0696Pd58OU540mI4uXLCEwNBYAXfQ92tQth5eXp4XPNO2bM2cOY8cmVoydMWMG//vf/6wc0YdHJgNpXGBgID/88ANeXl5ERkYCkCtXLoYNG8bAgQOTrG2QloSGhlKyZEllNcbp06czadIkK0f1du7evUvhwoXR6XRERkZiZ/fPgjzR0dHUqlWLixcvUqlSJXx9fXFwePmI9MjISAIDA1+ZLDwNCebZg0tobJ1wKdPsrXsWXpUsxEZH8t3Yz3l0/xZ53IoywcMbB0fnFPppfdjiY2O4dMaX834HuXjqCPFxMco2B0cnyrvXo2LNRpStXBNbu5e/D874/obnt4lJQJ/Rs6jR6FOePLzLirmTuHP9Ip8NnEijVi+Os7lx4wY/e29AaO3RRd1mdO/WjBs3LmVONA17vugbwLfffpshe0lSkkwG0onIyEiWLVvGggULlApnmTJlol+/fowYMQI3NzcrR/iiZ8+eUaJECYKDg4HEQUAzZ860clTJt379erp160bVqlU5efLkC9vv3buHu7s7oaGhdO7cmQ0bNrzTACdfX1/q1q1L1qxZmfnt92/ds/CyZCGzcyb+3PYjAbeu4JIlO1/NW/feg+GkRAaDHv8LJznv58P5E4eIehambLOxtaN0xRpU/Htmwn/HB+xcvYi9G39CrdGSK39hHt27oWyzc3CicavP+OSzAS/03oSFh/HdnEUIjQ67Z1e5cupQmv0ikJJmzZql9ArMnj1b6S2Q3p9MBtIZvV7Ppk2b8PDw4NKlSwBoNBo6d+7MmDFjqFixopUjTCo6OpqSJUsSGBgIJC4kMm/ePCtHlTxffvklixcvTix6tGDBS/c5cuQIjRo1wmg0MnPmTL766qu3Ps6dO3coUqQIDg4OxMTEvLA9IiKCwMBAHj58yO17D7j74BEP/pUsRMcZ/04W7BAaG8yoib17An3YPVBrcSzVFOcsuXB2ykRmFyeyujqTLasr2bJmIbNrYs+CjY28dfAuzCYTt/3/Slwa2c+H0CeByja1WkPxclWoVLMhFWo0JEu2XJjNZqYP60zAHX9s85bEyb0ttrmKYYqLJOayDzF//UqxMpUYMW3pCwnBpUuX8N76C1p9BKVcozny56HUPt00Yfr06cq4gblz5yrjCaT3I5OBdEoIwe+//46Hhwc+Pj7K840aNWLs2LE0adIkzUzDiYuLo1SpUty/fx+AQYMGsXTpUitH9WbPl4jdsGEDXbp0eeV+/14k5V2Wkw0LCyNr1sSqewkJCW99Yf5vsuDtvZqTx31RqVTkLFIes84lSbIgVJp/ehYAhMDBzkYmC+9JCMHDuzeUxODh3RtJthcsXpaS5avy+w5v7Es3IGvzYahUSQchxgdcJmTzZFp27kerboNeOMbXU6cRK2yxC79E4I3zaeZ3PLVNnTpVmVkwf/58RowYYd2APgAyGfgAnDt3jjlz5rB582ZMpsSiOuXLl2fMmDF06dIFXQotu/o29Ho9ZcqUUYo39erVi5UrV1o5qleLi4vD2dkZo9HIvXv33ngbZujQoSxZsgRHR0f8/PwoW7Zsso9lNBqVf6P3XYHO09OTQYMSLyIrV66kV69eb92zIJMFywh+HKDMTLh97YIyM0GltSXf0DWobV8+tuDp70tR3T2Jx+oDLwxMPHvuLBt3H0QXdYcdP3+vDGrNaIQQTJkyhRkzZgCJUxC//PJLK0eVvslk4ANy//595s+fz88//6x0N+fLl48RI0bQr18/nJ2tO3jMYDBQoUIFrl5NrDLXuXNnNm7caNWYXuXo0aPUqVOHXLly8ejRozd+AzMYDDRt2pRDhw5RqFAhTp8+rXzbTw5nZ2eioqK4ceMGxYoVe6eY9+zZQ5s2bTCbzW81BUsmCykvIiyUCycPsWXFfDSF3Mn2yau7thMCr/Fk7Vj+t2ADhYq/mFSOnfItmoRQejUtj4eHR0qGnaYJIfjf//7Ht98mFhJL79OYrc0y66lKaYKbmxsLFizg66+/xtPTk4ULF/Lw4UPGjBnDtGnTGDhwIMOGDSNv3tSt9/6cTqfjr7/+wt3dnQsXLrBp0ybi4uLYuXNnmuvu9PNLXFioRo0ayYpNp9OxZcsW3N3duXv3Lh07duS3335Ldq+Mi4sLUVFRREREvFO8p0+fpkuXLpjNZvr06cPkyclfydDFxQUXFxdKly790u3JSRb08Q6ERNkRHCSThZdxyZKNes078vuOtcTaOb12X/Xf2w0J8S/fQQhAo6zlkVGpVCpmzpyJyWRi9uzZDBkyBI1Go9yyk96OTAY+QJkzZ2bixImMGjWKtWvXMmfOHPz9/Zk9ezbz58+na9eujBkz5q26si1Fq9Vy9uxZatasycmTJ9m9ezfNmjXj119/TVMJwfOy09WrV0/2a7Jmzcru3bupUaMGhw4dYuTIkSxevDhZr3V1deXhw4fK2gxv4/bt23zyySfExsbSrFkzfvzxR4v+LGWyYDnZcubh1iP/1+6T8Pg6AFlz5HlhW1xcHEKtQWVOoGTJkikSY3qiUqn47rvvMJlMzJ07l4EDB6JWq+nXr5+1Q0t35G2CDMBsNvPLL7/g4eGBr6+v8nzz5s0ZO3Ys9evXT/ULsRCC+vXrc+TIESBxlcU///wzTSQEQgjy5s3L48ePOXLkCHXq1Hmr1+/evZs2bdoghMDT0zNZ31Tq1KnD0aNH2bJlCx06dEj2sUJDQ6lZsyY3b96kYsWKHD58GCen13/zTG3/ThZu3b3/d7IQROCTEB4HhxEdn5zbELa4OGUis4sjWTM7ky1L5sRkIbMrrpkzY5MOFlK6c/0Sy74fR8iTh+Tq7oFt3lIv7CPMJoLWjKZwrmyMnrXshe3Ll6/gWkAYdhHXuH7qgNVv/aUVQghGjRqlzPpZvnx5ml8KPa2RyUAGc/LkSebMmcP27dsxm80AVK5cmbFjx9K+fXu02tTrLBJC0LRpUw4cOABAtWrVOH78uNWXyn3w4AFubm5otVoiIiJeuZjQ6zyfD63VavHx8aFu3bqv3f/TTz9l7969LFu2TKnn/iZxcXE0atQIPz8/3Nzc8PPzI3fu9LeWQEREBA8fPvxPz8LLkgV7hEaX7pKF6MhnbF+1AN/ftiOEQK3RobJ1IFvbr7DLV0bZzxQXRfiBpcTdOM6Yb5dTvGzlJO0IBOP/Nw3UGpwiL3PvxuXUPpU0TQjBiBEjWLhwISqVipUrV/L5559bO6x0Q94myGCqVavGli1buH37NvPmzWPFihWcPXuWLl26UKhQIUaOHMkXX3xBpkyZUjwWlUrFb7/9Rps2bdi9ezcnT56kcuXKnDlzBo1Gk+LHf5Xn4wU++uijd0oEACZOnMjFixfZtGkT7du35/Tp0xQsWPCV+7u4JC5Ok9wxAyaTie7du+Pn54erqyv79+9Pl4kA/HMbokyZMi/dnpxkQR/vQHCUPUFBaSdZMJvNHP19B9tXLSA68hkANRp+StMOvVk5fwr3143HLncxtDmLYo6LJP72adRqFQMmzHkhEQCYN38BZl0mbKLvMbR/L4vHm96pVCoWLFiAyWRiyZIl9O7dG7VaTY8ePawdWrogewYyuJCQEJYuXcrixYsJDU2s8Z4lSxYGDx7M0KFDyZkzZ6rE0blzZzZv3gxA6dKlOX/+vNXuE48cOZIFCxYwdOhQFi1a9M7txMbGUqdOHc6dO0f58uU5duwYjo6OL933+dTESZMmMX369Ne2++9vQDY2Nhw4cOCNPQ8fMsv0LNjg4uRosWTh/q2rrFsykzvXLwKQ160o3Qb/j+LlqgCJixVdPOPL0d92EBL8CFtbOypUq0ftJm1xdn1xFsqKFSu4+iAUTUIEOUwPuHrp/Pv90D5gQggGDx6Mp6cnarWaNWvWpNly6mmJTAYkIPHC5e3tzdy5c7l9+zYAtra29OzZk9GjR1OiRIkUj6FXr154e3sDULRoUS5dupSkHkBqqV69OidPnmTt2rV069btvdoKCAjA3d2doKAg2rZty9atW196G2TSpEnMnDkzWQnIvHnzlMJPGzdupHPnzu8V44cuNZOFmKgIdq5ZzJ/7NiPMZmztHWjdbTANW3V9YzGjl9Eb9Mz2mEuEXotaH4V91HX+OuVLlixZLPkj+uCYzWYGDhzIsmXLUKvVrFu37rULh0kyGZD+w2QysXPnTjw8PJT1+FUqFa1atWLs2LHUqlUrRY8/aNAgPD0Tq7K5ublx5cqVVLll8Vx8fDzOzs4YDAZu375N4cKF37tNPz8/6tevj16v5+uvv2bq1Kkv7PO8Klv37t1Zs2bNK9vasmULnTp1AsDDw4MxY8a8cl8peSyRLNjb6iAygJDrxzAmJFYZLFmxFm16fkmBwsXeumchISGe5StWcjfwKUJrhzY+FIfYe/j67KNAgQKW/hF8kMxmM/3792f58uVoNBo2bNhAx44drR1WmiWTAemlhBAcPXqUOXPmsHv3buX5GjVqMHbsWFq1apVi9/Wfd9MD5MmTB39//1QbIe/n50fNmjXJnj07QUFBFpvdsHLlSmV088tmDCxbtoz+/fvTsmVL9uzZ89I2jh49SuPGjUlISGDo0KHKQCkpZb0pWXj2LILIoDsYY8MBUNs54+Dmjtbl7/U8BDjY6ZL0LGjVEB8Xh7OLM1kyZ0Gv1xMY+JD7Dx7wNCIGg9Ah1DrUxhh0MYEUzqblz4N/fDBTLFPL83U3Vq1ahUajUcbwSC+SyYD0Rv7+/sydO5fVq1ej1+sBKFasGKNHj6Znz57Y29tb/JhfffWVsrJYjhw58Pf3T5Uqbc+74Fu1asWuXbss2vaoUaOYP38+Dg4OHDt2jAoVKijbnn/jr1OnjjLd8t/8/f2pWbMm4eHhtGnThq1bt1p1kKWUWEl0ypQpLF68GJPJhK2tLc1afEKhYqUJfBJK4JNQHgc/JSbB9OqeBQH8nc+pROJ/VCY9amM02vgQXHV6lv24iNq1a1vzVNM1k8lE7969WbNmDVqtls2bN9O2bVtrh5X2CElKpsePH4uvvvpKuLq6ChI/xkT27NnFtGnTRGhoqMWP98033yjHyZo1qwgODrb4Mf6rY8eOAhCzZs2yeNsGg0E0adJEAKJAgQIiKChI2fb7778LQJQrV+6F1z1+/Fi4ubkJQFSvXl3ExsZaPDYp+cxms1i/fr3InTu38v5s3769uH///kv3DQ8PF5cuXRL79+8XS378SYye+LVwr9tM5C5WSeQqUU3kLFFD5CxRXeQq7i7yFP1IlChbUfTt2088efLECmf3YTIajaJbt24CEFqtVuzatcvaIaU5MhmQ3lpUVJRYsGCBcoEChL29vRgyZIi4ffu2RY81e/Zs5RguLi4iMDDQou3/V758+QQgDh06lCLth4WFiWLFiglA1K5dWyQkJAghhDh16pQARP78+ZPsHxUVJSpVqiQAUbRo0VRJiKRXu3r1qmjQoIHynixatKjYv3//e7VpNBqF2Wy2UITSqxgMBtGlSxcBCJ1OJ/bs2WPtkNIUmQxI78xgMIgNGzYoFytAqNVq0bFjR3Hq1CmLHWfhwoVK+05OTuLevXsWa/vfAgIClHOIiopKkWMIIcS1a9eEs7OzAETfvn2F2WwWN27cUM7vOYPBIFq0aCEAkS1bNnHz5s0Ui0l6vaioKDFu3Dih1WoFIOzs7MS0adNEXFyctUOT3oLBYBCdOnUSgLCxsRG//PKLtUNKM2QyIL03s9ksfHx8RLNmzZSLNiDq1asn9u7dK0wm03sfY9myZUq7Dg4OKXJh3LJliwBEhQoVLN72f+3bt0+oVCoBiIkTJ4rPP/9coNYI1BpRsVJlsXTpUtGrVy+l1+XEiRMpHpP0IrPZLLZu3ar0GAGiZcuW4s6dO9YOTXpHer1etG/fXgDC1tZW/Prrr9YOKU2QyYBkURcvXhQ9e/ZUvkEBonTp0mLFihUiPj7+vdpes2aNcgG1s7MTV69etVDUiUaPHi0AMXDgQIu2+yoeHh7Kz0jnlEU4ubcRrnV7ikzFqglUKoFKLVQqlby/aSU3btxQxngAomDBgmL37t3WDkuyAL1eL9q2baskBL///ru1Q7I6mQxIKSIgIECMGTNGODk5KR+muXPnFt9++60IDw9/53Y3b96sJAS2trbi3LlzFou5Zs2aAhDe3t4Wa/N1tm/fnnhrwL2NKDBmp3Abv1d55OnrKTTO2UX2nLmUcQVS6oiJiRGTJk0SNjY2Snfy5MmTRUxMjLVDkywoISFBtG7dWvly8ccff1g7JKuSUwulFBUREcFPP/3EDz/8QGBgIACOjo7069ePESNGvNMCKrt376Zt27aYzWZ0Oh2+vr5Uq1btveLU6/U4OzuTkJDAjRs3KFas2Hu1lxyVq7jj/9RItk7TX7pegD74Do9XDmPDhg1y9bRUsnv3boYPH869e/cAaNq0KYsWLUqV94OU+vR6Pe3bt2fv3r3Y29vzyy+/0KBBA2uHZRXWLQ8nffBcXFwYO3Ysd+7cwdvbm7JlyxIdHc38+fMpXLgw3bt356+//nqrNlu1asX+/fvRaDQYDAZq16790rn5b+PChQskJCSQNWtWihYt+l5tJce1a9c4d/YMmSq1fOXCQTY5CuNQoCwrV61K8Xgyurt37/Lpp5/SunVr7t27R758+di6dSv79++XicAHzMbGhq1bt9KiRQvi4uJo2bIlhw8ftnZYViGTASlV2NjY0LNnTy5evMj+/ftp2LAhJpOJdevWUaFCBZo0acKBAwdIbkdVkyZN8PHxQavVYjQaadiwoVIK+V08r1RYvXr1VFnV73kviS57wdfup8lWkAcBgSkeT0YVHx/PtGnTKF26NHv37kWr1TJ+/Hj8/f1p3769XOExA7C1tWXbtm00a9aM2NhYPvnkE3x9fa0dVqqTyYCUqlQqFc2aNcPHx4czZ87QpUsXNBoNBw4coEmTJlSsWJF169ZhMBje2Fa9evXw9fVFp9NhMplo1qzZK5fyfZMTJ04AiclAanB2dgbAFB322v1MMWG4ujinRkgZzq+//krZsmX5+uuviY+Pp0GDBly8eJHvvvsuVethSNZnZ2fHjh07+Pjjj4mJiaFFixYcO3bM2mGlKpkMSFZTuXJlNmzYwK1btxg2bBiZMmXir7/+onv37hQpUoR58+YRFRX12jaqV6/OiRMnsLGxwWw207p1a7Zu3frWsTzvGahRo8Y7ncvbqlSpErnz5iPm0qt7M0wxz4i/dYoO7dulSkwZxYMHD2jfvj3Nmzfn9u3b5M6dmw0bNuDj40OpUqWsHZ5kJXZ2duzatYtGjRoRHR1N8+bNlS8JGYEcQCilGWFhYfz4448sWrSIoKAgIHHMwcCBAxk2bBh58uR55WsvX76Mu7s78fHxqFQqvL296dGjR7KO+/jxY/LkyYNKpeLZs2fKt/aU5uHhwfgJE8nWegIOxZMmIWZDAk93fYs6+Dr3792TJWstQK/XM2/ePKZPn05sbCwajYZhw4YxderUVPs3l9K+2NhYWrZsyaFDh3B2dubAgQNUrVrV2mGlPKvOZZCkl4iLixPLli0TJUqU+Gcevk4nevfuLa5cufLK112/fl04ODgor/Hy8krW8Z5P8XtZXYCUZDQaRfsOHYRKrRaZStQS2dtNFjm7fS8yN+gj7LLmFbZ29nL+s4X88ccfSd5PderUERcvXrR2WFIaFR0dLerVq6csg3769Glrh5TiZDIgpVkmk0ns2rVL1K5dO8nKhp988on4888/X7qe+507d4Sjo6Oy7w8//PDG44wbN04Aol+/filxGq9lNBrF0qVLRfGSpf45R5VKdOnymbhw4UKqx/OhefjwoejcubPys82RI4fw9vaWtQCkN4qKihJ16tQRgHB1dRVnz54Vjx8/FjNnzhQdOnQQHTt2FHPnzhVPnz61dqgWIZMBKV3w8/MT7dq1UxYcAoS7u7vYtGmTMBgMSfYNCAhQ1v4HxHfffffatp//wq9YsSIlT+G1zGaz2L9/vwBE5syZrRbHh0Kv14u5c+cqiaFarRZDhw59rwWvpIwnMjJS1KpVS1mYSK3RCI2NrbAvWEHYu5UXaq1O2NjaiaVLl1o71PcmxwxI6crNmzeZP38+K1euJD4+HoBChQoxatQoevfurYwCDwoKonTp0oSFJY7W//rrr5k6deoL7RkMBlxcXIiLi+Pq1atWHUD29OlTsmXLBiROebO1tbVaLOnZkSNHGDJkCJcvXwagWrVqLF26lEqVKlk5Mik9ioyMpFy5cjx48ADn6h1xqdYetZ0jkDjI99mx9USf38fKlSvp1auXdYN9DzIZkNKlkJAQlixZwuLFi3n69CkAWbJkYciQIQwdOpQcOXIQGhpK6dKlCQkJAWDcuHF8//33Sdo5e/YsVapUwdXVladPn6JWW2+CjRACOzs79Ho99+7dw83NzWqxpEdPnjxh7NixrF27FoCsWbPy/fff07t3b6v+u0rpW0REBDlz5cambBOyNOr3wnYhBE9/mYt98FUCHwZgY2NjhSjfn/wNkdKl7NmzM3XqVB48eMCSJUsoXLgwYWFhTJ8+HTc3NwYOHEh4eDg3btwgd+7cAMyePZthw4YBiTMIvLy8mD59OpA4zdHaFwyVSqXMmHj06JFVY0lPjEYjixYtokSJEqxduxaVSkX//v25fv06ffr0sfq/q5S+Ja57ose56sun+KpUKpyrdSQ0JJjdu3encnSWI39LpHTNwcGBwYMHc+PGDbZs2ULVqlWJj4/Hy8uLEiVK8MUXX+Dt7U3+/PkB/l5nvjj5CxRg0OAh7Pk1cZ7/4SO+jB8/HqPRaM3TkcnAW/Lz88Pd3Z1hw4YRGRlJ5cqVOXHiBF5eXmTNmtXa4UkfgGvXrmGXvQBap1e/n2yyu2HrnIWrV6+mYmSWJZMB6YOg0Wjo0KEDJ06c4PDhw7Rs2RIhBDt27KBJkybkzp2bnDlzgkrN7fsBONfrTb4v15F/xGbyDl5Fpipt8Zgzlx49eiR7SeSUIJOB5AkJCaFPnz7UrFmTCxcu4OrqytKlSzl58mTGmBMupRqtVosw6F+7jxBmzAYDOp0ulaKyPJkMSB8UlUpF3bp12bNnD1euXKFPnz7Y2Nhw6tSpxIWMVCpyfvYtzlVaK4OAtE7ZcK3bg6wtx7Bx40b27dtntfhlMvB6JpNJ6fVZsWIFAL169eL69esMGjQIjUZj5QilD029evWIexpIwpNbr9wn/u55DHFR1KtXLxUjsyyZDEgfrNKlS/Pzzz9z7949JkyYgFqjJVOputjmfnkVOoeStbHPU4zFS5akcqT/kMnAq505c4YaNWoo40HKly/P0aNHWblyJTly5LB2eNIHKDo6mr1794JKTfjBnxHGF2ummPVxRB1dQ9ly5VNtOfOUIJMB6YOXO3duvvzyS8wmIw4lar9yP5VKhW3RGhw9ar0CJTIZeFFYWBiDBg2iatWqnD59GicnJxYsWMDZs2epVauWtcOTPlAnTpygYsWKLF++HIQZwyN/gjdOIPbmSYTJiDAaiLl2hJD141BHPWG196p0XeVSa+0AJCk1mEwmAFTq13cjqzRazGZzaoT0UjIZ+IfZbGbVqlWMHz+e0NBQALp164aHh4cyQ0SSLM1gMDBjxgxmzpyJyWQif/78eHt7Y2Njw7DhIzi3fXqS/WvVrsOSxTv46KOPrBSxZchkQMoQcuXKRZas2Yi7ew77IlVeuV/s7TMYExIYMmQIAwYMoHz58qkYpUwGnrtw4QJDhgzh+PHjQOItnyVLllC/fn3rBiZ90G7cuEH37t05ffo0kJh8Ll68GFdXVwDOnjnNuXPnOH/+PCqVimrVqlGmTBkrRmw5ctEhKcOYOHEicxYsImfvRWidX7zHHP/wGkHrxiZ5rmbNmgwcOJAOHTpgb2+f4jFGREQoHzwxMTE4ODik+DHTkoiICCZPnsySJUswm81kypSJqVOnMnz48HQ9UltK24QQeHl5MWrUKOLi4nB1dcXT05POnTtbO7RUI5MBKcMICQmhchV3gqP0uHw8CLuCFVCp1AiTgRj/o4T9tgRh1JMndy6qVavGnj17lHUHMmfOTK9evRgwYAAlSpRIsRiFEDg6OhIbG8utW7coUqRIih0rLRFCsG7dOsaMGaOUr+7UqRNz584lX758Vo5O+pA9efKEPn36KLOIGjZsiLe3d8Z731mhHoIkWc29e/dExUqVBSBsXXMKh/ylhI2jqwBEvvwFlOJGBQoUEDdv3hQzZ84Ubm5uSaom1q9fX2zcuFEkJCSkSIxFixYVgDhy5EiKtJ/WXL58WSkXC4jixYvL0s1SqtixY4fIli1b4ueBra2YP3++MJlM1g7LKmQyIGU4ZrNZ+Pr6ihEjRohevXqJCRMmiMuXLwshhBg6dKhyUcqdO7cIDw8XRqNR7Nu3T7Rq1Uqo1eok5XAnTJggbt++bdH46tatKwCxceNGi7ab1kRGRorRo0cLrVYrAGFvby9mzpwp4uPjrR2a9IGLjIwUX3zxhfK7/NFHH4lLly5ZOyyrksmAJP3H+PHjlQ+J7Nmzi5CQEGXbgwcPxJQpU0SePHmUfVQqlWjatKnYsWPHC+WU30WXLl0EIObNm/febaVFZrNZbNy4McnPsE2bNuLu3bvWDk3KAI4dOyYKFy6s/O6OGzdOJqBCJgOS9FLTpk1TLlSZM2cWjx49SrLdYDCIHTt2iKZNmya5hZAnTx4xZcoU8eDBg3c+9qhRowQgxowZ876nkeb4+/uLxo0bKz+vwoULi71791o7LCkD0Ov14n//+5/Su+fm5iYOHz5s7bDSDJkMSNIrzJkzR7loOTk5ifv37790v1u3bonx48eL7NmzK/ur1WrRqlUrsW/fPmE0Gt/quB4eHgIQXbt2tcRppAnR0dFi4sSJQqfTKfdnp06dKmJjY60dmpQBXLt2TVSuXFn5/ezRo4d49uyZtcNKU2QyIEmvsXTpUuUDJFOmTOLGjRuv3Dc+Pl5s3LhR1K9fP0lvQcGCBcXMmTPF48ePk3XMdevWCUA0aNDAUqdhNWazWWzfvl0UKPDP4MwWLVqIW7duWTs0KQMwm81i0aJFws7OTgAiS5YsYvPmzdYOK02SyYAkvYG3t7dQqVQCEHZ2dspgw9e5du2aGDlypMicObNyEdRqtaJjx47ijz/+eO2I5UOHDglAlChRwpKnkepu3bolmjdvrpy/m5ub2LlzpzCbzdYOTcoAAgMDk9zGa9KkiQgMDLR2WGmWTAYkKRk2b96sJAQ2Njbi7NmzyXpdbGys8Pb2FjVq1EjSW1CsWDExZ84cERoa+sJrrl+/rtyaSI9iY2PFlClThK2trQCETqcTX331lYiJibF2aFIGsXXrVpElSxYlgV+4cGGGnTKYXDIZkKRk2rt3rzL4SKvVimPHjr3V6//66y8xePBg4eTkpCQFtra2onv37sLX11f5xhwZGalsj4yMTIlTSTF79+4VhQoVUuJv3Lix8Pf3t3ZYUgYREREhPv/8c+X9V7FiRXHlyhVrh5UuyGRAkt6Cj4+P0Gg0AhAajUb4+Pi8dRtRUVHip59+EpUqVUrSW1CmTBmxaNEiER4eriQM169fT4GzsLy7d++K1q1bK+eSN29esXnzZnlLQEo1R44cEQULFlQG8E6cODHFFgb7EMlkQJLe0rFjx5RR8Wq1+r2mxp0+fVr06dNHODg4KBdSe3t74eLiIgBx8OBBC0ZuefHx8WLGjBnC3t5e6TEZM2ZMuuvRkNKvhIQEMWHCBOU2XsGCBYWvr6+1w0p3ZDIgSe/g3LlzwsbGRlm4ZMuWLe/V3rNnz8TixYtFmTJlXpiJ4OXlJaKioiwUueX89ttvolixYkqs9erVS9bgSkmylMuXL4sKFSoo78HevXuLiIgIa4eVLslkQJLe0eXLl5UpSyqVSqxevfq92zSbzeLo0aNKd+e/1zkYNGiQuHDhggUifz8BAQGiQ4cOSmw5c+YUa9eulbcEpFRjMpnEggULlEGqWbNmFdu2bbN2WOmaTAYk6T3cunVLZMqUSbkwenl5WaTdsWPHCkDUrVs3ybdvQFSvXl2sWrUq1RfsSUhIELNnz1bOV61Wi+HDh8vFW6RU9fDhQ/Hxxx8rvw/NmjV7YYVQ6e2pkSTpnRUpUoRr167h7OwMwIABA1iwYMF7t5snTx4AcufOzfXr1/Hx8aFjx45otVpOnDhBr169yJs3LyNHjsTf3/+9j/cmhw4dokKFCowbN46YmBhq1qzJuXPnWLBgAS4uLil+fEkC2Lx5M+XKlePAgQPY29uzZMkS9u3bR+7cua0dWvpn7WxEkj4ET548SbLA0IwZM96rvU2bNglA1KlTJ8nzjx8/FrNmzXrhNkK9evXEhg0bLF5w5dGjR+Kzzz5LUrhp5cqVcs62lKqePXsmunfvrrwPq1SpIqesWphMBiTJQp4+fZqkPsFXX331zm35+voKQBQpUuSl25+XVW7dunWSssrZs2cX48ePf++yygaDQcyfP1+Z4qhSqcSgQYNEWFjYe7UrSW/rzz//VJazVqvVYvLkyUKv11s7rA+OTAYkyYIiIyOTlOYdMWLEO7Vz+/ZtZZrhmwbmBQQEiK+//jrJcfl7+dXt27e/9Qfn0aNHRfny5ZV2qlatKs6cOfNO5yFJ7yo+Pl6MGTNGmTJYpEgRcfz4cWuH9cGSyYAkWVhMTIxwc3NTLqb9+vV76zZiY2OV14eHhyfrNQaDQezcuVM0a9ZM+QAFRO7cucXkyZNfWXXxuaCgoCSrt2XJkkV4eXnJWwJSqrt48WKShLRv375pcnrth0QmA5KUAhISEkTx4sWVD7Nu3bq9dRvPxyC8y3Kqt2/fFhMmTHihrPKnn34q9u7dm6SsstFoFEuWLBGurq7Kvn369BEhISFvfVxJeh8mk0nMnTtXWcMje/bsYufOndYOK0OQyYAkpRC9Xi/KlSunXGDbtm37Vq9/vgDRgQMH3jmGhIQEsWnTJtGgQYMktxAKFCggZsyYIfbu3ZtkWeSKFSsKPz+/dz6eJL2rBw8eiIYNGyrvxU8++UQ8efLE2mFlGDIZkKQUZDKZhLu7u/IB17Rp02QvzvN8LrW3t7dFYvH39xejRo1KMuvh+SNTpkxi4cKFSXoMJCm1rF+/XumZcnBwEJ6ennIRq1Qm1xmQpBSkVqs5efIkdevWBeC3336jfv36CCHe+Nrnaw08fvzYIrGUKFECDw8Ppk+fTqZMmZJsi4mJYeHChcyfP5/Q0FCLHE+S3iQ8PJyuXbvStWtXnj17RtWqVTl//jwDBgxApVJZO7wMRSYDkpTCVCoVf/75J82aNQPgyJEjVKtWDZPJ9NrXPU8GHj16ZJE4zp07R82aNRk6dCgxMTGULVuWlStXMmTIEJycnLh16xZjx44lb968dOvWDV9f32QlLZL0Lg4ePEj58uXZsGEDGo2GqVOncuzYMYoXL27t0DIma3dNSFJG0q5dO6Vrvly5csJgMLxy30WLFglAdOjQ4b2OGRYWJgYPHqzMMHB0dBTz5s1LMuUwKipKLFu2TFSpUiXJ7YPSpUuLH374IdkzGiTpTeLi4sTIkSOV91jRokXFiRMnrB1WhieTAUlKZf9eSa148eKvrLm+bds2AYiaNWu+03HMZrNYtWpVkhkFn332mQgMDHzt606fPi369u37Qlnl3r17ixMnTsh7udI7u3DhgihbtqzyvhowYICIjo62dliSkMmAJFlF//79k5QpflnRIT8/P2X72/rrr79E7dq1lWOULFlS+Pj4vFUbz8sq//vDGxAVKlQQnp6eIjIy8q3jkjImo9EoZs+erUwZzJEjh9izZ4+1w5L+RSYDkmQl/+4qzZs37wsX1/v37wtA2NjYJPvbeEREhBgxYoTQaDTKyOzvvvvulb0PyWE2m8WxY8dEjx49lJKxz283DBw4UJw/f/6d25Y+fPfu3RP16tVT3jetWrUSQUFB1g5L+g+ZDEiSFU2aNEn5kMyRI0eStf8TEhKUbaGhoa9tx2w2i3Xr1olcuXIpr2nfvv0bVx18W6GhoWLevHlJFlQCRLVq1cTKlStFTEyMRY8npV9ms1msWbNGODs7K9NXly1bJm8zpVEyGZAkK5s1a1aSJYD//a0pW7ZsAhAXL1585euvXLmSZFGhokWLiv3796dozGazWRw8eFB06tRJ6HQ65diurq5i2LBh77RqovThePr0qejYsaPyvqhRo4a4deuWtcOSXkMmA5KUBixYsED54HR2dhYPHjwQBw8eFC6urgK1RpQpW07MnDkzyYpsUVFRYty4cUKr1QpA2NnZienTp4u4uLhUjf3Jkyfi22+/faGsct26dcX69estXlZZStsOHDigFM3SarVi+vTpr501I6UNKiHkRGJJSguWLVtG//79AVBrtZiNRnRZ8mKTtzQiIYaEu2fRqGDlyhXY2NgwcuRIHj58CMCnn37KDz/8QKFChawWv9ls5vfff8fLy4vdu3djNpsByJYtG71796Z///4ULVrUavFJKSsuLo6JEyfyww8/AImLXK1du5YqVapYOTIpOWQyIElpyNq1a+nR83NUWhuytR6PfeEqykpsprgonvn8RPTVP+HvX9uCBQuycOFCPv30UytG/aKHDx+yfPlyli1bRmBgoPL8xx9/zIABA2jVqhU6nc6KEUqWdP78ebp3787Vq1cBGDx4MB4eHjg4OFg5Mim5ZDIgSWnI4cOHqV+/PtnbT8GhaNUXtguziaD1E9A/vsGk/33FxIkTsbe3t0KkyWM0Gvnll1/w8vLi119/VVY0zJUrF3379qVfv34UKFDAylFK78pkMuHh4cGUKVMwGAzkypWLFStW0Lx5c2uHJr0lmQxIUhrSvXsPtv12mBxfLH3l2uyxN/wI2TGTS5cuUbZs2VSO8N3dvXuXZcuWsXz5coKDg4HE2g3Nmzdn4MCBNG/eHI1GY+UopeS6d+8ePXv2xNfXF4B27drh5eVFtmzZrByZ9C5kbQJJSkNu3LqFJlfx1xZpsc1bEoA7d+6kVlgWUahQIWbNmkVAQACbN2+mYcOGmM1mfvnlFz799FMKFSrEjBkzLFaYSUoZQgi8vb0pX748vr6+ODo6snLlSrZu3SoTgXRMJgOSlIZksrdHJMS8dh9zfDRAmr498Do2NjZ07NgRHx8f/P39GTVqFFmyZCEgIIDJkyeTP39+2rdvz4EDB5RBiFLa8PTpUzp27EivXr2IioqiVq1aXLx4kV69eskqg+mcTAYkKQ1p0aI58XfPYoqNeOU+0Vf+JJOjIzVq1EjFyFJGiRIlmDt3LoGBgaxZs4ZatWphMpnYvn07TZo0oXjx4syePZuQkBBrh5rh/frrr5QrV45t27ah1WqZNWsWhw8ftuoMFsly5JgBSUpDQkNDyZe/ANrCVcn6yShU6qT30PVBdwjZOIFB/fqwcOFCK0WZsi5fvoyXlxerV68mMjISSOxNaN++PQMHDqROnTryW2gqio2NZdy4cSxZsgSAUqVKsXbtWipVqmTlyCRLksmAJKUxW7Zsoctnn2GbuziZKrfGNm8pzAkxxFz9k9jzeylXuhSH/zyEk5OTtUNNUTExMWzcuBFPT0/OnDmjPF+qVCkGDBhAz549yZw5sxUj/PCdPXuW7t274+/vD8CXX37J999/n25vUUmvJpMBSUqDDh48yKTJU/A7fkx5LpOTE32/+ILp06d/8InAf509exYvLy/WrVtHbGwsAHZ2dnTp0oUBAwZQrVo12VtgQUajke+//56pU6diNBrJnTs3q1atokmTJtYOTUohMhmQpDTM39+fO3fuYGtrS7Vq1XB0dLR2SFYVERHBunXr8PT05NKlS8rzH330EQMHDqRbt24ZLlGytDt37tCjRw+OHz8OQIcOHfD09CRr1qxWjkxKSTIZkCQp3RFCcOLECTw9Pdm0aRMJCQkAODo60rVrVwYOHEjFihWtHGX6IoRg5cqVDB8+nOjoaJydnVm8eDHdu3eXvS4ZgEwGJElK18LCwli9ejWenp5cv35deb5q1aoMHDiQzp07y2Vx3yAkJIT+/fuzc+dOAOrWrcvq1atxc3OzbmBSqpHJgCRJHwQhBIcPH8bT05Pt27djMBgAcHFxoWfPngwYMIAyZcpYOcq0Z9++fXzxxRcEBQWh0+mYMWMGo0ePlqtBZjAyGZAk6YMTHBzMypUr8fLy4u7du8rzderUYcCAAbRv3x47OzsrRmh9MTExjBkzBk9PTwDKlCnD2rVrqVChgnUDk6xCJgOSJH2wzGYzBw4cUMoqm0wmALJmzaqUVS5WrJiVo0x9p06donv37ty8eROAESNG8O2332b4BCkjk8mAJEkZQmBgoFJW+eHDh8rzjRo1YuDAgbRu3fqDL6tsNBqZNWsW06ZNw2QykTdvXry9vWnUqJG1Q5OsTCYDkiRlKEajkf379+Pp6cn+/fuTlFXu06cP/fr1+yAHzt28eZMePXpw8uRJALp06cLSpUvlwk0SIJMBSZIysHv37illlYOCggBQqVRKWeUWLVqk+4F0QgiWLVvGyJEjiY2NxcXFhaVLl9K1a1drhyalITIZkCQpw9Pr9ezevRtPT098fHyU5/Pnz0/fvn3p06cPefPmtWKE7yY4OJi+ffuyZ88eABo0aMCqVasoUKCAlSOT0hqZDEiSJP3LjRs3+Omnn1i1ahVPnz4FQKPR0KpVKwYOHEjjxo1Rq9N+wdc9e/bQp08fQkJCsLGxYdasWYwcOTJdxC6lPpkMSJIkvUR8fDzbtm3D09OTo0ePKs8XLlyY/v3707t3b3LkyGHFCF8uOjqaUaNGsWzZMgDKlSvH2rVrKV++vJUjk9IymQxIkiS9wZUrV5SyyhEREQDodDqlrHLdunXTxJK9J06coEePHty6dQuVSsXo0aOZPn26nDIovZFMBiRJkpIpJiaGTZs24enpyenTp5XnS5YsqZRVzpIlS6rHZTAYmDFjBjNnzsRkMpE/f35Wr15N/fr1Uz0WKX2SyYAkSdI7OHfunFJWOSYmBkgsq9ypUycGDhxI9erVU6W34MaNG3Tv3l1JTrp168bixYtxdXVN8WNLHw6ZDEiSJL2HyMhIpazyxYsXlefLly+vlFV2dna2+HGFEHh5eTFq1Cji4uJwdXXF09OTzp07W/xY0odPJgOSJEkWIITg5MmTSlnl+Ph4ADJlyqSUVa5UqZJFjvXkyRP69OnDvn37gMRVFFetWkW+fPks0r6U8chkQJIkycLCwsJYs2YNnp6e+Pv7K8+7u7szYMAAunTpQqZMmV762uDgYLy9vbl+/To2NjY0bNgwyVLJO3fupF+/foSGhmJra8v333/Pl19+KacMSu9FJgOSJEkpRAjBkSNH8PT0ZNu2bUpZZWdnZ6WsctmyZYHEokpTpkzh++9nI1RqbHMURBjiiQu+T67cefh52U9s376dFStWAFChQgXWrl0ryzJLFiGTAUmSpFQQHBzMqlWr8PLy4s6dO8rztWvXZsCAAZw7d475CxbgUrMLTpVbobF3AkAffJdnh34m/v4lhDCjUqkYN24c33zzDba2ttY6HekDI5MBSZKkVGQ2m/njjz/w8vJi165dSlllANd6vXCp3uGF1wijgcdrR6OOeMzvv/1K3bp1UzNkKQOQN5kkSZJSkVqtpkmTJmzbto0HDx4wbdo0nJycUOnscKrc8qWvUWl1uNToTEJ8nKwyKKUImQxIkiRZSZ48eZg8eTK1atXGzq08at2rVwq0L1QZIMn0RUmyFJkMSJIkWZlOpwWz6fU7mY0A6b6kspQ2yWRAkiTJymrUqIE+4DKmuKhX7hNz/TgqlYpq1aqlYmRSRiGTAUmSJCvr06cPagQRR9fxsjHdprgoYk5vo2mzZhQqVMgKEUofOpkMSJIkWVmOHDlYsGA+Uef28nTvHPTBdwEQJiMx148RumE8DiKehT/8YOVIpQ+VnFooSZKURnh7ezN+wkSCnjxGZ++E2ajHZEigRs1arFyxnBIlSlg7ROkDJZMBSZKkNMRgMLBv3z5lOeIGDRrw0UcfWTss6QMnkwFJkiRJyuDkmAFJkiRJyuBkMiBJkiRJGZxMBiRJkiQpg5PJgCRJkiRlcDIZkCRJkqQMTiYDkiRJkpTByWRAkiRJkjI4mQxIkiRJUgYnkwFJkiRJyuBkMiBJkiRJGZxMBiRJkiQpg5PJgCRJkiRlcDIZkCRJkqQMTiYDkiRJkpTByWRAkiRJkjI4mQxIkiRJUgYnkwFJkiRJyuBkMiBJkiRJGZxMBiRJkiQpg5PJgCRJkiRlcDIZkCRJkqQMTiYDkiRJkpTByWRAkiRJkjI4mQxIkiRJUgYnkwFJkiRJyuBkMiBJkiRJGZxMBiRJkiQpg5PJgCRJkiRlcDIZkCRJkqQMTiYDkiRJkpTByWRAkiRJkjI4mQxIkiRJUgYnkwFJkiRJyuBkMiBJkiRJGZxMBiRJkiQpg/s/cwGC83aBULUAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -233,9 +233,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "venv_xgi", "language": "python", - "name": "python3" + "name": "venv_xgi" }, "language_info": { "codemirror_mode": { @@ -249,6 +249,19 @@ "pygments_lexer": "ipython3", "version": "3.9.13" }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, "vscode": { "interpreter": { "hash": "78db47bee367e3fae825d59af43d695909ce208402094df58551906768c6e91c" diff --git a/tutorials/XGI in 1 minute.ipynb b/tutorials/XGI in 1 minute.ipynb index 55157e1bc..b0b946b15 100644 --- a/tutorials/XGI in 1 minute.ipynb +++ b/tutorials/XGI in 1 minute.ipynb @@ -1,7 +1,6 @@ { "cells": [ { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -22,7 +21,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -44,7 +42,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -64,7 +61,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -82,7 +78,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -99,7 +94,10 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 5, @@ -108,7 +106,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA/jklEQVR4nO3de3Rc9Xk3+q80Gsszkmx84WIbbAz2YGkrRCIaZeQJEQZBAiZgQORN0yT4TWLkRnLTk/a0zZv08iZN27w5zekqildUrfZIwFq0KMimUWgbCWKBxzPSABIwo7HH10gGdBld5yrt2bPPH7IEjm+67Jm9Z/b3s1b+aKP56TEx9le/y/NkybIsg4iIiHQrW+0CiIiISF0MA0RERDrHMEBERKRzDANEREQ6xzBARESkcwwDREREOscwQEREpHMMA0RERDrHMEBERKRzDANEREQ6xzBARESkcwwDREREOscwQEREpHMMA0RERDrHMEBERKRzDANEREQ6xzBARESkcwwDREREOscwQEREpHMMA0RERDrHMEBERKRzDANEREQ6xzBARESkcwwDREREOscwQEREpHMMA0RERDrHMEBERKRzDANEREQ6xzBARESkczlqF0BE+iTLMnp6euB2u+H1ehGNRmEymSAIAqxWK0pLS5GVlaV2mUS6kCXLsqx2EUSkH6IoorGxEfX19fD5fDAYDLBYLCgoKEAwGITf74ckSSgsLERdXR327dsHo9GodtlEGY3HBESUMh6PBzabDQcOHIAgCGhvb0cwGERfXx+6urrQ19eHYDCI9vZ2CIKAAwcOwGazwePxqF06UUbjzgARpURnZyd2796NLVu2oLm5GWVlZdf8jNvtxt69e9Hf34+2tjZUVlamoFIi/WEYIKKkm9sRqKiowOHDh5GXl7fgz4bDYezZswculwtOpxPFxcVJrJRInxgGiCipRFGEzWZDLBZDd3f3ooLAnHA4jPLycphMJjidTt4hIFIY7wwQUVI1Njait7cXzc3NSwoCAJCXl4empib09PSgsbFR4QqJiDsDRJQ0sixDEAQIgoCWlpZlr1ddXQ2fzwePx8Nnh0QK4s4AESVNT08PfD4fampqFFmvpqYGfX196O3tVWQ9IprFMEBESeN2u2EwGGC32xVZz263w2AwwO12K7IeEc1iGCCipPF6vbBYLDCZTIqsZzabYbFY4PV6FVmPiGYxDBBR0kSjURQUFCi6Zn5+PiKRiKJrEukdwwARJY3JZEIwGFR0zVAoBLPZrOiaRHrHQUVElDSCIODgwYPzQ4iWKxKJwO/349vf/rYC1SUHBzBROmIYIKKksVqtkCQJDocDVVVVy17P4XBAkiRs2L4O70+ewcqcPJiMZuTmmGHINihQ8dJdawDTwYMHOYCJNIt9BogoaZTvM/AE3vW8g1+90XrJT9crDCux0miGKScPK41mGA0rlv39Fsrj8eCpp55Cb28vHn/8cdTU1MBut1+0GxKNRuFwONDQ0IDW1laUlJSgubmZ7ZVJE3hngIiSJisrC3V1dWhtbV32c0C3241Dhw7j97/+Py67zT4jxTAVG8NQaAC/HT+Bs6PHMTjVj4loADExgmT93NPZ2TnfbrmrqwstLS2oqqq65FjEZDKhqqoKLS0tcLlciMViqKioQGdnZ1LqIloM7gwQUVIpN5vAimxjNlr+6znk5Cz+hDML2VhpNGHlhZ2DlQocLXAAE2UKhgEiSjqPx4OKigrYbLYl/aX56J5H4XK58OIrz8JSuF2xuuaOFlbmmGEy5i3qaIEDmCiT8JiAiJKuuLgYbW1tcLlcKC8vX/CRgdvtRnm5FS6XCw3PP6NoEAA+OloYDp1f9NECBzBRJuHOABGljMfjwd69e9HT04PHHnsM+/fvv+SiXSQSuXDR7uc4dOgwij5RiB8/8wPFg8BCfHS0YMZKY9780QIHMFGmYRggopSKxEL4yT/9PZ7/lxdwyn8GBoMB2y3bkZ+fj1AohJP+k5AkCdvvuB2///X/gS9+9QlNbZ+vMKyE33sa99/9INrb2xV5Mtne3o4HHngAb7/9NkpLSxWokmhxGAaIKKUGp/oRmpmELMvoe+843uv14uTxU4hFY1hpWontO7bhEyUCij6xQ7M/Jb/Q3IL//Wd/i2AwqFgzpVWrVuHgwYN4+umnFaiQaHHYdIiIUiYmRhCamQQw++xQuLMQwp2FKle1eCePn8Z2y3YOYKKMwQuERJQygfCg2iUoYjoW4wAmyigMA0SUEuHpKcTiYbXLUETuypUcwEQZhWGAiJJOlmUEIpmxKwAA23fcjpP+k4hGo4qsNzeASRAERdYjWiyGASJKuqnYOERpWu0yFHNniTA/gEkJcwOYrFarIusRLRbDABElVUKWMBYZVrsMRRXdWYhtltvQ0NCgyHoNDQ0oKipCSUmJIusRLRbDABEl1UR0FJIsql2GorKysvCVb3xJwQFMh1BbW6vZp5SU+dhngIiSJp6I47djJyAjoXYpihNFEU9+/quQ4zK6u93Lnk3gcrmWNICJSAncGSCipBmLDGVkEAAAo9GI/1P/Q/y2vx+P7nkU4fDiXkrMTS3s7+9HU1MTgwCpimGAiJJiJj6Nqdi42mUklaVwOxqef+bCACbrIgcwlcPlcqGtrY3ji0l1DANElBSjkUEAmX8K+Wl7GV585VlkG7Nhs9lQXV2Njo6OS54dRiIRtLe3o7q6GjabbX5scWVlpUqVE32EdwaISHFRMYz3J8+oXUZKiaKIF597Cc//y79dMoApHArD7/dDkiQUFRWhtrYW+/bt09QAJtI3hgEiUtzAxGlMx/XZWvd3BzDFZxJYv/oGCIIAq9WKkpISvhogzWEYICJFhaYnMRjsV7sMzchfsRo3rdqsdhlEV8U7A0SkGFmWM2YYkVIScma+pqDMwjBARIqZjI0hnphRuwxNkXVwiZLSH8MAESlCSmRe22El8CSW0gHDABEpYiI6goQcV7sMzeHOAKUDhgEiWra4JGIiGlC7DE2SeWeA0gDDABEt22hkiD8BXwH/uVA6YBggomWZjscQnJ5QuwzN4p0BSgcMA0S0LKNhfbQdXiqGAUoHDANEtGSRmRAiYlDtMjQtU6c2UmZhGCCiJZFl+cKuAF0NdwYoHTAMENGShKYnMS1Fr/2FOscLhJQOGAaIaNEScuLCiGK6Npm7A6R5DANEtGiT0VHEE6LaZaQN7g6Q1jEMENGiSIk4xqMjapeRVth4iLSOYYCIFmU8OoKELKldRlrhzgBpHcMAES2YKM1gIjqqdhlph3cGSOsYBohowcYiQ2CDocVjGCCtYxggogWJxaNsO7xEbDxEWscwQEQLwgZDS8edAdI6hgEiuqbwTBBRMaR2GWmLFwhJ6xgGiOiq2HZ4+fi0kLSOYYCIrio4PYEZKaZ2GWmNOwOkdQwDRHRFs22Hh9QuI+3xzgBpHcMAEV3RZHQUEtsOLxvDAGkdwwARXZaUiGMsOqx2GRmBxwSkdQwDRHRZY5FhXnxTCP85ktYxDBDRJURpGpOxMbXLyBjcGSCtYxggokuMhtl2WEm8M0BaxzBARBeJiRGEZibVLiOjsB0xaR3DABFdJMAGQ4pLcGeANI5hgIjmhaenEIuH1S4j4/CYgLSOYYCIAMz+hRWIcFcgGXhMQFrHMEBEAICp2DhEaVrtMjISdwZI6xgGiAgJWcIY2w4nDZ8WktYxDBARJqIBSHJc7TIyFpsOkdYxDBDpXDwhYjwSULuMjMZjAtI6hgEinRuLDPOCW5LxmIC0jmGASMdm4tOYio2rXUbG484AaR3DAJGOjUYGwbbDycedAdI6hgEinYqKYYRnptQuQxd4gZC0jmGASKfYdjh1uDNAWscwQKRDoelJTMcjapehG7wzQFrHMECkM7Isc1cgxRgGSOsYBoh0ZjI2inhiRu0ydIVPN0nrGAaIdERKSBiLjKhdhu5wZ4C0jmGASEcmoiNIsO1wyvECIWkdwwCRTsQlERNRth1Wh8zdAdI0hgEinRiNDPEnVBXxnz1pGcMAkQ5Mx2MITrPtsJrYeIi0jGGASAdG+ZRQddwZIC1jGCDKcJGZECJiUO0ydI93BkjLGAaIMpgsy9wV0AiGAdIyhgGiDBaansS0FFW7DAIbD5G2MQwQZaiEnLgwopi0gDsDpGUMA0QZajI6inhCVLsMuoAXCEnLGAaIMpCUiGM8yrbDWsKnhaRlOWoXQESLI8syenp64Ha74fV6EY1GYTKZIAgCrFYrSktLMR4dQUKW1C6VPobHBKRlWTJ/hxKlBVEU0djYiPr6evh8PhgMBlgsFhQUFCAYDMLv90OSJOwo3IEv7X0CX/zq4zAajWqXTRfcVLAZ+bmr1S6D6LJ4TECUBjweD2w2Gw4cOABBENDe3o5gMIi+vj50dXWhr68PwWAQ7e3tKBaK8YPv/h2e/PxX4fedVLt0uiDBYwLSMO4MEGlcZ2cndu/ejS1btqC5uRllZWXX/Izb7cbevU/ht/39aHj+GXzafu3PUHJdn78Jq1euVbsMostiGCDSsLkdgYqKChw+fBh5eXkL/mw4HMajex6Fy+XCi688C0vh9iRWStdyfd5GrDatU7sMostiGCDSKFEUYbPZEIvF0N3dvaggMCccDqO83IpsYzZe/M9neYdARevzNuA603q1yyC6LN4ZINKoxsZG9Pb2orm5eUlBAADy8vLQ1NSMvvd8ePG5lxSukBaDP3eRlnFngEiDZFmGIAgQBAEtLS3LXq+6+gm863kHv3qjFVlZWQpUSIu11nwD1ppvVLsMosvizgCRBvX09MDn86GmpkaR9Wpq9uPkidPoe++4IuvR4iX4cxdpGMMAkQa53W4YDAbY7XZF1rPb7TAYDHiv16vIerR43IQlLWMYINIgr9cLi8UCk8mkyHpmsxnbLdtx8vgpRdajxePUQtIyhgEiDYpGoygoKFB0zfz8fMSiMUXXpIXjzgBpGcMAkQaZTCYEg0FF1wyFQlhpWqnomrRwnFpIWsYwQKRBgiDA7/cjGo0qsl4kEsFJ/0lYdrDxkFo4tZC0jGGASIOsViskSYLD4VBkPYfDAUmS8OA9j+Dm67ZhnfkmmI0FyMriHwGpwmMC0jL2GSDSIOX7DFTD5/PB4/Fc1GdAlmVMx6OIimFExBBiYoQX3ZLEZMzHptVb1S6D6LL4YwGRBmVlZaGurg6tra1wu93LWsvtduPQoUOora29pOFQVlYWVhrNWGO+HptWb8XWdYXYtPo2rDXfCJMxDwAbFCmFP3eRlnFngEij5mYTRKNRuN3uZcwmKIfJZILL5UJOTs6iPp+QE4iJEUTFEKJiGLF4FOBFuCXJzTHjlutuV7sMosvizgCRRhmNRtTV1cHv9+MLX/gCwuHwoj4fDoexZ88e9Pf3o6mpadFBAACys7JhXpGPdXk34ebrbsdt6wqxYdWtuM50PXJzTODOwcLxAiFpGXcGiDTK5/Nh586dmJiYwIoVK7Bt2zY0NTXBarVe87Nutxt79+5Ff38/2traUFlZmZQapYSEmBhGRAwjKoYwI7GPwZUYDbnYssaidhlEl8WdASINGhwcxIMPPoiJiQlUVFTA4XDAZDLBZrOhuroaHR0dlzw7jEQiaG9vR3V1NWw2G0wmE5xOZ9KCAAAYsg3Iy12F6/M3YPOa7di6thA3FWzGqpVrYTTkJu37piP+3EVaxp0BIo0Jh8O455578Oabb2Lbtm1wOp1Yv349RFFEY2Mj6uvr4fP5YDAYYLFYkJ+fj1AoBL/fD0mSUFRUhNraWuzbtw9Go1HVX0s8ISI6E55/rRBPzKhaj5oMWUZsXbdD7TKILothgEhDJEnCY489hl/+8pdYt24dnE4ntm+/uFGQLMvo7e2F2+2G1+tFJBKB2WyGIAiwWq0oKSnR7JhiUZpBVAxf+E8I8YSodkkpk51lwG3ritQug+iyGAaINEKWZfzhH/4h6uvrkZubi9deew07d+5Uu6ykEqXpC/cNwojOhCHJmRsOspCN29cLapdBdFmLv15MREnxj//4j6ivrwcAPPfccxkfBIDZS3WrDblYvXItAGAmPj3/jDEihpGQ4ypXqBzOJiAtYxgg0oCXXnoJf/zHfwwA+MlPfoInn3xS5YrUsSInFytycrHatA6yLGNGmg0HETGMmBhGQpbULnEZZMiyrNkjHNI3HhMQqczlcmHXrl2IxWL41re+hfr6ev6FcRkfb5089590a5182zoB2ZwHQRrEMECkotOnT8NmsyEQCGD37t04fPjwkpoD6ZEsy4jFI/PBICaGNbcVL8sy+t714d1eL04eP40V8kqYzXnzlz1LS0sZ/EgTGAaIVDI6OoqKigqcPHkSd911Fzo7O5Gfn692WWkrIScu7ByEEJkJIxaPQK3WyaIo4sXnXsLz//JvOOU/A4PBgO2W7VhVsArBYHD+GWhhYSHq6uo08QyU9I1hgEgFsVgM999/P44ePYrNmzfD5XJhw4YNapeVUWbnKoTnXytMp2iugt93En9a9xfweY7j8ccfR01NDex2O0wm0/zXRKNROBwONDQ0oLW1FSUlJWhubkZxcXHS6yO6HIYBohRLJBL48pe/jH//93/H6tWr4XA4IAh8cpZsUkJCLP7RM8ZpKXrtDy1Sl+NNPP37dbh1yxY0Nz+LsrKya34mVa2jia6GYYAoxf78z/8cP/7xj2E0GvFf//VfuPfee9UuSZekRBzRj01kXO5cBb/vJJ588KuoqKjAy4dfXtSUybmhUi6XC06nkzsElHIMA0Qp1NDQgP379wMAmpub8bWvfU3limhOPBG/cKwwGw5EaXrBnxVFEU9+/quQ4zK6u5c/btrpdPIOAaUU37gQpch//ud/ora2FgDw13/91wwCGpOTnYP83NW4IX8Ttqyx4Na1O3Bj/i0oyF2DnOwVV/3si8+9BJ/nOJqbn11SEACAvLw8NDU1oaenB42NjUtag2ipuDNAlAI9PT24++67EQ6HsXfvXvzrv/4rn5SlmY/mKsw2QZIuzFWQZRkPfeYxlNx5F1paWpb9faqrq+Hz+eDxePh7hFKGOwNESdbf34/du3cjHA7jvvvuQ0NDA/+QT0NGwwqsWrkGNxbcgq1rd2DzGguuz9uEs74BnPKfQU1NjSLfp6amBn19fejt7VVkPaKFYBggSqLJyUns3r0bH374IQRBwEsvvYQVK66+5UzpYYUhF6tNa3HWdx4GgwF2u12Rde12OwwGA9xutyLrES0EwwBRkoiiiOrqang8HmzYsAGvvPIKVq9erXZZpDCv1wuLxXJRH4HlMJvNsFgs8Hq9iqxHtBAMA0RJIMsynn76aXR0dCAvLw+/+tWvsHnzZrXLoiSIRqMoKChQdM38/HxEIhFF1yS6GoYBoiT4m7/5GzQ1NSE7OxsvvvgiSktL1S6JksRkMiEYDCq6ZigUgtlsVnRNoqthGCBS2HPPPYe//Mu/BAD87Gc/w0MPPaRyRZRMgiDA7/cjGlWmo2EkEoHf72dXSkophgEiBb322mv4xje+AQD40z/90/kGQ5S5rFYrJEmCw+FQZD2HwwFJkmC1WhVZj2gh2GeASCF9fX3YuXMnJicn8cUvfhEvvPACsrOZtzOdLMsQBAGCILDPAKUt/klFpIDBwUE89NBDmJychN1uR3NzM4OATmRlZaGurg6tra3Lfg7odrtx6NAh1NbWMghQSnFngGiZQqEQ7rnnHrz11lvYvn07nE4n1q1bp3ZZlEKiKMJmsyEWi6G7u3vZswlcLhdycnKSUCnR5fFHF6JlkCQJv/d7v4e33noL69evxyuvvMIgoENGoxHNzc3o7+/Hnj17EA6HF/X5uamF/f39aGpqYhCglGMYIFoiWZbx7W9/G21tbVi5ciX+4z/+A9u2bVO7LFJJcXEx2tra4HK5UF5evuAjA7fbjfLycrhcLrS1tXF8MamCYYBoiX7605/iZz/7GbKysvD888+joqJC7ZJIZZWVlXA6nTCZTLDZbKiurkZHR8clzw4jkQja29tRXV0Nm802P7a4srJSpcpJ73hngGgJfvGLX+DJJ58EAPzDP/wDvvOd76hcEWmJKIpobGxEfX09fD4fDAYDLBYL8vPzEQqFcOLECSQSCWzfvh1/9Ed/hH379sFoNKpdNukYwwDRIjmdTtx7772IxWKoq6vDP/3TP/HmN12WLMvo7e2F2+2G1+tFJBKB2WxGW1sbzpw5g8bGRnzzm99Uu0wihgGixTh16hQqKioQCATwhS98AYcOHYLBYFC7LEozf/VXf4Uf/OAH+NKXvoQXXnhB7XKIeGeAaKECgQAefPBBBAIBlJWV4YUXXmAQoCW57777AACvvvoqEomEytUQcWeAaEFisRiqqqrgcDiwZcsWuFwu3HTTTWqXRWlqZmYGa9asQSQSwTvvvIM777xT7ZJI57gzQHQNiUQCX/va1+BwOLB69Wq88sorDAK0LCtWrJh/OdDR0aFyNUQMA0TX9N3vfhctLS0wGo04dOgQioqK1C6JMsDHjwqI1MZjAtIdWZbR09Mzf8M7Go3CZDJBEARYrVaUlpbOvw74+c9/jj/4gz8AMDua+Ctf+YqapVMGeeedd1BSUoK8vDyMjY1hxYoVapdEOsYwQLpxpbffBQUFCAaD8Pv9kCQJhYWFqKurw6ZNm/D4448jkUjgBz/4Af7iL/5C7V8CZZBEIoGbbroJIyMjeP3113H33XerXRLpGI8JSBc8Hg9sNhsOHDgAQRDQ3t6OYDCIvr4+dHV1oa+vD8FgEO3t7RAEAQcOHMCTTz6JRCKBr3/96/j+97+v9i+BMkx2djbuvfdeADwqIPUxDFDG6+zsnJ8o19XVhZaWFlRVVcFkMl30dSaTCVVVVWhpaYHL5cLWrVthNBrx5S9/mU2FKCmqqqoA8BIhqY/HBJTR5nYEKioqcPjw4UWNlp2bJOdyueB0OjlAhhR37tw5bN26FTk5ORgbG0NBQYHaJZFOMQxQxlJ6xrzT6WT/eFLc7bffjjNnzqCtrQ27d+9WuxzSKR4TUMZqbGxEb28vmpublxQEACAvLw9NTU3o6elBY2OjwhUS8aiAtIE7A5SRZFmGIAgQBAEtLS3LXq+6uho+nw8ej4f3B0hRLS0t+OIXv4ji4mK89957apdDOsWdAcpIPT098Pl8qKmpUWS9mpoa9PX1obe3V5H1iObs2rULwOz9lsHBQZWrIb1iGKCM5Ha7YTAYYLfbFVnPbrfDYDDA7XYrsh7RnPXr16O0tBQA8Nprr6lcDekVwwBlJK/XC4vFcsnzwaUym82wWCzwer2KrEf0cbw3QGpjGKCMFI1GFX+mlZ+fj0gkouiaRMBHcwo6OjrAa1ykBoYBykgmkwnBYFDRNUOhEMxms6JrEgHAZz7zGaxYsQIDAwM4deqU2uWQDjEMUEYSBAF+vx/RaFSR9SKRCPx+PwRBUGQ9oo/Ly8vDzp07AfCogNTBMEAZyWq1QpIkOBwORdZzOByQJAlWq1WR9Yh+19y9Ac4pIDWwzwBlJPYZoHTjcrlQUVGBNWvWYGRkBAaDQe2SSEe4M0AZKSsrC3V1dWhtbV32c0C3241Dhw6htraWQYCSpqysDKtWrcL4+Dh6enrULod0hmGAMta+fftQUlKCvXv3IhwOL2mNcDiMvXv3orS0FE8//bTCFRJ9JCcnZ74BEY8KKNUYBihjGY1GNDc3o7+/H48++uiiA8Hc1ML+/n40NTUhJycnSZUSzfr4E0OiVGIYoIxWXFyMn/6//4xjx5ywWq0LPjJwu90oLy+Hy+VCW1sbxxdTSsxdIjx69ChisZjK1ZCeMAxQRjvh/wDXrbkVP/xRA2ZmZNhsNjzxxBPo6Oi45NlhJBJBe3s7qqurYbPZ5scWV1ZWqlQ96c2OHTuwceNGxGIxHDt2TO1ySEf4moAy1sD5Ubi6/PP/dzwex6sdL+PX/92KgYGzMBgM2LZtO/Lz8xEKhXDq1ElIkoSioiLU1tZi3759MBqNKv4KSI++9rWv4bnnnsN3v/td/O3f/q3a5ZBOMAxQRgoEptD5Rh8SiUt/e8uyjHNn/Th92oeBgbOYno4hN3clbrllK37/y4/i7rsr+GqAVPPss8/iqaeegtVqRXd3t9rlkE4wDFDGmQpG8ZsjHszMxBf92Ts/sQV3WDYmoSqihXn//fdx8803Izs7G4FAAGvWrFG7JNIB3hmgjBKLiTjq8C0pCADA0PCkwhURLc6mTZuwY8cOJBIJHDlyRO1ySCcYBihjxOMSHM7jCIenl7xGIDAFSUooWBXR4nGkMaUawwBlBFmW0e0+hbGx0LLWkaQERseUnXZItFicU0CpxjBAGeGdd8/h/Q/GFFlraIhHBaSuyspKZGdn48SJExgYGFC7HNIBhgFKe/6TH+LkqUHF1hvmvQFS2XXXXTc/IZO7A5QKDAOU1s6/P4p33j2n6Jpj4yFMT4uKrkm0WDwqoFRiGKC0FRgNott9KilrD49MJWVdooX6+JwCvgCnZGMYoLQUDEZxzHkiaTf/eVRAaquoqIDJZMLg4CD6+vrULocyHMMApZ3paRFHjx1P6lb+0PBE0tYmWoiVK1fi7rvvBsCjAko+hgFKK7O9BE4gFEruRLdweDrp34PoWjjSmFKFYYDShizL6H7zFEZHU9MHgEcFpLa5S4RHjhxBPL60rppEC8EwQGnj3ff68f77yvQSWIihEYYBUldJSQnWrl2LYDAIt9utdjmUwRgGKC2cPPUh/Cc/SOn3HB6e5C1uUlV2djbuvfdeADwqoORiGCDNe/+DMfS+cy7l33dmJo7xiXDKvy/Rx3FOAaUCwwBp2uhYEN3dJ1X7/rw3QGqbCwNOpxPhMMMpJQfDAGlWKBSD49gJxFWcIsg5BaS22267DVu2bIEoinjjjTfULocyFMMAadL0tIijDp/qbYEDo1OIxyVVayB9y8rK4lEBJR3DAGmOJCVwzHUCQQ28808kZARS9JSR6Eo4p4CSjWGANGWul0AgoJ2/gHlUQGqbe1HQ29uLkZERlauhTMQwQJrynqcf58+Pql3GRYbZb4BUdsMNN+DOO+8EALz22msqV0OZKEftAojmnD4ziBP+1PYSWIiJiTBiMRErVxrVLoV07L777sO7776L+vp6OBwORKNRmEwmCIIAq9WK0tJSZGVlqV0mpSmGAdKEDz8cR0/vObXLuKLh4Uls3rxe7TJIh0RRRGNjI1566SUAwLFjxzA6OoqCggIEg0EcPHgQkiShsLAQdXV12LdvH4xGBldaHB4TkOrGxkNwdfk13e2PrYlJDR6PBzabDQcOHEB5eTna29sRCoXQ19eHrq4u9PX1IRgMor29HYIg4MCBA7DZbPB4PGqXTmmGYYBUFQ7H4HAcV7WXwEKw+RClWmdnJ2w2G2KxGLq6utDS0oKqqiqYTKaLvs5kMqGqqgotLS1wuVyIxWKoqKhAZ2enSpVTOsqStfzjGGW0mZk4XjviQTAYVbuUBfncAyVYVWC69hcSLdPcjkBFRQUOHz6MvLy8BX82HA5jz549cLlccDqdKC4uTmKllCkYBkgVkpTAG0d9GAlMqV3KgpWWbMW2229SuwzKcKIozu8IdHd3LyoIzAmHwygvL4fJZILT6eQdAromHhNQysmyjDffOp1WQQDgUQGlRmNjI3p7e9Hc3LykIAAAeXl5aGpqQk9PDxobGxWukDIRdwYo5d7z9OP4iffVLmPRjEYDHnm4DNnZzNCUHLIsQxAECIKAlpaWZa9XXV0Nn88Hj8fDZ4d0VfxTjVLqzJmhtAwCACCKEsbGOTWOkqenpwc+nw81NTWKrFdTU4O+vj709vYqsh5lLoYBSpnBwXG83XtW7TKWhUcFlExutxsGgwF2u12R9ex2OwwGA9xutyLrUeZiGKCUGB8PwenSdi+BhRganlC7BMpgXq8XFovlkueDS2U2m2GxWOD1ehVZjzIXwwAlXSQyjaPHTmi+l8BCjI2FIIocaUzJEY1GUVBQoOia+fn5iEQiiq5JmYdhgJJKFON4w3EcsdiM2qUoIpGQEUizVxCUPkwmE4JBZSd2hkIhmM1mRdekzMMwQEmTSCRwzOnH1FRm/VQyxHsDlCSCIMDv9yMaVaYRVyQSgd/vhyAIiqxHmYthgJLmzbfOZOT4X4YBShar1QpJkuBwOBRZz+FwQJIkWK1WRdajzMUwQEnh7RvAb/tH1C4jKaamIohGM+PYg7SltLQUhYWFaGhoUGS9hoYGFBUVoaSkRJH1KHMxDJDizp4bRp/vvNplJFUm7niQ+rKyslBXV4fW1tZlPwd0u904dOgQamtr2XCIrokdCElRg0MTOOo4nvZPCK9ly+brUW7dpnYZlIGUnk3gcrmQk5OThEopk3BngBQzMRHOiF4CC8F7A5QsRqMRzc3N6O/vx549exAOL67r5dzUwv7+fjQ1NTEI0IIwDJAiItFpHD12HPG4Pt7gx2IzmMywVxKkHcXFxfj3F1+Cw3EMVqt1wUcGbrcb5eXlcLlcaGtr4/hiWjCGAVo2UYzjqOO47i7VsTUxJcv0tIis7Ovxwx81YGZGhs1mwxNPPIGOjo5Lnh1GIhG0t7ejuroaNpttfmxxZWWlStVTOuKdAVqWRCKBo8dOYGhoQu1SUm7DTWvwGfsOtcugDCNJCXS+0YfR0dnmQ/F4HK92vIxf/3crBgbOwmAwYNu27cjPz0coFMKpUychSRKKiopQW1uLffv2wWg0qvyroHTDMEDL4n7rNM6dG1a7DFXkGLLx6CNWjjQmxciyjK7ukxg4P3rZ/+7cWT9On/ZhYOAspqdjyM1diVtu2Yr7778HTzz+eb4aoCXjzRJasj7fed0GAQCISwmMjYWwfv0qtUuhDOHtG7hsEABmnx1uve0ObL3tjkv+uzVr8xkEaFn4Iw0tybnfjsDbN6B2GarjqwJSytlzw/Adf39Jnx0fD2NmJq5wRaQnDAO0aEPDk3jr7dNql6EJDAOkhOGRSbzdc2bJn5dlmb8XaVkYBmhRJicjcLpOIJHgVRNgbqQxfyKjpZsKRnHMufx/pwZ1eImXlMMwQAsWjc7g6LHjEEV99BJYCFmWMTzCkca0NLGYiKMOnyL/TunxRQ8ph2GAFkQUJRw9dhyRyLTapWgO+w3QUsTjEhzO4wiHlfl3KhplIyxaOoYBuqZEIgFnlx8TE4tri6oXPKulxZJlGe63TmNsLKTouoODE4quR/rBMEDX9HbPWW5BXkUwGOWOCS2KxzuA81d4QrgcDKa0VAwDdFW+4+dxVse9BBaKfwjTQp05O4TjJ5b2hPBaAoEp3cwHIWUxDNAV9fcH4PGyl8BC8N4ALcTg0ATe7jmbtPUlKYFAgBdaafEYBuiyhkcm4X7rlNplpI2h4UldjG6mpZt9lpv8Ed98YkhLwTBAl5iciijy7llPpqdFTE7yJjdd3tyz3FRs4Q8OcZeKFo9hgC4Sjc7gqIO9BJaC9wbocuJxCcecJ1J2yZQXWmkpGAZonihKcLCXwJIxDNDvkmUZ3e5TGBtX9gnhtfCogBaLYYAAzPYS6Oo+iXH2Eliy0cAUJCmhdhmkIe++14/3PxhL+fdlGKDFYhggAEDvO+fw4eC42mWktbiUwOhYUO0ySCNOnxmE/+QHqnzv4eFJJBIMprRwDAOEE/4PcPrMkNplZIQhXt4iAB9+OI6e3nOqfX9RlBTvbkiZjWFA5wYGAnj3vd+qXUbGYL8BmpgIw9V9UvWnprzDQovBMKBjgcAUut9kLwEljY2HMDPDkcZ6FYlOp+wJ4bXw3gAtBsOATk0Fo3Cwl0BSDI/wJzI9mn2NcwLR6IzapQAAxsZCmJ4W1S6D0kSO2gXQ8smyjJ6eHrjdbni9XkSjUZhMJgiCAKvVitLSUmRlZc1//dwMdf4EmxxDQ5O4edM6tcugFJJlGV3dJzU32XN4eBK33LJe7TIoDTAMpDFRFNHY2Ij6+nr4fD4YDAZYLBYUFBQgGAzi4MGDkCQJhYWFqKurw759+5CVlQ3HMeVmqNOluDOgP++8q83XOINDEwwDtCA8JkhTHo8HNpsNBw4cgCAIaG9vRzAYRF9fH7q6utDX14dgMIj29nYIgoADBw7AZrPhhX/7VcoboOhNKBRDKBRTuwxKkZOnPsTJU4Nql3FZbE1MC8UwkIY6Ozths9kQi8XQ1dWFlpYWVFVVwWQyXfR1JpMJVVVVaGlpgcvlQjQaQ83Tv4c+b49KlesHXxXowwcfjKH3nXNql3FFsdgMZ2bQgjAMpBmPx4Pdu3ejoqIC3d3dKCsrW9DnrFYr3O5u7NxZgR///f+N/v7TSa5U34Z4VJDxxsdD6Oo+qXYZ18RXBbQQWbLaj2FpwURRnN8R6O7uRl5e3qLXCIfDsFqtmJmR8cMf/TNycnhtJBlWrMjBIw+XXXRxkzJHJDKNV3/jQSymjZcDV3PjDavx2buL1C6DNI47A2mksbERvb29aG5uXlIQAIC8vDw0Nzfj7Fk/Xu14WeEKac7MTFxzN8tJGaIYx9Fjx9MiCADASGBKE30PSNsYBtKELMuor6/H448/vuCjgSuxWq3Ys2cPfv3rVtW7pGUydoDLPIlEAq7uk2l1Dp9IyBgZmVK7DNI4hoE00dPTA5/Ph5qaGkXW279/Pwb6z+LcWb8i69GleIkw8/T0nsPg4ITaZSza0PCE2iWQxjEMpAm32w2DwQC73a7Iena7HQaDAadP+xRZjy4VGA1yezaDnPB/gDNn03OgVzoGGEothoE04fV6YbFYLnk+uFRmsxnbtm3HwMBZRdajS0lSAoFRjjTOBOffH03rgV7BUAzhMHtf0JUxDKSJaDSKgoICRdfMz8/H9DT/gEgmHhWkv9GxINzu9B/oxfHadDUMA2nCZDIhGFT2p8xQKITc3JWKrkkX4yXC9BYOx3Ds2AnEpYTapSwb+w3Q1TAMpAlBEOD3+xGNRhVZLxKJ4NSpk9h623ZF1qPLm5gIc3Jcmpp9QngCsQz5329oeBKJRPqHGkoOhoE0YbVaIUkSHA6HIus5HA5IkoRvfr0an3ugBCWfvBUbN6yB0WhQZH36CI8K0k8ikYDT5cfUVPo8IbyWeFzC2BjnktDlsQNhmpBlGYIgQBAEtLS0LHu96upq+Hw+eDyei7rkJRIJjE+EMTQ0iZGRKQRGp5BI8LfIcmy99QaUfep2tcugRXjzrdM4e25Y7TIUV7hjE4qFzWqXQRrEXrRpIisrC3V1dThw4ADcbjesVuuS13K73Th06BCeeeaZS9rlZmdnY93aAqxbWwAUzv40ERgNYnh4EsPDkxhnV71F472B9HL8xPsZGQSA2UuExYLaVZAWcWcgjSg1m6C8vBwmkwkul2vRswmmp0UMj0zNhoORSY7qXaDPP1CCggJlnoVS8gycH4WrK7MbcT3ycBlyc41ql0Eaw52BNGI0GtHc3IyKigrs2bMHhw8fXlQgCIfD2LNnD/r7++F0Opc0pCg314hbbl6HW25ed2HNGIYu7BoMj0zxstwVDI9MMgxoXGA0CPeb6f+E8FqGhiaxefN6tcsgjeHOQBrq7OzEww8/jM2bN6OpqWlBRwZutxt79+5Ff38/2traUFlZqXhdsixjcjIyGw5GJhEYmcqIJ1lK2LRxLXZW3KF2GXQFoVAMrx3x6CLM3rrleljLtqldBmkMXxOkocrKSjidTphMJthsNlRXV6Ojo+OSZ4eRSATt7e2orq6GzWaDyWSC0+lMShAAZu81XHddHu6wbMTd9kI8+ogV93xWQFHhzVi3rkDX43yHR/isS6tmZmanEOohCADAIJsP0WVwZyCNiaKIxsZG1NfXw+fzwWAwwGKxID8/H6FQCH6/H5IkoaioCLW1tdi3bx+MRvXOCkUxjkAgiKHhCQwNT2XUs62FuHdX8ezFTNKMRCKBN44ex/CIvv6CvP++O3HddUsbg06ZiWEgA8iyjN7eXrjdbni9XkQiEZjNZgiCAKvVipKSEk3+VB6NzmBkZOpCOJhENJoe8+GXSii6BUWFN6tdBn2M+81TOPfbEbXLSLlPFG/Gjjs2qV0GaQjDAGlGMBjF8Mjk/IVEUcysiX/Xr1+Feyr5rksr+nzn4e0bULsMVdxw/WpUfrZI7TJIQ/iagDSjoMCEggITbr/tJsiyjPGJ8Hx/g8BoEFKaX0YcHQtCFCV2edSA/v6AboMAAARGp/h7kS7CMECalJWVhbVr8rF2TT523LEJ8biE0bHQfDgYG0+/tqqJhIxAYAobNqxRuxRdCwSm4H4r858QXg1/L9LvYhigtJCTY8CNN6zGjTesBjB7A3x4ZHI+HATTpPnR0PAk/wBWUTAYhcN5gi22MTvFkL8XaQ7DAKWlFStycPOmdbh502zzo0hk+qPmR8OTmp00p7db61oyPS3i6LHjmJmJq12KJnCkMX0cLxBSRpqcjMxeRhyaxEhgCvG4Ni4jyrKMmzca8N57vfB6vYhGozCZTPMvP0pLSzX58iPdSVICrx/tQyAQVLsUTXnwc6XIz1+pdhmkAQwDlPESiQTGxmcvIw4NT2BsLJTybeJ4PI5XO17Gr/+7FQMDZ+d7QhQUFCAYDM73hCgsLERdXZ3qPSEyTVf3SfQPBNQuQ3PuKt2K22+7Se0ySAMYBkh3RFHC6OgUhoanMDwyiYkkT2Ls7z+Ngz/7Ec6d9eOxxx7D/v37YbfbYTJ9NKsgGo3C4XCgoaEBra2tKCkpQXNzM4qLi5Namx54+wbQ5zuvdhmaxDbZNIdhgHQvFhMxcqG/wdDwJCKRacXW7vP24O//7k+wdeutePbZZ1FWVnbNz6RijoRenPvtiC6GDy1VTo4Bj36hDNnZ7EyvdwwDRL8jFIrNHilceK2w1Atn/f2n8f3/9TTs9p14+eWXlzRh0uVywel0codgCYZHJvHGUR9fDlzDPZ8VcP31q9Qug1TGMEB0FbIsY2IijOGRKQwNT2I0sLBJjPF4HN//3tPIXZEFt9u9qCAwJxwOo7y8fH7AFO8QLNxUMIrXfvNexnWxTIYdd2zCJ4o3q10GqYxPC4muIisrC2vW5GPNmnzcYdkISUpgdCx44TLiJMbHw7hcnn6142WcO+tHV1fXkoIAAOTl5aGpqQk2mw2NjY341re+tdxfji5MT4twHDvOILBAQ0MTDAPEnQGi5RDFOIZHpubDQTAYhSzL+JPvfAXl5XfhF7/4xbK/R3V1NXw+HzweD58dXkM8LuH1oz6MjvIJ4WJ8YXcZVq7kzpOe8dYI0TIYjTnYtHEtSku24vMPlGD3Q3fBbIpiYOAs9u/fr8j3qKmpQV9fH3p7exVZL1PJsgz3W6cZBJZgaHhC7RJIZQwDRAoym3Lx/vlTMBgMsNvtiqxpt9thMBjgdrsVWS9TebwDOH9+VO0y0tLQEDtj6h3DAJHCvF4vLBbLRX0ElsNsNsNiscDr9SqyXiY6c3YIx0+8r3YZaWtoaOKyd19IPxgGiBQWjUZRUFCg6Jr5+fmIRCKKrpkphoYn0dN7Vu0y0lpsWkx68y3SNoYBIoWZTCYEg8qeWweDQT4tvIzJqQicLk4hVMLQMI8K9IxhgEhhgiDA7/cjGo0qsl4kEoHf70dDQwPsdju+973voaOjQ/c7BbGYiKMOPiFUyuDghNolkIr4tJBIYW+//TY+9alPob29HVVVVcter729HQ888MAl//8VK1bg05/+NHbt2oV77rkHFRUVWLlSHxPo4nEJnW/0YWwspHYpGSM7OwuPPGyF0WhQuxRSAcMAkcJkWYYgCBAEAS0tLcteb67PwC9/+UscOXIER44cwW9+8xucP3/x8J3c3FxUVFRg165d2LVrF8rLy5Gbm7vs7681sizD2eXH+++PqV1KxrFX3IGNG9eqXQapgGGAKAkOHjyIAwcOwOVywWq1Lnkdt9sNm82GZ5555qIOhLIs4/Tp0/jNb34z/5/BwcGLPmsymbBz5875cFBWVoYVK1YsuRatePe93+KE/wO1y8hIt992I+4qvU3tMkgFDANESSCKImw2G2KxGLq7u5c9m8DlciEn58rdw2VZht/vnw8GR44cwfDw8EVfYzab8ZnPfGY+HHzqU5+66prJJssyenp64Ha74fV6EY1GYTKZIAgCrFYrSktLL+m4eObMEN7qOaNSxZkvP38lHvxcqdplkAoYBoiSxOPxoKKiAjabDYcPH07p1EJZluHz+S4KB6OjFzfkKSgowN1334177rkHu3btQmlpKQyG5J8Xi6KIxsZG1NfXw+fzwWAwwGKxoKCgAMFgEH6/H5IkobCwEHV1ddi3bx+MRiMGB8dx9NgJvodPsgc/V4r8fH3cPaGPMAwQJVFnZycefvhhbN68GU1NTQs6MnC73di7dy/6+/vR1taGysrKZdeRSCTg9Xrnw0FnZyfGx8cv+prVq1fjs5/97Hw4+OQnP6n4nHuPx4OnnnoKvb29ePzxx1FTUwO73X5Rg6ZoNAqHw4GGhga0traipKQE9fU/x+CwjHicLweSrbRkK7bdfpPaZVCKMQwQJZnH48HevXvR09ODxx57DPv377/kL8BIJDL/F+ChQ4dQWlqKpqamRe8ILJQkSXj33XfnLyO+/vrrmJy8+J35mjVrUFlZOf9aobi4eFnhoLOzE7t378aWLVvQ3NyMsrKya35mLhidPXcOf/ZnP0GRwC3sZNu4YQ3sO3eoXQalGMMAUQpcaWs8Pz8foVBofmu8qKgItbW181vjqSJJEnp6euaPFF5//XWEQhc/21u/fv18ONi1axcKCwsXPEXR4/HAZrOhoqJiSUcmjz76KI4dc+KHP2rA5s23L+rXRouTY8jGo49YFd8VIm1jGCBKIVmW0dvbO39pLhKJwGw2z1+aKykp0cSY4ng8jrfeemv+WOHo0aOXNDm64YYb5o8Udu3aBYvFctnalbpMabVaMTMj44c/+mdVLz7qQeVni3DD9avVLoNSiGGAiK5JFEW43e75cOBwOBCLxS76mg0bNlwUDm6//XZkZWXNP7Ps6upa0NHAlcw9s/yfX/+/8LnPP7HcXxJdxY47NuETxZvVLoNSiGGAiBZtenoa3d3d8+HA6XRienr6oq+5+eabUVlZiSNHjqCiokKRBkxPPPEE3G/24P/5h+c1sYOSqa67Lg/333en2mVQCjEMENGyxWIxuFyu+XDgcrkgiuL8f690a+Yf/5//D1tvu2PZ69GVPfzQp2AypX+TKloYhgEiUlwkEsGxY8fw05/+FL/+9a8RDAYvej2xnHVXrVqFb3zzj1F1/57lF0pXZC3bhlu3XK92GZQivC5KRIozm82oqqrCtm3bYLFYFAkCc+tu27YdAwNnFVmPrmxoaELtEiiFGAaIKGmi0SgKCgoUXTM/Px/T07FrfyEty9DwJLs96gjDABEljclkQjAYVHTNUCiE3Fy2y0226WkRExNhtcugFGEYIKKkEQQBfr8f0WhUkfUikQhOnTqJbdssiqxHVzfIowLdYBggoqSxWq2QJAkOh0OR9RwOByRJwv/c+wQefuhTsH3agu3bbsJ11y2+kRFdG8OAfvA1AREljSzLEAQBgiAo0meguroaPp8PHo/nkj4DohhHIBBEYDSIwOgUxsZCSCT4x9tyZGdn4ZGHy2A0suNjpuP/wkSUNFlZWairq8OBAwfgdrsXNLXxStxuNw4dOoRnnnnmsg2HjMYcbNiwBhs2rAEAxOMSxsfDGAlMITAaxOhokFMPFymRkDE8MoVNG9eqXQolGXcGiCiplJpNUF5eDpPJBJfLtaTZBIlEApOTEYwEgghcCAjT0+K1P6hzt992I+4qvU3tMijJGAaIKOk8Hg8qKipgs9mWNLVwz549cLlccDqdio51ngpGZ4NBIIiRwBQikelrf0hn8vJy8dDn71K7DEoyhgEiSonOzk48/PDD2Lx5M5qamhZ0ZOB2u7F371709/ejra0NlZWVSa0xEpm+cO9gCiOBIKamItf+kA58/oESFBQo0ziKtImvCYgoJSorK+F0OmEymWCz2VBdXY2Ojo5Lnh1GIhG0t7ejuroaNpsNJpMJTqcz6UEAAMzmXGzevB53ld6Gz93/STzycBl2VtwBy/aNWLs2X7fDkfiqIPNxZ4CIUkoURTQ2NqK+vh4+nw8GgwEWiwX5+fkIhULw+/2QJAlFRUWora3Fvn37YDQa1S4bACCKEsbGQ/NHC6NjQUhSQu2ykm7DTWvwGfsOtcugJGIYICJVyLKM3t5euN1ueL1eRCIRmM1mCIIAq9WKkpISzf8knkgkMDYexuhoECMjUwiMTkEUM+/FQo4hG498wQqDgZvJmYphgIhIIbIsY2oqOvucMTB77yAWm1G7LEV89u4i3HjDarXLoCRhGCAiSqJQKIbA6OxrhdHAFIKh9ByydIdlI+78xBa1y6AkYRggIkqhaHTmQhOk2Z2DdBkGtHq1GQ9UfVLtMihJGAaIiFQkivHZOwcBbbdRlmUZN2804L33euH1ehGNRmEymebveJSWlmr+jgddGcMAEZGGSFICY2Oh+V4HardRjsfjeLXjZfz6v1sxMHB2/vVHQUEBgsHg/OuPwsJC1NXVaer1By0cwwARkYZd1EZ5dPZJY6raKPf3n8bBn/0I58768dhjj2H//v2w2+0wmT5qQBSNRuFwONDQ0IDW1laUlJSgublZ0U6RlHwMA0REaSYVbZT7vD34+7/7E2zdeiueffZZlJWVXfMzqe4YScphGCAiSnNKt1Hu7z+N7/+vp2G378TLL7+smVkSlDwMA0REGWZ6WkRgNDgfEMbHw1joH/XxeBzf/97TyF2RBbfbvewpk06nk3cI0sDi54ASEZGm5eYasWnjWmzauBbApW2Ux8aCiF+hjfKrHS/j3Fk/urq6lhQEACAvLw9NTU2w2WxobGzEt771rSX/Wig1uDNARKQzV2qjLMsy/uQ7X0F5+V34xS9+sezvU11dDZ/PB4/Hw2eHGscwQESkc3NtlI8cOYo9ez6H9vZ2VFVVLXvd9vZ2PPDAA3j77bdRWlqqQKWULJw6QUSkc1lZWVi92ozBwdk+Ana7XZF17XY7DAYD3G63IutR8jAMEBERAMDr9cJisVzUR2A5zGYzLBYLvF6vIutR8jAMEBERgNkGQgUFBYqumZ+fj0hkeU8dKfkYBoiICABgMpkQDAYVXTMUCsFsNiu6JimPYYCIiAAAgiDA7/cjGo0qsl4kEoHf74cgCIqsR8nDMEBERAAAq9UKSZLgcDgUWc/hcECSJFitVkXWo+Th00IiIgIw+8RQEAQIgoCWlpZlr8c+A+mDOwNERARg9olhXV0dWltbl/0c0O1249ChQ6itrWUQSAPcGSAionmiKMJmsyEWi6G7u3vZswlcLhdyctj5Xuu4M0BERPOMRiOam5vR39+PPXv2IBwOL+rzc1ML+/v70dTUxCCQJhgGiIjoIsXFxWhra4PL5UJ5efmCjwzcbjfKy8vhcrnQ1tbG8cVphGGAiIguUVlZCafTCZPJBJvNhurqanR0dFzy7DASiaC9vR3V1dWw2WzzY4srKytVqpyWgncGiIjoikRRRGNjI+rr6+Hz+WAwGGCxWJCfn49QKAS/3w9JklBUVITa2lrs27cPRqNR7bJpkRgGiIjommRZRm9vL9xuN7xeLyKRCMxmMwRBgNVqRUlJCV8NpDGGASIiIp3jnQEiIiKdYxggIiLSOYYBIiIinWMYICIi0jmGASIiIp1jGCAiItI5hgEiIiKdYxggIiLSOYYBIiIinWMYICIi0jmGASIiIp1jGCAiItI5hgEiIiKdYxggIiLSOYYBIiIinWMYICIi0jmGASIiIp1jGCAiItI5hgEiIiKdYxggIiLSOYYBIiIinWMYICIi0jmGASIiIp1jGCAiItI5hgEiIiKdYxggIiLSOYYBIiIinWMYICIi0jmGASIiIp37/wECI8ix3T+FZAAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -122,7 +120,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -130,7 +127,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -157,7 +153,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -184,7 +179,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -212,7 +206,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -224,9 +217,9 @@ ], "metadata": { "kernelspec": { - "display_name": "base", + "display_name": "venv_xgi", "language": "python", - "name": "python3" + "name": "venv_xgi" }, "language_info": { "codemirror_mode": { @@ -240,7 +233,19 @@ "pygments_lexer": "ipython3", "version": "3.9.13" }, - "orig_nbformat": 4 + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } }, "nbformat": 4, "nbformat_minor": 2 diff --git a/tutorials/XGI in 5 minutes.ipynb b/tutorials/XGI in 5 minutes.ipynb index 8f0af9dfb..a52ccb21e 100644 --- a/tutorials/XGI in 5 minutes.ipynb +++ b/tutorials/XGI in 5 minutes.ipynb @@ -1,7 +1,6 @@ { "cells": [ { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -28,7 +27,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -43,7 +41,7 @@ { "data": { "text/plain": [ - "'0.7.2'" + "'0.7.3'" ] }, "execution_count": 2, @@ -56,7 +54,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -79,7 +76,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -97,9 +93,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Unnamed Hypergraph with 20 nodes and 30 hyperedges\n", + "Unnamed Hypergraph with 20 nodes and 36 hyperedges\n", "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n", - "[{0, 4}, {0, 13}, {0, 19}, {1, 3}, {1, 4}, {1, 5}, {8, 1}, {1, 9}, {1, 12}, {1, 13}, {2, 13}, {2, 19}, {3, 5}, {3, 13}, {4, 6}, {17, 5}, {9, 10}, {10, 11}, {18, 11}, {14, 15}, {16, 19}, {0, 10, 11}, {1, 11, 13}, {2, 3, 14}, {2, 19, 15}, {9, 4, 5}, {16, 4, 7}, {8, 18, 7}, {17, 10, 11}, {17, 13, 14}]\n" + "[{0, 3}, {0, 6}, {0, 15}, {1, 9}, {1, 10}, {1, 13}, {2, 4}, {16, 2}, {3, 5}, {3, 14}, {19, 5}, {6, 14}, {10, 7}, {16, 7}, {17, 7}, {18, 7}, {8, 18}, {9, 17}, {9, 19}, {10, 15}, {16, 10}, {16, 12}, {17, 12}, {18, 14}, {19, 15}, {0, 4, 14}, {1, 15, 7}, {1, 12, 14}, {17, 2, 6}, {18, 3, 5}, {18, 3, 6}, {11, 17, 3}, {3, 12, 15}, {18, 15, 7}, {10, 19, 15}, {18, 12, 14}]\n" ] } ], @@ -110,7 +106,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -128,7 +123,10 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 5, @@ -137,7 +135,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACr5UlEQVR4nOzdd1iU17bA4d8UekeajSJFEQuoIMbYS4zGbppJ1OQcu6aYHhNTjMlJL/aYoqk3zd6xRwRFBQ1FUaRZKNKHGcqU+weCoiAMzIDKfp/nPvcEZva3UZxvfXuvtZdEp9PpEARBEAShxZI29wQEQRAEQWheIhgQBEEQhBZOBAOCIAiC0MKJYEAQBEEQWjgRDAiCIAhCCyeCAUEQBEFo4UQwIAiCIAgtnAgGBEEQBKGFE8GAIAiCILRwIhgQBEEQhBZOBAOCIAiC0MKJYEAQBEEQWjgRDAiCIAhCCyeCAUEQBEFo4UQwIAiCIAgtnAgGBEEQBKGFE8GAIAiCILRwIhgQBEEQhBZOBAOCIAiC0MKJYEAQBEEQWjgRDAiCIAhCCyeCAUEQBEFo4UQwIAiCIAgtnAgGBEEQBKGFE8GAIAiCILRwIhgQBEEQhBZOBAOCIAiC0MKJYEAQBEEQWjgRDAiCIAhCCydv7gkIgiAIAoBOpyM6OpqoqCji4uJQqVRYWFgQEBBAcHAwQUFBSCSS5p7mPUmi0+l0zT0JQRAEoeUqLy9nzZo1LFu2jISEBGQyGX5+ftjY2FBUVERiYiIajQZ/f3/mzZvH9OnTMTExae5p31PENoEgCILQbGJjYwkNDWX+/PkEBAQQFhZGUVER8fHxHD16lPj4eIqKiggLCyMgIID58+cTGhpKbGxsc0/9niJWBgRBEIRmcfDgQUaNGoWHhwfr1q2jV69edb4nKiqKadOmkZaWxtatWxkwYEATzPTeJ4IBQRAEoclVrgj06dOHjRs3YmVlVe/3FhcXM27cOCIjI4mIiKBLly5GnGnLIIIBQRAEoUmVl5cTGhpKSUkJx44d0ysQqFRcXExISAgWFhZERESIHIJGEjkDgiAIQpNas2YNMTExrFu3rkGBAICVlRVr164lOjqaNWvWGHiGLY9YGRAEQRCajE6nIyAggICAAP78889Gjzdp0iQSEhKIjY0VZYeNIFYGBEEQhCYTHR1NQkICM2fONMh4M2fOJD4+npiYGIOM11KJYEAQBEFoMlFRUchkMvr27WuQ8fr27YtMJiMqKsog47VUIhgQBEEQmkxcXBx+fn5YWFgYZDxLS0v8/PyIi4szyHgtlQgGBEEQhCajUqmwsbEx6JjW1tYolUqDjtnSiGBAEARBaDIWFhYUFRUZdEyFQoGlpaVBx2xpRDAgCIIgNJmAgAASExNRqVQGGU+pVJKYmEhAQIBBxmupRDAgCIIgNJng4GA0Gg3h4eEGGS88PByNRkNwcLBBxmupxDkDgiAIQpMR5wzcmcTKgCAIgtBkJBIJ8+bNY/369Y0uB4yKimLDhg3MnTtXBAKNJFYGBEEQhCZV2ZtAqVRy/PjxRvcmiIyMRC6XG2GmLYdYGRAEQRCalImJCcOGDePcuXOMHj2a4uJivd5f2bUwLS2NtWvXikDAAEQwIAiCIDSp7777jo8++giNRsORI0cICQmp95ZBVFQUISEhREZGsnXrVtG+2EBEOCUIdyGdTkd0dDRRUVHExcWhUqmwsLAgICCA4OBggoKCxB6qcEf6v//7P6ZPnw7Aiy++yNSpU3n66acJDQ1l/PjxzJo1i759+1Y7oVCpVBIeHs7q1avZsGEDQUFBREREiEDAgETOgCDcRcrLy1mzZg3Lli0jISEBmUyGn58fNjY2FBUVkZiYiEajwd/fn3nz5jF9+nTR5124Y2zevJmJEyeiVquZOXMmK1euRCKR1Pp7bW1tjUKhqPq97ty5M3PnzhW/10YgggFBuEvExsYydepUYmJimDBhAjNnzrzlCUqlUlU9Qa1fv57AwEDWrVsnnqCEZrdnzx5GjRpFWVkZTzzxBD/++CNSafWdap1OR0xMTNWKl1KpxNLSsmrFKzAwUKx4GYkIBgThLnDw4EFGjRqFh4cH69ato1evXnW+JyoqimnTppGWlsbWrVsZMGBAE8xUEG4VHh7O8OHDUSqVjB8/nj/++EMk/d1hRDAgCHe42NhYQkND6dOnDxs3btSrDKsy6zoyMlLssQrN4uTJkwwaNIjCwkIeeOABNm3ahJmZWXNPS7iJCAYE4Q5WWY9dUlLCsWPHGl2PHRERIfZahSYTFxfHgAEDyMnJoV+/fuzcuVM0FLpDidJCQbiDrVmzhpiYGNatW9egQADAysqKtWvXEh0dzZo1aww8Q0GoWVJSEsOGDSMnJ4devXqxdetWEQjcwcTKgCDcocQZ7sLdKj09nX79+pGamkqXLl04cOAArVq1au5pCbchVgYE4Q4VHR1NQkICM2fONMh4M2fOJD4+npiYGIOMJwg1yczMZOjQoaSmpuLr60tYWJgIBO4CIhgQhDtUVFQUMpmMvn37GmS8vn37IpPJGt0cRhBqk5uby7Bhw0hMTMTd3Z09e/bg5ubW3NMS6kEEA4Jwh4qLi8PPz6/aOQKNYWlpiZ+fH3FxcQYZTxBuVFRUxIMPPsi///6Lm5sbe/fuxd3dvbmnJdSTCAYE4Q6lUqmwsbEx6JjW1tYolUqDjikISqWShx56iGPHjuHo6EhYWBg+Pj7NPS1BDyIYEIQ7lIWFBUVFRQYdU6FQiIxuwaBKS0uZOHEihw4dwtbWlt27d4vzLO5CIhgQhDtUQEAAiYmJqFQqg4ynVCpJTEwkICDAIOMJglqtZvLkyezcuRMLCwu2bdtGz549m3taQgOIYEAQ7lDBwcFoNBrCw8MNMl54eDgajYbg4GCDjCe0bFqtlmeeeYb169djamrKpk2buP/++5t7WkIDiWBAEO5QlU1aVq5caZDxVq1aha9vR7p06WqQ8YSWS6fTMW/ePH766SdkMhl//PEHw4YNa+5pCY0gggFBuMNkZ2fzzDPP0K9fP5RKJRs2bGh0OWBUVBQbN26k/4CH2LErhoQzFykrUxtoxkJLotPpePXVV6vaD//000+MHTu2uaclNJI4gVAQ7hAajYY1a9bwxhtvkJeXB8DTTz/NiRMnUKvVjepNEBwcTFmZjvc/+AaZrKJbnFwuo4OXK76+blhaiMYxQv0sXryYRYsWAfDNN98wffr0Zp6RYAgiGBCEO8Dx48eZPXs2x48fB6B79+6sWLGC++67j9jYWPr06UNoaGiDuhaOHj2aiMhI3l/yDe7u3re8RiqV4O7uTEe/NtjaGOZMA+He9MUXX7BgwYKq//38888374QEgxHbBILQjHJzc5k9ezYhISEcP34cW1tbvvrqK44fP859990HQJcuXdi6dSuRkZGEhITUe8sgKiqKnj17cujQIRzsnXFxaVPj67RaHSkpWezaHcORiLPk5Bq2nFG4N6xZs6YqEHjvvfdEIHCPEcGAIDQDrVbLDz/8QMeOHVm1ahU6nY4nn3ySs2fP8uyzzyKXy6u9fsCAAURERGBhYUFoaCiTJk1iz549t5QdKpVKwsLCmDRpEqGhoZiammJjY8OVK2ks/fpdtFrtbed16XIu+/bHcvBQPBmZ+Yb+sYW71K+//lrVI+Pll1/mzTffbOYZCYYmtgkEoYmdOnWKOXPmcOTIEQA6d+7M8uXLGThwYJ3vLS8vZ82aNSxbtoyEhARkMhl+fn5YW1ujUChITExEo9HQuXNn5s6dy/Tp0zl27BiDBw+mrKyMMWOf4Mmn5tZ7rvb2VnTya0Pbto5IpeLZoSXatGkTEydORKPRMHv2bJYvXy66Xt6DRDAgCE2ksLCQRYsWsXTpUrRaLVZWVrz99ts8//zzmJiY6DWWTqcjJiaGqKgo4uLiqsoQAwICCA4OJjAwsNoH9i+//MKTTz4JwMxZrzFk6Bi9rmdtbY6fb2s83J2Ry2V6vVe4e4WFhfHQQw9RVlbGlClT+OGHH0RQeI8SwYAgGJlOp+O3337jxRdfJCMjA4BJkybxxRdf0K5duyabxzvvvMO7776LTCZj4Ztf0KVrL73HMDczwde3Nd4dXDExkdf9BuGudfjwYYYPH45KpWLixIn83//93y3bV8K9QwQDgmBE8fHxzJs3j/379wPg6+vLsmXLGD58eJPPRafT8cQTT/Dbb79hZWXD+x+spm1bzwaNJZfL8O7giq9PaywsTA07UaHZnThxgsGDB1NYWMiIESPYtGkTpqbi7/leJoIBQTAChULB4sWL+fzzz1Gr1Zibm7Nw4UJefvllzMyar6a/pKSEwYMHExERgatbW5Z8sAZbW/sGjyeVSvC4VpZoI8oS7wmxsbEMGDCA3NxcBgwYwPbt20VzqxZABAOCYEA6nY7169fzwgsvkJ6eDsDo0aP56quv8PLyaubZVcjKyqJ3796kpKTg79+dNxd9hYlJ45/62rZ1pFPHtjg6WBtglkJzOHfuHP379ycjI4OQkBD27Nlj8Dbawp1JBAOCYCDnzp1j/vz57Nq1CwBPT0++/vprRo8e3cwzu1V8fDx9+vShsLCQ/v1HMHf+WwbLEHd1scPPrw1urvYGGU9oGmlpafTr14+0tDS6devG/v37cXR0bO5pCU1EBAOC0EgqlYoPP/yQjz76iLKyMkxNTXnllVd4/fXX7+jl1bCwMB588EE0Gg2PPT6DCROnGXR8B3srOnZsS7u2jqIU7Q6XkZFB//79OXfuHH5+fhw6dAhXV9fmnpbQhEQwIAiNsHXrVp599lmSk5MBGD58OMuWLcPX17eZZ1Y/q1evZtasWQA8v2Ax9903xODXsLY2p6NvGzw8nJHJRFnanSYnJ4eBAwcSGxuLh4cH//zzD+3bt2/uaQlNTAQDgtAAKSkpPP/882zatAmAtm3b8uWXXzJx4sS77il4wYIFfPHFF5iYmPL2u8vw8+tilOuIssQ7T2FhIUOGDOH48eO0bt2af/75B2/vW/tXCPc+EQwIgh5KS0v59NNPWbJkCSqVCrlczgsvvMCiRYuwtr47E+c0Gg3jx49ny5Yt2Nk5sOTDb3FxaW2065mYyPDu4IaPt5soS2xGSqWSESNG8M8//9CqVSsOHTpE586dm3taQjMRwYAg1NOePXuYO3cuiYmJQEW/gOXLlxMQENDMM2s8hUJBv379iImJoX17Lxa/vxpLK+MGN1KpBE8PFzr6tcHa2tyo1xKqKy0tZezYsezatQtbW1v2799Pjx49mntaQjMSwYAg1OHSpUssWLCAP/74AwBXV1c+++wzJk+efNdtCdzOxYsXCQkJ4cqVK3QP7M1rr3+CTGb85XyJRFJRlujXBgdRlmh0arWaRx55hA0bNmBpaUlYWFhVh0yh5RLBgCDUory8nK+//pp33nkHhUKBVCpl3rx5vPfee9jZ2TX39IzixIkT9O/fH6VSyfAHJvCf/77YpAGPq4sdHTu2xdXl3vzzbW5arZapU6fy888/Y2ZmxrZt2xgyxPBJo8LdRwQDglCDQ4cOMWfOHOLi4gDo06cPK1asIDAwsHkn1gQ2bNjAxIkT0el0THv6eUaOeqTJ5+DoYI2fXxtRlmhAOp2O2bNns3r1auRyOevXr78jz8AQmoeo8xGEG2RmZjJlyhQGDBhAXFwcTk5OfPfddxw+fLhFBAIA48eP56OPPgLgx3Vfc/JEeJPPITdPQeTRRHbtjuFCciYajbbJ53Av0el0vPzyy6xevRqJRMJPP/0kAgGhGrEyIAhUZNSvXLmSN998k4KCAiQSCTNmzOCDDz5okaew6XQ6pk+fznfffYe5uSWL31+Fh6dPs83H3NwUP9/WdPByEWWJDfDuu+/yzjvvAPDdd9/xzDPPNO+EhDuOCAaEFi8yMpI5c+YQHR0NQM+ePVmxYgUhISHNPLPmVVZWxoMPPsi+ffto5eTKBx+uwcHBqVnnVFmW6OvTGnNzk2ady93i888/58UXXwTgq6++4tlnn23mGQl3IhEMCC1WTk4Or732Gt9++y0A9vb2fPDBB8yYMQOZTNbMs7sz5OXl0adPH86ePYu3jz/vvLscM7PmLwOUyaR4ejjj5yvKEm/nm2++YebMmQC8//77LFy4sJlnJNypRDAgtDharZbvvvuO1157jdzcXACmTZvGRx99hIuLSzPP7s5z/vx5QkNDycnJoXfoQF5Y8D5S6Z2RbiSRSGjX1pGOoizxFj///DNTpkxBp9Px2muv8cEHH4hkTKFWIhgQWpSTJ08yZ84cjh49CkDXrl1ZsWIF999/fzPP7M72zz//MGTIEMrLyxk3fgqTn5jV3FO6haurPZ06tsHFWZQlbtiwgYcffhiNRsO8efP4+uuvRSAg3JYIBoQWIT8/nzfffJOVK1ei1WqxsbHh3XffZf78+cjlIiGtPn766SemTJkCwOw5bzBo8EPNPKOaOTpY07FjG9q2aZllibt27WLMmDGUlZUxbdo0vvvuuztmJUe4c4lgQLin6XQ6fvrpJ15++WWysrIAePzxx/n0009p06ZNM8/u7vPWW2/x/vvvI5fLWfjmlwR0uXOPsLWxscDPtzUe7i2nW+KhQ4cYMWIEKpWKhx9+mF9//VUEu0K9iGBAuGfFxsYyZ84c/vnnHwA6derE8uXLGTx4cDPP7O6l1WqZPHkyv//+O1bWNiz5YA1t2rg397Ru63pZoismJvduYmhUVBRDhgyhqKiIUaNGsX79ekxNRSMooX5EMCDcc4qKinjnnXf46quv0Gg0WFpasmjRIl544QXx4WgAKpWKwYMHExkZSevW7Xn/g2+wsbnz9+lNTGT4eLvh433vlSXGxsYyYMAAcnNzGTRoENu2bcPCwqK5pyXcRUQwINwzdDodf/zxBwsWLODy5ctAxWl6X375Je7ud/bT690mMzOT3r17k5qaSufOQbz51pfITe6OG+y9VpZ47tw5+vXrR2ZmJqGhoezevRsbG5vmnpZwlxHBgHBPOHv2LPPmzWPPnj0AeHt7s3TpUh588MFmntm9KzY2lvvuu4+ioiIGDBzJnLkL76qEPYlEQvt2rejo1wZ7e6vmnk6DpKam0q9fP9LT0wkMDGTfvn04ODg097SEu5AIBoRmodPpiI6OJioqiri4OFQqFRYWFgQEBBAcHExQUFC9bixKpZL333+fTz/9lPLycszMzHjjjTd45ZVXMDe/+5/67nS7du1i1KhRaDQaHp88i/ETpjT3lBrEzc2eTn5tcXa2be6p1NuVK1fo378/58+fp1OnThw8eFCckyE0mAgGhCZVXl7OmjVrWLZsGQkJCchkMvz8/LCxsaGoqIjExEQ0Gg3+/v7MmzeP6dOnY1LD8rNOp2PTpk0899xzpKWlATBy5Ei+/vprvL29m/rHatFWrFjB3LlzAVjw4vuE9rl7EzQdHa3p1LEtbVo73NGrHDk5OVXNtDw9Pfnnn39o165dc09LuIu1jHob4Y4QGxtLaGgo8+fPJyAggLCwMIqKioiPj+fo0aPEx8dTVFREWFgYAQEBzJ8/n9DQUGJjY6uNc+HCBUaPHs348eNJS0vD3d2dDRs2sHXrVhEINIM5c+bw3HPPAbBs6XucPxffzDNquNxcBUcizrIr7BTJKVlotXdet8SCggIeeOAB4uLiaNOmDXv37hWBgNBoYmVAaBIHDx5k1KhReHh4sG7dOnr16lXne6Kiopg2bRppaWls3bqV3r178/HHH/Phhx9SUlKCiYkJL730EgsXLsTK6u7c871XaDQaxo4dy7Zt27Czd+TDD7/FydmtuafVaBYWpvj63DllicXFxYwYMYLDhw/j5OTEoUOH8Pf3b+5pCfcAEQwIRle5ItCnTx82btyo1427uLiYcePGceTIERwdHbl48SIAQ4YMYdmyZXTq1MlY0xb0VFRUxP3338/p06dxd/fmvfdXYWl5bwRppqbya2WJbpiZNU/VRGlpKaNHjyYsLAw7Ozv2799PUFBQs8xFuPeIYEAwqvLyckJDQykpKeHYsWMNeoIvLi6mR48eJCUl4eLiwhdffMEjjzxyR+/ptlRpaWn07t2bjIwMgnr04ZVXP0Imu3dOwJPLpHh6uuDn2xorq8YlqOqTRFteXs7DDz/Mpk2bsLKyIiwsjD59+hjiRxIEQAQDgpGtWLGC+fPnc/To0XptDdQmKiqK0NBQPvnkExYsWGDAGQqGFhUVxYABA1CpVDw48mGefuaF5p6SwVWWJXbq2BY7O0u93qtvEu0zzzzDf/7zH3799VfMzMzYvn27OEVTMDgRDAhGo9PpCAgIICAggD///LPR402aNImEhARiY2PFqsAd7u+//2bSpEkAPPOfFxnx4MRmnpHxtHZzoFPHNjg51V2WGBsby9SpU4mJiWHChAnMnDmTvn37VjstUKVSER4ezurVq1m/fj1OTk5kZWUhl8vZuHEjo0aNMuaPI7RQoppAMJro6GgSEhKYOXOmQcabOXMm8fHxxMTEGGQ8wXgmTpzIhx9+CMDaH74gJjqymWdkPFcy8th/MI59B2K5fDmX2p6vDh48WLVldvToUf7880+GDh16y7HBFhYWDB06lD///JPIyEjs7e2RyWQsXLhQBAKC0YhgQDCaqKgoZDIZffv2Nch4ffv2RSaTERUVZZDxBON69dVXefrpp9FqtXzx+ZukpSU195SMKieniPCIs+zec5qU1OxqZYmxsbGMGjWKPn36cOzYsXpvmQUHB3Py5EkGDhzIZ599dkuZrSAYitgmEIzm2WefZc+ePcTHG67uvHPnzgwbNoyvvvrKYGMKxlNWVsYDDzzAgQMHcHJy5YMPv8XeoVVzT6tJWFqa4evTmnZtHejXr2+jk2hDQkKwsLAgIiKixoO4BKExxMqAYDQqlcrgDVOsra1RKpUGHVMwHlNTU/7++298fX25ejWTTz5+jbLS0uaeVpNQKks5dTqFF158m5iYGNatW9fg8zCsrKxYu3Yt0dHRrFmzxsAzFQQRDAhGZGFhQVFRkUHHVCgUWFrql70tNC9HR0e2bduGo6Mj587FsWzZ4jvyZD9j0Ol07Nj2J+PHj29UNQ1UbBmMHz+e5cuX15qXIAgNJYIBwWgCAgJITExEpVIZZDylUkliYiJ+fn4GGU9oOr6+vqxfvx4TExMiI/bxx+8t4+k2OTmR9PRkZs2aZZDxRBKtYCwiGBCMJjg4GI1GQ3h4uEHGCw8PR6PRsHDhQl588UXOnj1rkHGFpjFgwICqJe71f6/j4IEdzTwj40s6nyCSaIW7gggGBKMJCgrC39+f1atXG2S8VatWYWpqRkFBAZ9//jmdOnVi4MCB/Prrr5SUlBjkGoJxTZ06lTfeeAOA1as+JD4+uplnZFzp6Rfw8fG9pXywoSwtLfHz8yMuLs4g4wlCJREMCEYjkUiYN28e69evb/STTFRUFBs3buSJJ+fw6muf0LPX/UilUg4ePMgTTzxB27ZtWbBgAQkJCQaavWAsixcvZtKkSajVaj79+HUyrlxs7ikZTVlZqUiiFe4KorRQMCpD9SYIDg6mrEzH+x98U3XWfU5OFvv3bWXv3i3kXM2sen2/fv2YMWMGEydONNgTmWBYKpWKgQMHcuzYMVq3cWfJkm+wtqn7BL+7SWlpOd9/9wWXLyVw5swZg40rymsFYxDBgGB0sbGx9OnTh9DQ0AZ1LRw7dixHjkSweMlq3N29b3mNVqMhJiaSPWGbOHnySFWmuoODA1OmTGH69OkEBAQY7OcRDCMjI4PevXuTlpZGQJceLFz4BfK7tH6+tLQcpbIUpbIMpari/6vVGmJO7mVP2I8UFRUZJDBVKpXY2tqyYsUKZsyYYYCZC0IFEQwITeLgwYM89NBDuLu7s3btWoKDg+t8T1RUFFOnTiUlJZVXX/uEzgF1t2vNzclm376t7Nu7mas3rBb07duXGTNm8PDDD4vVgjvIv//+S9++fSkqKmLwkNHMnPXaHd934sYbf7GyFJWqFLX61lJJiVRCdlYq333zBmFhYQwdOrTR1w4LC2P48OGcPHlStC8WDEoEA0KTiY2NZdq0aURHRzN+/HhmzZp1S5MWpVJZ1aRlw4YNBAR0ZerTL9W4InA7Wo2GU6eOsWfPJk4cD0er1QBgb2/PU089xYwZM+jSpYtBfz6hYXbs2MFDDz2EVqvliSfnMHbck809pSqVN/7iazf/2m78N5KbyEAHarUGnU7HD9+9Tv9+vfnrr78aPR/RrEswFhEMCE3q5vatUqkULy8vHB0dUSgUVe1bO3fuzNy5c5k+fToRR8+TmZnf4Gvm5mZzYP829u7dQnbWlaqv9+nThxkzZvDII4+Ig4ya2bJly5g/fz4SiYQFLy6hd+jAJp9DaWn5tZt+adWTv0ZTv8ORZDIpEilo1LpqBwKp1WX8/ttHXLqYyNGjR+u1IlabyjbeS5cuZc6cOQ0eRxBqIoIBoVnodDrWrVvH008/jbW1NY899hiWlpYEBAQQHBxMYGBg1ZOPQlFC2J5TqOv5wVwbrVbL6dPH2BO2mRPH/0GjqVgtsLOz48knn2TGjBl069at0T+b0DDz589n2bJlmJqa8e57K/D28TfKdXQ6HaWl6mt7+/rf+CtJpBLkMikajRat9taP0Zycy2zesIysrDRkMhk+Pr6cOHG80b0JIiMjkcvleo8hCLcjggGh2fz0009MmTKFQYMGsW/fvtu+9mziZU7/m2qwa+flXeXA/u3s3bOZrKzLVV/v3bs3M2bM4NFHH23wOfJCw6jVasaMGcOOHTtwcHBiyYdrcHJybdSYVTd+ZekNN3/9b/w3ksulIAF1ee1jxP57mN07f6C8vBRbW3seeXQ6v/y8nPvu68OmTZv0TqIdN24ckZGRREREiO0twShEMCA0m0WLFrF48WJmzJhR58FEWq2Wvftjyc8vNugctFotsf8eZ0/YJqKiDlWtFtja2vLEE08wY8YMAgMDDXpNoXaFhYX07duX2NhYPDx9Wbx4JeYWFVs4Op2O5OREks4nkJ5+gbKyUkxNzWjfvgPePv54evpSVqauyugvLi5FpWrcjb+STC5FIpGgUWu43SdmWVkJYbvWEfvvPwAEdOnB/GffxtHRmfi4aD7638t4enqwbt26eifRTps2jbS0NLZu3cqAAQMa/bMIQk1EMCA0m8mTJ/Pbb7/x8ccf8/LLL9f5+tw8Bfv2xxqtSUt+fu613ILNZGZcqvp6cHAwM2fO5NFHH8Xa2too1xauS01NpXfv3mRmZtKjZ18WLHif/fu3snvXetLTk6uW3G1sbCgqKuL8+XNoNBpcXNrRPWgI3QMHVZ1F0RiV2wBajRZNDdsAN8vKSmPT+qXk5l5BIpHy8CP/YcKEKUhlsqrXpKUlsXL5EpKTExk3bhyzZ8+uM4k2KCiItWvXihUBwahEMCA0m5CQEKKioli/fj3jx4+v13tiTqVw7vyVul/YCFqtlrjYk+zZs4moYwdRq9UA2NjYVK0WiLIu4zp27BgDBgygpKQEB4dWFBTk1VqBolKpCA8PZ9WqVWzYsAFXNw8eHDkDZ5f2Dbq2XF5x8674e687Y1+n0xETvY+9YT+j0ZTj4OjEc8+/S+fONf+OlJSU8vPP64g+uYfsrIvIZDI8PT2xsbFBpSqpCm68vHx46aUXmD59OiZ36fkLwt1DBANCs3F0dCQvL4/Tp0/TtWvXer2nvFzD7j2nUCpLjTy7CgUFuRw8sIM9YZvIyLh+bG6vXr2YMWMGjz32mMGPm23JdDodhUUq8vKK+d+HS1izZik+Pj788ssv9WoBHBUVxZQpU0lOTmHCpAW4e9QvCfF6NYD2ttsANyspKWbn9u84e+YYAD163MeceW9ia2tf63suXc4lIyMfnU5HVmYq5xJPEn64oqPj0GHjaN/eC29vfzy9/BjxQBC2NuJcDMH4RDAgNIucnBycnJyAigQpfUr7rlzJ4/ARwx3vWh86nY64uJPsCdvEsaMHqlYLrK2tmTx5MjNmzKBnz55NOqe7nVarpaiohLz8YvLzFeTmFVOQX4xaoyUtLYk335jBfff1YfPmzXon3I0ZM5bw8CM88dSiWlcIpFIJMj22AW52+XISmzcso6AgG5lMxhNPzmHkqEeRSmtv+aLRaPk3Nq1aHkNmRgprv38TB0cnVn+zudrrfbzdCAr00ntugqAvEQwIzeLo0aOEhobStm1bLl7Uv1FN5NFE0i/mGGFmdSssyOPgwR3s2bOZK5fTqr7eo0cPZsyYweOPP46tbePP2dfpdERHRxMVFUVcXBwqlQoLC4uq8sugoKC75uCZG2/8eXkK8vKv3/hvplareXPhDMxMJURFRTW4FK9Xr2AKCkt54qlF1XII5CbSqkOB6rMNcDOdTkvUsZ0c3P87Wq0GF5c2PP/Ce/j4dq7zvRkZ+Vy6nFvta5cvneende/g7NKa5Sv+rvY9uVzGQyN7YmIiQxCMSRSrCs3i/PnzAPj4+DTo/YHdvcjIzKe8XGPIadWLrZ0Do8dM5qHRj5MQH8OesE1ERu7n5MmTzJo1ixdffJHHH3+cGTNm0KtXL71v2DcfzCSTyfDz86tKmFuxYgUajQZ/f3/mzZt3x+0pV974c/MU5OcXk5unoLBAWe9zIvbu2URKcsUhPQ0t77SysuLHH9cRGhrKqZj9hPR+ACQS1GrNDSWB+gcCSmUR27euJul8DAChoYOYOfs1rKzq3irSarVkZhXc8nWNpmKVyUR+69+hWq0hLT0b7w5ues9VEPQhggGhWVQGA76+vg16v7m5Cd26enDi5AVDTksvEomEzgFBdA4IYlrh8xw6uJO9ezZx6VIq3377Ld9++y2BgYHMmDGDyZMnY2dnV+eYsbGxTJ06lZiYGCZMmMDXX39da8Lc6tWrmT9/Pt999x3r1q1rlmxzrVZLYaGq+hN/gbLB5Xw6nY7duyoSSuuTI3A7wcHBjBs3jsOH9xLUY2ijV1HS086wedNyFEV5mJiYMnXacwwbPq7e4169WnRtNaK6ymBAXkMwAJB0IVMEA4LRiWBAaBbnzp0DGr4yANDBy5W0tKtkXy001LQazNbWnodGP8aohx7lTMIp9uzZRGTEfmJiYpgzZw4vvfQSjz32GDNmzCAkJKTGG8jBgwcZNWoUHh4eHD16tNaboYWFBUOHDmXo0KFVdeh9+vQxeh165Y2/8om/sTf+miQnJ5Kensz3339jkPFmzZrF+vXrycpMxdXNs0FjaLVaIsI3EX54PTqdjrZtPXj+hcV4eNb/d1en09W4KgA3rAzUsrpTUKDk6tVCnJzurRbPwp1FBANCs2jsNkGlHj06ELbnVI3HwTYHiUSCf+dA/DsH8vTTL3Do0A7CwjZx6WIK33//Pd9//z3dunVjxowZPPHEE9jb2wMVKwKjRo2iT58+erV5Dg4O5tixY4wbN46HHnrIYCfUabVaCgqU15L7isnLK6ag0LA3/pokna/YFunbt69Bxuvbty8ymYwrVy40KBhQKPLYsmklaanxAAwYOJL//GdB1UFI9ZWTq6CsTF3j9zSacqD2lQGA80kZIhgQjEokEArNwsnJiZycHGJiYujevXujxopPuEhcfLqBZmZ4Op2Os2f/ZU/YJiIi9lJeVgZUPOE/9thjPPPMMzz33HOUlJRw7NixRp9dHxERoVcOwY03/ry8ipt/fkFxswRY33/3OckXYjlzJsFgY3bs2AkbWw+GDp+i1/suXDjNts2rUCoLMTOzYPqMl+g/4EG9r6/T6YhPuEhJSXmN30+Ij2TzxmUEdOnB2+8sq/E1UqmEkSN6YGFhqvf1BaE+xMqA0OTy8vLIyamoBGjsygBAp45tSL+YQ2GhstFjGYNEIqFTp2506tSNadOe49ChityC9PRkfvjhB3744QekUmmjE+bWrl1LaGgoa9asqbWrnUajpaBQSX5ecdU+f0Ghsllu/DqdDo1Gi0ajRa3WotFoKFIUG/zcBmtra8rVZfV+vUaj5p9Df3E0YisAHh4+vLBgMW3aejTo+vn5xbUGAhXXq3tlQKvVkZySRWf/dg2agyDURQQDQpOr3CJo3bq1QZoBSaVSevbowP4DsY0ey9isbWwZOeoRHhz5MIlnYwkL28iR8DDGjBljkIS58ePHs3z5cmbPno1Wq6OgUFmR2Hftid/QN36dTodWq0Ot1lS7qas1WjTqazd6zY3fu/b9a//7ZiUqDUWFhs0BUSgU2Ni2qtdrCwqusnnjci5fqshpGf7ABKZMnY+pqVmDr59RR/vt21UT3OhCciadOra57TkGgtBQIhgQmpyh8gVu5NTKBu8OriRdyDTYmMYkkUjo2KkrJqamHDq4g9mzZxtk3JkzZzJ8+HBWrf4DF1ePet/4rz+hX7txa7Ro1Dfc1LXXv6dRX/v+tZu8ITcanZzaEhO9t+pMhcZSKpUkJZ1n6PC6cxASz0axfdsaSkuUWFpaM2vO64SGDmrU9QsKlSiVt1+V0KhvX01QSaUq4/KVPNq1rV9gIwj6EMGA0OQaW1ZYm65d3Ll0OY+SkvovCTc3YyXMRUYe5f5+rarf1G+64d/4tH6npA65temARqMhPDycoUOHNnq88PBwNBoNrVt3qPU1anUZ+/f+xskTYQD4+gbw3PPv4uLaptHXz8jIr/M1Gm39ggGApKRMEQwIRiGCAaHJGaKssCYmJnKCAj2JiEw06LjGlJ5+AR8fX4M8BQNYWlri7e1DXFwcrdvePccja3U6lMWl6LDHwaE1q1atMkgwsGrVKlxc2uHiWvN+f27OFTZtXEZWZioAY8Y+wWOPz0Qub/xHo0JRgkJRUufrNOprOQP1SPrMyi6gsEgl+hUIBic2n4QmZ4xtgkrt2raibRtHg49rLGVlpc2eMNecysrKyc0t4tKlHHJzFZSXafD26cuGDRuIiopq1NhRUVFs3LiR7kFDajzXIS42nHU/vEVWZio2Nva8/sZnPPnUXIMEAgBXMvLq9TqNpuIgovqsDAAkJWU0eE6CUBsRDAhNzpjBAEBgoGdVG9o7nampGUVFRQYdU6FQYCK/c0vQtDodCkUJVzLyyMgoQKEoRXdDLqG3bx8cHNsyZcoUiouLG3SN4uJipkyZiqubJ4FBg6t9r6yshO1bv2Hr5pWUlZXQuXMQn3y6jqAefRrzY1WjVJZSWKiq12srqwnqWw6akprdLMdwC/c2EQwITaqgoIDs7GzAeMGApYUZXbu4G2VsQ2vfvgPnz59DparfjaMulQlzTs53XglaaWk5OTnVVwFqIpXKCAmdzIULKYwZM1bvgKC4uJixY8eSmprK6LGzkUqvB4bZWen8+MMi/j19CIlEwqSHn2HR21/j2Mq5UT/bzeqqILhRXccR36yyX4EgGJIIBoQmVbkq4OrqavDl8Rt5d3DF0dHaaOMbirePf1XCnCFUJsyVqIrRapv/6VGr1VJYpOLylTwyMwsoLq6+ClAbe/vW9BvwXw4fDqdnr1713jKIioqiR48eHDx4kJdf/Yj+/XpjYWGKTqcjJnofP65dRE7OZRwcnFj09lIeefS/SGWGXUUqKSkjL6/+AUxdxxHX5G6pmhHuHiIYEJqUsbcIKkkkEnr18EYqvbNb/Hp5+dG+vRerVq0yyHgrV65ELpdz8MDvrFqxgKOR2ygpadhSe2OUlJZzNaeQi5dzyc8rRt2AZW0XVx+GDH+O3FwVoaGhTJw4kT179tyyiqJUKgkLC2PixImEhoaSlJSEWq0mPjYaU1M57dvZsn3rSnbt+B61upygoD588uk6Arr0MNSPW40+qwKg/8oAXO9XIAiGIqoJhCZlrLLCmtjZWdLRrw0JZy4Z/VoNJZFIGP7ABH74/guioqIIDg5u8FhRUVFs2rQJT6+uZFxJpqgwhwP7fiP8n/V06z6AnsEP4ODgasDZV6fRaCkuLkFRXNqgm39N7O1b89jkNzmTcJh/Du9l/fr1yGQyvL19sLGxQaFQcP78OTQaDe3dvZg69Vk2bvyZvLyr/PX3D7i1bsuff3xHZuZlZDI5j0+eyUOjHzfawT1lZWpyc/ULvhoSDIDoVyAYlggGhCZlrLLC2vh3asfFizkU1aPEq7kMGTqW/fu3MXXqVKKiohrcm6AyYW7iwwvQajXEx0UQdWwHV7MvcuL4bk4cD8PPrye9QkbQrn3HRrf0raRSlaEoLkGlKgMDH1dgaWWKpaUFPXoOI6jHULIyU7ly5QJXsy9iZibFxdWLAQPH4O3tj6eXHxKJBL9O3Xj91WdAp2PZ0sUAeHh48Ntvv2Fp1YbEc5cNO8kbZGTm631mQ0ODgUuXc1GpykS/AsEgRDAgNKmm2iaoJJNJ6dGjAwcPxTfJ9RpCLpczZ+5C3lo4k7Fjx7Jp0ya9AoLi4mLGjBlLcnIKTzy1CKlUhlQqo1v3AXTt1p/UlDiiju3gQtIpEhOPk5h4HDc3L4J7P0jHTiHIZPp/DGg02oo6+uISNGrjdDKUSMHB/nreh0QiwdXNs6r7YPt2rXBxsbvlfS4urXF1bUtmZsWKkLu7O9HR0Tg4OABgaWlKzKkUg8+3vFxDTo7+lSENyRkA0a9AMCyRMyA0qaYOBgBcnO3w9HRpsus1hLu7N6++9glHjkTQq1ewXglzwcHBhB85woRJC3B2aV/t+xKJBE+vLjz86Mv8Z8ZHdA8chFxuQkZGMls2rWDViheIPLIZlUpRj6vpUKpKyc4u5NKlXAoKlEYLBABsbSyRyWr/iKrp+ftMwileeWlqVSAAkJaWxsGDB6v+29enNX1C/W47dkNkZRU0qO9DfRoV1eZCciZarXHbSgstgwgGhCZTWFhIZmZFFnRTBgMA3bq4Y2am/4dtU+ocEMQ7762ksKiU0NBQJkyYUK+EubIyHe++t5IO3l1uO76TU1tGjPwPs+d9Tb/+k7CyskNRlMfBA3+wctlzhO1aR27urQfaqNUa8guKuXQpl6vZRRXbAUYmk0uxta3jlL0bluO1Gg3r/17LO2/PIycnCz8/P3777beq3ICnnnqKK1euVL2+XdtW9L/fH1NTwyyOqtUashuY0NfQlQG43q9AEBpLortTDiUX7nnR0dH06NEDZ2dnsrKymvz6aWlXORp1rsmvq4+09KtkZOSyc/u3JMRHoNFokMlk+Pj4Ym1tfUvC3PDhExgydCxyuRylqpQzZy7Vu3GQWl1OQnwEx4/tJCsr7dpXJfj4BtIr+EFaOXeguLiU0tu03zWWVk42WFnevlNgu7aOuLrak5+Xw9Kv3+Xff48DFTf+FStWYG1tzZtvvsmSJUsA6N+/P/v376+WPFhYpOJweALFxaWNmu+VK3kNvin/9vMS0tISeP6F97ivr/5HMLs42zGgf+cGXVsQKomcAaHJNMcWwY3c3Z1ITc+uV/OY5qBSlXH1atG1PXwJGo2GAQMepGOnrqSnJ1NaWoKLq/ktCXOVLC3M8PJ04UJy/QItudyErt3606VrP9JS44k6tpOk89GcP1fxf/YObenkPxB3j6AG5RU0lJm5vM5AACq2CU6fOsbSr9+loCAPS0tLVqxYwdSpU6tes2jRIv7++2/OnDnDoUOH+PLLL1mwYEHV921tLBg0oAvhR86Ql9+wEkytVktWdsPL/PRpVFQT0a9AMAQRDAhNpinLCmvTI9CL3WGnUGvuvH3Wi5dy0Ol06HQ6UpJjAeg3YATdutW/3NDBwZrWqvJ6n4tfycnFh34D/0Mn/0ucPXuI5KRj5OddIvLIL5yK3oJvx374+N6HmZn+lQ76ujFpsDZarYYtm9ayJ+xPdDodXbt25ffff8ff37/a60xNTfntt9/o2bMnWq2WV155hcGDBxMYGFj1GgsLUwb0DyDyWGKDAsXsq0Wo1Q0vpaxqYdyAbYJKSUkZBAV6Nfj9giByBoQm09RlhTWxsjKnc+f2db+wiRUUKKvOss+5ehmFIg8TE1M6deqm91hure2xs6v7pl1WpiY3T8HFS7nkXC2itESNrZ0rwSEPM3bCO3QLHIWFhR0qVSGnY7axaf07RB39g8IC451+Z2VtVuc+fmHBVX79+X3Cdv+BTqdj1qxZHD169JZAoFJgYCBvvfUWUNEU6JFHHkGpVFZ7jYmJjL59OuqdaKrV6sjKKtDrPTdraGnhjUS/AqGxRDAgNJnm3iao5OvjhoO98Z9w60un03HxUk7Vf6ekVKwKdPLvjqlp3cvlN5NKJHh5OmNufuvNpbJJUEZGPhkZ+SiKStDVkAFvZmZFQJdhjB73FqH3PYmDYzs0mnLOnzvCti0fcnDfN2RcSdS7pv52JFIJ9nUEMecST/DDdwu5dPEc1tY2/PHHH6xcubLOFtALFy6kS5eKBMtz587x0ksv3fIaqVRKcE9vvUr1cnOLKCtT1/v1NalqVNSIYED0KxAaSwQDQpO5U4IBqVRKzx4dDHboTmNlZRdSckOSXuUWgT7bAzeTyaT4+rRGJqv4GUvLysm5oVVwfW9gMpkcrw69eODBFxkybB5t23UBJFy+HM/+vSvYue0TLiQdrXq6bQw7u9pLCdXqcvbs/pH1f31BSUkx3j7+/L1+Bw8//HC9xjYxMeHnn39Gdq0PwcqVK9m6dWuNrw3o3L5evx86nY6MzMatCoD+LYxrI/oVCI0hggGhSSgUiqrSruYOBqBib93Xp3VzTwO1WsOVG7LQNRo16WkJQOOCAagICOwdrLiSkUdmRgHFivo1CaqJRCLBxdWH/gP/y0Nj38C3Yz9kMlPy8y9zNOI3Nm94l9jTuygpqc95BbeSm8iwsTav8Xt5uRn8/OO7nDi+G4CHRj/O4sWraNfOQ69rdO/enUWLFlX999SpU8nIuLWUEqCDlyv339cR+W3OIsjLL6a0tPGVFvq2MK6N6FcgNIYIBoQmkZSUBECrVq2qToJrbgGd22FZj6x1Y7pyJQ/NDcmMVy4nUVZWgo2tPR6eDUu0LFKoSE7J4vS/qeRcVWBTV72+nmxsnOkVPJFxE96he9BoLC3tKSkp4t/TO9i84V2ORf5OQX7NN9naONhb1vgkHh93hLXfv0lmRgo2Nna89vonTJk6v8HJdq+//npV8mBubi5Tp06t9dAeNzcHBg4IwLyW8ykMVZViiJyBSueT9PtzF4RKIhgQmsSdskVwI7lcRs+g5svAVpWUkX21+vG1yde2CLp26alXM53ycg2ZmQXExaeTmHiF3FxF1Wl41pbmdR/g0wCmZpZ0DhjC6HFv0afvUzg6tkejKSfpfATbt/6P/XtXceXymTrzCswtTLGwqB6UlZeXsmP7t2zZtIKyshL8/bvz8afr6NGzb9VrGpKvYGJiwrp165DLK5IUd+/ezdKlS2t9vYODNYMHdcHmprK9ggKlwQ5fqgoGGrkyANf7FQiCvkQwIDSJOzEYgIqnP/f2Ts1y7YsXc2+5oaVeSx7sWs8tgsJCFUnJmfwbl8bFSznVcg9uZGtribmFcU5glEpleHr1ZPiDCxg6/Fnate8GSMi4coYD+1axY+tHJJ2PrFoOr0YCDg7Vkwazsy/y4w9vczrmABKJhImTnmbRO0tp1cowR0p369at2nbByy+/zOnTp2t9vZWVOYMGBNCqlU3V1/Qt3bwdQ64MVPYrEAR9iXMGhCZRWVbYnGcM1KZ7N08yMvMbnRWuj4pSwurlbaUlSi5fqthO6da99mCgrFxNTk4RV6/WP5NdKpXg1MqGjMx81OVGaiwkkeDs0gFnlw4oiq5y9uwhLpw/SkFBBsci/49T0Vvx9euLj9/9WFhU3FhtbMwxkVck9el0Ok6fOsie3T+iVpdhb9+K+c++TdduvQw+19dee42NGzdy8uRJysvLefzxxzl+/HitVQlmZib0v9+fY8fPc+bMpUafWFhJp9M16jjimlxIzqRTxzZGa9Ms3JvEb4vQJO7UlQEAc3MTunXVLxmtMW4uJayUlpaATqeldev2ODu3vuU9BQXFnE/KIDY2ncuX8/QOXqRSKc7OdjRFEYW1jRM9e01g7IR3COwxFksrB0pLFcT+u4vNG97haMRvFBZeqToPobRUyZZNK9i5/VvU6jK6dw/h40/X3TYQaExZo4mJCWvXrq26AcfHx/Pqq6/e9j1yuYw+vf2QSg33B6jVXj8bwBArAyD6FQgNI1YGhCZxJwcDAF6eLqSlXSUru/GlYnXJvlpY43J+ZUnhjTfAsrJyrl4t4mqOgvLyxq9cmMhluLjYkZmZDxg/KjA1tcC/8yA6durPxfTTnEk4QM7VVC4kHeVC0lHi/u2Ct08QJ6J2kZ+fhVQq47HHZzBm7BN1Ptk29oiDrl27smjRoqoDiZYuXcqIESMYOXJkre/Jyy/Gysqcdm1b1RjQ6evGkkwTuWmjx6uUlJRJu7atDDaecO8TwYBgdEqlkkuXKlrK3onbBJV6BHkRtvd0tex+Q7u5lPBGVcFA12Dy8oq5mlN0y1aCIZiZmeDgaENebsPKABtCKpXh7hGEu0cQV7OTSTx7iNSUaFKSY6t+bmtrWxa8uIQuXXs22bxeffVVNmzYwMmTJwGYNm0a//77L66urjW+/syZit9jV1c7TE1lJKdm13hoU31p1NeDwsqkRkMQ/QoEfYltAsHoKssKHRwccHR0bObZ1M7GxgL/Tm2Neo0rGXmo1bcGG4WFOeTmXkEikYLMhQvJmUYJBCpZW5lhbVNzXb+xOTl7MWLkM3h6VW+5rFAU8sXnb/J/v31Dfl7dT92GOP3w5u2C7OxsnnnmmRrHLihUculybtV/OzhY4+fTutaDkuqjskmRVCpDeu1AJENJEmWGgh5EMCAY3Z2+RXCjjn5tsLOzNMrYJSXlZGdXLyXU6XQUK0s5ffoYAG6tvZDLjH+Tlkgqjv41M2/6xcHConR+/fkdUpJjkctNeOLJuUyZ+izOLq0pKipg/d9rmT17PMuXvU9KSu0tpw11EnLXrl15++23q/57+/btLF++/JbXnT17+ZavWVub07Fjmzr7KdSmqkmRAVcFKol+BYI+RDAgGN3dFAxIpVJ6BHUwytiVXQkBysvV5OVfbxJ08dqpgzc/LRtTZYWBTN40HwM6nZb4uDC2b/6CosIc3Nza8f4H3zB23BM8NPoxvl76OwteWkLHTt3QqNUcPLCdV16aynvvzOfE8fBaDwcyhFdffZWePa9vT7z44ovExsZW/XdxcQlp6VdrfK+FuSmdOrZt0AFWhiwrvJnoVyDoQ+QMCEZ3J5cV1sSplQ0+3m4GPc2tsFBJXn4xyuJSFMUllJVeTxzT6bRkXEkEwNOz6YIBAJmsIqHwSkYeGLGrs0pVROSRn8m4chaA++8fzvSZL2Nhcf2MAZlMTmjoIEJDB3H+XDxbt/4fkRH7iY09QWzsCVq3cWfUqEfoP+BBzM0tDNokSS6Xs3btWnr27ElZWRllZWVMnjyZY8eOYW5uztnEy7e9nomJDD/f1te2d1T1vq6hywpvlnQhE+8ObkYZW7i3iJUBwejuppWBSl0C2mNhYZjsbkVxCdExKVy6lFvRJKi0elVAfv4VSksVmJiY0bZd0wdMJnIZLk62Rhs/48pZdm77mIwrZzE1NWPW7DeY/9zb1QKBm/n4dub5F95j2fI/GTP2CSwtrblyOY1v13zK7Fnj+PWXVWRlGnZPvEuXLlXbBRKJhH///ZfXXnsNlaqMlNS6n7BlMik+3m7VDieqizFXBkD0KxDqT6IzZHgtCDVwd3cnPT2dI0eO0KdPn+aeTr1dupzLkYizDXqvRqMlN0/B1atFZGblk5dbXOtrE+L3EXNyMx28u/Pwoy83dLqNVqRQ3TJPnU5HXu5FcnPSKCjIQKMpRyYzwc7ODcdW7jg4tqu1u59WqyH29E7iYvcAOtq08eSll5fQrr3+R0CrVMUc2L+d7dt+JzOzYu9eLpfz2GOP8cILL9CjRw+9x6yJWq2mT58+HD9+vOpry1esxdnFT69xLl/O5Uo9ehdcvJjILz++h6tbW5Yu+1Pf6dZL+3atCO2t3/yFlkcEA4JRqVQqLC0rEvKys7Nxcmqeo38b6kjkWS5dyq37hdcoFCVczSkiP0+BRqtDq9Vy+UoeWk3t/8z2711FxpUzDB76BMEhDxpi2g2i1WrJyy+mWFGKVqsh6VwESefDycu7gkwmo0MHH2xtbSgsLOLChfNoNBocHFrj7dMXb98+SKXXs+GVxfkcOfwj2dkXAOgVPJTnnn8DM7PGJUdqNRqOnzjMti3/R0LCqaqv9+/fnwULFvDQQw9VtSluqLi4OHr06EFZWcUZ//b2jnzy2Y/Y2elXCXP1aiFp6Tm33V5IS43nt18+oG07T7748tdGzbs2UqmEkSN6GGylS7g3iW0CwaguXKi4GdjZ2dGq1d13CEpgd09MTG5/c1GrNWRmVTQJOpt4mZycIjTXas8LCpW3DQQ0mnKysypKL5s6X+BmUqkUB3trlMVZ7Nn9JSdPrGfw4PsICwujqKiIxMQzHD8eRWLiGYqKiggLC2Pw4Ps4eWI9e3Z/SX5+RYvqSxdj2bHtY7KzL2Bqas7osXOZO39howMBAKlMRkjIAN5dvJKff97I5MmTkcvlHDp0iHHjxtGxY0eWLVuGQtHwMxQCAgJ45513qv5M8vNzWbniQ71zFJycbPHu4IrsNicWqitzBoy0TQCiX4FQPyIYEIzqxnyB2paT72SWFmZ07eJe4/eKFCqSkzM5HZvGxYu3NgkqV6spKiq57fjZ2cloNOVYWdnh5NzOYPNuqIvpZ9i5/XOcnaw4evQof/31F0OHDr3lzH4LCwuGDh3KX3/9RWRkJM5OVuzd/RWHD/3AoQPfUlamxM3Ni2nPvE+//sOxMkKraP/OXfnll19ITk7mtddew97enqSkJObPn0/79u159dVXSU9Pb9DYL7/8Mr169UKr1SKRSDh5Ipyw3Rv0HsfOzhJf39bIawkotUbOGah0ITnTqNUYwt1PBAOCUd2NyYM36+DlWpUUVl6uISMzn9jKVsF5xbWeQJefp4Q6HiYzK6sIvLo0e7CUnZXO+r8+o2/fvhw/fpxeverXICg4OJjjx4/Tt+99XL5UUY7XK3gET0xZhJNzG9q2Me5BU+3atePDDz8kPT2dZcuW4ePjQ35+Ph9//DFeXl5MnjyZqKgovcaUy+W88+4nyOUmVSsC69Z9zcX0ZL3nZ2VlTie/NpiZ33rDV6uNW01QSfQrEOoiggHBqO62ssLatGvjSHJyFv/GpnHpUi6ltbQKrlRSUlavvvKVpXZNeb5ATTQaNTu2f4OXlxebN2/Cyqr2TP+aWFlZsWXLZry9vWnVyo2Bgx9DLjfBzc2+zm2Whrp51d7a2pq5c+dy9uxZNm/ezMCBA9FoNPz222+EhITQr18/1q9fj0ZT90E8Go0Wrc6GRx79D1BxQmB5WRlfffUO5eV1/73ezMzMhE5+bbCyqr5CotU2zcoAVPQrEITaiGBAMKq7eWVAqSwlLj6d7TujOfVvKmZm8nruG+vIy6+9eqBSaWkxubkXAfDwDGjkbBvnVMx+MjNS+emnH/UOBCpZWVnx888/k5eXxamY/ZiZm+DibGfgmV5X29+FVCpl9OjR7N+/n5MnT/LUU09hYmLC4cOHmThxIr6+vnz11VcUFRXV+H6A1NRsSkrKGD1mMj4+ndFqNcjkclJTzvHbr6uqzeHChbOE7d7I9999zqqVH/L9d58TtnsjFy6crTZHubziLAL7G064rCotNPLKAFzvVyAINRHBgGBUd1swoNVquXQ5l3/CE9i24yTxCRdRKit617u5OWBew1LvzRSKUsrL6n76zMw4B+ho5dQWG5vm69mg0+mIid7L+PHj6701UJvg4GDGjRvHqei9tG3jYNB2vw0RFBTEjz/+SEpKCm+88QaOjo4kJyfz/PPP065dO1566SVSU1OrvUer1XImsaIhkUwmZ87chcjlJlVHB2/d8n9En4xg186/eWnBk7z2ytN8/91nJF+IpbAgg+QLsXz/3We89srTvLTgSXbt/LtqO0AqleLt7Yazc8W5DpWNippiZQBEvwKhdiIYEIympKSEtLQ04M7fJlAoSvg3No1tO6I5EnGWjBpqxKVSCe7tb18aqdVqyS+oe1UA7pwtgszMFLKzLjJr1iyDjDdr1iyysi6Sn3vJIOPVRp/c/jZt2rBkyRLS09NZtWoVHTt2pLCwkM8++wxvb28effRRIiMjAbh4MZfi4tKq97Zr78Wjj00HrvcQ+OzTN/jh+y8ICelRVW1x5kwCUVHHOHMmoaraIiSkBz98/wVvLpxBWlpS1Zju7Z1o29axasvCmNUENxL9CoTaiGBAMJrk5GR0Oh02NjY4Ozs393RuodFoSU+/ysFD8ezYFc2Zs5coKbn9frCNjQVOTrWfMFdQqLptKeGNMjOa5wjim2VcvoBMJqNv374GGa9v377IZDKSkhIMMl6tGnBEiqWlJTNnziQ+Pp5t27YxZMgQNBoNf/zxB3369OG+++5j9ZofqpbvK40e/Ti+vgGo1WpkMhmenh56VVuYmUp4a+FM4uOiq17j5mqPrV1FDkFTrQyIfgVCbUQwIBjNnVpWWFikIuZUCtt2nCTy2Dmysgv0en/bNo41JsWVqzUU1XNPVlF0FYUiB6lURnv3Tnpd39CuXr2Et7fPLTe0hrK0tMTHx5f0BmTeNxWpVMrIkSPZs2cPMTExTJs2DVNTUyIiIvjg/Vd4dt4jbN3yG8riivMKpDIZ4ydMQSaT0b9/f06ePKlXtUVUVBT33deHj/73crUVAlOTio9gUzPDl17WJumCSCQUbiWCAcFo7qR8AbVaQ0pqNvsPxrJrdwznzl+htPT2FQG1kctltGt36wFK+XnF9V67rtwiaNPGGzMzw9yEG6pcXYaNbf3P068Pa2trSktvf8ZCYxnq7NTu3bvzww8/kJqaypNPzcTG1p7s7Ax+XLeU2bPGsfaHr7hyOY2//voBX19ftmzZ0qBqi02bNuHp6cHK5UuqcgjU13IGPD1cm+yEQNGvQKiJ6FooGM2dUFaYn1/MheRM0tKvGnSv1NHBmtxcBQUFSqD+pYSVMiq3CLy6GmxODWUiN6WosPbM+oZQKBS4uDb+xMHbMfRJ6hKpBWPGTmXEiMc4dGgn27b9zqWLKWzf9jvbt/+BVCLh6NGjjaq2WLduHaGhoezds4kHRkysCgasrS0ZPKgLh8PPVP1OGdP5pAycjNicSrj7iJUBwWiaa2WgvFzDhQuZ7N33L2F7T5N0IdMoSVPu7Z2uZcvXr5SwklarvVZJ0PzJgwB29s4kJZ1HpTJM2ZlSqeT8+XO0b0BDouZ05kxFwqOpmRlDh43l8y9+4Y2Fn9OtWzAyqZRx48YZrNpi9+716HS6qjMLzMzMsLQwY9CAAKOWY1a6dDlXr+BVuPeJYEAwmqYOBnJyizh+Iomt245zIvoCuXkNP5++PkxN5bRp41jvUsJKebkXKStTYmpmQes2HYw4w9rpdDoupieybctqDu7/HY1GQ3h4uEHGDg8PR6PR4O3tb5DxamPIlYGc3KJbckckEgmBQaFMfnIOGo2G2bNnG+Ras2bNIj0tmZTkxKrtAlPTii0CExM59/ftVGfVSmOJfgXCzcQ2gWAUZWVlVfXbxtwmKCtTk5qWTXJKVpMsr96slaM1Sj2fsDIyKvIFPDw6V+v01xSUxYXExh7mdMwBcnIuV33d1MycVatWMXTo0EZfY9WqVbR398LT6+5pm1u5KlCTpPMJRqu2uHFloJJMJiUk2AdLSzPOnDVeeeaF5Ew6dWyDVCqeCQURDAhGkpycjFarxcrKCldXV4OPn51dSHJKFhcv5aDRNF8DlozMfOztLMkoKdMjebBpSwp1Oi0pKXGcjjlA4tnjaLXXattNzOjk35tugQPJykhlw4afiIqKIjg4uMHXioqKYuPGjTz9zAtGryAx1LpAQYHytuf2p6dfwMfH1yjVFjevDFSSSCR07eKOhYUp0THGqcqo7FfQru3d101UMDwRDAhGYYyywtLSclJSK1YB6lvCZ0wlJeVkZRViairHxsaCosK656RWl3E1u6Kts4eXcY8gLirK5d9Thzh96iAFBddry93cvOgeOBD/zn0wM684Grd16w7Exx9m6tSpREVFNShJrri4mKlTp+Ll5cfQYWMN9nMYW11P32VlpdjYGKfaQl3DysCNfLzdsLAw5eixc0YJepOSMkUwIAAiGBCMxFD5AjqdjsysApJTsrh8ORdtLR0Cm8OlyzlV+9Z2tpYolaVo1Lf/wM7OSkKr1WBj2wpHx9YGn5NWqyHpfAynTx0g6XxM1fzMzCzpHHAf3QMH4urmecv7Wrd25PkX3mHRmzMZO3Ysmzbp16youLiYsWPHkpKSyuIlq5HJjP/RYoicAYWihPSLObd9jamp2W37GDTsuhXVFoqiwmvXqL2ssG0bR/r368yRiLMNLoetTWW/Alub5i1vFZqfCAYEo2hsWaFKVUZKahbJKVnVjoa9UxQWqsjPv56jIJVKcHSwJjv7ev22TqcjL/ciuTlpFBRkoNGUk5uTDoCri7tB55Ofl8XpUwf49/QhFIr8qq+3a+dH96BBdOwUgonJrU+fUqkEd3cnWjnaAE68+tonfPS/lwkODmbdunX12jKIiopi2rRppKSk8uprn+Du7m3An+w2DBAXnjl7qc6gon37DoTt3oBKpTLIVkFltcWAgWPIyKhoVFXbykAlp1Y2DBoQwD/hCQb/95CUlEFQ4N1V+SEYnggGBKNoyMqAVqslM7OAC8mZXMnIN3gduaHodDouXrr1adLCwhRLKzMURUqSzkWQdD6cvLwryGQyOnTwwd7OBgkWFBRIOX8+mh++e53AoCF0DxzUoCdptbqcc4knOBWzn9SUuBvmYUOXbv3o3n0grZza1Pp+MzM5HbxcsbS8fiPqHBDE4iWrWfrVu/Tu3Ztx48YxZ84c+vbtW+1GqFQqCQ8PZ/Xq1WzYsIGgoCAOHfqHjCxdVWOnO51SVUpqWt1H83r7+FdVWxgiwfLGaouIiP3A7VcGKtnYWDB4YFfCj5wxaKVMSmo2XQLcjdZqWrg7iGBAMAp9ggGlspTklIpVgLuh9vlqTlGt81SX57F39ypycy8yfvx4Zs2adcuNVKVSER4ezqpVq9iw4Sdi/z3EgyNn4OzSvn7Xz77EqVP7ifv3MCpV5U1BgqdXF7oHDsTXr2edwYWtrQVeni7I5bfeANzdveke2JvU1PPs2rWbDRs2IJPJ8PHxxdraGoWiiHPnzqHVavH392fp0qVMnz4dExMT8vOL2X8gFnUTJHU2NlhMTLxSr20nLy8/2rf3Mli1xcqVK2nTxh1PL7+qQ4fqWhmoZG5uwoD+nYk8eo4rGbUnPeqjsl+Bdwc3g4wn3J1EMCAYXHl5OSkpKUDt2wRarZbLV/K4kJxFZmZ+002ukTQaLZcv1/whnJaawPq/PsPLy4sdO47WekBNZROboUOHEhUVxZQpU/nlp/eYMGkB7h411+aXlZVw9swxTsXs59LFc1Vft7Z2oGv3/nTrPgB7e5d6/Qxurva0aeNQa2JnWWkp+/ZuAWD23IW4OLcmKSmB9PRkSktLcHHx4tKlyygURSxbtozBgwdXvdfe3oqQEF+ORJyt11waozGxQGlpOcnJ9TujXyKRMPyBCfzw/RcGq7aQSKT88vOKqiOb67MyUEkul3FfHz9ORicb7KyApAuZIhho4UQwIBhcSkoKGo0GCwsLWreuniRXVKQiOSWL1NRsSgycDNUUrmTkoVbfesBQdlY66//6jL59+7J5c/2T74KDgzl+PIoxY8ay/q/PeeKpRdVWCDKuJHMq5gDx8UcoK62oVpBIpPj4BtGt+0A6eHer91kFMpkUDw9nHOxvP7fDh8NQKApxdnYjuFc/pDIZXh06Vn1fLpNiZyfn//7vN/bt21ctGICKhLcuAe2JjUuv17yaw/mkDL1WL4YMHcv+/dsaXW0xZcpULC2tKC5WsHnTL1V/dzKZfkv0UqmUXj29sbQ0Iy6+8X/Olf0KxBHFLZc4bUIwuJvLCjUaLWlpVzlwMI6du2M4m3j5rgwESksrSglvptGo2bH9G7y8vPQKBCpZWVmxefMmvLw82bF9DcriQk6eCGPtdwtZ98NbxETvpaxUhb29C/0HPsLseV8xYdIL+PgG1TsQMDc3oaNfmzoDAZ1Ox44dfwLwwIhJSGu4Sfn7t2P48GEA7Nmzp8Zx/Du1M/operoGZhCWl6s5d/6KXu+Ry+XMmbuQlJRUxo4dS3Fx/Y+fhuvVFqmpqbzz3kpefe0T2rb1qDrzYfbs2WzevFnvrY/O/u0I7uVz7VjsxjmflNHoMYS7l1gZEBpNp9MRHR1NVFQUcXFxHD9+/Np3JPz2f1uwsHQ1Sm+ApnbxUk6NH9anYvaTmZHK5k2Na2Lz448VTWyWL51fdZOQyeT4dexFt+4D8fDsjESif/xuZ2eJl6cLMlnd701IiCE15RxmZuYMHvJQDfM0w9enNZYWQ4CKZe+CggLs7G49T79njw4oFCVGOxa6odsEF5KzGvT76O7u3eBqi6lTp1ZVW3h4eOPhUZGXMWvGGAoL80lPT2fs2LEMHDiQzz77jB49etR7Xp4ezpibmxARmVjjqlV9VfYraKruicKdRawMCA1WXl7OihUrCAgIoGfPnsydO5c9e/ZQVlaGt7c38fFxTH58DM/Oe4xdO/+uOm3tblRUVL2UsJJOpyMmei/jx483SBObsWPHVpQptmrD4KFPMmf+UsaMm4enV5cGBQJtWjvg3cG1XoEAwI7tFasC/fo/gLX1rUvG3bt5IpNJcXd3x9fXF61Wy8GDB2scq2JvuyPm5nfOzUWt1pCYeLnuF9aistqirExHaGgoEydOZM+ePbc0eVIqlYSFhTFhwgRCQ0MpK9OxeMlqOgcEVb1GLpdjYlqRODh16lTMzMw4cOAAPXv2ZMqUKaSn13/5383VnkEDAhr1Zy36FbRsIhgQGiQ2NpbQ0FDmz59PQEAAYWFhFBUVER8fz/Hjxzl//jxFRUWEhYUREtKDH77/gjcXziAtLam5p643nU5X68E0mZkpZGddZNasWQa51uzZs1Gr1YweM5vgkBFYWjbs5DuZTIqPtxutW9eeKHizq9kZRB37B4ARD0665fsuzna0beNY9d9DhlSsDuzdu7fWMS0sTOl7X8d6ByN6acDSQGpa43NV3N29WbzkG55+5gWioqIZNmwYNjY2dOrkT69ewXTq5I+trS3Dhw9ny5YtODm34d3Fq2o8f6GymmDBggWcPXuWyZMnA/DTTz/h5+fHm2++We8Dj+ztrRgyqAs2jThA6EJyJlpt8x3vLTQfEQwIejt48CChoaGUlJRw9OhR/vzzT4YOHXrLgSyVWfN//fUXkZGRmJlKeGvhTOLjoptp5g2Tc5tSwozLF4zSxCYjo+Hn0VtYmOLfqS12dpZ6vW/37g1otRq6dOl5y41LIpEQ2N2z2tfqEwwAODpYE9zT8AcR6RsLaLVazpxt+KrAjeRyOQ+MmMinn//MRx//wH/++yIdvLtiZ9+aDt5d+c9/X+TlVz5CIpGSlXmRHTvW1ziOuvx6aaGHhwe//PILx44do1+/fpSUlLBkyRJ8fX355ptv6rWyZmlpxuCBXXByalgQWdmvQGh5JLo79WQX4Y5UuSIQGhra4CNrjxyJYPGS1U13Ul0jaDRaYuPSa92L3bP7R4oKUzl79ozBrtmxYydsbD0YOnyK3u91cLDCw91Z7yfxstJSZs0ci0JRyMuv/I/gkP7Vvu/dwZUeQdXbLefk5ODs7IxOp+PKlSu4ud2+NC0uPp34hIt6zet2XJztGNC/c71fn5KaTdTx8wa7fn1s3/Y7a3/4ClMzcz777Cdc3dqi0+lITk4k6XwC33/3GRqNhqlTp9KnTx+Cg4MJCqrYSti4cSOvvPJKVUJuQEAAn3zyCSNGjKhztUej0XLs+Hku1nHUck30/XMV7g1iZUCol7IyNfEJaUyY8Aju7u56BwJQkSS3adMmPD09WLl8yV2RQ1BbKWGlcnUZNraGb2JTrtbv8CWJBNq1daSDV/3zA250+PDuinJCl9b07Fl9lcPUVE5A51sPRGrVqhWBgYFA3asDUJH53ratY52vqy99nmN0Op1R2wHXZsSDD+Pv352y0hK+/noxO3f8xUsLnuS1V57m++8+w9PTk6CgII4dO8bcuXPp2bMnAQEBrFy5koceeoi4uDi++uorHB0diYuLY+TIkTzwwAOcPn36tteVyaSEhvji51v7CZS1qexXILQsIhgQbisru4Cjx86xdfsJPv/8a5KSzvLjjz82Kmt+3bp1JCcnsnfPJgPP1rBqKyW8kYnclKJCwzexMZHrdwiNj3drXF3tG3S9inLCvwB44IGJt5QTdvZvh5mZSY3vrTyRrz7BgEQiIaSXD/Z1lDcaw6XLuc3S6VIqlTJ7zkLkchMuJMWx9ocvCQnpUZVjc/78eU6ePEl8fHxVjk1AQADz588nNDSUxMREnn32Wc6fP8+LL76IqakpYWFhBAYG8t///pfLl2vf9pBIJHTv5kH3bp56zztJlBm2OCIYEG5RUlLOmbOX2LErmoOH4klLv4parWH3rvUGy5ofN24cu3evv2P7DwBcvJRb5/ycnNqSlHT+lmzyhlIqlSQlncfJuV29Xm9paYZ/p7bY2jY8aex25YS2tpZ4d3Ct9b035g3U5+9SLpfRt09HzGsJLvShzzkDZ840/apApdzcbKRSCd7e3hw9epS//vrrtjk2f/75J5GRkZSUlNCnTx8OHjyIg4MDn376KQkJCTzyyCPodDq+++47fH19effdd2977oGfb2tCe/vptWKUkpp9T5QDC/UnggEBqHg6zMjI40jkWbbtOMG/sWkoFCVV309OTiQ9PdlgWfOzZs0iPS2ZlOREg4xnaBWlhHUfLOPWpkNVExtDqGxi07p1hzpf26qVNR39WmNq2rjjQq6XE464pZywezcPpNLaPybuv/9+TExMSEtLIympfpUilpZm9OnT0SAH5dRHRmY+efX4uzSGtLQk/vfhS/Tr14+TJ0/WO5AODg7m2LFjhIaG8tBDDxEbGwtAhw4d+P333zly5AihoaEolUreeecdfH19+f7779Foar6Bt2/Xiv73+9f7d6WyX4HQcohgoIVTqkqJT7jI9p3R/BN+hkuXcmts3pJ0PsEoWfNJSQkGGc+QautKWBNXV0+cXdqxatUqg1x71apVuLi0w8XVo9bXSCQS3Ns74enhctsbdX1czc7g2LFDAIx4cGK177Vt44hbHVsPVlZW9OnTB6jfVkElp1Y29OzRuATS+i4qNdeqgFqtZsXyJXh5eTY4x2bjxo24u7szbdo0ysuvl0T26dOHI0eO8Pvvv+Pl5cWVK1f4z3/+Q48ePWo9FdLJyZZBA7tU61J5O0kX6te7Qbg3iGCgBdJqtVy6nMvh8DNs3xFNXHx6nW1n09Mv4OPja5B+7gCWlpb4+PiSnt7wEjpjyckpQqmsXwKfRCIhMGgIGzZsICoqqlHXrWxi0z1oSK3Z4iYmMvx8W+PsbJgz5Hfv3oBOq72lnFAqldCta+0ByY0qtwpquwnVxtPDmY5++ie4VarPtsTVq4VkX7193oex7N2ziZTkxEbn2Kxdu5bo6GjWrFlT7XsSiYRHHnmEhIQEPv30U+zs7Dh9+jTDhg1j5MiRxMXF3TKerY0Fgwd2qfNYarjer0BoGUQw0IIUF5cQG5fGth3RHIk4y5WMvHrv2ZeVlWJjY/is+cqubXcKjUard51198BBuLp5MGXKFL3PrK9U0cRmCq5ungQGDa7xNdZW5vh3aou1tXmDrnGzstJS9oRVJHE+OPLhat/z821T7+tUJhHu379f7wNrunZxp7Wbg17v0YehzhXQl06nM2iOzfjx41m+fHmN/17NzMx48cUXSUpK4tlnn0Uul7Njxw66devGrFmzyMys/oRvYWHKgP4B9Uo4Ff0KWg4RDNzjtFot6RdzOPRPPNt3RpNw5hIlJfqVrQGYmprV+yS0+lIoFJiZGebGZigZGfl6J07JZHIGD32Kc+fOM3r06AY1sRk9ejTnzp2nX/+Ha2w+5Oxsi59fa0xMDNdOpLZyQnNzUzp1bFvvcYKDg7G2tiYnJ4dTp07pNQeJRELvEB9sbfU7IAmgrvzB/PxirmQ0zwE6hs6xmTlzJvHx8cTExNT6mlatWvHVV18RFxfH+PHj0Wq1rF69Gh8fHz744INqSa4mJjLuv68jnp63b3td2a9AuPeJYOAeVVik4tTpVLZuP0nk0UQyswoaNV779h04f/6cQbPmz58/R/v2XgYZzxBKS8sb9Oek0ag5fGg9Go2aQ4cO0atXr3pvGURFRdGrVy8OHTqERqNm+7ZvuJp9fY9bKpXg4eGMe3uneh8rXB86na4qcfDmcsKuXdwxMal/S10TExMGDBgA6Jc3cP39cvr26Vhr+WJt6lrVao5zBSoZK8emPr9Xfn5+rF+/noMHD9KrVy8UCgULFy7Ez8+Pn376qWr1RiqVEtzTm87+tVeuiH4FLYcIBoxEp9Nx8uRJVq9ezbPPPsv06dN59tlnWb16NSdPnjRKSZ1arSE1LZv9B2PZtTuGxHOXKTVQq2BvH3+jZM3v27uV8MNhlJXdPmehKVy6XHcp4c10Oh27d/5AakosJiZmPDRmDgWFZfVqYjNx4kRCQ0MpKCxj4iMv0apVGxRFefzy03tcungOU1M5fr5tcGpl2O0ZuFZOmHr+lnJCRwdrPNz1bz1c36OJa2NtbU6f3n4GqzAoKlLV2k+iKRgjx8bPz6/GPIDa9O/fn6NHj/Lzzz/Tvn17Ll68yJQpUwgJCanWXCqgc3t69uhQa7B5ITkTjUbT5J9nQtMSxxEbWHl5OWvWrGHZsmUkJFQ8Hfj5+WFjY0NRURGJiYloNBr8/f2ZN28e06dPx8SkcTXXBQVKLiRnkppmvNpgnU7HSwueJCSkB3/99Vejx5swYQJbtmypOoXQ2tqW/gMeZPCQh5rlmOKiIhWJ5/TrcQ8QeWQzBw/8gUQiYeLDC/D2CUKjUXMqZj8x0XvJzrqITCbD29sHa2trFAoFSUnn0Wg0uLi0o3vQELoHDkImk6NSFvHXn59x+dJ5TExMeWHBEnoFG+bJ8mafffoGRyMPMHTYOGbMfKXq64MGdmlQ8HH69Gm6d++OpaUleXl5mJo2rHveheRMTpy8UK/X2ttbMWxItxq/F3UiiZRmfKJdtfJDCgsyiIo6ZrAxQ0JC6N69+y2JhPWhUqn46quv+OCDD6q2+8aMGcPHH39Mx44dAcjIyKtog6y5nvehVqvZu2cThw5u4dy5xCb5PBOahwgGDCg2NpapU6cSExPDhAkTmDlzJn379q32dKBSqQgPD2f16tWsX7+ewMBA1q1bR5cuXfS6Vnm5hvSLV0lOySI31zj94m+2a+ff/PD9F0RGRtarj3ttoqKiCA0N5eFH/oNGo2H//m3kXL2e5OTrF8CQIWO4774hmFs0YC9ZTxVH1V6us6LiZgnxkWzeuAyAYcOn0qPXsFvGzcpM5cqVC1zNvki5ugwTuSlOzu1o3boDLq4etzyNlZWVsGPbSs4knEAmkzF77kL69x/RuB/wJlezM5g7dxI6rZZPP/+pKvhyb+9E7xDfBo2p1Wpp3bo1WVlZHDx4kP79+9f9plrEnErm3Pm6E9fs7CwZPrT7LV9XKkvZsSu6xhLZpvL9d5+TfCGWM2cMVzrr6+uLubk5L7zwAr1798bf31/v0tKsrCzeffddVq9ejUajQS6XM2vWLN5++22cnJzIzVMQHn6GktJy0tKSWLF8CSnJiYwfP4FZs4z3eSY0PxEMGMjBgwcZNWoUHh4erFu3rl4ZxFFRUUybNo20tDS2bt1ate96O7l5Ci5cyCT9Ys5tz8w3BrVazZsLZ2BmKiEqKqpB5VLFxcUEBwdTVqbj/Q++QSaTo9VoOHXqGHv3buHE8X+qDk4xN7ek7/1DGTJkDN4+/gbdM7/R1ZwiUlP1O2Dl4sVE/u+XD9FoyukVPIIhw55s9Dwq8wNsbcxZuWIJ/xzaBcDUac8x6qFHGz1+pV9/WcnGDT/RpUtPFr2zFAC5TMoDDwRiaVG/GvSaPP744/zf//0fixYt4t13323wOFqtlsNHzpKZmX/b19UWDNQ3mDCmsN0b+f67zygqKjLIVoFSqcTGxqZatYaNjQ3BwcGEhITQu3dvevfuTevWres1XkJCAq+88gpbt24FwM7OjoULFzJ//nzUalix8mfeXvQsXl6e/Pjjj0b7PBPuHCIYMIDKTn59+vRh48aNenfyGzduHJGRkURERNQYUZeXq0lNq1gFqM+peMaUlpbEWwtnct99fYzStTA/L4eDB3ewb+8WrlxJr/q6u7s3Q4aOoV+/B7C2MUyNPVSUEsbFp+u1vZKXl8lPa99BpSrC168n4yY81+jDf8zMTPDu4IqFRcXyular5cd1S9m+7XcAxo2fwuOTZzY6IKqtO2FA5/a3TSSrj2+//Zbp06fTt29fDh8+3Lh5lqnZt/9fihTVS09v7PiXmZmOi7MVFhYWBAQEEBwcjL9/F3buiq621N0UtFotlhZmuLrZ4+ZiT0bGBXr37k1YWFhV6WVjhIWFMXz4cKZMmUJKSgrHjx9HqVTe8rr27dvTu3fvqgChZ8+et/03um/fPl588cWqKgVPT0/mzJnDu+++2+DOpHV9ngl3JhEMNFJ5eTmhoaGUlJRw7NixBj8th4SEYGFhQURERNWe29WrhSSnZHHxYk6Tf7jdTnxcNB/972U8PStWQeqzZRAVFcXUqVNJSUnl1dc+oXNA0G1fr9PpSEiIYd+eLURE7qO8rKK8ycTElN69BzJ46GgCAno0+uZ46XIuGRn59X69SqXg53Xvkpt7BTc3Lx5/ciGmpo0rj7S1tcDL0wW5vHoGv06nY9PGn/j1l4rTDQcPGc30GS8jkzW8vHDf3i2sWvkhzi6tWbr0D6QyGVZWZgwf2v2W6+srOTmZDh06IJfLyc3NbfS5FEVFKvbu/5fyck3V3vXuXetJT09GJpPh6+uLra1ttb1rb29fBg4aw5ChY5HLDVeGWRONRkOrVra4udrTto0jjo7WVd/T6XQEBAQQEBDAn3/+2ehrTZo0iYSEBGJjY5FIJKjVauLj4zl69ChHjx7l2LFjxMXF3XLOg0wmo0uXLtVWD/z9/ZHdUD2i1Wr56aefWLhwIZcuXUImk+Hj48OJEycM+nkm3NlEMNBIK1asYP78+Rw9erRRh4tU7qN/8cWXPDBiIskpWc3SZa2+0tKSWLl8CcnJiYwbN47Zs2ffsp+oVCoJDw9n1apVbNy4ES8vP2bPXah3gqBCUcjhf8LYu3czqSnnqr7u5taOwUMeYsDAkTg46J8BX1paTnzCxXrvLavV5fzx20ekp5/B1rYVT017B2vrxh2Y09rNntatHW4b1Ozds5lvvvkYnVZLcEh/nnv+XUxN9V/O1+l0vPLSVFJTz/PkU/MYM3YyAH1C/WjXtlWDf4YbdejQgeTkZLZu3cqoUaMaPV5GZj6//raN5cvev7Z3PZ5Zs2bVune9atUqNmzYgKeXH3Ma8Lt2OxqNFlMTOS6udri52uPe3um2Z/1XfjYYKsdm6dKlzJkzp9bXFRUVceLEiarg4OjRo1y6dGt5pbW1Nb169aoKDnr37k2bNm1QKpU8+uijbNu2jWPHjhnk86yuOQt3DhEMNIKho/+JEydx/Hg0n3z2k9H2xw2ppqc1Hx/fqqz5c+cSryWWtWPkqEcb/bSm0+m4kHSGvXu3EH54NypVxTKpVCqjR8/7GDp0DN0De9f7yflCciZ5efXbdtHpdGzbspq42MOYmlnw5FOLcHZp3+CfRSaT4unhXO92vseOHeSrL96mvLyMzp2DeOXVj7C0sq77jTeIj4/mnUVzMTMzZ+XqjVhb2+LibMeA/p0b8iPUaPr06Xz77be88MILfP75540e7+DBg4wcOQoPD3e99q71WYW6nbJSNQ6OVri62NGubSu92kQbetUwMjJS738/ly5dqrZ6EBUVVeOhWG3btiUkJISIiAj69u1rkIqhm1czhDubCAYa4eTJk/Ts2dPg+4IfffwDXh06GmCGTUOn05GSnEhSUgLp6cmUlpZgZmZOXOwJ0tIuMPmJ2Ywb/5RBr1lSoiLiyF727d3C2bP/Vn3d0dGZgYNGMXjIaFxcak+mUihKOJtY/6NqD/+znvB/1iORSHn40Zfx6tC1wXM3N6/IDzA316/8Lj4umo8+egWVshgPT18WLvwce4f6P9HfXE4okUgYOrhrvQOS+vj999957LHH6Natm96nEd6ssbk4deWn1KS8XINUKsHV1Q5XFzs6eOn/93Sj2NhY+vTpQ2hoqFHyifSl0Whu2V6IjY2ttr1g6M+zkydPEhTU8IBMaBoiGGiE1atXM3fuXINmDNva2vKf/77I0GHjGj/BZrZzx198/93nBHTpwdvvLDPadS6mJ7Nv3xYOHthBUVHFCYISiYSuXXsxeOgYgoP7YWJy/QNd31LCuNjDbN1csW//wIP/ITBoUIPnam9vhaeHs1695W+UkpzIkiULKMjPxdW1DQvf+hI3t7oT/24sJ/zsi59p374D3h1c6RFUd6tkfWRnZ+PiUnHEbWZmZtX/1pehnqorK1cWL/mmxqdqnU6HqqQMezsrXFzsaN/eiXZtHBs059ocPHiQhx56CHd3d9auXVvvHJumysxXKBScOHGCr776is2bNxv882zFihXMmDHDADMVjEmcQNgIcXFx+Pn5tYhOfg3RPbA3AGfOnKZEdWvms6G0a+/FlKnPsuqbTTy/YDHdugWj0+k4fTqKLz9/i1kzxrJu7VdcvPbnmpurqHcgkJ52hu1bKw556d3noUYFAm3bOOLdwbXBgQCAp5cfi99fhatrGzIzL/PWm7NISU6s8327dq2v6k7Yvn0HTExkBHRu+DZHbZydnenWreIgoP379zd4nDVr1hATE8O6desa1fFv3bp1JCcnsnfPpqqvl5WpKSkpx9bWAj+/Njw8IZSxo4Pp09vP4IEAwIABA4iIiMDCwoLQ0FAmTZpUx8mUkwgNDa1KwDN2iZ61tTUDBgygXbt2Bv880/fURKH5iGCgEVQqVYvo5NdQbm7tcHVtg0atJjbupNGvZ2Jiyn33DeHNRV+xbPlfTJg4DQdHJ4qKCti29XcWvPAEb74xk23b1lNWVvefcU7OZdb/9QVarYaOnUIYMPCRBs1LLpfi6+OGm5t9g95/Mze3dix+fzUenr4U5Ofy9ttziY+LrvX1ZaWl7N2zGbjenTCgc3u9ewHUV2OPJtbpdCxbtowJEyYYpOPfuHHj2Lnzb0CHi4sd99/Xiaee6M8DwwIJ7OaJpaXxm2V16dKFiIgIli5dSnx8PMOGDcPGxobOnTsTEhJC586dsbW1Zfjw4fz7byzvvvtBk5fmGevzrKYSSOHOI4KBRrCwsDB4J7/iYgVmZoaJzJubRCKhe2AoADHRkU16bRfXNjz2+AxWrFzPa69/QnBIf6RSGYmJ/7J182qWfz2PXTu+58qVCzWeq64sLuSv3z+lpKSYNm19GDV6FhKJ/v9cLC0rOgA2qCvfbdg7tOLdd5fj3zkQlbKYJe+/wLFjB2t87c3dCW1sLPDu4GrQ+dyoMhjYs2dPg94fHR1NQkICM2fONMh8Zs2axaWLKfh0sGBAv854eDgbZFx9mZiYMGfOHOLi4jh58iQrVqxg2LBhdO/enWHDhrFixQpOnjxJQkIcAwaNqVb+Z2ilpeXk5BaRmpZNXHw6R4+d42qOkoKCQoNeR6FQYGlp/FNEhcYzbiHuPS4gIIAVK1agUqkMtsd27tw5nnvuOR58IAiFQkWRogSFooQiRQnFxSUUF5feVU1BAgN7s3vXek6dOtos15fJ5PTo2ZcePfuSmZnB33/9TkzMfvLzsoiJ3kdM9D5cXNzpHjiIzgH3YW5hhVpdxvq/vyA/Pws7e2cmTHqhWs5BfTk6VjT9aeyBRLWxtLJm4Ztf8NWXbxN17BCffbqQmTNfZfCQ0VWvubE74YgRFd0JA7t7Gm1OUNEgRy6Xk5ycTHJyMl5e+nWmjIqKMlrHvzshkU0ikRAUFHTbuXh6uJCckoV3B7cGX6e8XF3x+VFUQpFChUJRgqK44vOkrEx9y+udndux5fzvBv08S0xM5Pnnn2/0WILxiWCgEYKDg6s6+Rki+7ayk1/v3r2xtjbH2tqcmz8KtFotiuJSiq8FCIpr/8iLFCV6n63fFAK69EAml5OZcYmMKxdxa924U+4ao1gpoXef0YSEjiIt9QynTx3g7JkosrLSCNu9jv37fsWvYzCKonwuXTyHmbklkx55CSsrO72uI5FA27atcHXR730NYWpqxoIX32fNN59UHShUUJDHuPFPIZFISIi/3p1w0OCHaO3mgJse5XENYWNjQ+/evQkPD2fv3r3897//1ev9xsjFudv2rtu3a0X4kTN4uDvf9jCo8nJNtc+A4uKSqgcIfTuW3tiZ1JCfZ405Y0FoOiIYaISgoCD8/f1ZvXq1Qf7xrF69ms6dOxMYGFjra6RSKbY2FtjaWHBz4ZxGo6VYWYqi6PqKQuXTQHMFChYWVnTq1I242JPExEQyovWkZpmHQlFSdaaARCLFw7MzHp6dGTpcQXzsEU7F7Cc7O534uCNV7+nUqTcW5vrV8svlMjp4uWBj03RbPTKZnJmzXsPW1oGNG37kt19XUVCQx5Sp89mxo2JVoF//Edja2tG9m0eTzGnIkCENDgbE3nUFH5/WnE/KwMfbrYabvQpFUQklBmpRDuDl5Uf79l6sWrWqyT7PhDuHCAYaQSKRMG/ePObPn09UVFSjTxnbsGEDS5cubfABHTLZ9UDhZmq1huLi0qplwqKi608TJSVlDZ53fXTv3vtaMHCUEQ82fTCg0+m4WEtvewsLa3oGD6dHr2H8c+gvIsKvZ52fitnPv6cP4eMTRLegQXh5db3t8rqVlRkdvFxveyqdsUgkEiY/MQtbW3t+XPc127f9Tnb2FaKi/gHgwZGT8PFu3WRBypAhQ3jvvffYu3cvWq1Wr20Jc3NzCgtb1t51bf8+o0+l0NrNvlEVKPUlkUgY/sAEfvj+izvi80xoWuKcgUa6E04Zayy1WlNtP/H69kOpQQKFlJRzvPLSVMzMzPl+7c4G7b83Rk5uESkpt+9KmJIcy5+/f4JWq6F36EM4OLpx+tQBLl86X/UaGxtHunYfQLfuA7Czq378sZOTDe3bOSGVNv8H36FDO1m5fElV98fOnQP530drGPFAICYmTfO7VVZWhoODA0qlklOnTlWVG9YmLy+PXbt2sWnzZjZv2kxJiQqFQnFP1bs3ZOWuuLiUgoJi2hih5LEmhupM2pyfZ0LDiL+lRjIxMWHdunX06dOHcePGNfiUsbS0NCIiIprlH45cLsPe3qrGk+iq9iSLS6vtTeqzJ+nh4YO9fSvy83M4e+Y0Xbo2rlxMH1qtlkuXcm/7muzsi2xY/xVarYbOAfcxYNCj1yohBpKdlc6pUweIiw2nqCiXI4c3cOTwRrw6dKFb90H4deyJp6crzk6G66TYWP37j8DCzJJPPnkNgLz8XNq1s2myQADA1NSU/v37s3PnTvbu3XtLMKDT6YiNjWXLlq1s3ryFqKijtzTZuRv3rmvM6bn2b0epLNM7+dfKyozsqwWUl2swMTFedUEluVzOnLkLeWvhTMaOHdvgroXN+XkmNIxYGTCQO/2UMWO4MVv5+qqCiuLi0lsCheXL3ufgge2MGfsETz41t8nmePlyLldu05WwWFHAj+veprDgKu3a+fHo5NeRy2+tv1ery0g8e4LTpw6QmnI9Ec3Gxp6Bg0YyeMhDtG3raYSfoGEqkwklEgk6nY7OnTuza9cu2rVrugTOTz/9lJdffplRo0axdetWiouL2bdvH5s2bWHHju1cvly9iU5AQAAjR45k5MiRzJ49my5duhil419jabValMqyJqv2KSkpI/tqEe3bGaaZVH00tDPp3fx51tKJYMCAYmNjmTZtGtHR0bV2V6vs5Ld69Wo2bNhAUFAQa9euvef6fpeVqSsCA0UpRQoVG9b/xVtvLcDDw4dPPvuxyeYQF59ea1fC8vJSfvt5CVeuXMDB0Y2npryNhWXdiWv5eVkkJBzmdMxB8vOv5yJ06tSdwUNH06fPYMzMjH+QTW1u7E44eszjHI86yJUrl2nfvj27d++mU6dOTTKP6OhoevTogampKX363E9EZDhlpdeXw83NzRk8eDCjRo1i5MiReHp6Vn2vqTv+3Uyn06FUlt6wnF+xbaZQqChWlta706WhpKVfxc3VvknzUap3Jh3P7Nkt9/OsJRDBgIGVl5ezZs0ali1bRkJCAjKZDD8/v6pOfpV91zt37szcuXOZPn16i+j3nZOTg7Ozc0XnwQsp2Ng6UnxTspSiuITyco3BrpmckkVurqLG7+l0Wjb+/TWJicexsLDmyanv4OhYv5puFxdb2rVthVarITo6kr17NnPy5BF015a5LSyt6NdvOIOHjKFDMzScio+L5p23K7oTbtn6Dx39XBg+fDhnz56lVatWbN++nZCQEKNcu7y8nMOHD7N+/UZ27NhBUtK5at/38PBg1KhRjBo1ikGDBtWaE9AUuTg6nQ6Vqqxajkzl035xcUmT3/Bvp6xMTUZmPu7t9W/V3RiVnUkP7N9MUtI58Xl2DxPBgJHodDpiYmKIiooiLi4OpVKJpaUlAQEBBAcHExgY2OKybHv37s2xY8f4/vvvefrpp2t8TUlJebV91qonsyIVao22xvfUpK6uhPv3/sqxo9uRyeQ8Nvl12rWv+6YtlUpwd3eileOtqwe5OdkcOLCdfXu3kJV1/bpeXn4MGTqG++8frnfL4dvR6XQkJyeSdD6B9PQLlJWVYmpqRvv2HYiI2EvsvycYPnw8Gzb8hqWlGVevXmXkyJFVSWHr169n+PDhBplLRkYGW7ZsZePGzfzzz4Fqp3JWblMMGzaML7/8En9//3r/3huq49++/Qfx8PC+nrB3w7K+Ro/fqeZ26VIujo7WWFg0bQIuwMgRQSQmJojPs3uYCAaEJrNo0SIWL17MI488wu+//673+1Wqsmp5CZWnqhUrSqoFCjqdjrOJlykurjlDO/rkXnbv/AGA0WPn0DngvjqvbWoqx7uDK5aWZrd9nVarJS72JHv3bubY0YOo1eXX3m9GaJ/BDB06ho6dujX4g7PySW33rvWkpycjk8nw8fHFxsaGoqIizp8/h0ajQSaT8d//zmHp0s+qntQUCgUTJkwgLCwMExMTfvzxRx577DG956DVaomKiuKvvzewe9cuTp+OqfZ9Z2fnqr3/S5cusWDBAvr378/BgzUfl3w7Dc3FmTp1Gqmpqbz++id09A/U+7p3IrVaw6XLuXi4N+1xyq1a2TB4oFj2v9eJYEBoMkeOHKFv3744ODiQnZ1t0LPXlarSqqe+80kZnIxOprS0nNLS8mrLvUlJp/j7j0/R6XT06z+J++4fV+fYNjYWdPByue1JcDUpKirg0MGd7Nu7uVonyjZt3Bk8ZAwDBo7Azq7+JWNpaUmsWL6ElOTEWnNSVCoV4eHhrFy5io0bNxAYGMi6deuq9nDLysqYMmUKv//+OxKJhK+//pp58+bVee38/Hy2bt3O5s1b2L9/L1evVi/V7NmzZ9Xyf69evarOFTh//jy+vr6YmJiQl5fXoOX+G3Nxxo4dy5w5c2rdu161ahUbN27Ey8uP2XMX4u7urff17mQZGfnY2FhgZXX7oNSQArt74utz8xFnwr1GBANCk1Gr1Tg7O5Ofn09ERAShoaFGuIaGnbtjUKmun49QVqampLScpKSzfP7Ji5SWqggMGsADI6dDHb/9bq72tGnj0KglUJ1Ox7lzcezbu4Xw8D2UllS0rpXJZPQK7seQoWPo1jUY6W2Co/i4aP734Ut4eXny448/1qubX23Z3Vqtlueee45ly5YBFSs277zzTrWfUafTERcXx59/bmB32C6ijkVWnVsAFUcODx8+nFGjRvHggw/i5lZzvoVOp8PT05O0tDR27tzJAw88cNs5l5aWV1Wm3JhPkl+g4P33XiA29kTVyoePj2/V3nXlikh7dy+GD5/AkKFj78myNq1WS1r6VTw9XJrsmg+N7NksWxNC0xLBgNCkHn74Yf766y/efvtt3nnnHYOPHxefTnzCxVu+npuTzRuv/5fc3GwCuvRg4cIvkJuYUFZWTkmJmtKyckpKyqtWE8rVGjzaO+HgYLh9fgCVqpjww3vYt3cL58/HV33dycmVQYMfYtDgh3Byqt5RMC0tiTffmEHfvvc1uO47MjKyWktcnU7H+++/z6JFi4CKzn6ffPIJu3fvYfPmrezbF0Z6elq1sTp16lT19N+3b19MTet3g3jmmWf44YcfePnll/n444/1bqBT6YXnHufSpVQemzwTWxs70tOTKS0twczMnPbtvfD29sfTy++e37vOzi7E3NykSU6TdHayZeCAAKNfR2h+IhgQmtR3333Hf//7X0JDQ4mIiDDo2EpVKbt2xdySaFiiUvL2ojkkJyfStq0Hi5esxtq69kOCbKzNCe3ti1wur5ZdXpnMaKha8tSU8+zdu5l/Du2iuLgi6U4ikRAYGMrgIaPp2et+AIOeCBcREVEt23vx4sVVAYFUKq128I+ZmRmDBg2qKv3r0KFDva95YwOd3377jVdffRYfX38++/xHvRvoAFy8mMKC5ycjl5vw7ffbsbTU/8/hXqHT6UhJzcbL0/irAz2CvBrVOVG4e9x762jCHa1ymfjYsWPk5ubi6Gi4Y1ZjY9NvCQS0Gg1ffvk2ycmJ2Nra8/obn902EGjt5kDvEJ+q0/pq6xxZXFxa4xHO+pwy5+HpwzP/WcCTT87l2LGD7N27mbjYk0RHRxAdHYGdnQPuHj6kJCdy9OjRBgUCAFZWVqxdu5bQ0FBWrVpFB28/dmzfzp49uzl79ky1n8vMzIzJkyczfvx4Bg8efNtrVh5jXVcDHXtHTwCSzp/h6tWr2Njo383x2NEDAHTt1qtFBwJQETDa2VqSX1CMvZ3x/iwkEglt2zTdQUdC8xLBgNCk2rVrR0BAAHFxcezZs4dHHnnEIOPm5BaRmnZr/4G1a7/i5IlwTExNeeW1j3FxbVPrGJ3929HZv12dy8xSqRQbG4sal2lvPn+++IZgobbz503NzLi/33Du7zecK1fS2b9vK/v3b6MgP5f4uJOMGzeuXjkCtxMcHMzYsWN56aWXKCu7nk8hlUq577776NixI7/++isqlYpTp07xv//9DysrK4M0uHJwcKJ9ey/S05OJiz1BaJ/Bes//6NGKSoTevQfq/d57kYODFSmp2djZWhptW8TF2RZzc3FmQEshggGhyY0YMYK4uDh27txpsGAg5lTKLV/bvu0Pdu74C4D58xfh51dzeZSJiYzewb60bu3Q6HncrnOkRqOtlhx3veZdVZXw2Lp1eyY/MZtHHp3Ozu1/8uOPS5k9e3aj5wUwe/ZsNmzYgJ2dHaNHj2bUqFEMHz4cOzt7FMUlTJw0mSefeISTJ0/So0cw7y5ehq2tYQ656dK1F+npyfz7r/7BQFbWFZIvnEUildLr2tZJSyeRSHB0tCYvrxhHR8PmtVRq14THHwvNTwQDQpN74IEH+Oyzz9i1axc6na7RTzZpaVdvOWnweNQ/rFv7FQBPPjW31huQra0l94X6NUkylkwmxc7WEjvbW1vpVj6BVyXUKUqIcnJAJpPRt29fg1y/b9++yGQyXljwOqNHP4xCUULE0ZQbViwsWPTOcpYsfp5Ll9J4+cVnWPjmF7h7NL48r2vXXuzY/iex/x7X+73Hrq0KdPYPxNau8QHbvcLO1pKU1GwcHKwMvjoglUpo11YEAy2J8ZtkC8JN+vXrh4WFBZcvXyY2NrZRY6nVGv6Nq571fiHpDF99+TY6nY6hw8YyeszkGt/brl0rBg/s0iSBQF3kchl2dpa0a9uKTh3b0qunN+ryPPz8/AzSxhfA0tISHx9fjh49QdKFTDKzCm7ZumjTxp3FS1bT3r0DeXlXeXvRHM4knGr0tTt3DkIilXLlSjpXszP0em9lMBDSWzS+uZlTKxuuXi2q+4V6cnVp2j4IQvMTwYDQ5MzNzRk0aBAAO3fubNRYieeuVLuhXc3O4H8fvkxpaQndu4fwzH9evOWpSSKR0K2rB316+zVJW9iGUqlU2NjU3ThJH9bW1pSWltz2NY6Ozrz73go6dupGcXERixc/x/Hjhxt1XUsra3y8/QH4V4/Vgfy8HM6ePQ1AcEj/Rs3hXmRtbY6qpOyW9s+NJbYIWh4RDAjNorKqoDHBgFJVytmz19vgKpXF/O/Dl8nPz8Hd3ZsXXlxyy8EzZmYm9Lvfn45+tScS3inMzMyrnfNvCAqFol4dFa2tbXnzrS/p0bMv5WVlfPrx6xzYv61R1+7arSIJUp9gICrqH3Q6Hd4+/recvyBUcHayJTu70GDjSaUS2rYR2zEtjQgGhGYxYsQIAA4fPoxCUXNnwbrExV0vJVSr1Xzx2ULS0pKwt2/Fa69/cksJmoO9FUMGdcHVRf/StqaiUJSQl6cgN0+Bj48fiYmJqFQqg4ytVCo5f/4c7dt71ev1ZmbmvPTyhwwYOBKtVsOK5UvYvOmXBl+/S9eKYCD23xP1Lr+sLCnsLbYIamVhYUpZucZgTZdauzlUldYKLYcIBoRm4evri6enJ2VlZRw4cEDv9+fmKUhJrSgl1Ol0fP/d55w6dQwzM3Nee/0TnJyrnw7g6eHMwAEBWFnV/VTclMrL1eTnF5OXpyAvT4GZmRwHB2scHazp378vGo2G8PBwg1wrPDwcjUaD97Xl+vqQy+XMmbuwKu/i55+W89OPyxp06JKfXxdMTE3Jz8/h0sWUOl+vUBQSG3sCgBBRUnhbLs62ZGUVGGSs9mKLoEUSwYDQLCQSSdXqwK5du/R+/42lhFs2/8qesI1IJBKee/5dOnh3qvqeVCohKNCL4F4+ejcaMgadTkdRkYqCAiUFBUrKytTY21vh4GCNg4N1tSeyoKAg/P39Wb16tUGuvWrVKtq7e+Hp5afX+yQSCU9NmceTT80FKv68VyxfgkZT+9HBNTE1NaNTp+5A/bYKTp48UtFvoL0Xbdq463WtlsbMzAStTkd5uabuF9+GXCbFzU1sEbREIhgQmk1lMKBv3kB6+lVycir20iMj9vHzT8sBmDrtWXoF96t6nbmZCQP6dcbHu3mPUy0tLaegUElBoZLCIhWWlmbY2VliZ2d525UKiUTCvHnzWL9+PVFRUY2aQ1RUFBs3bmT48AkNLkMbM/YJZs95A6lUxsED2/nk49frTEa8WdeuPQH493TdP8+xyMoqgoF6z7UlcnG2Iyu7casDbq0d7uikWsF4RDAgNJtBgwYhl8s5f/48SUlJ9XqPWq3hdGxFKeG5xDiWLn0PgBEPTuLBkdcPMHJ0tGbIkK44OdV+9LCxaLVaiopUFF77P52OqvMF7Gwtkcnq/89u+vTpBAYGMm3aNIqLixs0n+LiYqZOnYqXlx9Dh41t0BiVBg1+iJde+RATU1NOnghnyeIXUCjqn7zWtWswAHHx0bddWSgpURETEwmIfIH6MjGRIZNKb9vsqS5ii6DlEsGA0GxsbW2rDtSp71bBufMVpYRZmZf56H8vU15WRo+efZk27bmqJ17vDq4M7B+ApUXT9XwvKSmnqEhFUVFFfwJra/Oqkwgbc6SriYkJ69atIy0tjXHjxukdEFR2LUxNTWP23IXIZI1PDOvV637eeusrLC2tOXPmFG8vmkNu7q1HQdfEy8sPKysbVMpiLiSdrfV1p2KOUlZWiotLGzw8fRs955bC2bnhlQVyuQw3V3vDTki4a4hgQGhW+mwVqFRlnDlzCYWikA8/eJHCwny8vPx4/vl3kcpkSKUSevX0pkdQB72evhtCo9FW9R1QKEqQySRV/Qqsrc0NeiJcly5d2Lp1K5GRkYSEhNR7yyAqKoqQkBAiIyPZtm0rw4cZrk6/k3933n1vBQ4OTqSnXeCthTO5fDmtzvdJZTICAnoAt88bOHqtiiCk94B7viWxIclkUkxMZfXuG3GjNq0d7oi8GqF5iGBAaFaV5w3s27evWgOdmsTGpVFSUsrnny7k0qVUHB2defW1TzC3sMTCwpRBA7sYta2rSlWGUllKcXEJZWVqrKzMsbau+D9jl2INGDCAiIgILCwsCA0NZdKkSezZs+eWskOlUklYWBiTJk0iNDS0qm3xwIED6drFnZ49Ohjs5urh6cPi91fh5taO7OwMFr05iwtJZ+p83/USw5qDAXV5OSdOVFRQiMZE+nNqZcvVHP3PpxBbBC2bKCYVmlX37t1xcXEhKyuL1157DbVajUqlwsLCgoCAAIKDgwkKCiIvv5jklCy++eYjYmNPYG5uyWtvfIpjK2dcnO3oHeJr8A5rarWGsvJr+6+6ioxtY6843E6XLl2IiIhgzZo1LFu2jGHDhiGTyfDz88Pa2hqFQkFiYiIajYbOnTuzdOlSpk+fjonJ9T+XDl6uWFqaEXk0sdGZ5wAurm1YvGQVHyx5keQLZ3nn7Xm88ur/qm74NenarSKJ8OzZfykrLcXUrPp2TmzsCVTKYuztW+HrF9DoObY0UqkEC3NTlMpSLC3rt1VmYiLDVWwRtGgSXUMKhgXBAMrLy1mzZg1vvvkmeXl5VTc2GxsbioqKqm5s/v7+DH9gAleuZPLH798ikUp57bVPCOrRB1+f1nTr6o5UapibdGX3QB065DLZHXs+u06nIyYmhqioKOLi4lAqlVhaWlYFUIGBgbddASgoVHI4/EytbZX1pVQW88nHrxIXexK53IRnn3u71uZQOp2OWTPHkpd7lTcXfUW3bsHVvr961f/Yu2czwx8Yz3+nv2yQ+bU0Op2OS5dz691syNPDmeBePkaelXAnE8GA0CxiY2OZOnUqMTExjB8/nlmzZtG3b99qTXlUKhXh4eGsXr2a9evXI5FI0Gg0/Hf6S4wcOYmePbxxd29ci93yaye3Vf4zMDc3aTF71CpVGUcizpKb17ATIG9WVlbK0q/f5WjkASQSCf/570sMf2B8ja9dtnQxhw7uYNz4p5j8xPUWzVqNhhnTR1NYmF9joCDUX35+MTKZtF6NuPrd7y+SB1u4O/OxR7inHTx4kFGjRuHh4cHRo0fp1avmJWULCwuGDh3K0KFDiYqK4sknnyQlJQUfHz8GDeyCvb1Vje+7HZ1OV630SiaTGnx74W5hYWHKgP6dORZ1nkuXcxs9nqmpGS+8sJhvv/2MPWEb+XbNJxQW5jFx0tO3BFhduvTk0MEdHD4cRkmJirKyUkxNzZDL5RQW5mNpZU3nzkGNnlNLZm9vxcVLOXUGA2ZmJrg4N30J7v+3d+9xUZf5HsA/c4UZZriDclNQGINBkwx2FBMvpO5qRyy20+2s5Z40b625laZb67aZZjdP3vNU0lqnk63oqm0Grtk6gsxJqbgUXjDwVomiwwyXYeZ3/nAlTVEuv7kw83m/Xv0hzDzzRYP58Fy+D3kWzgyQS5WVlcFgMGDo0KHYunUrAgI6/oZusVgwadIkHDhwAEVFRUhNTe3Q82w2e9tv/hIJ2Hf9ZwRBwFdf16Dq8CnRxtv84Vv4aPPbAIBx4+/BI1OfgFQqRWtrK3YXbsPfP96MU6dqIJVKkZT009LQkSOHYbfbodUG4t5/fxRjsiddc9kUdZzZ3Ai7w4HgoPa/z/ol9MKQ2/q5sCryRAwD5DI2mw0GgwFNTU0oKSnpVBC4zGKxICMjo22X/JWb4y5zOBxXXdoik0lF21PgzY4eO4NDpce7dO/A9Xzy94/wztuvQxAEDBs2BpNyHsL69S/heHXVTZeG1q1bh/z8fMQn6DBz1iL06dNflJp80cmT5xAdHdLu8lfWiBRERnju5V3kGgwD5DJr1qzBnDlzbrg00BEmkwkGgwErV67EzJkzAVza+X/5/2SJBDwv3UVnvq9HUXEVWlu7f9IAAIz7CrBq1Z9hb22FXC5HUlIS3n333Q79+5tMJkyZMgXHj3+H+QteRoqeywZdYbU2o6nJhtBQzTWf8/dTYOKEIT6zT4baxzBALiEIAvR6PfR6PTZv3tzt8XJzc1FZWYnS0i8hkUggk0n5A00kFy5YsW+/eCcNCj7dirffehUjRozA9u3bu7Q0tH9/Ef68ZD1nCLro1KlziIq6dnYgsX9vpA3u2JXW5N04d0oucejQIVRWVmL69OmijDd9+nRUVFSgrOxryOUyBgERBQWpMXpkKkK6sEHz51pbW7F799+QlKTrdBAAgICAAGzbtg3x8X2xdvUStLZ2ve++LwsL06Lu3LWnRthoiC5jGCCXMJlMkMlkbXcRdFdmZiZkMlm3b/Oj61OplBiZpUdMdGi3xtlduA3Hq6vwl7+826U9IsClQJCXl4fq6irsLtzWrXp8lZ+fAjZbKxyOn/bSqFRKhIVp3VgVeRKGAXKJ8vJy6HS6qzaLdYdarYZOp0N5ebko49G15HIZhhp0SEqM6tLzBUHAp7u2YPLkyd3aIwIA6enpyMnJwaefbhFtg6OvCQ/Toq7up9mB2JgwzqhRG4YBconGxkZoteL+FqLRaGC1WkUdk64mkUgw+NZ4pA1O6PQbR3V1FWprq/HYY4+JUstjjz2G2ppqHK+uEmU8X6NQyK86aRMXxyUC+gnDALmESqWC2dz5y1NupKGhAWq1WtQx6foS+/dG5tABnTqlcfRIpVOWho4erRRlPF8UHn7pEqOAAD+EhXKJgH7CMEAuodfrUVVVdc0te11ltVpRVVUFvZ4X2bhKVFQIRmXpoVIpO/T42tpjSExMEnVpKDExCbW11aKM54tkMimkEgl6RQa7uxTyMAwD5BLp6emw2+0wGo2ijGc0GmG325Gezt71rhQcHIDRozp20qClpdkpS0PNzU2ijulrwsI0EK7YSEgEMAyQi6SlpSE5ORnr168XZbz169cjJSUFgwcPFmU86ji1yg9ZI/SI6h1yw8cplX5OWRry8/MXdUxfExSoRkRkkGh9JMg7MAyQS0gkEsyePRtbtmzp9nFAk8mE/Px8zJo1i7uh3UShkCFz2AAkJfZu9zFxcf1w5MhhUZeGjhw5jLg4Nsnpjri4cMTFhqH2RJ27SyEPwjBALpOeng6FQoGHHnoIFoulS2NYLBY8/PDDSEtLw7Rp00SukDrj0kmDBAy+Nf66oax/YrJTlob6908WZTxfFRsbBqlUCo3GHxfN4gQ16vkYBsgl9uzZgzFjxqC5uRnHjh1DTk5OpwOBxWJBTk4OampqsHHjRt5m5yGSEqMunTSQXf3jJCFBh7i4BKxbt06U11m3bh3i+iQgPkEnyni+KDBQjaDASydwYqJDcfr0eTdXRJ6CYYCc7qOPPsL48eNhNpuRlZWFrVu3ori4GBkZGR1eMjCZTMjIyEBxcTF27NjR4euLyTWiokIwMksPf/+fThpIJBKMHXc38vPzRVka2rp1K8aOvZtLQ93w8/bDwcEBOH/+2jbF5HsYBsip1q5di3vvvRctLS24++678cknn2DChAkoKiqCSqWCwWBAbm4uCgsLr1lbtlqtKCgoQG5uLgwGQ9u1xVlZWW76auhGQkI0GDM6FcFXnDQYkz0J8Qk6TJkypVtLQ1OmTEFCgg7Zd04Sq1yf9PMw0CsyCD/8eNFN1ZAn4a2F5BSCIGDx4sV4/vnnAVy6WGj16tWQyX5qWmOz2bBhwwasWrUKlZWXGtTodDpoNBo0NDSgqqoKdrsdKSkpmDVrFh599FEoFAp3fUnUQTabHQdKDuP0mUtT0DU1R/HsoukYNmwotm3b1ulbC++66y4Yjfvx4rL/5q2F3RASHIDsMYOu+fi58w2wtzoQERHohqrIUzAMkOjsdjtmzpyJN998EwCwePFiPPfcc+1O7wqCgNLSUphMJpSXl8NqtUKtVkOv1yM9PR2DBw/m1HAP43A4UPrlcRw99j0AoKL8EF5a9hTi4/siLy+vQ/0hTCYTfvOb3+Dw4cOw2+2YPedZjMj6pbNL91oDU/vglgEx1/1c1eHT0CV17Q4K8g4MAySqpqYmPPDAA8jPz4dEIsGaNWtE601PPU/V4dP48qvjAC7NEKxdvQTV1VXIycnBjBkzkJmZeVWHQqvVCqPRiHXr1mHr1q1ISNAhNq4f9n72MWQyGZ5Z9BoGDWKjqa741fg0BARcv0fDRXMjrJYm9L5J7wjyXgwDJJr6+npMmjQJn3/+OZRKJd5//33cc8897i6L3OzkqXMoKTmMVrsDra2t2F24DZ/u2oLa2mrIZDIkJia1LQ0dOXJpFiCuTwLGjr0bY7InQSqV4o3/Woz9xkKoVGr86c9rER+f5O4vq0cJDdVgzKiBN3zMkaNn0L9fL87C+SiGARLFqVOnMH78eHz99dcIDAzEtm3bMHLkSHeXRR7i3PkGGPd/i6amFgCXloaOV1fh6NFK1NZWo7m5CX5+/oiLS0D//smIT9Bd9aZks7XgxRfmobz8IEJCw7FkyZsIj2i/4RFdbdDAvhigi77hY6yNzTh/3oKY6FAXVUWehGGAuq2qqgpjx47Fd999h969e+OTTz7Brbfe6u6yyMNYrc3Yt/8bXLjQtWunLRYznnt2BmprjiE2NgHPv7AWGg03vXXEhF/dBrXK76aPO3bse8THR0Aq5UEzX8N/ceqWkpISZGZm4rvvvkNiYiL279/PIEDXpVb7YVSWHr16BXfp+QEBWjyz8FWEhkbgxIlqvLx8AVpa2F//ZsLDtR0KAsCl7oQnT55zckXkiRgGqMt27dqF0aNH4+zZsxgyZAiMRiMSEtg3ntqnUMgxfNgA9Evo1aXnh4f3wsJFr0GlDkBlRSlWr3oBDt7Ad0NxseEdfqxSKYfdIaC11e7EisgTMQxQl7z33nuYOHEiLBYL7rzzTuzZsweRkZHuLot6AKlUiiG39cOggX279Pw+ffvjqaeXQSaXo2j/bmz6yyqRK/QeEomk03sAYmNCceoU2xT7GoYB6rTXX38dDz30EFpbW3H//fdjx44dot9bT95vgC4aw65zp0FHpKYOwaxZfwAA7Nj+AXbu+F+xy/MKEeGBUKmUN3/gFeRyGSQSwGZrdVJV5IkYBqjDBEHA/PnzMW/ePADA7373O2zatAlKZed+2BBdFhMdiqwsPfz9Ot9ZcvgdY/HgQzMBAO/mvYGi/f8Qu7we7+fthzsqJiYUJzk74FMYBqhDbDYbHnnkESxfvhwAsHTpUrz++uvcdUzdFhqiwZjRAxH4r9v0OuPfJj2I8b/MhSAIWLXyeVRWlIpfYA8lkUgQE9O1Y4JSqRRKhQzNzTaRqyJPxZ/kdFOXrw7Oy8uDTCbD22+/jQULFrA5CYlGrfbD6JGdP2kgkUjw8MO/Q0ZGFmy2Fix/aT5O1FY7p8geJjIyCH5dmHG5LCoqBKfP1ItXEHk0hgG6obq6OmRnZ+Pjjz+GSqXC1q1b8cgjj7i7LPJCl08aJMR3biOqVCbD479bDJ0uFRaLGS8umYdz5350UpU9R1eXCC6TSCRQq5WwWnl80xcwDFC7ampqMHz4cBQXFyMkJASFhYWYOHGiu8siLyaVSnH7kP6dPmmg9PPD/GdeRlR0H5w9+z2WvvgkrNauXZnsDaRSCWK7uERwpciIIPx4llcc+wKGAbqu8vJyDBs2DN988w1iY2Oxb98+DBs2zN1lkY8YoIuG4Rc6yDpx0kCrDcKiRa8hKDgU3x0/jFdfWYhWm2+ueffuFQyFQi7KWBqNPy6aG0UZizwXwwBdw2g0Yvjw4Th58iSSk5Oxf/9+pKSkuLss8jFxsWHIGpHSqXXvyF7ReOaZV+Dnr8LXX5mwbt0y+GLH9c40GrqZsFAt6s/77iyLr2AYoKts374d2dnZqK+vh8FgwD//+U/ExcW5uyzyUWGhWowZlQqtVnXzB/9Lv/63YN68FyCVyvD53r/jg/9Z78QKPY9MJkVUlLhXEQcFq1Ffz0DgzRgGqM0777yDyZMno6mpCRMmTMDu3bsRFta9TUhE3RUQ4I/RI1MRGRHU4eek3TYU06bPBwDkb3kXn+7Kd1Z5Hqd372AoFDJRxwwKVMPMpQKvxjBAEAQBS5cuxdSpU2G32zFlyhTk5+dDre78uW8iZ1Aq5bhj+C2I78RJg9FjJuLX9/4WAPDWW6/i/0z/dFZ5HkXMJYIrhYVpUXfO7JSxyf0YBnycw+HA3LlzsXDhQgDA/Pnz8c4770Ch6Pr5ZCJnkEqlSB/SH6n6ji9b5f56KkaPuQuCw4EVrz+Hw1XlTqzQ/eQyKaJ6BztlbLXaD1Zri1PGJvdjGPBhLS0tePDBB/HGG28AuHTnwLJly9hMiDxa8i2xMGQkdeikgUQiwaPTnkLabUPR0tKMZcuewunTtS6o0j2iokIgl4u7RHCliPBA/Pgjjxp6I4YBH2U2mzFhwgR88MEHkMvleO+99zB37lx3l0XUIXFx4RhxR8dOGshkcjzxxJ/Rr98tMF+sx4tL5uHChXMuqNL14uKcs0Rwmb+/Ai22Vp88oeHtGAZ80A8//IBRo0ahsLAQAQEB2LlzJx544AF3l0XUKeFhWowe2bGTBv4qNRYsfAWRkdH4/sxJLFv6FJqavGtDnEIhQ+9OtnPuisiIQPzA2QGvwzDgY6qrq5GZmYkvvvgC4eHh2LNnD8aOHevusoi6RKPp+EmD4OBQLPzDa9Bqg3D0SCVWvPYs7HbvuaY3Jjq0U02aukqhkMNhd8DhcDj9tch1GAZ8SGlpKYYNG4YjR44gPj4eRqMR6enp7i6LqFvaThr0jbjpY6Oj+2D+guVQKJU4eHA//nvDK14z5R0b47pjwJGRQZwd8DIMAz7is88+Q1ZWFs6cOYNBgwbBaDRCp9O5uywiUUilUqTfngh9ys1PGugGDMTcuc9DIpVid+HfsOWvG51foJMplXL06tXxPgzdJZNJIZFI0Npqd9lrknMxDPiAv/71rxg3bhwuXryIESNGYO/evYiOjnZ3WUSiS0mOxS/SkyCV3vhETHrGCEyd+gQA4H8/2IDP9ux0RXlOExMdCqnUtT/OIyMCcbaOfQe8BcOAl1u3bh1+/etfo6WlBXfffTd27dqF4OBgd5dF5DR9+oQjqwMnDcaNvwc5k/8DALB+3TKUlha7ojyncPYpguuRSCSQy6Sw2bxn34UvYxjwUoIgYPHixZgxYwYEQcC0adPw4Ycfwt/f392lETldeHggRmXpodXc+P/3++6fjuF3jIXdbsdrr/wBx45966IKxePnp0BEuNYtrx0eHoi6cw1ueW0SF8OAF7Lb7ZgxYwb+9Kc/AQD++Mc/Yt26dZDJnNeMhMjTaLUqjBqZivAbvFFKpVLMnLkIAwfejqYmK5a9+CR++OG0C6vsvtgY1y8RXMlPKUdzs29eFe1NGAa8TFNTE+69916sX78eEokEa9asweLFi9lVkHySn58CI4anoM8NptHlCgV+/+SL6Ns3EfX1dVi6ZB4azD1np7yz7iLoqJAQDeovWN1aA3Ufw4AXqa+vx7hx47BlyxYolUp8+OGHmDFjhrvLInIrmUyKX2QkISU5tt3HqAM0eGbhqwgL74WTJ7/DSy89jZbmZhdW2TX+/sobzny4ikqlhLXR8/++qH0MA17i9OnTyMrKwueff47AwEDs2rULubm57i6LyGPoU+KQkZ7Y7kmD0LAILFz0KtRqDb795iu88caf4LB79tG5uNhQj5j1C9Sq0NDQ5O4yqBsYBrxAVVUVhg0bhq+++gq9e/fG3r17MXLkSHeXReRx+vaJwIjhKVAq5df9fFxcPzw9/yXI5QqUHPgMeXlveHRTolg3LxFcSRPgD4uFgaCnYhjo4UwmEzIzM3H8+HEkJibCaDRi8ODB7i6LyGNFRARi1MhUaNo5aZCiT8PsOc8CAP7+8WZs/9v/uLK8DlOr/RAe5v4lgst4xXHPxjDQg3366acYNWoUzp49iyFDhsBoNKJfv37uLovI4wVqVRh9g5MGwzKz8R+/mQ0A2PSXVTDuK3BleR3iyvbDHaXVqmA2e9cFUL6CYaCHev/99zFhwgRYLBZkZ2djz549iIyMdHdZRD3G5ZMGcbHXf1OdeNf9+NWEewEAq1e9gPKyg64s76bi4jwvDPj7K3jMsIdiGOiBVqxYgQcffBCtra247777sHPnTmi1njNdSNRT3OikgUQiwW+mPA6DYRRaW214efkC1NQcdUOV19Jo/BEaonF3GdcVFKTGhYs8atjTMAz0IIIgYMGCBXjiiUs91R9//HG89957UCqVbq6MqOeSSCTQp8Qh/fZrTxpIpVLMfvw53HLLrbBaG7B0ye9RV/eDmyr9SXuzGZ5AoZDzAqMeiGGgh7DZbJg6dSpeeuklAMDSpUuxYsUKt3YeI/Im8X0jcMfwZCgUV3fqVCr98PT8lxAT0xd1dT9g6ZLfw2pxbwtedzcaupmgQDUusBFRj8J3kh7AarVi8uTJ2LhxI2QyGd566y0sWLDAI84XE3mTyIggjB41EAEBfld9XKMNxDOLXkNwcBhqao7i5ZcXoNXmnrVxrVaFoCC1W167o+RyGewOh0cfy6SrMQx4uHPnziE7Oxs7d+6Ev78/8vPzMXXqVHeXReS1ArUqjBk1EGE/O7YXGRmFhYtehb+/GuVlB7Fm9RI4HA6X1+fJSwRXCg7i7EBPIhEY3VxCEAQcOnQIJpMJ5eXlaGxshEqlgl6vR3p6OtLS0q75Tb+2thbjxo1DZWUlQkJCsH37dmRmZrrpKyDyLa2tdpi+OIoTJ+qu+viXpQewbOmTsNvtmJTzEB58aKZL6xo3djACtSqXvmZXXbhghVbrz+XMHoBhwMlsNhs2bNiAVatWobKyEjKZDDqdDlqtFmazGVVVVbDb7UhOTsbs2bPx6KOPQqFQoKKiAuPGjcOJEycQExODXbt2Qa/Xu/vLIfIpgiCgrLwW33x78qqPf/bZx1iz6gUAwNTf/h7jf3mPS+oJClJjbPatLnktsdTXWxAcHODuMugmGNecqKysDAaDAXPmzIFer0dBQQHMZjMqKipw4MABVFRUwGw2o6CgAHq9HnPmzIHBYMCmTZswfPhwnDhxAsnJydi/fz+DAJEbSCQSDEztg9uH9L/qpMHIkb/CffdPAwC88/ZrKDmw1yX19JQlgitJZVLY7a5fTqHO4cyAk+zduxcTJkxA3759kZeXh9tvv/2mzzGZTJgyZUrbbIHBYMCOHTsQFtbzfgAQeZvvf7iAouJvYbNdOjYnCAI2vLkchQXboFAq8dxzKzHgloFOreGX49LabaPsyS5csHr8pkdfxzDgBJdnBIYOHYqtW7ciIKDjU2QWiwV33XUX9u3bh3379iEjI8OJlRJRZ1y4aIVx/zewWC5d12u3t+KVlxfii//bB40mEC8sWY/omL5Oee3QEA3GjHZu2HAWi6UJSqXimmOb5DkYBkRms9lgMBjQ1NSEkpKSTgWByywWCzIyMqBSqVBUVASFQuGESomoK5qabDAWfYNz5xr+9edGPL94Do4cqUBEZBSWLHkTwSHiz+YNGtgXA3TRoo/rKhcuWhEUyNkBT8U9AyLbsGEDSktLkZeX16UgAAABAQHYuHEjDh06hA0bNohcIRF1h7+/All3pCAmJvRff1Zh/jPL0at3DH784TSWLX0KTY3iH6nrifsFrqRUyGGztbq7DGoHZwZEJAgC9Ho99Ho9Nm/e3O3xcnNzUVlZibKyMjYYIvIwgiDg67IafFt1CgBw5vQJLFo0DeaL9Rg82ICnFyyHXC4X5bXCwrQYPTJVlLHc6aK5sccci/Q1nBkQ0aFDh1BZWYnp06eLMt706dNRUVGB0tJSUcYjIvFIJBIMGtgXQ9L6QSKRoHdULBYseBlKpR9KS4ux4c3lonXg6+mzApf5KeW81dBDMQyIyGQyQSaTidYYKDMzEzKZDCaTSZTxiEh8/fr1wvDMWyCXy5Ck0+OJeS9AIpVizz92YPOHb4nyGrExXhIG/BRtpzHIszAMiKi8vBw6nQ4qlTjTYGq1GjqdDuXl5aKMR0TO0btXMEaPTIVa7Ycht2fiP//zSQDAR5vfxj92b+/W2BHhgVCpvOdmUj8/zg54IoYBETU2NkKr1d78gZ2g0WhgtbK/N5GnCwpSY/TIVISGaHDn2Bzcfc8UAMCb65fj4MH9XR43Ls47ZgUu4xXHnolhQEQqlQpms1nUMRsaGqBW8zgOUU+gUimRNSIFMdGh+Pf7pmFE1i/hcNjx+qt/wNEjlZ0eTyKRICbau8IAcGm5oKmJswOehGFARHq9HlVVVWhsbBRlPKvViqqqKrYiJupB5HIZhhp0GKCLwWOPLcCgQelobm7CsqVP4vvvT958gCtERgbB39/7+ozI5TK33PhI7RPn3AsBANLT02G322E0GpGdnd3t8YxGI+x2O9LT00WojohcRSKR4NZBfaHR+OH3Ty3FH5+dgePHD+PFF+bhz0vWIzAwuO2xgiCguroKR49Uorb2GFpamqFU+iEurh8mTsyGINzilUeL/f0VaGxs8ar9ED0Z+wyIiH0GiOjnzpw5j51/348FT/8WZ89+jySdHs/9cSVkMjl2F27Dp7u2oLa2GjKZDImJSW03mh45cvi6N5p6E2tjM9QqP3eXQQAgkKhWr14tSKVSoaSkpFvjlJSUCFKpVFi9erVIlRGRu9TXW4Q1azcLARqtAEDQpw4R+vUbIEilUuGee+4RCgoKBKvVetVzrFarUFBQIOTm5gpSqVS47bbbhK+//tpNX4FzOBwOwWptdncZJAgCZwZEJvbdBMXFxaJ1MSMi92lsbMH69e/jyScfhSA4kJSUhE2bNnX4RtOHH34YNTU12LFjB7KyslxQsWs0NrbA31/B2U834wZCkSkUCuTl5aGmpgY5OTmwWCyder7FYkFOTg5qamqwceNGBgEiL6FSKTFyZBrkchmysrLwxRdfdCgIAJf2I5WUlMBgMGDixIkoKytzcrWuo1Ip0dzMOwvcjTMDTrJ3715MnDgRffr0wcaNGzu0CdCb0z+Rr+ONpu1rbrZBoZBBKuXvp+7Cv3knycrKQlFREVQqFQwGA3Jzc1FYWHjNsUOr1YqCggLk5ubCYDC0fZMzCBB5F95o2j62KXY/zgw4mc1mw4YNG7Bq1SpUVlZCJpNBp9NBo9GgoaEBVVVVsNvtSElJwaxZs7xyxzCRrxN40uimbLZWyGRSzg64CcOAiwiCgNLSUphMJpSXl8NqtUKtVkOv1yM9PR2DBw/2mm9qIrrawYMHMWTIEBQUFIjSg6SgoABjx47FwYMHkZaWJkKFnqGlpRVKJfdJuQP/1l1EIpEgLS3Nq75xiahjnHmjqTf9TJFKJXA4HJBIJDh06FDbL0+NjY1QqVRtvzylpaXxlyeRMQwQETkZbzTtGEFwYPXqdVi7du1Vy6qXGzGtWbPG6xsxuQsXZ4iInMwZN5qqVCrs3r0bK1aswLZt2/Dll1/i4sWLor6GK5WVlcFgMGDu3LnQ6/UoKCiA2WxGRUUFDhw4gIqKCpjNZhQUFECv12POnDkwGAxedczSnbhngIjIyR5//HEUFhaioqJCtDETExNx9OjRaz4eGhqKhISEa/6Lj49HfHw8/P39RatBLHv37sWECRPQt29f5OXl+XwjJndgGCAicrL169dj1qxZMJvNoiwVWK1WBAYGYsyYMQgKCkJ1dTWqq6tRV1d30+dGRUVdNygkJCQgLi7O5Y3OLs8IDB06FFu3bu3UscvLTdqKi4tRVFSE1NRUJ1bq3RgGiIiczFWnCcxmc1swqK6uxvHjx6/6c0NDww3HlclkiIuLazcs9O7dW9Sjf2zE5DkYBoiInMwT+gwIgoC6urp2g8Lx48fR0tJywzH8/PzagsHPg0JCQgJCQ0M7tct/zZo1mDNnDg4cONDh1szXYzKZYDAYsHLlSsycObPL4/gyhgEiIhe4/MZXXFzcofbk7XHWG5/D4cDp06fbDQu1tbVwOBw3HEOr1ba7XyEhIQEajabtsZ4QkOgnDANERC7Q0280tdlsqK2tbTcsnDlz5qZjhIeHtwUElUqFvLw8NmLyEAwDREQuUlZWhqFDh8JgMHjdZrnGxsa2gPDzoFBdXY3z589f8xypVIqGhgZRN1WuWbMG06ZN6/Z4voZNh4iIXCQ1NRU7duzAxIkTkZGR0eUbTT0tCACX+h4kJycjOTn5up+/cOHCVbMKGzdubOssKAZvbcTkKmw6RETkQr56o2lQUBAGDx6MyZMn44knnkBGRgZCQkJEfQ2NRgOr1SrqmL6CMwNERC6WmpqKoqKithtN77zzzhveaLpy5Uqva72rUqlgNptFHbOhoQFqtVrUMX0F9wwQEbmRr95o6qxGTNwz0DWcGSAiciNfvdE0PT0ddrsdRqNRlNMERqMRdru9W8c2fRlnBoiIyOXYZ8CzcAMhERG5nEQiwezZs7FlyxaYTKZujWUymZCfn49Zs2YxCHQRZwaIiMgtenojJm/CmQEiInILhUKBvLw81NTUICcnBxaLpVPPv9yIqaamBhs3bmQQ6AaGASIicpvLjZiKi4uRkZHR4SUDk8mEjIwMFBcXe2wjpp6EYYCIiNzKVxsxeRLuGSAiIo9gs9naGjFVVlbesBHTrFmzvK4RkzsxDBARkUfx1UZM7sQwQERE5OO4Z4CIiMjHMQwQERH5OIYBIiIiH8cwQERE5OMYBoiIiHwcwwAREZGPYxggIiLycQwDREREPo5hgIiIyMcxDBAREfk4hgEiIiIfxzBARETk4xgGiIiIfBzDABERkY9jGCAiIvJxDANEREQ+jmGAiIjIxzEMEBER+TiGASIiIh/HMEBEROTjGAaIiIh8HMMAERGRj2MYICIi8nEMA0RERD6OYYCIiMjHMQwQERH5OIYBIiIiH8cwQERE5OMYBoiIiHzc/wOrfPdYl5U8mwAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -152,7 +150,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -169,7 +166,10 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 6, @@ -178,7 +178,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -193,7 +193,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -208,7 +207,10 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 7, @@ -217,7 +219,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -231,7 +233,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -246,7 +247,10 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 8, @@ -255,7 +259,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -269,7 +273,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -299,7 +302,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -331,7 +333,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -354,7 +355,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -378,7 +378,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAGwCAYAAABPSaTdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAo5ElEQVR4nO3de1TVdb7/8dcGBRVhEyYgE94zJcX7KGl2AcVLlpeZycZGNBae8WCpWCpTYlgNjqepjme8VFNSZ+k0J9NcOiNKXjAnvDYeLxGJ2mghaKIgeEQu+/dHy73aP7XYsLd78/H5WGuv5f5+v/u73ztWi+f67u/3i8Vms9kEAABgKB9PDwAAAOBOxA4AADAasQMAAIxG7AAAAKMROwAAwGjEDgAAMBqxAwAAjNbE0wN4g9raWhUWFiowMFAWi8XT4wAAgDqw2Wy6dOmSIiIi5ONz8+M3xI6kwsJCRUZGenoMAABQD6dPn9Zdd9110/XEjqTAwEBJ3//HCgoK8vA0AACgLsrKyhQZGWn/PX4zxI5k/+oqKCiI2AEAoJH5qVNQOEEZAAAYjdgBAABG82jsZGRkqH///goMDFRoaKjGjBmj/Px8h20efPBBWSwWh8dvf/tbh21OnTqlUaNGqUWLFgoNDdVzzz2n6urqW/lRAACAl/LoOTs5OTlKTk5W//79VV1drd/97ncaNmyYvvjiCwUEBNi3S0pK0sKFC+3PW7RoYf93TU2NRo0apfDwcH322Wc6c+aMJk2apKZNm+r3v//9Lf08AADA+1hsNpvN00Ncc+7cOYWGhionJ0dDhgyR9P2RnV69eumNN9644Ws2bdqkRx55RIWFhQoLC5MkrVixQnPnztW5c+fk5+f3k+9bVlYmq9Wq0tJSTlAGAKCRqOvvb686Z6e0tFSSFBIS4rB81apVuvPOO9W9e3elpqbq8uXL9nW5ubnq0aOHPXQkKT4+XmVlZTp69OgN36eyslJlZWUODwAAYCavufS8trZWM2fO1KBBg9S9e3f78l//+tdq166dIiIidOjQIc2dO1f5+flau3atJKmoqMghdCTZnxcVFd3wvTIyMpSenu6mTwIAALyJ18ROcnKyjhw5ol27djksnzp1qv3fPXr0UJs2bRQbG6vjx4+rU6dO9Xqv1NRUpaSk2J9fuykRAAAwj1d8jTV9+nRt3LhR27dv/9HbPUvSgAEDJEkFBQWSpPDwcBUXFztsc+15eHj4Dffh7+9vv4EgNxIEAMBsHo0dm82m6dOna926ddq2bZs6dOjwk685ePCgJKlNmzaSpJiYGB0+fFhnz561b5Odna2goCBFRUW5ZW4AANB4ePRrrOTkZK1evVrr169XYGCg/Rwbq9Wq5s2b6/jx41q9erVGjhypVq1a6dChQ5o1a5aGDBmi6OhoSdKwYcMUFRWl3/zmN1q8eLGKior0wgsvKDk5Wf7+/p78eAAAwAt49NLzm/0ti5UrV2ry5Mk6ffq0nnzySR05ckQVFRWKjIzU2LFj9cILLzh89fSvf/1L06ZN044dOxQQEKCEhAQtWrRITZrUreW49BwAgManrr+/veo+O55C7AAA0Pg0yvvsAAAAuBqxAwAAjOY199kBAHdpP+9vnh4BDfD1olGeHgGNHEd2AACA0YgdAABgNGIHAAAYjdgBAABGI3YAAIDRiB0AAGA0YgcAABiN2AEAAEYjdgAAgNGIHQAAYDRiBwAAGI3YAQAARiN2AACA0YgdAABgNGIHAAAYjdgBAABGI3YAAIDRiB0AAGA0YgcAABiN2AEAAEYjdgAAgNGIHQAAYDRiBwAAGI3YAQAARiN2AACA0YgdAABgNGIHAAAYjdgBAABGI3YAAIDRiB0AAGA0YgcAABiN2AEAAEYjdgAAgNGIHQAAYDRiBwAAGI3YAQAARiN2AACA0YgdAABgNGIHAAAYjdgBAABGI3YAAIDRmnh6AMDbtZ/3N0+PAABoAI7sAAAAoxE7AADAaMQOAAAwGrEDAACMxgnKAACvxkUCjd/Xi0Z59P05sgMAAIxG7AAAAKMROwAAwGjEDgAAMBqxAwAAjEbsAAAAoxE7AADAaMQOAAAwGrEDAACMRuwAAACjETsAAMBoxA4AADCaR2MnIyND/fv3V2BgoEJDQzVmzBjl5+c7bHPlyhUlJyerVatWatmypcaPH6/i4mKHbU6dOqVRo0apRYsWCg0N1XPPPafq6upb+VEAAICX8mjs5OTkKDk5Wbt371Z2draqqqo0bNgwVVRU2LeZNWuWNmzYoA8//FA5OTkqLCzUuHHj7Otramo0atQoXb16VZ999pnee+89ZWZmKi0tzRMfCQAAeBmLzWazeXqIa86dO6fQ0FDl5ORoyJAhKi0tVevWrbV69Wr94he/kCR9+eWX6tatm3JzczVw4EBt2rRJjzzyiAoLCxUWFiZJWrFihebOnatz587Jz8/vuveprKxUZWWl/XlZWZkiIyNVWlqqoKCgW/Nh0Wi0n/c3T48AAI3a14tGuWW/ZWVlslqtP/n726vO2SktLZUkhYSESJIOHDigqqoqxcXF2bfp2rWr2rZtq9zcXElSbm6uevToYQ8dSYqPj1dZWZmOHj16w/fJyMiQ1Wq1PyIjI931kQAAgId5TezU1tZq5syZGjRokLp37y5JKioqkp+fn4KDgx22DQsLU1FRkX2bH4bOtfXX1t1IamqqSktL7Y/Tp0+7+NMAAABv0cTTA1yTnJysI0eOaNeuXW5/L39/f/n7+7v9fQAAgOd5xZGd6dOna+PGjdq+fbvuuusu+/Lw8HBdvXpVFy9edNi+uLhY4eHh9m3+/6uzrj2/tg0AALh9eTR2bDabpk+frnXr1mnbtm3q0KGDw/q+ffuqadOm2rp1q31Zfn6+Tp06pZiYGElSTEyMDh8+rLNnz9q3yc7OVlBQkKKiom7NBwEAAF7Lo19jJScna/Xq1Vq/fr0CAwPt59hYrVY1b95cVqtViYmJSklJUUhIiIKCgvT0008rJiZGAwcOlCQNGzZMUVFR+s1vfqPFixerqKhIL7zwgpKTk/mqCgAAeDZ2li9fLkl68MEHHZavXLlSkydPliS9/vrr8vHx0fjx41VZWan4+HgtW7bMvq2vr682btyoadOmKSYmRgEBAUpISNDChQtv1ccAAABezKvus+Mpdb1OH7cn7rMDAA3DfXYAAADciNgBAABGI3YAAIDRiB0AAGA0YgcAABiN2AEAAEYjdgAAgNGIHQAAYDRiBwAAGI3YAQAARiN2AACA0YgdAABgNGIHAAAYjdgBAABGI3YAAIDRiB0AAGA0YgcAABiN2AEAAEYjdgAAgNGIHQAAYDRiBwAAGI3YAQAARiN2AACA0YgdAABgNGIHAAAYjdgBAABGI3YAAIDRiB0AAGA0YgcAABiN2AEAAEYjdgAAgNGIHQAAYDRiBwAAGI3YAQAARiN2AACA0YgdAABgNGIHAAAYjdgBAABGa3Ds1NTU6ODBg7pw4YIr5gEAAHApp2Nn5syZeueddyR9HzoPPPCA+vTpo8jISO3YscPV8wEAADSI07GzZs0a9ezZU5K0YcMGnTx5Ul9++aVmzZql559/3uUDAgAANITTsfPdd98pPDxckvT3v/9dv/zlL9WlSxc99dRTOnz4sMsHBAAAaAinYycsLExffPGFampqlJWVpaFDh0qSLl++LF9fX5cPCAAA0BBNnH3BlClT9Ktf/Upt2rSRxWJRXFycJGnPnj3q2rWrywcEAABoCKdj58UXX1T37t11+vRp/fKXv5S/v78kydfXV/PmzXP5gAAAAA3hdOxI0i9+8QtJ0pUrV+zLEhISXDMRAACACzl9zk5NTY1eeukl/exnP1PLli114sQJSdL8+fPtl6QDAAB4C6dj55VXXlFmZqYWL14sPz8/+/Lu3bvrz3/+s0uHAwAAaCinY+f999/XW2+9pYkTJzpcfdWzZ099+eWXLh0OAACgoZyOnW+//VadO3e+bnltba2qqqpcMhQAAICrOB07UVFR+vTTT69bvmbNGvXu3dslQwEAALiK01djpaWlKSEhQd9++61qa2u1du1a5efn6/3339fGjRvdMSMAAEC9OX1k57HHHtOGDRv0ySefKCAgQGlpacrLy9OGDRvsd1MGAADwFvW6z87999+v7OxsV88CAADgck4f2QEAAGhMnD6yc8cdd8hisVy33GKxqFmzZurcubMmT56sKVOmuGRAAACAhqjXCcqvvPKKRowYoZ///OeSpL179yorK0vJyck6efKkpk2bpurqaiUlJbl8YAAAAGc4HTu7du3Syy+/rN/+9rcOy998801t2bJFH330kaKjo7VkyRJiBwAAeJzT5+xs3rxZcXFx1y2PjY3V5s2bJUkjR460/80sAAAAT3I6dkJCQrRhw4brlm/YsEEhISGSpIqKCgUGBjZ8OgAAgAZy+mus+fPna9q0adq+fbv9nJ19+/bp73//u1asWCFJys7O1gMPPODaSQEAAOrB6SM7SUlJysnJUUBAgNauXau1a9eqRYsWysnJUWJioiRp9uzZ+utf//qT+9q5c6dGjx6tiIgIWSwWffzxxw7rJ0+eLIvF4vAYPny4wzYlJSWaOHGigoKCFBwcrMTERJWXlzv7sQAAgKHqdVPBQYMGadCgQQ1+84qKCvXs2VNPPfWUxo0bd8Nthg8frpUrV9qf+/v7O6yfOHGizpw5o+zsbFVVVWnKlCmaOnWqVq9e3eD5AABA41en2CkrK6vzDoOCguq87YgRIzRixIgf3cbf31/h4eE3XJeXl6esrCzt27dP/fr1kyT913/9l0aOHKlXX31VERERN3xdZWWlKisr7c+d+XwAAKBxqdPXWMHBwbrjjjvq9HC1HTt2KDQ0VPfcc4+mTZum8+fP29fl5uYqODjYHjqSFBcXJx8fH+3Zs+em+8zIyJDVarU/IiMjXT43AADwDnU6srN9+3b7v7/++mvNmzdPkydPVkxMjKTvo+O9995TRkaGS4cbPny4xo0bpw4dOuj48eP63e9+pxEjRig3N1e+vr4qKipSaGiow2uaNGmikJAQFRUV3XS/qampSklJsT8vKysjeAAAMFSdYueHV1YtXLhQr732mp544gn7skcffVQ9evTQW2+9pYSEBJcNN2HCBPu/e/TooejoaHXq1Ek7duxQbGxsvffr7+9/3bk/AADATE5fjZWbm+vwtdE1/fr10969e10y1M107NhRd955pwoKCiRJ4eHhOnv2rMM21dXVKikpuel5PgAA4PbidOxERkbq7bffvm75n//8Z7d/FfTNN9/o/PnzatOmjSQpJiZGFy9e1IEDB+zbbNu2TbW1tRowYIBbZwEAAI2D05eev/766xo/frw2bdpkD4q9e/fq2LFj+uijj5zaV3l5uf0ojSSdPHlSBw8eVEhIiEJCQpSenq7x48crPDxcx48f15w5c9S5c2fFx8dLkrp166bhw4crKSlJK1asUFVVlaZPn64JEybc9EosAABwe3H6yM7IkSP11VdfafTo0SopKVFJSYlGjx6tr776SiNHjnRqX/v371fv3r3Vu3dvSVJKSop69+6ttLQ0+fr66tChQ3r00UfVpUsXJSYmqm/fvvr0008dzrdZtWqVunbtqtjYWI0cOVKDBw/WW2+95ezHAgAAhrLYbDabp4fwtLKyMlmtVpWWljp1nyDcHtrP+5unRwCARu3rRaPcst+6/v52+siOJH366ad68skndd999+nbb7+VJP33f/+3du3aVb9pAQAA3MTp2Pnoo48UHx+v5s2b6/PPP7ffibi0tFS///3vXT4gAABAQzgdOy+//LJWrFiht99+W02bNrUvHzRokD7//HOXDgcAANBQTsdOfn6+hgwZct1yq9WqixcvumImAAAAl3E6dsLDwx0uF79m165d6tixo0uGAgAAcBWnYycpKUkzZszQnj17ZLFYVFhYqFWrVunZZ5/VtGnT3DEjAABAvTl9U8F58+aptrZWsbGxunz5soYMGSJ/f389++yzevrpp90xIwAAQL05HTsWi0XPP/+8nnvuORUUFKi8vFxRUVFq2bKlO+YDAABoEKdj5xo/Pz9FRUW5chYAAACXq9dNBQEAABoLYgcAABiN2AEAAEarU+z06dNHFy5ckCQtXLhQly9fdutQAAAArlKn2MnLy1NFRYUkKT09XeXl5W4dCgAAwFXqdDVWr169NGXKFA0ePFg2m02vvvrqTS81T0tLc+mAAAAADVGn2MnMzNSCBQu0ceNGWSwWbdq0SU2aXP9Si8VC7AAAAK9Sp9i555579MEHH0iSfHx8tHXrVoWGhrp1MAAAAFdw+qaCtbW17pgDAADALep1B+Xjx4/rjTfeUF5eniQpKipKM2bMUKdOnVw6HAAAQEM5fZ+dzZs3KyoqSnv37lV0dLSio6O1Z88e3XvvvcrOznbHjAAAAPVWr796PmvWLC1atOi65XPnztXQoUNdNhwAAEBDOX1kJy8vT4mJidctf+qpp/TFF1+4ZCgAAABXcTp2WrdurYMHD163/ODBg1yhBQAAvI7TX2MlJSVp6tSpOnHihO677z5J0j/+8Q/94Q9/UEpKissHBAAAaAinY2f+/PkKDAzUH//4R6WmpkqSIiIi9OKLL+qZZ55x+YAAAAAN4XTsWCwWzZo1S7NmzdKlS5ckSYGBgS4fDAAAwBXqdZ+da4gcAADg7Zw+QRkAAKAxIXYAAIDRiB0AAGA0p2KnqqpKsbGxOnbsmLvmAQAAcCmnYqdp06Y6dOiQu2YBAABwOae/xnryySf1zjvvuGMWAAAAl3P60vPq6mq9++67+uSTT9S3b18FBAQ4rH/ttddcNhwAAEBDOR07R44cUZ8+fSRJX331lcM6i8XimqkAAABcxOnY2b59uzvmAAAAcIt6X3peUFCgzZs36//+7/8kSTabzWVDAQAAuIrTsXP+/HnFxsaqS5cuGjlypM6cOSNJSkxM1OzZs10+IAAAQEM4HTuzZs1S06ZNderUKbVo0cK+/PHHH1dWVpZLhwMAAGgop8/Z2bJlizZv3qy77rrLYfndd9+tf/3rXy4bDAAAwBWcPrJTUVHhcETnmpKSEvn7+7tkKAAAAFdxOnbuv/9+vf/++/bnFotFtbW1Wrx4sR566CGXDgcAANBQTn+NtXjxYsXGxmr//v26evWq5syZo6NHj6qkpET/+Mc/3DEjAABAvTl9ZKd79+766quvNHjwYD322GOqqKjQuHHj9M9//lOdOnVyx4wAAAD15vSRHUmyWq16/vnnXT2LkdrP+5unRwAA4LZWr9i5cOGC3nnnHeXl5UmSoqKiNGXKFIWEhLh0OAAAgIZy+musnTt3qn379lqyZIkuXLigCxcuaMmSJerQoYN27tzpjhkBAADqzekjO8nJyXr88ce1fPly+fr6SpJqamr07//+70pOTtbhw4ddPiQAAEB9OX1kp6CgQLNnz7aHjiT5+voqJSVFBQUFLh0OAACgoZyOnT59+tjP1fmhvLw89ezZ0yVDAQAAuEqdvsY6dOiQ/d/PPPOMZsyYoYKCAg0cOFCStHv3bi1dulSLFi1yz5QAAAD1ZLHZbLaf2sjHx0cWi0U/tanFYlFNTY3LhrtVysrKZLVaVVpaqqCgIJfum0vPAQC3u68XjXLLfuv6+7tOR3ZOnjzpssEAAABupTrFTrt27dw9BwAAgFvU66aChYWF2rVrl86ePava2lqHdc8884xLBgMAAHAFp2MnMzNT//Zv/yY/Pz+1atVKFovFvs5isRA7AADAqzgdO/Pnz1daWppSU1Pl4+P0lesAAAC3lNO1cvnyZU2YMIHQAQAAjYLTxZKYmKgPP/zQHbMAAAC4nNNfY2VkZOiRRx5RVlaWevTooaZNmzqsf+2111w2HAAAQEPVK3Y2b96se+65R5KuO0EZAADAmzj9NdYf//hHvfvuu8rLy9OOHTu0fft2+2Pbtm1O7Wvnzp0aPXq0IiIiZLFY9PHHHzust9lsSktLU5s2bdS8eXPFxcXp2LFjDtuUlJRo4sSJCgoKUnBwsBITE1VeXu7sxwIAAIZyOnb8/f01aNAgl7x5RUWFevbsqaVLl95w/eLFi7VkyRKtWLFCe/bsUUBAgOLj43XlyhX7NhMnTtTRo0eVnZ2tjRs3aufOnZo6dapL5gMAAI1fnf421g9lZGTozJkzWrJkiWsHsVi0bt06jRkzRtL3R3UiIiI0e/ZsPfvss5Kk0tJShYWFKTMzUxMmTFBeXp6ioqK0b98+9evXT5KUlZWlkSNH6ptvvlFERMQN36uyslKVlZX252VlZYqMjORvYwEA4AaN4m9j/dDevXu1bds2bdy4Uffee+91JyivXbvW+Wlv4OTJkyoqKlJcXJx9mdVq1YABA5Sbm6sJEyYoNzdXwcHB9tCRpLi4OPn4+GjPnj0aO3bsDfedkZGh9PR0l8wJAAC8m9OxExwcrHHjxrljFgdFRUWSpLCwMIflYWFh9nVFRUUKDQ11WN+kSROFhITYt7mR1NRUpaSk2J9fO7IDAADM43TsrFy50h1z3FL+/v7y9/f39BgAAOAW8NrbIIeHh0uSiouLHZYXFxfb14WHh+vs2bMO66urq1VSUmLfBgAA3N6cPrLToUOHH72fzokTJxo00A/fJzw8XFu3blWvXr0kff910549ezRt2jRJUkxMjC5evKgDBw6ob9++kqRt27aptrZWAwYMcMkcAACgcXM6dmbOnOnwvKqqSv/85z+VlZWl5557zql9lZeXq6CgwP785MmTOnjwoEJCQtS2bVvNnDlTL7/8su6++2516NBB8+fPV0REhP2KrW7dumn48OFKSkrSihUrVFVVpenTp2vChAk3vRILAADcXpyOnRkzZtxw+dKlS7V//36n9rV//3499NBD9ufXThpOSEhQZmam5syZo4qKCk2dOlUXL17U4MGDlZWVpWbNmtlfs2rVKk2fPl2xsbHy8fHR+PHjXX5ZPAAAaLycvs/OzZw4cUK9evVSWVmZK3Z3S9X1Ov364D47AIDbnafvs+OyE5TXrFmjkJAQV+0OAADAJZz+Gqt3794OJyjbbDYVFRXp3LlzWrZsmUuHAwAAaCinY+faycHX+Pj4qHXr1nrwwQfVtWtXV80FAADgEk7HzoIFC9wxBwAAgFt47U0FAQAAXKHOR3Z8fHx+9GaC0vd/uby6urrBQwEAALhKnWNn3bp1N12Xm5urJUuWqLa21iVDAQAAuEqdY+exxx67bll+fr7mzZunDRs2aOLEiVq4cKFLhwMAAGioep2zU1hYqKSkJPXo0UPV1dU6ePCg3nvvPbVr187V8wEAADSIU7FTWlqquXPnqnPnzjp69Ki2bt2qDRs2qHv37u6aDwAAoEHq/DXW4sWL9Yc//EHh4eH6y1/+csOvtQAAALxNnf82lo+Pj5o3b664uDj5+vredLu1a9e6bLhbhb+NBQCA+3j6b2PV+cjOpEmTfvLScwAAAG9T59jJzMx04xgAAADuwR2UAQCA0YgdAABgNGIHAAAYjdgBAABGI3YAAIDRiB0AAGA0YgcAABiN2AEAAEYjdgAAgNGIHQAAYDRiBwAAGI3YAQAARiN2AACA0YgdAABgNGIHAAAYjdgBAABGI3YAAIDRiB0AAGA0YgcAABiN2AEAAEYjdgAAgNGIHQAAYDRiBwAAGI3YAQAARiN2AACA0YgdAABgNGIHAAAYjdgBAABGI3YAAIDRiB0AAGA0YgcAABiN2AEAAEYjdgAAgNGIHQAAYDRiBwAAGI3YAQAARiN2AACA0YgdAABgNGIHAAAYjdgBAABGI3YAAIDRiB0AAGA0YgcAABiN2AEAAEYjdgAAgNGIHQAAYDRiBwAAGM2rY+fFF1+UxWJxeHTt2tW+/sqVK0pOTlarVq3UsmVLjR8/XsXFxR6cGAAAeBuvjh1Juvfee3XmzBn7Y9euXfZ1s2bN0oYNG/Thhx8qJydHhYWFGjdunAenBQAA3qaJpwf4KU2aNFF4ePh1y0tLS/XOO+9o9erVevjhhyVJK1euVLdu3bR7924NHDjwVo8KAAC8kNcf2Tl27JgiIiLUsWNHTZw4UadOnZIkHThwQFVVVYqLi7Nv27VrV7Vt21a5ubk/us/KykqVlZU5PAAAgJm8OnYGDBigzMxMZWVlafny5Tp58qTuv/9+Xbp0SUVFRfLz81NwcLDDa8LCwlRUVPSj+83IyJDVarU/IiMj3fgpAACAJ3n111gjRoyw/zs6OloDBgxQu3bt9D//8z9q3rx5vfebmpqqlJQU+/OysjKCBwAAQ3n1kZ3/X3BwsLp06aKCggKFh4fr6tWrunjxosM2xcXFNzzH54f8/f0VFBTk8AAAAGZqVLFTXl6u48ePq02bNurbt6+aNm2qrVu32tfn5+fr1KlTiomJ8eCUAADAm3j111jPPvusRo8erXbt2qmwsFALFiyQr6+vnnjiCVmtViUmJiolJUUhISEKCgrS008/rZiYGK7EAgAAdl4dO998842eeOIJnT9/Xq1bt9bgwYO1e/dutW7dWpL0+uuvy8fHR+PHj1dlZaXi4+O1bNkyD08NAAC8icVms9k8PYSnlZWVyWq1qrS01OXn77Sf9zeX7g8AgMbm60Wj3LLfuv7+blTn7AAAADiL2AEAAEYjdgAAgNGIHQAAYDRiBwAAGI3YAQAARiN2AACA0YgdAABgNGIHAAAYjdgBAABGI3YAAIDRiB0AAGA0YgcAABiN2AEAAEYjdgAAgNGIHQAAYDRiBwAAGI3YAQAARiN2AACA0YgdAABgNGIHAAAYjdgBAABGI3YAAIDRiB0AAGA0YgcAABiN2AEAAEYjdgAAgNGIHQAAYDRiBwAAGI3YAQAARiN2AACA0YgdAABgNGIHAAAYjdgBAABGI3YAAIDRiB0AAGA0YgcAABiN2AEAAEYjdgAAgNGIHQAAYDRiBwAAGI3YAQAARiN2AACA0YgdAABgNGIHAAAYjdgBAABGI3YAAIDRiB0AAGA0YgcAABiN2AEAAEYjdgAAgNGIHQAAYDRiBwAAGI3YAQAARiN2AACA0YgdAABgNGIHAAAYjdgBAABGI3YAAIDRiB0AAGA0YgcAABjNmNhZunSp2rdvr2bNmmnAgAHau3evp0cCAABewIjY+etf/6qUlBQtWLBAn3/+uXr27Kn4+HidPXvW06MBAAAPMyJ2XnvtNSUlJWnKlCmKiorSihUr1KJFC7377rueHg0AAHhYE08P0FBXr17VgQMHlJqaal/m4+OjuLg45ebm3vA1lZWVqqystD8vLS2VJJWVlbl8vtrKyy7fJwAAjYk7fr/+cL82m+1Ht2v0sfPdd9+ppqZGYWFhDsvDwsL05Zdf3vA1GRkZSk9Pv255ZGSkW2YEAOB2Zn3Dvfu/dOmSrFbrTdc3+tipj9TUVKWkpNif19bWqqSkRK1atZLFYvHgZI1PWVmZIiMjdfr0aQUFBXl6HDiJn1/jx8+w8eNnWH82m02XLl1SRETEj27X6GPnzjvvlK+vr4qLix2WFxcXKzw8/Iav8ff3l7+/v8Oy4OBgd414WwgKCuJ/0kaMn1/jx8+w8eNnWD8/dkTnmkZ/grKfn5/69u2rrVu32pfV1tZq69atiomJ8eBkAADAGzT6IzuSlJKSooSEBPXr108///nP9cYbb6iiokJTpkzx9GgAAMDDjIidxx9/XOfOnVNaWpqKiorUq1cvZWVlXXfSMlzP399fCxYsuO5rQTQO/PwaP36GjR8/Q/ez2H7qei0AAIBGrNGfswMAAPBjiB0AAGA0YgcAABiN2AEAAEYjdlAvO3fu1OjRoxURESGLxaKPP/7Y0yPBCRkZGerfv78CAwMVGhqqMWPGKD8/39NjwQnLly9XdHS0/UZ0MTEx2rRpk6fHQj0tWrRIFotFM2fO9PQoRiJ2UC8VFRXq2bOnli5d6ulRUA85OTlKTk7W7t27lZ2draqqKg0bNkwVFRWeHg11dNddd2nRokU6cOCA9u/fr4cffliPPfaYjh496unR4KR9+/bpzTffVHR0tKdHMRaXnqPBLBaL1q1bpzFjxnh6FNTTuXPnFBoaqpycHA0ZMsTT46CeQkJC9B//8R9KTEz09Cioo/LycvXp00fLli3Tyy+/rF69eumNN97w9FjG4cgOAJWWlkr6/pclGp+amhp98MEHqqio4M/kNDLJyckaNWqU4uLiPD2K0Yy4gzKA+qutrdXMmTM1aNAgde/e3dPjwAmHDx9WTEyMrly5opYtW2rdunWKiory9Fioow8++ECff/659u3b5+lRjEfsALe55ORkHTlyRLt27fL0KHDSPffco4MHD6q0tFRr1qxRQkKCcnJyCJ5G4PTp05oxY4ays7PVrFkzT49jPM7ZQYNxzk7jNX36dK1fv147d+5Uhw4dPD0OGiguLk6dOnXSm2++6elR8BM+/vhjjR07Vr6+vvZlNTU1slgs8vHxUWVlpcM6NAxHdoDbkM1m09NPP61169Zpx44dhI4hamtrVVlZ6ekxUAexsbE6fPiww7IpU6aoa9eumjt3LqHjYsQO6qW8vFwFBQX25ydPntTBgwcVEhKitm3benAy1EVycrJWr16t9evXKzAwUEVFRZIkq9Wq5s2be3g61EVqaqpGjBihtm3b6tKlS1q9erV27NihzZs3e3o01EFgYOB158gFBASoVatWnDvnBsQO6mX//v166KGH7M9TUlIkSQkJCcrMzPTQVKir5cuXS5IefPBBh+UrV67U5MmTb/1AcNrZs2c1adIknTlzRlarVdHR0dq8ebOGDh3q6dEAr8M5OwAAwGjcZwcAABiN2AEAAEYjdgAAgNGIHQAAYDRiBwAAGI3YAQAARiN2AACA0YgdAABgNGIHwG0jMzNTwcHBnh4DwC1G7ADwaqdPn9ZTTz2liIgI+fn5qV27dpoxY4bOnz/v6dEANBLEDgCvdeLECfXr10/Hjh3TX/7yFxUUFGjFihXaunWrYmJiVFJScsPXXb161W0zVVVVuW3fANyD2AHgtZKTk+Xn56ctW7bogQceUNu2bTVixAh98skn+vbbb/X8889Lktq3b6+XXnpJkyZNUlBQkKZOnSrp+6+t2rZtqxYtWmjs2LE3PBq0fv169enTR82aNVPHjh2Vnp6u6upq+3qLxaLly5fr0UcfVUBAgF555ZVb8+EBuAx/CBSAVyopKdGdd96pV155Rampqdetnzp1qtasWaPz58+rQ4cOunDhgtLS0jRmzBhJ0nfffaf77rtPGRkZGjNmjLKysrRgwQLZbDZdvHhRkvTpp5/qkUce0ZIlS3T//ffr+PHjmjp1qiZPnqwFCxZI+j52QkNDtWjRIj3wwANq0qSJ2rZte6v+MwBwgSaeHgAAbuTYsWOy2Wzq1q3bDdd369ZNFy5c0Llz5yRJDz/8sGbPnm1fP3/+fA0fPlxz5syRJHXp0kWfffaZsrKy7Nukp6dr3rx5SkhIkCR17NhRL730kubMmWOPHUn69a9/rSlTprj8MwK4NfgaC4BXq+vB5379+jk8z8vL04ABAxyWxcTEODz/3//9Xy1cuFAtW7a0P5KSknTmzBldvnz5pvsG0LhwZAeAV+rcubMsFovy8vI0duzY69bn5eXpjjvuUOvWrSVJAQEBTr9HeXm50tPTNW7cuOvWNWvWzP7v+uwbgPcgdgB4pVatWmno0KFatmyZZs2apebNm9vXFRUVadWqVZo0aZIsFssNX9+tWzft2bPHYdnu3bsdnvfp00f5+fnq3Lmz6z8AAK/B11gAvNaf/vQnVVZWKj4+Xjt37tTp06eVlZWloUOH6mc/+9mPXhn1zDPPKCsrS6+++qqOHTumP/3pTw7n60hSWlqa3n//faWnp+vo0aPKy8vTBx98oBdeeMHdHw3ALUTsAPBad999t/bv36+OHTvqV7/6lTp16qSpU6fqoYceUm5urkJCQm762oEDB+rtt9/Wf/7nf6pnz57asmXLdRETHx+vjRs3asuWLerfv78GDhyo119/Xe3atXP3RwNwC3HpOQAAMBpHdgAAgNGIHQAAYDRiBwAAGI3YAQAARiN2AACA0YgdAABgNGIHAAAYjdgBAABGI3YAAIDRiB0AAGA0YgcAABjt/wEN2Ozw8q1gcgAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -400,7 +400,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -426,7 +425,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -448,7 +447,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -460,9 +458,9 @@ ], "metadata": { "kernelspec": { - "display_name": "base", + "display_name": "venv_xgi", "language": "python", - "name": "python3" + "name": "venv_xgi" }, "language_info": { "codemirror_mode": { @@ -476,7 +474,19 @@ "pygments_lexer": "ipython3", "version": "3.9.13" }, - "orig_nbformat": 4 + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } }, "nbformat": 4, "nbformat_minor": 2 diff --git a/xgi/drawing/draw_utils.py b/xgi/drawing/draw_utils.py index c9ae6b12c..c80c65030 100644 --- a/xgi/drawing/draw_utils.py +++ b/xgi/drawing/draw_utils.py @@ -6,6 +6,7 @@ import matplotlib as mpl import matplotlib.pyplot as plt import numpy as np +import seaborn as sb # for cmap "crest" from matplotlib.colors import ( LinearSegmentedColormap, ListedColormap, From 94cd36b0cd80ef66f84c715f12c2186be407b549 Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Mon, 9 Oct 2023 18:45:03 +0200 Subject: [PATCH 16/26] reran notebooks --- tutorials/XGI in 15 minutes.ipynb | 87 ++++++++++++++----------------- 1 file changed, 39 insertions(+), 48 deletions(-) diff --git a/tutorials/XGI in 15 minutes.ipynb b/tutorials/XGI in 15 minutes.ipynb index e3b75b25a..f5c14fec4 100644 --- a/tutorials/XGI in 15 minutes.ipynb +++ b/tutorials/XGI in 15 minutes.ipynb @@ -1,7 +1,6 @@ { "cells": [ { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -24,7 +23,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -43,7 +41,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -68,7 +65,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -93,7 +89,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -132,7 +127,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -148,7 +142,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "[('0', {'4', '1'}), ('1', {'1', '129', '117'}), ('2', {'1', '51'}), ('3', {'1', '51'}), ('4', {'1', '41'})]\n" + "[('0', {'4', '1'}), ('1', {'117', '129', '1'}), ('2', {'51', '1'}), ('3', {'51', '1'}), ('4', {'41', '1'})]\n" ] } ], @@ -158,7 +152,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -166,7 +159,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -194,7 +186,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -223,7 +214,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -239,7 +229,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Hypergraph named email-Enron with 143 nodes and 1514 hyperedges\n" + "Hypergraph named email-Enron with 143 nodes and 1459 hyperedges\n" ] } ], @@ -252,7 +242,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -287,7 +276,7 @@ { "data": { "text/plain": [ - "True" + "False" ] }, "execution_count": 11, @@ -300,7 +289,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -328,7 +316,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -345,7 +332,10 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 13, @@ -354,7 +344,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOyddVhV2ffG31t0CgIiIgjYImKgqNjd3Z1jjTXmzGDN2N3tGNjdHdgKqJhYqAgWSkvd+/7+YDgj0jE/v6P78zz7Uc7Ze511Dpe737P23mvLSBICgUAgEAh+WOTf2gGBQCAQCATfFiEGBAKBQCD4wRFiQCAQCASCHxwhBgQCgUAg+MERYkAgEAgEgh8cIQYEAoFAIPjBEWJAIBAIBIIfHCEGBAKBQCD4wRFiQCAQCASCHxwhBgQCgUAg+MERYkAgEAgEgh8cIQYEAoFAIPjBEWJAIBAIBIIfHCEGBAKBQCD4wRFiQCAQCASCHxwhBgQCgUAg+MERYkAgEAgEgh8cIQYEAoFAIPjBEWJAIBAIBIIfHCEGBAKBQCD4wRFiQCAQCASCHxwhBgQCgUAg+MERYkAgEAgEgh8cIQYEAoFAIPjBEWJAIBAIBIIfHCEGBAKBQCD4wRFiQCAQCASCHxwhBgQCgUAg+MERYkAgEAgEgh8c5bd2QCAQfDvCw8Nx4cIF+Pr6IjAwEBqNBubm5ihXrhyqVasGOzu7b+2iQCD4f0BGkt/aCYFA8P9LYGAgpk+fjs2bNyMmJgZmZmZwcnKCQqFASEgInj17BgBo0KABxowZg9q1a39jjwUCwb+JGCYQCH4gSGL58uUoXbo0Dh48iDFjxuDp06d4//49rly5gosXL+Lp06cIDQ3F+vXr8eHDB9SpUwd9+/ZFRETEt3ZfIBD8S4jIgEDwg0ASw4YNw5IlSzBgwADMnj0bhoaGmbZZvXo1Ro0ahaJFi+LkyZPIly/f/5PHAoHg/wshBgSCH4QpU6bA09MTq1atQr9+/bLV9s6dO6hTpw6cnJxw/vx5qFSqf8lLgUDwLRDDBALBD8DNmzcxZcoUTJo0KdtCAACcnZ1x8OBBXLt2DbNmzfoXPBQIBN8SERkQCH4AqlSpgri4OFy7di1Xb/Xjx4/H3LlzERgYCGtr6zz0UCAQfEtEZEAg+M65efMmrl69ikmTJuU6vD9u3DioVCqsWbMmj7wTCAT/CwgxIBB852zduhXW1tZo0qRJrm0ZGxujY8eO2LJlSx54JhAI/lcQYkAg+M65ceMGqlWrBoVCkSf2atSogYCAAISHh+eJPYFA8O0RYkAg+M65f/8+nJ2d88xesq0HDx7kmU2BQPBtEWJAIPjO+fz5MwwMDPLMXrKt2NjYPLMpEAi+LUIMCAQ5RK1W47+wGEdPTy9PswdGRkZKdgUCwfeBEAMCQRZ5+fIlPD09Ubt2bZiamkKpVEIul8POzg5t2rTB+vXrERMT863dTEXp0qVx+/btPLN369YtyGQylCxZMs9sCgSCb4sQAwJBJrx79w5dunSBvb09FixYABMTE4wePRpr1qzBypUr0a5dO7x//x59+vRBwYIFMW/ePKjV6m/ttkTFihVx8eJFJCQk5Im9s2fPokSJEnk69CAQCL4tIumQQJABJ06cQJcuXQAkpfPt1q1bup3gs2fPMHfuXCxfvhzu7u7YtWsXrKys/j/dTZPbt2/DxcUFu3btQps2bXJl6+PHjyhYsCA8PT0xbty4PPJQIBB8a4QYEAjS4dChQ2jdujXq1q2LDRs2wMLCIkvtvL290aFDBxgaGuLChQuwtLT8lz3NnBo1aiA0NBQ+Pj7Q1tbOsZ3hw4dj5cqVePHiRZafh0Ag+N9HDBMIBGnw7NkzdOjQAU2aNMH+/fuz1fFVr14d3t7eiIyMRIcOHaDRaP5FT7PGkiVLEBAQgN9//z3HNs6ePYtFixbhzz//FEJAIPjOEJEBgeArSKJWrVp48eIF/P39czw2fubMGdSpUwdLlizB4MGD89jL7DN37lyMHj0ac+fOxciRI7PV9tq1a2jQoAHKly+PEydO5FkCI4FA8L+BiAwIBF9x9uxZnD9/HsuXL8/VJLnatWujV69emDZtGuLj4/PQw5wxcuRITJgwAaNGjULnzp0RGhqaaRu1Wo05c+agZs2aKFGyNPbs2SOEgEDwHSIiAwLBV7Rr1w7379/H3bt3IZPJcmXr7t27KFOmDLZv34727dvnkYe5w8vLC0OGDAFJ9O7dG926dUPp0qWhVCoBJEVGXr16hX379mHZsmUICAhA35+G4pcJnjA3MYSpfurNjkjC19cXly5dgp+fHz5+/AilUokiRYqgfPnyqFevHszMzP6/b1UgEGQRIQYEgi/QaDQwMTHB2LFjMXHixDyxWbZsWVSoUAFr167NE3t5wZs3bzBv3jysXbsWHz9+hK6uLuzt7SFXKBASEoLQDx+gVCpRt3FzDBryM1zKV5TaGukqYaybJAhIYuvWrZgzZw78/Pygra2NMmXKwNLSEgkJCXj06BFevHgBbW1tdOjQAb///jscHBy+1W0LBIJ0EGJAIPiCgIAAFCtWDMePH0f9+vXzxGbfvn1x8+ZN3Lp1K0/s5SWxsbG4fv06fHx88OLFC4RHx0HHyBQlSpdFGdeKMDMzh7GuEvKvIiQmeipEfXqPvn374siRI2jcuDEGDx6MevXqpdom+c2bN9i4cSMWL16Mjx8/YubMmRg8eHCuoy4CgSDvEGJAIPiC06dPo27dunjy5EmevcHOmDEDs2fPztIY/bcm6NNnhEanTE6kq5JDV5VynsDLF4Ho3LIREhLisXr16ixtjxwVFYWxY8di2bJlGDZsGBYsWPCvCwKSIAm5XEyPEggyQvmtHRAI/pdI1sZ52XnI5fL/ieWFWSGtvjkuUQMdpVzquKMiI9G1bTNoaalw8aI3ChUqlCXbBgYGWLp0KZydnTFw4EBYWVlh/Pjxeek+EhISsG/fPuzbtw8+Pj548uQJ1Go1jIyM4OLiAnd3d/Tq1QtFixbN0+sKBP91hFwWCL4gef3869ev88xmUFDQf2Zdvhyp1YCGQLz6nwDi9Mm/4v3bNzh27FiWhcCXDBgwAOPHj4enpyfu3LmTK3+TIYmNGzeicOHCaN++PQICAlCvXj0sWrQIq1evxvjx42FpaYnVq1ejWLFiaN68OV6+fJkn1xYIvgfEMIFA8AUJCQkwNDTEjBkzMHz48DyxWbVqVRQuXBheXl55Yu/f5E14HN5GxqU6rpTLYKSjxMP7d1G/eqVc506Ii4tDhQoVYGFhgaNHj8Lf3x937txBREQEVCoVihYtivLly8PU1DRTW5GRkejatSsOHDiATp06Yfz48ShTpkyadWNjY7F9+3b8+uuvCA8Px5o1a/5nVnkIBN8SIQYEgq+oW7cu4uPjceHChVzbCgoKgp2dHZYuXYoBAwbkgXf/Lu8i4hASkVoMAIChtgKeY4bj9PHDePHiRaqJgtnFy8sLXbp0ga6uLj5//gyZTAYdHR0kJCQgMTERAFCnTh0MGjQILVu2THPoJjIyEvXq1cPDhw+xceNGNG/ePEvXDg8Px08//YRt27Zh/fr16NGjR67uRSD4ryOGCQSCrxgwYAC8vb3h5+eXa1vLli2Drq4uOnfunAee/T+QwXy+2AQ1Du/fg549e+ZaCABAmzZtYGhoiEqVKuHy5cuIiopCTEwM4uLi8ODBA6xduxafP39GmzZtULt2bTx9+jSVjYEDB+L+/fs4ffp0loUAABgbG2Pz5s3o27cv+vTpAx8fn1zfj0DwX0ZEBgSCr0hISECZMmVgbGyMS5cuScl4ssv9+/dRrlw5jBgxAjNmzMhjL/8dPkTG43V4bJrngl48R9NqLjhy5AgaNWqUJ9dr2LAhVCoVDh48mG6dM2fOoE+fPggNDcXBgwdRo0YNAMD+/fvRsmVLbN68WdpZMrskJCTAzc0NCQkJ8PHxgZaWVo7sCAT/dURkQCD4CpVKhfXr1+PGjRs5TjwUHh6Ozp07w87eHp6ennns4b+HLINvhGdPAgAg3fH4nFCmTBk8ePAgwzq1a9fGnTt3UKlSJTRp0gQ+Pj4gid9++w0NGjTIVdRFpVJh7dq1uHv3Lnbt2pVjOwLBfx0hBgSCNKhSpQrmzJmDWbNmYfTo0UhISMi80d+8fv0atWrVwoMHD7Bg+TpQ/t9528zoCyEhPmkugZ6eXp5dT09PD3Fxac9R+BJDQ0McOHAAxYsXR9euXXH27Fn4+/tj1KhRuc5VUK5cOdSuXRvLli3LlR2B4L+MEAMCQTqMHDkS8+fPx4IFC+Dm5obLly8jo1G1uLg4rFq1CiVLloK/vz/i4+OxaulCfIyOR1hMwn8i10BGHauunj4AICwsLM+uFx4enuXNoPT09LBx40Y8e/YMkydPhoWFBerUqZMnfnTp0gWXLl1CREREntgTCP5rCDEgEGTA8OHDcfXqVSQkJKBq1aooX748Jk2ahIMHD8LHxwfXrl3Dpk2bMHToUFhbW2PAgAGo3aAJ5q/4C0qlEvt278CMKb8jJl6D0OhEqP/HBUFGL9lOxUsBQJ6mVfbz88vWsEPJkiXRv39/XLt2DRUqVMiz5FAVK1aU/BEIfkREBkKBIBMqVKiA27dv4/jx41i1ahWWLFmSKrWwSqWChZU1Du89CceixSCTAdPmLsW4nwdg6cI5MDQyQuv2nRBmZATbAubQVv1v6vCv9yD4kvyWVrCyLojTp0+jdevWubrOixcvcP78eVy+fBkeHh74448/UKZMGVSsWBEWFhY4fPgw/vrrL9y4cQNv3ryBRqOBtrY2LC0t4eTkhMTExDzd8MjR0REA8OrVqzyzKRD8lxCrCQSCbJK8xW9oaCgUCgXCw8Ph4eEBPT19XLn/ClpaWoiODMf+XVuxYdUSBAe9glqtltrb2haGW+Uq6N+vD2rXrv0/lTc/Oi4RT97HpHt+yayp2L5hJV6/fg1DQ8Ns2dZoNNi6dSuWLl2KK1euAABMTU1hbGyM8PBwfPr0CQCgo6OD2NhYFC9eHB4eHihevDi0tLTw/v173Lx5E+fOnUN0dDSMjY1x+PBhVK1aNec3/DdxcXHQ0dHBX3/9he7du+fankDwX0OIAYEgl2g0GlhaWeHD+/f4a9cR3LtzC0vm/oG42Fg0atQI7u7uKFmyJLS1tREaGgo/Pz8cP34cd+/eRenSpbFmzRq4ubl969sAAMTEJ+Lxu/TFQMjrV2hWzQWjR4/G9OnT8fDhQ5w6dQq+vr4IDg4GSRQoUACurq6oXbs2SpcuDQB48uQJevXqhYsXL6Ju3bro168fPDw8YGVlBSBJYAUFBeHs2bNYtmwZrl27hqZNm2LlypWwtrZO4UN0dDS2bNmCiRMn4tOnT+jRowfWrFmTq4mET58+haOjI44ePYqGDRvm2I5A8J+FAoEg13Ts2JEAaG1TiDKZjMOGDePr16/Tra/RaHjhwgVWqFCBcrmc06ZNo0aj+X/0OG0+xyXw1qvwNMuZW09Zq0FTAiAAlitXjgCoUqlYvnx5tmnThm3atGHFihWppaVFAKxWrRrnzp1LY2NjFilShOfOncuSH/v27aOlpSWtrKx49+7dNOuEhoayVatWlMlkrF27NtVqdY7ve/v27QTAt2/f5tiGQPBfRkQGBII8YPHixRgxYgSMjY2xf/9+VKtWLUvtEhMTMWXKFEydOhUTJ07EtGnTMqz/9u1beHt7w9fXFyEhIZDJZLC2toarqyuqV6+O/Pnz5+o+4hI1ePgmKtXxC6ePY9Lowfj44T1kMhlIokKFChg5ciRatWoFHR2dFPXj4+Nx4MABLFiwAJcuXYKlpSV8fHxQsGDBLPvy9u1b1KtXTxoeSKutWq1Gr169pGyCq1atyv5NA+jYsSNu376dac4DgeC75RuLEYHgP49Go2HDhg1pbGzMe/fu5cjGzJkzCYAHDhxI87yvry/bt29PpVJJACxYsCCrVKnCKlWq0MrKSnpD79y5M+/cuZPje4lLUKeIBlx5FMy2XXtJ0QB9fQPq6ulx2bJlWXoT12g0XLt2LQ0NDVmxYkWGhYVly583b96wQIECbNSoUbqRk9jYWJYsWZJKpZKXLl3Kln2SDAoKolKp5IIFC7LdViD4XhBiQCDIJTt27CAA7tixI8c2NBoNmzRpQktLK34IDZWOx8XFccKECVQoFCxatCgXLlzI4ODgVO2DgoI4d+5cFilShEqlkpMnT2ZCQkK2/UhQ/yMGNh04zUJ2RSQhUMiuCA0NDXn58uVs2/X19aWpqSnr1KmT7XD+wYMHCYC7du1Kt87169cJgI6OjtmyrdFo2Lx5c1pYWPDTp0/ZaisQfE8IMSAQ5AKNRkNnZ2c2atQo17ZevXpFlUrFyX/OYnyimp8/f2ajRo2oUqk4depUxsfHZ2ojNjaWv/76KxUKBVu1asW4uLhs+aBWq3nj2QcOGDGOCoWCAGhZoCB7Dvw5w8hFVjh16hQBcMmSJdlu6+HhwRo1amRYp2rVqpTL5fT29s6y3UWLFhEA9+zZk22fBILvCSEGBIJccOnSJQLg8ePH88Rep06dWMTBkUGhMWzTth11dHR48uTJbNs5ePAgtbS02KtXr2y1e/ToEUuVdZWiAY1atuPJmw9pms+MXbt2zbYfXzNw4EAaGhoyIiIiW+28vLwIgIGBgenWWb16NQHQxsaG0dHRGdpTq9WcPXs2AXDkyJHZ8kUg+B4RYkAgyAVTpkyhqalprmayf8m+ffsIgFNmzM310MP69esJgPv27cu0rkaj4bJly6irq0sANDQ25owla3nrVTinzl9BAAwICMixL8m8fPmScrmcy5Yty1a7N2/eZPo8bt26RQDU0tJi+/bt063n7+/PWrVqEQDHjh37P7GKQyD41ojVBAJBLmjZsiWio6Nx8uTJPLH3+vVr2NjYwMjYGI0aNsS2bdtybIskWrRoAT8/Pzx79gwqlSrNem/evEHv3r1x9OhRAIBbtZqYMm8ZLAskzd4f1qsDZImxOHf2bIbX02g0ePLkCd69eweZTAZbW1vY2NikWv/fpEkTxMTE4Gwm9r7G2toaffv2xZQpU9I8Hx0dDQMDAwwZMgRLlizBTz/9hJ49e0oJi3x8fHD06FFcuHABhQsXxpo1a1C3bt1s+SAQfK/876Q+Ewj+g4SEhMDW1jbP7FlbW0MmkyEiPBxTp07NlS2ZTIapU6ciKCgIBw4cSLPO3r17Ubp0aRw9ehTa2tqYP38+Vm3dJwkBAHhwxw/V0snyp1arceDAATRp0gQmJiYoVqwYqlevjmrVqsHW1haWlpbo1q0brly5Im3yVK1aNfj6+mZ74yZjY2NERaVe9piMQqEAAFSqVAktW7bEqlWr4ObmhnLlyqF+/fr4488/AbkS6/7ajICAACEEBIIvEGJAIMgFud0+Nz2btWrVgpOTU65tlS1bFpUqVcKWLVtSHI+MjETv3r3RunVrhIaGomzZsrh58yaGDx8OxRfpkSMjwvH+3Vspk+CX+Pj4oFy5cmjRogU+fPiAiRMn4uTJk7h//z7u3r2L/fv3Y8CAAbh8+TLc3d3RuHFjBAUFoXTp0oiIiMCbN2+ydS8xMTHQ1tZO9/zr168BAPnz58dvv/0GtVqNX37/E9sOncNV33t4/PIddu4/iiYt20GhTDtKIhD8qIiNigSCXFCgQAG8ePEiz+wFBQVBJpOhZs2aaZ6PjIyEj48P/Pz8EBoaCrlcjsKFC6N8+fIoU6aM9Hb8JTVq1Egx3HDx4kV0794dz58/h0wmw5gxYzB58mSpo03WNwkJCTh7/AgApEoqtGzZMgwbNgxlypTBlStXULly5VTXLVWqFJo3b47Jkydj//79GDJkCEqVKoWJEycCSNoPIKuEh4fj5cuXKFmyZLp1fHx8AACurq6wsLCAS7lyuO9/C937DYGFUUoR8TleDQMd8fUnEEh82ykLAsF/m6lTp9LExCTPJhAmT/rbu3dviuP+/v7s3bs3dXR0CIC6urosXLgwbWxsKJPJkvIAFCrEadOmpVovv3nzZgJg+/bt6eDgIK0UMDMz4/79+1P5cOraXfYdNpr5LQtIddevXy+dX7ZsGQFw2LBhWVrumMzHjx/ZsGFDKVXx+/fvs9z20KFDBMD79++nW6dTp04sVqyY9POgQYNYxLEo77wM55tPn/k2PE4q7yPiqBYTBwUCCTFMIBDkgrp16yIsLCzPJhDu3r0bAGBgYAAgKa3v77//DhcXF5w8eRK//fYb/P39ERkZicDAQLx69QoRERE4d+5c0rj4H3+gVKlSOHz4sGQz2daDBw9QqlQpNGrUCHZ2dggNDUXbtm3RpUsX+Pv7Y9euXWjQoAHqVS6DNYvm4P3bEJjkM4NpPjP4+fkBAG7duoVhw4Zh2LBhWLBgQbqTEtPC1NQU+/btg7u7O7S0tLK1W+Pq1avh7OyM4sWLp3k+ODgYu3btwoABA6RjpUqVQuCzJyCJr2dJawjEJWRvzoJA8F3zrdWIQPBfRqPR0MXFhQ0aNMj1ErUXL15I6YZ3797NqKgo1qlTh0qlkp6enllKIPTq1Ss2atSIADhr1iyS5KZNmwiAkZGRKeq+e/eOc+fOZaFChaQEQ8nFrVpNzli6gVcD3rFxq/YsUbIkExMT6eLiQmdn52wnM/qS169f08jIiD179sxS/Rs3blAul3PFihVpntdoNGzVqhXNzc358eNH6fjatWsJgH7PP/L1x5SRgbfhcQyNzHpUQyD43hFiQCDIJbt27SIAbt26Ncc2NBoN69evTwtLK+YzM+dvv/3GRo0a0cDAIMs7/X1pa+LEiQTAVatWcdSoUbSzs0u3fnR0NIcPH04ALONcloe9fekTGCaV5Vv2E4C0f8KFCxdyfJ/JLFiwgAqFgkFBQRnWi4mJYenSpenq6prukETysMXXOQhmzZpFPT193nkZzqDQmFRi4G14HOMS8mZ4RyD4ryPEgECQB7Rr144mJiY53iTojz/+IABWrlaD1WvVk8b2jx49miN7Go2GAwYMoK6uLkuVKsW2bdtm2mbdunUEwEEjx6cQA9effWLhIo40NTVl2bJl8yRJT1hYGPX19Tl16tR063z+/JmNGzemrq4ub9++neq8RqPhggULKJPJOHTo0FTnO3XqRJcKbrzzMpwv0xEDYdEiOiAQkEIMCAR5wqdPn+ji4kIzMzOeOXMmy+3i4+M5btw4ApAmAtraFaFcLufAgQNz5VNUVBTt7e0pl8vTnCiYFp6enlQoFNx88BxvPA/j3nN+7Dt0DLW0tKlUKjlp0qRc+fQlzZs3Z7169dI8d/fuXZYvX566urpppnp++PAh69evTwAcMWJEqgmccXFxtLC0ZPd+Q5LEwIe0xcC78DgmqsVEQoFAiAGBII8IDQ1lzZo1CYADBw7kixcv0q2r0Wh46tQpOjs7U6FQcPSvU7l2634aGhlL2xFnZ7Z9emzcuDHTWfgBAQH89ddfWbduXVpYWFChUFClUkm+fFkOHjyYa5+SmTx5Ms3MzKSf1Wo1b9y4wd69e1OpVNLMzIxTp06ln58f7927x3PnznHu3LmsW7eutI3z4cOH07S9bdu2pLkXJ6/wzstwPn+Xthh4Gx7HyM/Z391RIPjeEOmIBYI8RKPRYMmSJfjtt98QFRWFOnXqoGrVqihVqhR0dHTw4cMH+Pr64uixY3jy+DG0tLSxbvt+VKxcDQDwNOAhWjesjjatW2Pz5s259ic2NhbW1tYYPHhwqoyGz58/x9ChQ3H48GGYmprCw8MDLi4uMDU1RWxsLO7du4dz587h1atXUCqVSExMhI+PD1xdXXPtFwCsWbMG/fr1Q6NGjRAWFoY7d+4gOjoaenp6cHFxQVBQEF6+fJmijY6ODtzc3NC3b1+0bds2Vf4DICktsXPZsrCwLoRVW/YDAAx0lNDXTjuvgFwGmBmo/pUEUgLBfwWRdUMgyEPkcjmGDRuG3r17o1mLFjh16hS8L15E7OfPUh2VSoVChe1haWWNt2+Cce/2LUkMWBawRuznz6hTp06e+KOjo4OqVavixo0bKY7/9ddfGDx4MMzNzbFhwwZ06NAhzY6VJM6dOwdPT094e3tj+vTp8PLyytaSwvRQq9VJqZcjInDlyhW4u7sjJiYGt27dQpcuXTBo0CCEhobi6dOnSEhIgKmpKYoWLQqlMv2vLZIYMWIEgoODsXDdzhTH00NDIDZBA12t1AmbBIIfBZFnQCD4FzAwMMCoESNAEqb5zHH5biAu3HoKXT09JCQkQFdPD0NGTwAArF2xEPF/Z+N7EvAQAODi4pJnvpQrVw537tyRfl66dCl69uyJ9u3bw9/fHz169EhTCAD/pEY+d+4cli5div3796Njx45ITEzMtV+PHz+Gra0t3r59C3d3d1y4cAF+fn7o3bs3hg4dig0bNsDMzAyVKlVC1apVUbJkyQyFgEajwZgxY7B69WqMmzwLhe0d/jmXiS+f40XOAcGPjRADAsG/RK1ataBSqRDy+hUiI8KR38IS9g5J+w08efQATVu2h4VVAbx7E4L9u7YCAGKiowEAJiYmeebHlxv8nD17FkOGDMHIkSOxdu1aGBoaZsmGXC7HoEGDsHv3bhw4cACenp659uvGjRv4/Pkz3rx5g3Xr1kmplFevXo0+ffqgV69e6NKlC0JDQzO19eTJE3h4eGDOnDno0L0vWnfsnuI8M+nrEzVEfKIQBIIfFyEGBIJ/CX19fVSolJSz//KFM5DJgBKlywJIyssf/Poleg0YBgBYs2wB1Go1tP7eHyAmJibP/IiJiYGOjg6ioqLQu3dv1KxZE7Nnz87RGHmzZs3g6emJmTNn4ubNmzn26fnz5/D29kZYWBgOHjyIYsWKSefkcjlWrlyJDRs2YN++fbCxscGAAQNw/PhxfPjwAUBS2P/ly5fYvXs3WrZsiWLFiuHatWsAgP07vSRRlUxWpkZ9jlfn+H4Egv86QgwIBP8i9erVAwBcPn8GAOBY7J+Ndvxv+aJ9t14wNs2HwGdPcPzwPhRxLJp0zt8/z3zw9/eHtbU1/vzzT7x69Qpr167NVirgrxk7dixKlCiBSZMm5djG/PnzoVQqcfbs2TQ3ZZLJZOjRowcePnyIfPnyYd26dWjYsCHy588PLS0taGlpoXDhwmjbti0OHToElZaWNHQR+zkG/To1S2EvK+/88YmEWiPmUwt+TIQYEAj+RRrWrwsAuHrpAtRqtdTZA4D/bR/o6xmgW5+BAICVi+bANJ8ZbGwLw9vbO0+ur1arcf78edy+fRvTp0+HQqHA8OHDcfToUWg0OQuLq1QqDB8+HEeOHMHz58+z3f7KlStYsmQJJk2aBHd393TrHTt2DNWqVUNwcDDKly+PoUOHYvTo0fjpp58wYMAA9OrVCw0bNky6z6/mMPjf8sHaZfOkn+NjYxEVGZnhXAdCRAcEPzDfblWjQPD9k5iYSCNjEwLg9sNneeraPWnNvnO5CnwYEsWr919ST08/KX3w5j3sP2QUjY2NGRUVlevrHzx4UNrr4NSpU5w+fTpdXFwIgBUqVODdu3dzZDcqKooKhYLLly/PVrvAwEAWKlSIbm5uTExMTLOOWq3mzz//TACsV69emtkHv+TNmzccPnw4ZTLZ3zkSknZFhEzGytVrsaCNrfTMFQoFS5Yqza49evPQyfN8ExabajfDvMiwKBD81xBiQCD4l2nSrAUB8Ocxv/F+UAS1tLSTEgtpafHOi498GBLFngOGJnXQbu48ff0e5XI5p02blqvrJiYmslKlSqxQoUKK4xqNhufPn2fx4sWppaXFzZs358h+qVKl2L59+yzXv3jxIm1sbFikSBG+fv06zToajYb9+vWjXC7n4sWLs9Uxe3t708TEhDKZTNrwqVKlShw9ejTXr1/Pbdu2cdmyZezXrx/t7e0JgOVcK/C09/UUgiAmLm2RIhB8zwgxIBD8yyxYvJQAWLFKNT4MjmLxkmWkN9U9Jy7xYUgUz/sGUKVSEQC37DvBfkNGUqVSZfpWnBHTp0+nXC7nlStX0jz/+fNn9uzZkzKZLEebLLVt25YKhYJTp07lu3fv0q0XEBDAn376iTKZjFWqVElXCJD/7DS4YcOGbPuTvMsjAHbo0IH37t1Lt65areaRI0fo7OyclGZ52ox/djOMEvsVCH48hBgQCP5lHj58KKUY9nn8hk1atpPEwORZi/gwJIoPQ6LYrktPAmCNOg145/kHFi9ZmjY2Nnz8+HG2r7lp0ybKZDKOHz8+w3pqtZpdunShvr4+nz59mq1rdOjQgXK5nHK5nEqlkjVr1uSYMWO4aNEiLliwgEOGDKGbmxsBMF++fJwzZ066QwMkGRwcnK2tjb8kOjqaHh4e1NfX5549e7LcLi4ujmPGjCEA/jL+N0kQxIvdDAU/GEIMCAT/MhqNhja2hQmAKzfv5tBffpXEQLvOPZPEQHAUj1++TblcTgDcf+oKL/g9ZhHHojQzM+P27duzdK2YmBiOGjWKMpmMvXr1SrWBT1pERkbSzs6OdevWzdZ9ubu7p9q7QKVSSQLB0tKSnTt35l9//cWYmJhM7U2cOJGGhob89OlTtvwgKe3QeOnSpWy3Jf/ZNfKvrbv4NjyO4TFivwLBj4UQAwLB/wNde/QiAPboP4TzV26UOs/ipcpIkYGHIVFs3KINAbBJy7Z8FBLFK3cD2aBpSwJg7dq1uWfPHsbGxqay/+7dO86dO5d2dnbU1tbm7NmzsyQEktm1axcB0MfHJ0v11Wo1dXV1U4mBLyfqdevWLcvXT0hIoKWlJYcMGZLlNsmcPn2aALhs2bJst01Go9GwSZMmtLC04qPAN2I3Q8EPhxADAsH/A39t8iIAOhYrwdVe+1J0mreevZfEwL5TVwiAcrmcJy7f5qOQKD4KieKStV4sV8FNalOqVCk2bNiQdevWpZ2dHQFQS0uLnTt35oMHD7LtX0JCAm1sbLK8bfKJEyfSFQLJxdDQkAMHDuS0adN49OhRhoeHp2vv9u3bBMBz585l23cPDw9Wrlw5W+InLYKCgqitrc3fp/zJt+FxjIoV0QHBj4MQAwLBv8zr16/5yy+/UKlUUiaTpQqrV69Vjxt2Hub1B0G89fQda9RpQABs36WnJAYehUTx7stPKdpr6+iwSJEiHDVqFL28vPj27dtc+Tlw4ECWKlUqS3WbN29OLS2tVAIgeZjD2NiYpUuXZtmyZWlsnLQVsp6eHvv375/mHIj169cTACMiIrLl8717SUs1szqMkhndunVjYTs7hnz6LJYZCn4ohBgQCP4loqOjOWLECCqVSurr67NLly5ctGgRjx8/ztOnT3Pq1KksW7Ys9fT0UnTy+czMpQjAySv+khg4fulWijpyuZyrV6/OM39Xr15NuVzO6OjoDOsdOnSIADhw4EDJH5lMRltbW86ZM4eBgYEpOlGNRsOAgABOnjyZ1tbW1NHR4bx581K8yc+YMYOmpqbZ9nnBggXU1tZmXFxcttumxZEjRwiAV33v8W14HD/Hi2WGgh8DIQYEgn+BgIAAFi1alDo6Opw+fTrDwsKkc/fu3WO1atUIgLa2tuzbty+XLl3K7du3c9OmTRw/fjw9PDwok8moq6vL36fP44PXEVy1ebfU+ZarmDRkcPDgwTzzObmTz2jpX2BgIK2srNioUSNGRkZSV1eXCoWCnp6eWeqQo6KiOGzYMAJg9+7dpdUFM2fOpImJSbZ97tatGytVqpTtdunx/v37pIme6zbzbXgcP4plhoIfhPT3AxUIBDni2bNnqFGjBoyNjXHr1q0Um/CsWLECP//8M+zt7bF//340adJE2q3va54+fYrp06djyviROHnkANyq1pDOFXEsCr8b16BW51363GRb6fnz4MEDNG7cGHp6eli7di169+4NjUaDo0ePSnswZIa+vj4WLlyIypUro2vXrjAxMcHChQtRsGBBhIWF4dOnTzA1Nc2yz0FBQShSpEiW62eGubk5DA0N8SbkNQAgQU0kqDVQKUTmdsH3jfiECwR5SEJCAtq1awd9fX2cP38+hRBYsGABfvrpJ/Tt2xd+fn5o3rx5uh0vADg4OGDNmjU4efIkHt27g01rlknnSpUpBx0dXTx+/DjPfA8ICICenh7Mzc1THI+JicGsWbNQrlw56Orq4uzZszh9+jR27tyJTZs2ZVkIfEmnTp0wf/58LFq0CKdOnYKrqysAZHsnRJI52n0xI+RyeYpdDj/Hi62NBT8A3zo0IRB8T/z5559UKBS8ceNGiuNnz54lAI4ZMyZHk9Ju375NQyMjaW5BPrP8VCgUbNu2bV65znbt2rFs2bIMCAjg7du3uWXLFg4aNEhK8Ttq1CjGxMQwOjqaZmZm7NSpU66up1arWatWLTo5OTEhIYG2trbZTjjUsWNHVqtWLVd+fMmnT58IgEtXrZcSEIllhoIfASEGBII8IiYmhvny5ePQoUNTHI+Ojqa9vT2rV6+eq+VvW7duTTV7X0tLix8/fsyt6/z48WOaqwPs7e05duxYPnv2TKq7bt06ymQyPnnyJNfXvXTpEgHQw8ODxsbG1NLSYnBwcJbbz5o1i/r6+hlmNswOyTkLLly7lWK/gqhYMZFQ8H0jhgkEgjxi165d+PjxI4YNG5bi+ObNm/HixQusWbMGcnnO/+Q6dOiABg0apBhaSEhIwNKlS3NsM5mlS5eCJE6cOIFz587hypUr+PDhA549e4YZM2bA3t5eqrt582bUq1cPDg4Oub5ulSpVUKJECTx8+BA2NjbQaDQYMGBAijB9RtSqVQvR0dE4duxYrn0BgJ07d8LSqgAcnYqmOP45Xp1lnwSC/yTfWIwIBN8NPXv2pKura6rj5cqVY/PmzfPkGmkl+1GpVLx//36Obd6/f5/a2tocPXp0pnXVajWNjIz4559/5vh6XzNkyBAWK1aMmzdvlu5p5syZWWqr0WhYvnx51qtXL9c5AUJDQ2lgYMDR435NERVILmKZoeB7RkQGBII8wtfXFxUqVEhx7MOHD/Dz80PHjh3z5Bp16tSBiYmJ9LNSqYRGo0GzZs3w9u3bbNt7+/YtWrVqBTs7O0yZMiXT+kFBQYiIiEDZsmWzfa30KFu2LB49egRHR0fp2NixYzFhwgQkJCRk2FYmk2HChAk4efIkduzYkSs/hg4dCrlCgR69+6V5XkwkFHzPCDEgEOQRISEhsLW1TXHMx8cHAFCxYsU8uYZcLkfFihVh7+CE6w9ewczcAmq1GoGBgahatap0vazg4+OD6tWrIyIiAocOHYKurm6mbT5//gwAMDQ0zPE9fE2yLX4RhjcxzYdZs2bB1dUVx48fh0aTfkdcrFgxFCpUCP3798f9+/dz5MO6devg5eWFylWqwsLSKs06ycsMBYLvESEGBII8QiaTpRpXfv06ab36l2PuucXBwQE6uroYP2Ig3r4JBgDkM7eAtp4B3NzcMGLECDx//jzd9s+fP8fIkSPh5uYGAwMDeHt7p3grz4hkwRAZGZn7G/mbqKgoAEB4eLh0bMio8WjUvA0ePHiAhg0bokiRIhgwYABWrFiB7du3Y8OGDRg9ejSquLujdOnSeP36NaKjo1G9enVcuXIly9cmiYULF6Jv374AgBPHjuC2X/qCSkQHBN8rIumQQJBHFCxYEIGBgSmOJYuDvFwLL5fLERz0Cg/u3pGOFbItjI27j6JVPXcsXrwYCxcuhKurKypXrgw7OzsAQGBgIK5evQpfX1/I5XIUKlQI3t7e0NfXz/K1bWxsYGhoiDt37qBx48Z5cj+3b9+Gk5MT/P39IZfLoaWtjcrVa2LmlIlQq9UYN3km5kydiHXr1iExMVFqZ12wkJQoKTlyEB4ejqpVq2LEiBEYO3YsLCws0r3unTt38PPPP+PcuXMAkpItqdVqtGvRGPeeBkGlUqVqE5eggUabkMvzNreBQPCtkfHrVxmBQJAj+vbtixs3buD27dvSscOHD6Np06Z4/vy51CnnlsaNG+PYsWMpohD2Dk6oXb8x1i5fKB3T0taGlpY2PsdEA0gSEQkJCXCp4IZKVapjzdJ5aNy4MbZu3QoDA4MsXZskSpQoAVtbW5w4cSLX90ISLi4uKF26NIKCgnDx4kVUrVEHVgUKYqfXBlSqUh2zlqxDzfJOAACHosXxNOAh9A0MUdjeAff9b0Eul0tioICNLUKCXkIul0Mul6NFixaoWrUqSpcuDR0dHXz8+BF+fn44cfIkrly+DJWWFhLi41P5VaNWHezYdyRNn/W1FdDXTj9ZlEDwn+SbTV0UCL4ztm3bRgC8d++edCw4OJgAuGvXrjy5hkajoZmZmZR8qIxLeQKgUqlKscJAJpPxr11HaGRskmpXQZ/Hb2hjW5jOzs7U09Ojvb09T548mels/JcvX7J58+aS/S9zD+SUK1eStmxesWKF5KN5fgsqFAoCoNf+U1ywcpN0bvrCVSzpXE76WU/fgNY2tn/fm4J9hoxKcb8KhULaSTG5mOYzY826Dblw9WZu3H2MWtra0jml6p/nOG/RijRXFXwQuxkKvkOEGBAI8oi4uDhaWFiwX79+KY4XL16cHTp0yJNreHt7p+jYps1dlmqpIQCWLONCIxPTNM+N9fyDAOjv788nT57Qw8ODAOji4sK5c+fy4sWLfPfuHUNDQ3nv3j1u3LiRbdq0oUKhoIWFBb28vJgvXz527do1V/ei0WhYs2ZN2traskaNGpIASC616jXi/deR7N53sHRs8uwlzG9hJf2sq6efoo2evgEB8Odxk9K8d30DQ954FMyHIVF8EJxU5q/c+JWAUCb9q1TS9+6TdJYZ5jx5lEDwv4gQAwJBHrJgwQLKZDJeuHAhxTGlUsmXL1/m2n6bNm2oVCZ1VqWcy1HfwDDNTi+jUrxUGVarXl2yqVarefToUTZr1ozaX7wlf1mcnZ25ZMkShoeHkyTXr19PANyzZ0+O72Xp0qUEwDZt2qR5zeHjPHn3VbgU/fiys7e1K5JCCNg5OH1xf86cvnA1AdDA0CiV3fFTZklCILmMnDAlZb2/Iy82hWz5Jiw2lRgQuxkKvjeEGBAI8pDExERWrVqVhQoV4osXL0iSYWFhzJcvHxs2bJir8PKRI0fS7DS/DoMDoLa2Ds3M86dZX0dHJ92kQfHx8fTz8+PevXu5a9cunj17lp8+fUpVT6PRsHXr1tTV1eXp06ezfS87duxIFQn4Okyf3MknD4kkF5cKlTlp1uIUxwoULCT9f+XmvWzaugMBsPegEXQqXipV9MDv+ccUYuD+60i269IzzefVpXuvNKMDCYkiOiD4fhBiQCDIY4KCgmhnZ8fChQvTx8eHUVFRNDVNCtnPnj07RzafPn1KKysrqr7qLB2ciqfqvAoVtmPPAUNSHf+yUz127Fiu7zMmJob169enSqXi1KlTGR+f+dtyTEwMR44cSZlMxnLlyqXq6DMrNeo24PpdR6mtrUMArNu4BVVf7KmQ3NGbmOYjAK7feZQVq1RP8bYPgIXsivDaw2Defx0pCYI7Lz6xao06aV53+55DqcRAeExCrp+hQPC/ghADAsG/wKtXr1iuXDkqFAo2bNiQMpmMP/30EwFw8uTJ2dpYx9fXlzY2NnR0dOSECRPSjAR8WdZtP5BiUlxab903b97Mk/uMi4tjkyZNKJPJ6OTkxAULFjAoKChFHY1Gw+fPn/OPP/5goUKFqK2tzZkzZ7Jx48ZpRge+LMnj98nFyNiEen8PD1Sv3YC+zz+mmB8gk8m4ZvtBAqChkTF9n4WyROmyf4f8C9P4i3kUJvnMuP/szRSC4MajYBYtUSqVH7q6unwS9CGFGHgXHke12M1Q8J0gxIBA8C8RHx/PyZMnU6VSsVGjRtRoNJw8eTJlMhkrV67MK1euZDhs8OHDB06cOJFKpZLlypXj69ev+f79eyqVSjp/MY7+ZSnlXI7uHrUJgOUqVk45dKCjK/3/8uXLeXafy5cvJwB26NBBms9gZWXFSpUqsUKFCjQzM5OGJ3r37s0HDx7wxYsX6UYFPGcsYrESpTMcDpHJ5ezUcwBPXn/IqjXrphpGAMAGTVvT/1UECxW2JwAWK1mGp67dp0z2jx2FUsnZyzbw3heC4MyNhzS3sEx1/bLlyqeKDkSL3QwF3wlCDAgE/yIxMTFUKBRcsWKFdOzixYssVqwYAdDV1ZUTJkzgrl27eO7cOR4/fpzz589nhw4dqK2tTS0tLXp6ejIuLk5qX61a9XTfpLV1ksLnKi0tLlrrlfLtVk+fWn+H19euXZtn9zhs2DA6OTmRJN++fcs9e/Zw4sSJ7Nu3L/v168dJkybx4MGDKbZa7tGjR7pRAaVSyXxm5une45ciQvG3+FAolCxYqHCKetPmLaf/qwia5bdIetYVK/NuUARbtu+SymaX3j/R/1W4JAh2HbtIXV29VPXG/zo55TLDSLHMUPB9IMSAQPAvkrwU8Pr16ymOJyYm8vDhw2zdujWtrKxSdDja2tqsVKkSp0+fznfv3qWyOXLkSKpUKsozCLEXLFSYU+csTbez7du3b7o+x8TE0MfHhxcuXOC1a9cYFhaW4nx0dDR37drFsWPHsmnTpjQxMaG1tTXHjBnDnTt3Mjo6OsNnsn///q8694yHPdITBF8vnSxWskyKn1ds3kv/VxHSCgSP2vV5NyiCu09clmzo6v3T4ZctX4k3Hr+RBMGyv3amil7IZDKeu+KTQhDEimWGgu8AIQYEgn+B2NhYenp60tAwaelf8sqC9Hj79i0fPXrEZ8+eZToRb+bMmVQolWzbqUeaUYGsTMrT19dnZGSkZPPTp09csGCBNM/h6/pFixblmDFjOHDgQGkypI2NDZs0acKOHTuycePGLFQoaUa/iYkJR44cmeYqhLNnz1JHRyeFjzq6upn6m1w86tRnJXePLNU1NTPnYe9bkmhq0rIt7wZF8G5QBKt41CIAtu/ah/aORVO0OXLxFh/8PWzw67Q5qezmMzNj8McYSQx8EssMBd8BQgwIBHnM7du3WbJkSapUKrZq1YoA+OTJkzyzP23aNKq0tNIMY2enzJgxgxqNhqtWraKhoSGVSiXbtWvHFStW8OrVq3z48CF9fX35119/sVGjRlSpVNTT0+Mvv/zCx48fp+nb06dPOXbsWBoZGdHa2lpatRAfH8+pU6emmREQSJkPoFBhe+465p3mvAEgacVAnYbNUt1/8pDBl8XM3EL6f8fufSUxsGLT7iRRZGBIb/9ANmrZLkXkZMEaL0kQdO83OJXdho2bimWGgu8KIQYEgq9ITEzkgQMH2KtXLyllr0qlYv78+VmvXj16enqmm4r3xo0bNDY2ZpkyZXjnzh0+e/aMAHj48OE8869r1660trZm9+7dWbx4ccpkskxn5SeXmnUbpuj06tZNmnzXp08fhoSEpHm9bdu2UaFQsE6dOplGOJJ5+fIl69evT7lczi5dutDOzi7DiMWXHfmeE5d5/3VkitwB6RW5XM7K1WpkqW7fQcMlMeD/KpwORZOWZY7+7Q/eehnBCX/Mp+wLodJz4DDeD4rg3VfhrF2/SSp7y1ZvkMRAhFhmKPiPI8SAQPAF27dvZ+HCSRPRSpUqxX79+nHevHlcsmQJJ02axObNm9PIyIgymYxt2rRJsYzuzZs3zJ8/P93c3KRMfRqNhvny5ePvv/+eJ/5pNBo6Ojpy0KBB0rHXr19z0qRJNDAwyFQUfNkhy+Vy6ujo8MCBA+lez9vbm0qlkt26dWNCQvY6vMTERPbs2TPLuQSSlz7uP3Odh8/7SMe/zLJYNJ1oAQBa22QsCAyNjDlh6mzeePyGd4MiOHn2EgKglbUNfZ99pN+LcHodPi/NMQDAchWr8NazD/R58pYlSjmnsKdSqej/+OU/ywzFRELBfxghBgQCklFRUWzfvj0BsFWrVqkm/H1dd9WqVbSysqKJiQl3795NjUbDhg0bMl++fKkm/XXv3p329vbZyi2QHpcuXSIAHj16NNW5V69esW7dupTJZDTPb8FyFdwyfas+efJkuteKjo6mg4MD3d3dsy0EkknOyJiZSHH3qCWtBti4+5jU6SuVSpYq88/GRHZFHNm2a+9MhYVKS0uaQ/F1yWdmzmFjf+c538fSqoXZy9bT70U4/V6E8/ydFyzyRTKnfOb5efLqXV649ZT5LVNO9izi4CiWGQq+C4QYEPzwREdH08PDg/r6+ty2bVuW24WGhrJt27aUy+Xs0CEp/e3WrVtT1bt69Wq657KDRqNhixYtWKRIEarVaY9RJyQksEOHDlSpVPSoXT/DCMGECRMyvN6MGTOopaXFR48e5crvJ0+eUOuLLIFpdt4qFW3tHAiANeo0kI7Xb9JSOm5oZEwA1NJKSqjkOXMR+w0bnSKR0Nfly9wKXxd9A0OW+zsnQemyrvQLDJcEgc/zT2zSuuM/UQulikvXb+eBs9ep89Vchb4DBotlhoL/PEIMCH54evXqRX19/Rwl4lGr1VIo3MrKKt1OunXr1syfP3+aSwWzSvIWyTt27MiwXlxcHJ2dnanz95vxlxP29AySQuCWlpaMjY1N10ZiYiLt7OzYo0ePHPv7Jb1795YSEn1ZLAsUlP6fVvRgxsJVkgjo98X2xCWdXXjnVTj9gyJ4LSCEg0ZNSD3s8NW2zpmVWUv+iQ4kl99mLEzx/PoOGcl12w+mGvrYd+SUWGYo+E8jxIDghyZ585/cJOGJi4tjyZIlWaBAgRTJgb7kzZs3NDc3Z9WqVVMs6csq165do4GBAdu3b5+l+rdu3aJMJmPZsmXZoUMH1qlThyYmJpI4mDx5cobtk6MZ3t7e2fY1I3tfl93HL0oZE1MOYSQJg8MX/pk7sHHPcen/bTr1oH9QhFQm/jE3KWzvVIwm+cwy7fjTm8fQoHkbbjt6MYUg2HbEm/oG/8wjKO/mTs8ZC1O009PTZ+CbMH6KjmdwcDBXrlzJfv360cPDg25ubqxfvz5Hjx7NXbt28fPnz3nyTAWCvESIAcEPi0ajYbly5VirVq1ch3dv3rxJAPTy8kq3ztWrV2loaMjy5cvzwYMHWfZxy5YtNDAwoLu7e7aERNOmTeni4iLdm0aj4erVSVv73r59O8O2S5YsoUqlyjB6kB3i4+NTbbIEgKev36fPk7e0/2IL4uRNiMwtLHnO94kkYBo0ayXVMTQy5kX/QEkMePw9tDB8/GSOmzyTAGiWP2VKYWMTU+p/MTkwI1FQtVY9rt15VBIE3ndf0aFoCem8eX6LVLsclnF2YYvW7ahUKqlQKOjs7MxOnTqxd+/ebNmypTQx1dzcnL/++mumyZkEgv9PhBgQ/LAkv63m1bK/WrVqsVq1ahnW8fX1ZdGiRamtrc2xY8emu1RPo9Hw7NmzbNy4MQGwU6dOjIqKypY/e/bsIQB2796dkyZN4oEDBzht2jTq6OhkOiFw6NChLFmyZLrn4+LieODAAY4fP56NGzdm1apVWbNmTfbv358rV65kcHBwqjYlSpRI1ele8Q/kpTvPUgwXJJd6jZpz/+lrUuef3HkXLuJIAOw5YBj9gyJ44/Fb6vw9N2D3ySvceugsgaRNjZq17ZTKbrIoyWiVg0qlks4bGhmzcvVa/GnkBNZt0jJFndJlXb+IZshpY2PDBQsWpJlwiSQfPXrE4cOHU0dHh05OTrx27Vq2fqcCwb+FEAOCHxZPT0+amZnlySx/kly7di0BpErf+zUxMTEcN24cjYyMKJfL6erqyn79+vG3337jhAkT2KZNG9ra2hIAixcvzj179uTIn+DgYAKgra2ttFmQQqGgnp5ehqslSHLAgAF0dXVNdTw2NpbTpk2TUihbW1uzSZMm7N69Ozt06MAyZcpQoVBQqVSyffv2KZITubq6pup0r91/JU3i+3IJIQBWcq/Ov3YmDeMkZyls1qYjl23cRQDU0tbmiWv3pJ8tCxTknVfh9H0eKomDmvUaS/a69BpAC8sCKa6hraPDqjXqUKFQSnMWKlSowGHDhnHJkiVcuXIlPT092aRJE+rp6SW98btWSiEkklctDBw4MMuRm4cPH9LNzY26uro8depU9n6xAsG/gBADgh+WZs2asUGDBnlmz9/fnwB49uzZLNWPjIzk2rVr2atXL5YtW5YGBgY0NDRkzZo1OWrUKJ4+fTrXwxfGxsZSpsHAwEAuWLCARYoUoUwm46hRo9Idvx49ejTt7e1THLt16xZLly5NlUrFn376if7+/mm2/fTpExcuXEg7Ozvq6upy8eLF1Gg0tLe3TyUGmrZqL73Fd+09MNX5dp3/CcWrtLR44upd3nkVzgqVqxEAW3boyk49+yfV7dpbGjZwdXMnABYr+U9egiMXfOn37AP/WLCCDl8sHUyeINinTx8+fPgw3WcZHh7ORYsW0djEhMYmppLgAMC5c+dm+3cTExPDhg0bUl9fP8PrCgT/HwgxIPhhcXZ25uDBg/PMXmxsLAHwr7/+ynbbxMREurm5sW3btnnmD0laWFhw6tSpKY4lJCRw5syZ1NbWpoeHByMiIlK127hxY4oox8WLF2loaEgXF5dM5xskExUVxaFDhxKA9C8AGhikHLdXKBRct/2gNNafXunRf0hS9sCgCG7ef0oK9ScPMSxat00SA71+Gp40b+CLdMRnbjzkvS8yEE6YNodKpZJmZmY8c+ZMlp9pSEgI69atK6VW7t+/f5bbpvWMHB0d6e7unmcRKoEgJ8ghEPygaDQayOV59yeQbEuj0WS5TVRUFKZPnw4HBwdcu3YNb9++zTN/EhISEBYWBlNT0xTHlUolxowZgzNnzsDPzw9t27ZN5XPlypUBAKdOncKLFy/QpEkTuLq6wtvbG87Ozlm6vr6+PhYtWoTFixdj8eLF0nH3GnVS1Pvtz3moUr0W9PUNpGNFHIumqKNQKjFg6Gjp57LlK6Fuo+Ygibchr6HS0oJbVY8U5wEgIiJMOqarpwfZFzbPHDuEfPny4fLly6hVq1aW7gkArKyscOTIETRq1AgymQxDhgzJctuv0dfXx7p163D58mXs2rUrx3YEgtwixIDghyV//vwIDg7OM3vJtszNzbNU//z583B2dsbkyZNRu3Zt9O/fH3fu3MmWmMiIe/fuIT4+Hi4uLmmed3d3x549e3DixAksWbIkxTknJye4u7tj2bJl6NOnD4yMjLB//34YGBikaSsjhgwZgmHDhkliydLKWjpXvVZddOzWBwBgYGgoHa/XuDlGTZzyjxESnz9/TmF36NjfIZMlde/FSpaB3hdiIlkMJMTHS8d0dfWk/+/csh5XL57D5s2bUbRoSuGRFVQqFby8vFCgQAH8/PPPIJltG8lUr14dNWrUwLJly3JsQyDILUIMCH5INBoNSjuXhY+PT57ZTLbl6uqaad3NmzejTp06sLGxwd27d7Fu3Tp06tQJ4eHhuHLlSp74c/ToUejo6KQrBgCgbt26GDx4MMaPH4/Q0NAU537++WecOXMGp0+fxurVq2FsbJxjX6ZPnw4bGxsAwO5tG6XjjsVKAgBkAAwMjaTjLhUqQ6WlLf2sVqvRrXV9REaES8eKOBaFuYUlACDsY2iKDtk8vwVsCtul8EFLO8leQkICVsyfge7du6NevXo5vidDQ0OsXLkSZ8+exfnz53NsBwD69OmDCxcu4P3797myIxDkFCEGBD8Eao0G0XGJ+BAZh6CPsXgRGovS5d0RGBiIW7du5ck19uzZA6VSidOnT2dY79ixY+jRowe6d++Os2fPwtHREQDg4eEBBweHPHlDTExMxMqVK9GxY0fo6+tnWNfT0xOJiYlYv359iuPt2rVD/vz54erqigYNGuTKHz09PYwdOxYymQwx0dHS8asXz8P73ClcvnAWd+/4ScfjYj9jyZw/UtgIDnqF7q0bIODhfQQ+e4xH9+7gY+gHAEDQy0Ac3L0VoR/e49PHUISHfUKJUmWltjq6elCr1dBQg7PHD+Pd2zcYNWpUru4JABo1aoTixYtj6dKlubJTpUoVAMhTcSoQZItvPGdBIPhXSFCrGRGTwHfhsXwV+pnP3kXz6VflUXA4La0KsE+fPrm+3ps3b6ilpUXncq5UKpXcsmULyaT1+Ldv36a3tzevXbvGZ8+esUCBAmzQoEGaE8aWLFlCmUzGS5cu5cqfmTNnUi6X09fXN0v1O3XqRGdn5xTHwsPDKZPJuHz58lz58qW9tFISf4tSvHjxPLknkpw2bRoNDQ3TTUWdFTQaDbW1tblw4cI880sgyA4iMiD4LkhM1CDycyLeRcThVWgsXobG4n1UPCLj1IhXa5DWiG5kRDjM81tg3bp1uQ7NDx06FAYGhti8Yx+atWiNLl26wNLSEgYGBihbtiyqV68ONzc3FClSBKGhoXBwcMDLly9T2Rk4cCDc3NzQo0cPfPz4MUe++Pj44Pfff8fIkSNRrly5LLWpWbMm7t69i5iYGOmYn58fSKJatWo58uNrjIyMUKJEiVTHHYuWQNESpWBkbCIdS54LIPt7noGxab4Ukz1VKi0olEoAyPYkUKVSiapVq2bX/XSpWLEiIiMj8eTJkxzbkMlk0NbWRvwXcxwEgv9PhBgQ/CeJT9Qg4nMC3oXH4VXoZ7z8lNT5R8WpkZCFCXjHD+1Hg2rlcc//NuRyObp06YJ3797lyJfVq1dj586dmDZrHi55n8eFc2cgl8tRoUIFzJs3DxcvXsSDBw/g5+eHzZs3o3fv3tiyZQscHR0xatSoFBPjFAoFNm7ciLCwMNSrVy/bqwuuX7+OBg0awMXFBVOmTMm8wd+4uLhAo9HA399fOhYQEACZTIbixYtny4fMrqNQKFIcG/P7n9h/6hoKF3GUjpFEuQqVoaXSAgDsOHwOF249gWm+pMmZCQnx0NXVBQAs+WsXfh4/GQBgaV0Qlx8E4/qT91i+eZ9kr2Chwrh89wUu3HkGfX0DODg45Nk9OTk5AQBevXqVYxuxsbGIjo6GkZFR5pUFgn+Dbx2aEAiyQlyCmmHR8XwTFssXH2J462kIT17244lLvvQNCEo1BJBeuX4/kE1atpXCxUWcinPW8k00t7BkiZIl+ezZsyz7pNFouHTpUspkMnbr1ZftOnUlALZt146BgYEZto2KipLW+pcoUSJVWuLbt2/T0tKS5ubm3LZtW6bJh2JjYzlp0iQqlUpWrlyZHz9+zPJ9kOT9+/cJgHp6eixWrBiLFi1KExMTamlpsUKFCuzbty/Xr1+fo02WvqRfv37SUIFcLqdCoWDZ8pV4+JwPVV9tc7x22wHp/9cfvub915E8cul2ii2EVVpavBbwllcehdDCypoAOOq3P+j3IoyL1u+Q6llYWXPN1gOcMmcJdfX0OGPGjFzdx5cEBgYSAE+cOJFjG9evX0/KyCjSEwu+EUIMCP4niY1X81NUPEPCYhn4PoZP30Xz6IUb7NZnIIt8salNcilU2I7tu/Tg3hPe6QqBxWs2MZ+5uZTopvfgUbz84C1vPgvj3tM3aWNrR319fS5evDjTneUCAgLYqFEjAqB79RqsXrM2lUplthMO3b9/n/b29rSzs+Pr169TnHv79i3btGkjjXHPnj2bV65cYWRkJBMTE/n+/XueOHGCv/zyC83NzalQKPjbb7+lu3NiRqxYsUJKx2tsbMwGDRpwxIgRHDNmDHv27ElnZ2fK5XIaGRlxzJgx2d4nIZnWrVuzdOnS3Lp1K2fPns0OHTrQ0NCQMpksRYrfKtVr8vT1B1KHfy8ogvdfR9I/KILbjpyn7O+sgTKZjMs37+WGPSfYulNPKU1xtVr10tzvAEjaU2DYsGE58j8tLl26RAD08/PLsY2pU6dSoVDwl19+YUBAQJ75JhBkFSEGBN8ctVrNz3GJ/BgVz+BP/3T+yeXa3Wds2DRpgxhLS0sOHjyYGzZs4Pnz53nhwgVu2bKFI0aMkHaFq+pRi+dv3v+n/b3nbPTFjneOxUpy84FzvPksjDefhdEvMGlnuov3gti2a++kzHVmZhw2bBi9vLzo5+fH+/fv8/z585w/fz7r1KlDAFQqldTV1ZU6sR07duTo/l+8eEFra2vWq1cvVQRAo9Hw/Pnz7NChA7W+enNOLqamphw+fDgfPXqU7WvHx8dz2LBhBMBKlSpx//796W5iFBgYyHHjxlFXV5cODg45eou1t7fnyJEjUxyLjo7mihUraGJiIgmShau3cNcxbwJgPjNzLtuwg7/9MY99Bo9k45btpJ0Nc1oqVaqUbd/TY+HChdTS0sqRCCOTMkIWKJByz4Tq1avnSSRGIMgqQgzkARqNRqQSzQZqtZoxcYkMjYxn8KfPfP4+/bD+1v3HaZrPjObm5tywYUOGX7iJiYncs2cPCxUqRH0DAy5fv5ULV/1F03z5pM6737AxvPrwXSoh8GXZd9aHXfoMYsFChVN1IgqFgk5OTvzjjz8YGRnJV69e0cDAIFcpaUnyyJGkDXnWr1+fbp3Y2FjevHmTW7ZsYd26dWlmZsb79+/neBZ7fHw8mzdvTpVKxYULF2bZTkBAAN3c3Kinp8fz589n+XoBAQEEwO3bt6d5/s2bN6xbty7lcjnNzPOn2+HLZDIqlUrKZDLK5fI0t0ZOq/w0YhznrdzIfkNHUaFQMCgoKMu+Z4SHhwdr1qyZ4/azZs1K12cDAwP26dOHFy9ezPU+FQJBRggxkAPUajWPHj3Knj17snTp0tIYqI6ODitWrMjBgwdnuivcj4RarWZ0bAI/RMbx9cfPfJZB5/9l2X7gJHV0dVmrVi2+e/cuy9cLDw9n6zZtpA1oALBYyTL0OnRBEgHpCYGvy+rth2lkbEITU1MuXLgwlRgZP348jYyMGB4enuvn1Lp1a5YoUSJLX/p5sf3y0KFDqVKpeOTIkWy3jY6OZu3atWlkZJTuNsxfM3LkSObLly/DIZi4uDg2bNhQihB8LQK0tLRYr149TpgwgUuWLOGiRYs4bNgwVqhQgQCor29AUzNzKQL0ZfuVm/fw3usIXn0QRD09fU6cODHb9/01d+7cyVTEZYSvry9VKhVVqtRRHz09vRQ/Fy1alDNmzEhze2iBILcIMZBNjh49SkfHpP3US5YsyQEDBnDJkiVct24d582bx+7du7NQoUIEwMqVK+dqHPG/ilqtZlRsAj9ExjLoY9pr/DMrPo9eMb+FBWvUqJHp+H1aJCYmslWrVlQoFOzc+ydeffQu20LgwAU/muYzYzlX1zTFSGJiIvPnz59n489nzpwhgCy9bWs0GpYqVYouLi7phvUz4ty5c0nh+Fysaw8LC6ONjU2awxtf8+jRI+ro6HDChAmZ2v306RMtLCyk4RelUkl9fX3OnDmToaGh6bYLCAjgwIEDKZPJ0hQTDZu1oueshZw0cxHrN2lBbW1tPnjwINv3nUxiYiIrV65MlUrFatWqZ7p19df4+vrS1NRU8rV8pSrU/UoAAKCdnV0KYaBQKNi0aVPu2bMnx0MTAsHXCDGQReLj4zlgwAACYL169Xj58uV0vwATExN54MABlilThkqlkrNmzfquQ3wJajUjPyfwXUT6CX6yW1q170wTE5NUk+qyQ3h4OG1sbFi5Wq1sCwGf559YrmIV2hcpkm4HdPfuXQLI1o53GaHRaGhiYpJql8H0GDlyJGUyWZbrf4mbmxvd3d1zlSiHJA8dOpTpTPrPnz+zcuXKdHR0ZHR0dJbs7tq1i0DSioOqVatmOfpAkufPn6elpaXUyaaX6EihULBMGeccR3UmTpxImUzGnv0GU6FQ0NraOksrChISEjhjxgwqlcpUosXWrgi79hqY6rhMJmPVqlVZqVKlFMfz58/PkSNHprudtECQVYQYyAIJCQls3bo1VSoVV65cmeWOPS4ujuPGjSOAPAlJ/q+QkPhPdr+XedT5f1m8fR9SLpdz8eLFufY1uVPZtP9cloWA34tw/jZjUaZv6Zs2bSKAbL8RZkTt2rXZqlWrTOtpNBqWKVOGRYsWJQCuWbMmy9fw8fEhAO7fvz83rqbwo2XLlmmej4qKYqNGjairq8urV69m2e7Lly+pUqlYo0YNxsTEZNuvp0+f0sLCggqFgh06dODevXv56tUrajQaqtVqPn36VFraWaFChWyF3hMSEjh+/PikeQg//0Lz/BYpREfFihW5atUq3rt3T5pLFB0dzUuXLnHSpEm0tLRM6txr1JY6deUX8x7kcgXbdurOOg0apylgOnXqxGHDhtHKyirFuYoVK3L58uX89OlTtp+XQCDEQBb4/fffqVAoeODAgRy1nz17NgFw0qRJ9PLy4pYtW3jmzJn/zB9tfIKa4TEJfBsey5cfPudpx59WGTJyHA0NDfNkJnVCQgJtChViq449siwEfAPD6Fi0BFtm0inPmzeP+vr6ufbxS7p168bq1atnWm/79u3SG/nAgQMJgAMHDmRERESmbX/99Vfmy5cvzya9zp07N83Z9BcuXKCDgwP19fV56tSpbNls1qwZ8+fPzw8fPuTYr/PnzxMAFyxYkG6dmzdvMn/+/DQyMuLatWszDbtfv36dFStVolwu5y8Tp9DNvToB0OxvQWBqasYq1Wqm6Lx1dHSkIQ9dXT1pKGDyzIXs2X8IAVBbW4fNWrVPERHQ0tJm4xZt6VC0eCpRoFKpOHr0aG7dupWtW7dOEf3Q0dFhly5dePr06VxHfgQ/DkIMZIKfnx+VSiUnTZqUYxsajUYav/76j7p8+fJcvXp1lsOn/x/EJagZFhPPt38n+Pm3O/+vSwU3d7Zv3z7P7ufnn3+mrZ1DloSA34twbj6QNHZ/8uTJVLaio6O5d+9eTpw4UVp73759e06ZMoXHjx/P0fj9l3Tu3Jk1atTIsE5wcDDNzc3Ztm1bkkmfr8WLF1NPT4+WlpacPHkynz59miqC9eHDB65Zs4ZGRkZs0KBBrvz8kuR19jdv3uSjR4+4YcMGVq+e1Em6u7tne8ljcgKe9FYdZIcBAwbQ3Nw8w3knoaGh7Ny5MwHQ3Nycw4cPp5eXF318fHjr1i0eO3aMf/zxByv+HaIv4liUu46c5cBho5Im+unrU0/fgAA4c9FqPgqJ4o2HQfxr12FOmrGA1WvVTRpebNyc/i8+csKUmQRAG1s73gkMpUft+gRAC6sC3HvyEh2Llkj1PVHWtSKNTExTHdfR0eHvv//OJ0+ecN68eSxVqlSq+QaTJ0/ONAmWQCDEQCa0atWKxYsXZ3x8fK7svH37lgYGBhw3bhwjIyN57949/vXXX2zatCllMhnt7e3zbOw5u8QlqPkpOinBz7fo/L8sj99EUk9fn7Nmzcqz+9u4cSMB8MKdF1kSA79MmpnqTffjx48cNWoUTU2TvpCtrKxYt25dtmzZkjVr1qSJiQkBsGDBgpw2bVqOJj2SZMWKFdmtW7d0z79584alS5dmwYIF+fbt2xTnnj59yg4dOkirKIyNjenq6spKlSqxYMF/EvCoVCqOGDEiR/6lRWhoqDS+n3yNmjVrcvv27TmKPvTs2ZOFCxfOk8jFw4cPk4aJNm3KtO6dO3dYunTpNJcqGhoZs3rt+ly0disfBYdz1aad0rnqteslTSguXZYPXkfwUUhUijJ19uKkZ1K3IR+FRPHW03fM9/eKh5mLVvPmo9d0cCpGACzjUp4+ASHs2ntgmvMcrKxt0pwDoa+vzz///JORkZG8fv06Bw4cSCMjoxRzDurWrUsvL68cDbsIvn+EGMiAoKAgyuVyLlu2LE/sDRw4kFZWVqmExaNHj+jh4UEAeZomNT0+p5Hd73+l3H72hgC4devWPLvf5Jnz+875pjkk8PWxlh26sZyrq9T+8OHDLFCgAI2NjTlmzBgGBASkmRzIx8eH/fv3p5aWFosXL84bN25ky8/Pnz9TW1s73bD2kSNHWLBgQRYoUID3799P146TU+oMjcmlYcOGtLW15ZgxY7LlW0ZERERI9n/++edchfY1Gg0tLS05bty4PPPPzc2NnTt3zlLdmJgYOjg40KqgDb0OneOmA2d48IIffQM/8V5QBJ++i+bZ63dpZJwk/lq26yx1zht2HkolBB6FRHHV5j0EwBKlnaVjI8dPkqIMD15H8OSVOzQxTcqH0aRlWz4MjuTkmQsl26b5zFKIAD19/TR/v8bGxpw7dy5jYmIYHR3NzZs3s3bt2inqmJiYcNCgQbx58+Z3PbFZkD3ERkUZcPr0aWg0GnTs2DFP7HXp0gVv3rzB3bt3UxwvWrQozp49i19//RXjxo3DggUL8uR6AKDRaPA5Xo2P0QkICYtF4IfPCA6LxceYBMTEq6Em8+xaeYEMSbvVMQ/90iRvXEQg5HUQVi6YiZ+6tkTtckVQ3t4UFYrkQ3MPF4wZ1BMHd3oh/NMnmJmZAQDWrVuHpk2bwsXFBffu3cPMmTPh5OQk7aon+S2TwdXVFStXroSvry/09fXh4eGBkydPZtnPXbt2IS4uDg0bNpSORUZGYt++fWjQoAEaN26M0qVL4/r162nu/pdM1apVofx7Rz8gafMjbW1tbNu2DUePHoWFhQXev3+fZb8yI9mWqakpDA0NpWeXE4KDg/H27Vu4ubnllXuoWLEifHx8slRXV1cXc+bMwZvXQQCAMi7lUciuCHRUCuhoKRAXG4shfbsiIjwMLhXcEBkZgcTERNSo0wBVqtVM06ZlAWsAwJvg19KxLr36w8jYBM+eBODEkf2wtSuCRWs2Q6lU4vC+XVi+YBY6du+DddsPwMQ0Hz59DIWJqRlat+8KYxNTxERHAwDkX236FB4ejlGjRsHW1hbr169H27Ztcfr0aTx79gyenp6wtbVFWFgYli1bhgoVKsDFxQULFy7Ehw8fsvtYBd8ZQgxkgI+PD5ycnGBqapon9lxdXSGXy9P8YpLL5Zg6dSpGjRqFX375Bbdu3crRNZI6/0R8jIpHSFgsXn6MRUh4HMJiEvA5QQPN/1jn/zV6+vowMjLGs2fP8szms2fPIJPJsGzeNDSr7ozNqxfBwtQQPw8bihUrVmDRokVo06oFIj++we+jf8KVC6fx7OlTHD58GH379sWAAQNw6NAhFCxYMEvXK1WqFLy9vVGzZk20bNkylfhLC7VajTlz5kCpVKJjx46oUqUKihUrBmNjY7Rq1Qrh4eHw8vLC0aNHYWNjk6GtAgUKwNraGjdu3EC9evUgl8tx5MgRdOjQAUDSzoG+vr5ZupeskGzL1dUVN2/ezJWt5J3/HB0dM6mZdRwdHfHixYss12/atClsChXCvh2bAQBaCjm0VUmd7tRfx+DenVswzWeG3gN/xuljhyCXy/HLb1PTtWf1txj49DEUcbGxAAADQyN07T0AALBy4RyQhJu7B37/cx4AYOGsqTh+aB/c3D2w6+h5OBYtjg/v3+LwgV0YN3k6fvtjDgoVtodGrU7zmh8+fMCQIUNgb2+P1atXw8bGBpMmTcLz589x8uRJdOrUCdra2rhz5w6GDx8Oa2trtG3bFkeOHEFiYmKWn5Xg+0GIgQx4+fJlnm51qqenB2tr6zT3sU/mzz//RKlSpdC7d+8svR1rNBpExyUiNCoewZ9i8SI0FiHh8Qj7nPh3559n7v+/IJPJUKqsC27cuJFnNm/evAktLW3cvHQO8+fPx+vXr7F//354enqif//+GDRoEObPn48rly8jICAA3bt3w7Nnz9CuXTvUrFkTS5cuhVyevT8VXV1d7N69G3Z2dujZs2emX7Dz5s3D7du3Ub9+fRgZGUGhUKB06dJYvHgx7t+/j6tXr6JTp06pIhJpoVaroVQqoVarcfr0aUybNg21a9eWzletWhX+/v4Zfg6zw+HDh1GkSBE0bNgQZ8+ezdVbZnIUJ7vPOyMUCsU/0aEsoFQqUa9uXfj73oCWUg5tVZIve3d4YevGtZDJZJi1ZC3WLl8AAGjbqTucipVM156xiSm0dXQAAO/ehkjHu/cdBD09fdy/exsXzpwAAHTo1hvd+vwEABg7rD/u+99GocL22H7oDGrWbYi42FiM/3kgPrx/h6Pevli0ejPKVUg/ihISEoL+/fvD0dERf/31FzQaDerWrQsvLy+EhIRg6dKlKF++PBISErB79240adIEhQsXxoQJE/D48WPJTmxsLPz8/HDu3DlcvnxZRBK+R77xMMX/NC1atGDjxo3z1KatrW2mOQdOnz5NADx79myqc19m98urBD//a2X0xMnU1tbO1dhzMrGxsTQxMaGtrS1DQkKy3O7s2bM0Nzeno6NjtlIhf821a9cok8nSzQPw5s0bdu/ePd3EOABYrVo1enl5ZXkSa4sWLVi7dm02bdqUZcqUkSbiaTQaxsbG8tOnTzQ0NOT48eNzfF/JfPjwgTo6Ovzzzz/5/v17amtr848//sixvUePHqW7kiOnjBs3jjY2Ntlqs3jxYiqVSj4KDufTd9E8cv46df/eOnnI6AlcsCppUqqenj69bz1Jc67Al6WwvQMBcMve4ymO9x6YtElUuQpufBgcyUchUbz3KozVatb9e8JgQV68/ZSPQqJ4PyicfQYNlz4X9Rs3p9/Tt3wUEsVtB0+zQZMWKXZ+TKs4OjrSy8sr1ZLD27dvc/jw4TQzM0tR38HBgUWKFEnz81m4cGGOGjWKjx8/zrPfleDbISIDGWBhYYHXr19nXjGLxMfH4+3bt7C0tMywXq1atVC8eHGsWbMGiRoNImMT8T4yDkEfk97830bEI/yzGvFqDf5jL/6Z8upFIM6ePIqEhASsWLEi1/a2bNmCsLAwHD58GFZWVlluV7NmTVy+fBmRkZHo1KlTjucwVKpUCY0bN8bSpUtT2CCJNWvWoEiRItixYwd69eqFQ4cOITg4GBqNBgkJCbh37x7Wr18PlUqFzp07w83NDXfu3MnweiRx8+ZNODo64vDhw2jfvj3Gjx+PqlWrQl9fHzo6OtKw1/z581O8/eWE0aNHQ6VSoU+fPjA3N0f//v3xxx9/4OnTpzmy5+joCENDw1wPN3yJj48PXF1ds9XG3NwciYmJiI39jKioSAzp0xWfP8egao066PPTcMz9wxMA0GfQz7CwzPxzZWlVAADwJiTl90mvgcOgpa0Nv5vXcO3yBQBJkYn5KzbA3sEJb4JfY3CvjoiLjYVCocCY36ZhxsKVUGlp4cSRA+jUvC6Cg16hXAU3LFqzBScu30bX3gOgra2dph9PnjxB586dUbp0aezevVuKmDg7O2P+/PkIDg7Gzp07UbZsWSgUCjx//lyKUF29ehWPHz+Gv78/tm3bhubNm2P9+vUoWrQohg0bhui/5zEI/qN8Wy3yv83y5cupVCrzbCmOr68vAfDixYuZ1h05ciRtC9t987f0/6/y+E0kPafPpZ5e0ixphUJJbW3tHG3Lm0xISAiNjY3ZunXrHNs4efIkAXD58uU5trFv3z4CkN6g4uPj2aBBAwJgz549M8y3n8z169elZW8ZbZWcHFUaOHCgtNTP3NycnTp14uzZs/nXX39xzZo1HDZsGPX19VmxYsUcf7537twpLafs378///jjD/7+++80NjZmuXLlspQA6WvUajVtbGxYvnz5HPn0NcnRijlz5mSr3YYNGwiA9158YOMWbaS39Ct3Azl+clKegPyWVtKbeWalWesOBMAxv/+R6lznnv0IgFWq10xx/PilWzT+O7dAs9YdpMjBo5Aobj1wimbm+QmAZub5ufXAqRRtr91/yRHjPGlobJxhpKBs2bI8cOCAtKogPj6e3bp1IwB27NiRr169yvA5xcTEcN68edTV1aWTkxOfPXuW49+V4NsixEAG3L9/n0DeJD8hkzK/GRoaZinB0ObNmwmAt54Ef/OO+t8uZ675s1KVatIXVIXK1bjr+BUWsivCMs7OWeosvyY6OppVq1aliYlJrsL8JNmjRw8WKFAgx7kmPnz4QADs0qULe/bsSUNDQyoUimwvn4yNjWWXLl2oUCh46NChVOc1Gg0bNWpEGxsbamtrs0CBAty4cSNjY2PTtHft2jXq/r0rZHZTKu/YsUPaRhhISsX7dalYsWK2tgmOiopily5dpM9BXuz8OX36dGpra/P9+/fZajdmzBhaF7Th73/Oke5v26EzvPbgldRBT5uzJEtC4FFIFPsOHkEA7N53UKpzZ67fl8LwOw6fTXFuw85DUrKyURMmpzh39sYDFi9VJil3hJYWZyxcmcq2f2Aop8xaJAmH9ErFihV55MgRduzYkSqVips3b87W83r06BEdHR1ZqFChTAWE4H8TIQYywcPDg1WrVs31etyYmBhaWlpy8ODBWap/4sQJAuAFnwffvLP+N6MBv06bRR1dXQKgrp4+J0ybS7/AMN5+GcFdJ6/SxDQfS5cpw4cPH2b5Wb969Yru7u5UKJX09vbO6a9M4vbt2wTAnTt35tiGmZkZFQqF9La+cePGHNlJTExks2bNaG5unirpULKAlMlk7NChQ5Y6+PPnz9PIyIgFCxbk4cOHM/2cf/jwgT179pSuk1bHolKpWLdRMyoUChoYGHD58uUZRh/UajUPHjxIW1tb6fkoFAqWLVs2V8m+nj9/TgMDA/7000/Zblu9enVWqlJNSkA0YeosPgyJYu+ffiYAOhUrwftB4VkWA79OS0pJ3qBpyzTPt+7QlQBYq37jVOc8Z8yXnvfS9dtSnPN98ob1GjWTnn2fQcPT9OthcCTnLF1HC8sCGYoCANy1a1eOnndQUBALFizI2rVri/wF/0HEnIFMGDduHC5duoSNGzfmys6vv/6KsLAw/Pzzz1mqHx8fDwBQfLFe/Hvi+bMn6NSiAab9Ogaxnz+jorsHdp24gg7d+0Eul0OjIewdimPl1sOIiIyGi4sLpk2bhtDQ0HRtRkREYOHChShevDiuX7+B3r16oVq1arn21dnZGWXKlMGxY8dybMPI2BgNmrWCTCZD27Zt0a1btxzZUSgUWLNmDYCk8fpkrl+/jv79+0Mul6Nnz57w8vKCsbFxpvY8PDxw584dlChRAk2aNEGpUqUwb948XL58GZ8+fUJUVBSeP3+OXbt2oVevXrC2tsamTZsApJ8LIiEhAQ/v3YFarUZUVBR++uknFChQAAMGDMCaNWtw7tw5XLhwAV5eXhg1ahSKFCmCZs2aISgoCBqNBnr6BlCr1bhz5w7Gjx+fo+cUExODLl26IF++fJgxY0a22gYEBMDb2xuPHt5DQkICGjZrhW59fkLQy0BsWrscAPDLb39A8dUa/4ywtEpaXvg2JDjN8/2HjoJMJsPZE0fw8J5/inOde/RDl179QRK/DO6T4ry+vgEWrdmCQSPGAgDWLluAQT07ICoyIoUNmUyGZq3bw/vWY8xZth75zPOn8kEul2PAgAFo06ZNlu/rSwoWLIgNGzbgzJkz6N69O8LCwnJkR/BtkDG9v2iBRI8ePbB//354e3ujTJky2W5/6NAhNG/eHDNnzsQvv/ySpTZz5szBxIkTsfPwGZRydsnSkrL/Amq1Gn+tXoY5f05CXGws9PQNMGLCVLTt0itpORkJNQHNF2siYz/HYNncadi5eQ3kMhnq16+PihUrwt7eHnK5HC9fvoSPjw+OHTuGmJgYaVLU8ePHUb9+/Tzxu2/fvvDx8YGfn1+225KEmZkZSrtUwKXzp/HixYtMcwVkxsKFCzF69Gi8fPkSly5dQq9evSCTyWBnZ/f3UkqtbPt48uRJ/P7777h+/XqaHb29vT169OiBwMBAbNiwAUBSJ5PVrxCVSoWEhIRUxxITE6GlrYO42M8AACMjE0REhEl1Ro0ahenTp0OlUmXpOh8+fEC7du1w/fp1nDp1ClWqVMlSu2R69eqFrVu3IS4uFnYOTth19DwMDI0walAvHN67E1Wq18T67Qez9Td52/cG2jepBWMTU3Tq0ReJiYkwNDRC8VJlUMbFFWbmFhgxsAeO7N+NRs1bY8HKlC8fiYmJ6NelFS5fOAvrgoWw8+g5mOdPORH58L6dGD/iJ8TFxsKxaHGs2LgThQrbp+kPSWzbtA5zpv2KqMhIAIC+vj6Cg4NhZGSUref1Ne3atcO+ffugUCjQtm1b9O7dGzVr1szT5aJpwaRI979+ne8VIQb+JiwsDBcvXoSPjw9evXoFkrC0tISrqyucnZ3RsWNHvHr1Cvv374e7u3uW7W7btg09evRAkyZNsHPnziy/TbRp0wb79++HWq2GrZ092nbqjhZtOsDGtnBOb/Gb8+xJAMYMGwi/m9cAAJWr1YLnrMWwtrEFkPTHrNYQ6X0iP4V+wIFdW3D90lk8vHsb4WGfAAD6BoYoUbosKlSpDveaddGnbSMkJMTj6dOnKFKkSJ74PmPGDMyePTvDyER6vHz5EoULF4aWlhYaN26MvXv35tqfsLAwFCxYEEWKFMHdu3fh5uaGa9eu4dq1a6hUqVKubLdu3Ro3btzAnDlzoNFoYGpqChcXlxSrMaZMmQJPT0+YmVsg9MO7rBmWyZDeL9fI2AQR4WGpBIO2tjbi4+Ph7OyMlStXZpiZMDExETt37sTw4cORmJiI/fv3ZzsydOzYMTRq1AgAoKOji+1HzqJYidLwv+WDdo1qQCaTYe+JSyhR2jlL9uJiY7F98zpsXrcSL54nrbAoaGMDbW1tfPr4EZ8+fYJcLkfNeo1Qq15j/DZ6MGQyGY5c8EERx6IpbIWHfUL7JrUQ+OwJylWsjI07D0Prq1UD/rd8MahXB7x7EwIT03xYtGYz3Nw90vUv9vNnLF80G2uWzMOgQYOwcOHC7DyuNPH29oaHR8pr2tnZoVevXujRowcKF86b77CEhATs27cPe/fuhY+PD548eQKNRgNDQ0OULVsW7u7u6N27N4oVK5Yn1/ve+eHFwOPHjzFz5kx4eXnh8+fPMDMzg4ODA2QyGYKCgvD69WsoFAo0atQIr169gr+/P0aOHIlx48ZlmHY1MDAQ48aNw/bt29G5c2esX78+y29rHz58QIECBdJMVFOyTFl07NoLjZq3Qj4z8xzf9/8narUaa5cvwvyZUxEfFwd9A0OM/u1PtOrYXXq7Igm1mpkulVTIZYAsqX5cXCxIQkdHN8Vb2sSf++HIvh14/vw57Ozs8uQeZs2ahenTp+PTp0/Zbrt+/Xr07t0bALB69Wr07ds3T3yqVasWrl+/jjVr1mDNmjWIj4+Ht7d3ru1evnwZVatWxbFjx9CgQYM065BEy5Yt8yRjnVKpRGJiIpydnVG7dm04OztDX18f4eHhuH37Ng4cOIDg4GCo1WpUqFABrVu3Rvny5WFtbQ21Wo0nT57g+vXr2LRpE0JCQqCrq4uzZ89mO6Wxn58fatSogejoaGg0GkxfuAqt2ncGSXRr3RA3r15Cy3adMXPRqizZu+17A+OHD8SL50/RunVr9O7dG5UrV5aGb0jixYsXOH78OJYuWwb/O3dgZW2DN8FBaN2hK6YvSL209tmTAHRoWhsR4WFo1b4Lpi9YkSpC8fZNCAb36gj/Wz5QKpX4/c956NCtd7p+Pn50H01rVsLp06dTJKfKKSRhbm6Otm3bQi6Xw8vLCxERScMWMpkMderUQe/evdGyZUvo6urmyP7GjRsxfvx4hISEoEKFCqhSpQpKlCgBLS0tfPjwAb6+vjhz5gw+fPggLe3Nq++C75b/t9kJ/2Oo1WrOmzePOjo60k5zz549SzXxJSQkhEuXLmWJEknbilavXp3a2trU1tZmp06duGzZMnp7e9PHx4dnzpzh3Llz2bhxY8pkMpqZmdHLyyvbk2kmTJhAhULBkeN+Y43a9dLc+lgul7OSezXOX7Ge/s/fpZiY9yDoE4953+Te4xd45Px13n8Zmu3JfTcfvuSvU2eybsMmLGBdkFpaWtTW1mZh+yJs0rItZy5czruB7zO1c/yiD13KV5T8dq9Rh8eu3OPtlxFS8Q0M581nYZkWv8CsbUG8Yc+JLC/hzCrDhg1j0aJFc9TW1dVVmmx38+bNPPPpl19+oZ2dHWNiYqhQKLh06dI8savRaGhnZ8eRI0dmWC8kJIR6enqZTkjLrDRs2DDD56LRaHj27FkWL1GCcrmcWlpaqWwolUoaGZuwpHM5KhQKmpmZ8fDhw1m+302bNtHQ0JBK5T87FjZr05G3n4dyybptBEBtHR2eu/kwSxMG56/8i0qlkhUqVuS9e/ey5MPatWtpaGgkTTQ9ff1emrbXbTsgfSf88tu0NOvcfvaeTVu1k+6lW5+BvPcqLM26sxavIYBsryjJiLp167JFixYkmacbJkVERLBZs6QJk506deKdO3fSrRsbG8tNmzaxUKFC1NfX55YtW/Li1r5bfkgxkJiYyB49elAmk3H48OFZWuqXmJjIWbNmUVtbm+7u7pw6dSrLlSuXKjOXXC5n2bJluWbNGkZFRWXbN19fX+kPXaVScfQET958EMj5y9awqketFNvEJheVSkWPWnXZuWdflnWtkOrLUqlUsrSzC8dP+pM3H77MsPO+8+wte/YfRB0dHWppabFO3bocO3YsFy9ezEWLFvHnn39mFXd3ymQyGhubcMyvU6QsbV+WR8HhHPPrFGppaxMADQyNOGn2Ut56Ef6PEHgRTp/AzEVAdoSA34twXn/8nkqlMt3d/3JC1apV2bFjx2y327FjBwGwQ4ekdeYvXrzIM59mzpxJExMTXr16lQCyvUtiRrRt25Y1atTItN6QIUPSFKuZFZlMRqVSyXXr1mW5I0hMTOTMmTMlG3p6BtL/O/boxxuP39LveSjdqnpI4qtNmza8cOFCmtdQq9U8cuQI69SpQwDSkkEraxvpnlwrVqbt39kD+w8dzYdZEALJnXWXLl2yvRoiICCA1tbWVCgUbNu5R7rX+O2POdJzXP7XjjTrPAyO5Ihxnv8IcY9avP7gVap6E6bMpJ6eXrb8zIzu3buzatWqqY4/e/aMnp6etLW1TfF5cHZ25oIFCzJcAhoZGcnKlSvTyMiI+/bty7Iv4eHh7No1abVGeplABT+oGBgxYgTlcjm9vLyy3dbb25v6+vp0d3dntWrV0nxL0dHRYd++ffn06dNs2X7+/DkLFCiQ6svVxsaWm3cfYuCHGN55Gsx5S1fTzb16CmGQ/DbRokULLlq0iOfPn6efnx+9vb25dOlSdujQgVpaWtTR1eXEKTMYEBKRqgPfd/IiCxW2o56eHqdOnZpq6dqXPH36lEOHDqVcLqdzufL09nsk2Tl64Qady5WXfKteuz5PXHuQIhpw60U4fZ7nvRBILhUqV2O1atWy/ftNi6CgICoUimwnHnr16hXNzc3ZunVrKRlQQEBAnvhEklOmTKGOjg7r169PAPz48WOe2R47diyLFCmSab3r16/nKBogl8vTzJWQFdauXSvZMTYx5cK1W+kfFMG7f5erD1+n+LsAQDMzMzZs2JADBw5k//79WadOXZqamkp1dP6OcBgaGfPEFX+u3XaQBoZGKa5zMyCYD0OipJJWB3z9wStaWhVg3Xr1mJCQkKP7e/DgAXV0dCiXy9NNdfwwOJIduvVOEkX6Bjxw5mq6wmHJWi8pmZddEUcePHudxy76ceWmXRw/eSbLu1WhtrZ2ni4H7NKlC11cXNJNPKVWq3ny5El26tSJ2n+/MCS/2LRp04aHDx9O9fy6dOlCQ0PDHOWf0Gg0UiKuq1ev5uievnd+ODGQ/KU8f/78HLV//PgxnZ2dCYCFChXi8OHDuXnzZp45c4anTp3iypUr2adPHxoaGlImk7FXr1789OlTpnZPnjxJCwsLKhQKVqhclbI0IgD1GjXjNf8nDPwQwxcfYnjN/wlLlXEhAPbq1SvTBC9v377l0KFDCYBVqnmkSGi09/gFGhgYskLFinzy5EmWn8eVK1dYuHBh2hSy5dnrdzlyvKckkAyNTDh17vKU0YCXEfTL4rBAToWA34twTl+c1GHcvn07y/eSHr/++iv19fUZHh6e5TavXr1isWLFWKhQIb5584YvX74kgGy90WRGhw4daGlpSRsbGwLI0ucsq4wfP552dnaZ1ouLi6NSqUwzYpVRVMDT0zNX/vXu3ZsqlYpeB89IIiC5XLr7IsX1tLS0aZrPjDKZjIaGRizlXI61GzThkNET2bhF2xR1l67fzgfBUXwQHMVth85I96Wjq8dNe46lEANpCYNufX6ikZERX758mav7W7x4MQGweZuO6Xbyd19+oltVDwJgwUKFecX/uXTu3qswnrxyh6u37OWv02azScu21NbWyfD3kpfJglxdXSW7Dg4ObN26NSdNmsS9e/emGo79+PEjly5dyvLly6fwx9ramuPHj2dAQAD3799PAPzrr79y7FNCQgLLly/PEiVKpJuI60fmuxIDarWax44d45AhQ1ilShVaWVkxf/78LF68ODt16sQlS5bQycmJHh4eqTbqyApbt26lrq4u7e3tuX//fmkDmLSIjo7mkiVLaGBgQAsLi3THRK9fv85OnToRAIs4Okl/CAOGjWYBa5tUf7BaWloc7/kH77/8wOo161BPT48HDhzI1n2cOXOGJiYmLFehEv2fv+PNhy+Z38KC7u7ujIyMzJYtknz58iVtbW2pb/BP2NajTkOevP4ohQi4/SI8y/MDciMEkocKCts7sJKbW4a/p8x48OABVSoVjYyN09w46ms0Gg23bdtGMzMz2traSpEAjUbD/Pnzc+zYsTn25evr2NnZcdiwYTx//jwBZDh+ml26du1KNze3LNW1t7envr5BppvkJAuBIkWKMC4uLlf+hYWF0czMjD36D0klBo5eSkoS9eX4v/zvCEGTlu14LyhCKk7FS0l1+g4eKQmBB8FRHDBsNAFInahKpeKMhavSFQQ3H4fQwMCQv/76a67ujUwaEkkeLrhyNzBNMfDgdQT3nrgsJRKytLJmjToNaO/gJCVLyqhYWBZg/cbN2blnfwI5Tzb0NZ8/f6ZKpaK+vn661zYyMmK1atU4aNAgrly5klevXmVUVFS6GyYZGRmxTp06uY5eJCcQy2nSr++Z70IMaDQabt++nQ4ODpIS7dy5MydNmsRp06ZJ4iD5DaZdu3bZ7vS8vLwok8nYpUuXbLV9+fKlNLegVq1aHDlyJEeOHMk2bdqwsJ3d319aSWld/5y3lENGjpW+NGcvXs0GTVum+cdkYGhIlUrFM2fOZPdxkSRv3LhBPT09du3Vn81bt6epqSmDg4NzZIv8Z3c+bW0d/rFgFX2ff+KyTXvYc+BwVq5ei47FStCxWElW8ajDXj+N5IotB3jj6ad/RQgkl/W7jlMmk3HChAk5uqfw8HC6lCtHG1s7lqtYmQBYs1Ytbt26la9evZK+mDQaDZ88ecJVq1axXLlyBMB27dqlSoM8YMAAWltb5yqrXjJnzpwhAJ45c4bh4eEEwHXr1uXabjIlSpTgoEGDslTXycmJhkbGWRYDCxcuzBMff/nlFxoZm/Dm47cpxMD2I+dTdOJy+T/Dbo1atOXluy94LyiC5/yeSMedy1Wg/8swSQicvfmI2jpJ7eet+IsNm7WS6g4aMZYPgiNTiYHkiXi5jQokM23aNMrlcnbp2Z9/7TrMKbMWsfdPP7NOg6Z0LFpcmo+TXtHS1qZTsRKs27Ap+wwazqmzF3Pttv1s1Ky1VKd9l568ExhKx6LF2bx58zzxe9OmTX/bl9GjVl0uXbOJv06dwTYdurBkmbLpChWZTEYnJye2bduWnp6eHDduHGvVqiV9ro4ePZon/tWrV4+VK1fOE1vfE/95MRAREcG2bZNCfS1atOClS5fSVY/BwcH09PSknp4e7ezssjx29ODBA2pra7Nbt245iiiEh4fTxcWF+vr6LOLoRAenoqxctTr7D/6Z6712s33n7tIfxITJ09np77FAlZYWN+46zN//nEvl339AyWFLmUzGKVOmZNuXL1m0aJF03bVr1+bKFpm0uZKenj7HT53DQoXtk8KXNjZs2bIlhw0bxqFDh7Jps2a0tLIiANo7FOW0BWtSiYK8EALJZfj4KQTAcePGZWsMNzg4mJXc3GhoZMwdRy/R73kYZyxeR9eKVaRnZmhoSAsLC2lGvUwmY5MmTXjs2LE0bSa/laxevTpXz1mj0bBu3bosUaKE9FkvX748mzZtmiu7ydy7d49A1vbk0Gg0NM5gMxy9NN4Oc7tXRDLJG39t3HNcEgKb95+kS4VKUgdSoEABurm5sWLFisyXL1+SSNDRYcv2XelS3k36mzrv9yRFVKBV+6QJZxXc3PkgOJL3X0ew/9DR0j00adWOt59/SCEGuvYZSKccrjhJi8uXL2cqrlQqFe0dnOhcroJ0zx279eGZ6/f54HVEuvMNxnr+KX2XFChoQ5VKRZlMlq2032mRmJjIsmXLpho2qujmzuPeN/gi9DOfvIngce8bnL98HfsPGU6PWnWZ38IyfVGjpUUTE5McffemRfImVHk5rPY98J8WAxEREXRzc6ORkVG2NhN68uQJK1euTD09PV64cCHDuhqNhlWqVKGTk1OWVh2kR0BAAHV1ddn3p6F8Ffo5RXn5IYYDhgz/581j+BjWb9ycAKhvYMh9py5xz3Fv2tjaSZ2Ora1trt8w1Wo18+XLx3z58uU6bEuSN2/elL4EOnTowCtXrqQpzDQaDc+dO8cWLVoQAGvUa8zTvs/zXAgkl6FjPCmTyeji4sJr165leA9xcXFcu3YtTUxMmN/CklsPneftFxEpyomrD2hpZU0gaXdFd3d3Hj16NEudXPfu3WlsbJyr8dnVq1cTAI8cOZLimEwmy5O95QcOHEhLS8ssfSYCAwOlSFVmHReQNA6sVqsZGhrKd+/e5WrsNj4+ntra2hw7aQZvPn7Lrn1+okwmY8mSpbhixYpUvw+NRsMXL15w+vTpLFiwoPRZdfeonUII7D15RepYdxw5l6LD/2PeMmkFkWvFKrzs/1w6V8m9Otu3b5/j+/ma6Oho6bmZmOajR+367NbnJ/72xxyu8drHU1f9UywXTN5NUS6Xc9Xm3RmuePB98oYt23VO8bvR0dFhpUqVcjWsNnv27Ax//45Fi3H1ph18/j6aL0I/pyg3HwRy066DnDD5T7Zq14nFS5amXC6nTCZjvXr18uy5Jovd06dP55nN74H/rBjQaDRs06YNjYyMcrSkKjo6mrVq1aKJiUmGE++Sw7HHjx/Pjbsk/5n9fedxUJqCYMzEydIfTZee/ejmXp1A0halp67eoU/Aa9au35hyuZyzZ8/O0jU/fvzIDRs2cPDgwaxduzbd3d1Zv359jhw5ktu2baOFhQWHDh2a63sLCgqig4MDLSwssvWs9uzZw3xmZnQqXopn/Z7nuRCQBMFYT2lmecWKFTlt2jQePXqUfn5+vHnzJr28vPjzzz/TwjLpDaVxi3Y8f+t5KiGQXPQN/un8spPP4OPHj7SxsWHZsmX54cOHbD/nkydPUltbm3379k1xPDo6mra2tqxdu3au3qCuXLlCuVzOWbNmZan+4sWLMxwemLloNa2+mPtiampKI6N/Zuknb0g0ZMgQ3rp1K9v+Ojg6smvvn+haqQp1dHQ4b968LHVm0dHRHDFiRJJIrODGu6/C+SA4ivdfR7JK9VpJn4GWbdOcG7B+x0EaGiVFQwoVtueRCz58GBLFMi6u7NevX7bvISOSQ+qm+cwy3S75YXAk23Xu+bc4M+LhczdS1bnz/AMnTJmZYhfDr8P2gwYNytHY/LFjx9JcZprW58M0nxnHeU7jnWchqUTBi9DP9H30ko2bJw3NGBsbZ3nIKivExcURADds2JBnNr8H/rNiYNu2pEQgGe3tnhmhoaG0srJikyZN0v3wt2/fPkU4Nje8ffuWKpWKjZq24Pyla7hqw1Zu2XWI+46d5cmLN3nZ7yEnTvpT+uNp0qINi5csLX3pXPZ/ytVb9hBApssWQ0JC2LdvX+rq6lImk7F48eJs164de/bsyVatWtHe3l76w9y0aVOu7isuLo7lypVjoUKFcrSf+b1795g/f36Wd6tKn+ef/hUx4BsYxvJuSdskW1gWkL7Mvyw2hQqzQ/d+3H3yWroi4PaLCF66GyS1kcvl2Y4Y3b17l/nz56eTk1OWh6rUajUXLlxILS0tNmzYMM036uSdLqdOnZotf5J5+/YtHRwcWKlSpSwNqajVajo5OUlf7l8/Tx0dXfoHhrJuo2aUy+VUKpVs1qwZ//jjD+7cuZP79u3jsmXL2LdvX1pbJ0Va6tWrl63PkKOjE21s7WhkZMTLly9n+569vLwol8vZo/8QPgiO4qote5M6SC0tnrp2N93JgofP36SNbWECoK6eHlt16EbTfGbs3Llztn1Ij+ROK/nZjp88M9McB/4vPkrbgRcqbC9NPrz78hOnzl5MK+uC0u/H1q4IZy9Zy9/+nJeqw+7SpUuWkxBpNBquWrWKWlpaLFHaWdqF9MuSz8ycCoUy1XGlUsV2nbvxyLmrkhC4dOshC9vZ09zcnDt27GCZMmU4ZMiQPHuuCQkJBPJ2js33wH9SDKjVahYpUoQtW7bMta3du3en+3YXExNDQ0ND/vbbb7m+TjJ169bNUjg1uWhr60hhST19fdo7ONHIyChDcbJ9+3aampoyf/78nDZtGkNCQtKsd+TIEQLglStXcnVPnp6eVCqV9PX1zbGNc+fOSWF3bW0dauvoUEtbR/q/to5uyv/r6Cad//JcBkVLW5sq1T85IRQKhTQPA0iaba5UqZKKUpmiKBQKqcjl8hTjofnz58/R/QYEBLBQoUKUyWTs27dvum/F8fHx3LlzJ6tUSZqrMGTIkAzD95MnJ0WXfvvtt2yFex8/fszixYvTysoqy/kxFixYID2Hrr0HpPrsGhmbsFiJUlQqlZwwYUKGeSvi4+O5Y8eOpFUp+vrcunVrptdPTEyU3mpzE7mbPz9pi+B12w/SqXhJAmCvgcOkjv/+6wieunaXyzfu5KiJU9i8TUcWLVE6xWqF5FK8ePEc+/E1Pj4+BMC+g5KGEC2sCtA/MDRTQXDlbqA0pFixcjVOX7CShf9OnASAVtYFOXX2Yt5+/oF9Bv0zPJk89JXUSStZ0MaGa9asSVfsJg/31aqVFElp36Un/V985O1n79mwaatUz0Ymk7FC5arU0UktFgDQpXxFTp+3lHZFHGhvb8/AwECSZO3atdmqVas8e67Pnz8ngBznufhe+U+KgaNHjxJAjt4EvkatVtPR0ZGdOnVKcfz69evSW8/+/ftzfZ1kxo8fTy1tbeYzM6eRkTF1dfWopaVFhUKRpdnYAOjk5JSu/YULFxJIGrPPLAx969YtAsh0HD0j3r17Ry0tLU6cODHHNpIZNGhQjrLZfctiYWGRo3tdv349AbBOnTrSW7GtrS1btmzJQYMGccCAAaxZs6YUUq9atWqWlzb++WdSdMnNzS3T321kZCTnzJlDXV1dOjg4ZDkpko+PT8pkMemkCLa3t6efn1+WbJJJ84A6d+5MmUyWacTq8uXLlMvl7N+/f5btp4VarWZ1Dw9aWhX4W3QbcNiY39i6YzeWcSlPXb30l8h9XeRyeY6Gf9JiwYIFVCgUSYmMCiR9RqbMWpSldMgHz15P1enmMzPn+Mkzeef5B9589Jo16jSQzvUeOIwOTsVS1E/OyGhgYMAmTZrw999/54IFCzhjxgx269aNDo6OkrAu61oxlQ9b95+SbHxZrKwLskvv/unOM9HV1U0x9+WXX35hoUKF8uSZkuSuXbsIIFerp75H/pNiYPDgwXR0dMyzjFmTJ0+mkZGRNNa6d+9eamlpsXjx4gSQrS+zzFixYkWuOyAHB4c0be/dmxTi/OWXX7L0bF6/TsrUtnfv3hzfz8yZM6mtrZ0nX4CBgYGUyWQsWKgwS5ZxYdESpVnEqTht7R1YsFBhWhSwpll+CxqbmFLfwJDaOjqp0kH/fxe5XM7169dz+PDhrF+/Pj08PNi4cWOOGTOGu3fvZkxMTJr3aWBgwJ49e1Kj0TA+Pp779u3j6NGjaWlpSRMTE7q6urJNmzb8888/czSWfvnyZenz6+LiQk9PT+7fv59Xr16lt7c3V61axT59+lBfX59yuZxDhw7NcvrsS5cu0djYOEPhplAoWLBgwUwTYaWFWq1mz549qVKp6O/vn269hg0bUqFQ5MmXenJkKjulYCFbNmvdnr9Nm802HbtLn4eszufJCI1Gw1KlSrF+4+YpJgfa2Nqlu8dA8ryBtVv3s4xLygQ+Nes2pO+TN3wUEsVjF/1o75D0oqOjo8s5S9exWo2klMwWVgU4d9l6GhmbSG11dPVYrUYd5rewpI6uLo2MjOlcrgI79ejL6QtWSC8xu495pzls0axNxzSfX4t2nTnm9z9TDTEtW7ZMegY7duyQ9oXJq3TbnTt3zvE+I98z/0kx4Obmxi5duuSZvWPHjhFIShV77tw5qlQqtmvXTlrak5vw99csW7aMMpmMpmbmLFCwEB2KFmeJMi4sW96Nldw9WK1WPdZt1IJNWnVgm0492bB5W2m9s5GJKSGTUVtbO9WY7vv372lhYcEWLVpkWSRpNBpaWFjkKklK5cqV2a5duxy3/5o6derQ2bUST/s+pW9gmDTe7333FQ9c8ONfe09xwdpt9Jy1hMPGTWK3fkPYpHVHVvGow+KlnWlpbUPtdMKQWenY9Q0Mmd/CioUKF6FT8VIsXbY8XSu5s0r1Wqxeuz5rN2hKB6fif7/B6EkdooODA1u2bMkuXbqwadOmUlbAfPnycezYsSnSsnbo0IE2NjZpjsm2bNmSjRs3zpNnmZiYyIMHD1JPTy9N0ZSc30KhUHDq1KmZzn0IDw/nuHHjKJfLM43gyGQyXrp0Kce+f/78mSVLlmT58uXTHO6IiYmhrq5unoWPNRqNlKckrWJoZMxqNety8MhxXLV5D6/ee5Gq45u+YAXlcjnz58+f69TQ27dvJwBu2HmIj0Ki6Pf0rdRpzly0Ok0hsGXfCVasXFXyWU9Pn1Wq15Q+22u89nGN1z5pvoyVdUHuPubNzj37SZ/nPccv8lFIFI9fuiUtC1UqlVy0enO6AqT53519rXqN0q2zesueFJNuk4u+vgHnLt/A6QtWUkdHl9bW1kxMTGRQUBAbN26cJGRq1mT+/2PvqsPayp72xEhwdwqlUGihQJ0qVepGXam3W3fXrbuXrQt1dzfqSoVSpG5IjeJO3u+PkNuEJJBA9rfb/e77PPO03HvusST3zJkz846lJQIDA0v8OcfExEAgEGDFihUlruu/ht9SGbCyslI7xv79+/c4dOgQZs+ejYkTJ2LWrFk4ePAg3r17x5SRniEdP34cTk5O8PPzQ3Z2NmJjYyUa75EjWuv7hAkT5Lx3uVwuHEuXQd2GTdFr4HDMXLQG2w6dw9XQ1wyN79HLD2CVf54nNVkWpNkdO3YsTExMVPoHqEKnTp1QoUKFYllZcnJyoKurq9Uf1owZM5iFS+J0JtCI6lZWBDo6sLKxg7uHF2rUbYDmbTuhe78h+GPMFJjle1NbWEqiB6YvWI7nn5LwIiYZETEpiPicgoiYVKVSs2598Hg8mJqaYvbs2Sp3vy9fvsS4ceOgp6cHJycnXL9+HTExMZKX65o1Sp/p3bu32sx/6iAvLw8GMsyQBcXU1BTVqlUDj8eDiYkJhg8fjoMHDyI6OhqfP39GREQE9u3bh0GDBjHOqMrOyj28fJgdIo/Hwx9//FHivt+8eRNEys92R48eDS6XqzUCIwAYOHAg4yNSvoI3ugb2x6LVG3H2RqjKmP2CsmpTMHh8Pnr27Flsy2V8fDwsLCzQpEUbRMWmMHWPnTJboniWdZfrz5HzN1G3gT/zWegIhegzaDjuPH+LqNgUtO/aC0QS/yPpb6lStRq4HfYG0+YuYZS39dv2MXXee/FBQYEcMWGaXH+kcuH2U0Y5PHTuusq5ufn0NWrUrqf0e1i5Wk2IdHUxZ84cREVFwc7ODra2tjh16hSAX/TMISEhxf58xWIx2rRpoxVl7b+I31IZMDc3x4IFC1TelzIS1qlTh/myWVtbw9XVFdbWv8gtatasiT179uDDBwmXeZcuXaCnpyfnQGVjY4PJkydrre/16tWDjZ09PL0rKdWUZUVHRwhjE1MYGZvI7cR4PB4mTpzI1JmWlgYTExNMmDBB4/5cunQJRFQsJkPpvGmLGQyQeHeru4s3NDKGg5MzKlWviZYBXTBk7FQs27ALx64+xM3wT4xlQVaefUjCs09JWL/zEPMSJCL8uWSNXKy5KkVgxvwVICK0a9euUIc4Wbx58wZ+fn4QCAQYMGAAhEKhSk9taVrt4ia5KYiXL1/K7dal3x89PT0EBQUxUQlv377FpEmTUKpUKaXzLV0YZM3Hsme+K/7awSTDIaISk9cAkt9xlSpV0LJlS7nrUp56IlLLj0JdSMMkj126o9bCr0rGT5MQXU2bNk1jheDr16/wqVgRllbWuB32Rq7eR9ExzK5+zebdOBPykOEjkX5GXXr2xfXQaPnnomJgZv4rlLBNh654/v4HNu46zCgHBVMhz1wo+Z6X9/RG74HDmGebt2mPp2++Kow5oHMPEBH8GjYpdG4iY5IxbuqfDD10QTlx4gQcHBzg6ekpt7HJy8tDnTp14OjoiJiYmGJ/vkQSp191f7v/n/BbKgNubm4YOXIk83dubi7Cw8OxY8cOTJgwAa75ji3169fH/v37ER8fL/f8ly9fcPDgQcazX5ogw8TEBGPGjJErGxgYCGdnZ62wX3369AlcLhflPH2wZP12rN1+CH+MmQK/xs3g5OwKXQ1ywxsZGTHa7enTp4v9As7Ly0OVKlXg6empMQHM69cSOldtkndIozvGz1yIqfNXYuyM+RgwYgLad++DWvUaoZSTc5Emar5AAEdnF9Rp4I/ufQdj0uzFCNp5CGeuh+Lp2++SnX9MCurI7KamzllSpDKwbrvEdDtmzBiNX/LZ2dno1KkTeDweKlSooLLc3bt3QUS4fPlySacSgIRlksPhMA5+PB4P5cqVYzy1lSE+Ph5XrlzBmTNncO3aNXz9+hUbNkjOhmW/o0YyzIOVqvpCT19igShsfJpi6dKl0NPTQ05ODsRiMYKDg+V2rNpM2yx16rSzL4Ubj1+WSCEYNnYKiAjt27dXe+G5evUqSpcuDXNLS5y6dl9pvUNGTwQRyTnmcTgctOnQFZfuhimUv/HkFXwqV5P7ffjW9sORC7eYz6tj994KO/6KVaqDiDBl9iJEx6Vi3vL1jEXT07uSwvxcuhvG/C4PnL6KG09eYf22fRgxYRr6DRmFP0ZNwOI1m3H2+iNExabgwOmrsC/lpPDbbdu2LSwsLJQu+B8+fICDgwNcXV01etfl5eVh2bJlcu3o6+urdK7NycnBmTNnMGnSJDRp0gRVqlRBtWrV0KlTJyxatKhQP5bfGb+lMtClSxfUqVMH3759w5w5c2Bv/yt2ls/nw9bWVu1Qo6tXr8LR0ZH5Ihf8kklfzkePHi1xvydNmqSWt7y5pRUqV68F/xZt0bpDN7Rq3xX1/VvAQ8aawOPx0Lt3bwDA7NmzYW5uXmyzZFhYGAQCAYYMGaJRHd+/f5f8+DVgfywKGzZskHhQv/qmOgnR6+84eeMJ1gcfwZS5y9Cz/1DU92+OMmXdi+Rr53A4sHNwRI069dFUhm++cbPWCH39RUYhkD8muPP8AywsrdCqdetiz3NWVha8vb1hbm6uUvESi8Xw8PBA+/btSzKNAOR5AMq4uoHH46F06dLFpgOWTR2sjFdAKNIFn8/XKvHOtWvXQEQ4efIkw1gpG3WjTUVUqjgREVzdyuF+xMcSKQRL126BSKQLIyMjTJ48Ga9evVL47mRlZeHixYto164diAjVatTG5fvhSuu7HhqtwBrYpEUbnA55oLT8oXPXYZUfIWFsYoo5S9cwCoDUiuNb2w/PPyTIPXf+1hMQSaxvt579sk7sOXaB+dwtrW1w6GyI3HPS4wgzcwumfxYWFnAtWxYOMhansu7lMWvRStwJeyuX80Eq+/fvV/kZvXnzBs7OzhAKhVi8eHGReWKeP3+O+vmhj4OGj8HwsZOZdrhcLjZt2sSUzc3NxcqVKxnrmL29Pdq0aYNBgwahf//+8PPzY47c6tatW6Iji38jfktlYN26deDxeDA3N4eenh4GDhyI3bt3w8zMDNWqVcOPHz80qi8xMRG+vr7g8/mIjo6WuycWi+Hv76/S4UtdPH36VKUioKMjRK16jTB/1SacCHmMc3fCcfL6Yxy+dA/7Tl9H8LFL2HLgDP7afQyrtuzHlLnLYJL/owwKCkL37t3h5+dX7L4Bvyhuhw4dqhE1sb29vdYy8QHAoEGDULacJx6/S2Tk6btEPPuUiLBPyQj/nIIX+Tt7ZRL+KQlXHkRi+8Ez+HPJGgwYNgZNWrSFu4cX8yIsTCytbVDFtxYCOvfEyIkzsTxoBw6evYHufQbD2Ni4xJ7rz549A4/Hw/r161WWkX4WJTWB//XXXwqKUElzuUutG6pixfl8PubPn1+iNmQhpTuWKsCybXG5XK36q/Tr1w9l3cszC6hP5WqMB35x5dazN/CuVIXpu6mpKerUqQN/f39UrlyZSfftVs4D85avV+qbcPf5O/QZNFxB0XX3qKD0DD86LhVL121lyru6lcPFO88QHZeK1Zt2Mc+bWVjiQeQnhWeHjpEkS6vbwF/h3pUHL+CWz8WgIxRi2fptiI5LxZ3nb+HXUGJpq1y5MrZv347Pnz/LKT8/f/7E2bNn0b59e/B4PJRxdUPVGnXkvp8+Pj4qlW2xWIw1a9ZAKBTCyMgIXC4XRkZGGDBgALZu3Yo7d+4gNDQU58+fx4IFC1C7tsSZUigUYtqcRUy69r+275MjQBo4cCCio6Ph6+sLDoeDPn36qMwyK+XDqF5dYjkZMWKEVqjc/w347ZQBsViMUaNGMSa4+Ph45OXloV69eihdurTGioAUiYmJcHZ2Rs2aNRW8l9+/fw9DQ0O0bt26WPkApMxuOjo6EOnpgaflcLjy5cujSZMmxRq3LDZu3Ag+nw8vLy/cvHmz0B1wXl4ejhw5Al1dXa0xNObm5sLRyQkdu/dF+OdkvPicIicRhUkhCoJUXnxOxo2nb7D7+EUsXLURQ0ZPgmPpMmrNMY/Hw/jx40s8RgBo3749PDw8VM5ZXl4e/Pz8ULp0aXz79q1YbUREREBfXx8cDgc6OhLCJW3s2KUsmrI7dFkz9N+pDFSuXkvuMxEIBGjdWjuZ9vLy8uDi4oLOPfrgdMgDmJhKkhrV9muoFtFPUTJ36TpGIZCe0/s1bIJpc5fg0NkQpYv6w6jPGDJ6opwvRlXfWli3dS+z0AcfOSv3TMTnJAwYNoYp36BJC4S+jGXO62WzoHJ5PGzbf1Lu+ajYFIawaHnQNqVjCX0Vh4ZNWzL1dAscAHsHR4YxUB08efIEnp6eTO6B0vmhjqqUZLFYjIkTJzILcGpqKt6/f48pU6agfPnyChwthoaGaNKkCdauXYuaNWtCIBBgy94jjEJw7sZDORZSkUgEFxcXtSNg8vLysGrVKujo6KBx48YlyrHxb8FvpwzMnTsXRIQVK1YwL9Pg4GAQFc8JTha3bt0Ch8ORMx1JcfbsWQmVcPPmGplZw8PD4erqqjGZDofDgZ6+PiytbeHgWBplXN3h7uGFChWroFK1mvCtXR+1/BrCwFBCSuPj41OisUvx5MkTVKxYkalTyuEfHh6OsLAwHDt2DFOnTmXojKtWrQoiws2bN0vc9smTJ0FEsCvliAo+VVC9lh/q+zdH87Yd0aFbb/QaMAyDRk7A6MmzMXXuMsxbHoQVG4KxIfgIdh4+h0PnbuLMjce49jAa9yM+I+z9zyKVhQHDxzJzbmRsgm0HTmFZ0HaMnDgD7Tp3R+XqNRmnucjISC3M8C/mxxcvXqgs8/btW1hbW8PHx6fQCBGxWIw3b97g1KlTOHjwIE6dOoWzZ8/CxsZGIZ98wQiU4iIwMBC2trYwNzcHj8dDparV5ZSBwYMHa6UdALh+/TpTt30pJ1SrWUduTFwut0RJn6SQOtLuOXYB0XGpOHjmGrMIN2sdgIjPSSVWCHYfPc8oGUSEcdPmKC33+HU8xk6ZLees6eldCVv2HmeUhm69B4CIUMuvAfNcQSKhP0aOl7M0/DFyPPMZ1anfmPnOn7/15NdRwHEJpbW+gaFSR0GpRMYkY9DwcYyi7OLionHq5szMTLRp00YuWigiIkJp2aCgIBARVq1apfR+cnIynj17hkePHuH169dyPl5ZWVlo06YNeDwexkyegRcfvuPN1zQ8jPyA0s5lGD+a4hyfXbp0CQKBAJaWlti+fTsyMjI0ruPfgt9KGbh//z64XK4CPXDVqlXRvHlzrbTRrl07eHl5Kd21XbhwAWZmZrC0tMSWLVuUEspI8fXrV8yaNQsCgQBmFpaYPG8lth6+iF0nQ7D//F0cuRKKUzef4/SdCCxctwP1/FsoVRj09PTRo/9QnL7xFM8+JivI0w9JKO9VEQKBQGvmqrdv34KI4OvrqzQ9rbW1NXr16oW7d+8iNzcXFSpUQNWqVUvkAZ+eng4XFxetMxDqCIUwMTWDnYMjXNzKwatiVfjWrof6/s3Rsm0neHhJFB+hUMLlUK1mHSxYuQGrNu3Cpj3HEHz0Arr06g9TU1OtkVz9/PlTsqsLDi60XHh4OLPo7tu3T679yMhIjBw5Eubmimf3RMSYn6Xi4OCglb4Dv5w8nz9/jtq1ayt8ZtpSTAFJdIV090hE6DlgiJxlTdZ3prjIzc1FdV9flCtgdt+2/yRjBenSs69Kk7wmcuH2U+jnH1fp6AjldubKkgiVdS+PdVv3KrR95cELZt4PnrmmQCS04q/tcuUXrd7I1Ll49SaEvfuOSlUlKZxLu5Rljgu69OwLIkL7Lj3VGk/FKpKssR8+fCjW3GdlZTFHtHw+XymnxJs3b6Cnp1eicNWMjAy4uUn8ZgyNjDBg6ChcexCO9l16QF9fv1CH2qIgPdYjkrDDapK47N+E30YZEIvFqFixIqpUqSK36ERERIBIe5TBUgIiVayD8fHx6NSpE4gk5389evTAihUrcODAAezbtw9z585F69atoaOjoxAfb2ZhhToNm2LKvBU4ciUUD978xMO3iYxcePAKo6bOhaOzcvIT3zr1ERR8BE/eJ8opBLtOSDIrXrp0SStzIE2HGxcXh7y8PLx69YrxtD558qTCoihV0opLSSwWizFkyJBi8wn8L6RmzZramFoG9vb2as3X169fme9buXLlsGjRIoau19LSEhMmTMCZM2fw+fNnJCUl4fPnzzhz5gwmTJgAU1NTZhHVRh4PKaSm+1OnTiE1NRWVK1dWiEl//fq1VtqqVq2a3PeCx+NhwLCxCp/P8ePHi93G/PnzweFwsO/kZYXFbtWmYGYOB48YX2JlIDouFYEDhsqNZ9bClSqTCBVmkWjfpSeICN6Vq8kRCUmJg2QtElKl5o+Rv8ZwO+wN7OwlznK1/Brg8at4ph4p2VFhsuOQJIqppInOXr58CaFQCB0dHaX3e/TogVKlShXpLFgU7t+/r/S3/ddff5WoXrFYjMaNG8PFxYXxO1i3bl2J6vwn8NsoA1K60IIhVzt27AARISkpSSvtpKeng8fjYePGjYWWe/XqFSZNmoQaNWpAlM8QSCQJT2zUqBHzAi9MhEIR3D290XPAcGzcfxa3IuPx8G0iHrz5iS0Hz6Nlh27Q0VH0jreyscX4mQtx+8Vnxjrg6l5eK2xsYrEY3t7eKFOmjJyWnpCQACLC7t27lT63aNEiEBHmzZun0Q46NzcXEyZMABFh8twVuPr0PY5ff4pdJ0OwftdxLFq3A1Pmr8TwibMQOHgUArr2RqPmbVG9dj2Uq+ADOwdH5qikpCIbh69vYAgDIyPoGxiCy+OhcePGJZ5bWZQuXVqj1NEhISFo3bo1+Hw+BAIBlixZUuQ5ZWZmJhYvXgyBQAArKyuNCalUITs7G0SE7du3AwCio6PlLBE8Hk8u9Le4uHfvHogI9Ro3l/ucfKpUh53DL+90LpcLkUhUrMiCLVu2SBbJURNULnpzl65l2po0a0GJlYEZ85flL9wOCt9BaRKh8I8/i6zn7I1QuWelREKyZS7eecYcTTRt1U7BQfHE5bvQ1ZWEi0qJi2zs7NUiWWrcrBUqqLCiaooRI0aAz+crWFu/fPkCHR0dLFu2rMRtAJKkR7KWLHNzc61YVKWp7i9duoTRo0eDiLB582Yt9Ph/h99GGejbty/c3NwUvnjjxo1TydVfXHh4eGiUMjM3NxeJiYlITk5m+letWnXU9GuEWy9isHn/GQwcMRFelaoVmvSEw+HAysYO9Zu0wsylQTh3PxrXnn3ElPmr4OruqVCeLxCgVYeuOH71EWYtlrywrl+/XqKx79r1y9u4Ro0acufkZcqUUbmAicViJmNe48aN1UpDGxkZiRo1aoCIYOfgiD1nbuDRu8Riyf3XP3DlyTscD3mC4BPXsG7nUSxYuw2T563AsAkz0WvQSLTrEogGzVqjas26cPPwgq19KeZ4oCjRpulbLBbD2NhYI+bHhIQElC9fHvb29hrHOYeFhcHGxgYeHh5aYV7LyMgAEWHnzp3MtalTpzIvWb5AwhpZEg6ArKwseHp6gsfjoW3H7ujcs5/c5zF03FS5v6UUybNnz0ZCQgKePn2Khw8fIjo6WqnpOTExEf379wcRoXufgUUeAYyb+ifT1oKVf5VIGVi3VUKsJRTJf/fcynuqHc4Y9u47Q/RDJMlZUNDR8UHkJ8Yxz6tiFZU+ANL+SGXQ8HFFtv8w6jO4XK7WdsAvXrwA0a+8BFJs374dHA6n2I60BbF///5f708+X2tOwWKxGGXKlMHw4cMhFosxaNAgiEQirZBv/a/w2ygD5cuXx5AhQxSuDx48GJUrV9ZqWzVq1ECfPn2K/fypU6dARFi5eR9C3yUqyNk7L7Bg9RY0a9MJdg5OhZrHdfX04eFdGYGDR2Pe6i1o37WP0nzhru4eMDQ0gqOjY7GTBr19+xampqbQNzBAea+KsHcsDQ6HgxYtWmDv3r3o1asXrKysCt2Rnj9/Hg4ODuDxeAgICMDevXvx8uVLZGVlITMzE5GRkQgODkbz5s3B4XBgYGjE5BLgcrno2mcwQp59KLZSoKnMXiYJv6tWqy5OXn+MVvk86xaW1pj85xIMHj0Z5Ty9oKOjU6xIEmX4+PEj87mNHj1aLYWgR48eMDExUQh9VRdRUVEwNjZGr169ivW8LMLCwkAkTw378eNHxrKioyNkOA0KEn6pA7FYjD/++EPOQ7yMqxuatGwrt/g3LZAm18bOXo7qWyr6+vpo0KABduzYgUePHmHKlCmwsLCAvr4B/ly8Wi1fgKjYFPT7YyTTtix1r7oiTSLk4laO6ZuRsQmat27PpNeu4FMZN5++LrSem09fMxEcXO6vXe65m4+ZMuEff6JGHQn1r62dgxxfgDIZPHLCL2VnRVCRY1m/XbKoqnL4K85nbmZmpuD7NWzYMK2mhZaypkpFG/wxUnTv3p05TkxLS0PZsmVRr149rdX/d+O3UAaysrJUevmPHj0a7u7uWm3P09Oz2B7R379/h42NLTy8K2HnsSs4dfMZboZ/xqO3P5UqBqHvEnHv5TfsOnkNf4yZCp+qNWBgqOi0J/sStLZ1gKdPFdjYKVLHGhkZoXLlyhp7xr5+/RqlS5eGq6srE50h3ekVdBBT9jnIIiUlBUFBQfD29lY5Dmtra/B4PJx/8BJn70bAv1X7X6Y7S2vMW7UZD9/+/NuVgYVrJb4QVWvUwbOPybgTEQNzS6t8s2tNufAjbRHcSE3TUmnYsGGhDlhSPxbZnXhxIPX7UJeQSxWk5EMFj+aknzcnX7nl8XhwdXXVKAojLS2N2bETEczMLJi4f6FIBJ8qvyIXZI+HOBwO9PT00K9fP2zduhV3797F48ePcenSJSxZsgQN8olneDwe+Hw+AgcMxbWHkRov5lJiHR2hEDsPn1H72YJJhKR9vvP8HXNfas63tXPAyav3lNZTkEho+4FTaOAvOUaROv1FxaagY/feIJKkYz5xRXldsjJ93lKmX8YmpgwvgaxcfRCB6fOWopZfA3C5XOjo6Ci1uhQXjRs3hpGRkZxy3LRpU60QcEkhFouhr6+P5s0lc6bNnfu8efNgbm7O/C3NIhsaGqq1Nv5O/BbKgNT7WlkM68aNG8Hj8Qr17NcEWVlZ4PP5qF27tsYUxD9+/EClSpWUesQLhSJY2zmgXAUf1KjbEM3bdkb3fkMwbPwMTFuwGks37MKWg+dw5PJDXH3yDpdD32DJX8FoEdAFDk7OhXIT8PN3QyYmJnjw4AGsrKxgbW2No0ePFrnrzMvLw6ZNm2BoaIiyZcviw4cPyM3NhZ2dJDGSSzkPDJvyJ3adv4WVOw+jQuVqMDIyUjs17bdv33DhwgXs3LkTwcHBuHz5MkOfTEQQCHSwYM02PHqXiPW7jsPR2ZW5V7VmXRy6dP9vVQaWb5KYSL0qVWX8L1q27woulwtTU1NMmTIFT58+Rbly5dCxY0eNvg/KIBaLUalSJdRt0BjPPyRgedA26OrpQSgUYuDAgbh7966C5cXPzw/VqlUr8dmsWCxGtWrV0LRp0xLVU69ePdStW1fh+qBBgxQcCXk8HgQCAebPn4+fP3+qrDMvLw+nT5+Gs7Nz/kIj8ZUxMTXD7efv4NewyS9l0cJKrn4+n4958+bJZYZUhqioKDRtKgm969F3ULHCBV98SkTjZq0kFgcDQ6Vpe2VFWRKhwAFDmXeELK3vxTvPGLO+voEhNu85JleXKiKhA6cl59V8Ph9XH0Rgwox5zMZh467Dao3Lu5IkRNg236GwjKsbHkR+wpHzNzF0zCSU8/RSeO+YmpqW6HtUEJ06dQKHw5FLDNewYUN07dpVq+2YmZkxCqdswrqSYunSpTAyMmL+zsnJQalSpTB06FCttfF34rdQBtLS0lTujEJDQ7W6a7t165baOzZZhISEMLTGHA4XvPzsZwXJMNQVLpcHY1MzOJUpi0rVaqJR8zZo0roDqtaoCwcnZwXfAz6fz4RYxcbGok0bSQKTihUrIigoCM+fP2eiMLKysvDo0SMsXbqUyeMwYMAAOYbFESNGwK6UI+6+/ykn55++hYW1DapWrVYsp83Xr1/DxtZW4aijXAUfXHjwEneivmDo+BnMWT6Pz0fvP0bj5ouYv0UZWBcs0d7dPbzw5H0i2neV7KgGDhwoNz4pN39J+RT27NkDIoKllTU2BB9CdFwqevYbzHyG0n9dXV3h4ekJU1NTrVgFpJA63BY3FOzBgwcgUk4ZO3PmTKVmeukuWCQSoVu3bli5ciXOnDnDKIkjR46Eo6Oj3OIufU5PTx+RsakI/5SECTPm/7rH4YDP52vsQyEWixEUFAQul4tO3fsUK1ww7N13+Nb2kyyIZuZy5nmpFJVEyDbfefDgmWtyz92P+IjqteoyczFr0cpCiYSkIk1V7NfAn3nnTJu7RK3xnLv5mGnv8LnrDOVwQcZDDoeDch4VUMpJwjEiEom0Fm4LgNmtm5qaMs6uAQEB8Pf311obmZmZ4PP5mDRJwrKozdwWkyZNgqOjo9y1fv36oWLFilpr4+/Eb6EMAECpUqXkMvVJkZeXBzc3N61pj4GBgbCwsEC/fv1gYmICPT09DB8+HE+ePFGwFGRkZOD8+fPMwvtPhsZxOBy5tLhisRjnz59H69atmX7x+Xzo6+szfwsEAnTv3h137txRmAfponE5/KOCQrDjdAgMjYzhU7GiRmeGV65cgbW1DRzLuOL0gyh06ftHAQWIiwEjJ+LRu0ScuPEUdRs1Y+5Z2zlgyV/BWj862HxAQgBU2qUsAgeNAIfDUbrw5ubmolatWnB1dS22E967d+9gamoqpwjVb9wMI2Sc4aTnvN6VqqJazbrM9eL6gRTEt2/fVC7mRSErKwsVKlSAj4+PUv+JqVOnKlUGZGmgLSytFBznBAKBnNJsYyuTa0QgyE8clYLwz8nYe/IKzCwsweVyYWlpWez4cOn3e9HqjRorA9FxqQh9GQtP70ogkpj1Qx5FITouFZfvPUfbjt2Y8ahKIiRNBLR2yx6Fup9/SJB3DpRJ6FOQSEgqOw+fkZvTwpwiX3xKxN3w9zh/6wkOnL6Kxs1bg0hijZD6LsiKvr4B9PT0lW5sZDO8lhQ2NjaMUuLh4YEvX76UOO9KQTx69AhEEqpvLpdbZNSYJvD390ebNvKMmOvXrwefz9eav9HfCT79JqhatSrdunVL4TqXy6WhQ4fS+PHjafLkyeTj41PsNiIjI2n//v00d+5cmjhxIq1YsYKWLl1KmzdvpnXr1pGhoSF5eHiQrq4u/fz5k168eEG5ubnk5eVFGzdupK5du1JGRgalpqZSWloapaamyv1f3WupqamUnJxMqamplJmZqVbfAZC9vT3zN4fDoaZNm1LTpk0pOTmZnjx5QhEREZSZmUn6+vrk7e1N3t7epKenp7Q+aV1nD+8jJ1c3MjYxJaN8cfP0pvX7T9H04f2oUqVKNH78eBoyZIhc+7IIDw+n5cuX044dO4jL5VJZS2u6ffUC9R89mar7NaDJg3tRTnY2icVi2rJmCZ08uIuWb95HK7fspxuXz9GyPydR7OePNHFIINWq708TZy8hBydnDT9d5dARioiIKDkpkYI3raXly5dTYGCgQjkej0c7d+6kGjVqUNOmTencuXNkbm6udjvv3r2jBg0akIGRCR06f4r2B2+lnZvWUcjl83Qz5DJTLj42hoiI+g4eTtVq1qU6Pi5kZ2enUVuFwcLCghwcHOjJkyfUpUsXtZ/Ly8ujAQMGUFRUFD18+JAEAoFCmaioKMrLy1O4LhSKKD0tlYiIrGxsaePuI9S5RX3Ky8sjHo9HOTk5cuXT09OY/+cWuGdta08Z6ekkFospODiYnJyc1B6DLHr37k2XL1+mBTMmUt0GjcnC0lqj5w0MjWjLnqPUvV0TevfmFQV2bEGVq9Wg08cOUm5uLhERNWnRhkZOnE5l3T0Unre2tSMioi/xsQr3dHR0aOGqDWRkbEI7N6+nz58+EJfLpXnL11OHrr2ISPJ7z8zIoKTEn5SY+JN+/vhBXB6PxHl5ZGRsQvr6hjRr0ihKSvxJSYk/KTkxkRLz/5+akqx0TGmpKcqv5392ynDjxg0qU6ZM4ZOlBj58+EDx8fFEJPmuRUdHU8WKFWnEiBH048cPCg0NpapVq5a4nQsXLpBIJKLq1atTpUqV6MKFCzRo0KAS15ucnEx37tyhadOmyV23tLSk3NxcSktLIxMTkxK383eCAwD/dCfUwf79+6lbt2704sUL8vCQ/3FlZWVR1apVic/n071790goFGpcf3Z2NtWtW5eSkpLoyZMnpKurK3fvxo0bFBoaSlFRUZSVlUWGhobk4+NDvr6+VLlyZeJwOCUeozKIxWLKyMgoVJGIi4ujiRMn0qFDh6hjx45aaffixYvUtGlTpff4AgEZGZuSgZExZaSnUuKP7yQWi6latWpUvXp1cnBwILFYTK9fv6Z79+9T+PPnpCMUUnZWllw9AoEO1W3Sgir51qa9m9ZQ3OdPcvcbt2xHc1duprzcHNoetIKCN62hnOxs0tERUp+hY6j3H6NJmL+YFxevo15Q1+a1SUdHh3xr1KCQa9eIy+WqLP/kyRNq2rQp8fl82rRpE7Vq1arQ+gHQ9u3baeTIkcTh8uj4lbvkUEqygL17/ZLmT59At65fYcrz+XzKzc2lk1fvkZ6ePjWtXZG8vLzoyZMnJRqnLCpWrEhmZmZ05coVtb63379/p4EDB9LJkydpz5491LVrV6XjtLOzY17o6sLQyIhSkiWLk+x3xNTcgn7++E5ERE/f/iCBUEDZ2TnUt1MLCn8aSm3atKEjR45o1FZB/PjxgxwdHWnAsLE0bOzkYtUR8fwp9Qhoxig7RER16jem0ZNmklfFyiqfmz9jIgVvCaL+Q0bRoBHjJIt2UiIl/fxJSYkJ9PjhPTq8N5iysn5tBvT09MnKxpbSUlMoMfEn5WRnF6vPqlDG1Y1c3MqRk7MLJfz4TpfPnqTk5CSV5blcLlWtWpXu379f4ranTZtGixcvllMmuVwuicVi0tfXp06dOtH27dtL1EZubi65uLhQ48aNaevWrRQUFEQjR46k9+/fk4ODQ4nqXr9+PY0aNYo+fPggtynas2cP9ezZk1JTU0lfX79Ebfzt+CfNEpogKysL1tbW6NKli9L7oaGhEIlEaNu2rcZJI7KystCpUyfo6Ojg7t272uju/xR5eXkwMjLCwoULtVbnunXrwOVy4VXFF2Xcy8PC2lYpAVJBEQgEzLmvgjMZny+XLUxWhCJdOc99qYh09TB/zWY8epeII1cewbdOg1/mUydnrN5+qETHBEev/iJuUTdJyadPn5jzzapVq2LTpk2IjIxkjpGys7Px9OlTrFy5kvHJICLYOZRCVFyqvMSmYPSkmQrjdpJhofT09NTa5wpIeDSICC1btsSdO3dUmmCTk5MRFBQEKysrmJqaFsryJyVdKShS07Kurh7KV/BR+9hLVyavwqLVm3D6eih6DRjCXCspn4YUAwcOhI2tnca+A8qSCBERXMq6Y/uBU1i/fT8WrtqAybMW4o9RE9Ct9wC0bNcRdeo1QgWfyjA2MVN7LgoTPp8PQT7hE4/PZ45kvCtVwR+jJqBTjz6oXrMuDI3kibl4PB5q1q3PHFc0ax2AOUvWoIF/c5W/c109PbmjH7dyEu6Tc+fOlegziI2NhaGhoVxbXBknbA6HU2LeCgBYsmQJuFwuwy6blJQEMzMzdO7cuUT1fvv2DVZWVujWrZvCvWnTpsHGxkarvhV/F34bywAR0e7du6lXr150+PBh6tChg8L9c+fOUUBAAHl7e9OOHTsULAjK8PLlS+rTpw+FhobSwYMHqW3btn9H1/921K9fn8zMzOjo0aNaqa9Pnz60Z88e4nB55FW5GjUL6Ey1GjQhfUNDSk78SUk/Eyg5MZGSk6T/l+xokhMTKTnxJyUnJuT/m0hJiQkl3sXw+HxycHQmUzNzys7OprevIikzI4OIiNw9vSmgWx8qXcaVjIwlRxkmpmYkFOkWuvPNzsqie7eu0tgB3cjW1paCgoKoUqVK5OjoWOSOGQCdOXOGgoKC6Pz58wSAdHR0SFdXl9LS0ig3N5f4fD7VqtuAbly7TJL3GtGm3UfJr1ETph5xXh4dO7iXpo0dotAGh8MhkUiXADGlpqYSj8crxszJIzc3lwwMDCgrK4uxQri7u1PNmjWpfPnyJBQK6du3b/T48WO6desWpaWlUadOnWjlypVka2urci6aN29Oly9fVnpMQEQ0de4S6tn3DxrYI4Buy1hC+g8dQ1uDVhLRr51gUTAxMaGEhAStWOPOnz9PzZs3p0t3w6iUkzOlpiRLzOk/f1JyUiIlJibk79YlO/cf379S+LMn9P7NK2asHA6HSvoa1dM3ICNjY8pIT6ekxJ9ERFTaxZUaNG5OZhaWJM7Loz07NtHX+DgSiXRp1qKV1KRlW1q3fCFt37CGdIRCCj58ll5HR9L08cOJz+cTj8eXsywYGBpRvUZNqGGTFlStZh0Ke/yIxgzpo/K3aWhkRE6lXejF86fM+MwtLKl9l1509sQhivn8ibhcLllZWVFERASZmppqPG6xWExt2rTJ/w0R1WvUhPxbtqE5k8dSZqbk992+ay8Ke/yQ+Fyie/fukbGxscbtPH78mGrVqkUjRoygpUuXMtf37dtH3bt3p+DgYOrVq5fG9ebl5VGnTp3o+vXr9OLFC7KxsZG736hRI9LV1aXTp09rXPf/HP+gIqIxxGIx2rdvD319fdy4cUNpmfv378Pd3R06Ojro378/Hjx4oOD4l5eXh9DQUAwePBgikQiurq6/bXIJKRYuXAiRSKQVR7OUlBSFjHdSsXcsjZ6DR2LDobO4+fqbgnOhMrnzLgFXIz7j+J3n2HnmBtbuPYE5a7eiWUAX6MvEivP4fFAxoy+UiY6OEBZWNnBx90Dl6rVQv0lLtOnUE41atIOLW3mVVgo7OztMmzZN7SxsCQkJuHz5MtasWYMlS5agRYsWMDA0woPoWETEpKBy9ZpM3Ta29rjz/B027T6KTj36yCWlkYpAhtpX6uz59OnTEn+ugCQrpWxb0vj8SpUqwcjICLq6urC1tUWLFi0wd+5cteZAykuhSjgcDvaeuIyouFRcuBsmd+/i3edycyDleJAVIxNTub+1SQ399evX/J2ufokdgDmcX8+bmVvAr2ETtArojJ79BmPY2MmYOmcxFq/ehA3BhzBr4UoQERwcnfD8Q0IBIiEups1domCteBD5iXEw5XK5aNXuF+V5i7YdmMRDct9l+1Lo1f8PbNt/EofP3cD46XNRo049ue9YQbGytkXNAmWkoZCyWRdl71WrVq3Q0FFlyMvLw7Bhw0BE6N57IMO+OHXOYrn6m7RsCxtbe6YdTdPUP3r0CBYWFqhevbpCCLpYLEafPn3A4/E0dqrNyspC7969weVylebGefv2LTgczm9DS/xbKQOAJMywQYMGEIlEWL16tVIugPT0dCxYsAClSkliZg0NDVGjRg34+/ujRo0ajEnKzs4Oc+bMQVpa2j8wEu1CyuE9Z86cEte1atUqcDgctA1oj0b+TZUyHhIRRLq6qNukBaYtWYeT9yPUUgwKyrWoWAyfOgeGMula7R2d4VC6jMqXlYGhETr16o+eA4ejnn8LucWCx+MV+lKXmq3Lly+PlStX4t69e0hOTkZmZiZiYmJw6tQpDBs2DIaGhhCJRFixYoXGxCrHjx8HEeH641eIiEnB8PHT5PrAL+BxXzC3Qt0G/ujV/w8YGBgyYxozZkyJP1cAGDVqlAIPBo/Hg7+/f7HSr969e1cuN4cqMTUzx9kboVi5UV5xmLtsHQI692T+rl7LT+FZ6XGTd8UqcCnrjr59+2plLqQoGAEhEunC2tYObuU9UdW3Fsp7esuZyE3NzNGz3x/Ysu84jpy/icv3w/EoOgaRMclYt3Uv8/3rP3S0ymOGy/eeg0hCpHTwbIgckZBsJkNlkQbSBEWqxD4/+sDQyBjzlq9H247dYGZuoVCu4LgtLK3g4SV/lONdqSr6DBoOt3IeCs87lPrFnsrj8VCmTBmlkUnK8OnTJ/j7S8Ig5y5di+g4CbPi0nVbC801wufzYWlpiRMnThRpes/KysK8efMgEAjg6+urUonIycmBpaVEIe3bt69a0UKPHz+Gj48P+Hw+9u7dq7TMH3/8AWNjY6SmphY9If8C/HbKACAJ6Rs+fDiIJGe2u3btUko6lJaWhlmzZqF06dIgIjg6OqJLly5YuHAhLl269FuEe2iC8ePHQygUlogi9N27d9CTefGVdi6DrcF7cfLcJfTs0w+mSnYGUnEu645eQ0Yj6MBp3Hz1VSOl4OKz9+g9bCxEur/a9qxYpdCz1Wq1/HD39Vc8ev8TMxavg36+ksfhcGBqZg5Xt/Ko4dcQAV37oGvvwdDV04ONjY3SzIsFkZycjFGjRjF0zJoojNLz8/2nr2LusnUoU9Zdoe/GpmZo36UnOvfoi+o16zIJiFTF6RsYGBSL2lcW8fHxKi0+XC4XtWvXVjtUTywWY8+ePRCJRIUqXzweD54+v0LwpGx5UguQkbEJFq7exJSvWLWG0nqMjE1w/ckrVKrqW+KUxQXHwePxUd+/OTYEH8KtZxIq4MiYZCxbv03Od8PGzh5zlqwpMonQ/BVBzDPjps1RyVUgLSON53cp666U+S86LhWhr+KwZvNutO3YTWGx5HA4qFW3AWbMX47Vm4IxcNhYuRDBgr470s9FqhTq6ukz3AG/lLK6aNoqAMYFrDJS8apYRWmdHA4HHTt2xNWrVxXer2KxGOHh4Rg9ejT09fVhbmGJgcPGoEuvfkz6ZUWFRTH7q/Rvb29vrF27Fo8fP2aSDSUlJSEkJATTpk1jWE6nTp1aqB9ZTk4OdHV10S6gAwwNDaGnp4fBgwfjzJkziI+Ph1gsRl5eHqKiohAcHIzGjRtL5sDLSyW74LVr10BEWLVqlda+q383fktlQIqQkBDmg+Hz+ahYsSICAgLQoUMHVK1alcmkVrt2bZw5c+af7u7fjvT0dLi7u6N8+fIa0xEDEqbHypUro1QpRyxevhrW1jbMD7BGrdq4dP02fqRm4dqt+xg1biIcnEqrXAR09fVRv1lrTFm0GifuhqutFJx6EIn2PfvJMS5aWNv+ejkoMW+6lvOERb552c7ODm3btsXgwYPRr18/1KxZEyKRCDweD7Xr1NGYI+D8+fPQ09NDixYt1LYQSHNTFIzLlv2bLxCAm/9C9vb2Rv/+/TF27FgMHjwY1atXh1AoBIfDkcuk2K5du2I7IonFYrRt21YpOyYRwdrWDnp6etDV1cXcuXNVKh5isRg3btxgHCjVIdU6d/Mx87KXHY/swiP9v6mSHSwRoWHTloiKS0XzNu1Ru06dYs2BMkjTMRdUPGQtAYaGRhg+biqevf2mtoPhxJnzmeelO19ZificBJHol8WtgX9zBSKhG49fYvaiVajbwF/p997AwJBZ6A0MjeQUaakYGxtj+PDh2LNnDx4/fozw8HCEhIRgxYoVchTN0u9kVd9aKFdBNY146TKuKu8VVD4EAgG8vb3RqFEj+Pr6MhZZgUCgUslQR6SslqVLl5b7HskqDUZGRhg2bJhaG6OTJ0+CSEIbHBsbi+nTp8tZuwp+x2vUqIFdu3apzHb44sULWFpaws/PT2MW238Sv7UyIEV0dDSCgoLQv39/NGvWDE2bNkXv3r2xZs0ajTO8/e6Ijo6GtbU1ypUrp9E5c2RkJHx8fGBqaopnz54hOycPn74kYMKUadCVOSbo2LkrnkW+QkJaNhLSsvHg6QtM/3M+KuQTsKgSF3cP9Bg8Auv2nsSNl1+KVAoOhoTCv00HpT9ID5/KsM4nppEeCwwcOFDpeDMyMuDu7o6KFSsWOx/6hQsXwOFw1E6jOn/+fOYl5Vi6DBzzjzykSWV4PB5MTEywePFilUpbSkoKNm7cCEdHR7mX3KxZszTuv1gsxsyZihELslKvcTPUqP3rPJrP58PX1xcjR47E/PnzMXv2bHTp0oU5euPxeMz5sSyJlYWFBYyNf0WF8Pl8tO3YHeduPoFxPpuiQEeHmR/pgih7TKRMjE1MEfb+BybMmAd9fX2tWfUOHToEIkLlajWVnofLLb6GRvCuVBXtOnXHuKl/Yv32/Th/6wlefEpUqhAMGj6OmZ81m3cz1x9Fx6Beo6ZMvc1bt0fE5yRExabgxOW7GDlhOir4VFZov5STMyytrEEk8ea3d3BUKKNvYAgDQyPo6elhzZo1RR79REVFyWyoflmlZBVRIsmRQ1Hzo1w4ckpPcUQk0kXNuvUxY8FynL3+CBfvPIOre3mIRCJ8+PABt2/fxrZt2/DXX39hz549cmyrRUEsFqNRo0aoVq2a3PUPHz7AwcEBZmZmGDVqFDZv3oyLFy8W6a9w9OhRmJubw8vLS2tEYf8r/CeUARbyePnyJSpUqMDQbn769Ell2bi4OMycORNCoRBubm4ICwtj7uXmiZGUnoPnL9+iW49ezMtBKBRi9LgJeB/3nVEKEtKy8fzVeyxYtho16zaQCw0qKLr6+vBr0hKTFqzEsdthhSoFO05fR416jRTqsCvlBANDQ7i6uhYacjRr1izo6OggPDy8RHM6ZswYiEQitczoTZo0UWDZk5U2bdrgy5cvarWbmprKOFlJZeDAgWorNsnJyRgwYECRL1wrG1u4la+gcF0gEDBhogWtChwOBw4ODli4cCHCwsLkXsBfv37FyZMn0bZtW3C5XLiULafUwW389Hn5df1SeAruGqWL1KrNu3Di6j0QEQ4fPqzW+ItCu3bt4Fi6DKrKJBESCkWo798MgQOGomHTlnAq41roUYhAIICrWzk0bdkWQ0ZPxNJ1W3H0wi08fh2Pzj36MArQ9gOncP7WE5RxdZNTovoMGo5e/f9QWNw5HA4qVqmOHn0HIbD/EJXn/j6VqzFOmHw+H+XKl9eIGVAsFmPNmjXgcDjQ1zeAjZ29Qj/UWbSNjE3k2CZLIkbGJpgxfzlOhzxgHCnvPH+Lnv0GM5YHHo+nNJxPE0jpwY8dO6ZwLyYmhrGedO/eHffv31c5fyEhIWjbti3z+9bUyfHfAFYZ+I8iMzMTM2bMgIGBAXg8HurXr4/x48dj/fr1CAoKwqRJk9CoUSMIBALo6upi/PjxSv0uxGIxUjNzkZCWjWu37qOOXz3mB2thYYnlq9fha1K6nFKQkJaN1x/jsXLDVjRq0YZJUaxKnMuWQ7eBw7Fmz3Fcj45XqhSs33cKnhWrMs/weDz4+PgUavbPyMiAhYUFRo0aVeL5TE1NhbGxMSZPnlxouXfv3sm9PB1LuzC0tRwOBwMGDCiW6XDJkiVMnVwuFw4ODti4caNKpSAlJQUbNmyAvb29yoVM1ZFBUV71UjPtkiVL1Do6CQ8PR5UqVeVSHEvruvowCs1at5erv2Ccu7Q/9f2bIyouFZWr10StWrVKbIKNjo6WG6uOUIjeA4fh9vO3CnwQYe9/4FTIA6zavAsjJ0xHq4DO8KjgU+Su187BkYmQ4PP5jDOusYmpHO2yVEQiXdSu1wjtu/ZC42atlO7GrWxs0aPvIPy18yBCX8UhOi4V9158gLGJCZycnNRWNAtiw4YNxV68C+ZK0USMTUzh37wN9A1+cQ0E7TjAWFIev47HiAnT5BSNWnUbMBa34nrrP3/+HCYmJoVS2efl5WHDhg1yfmcBAQEYPXo0Ro4cidatW8PWVnKM6e7ujj179vwWnALKwCoD/3EkJSUhKCgIAQEBcHR0ZHZ6Dg4OaNOmDVavXq3WOXpGdh4S0rLxIzULew4egWvZXw4/7uXL48DRk/iRmqWgFCSkZeN9/E9sDD6AVh27FWkO1tXTR53GzTBh7jIcvflMIURx4YZd0NM3gLGxMZPMRBUOHjwIIu2lKR01ahQsLS0LXYQCAwOhq6uL5Rt24Oazt4iIScWYKXPA5/NRs2bNEqV8DQwMZBZwqRlXJBKhTp06GDlyJKZOnYoRI0agdu3aEIlECqZeqXA4HJibm2Pq1Km4cuUKfvz4gdzcXCQlJeHWrVtYuHAhnJycmLIFz2WNjY01JoDJyclBYGAgOBwOhsnkYmjfNRB3X3yEnYNiOu6CYaY8Hg+3wt5g+0GJT0ZQUFCx5zIvLw81a9ZkHOk69+yLkNBoRVKoIiQiJhmXH7zA5j3HMHn2InTq0QdVqtdkkv2oIxwOByamZnAsXQa29g4K92WtTCMnTFd6JDFl9iJJSmQ1vfmVQSwWIyAgQO7zLm6itcLExNQM/i3aYNrcpThx5R4iPidj9ebdzH1Xt3KIjElG+MefmLVoJeMPRESo4FMZi9dsYqwrUqfF5cuXa6Qc3rx5ExYWFvDx8VErJDI3Nxdnz57FhAkT0KBBA3h4eMDT0xP+/v6YMmUKrly58tsqAVKwygALtZGTm4fEtBwkpGXjS2IaFi1bCTPzXy+9+g0b49b9UKUKQUJaNhJSs/H5RyqCj5xGpz4DYWVrV+SLw8nFDV36DcGq4CMIiYrDluOXQUTYtWtXkf0dNWoUXFxctDb+8+fPg4jw8uVLpfeljkhzlq5FREwKImJSERGTigZNWoLH46l8Tl0kJCTA3Fz5IiONRFAVjSB9cfL5fCxatEil85MUeXl52LlzJ4yNjWFoaAhra2umjnv37hWr/7m5uWjRooUCt8KI8dOx+/hFhf7K7rqlWSwnzVqIqLhUdO7ZF7q6uir5RgqDWCzG2LFjJTtMv4a4eDdMYyVAHSVh6/6TaN2+s0JorqxC5+Ligpo1a6JKlSowMDBg7usIhahYpTo69+jLhKL2HjhMqSJwJ+wtDA2N0L9//2J9LrKIjY1VGn1QEjE2NWOsY14VKyPiczKiYlPlpLpMUq7FazZj9eZdcs6KjqXLYOXGndh24CRzjGRrZ48Tl25h4NDRICI0aNAAjx8/LnR8cXFxTJRQnTp1frtz/b8TrDLAQiPkicVIzshhFvh3MV8xfNRYJnKDy+WiV59+iHzzUbVSkJaNH6nZ+PwzHQfOXUfvoWPg5OJW5EtFpKsHSxs7ODk5qbXDrl+/Pjp16qS1sUsz/h08eFDh3o0bN5gwuwZNWuDRq3hExKQi/FMyzC0stZZVc/bs2XKmbXV3bjweD+bm5hqTF3369Amenp6wsrICl8stlgOjLGJjY2GixJN83LS5CvwLyrzj3cp7IjI2BTeevoJIJIJIJMK+ffvU3pWlpKSgX79+ICIMHjleqwrAs3ffsWn3UXQN7M/wBsiKMD+E0M/PD4cPH1Y44hGLxYiIiMDEiRNhZGSksEN3cnZBw6YtMWDYGCxctQHBR85i2NjJzDxpi5iqW7duJVYILK2sMX76XBy/fBcRn5Ox94REibezL6WgCJy5/oh5ztTMHN6Vfh0HmplbYOaC5Xj+IQGzFq1k5qRilWq49/wN3n5Nx+eEDBw5dRZOpSXhkb6+vpg+fTqOHDmCa9eu4dy5c1i6dCkCAgLA5/Ohp6eHZcuWlchK918Eqwyw0BhisRjpWblyi/vj8Ci0bf/L+19fXx9TZ87G52+JhSoFCWnZ+J6ShU8JGThx/RH+mDAD5ZV4UvNknIZmz56tVj8rVqyIoUOHanXcRCSX9jQ3NxdLly6FUChEWXcPJgTM07sSrj9+hRNX7oOIcPHiRa304cOHDwUWmKIJfyS7bFGxI2vi4+Nhb28PoVCoFQKV+fPnMwpN38EjVfdbRWjm/tNX4e7hJXetbdu2ePTokco2s7KysHfvXjg6OkIoFGH+yr+0ogDcDX+PRas3oUnLtiqd56RHLWZmZjh69Khac/T161d06NBBbYXPwcGhxJ+LFNIIC01EGilDROjYvTdefE6Sm6dbYW+ZsYS9+yGnDPToO1ihPj09fQwbOxmhr+IQ/vEnuvcZyNxr26ErIj8m4MP3dHxLzmDeI9+S0rH/4BG0btMGVlZWBerTQ+3atbFq1SqNmRL/v4BVBlgUG1k5efhZYGE/ezkEVapVZ36EdvYO+GvzNnxPySxSKUhIy8a3lCy8+5GGsw9eYOzsxahSs66Co5u6C2vVqlUxYMAArY03OzsbRIRt27bhx48f2LBhAzw9PcHhcNB70Ag8efMde45fZs6LbewcMHLiDBARkpKStNYPCwvlsfiFyfr160vU5sWLEjP+9u3bS9z/+Ph45jO9/fydXAIjdRY+Wf+CGnXqw8TUjNnJenp6YsiQIVi3bh02b96MRYsWoVOnTjAzkzji1anfCBfuPCuRAnD+9lNMnLUAVWvUVnC2NDQyhlmBz4fP58PR0REfPnzQaJ7EYjFmzZoFIsLEmQuwbf9xtOnQRSE5EpfLRYcOHUr8uUjx9u3bX5+HGs6n0nBHqbh7VEDo63hmviJjU3D4wi0I8h1DG/i3QIeugZgwYx4Wrd4o1waPx0O33gNw69kbRMel4n7ER9SsW5/5bkyYPgfvvqUhLjFD7r2RlpWLPBnrkFgsRlxcHF6+fIn379+zVgA1wCoDLEoEafih/BFAFjbv2IVSjk7Mj7xipco4df6yWgqB1L8gPikTr76l4uKzt5i+dD08fCSsZ58/f1arb126dEHt2rW1NtZnz55JFvl872EOhwNH5zLYe/IKImNTGR+B87fDGJIdgUAHNjY2WusDANSrV6/Ql7Ouri6MjY2ZBbJs2bJaIT9p3bo1vL29teIo5eUl2dnLnhVLFzaFnbWKBcmpjCsmzJCEJlpa2zDe6AKBQI7cyCqfPMvQyBh3w99rvPi/+JyEvScvY+DwsXBRwiZpamau1OufzxfA3sER+vr6eP36dbHmSSwWo1+/fhCJRLC1U4w+kI535MiRJf5MpMjKyipUGZM67xFJQgCJJPwGi9ZsZpz9Gjdrhecff2LusnVwL+/JfBblypVD7Tp1UKVKVYa/RPo9LePqhvO3njC+EGdvhDIMkHp6+tgYfACfEjLkNhapmbnIzfu9Hff+LWCVARYlhlgsRkpmjsKCHvsjGbPmzIeBTHrSFq1a48HTcPWVgnz/gtjEDKzdvg9EhG/fvqnVr6VLl0JPT69YnPvKsHHjRnA4HHTvPRCBAyWx/9a2dnjxOVlOGYiIScWd8I+oVrMOiAj29vZaaV+Kpk1/EdZIlYBGjRph//79+PjxI7NYS3fga9as0Uq7UgfKkqaSBYD+/fvLnUu369yd2QEWFGUKgq6ePs7efMw4IzZrHaBy8Xr4MhbuHhIOhfZde6mlADx58xVBOw6gQ7dABYdHLpcLYxNTOZbMgtK2YzccOBMCopJFPQCSiCA7OzuVVhOBQIDhw4eX+DORIiMjQ2k7IpEu6shwfkgdPO3sS+HE1XuIikvFvlNXmKMyaWRE27Ztcf78eYXfYW5uLkJDQzFkyBAIhULY2tljx8FTiI5LxZa9x5mU5valHHH++n3EJ7FKwN8JVhlgoTVkZOcqXcyj331Gv4GDf9Ge8vkYNGQ4Xn+M00gpOH7mAojUDxWMjo4GESE4OFgr4/OtUQO1/BoiIiYFT958Yzjidx27gMjYVAWF4Om7BHhUqAg9PT2t0pJ6e3szi5Kbm5tKMhTp4v3q1SuttJuVlQUdHR2tKBfjxo2Ti3ywd3DEgTPXUN5TORWulL9fKtVr1cWICdMUrCLK5FbYG+w7dYVZTHcdPa9UAbgV9gbzlq9HgyYtFEij+AKBUiIpO/tSaNa6PaxtJJExQpEIy4K2ISouFR2790apUqXUZsMrDOvWrVOpDHA4HDRp0qTEbUgRFham0IaHV0U0l2EElZKKVfCpjJvP3sjN48iJM8Dj8eDo6Ijr16+r1ebbt2/RoEEDcLlctG7fhVEAq/rWxJPoD4w1ICUjBzmsEvC3gFUGWGgV2bmKfgRSufPoKfybNmdeKMYmJpi7cAniElLUUgZef4wDEanMEqYM/v7+8PLyKjF9rTT50Jqte/PDBlPQrlN3EBG69xnEKAORMfIKwcbdx0CkOhxRU2RlZYHP54PD4aB169aFWj0WLVoEIyMjrcY/V6lSRStZA4cOHcooA9KdpL6BIZat36qW3wCXy5VzMLQocG4tq0Ccu/UEUXGp6NJLEkXgUtYdYR8SEBmbgtMhDzF26p/wqVJdoV3ZZD+MRUJXD/UaNcXUOYtx9kYotuw9zpjKrW3tcOjcDeZoQV/fQG1n16KQlJTEROwoExMTE60pnFu3bpWru2bdBmjQpIVCm/7NW+PJm69yisC1R1EwM7dAlSpVNGbhy83NRd++fZnPoVP3Xvj4NQkJadlIzshBTi6rBPydYJUBFlpHXp58+GFBOXrqHDwreDEvldLOZbBjz36VpEWy4uLqisDAQLX78ujRI40iEJQhJSUFjk5O8KpYBeGfkhhlYOPuoyAimFtY4vnHRKXWgbsvPoLH42kte9m5c+dAJMmYVlgmNgCYPHkynJ2dtdKuFM2aNUNAQECJ66lZs6b8IpvvFMfhcGBlrRiWp0p4PB4mz1qInYfPKtyzsJCcXx86dx1Rcam4H/mJofStXK0Gw2CnoGQUuObuUQH9h47G9oOnEPb+B+MUN3n2IqZ8xaq+cjvkUyEPQES4evWqFmZdgqpVqxY6F2fPntVKO3XrKjrtFpTeg4YjIiZZ3roSm4K69RvD3t6+2PH7ubm5aNy4MYyNTfDqQyySMnKQnfv7JPv5ncEqAyz+FojFYqRlKT82SEjLxrfkDKwJ2qQ0M2JhysDMP+dBKBRq9LKZMWMGuFwu9u/fr/E4MjIy0KRJE3C5XBgaGWPHobOMMvDsfQLjOLZ1/6lf1gEZhSAyNhXlPb3h4uKilZ1bixYtIBAI1HJImzFjhtb9FRo0aIDOnTuXqI60tDS5rHBSkaWj5XA4CrHu0qRUstdWbgxGdFwq40goFZFIF65u5UBEWL/jAFZt3oW2HbspeOIrE1Mzc7QK6IyFqzfixtPXCscJYe9/IKBLT6Z8+669GCVBKqs2BYOItEpqM3jwL15+HR0hrKxtmfFIKcdLagV69OhRvlVEgOXrtymkNpb9rPybt8bcZetw4/FLRMelYv02iU9PSTPEfvr0CUZGRhg9ZmyJ6mGhGVhlgMXfikwl4Yey8lFFZsSwqNdKy798HwNDQ0ON2Nby8vLQq1cvcLlczJ07V+0jg9evX8PX1xcCgQCO+V7NfD4fMxeuYhSCzj0lpucO3XqrVAZ69h8CIsLatWuLO40AfvkANG/eXK3yO3fuBBEhMTGxRO3KwsbGBtOmTStRHQXN0PKmecnRQaVKlTB16lQcPHgQFy9exIkTJzB//nw0a9YMHA6HUQqatQqAd6Wq0Nc3YKi2iSQZ/hwcJYl/CnP0k36mVWvUxujJs3D4/E3FHa+M3Hj6Gj5VqjNWhImzFuDqw0j8tfMQho+bimatAuDh5QODfMWmKOuNJhg7dqxShklZJakkoZ9ZWVnw8PAAn8/HjoOnmcRSTIIykS5q+TVUcKiUWk/s7EuhevXqWhnrhAkTYGpqirS0NK3Ux6JosMoAi78dOXliJKarPjZISMtWOzNiQlo2Vq77C0SkNoELIDE/Tps2DVwuFz4+PtizZ4/KF/X79+8xZcoUiEQiZnFxdfdAgyYtmZdft94D8ex9AnYckpinjYxN8Ox9gpxC8PxjEk5cfYDWHbrl71ZFePbsWbHmMDY2FjY2NuByuWqHqYWHh4OIcOHChWK1WRDv37/XeN4LIj09HWXKlGE+Zz19+Z26n59foeRBeXl5mDdvHgzzI1RcXcsiMDAQs2bNwuzZs9GvXz94eHgwi2RRVoABQ0fj0as4hZ3/tUdROHTuBv4KPoR5y9dj9ORZaNGmA0PyxOFwilQyiEhliuriYMCAAUUyA4pEIty9e1fjuvPy8tCnTx9wOBx07dWfCaGUfk52Do44ee2+5IgkJhlHzt/EyAnTUbFKdbn2tcFDAQCvXr0q8XeNhWZglQEW/xPkicVIKcSPQCrqZEb8kZqF1u0CIBQKcfLkSY36cevWLYZn39DQEPXq18fQoUMxZswY9OrVC25ubgrJeWTFu9Kv7HvVa9bFjaevYZl/1BG08xAiY1NxKuQhuvUeCMP8aAPZHZyZmRlCQ0M16vOHDx/g7u4OHo8HOzs7tZ8Ti8Vwc3PTGhXyzJkzwePxSpT4aezYscq5BDgcrFy5stCjlLi4OCalbGBgIJ48eaKybHR0NIYNG8Z8ljpCEWr7NUL/oaMxZ+laNPCXOLLq6urBv3lrVKtZB84uZRlnQG3JpUuXij1XBVG5cmX4VK6KRWs2oUbt+kxqadmcFBwOB0KhEIcOHVK73oSEBHTs2FHlGHg8HuwdHFHBpzLq1GuEFm07oGtgfwwYOgaNmrWSY17UJHVyUbC1tcWUKVO0Vh+LwsEqAyz+ZxCLxUhXEX5YkLSoqMyIcQkpaNVGkj986NChSE5OLrL9+/fvw8PDAzo6Oli0fCWmzZqDFq3bwr28J5xd3eBdqSpatO2IytVqFurRLkn4I3n5OjiWRquAziAitGjbEf2HjgGXy2XM6deuXcPPnz8hFovx8eNHeHh4QCAQYN68eUWakHNzc7F161YYGBjAwNAQHA5HY6a5lStXQiAQlDhzY0JCAqysrKCvrw8vL69i7XjXrl2rck63bt1a6LOxsbEoW7YsbG1tcfnyZbXbvH//PpycnLSefKegWNvao5ynD1zcPWCQHx/P4/EwdepUjedJGX78+AGBQACvilXA5/PB4/Hg7e2NAQMGYPz48Rg2bBjq1q3LHLdxuVw0atSoUCtLWloaNm/eDEtLS/B4POjp6atlTVElurq6Wo1cadasGdq0aaO1+lgUDlYZYPE/R2Hhh7IizYxoavaL3U02M+L3lEwsWrYSenp6MDIywogRI3DhwgXGaSs3NxcRERHYvn076tevDyIJE+KtB48V2opLzMSr+FS8iEnG88/JuHAvHF0C+4PDUc5+J68cSBYagUAAHR0dLFy4UGVWwIyMDEyePBlcLhcWFhaYNGkSLly4gC9fviAzMxMJCQkICQnBvHnz4OAgn85WR0cHAwcO1Giu09LSULZs2RKnT+7VqxeMjY1x9epVWFtbw9nZGSEhIWo9m5ycjD/++EPp3Onp6RUZHZKTk4Pq1avD3t6+WDvP+Ph4uLq6gs/nS+iCzS1gZGyilplfVrg8HlzLeaJJ6w4YOGoSpi5YhT/GTkU9/xYKeQmEQhEMjYxhYWFRZIZIdSA9IjAyMsKCBQvw5csXpeXS09OxY8cOuLq6MgptuXLlMGjQIKxcuRJBQUH4888/0bp1a+aohcPhwNWtPMwt5Pn8+w4egeuPX+JMyEPsOX4Rf+08iEHDx8qlWRYKRShT1g3mFpYwNzcv8Thl0aFDB63yJ7AoHKwywOIfgTIaY1Xy9vMXDBs5hjGFFsyMGBb9BmMnTIKlTHKSgjucGrVqY/P2YLnjBsUIhyx8+J6ON1/SEB2fioiYFFx5FM04DxauEEiOAIpKoSpFVFQURo0aBRMT5WZpWVN65Wo1QCRxdOvZs6fGc33r1i3weDz07du3WArBggULQETYuXMnAAlBjJ+fH4gIHTp0QEhIiNJ6v3z5gsWLF8PBwQF6enowNTUFl8tleAWIJAmtEhISCm1/0SJJCF9xzsKliI6OLjROX1ZMzSzg6VOFYcATCHQwYdZiPHiTgCNXHmHUlLmoVK2mYl4CYxM4lXFVUAyWLl1a7H4DwObNm8HhcNC8eXPExcWp9UxGRgYmTZok9/3kcrlMlEZZ9/KwLyVxsLSwsmYItKTfvblL1yI6P1zw1rM3WLJ2M8p5esnVZ2pmLpcoSyQSaZVcy9/fH+3atdNafSwKB6sMsPjHIBaLkZpZ9LGBVEKfR6JNQHu5hUQ2M+L3lEw8fPYCW4P3YNmqtVi57i8cP3MBbz9/UbuN7ynZ+PQjHW+/puPNl3S8+pKGZ+++y70slYlQKCyWc2BeXh7u378PS0tLcDgcZjcnmwWuYdOWsMnnpff09CzWXAcHB4PL5aJVq1ZqLygpKSkYPFiSUa5g6uKVK1eCiBjrhb6+PmrXro2AgAC0bNkSZcqUYealV69eePPmDV6/fi0XUsjj8Yrk1E9OToaBgQFGjx5drHHLYtGiRYrEQjo6zDVPn8oYM30+hoyfzoQ5WlrbYtrCNeg1aCScypRV+NwtrGxgaW1b6LGSQCAodsbIe/fugcvlomfPnsVS5P766y+5vnhVqopL956jS8+++Qu4LnRkFnSBQAf1GjVFnXqNUNqlrALzY1GiLXItsVgMKysrzJgxQyv1sSgarDLA4h9HZnae2ot1QlrJMyMWKanZiE3MxPtvEoXg9Zd0BB8+w7Tn4OikQE1bUlKhGzduSHwCugeiUtUacnUbGBph467DzAJa3FDBU6dOwdLSEmZmZpg3bx7i4+OVlktKSsK6devg5OQEPT09/PXXX8y93NxcxlIwbtw4iMVi3Lx5E0uWLEG3bt3QrFkztG7dGmPGjMHu3bsV8kgEBQXJje3mzZuF9nn9+vXg8Xj49OlTscZccFx6enowNjFTiGJQJQUXeQ6XCyNjE7VSR3v4VMG0pRvhWMYNNja2iIyM1Ki/6enpsLCwgI+PT4kYNEeMGAEul4tafg0wYvw0JjTy7xDZ9N4lwYsXL0BEGjsIsyg+WGWAxb8CObliJKapd2wgdTIscWbEonwWkjLxIV8hePMlHS3a/uJmX7BqA4aMmQwej4fSpUtrxTzaqVMnOLuUxZM33xQS72zddwI2dvbgcDglyg3w7ds3DBo0CLq6uuByufDw8EDv3r0xcuRIDBgwANWrV4dQKASPx0OHDh3kwhgfPHiA2rVrg4gwffr0YjmL5eTkwMbGhjFHp6amFlq+YsWKaNy4scbtqEJgYCDKVfDGw7c/ceXJO+w+FYLFQTthoQHrYVHi7umDP1ftwP6r4Qi+FIFZ6w5DR0cIfX19bNmyRa15e//+PRPZUlyrghSpqamwt1ee8ZCx0vD5cCztDCdnFznyJ02Ey+VqLavlyJEjYWlpqVWeBhaFg1UGWPxrkCcunMZYmSjLjNiydRuNMyOqPjbIwsfv6Xj3LR0v3v+AkbExY169cj8cAoEAy5Yt08r4r1+/DiLC7mMXERGTjAo+lWSsA4YI6NQDHA4H9vb2SElJKVFb+/btY+qWDU9zdHRE27ZtsXv3bly7dg2HDx/G1KlT4ePjAyJJOmR1k8+owrBhkoyPpqamhZbLy8uDUCjUqql4/fr1EAgEuBUZhz1nbmDwmCkoW85TYWETikTgKyH4kV341Fkg9Q2NIRTpgehXDgZvbx9s3rwZnz9/lls4MzIycPv2bfTv3x86Ojrg8/lo3bq1Vsa9fPlycLncEkULKBMOh4NGjRph8+bNOHToEIgIBw8eLFFfX79+DV1d3RKTW7HQDKwywOJfBbFYjPRCaIxVibYyIyq3QmQj5mcG3n1LR/ChX8cFUoeqFy9eaGXsubm50NXVQ8OmLTFz4Qp06NpL4cUrXYj++OOPYrcjDRNUtqApo/zl8/kwNTXFqVOnShSRkJWVhRkzJBntdHV1i/Q+P3tWQui0e/fuYrdZEJcvXwYRwdzKRv1Fj8OBrUMptO/aG0G7jmHf2Zvwa9SMua+rr4/ajVqgZZe+qFG/KZzdPaFvaFzoAir9v7m5Odzd3eHs7Cz33ZXeP3bsmFbG/f37dxARPDw8VPI8qOqvnp6+wv3atWtj7dq1cv4nYrEY7du3h4WFBWJiYorVz+zsbNStWxfOzs4lVnhZaAZWGWDxr0RWETTGqqSkmREL8yOIz/cjaCGTylUkEpVogSwIX19ftRep4lgkEhMT4evrW+gOsVyBNMJ8Ph+DBw8u0bh+/vyJWrVqgc/n488//8TGjRvB4XAK5YcYO3YsiKhYOSVUQWp9KUpEurpo0KQVlm3YjVsvPiP03U+EPHuPngOGMxYDHo+Hdt37Y/flZzj+8AOOP/yAg3ffYdvVKGy9GoVeY/5k6vOt0xBVavqhlLMLDI1M5BxECxN1nT3VQdmyZTFs2DA0b94cPB4P+gYGSpUAYxNT2No7KHxHqlSpgqVLl+LDhw8q24iPj4e9vT08PDwQGxurUf+ysrLQsWNHCAQC3Lhxo6TDZaEhWGWAxb8WmoQfFpQjJ8/Cw7MC8yLTJDNiYfI1OQuR77/BKD/szMrKSqtjbtu2rcqFQfpyrlatGmrVqgUiwoABA5CUlKRW3Y8ePYKbm5vGpmKBQIBx48YVe0yZmZmoVasWTE1Nce/ePQDAs2fPQESFHjn4+/uDx+Nh9erVxW67IA4cOKB0jLq6eqhUrSYCugZKFCCBAIcu3kXou5948Po7ps5fCdP8jIdEhOp1GuCvw1dx4GYU1h68jJmrd6Lf+Llo3nUgqjdoAXtnN43mWJkYGBhobdwA0KZNG7Ro0QI/f/6EtbW1nIXAysYW5St4KThGenh4YO7cuRpFCURGRsLOzg42NjY4ceKEWs88f/4cVapUgY6ODo4fP17cIbIoAVhlgMW/GpqGH8rKt+QMrA7aqHFmxKL9CLKx+/ApEEnyyGsTTZs2hZm5Bcp5esHCylruxdykSRO58MVNmzbBwMAA9vb2WLx4sVJWQLFYjIcPH6JPnz7FPjPm8/kakx3JYurUqRAIBLh//z5zLScnB7a2thgyZIjK5zw9PWFjY6NRyuqiMHHiRDkzvKdPZRy79gih734yUq+xxLJUqVpNrNx6AE5lXJnyhsYm8KxUHWU9K8LYzEKt+RPp6sG5bDnUrOePgO790H3ACJR2+aUsKDPbu3lUgKWldhXNjh07MiQ+R44cARHB3MJKgRehTJkymDZtWokcF2NiYtCypSSXh5+fH/bt26fw/UxJScGlS5fQpUsX8Pl8lC9fXu47wuJ/C1YZYPFbIEPD8ENZ+fglAeMnT1U7M6K6xwbSJC3aTEZTytER/YeORnR+QpgmLduCx+Nh06ZNSr203717h8DAQAjz48HLli2Ldu3aoUuXLmjYsCGMjIyYBZ1IeQY/c3PFLHQFpXLlygpti8VivH//Hs+ePUNUVJRSz+8XL16Ax+Nh7ty5CvdmzpwJAwMDhfBDKTw8PFCxYkVYW1trhcVPmquBSJICeP6qTbge9gH7z93Cys17MWHWYvQcMBy16jUGkeoz9IIiFOnCoYw7KtZqiIbtusPKXhLhYmljh30XH+B65BfciPqKay/iMGzyn0xcv6yJXiRDIzxx5gJMm7cMAoFAK+OWws/Pj0k/nZubK8dwaW9vj7Fjx+LBgwdaoxQWi8U4cuQI6tWrJ9dOhQoV4OLiwihBbm5uWLVqFTIyMrTSLovigVUGWPw2UJfGWJUoy4w4ZvxEpZkR1ZGQ2w9BRGqbQotCTEwMiAgrN+xAdFwqJs9aCA6Ho1bSmW/fvmHnzp3o2bMnypUrBxsbG5iamqplCVDHM57P5+PHjx/IysrC/v370bRpUwX2RIFAgMqVK2P+/PkMh8Eff/wBW1tbpYtafHw8TE1NVSZSatiwIRo1agQiwt69e0s2uQCuXr0qGS+PB6cyrmonJZLOIZfHQ3kPDzRr1gxNmjRBmTIuzPUqfk0wa9MxNOvSH0QEXT097Dh5HTeivuJG1FfsOnsbFSpVU6jb2MQU+vk7cxNTM2zdfwoRMSnYECzxzFeX0bIo5OXlwdDQEAsXLmSuTZo0CYaGhrhx44ZWmQOV4e3bt9i/fz+mTp2KESNGYPz48diyZQuePn2q1XwGLIoPVhlg8VshL0/z8MOCUjAzoqWllUJmRHXkR2oWnEqX1loylXnz5kGkq4sHkZ9w8c4zCEUijBo1Sq1nr169yuzAhEIhqlWrhi5duqBNmzawt7dXSsXL5XLVUgR4PD44HA4GDRqEUqVKgYhQt25dzJs3D2fOnMG9e/cQEhKC9evXo0ePHhCJRNDR0cGMGTOgr6+PmTNnquz37t27QURYt26dwr3x48fD0dERzZs3R6lSpdT2jVCGrKwsVKhQQalyZGxqBndPH5Sr4AORrt6v+ckvW6NGDezbtw9paWkK9f748QPr1q1DWTc3pjwR4c9VW3Aj6iuuhsdi8LjpEAjk51+go4Nafg2Z/pT39Maxi7cxff4yuLqVZz6fefPmFXvMsrhx4waI5H00Dh+WEFlp00mRxe8LVhlg8dtBLBYjrRjhhwUX8qIyI6ojy1etA5fLLRYVsSwSExNha2uLjt17IzouFd16D4CNjY3SBUgW6enpGDJkCIgIvr6+2L9/PzIzM5GRkYGJEyeCx+PB0NAQ/fv3x9atW3Hv3j08efIEV65cwbJly9CwYUO53a9yy8Gve/7+/kWeJf/48QPTpk0Dj8cDj8fDqVOnVJYVi8UYPXo0iAjz5s2Ti8yQhhYeP34cBgYG6NatW7F2sNI2uFyuHHeArq4eeg0aiZVbD6BchYrMdVv7UnBwdIahoSG2bdum1s41KysLs2bNApfLhaOzC64+j8GOEyFwLxCZQURo1LQVmrT45SjqXbkaKvhUVurZb2tri5ycHI3HXBBdunSBm5ub3Pw9fvwYRISHDx+WuH4Wvz9YZYDFb4vMYoYfykpRmRGLkriEFLi5lysxZWzfvn1haGiEkEdRePw6Hvr6BoXuqAFJRsL69etDV1cX69atY170Hz9+RIUKFaCjo4N58+YVmd755cuXaNGiRaHWASnzoSYm3UePHsHKygpubm6F+lWIxWLMmDEDHA4HNWrUwPXr1yEWi5Gbm4vSpUuje/fuOHDgADgcDvr27asRK11ubi4mTpzIjGHin0uxOCgYrkqIhvT0DTB43AxUqFQN5hYWxVLwTp48CYFAAA/vSnKWAiJCOQ8vrNywEx4VfOTmVdlcy/5//vz5GvdDFtJwSllaaQB4+vQpiAgPHjwoUf0s/htglQEWvzVy8sRILGb4oawUlRmxMLly8y74fD66du1arF3ckiVLJOboOvUQGZOMHYdOg4gQHh6u8hkpwYu+vj5u3brFXI+Li0OZMmXg5OSkkTe4WCzGxo0bVR4bbNmyReNxAcCrV69gaWmJ1q1bF6lI3Lp1Cx4eHiCShLSNHDkSgYGSUL9Lly5h165dEAgE8PT0xJ07d4psOywsDDVq1ACHw0FZNzdY29jhdsRn3I2MxcARExQYBvUNDFGtdn1wuVy5OdUUGzZskKvXxNQMM+cvx4jx0xSOCwpXwLjQ09cHn89nQjI1xdevX+Hs7Iw6deooWFVOnjwJIiqUN4DF/x+wygCL3x55YjFSSuhHIJWiMiOqku279oHL5aJx48ZqJ9VJSUlhTPxSadG2AwaNGAddXd1CyYykZ+2HDx9mronFYjRt2hS2trZ4//59seZy165dBfwFeOjWrVux6pLi2LFjICLs2bOnyLJisRiXL19Gz549UTb/CIfL5cLa2hofPnzAs2fPULlyZeYsf/Xq1bh9+zZiY2MRHx+PBw8eICgoiDn+cHNzw6BBg0BEWL/zEBas3gQrGztmfFV8a2P0lD/h4laOaasknArSMTRs2BB8Ph+Nm7VCs9YBcuGMmor0qEdTBSUmJgbe3t6wtrbGmzdvFO7PnDkTFhYWrAMfCwCsMsDiPwKxWIz07JL5EcjK2cshqFz1l/e3OpkRt+7aD4FAwDjNff78GV++fMHGjRsxcOBA1KlTB1WqVEGdOnXg5+cHU1NTZifu7FKW2any+Xw4OzurHGtWVhZsbGyYMDEpduzYASLC2bNnSzSXgYGBjA+BSCTC9+/fS1QfALRq1QpeXl4aLzxpaWkICwtD6dKl4eTkhKdPnyInJwfHjx9HkyZNlDpG8vl81K1bF7t27cKUKVNARHAsXQYe3r/8AuxKOWL5hmA8/ZCI0PeJuP/6B5q2kbDfqQp11AS3b98u9uIvLxxGIeByuZg6dWqRfiR5eXkIDg6Gqakp7OzslNJli8VieHh4oFOnTiUeK4v/BlhlgMV/CiUNP5SV7ymZ2Lw9GA6lHJmXc1GZEdds3M6c9XI4HIbox9PTEz169MCgQYPQpUsXlClTBhwOJz9BkGRBa+Df4pdyUIgyIGXRkz1GEIvFKFeuHNq3b1/iOUxISIBIJJLkdxg0qMT1AcDFixdBRLh9+3axnv/48SM8PT3B4/Ewc+ZM/PjxA4BEMXr8+DFOnTqFkydP4sGDB0hPT8ft27dRubJypzxLaxs0aNISgYNHYMrc5Vi38wiOXwuFu6dXia0gUshyGmgi1rZ2aNysNabNW47Gzdso+BFwOBwYGxtj1KhROHXqFD5//oy0tDR8//4dISEhmD9/PsqUKQMiQvfu3VUqcpcuXQIR4cqVK1oZL4vfH6wywOI/h5LQGCuTmO9JmPnnPLUyI35LyUIFn0rg8XiwsrLCsmXLmIWrID5+/IgZM2bA0NBQwYxcMOeBWCxmogQ6duyIGjVqyNUldRILCQnRyhx27doVRIQLFy5opb68vDwYGxuXyBluxYoVzIKoo6ODLl26YNWqVbh48SKuX7+OQ4cOYcqUKahQoQIzh5osxBwOB0FBQVoZLwAMHjy4yOMBXV09tArogm0HTuNBVCwiYlIR+uoratdvrFDWzqEUYyWwsFDOfqinp4devXrh7t27KvuVnp4ONzc31KhRgz0iYMGAVQZY/CdREhpjVaJOZsRZc+aDiBAYGIifP3+q1ddPnz6hcePGzO6vay8Jcc2tW7ewbNkyNGnSBObm5swLX0dHR+Fce86cOTA1NdXay11qXtfGEYEUDRo0ULBcvHnzBmvWrEHv3r1Rt25d1KxZEy1btsT06dNx7tw5RiFKS0tDqVKl5Hb6PB5PYedfkrN5ItJqgpx169b9IrgS6cLQ6FcmQyNjE0ydsxRP3yUgIiYVETGpuPIgCgOHj2fYCIkkRE71GvrD2uYXpbahoSGqVKmC58+f48SJE9i9ezcOHTqE58+fF+nAmpeXhz59+kAoFCIyMlJrY2Xx+4NVBlj8p5FZAhpjVaIqM+KGLZIz+5kzZ2q8KOfk5KBbt26SXa9QyBwh6OjooGXLlpg9ezZ27tyJrVu3goiwbds2uefbtWuHxo0ba23eFixYAKFQqLX6AIkvQu3atQEAoaGhaN68ObPLr1q1Knr06IE+ffqgefPmsLaW5GVwdHTEypUrMXz4cLUIkkoqoaGhWhvvtm3bQESo27AJU79QKMKAYWNxPzIGETGpePE5BcFHL6BJy3YKXA916jdEkxatmL8dHR1x6tQpPH78GEZGRvD19cXnz5/V7k9qaioCAwPB4XC0mhaaxX8DfGLB4j8MoYBLPC6H0rLzSAxopc5y5T3owNETdO3KZZoxZSJFvAinGVMmkkAgoE6dOtHs2bOJw+FoVCefz6edO3dSVFQUPX/+nHg8Hk2bNo2GDh1KlpaWTLnU1FTq378/6erqyj3/9etXKlu2rFbGR0Skr69P0NJ8SSEWiwkAzZo1i+bPn0/lypWjLVu2UNeuXUlPT0+uLAAKDQ2l9evX07hx44jD4ZCRsTHx+AL68e1rkW05ODpTqdJlKCUlicKfPCJ9AyOq4deQOBwucXlc4vF4xOXyiMvjEYfDodTkJLp67gQlJiZqbbxJSUnE5XLp5tWLxOFwqHX7rjRy0kyysy9FWZmZdPTALtq99S+KehGm8GwD/2b06P4dSklOJh6PR2PGjKHZs2eTvr4+ERFdvXqVWrduTZ6enrR48WLq3bs3iUQipf0Qi8V07tw5GjVqFMXExNDu3bupe/fuWhsni/8I/mFlhAWL/wnyxCWnMVYm0syIurp6MDY2LnHSovDwcHC5XEybNk3p/ZycHPB4PKxfv17ueu3atdGrV68StS0LKVVtTEyM1uqsXr06dHR0wOVyMWvWLLWT8Ny5cwdlypSBqZk5DPITLxUlFx5E4dG7n9hy6AKICDb2pXDn1Q/cefUD917/wP03CXjwJgF3or7grz0nEdC1N3g8HpYvX6618UqjMmrUqY/DF27LHQWYmv069hGJdFGjjh/zt2yWzWrVquHJkydK609ISEDv3r1BRDAzM8OgQYOwefNmhISE4MaNG9i3bx/GjRsHFxdJDoW6detqlIqYxf8vsMoAi/83EIvFSC8hjbEy+fglAYaGRpg6dapW+tmxY0eUL19e5VGDt7c3BgwYIHetW7du8PX11Ur7AHD37l0QkdZyy2dnZzOZFQ8ePKjx89+/f4eXlxdjSjdTkmlR9qx93a6juP8mAQcu3mXO6B+/T0Tou5/YefQSOvboB0dnVzmqZR6Ph+bNm2tlvLm5ubC1tUW9Rs0Q/ikZu45dRNNWAXJHAXb2pTBp5jys/Gsbc13qY2BoaIi1a9cWyjUhxcuXLzF27Fh4eHgoHKU4OTkhMDAQt2/fZp0FWRQKVhlg8f8OWVqgMZaVXfslGeaUEbsUB+fOnQMRISIiQun9QYMGwdnZWY5Rbvjw4RCJRFpLeXv48GHw+XwFLoPi4tAhyRyNHj262HXExMTA0NAQqtILGxmbgMeTOBCOnjoHj98n4sT1J8wia+9YmrmvSjgcDt69e1fi8Z46dQpEhD9GTUJ5GfphIkL1WnURtH0vXsUnYffR0wzrpVQ6dOigkS+ALFJTUxEdHY3IyEitOn+y+O+DVQZY/L+ENsMPx02aAisrK63tvH7+/Akiwq5du5Tel+7aZcmF2rSRxKQfOHBAK31o164dOBwOeDxeiRfHvLw8+Pr6wsjISK2dbmGQEispVQZMTKFvIAn/tLFzgLmldaGLvrLrPB6vxApQVlYWvLy8oJNvCSEiCEUidO7ZB2dC7uHd9zS8+56GLbsPylkKHBwccPLkyRK1zYJFccEqAyz+30Jb4YcBHTuhQYMGWu2bvb09ZsyYobLf1atXh7e3N2MJsLOzg6OjI3x9fUucm/7Vq1eMuZnH46F+/folUnT++usvEBFmzZpVon4BEvO7nZ19sSIFjExMVEYkmJiay/29f//+Yvdx8uTJjLJha18KE6bPQWj0B0YJePM1BSPHTZRrb+TIkUhJSSnx/LBgUVxwCzoUsmDx/wUcDof0hTzSFfBKVE9OTg4JhUIt9UoCoVBI2dnZSu9xOBzauHEjRURE0IwZMyg+Pp5iY2OpX79+dP/+fQoKCip2u2KxmPr160cmJibE4/EoLy+PQkJCaObMmcWq786dOzR69GjS0dGh6dOnF7tfUvB4PBo4cADxeEV/Zh5eFal2vcZMZEdyYiKJxWLmvrWtHdVr3IwMjIwp8ecP4nA41KPfH9S0VQAFBgbSmTNnNO7fihUraNGiRWRfyonWbt1N1x89p6Gjx5GZuQUREb2JjqB2jWvTmuVLiIjIwMCAbt++TatXryYDAwON22PBQmv4p7URFiz+DcjOzUNiMS0D3XoGomrVqlrri1gshrGxMRYsWFBouaVLl4KIMGzYMBBJ8tIPGzYMIpGoWEyEYrEY48aNAxEx/8rK8OHDkZ6ernZ9hw8fhkgkApfLRZMmTTTujypcuHBBuYmfz4e7h1e+RYOv9ChAKBKhXeceWLByI6rWqM1cd/fwwoEz1xERk4qn7xLQuHlrcLlcjB8/Xq0xf/nyBe3bSxJcderRG2++pjCWgHff0xD1+TvGjJsgdyzg6OiIhIQErc0LCxYlAasMsGCRj+KGH85fvAxCoRDZ2dla6cebN28UfAKU4cSJEzAwMGAWl4cPHyIjIwONGjWCrq4u9uzZo7Z5PyUlBQMGDAARYc2aNdi0aZPCQsrlcuHq6opjx44VynQXFhaGjh07MmfzfD4fEydO1GgOCsPnz5/l+lXGVZIDQFdPDwIliYuk0u+PUbgb/hHDx01lyunq6mH8jPkI+5DIMAFGxKTi+cckjJs+DwKBABYWFpgxYwaePn0q9xmnpaXh9u3bGDp0KPT19WFqZoa1m3fKKQHvvqfh4LGTcHZ2luuLm5sb6+DH4l8FVhlgwUIGYrEYaRqGH14MuQUiwuXLl7XSh6CgIHC53EI5C+bOnQsiQsuWLRnO/iNHjgCQcM93794dRIQ2bdrgwYMHKuvJysrC3r174ezsDF1dXWzduhUAMG3aNKXUvtKdrY2NDXr37o3Vq1dj165d2Lx5M0aPHs2kF5bdAQsEApX+D8XB9+/f5fpkaKice8DOvhRGT54Fr4pVJBaUsVMZxYFIwgx46d4LOSVAKkcv3kUFn8oK4xYIBLCzs4ONjQ0TlmhpZY0R4ybhYeQ7OSXg+av36NylC1OHdD5dXV0RGxurtflgwUIbYJUBFiyUQJPwwx+pWShX3kMrGQPFYjG8vLwQEBCgssyqVatARJgzZw6z87exscHkyZPlyh0+fBhOTk4gInh7e2Pw4MHMrn/RokXo3LkzrKysQETw9/fHq1evmGf9/f1VetzLLm6yZQqGyMleHzZsWInnRoro6GiVfdLV02P+f/CsxOxfu14juTLmllZYHrQDLz6nKCgBVx9Go12nHiCZccnlQ8g/iujUow/mLVuDk5dv4WVcopwS8PFHGtasD4KxsTHzvKWlhBehVKlSeP/+vdbmggULbYFVBliwUIHcPDES1Qw/XLV+A4gI165dK1GbmzdvBpHq7IPPnz+HQCDAmDFj5K737NkTLi4uCpEEubm5OHXqFAIDA+Hp6cks2IaGhqhbty4mTJigkO/+y5cvJU74U1CqV69eonmRxf79+wvUL1mszS0sEfoyjrk+b8VfWLpum1yIX6cefXH3xScFJeBBVCwGjRgPoVB5pkMbW3uMmTIbd8Pf4c3XVIWjgHff0/AhIR13Hz1BrVq1mOcqVqwILy+JH4O1tTWio6O1Ng8sWGgTrDLAgkUhEIvFSMksWiH4npKJmrXrwNnZGd++fStWW9HR0TA0NES/fv1UlqlTpw48PDyQmZkpd/327dsgIrXi1IvyI5g9e7bWkwLx+XytnZH37dtXTllZuEqiiDmWLoOouFRm8bdzcJTrQ7tOPRSUgGfvf2L6/OUwNVeeEriKby2s3LQLLz7/VKkEvPueho9ff2LS5MlMvwwMDLBs2TI0aNAARARTU1OEhYVpZfwsWPwdYEMLWbAoBBwOh/R1eKQrKPynwuVyaf3GLZSalkb+/v705csXjdqJjIykBg0akIODA61YsUJpmdDQULp16xbNnz9fLpQRAH348IGEQiENGTKEUlJSihyTKkRHR9OCBQvkQvC0AbFYTNu2bStxPT9//qS9e/dSbm4uEUnG4lDKiYiIuDwe5eTkEJ8vICKi2M8fSUcopCrVaxERkaGRMVMPALp87iS1qleZ5k0bRz9/fJdrp3b9RnTk4m3ae+ICtQkIID2RDnG5ivOmK+BR+P3rVL9GFVq8aBHl5uZSu3bt6NmzZxQSEkLXrl0jAwMDOn/+PHl5eZV4/CxY/G34p7URFix+F2TnFu1HcOt+KKytbWBpaYmDBw8WuQvPzc3FmjVrIBQKIRAI8PjxY5VlR4wYAXt7ezlP/uzsbAQGBoKI0KJFC+jp6aFDhw7FYvr7+fMnPD09FVLpqhIdHaFa5aRibGyMuLg4jfsli8GDB8tZLYxNTLD76Pl8S0ApuHtUkPEf0MfZG08wZsqfEstA556IiEnF3hNXmBDEgmJuaYUDZ0PwMj4Fb7+ptgR8+pmOtx9j0K1bN+ZZBwcHHDt2DLm5ueiS7zhY3DBPFiz+12CVARYsNIA6NMZRbz+hVdt2ICJ4enpi1apVCA0NZdgCpSFpc+fOhaPjL1M2l8uFn58fMjIylLZdvXp1ucyEeXl56Ny5MwQCAZOf/tixY+DxeAgICMDPnz/VHtfbt2/lEgGpElMz5eZ0dYTH46FZs2aFhiUWhtOnTyvUWc7DCxt3HVY4kiAimFlYIiImFTMXrAQRoUad+vCqVFVl//xbtMGTt/GFKgHvf6QhITUTGzduhImJCfO5jRo1CsnJycjLy0P//v1BJHGcLCo8lAWLfwtYZYAFCw0hFouRVgSN8Y/ULBw/cwGt2rZTCLNjdq66uujSozc2Bh9mdrtcLhcNGzZU6ncgEomwYsUK5u81a9aAiHD06FG5cidOnICRkRHs7Oywd+/eQvkPkpKSsGzZMohEIpVOg9p0JuRwOOjatavGCZXOnz8PPT09hQiHStVqwMTUjPm7bcdu6NZ7ADPXETGpGDttrkI/uFwuTEzMmD6Nn/anAlFQQfmWmoVnYc9Ru/YvsqLKlSvj4cOHzPdi1KhRTP2HDx/WaIwsWPyTYJUBFiyKicycPLUiDT59/YnzV29gTdAmLF25Bus3bsG1W/cR/zMV31Oy8O5bGsZN/7Vg8Xg8WFpaYteuXcxCnpubCyLCtm3bAADv37+Hnp6eypC9jx8/omXLliAi2NraYtCgQdi4cSPOnDmDU6dOYeXKlejevTv09fXB4XDA5XIRGBiIPXv2IDw8HB8/fkRERAT279+PoUOHwsDAQGmooYmZeZEKgLmllYJC4OHhgdDQ0CLnOC0tDWPHjgWHw4Fvbb9C23FwLI2ouFQsXLWRueZe3lOujI5QiCat2sHMQhLqZ2Rsgu37jxWqBMQlZSAxORVTp05lFCN9fX2sXLlSzsoxffp0pp0dO3Zo4RvGgsX/DqwywIJFCZCTq374oSqJTcxEdGwy3PIXLi6XC2tra2YhHzFiBHbu3Akej4f169cDAMaPHw9TU9Mik9uEhYVh+PDh8PLykjtrFwqF8PX1xcyZM1G/fn14eXkV6t+QmpqK2bNng8fjqe1TUNSRARGhUaNG2LNnD16/fs20n5SUhGvXrmH8+PEwMjICl8uFd6WqmDhzgdIdfou2ErbD8hW8Efb+B4aMmay0TWMTE8xcuJKxzriVK49rD8JU+wUkpCM1KwcXL16Ei4sLU0+bNm3w8eNHuflZvHgxc3/dunUl/FaxYPG/B6sMsGBRQuSJxUgptLU9fQAAMDlJREFUBo3xryOFbLz/no7LDyLB4/0yyY8cORJDhgyBq6srY/YeOnQosrOzYWZmhnHjxmnUz/T0dHz+/BmxsbFyRwfnzp0DEeH+/fty5V+/fo3p06ejYcOGMDc3B4/Hg1AohEgkKpKQSFOlQDo+oQwngOy9BSs3oJyHt8LzazbvwqbdR0FEsLSygZGxibwlQEeILoGSYwOh6BeHQPM2AQh//0WlX8DP9GzEx8czTI5EBHt7exw7dkxhXtevX8+UWbhwYbG+QyxY/NNgQwtZsCghuPnZD0X84v2cOBwiXR0uOZZyoEmzFjLX16xZQ8bGxhQREUE/f/6k5s2b082bNyk8PJwSEhIoICBAo3Z0dXXJ3t6ebG1tSSAQMNf9/f1JX1+fbty4QUREnz59ooCAAHJ1daX169eTsbExjRo1itauXUuLFy+m3r17U7ly5YiIiM/nF9qm9D6XyyUnJyeqUKECOTo6KoQ3cjgcatmuE2VlZZF9fqhgXl4ecz/0/h2KighTqN/Y1Iy2BK0kIqJvX+MpOSlR7v6A4WOpQ5eeRESUlZlJHA6HJkyfTeu37iJ9JVkC9YU8sjUS0uE9O6l8+fK0d+9e4nA4NHLkSIqIiKB27drJld+1axcNGzaMiIimTp1KkydPLnQ+WLD41+Kf1kZYsPgvQRMaYwXfgh8ZCP+UBE/vSnLn6z4+Prh8+TJOnDgBIsL06dPB5XKRmpqqtX7Xrl0b3bp1w8GDB2FkZAR7e3ts27at0Ix9Dx8+RNu2bZl+UoEdP4fDQUBAAC5cuKDQ1+TkZJw6dQotWrQAh8OBvr4B+v4xEkQSJ0BrG7tiWRq4XB66Bg5gaInr1GsECxmfhc27Dyi1BsQmZiAzJxcvXrxAnTp1mPKVKlVSmdvhyJEjzNHLyJEj1U4KxYLFvxGsMsCChZahTvihchbDbLyKS8G1R9Hg839FHRgYGoKI4OzsDBMTE7i7u8PMzEyrfe7cuTM8PDwYb39NwhIPHDjApCqm/HN8d3d3xsu+KNy4cQPOzs4Q5Zvxh42bwvhPSMXWzqFIRcDYxBTnbj1BZGwq7Es5KVVSHkW9l2cOTEhHSmYO0tPTMX36dMafQE9PD8uXL1cZBnnu3DmmbN++fRVooFmw+N3AHhOwYKFl8LgcMhTxSIen2c+LyyXS1xWQpY0tTZu7jLmempJCsxatIh1dfUpJSaHo6Gg5E7o28P37d4qMjKQBAwbQnj17yMTERO1nO3fuTFeuXCE+n09cLpcaNmxIjx8/pqpVq6r1fN26denJkydUqVIl4vF49CryBb2KjmTuczgccnByVvl86TKuRETkUrYcObuUpeycbMrKzCAiIgDUrHU70tPXJyKilOTk/EqJjHUFZG8ions3Q8jb25vmzZtHOTk51Lp1a4qIiKCxY8cqPQa5ceMGBQQEUE5ODnXu3Jk2b95MXC77KmXxm+Of1kZYsPgvIyNbvfBDRvKdCcM/J8O7UjVmR2tiYoYbT15BT9+AuVbcHAgFkZmZCX19fVSsWLFQToLCkJWVhVKlSsHDwwNpaWnFqiMxMRFOTk5q50XQ1zfAqk3BWLUpGESEqr61cOPpa1SqVoMpw+cL8PZbKqxtbEFEOHXlFr4mZyInNw9fv35Fz549mbJ2dnY4cuRIoeb+Bw8ewDDfUtOyZUuN+RJYsPi3glVnWbD4GyEScMlQyCMuqc4HIId8Z0Iuh0OrN+9hdpyJiQkUtHIx9ew3mCn64MEDrfQxODiY0tLSaMeOHXKOhZogKCiI4uLiaM+ePaSnp1esOoyNjSk4OFhpXgSOkp33iAnTqHnr9gSAiIjS09OpY7O69OThPdLJz92Qm5tDWZmZTF4CQV4GmesLaOeO7VSuXDnavXs3cTgcGjFiBEVGRlL79u1V5m4IDw+nZs2aUUpKCjVo0IAOHTpEOjo6xRorCxb/NrDKAAsWfzP4PC4Z6vKIryTRjTIIeFwy1OWTlY0tDR41ibm+P3gLVarqK6mTz6fdu3drpX9LliyhRo0akY+PT7GeF4vFtH79eurUqRNVrFixRH3x8/Ojpk2bEo/Hk7sOJQpC+Qrecvciw5/R1/g4cnErRxNnLWDKxcV+JlMTiTLwMiqS6tevTwMGDKCEhASqWLEi3bt3j9asWUNGRkYq+/Xq1Stq3LgxJSQkkK+vL504cYJ0dXVLNFYWLP5NYJUBFiz+B+ByOGQg5JFQzfBDXQGPeFyi4eOmkq6ePnN9yugh5OBUmnJzc+nQoUP04cOHEvXr27dv9Pr1awoMDCx2HdeuXaPXr1/T4MGDiy6sApmZmfTw4UM6ffo0Va9eXaVPhI7Or2yNpRydKTs7mw7u2UlEEv8A/xZtaP+pq1SxcnWmXFZCPJkYSxb6MWPG0M2bN0lPT4+WLVtGDx8+pOrVq1Nh+PjxIzVq1Ii+fPlCPj4+dO7cOTI0NCz2WFmw+Ffinz6nYMHi/xvUDT+MTcxE+OdkjJw4U+6svJRT6fzzcD4aNmxYopA2aVKdyMjI4o0lKwsuLi4QCAQan59nZWVh79698PPzU5r/gMvlgsvlykVW6BsYMv+//vglKleryfzt6OyCiJgURMSk4O7zd8z1kSNHwsDgl69Fy5Yt8f79e7X6GBcXx5A+ubu748uXL8WZJhYs/vVgLQMsWPyPocPnkqGITzwVZ9NSiPhcEvI51K33QDmz+acP74mIKDc3l65evUrTpk1jzs01wfnz52nHjh1EROTq6qrx80RECxYsoLdv35KHh4dG5+e3b9+mChUqUPfu3YnP59Pq1avp/v37FBcXRzExMXTz5k1atmwZ+fj4UG5uDjN+qT+BjlBInVrUo8cP75JIJDHXO5UuQxwOhwR8DllZWTH+FmvWrKHU1FQiIuratSudOnWKnJyciuzjjx8/yN/fn16/fk1OTk50+fJlsrKy0mh+WLD4XcAqAyxY/AOQhh8KeIUoBBwiYz0BGRobU9NW7VUWW7hwIQ0dOpTS09PVahsAbdmyhdq2bUsVKlQgIipWaFxUVBTNnz+fKlSoQMbGxmo/t3LlSqpbty6Zm5tTWFgYXblyhYYOHUrVq1cnGxsbsrOzozp16tCYMWPo8ePHdPPmTSpTRrLQZ2ZIxpidlUVf4+PI1a0cDR07iRkDl0NEIDq8f5ecgiT1ZXBwcFDpICiL5ORkat68OYWHh5OtrS1duXKFHBwc1J8cFix+M7DKAAsW/xA4HA7p6/BIV6D6Z8jncUlXwKUO3VSf6Ts5u9D2HTvIw8OD9u/fT9nZ2UrLAaDbt2+Tv78/DRw4kAIDA2nGjBlERBQbG6tx/9etW0fm5uZUrVo1SklJUeuZNWvW0NixY2nChAl069Yt8vLykrv/4sULmjp1KjVu3JhsbW3JxMSEOnXqRPb29uTh4SG3wPs3b037z1wjM3NLIpIoA29eRVOP9s1p0qg/mLKOjo4MdXOylGegEKSnp1Pr1q3p4cOHZG5uTpcvXyYXFxe1xseCxe+KwonFWbBg8beCw+GQSMAjHpdDaVl5pMzYb6ynQ9Vr1SU7+1IUG/OJiCTRBLm5uURE9PH9W7KxtadPnz5Rt27dyMzMjBo2bEiVK1cmU1NTysjIoPDwcLp+/Tq9efOG+Hw+1ahRgzZt2kQxMTFERBQaGqrRzjc7O5uCg4Np5MiRZGFhQXv27KGcnJxCQxMfP35MY8eOpTFjxtDixYvl7r148YJGjBhB165dIwsLC6pduzYNGjSIjIyMKCUlhcLCwigiIoKIiHg8HjmWdqE1WyShl9JogvdvX1PbRjUoJyeHdPX0yNbOgd6+fklJSUmM5SIpKanQcWVlZVGHDh3oxo0bZGRkRBcvXiQPDw+154UFi98W/6TDAgsWLH4hL0+MJCXZD3+kZmHhsjXQ09cHEaF27dqYPHkygoODceDAAQQFBWHAgAGws7NjKHi5XC6T9U/ihMdn/k/5jnRz586FWCyGs7MzevfurVFfQ0NDQUS4ffs2bt26BSLCzZs3CxlbHipWrAgfHx85R0OxWIzly5dDR0cH5cuXx4EDB1Q6ImZnZ+Pw4cMoX748uFwuxk39E1GxKegzaLic42G9xk1x41Ek+gwayszH5s2bQURo1qyZyj7m5OSgffv2DB3xrVu3NJoTFix+Z7DKAAsW/yKIxWKkZeUyisD72G9o2LgJiAh9+vTBy5cvVT6bm5uLkydPomzZsoWy+Pk1bMJw/w8fPhxz5syBUCjUyFN+69at4HA4SEtLQ25uLpydnREYGKiy/KVLl0BECAkJkbs+bdo0EBHGjRuHjIwMtdrOysrClClTQERwdSvHjEtHKMSqTcGIjk/Bm6/pmLN4FXPvr7/+AhGhVq1aSuvMy8tDr169JPXo6ODSpUtqzwULFv8FsMoACxb/QmTm5OFD3HdUrlIVJiYmOHfunNrPZmRkYMSIEUoVAVv7UoiKTcHl++GMpaBUqVIwNDREly5d1G5j+fLlMDAwYP5eunQpBAIBnj9/rrR8586dUaFCBbkwyN27d4OIsGzZMrXblcXatWvlxta4WStEx6fi5ZdUvP6ajq17jzL3li1bBiKCp6enQj1isRhDh0qsCDweD8ePHy9Wf1iw+J3BOhCyYPEvhJDPpUljR9LrVy/p6tWr1KxZM7WfFYlEtHr1apo6darCvbiYT/Tj+1eyd3AkLo9HYrGYYmJiKCUlhQ4cOEBbtmxRqw2BQEA5OTmMk96IESOobNmy1Lt3b8rMzFQof+vWLWrdujXjyR8fH08jRoygbt260bhx49QemyyGDx9Offr0IaFQRETEUBATERGI7OxLMX9KHQcL+gwAoClTplBQUBBxOBwKDg6mtm3bFqs/LFj8zmCVARYs/oU4ceIE7d+3l9avX0+VKlXS+HkOh0Nz586lunXrKmTeu3bxHH368I7E+Sx/srkABg0aROvXry+St8DFxYWysrLo3bt3REQkFApp586dFBERQZ07d2YUgqdPn9KYMWMoLi6Otm3bRvb29lSuXDmqV68eAaC1a9dqPDZZrFy5kgwMJAyN8vkLQLb2vxwiv337RkSKysCCBQsYZ8YNGzZQ9+7dS9QfFix+W/yzhgkWLFgUhFgsRqVKldC4ceMSsQsCwOvXrxX8BwyNjIvMCNikSRNER0errDc+Ph5EhN27d8tdP3fuHEQiEdzd3VGxYkUQESwtLdGiRQtMmjQJs2fPxtChQyEUCjFu3LgSjU2KadOmgcfjoUXbDoiOkxwTvPqShrdf06GjowMiQosWLZix5eXlAQBWrfrlU7B8+XKt9IUFi98VrDLAgsW/DPfv3wcR4cyZM8WuQywW4+3btzh8+DC8vLzUTgssFWkkQsOGDbF8+XJcu3YN4eHhCA0Nxa5duzB06FDo6OigQYMGcu3m5eWhb9++4HA48PHxwdGjR5GTkyNX5urVqyAiPH36tNjjk0V0dDSICDXq1pdRBlLx9ms6rG0kERbe3t7M2BITE7F161bm79mzZ2ulHyxY/M5glQEWLP5lmDt3LkxMTJgdrCZISEjA4sWLUaZMGWaxEwqFEAh+8fsrywNQUAT5O2oej6dUkZCt4/79+wAkikBgYCC4XC4WLFigoARIsXTpUujp6SE3N7dE8ySFWCyGgYEBPLx8GGXg5ZdUvPmaDp9KVRjrhNRKsG7dOnA4HCaKoaTWFxYs/gtgfQZYsPiXITQ0lKpUqaIxRfCJEyeofPnyNHPmTKpTpw6dPn2a4uPjKTMzk7Kzsyk+Pp5Onz5NXbt2JT6fr5AmWBY5+SyGeXl5jE8BXyAg+1JOVLVGbfKpIsn0x+PxqFevXpSZmUkLFiygXbt20e7du2nKlCkKvgpSfPjwgVxcXAptXxNwOBxydXWl9PQ0hXuOpcsQkSTPgDRF8ahRowgADRo0iJYuXaoWPTELFv91sMoACxb/MsTExJCzs7Pa5QHQ1KlTqV27duTr60tv376lnTt3UsuWLcna2popZ21tTS1btqRdu3bRhw8f5CIU9PT05bzxTUzNFNqxsLCi5X/toF1HL9CuoxeoTr1GlJeXR69fv6YWLVrQnDlzaMqUKdStW7dC+ysWi7WmCEjB4/GIQHIMjiAiZ5eyCm3m5eVR9+7dmQgCFixYsMoACxb/OgDQaJFasGABLVy4kJYuXUrHjx8nOzu7Ip+xs7OjU6dO0dKlSyUXOBzS1dVj7if+TCBDIwmFr76hETm7lKX4uBjq1b4pHdyznRJ+fCPfOvWIiENisZhCQkLIycmJZs6cWWTb5ubmFB8fr/b41EFcXBwJRZIQQyYQAiD7Uo5Mma9fvxIRUY0aNWjHjh1aV0hYsPidwSoDLFj8y2BjY0MfP35Uq+y9e/do5syZNGvWLBo/frxGSgSHw6Hx48fTjBkzKCM9jZISfzL33Mp7UpOW7YiIqIJ3Jdp9/BJVqV6LcrKzadaEEVTHuwwtnz+TZPfi48ePJ6FsrL8KVKpUieLj45m8CCXFjx8/KDY2lszMLeSug4hs7X6FFyJfSxgyZEihORRYsPj/CFYZYMHiX4bKlStTaGhokbH+YrGYBg4cSFWrVqXp06cXu72ZM2eSj4+P3E75ZeQLOrJvJxER3b99nWp7labQB3fknuPx+FTKyZk4HA5xOBy1Y/Rr1qxJXC6XTp48Wew+y0Jaj5WNokUkNyeH+b8o33KQkZGhlXZZsPgvgVUGWLD4l6Fhw4b0/ft3unHjRqHlrl69SuHh4bR06VKVznrqgM/n0+rVqykvn4SIiEhHp+gdfl5eLn368I4AkLu7OxkaGqrVno2NDbVp04aCgoLkCI+KAwC0atUq4nK5xOXmW0XydahPH97RlLFD5NolKjpzIQsW/x/BKgMsWPzL4OfnR+XKlaPVq1cXWm779u3k6elJdevWLXGbdevWJTc3N+bv7OysQstzOByG8Y/L5VKFChU0am/ChAkUHh5O69ev17yzMti8eTOFhYWRWCym11GRzPUv8XHUu1Nr+hIfzxydSFkRWWWABQtFsMoACxb/MnA4HJo6dSodO3aMTp06pbLc3bt3qWnTplrxiOdwONSiRQulZ+l6+vpkV8qRXN09qHwFHyrn6U1OZVzJxMSUaVvTM/hatWrR8OHDadKkSfT48eNi9TksLIzGjRtHdg4SJ8FX0ZGUnZVFP75/oz4dW9GnD+/IsXQZsnOQ5ChIS5OEHrLKAAsWimCVARYs/oXo2bMntWjRggYMGEBv3rxRuJ+cnEzv3r0rVt4CVahUqRLlyJyxS5Gelkaxnz7S6+gIigx/RlEvwuj9m1f0M+EHASCxWEyxsbEat7do0SLy9vYmf39/un37tkbPPnjwgOrXr092Do7UoElzIiLKzMygYwd304Bu7ejNq2iysbOn4ENnyLG0JExTqgxIkxaxYMHiF4p/0MiCBYu/DRwOh7Zv305+fn5Ur149OnHiBFWpUoW5n5KSQkREZmaKfADFhbm5OfN/fQNDSktNIWdXN6pcvSaZmJiRiakZGZuYkolZ/r8mpmRiak77g7fSvh0bNA6J1NfXp/Pnz1ObNm3Iz8+Pxo8fT1OnTiVjY2OVzyQnJ9OSJUto4cKFxOFwqLJvLRLK+Dcs/nMapaelkrmFJe04dIocHB2ptLMr3b15nfFPYC0DLFgoglUGWLD4l8LKyoquXbtGrVu3Jl9fX5o4cSKNHTuWLCwsGLN8VlbhZ/uaQDb1cFamxON+wPCx1LZTd+KAVDIi+tauS3+tWkS3b9+mOnXqaNSmiYkJXb16lZYvX04zZ86kdevWUbdu3ah+/frk4+NDhoaGlJqaSs+ePaMbN27Q3r17KSsri7oG9qd9O7fQlfNnqGmrdkx96WmppK9vQNv2n6Qyrm4EInJwdJJrk1UGWLBQBKsMsGDxL4atrS3dvXuXFi1aRPPnz6cVK1ZQ27ZtqWbNmmRkZEQvXryggIAArbT14sUL4vF4lJeXR7m5uURENGv8CLoTcoW69RlElavVULrzr1azLjk5u9C69es1VgaIJNEMkyZNol69etGGDRto8eLFtHXrVoVyAoGABg4fR1169iUbO3siItq7YzPdu3VdrlzVmrWpnKcX87cs1wARe0zAgoUysD4DLFj8yyEQCGjGjBn06dMnmjNnDr1//54mT55MqampdOvWLa21Iz23l3UGzM3NoTPHD1HPdv4U4F+TDuzaSmlpqXLPcTgcqlTVlw7s30/Xr8svzJrAzs6OcnJyGEVECh5PsmfR0zegEROmM4rAqIkzyMTUjCFL4nIlPAl3b4ZQQsKPfCZCkJ29vDLAWgZYsFAEB0Uxm7BgweJfh5ycHFq0aBHNnj2b3r9/T6VKlSpRfR8/fiRnZ2eqX78+ubu7U1hYGIWGhlJmZiYJBDoEiJlFWt/AkNp16k5dew+g/2vvzqOqKvc+gH/PCCozARr0moATqAliec0BpxzulWti91qgpr7OgWaaicO9XMoso9AcyIUapXhzIkciBNTemxI44IgBenFCjBABmQ+/9w/yrM7VW8o5JXC+n7VYCzf7+e1nn+Va57ufvffz2No54G/zQ5CadABKpRKurq5IT083WBPhYSUnJ2PIkCH3TbakUCohdXXwaN8J+w5nQD+dgAhe+fMLOJF+FAAwcNifcPP6NZw/cwrzFkdgymuvQ6EAbly5Av+eXvp6jo6OKCwsbOAnRdRMPZa1EonIaCUlJWJtbS0zZ840utaMGTPExsZGSktL9dvKy8slNjZWOnToIAqFQiwtW4jDE04GSxmrflrKWK1Wy+QZs8XZpbV4eXlJXl7eIx0/ISFBLC0tH7hc8r2frj5+kn7xhly4USZZN0rl1amvGfzdq2t3eefDtQJAXJ9qK+ev35HvC8rk/LXi+5Zf5rLFRIYYBoiasJUrVwoASUlJaXCN5ORkASCrVq164N8rKyslLCxM/2Vqa+8g1ja2Bl+w9o5PyKy5b8lnOw7Ik25PiY2Njaxfv15qamp+8dhFRUUyc+ZMAaAPAgqFQgBI69atxdfXV7p37y7W1tYCQFq2aiV/CZ4o4yZP1x+7s3c3/e+bv0wSW3sHASDrYrfJ9wVlklNQLrZ29gb9LS8vb/DnRdQcMQwQNWE6nU78/f3F0dFRTp8+/cjtMzMzxcHBQfz9/UWn0/3ivhs3brzvav2ptk+L489GC1QqlQwYMlz6+A8SAOLi4iKLFy+WAwcOyJUrV+TWrVuSlZUlW7dulYkTJ4qlpaWoVCp9+06dOkl0dLQUFBQYHLuurk5ycnIkPDxcXFxc9MFhUcT78tIrr+rbP+PbUyZODxUA0sd/sHxfUCbZBXelo5e3Qb/z8/Mf+bMias4YBoiauB9//FF8fHzE1tZWNm/e/FBD4HV1dbJ582axtbUVHx8fKSoqeqhjvfnmm/cN5Ts4PiEjR/9VfHv2MthuZW0jAESr1T5w2N/FxUWcnZ1FoVCIhYWFREVF/WogEREpLS2VGTNmCAD5a/BEGT12nAAQzU/Hmb/kbf3oQuK3JyW74K4MGf4ng2NnZWU91PkSmQuGAaJmoLi4WMaOHSsAZPDgwbJv3z6pra29b7/a2lrZu3evDBpUf+U+duxYKS4ufujjVFRUSLt27fRftj//sbWzl+BJ02XMy+NF/dOzBOHh4VJVVSU5OTmyf/9+iY+Pl08//VR69uwpAMTZ2VlsbGwkLS3tkc9506ZNolAopEPn+qv+fgNfEADyhJOzfmRiwtRZkl1QJhOnGT5f8N133z3y8YiaM4YBomYkPj5efH19BYBYW1tLv379ZMKECTJhwgTp06eP/t57jx49JD4+vkHHWLdu3QPDwL0fCwtLASAxMTH3tT127JjY2dmJp6enhIbWD+cnJyc3+HzfffddfV/mLgqXpz3a1wei4QH1n4GNrZy6VCBh4csN+piUlNTgYxI1R3y1kKiZERFkZGQgJSUFGRkZuHr1KjIyMuDr64vAwEAMGjQIfn5+Da5fWloKBwcHPPd8f5xIP4aK8rsGf1cqlZg6dSrWrVtnsD03Nxd+fn7w9vbG559/ji5dumDy5MlYtWpVg/ui0+nQq1cvnDx5Em8sikD7jp0xJehFqFQquLR+EjeuX8U/VqyCvb0DQv43WN9ux44dCAwMbPBxiZqdxxxGiOg39tVXXwkAyc7ONlnNZ7p3lzGvTJATOTdlUcT74uTSWn/V7eTkJCUlJQb763Q66devn7Rr106Ki4tlxYoVotVq5datW0b3JTExUQDIuMkzJCu/TAYO/aMAkKfdPQWAdOzsLdv2pxqMDGzYsMHo4xI1J5yBkKiZy8nJgUajgYeHh8lqent5ITvrPEQE4ybPwKGMLCyLWge1Wo2QkBBYW1sb7B8XF4cjR45g48aNsLW1RVxcHF588UU4OTkZ3ZfBgwfDzc0N586cAgAsDF8OrYUF/n0pBxqtFhcvnMMPBfkGbTglMZEhrk1A1MzV1NRAo9E80oqCv0ar1eLc6ZPo0b4NFAoFWrZqBa3WArW1tRg3btx9+69evRovvPAC/P39UVlZiTNnzmDq1Kkm6YtSqcTAgQORcqh+KuSn2rbDpOmhiF65AhqNFjXV1YiL3QCFQgERgUqlQlRUFA4fPowePXrA398fzz//vEk/H6KmhiMDRM2cnZ0dysvLUVZW9us7P6SCggLodDoA9c8o3C0rw+2iH2Fvb4+2bQ1XCczJyUFaWpr+yz87Oxu1tbXo1q2byfrzzDPP4FbBTf2/p4bOQ5sn3VB+twwqlQr/OpwMCwsLPPfccwgKCoK/vz9KS0sRGRmJvn37okuXLti8efN9UyETmQuGAaJmrnv37gCAU6dOmaxmeno61GoNtBYWBtvbt29/3xV2eno6AMDf3x8AUFFRvzzyf95KMIaVlRWqq6r0X+YKKNDWvf62iJ+fH3bs2IGSkhIcO3YMsbGx+PTTT3Hw4EEUFRUhOTkZnp6eGDduHEaOHIlbt26ZrF9ETQXDAFEz5+3tDRsbGyQkJJikXmZmJgoLC1FTUw3/QUNx9MxlJHxzAr2e72+w4uE958+fh6urKxwdHQEALVq0AFD/VoKplJaWQmthAYVCgfLyu5ga9CJOn0hHdHQ0jh49isDAwAf2TaFQYODAgdi9ezd2796N9PR09O3bF/n5+Q84ClHzxTBA1MxpNBqMHz8eMTExqKqqMrremjVrYGtnD7Vaja8P7EHw6GEAgE7eXZF/8+Z9+1dUVBiMArRv3x5qtRqZmZlG9+WezMxMtG79JEQEb4VOxfkzp5CUlIRp06Y99LMAAQEB+Pbbb1FeXo4RI0agurraZP0jauwYBojMQEhICIqKivDOO+8YVefEiRPYsGEDhgwPwOb4RDi3boPc7It4aYQ/AOBSbi6Ki4sN2rRo0cJgFMDS0hLdunVDamqqUX25p66uDikpKbC2tcO+Xdvw9f7diI2NRe/evR+5loeHB/bs2YOzZ88a/VkRNSmP871GIvr9hIeHi0qlkiNHjjSofXFxsXTq1Em/sFDQxKmSdOyM9Hj2Dwbv8MfGxhq0i4uLEwBSWFio3/bhhx+KRqORmzdvGnVOIiIHDhwwmP3wpZdeMrrmkiVLRKPRcEEjMhsMA0Rmorq6Wvz9/cXGxkYOHTr0SG0LCwulV69eYmdnp18DAYC0bechm3d9JUETp+qXIfbx8TVYLCk7O1sAyI4dO/TbioqKpFWrVjJ9+nSjzqmmpka6d+9usPJhQ1Zv/E9FRUXSokULiYiIMLoWUVPA2wREZkKj0WDPnj3w8/PDwIED8dZbb6G8vPwX24gI4uPj4e3tjezsbCQlJWHr1q1ITEyEq6sr8i7nYvyYEbCyskHEio+hVKlw8mT9rYR7PD098dxzz2H9+vX6bfb29njvvfcQHR2NxMTEBp/TsmXLkJmZqX/N0cfHB127dm1wvZ/3LzAwEDt37jS6FlGT8LjTCBH9vmpqamTZsmWi1WrFzs5O5syZIwcOHJCbN29KdXW1lJSUyNGjRyUyMlK8vLwEgIwcOVJu3LhhUKeoqEiCg4P1V+QdvbrIB2s3ScuWraRly5YGV+ibN28WAJKamqrfptPpZNiwYWJtbS3/+te/Hvk8Pvnkk/rpj51b/3SLwEJmz57d0I/lPmvXrhW1Wi0VFRUmq0nUWDEMEJmpS5cuyZtvvilOTk4PXH1Qo9FIYGCgHDx40GDY/z/t2LFDHB0d9W0mTw8Va2sbsbe3l6NHj4rI/WsT3FNaWir9+/cXrVYry5cvl5qaml/td3FxsUycOFEASPCkadKz1/P6Pq9fv974D+Ynhw8fFgBy4cIFk9UkaqwYBojMXF1dneTm5squXbtk06ZNsmXLFsnIyJDKysqHrnHz5k0JCAjQfyl3ecZHnnByFqVSKQsXLpTi4mLJyckRe3t76d27t0EgqKiokPnz54tSqZQOHTpIVFSUXLlyxSCA1NbWytmzZ2XhwoXi4OgoKpVKrG1sJT3rmvg91/u/PrxojLS0NAEgmZmZJqtJ1FhxCWMiMgkRQWxsLEJDQ1FaWgpLyxZwb98BF86ehoWFBV555RW4ubkhKioKTk5O2LRpE/r27atvn5GRgQ8++AA7d+5EbW0tnJyc4OrqCp1Oh9zcXJSXl0OlUuGFP47CmVMZuHYlD38Nnojsi1k4kX4UGo0G77//PubMmWOS80lISMCIESNw+fJlPP300yapSdRYMQwQkUnl5eVh4sSJ+nkEvLo8gyt5l1BZUYHa2loA9YsLiQhGjBiBmTNnol+/frCysgIA/PDDDzh8+DD27t2Lb7/9Frm5ubCwtETlT9MYvxQ0AQGjx2Jc4HAAgGeHTsj5Pgvt3D3Rt09vxMbGmuQ83nnnHaxYsQK3b9/mIkbU7DEMEJHJ1dXVYfXq1ViwYAEqKythZWWNNm5PITvrPABg2MjRaNvOA4eSDuDihXNQKBTwbN8etjY2uHPnDi5dugSdTge1Wo3a2lrY2tnjSbencOHsaajVaqRmZGF15DJ88flGaC0sUF1VhQFDhuP786fx73//G2q18Quy9u/fH5aWlka97UDUVPDVQiIyOaVSidDQUJw8eRI9e/ZEWVkpsrPO42l3TwDAV3t34fTJdGzatg97Uo4h4oPV6N1/CNw7doF7R2/U1dUBgH4k4U7xbbRs1Uq/bWrwaMyevwTOrdug+qcplp/vPxDXr1/Hnj17jO7/uXPncOTIEUyaNMnoWkRNAUcGiOg3VVtbi+XLlyM8PBy1tbWwsrZGTXU1qqqq4Or2P/h4Qxy8u3U3aPPR8nBEr1xxX60nnJxR+EP9qoKBL4/HoKF/xMxX/woAWBSxAkkHduP2j7eQeeqUfkGkRyUiGDp0KLKyspCTkwOtVtugOkRNCUcGiOg3pVarsXjxYqSlpcHb2xtlpaWoqqpCKysrXL92BS//eTC+3L7VoM2suQvh3bX7fbXuBQEA2Ln1M+RfvwobW1sAwGcxa7H4nUhcycvDvHnz0NDrnI8//hhJSUlYv349gwCZDYYBIvpd+Pr6IiMjA/Pnz4dCocDdsjJYWFiiqrISC0Kn4O3F81FTUwMA0Gq1WLE6BhYWlr9Yc9nSBbCytgEAXM27jENJCVgY/h7Wrl2LRYsW6W83PKyNGzdizpw5mDNnDoYNG9awEyVqgnibgIh+d9988w1effVVXLp0yWB7z17PI2r9Z3jCyQUA8PmGdXh78fwH1mjj6ob869egUqn00xFrLSyw++BRHDr4Fd4LD8OAAQMQExMDd3f3X+xPYWEhZs+ejbi4OEyfPh1r1qyBUslrJTIfDANE9FiUlZVh3rx5+OSTTwAACoUSInVwafMkVm+IQzcfP9TV1WHyy6Pw7ZEUfbuWraxQfrfsvt/t7B1QfLsIXl2ewc7Eb3Ds/w5j0RszcetmPkaNGoWgoCD4+fnB1dUVCoUChYWFOH78OHbu3IktW7ZAq9Vi1apVCA4O5quEZHYYBojosUpISMDkyZORn5+v36bRavG3dz/CS69MQEH+DYzo3wNlpaUAYPBF7eHhgc6dO0OpVCIvLw/nzp1DTU0Nnmr7NBYsXYbe/Qci/ovNiIuNQe73WfW1NRooFApUV1cDAFxdXTFt2jRMmzYNzs7Ov+OZEzUeDANE9NgVFRXhtddew9athg8Sjh0/GYsiViBxXzzmzZpcPx+Bpyfmzp2Ll19+GbY/PTx4T3V1NRISEhAVFYVDhw5h6J9GIfy9lbCzd8DNG9dx7vRJbNvyKQ4nJ6Jfv37YsGED3N3deUuAzB7DABE1Gtu2bcP06dNx+/Zt/bbuvj1ha++Ab1KTsHTpUoSFhUGj0fxiHRHBtm3bMHPmTDg4uSB2+z79cwi7vtiMhXOmY8CgwUg5mPSbng9RU8EwQESNSn5+PqZMmYL9+/frt6lUKuzatQsBAQGPVOvixYsYMGAAHJxc8M+9KdBqtTj6TSpe/ctItO/YCd9nXTB194maJI6NEVGj0qZNG+zduxcxMTGwsLAAUP/u/6MGAQDo2LEj9u3bh4vnz+KTVfWTGLV+0g0AcP3a1QbPRUDU3HBkgIgaJRFB+/bt4ebmhtTUVKOe8F+6dCneffddpHx3Hja2dujuUf+gYFFREezt7U3VZaImiyMDRNQopaSkIDc3F+Hh4Ua/6vfGG2/AwsIC2+M+RYuWLWFrVx8AkpOT9YsiEZkzjgwQUaM0bdo0pKam4uLFiyZ57z8oKAhfJx2E61NtcTbzhEEAsLKygp+fH8aPH4+xY8c2eF0DoqaKIwNE1ChlZGSgT58+RgcBnU6Hjz76CDt37kTx7SJ4tvsfREZGIjk5GceOHUNiYiKWLFkCrVaLSZMmoW3btvjnP//J5wnIrHBkgIgapVatWiEiIgJz585tcI3i4mKMHj0aqampCAkJQVhYGFq3bv1f98/NzcVbb72FHTt2IDg4GBs2bOBiRWQW1I+7A0RED1JVVWXUcH1ZWRmGDh2K7OxspKSkYMCAAb/axsPDA9u3b8eWLVswadIk3L17F9u3b4dKpWpwP4iaAt4mIKJGycrKCsXFxQ1u//rrr+PcuXNISkp6qCDwc0FBQdi+fTu+/PJLfPjhhw3uA1FTwTBARI1S165dcerUqQa1TU5ORkxMDCIjI9GjR48G1QgICMDrr7+OJUuWIDs7u0E1iJoKPjNARI3S/Pnz8fnnn+Pq1au/Ov3wfxoyZAju3LmDtLQ0ox5ArKiogLu7O0aPHo01a9Y0uA5RY8eRASJqlMaPH4+CggLEx8c/UrucnBwcPHgQoaGhRr+J0KJFC0yZMgWfffYZ7t69a1QtosaMYYCIGqWuXbtiwIABWLJkCSoqKh663eHDh6FUKjFq1CiT9GPMmDEoKyvDiRMnTFKPqDFiGCCiRmvNmjXIy8vDggULHrrNiRMn0KlTJ1hZWZmkD15eXrC0tMTx48dNUo+oMWIYIKJGq3PnzoiMjMTHH3+M8PDwh5oIqKCgAG5ubibrg1qtRps2bVBQUGCymkSNDecZIKJGbdasWSgpKUFYWBi+++47rF+/Hq6urv91f4VCYfLZA+vq6qBU8tqJmi/+7yaiRm/hwoXYu3cvTp48CU9PT0yaNAkpKSkoKSnR71NVVYWMjAzk5eUhKyvLZMeurKzE9evXTTraQNTY8NVCImoybt++jejoaERHR+PKlSsAABcXFyiVShQWFqKmpgaWlpaorKxEYWEhHB0djT5mWloaevXqhbS0NDz77LNG1yNqjBgGiKjJ0el0yMrKwvHjx5GXl4e6ujo4OzvD19cXTk5O6NChA1auXIlZs2YZfazZs2dj69atuHbtGtcpoGaLYYCImp0xY8bgzJkzOHPmjFFf4D/++CPc3d0xa9YsLFu2zIQ9JGpc+MwAETU7ixYtQm5urtFf4KGhoVAqlQgJCTFRz4gaJ4YBImp2fHx8EBYWhrfffhv79u1rUI3Vq1cjLi4Oq1atQps2bUzcQ6LGhWGAiJqlpUuXIiAgAKNHj0ZMTMxDv25YW1uLv//97wgJCcHcuXMRHBz8G/eU6PFjGCCiZkmtVuOLL77AhAkTMGXKFAwfPhxpaWn/NRTU1dXh66+/Rq9evRAREYF//OMf+OCDD4xe34CoKeADhETU7O3fvx8hISG4fPkyunXrhj59+qBbt25o2bIl7ty5g1OnTiE1NRWXLl2Cj48PoqOj+RohmRWGASIyCzqdDomJidi6dSsyMjJw8eJFiAjUajW6dOmCZ599FhMmTMAf/vAHjgaQ2WEYICKzpNPpUFNTA61Wy6mGyewxDBAREZk5xmEiIiIzxzBARERk5hgGiIiIzBzDABERkZljGCAiIjJzDANERERmjmGAiIjIzDEMEBERmTmGASIiIjPHMEBERGTmGAaIiIjMHMMAERGRmWMYICIiMnMMA0RERGaOYYCIiMjMMQwQERGZOYYBIiIiM8cwQEREZOYYBoiIiMwcwwAREZGZYxggIiIycwwDREREZo5hgIiIyMwxDBAREZk5hgEiIiIzxzBARERk5hgGiIiIzBzDABERkZljGCAiIjJz/w9DPCv4ZBaKDQAAAABJRU5ErkJggg==", + "image/png": "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\n", "text/plain": [ "
" ] @@ -368,7 +358,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -383,7 +372,10 @@ { "data": { "text/plain": [ - "" + "(,\n", + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 14, @@ -392,7 +384,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -413,7 +405,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -421,7 +412,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -447,7 +437,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -468,7 +458,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -492,7 +481,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -513,7 +502,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -532,7 +520,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -546,7 +533,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAG1CAYAAAAfhDVuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABGoklEQVR4nO3de3gU1d0H8O+GQIhANgTMhkgiqYCgUAUiMUi9lDyi8GJR1OIbAZGCWqJyESH1gXoP2lYplkLtBahVUVvByqtYDAKiMUAAFcSANUIUklRjNgQlBHLeP3h2u7PZ3exlLmfOfj/Ps48yOztzzm8u+c2ZM2ccQggBIiIiIkUlWF0AIiIiIiMx2SEiIiKlMdkhIiIipTHZISIiIqUx2SEiIiKlMdkhIiIipTHZISIiIqUx2SEiIiKlMdkhIiIipTHZISIiIqXFfbKzbNky9OnTB507d0ZeXh62b99udZEMUVJSgksuuQTdunVDeno6xo8fj8rKSs08J06cwMyZM9GjRw907doVEyZMQG1trWaew4cPY+zYsTjrrLOQnp6OefPm4dSpU2ZWRXeLFy+Gw+HArFmzvNPiMRZfffUVbr31VvTo0QPJyckYPHgwdu7c6f1eCIFFixahV69eSE5ORkFBAQ4ePKhZRn19PQoLC5GSkoLU1FRMmzYNTU1NZlclZqdPn8bChQuRk5OD5ORknHfeeXjkkUfg+3YdleOxdetWjBs3DpmZmXA4HFi3bp3me73q/tFHH+FHP/oROnfujKysLDz55JNGVy0qoeLR0tKC+fPnY/DgwejSpQsyMzMxefJkHDlyRLOMeImHvzvvvBMOhwNLlizRTDc9HiKOrVmzRnTq1En85S9/Efv27RPTp08Xqampora21uqi6W706NFi5cqVYu/evWLPnj1izJgxIjs7WzQ1NXnnufPOO0VWVpYoLS0VO3fuFJdeeqkYMWKE9/tTp06JQYMGiYKCArF7927xxhtviJ49e4ri4mIrqqSL7du3iz59+ogf/vCH4t577/VOj7dY1NfXi3PPPVfcdtttory8XHz++efirbfeEp999pl3nsWLFwun0ynWrVsnPvzwQ3HdddeJnJwc8f3333vnueaaa8RFF10kPvjgA/Huu++Kvn37iltuucWKKsXkscceEz169BDr168XVVVV4pVXXhFdu3YVv/3tb73zqByPN954QzzwwAPi1VdfFQDE2rVrNd/rUXe32y1cLpcoLCwUe/fuFS+++KJITk4Wf/jDH8yqZthCxaOhoUEUFBSIl156SXz66aeirKxMDB8+XAwbNkyzjHiJh69XX31VXHTRRSIzM1M8/fTTmu/MjkdcJzvDhw8XM2fO9P779OnTIjMzU5SUlFhYKnPU1dUJAGLLli1CiDMHbMeOHcUrr7zinWf//v0CgCgrKxNCnNnBExISRE1NjXee5cuXi5SUFNHc3GxuBXRw7Ngx0a9fP7Fx40ZxxRVXeJOdeIzF/PnzxciRI4N+39raKjIyMsSvfvUr77SGhgaRlJQkXnzxRSGEEJ988okAIHbs2OGd58033xQOh0N89dVXxhXeAGPHjhW33367ZtoNN9wgCgsLhRDxFQ//P2Z61f33v/+96N69u+Z4mT9/vjj//PMNrlFsQv1x99i+fbsAIA4dOiSEiM94fPnll+Kcc84Re/fuFeeee64m2bEiHnF7G+vkyZOoqKhAQUGBd1pCQgIKCgpQVlZmYcnM4Xa7AQBpaWkAgIqKCrS0tGjiMWDAAGRnZ3vjUVZWhsGDB8PlcnnnGT16NBobG7Fv3z4TS6+PmTNnYuzYsZo6A/EZi3/+85/Izc3FTTfdhPT0dAwZMgR//OMfvd9XVVWhpqZGExOn04m8vDxNTFJTU5Gbm+udp6CgAAkJCSgvLzevMjoYMWIESktLceDAAQDAhx9+iG3btuHaa68FEH/x8KVX3cvKynD55ZejU6dO3nlGjx6NyspKfPvttybVxhhutxsOhwOpqakA4i8era2tmDRpEubNm4cLL7ywzfdWxCNuk52vv/4ap0+f1vyxAgCXy4WamhqLSmWO1tZWzJo1C5dddhkGDRoEAKipqUGnTp28B6eHbzxqamoCxsvznZ2sWbMGu3btQklJSZvv4i0WAPD5559j+fLl6NevH9566y3cdddduOeee7B69WoA/61TqOOlpqYG6enpmu8TExORlpZmu5gsWLAAEydOxIABA9CxY0cMGTIEs2bNQmFhIYD4i4cvvequ2jHkceLECcyfPx+33HILUlJSAMRfPJ544gkkJibinnvuCfi9FfFIjPgXZHszZ87E3r17sW3bNquLYonq6mrce++92LhxIzp37mx1caTQ2tqK3NxcPP744wCAIUOGYO/evVixYgWmTJlicenM9/LLL+P555/HCy+8gAsvvBB79uzBrFmzkJmZGZfxoPC0tLTg5ptvhhACy5cvt7o4lqioqMBvf/tb7Nq1Cw6Hw+rieMVty07Pnj3RoUOHNk/Y1NbWIiMjw6JSGa+oqAjr16/HO++8g969e3unZ2Rk4OTJk2hoaNDM7xuPjIyMgPHyfGcXFRUVqKurw9ChQ5GYmIjExERs2bIFS5cuRWJiIlwuV9zEwqNXr1644IILNNMGDhyIw4cPA/hvnUIdLxkZGairq9N8f+rUKdTX19suJvPmzfO27gwePBiTJk3C7NmzvS2B8RYPX3rVXbVjyJPoHDp0CBs3bvS26gDxFY93330XdXV1yM7O9p5fDx06hLlz56JPnz4ArIlH3CY7nTp1wrBhw1BaWuqd1traitLSUuTn51tYMmMIIVBUVIS1a9di06ZNyMnJ0Xw/bNgwdOzYUROPyspKHD582BuP/Px8fPzxx5qd1HNQ+/+hlNmoUaPw8ccfY8+ePd5Pbm4uCgsLvf8fL7HwuOyyy9oMRXDgwAGce+65AICcnBxkZGRoYtLY2Ijy8nJNTBoaGlBRUeGdZ9OmTWhtbUVeXp4JtdDPd999h4QE7emxQ4cOaG1tBRB/8fClV93z8/OxdetWtLS0eOfZuHEjzj//fHTv3t2k2ujDk+gcPHgQb7/9Nnr06KH5Pp7iMWnSJHz00Uea82tmZibmzZuHt956C4BF8YiqW7Mi1qxZI5KSksSqVavEJ598ImbMmCFSU1M1T9io4q677hJOp1Ns3rxZHD161Pv57rvvvPPceeedIjs7W2zatEns3LlT5Ofni/z8fO/3nsetr776arFnzx6xYcMGcfbZZ9v2cWtfvk9jCRF/sdi+fbtITEwUjz32mDh48KB4/vnnxVlnnSX+9re/eedZvHixSE1NFa+99pr46KOPxE9+8pOAjxsPGTJElJeXi23btol+/frZ4lFrf1OmTBHnnHOO99HzV199VfTs2VPcf//93nlUjsexY8fE7t27xe7duwUA8dRTT4ndu3d7ny7So+4NDQ3C5XKJSZMmib1794o1a9aIs846S8pHrUPF4+TJk+K6664TvXv3Fnv27NGcX32fJIqXeATi/zSWEObHI66THSGEeOaZZ0R2drbo1KmTGD58uPjggw+sLpIhAAT8rFy50jvP999/L37+85+L7t27i7POOktcf/314ujRo5rlfPHFF+Laa68VycnJomfPnmLu3LmipaXF5Nrozz/ZicdYvP7662LQoEEiKSlJDBgwQDz77LOa71tbW8XChQuFy+USSUlJYtSoUaKyslIzzzfffCNuueUW0bVrV5GSkiKmTp0qjh07ZmY1dNHY2CjuvfdekZ2dLTp37ix+8IMfiAceeEDzx0vleLzzzjsBzxdTpkwRQuhX9w8//FCMHDlSJCUliXPOOUcsXrzYrCpGJFQ8qqqqgp5f33nnHe8y4iUegQRKdsyOh0MInyFBiYiIiBQTt312iIiIKD4w2SEiIiKlMdkhIiIipTHZISIiIqUx2SEiIiKlMdkhIiIipTHZAdDc3IwHH3wQzc3NVhdFCoyHFuOhxXhoMR5ajIcW46FlVTw4zg7ODHXudDrhdrs17zOJV4yHFuOhxXhoMR5ajIcW46FlVTzYskNERERKUybZWbZsGfr06YPOnTsjLy8P27dvt7pIREREJIFEqwugh5deeglz5szBihUrkJeXhyVLlmD06NGorKxEenp6u7/3vMnY7XYbXVRbaGxs1Pw33jEeWoyHFuOhxXhoMR5aesdDCIFjx44hMzMTCQnB22+U6LOTl5eHSy65BL/73e8AnElesrKycPfdd2PBggVt5m9ubtZ0jqqqqsLFF19sVnGJiIhIR9XV1ejdu3fQ723fsnPy5ElUVFSguLjYOy0hIQEFBQUoKysL+JuSkhI89NBDbaZXV1cb2mHK0ykr0u/MoMf6Pcswqy56rcfq2JPx4n0bm1H/eI8xRU6PfaaxsRFZWVno1q1byPlsn+x8/fXXOH36NFwul2a6y+XCp59+GvA3xcXFmDNnjvffnmClpKQY3js81PKt7qmvx/o9yzCrLnqtx+rYk/HifRubUf94jzFFTq99xuFwhPze9slONJKSkpCUlNRmutPp9P6/EXf3/JfpcDgghPD+N5BQ3xnBv0yRrN8zv90E2y568l1msP9XjWdfiKV+4exPvssPFk8ZYmzldjdiXf51kCHGZC9m7jO2fxqrZ8+e6NChA2prazXTa2trkZGRYVGpiIiISBa2T3Y6deqEYcOGobS01DuttbUVpaWlyM/Pj2hZbrcbQgjN1ZeRPOsJlN0Guio2sjz+ZQlVtvaWE022Hk7d/Ocx6qrA7lfcRnA4HBHvf9HuC6GWFejjP5+sVGsFUaEO0Qp2LOh5jrZjK7mvaM4ZRlLiNtacOXMwZcoU5ObmYvjw4ViyZAmOHz+OqVOnWl00IiIispgSyc5Pf/pT/Oc//8GiRYtQU1ODiy++GBs2bGjTaZmIiIjijxLj7MQq2Ls6zOpEqHInVZVFu91U2t5G1yWajvJERuK+GDs9Yxjuu7Zs32eHiIiIKBQmOz58Hz0HIu+AF21nLNmuEjz18O1g5v//dhNJmcOdN9rtZvSj2GYyeriBYB3l7bwvGs3KmMS6bjtsT9nO13ZkRQyZ7BAREZHSmOwQERGR0pjsRCFYU2u0TXMyNN16blMFuj0Q7P9lE6icso31AMQWTxmb0EOVyYjYy7Y9ZWP0OGG+5wr/T6zrlXH/JjUw2SEiIiKlMdkhIiIipSkxqKBeYn3VfLRkaLr1f0FhsNdVyPyyz0DD8YdT3kDfB3uJpR7jQ6j22oBgjBqPJJbbxSrH25eRLx1t77alijEOVi+zXmFDsWPLDhERESmNLTtRUD17D9aCE+3LQa3WXnkjab2xS91luMI2qmUh0Dr0ntfujGw9lGHfMpvdzwfElh0iIiJSHJMdIiIiUhqTHdKIl86zgdhlPKFwyLTtZCoLxS7U9oznbW33c4bqmOwQERGR0pjs+PB/EWikVM/s4+nli/F8hSo7u7+U1myMkTl4zpAbkx0iIiJSGpMdIiIiUhqTHR+xjqCsWjOmKuPshEvVelnF/wWRehFCcFtFwIhY8dYYGU3vfYzJDhERESmNyQ6FzahOoXotL9hywmlhMKIFwkqy1MW3FUaWMlHsgr1zTtVtrGq94gmTHSIiIlIakx0iIiJSGpMdaiNYR2SjOijrtbxQL+sLt1OrVc3VRnTitbocwfafaAUqGzsqWydQ7FXdHqHqZeUtLtlvr8VSPt/b33rUk8kOERERKY3JDhERESmNyY6PSF8X4d+0JnuTYjiCPXFl9yH62yuz/wtQza5juM3/RpdL5tsQgcpmx31RZfG4Paw8ZqJZt5nbSI/Y6DWuFpMdIiIiUhqTHR++IyiH04oRzfghwcam8J3e3ngxRvLvhOxZnye7djgcmixbz9aeaJcRqoXNt/yef/t/PHyvIGQddTbScql2pR1sVO9YlxdonzEydsGO5VjGrrFiW+u9PYIt12zB9odg5w491mMWs1uirN6WHkx2iIiISGlMdoiIiEhpiVYXQFaR3M6IZt5Q00KNF2O2QGXzvZWl522faJcRKn56j/USCxm2n90ZNcZToH3GyNhFcoyHWw4Z9i//29x6LddsZu0PVtfTDL5dCKysL1t2iIiISGlMdihiql2NyNKBjkhvsg6hoAqeO8Jn9b7BZIeIiIiUxmSHiIiIlMZkx0ekIyiTGsxoXg1nHCUyXrzF3upbB6oz4uW2RvyGmOwQERGR4pjsEBERkdI4zo4P39dFRCKS8QMCzev/yoJIXlopC6vHUPAVqiye7/z/a7RQY//oJdi+Jct2kYEssfB9jUk4tyVkKTfpK5rtard9QZZzEFt2iIiISGlSJzslJSW45JJL0K1bN6Snp2P8+PGorKzUzHPixAnMnDkTPXr0QNeuXTFhwgTU1tbqXha9XggabIRU/5dQhvrISKZyhdoeeo/8bMZLI8MVy+i7kTCjrpGuI9TLc2UUyfEu07Elu1AvBY52eXbbt/yZXU6jXg4bbPnhkjrZ2bJlC2bOnIkPPvgAGzduREtLC66++mocP37cO8/s2bPx+uuv45VXXsGWLVtw5MgR3HDDDRaWmoiIiGTiEDa6bPjPf/6D9PR0bNmyBZdffjncbjfOPvtsvPDCC7jxxhsBAJ9++ikGDhyIsrIyXHrppWEtt7GxEU6nE263GykpKQHnCee+oyz3JukMM7aH2X1/ZGBmXGOdP562C7Xd3rFuf9++Ve2tS1Zml9Po9fkvP5y/34DkLTv+PB2I09LSAAAVFRVoaWlBQUGBd54BAwYgOzsbZWVlQZfT3NyMxsZGzac90b7k05enSTTUx+7MrIMMHbnNeGmkXkLFK5LtZnaH7ljmj+QWc6zCOb5VPe5lofeLf0PdRrTDMQ+YX06j1xft8m2T7LS2tmLWrFm47LLLMGjQIABATU0NOnXqhNTUVM28LpcLNTU1QZdVUlICp9Pp/WRlZRlZdCIiIrKQbZKdmTNnYu/evVizZk3MyyouLobb7fZ+qquro15WpFfEwTofBrqCkP2KL9CowGaNRuzbMTjSq2PZ4xqN9uoUSyuYCqM/WzG8gBEPHdg1/rKVm61r8ccW4+wUFRVh/fr12Lp1K3r37u2dnpGRgZMnT6KhoUHTulNbW4uMjIygy0tKSkJSUpKRRSYiIiJJSN2yI4RAUVER1q5di02bNiEnJ0fz/bBhw9CxY0eUlpZ6p1VWVuLw4cPIz883u7hEREQkIalbdmbOnIkXXngBr732Grp16+bth+N0OpGcnAyn04lp06Zhzpw5SEtLQ0pKCu6++27k5+eH/SRWrCJtHo/mdo+svf4DjQrsW1Yjb235jjyrV2dWOzOyTmaM/qwC/9t9/qMj+4+a3N4o3/7/7/mtHQWrj1Xi7QnK9sRDLKROdpYvXw4AuPLKKzXTV65cidtuuw0A8PTTTyMhIQETJkxAc3MzRo8ejd///vcml5SIiIhkZatxdowS7nP6egjUGtHeGCF2yrrNaNnxv2q2S2ysxFgZL9DIsYHegRVLy47dyVQfmcpiNTvHQslxduyuvXFO7PxEgKf8gZ5I0Zuezfp2jrmHUS+SVCE2Zgr2ug7/21kewV41osJtq2CsqE+w2KsW21gYPQigDJjsEBERkdKk7rOjmlDZc7CrwvZ+ZyXfqyPP1Wu4TfV60GPZssY2EsFiHesVVbSxieerZv/b055poUb2DSdWdr4NGevt+Fj3p1DnVr3WYWeBXrEB6LevyRJXtuwQERGR0pjsEBERkdJ4G8tEwd7IK0szX6TCecWAEc3Dvrdn7Bo7vYXTVG+WeN4m/rds9DoO7BxT/1vdvtMi+b2R7BzfWIW6xaoStuwQERGR0tiy48fIjmqqZ9Bm1ccOcbNzh9JA4rkDZyT8Hyow8yEDO2wj2ctnNdXOGzJhyw4REREpjckOERERKY23sfxEMh5EsHFM2AQpj/a2pZ5N//7jDkXzO1nJXr5oqXQM263MdtjvAXPLaYd4REqW7cyWHSIiIlIaW3YCCDcLjWWE2ViXYcayZcnIY9HeCxX1rF+0y7IyxoFaNuy+zSMRT3WVrfOrLOVoT7it/Hapj0ckZY7lPCFLXNiyQ0REREpjskNERERK420sC8j2ckwzbvFYTaW66IlxiR9GbWs73sLRm9X1990G4W4Pq0axjvT2WaB5o9nn2LJDRERESmOyQ0REREpjsmMx317ugXq8BxsHRE/tNQeaUQa91+H7AkbSVzQxdTgchm1juwmn3Haqm//LjY1gp3hYRban7YKJtHx6PTHKZIeIiIiUxmTHYr4ZqqydhM0og2fkat8WgFiu5sx8AWN7VLsqDacl0L/OQgjdt4UM2zYaencelUl7o5XHulz/ZfieK/Q4b9j1WI32+JKlvr7nft9tqed5g8kOERERKY3JDhERESmNyU4ckKWp0iPUyxd9my3NaMqXoQO4aiJpepZt3wyHHcvsz4o6hNuROVRndv/9yvdcocd5Ix6PVaOFs6/5nvuNuOUNMNkhIiIixXEE5SCiedxN1pFErRr9MphIXqwX7fqMGEU0VrHWSUV6xCHcK0e9qLDtrK5DqPVbXTYZ2Okc0V5ZZakHW3aIiIhIaUx2iIiISGm8jRWEf9ObCp0S9WBWk2SsnQ3NKmckzc0yjf2jmmAxtdPtADtgPMmfXfYHtuwQERGR0pjsEBERkdKY7AQRaLh7oljY6VaoncrKY9M8jDXZFZMdIiIiUhqTHR34vrQsHkXaChDO/MHmka3FIdxRYf3nlV2gF7PaUThjY8nC7rG2g2AvEg30nZXsdK7wJ+t+zGSHiIiIlMZkh4iIiJTGZCeISMbZ8cwrY9Nde/QocyRNrrG+xkHm5l2zXz1h9LKMfCmfWex0a9HusbaDYC8SDfSdlfT+W2Lm3yZZ92MmO0RERKQ0jqAcJiNfKmnlqKRmrzfal3rGugwzmLkd+WLLtgLFX5W6UfSieamz1fQun+z1NQNbdoiIiEhpTHaIiIhIabZKdhYvXgyHw4FZs2Z5p504cQIzZ85Ejx490LVrV0yYMAG1tbW6rTOWMWHCFWkTo4wdoY0sk29H2VAvfIxmup7ltrKpOFA9jNgmRm1nPcbmiOU2stkiWaeMx7uR9K5ve+ePcNdn5HZQbRsbOX5RtMuzTbKzY8cO/OEPf8APf/hDzfTZs2fj9ddfxyuvvIItW7bgyJEjuOGGGywqJREREcnGFslOU1MTCgsL8cc//hHdu3f3Tne73fjzn/+Mp556Cj/+8Y8xbNgwrFy5Eu+//z4++OAD08oX66PnkVzVmt2Z2eorjnDX7z+ScXsxVa3DXqD66FFHs7Z/oKtuM9dtxXqj2bftJppYhlNfPUdYD9ba438eMXI7RNpiHS6rzt9WxKo9tkh2Zs6cibFjx6KgoEAzvaKiAi0tLZrpAwYMQHZ2NsrKyoIur7m5GY2NjZoPERERqUn6R8/XrFmDXbt2YceOHW2+q6mpQadOnZCamqqZ7nK5UFNTE3SZJSUleOihh/QuKhEREUlI6pad6upq3HvvvXj++efRuXNn3ZZbXFwMt9vt/VRXVwed14zRkSMZcVLWcXGMKlc0yw2nQ3Msy/cIdqvM6lt/egjWdG/m/mfVbTgz6ijrKLPRCjUKtxFiGWE93HmsHEFcr1tnMuxjMpQBkDzZqaioQF1dHYYOHYrExEQkJiZiy5YtWLp0KRITE+FyuXDy5Ek0NDRofldbW4uMjIygy01KSkJKSormQ0RERGqS+jbWqFGj8PHHH2umTZ06FQMGDMD8+fORlZWFjh07orS0FBMmTAAAVFZW4vDhw8jPz7eiyERERCQZqZOdbt26YdCgQZppXbp0QY8ePbzTp02bhjlz5iAtLQ0pKSm4++67kZ+fj0svvVTXshj5ughZWPnaCj2YXf5YmtJjKasZ9bTzfuAr2JM2qtRPFirE04ynrsLl/3SpDGWyO6mTnXA8/fTTSEhIwIQJE9Dc3IzRo0fj97//vdXFIiIiIkk4BFNGNDY2wul0wu12a/rvRJpRy5yBy3TVYgbPtrBym/iuu72OsvGyXexC5mOZ4ofZHb/tKNjfb39Sd1AmIiIiihWTHSIiIlKa7fvsGEmmpsJYm9Vlqku0IomBZz4r6+27bhk7HMpSDr2FU6/25lExLmQ/3A/1w5YdIiIiUhqTHZtghq9ODGR5Qad/52kVRn4G4O2Y3t48FDlV9hHZMc76Y7JDRERESmOyQ0REREpjsqMj/6bxcJsi/edjE6bxMbBLjD0vG/Uvr/+tmlD1CfeWjkq3duxWl2DbKNL91Oj92m5xtSu94hzsZcXxiMkOERERKY3JDhERESmNyU4Yom1KjnRMmGD/jkeqvugy2G2pYIQQ3o/vMjzf+c4XahkUGbOb/mN5qWws85Pa/M8dHvF4a4vJDhERESmNyU4Y4v3qip2F9ROopSaQUDGRcf+KtjN+JL+NVCzLlTHG8S6ezhPRCPeBBUD//dsOfyOY7BAREZHSmOwQERGR0pjsxJFoXwugamdho7V3yybaW1UyNudH2xk/kt9GStX9Kl7F8/YM55gP94GFcJcXCTv8jWCyQ0REREpjsqOjWEaxNYOKI+WaSY8WMT2uvmTZfjLs0+GwSzlJrm0lU1liPeYDjcAeb5jsEBERkdKY7BAREZHSmOxEgON2xDezt6Hs+4yR5dPzFoLscaT/kmlbyVSWWNmpLkbdPmSyQ0REREpjskNERERKY7JjoGiH0JfpKQAiK9ip2Z2I9GPUsc9kh4iIiJTGZCcCRr0Q1H8+XtVSOBwOB1sBiYjCwGSHiIiIlMZkh4iIiJTGZEdHvP10hiq3VmSvhxBCuX1O9phTcNx2JDMmO0RERKQ0Jjuku2CtDe1d+fl3uLX6SlG1VpNwxRp3jjQen6Lddp7jPpb9xupzBZ0h83ZgskNERERKY7JDRERESku0ugAUP8Jt5va/lcVbG+ZivMkK4ex3oW6TBPuO+7M59LyFZcR5ny07REREpDS27JB0eCVmLc8VGrcDmSGS/cx3Xt+rf999Vvb91w6t1eGW0agOyUbEhy07REREpDQmO0RERKQ0JjskDbuMCGzkWBIyjFMR63awwzYkeUS7z/vuZ/77rMz7oMxl84jkJdZGnLeNOA8y2SEiIiKlMdkhIiIipUmf7Hz11Ve49dZb0aNHDyQnJ2Pw4MHYuXOn93shBBYtWoRevXohOTkZBQUFOHjwoIUlpmjFOmS8WYxshrZDE3d77LANSS56vKJEplfNxAvfOOtxO8vI7SZ1svPtt9/isssuQ8eOHfHmm2/ik08+wW9+8xt0797dO8+TTz6JpUuXYsWKFSgvL0eXLl0wevRonDhxwsKSExERkSwcQuJLyQULFuC9997Du+++G/B7IQQyMzMxd+5c3HfffQAAt9sNl8uFVatWYeLEiQF/19zcjObmZu+/GxsbkZWVBbfbjZSUFP0rQrYRanwJmcbvsMNYHbJhzKLjiRvjFxuZzh8qaWxshNPpbPfvt9QtO//85z+Rm5uLm266Cenp6RgyZAj++Mc/er+vqqpCTU0NCgoKvNOcTify8vJQVlYWdLklJSVwOp3eT1ZWlqH1ICIiIutInex8/vnnWL58Ofr164e33noLd911F+655x6sXr0aAFBTUwMAcLlcmt+5XC7vd4EUFxfD7XZ7P9XV1cZVgoiIiCwl9esiWltbkZubi8cffxwAMGTIEOzduxcrVqzAlClTol5uUlISkpKSovqt/7DkwYYvNxubmNvXXoza6xznOxS91fTY1jLtv2bx71BJ7fPEifEKLpxjh/GzltQtO7169cIFF1ygmTZw4EAcPnwYAJCRkQEAqK2t1cxTW1vr/Y6IiIjim9TJzmWXXYbKykrNtAMHDuDcc88FAOTk5CAjIwOlpaXe7xsbG1FeXo78/HxDyuT7eF0kmbrRLQK8amhfOFdeel2dydICFIp/XVTfh3xHe7XDiK9kH6ofOyqQ+jbW7NmzMWLECDz++OO4+eabsX37djz77LN49tlnAZw5wcyaNQuPPvoo+vXrh5ycHCxcuBCZmZkYP368tYUnIiIiKUid7FxyySVYu3YtiouL8fDDDyMnJwdLlixBYWGhd577778fx48fx4wZM9DQ0ICRI0diw4YN6Ny5s4UlJyIiIllIPc6OWcJ9Tp/OiIeOrMHIUndZykHxI5x9jvslmU2JcXaIiIiIYsVkh4iIiJTGZCdCwZ66sOvTGNG8fDOem6llqbss5QiXXY8PiuwcYbf9kuJHVMnOrl278PHHH3v//dprr2H8+PH4xS9+gZMnT+pWOCIiIqJYRZXs3HHHHThw4ACAM690mDhxIs466yy88soruP/++3UtoGyCXbnY9YrGiDFHIhVN65Lq7ByPQGX37GN2rpcszI6hUWMThctzfuC+ozajt29Uyc6BAwdw8cUXAwBeeeUVXH755XjhhRewatUq/OMf/9CzfEREREQxiSrZEUKgtbUVAPD2229jzJgxAICsrCx8/fXX+pWOiIiIKEZRJTu5ubl49NFH8dxzz2HLli0YO3YsAKCqqqrNG8jjCZtZoyPDrTSZmDVWiVH7a6iyczvHLt5iaPVtNDKH0ds3qmRnyZIl2LVrF4qKivDAAw+gb9++AIC///3vGDFihK4FJCIiIoqFriMonzhxAh06dEDHjh31WqQpohlBOdDVN0cPJbIPHq9E9mf4CMoNDQ3405/+hOLiYtTX1wMAPvnkE9TV1UW7SCIiIiLdRfUi0I8++gijRo1CamoqvvjiC0yfPh1paWl49dVXcfjwYfz1r3/Vu5xEREREUYmqZWfOnDmYOnUqDh48qHm7+JgxY7B161bdCiezcJq/2WGZSF6q3sLieYeoraiSnR07duCOO+5oM/2cc85BTU1NzIUiIiIi0ktUyU5SUhIaGxvbTD9w4ADOPvvsmAtFREREpJeokp3rrrsODz/8MFpaWgCcaTY9fPgw5s+fjwkTJuhaQDtTtZmcSAWq3u7heYeoraiSnd/85jdoampCeno6vv/+e1xxxRXo27cvunXrhscee0zvMhIRERFFLaqnsZxOJzZu3Iht27bho48+QlNTE4YOHYqCggK9y0dEIXCsmOgxbkTxI6pkx2PkyJEYOXKkXmUhIiIi0l3Yyc7SpUvDXug999wTVWGIiIiI9Bb26yJycnI0//7Pf/6D7777DqmpqQDOjKh81llnIT09HZ9//rnuBTWSXq+LIKL4JMP5IFiHa6vLRWQk3V8XUVVV5f089thjuPjii7F//37U19ejvr4e+/fvx9ChQ/HII4/oUgEiIiIiPUT1ItDzzjsPf//73zFkyBDN9IqKCtx4442oqqrSrYBmiKZlJxgZrvDMYkRd4yl+4WovJr5X9HrELtZtoOo2VLVeZglnPw53ZHpuB334twbaMa6Gvgj06NGjOHXqVJvpp0+fRm1tbTSLJCIiIjJEVMnOqFGjcMcdd2DXrl3eaRUVFbjrrrv4+DkRERFJJapk5y9/+QsyMjKQm5uLpKQkJCUlYfjw4XC5XPjTn/6kdxmlFKgzYLw1rxpR11iXqeKouO3FRAjh/ZixPqN/LytV62WWcPZjPZZD4fM9d5gZVyvO01GNs3P22WfjjTfewIEDB7B//344HA4MGDAA/fv317t8RERERDGJaVDB/v37o1+/fgDUvKIORQjRpiWHVxzW4zagWMRb6yyRFaw4xqK6jQUAf/3rXzF48GAkJycjOTkZP/zhD/Hcc8/pWTYiIiKimEXVsvPUU09h4cKFKCoqwmWXXQYA2LZtG+688058/fXXmD17tq6FJCIiIopWVOPs5OTk4KGHHsLkyZM101evXo0HH3wwLsfZ8dzGYxM4Eakmktt7dr8VaGX5Q63bbnH1L6+e5fddluHj7IwYMaLN9BEjRuDo0aPRLJKIiIjIEFElO3379sXLL7/cZvpLL73k7bBMREREJIOo+uw89NBD+OlPf4qtW7d6++y89957KC0tDZgExQM7NS8SEUUikvOb3c+FVpY/1LrtFlf/8upZ/miWFVXLzoQJE1BeXo4ePXpg3bp1WLduHXr27Int27fj+uuvj2aRRERERIaIqoOyavR8ESipy+gOgr7Ll7EzooxlilfcFu1jjOJDuH+/I7qNlZCQ0O7ggQ6HI+BLQomIiIisEFGys3bt2qDflZWVYenSpWhtbY25UERERER6iSjZ+clPftJmWmVlJRYsWIDXX38dhYWFePjhh3UrnOzYTBpfzLqFZfS6oiVjmeIVt0X74j1Gwf4+Wf13y6r1R/26iCNHjmD69OkYPHgwTp06hT179mD16tU499xz9SwfERERUUwiTnbcbjfmz5+Pvn37Yt++fSgtLcXrr7+OQYMG6V6406dPY+HChcjJyUFycjLOO+88PPLII22ugBctWoRevXohOTkZBQUFOHjwoO5lkV28vYhVNfF+FUpE+gp2TrH6XGPV+iNKdp588kn84Ac/wPr16/Hiiy/i/fffx49+9COjyoYnnngCy5cvx+9+9zvs378fTzzxBJ588kk888wzmjItXboUK1asQHl5Obp06YLRo0fjxIkThpWLiIiI7COiR88TEhK8rScdOnQIOt+rr76qS+H+53/+By6XC3/+85+90yZMmIDk5GT87W9/gxACmZmZmDt3Lu677z4AZ1qeXC4XVq1ahYkTJ4a1nmgfPbf63qcvmcpCRERkBkMePZ88ebKpt0tGjBiBZ599FgcOHED//v3x4YcfYtu2bXjqqacAAFVVVaipqUFBQYH3N06nE3l5eSgrKwua7DQ3N6O5udn778bGxqjKF2pMFLOTD6tfXBdOffWISawvJPR/YSuTxMjEU7z4cl8C4mufN4Is8Yso2Vm1apVBxQhswYIFaGxsxIABA9ChQwecPn0ajz32GAoLCwEANTU1AACXy6X5ncvl8n4XSElJCR566CHjCk5ERETSiPppLDO8/PLLeP755/HCCy9g165dWL16NX79619j9erVMS23uLgYbrfb+6murtapxERERCSbqF4EapZ58+ZhwYIF3ttRgwcPxqFDh1BSUoIpU6YgIyMDAFBbW4tevXp5f1dbW4uLL7446HKTkpKQlJRkaNllaLYzg6ee4dRXj5gEW0agptJA83puuelZJtX5x9aIZmkZmrrtMNYRRS/afYz7gRqkbtn57rvvkJCgLWKHDh28ozTn5OQgIyMDpaWl3u8bGxtRXl6O/Px8U8tKREREcpK6ZWfcuHF47LHHkJ2djQsvvBC7d+/GU089hdtvvx3AmUx91qxZePTRR9GvXz/k5ORg4cKFyMzMxPjx460tfByR4ao8kpYHI1opVG4tMqO1Q4aYyTjaLOlH5u0oU2d4vfd5GeoESJ7sPPPMM1i4cCF+/vOfo66uDpmZmbjjjjuwaNEi7zz3338/jh8/jhkzZqChoQEjR47Ehg0b0LlzZwtLTkRERLKIaJwdVUU7zo5HvF/9yVb/WB9Pj3adHjLFgmIj275NalK5Zcdo4f79lrrPjl3Yaccwgmz1j6Q8epVdCOH9mIGvBzGHbPs2Gc+KY8vMc4dHsHqqus8z2SEiIiKlMdkxiJFXBypc1Udah/bmjzYmesTSqitB1aiwX+uJ8bCGlaPRm0nFc0goTHaIiIhIaUx2iIiISGlMdgwSb02EkYo0PjLHU+ay2QnjqOU/HpTnQ2pSdf+XZZ9lskNERERKY7JDRERESpN6BGW7MWswJlWbO2MRbUwYS7ID7qdkV7Lsu2zZISIiIqUx2bEpWTp9UfzgPkdEdsVkh4iIiJTGZIeIiIiUxmTHpmTp9BUPePvmjHjd57j9ieyPyQ4REREpjcmOgcy+IuQVqDHitUWDzuD2J7I/JjtERESkNCY7REREpDQmOwbw3E4yu/k7nPXxVpfxPDEOFGs9XubIbUhEFBkmO0RERKQ0JjsGkLFDoyytAbKUw0ie7R9sP/BMj4dYkH2EapEksjsmO0RERKQ0JjtERESkNCY7caK9Wytml8MosjfB+9Y/2lhYvQ19yR5vCp8s5wgiIzDZISIiIqUx2SEiIiKlMdkhpbAJ3lyMNxHZAZMdIiIiUhqTHR0FusoNNGKu73gWenfw9F2eVZ1Hg40crOfy9FguRSeeY+45ZqM9dmWKnQxlkaEMRlC1XoB968Zkh4iIiJTGZIeIiIiUxmTHYIFubfmOZ6F3B08hRNgvIjWqOTJUnX3XHe6tgFD1YAfZ2ETzioB4i7lvbDzHbLTHrtWx86+L1UKVwYjb/GZwOBxSxFZvnu1h17ox2SEiIiKlMdkxULgtLHoLd31WZuixXB2Hgy81DI/Mo+bKsu1kjE207FSXcM8PZu4nsbZE25mR52szMNkhIiIipTHZISIiIqUx2TGQnZv8whHrmCOhlhsrmW/PRCqceIQa28js20F6rU+mbSfDLTUZyhApo84RvszcT2TaJ/Vix/0qGkx2iIiISGlMdoiIiEhpiVYXgOzLqCZdFZuKYxFOPNobz4liZ/UYI3bcjnYssxms3pd8yVAOM+LBlh0iIiJSmqXJztatWzFu3DhkZmbC4XBg3bp1mu+FEFi0aBF69eqF5ORkFBQU4ODBg5p56uvrUVhYiJSUFKSmpmLatGloamoysRahGd35yw4vyTR7JNRI1tXevJF2DpYl5kbRc5wRO42Qa/cxRgKxU/xV47svqb4N9D5nRMvSZOf48eO46KKLsGzZsoDfP/nkk1i6dClWrFiB8vJydOnSBaNHj8aJEye88xQWFmLfvn3YuHEj1q9fj61bt2LGjBlmVYGIiIgk5xCSXK44HA6sXbsW48ePB3Am08vMzMTcuXNx3333AQDcbjdcLhdWrVqFiRMnYv/+/bjggguwY8cO5ObmAgA2bNiAMWPG4Msvv0RmZmZY625sbITT6YTb7UZKSoru9TIyxKGWL8t9YbNHko6k3u3NG86yfOeRJeZG0bN+Vo0wTmcw/nLgOSO2ZYX791vaPjtVVVWoqalBQUGBd5rT6UReXh7KysoAAGVlZUhNTfUmOgBQUFCAhIQElJeXB112c3MzGhsbNR+jhEpE9GhGDvaCzXgWyYHV3ryRdg5W+aQFaF80q8ey7BavWOtu5fEZaMwbPbdntGWKd9EcA3aKm57HeCzLkjbZqampAQC4XC7NdJfL5f2upqYG6enpmu8TExORlpbmnSeQkpISOJ1O7ycrK0vn0hMREZEspE12jFRcXAy32+39VFdXm14GPV+E6Zvl+y7T6qs2DztewXvIED/ZxLot7RzTWDuWGnUshNsJ1P/jmW6VcG4R241qo0bLsg1iLYe0yU5GRgYAoLa2VjO9trbW+11GRgbq6uo03586dQr19fXeeQJJSkpCSkqK5kNERERqkjbZycnJQUZGBkpLS73TGhsbUV5ejvz8fABAfn4+GhoaUFFR4Z1n06ZNaG1tRV5enullJiIiIvlYOoJyU1MTPvvsM++/q6qqsGfPHqSlpSE7OxuzZs3Co48+in79+iEnJwcLFy5EZmam94mtgQMH4pprrsH06dOxYsUKtLS0oKioCBMnTgz7SSw703P8AgpM9aesPPVStX5GsjpestxeMJLVMY6WXcvtz//8YOfzhaXJzs6dO3HVVVd5/z1nzhwAwJQpU7Bq1Srcf//9OH78OGbMmIGGhgaMHDkSGzZsQOfOnb2/ef7551FUVIRRo0YhISEBEyZMwNKlS02vCxEREclJmnF2rGTkODtW8b/q42YmmdjxytCXDOXXowwca4fszvbj7BARERHpgckOERERKY3JjsGM7EQYatmyjKPRHjt0spRlVGq9ymB1XTzrlyWu0ZDhmNLjZZJ2HgMrEhwlOrrjTaZjNNayMNkhIiIipTHZISIiIqUx2TGYkU3Ekb6kUjYyPNFiJ3rFSpaYx8stFDNEEkdZbkuYyYr9zDfOssQ80jjIdIzGWhYmO0RERKQ0JjtkGVmuGNpjl3KGy+pOhzJdLcYju8ReltaQaPmONCxDzKMpg9XnCj0x2SEiIiKlMdkhIiIipTHZUZwMTZAyN4WGWy4ZmqH1Ekuzut7bUdb9oj12Lbcvq8eeae+8oMIxJ1sdIt3mstyC0wOTHSIiIlIakx2DBcqk9RpBtr3fy3L1GerKwOoyhnvVYnU59SxDoEdiI2nhirUc4VzVyy6WljE9H0mOZPv5r9vKK3ZPi4EqrQa+It23zToOohnqI9i5wopjN9Z1MtkhIiIipTHZISIiIqUlWl0A1QVqNtTrBZ3t/d6qJuJAzaXBymKXZmwZyqlHGfy3TTT7opH7rd1G1Y60vOEeF5Euz+6jqaskmlGKzRDNLaxQ5wq9jtVwlxPrutiyQ0REREpjskNERERKY7JDhrLzEzcq4q0M/XEfJxWpdq5gskNERERKY7IjAZWvDGW+OlA57maK5ziqOlaMncTz/mclvfZ7s44fJjtERESkNCY7REREpDQmOxJQrRncLvWxSzn1ZESTv55xtOM24W2UyOgdLzvuM7KK5FUmdtvvmewQERGR0jiCMhnGbqPhyizcWHqutuwadzuW305llQHjdYaM58dAIyaHM2+49KxzpC1LbNkhIiIipTHZISIiIqUx2bEpO3QOk62JNlZWxjzcWLY37oue28Sozs6q7Td24nA4bHFuUYER+7ns207vhxmEEHC73WHNz2SHiIiIlMZkh4iIiJTGZEcSkTY/sqnffIy5FuOhHt5GtDduu+CY7BAREZHSmOxIghk5ERFZRfbOzbFiskNERERKY7JDRERESmOyIxnVmxJJDUbupzwGiMxnt64UnvOE0+kMa34mO0RERKQ0JjuSsVt2TfGJ+ykRWSnScxCTHSIiIlIakx0iIiJSmqXJztatWzFu3DhkZmbC4XBg3bp13u9aWlowf/58DB48GF26dEFmZiYmT56MI0eOaJZRX1+PwsJCpKSkIDU1FdOmTUNTU5PJNdGPXTpn2qWc8aa9FznKvt1kLx+RyiI5/mQ5Vm3xItDjx4/joosuwrJly9p8991332HXrl1YuHAhdu3ahVdffRWVlZW47rrrNPMVFhZi37592LhxI9avX4+tW7dixowZZlWBiIiIJOcQkvQ0dDgcWLt2LcaPHx90nh07dmD48OE4dOgQsrOzsX//flxwwQXYsWMHcnNzAQAbNmzAmDFj8OWXXyIzMzPgcpqbm9Hc3Oz9d2NjI7KysuB2u5GSkqJrvSh6DoeDHWFtyHPFx21nDMb3DN848FwRvxobG+F0Otv9+22rPjtutxsOhwOpqakAgLKyMqSmpnoTHQAoKChAQkICysvLgy6npKQETqfT+8nKyjK66ERERGQR2yQ7J06cwPz583HLLbd4s7eamhqkp6dr5ktMTERaWhpqamqCLqu4uBhut9v7qa6uNrTsREREZJ1EqwsQjpaWFtx8880QQmD58uUxLy8pKQlJSUk6lIyMpGKztG9ze7RN77I32ctcNhUwvmf4xkH1mMh+zNuB9MmOJ9E5dOgQNm3apLknl5GRgbq6Os38p06dQn19PTIyMswuKhEREUlI6ttYnkTn4MGDePvtt9GjRw/N9/n5+WhoaEBFRYV32qZNm9Da2oq8vDyzi0tEREQSsrRlp6mpCZ999pn331VVVdizZw/S0tLQq1cv3Hjjjdi1axfWr1+P06dPe/vhpKWloVOnThg4cCCuueYaTJ8+HStWrEBLSwuKioowceLEoE9iEVkp3Kb3UM3Wsjdnhyo7m+NjxxjGn3C3t//YN9xP/svSR883b96Mq666qs30KVOm4MEHH0ROTk7A373zzju48sorAZwZVLCoqAivv/46EhISMGHCBCxduhRdu3YNuxzhPrpGZBY7/0FjsmMsxpCCicdkJ9y/39KMs2Mluyc7PPkRxTeeA8gosu9bSo6zQ0RERBQpJjtERESkNCY7CpC5iVEVMrz0Ts8yyFAf0ofstxnile8xJsPx1t5LgoNRZd9iskNERERKY7KjEBmuHoDoryBkZtXVjW8c9SyDKldrFN62NPt4VO34j4ZsIzwLIaQoh1WY7BAREZHSmOwQERGR0qR/NxaFr70ReSP9jRHliHeRdiYNNC87pFKk2ttfQt12imZf4/5pHp4PwsOWHSIiIlIakx0iIiJSGpOdOOHfzBnvPfOJqC3POcH/v2SeSJ9k4zYKD5MdIiIiUho7KMcRXgGYK1DHQT22Abcj6c1/TBiOk2OdcI9vdkyODFt2iIiISGlMdoiIiEhpTHaIDMImZrIrPsAQnVC3//S4NWjU62PiAZMdIiIiUhqTnTjFDojy4zYispdQrS18OMFaTHaIiIhIaUx2iIiISGlMduIUm0Oj53A4DL3F5Fm2nbcRb8GpgdtRf57zB2NrLiY7REREpDQmO0RERKQ0JjsUlXhugjV6DBI7377yiKUO8bxvySba7cjbNMF5zh8qHOdW8uxfTqczrPmZ7BAREZHSmOxQVHhVIi8rrqj17HTJfcv+uA2pPWZ31GayQ0REREpjskNERERKY7JDZCArbilZcQvBs0491s2OrWrgrSzyCHRM69FRO5JzBZMdIiIiUhqTHSIDqXp1G+xKjYgoGL1bbSM55zDZISIiIqUx2SEiIiKlMdkhoohxBGkiClegBxhivaXlWZbb7Q5rfiY7REREpLREqwtAZEcOh0PXFgjfqxy7t2zoHRsi0grWKiKE8B5/sh+HZpeNLTtERESkNCY7REREpDTexiIpyN7k6i+SsoZTNzvVvT0q1YVIT5Gc50LNG2oZeo5mrhK27BAREZHSLE12tm7dinHjxiEzMxMOhwPr1q0LOu+dd94Jh8OBJUuWaKbX19ejsLAQKSkpSE1NxbRp09DU1GRswYmIiMg2LE12jh8/josuugjLli0LOd/atWvxwQcfIDMzs813hYWF2LdvHzZu3Ij169dj69atmDFjhlFFJoOo3OSqct30wBd/UryI5FzA84a+LO2zc+211+Laa68NOc9XX32Fu+++G2+99RbGjh2r+W7//v3YsGEDduzYgdzcXADAM888gzFjxuDXv/51wOSIiIiI4ovUfXZaW1sxadIkzJs3DxdeeGGb78vKypCamupNdACgoKAACQkJKC8vD7rc5uZmNDY2aj5ERmCrRft4BUtEkfKcW51OZ1jzS53sPPHEE0hMTMQ999wT8Puamhqkp6drpiUmJiItLQ01NTVBl1tSUgKn0+n9ZGVl6VpuIiIikoe0yU5FRQV++9vfYtWqVbpfHRcXF8Ptdns/1dXVui6fiIiI5CFtsvPuu++irq4O2dnZSExMRGJiIg4dOoS5c+eiT58+AICMjAzU1dVpfnfq1CnU19cjIyMj6LKTkpKQkpKi+RAZwYpbNFbeOuNtOyIyQ6QvApV2UMFJkyahoKBAM2306NGYNGkSpk6dCgDIz89HQ0MDKioqMGzYMADApk2b0Nrairy8PNPLTERERPKxNNlpamrCZ5995v13VVUV9uzZg7S0NGRnZ6NHjx6a+Tt27IiMjAycf/75AICBAwfimmuuwfTp07FixQq0tLSgqKgIEydO5JNYFLes7PDLzsZEZIZIR9239DbWzp07MWTIEAwZMgQAMGfOHAwZMgSLFi0KexnPP/88BgwYgFGjRmHMmDEYOXIknn32WaOKTERERDbjELwUg9vtRmpqKqqrq9l/h4iISHJOpxNutxuNjY3IyspCQ0NDyMfQpe2zY6ZvvvkGAPgIOhERkU34JjfHjh1jstOetLQ0AMDhw4fDHqBIZZ5MmS1dZzAeWoyHFuOhxXhoMR5aesdDCIFjx46120+XyQ6AhIQzXZecTid3Rh98LF+L8dBiPLQYDy3GQ4vx0NIzHuE0Ukg7zg4RERGRHpjsEBERkdKY7ODMiMq//OUvkZSUZHVRpMB4aDEeWoyHFuOhxXhoMR5aVsWDj54TERGR0tiyQ0REREpjskNERERKY7JDRERESmOyQ0REREpjskNEFMCVV16JWbNmWV0MItIBkx0iisltt92G8ePHt5m+efNmOBwONDQ0mF4mIiJfTHaISFknT560ughEJAEmO0RkqOPHjyMlJQV///vfNdPXrVuHLl264NixY/jiiy/gcDiwZs0ajBgxAp07d8agQYOwZcsWzW/27t2La6+9Fl27doXL5cKkSZPw9ddfe7+/8sorUVRUhFmzZqFnz54YPXp0WL87fvw4Jk+ejK5du6JXr174zW9+06YeR48exdixY5GcnIycnBy88MIL6NOnD5YsWeKdp6GhAT/72c9w9tlnIyUlBT/+8Y/x4Ycfer//8MMPcdVVV6Fbt25ISUnBsGHDsHPnzpjiS0TtY7JDRIbq0qULJk6ciJUrV2qmr1y5EjfeeCO6devmnTZv3jzMnTsXu3fvRn5+PsaNG4dvvvkGwJlE4sc//jGGDBmCnTt3YsOGDaitrcXNN9+sWe7q1avRqVMnvPfee1ixYkVYv5s3bx62bNmC1157Df/617+wefNm7Nq1S7PcyZMn48iRI9i8eTP+8Y9/4Nlnn0VdXZ1mnptuugl1dXV48803UVFRgaFDh2LUqFGor68HABQWFqJ3797YsWMHKioqsGDBAnTs2DH2IBNRaIKIKAZTpkwRHTp0EF26dNF8OnfuLACIb7/9VpSXl4sOHTqII0eOCCGEqK2tFYmJiWLz5s1CCCGqqqoEALF48WLvcltaWkTv3r3FE088IYQQ4pFHHhFXX321Zt3V1dUCgKisrBRCCHHFFVeIIUOGaOZp73fHjh0TnTp1Ei+//LL3+2+++UYkJyeLe++9VwghxP79+wUAsWPHDu88Bw8eFADE008/LYQQ4t133xUpKSnixIkTmnWdd9554g9/+IMQQohu3bqJVatWhR9cItJFopWJFhGp4aqrrsLy5cs108rLy3HrrbcCAIYPH44LL7wQq1evxoIFC/C3v/0N5557Li6//HLNb/Lz873/n5iYiNzcXOzfvx/AmVtA77zzDrp27dpm/f/+97/Rv39/AMCwYcM037X3u++//x4nT55EXl6ed3paWhrOP/98778rKyuRmJiIoUOHeqf17dsX3bt316ynqakJPXr00Kzj+++/x7///W8AwJw5c/Czn/0Mzz33HAoKCnDTTTfhvPPOa1MuItIXkx0iilmXLl3Qt29fzbQvv/xS8++f/exnWLZsGRYsWICVK1di6tSpcDgcYa+jqakJ48aNwxNPPNHmu169emnKEsnvPvvss7DL0F75evXqhc2bN7f5LjU1FQDw4IMP4n//93/xf//3f3jzzTfxy1/+EmvWrMH111+vSxmIKDD22SEiU9x66604dOgQli5dik8++QRTpkxpM88HH3zg/f9Tp06hoqICAwcOBAAMHToU+/btQ58+fdC3b1/Nxz/B8dXe78477zx07NgR5eXl3t98++23OHDggPff559/Pk6dOoXdu3d7p3322Wf49ttvNeupqalBYmJim/X07NnTO1///v0xe/Zs/Otf/8INN9zQpi8TEemPyQ4RmaJ79+644YYbMG/ePFx99dXo3bt3m3mWLVuGtWvX4tNPP8XMmTPx7bff4vbbbwcAzJw5E/X19bjllluwY8cO/Pvf/8Zbb72FqVOn4vTp00HX297vunbtimnTpmHevHnYtGkT9u7di9tuuw0JCf89PQ4YMAAFBQWYMWMGtm/fjt27d2PGjBlITk72tk4VFBQgPz8f48ePx7/+9S988cUXeP/99/HAAw9g586d+P7771FUVITNmzfj0KFDeO+997Bjxw5vMkdExmGyQ0SmmTZtGk6ePOlNYPwtXrwYixcvxkUXXYRt27bhn//8p7dVJDMzE++99x5Onz6Nq6++GoMHD8asWbOQmpqqSUz8hfO7X/3qV/jRj36EcePGoaCgACNHjmzT9+evf/0rXC4XLr/8clx//fWYPn06unXrhs6dOwMAHA4H3njjDVx++eWYOnUq+vfvj4kTJ+LQoUNwuVzo0KEDvvnmG0yePBn9+/fHzTffjGuvvRYPPfSQHqElohAcQghhdSGIKD4899xzmD17No4cOYJOnTp5p3/xxRfIycnB7t27cfHFF1tXwAh8+eWXyMrKwttvv41Ro0ZZXRwiCoEdlInIcN999x2OHj2KxYsX44477tAkOnaxadMmNDU1YfDgwTh69Cjuv/9+9OnTp80TZUQkH97GIiLDPfnkkxgwYAAyMjJQXFxsdXGi0tLSgl/84he48MILcf311+Pss8/G5s2bOSggkQ3wNhYREREpjS07REREpDQmO0RERKQ0JjtERESkNCY7REREpDQmO0RERKQ0JjtERESkNCY7REREpDQmO0RERKS0/wd2v5G8EMy9vAAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -563,7 +550,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -578,7 +564,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 19, @@ -587,7 +573,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -602,7 +588,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -610,7 +595,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -627,8 +611,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "The density of the hypergraph is: 1.3578021599921747e-40\n", - "The assortativity of the hypergraph is: 0.19143485034933905\n" + "The density of the hypergraph is: 1.3084764540479412e-40\n", + "The assortativity of the hypergraph is: 0.227186574526993\n" ] } ], @@ -640,7 +624,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -656,7 +639,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "{0: 0.6340626251831323, 1: 0.7746827669192289, 2: 0.7303976725029351, 3: 0.5904956595432785, 4: 0.6916793161487033, 5: 0.7890813515187918, 6: 0.7620065639811913, 7: 0.6115739556010492, 8: 0.5616991341991342, 9: 0.6084595266651016, 10: 0.590776916827337, 11: 0.7506220672799198, 12: 0.5599215719345589, 13: 0.7245633937457829, 14: 0.7823942966055315, 15: 0.5592097214379823, 16: 0.5044973544973546, 17: 0.5726657329598505, 18: 0.781768359614683, 19: 0.590776916827337, 20: 0.7735020373348236, 21: 0.7704941158585658, 22: 0.7670244117302955, 23: 0.7696153486562693, 24: 0.7654444277798095, 25: 0.7303976725029351, 26: 0.5863413253413253, 27: 0.7391417547320522, 28: 0.7593273953610492, 29: 0.5599215719345589, 30: 0.6916793161487033, 31: 0.7579629172635124, 32: 0.5768117684784352, 33: 0.7661040144835769, 34: 0.5592097214379823, 35: 0.5402182468388002, 36: 0.6566465365016084, 37: 0.5998460265093329, 38: 0.584939853968194, 39: 0.7556100624072973, 40: 0.7735020373348236, 41: 0.57782215007215, 42: 0.5402182468388002, 43: 0.7756995099886517, 44: 0.5592097214379823, 45: 0.57782215007215, 46: 0.7180589326815734, 47: 0.5748706452277881, 48: 0.5829534258844603, 49: 0.5592097214379823, 50: 0.5726657329598505, 51: 0.5598214285714286, 52: 0.5587388801674515, 53: 0.5794784580498866, 54: 0.5658175770308121, 55: 0.6084595266651016, 56: 0.7689359323323871, 57: 0.7180589326815734, 58: 0.5616991341991342, 59: 0.5998460265093329, 60: 0.5948058930316994, 61: 0.6470017776835955, 62: 0.5587388801674515, 63: 0.5592097214379823, 64: 0.57782215007215, 65: 0.5976038731991112, 66: 0.24829931972789113, 67: 0.5510461760461761, 68: 0.5044973544973546, 69: 0.2, 70: 0.5598214285714286, 71: 0.5863413253413253, 72: 0.7180589326815734, 73: 0.40608465608465605, 74: 0.5044973544973546, 75: 0.5998460265093329, 76: 0.0, 77: 0.5726657329598505, 78: 0.5510461760461761, 79: 0.24829931972789113, 80: 0.5787440945335682, 81: 0.5863413253413253, 82: 0.5861775380491958, 83: 0.5510461760461761, 84: 0.5768117684784352, 85: 0.5658175770308121, 86: 0.16666666666666666, 87: 0.5044973544973546, 88: 0.24829931972789113, 89: 0.40608465608465605, 90: 0.5768117684784352, 91: 0.5599215719345589, 92: 0.2, 93: 0.3333333333333333, 94: 0.6916793161487033, 95: 0.5810558316327546, 96: 0.5599215719345589, 97: 0.7458813514961049, 98: 0.574763297131718, 99: 0.5810558316327546, 100: 0.7021011385129026, 101: 0.6084595266651016, 102: 0.7095684795345422, 103: 0.6048427319734138, 104: 0.7556100624072973, 105: 0.5976038731991112, 106: 0.5402182468388002, 107: 0.6340626251831323, 108: 0.7596004635846704, 109: 0.5748706452277881, 110: 0.5748706452277881, 111: 0.5976038731991112, 112: 0.5598214285714286, 113: 0.5948058930316994, 114: 0.5044973544973546, 115: 0.24829931972789113, 116: 0.3333333333333333, 117: 0.5510461760461761, 118: 0.28344671201814053, 119: 0.5598214285714286, 120: 0.6115739556010492, 121: 0.40608465608465605, 122: 0.5829534258844603, 123: 0.5748706452277881, 124: 0.5592097214379823, 125: 0.5598214285714286, 126: 0.6340626251831323, 127: 0.5598214285714286, 128: 0.24829931972789113, 129: 0.5521645021645023, 130: 0.24829931972789113, 131: 0.5616991341991342, 132: 0.5726657329598505, 133: 0.5768117684784352, 134: 0.5587388801674515, 135: 0.5598214285714286, 136: 0.24444444444444444, 137: 0.5853742270408937, 138: 0.40608465608465605, 139: 0.28344671201814053, 140: 0.16666666666666666, 141: 0.24444444444444444, 142: 0.24444444444444444}\n" + "{0: 0.7804612787100978, 1: 0.6780441301803274, 2: 0.7689183265963335, 3: 0.791038445681303, 4: 0.7856925737994167, 5: 0.6965494874182317, 6: 0.7072322879888286, 7: 0.7730900667477023, 8: 0.7118552061973111, 9: 0.7683540442301209, 10: 0.8031870323887131, 11: 0.76833559781224, 12: 0.7490487746981251, 13: 0.7755923252981957, 14: 0.6848194711637989, 15: 0.7573675775256802, 16: 0.4584199134199135, 17: 0.638446173924115, 18: 0.7017206124203775, 19: 0.8031870323887131, 20: 0.7009358405995354, 21: 0.738118399364662, 22: 0.7075910814158463, 23: 0.7223895333094579, 24: 0.739291988588228, 25: 0.7710850845455389, 26: 0.7821012321012321, 27: 0.768337509507563, 28: 0.7700134952824707, 29: 0.7490487746981251, 30: 0.7856925737994167, 31: 0.7659625084060587, 32: 0.7786708147819262, 33: 0.7038081247195713, 34: 0.7727459637785723, 35: 0.7573675775256802, 36: 0.7861972454329856, 37: 0.7797302518270263, 38: 0.7759247429139076, 39: 0.7659625084060587, 40: 0.7009358405995354, 41: 0.7757340067340067, 42: 0.7573675775256802, 43: 0.6975586879901238, 44: 0.7573675775256802, 45: 0.7757340067340067, 46: 0.7759756479670126, 47: 0.7288875146018, 48: 0.7812697583387238, 49: 0.7727459637785723, 50: 0.6644212904016823, 51: 0.5541149591149591, 52: 0.49949772449772456, 53: 0.49949772449772456, 54: 0.638446173924115, 55: 0.7683540442301209, 56: 0.7104077955538087, 57: 0.7725113110513565, 58: 0.7118552061973111, 59: 0.7887064044826144, 60: 0.7812697583387238, 61: 0.7804612787100978, 62: 0.42930819180819185, 63: 0.7727459637785723, 64: 0.7757340067340067, 65: 0.7866768592959072, 66: 0.4117462894248609, 67: 0.4727321920503739, 68: 0.4584199134199135, 69: 0.4258333333333334, 70: 0.5541149591149591, 71: 0.7821012321012321, 72: 0.7725113110513565, 73: 0.3619137806637807, 74: 0.4584199134199135, 75: 0.7887064044826144, 76: 0.0, 77: 0.638446173924115, 78: 0.4727321920503739, 79: 0.4798340548340549, 80: 0.782342244842245, 81: 0.7821012321012321, 82: 0.7894392381608293, 83: 0.4727321920503739, 84: 0.7786708147819262, 85: 0.638446173924115, 86: 0.0, 87: 0.4584199134199135, 88: 0.4798340548340549, 89: 0.3619137806637807, 90: 0.7786708147819262, 91: 0.7490487746981251, 92: 0.4258333333333334, 93: 0.0, 94: 0.7827884699639654, 95: 0.7680722410445265, 96: 0.7490487746981251, 97: 0.7690633411984246, 98: 0.6644212904016823, 99: 0.7680722410445265, 100: 0.7856925737994167, 101: 0.7683540442301209, 102: 0.7725113110513565, 103: 0.7894392381608293, 104: 0.7659625084060587, 105: 0.7866768592959072, 106: 0.7490487746981251, 107: 0.7752549928556385, 108: 0.7035118435926735, 109: 0.7288875146018, 110: 0.7288875146018, 111: 0.7866768592959072, 112: 0.5978351972101971, 113: 0.7812697583387238, 114: 0.4584199134199135, 115: 0.4117462894248609, 116: 0.0, 117: 0.4727321920503739, 118: 0.4798340548340549, 119: 0.5978351972101971, 120: 0.7730900667477023, 121: 0.3619137806637807, 122: 0.7730900667477023, 123: 0.7118552061973111, 124: 0.7573675775256802, 125: 0.5978351972101971, 126: 0.7752549928556385, 127: 0.5978351972101971, 128: 0.4117462894248609, 129: 0.502430145611964, 130: 0.4117462894248609, 131: 0.685872720521843, 132: 0.638446173924115, 133: 0.7821012321012321, 134: 0.49949772449772456, 135: 0.5978351972101971, 136: 0.40510101010101013, 137: 0.791038445681303, 138: 0.4117462894248609, 139: 0.40510101010101013, 140: 0.16666666666666666, 141: 0.40510101010101013, 142: 0.40510101010101013}\n" ] } ], @@ -666,7 +649,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -684,7 +666,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "[8, 58, 131]\n" + "[8, 58, 123]\n" ] } ], @@ -694,7 +676,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -717,8 +698,8 @@ "3 36 0.606272\n", "4 50 0.569712\n", ".. ... ...\n", - "138 9 0.535714\n", - "139 7 0.333333\n", + "138 8 0.535714\n", + "139 6 0.333333\n", "140 4 1.000000\n", "141 6 1.000000\n", "142 6 1.000000\n", @@ -733,7 +714,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -741,7 +721,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -753,9 +732,9 @@ ], "metadata": { "kernelspec": { - "display_name": "base", + "display_name": "venv_xgi", "language": "python", - "name": "python3" + "name": "venv_xgi" }, "language_info": { "codemirror_mode": { @@ -769,7 +748,19 @@ "pygments_lexer": "ipython3", "version": "3.9.13" }, - "orig_nbformat": 4 + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } }, "nbformat": 4, "nbformat_minor": 2 From 723d989997fcc2bd8ab49a30dcb9f9a3e7e997e0 Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Mon, 9 Oct 2023 18:46:42 +0200 Subject: [PATCH 17/26] reran notebooks --- tutorials/In Depth 1 - Drawing nodes.ipynb | 30 +++---- .../In Depth 2 - Drawing hyperedges.ipynb | 82 +++++++++---------- 2 files changed, 56 insertions(+), 56 deletions(-) diff --git a/tutorials/In Depth 1 - Drawing nodes.ipynb b/tutorials/In Depth 1 - Drawing nodes.ipynb index 51dc21801..05ccdddc2 100644 --- a/tutorials/In Depth 1 - Drawing nodes.ipynb +++ b/tutorials/In Depth 1 - Drawing nodes.ipynb @@ -56,9 +56,9 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ,\n", - " ))" + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 3, @@ -67,7 +67,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -324,7 +324,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 10, @@ -368,23 +368,23 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "id": "06cc1283", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 12, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -411,23 +411,23 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 12, "id": "823b1252", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 14, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -470,7 +470,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "id": "389fd7d7", "metadata": {}, "outputs": [ @@ -506,7 +506,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 14, "id": "ad1e2012", "metadata": {}, "outputs": [ diff --git a/tutorials/In Depth 2 - Drawing hyperedges.ipynb b/tutorials/In Depth 2 - Drawing hyperedges.ipynb index 8df2aab6a..951088569 100644 --- a/tutorials/In Depth 2 - Drawing hyperedges.ipynb +++ b/tutorials/In Depth 2 - Drawing hyperedges.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 1, "id": "b762703f", "metadata": {}, "outputs": [], @@ -38,7 +38,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "id": "0a032899", "metadata": {}, "outputs": [], @@ -51,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 3, "id": "444f90d3", "metadata": {}, "outputs": [ @@ -59,18 +59,18 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ,\n", - " ))" + " (,\n", + " ,\n", + " ))" ] }, - "execution_count": 6, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA7kElEQVR4nO3dfVBc550n+m/TtEQ3NLLsRJZfJFkvdASNbZDV7cY4JruDFWfkGmMbZ1KTtaOZrIzHiE1md2/dTWYmt2amMpOd2ntTa2k0Q0gyICdbiYmRPEWcu2ll9zI2puHIAsndtNy8SY0kBOgF6Ffol3P/UCBCQhLQp/ucPuf7qUpV4sCvf6o45svz/J7n0YmiKIKIiIg0K0fuBoiIiEheDANEREQaxzBARESkcQwDREREGscwQEREpHEMA0RERBrHMEBERKRxDANEREQaxzBARESkcQwDREREGscwQEREpHEMA0RERBrHMEBERKRxDANEREQaxzBARESkcQwDREREGscwQEREpHEMA0RERBrHMEBERKRxDANEREQaxzBARESkcQwDREREGscwQEREpHEMA0RERBrHMEBERKRxDANEREQaxzBARESkcQwDREREGscwQEREpHG5cjdARMogiiJ6e3shCAI8Hg8ikQiMRiOsVitsNhvKy8uh0+nkbpOI0kAniqIodxNEJJ9YLIampiYcOnQIXq8Xer0eFosFZrMZgUAAPp8PiUQCxcXFOHDgAPbv3w+DwSB320QkIW4TEGmY2+2Gw+FAQ0MDrFYrnE4nAoEA+vv70d3djf7+fgQCATidTlitVjQ0NMDhcMDtdsvdOhFJiCsDRBrV0dGBvXv3YsuWLWhpacHu3bvv+j2CIGDfvn3w+/1ob29HVVVVBjolonRjGCDSoPkVgYqKChw7dgz5+fnL/t5QKISamhq4XC50dXWhtLQ0jZ0SUSYwDBBpTCwWg8PhQDQaRU9Pz4qCwLxQKAS73Q6j0Yiuri7OEBBlOc4MEGlMU1MT+vr60NLSsqogAAD5+flobm5Gb28vmpqaJO6QiDKNKwNEGiKKIqxWK6xWK1pbW1OuV1tbC6/XC7fbzWOHRFmM9wwQaUhvby+8Xi/eeustSerV1dVhz5496OvrQ3l5ecr1eNcBkTwYBog0RBAE6PV6VFZWSlKvsrISer0egiCkFAbudtfB4cOHedcBURpxZoBIQzweDywWC4xGoyT1TCYTLBYLPB7PqmvwrgMi+TEMEGlIJBKB2WyWtGZBQQHC4fCqvrejo2PhZEN3dzdaW1tRXV19S1gxGo2orq5Ga2srXC4XotEoKioq0NHRIcUfgUjzGAaINMRoNCIQCEhac2ZmBquZQ3a73di7dy8qKirQ09OzrEuPAMBms6GnpwcOhwPPP/88VwiIJMDTBEQa0tjYiPr6egQCAUm2CsLhMMxmM5LJJLZs2QKHw7Hwr/Lycqxdu3bJ7+NdB0TKwgFCIg2x2WxIJBLo7OxEdXV1yvU6OzuRTCYBAOfOncO5c+fw85//HACwZs0alJeXw+Fw4Mknn4TD4cAjjzwCnU63cNdBd3d3yncdOBwONDU14c0330z5z0OkVVwZINKQdN0z8NFHH+HEiRNwuVwL/7p8+fItX79hwwY8+eST6OnpwdNPP41f/OIXkvXAuw6IVo9hgEhjDh8+jIaGBrhcLthstlXXEQQBDocDBw8evOW3clEUMTIysigc9Pb2Ih6PL3yN0+mUZHXC6XRiz549OHnypCR3HRBpEcMAkcZIvV/vcrmQm3v3HcdIJILe3l58//vfx9GjRyWdWygsLMThw4fx+uuvp1yPSIt4moBIYwwGA1paWuD3+1FTU4NQKLSi759/tdDv96O5uXlZQQC4fpLhqaeewgMPPKC4uw6ItI5hgEiDSktL0d7evrBVIAjCsr5PEATY7Xa4XC60t7ev6vlipd11QEQMA0Sa9cwzz+Ctgz/B3JwIh8OBl19+GcePH0ckEln0deFwGE6nE7W1tXA4HAtH+aqqqlb1uem46yAYDMJkMklak0hLGAaINKrfex4F5g34m+/+AH/8J38GQejFs88+C7PZjJ07i7F7tw07dxajsLAQe/bsgdfrxcGDB9HV1bWqFYF5VqsVPp/vltCxWuFwGD6fD1arVZJ6RFrEAUIiDRqfmMa/ftC/6K+JooizIz4MDXkxOjqC2dko1q7Nw6ZNW1H78u+juvoZSY7unTx5Ek888QRPExApCMMAkcZEInM4/pvTiM7Glv0927fdj13l2yT5/HTddcB7BohWj9sERBoiiiJ6hMEVBQEAGLs0JVkPOp0OBw4cQFtb27IHF29HEAQcPXoU9fX1DAJEKeDKAJGGePpH0e89v6rv3VP9ONatk2ZIT667DohoaVwZINKI8YnpVQcBABi7dE2yXm686+CFF17I2F0HRLQ0hgEiDYhE5tDTM5BSjYtj0oUB4PpdBz/80U/w0UddGb/rgIgWYxggUrnVzgnc7MqVAGZTrHGjq9eCMKzZiL/5bmPG7zogosU4M0CkcqnMCdzMbtuBLZs/m3KdaDSG4//rNCKROQBAPB7Hb46/h1//zzaMjo5Ar9ejqKgIZrMZwWAQPp8PiUQCJSUlqK+vx/79+2EwGFLug4iuYxggUrGl7hNIxcMP34eKJy0p1Ugmk+j4oB+XL996C+GNdx1cuXwR69fnwWQywWq1wmazoaysjKcGiNKAUzdEKiXFnMDNxsenkEwmkZOz+h3GU6fPLRkEgOvHDrdu+xy2bvscNnx2HaqeKVn15xDR8nFmgEiFpJoTuFkslsDlK6t/V2B4ZByDQ5ck7IiIpMAwQKRC/d7zmJicTkvtsbGpVX3flasB9PaNLPvruRtAlDkMA0Qqk+p9AnezmvsGIpE5fNTlQzLJESUiJWIYIFKRdMwJ3CwQiCAQWP6Lg4lEEh+5PkU0OreyD+LSAFHGMAwQqUS65gSWspK3Cnr7RnD1ajB9zRBRyhgGiFQinXMCN7u0zK2CoeFLGDk7keZuiChVDANEKpDuOYGbTV6eQSwWv+PXXL48g75TZ1f9GdwlIMochgGiLJeJOYGbJZMiLo3ffhUiHJ5Fl4sDg0TZgmGAKItlck7gZrfbKojHE/io69OUe9KBSwNEmcIwQJTFMjkncLOxS1NY6jbzk70juDa1sieJiUheDANEWSrTcwI3m52N4eq1xacEfANjOOeflKkjIlothgGiLCTHnMBSLt1wxHB8YhqnPzknWW0OEBJlDsMAUZaRc07gZhfHrs8NhEJRdPcMLLltQETKx1cLibKMnHMCN5uaCmEmEEZ3zyBmJQ4nfKqYKHMYBoiyyKXxKVnnBJbym9+4EU8k5G6DiFLAbQKiLBGJzKFHGJS7jUUujU/hjO+C3G0QUYq4MkCUBZLJJLp7BiRfik/F9EwYFy5cRU6ODslkEjk5Ev9uwV0CoozhygBRFvCeuYDJyzNyt7FgdjaGkZHrbw4kkyICgajMHRFRKhgGiBROaXMCiUQSQ8PjSCSSC39teiYs+edwgJAocxgGiBRMaXMCoiji7LkJRCJzi/769LT0YYCIModhgEihlDgncOnSFKambv3BPzcXvyUgEFH2YBggUiilzQlMTYcWLhlayvS0tO8RcJOAKHMYBogUSGlzAtHoHM6evfObA9MzkQx1Q0RSYxggUhilzQksNTC4lGAwinhcusuHOEBIlDkMA0QKorQ5AVEUMXJ2AtHo8vrh6gBRdmIYIFIQpc0JXBy7tqKTAlLPDRBRZjAMECmE0uYErl0LLnqieDlmZiKSvVzIbQKizGEYIFIApc0JRCJzOHvuzgODS0kkkgiGeBshUbZhGCCSmdLmBOLxBIaGx5FMru43/OlpaeYGuDBAlDkMA0QyU9KcwPzAYCrBhHMDRNmHYYBIRkqbE7hw8SpmUjwREI3Gln36gIiUgWGASCZKmxO4ejWI8fFpSWpJ8nAR9wmIMoZhgEgGSpsTCIdncc6/8oHB2+HDRUTZhWGASAZKmhNIdWBwKcFQ9K43Ft4N1wWIModhgCjDlDQnIIoihkfGMTcXl7ZuUkx59oCIModhgCiDlDYncP7CFQQC6bkXQJK5ASLKCIYBogxR2pzAlSsBTEykb6si1TDAGwiJModhgChDlDQnEApF4R+9nNbPiMcSCPE2QqKswDBAlAFKmhOIxeIYHpmQdGDwdlI5VcCFAaLMyZW7AaJsJIoient7IQgCPB4PIpEIjEYjrFYrbDYbysvLF5a5lTQncH1gcELygcHbmZ6J4MEHM/JRRJQChgGiFYjFYmhqasKhQ4fg9Xqh1+thsVhgNpsRCARw+PBhJBIJFBcX48CBA/j617+O7p5BxcwJjJ6/gmAwc0v34fAs5ubiWLOG/6ghUjJuExAtk9vthsPhQENDA6xWK5xOJwKBAPr7+9Hd3Y3+/n4EAgE4nU5YrVY0NDRg1y4bPj7ZK3frAIDJyzOYnMz8zMJqBwk5QEiUOQwDRMvQ0dEBh8OBaDSK7u5utLa2orq6GkajcdHXGY1GVFdXo7W1FS6XC6IYx1/+eR36PfIGgmAwitHRK7J8Nm8jJFI+hgGiu3C73di7dy8qKirQ09OD3bt3L+v7bDYbBEHAU09V4L9+7/+A3z+U5k6XNjcXx/DIOEQx/QODSwkEIkgmV34bIRcGiDJHJ8r1TwiiLBCLxRZWBHp6epCfn7/iGqFQCDabDXNzIv7muz9Abm7m9s+TSRG+gYsIhWYz9plL2bF9I9atM63oe4p2bETZ41vT1BER3YgrA0R30NTUhL6+PrS0tKwqCABAfn4+WlpaMDLiw2+Ovydxh3fmH52UPQgA3CogUjqGAaLbEEURhw4dwksvvbTsrYHbsdlsqKmpwa9/3Zax5fqJyWlcuRLMyGfdzeqGCLlPQJQpDANEt9Hb2wuv14u6ujpJ6r3xxhsY9Y/g7IhPknp3EghEcP68PAODS5mbiyMSmZO7DSK6DYYBotsQBAF6vR6VlZWS1KusrIRer8fQkFeSerdzfWBwAkqbBpqeDq3o63m0kChzGAaIbsPj8cBisdxyfHC1TCYTduwowujoiCT1lpJMJjE0PI54PJG2z1itKc4NECkWwwDRbUQiEZjNZklrFhQUYHY2fTcAnvNfRjgs/8DgUkKhWcRiygspRMQwQHRbRqMRgUBA0prBYBBr1+ZJWnPe+PgUrl5VxsDg7cwEIsv+Wu4SEGUOLwwnug2r1YrDhw8vPEKUqnA4jMHBAVR94Q+W9fWiKGJkxIehQS9GR4cxNzeLNWvWYtOmbdi+oxhbt1oW9tVnZsK4cPFqyj2m2/R0CPfdW7Csr+XMAFHmMAwQ3YbNZkMikUBnZyeqq6tTrtfZ2YlEIoHt24vv+HXxeBy/Of4efv0/2zA6OgK9Xo8dO4oWHkNy/vooEokENm3aij1ffAlPf/73MXJWeQODS5mZiUAURf6gJ1IYbhMQ3UZ5eTmKi4vR2NgoSb1//Md/xNq1azEw4EY8tvQrhn7/EP7iz1/HP//4+7Dbdy08hnTmjBeC0IMzZ7wLjyHZ7bvwzz/+Pv7i2/sxdvGcJD2mWyKRRCCDryYS0fLwOmKiOzh8+DAaGhrgcrlgs9lWXUcQBDz55JMLFw49/PAmvPLlr+PJJ38POXo9AKDf04vv/d1/xtatj+DIkSPLuuhIEAS89trXMDJyFi/V/kds3nLnVQcl2LBhHTY9fN9dv65450MotW7OQEdExDBAdBuiKGJyZgy/98yzSMZF9PQIq36bwG63QZerw8t/VIN/+n4TJsYnAQA7dljwR1+tg7lwA/7yz19HZeVTeO+991b0OaFQCH/wBy+gs/MjfPXV7+CzGzatuMdMysszwFpy9x4ZBogyh2GAaAmxxBzGA+cRjYfg8w7gy7//GhwOB947tvIf1C/UvACXy4V33j8CS3ERIuEIfvLjn+EHb/0YU9emAVw/cvjww5tw4sTqA8fu3TZMz8ziq69+B3q9sseBrCWbkJdnuOPXlBQ/vKzQQESp48wA0U1motfgnxpANH79xjxLcREaf3IQLpcLdvv1Z4mXQxAE2O02uFwuNP7kICzFRQAAo8mI/Qf+GP/rxPuo/091MBgMCIVCePvtIyk9hnTkSAvGL53Fqb7/vaoamcSHi4iUhWGA6LfiyTguzpzDRPA8RDG56L97snI33nn/CHIMOXA4HKitrcXx48cRiSw+Nx8Oh+F0OlFb+zIcDgdyDDl45/0jeLLy1v1/c6EZ3/g/38TDmx+S9DGkU72/ydhjSKu1uoeLiChdlL2WSJQhwdkZTAQvICnGb/s1luIivPOrI3jn7Xfxkx/9DM8++yz0ej2KLEUoKChAMBjEgG8AiUQCRZ/bju/83X/Bl199GQbD7ZfD+097MTJ0Fj/4pyZJ/hxvvPEG2traMDF+DvdvfESSmukQDEWRSCSh1/P3ESIlYBggTUskE7gcGkNg9tqyvt5gMOCrf/IV/NEf/yH6PzmDT/o8GDgziGgkijxjHr7677+MR8usKHl057LO0p/u86TlMaSxsWFFhwExKWJmJoL161e3LUJE0mIYIM0KzwUxETyPeHLpM/93otPpYH2sGNbHUjvKN3BmCEWWIkkfQ9q+fQcuT56XpF46TU+H7xgGeDERUeYwDJDmJMUkroTGMR29LHcrmI1G0/IYUiw+J2nNdJgOcG6ASCm4YUeaEo1HcH5qSBFBAADW5uWl5TEkQ+4aSWumQzyWQDDE2wiJlIBhgDRBFEVcDU/g/NQQ5hLK+QFUtHM7BnwDt5xKWK1wOIyhoUF85rMPS1Iv3e50xJC7BESZwzBAqjeXmMX56WFcDY8DUNaRu8fKrAuPIUlh/jGkJ57YDaNR+asDvG+ASBkYBkjVpiJXMHptELNxZf7QKXmsGDss2yR7DKmxsREWy+ew59lnUFL8MIp2bITZLM1wYjpEInOYm1v6OCcHCIkyh2GAVCmeiOHC9Aguhy5CRPLu3yATnU6Hf/f1r6CtrW3ZNxvejiAIOHr0KL7xjf+Aqmes2PPs4ygv24qSnQ+heOdDuHd9viJ/wPICIiL58W0CUp1AdAqToYtIigm5W1mWWCyGV557FWLKjyHZYTQa4XK5kJv7u4NCsVgcwyMTGB4Zx9WrAYxPTOPK5QASSWX8X3/dOhN2bN94y19/tHQzdn7uIRk6ItIehgFSjUQyjsngRQTnpuVuZcVSfQyppqYGLpcLXV1dKC0tXfLrRFHE2Ng1DA6P4+LFq5icnMbE5AxiMXlDU06ODo8/tgU5OYsXKh97dAs+Z3lQpq6ItIXbBKQKobkA/NcGszIIAKk+hmSHy+VCe3v7bYMAcH1L4sEH78UzTxfjS8+Vo/KpnSh7/BFs2fyZu74gmE7JpIhAQJrTFES0OgwDlNWSYgITwQsYmzmLhLjymwSVZOWPIdXC4XDAaDSiq6sLVVVVy/6sdYUm7Crfhj94fjd+798+BrttB3Zsvx8FBXlS/7GWZXqaYYBITtwmoKwViYUwHjiPeFL5t+2tRCwWW3gMadA3DL1eD4ulCAUFZgSDQfh8PiQSCZSUlKC+vh779++/42NIyyGKIi5dmsLA0CUMD1/C+MQ0pqbCGXv90GDIxWOPbl7017hNQJQ5DAOUda5fIDSOa5HLUNq9AVISRXHhMaSzPj90iVyYTCZYrVbYbDaUlZWl5XTATCCCwcExfOq7iItj13D1SmaGDYt3PgSTae3Cf2YYIMochgHKKrPxKMYDo4q6RTATTAYzHlz3SEY/MxaLY+TsJM58egFnz01gYnIG8TQOGz744Ho8sHH9wn9+/LFHYCl6IG2fR0S/w4eKKCuIooipyGVcUeAtgpkgyvBnNhhyYSl6AEU7NuLSpSmc8V3AmTMXMD4xjWhU+vmM6enwojBARJnDMECKF0vMYTxwHtF4SO5WNEmn0+GBB9bjgQfW44ld2zE4OIa+U2dxcewagkHpVmhCoVnEYgkYDPrffq5kpYnoLrhNQIo2E72GydBFiKJybxHMBKMhHw+t2yZ3GwtisTjOnptEb98IhkcmMDWVelATRRH6nBlcnjyH0dFhmM1rsPH++xZmJMrLyxV5gyKRGjAMkCLFk3FMBC8gPDcjdyuKoLQwMG/+FMIp9zl43KO4cjWA5AqHDROJOE71/W/09f4GkxPnodfrsWNHEQoLF5+eKC4uxoEDByQ5PUFEizEMkOIEZ2cwEbyApLj0AzZalJebj4fvUV4YuNFMIAKv9zxOfDyEsUvXEI/ffTVncmIUv3r/Bxi/dA4vvvgi3njjDVRWVsJo/N3jSpFIBJ2dnWhsbERbWxvKysrQ0tJyxwuWiGhlGAZIMRLJBC6HxhCYvSZ3K4qTDWFgXiwWx9DwOLq6fTh7bhKztxk29J/zou0X/ze2bt2Kt98+gt27d9+1tiAI2LdvH/x+P9rb21d00RIR3R7DAClCeC6IieB5xJPZfYtguuTlmvDwPdvlbmNF5t9CcAmD8Hj8CIVmF/67yYlR/PTtv0JlZSX+5V/S8xYDES0fwwDJKikmcSU0junoZblbUbS1uSZsyrIwcKOZQAQffzwE4eMhTE5O4adv/xXWFebhxInUX2ns6uriDAFRivg2AckmGo9gdGqQQWBZsjuzF5qN+DdfKMWf/Ye9yM05h/FL5/D220dWFQQAID8/H83Nzejt7UVTU5PE3RJpD1cGaNlEUURvby8EQYDH40EkEoHRaFzx0S9RFHEtMomr4Qlk+w+5TFmrN2LT+h1yt5EyURRhtVphtVrR2tqacr3a2lp4vV643W4eOyRKAcMA3VUsFkNTUxMOHToEr9f724dzLDCbzQgEAis6+jWXmMV44Dxm4+EM/ymy2xp9HjavL5K7jZSdPHkSTzzxBJxOJ6qrq1Ou53Q6sWfPHpw8eRLl5eUSdEikTdwmoDtyu91wOBxoaGiA1WqF0+lEIBBAf38/uru70d/fj0AgAKfTCavVioaGBjgcDrjd7kV1rl8nfAWj1wYZBDRMEATo9XpUVlZKUq+yshJ6vR6CIEhSj0irGAbotjo6OuBwOBCNRtHd3Y3W1lZUV1cvOgMOAEajEdXV1WhtbYXL5UI0GkVFRQU6OjoAAPFEDBdnzuJy6CJEaPsmQa3zeDywWCy3/D20WiaTCRaLBR6PR5J6RFrFMEBLcrvd2Lt3LyoqKtDT07OsM+AAYLPZ0NPTA4fDgeeffx7dH38E/9QAIrFgmjtWNzkeKkqHSCQCs9ksac2CggKEw1xtIkoFwwDdIhaL4Wtf+xq2bNmCY8eOrXjiOz8/H8eOHcPmzZvx77/+OmbntPXccFqoIwvAaDQiEAhIWjMYDMJkMklak0hrGAboFk1NTejr60NLS0vKR7/6P/HinbfflbhD7VHLyoDVaoXP50MkEpGkXjgchs/ng9VqlaQekVYxDNAioiji0KFDeOmll5a9NXA7NpsNL75Yg5/++OfgoRUCrv89kUgk0NnZKUm9zs5OJBIJ2Gw2SeoRaRXDAC3S29sLr9eLuro6SerV1b2BgU+H0P/JGUnqaZc6wlR5eTmKi4vR2NgoSb3GxkaUlJSgrKxMknpEWsUwQIuk6+jXJ32c9k6FOqIAoNPpcODAAbS1taV8HFAQBBw9ehT19fW8cIgoRQwDtEg6jn4VWYowcGZQknqapZY0AGD//v0oKyvDvn37EAqFVlUjFAph3759KC8vx+uvvy5xh0TawzBAi6Tr6Fc0whMFqVFPGjAYDGhpaYHf70dNTc2KA8H8q4V+vx/Nzc3Izc1NU6dE2sEwQIuk6+hXnjFP0ppao54ocF1paSna29vhcrlgt9uXvWUgCALsdjtcLhfa29v5fDGRRBgGaJF0HP0a8A2gaGf2P7IjL7XFAaCqqgpdXV0wGo1wOByora3F8ePHb/l7LxwOw+l0ora2Fg6HY+HZ4qqqKpk6J1IfhgFaJF1Hvx4t4zlwulVpaSm6urpw8OBB9Pf349lnn4XZbEZJSQnsdjtKSkpgNpuxZ88eeDweHDx4EF1dXVwRIJIYXy2kRaR/YvZlnHafwi8/aOPEdwp0uhxsv0/dgUoURfT19S08kR0Oh2EymfDTn/4UV65cwa9+9Ss899xzcrdJpEqcvKFF5o9+NTQ0QBCElC5zuX706xi+83f/hUEgVRqI7DqdDuXl5bc8RTw1NYUjR47gww8/ZBggShNuE9AtpDv69TWUPFqMP3ytVuIOSUs+//nPAwA++OADmTshUi+GAbqFFEe/Xqh5Aef8fvzXg3/No18SUMvbBKsxHwa6u7sxOzsrczdE6sQwQEtK7eiXDS6XC40/OQhLcVGaOyW1s1gs2LBhA2ZnZ3HixAm52yFSJYYBuq3VHv3KMeTgnfeP4MnK1B46ohtpd2VAp9Ph6aefBsCtAqJ0YRigO1rO0a/CwkLs2bMHXq8X/+37f493fnWEKwIkKc4NEKUXjxbSst3u6JfVaoXNZlt4Oe781BBmE9JcWkS/s/2+Us2eyvj444+xe/durFu3DleuXIFer5e7JSJVYRggyYXngrg4MyJ3G6qj5TAQj8exfv16BINB9PX14fHHH5e7JSJV4TYBSc60pgBGQ4HcbaiOlk8U5Obm4qmnngLArQKidGAYoLS4L3+j3C2QynBugCh9GAYoLfJyjShYe4/cbaiMdlcGgMVhgLubRNJiGKC0uc+0AYA297jTQes//+x2OwwGA8bGxjA8PCx3O0SqwjBAaWPQr8W6vHvlbkNFtJ0GjEbjwlsZ3CogkhbDAKXVetMG6Pi3GUmEcwNE6cGjhZR2V8PjuBqekLuNrCOKIvpPe3G6z4OBM0MwiHnIN+Uv3OtQXl6uuaOGv/zlL/H888+jqKgIPp9P7naIVINhgNIuKSZw9qoPSTEudytZIRaL4Z2338VPfvQzDPqGodfrUWQpQqG5EIFAAD6fD4lEAsXFxThw4AD2798Pg8Egd9sZMTU1hXvvvReiKGJsbAwbN/LUCpEUuH5LaZej0+Ne02flbiMr+LwDeOW5V/HX3/oeyh7bBafTiUAgAG+/F93d3ejv70cgEIDT6YTVakVDQwMcDgfcbrfcrWfEPffcg0cffRQA8OGHH8rcDZF6MAxQRqzLuw+5OWvkbkPRujtP4JUvvQoxLqK7uxutra2orq6G0Whc9HVGoxHV1dVobW2Fy+VCNBpFRUUFOjo6ZOo8szg3QCQ9hgHKCJ1Oh/tM98vdhmL5vAN4/asHUFFRgZ4eAbt3L+/FR5vNhp6eHjgcDjz//POaWCFgGCCSHmcGKGNEUcTo1CDmElG5W1GUWCyGV567viLQ0yMgPz9/xTVCoRDsdjuMRiO6urpUPUNw8eJFPPTQQ8jJycG1a9dQWFgod0tEWY8rA5QxOp0On+E1xbd45+134XWfQUvLkVUFAQDIz89Hc3Mzent70dTUJHGHyvLggw9i27ZtSCaT+Oijj+Ruh0gVGAYoo0xrzDAaVvcDT41EUcRPfvQzvPTSS8veGrgdm82GF198Ef/wD/+g+ut6uVVAJC2GAcq4+0xcHZjXf9qLQd8w6urqJKlXV1eH/v5+9PX1SVJPqRgGiKTFMEAZl2cwoWDNOrnbUITTfR7o9XpUVlZKUq+yshJ6vR6CIEhST6nmw0BPTw9mZ2dl7oYo++XK3QBp07359yM4NwNRTC66ZW82GsXavDwU7dyOx8qsKHmsWNW37A2cGUKRpeiW44OrZTKZYLFY4PF4JKmnVEVFRdiwYQMmJiYgCAKefvppuVsiymoMAyQLXTIH7779L/jhP/1o0S17ZrMZgUAA/+Off45EIoEdlm34d1//Cr786suqnJCfjUZhNpslrVlQUIBwOCxpTaXR6XR4+umn0dbWhg8++IBhgChF3CagjHO73XA4HPj2f/7LW27Z6+nugbffu3DLXtlju/DX3/oeXnnuVfi8A3K3LqncHAPyTQUIBoKS1g0GgzCZTJLWVCLODRBJh2GAMqqjowMOhwPRaHRFt+yJcRFf/v3X0N15QqbOV06vy8Xa3OvzEfcYP4vPFjyEBwu3Yst6C7bfV4pH7t2JJ3c9BZ/Ph0gkIslnhsNh+Hw+WK1WSeop2XwY6OzsRCKRkLkbouzGS4coY+ZXBCoqKnDs2LEVnakPhUJ4oeYFuFwuvPP+EViKi9LY6fLk6PTIzTHAoF+D3Jw1MOiv/3tDzhrk6tcgR3f3rH3y5Ek88cQTcDqdqK6uTrknp9OJPXv24OTJkygvL0+5npLF43GsX78ewWAQvb29KCsrk7sloqzFMEAZEYvFFlYEenp6Urhlz4YcQw7e+dWRtM8Q6KBD7sIPdwMMOWuu/+DXr4EhxwB9TuojN6Iowmq1wmq1orW1NeV6tbW18Hq9cLvdqh68nPfFL34Rv/71r/HWW2+hoaFB7naIsha3CSgjmpqa0NfXh5aWlhRv2WtB/ydevPP2uxJ0pUNuzhoYDfkoXHsv7jXdj/sLNuGhddvwyL07sf0zpdiy3oIH1z2CDQUPYb3psyhYuw55uUZJggBwfRDuwIEDaGtrS/k4oCAIOHr0KOrr6zURBADODRBJhSsDlHbS//b7Mk67T+GXH7Td9YeeXvfbZfwbf7NfWNo3KOKHpnSrJtffJnC5XMjN1cZBoY6ODnzhC1/Axo0bcfHiRUX870mUjRgGKO3StS9+7Dc/x6OPl96yfH/j0v5y9u2VwO12o6KiAg6HY1XzFDU1NXC5XOjq6kJpaWkaO1WWSCSCdevWIRaLYWBgADt27JC7JaKslB3/pKSsJghCWm7ZG/Ndxbb7SrBp/Q5sLNyMz+RvxDrjfchfY8aa3LVZEwQAoLS0FO3t7XC5XLDb7cveMhAEAXa7HS6XC+3t7ZoKAsD1Uyc2mw0AtwqIUpE9/7SkrOXxeGCxWCS/Zc/r9UpSTymqqqrQ1dUFo9EIh8OB2tpaHD9+/JZjh+FwGE6nE7W1tXA4HAvPFldVVcnUubw4N0CUOoYBSrtIJMJb9paptLQUXV1dOHjwIPr7+/Hss8/CbDajpKQEdrsdJSUlKCwsxJ49e+D1enHw4EHNbQ3cjGGAKHXamDIiWRmNRgQCAUlrqvmWPYPBgDfffBN/+qd/ir6+PgiCAI/Hg3A4DJPJhG9+85uw2WwoKyvjwByubxvpdDoMDg7i0qVL2LiRr2ISrRTDAKWd1WrF4cOHEYlEJNkqmL9l75vf/GbqzSmYTqdDeXm56i8PStU999yDRx99FKdPn8YHH3yAV155Re6WiLIOtwko7Ww2GxKJBDo7OyWpN3/97PzgGBG3CohSwzBAaVdeXo7i4mI0NjZKUq+xsRElJSW8fpYWMAwQpYZhgNKOt+xRus2HgVOnTmF6elrmboiyDy8doozgLXuUbtu3b8fw8DDef/99fOlLX5K7HaKswpUBygiDwYCWlhb4/X7U1NQgFAqt6Pvnb9nz+/1obm5mEKBbcKuAaPUYBihjeMsepRPDANHqMQxQRvGWPUqX+TDQ09ODaDQqczdE2YUzAySLWCyGpqYmHDp0CF6vF3q9HhaLBQUFBQgGg/D5fEgkEigpKUF9fT32798Pg8Egd9ukYKIoYuPGjZiYmMC//uu/LoQDIro7hgGSlSiKS96yZ7VaecserVhtbS3effddfPe738W3v/1tudshyhqcwiJZ8ZY9ktLnP/95vPvuu5wbIFohzgwQkWrMbw189NFHSCQSMndDlD0YBohINR5//HGYzWbMzMzg9OnTcrdDlDUYBohINfR6PZ566ikAwIcffihzN0TZg2GAiFSF9w0QrRzDABGpyo1hgIeliJaHRwuJSFUikQgKCwsRj8fx6quvYu3atTAajQvHVcvLy3lclegmDANEpAo3X2SVk5ODoqIirFu3DoFAYOEiq+LiYhw4cIAXWRHdgNsERJT13G43HA4HGhoaYLVa4XQ6EQwGcebMGXR3d6O/vx+BQABOpxNWqxUNDQ1wOBxwu91yt06kCFwZIKKs1tHRgb1792LLli1oaWnB7t277/o9giBg37598Pv9aG9v55sXpHkMA0SUteZXBCoqKnDs2DHk5+cv+3vnn8V2uVzo6uria5ikaQwDRJSVYrEYHA4HotEoenp6VhQE5oVCIdjt9oVXMTlDQFrFmQEiykpNTU3o6+tDS0vLqoIAAOTn56O5uRm9vb1oamqSuEOi7MGVASLKOqIowmq1wmq1orW1NeV6tbW18Hq9cLvdPHZImsSVASLKOr29vfB6vairq5OkXl1dHfr7+9HX1ydJPaJswzBARFlHEATo9XpUVlZKUq+yshJ6vR6CIEhSjyjbMAwQUdbxeDywWCwwGo2S1DOZTLBYLPB4PJLUI8o2DANElHUikQjMZrOkNQsKChAOhyWtSZQtGAaIKOsYjUYEAgFJawaDQZhMJklrEmULhgEiyjpWqxU+nw+RSESSeuFwGD6fD1arVZJ6RNmGYYCIso7NZkMikUBnZ6ck9To7O5FIJGCz2SSpR5RteM8AEWUd3jNAJC2uDBBR1tHpdDhw4ADa2tpSPg4oCAKOHj2K+vp6BgHSLK4MEFFWkvptApfLhdzc3DR0SqR8XBkgoqxkMBjQ0tICv9+PmpoahEKhFX3//KuFfr8fzc3NDAKkaQwDRJS1SktL0d7eDpfLBbvdvuwtA0EQYLfb4XK50N7ezueLSfMYBogoq1VVVaGrqwtGoxEOhwO1tbU4fvz4LccOw+EwnE4nXn75ZTgcDsR0OnR88AGqqqpk6pxIOTgzQESqEIvF0NTUhEOHDsHr9UKv18NiscCUn49gMIjBgQEkEgls3r4dX3zlD1H94kvYtuGz2P3IZrlbJ5IdwwARqYooiujr64MgCOj++CT8k5NYk5eHTdu2Y4fViq2f27no1MBT2x7BxnWFMnZMJD+GASJSreHJK+g7f+GOX5NnyMWzxZ+DQa/PUFdEysOZASJSrVgicdevicbiOH3+Yga6IVIuhgEiUq3ZeHxZX3fu6jWMz0j78BFRNmEYICLVWs7KwLze0fMr+noiNWEYICLVmlvBD/fwXAyei5fS2A2RcjEMEJFqzcVX9pv+8OUrmAwE09QNkXIxDBCRas0tc2bgRif95xHndgFpDMMAEanWamYAQnNz8IyNp6EbIuViGCAi1VrJzMCNhiYv43JwZQ8fEWUzhgEiUqV4IoFkCneqnfSfRzyZlLAjIuViGCAiVVrtqsC84OwsvGM8XUDawDBARKq00pMESxmcuIyrobAE3RApG8MAEamSFBcIiQA+PjeKBLcLSOUYBohIlZZ7FfHdBGZnceYSTxeQujEMEJEqSXm1sG98ElPhiGT1iJSGYYCIVCnVAcIbzW8XpHI6gUjJGAaISJVWc/vgnUxHo9wuINViGCAiVZLiNMHNuF1AasUwQESqlI7niJOiiJP+89wuINVhGCAiVZJyZuBGU5EIBsYn01KbSC4MA0SkSrE0bBPM814ax0wkmrb6RJnGMEBEqjSbkHaA8EZJUcTHfp4uIPVgGCAiVUrnygAAXAtHMDhxOa2fQZQpDANEpDrxZBKJDPzW7h27hECU2wWU/RgGiEh10r0qMC/x29MFIrcLKMsxDBCR6sylcV7gZldCYQxNcruAshvDABGpTjruGLiT/rFxBGdnM/qZRFJiGCAi1UnH7YN3Ek8muV1AWY1hgIhUJ9NhAAAuB0MYuXw1459LJAWGASJSnXTdPng37otjCM3OyfLZRKlgGCAi1YllcIDwRvFkEr2j52X5bKJUMAwQkerMyrBNMG8iEMRZbhdQlmEYICLVyfRpgpt9cnEMkbmYrD0QrQTDABGpjhwDhDeKJRI4ye0CyiIMA0SkOnLNDNxofCaAc1euyd0G0bIwDBCR6sh1muBmpy9cRDTG7QJSPoYBIlIdubcJ5sUSCfSNXpC7DaK7YhggIlVJJJOIJ5Nyt7Hg4vQMRq9yu4CUjWGAiFRF7pMESzl9YYzbBaRoDANEpCpK2SK40Ww8jlPnL8rdBtFtMQwQkaooZXjwZhempnFhalruNoiWxDBARKqixG2CeadGL2A2Lv+xR6KbMQwQkaoocZtgXjQex2luF5ACMQwQkarMKeDCoTsZvTaFsekZudsgWoRhgIhURckrA/N6R89jjtsFpCAMA0SkKkqeGZgXjcXxyYUxudsgWsAwQESqki0DeueuXsOlmYDcbRABYBggIpXJhpWBeb3+81nVL6kXwwARqUo2zAzMi8RicHO7gBSAYYCIVCXbftMeuXIVEwFuF5C8GAaISFWUegPhnfT6LyCehX2TejAMEJFqJEUx61YGACA0NwfPxUtyt0EaxjBARKqRjUFg3tDlK7gcDMrdBmkUwwARqUa2X+Rz8tx5xJNJudsgDWIYICLVyKaTBEsJzs2hn9sFJAOGASJSjWzeJpg3OHkZV4IhudsgjWEYICLVyMaTBEs56ed2AWUWwwARqUa2bxPMC8zO4tNL43K3QRrCMEBEqqH054tXwjc+iWuhsNxtkEYwDBCRasRUsjIAACKAj/3nkeB2AWUAwwARqYZaZgbmzUSj+HR8Qu42SAMYBohINbL9noGlfHppAlPhiNxtkMoxDBCRaqhtZQC4vl1w0j+KpCjK3QqpGMMAEamGmmYGbjQVicLH7QJKI4YBIlINNa4MzDtzaQLTEW4XUHowDBCRKoiiqOowkBRFfHzuPLcLKC0YBohIFdRwFfHdTEUiGJiYlLsNUqFcuRsgIpKCmlcFbnRmbBwPriuEOS8PwPUVkd7eXgiCAI/Hg0gkAqPRCKvVCpvNhvLycuh0Opm7JqXTiSLXnIgo+10NhfH/+QblbiMj7jWZ8NTWzfjhD3+IQ4cOwev1Qq/Xw2KxwGw2IxAIwOfzIZFIoLi4GAcOHMD+/fthMBjkbp0UitsERKQKWlkZAIC+06ewy2ZDQ0MDrFYrnE4nAoEA+vv70d3djf7+fgQCATidTlitVjQ0NMDhcMDtdsvdOikUVwaISBVGr16DcG5U7jbSzvPxCfztNxqwdcsWHDlyBLt3777r9wiCgH379sHv96O9vR1VVVUZ6JSyCcMAEanC0ORlnDp/Ue420so/OIBv7XsNlRUVeO+995Cfn7/s7w2FQqipqYHL5UJXVxdKS0vT2CllG4YBIlIF79g4vCp+9jcei+Hb+17DGogQBGFFQWBeKBSC3W6H0WhEV1cXZwhoAWcGiEgV1D4zcPxoG0Y+PYMjR46sKggAQH5+Ppqbm9Hb24umpiaJO6RsxpUBIlKFE2f98F+bkruNtBBFEX/2ykuw79qFX7S2plyvtrYWXq8Xbrebxw4JAFcGiEgl1LwyMHLmDEaHh/FGXZ0k9erq6tDf34++vj5J6lH2YxggIlWYU+kjRQAw6HFDr9ejsrJSknqVlZXQ6/UQBEGSepT9GAaISBXUvDIwOjyEHUVFMBqNktQzmUywWCzweDyS1KPsxzBARKqg5rcJ5mZnYTabJa1ZUFCAcDgsaU3KXgwDRJT1RFHEXDwudxtps2btWgQCAUlrBoNBmEwmSWtS9mIYIKKsF08moeZjUZu2bcfgwAAikYgk9cLhMHw+H6xWqyT1KPsxDBBR1lPz8CAA7LCWIpFIoLOzU5J6nZ2dSCQSsNlsktSj7McwQERZT83zAgCwdedObNq2Df/U2ChJvcbGRpSUlKCsrEySepT9GAaIKOvNqnheAAB0Oh2e+/JXcLStLeXjgIIg4OjRo6ivr+eFQ7SANxASUdY7f20KPWf9creRVlK/TeByuZCbm5uGTikbcWWAiLKe2mcGACDXYMCBv/pr+P1+1NTUIBQKrej7518t9Pv9aG5uZhCgRRgGiCjrzSXUvU0w72mbDe3t7XC5XLDb7cveMhAEAXa7HS6XC+3t7Xy+mG7BMEBEWU8LKwMPrivEri2b8IUvfAFdXV0wGo1wOByora3F8ePHbzl2GA6H4XQ6UVtbC4fDsfBscVVVlUx/AlIyzgwQUdb7+Nwozl29JncbaXO/uQCObY9An/O7399isRiamppw6NAheL1e6PV6WCwWFBQUIBgMwufzIZFIoKSkBPX19di/fz8MBoOMfwpSMoYBIsp6XcNnMTY9I3cbaXFffj4qd2xFbs7SC7miKKKvrw+CIMDj8SAcDsNkMsFqtcJms6GsrIynBuiuGAaIKOt1+IZwZYUDddngHqMRny/aBoNeL3crpHIcJyWirCKKInp7exd+E45EIpiMRLFxyyPYYS3F1p07VfGbcGFeHip3bGUQoIzgygARZYXb7ZGbzWZMz8xgcGAAiUQCm7Ztw3Nf/gqqX3wJuVm6R16wZg2esWxHXpb2T9mHpwmISPHcbjccDgcaGhpgtVrhdDoRCATQ39+P7u5unPF6EQgE4HQ6Yd+1Cz/6++/h2/teg39wQO7WV8xoMKByxzYGAcoorgwQkaJ1dHRg79692LJlC1paWrB79+67fo8gCPja176Gs+f8+NZ/fwvWJ+7+PUqwNjcXzxRtgzkvT+5WSGMYBohIseZXBCoqKnDs2LEVXcEbCoXwwgsv4KMuF/62uQWbdxSlsdPUGfR6fH7HNtxjMsrdCmkQwwARKVIsFoPD4UA0GkVPT8+q7+K32WyI6XT47j8fUewMQW5ODiq3b8V9BSv/MxJJgacJiEiRmpqa0NfXh+7u7lUFAQDIz89HS0sLHA4Hjh9tw3Nf/kOJu1xMFEWMnDmDQY8bo8NDmJudxZq1a7Fp2/bbnnTQ63RwbNvCIECy4soAESmOKIqwWq2wWq1obW1Nud7LL7+ME6dO4f955920HDuMx2I4frQN/+87P8Po8DD0ej12FBXBbDYjEAjc9qRDjk6HJ7duwQPrCiXviWgleJqAiBSnt7cXXq8XdXV1ktR744034B8awsinZySpdyP/4AC+ve81/Ojvvwf7rl0LJx3OeL0QenrueNJh95ZNDAKkCAwDRKQ4giBAr9ejsrJSknqVlZXQ6/UY9HgkqTfP8/EJfGvfa1gDEd3d3fhFayuqq6thNC4eAjQajaiursYvWlvhcrmwBiL+4k/2Yej0KUn7IVothgEiUhyPxwOLxXLLD9XVMplM2FFUhNHhIUnqAddXBP72Gw2orKiAIAjLOvIIADabDYIgoMLhwPPPPw+32y1ZT0SrxTBARIoTiURgNpslrVlQUIC5aFSSWvFYDIf+r+9g65YteO+991Y84Jifn49jx45h8+bN2LdvH2KxmCR9Ea0WwwARKY7RaEQgEJC0ZigUwv33rseD6wphXrsWOSkMEh4/2oaRT8/gyJEjKZ10aG5uRm9vL5qamlbdC5EUeJqAiBSnsbER9fX1CAQCkmwVhMNhFBYW4vDhw3j99dcBAElRRGh2FoHoLAKzswhGr//7mWgU8WTytrVEUcSfvfIS7Lt24RcSnHSora2F1+uF2+1WxQNLlJ14zwARKY7NZkMikUBnZyeqq6tTrtfZ2YlEIgGbzbbw13J0Opjz8pa8+jcai2EmGkUg+tuQMHs9JERjcYycOYPR4WH8uLEx5b4AoK6uDnv27EFfXx/Ky8slqUm0UgwDRKQ45eXlKC4uRmNjoyRhoLGxESUlJSgrK1vW1+cZDMgzGLDhprmFWCKBgx90pOWkgyAIDAMkG84MEJHi6HQ6HDhwAG1tbRAEIaVagiDg6NGjqK+vT3kZ3qDX4+zggOQnHSwWCzwSH3skWgmGASJSpP3796OsrAz79u1DKBRaVY1QKIR9+/ahvLx8YVYgVek66RAOhyWtSbQSDANEpEgGgwEtLS3w+/2oqalZcSAIhUKoqamB3+9Hc3MzcnOl2RVNx0mHYDAIk8kkaU2ilWAYICLFKi0tRXt7O1wuF+x2+7K3DARBgN1uh8vlQnt7O0pLSyXryWq1wufzIRKJSFIvHA7D5/PBarVKUo9oNRgGiEjRqqqq0NXVBaPRCIfDgdraWhw/fvyWH8bhcBhOpxO1tbVwOBwwGo3o6upCVVWVpP3ceNJBCkuddCDKNN4zQERZIRaLoampCYcOHYLX64Ver4fFYkFBQQGCwSB8Ph8SiQRKSkpQX1+P/fv3w2AwSN6H1C8q8p4BUgKGASLKKqIooq+vD4IgwOPxIBwOw2QywWq1wmazoaysLO0/VA8fPoyGhga4XK6UfqMXBAEOhwMHDx7Em2++KWGHRCvDMEBEtEKxWAwOhwPRaBQ9PT2rupI4FArBbrfDaDTC5XJJNuBItBqcGSAiWiGlnnQgWi2GASKiVVDiSQei1WIYICJaJaWddCBaLc4MEBGlSCknHYhWi2GAiEgiSjjpQLQaDANEREQax5kBIiIijWMYICIi0jiGASIiIo1jGCAiItI4hgEiIiKNYxggIiLSOIYBIiIijWMYICIi0jiGASIiIo1jGCAiItI4hgEiIiKNYxggIiLSOIYBIiIijWMYICIi0jiGASIiIo1jGCAiItI4hgEiIiKNYxggIiLSOIYBIiIijWMYICIi0jiGASIiIo1jGCAiItI4hgEiIiKNYxggIiLSOIYBIiIijWMYICIi0jiGASIiIo1jGCAiItI4hgEiIiKN+/8BW9GWb9v4UNYAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -101,7 +101,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 4, "id": "95737dd8", "metadata": {}, "outputs": [ @@ -109,17 +109,17 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ))" + " (,\n", + " ))" ] }, - "execution_count": 7, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -150,7 +150,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 5, "id": "b4ed641d", "metadata": {}, "outputs": [ @@ -158,17 +158,17 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ))" + " (,\n", + " ))" ] }, - "execution_count": 11, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -193,7 +193,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 6, "id": "4505c0aa", "metadata": {}, "outputs": [ @@ -201,17 +201,17 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ))" + " (,\n", + " ))" ] }, - "execution_count": 21, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -248,23 +248,23 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 7, "id": "f5631114", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 29, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAf8AAAGTCAYAAAAmxxufAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABauUlEQVR4nO3deXxU9b0//tdkX2dIAlkJEEhI2MKmYtCKLcgipdBFC9feoKL+5NIW6oIXr6IVKIj1ulzvBbQo0pYvrSh4tQoiGryUAGGJhtUkBLJONmYymUlmP78/YkaGbDMnM3POZF7Px+M8ypw5c87nHJt5z+f92RSCIAggIiKigBEkdQGIiIjItxj8iYiIAgyDPxERUYBh8CciIgowDP5EREQBhsGfiIgowDD4ExERBRgGfyIiogDD4E9ERBRgGPyJiIgCDIM/EdEA9vzzz0OhUDhtOTk5vX7mvffeQ05ODiIiIjBhwgR88sknTu8LgoC1a9ciJSUFkZGRmDVrFkpLS715G7K0adMmKBQKrFq1qtfj+nqeUmDwJyIa4MaNG4e6ujrHduTIkR6PPXr0KJYsWYJly5bhzJkzWLRoERYtWoSzZ886jtm8eTNef/11bN26FcePH0d0dDTmzJkDo9Hoi9uRhaKiImzbtg25ubm9HufK85SCggv7EBENXM8//zz27duH4uJil47/5S9/CYPBgI8//tix79Zbb8WkSZOwdetWCIKA1NRUPP7443jiiScAAC0tLUhKSsKOHTuwePFib9yGrOj1ekyZMgX/8z//g/Xr12PSpEl49dVXuz22r+cplRDJrkxEFECMRiPMZrNHziUIAhQKhdO+8PBwhIeHd3t8aWkpUlNTERERgby8PGzcuBHDhg3r9tjCwkI89thjTvvmzJmDffv2AQAqKiqgVqsxa9Ysx/sqlQrTpk1DYWGhT4O/p56pu89zxYoVmD9/PmbNmoX169f3eu6+nqdUGPyJiLzMaDRi2PB0NDY0eeR8MTEx0Ov1Tvuee+45PP/8812OnTZtGnbs2IHs7GzU1dXh97//PX7wgx/g7NmziI2N7XK8Wq1GUlKS076kpCSo1WrH+537ejrGF4xGIyIjIz1yLnee5+7du3H69GkUFRW5dO6+nqdUGPyJiLzMbDajsaEJXxV/hpjYmH6dS9+qxx2TZqOqqgpKpdKxv6da6rx58xz/zs3NxbRp0zB8+HD8/e9/x7Jly/pVFil5KosCdKTxXXmeVVVVWLlyJQ4ePIiIiAiPXV8KDP5ERD4SExvT7+DfSalUOgUrVw0aNAijR49GWVlZt+8nJyejvr7eaV99fT2Sk5Md73fuS0lJcTpm0qRJbpfHE25M2bujs9ubK8/z1KlTaGhowJQpUxz7bDYbvvrqK7zxxhswmUwIDg52+kxfz1Mq7O1PROQzCg9t4un1epSXlzsF7uvl5eXh0KFDTvsOHjyIvLw8AEBGRgaSk5OdjtHpdDh+/LjjGF+6cRijmM1VM2fORElJCYqLix3bTTfdhPvuuw/FxcVdAj/Q9/OUCmv+REQ+Iny39fcc7njiiSewYMECDB8+HLW1tXjuuecQHByMJUuWAADy8/ORlpaGjRs3AgBWrlyJGTNm4OWXX8b8+fOxe/dunDx5Em+++SYAOMa1r1+/HllZWcjIyMCzzz6L1NRULFq0qJ935z53A3h3XB30Fhsbi/Hjxzvti46ORkJCgmO/u89TKgz+REQDWHV1NZYsWYLm5mYMGTIEt99+O44dO4YhQ4YAACorKxEU9H0SePr06di1axeeeeYZPP3008jKysK+ffucgt7q1athMBjwyCOPQKvV4vbbb8f+/fv9vh3cE8Q8TylwnD8RkZfpdDqoVCqcKi/0SIe/qaPy0NLSIqrNf6DofKYhISH9bvO3Wq0B9zxZ8yci8hFB6Nj6ew76nifS/oGIHf6IiIgCDGv+RETkt1jzF4fBn4jIR6To7T/QMfiLw+BPRER+i8FfHLb5ExERBRjW/ImIyG+x5i8Ogz8RkY9wqJ/nBQUFeWRu/0DDtD8REVGAYc2fiIj8FtP+4jD4ExH5CIf6eR6DvzhM+xMREQUY1vyJiMhvseYvDoM/EZGPsLe/5zH4i8O0PxERUYBhzZ+IiPwWa/7iMPgTEfkIe/t7nkKhQFCQ+CS23W73YGn8B4M/ERH5rf7W/AM1a8A2fyIiogDDmj8REfkt1vzFYfAnIvIRtvl7HoO/OEz7ExERBRjW/ImIfIVVf49jzV8cBn/yS3a7vV/De4ikwNjveQz+4jD4k1966aWX8F//9V+YPHmy0zZ8+PCA/WMmInIVgz/5nbY2EwoK/omamhrU1NTg448/drwXFxeHSZMmYdKkSY4fBDk5OQgJ4f/ViQaioKAgZgFFUAgCl4kg/2Gx2PDl4bNobrqG1JRgfPPN1zhz5gzOnDmDc+fOwWKxdPlMREQEJkyY4JQhmDBhAqKioiS4AwpEOp0OKpUKRy4VIiY2pl/n0rfqcXt2HlpaWqBUKj1UQv/T+UxTUlL6PcNfXV1dwD1PVofIb9jtdhw/UYqWljaEhEYgKysbM2bc4XjfbDbj3LlzKC4udvwgKC4uhl6vR1FREYqKihzHBgUFIScnB5MnT3bKEsTHx0txa0REPsWaP/mNM8UVKCtXO14PSx+Mabdk9foZu92O8vJyx4+Bzq2hoaHb44cNG9alH8HQoUPZj4D6xVHzv+ihmn8Oa/6dzzQ1NbXfNf/a2tqAe56s+ZNfKC2rcwr8AFBbp4HVakNISHCPnwsKCkJWVhaysrJw7733AgAEQUBdXZ1TduDMmTO4fPkyKisrUVlZiQ8//NBxjoSEhC4ZgtGjRyM4uOfrEnWHvf09j739xWHwJ9mrrb2G4q+vdNlvtdqgrtdiaFqCW+dTKBRITU1Famoq5s+f79iv1Wrx9ddfO2UIzp8/j+bmZnz++ef4/PPPHcdGRUUhNzfXKUMwfvx4REREiL5PInIfg784DP4kaxqNHsdPlPb4fnV1s9vBvyeDBg3CjBkzMGPGDMc+o9GIs2fPOmUJvv76a7S1teHYsWM4duyY49jY2FhoNBpmBIhI9hj8Sbba2k04cvQSrLae19uucyH13x8RERG46aabcNNNNzn22Ww2lJaWdulHMHToMAZ+Ih9jzV8cBn+SJYvFhn8evQSj0dzrcVabHXVqLdKHeqb274rg4GDk5OQgJycHS5YsAQCUldeh+OueMxREANv8vYHj/MXhEyPZEQQBx0+UQqs1uHR8VXWTl0vU1/Wbcab4CmKiYyUtBxGRqxj8SXa+/uYK6tQal49Xq7WwWGxeLFEv167X4kQRa/zkIsFDm0ibNm2CQqHAqlWrejzmzjvvdKTSr9+u7xx7//33d3l/7ty54gvWD92V1d0tEDHtT7JSWlaH0jJ13wdex2azo65Og2HDBnupVN1rvtaKwsJLsNu/+zYO0C8Rcp2Uaf+ioiJs27YNubm5vR73wQcfwGz+vrmtubkZEydOxD333ON03Ny5c/HOO+84XoeHh4ssWf+wzV8c1vxJNurqNPj6m6uiPltd0+zh0vSuRdeGI/+82GtnRCK50Ov1uO+++/DWW28hLi6u12Pj4+ORnJzs2A4ePIioqKguwT88PNzpuL7OS/LC4E+yoNUacOz4txA74WSdWgOLxerhUnWvrc2E/ztyAWazb65H1B2dTue0mUymHo9dsWIF5s+fj1mzZrl9ne3bt2Px4sWIjo522l9QUIDExERkZ2dj+fLlaG727Q/wTkz7i8PgT5LrGNLXv1q03S6gptb1fgJimUwWfHXkAtrbu45CCNQvEXKdJ5v809PToVKpHNvGjRu7vebu3btx+vTpHt/vzYkTJ3D27Fk89NBDTvvnzp2LnTt34tChQ3jxxRdx+PBhzJs3DzabNH1vGPjdxzZ/kpTFYsPRo5e6Dabuqq5uxojhQzxQqu5ZLDYc+edFtLa2d/t+AH+PkASqqqqc5qLvrs29qqoKK1euxMGDB0XNPrl9+3ZMmDABt9xyi9P+xYsXO/49YcIE5ObmYtSoUSgoKMDMmTPdvg75Hmv+JBlBEHCiqBQaF4f09aW+Qeu1VLzNZsfRwku4ptF75fwUIDxY9VcqlU5bd8H/1KlTaGhowJQpUxASEoKQkBAcPnwYr7/+OkJCQnqtqRsMBuzevRvLli3r87ZGjhyJwYMHo6yszNUn4TGd4/z7swUi1vxJMl9/cwW1dZ5L1Xek/q8hY0Six84JfDfvQFEpGhpbPHpeCjy+7u0/c+ZMlJSUOO174IEHkJOTg6eeeqrXGSnfe+89mEwm/OpXv+rzOtXV1WhubkZKSoobpfMM9vYXh8GfJFFWrnZ7SJ8rqqqbPR78T5+pQE3NtT6PC9QvEZKv2NhYjB8/3mlfdHQ0EhISHPvz8/ORlpbWpU/A9u3bsWjRIiQkOM+eqdfr8fvf/x4///nPkZycjPLycqxevRqZmZmYM2eOd2+oGwz+4jD4k8/V1Wm6XaXPExoaWmAyWRAeHuqR8509V4nLFfUeOReRHFVWVnZJfV+6dAlHjhzBZ5991uX44OBgfPPNN3j33Xeh1WqRmpqK2bNnY926dZKN9Sf3MfiTT2m1Bhw7USp6SF9fBKEj9T8yI6nf5/q2tA4XLta4fHxg1h/I3xQUFPT6GgCys7N7/BuNjIzEgQMHvFAycfrbbu+t7yK5C8yeDiSJ9nZzx5A+q3eHA1VX93+88dXKRnz9zZX+F4boOhLP7jsgcZy/OAz+5BNWqw3/PHrRI0P6+tLQqIPRaBH9+bo6DYpOlrv9uUD9EiEi/8PgT17XuUqfp4b0uXK9mlpxtf+mJh0K+zHTIBH5Fof6iROYd00+9fU3Vz06pM8VVVXuB/+WljYcOXoRNrEzDbLiT30QBM9s9D2m/cVh8CevKr+sRmlZnc+v29ikc6uJQa834qsjFyRbGpiIyJcY/Mlr1GoNzhRfkez6rq70195uxv/98wKMRu/3RyAiz/J1zX/Lli3Izc11zKyYl5eHTz/9tMfjd+zY0eV6YqZa9jQO9SOvaGlpQ+Fx7w3pc0V1TTOyMnufccxiseLI0YvQ6439vl6gpg/JPczae5avh/oNHToUmzZtQlZWFgRBwLvvvouFCxfizJkzGDduXLefUSqVuHTpkuO1HL4rGPzJ4zpr0t4e0teXpqZWtLWZEBXV/cQjVqsNR45ehNZDHRFl8PdMRF62YMECp9cbNmzAli1bcOzYsR6Dv0KhQHJysi+K5zKm/cmjfDmkzxXVPUzLa7fbcfxEKZqaWn1cIiLyJE+l/XU6ndNmMpn6vLbNZsPu3bthMBiQl5fX43F6vR7Dhw9Heno6Fi5ciHPnznns/sVi8CeP6Vilr8xnQ/pcUVXd1GWfIAg4dfqyz0cgEAmC4JGNvuepoX7p6elQqVSO7ca1Dq5XUlKCmJgYhIeH49FHH8XevXsxduzYbo/Nzs7G22+/jQ8//BB/+ctfYLfbMX36dFRXV3vlebiKaX/ymG9KKlFT2/cCOL507ZoeBoMR0dHfd7D5pqQSV642evxaCo71I/I5Ty3sU1VVBaVS6djf2zoF2dnZKC4uRktLC/bs2YOlS5fi8OHD3f4AyMvLc8oKTJ8+HWPGjMG2bduwbt060eXuLwZ/8ojyy2p8W1ordTG6VV1zDdmjUwEAFy/VyLacRCSdzt77rggLC0NmZiYAYOrUqSgqKsJrr72Gbdu29fnZ0NBQTJ48GWVlZf0qb38x7U/9JvWQvr5UVXWk/i9X1KPkbKXXriOHHrxEgUahUPQr5e+Jv1u73e5SHwGgo59ASUkJUlJ6H4nkbaz5U7/IYUhfXzRaA779thbfeDHwE7nCEwvzyPcvTRqeSvu7as2aNZg3bx6GDRuG1tZW7Nq1CwUFBY6VDvPz85GWluboM/DCCy/g1ltvRWZmJrRaLV566SVcvXoVDz30kOgyewKDP4nmq1X6+qu1tR0HD32DxESVV6/Dij/RwNfQ0ID8/HzU1dVBpVIhNzcXBw4cwF133QUAqKysdJp3QKPR4OGHH4ZarUZcXBymTp2Ko0eP9thB0FcY/EkUq9WGo4WX0NbmWqpLKm1tJpRfrkd4eKjXgz8R+Z6va/7bt2/v9f2CggKn16+88gpeeeUVd4vldQz+5LbOIX3XNHqpi9Iro9GC0jI1bDY72tpMMBotiIgI9d4FWfWnPnhiYR4Zt7BJor8z/HFVPyIXyXFI343MZitKy+qcmiQ0Wnn/WCEi8hUGf3LL5cv1sh8qZ7XaUFauhtlsddqv0chn8iEi8gwu6SsO0/7kMnW9FqeLK6QuRq/sdjvKytXdTi/c3m5Gu9GMyIgwr1w7QL9DiCTFtL84gXnX5LaWljYUHvtW1kP6BEFA+eV6GAw9d0Jk7Z+IiMGfXOAPQ/oEQUDFlQbodO29HqfxYidFTu9LfRE8tNH3mPYXh2l/6pW/DOmrqm52qVZvNFrQ3m5GZKR3Uv9EveIsPx7n66F+AwWDP/VIEAScOCn/IX21dRo0NupcPl6j0SMyMt7j5QjQ7xByA2O/57HNX5zAvGtyScnZStTUyHtIX0NjC+rcXJr3moyWHCYikgJr/tStyxX1uPStvIf0XbumR1VVs9ufMxktaGszISqq5yU7xQjU9CGRlJj2F4fBn7pQ12tx+oy8h/S16Npw5Wqj6M9rNAaPB38i8j2m/cUJzLumHrXo2nDsuLyH9On1Rly+XN+vMnpltr/ArEAQkR9izZ8cjEYLjvzzIiwW+Q7pa283o/yyGnZ7/36cmExWGAxGREdHeKhkRH1jhz/PY9pfHAZ/AtAxpO+fhRdlPaTPbLairFwNq9XukfNptG0eDf6B+iVCbmD09zgGf3GY9qfvh/Rdk++QPovFhtKyui7z9feHNyf8ISKSM9b8CWfPVcl6SJ/N1jFfv9Fo8eh5zWYr9AYjYpj6Jx9hxd/zFApFvzrtBWrNn8E/wF2uqMfFSzVSF6NHdruA8stqrzVHaDR6jwX/wPwKIZIW0/7iMO0fwOobWmQ9pK9jvv56tLYavXYNjabNa+cmIpIr1vwDVIuuDYXHLsl6SF9lVRO0Wu8GZ4vFCr3eiJiY/tf+A7UGQSQljvMXJzDvOsAZjRb886i8h/TV1FxDU1OrT64l97ULaOAQBM9sYm3atAkKhQKrVq3q8ZgdO3Z0WfUuIsL5x7EgCFi7di1SUlIQGRmJWbNmobS0VHzB+oGr+onD4B9gOof09bbmvdTq67VQ12t9dj2th+b6D9QvEfIPRUVF2LZtG3Jzc/s8VqlUoq6uzrFdvXrV6f3Nmzfj9ddfx9atW3H8+HFER0djzpw5MBq910TXk86af3+2QBSYdx2gBEFA0alyWQ/pa25uRbWPRx5YLDa06tt9ek0iX9Lr9bjvvvvw1ltvIS4urs/jFQoFkpOTHVtSUpLjPUEQ8Oqrr+KZZ57BwoULkZubi507d6K2thb79u3z4l2QJzH4B5Cz56pQXe3+Qji+om0x4Gql+Pn6+0Nzrf+1f1b8yZd0Op3TZjL1nM1bsWIF5s+fj1mzZrl0br1ej+HDhyM9PR0LFy7EuXPnHO9VVFRArVY7nUulUmHatGkoLCwUf0MiMe0vDoN/gKi40iDrIX2tre2oqGjoV3tmf2haDLLu/EgDg+ChDQDS09OhUqkc28aNG7u95u7du3H69Oke379RdnY23n77bXz44Yf4y1/+ArvdjunTp6O6uhoAoFarAcApG9D5uvM9X2LwF4e9/QNAx5C+y1IXo0dtbSaUX67v93z9/WG12NDaaoRSGSlZGYjcUVVVBaVS6XgdHt51lcqqqiqsXLkSBw8e7NJpryd5eXnIy8tzvJ4+fTrGjBmDbdu2Yd26df0vOMkCa/4DnK61HYXHLkkaWHtjMllQVq6GzeaZ+fr741p/V/oL0BoESUOpVDpt3QX/U6dOoaGhAVOmTEFISAhCQkJw+PBhvP766wgJCYHN1veIn9DQUEyePBllZWUAgOTkZABAfX2903H19fWO93yJNX9xGPwHsI5V+i7IdkifxWJFaVmdbMrXou1f6j8wv0LILZ7M+7tg5syZKCkpQXFxsWO76aabcN9996G4uBjBwcF9nsNms6GkpAQpKSkAgIyMDCQnJ+PQoUOOY3Q6HY4fP+6UMfAVBn9xmPYfoOQ+pM9qtaG0TA2TyXML9fSX1WqHTtcOlSpK6qIQeURsbCzGjx/vtC86OhoJCQmO/fn5+UhLS3P0CXjhhRdw6623IjMzE1qtFi+99BKuXr2Khx56CAAc8wSsX78eWVlZyMjIwLPPPovU1FQsWrTIp/dH4jH4D0ByH9Jnt9tRfrke7e1mqYvShUZrYPAnr5Hjwj6VlZVOY901Gg0efvhhqNVqxMXFYerUqTh69CjGjh3rOGb16tUwGAx45JFHoNVqcfvtt2P//v0u9yvwJM7tL45CYBfnAefsuUpcuCjPnv2CIKD8cj1aWuQ5p35wcBByJwxHUJD7XwgjM5IwdcpIL5SK/J1Op4NKpcJHZ44iOjamX+cytOqxYPJ0tLS0OHX4CzSdz/SnP/0pQkNDRZ/HYrFg7969Afc82eY/wFRcaZB14L9ytVG2gR/oWD64tVW+5SMi8gSm/QeQhkZ5D+mrrrkm26aI613TGKBSRbv9uQDNHpIb5Jj293dM+4vD4D9AGNpMOH+hWrZD+urUGjQ0tEhdDJe0tLTBbrcH7Jzf5EWM/h7H4C8Og/8A0G4xICQkFHfeMQ4NDS24VFoLtVordbEcGpt0qK3VSF0Ml9lsdrTo2hE3yL3af6B+iRBJiUv6isPg78esdguaDGq0mXUYHJ2KMCEUiYkqJCaq0NLShkvf1qCyqlnSaWs1Gj0qK5sku75YWo3e7eBPROQvGPz9kCAIaDE241pbA+xCxwQ5DfpqNLepMShiMFQR8VCponDLzVmYMH44LpXWoqKiHlarb2fR0+naUXFFmoV6+ktM6p8VfyLfY9pfHAZ/P9NuMaBRXwuzreu62Ta7Fc1tamjaG6CMiMegyMGIjAzDpNwRGD82HWXlapSW1cFotHi9nAaDCZcr6v12sRybXUBLSzvi4lj7J89hk793BGoA7w8Gfz9htVvRbFCj1dR327ldsEPb3gRtezNiwwchLnIwwkIikJOdhtFZqaipbcbZc1XQ67v+gPAEo9Esm/n6++OaVs/gT0QDEoO/zAmCAJ3xGprb6h0pfjc+jVaTBq0mDaLCYhEXOQSRodFIHzoYQ9MSoNEY8HXJFTQ1tXqsvGazFaVlalit8pivvz90LW2w2ewIDnY19c/aB5GvMe0vDoO/jBktbWjU18Jka+/3udrMrWgztyIiJAqDIgcjJlyF+PgY/HDGeLS1m3DhQjUuVzT06xod8/XXwWyWz3z9/WG3C2hpaUN8vGszsgXqlwi5TgDQ35Ywpv2dMfiLw+AvQza7Fc2GeuhM1zx+bqO1DerWSoS2hWNQ5GAowwchKjIcU6eMwsTcEaisbMLXJVfc7hxos9lRVq72SX8CX9JoDS4HfyIif8HgLyOCIEBn0qDZUA+74N3as8VmQqO+BtcM9RgUmQBlRAJCQoIxcmQSMjIS0dTUiq+/uQKN1tDnuex2AZcr6mW7gmB/tOjcTf0TkS+x5i8Og79MGK3tHSl+q2/nlbcJVjS31eNae2PHEMGIBIQGh2HIECVm/mgC2tvNuHSpFpev1Hc7e2DHfP0N0On63zQhR4JdgLalDQku1P4D9DuESFIM/uIw+EusY3hePXRGz6f43SE4jRBQYVDkEISHRCAqKhyTJo1Abu5wVFY14dK3tWht/T7QV1U3Q6PpOzvgzzQavUvBn4jIXzD4S0hn1KDJoPZ6it89AlpNWrSatIgKjUVc1GBEhsYgOFiBjBGJyBiRCK3WgEvf1uJ4USkaG3VSF9jrdK3tLqX+A7UGQW7gQH+PY81fHAZ/CZisRjTqa2G0yrvG3GZpRVtLK8JDIhEXOQTRYUooFAoMGhSNtNR4DBmsRFBQEJqadAOuo9/1BLsAjdaAwQmxUheF/Bxjv+cx+IvD4O9DNrsN19oa0GJshj/9CZus7R0jBILCMChyMMJDIqEIUmBY+mCEhoYgKVEFvd6IxiYdtFqDbFcW7A+Npu/gH6DfIUSSYvAXh8HfR1qNWjQZ1LAJ/ltDttjNaDTUAgBGpYxHWmo8jEYLrlY24mplI2JiImC12tB8TT/gsgGtre2wWm0ICQmWuihERP3G4O9lZqsRjYZatFvkneIXKyIiFNmjU5E9OhUajf67HwJNjmxAU1MrNFq932cDBEGAVmvA4MHKHo8J1BoEkZRY8xeHwd9L7IIN19oaoW1vgj+l+F0lQIDihuls4+JiEBcXgwnjh6NOrcHVq42IjY1EujUBzdda0djo39kATR/Bn6gvbPP3PAZ/cThziRfoTS24qimFtr0RgfinGhwchKFpCbhteg5+fPdUTJ6UgazMFIwbm47s0alIiI9FUJD//cG1thphsfj/mgVEJN6WLVuQm5sLpVIJpVKJvLw8fPrpp71+5r333kNOTg4iIiIwYcIEfPLJJz4qbc9Y8/cgs9X0XYpfL3VRvE4QBJfWsempWaC93Yzma61oampFe7vZ+wX2AEEQoG0xYAhr/yQWq/4e5+ua/9ChQ7Fp0yZkZWVBEAS8++67WLhwIc6cOYNx48Z1Of7o0aNYsmQJNm7ciB//+MfYtWsXFi1ahNOnT2P8+PGiy91fDP4eYBfs0LQ1QDNAU/ye0l2zQJ1ai9bWdr/pG6C5pu8x+Adq+pBISr4O/gsWLHB6vWHDBmzZsgXHjh3rNvi/9tprmDt3Lp588kkAwLp163Dw4EG88cYb2Lp1q+hy9xeDfz/pTTo0GWphtftvW7Y44oN0Z7PA0LQEp9EC167pZZ8NaNV3pP5DQ9nrn2gg0emcJywLDw9HeHh4r5+x2Wx47733YDAYkJeX1+0xhYWFeOyxx5z2zZkzB/v27etXefuLwV+kjoVx6tBmaZW6KJLwVP28p2aBa9f0aGpuhUYjv2yARqtH4hCV1MUgIniu5p+enu60/7nnnsPzzz/f7WdKSkqQl5cHo9GImJgY7N27F2PHju32WLVajaSkJKd9SUlJUKvVosvsCQz+brILdmjbG6Fpa4QQ0Cl+z997d80CVdXNsssGaDSGboM/s/7UFzb5e56ngn9VVRWUyu+b9Hqr9WdnZ6O4uBgtLS3Ys2cPli5disOHD/f4A0COGPzdYDDr0Kivg9UujyAkKS9+A/XULFBTe62jb4DE2QC93giz2YqwMP75EA0Unb33XREWFobMzEwAwNSpU1FUVITXXnsN27Zt63JscnIy6uvrnfbV19cjOTm5/4XuB357ucBiM6PJUAeDeeAvYuMqX2U9umsWKL/cAHW9RtJsgEZrQFKic+2fHf6oT6z6e5wcxvnb7XaYTKZu38vLy8OhQ4ewatUqx76DBw/22EfAVxj8e2H/bpnbjhS/XeriBLzumgVKy9VobNRBq9HD5sNsgEaj7xL8icj3fB3816xZg3nz5mHYsGFobW3Frl27UFBQgAMHDgAA8vPzkZaWho0bNwIAVq5ciRkzZuDll1/G/PnzsXv3bpw8eRJvvvmm6DJ7AoN/D9rMrWjU18Fi7/7XHElX/bi+WWDqlFG4WtmIy5fVqLjSiMYmnU+yAQaDCWazBWFhoY59rPlTX1jx9zxfB/+Ghgbk5+ejrq4OKpUKubm5OHDgAO666y4AQGVlJYKCvp8/b/r06di1axeeeeYZPP3008jKysK+ffskHeMPMPh3YbVZ0GSog97cInVRZE0uX0DdNQucu1CN2lqN17MBGk0bkpJY+ycKJNu3b+/1/YKCgi777rnnHtxzzz1eKpE4DP7fEQQB2vYmXGtrYIrfFXKJ/te5sVmgrFyN8xeq0djonWzANY2ewZ9IYnJo8/dHDP4A2sx6NBpqYbExxe8qOQ9zvL5ZYNrNWaisasLZ85W4XNEA7TXPZQPa2kwwmSwIDw/t+2Ai8ppADeD9EdDB32q3oMmght6klboofki+wf96kZFhTs0C5ZfVOPP1FdTWajySDdBoDUhOGtT/ghIR+VBABn9BENBibEZzWz0EgSl+Mfwj9DuLi4vBTVMzMXnSSNSpNfim5CrOX6iB5lqr6GyARvN98Gftg/rEHn8ex7S/OAEX/NstBjTqa2G2GaUuin8T/Pcb6PpmgR/OGI/LFfU4feYyKq40oq3NvaaftjYTjEYLIiKY+ifX+O9fjjwx+IsT1PchA4PVbkV9azVqWi4z8JNDZGQYxo1Nx7/eNwO/+be5mDtnEpKTByE4yPUvBI22YwnnAP0OIT+yadMmKBQKpwlnbvTWW2/hBz/4AeLi4hAXF4dZs2bhxIkTTsfcf//9jqDbuc2dO9fLpSdPGvA1/44U/zVca6uHXbBJXZwBQ84d/sSKi4vBnXeMww9uG4Oq6iYUnSzHhUs1aDP0ng3QaAxISY7zUSmJxCkqKsK2bduQm5vb63EFBQVYsmQJpk+fjoiICLz44ouYPXs2zp07h7S0NMdxc+fOxTvvvON43dcKeN7Cmr84Azr4Gy1taNTXwmRrl7oo5EeCg4MwYngiRgxPRHu7GWfPVeLk6cuormrqtm9Ae7sZ7UZzwH6JkBskavPX6/W477778NZbb2H9+vW9HvvXv/7V6fWf/vQnvP/++zh06BDy8/Md+8PDwyWfnx5g8BdrQKb9bXYrGlprUN1SzsBP/RIZGYabb8rE8kdmY+Vv5+P227KhVEZ2OU6jMUhQOgpkOp3OaetpbnkAWLFiBebPn49Zs2a5fZ22tjZYLBbEx8c77S8oKEBiYiKys7OxfPlyNDc3u31uks6AqvkLggCdUYPmNjVT/F4m+HGHP7ESh6jw47tvwrw5U3DxUg1OFJWhrLwONpsAjUbPNn/qkycr/q6uP797926cPn0aRUVFoq731FNPITU11emHw9y5c/Gzn/0MGRkZKC8vx9NPP4158+ahsLAQwcHBoq4jFmv+4gyY4G+0tKHRUAuTlTV93wi84N8pODgI48amY9zYdOha23CyqBynv65Aa6sRFosFoaHs+U/e58r681VVVVi5ciUOHjyIiIgIt6+xadMm7N69GwUFBU6fX7x4sePfEyZMQG5uLkaNGoWCggLMnDnT7ev0R1BQkNNc+mI+H4j8Pvjb7FY0t9VDZ7wmdVEoACljo/CjH01AbKwRe977Ey5NmIBf/vKXUheLAoAr68+fOnUKDQ0NmDJlimOfzWbDV199hTfeeAMmk6nHmvof//hHbNq0CZ9//nmfnQRHjhyJwYMHo6yszOfBnzV/cfw2+AuCgFaTFk0GNeyCVeriBJyB2Nu/P0JDQ9Hc3Izz589LXRQih5kzZ6KkpMRp3wMPPICcnBw89dRTPQb+zZs3Y8OGDThw4ABuuummPq9TXV2N5uZmpKSkeKTc5H1+GfxN1nY06mthtLZJXZTAxdjvZPTo0QgKCkJDQwOam5uRkJAgdZGIEBsb22Xp2OjoaCQkJDj237j+/Isvvoi1a9di165dGDFiBNRqNQAgJiYGMTEx0Ov1+P3vf4+f//znSE5ORnl5OVavXo3MzEzMmTPHtzcI1vzF8qvGDpvdhkZ9Laq05Qz8EmPsdxYVFYURI0YAAC5cuCBtYUi2BMEzmydVVlairq7O8XrLli0wm834xS9+gZSUFMf2xz/+EQAQHByMb775Bj/5yU8wevRoLFu2DFOnTsX//d//STLW/8bJhsRsgchvav46owbNBjVsTPHLBMP/jcaMGYPLly/jwoULuP3226UuDlG3blxv/sbXV65c6fXzkZGROHDggGcLRT4n+5q/yWpEtfYyGvTVDPwka2PGjAEAXLp0CXY7F4wi8gXW/MWRbc3fLthwra0B2vZmsJYpP+zw19WIESMQEREBg8GAyspKRzMAEXkP2/zFkWXN32Rtx9VrpdC2N4GBX6b4n6WL4OBgZGdnA2C7PxHJmyyDf2hwGGdLkznW/LvXmfpn8KfuCB7a6HtM+4sjy+AfpAjG4OhUqYtB5LbO4H/58mUYjVw6mm7A6O9xDP7iyDL4A0BMuBJRobFSF4N6wJp/94YMGYKEhATYbDaUlpZKXRyiAY/BXxzZBn8AGBKTCoW8i0jkRKFQYOzYsQCY+ici+ZJ1ZA0NDkN8VKLUxaDuBOCqfq7KyckBwOBP5Aus+Ysj6+APAIMiByM02PezRlHvGPp7lp2dDYVCAbVajWvXuOAUkTcx+Isj++CvUCgwhJ3/ZIjhvyfR0dEYPnw4AODixYsSl4aIqCvZB38AiAqLQWz4IKmLQeQytvtTd9jZ3/MUCgWCgoJEb6z5y1xCdAqCFN0vP0m+J7DNv1fXj/fnVL/kIMeVffwc0/7i+E3wDwkKQUJUktTFIHJJRkaGY6rfqqoqqYtDROTEb4I/ACgj4hEeEiV1MYj6FBwcjNGjRwNguz+RN7HmL45fBX+FQoEhMakAAvM/lpxwkp++dab+z58/L3FJSC7Y5u95DP7i+FXwB4CIkEioIuKlLgZRn66f6tdkMklcGiKi7/ld8AeA+KgkBCtCpS5GQGOHv74lJiYiPj4eVquVU/1SB1b9PY41f3H8MvgHBwVjcEyy1MUIcPwG6otCoeAqf0RexuAvjl8GfwCIDR+EyNAYqYsRsBj6XcPgT+RdDP7i+G3wBzoX/gnM/3DkH3JycqBQKFBXVwetVit1cYiIAPh58A8LDkdc1BCpixGgWPd3RXR0NIYNGwaAtX+inthsNhQXF0Oj0bj92UCt+fe3MuHXwR8ABkUOQUhQmNTFCDjs7+c6pv6pE/v7dVi1ahW2b98OoCPwz5gxA1OmTEF6ejoKCgrcOlcgBP8XX3wRf/vb3xyv7733XiQkJCAtLQ1ff/21qHP6ffAPUgQhMYYL//jeQPgK8o3r5/nnVL9EwJ49ezBx4kQAwEcffYSKigpcvHgRv/vd7/Af//EfEpdOfrZu3Yr09HQAwMGDB3Hw4EF8+umnmDdvHp588klR5/T74A8AUWGxiAlTSV0Mom5lZGQgPDwcer0eNTU1UheHpMSqPwCgqakJyckdI7Y++eQT3HPPPRg9ejQefPBBlJSUuHWuQKj5q9VqR/D/+OOPce+992L27NlYvXo1ioqKRJ1zQAR/ABgckwKFYsDcjuxxhj/XhYSEOKb6ZeqfCEhKSsL58+dhs9mwf/9+3HXXXQCAtrY2BAe7t4Bbf1b069zkLi4uzrFGyP79+zFr1iwAHfOt2Gw2UeeU/127KCQolAv/+BJjv1tycnIAMPgTAcADDzyAe++9F+PHj4dCoXAEs+PHjzv+Vuh7P/vZz/Av//IvuOuuu9Dc3Ix58+YBAM6cOYPMzExR5wzxZAGlpopIgM6ogdlmlLooRE462/3LyspgNpsRFsZOqoHIE1n7gfC7+/nnn8f48eNRVVWFe+65B+Hh4QA6FsT693//d7fO1d/UvT+k/V955RWMGDECVVVV2Lx5M2JiOua4qaurw7/927+JOueACv4KhQKJMWmobimXuigDHtP+7klKSkJcXBw0Gg3KysocPwaIAtUvfvELAIDR+H1lbenSpW6fJxCCf2hoKJ544oku+3/3u9+JPueACv4AEBEaBWVEPHTGa1IXZYBj8HdH51S/R48exYULFxj8KaDZbDb84Q9/wNatW1FfX49vv/0WI0eOxLPPPosRI0Zg2bJlUhdRcv/7v//r8rE/+clP3D7/gAv+AJAQlQS9SQe7YJW6KAMWQ7/7rg/+FKCY9wcAbNiwAe+++y42b96Mhx9+2LF//PjxePXVV90K/gO15r9o0SKn1wqFwmlBtevLLabT34Dp8He94KAQDI7mwj9exVl+3NY51W9NTQ1aWlqkLg6RZHbu3Ik333wT9913n1Pv/okTJ+LixYtunWugDvWz2+2O7bPPPsOkSZPw6aefQqvVQqvV4pNPPsGUKVOwf/9+UecfkDV/AFBGxEFn1MBoNUhdFCIAQExMDNLT01FZWYmLFy9i2rRpUheJSBI1NTXd9lK32+2wWCxunWug1vyvt2rVKmzduhW33367Y9+cOXMQFRWFRx55RFQ2cUDW/Dt1zPwn//+w/ohzKojTOdXv+fPnJS4JkXTGjh2L//u//+uyf8+ePZg8ebIEJZK38vJyDBo0qMt+lUqFK1euiDrngK35A0BYSAQGRQ6Gtr1R6qL4lSBFCEKDQhESHIqQoOu26177w69lORozZgwOHDiAixcvQhAEPscAwyb/DmvXrsXSpUtRU1MDu92ODz74AJcuXcLOnTvx8ccfu32+gf53dPPNN+Oxxx7Dn//8ZyQldcxnU19fjyeffBK33HKLqHMO6OAPAPFRidCbtLDa3UslDVRBiuBug3lIUChCg0MRHBSKINbqvWbkyJEICwuDTqdDTU0Nhg4dKnWRiHxu4cKF+Oijj/DCCy8gOjoaa9euxZQpU/DRRx85ZvtzVSCk/d9++2389Kc/xbBhwxzT/FZVVSErKwv79u0Tdc4B/y0fpAjCkOjAWPgnSBGMsOAIRIXGQhkej/ioJCTGDEWqMgPDBo3GyIRxGJkwFsPispCqGoHEmDTERyVCGRGHqLAYhAaHM/B7WWhoKKf6Jcls2rQJCoUCq1at6vW49957Dzk5OYiIiMCECRPwySefOL0vCALWrl2LlJQUREZGYtasWSgtLXWrLD/4wQ9w8OBBNDQ0oK2tDUeOHMHs2bPdvSWf27hxI26++WbExsYiMTERixYtwqVLl3r9zI4dO7p0MoyIiHD5mpmZmfjmm2/w0Ucf4be//S1++9vf4uOPP0ZJSQln+OtNdLgS0SYlDGad1EURTYGgbtPwod/9OzgoFMFB7s2JTdLIycnB2bNnceHCBbdrOeTnJMz7FxUVYdu2bcjNze31uKNHj2LJkiXYuHEjfvzjH2PXrl1YtGgRTp8+jfHjxwMANm/ejNdffx3vvvsuMjIy8Oyzz2LOnDk4f/68W0HNE3xd8z98+DBWrFiBm2++GVarFU8//TRmz56N8+fPIzo6usfPKZVKpx8J7l5XoVBg9uzZHvuBFBDBHwAGR6egzayHAPktqaqAAsHfpd1DgsIQEhTS8b/BIY7XwUEB859qwLt+ql+LxYLQ0FCJS0S+IlXs1+v1uO+++/DWW29h/fr1vR772muvYe7cuY6lYtetW4eDBw/ijTfewNatWyEIAl599VU888wzWLhwIYCOoXtJSUnYt28fFi9e3Gd54uLiug1+nTXizMxM3H///XjggQf6PJevg/+NQ+t27NiBxMREnDp1CnfccUev1+lcyVAMg8GAw4cPo7KyEmaz2em93/72t26fL2AiSmhwGOKjEtHcpvbxlRXdtrGHBoUi+LuaOwN7YElOTsagQYOg1WpRVlbmGAFA5A6dzjmTGR4e7pgj/0YrVqzA/PnzMWvWrD6Df2FhIR577DGnfXPmzHG0LVdUVECtVjsW4wE6ep1PmzYNhYWFLgX/tWvXYsOGDZg3b56jw9qJEyewf/9+rFixAhUVFVi+fDmsVqvTJEDe5M7zvF7nnB3x8fG9HqfX6zF8+HDY7XZMmTIFf/jDHzBu3DiXynbmzBncfffdaGtrg8FgQHx8PJqamhAVFYXExEQG/74MihyMVpPWgwv/KL6rpd8Y3L+rvQeHIlgR4hcdSsh3Oqf6LSwsxIULFxj8SZTOjl+dnnvuOTz//PNdjtu9ezdOnz7t8rrvarXa0aO8U1JSEtRqteP9zn09HdOXI0eOYP369Xj00Ued9m/btg2fffYZ3n//feTm5uL111/vM/j3d1nezs+6+jyvZ7fbsWrVKtx2222OJpHuZGdn4+2330Zubi5aWlrwxz/+EdOnT8e5c+dc6vT7u9/9DgsWLMDWrVuhUqlw7NgxhIaG4le/+hVWrlzZ9012I6CCv0KhwJCYVNS0XHbp+GDF9+3qwUGhCAkKQWhwmCPYBwcxsJM41wd/CiAezPtXVVVBqVQ6dndXS62qqsLKlStx8OBBn7fF9+bAgQN48cUXu+yfOXMmHn/8cQDA3Xff7dIKf55K+7vyPG+0YsUKnD17FkeOHOn1uLy8POTl5TleT58+HWPGjMG2bduwbt26Pq9TXFyMbdu2ISgoCMHBwTCZTBg5ciQ2b96MpUuX4mc/+1mf57hRQAV/AIgMjUZseBzazK1dh7vd0KGOgZ28JTs7GwBQXV0NnU7n9KVD5AqlUtnn/29OnTqFhoYGTJkyxbHPZrPhq6++whtvvAGTyeQ0vS7Q0SxVX1/vtK++vt7RXt35v/X19UhJSXE6ZtKkSS6VPT4+Hh999FGXVek++ugjR/rcYDAgNjbWpfN5givP83q//vWv8fHHH+Orr75ye8huaGgoJk+ejLKyMpeP78xQJCYmorKyEmPGjIFKpUJVVZVb1+4UcMEfAJJiObaapKVUKpGeno6qqipcvHhR9EQdRL2ZOXMmSkpKnPY98MADyMnJwVNPPdUl8AMdtdRDhw45DQc8ePCgo+aakZGB5ORkHDp0yBHsdTodjh8/juXLl7tUrmeffRbLly/Hl19+6fj/flFRET755BNs3brVcc0ZM2b0eS5fd/gTBAG/+c1vsHfvXhQUFCAjI8Pta9psNpSUlODuu+926fjJkyejqKgIWVlZmDFjBtauXYumpib8+c9/7rW5oTcBGfyJ5GDMmDGoqqrChQsXGPwDhK97+8fGxnYJDtHR0UhISHDsz8/PR1paGjZu3AgAWLlyJWbMmIGXX34Z8+fPx+7du3Hy5Em8+eabAOCYJ2D9+vXIyspyDPVLTU3tshJdTx5++GGMHTsWb7zxBj744AMAHdmww4cPY/r06QDgSP/3xdfBf8WKFdi1axc+/PBDxMbGOvo5qFQqREZGAuj6TF944QXceuutyMzMhFarxUsvvYSrV6/ioYcecumaf/jDH9Da2gqgY0XE/Px8LF++HFlZWXj77bfdKn8nBn8iiYwZMwafffYZLly4wKl+STKVlZVOHeamT5+OXbt24ZlnnsHTTz/tmEXu+h8Rq1evhsFgwCOPPAKtVovbb78d+/fvd6tfwW233Ybbbrut3+X3VIc/V23ZsgUAcOeddzrtf+edd3D//fcD6PpMNRoNHn74YajVasTFxWHq1Kk4evSoY9hvX2666SbHvxMTE0Wv5Hc9hSBwbVYiKVgsFjz++OOwWCx45plnkJaWJnWRyEt0Oh1UKhV2Hv4nomJi+nWuNr0e+TNuQ0tLi1/1FblxKF1vXLmvzmf6X//1X44atxjt7e34zW9+I+vn+dxzz+HBBx/E8OHDPXZOzuVKJJHQ0FBkZWUBgNtrmBP5m0GDBiEuLs6lzR03TpsrZpO7Dz/8EKNGjcLMmTOxa9cumEymfp+TwZ9IQlziN7AIgmc2f/Tll1/iiy++wBdffIG3334biYmJWL16Nfbu3Yu9e/di9erVSEpKcrsNOxCCf3FxMYqKijBu3DisXLkSycnJWL58uctzN3SHbf5EEuoM/qWlpZzqlwa063vuv/DCC/jP//xPLFmyxLHvJz/5CSZMmIA333wTS5culaKIsjZ58mRMnjwZL7/8Mj766CO88847uO2225CTk4Nly5bh/vvvh0qlcvl8rPkTSSg1NRUqlQoWiwXl5eVSF4fIJwoLC506sXW66aabcOLECbfOFQg1/+sJggCLxQKz2QxBEBAXF4c33ngD6enp+Nvf/ubyeRj8iSSkUCiQk5MDgEv8UuBIT0/HW2+91WX/n/70py7T7PYlUIL/qVOn8Otf/xopKSn43e9+h8mTJ+PChQs4fPgwSktLsWHDBrfm+Gfan0hiY8eOxfHjx3HhwgX89Kc/lbo4RF73yiuv4Oc//zk+/fRTTJs2DUDHwj7ffvutY9w/fW/ChAm4cOEC5syZg+3bt2PBggVdJmhasmSJW/P8M/gTSayz5l9VVYXW1lafTmlKJIW7774bpaWl2LJliyPjtWDBAjz66KNu1/x9Pc5fCvfeey8efPDBXocDDx48GHa760vWM/gTSUypVGLo0KGorq7GxYsXcfPNN0tdJPIWX0/xJ2MVFRW4cuUK6urqsGfPHqSlpeHPf/4zMjIycPvtt7t8Hl/P8OcrNy6r/PLLL/d47H/+53+6fX4GfyIZGDNmDKqrq3HhwgUGfxrw3n//ffzrv/4r7rvvPpw5c8Yxbr2lpQV/+MMf8Mknn0hcQumdOXPG6fXp06dhtVodi4J9++23CA4OxtSpU0WdX/75DqIA0Dnkr3OqXxqYBA9t/m79+vXYunUr3nrrLafhrbfddhtOnz7t9vkGYme/L7/80rEtWLAAM2bMQHV1NU6fPo3Tp0+jqqoKP/zhDzF//nxR52fwJ5KBUaNGITQ0FFqt1rFQCNFAdenSJdxxxx1d9qtUKmi1WrfOFQi9/V9++WVs3LjRafbDuLg4rF+/vtfmgN4w+BPJQFhYGDIzMwFwyB8NfMnJyd2uZX/kyBGMHDnSrXN1dvjrzyZ3Op0OjY2NXfY3NjY6Vvtzl/zvmihAXJ/6JxrIHn74YaxcuRLHjx+HQqFAbW0t/vrXv+KJJ57A8uXLpS6e7Pz0pz/FAw88gA8++ADV1dWorq7G+++/j2XLluFnP/uZqHOywx+RTHQG/2+//ZZT/Q5Q7Ozf4d///d9ht9sxc+ZMtLW14Y477kB4eDieeOIJ/OY3v3HrXAO1t//1tm7diieeeAL/8i//AovFAgAICQnBsmXL8NJLL4k6J4M/kUykpaVBqVRCp9OhoqICo0ePlrpI5GmM/gA6Au5//Md/4Mknn0RZWRn0ej3Gjh2LGBHLHQdC8I+KisL//M//4KWXXnJMAz5q1ChER0eLPieDP5FMdE71e+LECVy4cIHBnwa8sLAwjB07Vupi+I3o6Gjk5uZ65Fxs8yeSkc4vQrb7E7kmEHr7ewNr/kQy0jnVb2VlJfR6vag0KFEgCYS0vzew5k8kIyqVCmlpaRAEAZcuXZK6OEQ0QDH4E8lMZ+3//PnzEpeEPI5T/HlcIIzz94bAvGsiGbu+3Z9T/Q4sjP2exzZ/cRj8iWQmMzMTISEh0Gg0qK+vl7o4RDQAMfgTyUxYWBhGjRoFgL3+ifrCmr84DP5EMsQhf0SuYfAXh8GfSIY6p/otKyuDzWaTuDTkKWzz9zx2+BOH4/yJZCgtLQ2PPPIIBiWnIDg4WOriENEAE5g/eYhkLigoCBMmTsTZxmboTSapi0OexGq/RzHtLw6DP5FMma1WWGw2nKiohM1ul7o45BFM/Hsag784DP5EMmW2drT1a9vbcbamTuLSENFAwuBPJFMmq9Xx7/KmZlRrtNIVhkimWPMXhx3+iGTq+uAPAKcrqzEoKhIx4eESlYj6zRNZe2b9nXBhH3FY8yeSKfMNwd9qt+NExVW2/xNRvzH4E8mUydp1fL+23YgStv8TOSgUin6N8Q/Umj/T/kQydWPav9PlpmYkREchPT7OxyWi/mLW3/OY9heHNX8imbox7X+9M1U10Bs5/p+IxGHwJ5Kp7tL+nax2O45XXIWV7f/Uhy1btiA3NxdKpRJKpRJ5eXn49NNPezz+zjvv7LZH/Pz58x3H3H///V3enzt3ri9upwv29heHaX8imeqt5g8ALUYjvqmuxZRhQ31UIvJHQ4cOxaZNm5CVlQVBEPDuu+9i4cKFOHPmDMaNG9fl+A8++ABms9nxurm5GRMnTsQ999zjdNzcuXPxzjvvOF6HSzQKhWl/cRj8iWTK7MKCPlear2FITDTb//2FBI3+CxYscHq9YcMGbNmyBceOHes2+MfHxzu93r17N6KioroE//DwcCQnJ7tXGC/o7+I8gbqwT2DeNZHMCYLQY4e/G52pqkGr0ejlEpHc6HQ6p83kwhoQNpsNu3fvhsFgQF5enkvX2b59OxYvXozo6Gin/QUFBUhMTER2djaWL1+O5uZmUfdB0mDwJ5IhV2r9nTrG/1ey/d8PeHJm//T0dKhUKse2cePGHq9bUlKCmJgYhIeH49FHH8XevXsxduzYPst74sQJnD17Fg899JDT/rlz52Lnzp04dOgQXnzxRRw+fBjz5s2TZPlptvmLw7Q/kQyZLK7V+jux/T/wVFVVQalUOl731uaenZ2N4uJitLS0YM+ePVi6dCkOHz7c5w+A7du3Y8KECbjllluc9i9evNjx7wkTJiA3NxejRo1CQUEBZs6cKfKOyJdY8yeSIbPNveAPdLT/V17TeKE0JEedvfc7t96Cf1hYGDIzMzF16lRs3LgREydOxGuvvdbr+Q0GA3bv3o1ly5b1WZaRI0di8ODBKCsrc/s+SBqs+RPJUG/D/HpTXFWDQZGRUEZGeLhENJDY7fY++wi89957MJlM+NWvftXn+aqrq9Hc3IyUlBRPFdFl7O0vDmv+RDLkbtq/k9Vux4krbP+XLU82+rtozZo1+Oqrr3DlyhWUlJRgzZo1KCgowH333QcAyM/Px5o1a7p8bvv27Vi0aBESEhKc9uv1ejz55JM4duwYrly5gkOHDmHhwoXIzMzEnDlz3CucB7DNXxzW/IlkSEzav5POaMTXVTWYOjzdgyUif9XQ0ID8/HzU1dVBpVIhNzcXBw4cwF133QUAqKys7DLc7dKlSzhy5Ag+++yzLucLDg7GN998g3fffRdarRapqamYPXs21q1bJ9lYf3Ifgz+RDIlN+3e6ek2DwTExGJ7A8f+Bbvv27b2+X1BQ0GVfdnY2BKH7FENkZCQOHDjgiaJ5BNP+4jD4E8lQX7P7ueLr6hrERbH9nwY2Bn9x2OZPJEOeCP6O+f8lGHtNRPLG4E8kQ67O7teXVpMJxVU1HjkXkRyxw584TPsTyVB/2/yvV6nRYnBMDEYMju/7YPIuCeb2H+iY9heHNX8iGfJE2v96X1fXoKW93aPnJJIDX9f8N27ciJtvvhmxsbFITEzEokWLcOnSpT4/99577yEnJwcRERGYMGECPvnkE7G37BEM/kQyY7XZYOuhp7VYNkHomP+f7f9E/XL48GGsWLECx44dw8GDB2GxWDB79mwYDIYeP3P06FEsWbIEy5Ytw5kzZ7Bo0SIsWrQIZ8+e9WHJnTHtTyQzRg/X+ju1mkw4U1WDm0cM88r5qW/M+vu//fv3O73esWMHEhMTcerUKdxxxx3dfua1117D3Llz8eSTTwIA1q1bh4MHD+KNN97A1q1bvV7m7rDmTyQzZg+299+oSqPFlaZrXjs/ka95Ku0vZolkAGhpaQEAxMf33KemsLAQs2bNcto3Z84cFBYWirzr/mPwJ5IZT7f33+jr6hpo29j+T3Q9d5ZI7mS327Fq1SrcdtttGD9+fI/HqdVqJCUlOe1LSkqCWq3ud7nFYtqfSGY82dO/OzZBwIkrlfhhdiZCg4O9ei26AfP+Huep3v7uLJHcacWKFTh79iyOHDki+vpSYfAnkpn+zOvvKr3JhDOVNbglg+3/5N88Ffw7l0Z21a9//Wt8/PHH+OqrrzB06NBej01OTkZ9fb3Tvvr6eiQnJ7tfYA9h2p9IZsSu6Oeuaq0WlxubfXItooFCEAT8+te/xt69e/HFF18gIyOjz8/k5eXh0KFDTvsOHjyIvLw8bxWzT6z5E8mMp2b3c0VJTS3io6MwKCrSZ9ck8jRfTtSzYsUK7Nq1Cx9++CFiY2Md7fYqlQqRkR1/R/n5+UhLS3P0G1i5ciVmzJiBl19+GfPnz8fu3btx8uRJvPnmmz4r941Y8yeSGbMPx+J3jP+/CgvH//uI4KGNOvl6kp8tW7agpaUFd955J1JSUhzb3/72N8cxlZWVqKurc7yePn06du3ahTfffBMTJ07Enj17sG/fvl47CXoba/5EMuOrtH8nvdmM05XVmJYx3KfXJfJHPS11fL3ulkm+5557cM8993ihROKw5k8kM94e6tedGm0LyhubfH7dgMOKv8dxYR9xWPMnkhmTRCn4kpo6JERHs/2f/AoX9hGHNX8iGbELgmTt73a2/xMFDAZ/IhmRIuV/vc72fyIa2Bj8iWTEl8P8elKjbUFZA9v/vYJt/h7HNn9x2OZPJCPeXNTHHWdr65AQHYW46Cipi0LUK7b5i8OaP5GMyKHmD3zX/n+lUvJmCCLyDgZ/IhmRS/AHAAPb/8kPMO0vDoM/kYzIJe3fqbZFh7KGRqmLQdQjBn9xGPyJZERONf9OZ2vVuGZok7oYRORBDP5EMiLH4N/R/n+V7f8kS6z5i8PgTyQjckv7d2ozW3CK7f/9x6F+HsfgLw6DP5GMyLl2XdeiQynb/4kGBI7zJ5IRk02+wR8AztWqER8VhYSYaKmLQgSA4/zFYs2fSEbkmvbvZBcEFF2tlGXfBApMTPuLw+BPJBNmqxV2F9YKl1qb2YJTV6tcWtecbsA2f5IJBn8imZB7rf96al0rSjn/P5HfYps/kUz4Wyr9XG0d4qOjMJjt/yQhtvmLw5o/kUz4W/AXABRdYfs/SYtt/uIw+BPJhD+l/Tu1Wyw4yfZ/Ir/D4E8kE3If5teTel0rvuX4f9nasmULcnNzoVQqoVQqkZeXh08//bTH43fs2NGlZhwREeF0jCAIWLt2LVJSUhAZGYlZs2ahtLTU27fSLdb8xWHwJ5IJOU/w05fztWo06Q1SF4O6MXToUGzatAmnTp3CyZMn8aMf/QgLFy7EuXPnevyMUqlEXV2dY7t69arT+5s3b8brr7+OrVu34vjx44iOjsacOXNgNBq9fTtdMPiLw+BPJBP+mPbvJAA4ceUqjBaL1EWhGyxYsAB33303srKyMHr0aGzYsAExMTE4duxYj59RKBRITk52bElJSY73BEHAq6++imeeeQYLFy5Ebm4udu7cidraWuzbt88Hd0SewOBPJBNGP675A4DRYuX4/z4oBM9sAKDT6Zw2k8nU5/VtNht2794Ng8GAvLy8Ho/T6/UYPnw40tPTu2QJKioqoFarMWvWLMc+lUqFadOmobCwUPzDEYk1f3EY/Ilkwp/T/p3qW/X4tp7t/z3z3Cw/6enpUKlUjm3jxo09XrWkpAQxMTEIDw/Ho48+ir1792Ls2LHdHpudnY23334bH374If7yl7/Abrdj+vTpqK7uWNhJrVYDgFM2oPN153u+xOAvDsf5E8mEP6f9r3e+To346CgMiY2RuigDWlVVFZRKpeN1eHh4j8dmZ2ejuLgYLS0t2LNnD5YuXYrDhw93+wMgLy/PKSswffp0jBkzBtu2bcO6des8exMkGdb8iWRioIyXFwAUXa1k+7+Xdfbe79x6C/5hYWHIzMzE1KlTsXHjRkycOBGvvfaaS9cJDQ3F5MmTUVZWBgBITk4GANTX1zsdV19f73iP5I/Bn0gGrHY7rHa71MXwGKPFyvH/3ZHJ3P52u92lPgJARz+BkpISpKSkAAAyMjKQnJyMQ4cOOY7R6XQ4fvx4r/0IvIkpf/cx7U8kAwOhvf9GDa16XKpvQE5yUt8Hk9esWbMG8+bNw7Bhw9Da2opdu3ahoKAABw4cAADk5+cjLS3N0WfghRdewK233orMzExotVq89NJLuHr1Kh566CEAHYF21apVWL9+PbKyspCRkYFnn30WqampWLRokc/vj9P7isPgTyQDA6W9/0bn6+qREB3N9n8JNTQ0ID8/H3V1dVCpVMjNzcWBAwdw1113AQAqKysRFPR9Elij0eDhhx+GWq1GXFwcpk6diqNHjzr1D1i9ejUMBgMeeeQRaLVa3H777di/f3+XyYBIvhQC83JEkqvXteKf5RVSF8MrIkJC8KOcLESEhkpdFMnodDqoVCq89b9fISq6fz+E2gx6PPyTO9DS0uLU4S/QdD7TM2fOIDY2VvR5WltbMXny5IB7nmzzJ5KBgZj272S0WlF0he3/5B0c6icOgz+RDJgGaNq/U6Nejwvq+r4PJCKfYJs/kQwMlGF+vbmobsDgmGgk9iNF6/c80VufCRQn7PAnDmv+RDIwkNP+1zt5pYrj/8mjmPYXh8GfSAbMtoGd9u9ktFpx4kol7Gz/J5IUgz+RDBgtgVHzB4AmvQEX2f5PJCm2+RPJQKCk/TtdVDcgIToaScoAa/8XhI6tv+cgB7b5i8OaP5EMBEra/3onr1ah3cz2fyIpMPgTSUwQhIDo7X8jE9v/yQPY4U8cBn8iiQVirb9Ts8GAC3W+XwOeKNCxzZ9IYoHW3n+jS/WNSIiJQXIAtP8rvtv6ew76Htv8xWHNn0higZjyv9Gpq1VoM5ulLgZRwGDwJ5LYQJ/a1xUmqxVFbP8nEdjmLw6DP5HEAj3t36nZ0IbztQO8/V/w0EYODP7iMPgTSYxp/+9929AIdYtO6mIQDXgM/kQSY9rf2Um2/xN5HYM/kcSY9ndmttkGbvs/0/4ex7S/OAz+RBJj8O+q2dCGc7V1UheDaMBi8CeSGNP+3SttaEId2/+pD6z5i8PgTyQxdvjrGcf/U18Y/MVh8CeSGNP+PTPbbDhRMUDb/8kvffXVV1iwYAFSU1OhUCiwb9++Xo8vKCjo9geHWi3tsFYGfyIJWW022BjYenWtrQ1nawZG+7/CQxtJx2AwYOLEifjv//5vtz536dIl1NXVObbExEQvldA1nNufSEJs73dNWWMTBsdEI3WQSuqi9JMnuuvzx+L1fD23/7x58zBv3jy3r5OYmIhBgwa5/TlvYc2fSEJM+buuoVUvdRH6j0P9PM5Tbf46nc5pM5lMHi3npEmTkJKSgrvuugv//Oc/PXpuMRj8iSTEzn6uGTVkMCYOTZW6GDSApaenQ6VSObaNGzd65LwpKSnYunUr3n//fbz//vtIT0/HnXfeidOnT3vk/GIx7U8kIab9+zY2JQk5yUlSF4MGuKqqKiiVSsfr8PBwj5w3Ozsb2dnZjtfTp09HeXk5XnnlFfz5z3/2yDXEYPAnkpDZxpp/byYOTcWoIYOlLgbJmKfa/JVKpVPw96ZbbrkFR44c8cm1esLgTyQhtvl3L0ihwNRhQ5EeHyd1UYg8rri4GCkpKZKWgcGfSEJGC4P/jUKCgnDLiGFIVvmmFuZT7Ozvcb7u7a/X61FWVuZ4XVFRgeLiYsTHx2PYsGFYs2YNampqsHPnTgDAq6++ioyMDIwbNw5GoxF/+tOf8MUXX+Czzz4TXWZPYPAnkpDZxjb/64UGByNv5AgMjomWuijkJ3wd/E+ePIkf/vCHjtePPfYYAGDp0qXYsWMH6urqUFlZ6XjfbDbj8ccfR01NDaKiopCbm4vPP//c6RxSYPAnkhDT/t+LCAnBbZkZUEVGSl0Uoh7deeedEHqZmGvHjh1Or1evXo3Vq1d7uVTuY/AnkhB7+3eIDgvDbZkZiPFQD2v5Yt6f5IHBn0hCHOcPqCIicFtmBiJCQ6UuCvmpQF2cpz8Y/IkkYhcEWAK8zT8hOgp5I0cgLIRfRUS+xL84IokEent/UmwMpo0cgZCgAJtolFl7j/J1h7+BIsD+6ojkI5BT/kMHDULeqIyAC/xSrOq3ZcsW5ObmOiaxycvLw6efftrj8W+99RZ+8IMfIC4uDnFxcZg1axZOnDjhdMz999/fZX78uXPnulkyklJg/eURyYg5QDv7ZSTE4+YR6QgK0BqXrw0dOhSbNm3CqVOncPLkSfzoRz/CwoULce7cuW6PLygowJIlS/Dll1+isLAQ6enpmD17NmpqapyOmzt3rtMStf/v//0/X9xOF55a2CfQMO1PJJFArPlnJyViXGqy1MUIKAsWLHB6vWHDBmzZsgXHjh3DuHHjuhz/17/+1en1n/70J7z//vs4dOgQ8vPzHfvDw8ORnMz/lv6KNX8iiQRa8M9NS2Hg9+CSvmKWoLXZbNi9ezcMBgPy8vJcKnJbWxssFgvi4+Od9hcUFCAxMRHZ2dlYvnw5mpubXTqfp7HmLw6DP5FEAiXtrwAwdVg6MhOHSF2UAcWdJWhLSkoQExOD8PBwPProo9i7dy/Gjh3r0nWeeuoppKamYtasWY59c+fOxc6dO3Ho0CG8+OKLOHz4MObNmwdbgI9e8SdM+xNJJBB6+wcrFLh5xDCkDlJJXZQBx50laLOzs1FcXIyWlhbs2bMHS5cuxeHDh/v8AbBp0ybs3r0bBQUFiIiIcOxfvHix498TJkxAbm4uRo0ahYKCAsycObMfd0W+wuBPJBHjAA/+IUFByBs5AkNiY6QuyoDkzhK0YWFhyMzMBABMnToVRUVFeO2117Bt27YeP/PHP/4RmzZtwueff47c3Nxezz9y5EgMHjwYZWVlPg/+HOonDoM/kUQGcto/PCQEt43KwKAoztPvTB7T+9rt9l77CGzevBkbNmzAgQMHcNNNN/V5vurqajQ3N0u+TC25jsGfSCIDNe0fFRaK20ZlIPa6NDFJZ82aNZg3bx6GDRuG1tZW7Nq1CwUFBThw4AAAID8/H2lpaY4+Ay+++CLWrl2LXbt2YcSIEVCr1QCAmJgYxMTEQK/X4/e//z1+/vOfIzk5GeXl5Vi9ejUyMzMxZ84cye6T3MPgTyQRk23gBf/Y8HDclpmBqLAwqYsiTxJU/BsaGpCfn4+6ujqoVCrk5ubiwIEDuOuuuwAAlZWVCLpusqUtW7bAbDbjF7/4hdN5nnvuOTz//PMIDg7GN998g3fffRdarRapqamYPXs21q1b12u/A29h2l8cBn8iiQy0tH9cVCSmj8pAOOfp75GYGfq6O4c7tm/f3uv7BQUFTq+vXLnS6/GRkZGOrAH5L/6VEknAYrPB3sua4P5mSEwM8kYOR0hwsNRFISIXMPgTSUChUOCm4ekwmMwwmEwwmM3Qm8x+OfFPqkqJm0cMQ3CAzdNP8sC0vzgM/kQSCAkKwrD4uC77LTYbDCYz9N/9IOj4cWCGwWxCm9kiQUl7Nzw+DpOHDeU8/a6SR2d/IgZ/IjkJDQ7GoKjIbofI2ex2tH33g0BvMnX873ev28xmnzcjZCUOxoS0VJ9e0/8x+nsaa/7iMPgT+YngoCDERkR0O4TOLghoN1tgMJugN3ZkCr7PGphhtds9WpZxqcnITkr06DmJyHcY/IkGgCCFAtHhYYgOD0NibNf3jRYL9Nc1IVz/A8Hs5nzsk9PTkDE4wUMlJyIpMPgTBYCI0FBEhIZicEx0l/fMVqsjQ+BoTvjuR4LR8n0HxKDvOikOjRvkw5IT9Y5pf3EY/IkCXFhICMJCQhAXHdXlPavd3jEawWRGeEgIErr58UBE/ofBn4h6FBIUBFVkJFSRnKPfI9jfj2SCwZ+IiPwW0/7icFYOIiKiAMPgT0REFGCY9ici8hW2+Xsc0/7isOZPREQUYBj8iYiIAgzT/kREPsW8PUmPwZ+IiPwW2/zFYdqfiIgowLDmT0TkK+ztTzLB4E9E5COK77b+noO+x7S/OEz7ExERBRgGfyIiogDDtD8Rka8IQsfW33OQA9P+4rDmT0REFGAY/ImIiAIM0/5EROS3mPYXhzV/IiKiAMPgT0REFGCY9ici8hXO8OdxTPuLw5o/ERFRgGHwJyIiCjBM+xMRkd9i2l8cBn8iIl9hmz/JBNP+REREAYY1fyIi8ltM+4vD4E9E5DPM+5M8MO1PRDSAbdmyBbm5uVAqlVAqlcjLy8Onn37a62fee+895OTkICIiAhMmTMAnn3zi9L4gCFi7di1SUlIQGRmJWbNmobS01Ju3IRtfffUVFixYgNTUVCgUCuzbt6/PzxQUFGDKlCkIDw9HZmYmduzY4fVy9oXBn4jIVwQPbW4YOnQoNm3ahFOnTuHkyZP40Y9+hIULF+LcuXPdHn/06FEsWbIEy5Ytw5kzZ7Bo0SIsWrQIZ8+edRyzefNmvP7669i6dSuOHz+O6OhozJkzB0aj0b3CeUBn2r8/mzsMBgMmTpyI//7v/3bp+IqKCsyfPx8//OEPUVxcjFWrVuGhhx7CgQMHxNyuxygEgYtDExF5k06ng0qlwo6dBxEVFd2vc7W1GXB//l1oaWmBUqkUdY74+Hi89NJLWLZsWZf3fvnLX8JgMODjjz927Lv11lsxadIkbN26FYIgIDU1FY8//jieeOIJAEBLSwuSkpKwY8cOLF68WNyNuanzmfbnOfT3PAqFAnv37sWiRYt6POapp57CP/7xD6cfT4sXL4ZWq8X+/fvFFrvf2OZPROQj7e0Gj51Dp9M57Q8PD0d4eHivn7XZbHjvvfdgMBiQl5fX7TGFhYV47LHHnPbNmTPHkd6uqKiAWq3GrFmzHO+rVCpMmzYNhYWFPgv+nW58DmI/L+Z5uqKwsNDpWQEdz3PVqlX9Pnd/MPgTEXlZWFgYkpOTsfz/W+SR88XExCA9Pd1p33PPPYfnn3++2+NLSkqQl5cHo9GImJgY7N27F2PHju32WLVajaSkJKd9SUlJUKvVjvc79/V0jC90PtMbn4MY7j5Pd/T0PHU6Hdrb2xEZGdnva4jB4E9E5GURERGoqKiA2Wz2yPkEQejSVt1bLTU7OxvFxcVoaWnBnj17sHTpUhw+fLjHHwD+wJPP1N3nORAw+BMR+UBERAQiIiIkuXZYWBgyMzMBAFOnTkVRURFee+01bNu2rcuxycnJqK+vd9pXX1+P5ORkx/ud+1JSUpyOmTRpkpfuoHtSPlNX9fQ8lUqlZLV+gL39iYgCjt1uh8lk6va9vLw8HDp0yGnfwYMHHX0EMjIykJyc7HSMTqfD8ePHe+xHEMj6ep5SYc2fiGgAW7NmDebNm4dhw4ahtbUVu3btQkFBgWOoWX5+PtLS0rBx40YAwMqVKzFjxgy8/PLLmD9/Pnbv3o2TJ0/izTffBNDRw33VqlVYv349srKykJGRgWeffRapqam99nofKPR6PcrKyhyvKyoqUFxcjPj4eAwbNgxr1qxBTU0Ndu7cCQB49NFH8cYbb2D16tV48MEH8cUXX+Dvf/87/vGPf0h1Cx0EIiIasB588EFh+PDhQlhYmDBkyBBh5syZwmeffeZ4f8aMGcLSpUudPvP3v/9dGD16tBAWFiaMGzdO+Mc//uH0vt1uF5599lkhKSlJCA8PF2bOnClcunTJF7cjuS+//LLb2Rc6n+HSpUuFGTNmdPnMpEmThLCwMGHkyJHCO++84/Ny34jj/ImIiAIM2/yJiIgCDIM/ERFRgGHwJyIiCjAM/kRERAGGwZ+IiCjAMPgTEREFGAZ/IiKiAMPgT0REFGAY/ImIiAIMgz8REVGAYfAnIiIKMP8/g1Ujy+DO8k4AAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -295,23 +295,23 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 8, "id": "a253c2e4", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 32, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -344,23 +344,23 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 9, "id": "1548e22b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 37, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -396,13 +396,13 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 10, "id": "8eeba210", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -446,7 +446,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 11, "id": "d677fbc5", "metadata": {}, "outputs": [ @@ -462,7 +462,7 @@ " 6: {2, 5}}" ] }, - "execution_count": 50, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -473,7 +473,7 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 12, "id": "4615bc2b", "metadata": {}, "outputs": [ @@ -494,7 +494,7 @@ " 12: {4}}" ] }, - "execution_count": 55, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } From 912a279497efdb22675ec30a546e04c6315a66b5 Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Mon, 9 Oct 2023 18:52:24 +0200 Subject: [PATCH 18/26] fix: added seaborn to default requirements --- requirements/default.txt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/requirements/default.txt b/requirements/default.txt index bb856f55a..afbb2b5ed 100644 --- a/requirements/default.txt +++ b/requirements/default.txt @@ -3,4 +3,5 @@ scipy>=1.8 pandas>=1.3 networkx>=2.7 requests>=2.0 -matplotlib>=3.4 \ No newline at end of file +matplotlib>=3.4 +seaborn>=0.10 \ No newline at end of file From 27779d34396557cc2500909c284f0b93c377656b Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Mon, 16 Oct 2023 10:45:45 +0200 Subject: [PATCH 19/26] fix: updated draw_simplices to make it consistent with draw_hyperedges --- xgi/drawing/draw.py | 136 ++++++++++++++++---------------------------- 1 file changed, 48 insertions(+), 88 deletions(-) diff --git a/xgi/drawing/draw.py b/xgi/drawing/draw.py index b999ab41e..0b12722e4 100644 --- a/xgi/drawing/draw.py +++ b/xgi/drawing/draw.py @@ -21,6 +21,7 @@ from ..algorithms import max_edge_order, unique_edge_sizes from ..core import DiHypergraph, Hypergraph, SimplicialComplex from ..exception import XGIError +from ..utils import subfaces from .draw_utils import ( _CCW_sort, _color_arg_to_dict, @@ -213,20 +214,27 @@ def draw( max_order = max_edge_order(H) if isinstance(H, SimplicialComplex): - ax = draw_simplices( + ax, (dyad_collection, edge_collection) = draw_simplices( SC=H, pos=pos, ax=ax, dyad_color=dyad_color, dyad_lw=dyad_lw, + dyad_style=dyad_style, + dyad_color_cmap=dyad_color_cmap, + dyad_vmin=dyad_vmin, + dyad_vmax=dyad_vmax, + alpha=alpha, edge_fc=edge_fc, + edge_fc_cmap=edge_fc_cmap, + edge_vmin=edge_vmin, + edge_vmax=edge_vmax, max_order=max_order, - settings=settings, hyperedge_labels=hyperedge_labels, + rescale_sizes=rescale_sizes, **kwargs, ) - dyad_collection = None # for compatibility with simplices until update - edge_collection = None # for compatibility with simplices until update + elif isinstance(H, Hypergraph): ax, (dyad_collection, edge_collection) = draw_hyperedges( @@ -685,10 +693,19 @@ def draw_simplices( ax=None, dyad_color="black", dyad_lw=1.5, + dyad_style="solid", + dyad_color_cmap="Greys", + dyad_vmin=None, + dyad_vmax=None, edge_fc=None, + edge_fc_cmap="crest_r", + edge_vmin=None, + edge_vmax=None, + alpha=0.4, max_order=None, - settings=None, + params=dict(), hyperedge_labels=False, + rescale_sizes=True, **kwargs, ): """Draw maximal simplices and pairwise faces. @@ -761,94 +778,37 @@ def draw_simplices( # Plot only the maximal simplices, thus let's convert the SC to H H_ = convert.from_max_simplices(SC) + # add the projected pairwise interactions + dyads = subfaces(H_.edges.members(), order=1) + H_.add_edges_from(dyads) + H_.cleanup(multiedges=False, isolates=True, connected=False, relabel=False, in_place=True, singletons=True) # remove multi-dyads + if not max_order: max_order = max_edge_order(H_) - ax, pos = _draw_init(H_, ax, pos) - - if edge_fc is None: - edge_fc = H_.edges.size - - if settings is None: - settings = { - "min_dyad_lw": 2.0, - "max_dyad_lw": 10.0, - "edge_fc_cmap": cm.Blues, - "dyad_color_cmap": cm.Greys, - } - - settings.update(kwargs) - - dyad_color = _color_arg_to_dict(dyad_color, H_.edges, settings["dyad_color_cmap"]) - dyad_lw = _scalar_arg_to_dict( - dyad_lw, - H_.edges, - settings["min_dyad_lw"], - settings["max_dyad_lw"], + ax, (dyad_collection, edge_collection) = draw_hyperedges( + H_, + pos=pos, + ax=ax, + dyad_color=dyad_color, + dyad_lw=dyad_lw, + dyad_style=dyad_style, + dyad_color_cmap=dyad_color_cmap, + dyad_vmin=dyad_vmin, + dyad_vmax=dyad_vmax, + edge_fc=edge_fc, + edge_fc_cmap=edge_fc_cmap, + edge_vmin=edge_vmin, + edge_vmax=edge_vmax, + alpha=alpha, + max_order=max_order, + params=params, + hyperedge_labels=hyperedge_labels, + rescale_sizes=rescale_sizes, + **kwargs, ) - edge_fc = _color_arg_to_dict(edge_fc, H_.edges, settings["edge_fc_cmap"]) - - # Looping over the hyperedges of different order (reversed) -- nodes will be plotted - # separately - for id, he in H_.edges.members(dtype=dict).items(): - d = len(he) - 1 - - if d == 1: - # Drawing the edges - he = list(he) - x_coords = [pos[he[0]][0], pos[he[1]][0]] - y_coords = [pos[he[0]][1], pos[he[1]][1]] - - line = plt.Line2D( - x_coords, - y_coords, - color=dyad_color[id], - lw=dyad_lw[id], - zorder=max_order - 1, - ) - ax.add_line(line) - else: - # Hyperedges of order d (d=2: triangles, etc.) - # Filling the polygon - coordinates = [[pos[n][0], pos[n][1]] for n in he] - # Sorting the points counterclockwise (needed to have the correct filling) - sorted_coordinates = _CCW_sort(coordinates) - obj = plt.Polygon( - sorted_coordinates, - facecolor=edge_fc[id], - alpha=0.4, - zorder=max_order - d, - ) - ax.add_patch(obj) - # Drawing all the edges within - for i, j in combinations(sorted_coordinates, 2): - x_coords = [i[0], j[0]] - y_coords = [i[1], j[1]] - line = plt.Line2D( - x_coords, - y_coords, - color=dyad_color[id], - lw=dyad_lw[id], - zorder=max_order - 1, - ) - ax.add_line(line) - - if hyperedge_labels: - # Get all valid keywords by inspecting the signatures of draw_node_labels - valid_label_kwds = signature(draw_hyperedge_labels).parameters.keys() - # Remove the arguments of this function (draw_networkx) - valid_label_kwds = valid_label_kwds - {"H", "pos", "ax", "hyperedge_labels"} - if any([k not in valid_label_kwds for k in kwargs]): - invalid_args = ", ".join([k for k in kwargs if k not in valid_label_kwds]) - raise ValueError(f"Received invalid argument(s): {invalid_args}") - label_kwds = {k: v for k, v in kwargs.items() if k in valid_label_kwds} - draw_hyperedge_labels(H_, pos, hyperedge_labels, ax_edges=ax, **label_kwds) - - # compute axis limits - _update_lims(pos, ax) - - return ax + return ax, (dyad_collection, edge_collection) def draw_node_labels( From 0e24377e11c8ee27123806a3a89ab1d4fe01d137 Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Mon, 16 Oct 2023 10:46:48 +0200 Subject: [PATCH 20/26] doc: updated docstrings accordingly --- xgi/drawing/draw.py | 55 ++++++++++++++++++++++++++++++--------------- 1 file changed, 37 insertions(+), 18 deletions(-) diff --git a/xgi/drawing/draw.py b/xgi/drawing/draw.py index 0b12722e4..abdfc58bc 100644 --- a/xgi/drawing/draw.py +++ b/xgi/drawing/draw.py @@ -714,12 +714,12 @@ def draw_simplices( ---------- SC : SimplicialComplex Simplicial complex to draw - ax : matplotlib.pyplot.axes, optional - Axis to draw on. If None (default), get the current axes. pos : dict, optional If passed, this dictionary of positions node_id:(x,y) is used for placing the 0-simplices. If None (default), use the `barycenter_spring_layout` to compute the positions. + ax : matplotlib.pyplot.axes, optional + Axis to draw on. If None (default), get the current axes. dyad_color : str, dict, iterable, or EdgeStat, optional Color of the dyadic links. If str, use the same color for all edges. If a dict, must contain (edge_id: color_str) pairs. If iterable, assume the colors are @@ -732,30 +732,49 @@ def draw_simplices( iterable, assume the widths are specified in the same order as the edges are found in H.edges. If EdgeStat, use a monotonic linear interpolation defined between min_dyad_lw and max_dyad_lw. By default, 1.5. - edge_fc : str, dict, iterable, or EdgeStat, optional - Color of the hyperedges. If str, use the same color for all nodes. If a dict, - must contain (edge_id: color_str) pairs. If other iterable, assume the colors - are specified in the same order as the hyperedges are found in H.edges. If - EdgeStat, use the colormap specified with edge_fc_cmap. If None (default), color - by simplex size. + dyad_style : str or list of strings, optional + Line style of the dyads, e.g. ‘-’, ‘–’, ‘-.’, ‘:’ or words like ‘solid’ or ‘dashed’. + See matplotlib's documentation for all accepted values. By default, "solid". + dyad_color_cmap: matplotlib colormap + Colormap used to map the dyad colors. By default, "Greys". + dyad_vmin, dyad_vmax : float, optional + Minimum and maximum for dyad colormap scaling. By default, None. + edge_fc : color or list of colors or array-like or dict or EdgeStat, optional + Color of the hyperedges. The accepted formats are the same as + matplotlib's scatter, with the addition of dict and IDStat. + Those with colors: + * single color as a string + * single color as 3- or 4-tuple + * list of colors of length len(ids) + * dict of colors containing the `ids` as keys + Those with numerical values (will be mapped to colors): + * array of floats + * dict of floats containing the `ids` as keys + * IDStat containing the `ids` as keys + If None (default), color by edge size. + edge_fc_cmap: matplotlib colormap + Colormap used to map the edge colors. By default, "crest_r". + edge_vmin, edge_vmax : float, optional + Minimum and maximum for edge colormap scaling. By default, None. + alpha : float, optional + The edge transparency. By default, 0.4. max_order : int, optional Maximum of hyperedges to plot. By default, None. hyperedge_labels : bool or dict, optional If True, draw ids on the hyperedges. If a dict, must contain (edge_id: label) - pairs. Note, we plot only the maximal simplices so if you pass a dict be - careful to match its keys with the new edge ids in the converted - SimplicialComplex. These may differ from the edge ids in the given SC. By - default, False. - settings : dict + pairs. By default, None. + rescale_sizes: bool, optional + If True, linearly interpolate `dyad_lw` and between min/max values + (1/10) that can be changed in the other argument `params`. + If `dyad_lw` is a single value, `interpolate_sizes` is ignored + for it. By default, True. + params : dict Default parameters. Keys that may be useful to override default settings: - * min_dyad_lw - * max_dyad_lw - * dyad_color_cmap - * edge_fc_cmap + * "min_dyad_lw" (default: 1) + * "max_dyad_lw" (default: 10) kwargs : optional keywords See `draw_hyperedge_labels` for a description of optional keywords. - Raises ------ XGIError From ee380a91d77be1d6155a2f07fd8971001deae11f Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Mon, 16 Oct 2023 10:48:01 +0200 Subject: [PATCH 21/26] style: black and isort --- xgi/core/hypergraph.py | 4 ++-- xgi/drawing/draw.py | 15 +++++++++++---- xgi/drawing/draw_utils.py | 2 +- 3 files changed, 14 insertions(+), 7 deletions(-) diff --git a/xgi/core/hypergraph.py b/xgi/core/hypergraph.py index 4226953fc..3d1539ba4 100644 --- a/xgi/core/hypergraph.py +++ b/xgi/core/hypergraph.py @@ -273,13 +273,13 @@ def __lshift__(self, H2): [{1, 2}, {2, 3}, {1, 3, 4}] """ tempH = Hypergraph() - + tempH.add_nodes_from(zip(self._node.keys(), self._node_attr.values())) tempH.add_nodes_from(zip(H2._node.keys(), H2._node_attr.values())) tempH.add_edges_from(zip(self._edge.values(), self._edge_attr.values())) tempH.add_edges_from(zip(H2._edge.values(), H2._edge_attr.values())) - + tempH._hypergraph = deepcopy(self._hypergraph) tempH._hypergraph.update(deepcopy(H2._hypergraph)) diff --git a/xgi/drawing/draw.py b/xgi/drawing/draw.py index abdfc58bc..8d944b48c 100644 --- a/xgi/drawing/draw.py +++ b/xgi/drawing/draw.py @@ -5,7 +5,7 @@ import matplotlib.pyplot as plt import numpy as np -import seaborn as sb # for cmap "crest" +import seaborn as sb # for cmap "crest" from matplotlib import cm from matplotlib.patches import FancyArrow from mpl_toolkits.mplot3d.art3d import ( @@ -234,7 +234,7 @@ def draw( rescale_sizes=rescale_sizes, **kwargs, ) - + elif isinstance(H, Hypergraph): ax, (dyad_collection, edge_collection) = draw_hyperedges( @@ -663,7 +663,7 @@ def draw_hyperedges( array=edge_fc_arr, cmap=edge_fc_cmap, alpha=alpha, - zorder=max_order - 2 # below dyads + zorder=max_order - 2, # below dyads ) # edge_collection.set_cmap(edge_fc_cmap) if edge_c_mapped: @@ -800,7 +800,14 @@ def draw_simplices( # add the projected pairwise interactions dyads = subfaces(H_.edges.members(), order=1) H_.add_edges_from(dyads) - H_.cleanup(multiedges=False, isolates=True, connected=False, relabel=False, in_place=True, singletons=True) # remove multi-dyads + H_.cleanup( + multiedges=False, + isolates=True, + connected=False, + relabel=False, + in_place=True, + singletons=True, + ) # remove multi-dyads if not max_order: max_order = max_edge_order(H_) diff --git a/xgi/drawing/draw_utils.py b/xgi/drawing/draw_utils.py index c80c65030..b5a5e27e2 100644 --- a/xgi/drawing/draw_utils.py +++ b/xgi/drawing/draw_utils.py @@ -6,7 +6,7 @@ import matplotlib as mpl import matplotlib.pyplot as plt import numpy as np -import seaborn as sb # for cmap "crest" +import seaborn as sb # for cmap "crest" from matplotlib.colors import ( LinearSegmentedColormap, ListedColormap, From c3e6c1d427de45028b3cf1e92824b4668d448d59 Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Mon, 16 Oct 2023 10:59:35 +0200 Subject: [PATCH 22/26] fix: tests --- tests/drawing/test_draw.py | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/tests/drawing/test_draw.py b/tests/drawing/test_draw.py index 9dc5a8199..24a3b7755 100644 --- a/tests/drawing/test_draw.py +++ b/tests/drawing/test_draw.py @@ -232,12 +232,16 @@ def test_draw_simplices(edgelist8): S = xgi.SimplicialComplex(edgelist8) fig, ax = plt.subplots() - ax = xgi.draw_simplices(S, ax=ax) + ax, collections = xgi.draw_simplices(S, ax=ax) + (dyad_collection, edge_collection) = collections # number of elements - assert len(ax.lines) == 18 # dyads - assert len(ax.patches) == 3 # hyperedges - assert len(ax.collections) == 0 # nodes + assert len(ax.lines) == 0 + assert len(ax.patches) == 0 + assert len(ax.collections) == 2 + + assert len(dyad_collection.get_paths()) == 16 # dyads + assert len(edge_collection.get_paths()) == 3 # other hyperedges # zorder for line in ax.lines: # dyads From 29df5a3a6d9050a3688b1f019106e8ee2a36e760 Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Mon, 16 Oct 2023 11:50:08 +0200 Subject: [PATCH 23/26] tests: more for draw_hyperedges --- tests/drawing/test_draw.py | 101 ++++++++++++++++++++++++++++++++++++- 1 file changed, 100 insertions(+), 1 deletion(-) diff --git a/tests/drawing/test_draw.py b/tests/drawing/test_draw.py index 24a3b7755..a8599a914 100644 --- a/tests/drawing/test_draw.py +++ b/tests/drawing/test_draw.py @@ -1,6 +1,7 @@ import matplotlib.pyplot as plt import numpy as np import pytest +import seaborn as sb import xgi from xgi.exception import XGIError @@ -32,6 +33,31 @@ def test_draw(edgelist8): plt.close() + # simplicial complex + S = xgi.SimplicialComplex(edgelist8) + + fig, ax = plt.subplots() + ax, collections = xgi.draw(S, ax=ax) + (node_collection, dyad_collection, edge_collection) = collections + + # number of elements + assert len(ax.lines) == 0 + assert len(ax.patches) == 0 + offsets = node_collection.get_offsets() + assert offsets.shape[0] == S.num_nodes # nodes + assert len(ax.collections) == 3 + + assert len(dyad_collection.get_paths()) == 16 # dyads + assert len(edge_collection.get_paths()) == 3 # other hyperedges + + # zorder + for line in ax.lines: # dyads + assert line.get_zorder() == 3 + for patch, z in zip(ax.patches, [0, 2, 2]): # hyperedges + assert patch.get_zorder() == z + + plt.close() + def test_draw_nodes(edgelist8): @@ -204,8 +230,10 @@ def test_draw_hyperedges(edgelist8): fig, ax = plt.subplots() ax, collections = xgi.draw_hyperedges(H, ax=ax) - (dyad_collection, edge_collection) = collections + fig2, ax2 = plt.subplots() + ax2, collections2 = xgi.draw_hyperedges(H, ax=ax2, dyad_color="r", edge_fc="r", dyad_lw=3, dyad_style="--") + (dyad_collection2, edge_collection2) = collections2 # number of elements assert len(ax.lines) == 0 @@ -220,6 +248,77 @@ def test_draw_hyperedges(edgelist8): for patch, z in zip(ax.patches, [2, 2, 0, 2, 2]): # hyperedges assert patch.get_zorder() == z + # dyad_style + dyad_collection.get_linestyle() == [(0.0, None)] + dyad_collection2.get_linestyle() == [(0.0, [5.550000000000001, 2.4000000000000004])] + + # dyad_fc + assert np.all( + dyad_collection.get_color() == np.array([[0, 0, 0, 1]]) + ) # black + assert np.all( + dyad_collection2.get_color() == np.array([[1, 0, 0, 1]]) + ) # black + + # edge_fc + assert np.all( + edge_collection.get_facecolor()[:, -1] == np.array([0.4, 0.4, 0.4, 0.4, 0.4, 0.4]) + ) + assert np.all( + edge_collection2.get_facecolor() == np.array([[1., 0., 0., 0.4]]) + ) + + # edge_lw + assert np.all(dyad_collection.get_linewidth() == np.array([1.5])) + assert np.all(dyad_collection2.get_linewidth() == np.array([3])) + assert np.all(edge_collection.get_linewidth() == np.array([1.])) + + # negative node_lw or node_size + with pytest.raises(ValueError): + ax, collections = xgi.draw_hyperedges(H, ax=ax, dyad_lw=-1) + (dyad_collection, edge_collection) = collections + plt.close() + + + plt.close("all") + + +def test_draw_hyperedges_fc_cmap(edgelist8): + + H = xgi.Hypergraph(edgelist8) + + # default cmap + fig, ax = plt.subplots() + ax, collections = xgi.draw_hyperedges(H, ax=ax) + (dyad_collection, edge_collection) = collections + assert dyad_collection.get_cmap() == plt.cm.Greys + assert edge_collection.get_cmap() == sb.color_palette("crest_r", as_cmap=True) + plt.close() + + # set cmap + fig, ax = plt.subplots() + dyad_colors = [1, 3, 5] + ax, collections = xgi.draw_hyperedges(H, ax=ax, dyad_color=dyad_colors, dyad_color_cmap="Greens", edge_fc_cmap="Blues") + (dyad_collection, edge_collection) = collections + assert dyad_collection.get_cmap() == plt.cm.Greens + assert edge_collection.get_cmap() == plt.cm.Blues + + plt.colorbar(dyad_collection) + plt.colorbar(edge_collection) + + assert (min(dyad_colors), max(dyad_colors)) == dyad_collection.get_clim() + assert (3, 5) == edge_collection.get_clim() + plt.close() + + # vmin/vmax + fig, ax = plt.subplots() + ax, collections = xgi.draw_hyperedges(H, ax=ax, dyad_color=dyad_colors, dyad_vmin=5, dyad_vmax=6, edge_vmin=14, edge_vmax=19) + (dyad_collection, edge_collection) = collections + plt.colorbar(dyad_collection) + plt.colorbar(edge_collection) + assert (14, 19) == edge_collection.get_clim() + assert (5, 6) == dyad_collection.get_clim() + plt.close() From 6d0a22988788f940f4f2d44adf8e4e779e08b9a5 Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Mon, 16 Oct 2023 11:50:23 +0200 Subject: [PATCH 24/26] style: black --- tests/drawing/test_draw.py | 50 +++++++++++++++++++++----------------- 1 file changed, 28 insertions(+), 22 deletions(-) diff --git a/tests/drawing/test_draw.py b/tests/drawing/test_draw.py index a8599a914..7c365a503 100644 --- a/tests/drawing/test_draw.py +++ b/tests/drawing/test_draw.py @@ -33,7 +33,7 @@ def test_draw(edgelist8): plt.close() - # simplicial complex + # simplicial complex S = xgi.SimplicialComplex(edgelist8) fig, ax = plt.subplots() @@ -41,11 +41,11 @@ def test_draw(edgelist8): (node_collection, dyad_collection, edge_collection) = collections # number of elements - assert len(ax.lines) == 0 - assert len(ax.patches) == 0 + assert len(ax.lines) == 0 + assert len(ax.patches) == 0 offsets = node_collection.get_offsets() assert offsets.shape[0] == S.num_nodes # nodes - assert len(ax.collections) == 3 + assert len(ax.collections) == 3 assert len(dyad_collection.get_paths()) == 16 # dyads assert len(edge_collection.get_paths()) == 3 # other hyperedges @@ -232,7 +232,9 @@ def test_draw_hyperedges(edgelist8): ax, collections = xgi.draw_hyperedges(H, ax=ax) (dyad_collection, edge_collection) = collections fig2, ax2 = plt.subplots() - ax2, collections2 = xgi.draw_hyperedges(H, ax=ax2, dyad_color="r", edge_fc="r", dyad_lw=3, dyad_style="--") + ax2, collections2 = xgi.draw_hyperedges( + H, ax=ax2, dyad_color="r", edge_fc="r", dyad_lw=3, dyad_style="--" + ) (dyad_collection2, edge_collection2) = collections2 # number of elements @@ -253,25 +255,20 @@ def test_draw_hyperedges(edgelist8): dyad_collection2.get_linestyle() == [(0.0, [5.550000000000001, 2.4000000000000004])] # dyad_fc - assert np.all( - dyad_collection.get_color() == np.array([[0, 0, 0, 1]]) - ) # black - assert np.all( - dyad_collection2.get_color() == np.array([[1, 0, 0, 1]]) - ) # black + assert np.all(dyad_collection.get_color() == np.array([[0, 0, 0, 1]])) # black + assert np.all(dyad_collection2.get_color() == np.array([[1, 0, 0, 1]])) # black # edge_fc assert np.all( - edge_collection.get_facecolor()[:, -1] == np.array([0.4, 0.4, 0.4, 0.4, 0.4, 0.4]) - ) - assert np.all( - edge_collection2.get_facecolor() == np.array([[1., 0., 0., 0.4]]) + edge_collection.get_facecolor()[:, -1] + == np.array([0.4, 0.4, 0.4, 0.4, 0.4, 0.4]) ) + assert np.all(edge_collection2.get_facecolor() == np.array([[1.0, 0.0, 0.0, 0.4]])) # edge_lw assert np.all(dyad_collection.get_linewidth() == np.array([1.5])) assert np.all(dyad_collection2.get_linewidth() == np.array([3])) - assert np.all(edge_collection.get_linewidth() == np.array([1.])) + assert np.all(edge_collection.get_linewidth() == np.array([1.0])) # negative node_lw or node_size with pytest.raises(ValueError): @@ -279,7 +276,6 @@ def test_draw_hyperedges(edgelist8): (dyad_collection, edge_collection) = collections plt.close() - plt.close("all") @@ -298,7 +294,9 @@ def test_draw_hyperedges_fc_cmap(edgelist8): # set cmap fig, ax = plt.subplots() dyad_colors = [1, 3, 5] - ax, collections = xgi.draw_hyperedges(H, ax=ax, dyad_color=dyad_colors, dyad_color_cmap="Greens", edge_fc_cmap="Blues") + ax, collections = xgi.draw_hyperedges( + H, ax=ax, dyad_color=dyad_colors, dyad_color_cmap="Greens", edge_fc_cmap="Blues" + ) (dyad_collection, edge_collection) = collections assert dyad_collection.get_cmap() == plt.cm.Greens assert edge_collection.get_cmap() == plt.cm.Blues @@ -312,7 +310,15 @@ def test_draw_hyperedges_fc_cmap(edgelist8): # vmin/vmax fig, ax = plt.subplots() - ax, collections = xgi.draw_hyperedges(H, ax=ax, dyad_color=dyad_colors, dyad_vmin=5, dyad_vmax=6, edge_vmin=14, edge_vmax=19) + ax, collections = xgi.draw_hyperedges( + H, + ax=ax, + dyad_color=dyad_colors, + dyad_vmin=5, + dyad_vmax=6, + edge_vmin=14, + edge_vmax=19, + ) (dyad_collection, edge_collection) = collections plt.colorbar(dyad_collection) plt.colorbar(edge_collection) @@ -335,9 +341,9 @@ def test_draw_simplices(edgelist8): (dyad_collection, edge_collection) = collections # number of elements - assert len(ax.lines) == 0 - assert len(ax.patches) == 0 - assert len(ax.collections) == 2 + assert len(ax.lines) == 0 + assert len(ax.patches) == 0 + assert len(ax.collections) == 2 assert len(dyad_collection.get_paths()) == 16 # dyads assert len(edge_collection.get_paths()) == 3 # other hyperedges From c8b17ad6f6f5c5297a274497efd68f0af93da73c Mon Sep 17 00:00:00 2001 From: Maxime Lucas Date: Mon, 16 Oct 2023 11:58:34 +0200 Subject: [PATCH 25/26] reran plotting notebooks --- .../In Depth 2 - Drawing hyperedges.ipynb | 83 ++------- tutorials/Tutorial 5 - Plotting.ipynb | 170 ++++++++++++------ 2 files changed, 126 insertions(+), 127 deletions(-) diff --git a/tutorials/In Depth 2 - Drawing hyperedges.ipynb b/tutorials/In Depth 2 - Drawing hyperedges.ipynb index 951088569..b9feb5125 100644 --- a/tutorials/In Depth 2 - Drawing hyperedges.ipynb +++ b/tutorials/In Depth 2 - Drawing hyperedges.ipynb @@ -59,9 +59,9 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ,\n", - " ))" + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 3, @@ -109,8 +109,8 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ))" + " (,\n", + " ))" ] }, "execution_count": 4, @@ -158,8 +158,8 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ))" + " (,\n", + " ))" ] }, "execution_count": 5, @@ -201,8 +201,8 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ))" + " (,\n", + " ))" ] }, "execution_count": 6, @@ -255,7 +255,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 7, @@ -302,7 +302,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 8, @@ -351,7 +351,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 9, @@ -443,65 +443,6 @@ "metadata": {}, "outputs": [], "source": [] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "d677fbc5", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{0: {1, 2, 3},\n", - " 1: {3, 4, 5},\n", - " 2: {3, 6},\n", - " 3: {6, 7, 8, 9},\n", - " 4: {1, 4, 10, 11, 12},\n", - " 5: {1, 4},\n", - " 6: {2, 5}}" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "H.edges.members(dtype=dict)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "4615bc2b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{1: {0, 4, 5},\n", - " 2: {0, 6},\n", - " 3: {0, 1, 2},\n", - " 4: {1, 4, 5},\n", - " 5: {1, 6},\n", - " 6: {2, 3},\n", - " 7: {3},\n", - " 8: {3},\n", - " 9: {3},\n", - " 10: {4},\n", - " 11: {4},\n", - " 12: {4}}" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "H.nodes.memberships()" - ] } ], "metadata": { diff --git a/tutorials/Tutorial 5 - Plotting.ipynb b/tutorials/Tutorial 5 - Plotting.ipynb index d390c7db9..1a82ea0af 100644 --- a/tutorials/Tutorial 5 - Plotting.ipynb +++ b/tutorials/Tutorial 5 - Plotting.ipynb @@ -90,9 +90,9 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ,\n", - " ))" + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 4, @@ -101,7 +101,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -134,9 +134,9 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ,\n", - " ))" + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 5, @@ -145,7 +145,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -170,9 +170,9 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ,\n", - " ))" + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 6, @@ -181,7 +181,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -212,9 +212,9 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ,\n", - " ))" + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 7, @@ -223,7 +223,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA1RElEQVR4nO3de3Bb130v+i+wARIAAb1MSbYlPiSRsEhQMmkLNBjYpuO6slP7XuvBJD1NEys5UaippLS9c3pOm5PTzm2ax+n03N6JVdcqT1NScWdyrJSUZtg2qZQzV3FgQtpOSVsAIYHUC5RkPfnCk8Rj3z8o0npafGxwE1jfz4zHHllc/Eng3vhi7bXWT6coigIiIiISll7rAoiIiEhbDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBGfQugAiUSiKgu7ubsiyDL/fj3g8DrPZDIfDAafTibq6Ouh0Oq3LJCIB6RRFUbQugiifJZNJtLS0YN++fQgEApAkCXa7HTabDeFwGMFgEOl0GlVVVdizZw927twJo9GoddlEJBA+JiDKIp/PB5fLhb1798LhcODIkSMIh8Po7e3F8ePH0dvbi3A4jCNHjsDhcGDv3r1wuVzw+Xxal05EAuHMAFGWHDt2DK+++irKysrQ1taGTZs2PfRrZFnGjh07EAqF0NnZicbGxnmolIhExzBAlAWTMwINDQ04dOgQioqKpv210WgUW7ZsgdfrRVdXF2pqarJYKRERwwCR6pLJJFwuFxKJBE6cODGjIDApGo2ivr4eZrMZXV1dXENARFnFNQNEKmtpaUFPTw/a2tpmFQQAoKioCK2treju7kZLS4vKFRIR3YkzA0QqUhQFDocDDocDBw8enPN4TU1NCAQC8Pl83HZIRFnDmQEiFXV3dyMQCKC5uVmV8Zqbm9Hb24uenh5VxiMiuh+GASIVybIMSZLgdrtVGc/tdkOSJMiyrMp4RET3wzBApCK/3w+73Q6z2azKeBaLBXa7HX6/X5XxiIjuh2GASEXxeBw2m03VMa1WK2KxmKpjEhHdjmGASEVmsxnhcFjVMSORCCwWi6pjEhHdjmGASEUOhwPBYBDxeFyV8WKxGILBIBwOhyrjERHdD8MAkYqcTifS6TQ8Ho8q43k8HqTTaTidTlXGIyK6H54zQKQinjNARLmIMwNEKtLpdNizZw/a29vnvB1QlmV0dHRg9+7dDAJElFWcGSBSmdq9CbxeLwwGQxYqJSKawJkBIpUZjUa0tbUhFArh9ddfRzQandHXT3YtDIVCaG1tZRAgoqxjGCDKgpLStfjWt/4K77/fBafTOe1HBrIso76+Hl6vF52dnWxfTETzgmGASGUjozH88pe9qLBvxHe+ux/j4wpcLhe2b9+Oo0eP3rPtMBaL4ciRI9i+fTtcLtdU2+LGxkaN/gREJBquGSBS0chIDMfe68XYWHLq11KpFH5x9DD+7eftGBg4B0mSUFFRCavVikgkgv7+PqTTaZSUrsHmzdvw/e99G8uXL9HuD0FEwmEYIFLJ/YLA7RRFwflzQZw5E8DAwDmMjSVQWGhCSckarFtXhfI1duh0OhQX2/DZRj4eIKL5wzBApIKHBYGZctVXoqSkWJWxiIgehmsGiOZoeDiqahAAgI98IaRSadXGIyL6NAwDRHMwPBzFL38VUDUIAEAsNobTwcuqjklE9CAMA0SzlI0ZgdudDl5GLDaWlbGJiG7HMEA0C0NDERx7rxfj46msfY90OoMPT17I2vhERJMYBohmaGgogl/+KpDVIDDp4sWbuH59NOvfh4jExjBANAPzMSNwt56PzoObfogomxgGiKZp8FYQSCbnd5X/8HAU585dm9fvSURiYRggmobBoQh+qUEQmOTrHZjX2QgiEgvDANFD3BwMaxoEAGBsLInewIBm35+I8hvDANGnuDkYxnu/CmgaBCb1n7mKkdGY1mUQUR5iGCB6gIkZgYURBICJ3gYffsSthkSkPoYBovu4cXMiCCy0I4GvXh3G5cuDWpdBRHmGYYDoLjduTjwaWGhBYNKHJy8gnc5oXQYR5RGGAaLb3LgxuqCDAABEIgn09X+sdRlElEcYBohuyYUgMClw6hLi8XGtyyCiPMEwQITbgkCOTL+nUmn4/CGtyyCiPMEwQMK7fj23gsCk8xeu4+ZgWOsyiCgPMAyQ0K5fH8WvPLkXBCb1fMi+BUQ0dwwDJKxr10dyOggAwOBgBBdCN7Qug4hyHMMACena9RF4PKdyOghMOukLLZiDkYgoNzEMkHCuXsufIAAAicQ4Tp2+pHUZRJTDGAZIKFevjcDzfv4EgUnBvsuIRBJal0FEOYphgIRx5eowPO+fysvT+zIZBR+dZN8CIpodg9YFLCSKoqC7uxuyLMPv9yMej8NsNsPhcMDpdKKurg46nU7rMmkWrlwdxvtdp/MyCEy6dHkQV64O49GVS7QuhUhTvJfPnE7hviQkk0m0tLRg3759CAQCkCQJdrsdNpsN4XAYwWAQ6XQaVVVV2LNnD3bu3Amj0ah12TRNIgSBSTabGZtf2gi9npN+JB7ey2dP+DuGz+eDy+XC3r174XA4cOTIEYTDYfT29uL48ePo7e1FOBzGkSNH4HA4sHfvXrhcLvh8Pq1Lp2m4cmVImCAAAOFwHGfOXtW6DKJ5x3v53Ag9M3Ds2DG8+uqrKCsrQ1tbGzZt2vTQr5FlGTt27EAoFEJnZycaGxvnoVKajY8/HsL73tPIZMT6ETcaJXzu5ToUFvITD4mB9/K5EzYMTKbIhoYGHDp0CEVFRdP+2mg0ii1btsDr9aKrqws1NTVZrJRmQ9QgMGntmpV4+qm1WpdBlHW8l6tDyDCQTCbhcrmQSCRw4sSJGf3wTIpGo6ivr4fZbEZXVxefOy0gogeBSb/5GxuxZMnMf7aJcgXv5eoRcs1AS0sLenp60NbWNqsfHgAoKipCa2sruru70dLSonKFNFuXLw8yCNzS8+F5rUsgyirey9Uj3MyAoihwOBxwOBw4ePDgnMdrampCIBCAz+fjVhWNXbo8CO/xIIPAbVzP2FGy+hGtyyBSHe/l6hJuZqC7uxuBQADNzc2qjNfc3Ize3l709PSoMh7NDoPA/X108gJSKfYtoPzDe7m6hAsDsixDkiS43W5VxnO73ZAkCbIsqzIezRyDwIPFYmM4HbysdRlEquO9XF3ChQG/3w+73Q6z2azKeBaLBXa7HX6/X5XxaGYuXrrJIPAQweBlxGJjWpdBpCrey9UlXBiIx+Ow2Wyqjmm1WhGLxVQdkx5uIgj0MQg8RCqdYd8Cyju8l6tLuDBgNpsRDodVHTMSicBisag6Jn26gYsTQUCw9a+zNnDxJm7cGNW6DCLV8F6uLuHCgMPhQDAYRDweV2W8WCyGYDCI1esew1DsOmLjEaQzXLCVTQMXb+L4CQaBmer+8Dz/zihvZOte7nA4VBkv1wgXBpxOJ9LpNDwejyrjeTwepNNp2GvW4mbsCi6PnsO5wV6cHzyNK6OhWwEhjHQmpcr3E93AwA0GgVkaHo7i3LlrWpdBNCeKouBGJALr6tKs3MudTqcq4+UanjMwR01N2/GR70P883vtD92batAbUWgw3/rHhEKDBQY9u0hP18DADRyX+xkE5qCw0IjPvVwLo5E/d5RbRuJxXBwaxsDQMGLjSSiKgj/8/DbUP/UUfspzBuZMuJkBnU6HPXv2oL29fc5bSGRZRkfHIXzpa1+c1g9PKpNEdHwUg7Gr+Hj0As4PBnDu5ilcHjmPwdhVRMdGkUon51RTvgqFGATUMDaWhL/3otZlEE1LfDyJvmvX8b9PBfGLU304ffU6YuMT90idTodXvvDb6FDtXt6B3bt3CxkEAAFnBgA1z7N2Qm/U4+DPfgyDQb1PWpLOcNvswcRMglEqUG18rSiKgu7ubsiyDL/fj3g8DrPZDIfDAafTibq6uvteiKHQDZz4gEFALXq9Dr/50pNYZFNnSxaRmpLpNC4Nj+Di0DCuhSOf+ntTySS+teMrKIACWZbn3JvA6/Wqei/PJUKGAWCi01VDQwNcLtesOl29vuV1eL1evPsvB2CvqsxipRP0OumORwwmgxkGfUFOpNhkMomWlhbs27cPgUAAkiTBbrfDZrMhHA4jGAwinU6jqqoKe/bswc6dO6eahVwIXYf8wRkGAZWtXLkEzz9bpXUZRACAjKLg6mgYocEhXBkZRXoG13uovw/f2vEGPtPgwuHDh9m1cJaEDQPARA/s1157DaWlpWhtbZ3WwpGJHthv4EIohP3vvIln3A/vm50tep2EAskEk9GMQumTGYSFFBB8Ph/eeOMN9PT0YNu2bWhubobb7b7joJB4PA6Px4P9+/ejvb0dtbW1aGtrg9W2EvIH/RpWn9/cDU/g8ceXaV0GCexmJIqBoWFcGh7BWGr2i6z9v/4A3//9b6K8rBRtbW0zuJfvQCgUQmdnJxobG2f9/fOBcGsGbtfY2Iiuri6YTCa4XC40NTXh6NGj92xVicViOHLkCJqatsPlckFv1OPdfzmgaRAAgIySRiIVxXD8Bq5GBhAaDuLszV5cHD6L65HLGE0MYSyV0OxT9bFjx6Yexxw/fhwHDx7ESy+9dM+JYWazGS+99BIOHjwIr9eLRCIBl6sBbW1zXxRED/bhyQtIpzNal0GCCScS6P34Cv7NfwrH+s7g7I2bcwoCAOB4ehO+19qGpE4Hl8uF7Q+5l2/fPnEvn2xbLHoQAASfGZg0MHgWP/qff493/v4n6A+ehSRJqLRXwmq1IhKJoC/Yh3Q6jcon1uFLX/sivvDl7TnV81oHHQruWoNQKJmyOoPg8/ngcrnQ0NAwu8cwr7+O99/vwne+ux+lpeuyVqfoNm4owxP2x7Uug/JcIpnExaERDAwNYSimzrkA95NKJnG0ox0/e/cnGDg7cS+vqPzkXt7fN3EvL123Di9//ov4o29+E5WPrcxaPblE+DAwnh5DaKgPgAJFUdB78hRO9vjRd6ofiXgCJrMJlesrsKHWgeoN6xfUFPzc6FAome5YqFhgMEGvm/tkkVoLNJ1OJ8bHFXznu38n7KKebDMYJLyyuRZmc+4vUKWFJZXJ4OPhEYSGhnFtNIz5fKNRFAXnTp9Cv9+PgbNnMJ5IoMBkQsnadahwOLDmiYl7eaHBgM3VT8AoSfNY3cIkfBi4Gr6I8NiQ1mUsEDoUSIV3nYVgnnFAeOutt7B3714cP34cmzbN/lGKLMtwuVz46tf+EC+/sn3W49CnKy9bDuemCq3LoDyQURRcD0cwMDiEyyOjSGUW/mOodcuL8eRqzo4JHQaS6TFcuDUrQA8yGRA+ecRQIJkg6e+fpNU+1Gn79u2QP+jGX/2Pd/JoVmbhefGzNXhkmbpNX0gcQ9EYQkPDuDQ0jMQcn//PNx2A31hvxyKzSetSNCX03OtQ7AYYBB5GwXg6gfF0AuGx4alfNervDAiFBhMkvQHd3d0IBAL44Q9/qMp337VrF9o3b8b5c0GsWfuEKmPSvXo+PI8XX6hh4KJpi4yNTZwIODiM8FjutshWAHx06TKerVirdSmaEjYMJNPjGOXjgVlLZsaQHB9DZHxk6tcM+gIc/eXPIEkS3G63Kt/H7XZDkiScORNgGMiiwcEIQgM3UFa6XOtSaAEbS6Vw6dZCwJvR/Gn1ey0cwaXhEaxasljrUjQjbBgYil8HZwXUlcqMw+f3o9Jeec/2wdmyWCyoqKjEwMA5VcajB/voZAiPP7YMRiMXU9EnUpkMroyMYmBoGFdHw8jk6ZPlk5cuY+UiGwx6MXfcCxkGkulxjCY4K5ANY4kEbDZ1nz1brVaMjSVUHZPulUiM49TpS9hQU6p1KaSxic6AUYRuLQRMpvO/LXtsPIn+a9ex/lExtxoKGQaG41wrkC2FJhPC4bCqY0YiEaxYKfbinvkS7LuMNeUrYLXy71tEI/E4BgYnOgPGk+I1TTt95RpKly2FpUC8rbbCzYek0kmMJAa1LiNvVa5fh75g3z0nf81WLBZDf38fXnn5ebgbnsDGDWVYU74CxcU2mApz5+CnXJHJKPjo5AWty6B5FBsfx+mr1/CLwERnwOC160IGAQBIKwpOXvpY6zI0IdzMANcKZNfGWgfS6TQ8Hg9eeumlOY/n8XiQTqfx3HPu+56jPz6eQjgSRzicQDgcn/rvSCSOTIav82xcujyIq9dGsHKFuIup8l0ynb61EHAY1yOf3hlQNJeGR3A9HMFym1XrUuaVUOcMpDJJXBg8DYVhIGsURcFvPbsVtRufUuWcgaamJgQCAfh8vhlte1MUBdHo2K2AMBEUIpEERsNxJBLjc64r3y1aZMFv/sYG6AVdTJWPMooytRBwpp0BRbPIZMKL6yuhF2irrVAzA8PxGwwCWabT6fC7//G38ed/8gPIsjyt7mEPIssyOjo68Oabb854/7tOp4PVaoLVasJjd/2/ZDJ1T0CY/G827pkwOhrDmbNXUVlx998e5RJFUXAzGsPA4BAuDY9gXICFgGoYTSRw9vpNVKwo1rqUeSPMzEAqk7o1K8CbfbYlk0l8/pUvQ0kpOHFCnnVvgvr6epjNZni93nnpTaAoCmKxsamgMPFPAuFIHPG4eLMJRqOEz71ch8JCIxRFQXd3N2RZht/vRzweh9lshsPhgNPpRF1dHQ8sWkDCiQRCg8O4ODSM6Lh4P7tqMEoSNlc/gUJB+qIIEwZuRK9gOH5d6zKEEQz04Qu/9RW4XC4cPnR4xl0Lt2zZAq/Xi66uLtTU1GSx0ulJJtOIRD4JB5OPHyLhOFJ5PJtQWrIMv/7gF9i3bx8CgQAkSYLdbofNZkM4HEYwGEQ6nUZVVRX27NmDnTt35lRHT7VpGZomOgMOIzQ4jGGVFvCKbs0jy1BXuhqAtq/tfMiLMPCwF2njkxtwYSjIWYF5dtzzAZp/dy/KSkvR2to2rUcGsixjx44dCIVC6OzsXPB9xhVFQTw+jtFbjxluX6MQi+XuEa0AEAqdwVt/812cPxfEtm3b0NzcDLfbfceBUvF4HB6PB/v370d7eztqa2vR1ta2IALcfEomk2hpaZn30JRKp3F5ZBQDg0O4Fo7wIWgWPLe2HAf/8Z28D8Q5HQamewHa19vxO19twhe+vD0nX6RcFgz04b/s/VP0ngxg69at2LVr1z1vKLFYbOoNpaOjA3V1dWhtbc35N5RUKn1PQJj8Z6HPJvT6u/GD7/8nrFlTjgMHDkyr+2SuBTm1+Hw+vPHGG+jp6ZmX0JRRFFwbDWNgaBgf50hnwFwV6u/D3/7ff4b+QCDvA3HOhoHZXIBVNevxl/u+A3tVpYaViyeZTOLdH/8T3vn7n6A/eBaSJKG8vBw2mw1jY2NToa26uhq7d+/O2WQ9E7H42CdBIRzH6K3tkNGo9rMJodAZfPtb34Db/RkcPpz7j3iy6dixY3j11VdRVlaGtra2rIamwWgMA0MT6wDGcqwzYC7y//oDfO/392JNWZkQgTgnw8DsL8A3cCEUwv533sQz7od/DalLURT0njyFX/z8/8Obf/m3KCwsRHNz89TjnNra2px+5qaGVCqNaHTsjh0Ok+cnJJPZXwmeSqXw7f/6DRQW6CDLc1/82dXVlbfBzufzweVyoaGhAYcOHcpKaIqMjU2dCBjJ4c6AuSbU34c/2fEVuBsahAnEORcG5noBvr7ldXi9Xrz7Lwc4Q6CRc2fOY7Pr/8TixYsxPDysdTk5Ix4fRzgSRySc+GSNwq3ZBLUu45//7J/wDz/6axw/fnxaIftBZFmGy+XCm2++id/7vd9TpbaFJJlMwuVyIZFI4MSJE6qGprFUaqo18GAsfzoD5opUMolv7fgKCqAIFYhzKgyodwE6oTfq8e6/HsiJFynfXDg3gJfqX4XValW9j4GI0ukMItHEHTMJkzMLM5lNUBQF/+n/+l3U1z+Fn/70p3Oua7YHRuWCt956C3v37lUtNP2/P/whtv7OlxC6tRAwXzsD5oKfvfu/8Pd/+QPhAnFOhQG1L8A//f4f40tf+20VK6TpuBi6hM8+/TmYzWbE+MknqxKJJCKRyXCQuLU9Mo7IfWYTzp49jT/+z1/FkSNHVDlK+siRI9i8eTP+/d//HXV1dXMeb6FQFAUOhwMOh0OVUza3NzXhg54e/D/v/lPehaZcoygK/vDz21D/1FP4qYYnqGohZ05TUBQF+/btw7Zt2+YUBADA6XRi69Yt+Mcf/S/8zle/uOBfpHwjSRIAIM3T0LLOZDLCZDKiuHjRHb+eyWQQuXVc8+QpjO97/hWSJMHtdqvyvd1uNyRJgizLeRUGuru7EQgE8MMf/lCV8XY1N2Pz5s04d/oU1q6vUmVMmp1zp05h4OxZ/Gj/flXGa7712vb09Cz4ayBnwoDaF2Bz8y5s3rwZvSdPwbGRF+B80ksT590zDGhHr9djkc2MRbZPdt/8uG0Ydrv9jh05c2GxWLBu3Tq8/fbb6Ovrg06ng16v1/zfcx2js7MzK6Gp3+9nGNBYv98nbCDOmTAgy3JWXqSTPX6GgXkm6TkzsBDF43HYbDZVx7RYLOju7kZ3d7eq42pt3bp1qoamispKDJw9o8p4NHsDZ8+gorJS1dfWbrfD7/erMl425UwY8Pv9qn9qqbRXou9Uvyrj0fRNzgwAE9PV7Iy3MJjNZtUXdMZiMTz99NN48cUXkclkoCjKp/57Or9nuv9Wc6zbx/z444+xeLG67Z2tVivGEwlVx6SZGx8bUz0QW63WnFgblTNhIBufWqxWKxJxXoDzbXLNADAxO8AwMP8mT0ccHZ04w2A0HAd0ixEMBqeO856rWCyGM2fO4K233sI3vvENFapeGL75zW/i6NGjqo4ZiUSw0mRSdUyauYLCQtUDcSQSgcViUXXMbMiZMJCNTy2RSAQmMy/A+Xb7zEA6neb2zixKJlMYGb11yuFofOoAo0jk3hC8avU6pNNpeDweVXYTeDwepNPpObWxXogcDgfeeustVUNTf18fXtj+eRWqo7koWbsOPz/4rqqvbTAYxB/8wR/Mvbgsy5kwkI0LsC/Yhy99/QsqVEczIenvDAM0d5MHEo3e9sY/Go4jkZh++9o1a+woKVmDt99+W5UwsH//flRXV6O2tnbOYy0kTqczK6GpwuFQoTqaiwpHjbCBOGfCQLYuwA21vADn292PCWh6FEVBLDY29UY/ebDQ6GhMlaOKdTodNr+8Df/wo7+GLMtzuoHJsoyOjg68+eabebd1t66uDlVVVdi/f7+qoelr/8drE70HhkfYe0Aja9avR8natXhb5dc2FwJxzhw6pPZBH01N2/GR70P883vteXezWuiSySSqH38aADA4OIilS5dqXNHCkslkEJ58nj/VyCiOyDx0O1S7N4HX64XBkDOfOaZt8gA0r9c759B09yl1GUXBlZFRhAaHcGU0zNMI59nkCYTZeG0XspwJA4D6FyBPIJxfiqKg96MAPuz24c/+6C8AAF//+texadMmOJ1O1NXVCRXMUqn01Bv91PT+rUOAtLwsQ6Ez+G//tRmf+Yw4TVpmSu3eBA8KTWOpFAYGhxEaHMJwPK5G6fQQavcmyJVAnFNhQO3eBAd/9uOceJFy3YNaGC9atAiJRGKqhXFVVRX27NmTdy2Mx8aSdzzHn5zej8UWbhe6Xn83/vsP/gjl5ROdQacTvnO5fets+Hw+NDQ0wOVyZa1r4e1G4vGJYDA0hESSjxGyKdTfh2/teAOfaXAJE4hzKgwAc78A2bVwfgUDffjPe/4bAr5T2LZtG5qbm+F2u+9YBBqPx+HxeLB//360t7ejtrYWbW1tOXMRTYrFx+5YwDf5SX9sLKl1abMSCp3B3771XZw7G8TWrVuxa9eue167WCw29dp1dHSgrq4Ora2tOffazdaxY8fw2muvobS0FK2trfMSmjKKgmvhCEI3h/DxyAjSuXULzxn+X3+A7//+N1FeVipEIM65MADM5QJ8AxdCIex/5008455bfwN6uOOeD/CNL+1BeVkZ2toOTKunxEK/mDKZDKK3zvT/ZAHfxH+nUvm3GLK8rBjyiSPYt28fAoEAJEmC3W6H1WpFJBKZmtWprq7G7t27825WZzp8Ph927NiB7u7ueQ9NyXQal4ZGcGFwCDej0bn+Ueguof4+tHznz3HK78v7QJyTYQCY3QVYvaEK//3NP+eMwDwIBvrw+c99GQ0NDTh8KPem2dLpzK1DeWJ3TO2Hw3FkMjl5ycxYYaERr2yuRUGBAYqioKenB7Isw+/3IxaLwWKxwOFwwOl0ora2Vqj1HndLJpNoaWnRNDRFxsYQGhzCwOAwouPT31JKD2aUJHy2ci0O/MM/5H0gztkwAMzsAvzS176Irb/zWk6+SLkmmUzi8698GUpKwYkTc1+A09XVlbXXLZlMTbX3HR2NTZ3IF71Pi1/RPFW3BuvWPqp1GTllIYQmRVFwMxrFhZtDuDQ8glQmuztQ8tmTqx/HuuXFABbGa5tNOR0GJk3nRUqkYrg0clbrUoXwjz/6Cf78T36A48ePz6ndtJpbcxKJJEbDsTue54+MzuxQHpEsXmzBSy9u4FHROS6VyeDj4RGEBodwNRzRupycsthkwmfXV0Kfw2/wM5EXYWC6Lg6fRSLF52rZpCgKfuvZrajd+JRK50E0IRAIwOfzPTR1Tx7KM/lGf/tz/fFxrr6eicbnq7FiubrNeEhb8fEkQkNDCN0cQnhs4e5kWSieq1iL5Tar1mXMG6H21S21LMfHowwD2dT7UQD9wbP427/Zr8p4zc3N2Lx5M3p6eqb6gWcyGUSiYxgdvfOTfngeDuURwarHlzEI5CFzgRFPrFyBJ1auwFA0NrG+YGgY4zwF9B6rliwWKggAgoWBogIbCiUzxtI8vCNbPurxQ5IkuN1uVcZzu92QJAmHDv8c8YQFo+E4otGEMIv45pter8PGDWVal0FZtrTIgqVFFtSsegxXRsMTjxF42iEAwKDXY8Oqx7QuY94JFQaAidmBK+GQ1mXkrb5TZ1Bpr1SlmRQAWCwWVFRUQpb/HTUbFtY2w3xkr3wcVis7eYpC0uuxaslirFqymKcd3mJfuRyWggKty5h3woWBooJFMEqFSKb5zCwbxhIJ2Gw2Vce0Wq0YG7u35S6py2QqwPonVmldBmmk0GBAxYpiVKwoxkg8PvUYQaTTDi0FRlSsWK51GZoQLgzodDosNS/HtchFrUvJS4UmE8LhsKpjRiIRrFjJT6vZVuMogdEoPfw3Ut5bbDZjwyozHI8/JtRphxtWPQ6DoDtohPxT2wqXwKDneQPq0qHQYMbGDRvRF+xDXKVpxlgshv7+PpSUrFFlPLq/pUuKUF4m5iciejC9TodHF9lQv6YUv7WhGk+VrMYjszg3JBessFmxaom4C2eFmxkAJmYHlpiX40b0stal5CyDvgAmowUmgxkmgwUFBhP0Oj1efPY3kU7/MTwejyr9wD0eD9LpNNatq1KhanqQ2ifLc/rAFMo+oyShvHgZyouXTZ12GBocQmw8N3tv3E4HYOOqx7UuQ1NCnTNwu4ySwYXB00gr4jwPmy29ToLJYIHJaEahYSIASPr750hFUeBwOOBwOFQ5Z2D79u2QP+jGX/2Pd/hmlSUlqx+B6xm71mVQDlIUBTciUYQGc/u0w3XLi/HkarHDgJAzAwCg1+mxxFyMm7ErWpeywExM909+4jcZzTBKhdP/ap0Oe/bswd69eyHL8rSaSD2ILMs4dOgQvvq1P2QQyBKDpOdWQpo1nU6H5TYrltuseLJkFS7fOu3wWg6ddlhoMKD6sZVal6E5YWcGACCdSePC0GlkFHEP3TBKhTAZPvnEX2gwz/mNN5lMwuVyIZFI4MSJE7PuTeB0OjE+ruAvvvd3kCRhc2tWVVethqO6ROsyKM/ExscxMDScE6cdPlWyGuXFy7QuQ3NChwEAuBm9iqH4Na3LmBd6nWHiE7/xkzf+B033z5XP50NDQwNcLhcOHTo0466Fr7++Be+//z6+8939KC1dl5UaRWc2F+CVzbUwGLiDgLJn8NZphxcX4GmHS8xmfPaJCs48gmEA6UwK5wcnZgd6Pwrgox4/+k6dwVgigUKTCZXr12FjrQPVG6ty6gdGB/3EdL9xYrq/0GCGUZrfgzSOHTuG1157DaWlpWhtbZ3WIwNZlrFjxw6EQiH83d8dgKGAXfOy5RlnJUpLi7UugwSRzmTm7bRDRVFw7tQp9Pt9GDh7BuNjYygoLETJ2nWocNRgzfr10Ol0aKxch0es+bk7YqaEDwPJZBJ/ve+v0PL2/0R/8CwkSUKlvRI2mw3hcBh9wT6k02lU2Nfid//jb+MLX96+INsgF0imW8/6LSg0mlEomRZEePH5fNixYwe6u7uxdetW7Nq1C263+44TCmOxGDweD/bv34+Ojg7U1dWhtbUVNTU1OH/hOuQP+jX8E+SnRx6x4cUXarQugwSVSCZxcWhE9dMOU8kkjna042fv/gQDZyfu5xWVn9zP+/sm7ucla9fiP+z4Kv7ij//Lgryfa0HoMODz+fDGG2+gp6cH27ZtQ3Nz8z1vVPF4fOqNqr29HVU16/GX+74De1WlZnVLOuMdn/gnpvsX7lRvMplES0sL9u3bh0AgAEmSYLfbYbVaEYlEEAwGkU6nUV1djd27d2Pnzp13XKCh0A2c+KAfAv+oqu43XtyAZUvFasRCC9PUaYeDw0ikZr+7K9Tfh31/9qc4d/oUtm7bhl2fcj9/e/9+dLS3o7a2Fm1tbaipYTAWNgwcO3YMr776KsrKytDW1oZNmzY99GsmprDfwIVQCPvfeRPPuB/+NXOlg/6OLX0mgwUGKTeTrKIo6OnpgSzL8Pv9iMVisFgscDgccDqdqK2tfeBsxsVLN3H8RB8bFKmgvGw5nJsqtC6D6A4ZRcG10TBCg8MzPu3Q/+sP8L3f34s1ZWU4cODADO7nE48kOzs70dgodu8TIcOAz+eDy+VCQ0PD7Ba3bXkdXq8X7/7LAZVnCHQokAqnpvpNBgsKpMIFMd2/EFy+PIiu40EGgjkwSHq88nIdzGbxGrFQ7kim07g4NNE06WY09qm/N9Tfhz/Z8RW4Gxpw+PDhGd/Pt2zZAq/Xi66uLqFnCIQLA2pte6uvd0Jv1OPdfz0w62dOBr1xaqrfZJz4t14n5AnR03blyhDe9waRTufm4SZaq3GUoGr9aq3LIJq2SGIMoaH7n3aYSibxrR1fQQEUyLI8h/t5PcxmM7q6uoRdQyDcO09LSwt6enrQ1tY2qx8cACgqKkJraxt6Twbw7o//aVpfo9dJMButWGpejsdsZShfth7ly9bj0UWlWGpZDrOxiEFgGh59dCmeda+HQeLf1UwVFRXCXin2KWuUe6ymQlQ/9iherl6P5yrWomzZ0qlmQkc72nHu9CkcOHBgjvfzVnR3d6OlpUXN0nOKUDMDah+V29S0HR/5PsQ/v9d+11S+DoWSaWqq32SwwCgVcLpfRTdujOI9zymkUgtr3/JC1uCyY/WqR7Qug2jOUpkMLg0N4wXXM3i6thY/VeV+3oRAIACfzyfkvVqoj1fd3d0IBAJobm5WZbzm5l3oO30GQf8ZWAuXoLjoMaxavBZrH6lGydIKrLCuwiLTUhQY+NxfbcXFi/D8c1VsuTtNy4sXMQhQ3jDo9bh54TzO9/djl2r382b09vaip6dHlfFyjVBhQJZlSJIEt9utynhutxuSJOFS8DoetZVgibmY0/3z6JFlNjQ+V42CAh5V/DC1T5ZrXQKRqrJ1P5dlWZXxco1Q71p+vx92u/2OfadzYbFYYLfb4ff7VRmPZm7pUiteeN6BwkIxF/1Mx9o1K7FkCU9Zo/zC+7m6hAoD8XgcNptN1TGtVitisU/f+kLZtXixBS80OmAycbvc3YxGiY2IKC/xfq4uocKA2WxGOBxWdcxIJAKLxaLqmDRzi2xmvPB8NffP36Vq/WqYTJw1ofzD+7m6hAoDDocDwWAQcZXOwo7FYggGg3A4HKqMR3Njs5nx2UYHiooKtS5lQbBZTaisYKMnyk+8n6tLqDDgdDqRTqfh8XhUGc/j8SCdTk+rGx/Nj6IiE1543gGr1aR1KZp7cmM59HqhLnESCO/n6uI5A3Mg+r7UhSweH8ex93oRDqvXES2XrFy5BM8/W6V1GURZw/u5uoT62KDT6bBnzx60t7fPefuILMvo6OjA7t27hfzBWejM5gK88LwDixeL9/xPp9PhyY1lWpdBlFW8n6tLqJkBQM3eBBNnWXu9XhgM3Oe+UI2NJfHerwIYGo5qXcq8qax4FLVPrtG6DKKs4/1cPULNDACA0WhEW1sbQqEQtmzZgmh0Zm8Sk12uQqEQWltbhf3ByRWFhUY8/1w1li2zal3KvCgoMKC6ilsJSQy8n6tHuDAAADU1Nejs7ITX60V9ff20p5hkWUZ9fT28Xi86OzuFbneZSwoKDHj+2SoUF6u7J3khclSX8ERGEgrv5+oQMgwAQGNjI7q6umA2m+FyudDU1ISjR4/es00lFovhyJEjaGpqgsvlmmpz2djYqFHlNBtGowHPfqYKK5Yv1rqUrFm0yIK1a1ZoXQbRvOP9fO6EWzNwt2QyiZaWFuzbtw+BQACSJMFut8NqtSISiSAYDCKdTqO6uhq7d+/Gzp07he13nQ9SqTTe9wZx9eqw1qWo7rlnq/DoyiVal0GkGd7PZ0/4MDBJURT09PRAlmX4/X7EYjFYLBY4HA44nU7U1tYKu8o036TTGXR5g/j4ypDWpajm8ceWwv2Z9VqXQbQg8H4+cwwDJKRMJgPviT5cujSodSlzptfrsPmlJ2GzqdOwhYjEI+yaARKbXq+Hq74SpSXFWpcyZxXrHmMQIKI5YRggYen1etQ7K1BetlzrUmatsNCI6qpVWpdBRDmOYYCEptPpsOnpdVi7ZqXWpcxKjaMERiO3EhLR3DAMkPB0Oh2efmptznX4W7KkCGvKuZWQiOaOYYDolton18Be+bjWZUxb7cZyrogmIlUwDBDd5smNZaiuWq11GQ+1evUjWL58kdZlEFGeYBgguoujugSO6oV7vr8k6bGxplTrMogojzAMEN1HddVqbNywMNsA2ysfQ1GRSesyiCiPMAwQPcAT9sdR+2S51mXcwWQqwBN2biUkInUxDBB9isqKx/B03Vqty5iyoaYURqOkdRlElGcYBogeYu3alXBuqtB85f6yZVaUleb+iYlEtPAwDBBNQ3nZctRrHAhqn+RWQiLKDoYBomkqLS2G65lK6PXz/4ZcWlKMR5bZ5v37EpEYGAaIZmD1qkfQ8Ix9XgOBQdJjwwZuJSSi7GEYIJqhxx9fBvdn1kOS5ufyeeKJVbCYC+flexGRmBgGiGbh0ZVL8Kx7PQxZDgQWSyHslY9l9XsQETEMEM3SiuWL8dyzVTAYsrfVb2NNaVbHJyICGAaI5qS4eBGef64qK3v/i4ttKCnhVkIiyj6GAaI5emSZDY3PVaOgwKDquLUby1Udj4joQRgGiFSwdKkVLzzvQGGhUZXxystXYOlSqypjERE9jE5RFEXrIojyxWg4jmO/7EUiMX7f/68oCs6dC+JMfwADA2cxPj6GgoJClJSsxbqKKqxZY4fRaMArm2thNhfMc/VEJCqGASKVhcNxHHuvF/H4J4EglUrhF0cP499+3o6BgXOQJAkVFZWw2WwIh8Po7+9DOp1GSckafPWrX8e3v/1HMBrVmWUgInoYhgGiLIhGEzj2Xi+i0TGEQmfw1t98F+fPBbF161bs2rULbrcbZrN56vfH43F4PB68/fZ+dHS0o7a2Fm1tbaipqdHwT0FEomAYIMqSWGwM+/7mx/izP/0m1qwpx4EDB7Bp06aHfp0sy9ixYwdCoRA6OzvR2Ng4D9USkcgYBoiyxOfzweVyweVy4fDhwygqKpr210ajUWzZsgVerxddXV2cISCirGIYIMqCZDIJl8uFRCKBEydOzCgITIpGo6ivr4fZbEZXVxfXEBBR1nBrIVEWtLS0oKenB21tbbMKAgBQVFSE1tZWdHd3o6WlReUKiYg+wZkBIpUpigKHwwGHw4GDBw/OebympiYEAgH4fD7odPPfPpmI8h9nBohU1t3djUAggObmZlXGa25uRm9vL3p6elQZj4jobgwDRCqTZRmSJMHtdqsyntvthiRJkGVZlfGIiO7GMECkMr/fD7vdfsc5AnNhsVhgt9vh9/tVGY+I6G4MA0Qqi8fjsNlsqo5ptVoRi8VUHZOIaBLDAJHKzGYzwuGwqmNGIhFYLBZVxyQimsQwQKQyh8OBYDCIeDyuynixWAzBYBAOh0OV8YiI7sYwQKQyp9OJdDoNj8ejyngejwfpdBpOp1OV8YiI7sZzBohUxnMGiCjXcGaASGU6nQ579uxBe3v7nLcDyrKMjo4O7N69m0GAiLKGMwNEWaB2bwKv1wuDwZCFSomIODNAlBVGoxFtbW0IhULYsmULotHojL5+smthKBRCa2srgwARZRXDAFGW1NTUoLOzE16vF/X19dN+ZCDLMurr6+H1etHZ2cn2xUSUdQwDRFnU2NiIrq4umM1muFwuNDU14ejRo/dsO4zFYjhy5Aiamprgcrmm2hY3NjZqVDkRiYRrBojmQTKZREtLC/bt24dAIABJkmC322G1WhGJRBAMBpFOp1FdXY3du3dj586dMBqNWpdNRIJgGCCaR4qioKenB7Isw+/3IxaLwWKxwOFwwOl0ora2lrsGiGjeMQwQEREJjmsGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhwDANERESCYxggIiISHMMAERGR4BgGiIiIBMcwQEREJDiGASIiIsExDBAREQmOYYCIiEhw/z9SO969EV/xDgAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -257,9 +257,9 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ,\n", - " ))" + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 8, @@ -268,7 +268,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -301,9 +301,9 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ,\n", - " ))" + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 9, @@ -351,9 +351,9 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ,\n", - " ))" + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 10, @@ -362,7 +362,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -403,9 +403,9 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ,\n", - " ))" + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 11, @@ -414,7 +414,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -482,9 +482,9 @@ "data": { "text/plain": [ "(,\n", - " (,\n", - " ,\n", - " ))" + " (,\n", + " ,\n", + " ))" ] }, "execution_count": 13, @@ -493,7 +493,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -556,22 +556,21 @@ "metadata": {}, "outputs": [ { - "ename": "XGIError", - "evalue": "Invalid colormap!", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mXGIError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn [16], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m xgi\u001b[38;5;241m.\u001b[39mdraw(SC, pos, node_labels\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n", - "File \u001b[0;32m~/Dropbox (ISI Foundation)/WORK/SCIENCE/xgi/xgi/drawing/draw.py:216\u001b[0m, in \u001b[0;36mdraw\u001b[0;34m(H, pos, ax, node_fc, node_ec, node_lw, node_size, node_shape, max_order, dyad_color, dyad_lw, dyad_style, dyad_color_cmap, dyad_vmin, dyad_vmax, edge_fc, edge_fc_cmap, edge_vmin, edge_vmax, alpha, node_labels, hyperedge_labels, rescale_sizes, aspect, **kwargs)\u001b[0m\n\u001b[1;32m 213\u001b[0m max_order \u001b[38;5;241m=\u001b[39m max_edge_order(H)\n\u001b[1;32m 215\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(H, SimplicialComplex):\n\u001b[0;32m--> 216\u001b[0m ax \u001b[38;5;241m=\u001b[39m \u001b[43mdraw_simplices\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 217\u001b[0m \u001b[43m \u001b[49m\u001b[43mSC\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mH\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 218\u001b[0m \u001b[43m \u001b[49m\u001b[43mpos\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpos\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 219\u001b[0m \u001b[43m \u001b[49m\u001b[43max\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43max\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 220\u001b[0m \u001b[43m \u001b[49m\u001b[43mdyad_color\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdyad_color\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 221\u001b[0m \u001b[43m \u001b[49m\u001b[43mdyad_lw\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdyad_lw\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 222\u001b[0m \u001b[43m \u001b[49m\u001b[43medge_fc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43medge_fc\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 223\u001b[0m \u001b[43m \u001b[49m\u001b[43mmax_order\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmax_order\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 224\u001b[0m \u001b[43m \u001b[49m\u001b[43msettings\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msettings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 225\u001b[0m \u001b[43m \u001b[49m\u001b[43mhyperedge_labels\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhyperedge_labels\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 226\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 227\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 228\u001b[0m dyad_collection \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;66;03m# for compatibility with simplices until update\u001b[39;00m\n\u001b[1;32m 229\u001b[0m edge_collection \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;66;03m# for compatibility with simplices until update\u001b[39;00m\n", - "File \u001b[0;32m~/Dropbox (ISI Foundation)/WORK/SCIENCE/xgi/xgi/drawing/draw.py:790\u001b[0m, in \u001b[0;36mdraw_simplices\u001b[0;34m(SC, pos, ax, dyad_color, dyad_lw, edge_fc, max_order, settings, hyperedge_labels, **kwargs)\u001b[0m\n\u001b[1;32m 782\u001b[0m dyad_color \u001b[38;5;241m=\u001b[39m _color_arg_to_dict(dyad_color, H_\u001b[38;5;241m.\u001b[39medges, settings[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdyad_color_cmap\u001b[39m\u001b[38;5;124m\"\u001b[39m])\n\u001b[1;32m 783\u001b[0m dyad_lw \u001b[38;5;241m=\u001b[39m _scalar_arg_to_dict(\n\u001b[1;32m 784\u001b[0m dyad_lw,\n\u001b[1;32m 785\u001b[0m H_\u001b[38;5;241m.\u001b[39medges,\n\u001b[1;32m 786\u001b[0m settings[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmin_dyad_lw\u001b[39m\u001b[38;5;124m\"\u001b[39m],\n\u001b[1;32m 787\u001b[0m settings[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmax_dyad_lw\u001b[39m\u001b[38;5;124m\"\u001b[39m],\n\u001b[1;32m 788\u001b[0m )\n\u001b[0;32m--> 790\u001b[0m edge_fc \u001b[38;5;241m=\u001b[39m \u001b[43m_color_arg_to_dict\u001b[49m\u001b[43m(\u001b[49m\u001b[43medge_fc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mH_\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43medges\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msettings\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43medge_fc_cmap\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 792\u001b[0m \u001b[38;5;66;03m# Looping over the hyperedges of different order (reversed) -- nodes will be plotted\u001b[39;00m\n\u001b[1;32m 793\u001b[0m \u001b[38;5;66;03m# separately\u001b[39;00m\n\u001b[1;32m 794\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m \u001b[38;5;28mid\u001b[39m, he \u001b[38;5;129;01min\u001b[39;00m H_\u001b[38;5;241m.\u001b[39medges\u001b[38;5;241m.\u001b[39mmembers(dtype\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mdict\u001b[39m)\u001b[38;5;241m.\u001b[39mitems():\n", - "File \u001b[0;32m~/Dropbox (ISI Foundation)/WORK/SCIENCE/xgi/xgi/drawing/draw_utils.py:366\u001b[0m, in \u001b[0;36m_color_arg_to_dict\u001b[0;34m(color_arg, ids, cmap)\u001b[0m\n\u001b[1;32m 364\u001b[0m maxval \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0.9\u001b[39m\n\u001b[1;32m 365\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 366\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m XGIError(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInvalid colormap!\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 368\u001b[0m \u001b[38;5;66;03m# handle the case of IDStat vs iterables\u001b[39;00m\n\u001b[1;32m 369\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(color_arg, IDStat):\n", - "\u001b[0;31mXGIError\u001b[0m: Invalid colormap!" - ] + "data": { + "text/plain": [ + "(,\n", + " (,\n", + " ,\n", + " ))" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABLDklEQVR4nO3deVjVZf7/8efhgHpYXDMV942EYykqeAwbWxzLzEQkp6ZFqjEypcxpnWn6Ne3LNN/GNDWmScpWS0nJNGwxJZCTQMWi4Iq5ZpnBOaBwOL8/DMoAZeccz+txXV5zDZ/7c/OG65rhde7V4HQ6nYiIiIjH8mrtAkRERKR1KQyIiIh4OIUBERERD6cwICIi4uEUBkRERDycwoCIiIiHUxgQERHxcAoDIiIiHk5hQERExMMpDIiIiHg4hQEREREPpzAgIiLi4RQGREREPJzCgIiIiIdTGBAREfFwCgMiIiIeTmFARETEwykMiIiIeDiFAREREQ+nMCAiIuLhFAZEREQ8nMKAiIiIh1MYEBER8XAKAyIiIh5OYUBERMTDKQyIiIh4OIUBERERD6cwICIi4uEUBkRERDycd2sXIOJqnE4nmZmZWK1WcnJyKCkpwWQyYTabCQsLIzQ0FIPB0Npliog0GYPT6XS2dhEirqCsrIz4+HgWLFhAXl4eRqORoKAgAgICKCoqIj8/H4fDQXBwMHPmzGHmzJn4+Pi0dtkiIo2maQIRIDs7G4vFQlxcHGazmeTkZIqKisjNzWXz5s3k5uZSVFREcnIyZrOZuLg4LBYL2dnZrV26iEijaWRAPN6GDRuYNGkSffv2JSEhgVGjRp3xHavVSkxMDIWFhSQlJTFu3LgWqFREpHkoDIhHqxwRGDNmDImJifj5+dX5XZvNRmRkJGlpaaSmpjJ06NBmrFREpPkoDIjHKisrw2KxUFpaSnp6er2CQCWbzUZ4eDgmk4nU1FStIRARt6Q1A+Kx4uPjycrKIiEhoVoQ6NevHwaDodq/2bNnn9LOz8+PpUuXkpmZSXx8fEuWLyLSZDQyIB7J6XRiNpsxm80sX7682vPvv/8eh8NR9d+zs7P54x//yGeffcbFF19crX10dDR5eXlkZ2dr26GIuB2NDIhHyszMJC8vj9jY2Bqfd+3ale7du1f9S0pKYuDAgbUuFIyNjSU3N5esrKxmrFpEpHkoDIhHslqtGI1GIiIiztj2xIkTLFu2jFtuuaXWT/0REREYjUasVmtTlyoi0uwUBsQj5eTkEBQUhMlkOmPbxMREfvrpJ2JiYmpt4+vrS1BQEDk5OU1YpYhIy1AYEI9UUlJCQEBAndq+8sorTJw4kcDAwNO28/f3x263N0V5IiItSncTiEcymUwUFRWdsd2ePXtYv349K1asOGPb4uJifH19m6I8EZEWpZEB8Uhms5n8/HxKSkpO2+7VV1/l3HPPZdKkSadtZ7fbyc/Px2w2N2WZIiItQmFAPFJYWBgOh4OUlJRa21RUVPDqq68yY8YMvL1PP4iWkpKCw+EgLCysqUsVEWl2OmdAPNKZzhkA+Pjjj7n88svZtm0bQUFBp+0vKiqKL7/8kry8PDp16tSgenRtsoi0FoUB8VgvvfQScXFxpKWlNeoTvdVqZfTo0TidTjp06MDcuXOZO3cuHTt2POO7ujZZRFyBwoB4rKa6myAsLIyjxcV4+/jw3c6dALRv35677rqLu+++u9aRguzsbGbMmEFWVhZRUVHExsYSERFxynbHkpISUlJSWLJkCStWrGD48OEkJCToUiQRaVIKA+LRsrOzGTNmDBaLpUG3Fk6ZMoUvU9N4cmkCvQYMJO2T9SyPX0Lh9u3AyVBw5513cvfdd9O5c+eqd3Vtsoi4EoUB8XiVf5h79uzJsmXL6jRlYLVamTFjBrv3FPLgf+ZjHvnrH/OKigo2f/Yp7y5ZTOH2AgACAgKIi4tj3rx5HDhwQNcmi4hLURgQj1dRUcGIESPIzs7G6XQSOXUqs26/vdqQvd1uJyUlhcWLF5OYmMiAIUOY/cij9Bk0uNZ+0z/7lOXxL7M7fxtw8pbD9u3b06lTp2pTE0VFRfzjH/9g5cqVHD58mNDQUP7zn/9UCye6NllEmprCgHi8+Ph4brvtNtqaTEy75VY2frSGvTt3YjQaGTR4MP7+/hQXFVFQUEBFRQW9+w/gij9dy/ipUXjX4Q9xRUUF1g2fs/zlxezatg2DwUB6enq1qYE//elPZGdns2jRIgIDA1m2bBn/93//R25uLj179jylrdVqxWKx8OKLL3LHHXc06e9DRDyPwoB4tMOHDzNkyBCOHj3Kzffcx1V/vh6n08mubVvZnpPD3p07OFFaSpu2bflizRqKfz7Ggy/MZ9Qf6j9fX1FRwR2Tr+SiMWN4//33T3lWeTzyBx98cMoBRyNHjmTixIk8/vjj1frTtcki0lR0HLF4tHvuuYejR4/Sf8gQJk7/EwAGg4EBQ4IZMCT4lLbl5eV8/N5yMlNSGhQGdm/bxvcHDjBr1qxqz8rLy3E4HLRr1+6Ur5tMJjZt2lRjf7GxsUyYMIGsrCxCQ0PrXY+ISCWdQCge69NPP+X111/HYDBw+9//gfEMpwyOiBgLQEbKRhoyoLY9J7vWa5MDAgIYM2YMjz32GPv378fhcLBs2TJSU1M5cOBAjf3p2mQRaSoKA+KRjh8/XvUJ/fJrpjPIfOZV+UPDwvH28eHw/v3s27273t9z784dDBo8uNZrk19//XWcTic9e/akbdu2zJ8/n+uuuw4vr5r/Z6prk0WkqSgMiEd65plnyM/Pp+M55/Dn2XF1esfk64t55EgAMlNqHro/nRPHj5/22uSBAweyYcMGiouL2bt3L+np6ZSVlTFgwIBa39G1ySLSFBQGxOMUFBTw5JNPAnDLX+/F7zR/oH8v9MLKqYK6h4HSEjvWDZ+T/+03/HT06Bnb+/n50aNHD44ePcq6deuYMmVKrW11bbKINAUtIJSzypku/Bk+fDh33HEHx48fZ/iYC7lwwuX16n/E2ItY+u9/kZuxhRK7HVMNf4idTif7du8mM2UTGSmbyM3YQnlZGQBeXl5VNf3eunXrcDqdnHfeeWzfvp17772XIUOGcPPNN9dYS+W1yXPnzq3XzyAi8nsKA3JWONOFPy+99BIOh4NevXrx3Xff4dOmDTMf+Fu9t+QF9u3LuT17cnjfPrKt6YSNuxg4+ek/22olMyWFjC83cXjfvlPeOzcwkIEhZlLXJ5OSksL48eOr9X3s2DEefPBBvvvuOzp37sy0adN44oknaj1USNcmi0hTURgQt/f7C3/mz59f64U/ixYtYt++fbTv1IkTx0vr/b0MBgMjIsay9t132PjRGg7t20fGpo3kZmyh7MSJqnbePj6EjBjJiIixhEaMpWe/fgDcfU0Ui5csqTEMTJ8+nenTp9e5liVLlhASEsLw4cPr/XOIiPyWDh0St9bQC39qu1fgdI6XlJC95SvWLX+XLRu/qPa8a49AQiMiGBExlqFh4TVOIax99x1eefbpJrk2WScQikhTURgQt5Wdnd2oC39+e+NgbfcLHCgsJCNlI5kpKeRs+YoTx4+f8nzw0PO58I9/JDRiLL36DzjjtEN5WRl/i7mJNjixWq0Nvja58m6CtLQ0vM9wPoKIyJkoDIhbKisrw2KxUFpaWu3CH4fDwSOPPMKyZcs4ePAggYGBxMTE8NBDD53yx9pmsxEWFkaZwcATr76Gt48Px0tLyd2yhYyUjWSkpHBwb+Ep3/ec7t0ZETGWguxsdm3byk1z5zHlphn1qr1wewF/i5nBhWMsfPDBB7q1UERanT5SiFuKj48nKyuLzZs3V/tj+swzz7Bo0SISEhIwm8189dVX3HzzzXTo0IE777yzqp2fnx8JCQlYLBZeeOhvlNrtJz/9l/66lsDo7U3w8FBGjL2I0IgIeg8YiMFg4MO33mDXc1vJ2LSx3mGgz6DBPPif+Tx1152EhYWRkJBQ52uTY2JiKCwsJCkpSUFARJqMRgbE7TidTsxmM2azmeXLl1d7ftVVV9GtWzdeeeWVqq9NmzYNk8nEsmXLqrWPiopi9erVlJeXA9ClWzdCLxzLiIgIzg8fja+/f7V3DhQWMidyMt7e3rz66YYa25xJ4fYCFj7yMDu3biUyMpJZs2bVem3ykiVLWLlyJaGhoSxdulRBQESalEYGxO1kZmaSl5fH/Pnza3x+4YUX8vLLL5Ofn09QUBBff/01mzZt4t///neN7WfNmsXKlSuZdO2fuWxqFH0GDTrj3H+PPn3o3rsPB/cW8m36ZkZfelm9f44+gwbzxKuvsX7lCt5dsogVK1ZUbYn09/enuLiY/Px8HA4HISEhvPjii8ycObPWrYYiIg2lMCBux2q11nrhD8ADDzzAzz//zJAhQzAajTgcDp544gmuv/76GttXXvjTa+BA+g6ueSFhTUaMHcuat94kI2VTg8IAnNyCeMX0P5GSvI5jW7Zw44030r59e+x2O76+vsydO7fqsCRdUywizUVhQNxOTk4OQUFBtV748+677/LGG2/w5ptvYjabycrKYu7cuQQGBjJjRvX5fV9fXwYNHszenTvqVceIC38NA06ns8F/rJ1OJ3vy8wGYO3cuw4YNa1A/IiINpTAgbqekpOS0F/7ce++9PPDAA1x77bUAnH/++ezZs4ennnqqxjAAJy/8+e3CwboIGTmSNu3a8ePhw+wpKKBfUFC93q/0/YED2IqK8PHxITg4uEF9iIg0hi4qErdjMpkoKiqq9bndbq927a/RaKSioqLWd4qLi2nTrl296mjbrh1DR53cBZD5Zf1vMay0p+DkqEBISAht2rRpcD8iIg2lMCBux2w2k5+fT0lJSY3PJ0+ezBNPPMGHH37I7t27WblyJf/+97+ZOnVqje3tdjvbCwroPWBgvWsZEfHLLYabGh4Gdm3bCqDpARFpNQoD4nbCwsJwOBykpKTU+PzFF18kOjqaO+64g+DgYO655x5iY2N57LHHamxfeeHPILO53rWE/hIGtn6dhe00oxWns/uX9QK6Y0BEWovCgLid0NBQgoODWbJkSY3PAwICeOGFF9izZw8lJSXs2LGDxx9/vNYh+MWLF9Nn4ED6nzek3rV079WLwH79qHA4+GZzWr3fB9idvw3QyICItB6FAXE7BoOBOXPmsGLFCqxWa6P6slqtJCYmcvk1f2rwboBfpwo21vtde3Exh777DlAYEJHWozAgbmnmzJkMHz6cmJgYbDZbg/qw2WzcNGMGA4YM4Y9R0xpcS1UY+DKF+h7oWbl4sFevXnTp0qXBNYiINIbCgLglHx8fEhISKCwsJDIyst6BwGazMXnyZLYXFHDjXfMwNuLmv5ARI2nbrh0/HTlStRiwrrReQERcgcKAuK2hQ4eSlJREWloa4eHhdZ4ysFqthIeHs3HjRsrLy3n1+eewFf3c4Dp82rTh/PDRAGTWsqixNpXrBRQGRKQ1KQyIWxs3bhypqamYTCYsFgvR0dGsX7++2rZDu91OcnIy0dHRWCwWTCYTq1atolu3buzO38ZTd93J8Vq2KtbFiLG/TBWk1G/dwK5tWjwoIq1PtxbKWaGsrIz4+HgWLFhAXl7eaS/8mT17dtWFP9988w1/+MMfOHbsGCPHXsR9z/8f3g24COjw/v3MumoiXl5evPrpBvzbtz/jO47ycm646EJOHD9OQUEBgwYNasiPLiLSaAoDclZxOp1kZWVhtVrJycmpuvDHbDbXeuHPpk2bmDBhAiUlJfxh4pXEPfZEtRMM6+Ku6Kl8t3Mn8556hojLrzhj+707dzA3Ogp/f3+OHTvWoO8pItIUdDeBnFUMBgOhoaGEhobW+Z2xY8fy3nvvMWXKFL74aA3+HTpwy73313ur4YiIi/hu504yvkypUxioXDx4wQUXKAiISKvS/wOJAFdeeSUJCQkYDAbWvP0Wy1+u+UCj0xnxy5XKmSmbTnsPQqXdOoZYRFyEwoDIL/785z8zf/58AN5Zsog1b79Vr/eHhI6gna8vx378kZ1b887YXtsKRcRVKAyI/MacOXN45JFHAHjl2afZ+NGaOr/r4+PDBaMrtxie+eIiHUMsIq5CYUDkdx5++GHi4uIAePH//YMt9ThmeETERcCZbzE8euQIP/3wA15eXpx//vkNL1ZEpAkoDIj8jsFg4IUXXuD666/HUV7Ov+79K3mZGXV6t/Jo4oLsb/n56NFa21WOCgQFBeHr69v4okVEGkFhQKQGXl5evPrqq0yaNIkTx4/z5F13Vv0BP50u3brRZ9BgnE4nX6el1tpOUwQi4koUBkRq4ePjw7vvvsvYsWOxFxfx2OxZHCgsPON7v55GWPtUgRYPiogrURgQOQ1fX19Wr17NsGHD+OmHH3j0jlh+/P7wad+pnCrI+vJLHA5HjW126xhiEXEhCgMiZ9CxY0fWrl3LwIEDObx/P4/NnkXRsWO1tj/vgmH4+vvz809H2ZGbU+358dJS9u/ZDWhkQERcg8KASB10796d5ORkAgMDKdy+nafuiqO0xF5jW28fHy4YbQFqvsVw747tVFRU0LVrV7p3796sdYuI1IXCgEgd9e/fn3Xr1tGpUye2ffM1z/51HmVlZTW2rZwqqOkWw9+uF6jvkcciIs1BYUCkHoYOHcqHH36Ir68vX6el8uI//l7juoDQX44m3pGby7Effzjl2a5fjiHWFIGIuAqFAZF6GjNmDCtXrsTHx4eUj9fx32ee4veXf3buei79zzsPp9NJ5pdfnvJM2wpFxNUoDIg0wIQJE1i2bBkGg4GP31vOWy8trNYm9JfTCDO//HXdQEVFBXsKCgCNDIiI69AVxiINNH36dI4ePcrtt9/O+6/EE9ChA5NvuLHq+YiICFb8779s2bSRtcvfYd+uXfz0ww+U2Gx4e3tjs9lwOp1aNyAirU4jAyKNEBsbyxNPPAHA0n//i8+TVgNQXlbGrm1b8fHxoaS4mP89+ww7sjI5fvRHBg4cSEVFBaNHj8ZsNvPSSy/VuhBRRKQlGJy/n+wUkXpxOp3cc889/Pvf/8bLaOTmv97D56tXs2vbVqZOncrtt99OREQEJpOp6p2SkhJSUlJYsmQJK1asYPjw4SQkJDB06NBW/ElExFMpDIg0gYqKCm655RYSEhIwGo0MDgri9ddeY9SoUWd812q1EhMTQ2FhIUlJSYwbN64FKhYR+ZXCgEgTycrKIjw8nLFjx7J69Wr8/Pzq/K7NZiMyMpK0tDRSU1M1QiAiLUphQKQJlJWVYbFYKC0tJT09vV5BoJLNZiM8PByTyURqaio+Pj7NUKmISHVaQCjSBOLj48nKyiIhIaFaENi3bx833HADXbp0wWQycf755/PVV19V68PPz4+lS5eSmZlJfHx8S5UuIqKRAZHGcjqdmM1mzGYzy5cvP+XZ0aNHCQ0N5ZJLLmHWrFl07dqVgoICBg4cyMCBA2vsLzo6mry8PLKzs7XtUERahMKASCNlZGQwcuRIkpOTGT9+/CnPHnjgAVJSUti4sfodBbVJTk5mwoQJZGRkEBoa2tTliohUo2kCkUayWq0YjUYifrmP4LdWrVrFqFGjuOaaazj33HMJDQ094xRAREQERqMRq9XaXCWLiJxCYUCkkXJycggKCjrlHIFKO3fuZNGiRQwePJh169Yxa9Ys7rzzThISEmrtz9fXl6CgIHJycpqzbBGRKjqOWKSRSkpKCAgIqPFZRUUFo0aN4sknnwQgNDSU7OxsFi9ezIwZM2rt09/fH7vd3iz1ioj8nkYGRBrJZDJRVFRU47MePXoQEhJyyteCg4MpLCw8bZ/FxcX4+vo2WY0iIqejMCDSSGazmfz8fEpKSqo9i4iIYNu2bad8LT8/n759+9ban91uJz8/H7PZ3OS1iojURGFApJHCwsJwOBykpKRUe3b33XeTlpbGk08+yfbt23nzzTd5+eWXmT17dq39paSk4HA4CAsLa86yRUSqaGuhSCOd7pwBgKSkJB588EEKCgro378/8+bNY+bMmbX2p3MGRKSlKQyINIGXXnqJuLg40tLSGvWJ3mq1YrFYePHFF7njjjuasEIRkdopDIg0gaa+myAtLQ1vb232EZGWoTUDIk3Ax8eHhIQECgsLiYyMxGaz1ev9ylsLCwsLWbp0qYKAiLQohQGRJjJ06FCSkpJIS0sjPDy8zicIWq1WwsPDSUtLIykpSdcXi0iLUxgQaULjxo0jNTUVk8mExWIhOjqa9evXV9t2aLfbSU5OJjo6GovFUnVt8bhx41qpchHxZFozINIMysrKiI+PZ8GCBeTl5WE0GgkKCsLf35/i4mK2bdtGRUUFQUFB3HXXXcycORMfH5/WLltEPJTCgEgzcjqdZGVlYbVaycnJwW634+vry5o1a9i+fTvz588nLi6utcsUEQ+nMCDSCp577jnuu+8+JkyYwLp161q7HBHxcAoDIq1g69atBAcH4+Pjw5EjR2jfvn1rlyQiHkwLCEVawXnnncfgwYMpKyvj448/bu1yRMTDKQyItAKDwcDkyZMBWL16dStXIyKeTmFApJVUhoE1a9bgcDhauRoR8WQKAyKtJCIigo4dO3LkyBHS0tJauxwR8WAKAyKtxMfHh4kTJwKaKhCR1qUwINKKtG5ARFyBthaKtKKjR49y7rnnUl5ezvbt2xk4cGBrlyQiHkgjAyKtqFOnTlx00UWARgdEpPUoDIi0Mk0ViEhr0zSBSCvbvn07gwcPxtvbmyNHjtChQ4fWLklEPIxGBkRa2aBBgxgyZAjl5eWsXbu2tcsREQ+kMCDiAjRVICKtSWFAxAVcffXVwMnTCMvLy1u5GhHxNAoDIi5gzJgxdOnShaNHj5KSktLa5YiIh1EYEHEBRqORK6+8EtBUgYi0PIUBERehdQMi0lq0tVDERfz888+cc845lJWVsW3bNoKCglq7JBHxEBoZEHER7du3Z9y4cYBGB0SkZSkMiLiQyl0FCgMi0pI0TSDiQnbv3k3//v0xGo0cPnyYzp07t3ZJIuIBNDIg4kL69evH0KFDcTgcfPTRR61djoh4CIUBERejXQUi0tIUBkRcTGUYWLt2LWVlZa1cjYh4AoUBERcTHh5O165dOXbsGBs3bmztckTEAygMiLgYo9HIpEmTAE0ViEjLUBgQcUG/3WKoDT8i0ty0tVDEBRUXF9OlSxdOnDhBTk4OISEhrV2SiJzFNDIg4oL8/f259NJLAU0ViEjzUxgQcVHaYigiLUXTBCIuqrCwkL59++Ll5cWhQ4c455xzWrskETlLaWRAxEX16dOHYcOGUVFRwZo1a1q7HBE5iykMiLgwXVwkIi1B0wQiLsxqtRIeHo6/vz9Hjhyhbdu2rV2SiJyFNDIg4sJGjhxJ9+7dKS4uZsOGDa1djoicpRQGRFyYl5cXV111FaCpAhFpPgoDIi7ut1sMNasnIs1BawZEXJzdbqdLly6UlpbyzTffcP7557d2SSJyltHIgIiL8/X1Zfz48YCmCkSkeSgMiLgBnUYoIs1J0wQibmD//v307NkTg8HAgQMH6NatW2uXJCJnEY0MiLiBwMBARo4cidPp5MMPP2ztckTkLKMwIOImNFUgIs1F0wQibiIjI4ORI0fi6+vLDz/8QLt27Vq7JBE5S2hkQMRNhIaG0rNnT+x2O5999llrlyMiZxGFARE3YTAYNFUgIs1CYUDEjeg0QhFpDlozIOJGSktL6dKlC3a7nYyMDEJDQ1u7JBE5C2hkQMSNtGvXjj/+8Y+ApgpEpOkoDIi4Ga0bEJGmpmkCETdz6NAhevTogdPpZN++fQQGBrZ2SSLi5jQyIOJmunXrRnh4OIBOIxSRJqEwIOKGNFUgIk1J0wQibuibb75h2LBhtGvXjh9++AFfX9/WLklE3JhGBkTc0Pnnn0+fPn0oLS3lk08+ae1yRMTNKQyIuCGdRigiTUlhQMRNXX311QAkJSVRUVHRytWIiDvTmgERN3X8+HHOOecciouLsVqtjBo1qrVLEhE3pZEBETfVtm1bLr/8ckBTBSLSOAoDIm6sct3AqlWrWrkSEXFnmiYQcWPff/893bp1w+l0UlhYSO/evVu7JBFxQxoZEHFjXbt2ZcyYMcDJhYQiIg2hMCDi5ip3FWjdgIg0lKYJRNxcbm4uZrOZtm3b8sMPP+Dn59faJYmIm9HIgIibCw4OZsCAARw/fpzk5OTWLkdE3JDCgIib02mEItJYmiYQOQt88sknjB8/nk6dOvHEE0+Ql5dHSUkJJpMJs9lMWFgYoaGhGAyG1i5VRFyQwoCImysrK2PRokXce++9nDhxAqPRSFBQEAEBARQVFZGfn4/D4SA4OJg5c+Ywc+ZMfHx8WrtsEXEhmiYQcWPZ2dlYLBbuvvtuJk+eTHJyMkVFReTm5rJ582Zyc3MpKioiOTkZs9lMXFwcFouF7Ozs1i5dRFyIRgZE3NSGDRuYNGkSffv2JSEhoU53E1itVmJiYigsLCQpKYlx48a1QKUi4uoUBkTcUOWIwJgxY0hMTKzXdkKbzUZkZCRpaWmkpqYydOjQZqxURNyBpglE3ExZWRkzZsygb9++1YLAokWLuOCCC2jfvj3t27dnzJgxfPTRR6e87+fnR2JiIn369CEmJoaysrKW/hFExMUoDIi4mfj4eLKyskhISKg2ItCrVy+efvpptmzZwldffcWll17KlClTyMnJOaWdn58fS5cuJTMzk/j4+JYsX0RckKYJRNyI0+nEbDZjNptZvnx5nd7p3Lkzzz33HLfeemu1Z9HR0eTl5ZGdna1thyIeTCMDIm4kMzOTvLw8YmNjz9jW4XDw9ttvY7PZqi4z+r3Y2Fhyc3PJyspq4kpFxJ0oDIi4EavVitFoJCIiotY23377Lf7+/rRt25bbb7+dlStXEhISUmPbiIgIjEYjVqu1uUoWETegMCDiRnJycggKCsJkMtXa5rzzziMrK4vNmzcza9YsZsyYQW5ubo1tfX19CQoKqramQEQ8i3drFyAidVdSUkJAQMBp27Rp04ZBgwYBMHLkSKxWK//5z39YsmRJje39/f2x2+1NXquIuA+NDIi4EZPJRFFRUb3eqaio4Pjx47U+Ly4uxtfXt7GliYgbUxgQcSNms5n8/HxKSkpqfP7ggw/yxRdfsHv3br799lsefPBBPv/8c66//voa29vtdvLz8zGbzc1Ztoi4OE0TiLiRsLAwHA4HKSkpjB8/vtrzw4cPc9NNN3HgwAE6dOjABRdcwLp16/jjH/9YY38pKSk4HA7CwsKau3QRcWE6Z0DEjTTknIHT0TkDIgKaJhBxKwaDgTlz5rBixYpGbwe0Wq2sXLmS2bNnKwiIeDiNDIi4mbKyMiwWC6WlpaSnp9frkqJKNpuN8PBwTCYTaWlpeHtrxlDEk2lkQMTN+Pj4kJCQQGFhIZGRkdhstnq9X3lrYWFhIUuXLlUQEBGFARF3NHToUJKSkkhLSyM8PLzOUwZWq5Xw8HDS0tJISkrS9cUiAigMiLitcePGkZqaislkwmKxEB0dzfr166ttO7Tb7SQnJxMVFYXFYsFkMpGamsq4ceNaqXIRcTVaMyDi5srKyoiPj2fBggXk5eXh5eXF4MGD8fcPoLi4mO3bC3A4HHh7ezNs2DBSU1Px8fFp7bJFxIUoDIicJfbu3UufPn0wGAxMuDyKsrITtG3bjt69+2My+fGfF/4f3t7e7Nmzh8DAwNYuV0RciFYOiZwlKi8jCuzZl1v/8tdqzz9et4K8vK9ZvHgxjz76aEuXJyIuTGsGRM4S2dnZAPTuPaDG5xOvvAaAxYsXn/auAhHxPAoDImeJymuIe/fuX+PzsPA/0KXLuXz//fe88847LVmaiLg4hQGRs0TVyECfmkcGjEZvLr8iCoD58+ej5UIiUklhQOQsUFFRccaRAYBLL7saH582bNmyhdTU1JYqT0RcnMKAyFlgz5492O12vL196N69V63t2rfvyNiLJgDw4osvtlR5IuLiFAZEzgKVUwQ9e/XDaDz9JqGJE6MBeO+999i3b1+z1yYirk9hQOQsULVeoFftUwSV+vUPIjhkOOXl5SxevLi5SxMRN6AwIHIWqFovUMviwd+r3Ga4ZMkSSktLm60uEXEPCgMiZ4Ez7ST4vbCwi+hyTjdtMxQRQGFAxO2Vl5ezdetW4PQ7CX7LaPTm8sunAicXEmqboYhnUxgQcXM7duzg+PHjtG3bjq5de9T5vUsvuxqfNtpmKCIKAyJur3KKoFfv/nh51f1/0u3bd+Siiy4HTh5CJCKeS2FAxM3V5bCh2lzxm22G3333XZPWJSLuQ2FAxM2d6YKi0+nXbzDBIcNxOBzaZijiwRQGRNxcY8IAaJuhiCgMiLi148ePU1BQANR9W+HvVW4zPHLkiLYZingohQERN5afn095eTm+vv507ty1QX2c3GZ48jbD//znP9pmKOKBFAZE3NhvFw8aDIYG93PZ+JPbDDMzM/nyyy+bqjwRcRMKAyJurL4nD9YmIKCDthmKeDCFARE31tjFg79Vuc3w/fff1zZDEQ+jMCDixhpzxsDv9es3mJCQUG0zFPFACgMibsput7Njxw6g8dMElbTNUMQzKQyIuKmtW7fidDpp374jHTp0bpI+R4WN5Zxfthm+/fbbTdKniLg+hQERN9WU6wUqGY3eTPhlm+H8+fO1zVDEQygMiLipptpJ8Hu/3WaYkpLSpH2LiGtSGBBxE06nk4yMDJYsWcKdd95ZNYxfVHSMnTu3Ndmn+N9uM3zxxRebpE8RcW0Gp8YBRVxaWVkZ8fHxLFiwgLy8PIxGI0FBQZhMJo4dO8bu3btxOBz07t2fCZdHcdn4KXh7ezfqe+7ZvZ1777kJo9HI7t276dWrVxP9NCLiijQyIOLCsrOzsVgsxMXFYTabSU5OpqioiNzcXLZs2cL27dspKioiOTmZ8PARvPq//+Ohv99GYeGORn3fvv0GYTaPwOFwsGjRoib6aUTEVWlkQMRFbdiwgUmTJtG3b18SEhIYNWrUGd+xWq3MmDGD3bv3cP8DzxFiDm3w99+c9jnP/+tvdOnShb1792IymRrcl4i4No0MiLig7OxsJk2axJgxY0hPT69TEAAICwvDarVy4YVjeObpexs1QlC5zfCHH37QNkORs5zCgIiLKSsrY8aMGfTt25fExET8/PwAeOSRRzAYDKf8GzJkSLX3/fz8+OCDD+jXry+LFj5BeXl5g+owGr25/IppwMmFhBpEFDl7KQyIuJj4+HiysrJISEioCgKVzGYzBw4cqPq3adOmGvvw8/MjISGBXbvy+WT9Bw2u5bLLrqZNm7baZihyllMYEHEhTqeTBQsWEBUVVePUgLe3N927d6/6d84559TaV1hYGJGRkXz88YoGf6r3D2jPRX/QbYYiZzuFAREXkpmZSV5eHrGxsTU+LygoIDAwkAEDBnD99ddTWFh42v5uv/129hbuYveu/AbXNHHiyfsKVqxYwd69exvcj4i4LoUBERditVoxGo1ERERUezZ69GiWLl3K2rVrWbRoEbt27eKiiy6iqKio1v4iIiIwGo3s2JHX4Jr69B2obYYiZzmFAREXkpOTU3Wg0O9NnDiRa665hgsuuIDLL7+cNWvW8NNPP/Huu+/W2p+vry+DBg1m795djaqr8jbDl19+mZKSkkb1JSKuR2FAxIWUlJQQEBBQp7YdO3YkKCiI7du3n7adv78/x4837jrikaMi6Nq1u7YZipylFAZEXIjJZDrtsP9vFRcXs2PHDnr06HHGdm3btmtUXb/dZqjbDEXOPgoDIi7EbDaTn59f41D8Pffcw4YNG9i9ezdffvklU6dOxWg0ct1119Xan91uZ/v2Anr37t/o2i69dDJt2rQlKyur1i2NIuKeFAZEXEhYWBgOh6PGPf3fffcd1113Heeddx7Tp0+nS5cupKWl0bVr11r7S0lJweFwMHBgcKNr0zZDkbOX7iYQcSFOpxOz2YzZbGb58uWN7m/atGlYv8rkX88vw2AwNLq/wj07uOevN2I0Gtm1axe9e/dudJ8i0vo0MiDiQgwGA3PmzGHFihVYrdZG9WW1WklMTGTChKgmCQLwyzbDodpmKHK20ciAiIspKyvDYrFQWlpKenp6tSOJ68JmszFixAgOHfqe+QuWYzL5Nll96ekb+NezD+o2Q5GziEYGRFyMj48PCQkJFBYWEhkZic1mq9f7NpuNKVOmsGPHDo4dO8qj/4zjyJFDTVbfqJFjq7YZvvXWW03Wr4i0HoUBERc0dOhQkpKSSEtLIzw8vM5TBlarlfDwcDZv3swzzzxD586d2bE9jwfuu5ns7C1NUpuX0ahthiJnGYUBERc1btw4UlNTMZlMWCwWoqOjWb9+fbVth3a7neTkZKKjo7FYLJhMJlJTU/nrX//Kli1bCA0N5eeff+LxR+eStPqtJvnjXbnN8Ouvv9Y2Q5GzgNYMiLi4srIy4uPjWbBgAXl5eRiNRoKCgvD396e4uJj8/HwcDgchISHMnj2bmTNn4uPjU/V+SUkJsbGxvP766wBcGDGe22c9SLt2jZvrf3nJM6xP/oDo6Ogm2fkgIq1HYUDETTidTrKysrBareTk5GC32/H19cVsNhMWFsbw4cNr3TVQeTXyvHnzKC8vp0+fgdxz31N0796rwfUUFu7gnnkntxnu3LmTPn36NLgvEWldCgMiHmTjxo1cc801HDp0CD+/AO686xFCR4xpcH+PPhJHdvYWHnjgAZ566qkmrFREWpLWDIh4kIsuuogtW7ZgsViw2Yp4+ql7eP+9V6moqGhQf1dcGQ3oNkMRd6cwIOJhevbsyeeff87tt9+O0+nknbfj+ddzD2K3Fde7r8pthj/++KO2GYq4MYUBEQ/Utm1bFi1axCuvvEKbNm34yrqRBx/8C999t7te/ZzcZnhydEDbDEXcl8KAiAe75ZZb2LRpE7169eLA/kL+9sBf2Jz2eb36uPSyq2jbth1ff/01GzdubJ5CRaRZKQyIeLiwsDC2bNnCxRdfTGmpnef/9TfefGMxFQ5Hnd7392/PRX+4AtBthiLuSmFARDj33HNJTk5m3rx5ACSufI2nnvwrRUXH6vT+FRNPnki4cuVKCgsLm61OEWkeCgMiAoC3tzfPP/88b775JiaTia+/TueB+29h9678M77bp89Ahg4dSUVFhW4zFHFDCgMicorrrruOtLQ0BgwYwPeHD/DQ32PZ+MW6M7438cprAG0zFHFHCgMiUs0FF1zAV199xcSJEzlx4jgvzv8nS199gfLy8lrfGTkygq7n9uDHH3/kzTffbMFqRaSxFAZEpEadOnVi9erVPPTQQwCs+fBdHnv0Tn766cca23sZjVyh2wxF3JLCgIjUymg08thjj7Fy5UoCAgLIy83i/vtiyM/PrrH9JZee3Gb4zTff8MUXX7RwtSLSULqbQETqZOvWrUydOpWtW7fi7e3DLbfezfg/RlZr9/KSZ1mfnEhUVBR///vfqy5WKikpwWQyVV2sFBoaWuvFSiLSshQGRKTOioqKiImJYcWKFQBcetlkbv3LX/HxaVPVZvfufO67JwZvb2/Ky8urrlwOCAigqKio6srl4OBg5syZU+3KZRFpeZomEJE6CwgI4L333uOpp57CYDDw6Ser+X//uIMffjgMnLzWePGip/Hy8uLqq68mOTmZoqIicnNz2bx5M7m5uRQVFZGcnIzZbCYuLg6LxUJ2ds3TDiLSMjQyICIN8vHHH3Pttddy9OhROnToxNSoGbz91hL69+/Ha6+9xqhRo87Yh9VqJSYmhsLCQpKSkhg3blwLVC4iv6cwICINtmvXLqZOncrXX3+Nl5cXF198MatWrcLPz6/OfdhsNiIjI0lLSyM1NZWhQ4c2Y8UiUhOFARFplGPHjjFo0CA6d+5MRkZGvYJAJZvNRnh4OCaTidTUVK0hEGlhWjMgIo3yxhtv8OOPP/LGG2+cNgg8/fTTGAwG5s6dW+2Zn58fS5cuJTMzk/j4+GasVkRqopEBEWkwp9OJ2WzGbDazfPnyWttZrVamT59O+/btueSSS3jhhRdqbBcdHU1eXh7Z2dnadijSgjQyICINlpmZSV5eHrGxsbW2KS4u5vrrryc+Pp5OnTqdtr/Y2Fhyc3PJyspq4kpF5HQUBkSkwaxWK0ajkYiIiFrbzJ49m0mTJjF+/Pgz9hcREYHRaMRqtTZlmSJyBt6tXYCIuK+cnByCgoIwmUw1Pn/77bfJyMio8x93X19fgoKCyMnJacoyReQMFAZEpMFKSkoICAio8dnevXu56667SE5Opl27dnXu09/fH7vd3lQlikgdKAyISIOZTCaKiopqfLZlyxYOHz7MiBEjqr7mcDj44osvWLBgAcePH8doNFZ7r7i4GF9f32arWUSq05oBEWkws9lMfn4+JSUl1Z5ddtllfPvtt2RlZVX9GzVqFNdffz1ZWVk1BgG73U5+fj5ms7klyheRX2hkQEQaLCwsDIfDQUpKSrUFggEBAdVOE/Tz86NLly61njKYkpKCw+EgLCys2WoWkeo0MiAiDRYaGkpwcDBLlixpkv4WL15MSEgIw4cPb5L+RKRudOiQiDTKSy+9RFxcHGlpaY36RG+1Whk9ejS9evVi+fLljB49ugmrFJHTURgQkUYpKyvDYrFQWlpKenp6g+8mGDVqFDt37uTEiRMYDAb+8pe/8NRTT9GlS5dmqFpEfkvTBCLSKD4+PiQkJFBYWEhkZCQ2m61e79tsNiZPnsz27dt57qUnmPqnq3E6ncTHxxMUFER8fDwVFRXNVL2IgEYGRKSJbNiwgauuuoo+ffqwdOnSOk0ZWK1WZsyYQUFBAeXl5fTq25M3Ev/Hvr37+ecDT7IttwCA0aNH89JLL52yTVFEmo5GBkSkSYwbN47U1FRMJhMWi4Xo6GjWr19fbduh3W4nOTmZadOmYbFYMLbx4r9vL6RPv958t2cf10feQmCvHiR+8g5/e+xe/Pz92Lx5M6NGjWL27NkcPXq0lX5CkbOXRgZEpEmVlZURHx/PggULyMvLw2g0MnjwYNq1a0dxcTG7du3C4XDQrl1b7ntkHtfeFI2Pjw8H9h/khim3Urh7L736BLIs8X/07B3IoYOHefr/PU/Sio8A6Nq1K8899xw33XSTbjYUaSIKAyLSLJxOJ1lZWVitVj777DPefvttTL4m7nt4Ls8++gIl9hLeXPUqYWNGVr1zYP9Bboz8C3t2FdKrTyCvr3yFXn16ApC2KZ1H7n+SHfk7ARg7diwLFy7kggsuaJWfT+RsojAgIs1u586dDBw4EJNvO77Zk84Ddz7M+28lcu2Ma3jsX/84pe3BA4e4Ycqt7NlVSM/egSxL/DUQnDhRxtIlr7PgX0sosZdgNBqJi4vjn//8J+3bt2+NH03krKAwICLN7ujRo3Tu3BmAnH1b+CptCzOm3UbHTh1Iyf6UNm18Tml/8MAhboz8C7t37qkWCAAO7DvIk/94jrWrkwHo3r07zz//PNddd12dpg6cTieZmZlYrVZycnIoKSnBZDJhNpsJCwsjNDRUUxDiURQGRKTZVVRU4O3tjdPpJDXnMzp16cgfhk3g8KHvWfz6f7jsikuqvfPbQBDYqwfLEl+hd99ep7TZ+GkKjz74NLt37gHgkksuYcGCBYSEhNRYR03rGYKCgggICKCoqIj8/HwcDgfBwcHMmTOHmTNn4uPjU2NfImcT7SYQkWbn5eVFhw4dADh27GeMRiOTpl4BwOr3P6rxne49urHsg1foP7Av+787wA2Rt1K4+7tT2lx0aQRJX7zP3Afm0LZdWz777DOGDRvGfffdR3Fx8Slts7OzsVgsxMXFYTabSU5OpqioiNzcXDZv3kxubi5FRUUkJydjNpuJi4vDYrGQnZ3dDL8REdeiMCAiLaJTp04A/PzTzwBcHT0JgE/WfU5xcc0HFXXrfi6vJ/4aCG6cWj0QtG3bhtl/vY21KYlcdsXFlJeX89xzzxEcHMx7772H0+lkw4YNVackbt68meXLlzN+/HhMJtMpfZlMJsaPH8/y5ctJS0ujtLSUMWPGsGHDhqb+dYi4FIUBEWkRlWHg2C9hwHxBMAMG9aO0pJTkDz+p9b1u3c9lWeL/GDCo3y8jBLdUCwQAvfr0ZPHr81nyxov06tuT7777jmuuuYaIiAiuvPJKxowZQ3p6OqNGjapTvWFhYaSnp2OxWLjqqqs0QiBnNYUBEWkRHTt2BE5OEwAYDAYm/zI6sOq9Nad999zuXXl95SsMGNyfA/sOckPkLezZtbfGtpdOGMdHG1cy555YvH28SU9Pp1evXtxzzz1ce+21BAYGYjAYSExMPOW9FStWMGHCBLp06YLBYCArKws/Pz8SExPp06cPMTExlJWVNe6XIOKiFAZEpEX8fpoAYHLUlQB8+UUa3x86ctr3z+3elddX/LdOgaCdqR133T+bWXNn4nQ6eeONN6ioqGDYsGEsXLiwxndsNhtjx47lmWeeOeXrfn5+LF26lMzMTOLj4+v884q4E4UBEWkRVdMEx34NA33792bYyPOpqKhgzQfrztjHud27suyXEYKD+w+dDAQ7C2ts63Q6+eiDdURFRTFq1CgmTpzI448/ztSpU2tsf+ONN/Lwww8zfvz4as/CwsKYOnUqCxcuRBuw5GykMCAiLaIyDBQdKzrl61dP+2Wq4P0P69RP127nsGzlKwwMGsDB/Ye4vpZAkPtNHtvzdxIbG9vIyk+KjY0lNzeXrKysJulPxJUoDIhIi/j9AsJKkyIvx2g08k1GNrt37KlTX78NBIcOHOb6yFuqvftNVg5Go5GIiIgmqT8iIgKj0YjVam2S/kRcicKAiLSIqjUDx04NA126diFinAWA1StOv5Dwt845twvLVr7CoPMGcujAYW6IvPWUQFCwdQeDgwZX2z7YUL6+vgQFBZGTk9Mk/Ym4EoUBEWkRtY0MwK9nDqx6b0295uTPObcLr6/478lAcPBkINi1YzcAx0tLCQgIaHzhv+Hv74/dbm/SPkVcgcKAiLSI2kYGAMZPvJR2pnbs3rmHb7Pq98n75AjBfxk85JdAMOVkIGjbrh1FRUVn7qAeiouL8fX1bdI+RVyBwoCItIjTjQz4+fty2RUXA7D6/bpPFVTq0vXkCEFQ8CAOH/qeG6bcSqfOHSjIL6CkpAQ4+Yc8KyuragHgrl27yMrKorDw5OLDH3/8kaysLHJzcwHYtm0bWVlZHDx4EAC73U5+fj5ms7ne9Ym4OoUBEWkRNZ0z8FuVUwUfrlyLw+God/9dunbhtd8Egtf/+xYOh4OUlBQAvvrqK0JDQwkNDQVg3rx5hIaG8vDDDwOwatUqQkNDmTTpZB3XXnstoaGhLF68GICUlBQcDgdhYWH1rk3E1enWQhFpEUeOHKFr164A5O7fUu02wLKyMiKGXsbRH3/i1eVLGHvxmAZ9nx+O/MhNUX8hP287bdu25aqrruK9995rdP3R0dHk5eWRnZ2t643lrKORARFpEZXHEQP8fKz6XL6Pjw8Tp0wAYNV7dTtzoCZdzunMayv+S7+BfTl+/DgrVqxo9HZAq9XKypUrmT17toKAnJUUBkSkRXh7e1et7q9pESH8egDRxx9+QmlJaYO+j8PhYOU7q9i3dz9w8vrkG264AZut5psRz8RmsxETE0NoaCi33XZbg/oQcXUKAyLSYn7dUVDzKv/QsGH07B2IrdjGp+vqf23w7h17+PPkm3nmkX9TdqKMCy8aTY9ePdixYweTJ0+udyCw2WxERkZSWFjI0qVL8fb2rndNIu5AYUBEWsyZFhF6eXkxOWoiUL8DiCoqKkh4+Q0mX3INGdYs/Pz9ePL/HmHp+y/z/ro36Nk7kC+++IIRI0bUecrAarUSHh5OWloaSUlJDB06tM71iLgbhQERaTE1XVb0e5W7Cjas38hPR4+dsc+9e77jpqiZPP73ZygtKeXCcRbWbFzBNTdEYTAY6NylE++te4M+/XqzY8cORo8eTVRUFOvXr6/adljJbreTnJxMVFQUFosFk8lEamoq48aNa8RPLeL6NOYlIi3mdGcNVBo8ZBBDzOexNWcba1cnc+1N0TW2czqdvJWwnGf+3/PY7SX4+pq475F5/DlmerVFfp06d+SdNa9x49S/sC03n1WrVrFy5UqMRiODgwbj7+9PcXExBfkFOBwOvL29ueKKK0hMTKy260HkbKSRARFpMWeaJqh0dfSVQO27Cg7sO8jN02/n/937OHZ7CWFjRrJ6w/tcf/Ofal3t36lzR/722L3AyUWG/u39uWPeTMLHjmDAeX0IHzuCR579O3f/LY7y8nJyck5edCTiCTQyICItpi7TBABXRU3kuUdfwJq6hf3fHSCwVw/g5GjA+299wBMPPUtxUTFt27Xlr3+/kxm3XY+X15k/26xf8ykA7TsE8POxIt549Z1fTi4cXNWmtKSU/y5Yyp49e/jss8+47LLLGvrjirgNjQyISLNzOp1kZGRQUFAAwKdrP+fRB5/mrYTl5HydW+1yoh6B3QkbMxKA1Ss+AuDwwe+JvSGOB+96mOKiYoaPuoBVn73LzbffWKcgcPz4iapFiU/83yOEnD+EH48c5caov5CfV1DVrp2pHVdFXQHA//73v8b/8CJuQCcQikizKSsrIz4+ngULFpCXl4fRaKRfv3506NABe4m9ao5+UNAAbrj1WqbfOK1qjv6d19/joXmPcl5IELfdeTOPPvAUx376GZ82Psx9YDa33jGjXsP4H636mDtvvYfugd34PGMtRT8XExN9Gznf5NGpSyeWrfx1hOCbzGymTfgzbdu2Zd26dWzdupWcnBxKSkowmUyYzWbCwsIIDQ3VIURyVlAYEJFmkZ2dzYwZM8jKyiIqKorY2FgiIiIwmUxVbUpKSkhJSWHJkiWsWLGC4KFDeHbBYwQFD+bYTz8zJuQSysrKqtoPHRbCswseZ/CQQfWu5y/XzWbD+o3MmvsX5v39TgB+OnrslEDw+op4zgsJ4sSJE1w84gp+PHIUh8OB0WgkKCiIgIAAioqKyM/Px+FwEBwczJw5c5g5c6YWGopb0zSBiDS5DRs2YLFYKC0tZfPmzSxfvpzx48efEgQATCYT48ePZ/ny5aSlpeEsdzL9ypvYnPIVqRs3V7UzGAzc9cBs3v3o9QYFgcMHv2fjpycvLJp67dVVX+/YqQMJ78czdFgIR384yo1RM1m3ej3TJ97ED9//yJQpU0hOTqaoqIjc3Fw2b95Mbm4uRUVFJCcnYzabiYuLw2KxkJ2d3cDflkjr08iAiDSp7OxsLBYLY8aMITExET8/vzq/a7PZmDJlChs3fsGJE7+OCHQ99xw2fbu+TmsDavLyi//juUdfYGR4KG9/mFDt+bGffubma2L5NiunahTgtddeY9SoUWfs22q1EhMTQ2FhIUlJSTqTQNySRgZEpMmUlZUxY8YM+vbtW+8gAODn58cHH3xAv3798fb25tY7ZuAf4Mf3h4+wZXNmg2pyOp2seHsVAFG/GRX4rQ4d2/PQk/fj7e3NH/7wB6xWa52CAEBYWBjp6elYLBauuuoqjRCIW1IYEJEmEx8fT1ZWFgkJCdWCwBdffMHkyZMJDAzEYDCQmJhYYx9+fn4sW7aMiooKevftyYRJ4wFY9X7djyf+ra8zvmVH/k7amdoxMfLyGtuUlZXx6ANPMzhoMPfffz/XXnttrXU6nU4efvhhevToUTXNsX//fhITE+nTpw8xMTGnrHMQcQcKAyLSJJxOJwsWLCAqKqrGT9U2m41hw4axcOHCM/YVFhbG1KmRvPG/d5g87eQBRGtXfXzK1EFdrXj7AwAuv2o8AQH+NbZ59/X3ycveymsJr1FRUXHaOp999lnmz5/P4sWL2bx5M35+flx++eUYjUaWLl1KZmYm8fHx9a5TpDXp0CERaRKZmZnk5eUxf/78Gp9PnDiRiRMn1rm/2NjbmTBhAh06tufcbl05fOh7Nn6WwmWXX1znPkpLSklasRaAaddNqbGN0+lk2StvnxJiaqvT6XTywgsv8NBDDzFlysn+XnvtNbp160ZiYiLXXnstU6dOZeHChcyaNUvbDsVtaGRARJqE1WrFaDQSERHRJP1FRERgNBrJ+SaPSVNPHgK0+r36TRUkf/QpRT8X0bN3IKMjwmpsk/tNHtvzdxIbG3vG/nbt2sXBgwcZP3581dc6dOjA6NGjSU1NBSA2Npbc3FyysrLqVatIa9LIgIg0iZycHIKCgqptH2woX19f+g/oz4vPLqJL1y7AyYODjhz5kbZtfDB4eWE0euHl9es/o9GIwcuA0WjEy8uLlA1pwMkthP984Em8DF54GSvbemHw8mJbTkGdQ8zBgwcB6Nat2ylf79atW9WzyhBjtVoJDQ1tkt+FSHNTGBCRJlFSUkJAQECT9unv58/2gu0cPvQ9ABUVFWzelF7vfnK+ySPnm7xanw8cOLBJQ0xQUBA5OTlN0p9IS1AYEJEmYTKZKCoqatI+S0pKuHj8RURdO4U1q9axdlUyQcGDufWOm6iocFLhcFDhdOJwOHBWnPzPiooKKioqSPk8lY2ffUmvPoFM+/PUk20r36lw4qhw4Kyo4ItPv6S9X4c61dO9e3cADh06RI8ePaq+fujQIYYPH1713/39/bHb7U36uxBpTgoDItIkzGYzL730UtX5/Y1lt9vZvn07N9z2JyZOmUDI+UNYuyqZ7dt28IdLx3LOuV1qfdfpdPLW0uUAzLlnVq2LBwFOnHgaa0pGnWrq378/3bt355NPPqn64//zzz+zefNmZs2aVdWuuLgYX1/fOvUp4gq0gFBEmkRYWBgOh4OUlJQanxcXF5OVlVW1sG7Xrl1kZWVRWFhYY/uUlBQcDgfnDzcD0HdAH4aNPJ+Kigo+TFx72loy0rPYs6sQX18TV0z+42nbDh4ykIL8AkpKSs5Yp8FgYO7cuTz++OOsWrWKb7/9lptuuonAwEAiIyOBkyEmPz8fs9l82u8r4koUBkSkSYSGhhIcHMySJUtqfP7VV18RGhpatahu3rx5hIaG8vDDD9fYfsmSxQw+byAh5w+p+trV0yYBsOr9D09by/tvJQJwxdUT8PM//Sf0C4abTwkxZ6rzvvvuIy4ujttuu42wsDCKi4tZu3Yt7dq1A34NMWFhNe9eEHFFuptARJrMSy+9RFxcHGlpaY36Y2i1WrFYLDz81ANcf8u1VV8/cvgHxl4wHofDQXLaavoN7FvtXbvNzoVDL8NWbOOND/5H+IWnP1bY6XRycegVWEaP4f33329wzZWio6PJy8sjOztb5wyI29DIgIg0mZkzZzJ8+HBiYmKw2WwN6sNms3HDDTcwMGgAf7op+pRn55zbhQv/MBqA1StqPnPg4w8/wVZso3e/XoSNGXna7/XzsZ+5b87f2b/vACtXrsRqtTao5kpWq5WVK1cye/ZsBQFxK1pAKCJNxsfHh4SEBMaMGUNkZGSDbi28+uqr2bFjB+1MbdmyOYvREad+sr86ehIbP/uS5W+s5JyuXSjYtpPjpaW0bdeOwUMGsvyNFQBEXTvltH+QN32eyoN3PczB/YcwGAx0796dmJgY0tPT633BUmXtMTExhIaGctttt9X7fZHWpJEBEWlSQ4cOJSkpibS0NMLDw+v8adtqtRIeHk56ejpDhgzBVmzn5umxJK38qKpNWVkZP/5wFB8fHw7sO8g/H3gKa0oGu/L3Yk3J4J/3P8m3mTl4e3tj+KX979ltdh657wluviaWg/sPMXDgQDZt2sTHH39MYWEhkZGR9R7VsNlsREZGUlhYyNKlS/H21ucscTNOEZFm8O233zpHjhzp9PLyck6bNs2ZnJzstNvtp7Sx2WzOjz/+2Dlt2jSnl5eXc+TIkc5vv/3WabfbnVFRUU7ACTjvf2SeM2nDe07zBSGn7c9utzuTk5Or+jNfEOL88Iv3nQXff+Ms+P4b5zsfvubs279PVb933HGHs7i4uOr9zz//3Onv7+8MCQlxpqen1+nnTE9Pd4aEhDj9/f2dn3/+eeN/cSKtQGFARJrNiRMnnAsXLnQGBwc7AafRaHQGBwc7w8LCnMHBwU6j0egEnCEhIc6FCxc6T5w4UfVueXm586677qr6w92mTRtnSEiw02q11ul7n/wjHez08/dzvrp8ifO2uFucXl5eTsDZs2dP58cff1zje40JMSLuSrsJRKTZOZ1OsrKysFqt5OTkYLfb8fX1xWw2ExYWxvDhw2ud37/vvvt4/vnnGTduHKtXr673GoQpU6awYcMGysvLAbjxxhuZP38+HTt2rPW9srIy4uPjWbBgAXl5eRiNRoKCgvD396e4uJj8/HwcDgchISHMnj2bmTNn4uPjU6/fiYgrURgQEZdVVlaGxWKhpKQEq9Xa4IV9I0aMYM+ePbz22mtMnz69zu82JsSIuBOtchERlxUfH09WVhabN29my5YtPPfcc2zZsoUDB05uBaw89a+srIyHHnqINWvWsHPnTjp06MD48eN5+umnCQwMZNmyZVgsFo4cOVKv728wGE45gEjkbKXdBCLikpxOJwsWLCAqKopRo0Zhs9kYNmwYCxcurNbWbreTkZHBP/7xDzIyMlixYgXbtm3j6quvBk4elTx16lQWLlyIBkNFqtM0gYi4pIyMDEaOHElycjLjx48/5ZnBYDhlZKAmlVsV9+zZQ58+fUhOTmbChAlkZGTok77I72hkQERcktVqxWg0EhER0aD3jx07hsFgqFooGBERgdFobPQpgyJnI4UBEXFJOTk5BAUFNeg65NLSUu6//36uu+462rdvD4Cvry9BQUHk5OQ0dakibk9hQERcUklJCQEBAfV+r6ysjOnTp+N0Olm0aNEpz/z9/bHb7U1VoshZQ7sJRMQlmUwmioqK6vVOZRDYs2cPn376adWoQKXi4mJ8fU9/pbGIJ9LIgIi4JLPZTH5+PiUlJXVqXxkECgoKWL9+PV26dDnlud1uJz8/H7PZ3Bzlirg1jQyIiEsKCwvD4XCQkpLC+PHjKS4uZvv27VXPd+3aRVZWFp07d6ZHjx5ER0eTkZFBUlISDoeDgwcPAtC5c2fatGlDSkoKDoeDsLCw1vqRRFyWthaKiEtyOp2YzWbMZjPLly/n888/55JLLqnWbsaMGTzyyCP079+/xn4+++wzLr74YqKjo8nLyyM7O1unBor8jkYGRMQlGQwG5syZQ1xcHFarlYsvvvi0Bwad7pnVamXlypW8+OKLCgIiNdDIgIi4rMq7CUpLS0lPT2/w3QTh4eGYTCbS0tLw9tZnIJHf0wJCEXFZPj4+JCQkUFhYSGRkJDabrV7v22w2IiMjKSwsZOnSpQoCIrVQGBARlzZ06FCSkpJIS0sjPDy8zicIVh5HnJaWRlJSEkOHDm3mSkXcl8KAiLi8cePGkZqaislkwmKxEB0dzfr166ttO7Tb7SQnJxMdHY3FYsFkMpGamsq4ceNaqXIR96A1AyLiNsrKyoiPj2fBggXk5eVhNBoJCgrC39+f4uJi8vPzcTgchISEMHv2bGbOnImPj09rly3i8hQGRMTtOJ1OsrKysFqt5OTkYLfb8fX1xWw2ExYWxvDhw7VrQKQeFAZEREQ8nNYMiIiIeDiFAREREQ+nMCAiIuLhFAZEREQ8nMKAiIiIh1MYEBER8XAKAyIiIh5OYUBERMTDKQyIiIh4OIUBERERD6cwICIi4uEUBkRERDycwoCIiIiHUxgQERHxcAoDIiIiHk5hQERExMMpDIiIiHg4hQEREREPpzAgIiLi4RQGREREPJzCgIiIiIdTGBAREfFwCgMiIiIeTmFARETEwykMiIiIeDiFAREREQ+nMCAiIuLhFAZEREQ8nMKAiIiIh/v//h7Q978CSG8AAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -586,7 +585,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "66cf2c2c", "metadata": {}, "outputs": [], @@ -605,7 +604,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "id": "aadc6917", "metadata": {}, "outputs": [], @@ -628,10 +627,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "f840930c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(,\n", + " (,\n", + " ,\n", + " ))" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure(figsize=(10, 10))\n", "ax = plt.subplot(111)\n", @@ -648,10 +671,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "03902a8e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(,\n", + " (,\n", + " ,\n", + " ))" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure(figsize=(10, 10))\n", "ax = plt.subplot(111)\n", @@ -676,10 +723,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "36596a26", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "centers, heights = xgi.degree_histogram(H)\n", "\n", From 172ea736b0e83698cbd9e69d115d447d83cadc20 Mon Sep 17 00:00:00 2001 From: Nicholas Landry Date: Mon, 16 Oct 2023 14:55:28 -0400 Subject: [PATCH 26/26] Fix --- xgi/drawing/draw_utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/xgi/drawing/draw_utils.py b/xgi/drawing/draw_utils.py index b5a5e27e2..7d7ee394e 100644 --- a/xgi/drawing/draw_utils.py +++ b/xgi/drawing/draw_utils.py @@ -136,7 +136,7 @@ def _parse_color_arg(colors, cmap, ids, id_kind="edges"): if id_kind == "edges" and isinstance(colors, NodeStat): raise TypeError("The color argument for edges cannot be a NodeStat") - elif id_kind == "nodes" and isinstance(colors, Edgestat): + elif id_kind == "nodes" and isinstance(colors, EdgeStat): raise TypeError("The color argument for nodes cannot be an EdgeStat") xsize = len(ids)