diff --git a/configs/datasets/graph_8.yaml b/configs/datasets/graph_8.yaml new file mode 100755 index 00000000..1ede10af --- /dev/null +++ b/configs/datasets/graph_8.yaml @@ -0,0 +1,12 @@ +data_domain: graph +data_type: trivalent +data_name: graphs_8vertices +data_dir: datasets/${data_domain}/${data_type} + +# Dataset parameters +num_features: 1 +num_classes: 2 +task: classification +loss_type: cross_entropy +monitor_metric: accuracy +task_level: node diff --git a/configs/transforms/liftings/graph2combinatorial/curve_lifting.yaml b/configs/transforms/liftings/graph2combinatorial/curve_lifting.yaml new file mode 100644 index 00000000..c210b5e9 --- /dev/null +++ b/configs/transforms/liftings/graph2combinatorial/curve_lifting.yaml @@ -0,0 +1,4 @@ +transform_type: 'lifting' +transform_name: "CurveLifting" +feature_lifting: ProjectionSum +max_rank: 2 \ No newline at end of file diff --git a/modules/data/load/loaders.py b/modules/data/load/loaders.py index 5d0d14b1..7b0641f0 100755 --- a/modules/data/load/loaders.py +++ b/modules/data/load/loaders.py @@ -16,7 +16,9 @@ ) from modules.data.utils.custom_dataset import CustomDataset from modules.data.utils.utils import ( + load_8_vertex_cubic_graphs, load_cell_complex_dataset, + load_double_house_graph, load_gudhi_dataset, load_hypergraph_pickle_dataset, load_manual_graph, @@ -139,6 +141,10 @@ def load(self) -> torch_geometric.data.Dataset: data = load_manual_graph() dataset = CustomDataset([data], self.data_dir) + elif self.parameters.data_name in ["graphs_8vertices"]: + graphs = load_8_vertex_cubic_graphs() + dataset = CustomDataset(graphs, self.data_dir) + elif self.parameters.data_name in ["manual_rings"]: data = load_manual_mol() dataset = CustomDataset([data], self.data_dir) diff --git a/modules/data/utils/utils.py b/modules/data/utils/utils.py index 1993c23f..da62e0fa 100755 --- a/modules/data/utils/utils.py +++ b/modules/data/utils/utils.py @@ -10,6 +10,7 @@ import toponetx.datasets.graph as graph import torch import torch_geometric +import torch_geometric.data from gudhi.datasets.generators import points from gudhi.datasets.remote import ( fetch_bunny, @@ -23,6 +24,45 @@ rootutils.setup_root("./", indicator=".project-root", pythonpath=True) +def get_ccc_connectivity(complex, max_rank): + r""" + + Parameters + ---------- + complex : topnetx.CombinatorialComplex, topnetx.SimplicialComplex + Combinatorial Complex complex. + max_rank : int + Maximum rank of the complex. + + Returns + ------- + dict + Dictionary containing the connectivity matrices. + """ + practical_shape = list( + np.pad(list(complex.shape), (0, max_rank + 1 - len(complex.shape))) + ) + + connectivity = {} + # compute incidence matrices + for rank_idx in range(1, max_rank + 1): + matrix = complex.incidence_matrix(rank=rank_idx - 1, to_rank=rank_idx) + connectivity[f"incidence_{rank_idx}"] = from_sparse(matrix) + + # compute adjacent matrices + for rank_idx in range(max_rank + 1): + matrix = complex.adjacency_matrix(rank_idx, rank_idx + 1) + connectivity[f"adjacency_{rank_idx}"] = from_sparse(matrix) + + for rank_idx in range(1, max_rank + 1): + matrix = complex.laplacian_matrix(rank_idx) + connectivity[f"laplacian_{rank_idx}"] = matrix + + connectivity["shape"] = practical_shape + + return connectivity + + def get_complex_connectivity(complex, max_rank, signed=False): r"""Gets the connectivity matrices for the complex. @@ -365,6 +405,100 @@ def load_manual_graph(): ) + +def load_k4_graph() -> torch_geometric.data.Data: + """K_4 is a complete graph with 4 vertices.""" + vertices = [i for i in range(4)] + y = [0, 1, 1, 1] + edges = [ + [0, 1], + [0, 2], + [0, 3], + [1, 2], + [1, 3], + [2, 3], + ] + G = nx.Graph() + G.add_nodes_from(vertices) + G.add_edges_from(edges) + G.to_undirected() + edge_list = torch.Tensor(list(G.edges())).T.long() + x = torch.tensor([1, 5, 10, 50]).unsqueeze(1).float() + return torch_geometric.data.Data( + x=x, edge_index=edge_list, num_nodes=len(vertices), y=torch.tensor(y) + ) + + +def load_double_house_graph() -> torch_geometric.data.Data: + """Double house graph is a featured graph in Geiger et al.""" + vertices = [i for i in range(8)] + y = [0, 1, 1, 1, 0, 0, 0, 0] + edges = [ + [0, 1], + [0, 2], + [0, 7], + [1, 2], + [1, 3], + [2, 4], + [3, 5], + [3, 4], + [4, 6], + [5, 6], + [5, 7], + [6, 7], + ] + G = nx.Graph() + G.add_nodes_from(vertices) + G.add_edges_from([[v1, v2] for (v1, v2) in edges]) + G.to_undirected() + edge_list = torch.Tensor(list(G.edges())).T.long() + x = torch.tensor([1, 5, 10, 50, 100, 500, 1000, 5000]).unsqueeze(1).float() + return torch_geometric.data.Data( + x=x, edge_index=edge_list, num_nodes=len(vertices), y=torch.tensor(y) + ) + + +def load_8_vertex_cubic_graphs() -> list[torch_geometric.data.Data]: + """Downloaded from https://mathrepo.mis.mpg.de/GraphCurveMatroids/""" + # fmt: off + edgesets = [ + [{1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 5}, {4, 6}, {5, 7}, {5, 8}, {6, 7}, {6, 8}, {7, 8}], + [{1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 5}, {3, 6}, {4, 5}, {4, 7}, {5, 8}, {6, 7}, {6, 8}, {7, 8}], + [{1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 5}, {3, 6}, {4, 7}, {4, 8}, {5, 7}, {5, 8}, {6, 7}, {6, 8}], + [{1, 2}, {1, 3}, {1, 4}, {2, 5}, {2, 6}, {3, 5}, {3, 7}, {4, 6}, {4, 7}, {5, 8}, {6, 8}, {7, 8}], + [{1, 2}, {1, 3}, {1, 4}, {2, 5}, {2, 6}, {3, 5}, {3, 7}, {4, 6}, {4, 8}, {5, 8}, {6, 7}, {7, 8}], + ] + # fmt: on + + list_data = [] + for i, edgeset in enumerate(edgesets): + n = 8 if i < 5 else 10 + vertices = [i for i in range(n)] + x = ( + torch.tensor([1, 5, 10, 50, 100, 500, 1000, 5000]).unsqueeze(1).float() + if i < 5 + else torch.tensor([1, 5, 10, 50, 100, 500, 1000, 5000, 10000, 50000]) + .unsqueeze(1) + .float() + ) + y = ( + torch.tensor([0, 1, 1, 1, 0, 0, 0, 0]) + if i < 5 + else torch.tensor([0, 1, 1, 1, 0, 0, 0, 0, 1, 1]) + ) + edgeset = [[v1 - 1, v2 - 1] for (v1, v2) in edgeset] + G = nx.Graph() + G.add_nodes_from(vertices) + # offset by 1, since the graphs presented start at 1. + G.add_edges_from(edgeset) + G.to_undirected() + edge_list = torch.Tensor(list(G.edges())).T.long() + + data = torch_geometric.data.Data(x=x, edge_index=edge_list, num_nodes=n, y=y) + + list_data.append(data) + return list_data + def load_manual_mol(): """Create a manual graph for testing the ring implementation. Actually is the 471 molecule of QM9 dataset.""" @@ -486,6 +620,7 @@ def load_manual_mol(): ) + def get_Planetoid_pyg(cfg): r"""Loads Planetoid graph datasets from torch_geometric. diff --git a/modules/matroid/matroid.py b/modules/matroid/matroid.py new file mode 100644 index 00000000..cc19328f --- /dev/null +++ b/modules/matroid/matroid.py @@ -0,0 +1,289 @@ +from collections.abc import Callable, Collection, Iterable +from itertools import chain, combinations + +import networkx as nx +from toponetx.classes.combinatorial_complex import CombinatorialComplex + +from modules.utils.utils import get_spanning_trees + + +def powerset(iterable: Iterable): + """From https://docs.python.org/3/library/itertools.html#itertools-recipes + Example: powerset([1,2,3]) → () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3) + """ + + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s) + 1)) + + +def fs(iterable: Iterable): + return iterable if isinstance(iterable, frozenset) else frozenset(iterable) + + +class CCMatroid(CombinatorialComplex): + """Matroids is a set system that implements the following + + Matroids are combinatorial structures that follow certain rules, see the accompanying functions: + - from_bases + - from_circuits + - from_rank + for more details. + Moreover, if a set is independent: + - (1) then its subsets are + - (2) if there is a bigger independent set, we can construct a new nontrivial independent set by adding an element from the bigger set to the smaller. + + Parameters + ---------- + ground : Collection + A collection of ground elements that the matroid is based on. We need this to compute the dual matroid + independent_sets : Collection, optional + These are the simplicial complexes that follow (1) and (2). + If None, then this is considered a dubious matroid, where only the empty set is independent. + + Examples + -------- + Define the uniform matroid U24: + + >>> ground = range(4) + >>> independent_sets = [subset for subset in power(ground) if len(subset) <= 2] + >>> M = CCMatroid.from_bases(ground=ground, independent_sets=independent_sets) + >>> M.skeleton(1) # [[0, 1], [0, 2], [0, 3], [1, 2], [1, 3], [2, 3]] + """ + + def __init__( + self, + ground: Collection, + independent_sets: Collection | None = None, + **kwargs, + ) -> None: + CombinatorialComplex.__init__( + self, cells=None, ranks=None, graph_based=False, **kwargs + ) + # Remove the empty set from the set of independent sets. + independent_sets = list(filter(lambda X: len(X) != 0, independent_sets)) + ranks = map(lambda X: len(X) - 1, independent_sets) + + for ind, rnk in zip(independent_sets, ranks, strict=True): + self.add_cell(ind, rnk) + self.max_rank = self.ranks[-1] + self._ground = frozenset([g for g in ground]) + + @classmethod + def from_bases(cls, ground: Collection, bases: Collection | None) -> "CCMatroid": + """Constructs a matroid from its bases + The bases of a matroid are ones where we cannot use the augmentation axiom to further increase its cardinality. + As matroids are simplicial complexes, we can use the independence criterion to form the independent sets. + + Parameters + ---------- + ground : Collection + A collection of ground elements that the matroid is based on. + bases : Collection, optional + A collection of bases + + Returns + ------- + CCMatroid + The associated matroid associated with the bases. + """ + independent_sets = frozenset( + [frozenset(ind) for base in bases for ind in powerset(base)] + ) + return cls(ground=ground, independent_sets=independent_sets) + + @classmethod + def from_circuits(cls, ground: Collection, circuits: Collection) -> "CCMatroid": + """Constructs a matroid from its circuits. + A set X is a circuit of M if every proper subset of X is independent in M, but X itself is not dependent. + + Parameters + ---------- + ground : Collection + A collection of ground elements that the matroid is based on. + circuits : Collection, optional + A collection of circuits + + Returns + ------- + CCMatroid + The associated matroid associated with the circuits. + """ + + def is_independent(subset: frozenset): + return all(not circuit.issubset(subset) for circuit in circuits) + + independent_sets = [] + for subset in powerset(ground): + subset = frozenset(subset) + if is_independent(subset): + independent_sets.append(subset) + independent_sets = frozenset(independent_sets) + return cls(ground=ground, independent_sets=independent_sets) + + @classmethod + def from_rank( + cls, groundset: Collection, matroid_rank: Callable[[Collection], int] + ) -> "CCMatroid": + """Constructs a matroid from its rank function + A rank function is submodular, and we can use its definition to create the independent sets. + More precisely, a subset X of the ground set is independent if its computed rank, r(X) == len(X) + + Parameters + ---------- + ground : Collection + A collection of ground elements that the matroid is based on. + matroid_rank : Callable[[Collection], int] + A rank function. A rank function is order preserving, submodular, and normalized. + + Returns + ------- + CCMatroid + The associated matroid associated with the rank function. + """ + independent_sets = [ + subset + for subset in powerset(groundset) + if len(subset) == matroid_rank(subset) + ] + independent_sets = frozenset(independent_sets) + return cls(ground=groundset, independent_sets=independent_sets) + + def matroid_rank(self, input_set: Iterable) -> int: + """Matroid rank function + This is the original matroid rank function that isn't from the combinatorial complex rank. + We need this function to compute certain matroids. + It also has a nice definition with dual matroids. + + Parameters + ---------- + input_set : Collection + A collection of elements based on the current matroid's ground set. + + Returns + ------- + int + The computed matroid rank of the input. + """ + input_set = fs(input_set) + size = len(input_set) + if size == 0: + return 0 + + for level in range(size - 1, -1, -1): + skeleton = self.skeleton(level) + for independent_set in skeleton: + if frozenset.issubset(independent_set, input_set): + return level + 1 + + raise KeyError(f"hyperedge {input_set} and its subsets are not in the complex") + + @property + def ground(self) -> frozenset: + return self._ground + + @property + def bases(self) -> frozenset: + return frozenset(self.skeleton(self.max_rank)) + + @property + def circuits(self) -> Collection: + """Not implemented; not important to implement for the purposes of the PR""" + raise NotImplementedError + + def span(self, S: Collection) -> frozenset: + """Returns the closure of a set. + The closure of a set $S$ is defined as the elements that do not contribute to rank of $S$. + In some aspects, it represents $cls(S) - S$ represents the boundary of $S$ (much like normal topology). + + Parameters + ---------- + S : Collection + A collection of elements based on the current matroid's ground set. + + Returns + ------- + frozenset + The closure of S + """ + S = fs(S) + rankS = self.matroid_rank(S) + closure = { + g + for g in (frozenset.difference(self.ground, S)) + if self.matroid_rank({g} | S) == rankS + } + return frozenset.union(S, frozenset(closure)) + + def dual(self) -> "CCMatroid": + """Returns the dual of a matroid + The dual of a matroid is computed by taking the complement of its bases. + + Returns + ------- + CCMatroid + The dual of the associated matroid + """ + new_bases = [frozenset.difference(self.ground, base) for base in self.bases] + return CCMatroid.from_bases(ground=self.ground, bases=new_bases) + + def deletion(self, T: Collection) -> "CCMatroid": + """Returns the deletion matroid of T + The deletion of a matroid M on T is computed by removing T from all of its independent sets. + + Parameters + ---------- + T : Collection + A collection of elements to be removed based on the current matroid's ground set. + + Returns + ------- + CCMatroid + The deletion of the associated matroid + """ + T = frozenset(T) + new_bases = [base - T for base in self.bases] + return CCMatroid.from_bases(ground=self.ground, bases=new_bases) + + def contraction(self, T: Collection) -> "CCMatroid": + """Returns the contraction matroid of T + The contraction of a matroid M on T is computed by removing T from all of its dual's independent sets. + The explanation above is more apt explained akin to contraction of graphs, and + thus we use an equivalence based on the dual matroid to compute easily. + + Parameters + ---------- + T : Collection + A collection of elements to be removed based on the current matroid's ground set. + + Returns + ------- + CCMatroid + The contraction of the associated matroid + """ + T = frozenset(T) + return CCMatroid.dual().deletion(T).dual() + + +class CCGraphicMatroid(CCMatroid): + """Class for Graphic Matroids. + + A graphic matroid uses an underlying graph (edges) as the ground set of a matroid. + Its bases are the spanning trees of the graph, which means the forests of a graph are the independent sets. + + Parameters + ---------- + edgelist : Collection + A collection of graph edges that the matroid is based on. Internally, it uses `nx.Graph` to compute the spanning trees. + """ + + def __init__(self, edgelist: Collection, **kwargs): + data = get_spanning_trees(edgelist) + ground_edges, spanning_trees = data["ground_edges"], data["spanning_trees"] + independent_sets = frozenset( + [frozenset(ind) for base in spanning_trees for ind in powerset(base)] + ) + CCMatroid.__init__(self, ground=ground_edges, independent_sets=independent_sets) + + def graph(self) -> nx.Graph: + """Create the graph from the 0th skeleton. Use some kind of contraction mapping.""" + raise NotImplementedError diff --git a/modules/models/combinatorial/hmc.py b/modules/models/combinatorial/hmc.py index fd1b52d2..ab43a7ba 100644 --- a/modules/models/combinatorial/hmc.py +++ b/modules/models/combinatorial/hmc.py @@ -5,6 +5,7 @@ class HMCModel(torch.nn.Module): r"""HMC model that runs over combinatorial Complexes (CCC) + Parameters ---------- model_config : Dict | DictConfig @@ -19,6 +20,7 @@ def __init__(self, model_config, dataset_config): if isinstance(dataset_config["num_features"], int) else dataset_config["num_features"][0] ) + negative_slope = model_config["negative_slope"] hidden_channels = model_config["hidden_channels"] out_channels = dataset_config["num_classes"] @@ -60,7 +62,7 @@ def forward(self, data): Returns ------- - torch.Tensor + tuple of torch.Tensor Output tensor. """ x_0 = data.x_0 @@ -82,7 +84,6 @@ def forward(self, data): inc_1, inc_2, ) - x_0 = self.linear_0(x_0) x_1 = self.linear_1(x_1) x_2 = self.linear_2(x_2) diff --git a/modules/transforms/data_transform.py b/modules/transforms/data_transform.py index a7c21f33..22e4613c 100755 --- a/modules/transforms/data_transform.py +++ b/modules/transforms/data_transform.py @@ -8,6 +8,8 @@ OneHotDegreeFeatures, ) from modules.transforms.feature_liftings.feature_liftings import ProjectionSum +from modules.transforms.liftings.graph2cell.cycle_lifting import CellCycleLifting +from modules.transforms.liftings.graph2combinatorial.curve_lifting import CurveLifting from modules.transforms.liftings.graph2cell.cycle_lifting import ( CellCycleLifting, ) @@ -58,12 +60,13 @@ "SimplicialVietorisRipsLifting": SimplicialVietorisRipsLifting, # Graph -> Cell Complex "CellCycleLifting": CellCycleLifting, + # Graph -> Combinatorial Complex + "CombinatorialRingCloseAtomsLifting": CombinatorialRingCloseAtomsLifting, + "CurveLifting": CurveLifting, # Point Cloud -> Simplicial Complex, "AlphaComplexLifting": AlphaComplexLifting, # Point-cloud -> Simplicial Complex "DelaunayLifting": DelaunayLifting, - # Graph -> Combinatorial Complex - "CombinatorialRingCloseAtomsLifting": CombinatorialRingCloseAtomsLifting, # Feature Liftings "ProjectionSum": ProjectionSum, # Data Manipulations diff --git a/modules/transforms/liftings/graph2combinatorial/base.py b/modules/transforms/liftings/graph2combinatorial/base.py index db005333..d61d294a 100755 --- a/modules/transforms/liftings/graph2combinatorial/base.py +++ b/modules/transforms/liftings/graph2combinatorial/base.py @@ -1,4 +1,165 @@ -from modules.transforms.liftings.lifting import GraphLifting +from collections.abc import Iterable + +import networkx as nx +import torch +import torch_geometric +from toponetx.classes import CombinatorialComplex + +from modules.data.utils.utils import get_ccc_connectivity +from modules.matroid.matroid import CCGraphicMatroid, CCMatroid +from modules.transforms.liftings.lifting import AbstractLifting, GraphLifting + + +class Graph2MatroidLifting(GraphLifting): + r"""Abstract class for lifting graphs to matroids. + Matroids are a special type of combinatorial complexes. + + Parameters + ---------- + **kwargs : optional + Additional arguments for the class. + """ + + def __init__(self, **kwargs): + super().__init__(**kwargs) + self.type = "graph2matroid" + + def _generate_matroid_from_data( + self, data: torch_geometric.data.Data + ) -> CCGraphicMatroid: + r"""Generates a graphic matroid from the input data object. + + Parameters + ---------- + data : torch_geometric.data.Data + The input data. + + Returns + ------- + GraphicMatroid + The generated graphic matroid M(G). + """ + num_nodes = data.x.shape[0] + nodes = list(range(num_nodes)) + edges = data.edge_index.t().tolist() + G = nx.Graph() + G.add_nodes_from(nodes) + G.add_edges_from(edges) + G.to_undirected() + + return CCGraphicMatroid(edgelist=G.edges()) + + def get_edges_incident( + self, vertex: int | Iterable[int], data: torch_geometric.data.Data + ) -> torch.Tensor: + r"""Computes the edges incident by looking at data.edge_index + + Parameters + ---------- + vertex : Iterable[Int] + The input vertices to calculate the edges + data : torch_geometric.data.Data + The input data. + + Returns + ------- + torch.tensor + The part of the edge_index that contains the vertex in question. + """ + if not vertex and isinstance(vertex, Iterable): + return torch.empty(0) + row, col = data.edge_index + vertices = ( + torch.tensor(vertex) + if isinstance(vertex, Iterable) + else torch.tensor(vertex).unsqueeze(0) + ) + + mask = ( + sum(row == vertex for vertex in vertices) + .bool() + .logical_or(sum(col == vertex for vertex in vertices)) + ) + return data.edge_index[:, mask] + + +class Matroid2CombinatorialLifting(AbstractLifting): + r"""Abstract class for lifting matroids to combinatorial complexes. + + This handles any pecularities for converting a matroid to the more general CC. + This class is then redundant, but it is included for completeness. + + Parameters + ---------- + max_rank : int, optional + The maximum length of the complex to be lifted. Default is None. + **kwargs : optional + Additional arguments for the class. + """ + + def __init__(self, max_rank: int | None = None, **kwargs): + super().__init__(**kwargs) + self.type = "matroid2combinatorial" + self.max_rank = max_rank + + def matroid2cc(self, matroid: CCMatroid) -> CombinatorialComplex: + """Turns a matroid to the more general combinatorial complex + This method may be a little bit repetitive. + + Parameters + ---------- + matroid + Some `CCMatroid` + + Returns + ------- + CombinatorialComplex + The combinatorial complex of `matroid`. + """ + cc = CombinatorialComplex() + rank = matroid.cells.get_rank + for ind in matroid.cells: + if len(ind) == 0: + continue + ind_rank = rank(ind) + # this condition forms a truncated matroid. + if not self.max_rank or ind_rank <= self.max_rank: + cc.add_cell([i for i in ind], ind_rank) + return cc + + def _get_cell_attributes( + self, cc: CombinatorialComplex, name: str, rank=None + ) -> dict: + """This is a copycat of get_cell_attributes. Unknown if this is actually needed, + it's just that I get errors when calling the vanilla method.""" + attributes = cc.get_cell_attributes(name) + if rank is None: + return attributes + + return {ranked: attributes[ranked] for ranked in cc.skeleton(rank)} + + def lift_topology(self, data: torch_geometric.data.Data) -> dict: + """The topological lifting to the graphic curve matroid.""" + ground = data["ground"] + bases = data["bases"] + M = CCMatroid.from_bases(ground=ground, bases=bases) + matroid_rank = M.max_rank + if self.max_rank: + matroid_rank = min(matroid_rank, self.max_rank) + cc = self.matroid2cc(M) + + features = data["x"] + rank_0_features = { + node: features[list(node)].squeeze(0) for node in cc.skeleton(0) + } + cc.set_cell_attributes(rank_0_features, "features") + + connectivity = get_ccc_connectivity(cc, matroid_rank) + # cc.get_cell_attributes("features", 0).values() doesn't seem to work? The alternative: + connectivity["x_0"] = torch.stack( + list(self._get_cell_attributes(cc, "features", 0).values()) + ) + return connectivity class Graph2CombinatorialLifting(GraphLifting): @@ -6,10 +167,32 @@ class Graph2CombinatorialLifting(GraphLifting): Parameters ---------- + *liftings : optional + the topological liftings needed to go from a graph to a combinatorial complex **kwargs : optional Additional arguments for the class. """ - def __init__(self, **kwargs): + def __init__(self, *liftings, **kwargs): super().__init__(**kwargs) self.type = "graph2combinatorial" + self.liftings: Iterable[AbstractLifting] = liftings + + def lift_topology(self, data: torch_geometric.data.Data) -> dict: + r"""Lifts the topology of a graph to a combinatorial complex. This is modified so that we can define multiple liftings. + + Parameters + ---------- + data : torch_geometric.data.Data + The input data to be lifted. + + Returns + ------- + dict + The lifted topology. + """ + if not self.liftings: + raise NotImplementedError + for lifting in self.liftings: + data = lifting.lift_topology(data) + return data diff --git a/modules/transforms/liftings/graph2combinatorial/curve_lifting.py b/modules/transforms/liftings/graph2combinatorial/curve_lifting.py new file mode 100644 index 00000000..6c328e37 --- /dev/null +++ b/modules/transforms/liftings/graph2combinatorial/curve_lifting.py @@ -0,0 +1,141 @@ +from collections.abc import Collection + +import torch_geometric +import torch_geometric.data + +from modules.matroid.matroid import CCMatroid, powerset +from modules.transforms.liftings.graph2combinatorial.base import ( + Graph2CombinatorialLifting, + Graph2MatroidLifting, + Matroid2CombinatorialLifting, +) + + +class GraphCurveMatroidLifting(Graph2MatroidLifting): + r"""Lifts graphs to graph curve matroids by identifying cycles or certain acycles as n-cells. + + Parameters + ---------- + max_rank : int, optional + The maximum length of the complex to be lifted. Default is None. + **kwargs : optional + Additional arguments for the class. + """ + + def __init__(self, max_rank: int | None = None, **kwargs): + super().__init__(**kwargs) + self.max_rank = max_rank + + def edges_incident( + self, v: Collection | int, data: torch_geometric.data.Data + ) -> list[frozenset]: + """Returns edges incident to v based on (graph) data + + Parameters + ---------- + v: Collection | int + vertex or list of vertices to find incidence + data : torch_geometric.data.Data + pytorch geometric data that contains data of a graph. + + Returns + ------- + list[frozenset] + The list of undirected edges incident to v. + """ + return [ + frozenset(edge) + for edge in self.get_edges_incident(vertex=v, data=data).t().tolist() + ] + + def rank_check( + self, dual: CCMatroid, V: Collection, data: torch_geometric.data.Data + ) -> set[frozenset]: + """Part of the Algorithm proposed by Geiger et. al + We compute the graph curve matroid by computing its circuits. + This function serves as a preprocessing for calculating the circuits. + Taken from https://mathrepo.mis.mpg.de/_downloads/30a7910c728d51fc01271eb30e46a42a/graphCurveMatroid.m2 + + Parameters + ---------- + dual: CCMatroid + the dual matroid of a given graphic matroid connected to data. + V: Collection | int + vertex or set of vertices to find incidence + data : torch_geometric.data.Data + pytorch geometric data that contains data of a graph. + + Returns + ------- + set[frozenset] + The associated set of C of vertices that follow rank(dual(matroid(G)),incidentEdges(C,G)) <= |C| + """ + subsets = powerset(V) + check_1 = set() + for subset in subsets: + if len(subset) == 0: + continue + B = self.edges_incident(subset, data) + if dual.matroid_rank(B) <= len(subset): + check_1.add(frozenset(subset)) + return check_1 + + def _graph_curve_matroid(self, data: torch_geometric.data.Data) -> CCMatroid: + """Algorithm proposed by Geiger et. al + We compute the graph curve matroid by computing its circuits + + Parameters + ---------- + data : torch_geometric.data.Data + pytorch geometric data that contains data of a graph. + + Returns + ------- + CCMatroid + The associated graphic curve matroid of the graph in `data`. + """ + graphic_matroid = self._generate_matroid_from_data(data) + num_nodes = data.x.shape[0] + dual = graphic_matroid.dual() + + groundset = list(range(num_nodes)) + rank_check_set = self.rank_check(dual, groundset, data) + circuits = set() + for C in rank_check_set: + ok = True + for A in powerset(C): + A = frozenset(A) + if A != C and A in rank_check_set: + ok = False + break + if ok and len(C) != 0: + circuits.add(C) + + return CCMatroid.from_circuits(ground=groundset, circuits=circuits) + + def lift_topology(self, data: torch_geometric.data.Data) -> dict: + M_g = self._graph_curve_matroid(data) + data = data.clone() + data["ground"] = M_g.ground + if self.max_rank: + data["bases"] = M_g.skeleton(self.max_rank) + else: + data["bases"] = M_g.bases + return data + + +class CurveLifting(Graph2CombinatorialLifting): + r"""Implemented class for lifting graphs to combinatorial complexes via the graph curve matroid + + Parameters + ---------- + **kwargs : optional + Additional arguments for the class. + """ + + def __init__(self, **kwargs): + super().__init__( + GraphCurveMatroidLifting(**kwargs), + Matroid2CombinatorialLifting(**kwargs), + **kwargs, + ) diff --git a/modules/utils/utils.py b/modules/utils/utils.py index 83ac96e9..c0ea5bc2 100644 --- a/modules/utils/utils.py +++ b/modules/utils/utils.py @@ -1,6 +1,7 @@ import pprint import random import shutil +from collections.abc import Collection import matplotlib.pyplot as plt import networkx as nx @@ -15,6 +16,18 @@ rootutils.setup_root("./", indicator=".project-root", pythonpath=True) +def get_spanning_trees(edgelist: Collection): + graph = nx.Graph() + graph.add_edges_from(edgelist) + ground_edges = [frozenset(edge) for edge in graph.edges] + spanning_trees = [] + for tree in nx.SpanningTreeIterator(graph): + edges = tree.edges() + cvt_tree = [frozenset(edge) for edge in edges] + spanning_trees.append(frozenset(cvt_tree)) + return {"ground_edges": ground_edges, "spanning_trees": spanning_trees} + + def load_dataset_config(dataset_name: str) -> omegaconf.DictConfig: r"""Load the dataset configuration. diff --git a/test/transforms/liftings/graph2combinatorial/test_curve_lifting.py b/test/transforms/liftings/graph2combinatorial/test_curve_lifting.py new file mode 100644 index 00000000..a1c57673 --- /dev/null +++ b/test/transforms/liftings/graph2combinatorial/test_curve_lifting.py @@ -0,0 +1,209 @@ +"""Test the message passing module.""" + +from math import comb + +import torch +import torch_geometric +import torch_geometric.data + +from modules.data.utils.utils import ( + load_double_house_graph, + load_k4_graph, + load_manual_graph, +) +from modules.matroid.matroid import CCMatroid, powerset +from modules.transforms.liftings.graph2combinatorial.base import ( + Matroid2CombinatorialLifting, +) +from modules.transforms.liftings.graph2combinatorial.curve_lifting import ( + GraphCurveMatroidLifting, +) + + +class TestGraphCurveLifting: + """Test the CurveLifting class. + + It consists of 2 components: GraphCurveMatroidLifting & Matroid2CombinatorialLifting + """ + + def setup_method(self): + # Load the graph + self.data1 = load_manual_graph() + + self.graph_curve_lifting = GraphCurveMatroidLifting() + self.matroid_lifting = Matroid2CombinatorialLifting() + + # Matroid Construction Test 1: + def test_uniform_matroid_construction(self): + """In this test, we test different ways of constructing matroids.""" + n = 11 + k = 4 + ground = frozenset(range(n)) + bases = frozenset([frozenset(s) for s in powerset(ground) if len(s) == k]) + + bases_U_kn = CCMatroid.from_bases(ground=ground, bases=bases) + for base in bases_U_kn.skeleton(k - 1): + assert ( + len(base) == k + ), f"Matroid construction of U^{n}_{k} gone wrong for {base}" + + circuits = frozenset( + [frozenset(s) for s in powerset(ground) if len(s) == k + 1] + ) + circuits_U_kn = CCMatroid.from_circuits(ground=ground, circuits=circuits) + assert ( + circuits_U_kn.bases == bases_U_kn.bases + ), "Uniform matroid constructed from bases and circuits not equal" + + def rank(X): + nonlocal k + return min(len(X), k) + + rank_U_kn = CCMatroid.from_rank(ground, rank) + assert ( + circuits_U_kn.bases == rank_U_kn.bases + ), "Uniform matroid constructed from circuits and rank not equal" + + assert ( + rank_U_kn.ground == ground + ), "Uniform matroid ground set is constructed incorrectly." + + # Test 1: check for k4 matroid correctness + def test_k4(self): + """Test the graph curve matroid of the K_4 graph. + In Geiger et al., it turns out the graph curve matroid on $K_4$ is actually isomorphic to the uniform matroid on 4 elements into 2 subsets. + In order to prove correctness, we will show that the graph curve matroid of the K_4 graph is isomorphic to the U_2^4 matroid. + """ + k4 = load_k4_graph() + k4_curve = self.graph_curve_lifting.lift_topology(k4) + + k4_curve_matroid = CCMatroid.from_bases( + ground=k4_curve["ground"], bases=k4_curve["bases"] + ) + + uniform_ground = k4_curve_matroid.ground + uniform_bases = [s for s in powerset(uniform_ground) if len(s) == 2] + + u_24 = CCMatroid.from_bases(ground=uniform_ground, bases=uniform_bases) + assert ( + u_24.bases == k4_curve_matroid.bases + ), "Matroid creation is wrong, M_g(k4) is not isomorphic to U_2^4" + + # Test 2: check for double house matroid correctness + def test_double_house_graph(self): + """Test the graph curve matroid of the double house graph. + In Geiger et al., the double house graph is important for calculation reasons. + """ + double_house = load_double_house_graph() + curve = self.graph_curve_lifting.lift_topology(double_house) + double_house_matroid = CCMatroid.from_bases( + ground=curve["ground"], bases=curve["bases"] + ) + + A = frozenset({0, 1, 2}) + + assert ( + A not in double_house_matroid + ), f"Graph Curve Matroid creation is wrong, {A} is not in the circuits of the double house graph" + # [2, 3, 5, 6, 7] is a circuit + assert [1, 2, 4, 5] in double_house_matroid.cells, "[1, 2, 4, 5, 6] circuit check fail" + assert [1, 2, 4, 6] in double_house_matroid.cells, "[1, 2, 4, 5, 6] circuit check fail" + assert [1, 2, 5, 6] in double_house_matroid.cells, "[1, 2, 4, 5, 6] circuit check fail" + assert [1, 4, 5, 6] in double_house_matroid.cells, "[1, 2, 4, 5, 6] circuit check fail" + assert [2, 4, 5, 6] in double_house_matroid.cells, "[1, 2, 4, 5, 6] circuit check fail" + + # rank check + assert double_house_matroid.max_rank == 3 # this is 4 in matroid rank + + # bases check + assert len(double_house_matroid.bases) == 54 + + # Test 3: Test the matroid to combinatorial complex + def test_lift_matroid2cc_topology(self): + """We inspect the combinatorial complex of the uniform matroid. + It's easy to count the level set of the uniform matroid, so we do some tests to do that. + """ + n = 6 + k = 4 + + uniform_ground = [i for i in range(n)] + uniform_bases = [s for s in powerset(uniform_ground) if len(s) == k] + + u_kn = CCMatroid.from_bases(ground=uniform_ground, bases=uniform_bases) + + cc = self.matroid_lifting.matroid2cc(u_kn) + assert len(cc.skeleton(1 - 1)) == comb( + n, 1 + ), f"Matroid 2 combinatorial complex was generated incorrectly for rank={1 - 1}" + assert len(cc.skeleton(2 - 1)) == comb( + n, 2 + ), f"Matroid 2 combinatorial complex was generated incorrectly for rank={2 - 1}" + assert len(cc.skeleton(3 - 1)) == comb( + n, 3 + ), f"Matroid 2 combinatorial complex was generated incorrectly for rank={3 - 1}" + assert len(cc.skeleton(4 - 1)) == comb( + n, 4 + ), f"Matroid 2 combinatorial complex was generated incorrectly for rank={4 - 1}" + + # Test 4 + def test_lift_topology(self): + """Test the actual incidence matrix of the matroid lift""" + n = 6 + k = 4 + + uniform_ground = [i for i in range(n)] + uniform_bases = [s for s in powerset(uniform_ground) if len(s) == k] + + features = torch.ones((n, 1)) + data = torch_geometric.data.Data( + x=features, ground=uniform_ground, bases=uniform_bases + ) + + lifted_data = self.matroid_lifting.forward(data) + expected_incidence_1 = torch.tensor( + [ + [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0], + [0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0], + [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0], + [1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0], + ] + ) + + assert ( + expected_incidence_1 == lifted_data["incidence_1"].to_dense() + ).all(), "Something is wrong with incidence_1." + + # Test 5 + def test_lift_topology_rank(self): + """Test the actual incidence matrix of the matroid lift wrt to truncation""" + n = 6 + k = 4 + + matroid_lifting_k1 = Matroid2CombinatorialLifting(max_rank=k - 2) + assert k - 2 > 0 + uniform_ground = [i for i in range(n)] + uniform_bases = [s for s in powerset(uniform_ground) if len(s) == k] + + features = torch.ones((n, 1)) + data = torch_geometric.data.Data( + x=features, ground=uniform_ground, bases=uniform_bases + ) + + lifted_data = matroid_lifting_k1.forward(data) + expected_incidence_1 = torch.tensor( + [ + [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0], + [0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0], + [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0], + [1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0], + ] + ) + + + assert ( + expected_incidence_1 == lifted_data["incidence_1"].to_dense() + ).all(), "Something is wrong with incidence_1. The lift under a truncated matroid is not the same." diff --git a/tutorials/graph2combinatorial/curve_lifting.ipynb b/tutorials/graph2combinatorial/curve_lifting.ipynb new file mode 100644 index 00000000..da673b28 --- /dev/null +++ b/tutorials/graph2combinatorial/curve_lifting.ipynb @@ -0,0 +1,1473 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Graph-to-Combinatorial GraphCurve Lifting Tutorial" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "This notebook shows how to import a dataset, with the desired lifting, and how to run a neural network using the loaded data.\n", + "\n", + "The notebook is divided into sections:\n", + "\n", + "- [Loading the dataset](#loading-the-dataset) loads the config files for the data and the desired tranformation, createsa a dataset object and visualizes it.\n", + "- [Loading and applying the lifting](#loading-and-applying-the-lifting) defines a simple neural network to test that the lifting creates the expected incidence matrices.\n", + "- [Create and run a simplicial nn model](#create-and-run-a-simplicial-nn-model) simply runs a forward pass of the model to check that everything is working as expected.\n", + "\n", + "***\n", + "***\n", + "\n", + "Note that for simplicity the notebook is setup to use a simple graph. However, there is a set of available datasets that you can play with.\n", + "\n", + "To switch to one of the available datasets, simply change the *dataset_name* variable in [Dataset config](#dataset-config) to one of the following names:\n", + "\n", + "* cocitation_cora\n", + "* cocitation_citeseer\n", + "* cocitation_pubmed\n", + "* MUTAG\n", + "* NCI1\n", + "* NCI109\n", + "* PROTEINS_TU\n", + "* AQSOL\n", + "* ZINC\n", + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imports and utilities" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/gescalona/miniforge3/envs/topox/lib/python3.11/site-packages/threadpoolctl.py:1214: RuntimeWarning: \n", + "Found Intel OpenMP ('libiomp') and LLVM OpenMP ('libomp') loaded at\n", + "the same time. Both libraries are known to be incompatible and this\n", + "can cause random crashes or deadlocks on Linux when loaded in the\n", + "same Python program.\n", + "Using threadpoolctl may cause crashes or deadlocks. For more\n", + "information and possible workarounds, please see\n", + " https://github.com/joblib/threadpoolctl/blob/master/multiple_openmp.md\n", + "\n", + " warnings.warn(msg, RuntimeWarning)\n" + ] + } + ], + "source": [ + "# With this cell any imported module is reloaded before each cell execution\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "from modules.data.load.loaders import GraphLoader\n", + "from modules.data.preprocess.preprocessor import PreProcessor\n", + "from modules.utils.utils import (\n", + " describe_data,\n", + " load_dataset_config,\n", + " load_model_config,\n", + " load_transform_config,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Matroids\n", + "Matroids $\\mathcal{M} = (S, \\mathcal{I})$ defined on a ground set $S$ are simplicial complexes with a special exchange/augmenting property, that is:\n", + "$$\n", + "\\forall X, Y \\in \\mathcal{I}, |X| < |Y| \\rightarrow \\exists z \\in Y - X, X + z \\in \\mathcal{I} \n", + "$$\n", + "In particular, we say that $X$ is **independent** for $X \\in \\mathcal{I}$. The property suggests that there are maximal such sets $B$. We say that $B$ is **base** for $\\mathcal{M}$. We can construct all independent sets from $\\mathcal{B} = \\{B : B \\text{ is a base of } \\mathcal{M}\\}$.\n", + "\n", + "Tied to any matroid is a *submodular* $\\mathit{rank}_\\mathcal{M}$ function, where if $X \\in \\mathcal{I}$, $\\mathit{rank}(X) = |X|$. The fact that it is submodular is very important, but we leave this distrinction to another setting.\n", + "\n", + "In order to modify matroids to be a combinatorial complex, it is enough to:\n", + "- Remove $\\emptyset$ from $\\mathit{I}$\n", + "- Set $\\mathcal{rnk}(X) = \\mathcal{rank}_M(X) - 1$\n", + "\n", + "If $X \\not\\in \\mathcal{I}$, then $X$ is considered dependent. Similar to bases, dependent-wise minimal sets are called **circuits**. These are also another characterizations of matroids, where any proper subset of circuits are independent in $\\mathcal{M}$.\n", + "\n", + "These four equivalent characterizations of matroids: *independent* sets, bases, circuits, and rank function as well as a ground set $S$ are used to construct matroids throughout the codebase.\n", + "\n", + "For further discussion on the topic, Oxley's book is widely recommended." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Graphic Curve Lifting Explanation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to make a Graph Curve Matroid, we need the following (from some graph $G = (V, E)$):\n", + "- The graphic matroid of the graph $G$: $M(G) = (E, \\mathcal{I})$\n", + "- Its dual $M^* = M^*(G) = (E, \\mathcal{I}^*)$, the bond matroid, and its rank function: $\\mathit{rank}^*: 2^E \\to \\mathbb{Z}_+$.\n", + "\n", + "\n", + "## Dual Matroid\n", + "A dual matroid of another matroid is where the bases of the dual matroid are the complements of the original matroid's bases. Formally, if $\\mathcal{M} = (S, \\mathcal{B})$, then let $\\mathcal{B}^* = \\{S - B : \\forall B \\in \\mathcal{B}\\}$, so that the dual of the matroid $\\mathcal{M}$ is defined as $\\mathcal{M}^* = (S, \\mathcal{B}^*)$\n", + "\n", + "## Graphic Matroid\n", + "A graphic matroid is a matroid where its bases are the edges that make the maximum spanning trees of the graph $G$. We denote $M(G) = (E, \\mathit{I})$, where $G = (V, E)$ and $I \\in \\mathcal{I}$ if $I$ is a forest/spanning tree of $G$.\n", + "\n", + "## Bond Matroid\n", + "A bond matroid is a matroid where its independent sets are the edges that when removed, retain the number of connected components of the graph. Formally, if $G = (V, E)$, then let $\\mathcal{M}^*(G) = (E, \\mathcal{I}^*)$. For $X \\subseteq E$, if $X \\in \\mathcal{I}^*$, then the graph induced by removing $X$ from $E$ of $G$ had no more or less connected components. The bases of $\\mathcal{M}^*(G)$ are maximal such sets, its circuits are the minimal sets that do increase the number of connected components. For $X \\subseteq E$, $\\mathit{rank}_{\\mathcal{M}^*(G)}(X)$ is the maximal number of edge deletions from $X$ that do not increase the number as well.\n", + "\n", + "One thing is important to note about this matroid: from graph theory, we know that unique duals of nonplanar graphs do not exist, meaning it is harder to analyze the graphs by their (nonunique) duals. However, for a graphic matroid, a unique dual **always** exists, which is a nice property. \n", + "\n", + "## Graphic Curve Matroid\n", + "The idea now is to use the bond matroids, but there is one problem: the ground set is based on edges, instead of vertices. We can always make a trivial reduction from edges to vertices by means of incidence, however, some natural reductions exist. One of these is called the **Graph Curve Matroids**, introduced recently by Alheydis Geiger, Kevin Kühn, and Raluca Vlad. These matroids are directly related to hyperplanes of graph curves, hence the name.\n", + "\n", + "(Proposition 2.3): Given $G = (V, E)$, and $M(G)$, its graphic matroid, we can construct the Graph Curve Matroid $M_g = (V, \\mathcal{I})$, where $A \\subseteq V$:\n", + "- is dependent in $M_g$ iff $\\exists$ nonempty $A' \\subseteq A, \\mathit{rank}_{\\mathcal{M}^*(G)}(A') \\leq |A'|$\n", + "- is independent in $M_g$ iff $\\forall$ nonempty $A' \\subseteq A, \\mathit{rank}_{\\mathcal{M}^*(G)}(A') > |A'|$\n", + "\n", + "where $\\delta(A)$ refers to the edges incident to the vertices in $A$. The above was shown in [1]. Admittedly, while well-defined, these definitions are not intuitve. We go into more detail for a double house graph that I added that is used in the paper as a prominent example.\n", + "\n", + "\n", + "[1] Geiger, Alheydis, Kevin Kuehn, and Raluca Vlad. \"Graph Curve Matroids.\" arXiv preprint arXiv:2311.08332 (2023). https://arxiv.org/abs/2311.08332.\n", + "\n", + "[2] H. Whitney, On the abstract properties of linear dependence, Amer. J. Math. 57(3) (1935) 509–533." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Transform configuration for graph2combinatorial/curve_lifting:\n", + "\n", + "{'transform_type': 'lifting',\n", + " 'transform_name': 'CurveLifting',\n", + " 'feature_lifting': 'ProjectionSum',\n", + " 'max_rank': 2}\n" + ] + } + ], + "source": [ + "# Define transformation type and id\n", + "transform_type = \"liftings\"\n", + "# If the transform is a topological lifting, it should include both the type of the lifting and the identifier\n", + "transform_id = \"graph2combinatorial/curve_lifting\"\n", + "\n", + "# Read yaml file\n", + "transform_config = {\n", + " \"lifting\": load_transform_config(transform_type, transform_id)\n", + " # other transforms (e.g. data manipulations, feature liftings) can be added here\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading the Dataset: Manual" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Dataset configuration for manual_dataset:\n", + "\n", + "{'data_domain': 'graph',\n", + " 'data_type': 'toy_dataset',\n", + " 'data_name': 'manual',\n", + " 'data_dir': 'datasets/graph/toy_dataset',\n", + " 'num_features': 1,\n", + " 'num_classes': 2,\n", + " 'task': 'classification',\n", + " 'loss_type': 'cross_entropy',\n", + " 'monitor_metric': 'accuracy',\n", + " 'task_level': 'node'}\n" + ] + } + ], + "source": [ + "dataset_name = \"manual_dataset\"\n", + "dataset_config = load_dataset_config(dataset_name)\n", + "loader = GraphLoader(dataset_config)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Dataset contains 2 samples.\n", + "\n", + "Providing more details about sample 0/2:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Graph with 8 vertices and 13 edges.\n", + " - Features dimensions: [1, 0]\n", + " - There are 0 isolated nodes.\n", + "\n" + ] + } + ], + "source": [ + "dataset = loader.load()\n", + "describe_data(dataset, 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Dataset contains 2 samples.\n", + "\n", + "Providing more details about sample 1/2:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Graph with 8 vertices and 12 edges.\n", + " - Features dimensions: [1, 0]\n", + " - There are 0 isolated nodes.\n", + "\n" + ] + } + ], + "source": [ + "describe_data(dataset, 1) # this is the double house graph" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We than apply the transform via our `PreProcesor`:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Transform parameters are the same, using existing data_dir: /Users/gescalona/Desktop/challenge-icml-2024/datasets/graph/toy_dataset/manual/lifting/4211167841\n", + "\n", + "Dataset contains 2 samples.\n", + "\n", + "Providing more details about sample 0/2:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - The complex has 6 0-cells.\n", + " - The 0-cells have features dimension 1\n", + " - The complex has 15 1-cells.\n", + " - The 1-cells have features dimension 1\n", + " - The complex has 20 2-cells.\n", + " - The 2-cells have features dimension 1\n", + "\n" + ] + } + ], + "source": [ + "lifted_dataset = PreProcessor(dataset, transform_config, loader.data_dir)\n", + "describe_data(lifted_dataset, 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Dataset contains 2 samples.\n", + "\n", + "Providing more details about sample 1/2:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - The complex has 8 0-cells.\n", + " - The 0-cells have features dimension 1\n", + " - The complex has 28 1-cells.\n", + " - The 1-cells have features dimension 1\n", + " - The complex has 54 2-cells.\n", + " - The 2-cells have features dimension 1\n", + "\n" + ] + } + ], + "source": [ + "describe_data(lifted_dataset, 1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, I would like to note that the `describe_data` method may have weird visualization issues. It may be better to view the actual bases/circuits on their own (scroll all the way at bottom).\n", + "\n", + "Graphs that are not trivalent ($\\forall v \\in V, \\mathit{deg}(v) >= 3$) are not that interesting, and the [1] focuses on these types of graphs. In fact, with that assumption, we can revise proposition 2.3 with the following:\n", + "Let $G = (V, E)$. First, let $\\omega(A) = $ the number of connected components of the subgraph induced by $G$ on $A$, where $A$ is a vertex-set.\n", + "\n", + "(Proposition 3.1): Let $A \\subseteq V$. $A$ is a circuit of $M_g$ iff:\n", + "- $A$ is a cycle.\n", + "- $A$ is acyclic and $\\omega(V - A) = \\omega(A) + 1$.\n", + "\n", + "(Proposition 3.3): If $A$ is acyclic, then $A$:\n", + "- is dependent in $M_g$ iff $\\exists$ nonempty $A' \\subseteq A$, $\\omega(A') < \\omega(V - A')$\n", + "- is independent in $M_g$ iff $\\forall$ nonempty $A' \\subseteq A$, $\\omega(A') \\geq \\omega(V - A')$\n", + "\n", + "The above propositions are a lot more descriptive vs proposition 2.3.\n", + "\n", + "Example 2.4: $A = \\{0,1,2 \\}$ is a dependent set/circuit because it is a cycle in $G$. \n", + "\n", + "Example 3.4: Let $A = \\{1, 2, 4, 5, 6\\}$. $A$ is a circuit because $\\omega(V - A) = \\omega(A) + 1$\n", + "\n", + "Example A: Let $A = \\{0, 1, 7\\}$. $A$ is a 2-cell (matroid rank 3), and it is independent. Try removing any of its subsets and see if the resulting graph is disconnected. We can also see that it's an acycle. This corresponds to a hyperedge on the combinatorial complex.\n", + "\n", + "(Lemma 4.4): If $B \\in \\mathcal{B}_{\\mathcal{M}_g}$, then equality of propsition 3.3 is achieved, ie $\\omega(B) = \\omega(V - B)$\n", + "\n", + "Example B: Let $A = \\{1, 2, 6, 7\\}$. By computation, this is a basis (see below). $A$ is a basis because we can separate the graphs to 2 connected components, where $A$ is one and $V - A$ is another.\n", + "\n", + "I will say this again, but since the `max_rank` is set to $2$ in order to be compliant with the HMC model, higher order information does not exist, such as esp Example 3.4 and Example B. See the Extra section where I lift this restriction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One limitation is that the graphic curve matroid is hard to compute, it requires checking every subset of a possible candidate set to make the graphic curve matroid. Not to mention that creating the graphic and cographic matroids are also expensive as well. At the moment, this is a *deterministic* lifting that calculates every spanning tree, however, an *indeterministic* lifting exists by sampling bases of a matroid." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create and Run a Combinatorial NN Model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this section a simple model is created to test that the used lifting works as intended. In this case the model uses the `adjacency_0`, `adjacency_1`, `adjacency_2`, `incidence_1`, `incidence_2` so the lifting should make sure to add them to the data.\n", + "\n", + "At the moment, the `max_rank` config option shrinks any matroid down to a basis of 3 elements in order to ensure that the Preprocessor runs correctly, but this actually a genuine limitation, since the full basis of a matroid describes a lot of information." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Model configuration for combinatorial HMC:\n", + "\n", + "{'in_channels': None,\n", + " 'hidden_channels': 32,\n", + " 'out_channels': None,\n", + " 'n_layers': 2,\n", + " 'negative_slope': 0.2}\n" + ] + } + ], + "source": [ + "from modules.models.combinatorial.hmc import HMCModel\n", + "\n", + "model_type = \"combinatorial\"\n", + "model_id = \"hmc\"\n", + "model_config = load_model_config(model_type, model_id)\n", + "\n", + "model = HMCModel(model_config, dataset_config)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/gescalona/miniforge3/envs/topox/lib/python3.11/site-packages/topomodelx/nn/combinatorial/hmc_layer.py:680: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/SparseCsrTensorImpl.cpp:56.)\n", + " A_p = torch.sparse.mm(A_p, neighborhood)\n" + ] + } + ], + "source": [ + "y_hat = model(lifted_dataset.get(0))\n", + "y_hat = model(lifted_dataset.get(1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If everything is correct the cell above should execute without errors. \n", + "\n", + "I think one thing to point out is that the incidence matrix can better be defined with using the exchange/augmentation property. This means that we can have more descriptive incidence matrices.\n", + "\n", + "If $X, Y \\in \\mathcal{I}, |X| + 1 = |Y|$, let $Z_{X, Y} = \\{z : \\forall z \\in Y - X, X + z \\in \\mathcal{I}\\}$. The incidence matrix would normally be defined as a, $f(X, Y) = \\delta(X, Y)$, but consider instead $f(X, Y) = g(Z_{X, Y})$, for some $g: Z_{X, Y} \\to \\mathbb{R}$?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Extra" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "from modules.data.utils.utils import load_double_house_graph, load_manual_graph\n", + "from modules.transforms.liftings.graph2combinatorial.curve_lifting import (\n", + " GraphCurveMatroidLifting,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "y = GraphCurveMatroidLifting()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "G = load_manual_graph()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "manual_curve_matroid = y._graph_curve_matroid(G)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[frozenset({0, 1, 7}),\n", + " frozenset({0, 2, 5}),\n", + " frozenset({0, 2, 4}),\n", + " frozenset({0, 5, 7}),\n", + " frozenset({1, 5, 7}),\n", + " frozenset({0, 4, 7}),\n", + " frozenset({1, 4, 7}),\n", + " frozenset({1, 2, 7}),\n", + " frozenset({0, 4, 5}),\n", + " frozenset({0, 2, 7}),\n", + " frozenset({0, 1, 2}),\n", + " frozenset({1, 2, 5}),\n", + " frozenset({1, 4, 5}),\n", + " frozenset({2, 4, 7}),\n", + " frozenset({4, 5, 7}),\n", + " frozenset({0, 1, 4}),\n", + " frozenset({2, 5, 7}),\n", + " frozenset({1, 2, 4}),\n", + " frozenset({2, 4, 5}),\n", + " frozenset({0, 1, 5})]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# these are the 3-basis of the graph curve matroid on the manual graph\n", + "manual_curve_matroid.skeleton(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[frozenset({1, 2, 4, 5, 7}),\n", + " frozenset({0, 2, 4, 5, 7}),\n", + " frozenset({0, 1, 2, 4, 5}),\n", + " frozenset({0, 1, 4, 5, 7}),\n", + " frozenset({0, 1, 2, 5, 7}),\n", + " frozenset({0, 1, 2, 4, 7})]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# these are the basis of the graph curve matroid on the manual graph\n", + "manual_curve_matroid.skeleton(4)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "house_curve_matroid = y._graph_curve_matroid(load_double_house_graph())" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[frozenset({0, 1, 7}),\n", + " frozenset({0, 2, 4}),\n", + " frozenset({0, 4, 6}),\n", + " frozenset({1, 3, 7}),\n", + " frozenset({3, 4, 5}),\n", + " frozenset({2, 6, 7}),\n", + " frozenset({0, 1, 3}),\n", + " frozenset({4, 6, 7}),\n", + " frozenset({1, 3, 6}),\n", + " frozenset({0, 6, 7}),\n", + " frozenset({2, 3, 4}),\n", + " frozenset({1, 5, 7}),\n", + " frozenset({0, 3, 5}),\n", + " frozenset({1, 4, 6}),\n", + " frozenset({0, 2, 3}),\n", + " frozenset({1, 2, 7}),\n", + " frozenset({2, 3, 5}),\n", + " frozenset({1, 2, 6}),\n", + " frozenset({0, 3, 4}),\n", + " frozenset({1, 4, 5}),\n", + " frozenset({2, 5, 7}),\n", + " frozenset({2, 4, 5}),\n", + " frozenset({0, 5, 7}),\n", + " frozenset({1, 3, 5}),\n", + " frozenset({0, 2, 5}),\n", + " frozenset({2, 4, 6}),\n", + " frozenset({1, 4, 7}),\n", + " frozenset({0, 4, 5}),\n", + " frozenset({0, 3, 6}),\n", + " frozenset({1, 6, 7}),\n", + " frozenset({3, 4, 6}),\n", + " frozenset({1, 3, 4}),\n", + " frozenset({2, 3, 7}),\n", + " frozenset({2, 3, 6}),\n", + " frozenset({1, 2, 5}),\n", + " frozenset({0, 1, 6}),\n", + " frozenset({3, 6, 7}),\n", + " frozenset({4, 5, 7}),\n", + " frozenset({0, 1, 4}),\n", + " frozenset({0, 3, 7}),\n", + " frozenset({3, 5, 6}),\n", + " frozenset({0, 5, 6}),\n", + " frozenset({4, 5, 6}),\n", + " frozenset({0, 4, 7}),\n", + " frozenset({0, 2, 6}),\n", + " frozenset({2, 5, 6}),\n", + " frozenset({1, 2, 3}),\n", + " frozenset({0, 2, 7}),\n", + " frozenset({3, 4, 7}),\n", + " frozenset({2, 4, 7}),\n", + " frozenset({1, 2, 4}),\n", + " frozenset({3, 5, 7}),\n", + " frozenset({0, 1, 5}),\n", + " frozenset({1, 5, 6})]" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# these are the 3-basis of the graph curve matroid on the double house graph\n", + "house_curve_matroid.skeleton(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[frozenset({2, 3, 5, 6}),\n", + " frozenset({0, 3, 4, 6}),\n", + " frozenset({0, 3, 4, 7}),\n", + " frozenset({0, 2, 5, 6}),\n", + " frozenset({2, 4, 5, 6}),\n", + " frozenset({0, 2, 4, 7}),\n", + " frozenset({1, 2, 4, 5}),\n", + " frozenset({0, 1, 3, 5}),\n", + " frozenset({2, 3, 4, 7}),\n", + " frozenset({0, 2, 5, 7}),\n", + " frozenset({1, 2, 3, 5}),\n", + " frozenset({1, 4, 6, 7}),\n", + " frozenset({0, 4, 5, 7}),\n", + " frozenset({1, 2, 4, 7}),\n", + " frozenset({0, 2, 3, 6}),\n", + " frozenset({1, 2, 6, 7}),\n", + " frozenset({2, 3, 4, 6}),\n", + " frozenset({0, 3, 5, 6}),\n", + " frozenset({1, 4, 5, 7}),\n", + " frozenset({0, 1, 6, 7}),\n", + " frozenset({0, 3, 5, 7}),\n", + " frozenset({2, 4, 5, 7}),\n", + " frozenset({2, 3, 4, 5}),\n", + " frozenset({0, 1, 3, 6}),\n", + " frozenset({1, 3, 4, 5}),\n", + " frozenset({2, 4, 6, 7}),\n", + " frozenset({1, 2, 3, 6}),\n", + " frozenset({0, 2, 6, 7}),\n", + " frozenset({1, 3, 6, 7}),\n", + " frozenset({0, 3, 4, 5}),\n", + " frozenset({1, 3, 4, 7}),\n", + " frozenset({1, 3, 4, 6}),\n", + " frozenset({1, 2, 5, 7}),\n", + " frozenset({0, 2, 3, 5}),\n", + " frozenset({1, 2, 4, 6}),\n", + " frozenset({0, 1, 4, 5}),\n", + " frozenset({0, 1, 5, 6}),\n", + " frozenset({0, 1, 5, 7}),\n", + " frozenset({0, 3, 6, 7}),\n", + " frozenset({2, 3, 5, 7}),\n", + " frozenset({1, 2, 5, 6}),\n", + " frozenset({0, 1, 4, 6}),\n", + " frozenset({0, 4, 6, 7}),\n", + " frozenset({1, 4, 5, 6}),\n", + " frozenset({0, 1, 4, 7}),\n", + " frozenset({0, 2, 4, 6}),\n", + " frozenset({1, 2, 3, 7}),\n", + " frozenset({1, 3, 5, 7}),\n", + " frozenset({0, 4, 5, 6}),\n", + " frozenset({0, 1, 3, 7}),\n", + " frozenset({1, 3, 5, 6}),\n", + " frozenset({0, 2, 4, 5}),\n", + " frozenset({0, 2, 3, 7}),\n", + " frozenset({2, 3, 6, 7})]" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# these are the basis of the graph curve matroid on the double house graph\n", + "house_curve_matroid.skeleton(3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is where we explore part of a dataset that [1] references.\n", + "\n", + "The first 5 graphs are trivalent graphs with 8 vertices, and the other 5 are trivalent graphs with 10 vertices" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Dataset configuration for graph_8:\n", + "\n", + "{'data_domain': 'graph',\n", + " 'data_type': 'trivalent',\n", + " 'data_name': 'graphs_8vertices',\n", + " 'data_dir': 'datasets/graph/trivalent',\n", + " 'num_features': 1,\n", + " 'num_classes': 2,\n", + " 'task': 'classification',\n", + " 'loss_type': 'cross_entropy',\n", + " 'monitor_metric': 'accuracy',\n", + " 'task_level': 'node'}\n" + ] + } + ], + "source": [ + "dataset_name = \"graph_8\"\n", + "dataset_config = load_dataset_config(dataset_name)\n", + "loader = GraphLoader(dataset_config)\n", + "dataset = loader.load()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Transform parameters are the same, using existing data_dir: /Users/gescalona/Desktop/challenge-icml-2024/datasets/graph/trivalent/graphs_8vertices/lifting/4211167841\n" + ] + } + ], + "source": [ + "lifted_dataset = PreProcessor(dataset, transform_config, loader.data_dir)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These are the 8-vertex Graphs." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Dataset contains 5 samples.\n", + "\n", + "Providing more details about sample 0/5:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Graph with 8 vertices and 12 edges.\n", + " - Features dimensions: [1, 0]\n", + " - There are 0 isolated nodes.\n", + "\n", + "\n", + "Dataset contains 5 samples.\n", + "\n", + "Providing more details about sample 0/5:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - The complex has 8 0-cells.\n", + " - The 0-cells have features dimension 1\n", + " - The complex has 28 1-cells.\n", + " - The 1-cells have features dimension 1\n", + " - The complex has 48 2-cells.\n", + " - The 2-cells have features dimension 1\n", + "\n", + "\n", + "Dataset contains 5 samples.\n", + "\n", + "Providing more details about sample 1/5:\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgcAAAIbCAYAAAB/tT3bAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAACU2UlEQVR4nOzdd3yTVfvH8c+d0b3ooDIEBAQRQQUXIiCjUIYoIpSl/FygLAURFJkPog+ooIAgiLsoZckoeygg4CMCWqAVRJbs0tKmK2nG/fsjtFJZbWl7p8n1fr18adMk9xWV5JtzrnOOoqqqihBCCCHEJTqtCxBCCCGEa5FwIIQQQogCJBwIIYQQogAJB0IIIYQoQMKBEEIIIQqQcCCEEEKIAiQcCCGEEKIACQdCCCGEKEDCgRAl7MiRI3Tr1o0KFSpQoUIFunXrxpEjRwr9+MaNG9O/f/9Su/+NREVFMXLkyELdt3///lSoUAFFUahVqxb9+/cv0mstrqioKKZMmVLq1xHCU0k4EKIEbdy4kcaNG3P//feze/dudu/eTc2aNWncuDEbN24s1HO8+eabdOvWrdDXLOr9S8KRI0eoVasWR44cYdGiRVy8eJE5c+aQmprK4sWLy7QWIUTJM2hdgBDuIi0tjaioKBYtWsRTTz2Vf/vkyZOpVasW3bp14+jRo4SEhFz3eS5/bGEU9f4loVu3btSsWZMNGzbk39amTRvatGlT5rUIIUqejBwIUUJGjhxJo0aNrvph3a9fP0JDQ3n33Xc1qKxkLV68mD179jBnzhytSxFClBIJB0KUkI0bN173m/NTTz1VYGqhW7duzJ07l7lz51KrVq383/17zj8tLS2/h6Fx48aMHDmSWrVq0bhx46vev1u3bkyZMiW/H+Dy5wbnh3vjxo3z+wSKOg0QFxdHo0aNqFmz5g3ve63XeKMa+vfvz8iRI/NfQ4UKFa64T0pKyjVfoxDi5kg4EKKEHDlyhPvvv/+av69VqxZ79uzJ/zktLY05c+YwefJkJk+efM1gMXLkSEJDQ7l48SL9+/dn8eLF/PXXX+zevfuq909LS2PkyJH50xiNGjUq0LCYmprKp59+iqqqzJkzh27duhWoqzCv87777ivUfa/1Gm9Uw5EjR5g7d27+a+jevfsVjZ1Tpky55msUQtwcCQdClKDU1NRr/i4tLe2K244cOcLu3buv2zewcOHC/A++fv36ceTIkRuuCGjUqBFt2rQhJCTkihUE/fr1o1GjRoCzT6BmzZpF+tadlpZ2w76Jy13tNRamhn79+uW/hjlz5lCzZs0CUxnXe41CiJsj4UCIElKzZk3++uuva/7+r7/+umIoPu/DrahCQ0Ov+/vLv9lf7b5538obN25c5A/VmjVrXjHS0K1bNxRFQVEUoqKiCvzuWq+xqDW0adOmwP1u9BqFEMUn4UCIEtKmTZvrzt8vXLjwiqmDwszbt2nTJr+RccqUKTRq1OiGgeJ6v2/cuDGLFi2if//+7N69O/8bfGFFRUWxcePGAiMhixYtQlVVRowYccX9r/Yab7YGuP5rFELcHAkHQpSQyZMnc+TIkatuzjNy5EjS0tKYPHlykZ8370O4Vq1abNiwgU2bNhW7xiNHjrBnzx42bNhQ7GWHI0aMoGbNmoXeKKmkati4ceN1ezqEECVHwoEQJSQkJIRFixYxcuRIRo4cmd8b0L9/f6ZMmcKGDRuK9W33yJEjxMTEsGHDBubMmXNT35jzht/nzp0L/LMssagWLVrEwoUL8xsJ09LS2LNnT6GmBwpbw9y5c/OfO68ZsV+/fkWuVQhRdBIOhChBTz31FH/99RdHjhyhcePGNG7cmNTUVP76669if1OvWbMm3bp1o1atWtSqVQtFUYq9I2JISAgjRozIXwKY9+29qIGjUaNGHD16lNDQUF588cX8baKBG44oFLaGvOmU2267Lb+pUaYShCgbiqqqqtZFCCGubvHixbz44osFdlbcs2cPrVu3ZvLkyW77TToqKopGjRoVaxpGCHHzZORACBe2a9euK75VN2rUiO7du19znwMhhLhZEg6EcGExMTFs3LiRxYsX5zcmLl68OH++XwghSoMcvCSEC2vUqBGLFi1i8uTJvPjii4CzB+HTTz+VQ46EEKVGeg6EEEIIUYBMKwghhBCiAAkHQgghhChAwoEQQgghCpBwIIQQQogCJBwIIYQQogAJB0IIIYQoQMKBEEIIIQqQcCCEEEKIAiQcCCGEEKIACQdCCCGEKEDCgRBCCCEKkHAghBBCiAIkHAghhBCiAAkHQgghhChAwoEQQgghCpBwIIQQQogCJBwIIYQQogAJB0IIIYQoQMKBEEIIIQqQcCCEEEKIAiQcCCGEEKIACQdCCCGEKEDCgRBCCCEKkHAghBBCiAIkHAghhBCiAAkHQgghhChAwoEQQgghCpBwIIQQQogCJBwIIYQQogAJB0IIIYQowKB1AUII4UrsqkqK2c75HBvJOXaybA7sqopeUfA36Ijw1VPR10CYjx69omhdrhClQsKBEEIAplw7B1ItJKSaybKqOFQVnaLgUNX8++T9rFMU/I0KDUN9qB/qTZCXXsPKhSh5iqpe9n++EEJ4GIvdwfYz2SSkWrCrKqhg0CnoAOUqIwOqquIAbA4VFNArCg1DvWlayQ9vvczUCvcg4UAI4bFOZFhZfzKT9Fw7OhQMytUDwbWoqopNBQcqIV56oqoGUC3QWIoVC1E2JBwIITxSQoqZTaeycKgqRkVBdxP9Aw5VxXppuqF1FX8ahvmUYKVClD0ZAxNCeJyEFDObTmbhcKh43WQwAGcvgpei4HCobDqZRUKKuYQqFUIbEg6EEB7lRIY1f8TAS6cUaRrhehRFwUvnbFjcdCqLExnWEnleIbQg4UAI4TEsdgfrT2aWeDDIc3lA2HAyE4vdUaLPL0RZkXAghPAY289kk55rx6iUfDDIoygKRkUhLdfO9jPZpXINIUqbhAMhhEcw5dpJSLWg4+Z7DG5EpyjoUEhItWDKtZfqtYQoDRIOhBAe4cClfQwMZbSpoUFx7rZ4INVSNhcUogRJOBBCuD27qpKQaga1aPsY3AxFUUCFhFSzc3MlIcoRCQdCCLeXYraTZVUx6Mr2LASDTiHL6jyrQYjyRMKBEMLtnc+xOc9EKMR9D+/eyf4t69gVvzD/tu8mDC3wc2HpcO6imJxjK/JjhdCShAMhhNtLzrGjK8QKhdTTf+MXGEzl2+9k64LP8m+vUvcuUk6fKPJ1lUvXPJ8jIweifJFwIIRwe1k2R4HTFa8l9cxJKte5k/1b11OrURMAHKqDOx9pQ1jlW4t1bYeqkm2T/Q5E+SJHNgsh3F5hGwJrN3YGgn0/rqH1s0NIN6WTk5NDemoK4bXr43A4SNy2AYCcjHQqVLo1/zHXY5OGRFHOyMiBEMLt6Qu5QsHusHPh/BlOHtxPSI06WK1WvLy8SD72J/5hFTmc+DsHf9nGXS3acX+n7mxdMK9Qz2sooxUSQpQUCQdCCLfnb9Bdc+MjFZUccw6pF1NJTk7mzJHDVLilKqGhoYSHhaEoCgaDgfCwME4n/oaqN2DKMKGqKr4BQRzevfO619YpCn4GeasV5YtMKwgh3F6Erx6HqqLm73Ogkmu1Ys7JwWy24FAdeHl5ERwcjPHWauj1eryMXgAkbttAw5bt0en0mNNSqBARSU5ODrm5uXj7B2DONF3zuqqqoqoqFX31ZfRKhSgZEg6EEG6voq8BnaJgczjItZjJycnBZrOh1+vx8/fDx8cHg975duhbpTr1m0exK34h3gFBhFevjcHwz1ul0ehFWFgY6enpmM1mLl44h4qKwpUjEw6cYSTCV95qRfki/8cKIdya1Wpl1w8byfCpjuLtj9Wcjbe3N4GBgXh5eV31Qz2633AAcq25pKam5oeDsMrVyMnMwKA3EBoais2Sg09wGKmpqQQHB+cHjDw2h0qAl44wHxk5EOWLTIQJIdxSYmIiY8eO5d577+XFF57n9C8/4u3tTXh4BCHBIXh7eV81GFzOZrPl9xwA1GrUhFMH9wOgoJCRfJZ7WkShOhykpKSQnZMNOFcmqKoKCjQM9Sl0Q6QQrkJRVVljI4RwD2lpaXz//fd899137N+/n/DwcJ566im6d+9O5Zq38/kfaagqGAu5jbIpw4Q1N5ewsPD82/ZvWQc4lzL6BgZzV4t2qKqDjIxMsnOcoxLBQUHY0aEo8NwdIQR5yciBKF8kHAghyjW73c6WLVuIi4tj7dq1qKpK69at6dGjB61atcJoNObfd/PJTPammDEqhTu2OTU1Fb1eT3BwcKFqsVgspJvSURQd/kHB3BfpT6uqAcV+bUJoRcKBEKJcOnLkCHFxcSxatIizZ89St25dYmJi6Nq1KxEREVd9jMXuIPZQOmm5drxusJ2yikry+fP4BwTg7+df6LrsdgeZFgsXTx1H+SWe8WPewt+/8I8XwhVIQ6IQotzIzMwkPj6e7777jl27dhEUFESXLl2IiYnh7rvvvuHZCd56HVFVA1hy1ESuQ8VLd+0jnB12Ow5VLbBS4UZUVcUG+Pn6cIuSxruLF7J964/MmDGDxo0bF+WlCqEpGTkQQrg0VVX5+eefiYuLY+XKlZjNZpo1a0bPnj2Jjo7G29u7yM+ZkGJm08ksHKqKl+7qIwhmi5m0tDQiIiLQ627cM6CqKrkOFZ2i0LqqPw3DfDh27BiDBw9m7969vPLKK7z66qsFpjmEcFUSDoQQLun06dMsXLiQuLg4jh8/TvXq1YmJiaFbt25UqVLlpp8/IcXMplPOgHC1HoTMrEyys7OpGBEBN1jV4FBVrOqlYFDFGQzy2Gw2ZsyYwdSpU2nQoAEzZsygVq1aN12/EKVJwoEQwmWYzWbWrl3LggUL2LZtGz4+Pjz22GPExMTw4IMPotOV7OrrExlWNpzMJC3Xjg4Fg/LPNENaehoOh4PQCqHXfLyqqthUcKAS4qUnqmoA1QKvPjLw22+/MWjQIE6fPs24ceN45plnbjgNIoRWJBwIITSlqiq///47cXFxfP/995hMJh544AF69OhBp06dCAgo3W5/i93B9jPZJKRanKc3qmDQKVxMTcHLy4ugwKAr6nXg3OAIxXmoU8NQb5pW8sNbf/3wkp2dzcSJE/nqq69o1aoVU6dOpWLFiqX46oQoHgkHQghNJCcns2TJEuLi4jh48CCRkZF0796dmJgYatasWeb1mHLtHEi1kJBqJsvqICs7By+jEf1lDYk6RUFVVRRFwd+o0DDUh/qh3kXex2DTpk0MGzYMm83G+++/T/v27Uv65QhxUyQcCCHKjNVqZfPmzSxYsIBNmzahKArR0dH06NGD5s2bo9drv1mQXVXZ/tsBxr33IS+PeAv/CuHYVBXDpdMVK/rqifA1EOajv6mdD1NSUnj99ddZu3YtMTExTJw4sdRHSYQoLAkHQohS98cffxAXF8eSJUu4cOECDRo0oEePHjzxxBNUqFBB6/Ku8O233zJixAgOHz6Mj4/PjR9QTKqqEhcXx5gxYwgLC2PGjBncf//9pXY9IQpL9jkQQpQKk8nE999/T1xcHL/99huhoaF07dqVHj16UK9ePa3Lu67ExERq1qxZqsEAnM2PPXr0oEmTJgwePJguXbowaNAgXnvtNVnyKDQlIwdCiBJjt9vZvn07CxYsYPXq1djtdlq1akVMTAxRUVHl5gPvySefpGLFinzyySdldk273c7HH3/M+++/T7169Zg5cya33357mV1fiMtJOBBC3LRjx46xcOFCFi5cyOnTp6lduzY9evSga9euREZGal1ekaiqSr169Xj55Zd55ZVXyvz6CQkJDBo0iL///puxY8fyf//3f7LkUZQ5mVYQQhRLdnY28fHxxMXFsXPnTgICAnjiiSeIiYmhUaNG5fYD7cyZM5hMJu68805Nrt+wYUPWrVvH22+/zVtvvcX69ev58MMPy13IEuWbjBwIIQpNVVV+/fVXvvvuO1auXElWVhaPPPIIMTExdOjQAV9fX61LvGkbN27kmWee4ZdffqFq1aqa1vLjjz8ydOhQLBYLU6ZMoVOnTprWIzyHjBwIIW7o7NmzLFq0iLi4OI4cOULVqlV56aWX6NatG9WqVdO6vBKVlJREUFBQiWzRfLMeffRRNm/ezIgRI+jXrx/du3dn4sSJBAYGal2acHMyciCEuCqr1cqaNWuIi4tjy5YteHl50bFjR2JiYnj44YdLfCtjV/Hyyy9z9uxZvv/+e61LyaeqKosWLWL06NGEhIQwY8YMHnzwQa3LEm7MPf90CyFu2tChQ3nppZcwmUxMnjyZ3377jRkzZvDII4+4bTAA58iBVv0G16IoCt27d2fTpk1UrlyZJ598kkmTJmG1WrUuTbgp9/0TLoS4Kc2bN2fLli2sXLmS3r17ExQUdOMHlXMWi4W//vrLZfdhuPXWW1myZAlvvvkmc+fOpUOHDhw8eFDrsoQbknAghLiq7t27e9w6+z///BO73e6y4QBAr9czaNAgVq1ahdVqpV27dsybNw+Hw6F1acKNSDgQwhPs2wezZkF8PMTGal2Nyzpw4AAAd9xxh8aV3Nhdd93F2rVreeaZZxg7diw9e/bk7NmzWpcl3ISEAyHcnckEw4fDgAHQoIHzZ3AGhXbttK3NxSQlJVGjRg38/f21LqVQfHx8+M9//sOCBQs4dOgQLVu2ZMWKFVqXJdyAhAMh3N3WrVC9Omzb5vx5wADn3zt1gpAQzcpyRYmJiS49pXAtzZs354cffqBFixa89NJLDB48GFNeCBSiGCQcCOHugoPhnnugWTNnSDh+XOuKXJKqqiQmJrrcSoXCCgkJYfbs2cyYMYP169fTqlUrduzYoXVZopyScCCEG8jJyWHJkiVMmjTpyl82awapqc5phPh4OHGi7AssB5KTk0lNTS234QCcSx67du3Kpk2bqF69Ot26dWPixInk5uZqXZooZ2SHRCHKKVVV2bNnDwsWLGDFihVkZGTw8ssvX/3Oo0eXbXHlUFJSEkC5nFb4t6pVq7Jw4ULmzJnD5MmT+fHHH5k5c6ZbvDZRNmTkQIhy5ty5c8yaNYsWLVrw2GOP8cMPP/D888+zY8cOxowZU/gn2rbNOYoQH196xZYjiYmJ+Pn5uc120Hq9ngEDBrBmzRpUVSU6Opo5c+bIkkdRKLJ9shDlgNVqZcOGDcTFxbF582b0ej0dOnSgR48eNG3aFL1er3WJ5d6QIUM4evQoK1eu1LqUEmexWPjvf//LnDlzeOSRR/jwww+pXLmy1mUJFybhQAgXlpiYyIIFC1i6dCmpqancc889xMTE8MQTTxAcHKx1eW6lTZs2NGrUiClTpmhdSqn56aefeOWVV8jKymLTpk0ucbiUcE3ScyCEi0lLS+P7779nwYIF7Nu3j/DwcLp370737t3LxeY85ZHVauXPP/+kd+/eWpdSqh555BE2b97M2LFjiYiI0Loc4cIkHAjhAux2O1u3bmXBggWsXbsWVVVp3bo1w4YNo1WrVhiNRq1LdGuHDx/GarWW65UKhRUcHMxHH32kdRnCxUk4EEJDR48eZcGCBSxatIizZ89St25dRo0axZNPPinf7MqQO61UEKIkSDgQooxlZmYSHx/PggUL+OWXXwgKCqJLly7ExMRw9913oyiK1iV6nMTERKpUqeIRJ08KURgSDoQoA6qq8vPPPxMXF0d8fDw5OTk0a9aM2bNnEx0djbe3t9YlerSkpCSPmFIQorAkHIhyx66qpJjtnM+xkZxjJ8vmwK6q6BUFf4OOCF89FX0NhPno0Wv8Lfz06dMsXLiQuLg4jh8/TvXq1Rk0aBDdunWTTnEXkpiYSI8ePbQuQ3v79jn3v6hWDdLSoE8frSsSGpFwIMoNU66dA6kWElLNZFlVHKqKTlFwXLYaN+9nnaLgb1RoGOpD/VBvgrzKbh8As9nM2rVrWbBgAdu2bcPHx4fHHnuMqVOn8uCDD6LTyd5jriQ1NZVz585Jv0He6Z3r1jnP31i1ynl7bOw/Z3JIWPAYEg6Ey7PYHWw/k01CqgW7qoIKBp2CUVEuzc8XHB1QVXAAmbkOdpzL5n/nc2gY6k3TSn5460vng1lVVX7//Xfi4uL4/vvvMZlMPPDAA3zwwQd06tSJgICAUrmuuHl5zYgeP61w+emd1ao5T+/MO8mzWTNIT3fuptmpk7Z1ijIh4UC4tBMZVtafzCQ9144OBS9FQdFdf6pAURT0gF6voKoqNhX2ppg5mmElqmoA1QJLblnghQsXWLJkCQsWLODgwYNERkbSt29fYmJiqFmzZoldR5SepKQkvL29qVGjhtalaOvy0zvBOVKwbx80aPDP77dskXDgISQcCJeVkGJm06ksHKqKUVHQFaN/QFEUjAo4VEjLtbPkqInWVfxpGOZT7LqsViubN29mwYIFbNq0CUVRaN++PWPHjqV58+aylXE5c+DAAerWrYvB4OFvh82aOT/8887ayNuBMz1du5qEZjz8T4NwVQkpZjaddAYDL51y08v7dIqCF5DrUNl0MgugyAHh4MGDxMXFsXjxYi5cuECDBg2YMGECXbp0ISQk5KbqE9pJSkqSfoM8Vzu98/hx59/T050jC8IjSDgQLudEhjV/xKAkgkEeRVHw0l0KCKeyCPHS33CKwWQy8f333xMXF8dvv/1GaGgoXbt2pUePHvKB4gZsNhsHDx6ka9euWpfimpo1+2cFw4kTzj6Ey+Sd8ChNtu5HwoFwKRa7g/UnM0s8GOTJDwiqyoaTmfSpE3xFk6Ldbmf79u0sWLCANWvWYLPZaNWqFfPmzSMqKkq2MnYjx44dw2KxSNC7nrxAkNeLcBmdTsfkyZPp1asXt956axkXJkqThAPhUrafySY9137ZSoSSpygKRpw9CNvPZNOqqnMlwbFjx1i4cCELFy7k9OnT1K5dm9dff52uXbsSGRlZKrUIbSUmJgKyUqG4HA4Hq1ev5rPPPuPtt9+mW7dussOnm5BwIFyGKddOQqoFHcVrPiwKnaKgU529DWd/2cSS+V+zc+dOAgICeOKJJ4iJiaFRo0byRufmkpKSiIyMJDQ0VOtSyiWdTkd8fDxjxozh1VdfZcOGDUyZMoUKFSpoXZq4SYqqXraDjBAa2nk2mx3nsp3LFUv1Q1kl12olJycHh6Lnl7i5+J45RExMDB06dMDX17cUry1cSd++fbHZbMyfP1/rUsq9VatW8frrr+Pt7c20adN49NFHtS5J3ATpIhEuwa6qJKSaQaXUgoHdYScrK5MLKSmkpqaSm5uL0Wgk+rkhfBcXR9euXSUYeBhZqVByOnbsyA8//EC9evXo1asXb731Fjk5OVqXJYpJwoFwCSlmO1lWFcMNNjgqKhUVs8XMxbSLXEhOJjMrC6PRSGiFCoSHh+Pr7YUFPSlme4leV7g+k8nEyZMnpd+gBEVGRjJ//nwmTZrEt99+S7t27UhISNC6LFEMEg6ESzifY3OeiXCD+x3evZP9W9axK35h/m3fTRha4GcAq82KKcNEcnIyaWlpqA4HgUFBREREEBwUjJeXNwoKOpxbHyfn2Er+RQmXlrdtsowclCxFUXj22WdZv349vr6+dOrUiY8++gi7XQJ4eSLhQLiE5Bw7uhv0GqSe/hu/wGAq334nWxd8ln97lbp3kXL6BA7VQXZ2FikpF0hJScFiNuPr60t4eDihoWH4+fqhUwr+L69cuub5HHnj8jSJiYkYjUZq166tdSlu6fbbbyc+Pp6BAwfy3nvv0aVLF47nbagkXJ6EA+ESsmyOAqcrXk3qmZNUrnMn+7eup1ajJvm3397kUbyDw0g+f56MzEz0BgMVKlQgPCKCwIBADPrrL8pxqCrZNkeJvA5RfiQlJVG7dm3Zt6IUGY1GRo4cyffff8/58+dp06YNCxYsQPrgXZ+EA+ES7IV4s6jd2BkI9v24hrtatAMgNzeXjAwTt9RtgENVObTzB3avWszS98fy25YNmDJMZGZlkpOTjSXXgtVmxaE6UCl4PZu8WXmcpKQk6TcoI/fffz8bN27kscceY9iwYTz//POkpKRoXZa4DtnnQLgEfSFXKORkmjj9ZyK1GzdBRcWUYeLCsb+4P/pxTh06gJ+fH/e26US2KZ3ZLz7BoK/XYrfb87d5zaMoCjqdDr1Oh8HXn4S9B/g7fh+RkZFUqlSJyMhIIiMjCQwMlL0O3JDD4SApKYkOHTpoXYrHCAgIYOrUqURFRTF8+HBatWrF1KlTad26tdaliauQcCBcgr9BV6iNjy6ePkloJec2rVlZWdjtdvz9/TAajNhycvh73x4aR3UmwD+AgJBQLBfOUbnOnaioOBwOHHY7doejwD+rDgcnj/zJt/M+Jv1fJ9D5+voWCAy33HLLFQHilltuwcen+Kc8irJ34sQJsrOzZeRAA+3bt6dx48YMGzaMp59+mr59+zJ27FhZRuxiJBwIlxDhq8ehqqg32OfAJyAQAJvdRlZWFif27uT+dk8AzmmHvKkHgGxTGpXrON/8FRT0Oj16nZ7LZ5hVVSXXoTLk2T7Mee0FzGYzZ8+e5dy5c5w7dy7/n8+cOcO5c+f4/fffOXv27BXrt4OCgq4IELfcckuBf46IiJD5bRchKxW0VbFiRb755hu+/vprJkyYwLZt25g5cyb3yKmPLkN2SBQu4XyOjdhD6eiVG08xrJ37Pt7BYXj7+VO38UOEVa52xX2WTR1P7cZN8nsTrsWuqthV6FMnmIq+hcvKqqqSkZFxzQBxebiwWq35j1MUhfDw8OsGiMjISMLCwuSUu1L2wQcf8OWXX5KQkCDTRhr766+/GDRoEPv372fYsGEMHjwYg0G+t2pNwoFwCXZVZV7SRTJzHVeckvhvOeYc0tPTqVChAt5e3lf8fv+WdQA3DAbgPAUywEvHC/UqFLrvobAcDgcXL168boA4e/YsycnJBbq3DQYDFStWvG6AqFSpkvRD3ISvvvoKs9lM//79tS5FAFarlQ8//JCPPvqIe++9lxkzZlCjRg2ty/JoEg6EyyjM2QoO1cGFCxfw8vIiJDjkit8f3r0TcE4xnD6UiE9AIKGVr36UrKqq5KoqD0f60eQWvxJ7HUVls9m4cOHCdUcgzpw5Q1paWoHH+fj45IeF6/VFyFzulfLe9iRcuZbdu3czePBgzp8/z4QJE+jVq5f8N9KIhAPhMky5dj7/Iw1VBeM1tlFON6VjsVgICwtDr9MX+F3q6b/5+KWn8n82Z2UwaVPiNa9ndagoCjx3RwhBXvpr3s9VWCyWAmHhatMaZ8+eJTs7u8DjgoKCrhkg8kYlKlasKP0QwiVkZWUxbtw4vv32W9q2bcv7779PeHi41mV5HAkHwqVsPpnJ3hQzRuXKY5tzrbmkpqYSFBSEn+/NfdN3qCpWVeXeMB9aVQ24qedyNZmZmdcNEHk/X94PARAWFnbdAJHXD6HXu36QEuXf+vXree2111AUhQ8++ICoqCitS/IoEg6ES7HYHcQeSict115gekFFJSUlBUVRCA0NRaH4Q4150wkhXnr61Am+YY+DO1JVlbS0NM6ePVug/+HfASI5ObnAHhF6vZ6IiIgbrswIDg6W4WBx05KTkxk+fDgbNmygT58+jBs3Dn9/f63L8ggSDoTLOZFhZclREw6HipfOGRCysjLJzMwiNCwUo6H4w995Sxd1OoWutwVRLVCG0q/HbrcX6Ie4Vl9Eampqgcd5e3tf0UR5tcZKeaMXN6KqKvPnz2fcuHFERkYyc+ZMGjVqpHVZbk/CgXBJCSlmNp3MwqGq6FUHKakp+Pn5EXhpn4PiyA8GikLrqv40DJONi0pKbm7uNacwLr8tIyOjwOMCAwNvGCAiIyPx8vLS6JUJV3H06FEGDx7M77//zquvvsqQIUOkT6YUSTgQLishxcymU1lk55jJzckmPLQCilK8KYC8HgOdotC6igQDrWRmZnL+/PnrBogzZ86Qm5tb4HGhoaFXXYmR93Pt2rXx8/OTqQw3Z7PZ+Oijj/jwww9p2LAhM2fO5LbbbtO6LLck4UC4tO/W/cjuLC8qVq+F0WDAoBRt+ZmqqthUcODsMYiqGiBTCS5OVVXS09MLTGX8+5/z+iHsdudR22+++Sb9+/e/coRh3z7Ytg2qVYO0NOjTp+xfkChxe/bsYfDgwZw9e5bx48fTp0+fYgdDu6qSYrZzPsdGco6dLJsDu6qiVxT8DToifPVU9DUQ5qMv8b1QXJmEA+GyTCYTzZs35/6HHqbn6CkkpFqcpzeqYNAp6Lh6UFBVFQdgc6hwacfFhqHeNK3k55HNh+7KbreTkpLCuXPnCAgIoFq1agVXUphM0K0brFsHx4/DqlUwYADExkL16rBlC4wefcXzHj16lIiICAIC3GsVi7vJzs5mwoQJfPPNN7Rp04YPPviAiIiIQj/elGvnQKqFhFQzWVYVx6WRxcuPjs/7Waco+BsVGob6UD/Uu1wsfb5ZEg6Eyxo1ahSLFi1i69atVKpU6Yo/zKqqolzlD3Pe7Z72h1n8S3w8rFgBTz/tHDmoXt0ZGFascI4g9OsHb73lvP0ydevWJSMjA39//xsu7YyMjMTb+8pdOkXZ2bhxI8OGDcPhcPDBBx/Qrt31d0a12B1sP5MtXzZuQMKBcEl79+6lU6dOjB8/nhdffLHA7/KGAZNzbJzPsZNtc2BTVQyKgp9BR0VfPREeOAwo/mXbNue0woABzp+PH/8nCMTGwrFjVx05+OWXXzh9+vRV+yLOnDmDxWIpcP+QkJArTun8d2NleHi4nBdQilJSUhg+fDjr1q2jZ8+eTJgw4aojPycyrKw/mUl6rh0dikxTXoeEA+FybDYb0dHR6PV6Vq1aJW+qovjefhvyTvoLDoZmzf753YgRMHDgFSMH16OqKiaT6Yqlnf/uizh//jw2my3/cTqdjoiIiOsGiMjISOceHhJoi0VVVRYsWMCYMWOIiIhg5syZNG7cOP/3eQ3ODlW96iZrReEJDc4SDoTL+eSTT3j77bdZtWoVd999t9blCHcSH/9PSJg1y3lb3shCCXI4HPn9ENdrrLxw4UKBxxmNxhsGiFtuuYWAgAAJEddw7NgxBg8ezN69exkyZAhDhw4lyWTPXxqdt3fKzXL3pdESDoRLOXXqFM2bN6dnz568/fbbWpcj3I3JBFu3Ov9561aYMkXTcqxWK8nJydcMEHlTGSaTqcDj/Pz8bhggIiMj8fFxrw+swrLZbMycOZOpU6fycKeu3P/im6DoSiwY5HHnTdUkHAiX8n//93/8/vvvbN26lcDA4m94JIQ7ycnJKbAfxNWWdp49exaz2VzgccHBwVfsDfHvUBEeHu62mwn9+lsCS09Z8a0QgZdBh7+vL9zE1utX467bsUs4EC5j7dq1PPfcc8ydO5dOnTppXY4Q5YqqqmRkZFwzQFzeD3H5oVuKohAeHn7dAJHXD6HTla8Pvs0nM9l7wYwlO4vs7Cy8vb0JCgq64kTXm+WOB7lJOBAuITMzkxYtWlC/fn2++uormU8VJS6vQdDTG1wdDgcXL1686hTG5bclJydz+ceDwWCgYsWKN1yZERgY6BJ/fv99BLwl14IpPR0V5zHmPt4lO+VS3o6AvxEJB8IljBs3jm+++YYtW7Zw6623al2OcDOqqjJr1iwaNWpEkyZNtC6nXLDZbFf0Q1xtJCItLa3A43x9fa+6L8S/+yF8fX1Ltf6dZ7PZcS67wOmuDtWByWTCbDbj6+tLYGAgumJuyf5vedMLD0f60eSWmztS3hV4doQWLmHfvn189tlnjBo1SoKBKBXnz59n0qRJfP7551qXUm4YDAYqVapEpUqVrns/s9l8xfkYlweIffv2cfbsWbKzsws8Ligo6JoBIu+2ihUrFqsfwq6qJKSaQQVF988ohk7RERIcTI63NxkmE7m5uQQHB+NlvPmDvRRFAYfzug9E+pb7PVYkHAhN2e12RowYQd26da/Y7EiIkpKYmAhAvXr1NK7E/fj4+FC9enWqX2e/CFVVyczMvGaAOHr0KDt37uTcuXMF+iGA/H6IawWIW265hbCwsAL9EClmO1lWFYPuah/QCr4+vngZjSRs28TB9Is4rLk0e+ppFBS+mzCU2o2bcH+n7kX+d2HQKWRZnZu0VfQt3x+v5bt6Ue59/fXX/P7776xYscJtO6aF9pKSkvD395eRKY0oikJgYCCBgYHUrl37mvdTVZWLFy9esRIj7+d9+/axceNGkpOTcTgc+Y8zGAxERETkh4WqDzyKb+ModKodvU6HXq9Hp9Nd2vjIGRjSz52hYuWqqFWrE/vWAOq36khwcDBV6t5FyukTxXqdOsCmqiTn2CQcCFFc586d49133+Xpp5/mvvvu07oc4cYSExOpV69eueu29zSKohAaGkpoaOh1R3lsNhspKSlXDRBnz57lbFYuVXMtWLKzrnh+vU6HTq/nxOE/qNXoIf63NJZajR5yblx14QI173+E00m/Fbt+RYHzOXbqF+sZXIeEA6GZMWPG4OPjw6hRo7QuRbi5pKQk7r//fq3LECXEYDDkTy1cbRfV+OMZ/HHRQkhgAA6HA7vdjsPhwGG3Y3c4cNgdVGvQGIvFwr4f1tC0d3/sdnv+ctBbGzi/rORkmtgVvwiA5j2eL1RtDlUl2+a48R1dnMRooYlNmzYRHx/PhAkTCA4O1roc4casVit//vmn9Bt4EPulRXgKCnqdHi+jFz7ePvj5+RMYEEhwcDChFULx9/biwonD3Ne6PeHh4YSFhpH69xH8QsIA+Gv3TrJNF4t8fZsbLAKUkQNR5nJychg1ahTNmjXjiSee0Loc4eYOHz6MzWbjzjvv1LoUUUYKu1Lg4umThFa6FZ2iQ6fXgR4Men3+MfB3tWhHTkY6OZkZRbq+oZyvVAAJB0IDU6dO5dy5c8TFxbnEZinCveWtVKhbt67GlYiy4m/QFerURZ+Aglu079+yjjseaYPdbi/2tXWXjo4v7yQciDKVlJTEnDlzGDZsGDVq1NC6HOEBEhMTufXWWwkKCtK6FFFGInyd3/5Vlet+AQmtfCv1m0exK34hvoHBVL79ThRFKbASoihUVUVVVSr6lv8dEiUciDLjcDgYMWIENWrUYEApHJMrxNXkrVQQnqOirwGdouAAbvQxHd1veIGfM7MyKe7GwQ6cYSSinC9jBGlIFGXo22+/Zffu3UyePBkvr5vfkUyIwkhKSpJ+Aw8T5qPH36hgcxT9Q/5mRg5sDhV/o0KYT/kfOZBwIMpEcnIyb7/9NjExMbK3vSgzFy5c4Pz58zJy4GH0ikLDUB9QKPIogE6nc04PoHJ4985Lf+1g/5Z1132cqqqgQMNQn3K/dTLItIIoIxMmTECv1zNmzBitSxEe5I8//gCgfv3yviWNKKr6od7873wONhWMRfiszutRUFWV2o2bULtx4b7M2FRnKKkf6l2ccl2OjByIUrdt2zaWLl3K2LFjCQ0N1boc4UESExPz9/4XniXIS0/DUG8cqPlLEwsj75TGokwtOFQVByoNQ73d4rhmkHAgSpnFYmHkyJE0adKE7t2LfpCJEDcjKSmJO+64A73ePd6wRdE0reRHiJce66VVBIWRd4pjYe+vqipWVSXES0/TSuX/qOY8Eg5EqZo+fTqnTp1i8uTJsqeBKHOyUsGzeet1RFUNQKco5DoKFxDy9kdQCzFyoKoquQ4VnaIQVTUAb737fKS6zysRLufw4cPMnDmTgQMHXvckNiFKg81m4+DBg7JSwcNVCzTSuop/oQOCculwrhtNRVweDFpX8adaoHudKisNiaJUqKrKyJEjqVKlCkOGDNG6HOGBjhw5Qm5urowcCBqG+QCw6VQWuaqKEa65g+LlDYnX4rg0laDTOYNB3vO7EwkHolQsWrSInTt3smDBAnx83O8PjnB9SUlJABIOBOAMCCFeejaczCQt145OBYNy5Q6KCso19zpQVRWbCg6cPQZRVQPcbsQgj4QDUeJSU1OZMGECXbp0oXnz5lqXIzxUYmIit9xyCxUqVNC6FOEiqgUa6VMnmO1nsklItZCrquBQMegUdPwTFPL2OgBnIHDg3OAIxblc8d5QH5pW8nOrHoN/k3AgStzEiROx2+2MHz9e61KEB/P396dv375alyFcjLdeR6uqAdxX0ZcDqRYSUs1kWVVsqoqiOKcMjH4BqDpdfo+CoigEeOloGOpDfTdarng9ilrcTaSFuIqff/6ZJ598ksmTJ/P0009rXY4QQlyXXVVJMdtJzrFxPsdOts3BD1u24ufjTcumTajoqyfC10CYj94tdj4sLAkHosRYrVbatGlDUFAQy5cvR6dz3yE3IYT7euaZZ9DpdHz55Zdal6IZmVYQJWbWrFkcPXqUdevWSTAQQpRbQUFBnD59WusyNCXv4KJEHDt2jGnTptGvXz/pDhdClGvBwcGkp6drXYamJByIm6aqKm+88QYVK1Zk2LBhWpcjhBA3JSgoiIyMDK3L0JRMK4ibtnz5crZu3crXX3+Nn5/77C0uhPBMQUFBmEwmrcvQlIwciJtiMpkYN24cHTt2pE2bNlqXI4QQNy1v5KAoJzO6Gxk5EDflnXfeIScnh4kTJ2pdivBk+/bBtm1QrRqkpUGfPlpXJMqxoKAgVFUlMzOToKAgrcvRhIwciGLbvXs3X3/9NW+88Qa33HKL1uUIT2UywfDhMGAANGjg/BkgPt7519tva1ufKHeCg4MBPHpqQcKBKBar1cqIESO4++67ZRc6oa2tW6F6defIAThDQnw8BAdDp04QGgqxsdrWKMqVvNECTw4HMq0giuXTTz/l4MGDrFmzBr3e/bcSFS4sOBjuuQeaNXP+fPy4MxTkOXYMZLdOUQR54cCTlzNKOBBFdvLkST744AOee+45GjRooHU5wtM1awZbtjhHC8AZFqpXd/7ztm3QsKFzukGIQpKRAwkHoohUVWXUqFEEBwczYsQIrcsRwmn06Ctv27cP0tOdzYn79klAEIUmIwfScyCKaPXq1WzcuJFJkyYREBCgdTlCXN3x49CvH3zzDbRr51zBIEQheXl54ePj49EbIcnIgSi0jIwMRo8eTVRUFNHR0VqXI8S1Va8OO3dqXYUoxzx9C2UZORCFNmXKFEwmE5MmTULxoKNLhRCeJzAw0KN7DiQciEJJSEjgiy++YPjw4VStWlXrcoS4KqvVis1m07oM4QZk5ECIG7DZbLz++uvccccdvPDCC1qXI8RVqarKd999R2JiotalCDfg6YcvSTgQN/Tll1+yf/9+pkyZgtFo1LocIa7q5MmTvPHGG1y4cEHrUoQb8PTDlyQciOs6c+YMkydP5plnnqFRo0ZalyPENSUlJQFw5513alyJcAdBQUEyrSDEtYwZMwZ/f3/efPNNrUsR4roSExMJCQkhMjJS61KEG/D0kQNZyiiuacOGDaxevZrZs2d77MlkovxISkrizjvvlJU0okRIQ6IQV5Gdnc2oUaN49NFH6dy5s9blCHFDBw4coF69elqXIdxEXkOiqqpal6IJCQfiqj744AMuXLjAu+++K9/EhMvLycnh6NGj0m8gSkxwcDB2u53s7GytS9GEhANxhcTERObOncvQoUOpnneAjRAu7ODBg6iqKiMHosQEBgYCnnv4koQDUYDD4WDkyJHUqlWLl19+WetyhCiUpKQkdDoddevW1boU4SaCg4MBzz18SRoSRQGxsbHs3r2b77//XvY0EOVGYmIit912G76+vlqXItxEXhO2p26EJCMHIt/58+d555136NmzJw8++KDW5QhRaHkrFYQoKZ5+bLOEA5Fv3LhxGAwGRo8erXUpQhSaqqokJiZKv4EoUXnhwFN7DmRaQQCwZcsWli9fzkcffUSFChW0LkeIQjt37hxpaWkyciBKlI+PD0ajUUYOhOcym8288cYbNG3alKeeekrrcoQokryDlmTkQJQkRVE8+vAlGTkQfPTRR5w+fZrY2FjZ00CUO4mJiQQEBMhR4qLEefIWyjJy4OEOHTrErFmzGDJkCLVq1dK6HCGKLK/fQIKtKGmefPiShAMPlrenQdWqVRk0aJDW5QhRLLJSQZQWGTkQHmnhwoX873//Y/LkyXh7e2tdjhBFlpuby+HDh6XfQJQKTz58ScKBh0pJSeE///kPXbt25ZFHHtG6HCGK5c8//8Rut1O/fn2tSxFuyJMbEiUceKiJEyeiqirjxo3TuhQhii1vpYJsmyxKgyePHMhqBQ+0Y8cOFi5cyPvvv094eLjW5QhRbElJSVSvXp2AgACtSxFuKDAwUHoOhGfIzc1lxIgR3H///fTo0UPrcoS4KbIzoihNnjxyIOHAw8ycOZMTJ04wZcoUdDr5zy/KN1mpIEpTUFAQVqsVi8WidSllTj4dPMjRo0eZPn06L730kszRinIvOTmZ5ORkGTkQpcaTD1+ScOAhVFVl5MiR3HLLLQwdOlTrcoS4aUlJSQAyciBKjScfviQNiR7i+++/56effiI2NlbOvBduITExEV9fX6pVq6Z1KcJNyciBcGtpaWmMGzeOzp0706pVK63LEaJEJCUlcccdd6DX67UuRbip4OBgwDNHDiQceIBJkyaRm5vLhAkTtC5FiBKTmJgoUwqiVOWNHHjiRkgSDtzcrl27mD9/Pm+88QaRkZFalyNEibBarRw6dEjCgShV/v7+6HQ6j5xWkJ4DN+ZwOMjIyGDevHm0a9dO63KEKDFHjhzBarXKSgVRqhRF8diNkCQcuLkWLVqgKIrsaSDcSt5KBQkHorR56kZIEg7cmAQC4a4OHDhA5cqV8xvGhCgtnnr4knx6CCHKHdkZUZQVTx05kHAghCh35EwFUVY8tedAwoEQoly5ePEiZ8+elZEDUSZk5EAIIcoB2TZZlKWgoCCPHDmQhsTybN8+2LYNqlWDtDTo00frioQodUlJSXh5eXHbbbdpXYrwABIORPliMsHw4bBuHRw/DqtWOW9v1w5CQqBBAxg9WtMShSgNiYmJ1K1bF4NB3r5E6ZNwIMqXrVuhevV/Rg4GDHDePngwdOqkbW1ClCJZqSDKUlBQEDk5OVitVoxGo9bllBnpOSivgoPhnnugWTNnSDh+3Hn7iRPOwPD225qWJ0RpsNvt/PHHH7JSQZQZTz18ScJBedWsGaSmQny8868TJ5y3Dxjg/F2NGs7bhXAjx44dw2w2y8iBKDOeeviSTCuUZ//uKdi2zfn3Zs2cPQkhIWVekhClKTExEZBtk0XZyRs58LTljDJy4E6aNYP09H9CgvQeCDeTlJRExYoVCQsL07oU4SECAwMBz5tWkJEDd5MXCJo107YOIUqB7IwoypqMHAghhItLSkqifv36WpchPEhAQADgeT0HEg6EEOWCyWTi77//lpEDUab0ej2BgYEyciCEEK7o4MGDgGybLMqeJx6+JOGgnDl37hydO3dm1qxZWpciRJlKTEzEYDBQu3ZtrUsRHsYTD1+ScFDOjBs3jqNHj9KrVy+tSxGiTCUlJXH77bd71C51wjV44hbKslqhHPnhhx9YsWIFM2fOJET2MBAe5sCBA9JvIDThieFARg7KiZycHN58802aNWtGly5dtC5HiDLlcDj4448/pN9AaCI4ONjjwoGMHJQT06ZN4+zZs3z33XcoiqJ1OUKUqb///pusrCwZORCakIZE4ZL++OMPPvnkE4YMGSJn2AuPlJSUBMhKBaENaUgULsfhcDBy5EiqV6/OoEGDtC5HCE0kJiYSGhpKxYoVtS5FeKCgoCCP2wRJphVc3IIFC9i1axeLFy/Gy8tL63KE0ERSUhJ33nmnTKkJTQQHB5ORkYHdbkev12tdTpmQkQMXduHCBSZOnEj37t15+OGHtS5HCM3ImQpCS3mHL2VmZmpcSdmRcODCJkyYgKIojB07VutShNBMdnY2x44dk34DoRlPPHxJphVc1E8//cSSJUuYOnUqoaGhWpcjhGYOHjyIqqoyciA0ExQUBHjWsc0ycuCCLBYLI0eO5MEHHyQmJkbrcoTQVGJiIjqdjjp16mhdivBQeSMHnhQOZOTABc2cOZOTJ0/yxRdfSAOW8HiJiYnUrFkTHx8frUsRHiqv58CTwoGMHLiYv/76i+nTpzNgwAD5piQE/6xUEEIrQUFBREZGYrFYtC6lzMjIgQtRVZWRI0dSpUoVXnnlFa3LEUJzqqqSmJhIixYttC5FeDCj0cjevXu1LqNMSThwIYsXL2bHjh189913MoQqBHDmzBlMJpOMHAhRxmRawUVcvHiRCRMm8Pjjj8u3JCEuSUxMBGTbZCHKmoQDF/H2229js9mYMGGC1qUI4TKSkpIICgqicuXKWpcihEeRaQUX8L///Y/vvvuO//73v7J3vBCXydsZUVbtCFG2ZORAY1arlREjRtC4cWP69OmjdTlCuBRZqSCENiQcaGz27NkcOXKEKVOmoNPJfw4h8lgsFv766y/ZGVEIDci0goaOHTvGtGnT6Nevn7wBCvEvhw4dwm63y58NoZ19+2DbNqhWDdLSwINGd+WrqkZUVWXUqFGEh4fz2muvaV2OEC4nb6XCHXfcoXElwiOZTDB8OAwYAA0aOH++/HcjRmhXWxmQkQONrFy5kh9//JGvvvoKPz8/rcsRwuUkJSVRo0YN/P39tS5FeKKtW6F69X9GDgYMKPi7tDTNSisLMnKgAZPJxJgxY+jQoQNRUVFalyOES0pMTJRmRKGd4GC45x5o1swZEo4fd94eHw+dOmlaWlmQcKCBd999l+zsbCZOnKh1KUK4pLxtk6XfQGimWTNITXWGgfh4OHHC2YPQoIHWlZUJmVYoY3v27OHrr79mwoQJVKpUSetyhHBJycnJpKamysiB0Nbo0QV/3rfvn7+OH3frsCAjB2XIZrMxYsQIGjRowLPPPqt1OUK4rKSkJAAZORCupUED55RCWlrBBkU3JCMHZWjevHn88ccfrF69Gr1er3U5QrisAwcO4OfnR7Vq1bQuRYgr9enj9ssaZeSgjJw8eZL33nuPZ599loYNG2pdjhAuLSkpiXr16snGYEJoRP7klQFVVXnrrbcICgpihJuvjRWiJEgzohDaknBQBtauXcuGDRt4++23CQwM1LocIVya1Wrl8OHDEg6Eyzl48CDJyclal1EmJByUsszMTN566y2ioqLo0KGD1uUI4fIOHz6M1WqVlQrC5Tz//PPMnj1b6zLKhISDUvbee++Rnp7OpEmT5NhZIQpBVioIVxUcHIzJzVcp5JFwUIr27dvHZ599xmuvvUbVqlW1LkeIciExMZGqVasSFBSkdSlCFBAUFCThQNwcu93OiBEjqFu3Li+++KLW5QhRbuStVBDC1QQFBZGenq51GWVCwkEp+eqrr0hISGDKlCkYjUatyxGi3JAzFYSrkpEDcVPOnj3Lf//7X55++mkaN26sdTlClBupqamcO3dORg6ES5KeA3FTxo4di6+vL6NGjdK6FCHKlcTERAAZORAuyZNGDmT75BK2ceNG4uPjmTVrljRUCVFESUlJeHt7U6NGDa1LEeIKgYGBmEwmVFV1+9VnEg5KUHZ2NqNGjaJ58+Y8/vjjWpcjhEuyqyopZjvnc2wk59jJsjmwqyp6ReGETyTNY54j1QpheudtQriK4OBgrFYrZrMZX19frcspVRIOStDUqVM5f/48CxcudPtUKURRmXLtHEi1kJBqJsuq4lBVdIqCQ1Xz7+Nd+17uuOM+Yg+l429UaBjqQ/1Qb4K85KAyob280WCTySThQBROUlISc+fO5bXXXpMhUSEuY7E72H4mm4RUC3ZVBRUMOgWjolwK0c4graKSnp1JQEAAegUycx3sOJfN/87n0DDUm6aV/PDWS5uU0E5wcDDgDAeRkZEaV1O6JByUAIfDwYgRI7jtttsYMGCA1uUI4TJOZFhZfzKT9Fw7OhS8FAVFd/VRNbvdjqqqGA1G9IqCXq+gqio2FfammDmaYSWqagDVAmVpsNBG3tk4ntCUKOGgBMyfP5/du3ezdOlS2dNAiEsSUsxsOpWFQ1UxKgq6G0y12Ww2AAzGf96WFEXBqIBDhbRcO0uOmmhdxZ+GYT6lWrsQV5M3cuAJGyHJGN1NSk5OZtKkScTExPDQQw9pXY4QLiEhxcymk1k4HCpehQgGADarFb1ej0658m1JpzhHHRwOlU0ns0hIMZdG2UJc1+U9B+5OwsFNGj9+PHq9njFjxmhdihAu4USGNX/EwEunFLo512qzYTBcezBTURS8dM4Gxk2nsjiRYS2pkoUoFD8/P/R6vYQDcX1bt27l+++/Z9y4cYSGhmpdjhCas9gdrD+ZWeRgAM5pheuFAygYEDaczMRid9xsyUIUmqIoHrMRkoSDYjKbzbzxxhs8/PDDdOvWTetyhHAJ289kk55rv2wlQuE4VAd2u/2G4QDy+hAU0nLtbD+TfTPlClFknnL4koSDYpo+fTqnTp3iv//9r+xpIATOfQwSUi3oKFyPweXymxELEQ7A2YOgQyEh1YIp117kWoUoLhk5ENf0559/8vHHHzNo0CBq166tdTlCuIQDl/YxMBQjK9tsNhRFKXQ4ADAozt0WD6Rain5BIYrJUw5fknBQRKqq8sYbb1ClShWGDBmidTlCuAS7qpKQagaVYo2k2aw2DHo9CoV/rKIooEJCqtm5uZIQZcBTRg5kn4MiWrhwITt37iQuLg5vb2+tyxHCJaSY7WRZVQzX2OAoz+HdOzFnmsjJSOf+Tt0B+G7CUG6p24BGHboW+boGnUKW1XlWQ0VfeTsTpS8wMJBz585pXUapk5GDIkhNTeU///kPTz75JM2aNdO6HCFcxvkcm/OshOvcJ/X03/gFBlP59jvZuuCz/Nur1L2LlNN/F2lKIY8O52heco6t6EULUQzBwcHSkCgKmjhxIna7nXHjxmldihAuJTnHju4GKxRSz5ykcp072b91PbUaNcm//Y6mrQiOrFyscKBcuub5HGlKFGVDphVEAXlTCVOmTCEiIkLrcoRwKVk2x6XTFa8dDmo3dgaCfT+uod2Lr+XfbrFYqNagMVarlYM7fiC8cjVOHdoPkD/1cD0OVSXbJvsdiLIhDYkiX25uLiNHjuS+++6jV69eWpcjhMspbENgTqaJ038mUrtxE1RUMjIzOHbgN8KrVCP1/Dk2fTUL/1uqULdpa5ZNG1/o69ukIVGUkaCgIMxmM7m5uVqXUqpk5KAQZs2axbFjx1i3bh06neQpIf5NX8gVChdPnyS00q2oqkq6KR2z2Yyvry9hYWGEVKhAv5nfkpOTw+nDSdxavxHZ2dn4+Ppc9byFyxlkrxFRRi4/XyE8PFzjakqPfNLdwLFjx/jwww/p378/9erV07ocIVySv0FXqI2PfAICUVFJvZiKxWLhzL5fua/t44CCXqfH3z+AIz9vJmHNYp54410yMjNITk4m3ZROrjUXuHKEQKco+BnkrUyUDU85fEn+RF2HqqqMHDmSyMhIhg0bpnU5QrisCF89DlVFvcHwfmBEJLc1bspv65ZxZv+vVL/z7ivu80CnGB7q3JOfF3xGRHg4AQEBWHNzSU1N5UJKClnZWThUZ4+BeumaFX31pfK6hPi3vGOb3T0cyLTCdSxbtoxt27bxzTff4Ovrq3U5Qrisir4GdIqCA7jWx7TZnEO6yUTLvoMJCQm56hRdTqYJ34AgajduwncTXuWuFu2o3bgJfn5+WHNzyc7JITMzk8zMTHy8vfH280OnNxIhexyIMiIjBx4uPT2dcePG0alTJ1q3bq11OUK4tDAfPf5GBZvjypEDFZXMrEzS0tPx8fGhQmiFqwaDXfEL2fLt3Pyf/YJC8At0fktTUPDy8iYkOISIiAjnaILNRnaOhdSzp1j81TxSUlJK7wUKcUleOHD3vQ4kHFzDO++8g9lsZuLEiVqXIoTL0ysKDUN9QKHA1IKKSnp6OpmZmQQGBhIcFHTNLZLvejSaqnUbcHj3TtbOfZ/7O3Wncp07r7ifTtHh7+dPWGgoPr6+2I4dYPK779KoUSNeeuklfvrpJxwOWdooSkdAQACKorj9yIGi3miS0APt3r2bxx57jEmTJvHss89qXY4Q5YIp187nf6ShqmDUKdgddtLS0rDZbAQHB+Pj7VOi17M6VBQFnrsjBHuWiUWLFjF//nz+/PNPatSoQZ8+fejevbtbd5QLbdxxxx0MGTKEAQMGaF1KqZFw8C9Wq5V27drh7e1NfHw8er00OglRWJtPZrI3xYzisJOelgZASEgIRoOxRK/jUFWsqsq9YT60qhqQf7uqquzatYvY2FhWrFiBw+EgOjqaPn368Mgjj8hSZFEiHnjgAbp27crIkSO1LqXUyJ+Uf/n00085dOgQU6ZMkWAgRBE1reSHzpJNVo4FnU5HaGhoiQcD9VIwCPHS07SSX4HfKYrCAw88wPTp0/ntt98YN24cf/75Jz169ODhhx9mxowZnD9/vkTrEZ4nMDDQ7acVJBxc5u+//+b999/n+eefp0GDBlqXI0S5oqoqs2dM59vRA9HpFAKCK9xw86LiXCPXoaJTFKKqBuCtv/bzh4SE8Pzzz7N582ZWrlxJkyZNmDZtGvfddx/PP/88P/zwA3a7nMkgis4TDl+ScHCJqqq89dZbVKhQgddff13rcoQoV8xmMwMHDmTKlCn07tCaTrXD0SkKuY4b731QWJcHg9ZV/KkWWLgRCUVRaNy4MdOmTeO3335jwoQJHDt2jN69e9OkSRM+/PBDjziCV5QcTzh8ScLBJatXr2bjxo1MmjSJgICAGz9ACAHA+fPneeqpp1i7di1z587l1Vdf5e5wX1pX9UenU8hV1UuHMhWfQ1XJVVV0OoXWVf1pGFa85sagoCCeffZZNm7cyKpVq2jWrBkzZszgvvvuy79dRhPEjXjC4UvSkAhkZGTQvHlz7r77br788kutyxGi3Dhw4AB9+/bFbrfz5ZdfcvfdBXc8PJFhZcPJTNJy7ehQMChc91jnf1NVFZsKDpw9BlFVAwo9YlBYGRkZfP/993zzzTccOHCAypUr07NnT3r27EnlypVL9FrCPYwZM4bt27ezefNmrUspNTJyAEyePJmMjAwmTZqkdSlClBtr166lc+fOhIeHs2bNmiuCAUC1QCN96gRzb5gPigK5qorF7sB+na2WVVXFful+uapzueK9YT70qRNc4sEAnM1lzzzzDOvXr2fNmjW0bNmS2bNn88ADD9C3b182bNiAzWYr8euK8isoKMjtew48fuTg999/p0OHDowZM4aXXnpJ63KEcHmqqvLxxx/zzjvv0KlTJz766KNCbS9uyrVzINVCQqqZLKszHCiKUmDKQaco+bf7G50bK9UP9SbIq2xXDmVmZrJ8+XJiY2P5/fffueWWW/JHE6pWrVqmtQjXM2fOHN5//33+/PNPrUspNR4dDmw2Gx07dsRut7N27VoMBtmfXYjryc3NZfjw4SxevJhhw4YxbNiwIu8dYFdVUsx2knNsnM+xk21zYFNVDJdOV6zoqyfC10CYj77QR0GXpn379jF//nyWLl1KVlYWLVu2pE+fPrRu3RqjseRHMoTrW7BgAcOGDePEiRNu+7nh0eFg3rx5jBs3jvj4eO69916tyxHCpV24cIHnnnuOhIQEPvroIx5//HGtSypTWVlZrFixgtjYWPbu3UtkZCQ9evSgZ8+eVKtWTevyRBlavXo1L7zwAomJiYSEhGhdTqnw2J6DM2fOMHnyZPr27SvBQIgbSEpKokOHDpw4cYKlS5d6XDAA8Pf3p2fPnqxatYqNGzfSoUMHPv/8c5o0aUKvXr1YtWoVVqtV6zJFGfCEw5fK/chB3hDl+RwbyTl2smzOZie9ouBv0BHhq6fiVYYon3/+eXbv3s3WrVvz/0MLIa60YcMGBgwYQI0aNfjqq6+kg/8y2dnZrFy5ktjYWHbv3k1ERAQxMTH06tWLGjVqaF2eKCUJCQlER0ezbt06t90wr9xOlvy7ucmhOjdH+XdzU97tlzc3/W/LZtasWcMnn3wiwUCIa1BVlTlz5jBx4kSio6OZMWMGfn5+N36gB/Hz8yMmJoaYmBiSkpKYP38+X3/9NTNnzqRZs2b06dOH6Oho6U1wMzJy4IIsdgfbz2STkGrBrqqggkGnoOPq66dVVcUBznPmFdADCWsXY036ha+/+KxIa66F8BRWq5WRI0eyYMEChgwZwogRI+TQokIym83Ex8cTGxvLL7/8QlhYGDExMfTu3ZvbbrtN6/JECbh48SL169fns88+o3379lqXUyrKVTg4kWFl/clM0m9iQ5VMsxmb3U64vzcdbwstlXXTQpRnqampvPDCC+zevZsPPviAp556SuuSyq1Dhw4xf/58Fi1aRFpaGk2bNqVPnz60b98eLy8vrcsTxWSz2ahWrRrTpk0jJiZG63JKRbn5KpCQYmbJURPpuXaMioJRpxT5W7/NbiPbZMKoKGSrepYcNZGQYi6lioUofw4dOkTHjh35888/WbJkiQSDm1SnTh0mTJjA3r17+fjjj3E4HLz88svce++9TJgwgcOHD2tdoigGg8GAn5+fW08rlItwkJBiZtPJLBwOFS9FQVeMqQAVFZPJhN6gx9/fDy9FweFQ2XQySwKCEMAPP/zAY489hp+fH2vWrOG+++7TuiS34e3tTZcuXViyZAlbt24lJiaGhQsX0rx5c5588kmWLl2KxWLRukxRBO5++JLLh4MTGVY2ncrCoap4FWO0IE9OTg5Wq5WgoCAUnM/jpXM2LG46lcWJDFmCJDyTqqrMmzePp59+moceeojly5fLLoClqHbt2owdO5a9e/cye/ZsDAYDgwYN4t5772XcuHEcOnRI6xJFIbj74UsuHQ4sdgfrT2bedDCwO+xkZmbi6+uLl/Gfeb7LA8KGk5lY7I6SKl2IciGv8XDs2LG89NJLfP7553IqaRnx8vLi8ccfZ+HChWzfvp1evXqxdOlSHn30UR5//HEWLVqE2Syjmq7K3UcOXLohcfPJTPammDEWcyohT1p6Grm5uYSHh6NTrsxDDlXFqqrcG+ZDq6ryxig8Q1paGi+++CK//PILU6ZMcdvGqvLEarWydu1aYmNj2bZtG0FBQTz11FP07t2bevXqaV2euMzTTz+NwWDgiy++0LqUUuGyIwemXDsJqRZ03FwwsORaMJvNBAYGXjUYgHM/BB0KCakWTLlylrtwf3/99RcdOnQgMTGRhQsXSjBwEUajkccee4y4uDh27NhB3759WblyJa1bt86/PScnR+syBe4/cuCy4eDApX0MDDexDYGKSobJhJeXF74+Pte9r0Fx7rZ4IFWagoR727p1Kx07dsTLy4vVq1fz4IMPal2SuIoaNWrw5ptv8uuvvzJv3jwCAwMZNmwY99xzD6NGjSIxMVHrEj1acHCwrFYoa3ZVJSHVDGrR9jH4t6zMTOwOx6XdrK7/PIqigAoJqWbn5kpCuKEvv/yS3r17c99997Fy5UqqV6+udUniBoxGIx06dODbb79l586dPPfcc6xZs4Y2bdrQsWNHt/726sqCgoLIyMjQuoxS45LhIMVsJ8uqYtAVPxjY7DaysrPx9/fHoC/cLtEGnUKW1XlWgxDuxGaz8dZbbzFq1Ciee+45vvrqKwIDA7UuSxRRtWrVGDlyJL/88guff/45oaGhnD9/XuuyPFJQUJBbjxy45NkK53NsOFQVYyFGDQ7v3ok500RORjr3d+oOwHcTXuWWO+6mQZvH8Pf3L/R1dYBNVUnOsVHR1yX/1QhRZCaTiX79+rFjxw6mTJlCnz59tC5J3CSj0Uh0dDTR0dFyEqRG8kYOHA6HW24t7pKvKDnHjk658dLF1NN/4xcYTOXb72Trgs/yb69Y8w5STh0nKNC5p0FhKZeueT5HRg6Eezh27BgdO3bk999/57vvvpNg4IaueqjTvn0waxbEx0NsbNkX5QGCgoKcW/JnZmpdSqlwyXCQZXMUOF3xWlLPnKRynTvZv3U9tRo1AUBVHVS95wHCq9Yo1t7lDlUl2yb7HYjyb/v27fmHwqxevZqmTZtqXJEoEyYTDB8OAwZAgwbOnwG2bXOGhVmz/rlNFFtwcDCA2/YduGQ4KGxDYO3GzkCw78c13NWiHQAOhwPVoVLlznuw2218N2Eopw8lcvpQImvnvl+o57VJQ6Io52JjY+nZsyd33303q1atktMAPcnWrVC9ujMMgDMkHD8OW7ZAp07Qpw/IUfU3Le/YZndtCHXJcKAvwgqFnEwTp/9MzA8KOr2eC8cPE1SxEimpqVw4dZzPhj/L2k8/oEWvfoV6ToMc4yzKKZvNxtixYxkxYgRPP/00sbGx+W9iwkMEB8M990CzZs6QcPy4MyiYTM6Rg+nTta7QLeT9uXLXpkSX7LrzN+gKvfHRxdMnCa10a/7PCgpGoxG9Xo9er+eejt25t00n/P39C9V/oFMU/AwumZmEuC6TycSAAQPYsmULkyZN4tlnn9W6JKGFZs2cowTx8c6fLw1/U6OGc+QgLc3Zh/Cv/pPMzEzn+6R8OSoUdx85cMlwEOGrx6GqqIXY58AnoOByrP1b1nF3qw6kpaUREhLCxb+PsHdjPHZLDr6+fjz42LV3glNVFVVVqeirL5HXIURZOX78OH379uXs2bPMnz+f5s2ba12S0NLo0QV/Dgn5Z5ohJMQZEP7ljz/+4PXXX6dPnz507dqVkJCQUi6yfHP3cOCSX5Er+hrQKQqFaQsMrXwr9ZtHsSt+Ifu3rKPy7Xfi7e2NoihYLBY6DxrFA+27cGfLjvwwfw4ZaanXfC4HzjASIcsYRTny888/06FDB6xWK6tWrZJgIK7UoIHz7/Hx8NtvV4waANSpU4c6deowYcIE7rnnHgYPHsz//vc/XPj4HU15e3vj7e3ttuHAJT8Fw3z0+BsVMnMd6PU3HuKK7jf8itu8vbxJ2LyG9NPHiO43nLCwMHz8Azn2xwFq3d0YP19f/r1ros2hEuClI8xHRg5E+RAXF8eIESN44IEH+PTTT+Xbnri2AQOcf+/U6aq/DgoKYs6cOSQnJ7No0SJiY2NZsmQJtWvXpk+fPnTr1o0KFSqUYcGuz503QnLJkQO9otAw1AcUip1avX288Q+vmL/EUa/TY7eYqV7/bkwmE+kmEyr/PLeqqqBAw1CfIjVECqEFu93OxIkTGTp0KDExMXz77bcSDESJiIiIYMCAAfz0008sXLiQO++8k0mTJnHPPfcwcOBAdu7cKaMJl7jz4Usue2SzKdfO53+koapgLMY2yg7VQfL585xM+AVvL29OHtzHA51iCK18KznmHEwmEwaDgZDgYPR6A1aHiqLAc3eEEOQlIwfCdWVmZjJw4EA2bdrEhAkTeO6556SJTJSqlJSU/NGEI0eOULNmTXr37k337t0JCwvTujzNdOrUiTp16jB16lStSylxLhsOADafzGRvihmjUrxjm1MvpqIoChVCrhwKs9qspKel4VBVgoKCUYxG7g3zoVXVgJIoXYhScfLkSfr27cvJkyf55JNPaNmypdYlCQ+iqio///wzsbGxxF9aDdG+fXv69OnDww8/7JbbCF9Pr1698Pf359NPP9W6lBLn0v8lm1byI8RLj/XSKoKi8vb2Jjc3F1W9srXRaDASGhaG0WgkO9eKNT2VJhWvf6yzEFr69ddf6dChA9nZ2axcuVKCgShziqLQpEkTPv74Y3777TfeeustkpKS6N69O4888gizZs3iwoULWpdZZqTnQCPeeh1RVQPQKQq5jqIHBB9vb1RVxZKbe9XfKyj4BQbjZTSw9J3X+b+ne5OSklISpQtRohYvXkzXrl2pVasWq1atok6dOlqXJDxchQoV6NevHz/++CPLli3jvvvuY8qUKTRq1Ih+/fqxdetWHA733orenXsOXDocAFQLNNK6in+xAoJeb8BoMGCxWK74naqq5DpUdIpCh5qhTB39OomJibRr1469e/eW5EsQotgcDgfvvvsuQ4YM4cknn2ThwoWEhoZqXZYQ+RRF4YEHHmD69On89ttvjBs3jj///JMePXrw8MMPM2PGDLc9VlrCgcYahvnQuqo/Op1CrqoW6lCmPN4+PlgslgIrExyqSq6qotMptK7qT8MwHx555BHWr19PpUqVeOKJJ/jqq6+kI1doKisrixdeeIGZM2cyduxYpk6devUT+IRwESEhITz//PNs3ryZlStX0qRJE6ZNm8Z9993H888/zw8//IDd7j6n3gYHB7ttOHDphsR/O5FhZcPJTNJy7ehQMCg33kHRarOSkpJCaIUKGI1e2FRwoBLipSeqagDVAgu+2VqtVsaPH88XX3zBU089xeTJk/H19S3NlyXEFU6fPk3fvn05duwYs2bNIioqSuuShCgWk8nEkiVLiI2NJSkpiapVq9KrVy969uxJZGSk1uXdlK+++ooxY8Zw/Phxt1sxVK7CAYDF7mD7mWwSUi3O0xtVMOgUdFw9KKiqg5S0NLx9/PDy9rq0h4I3TSv54a2/9sDJ0qVLef3116lRowbz5s2TU+1EmdmzZw/PPvss3t7efPXVV9SrV0/rkoS4aaqq8ttvvxEbG8uyZcvIzc2lTZs29O7dm5YtW6LXl78l5N9//z0DBw7k8OHD+Pn5aV1OiSp34SCPKdfOgVQLCalmsqzOXgRFUQpMOegUxdlbkGshMzWZTvfUoX6od6H3Mfjjjz944YUXSE5OZvr06bRr1660Xo4QACxbtoxXX32Vhg0b8vnnnxMeHq51SUKUuIyMDL7//nu++eYbDhw4QOXKlenZsyc9e/akcuXKWpdXaJs2beLpp59mz5493HLLLVqXU6LKbTjIY1dVUsx2knNsnM+xk21zYFNVDJdOV6zoq+dk0j6e79GVNatX0SBvj/FCysjI4NVXX2XNmjUMHDiQkSNHYjC45K7TohxzOBxMnTqVqVOn0q1bN9577z28vLy0LkuIUqWqKgkJCcTGxvL9999jNptp3bo1ffr0oWXLli7/Xvvrr7/SuXNnfvjhB+rWrat1OSWq3IeDwrBarTRo0IAXXniB4cOvPIfhRlRVZfbs2bzzzjs8/PDDzJo1S77RiRKTk5PDq6++Snx8PKNGjWLAgAFuN38pxI1kZmayfPlyYmNj+f3337nlllvyRxOqVq2qdXlXdejQIR599FFWrFjBfffdp3U5JapcrFa4WUajkaioKNasWVOsxyuKwoABA1i4cCF//PEHbdu2Zffu3SVcpfBEZ8+epUuXLmzcuJHPPvuMgQMHSjAQHikgIIDevXuzZs0a1q1bR9u2bfn000958MEH6dOnD2vXrsVqtWpdZgHBwcEAbrkRkkeMHACsWrWKF198kZ07d1K9evViP8+5c+fo168fe/fuZfz48Tz77LPyZi6KJSEhgb59+6LT6fj666+pX7++1iUJ4VKysrJYsWIFsbGx7N27l8jISHr06EHPnj2pVq2aZnXlTWefTMvmnZmf0Cq6I1VuvRW9ouBv0BHhq6eir4EwH325PcjPY8JBVlYW9evXZ9SoUfTr1++mnstqtTJx4kTmzZvHE088wfvvv+92naqidMXHxzNkyBDuvPNOPv/8cypWrKh1SUK4tMTERObPn8/ixYvJzMykRYsW9O7dm7Zt25bZ/h//boR3qCrZWVl4+fhguLTaQnepMV6nKPgbnScMF6UR3lV4TDgAeOaZZ8jKymLJkiUl8nzLly/ntdde49Zbb+Wzzz6jZs2aJfK8wn2pqspHH33ElClTeOKJJ5g6dSo+PnKmhxCFlXe2SGxsLLt37yYiIoKYmBh69epFjRo1SuWa11tCn3whGX8/P/z9/zm0T1VVHIDNoYJCoZfQuxKPCgfffvstI0aMICEhocS2oD106BAvvPACZ8+e5cMPP6RDhw4l8rzC/ZjNZoYNG8ayZcsYMWIEr7zyikxJCXETkpKS8kcTTCYTzZo1o0+fPkRHR5fYaMKJDCvrT2aSfo3N9y5cSMbbx4fAgMCrPl5V1RtuvueKPCocJCcnc8899zB16lRiYmJK7HkzMzMZNmwY8fHxvPzyy7z55psuvwRHlK1z587x3HPPkZSUxPTp0+nUqZPWJQnhNsxmM/Hx8cTGxvLLL78QFhZGTEwMvXv3vqkN7BJSzGw6lYVDVTEqCrqrhPmU1BSMBiNBQUHXfS6HqmK9NN3Quopz235X5lHhAODxxx8nNDSUL774okSfV1VV5s6dy9tvv80DDzzA7NmzZR5ZALB//3769u2Lw+Hgq6++omHDhlqXJITbOnToEPPnz2fRokWkpaXRtGlT+vTpQ/v27Yu0d0hCiplNJ53BwEunXHOUL/ViKjqdjpDgkBs+5+UH/uWd6+OqysfkRwlq164dW7ZsIScnp0SfV1EU+vfvz+LFi/nrr79o164du3btKtFriPJn7dq1PP7441SsWJG1a9dKMBCilNWpU4cJEyawd+9ePv74YxwOBy+//DL33nsvEyZM4PDhwzd8jhMZ1vwRg+sFAwCdTlfoQ/oURcFL52xY3HQqixMZrrU083IeFw7at2+P2Wxm69atpfL8Dz74IOvWraNGjRp07dqVTz/9VE539ECqqjJz5kyee+452rRpw9KlS8v9ITNClCfe3t506dKFJUuWsHXrVmJiYli4cCHNmzfnySefZOnSpVgsliseZ7E7WH8ys1DBAJwf+A6Ho9B1XR4QNpzMxGIv/GPLksdNKwA8+uij3HvvvUybNq3UrmG1Wnn33Xf55JNP6Ny5M++//z4BAQE3fqAo93Jzcxk+fDiLFy/mtddeY+jQoeh0HpfDhXA5ubm5rFmzhvnz5/PTTz8REhJCt27d6N27N3Xq1AFg88lM9qaYr9lj8G8ZmRlYLBbCw4q2a25eD8K9YT60qup6nw0eGQ7efffd/C06S7txMD4+nqFDh1K5cmXmzZvH7bffXqrXE9q6cOECzz33HAkJCXz00Uc8/vjjWpckhLiKo0ePMn/+fOLi4khJSeH++++nx/89z9maDwMKRl3hVhJlZmWSnZ1NxYii95hZHSqKAs/dEeJy+yB45NeZ6OhoLl68yK+//lrq1+rUqVP+ts0dOnRg5cqVpX5NoY2kpCQ6dOjAiRMnWLp0qQQDIVzYbbfdxujRo9mzZw9z5szBx8eH737cRWZ2NjlZGdhshesHKErPwb8ZFOduiwdSr5ze0JpHhoO7776byMhI1q5dWybXq127NqtXr6Z169b079+f8ePHu9we4eLmbNiwgc6dOxMcHMzq1atp1KiR1iUJIQrBaDTy2GOP8e2CBbR9bjAGgwGz2cyFlBRSU1PIMeegcu0Pf0VRUFX1uve53mNRISHV7NxcyYV4ZDjQ6XRER0ezdu3aMmsW9Pf3Z/bs2UycOJHPP/+cbt26ce7cuTK5tig9qqryySef8H//9380b96c5cuXl6vz6IUQTilmO7no8fP2JiIigpCQEBSdjvT0dJLPJ2PKMGG9ymiCTnF+jKpFaEq8nEGnkGV1ntXgSjwyHIBzSeOJEyf4448/yuyaiqLw/PPPs2TJEo4fP07btm35+eefy+z6omRZrVaGDRvGf/7zHwYPHsynn34qZ2wIUU6dz7E5z0QAFBR8vH2oEFKBiPBw/Px8sVgspKSksOfHtezesJJfVsYBoOgUVk0bxy/xi4p1XR3OLxnJObaSezElwGPDQdOmTQkMDCyzqYXL3X///axfv57bb7+dbt268cknn8hyx3ImNTWV7t27s3TpUqZPn84bb7whKxKEKMeSc+zolCuXLur1BgICAgkPD0fNycQvMISAyCpsjp2DKcOEw+4gstYdpJ46XqzrKpeueT5HRg5cgtFopFWrVpqEA4CIiAgWLFhA//79+c9//kO/fv3IyMjQpBZRNIcOHaJDhw4cPnyYJUuW8NRTT2ldkhDiJmXZHDiu8yVNQSErJZk7Gj/E2QO7qdXoISwWC2npadS+vxkhlW4t9rUdqkq2zbX2O/DYcADODZH27dvHqVOnNLm+wWBg9OjRfPbZZ2zZsoUOHTpw8OBBTWoRhbN582Yee+wx/P39WbNmDffdd5/WJQkhSkBhGgJrN24CwP4t67i7dcf87ZiNRiN3PNCswH33b1nH4d07C319m4uNHnt0OGjZsiVGo5H169drWkf79u1Zu3YtRqORDh06sGzZMk3rEVdSVZV58+bxzDPP8NBDD7F8+XKqVq2qdVlCiBKiL+QJqdmZJk4dOkBwtdpYLBaCgoLIvnCG0Mr/jBzkZJrY8t2nmDNNhb6+wcVOaPXocBAYGEjTpk3z9yHQUs2aNYmPj6d9+/YMGDCA0aNHy3JHF2G1Whk5ciRjx47lpZde4vPPP5fdLoVwM/4G3Q12RFQxm3M4kphAUEQl/Pz8CA8Px8/XD4WCj9v/41oaPNq+0NfWKQp+Btf6OHatajQQHR3Nzp07SU9P17oU/Pz8mDFjBpMmTeKbb76ha9eunD17VuuyPFpaWhq9evUiLi6OadOmMXr0aPR619rJTAhx8yJ89ThU9arN4bnWXFJTU0lLTycgqAIGg4HAgEB0io79W9ZxV4t2+fc9fSiRWo2aFPq66qVrVvR1rfcVjw8H7dq1w263s3HjRq1LAZydq88++yxLly7l1KlTtG3blu3bt2tdlsf69NNPSUxMZOHChcTExGhdjhCilFT0NaBTFC5vC7Q77KSlp5GamooKhFYIpcYd9bmrRVt2xS9k/5Z1VL79zgLPk3rm7wJTDDfiwPm+H+Fbulv5F5VHnq3wbx07dqRKlSrMnTtX61IKSElJ4eWXX2bHjh28+eabDBgw4IYnhImSlZWVxYULF6hevbrWpQghSpFdVZmXdJHMXAdeOuef/azsbHSKQkBgID4+PldMH/zb1gWfEVrJ2Yu078e1+AYG80Cn7lSuc+c1H2OxOwjw0vFCvQqF7nsoCxIOgBkzZvDRRx9x4MABvL29tS6nALvdzpQpU5gxYwbR0dF8+OGHBAUFaV2WEEK4ne1nMvnpdCbZ6Wk4VBV/Pz/8/P3zd0EsirVz36dq3QYFphz+TVVVclWVhyP9aHKLa22g5vHTCuDsO8jOzmbbtm1al3IFvV7Pm2++yRdffMGOHTto3749SUlJWpclhBBuZceOHbw7+HlyMjPx8vMnPDycgEt9BUV1ePdO/trzM/t+XEvq6b+veT+b6lwlUT/Utb6UgoQDwHkw0m233abZhkiF0a5dO9auXYuPjw8dO3ZkyZIlWpckhBDl3rFjx3juued46qmnUCzZ1A1U8PH1RSlGKMhTu3ETBn6ymJ7jpl2z/8ChqjhQaRjq7XLHNYOEA8DZDNK+fXvWr1+P3e5aW1herkaNGsTHx/PYY48xePBgRo0aRW5urtZlCSFEuWMymZgwYQItWrQgISGBWbNmsWLFCp68+zZCvPRYr7FyoSSoqopVVQnx0tO0kmtNJ+SRnoNLfv31Vzp37syKFStcftc7VVWJjY1l9OjRNGjQgLlz58pJgIW1bx9s2wbVqkFaGvTpo3VFQogyZLPZ+Oabb3j//fexWCwMHjyY/v374+Pjk3+fExlWlhw14XCoeOmuPG/hZqiqSq5DRadT6HpbENUCjSX23CVJRg4uuffee4mIiHDpqYU8iqLw9NNPs3z5cs6ePUvbtm356aeftC7L9ZlMMHw4DBgADRo4fzaZYMQI59+FEG5t8+bNtG7dmtGjRxMdHc327dt55ZVXCgQDgGqBRlpX8UenKOQ6Sm4EIT8YKAqtq/i7bDAACQf59Ho9UVFRrFmzptyckHjPPfewfv167rrrLnr06MH06dNxFPNMcY+wdStUr+4cOQBnSDh+HH7/Hbp1g3bt4O23ta1RCFHiDh48SK9evejTpw8VK1Zk/fr1fPDBB0RGRl7zMQ3DfGhd1R+dTiFXVa97KFNhOC6tTNDpFFpX9adhmM+NH6QhmVa4zMaNG3nmmWfYsmULt99+u9blFJrdbmfq1KlMmzaNqKgoZsyYIcsdr2bbNue0woABzp+PXzpiNW8Pg/h46NRJm9qEECUuJSWF9957j9jYWKpVq8a4ceNo27ZtkaYJTmRY2XAyk7RcOzoUDApFeryqqthUcODsMYiqGuDSIwZ5JBxcxmKxUL9+fV555RUGDx6sdTlFtnHjRgYNGkSFChWYN28e9evX17ok1/P223DPPc5/Dg6GZpdOUouNhc6dQUKVEOVebm4u8+bN46OPPkJRFIYNG8azzz6L0Vi8D2WL3cH2M9kkpFqcpzeqYNAp6Lh6UFBVFQdgc6igOJcrNgz1pmklP7z15WPAXsLBv/Tr149Tp06xatUqrUspluPHj/PCCy9w+PBhJk+eTPfu3bUuqXzo1w9cbIdMIUTRqKrK6tWrefvttzl58iTPPPMMr732GqGhoSXy/KZcOwdSLSSkmsmyOnsRFEUpMOWgU5T82/2NCg1DfajvossVr8e1NnN2Ae3atWPw4MGcO3fuuvNRrqp69eqsXLmSN998k1dffZXdu3czceLE/HPHxVWYTBASonUVQoibkJCQwPjx4/n5559p3bo1X3/9dYlPDwd56Wlyix8PRPqSYraTnGPjfI6dbJsDm6piuHS6YkVfPRG+BsJ89C61JXJRyMjBv6Snp3PXXXcxadIknnnmGa3LuSnffvsto0aNol69enz66adUrVpV65KEEKJEnTt3jnfffZdFixZRp04dxo8fT4sWLbQuq9yTcHAV3bt3x2Aw8O2332pdyk1LSEjgxRdfJCMjg1mzZvHoo49qXVKZyMrKwtfXF52ufMzvCSGKJicnh9mzZ/Pxxx/j6+vLiBEj6NWrFwaDDIiXBHnnvIq89a8mN1j73rBhQ9atW8e9995L7969mTZtmtsvd/z777/p3Lkzq1atKjfLUoUQheNwOFiyZAmPPPIIH330Ec8++yw7duzgmWeekWBQgiQcXEXHjh257bbb2L17t9allIiQkBC++eYbhg0bxvvvv0/fvn1JS0vTuqxSsWvXLjp06EB2djZ169aVI66FcCO7du2iU6dODB48mEaNGrFlyxZGjx4tS7dLgUwreJgffviBgQMHEhgYyLx582jQoIHWJZWYxYsX89prr9G4cWPmzZtXYh3KQght/f3330yaNIkVK1bQsGFDxo8fz0MPPaR1WW5NRg48TMuWLVm3bh0VKlTgscce47vvvtO6pJvmcDh49913GTJkCF27diUuLk6CgRBuICMjg3feeYdmzZrxv//9jw8//JDVq1dLMCgDMnLgoSwWC6NHj2b+/Pn07NmTd955B29v1ztT/EaysrIYPHgw69atY+zYsfTr10+mEoQo5+x2OwsWLGDy5MlkZmYyYMAABgwYgJ+fa55g6I4kHHi4uLg43njjDerUqcOnn35KtWrVtC6p0E6fPk3fvn05duwYs2bNIioqSuuShBA3adu2bYwfP56kpCS6du3KqFGjqFSpktZleRyZVvBwMTExrFy5kvT0dNq1a8fmzZu1LqlQ9uzZQ/v27UlPT2fFihUSDIQo5/766y/69u1LTEwMAQEBrFq1ihkzZkgw0IiEA8Fdd93FunXruP/++3n66ad5//33sdvtWpd1TcuWLePJJ5+kevXqrF69mnr16mldkhCimNLS0hgzZgwtW7bkjz/+4JNPPmHZsmXce++9Wpfm0WRaQeRzOBzMmDGDKVOm0KJFCz7++GMqVKigdVn5HA4HU6dOZerUqXTr1o333ntPtoUWopyyWq189dVXfPDBB9jtdoYMGcKLL75YLnuf3JGEg6vZt895vG+1apCWBn36aF1Rmdq6dSsvv/wy/v7+fPrpp9x9991al0ROTg6vvvoq8fHxjBo1igEDBkjjoRDlkKqqbNy4kQkTJnDs2DF69erF66+/TkREhNalicvItMK/mUwwfDgMGAANGjh/BudRv/HxMGuWtvWVgebNm7N+/XrCw8Pp3LkzsbGxmu40ePbsWbp06cLGjRv57LPPGDhwoAQDIcqhpKQkYmJi6Nu3L1WqVGHDhg1MmTJFgoELknDwb1u3QvXqzpEDcIaE+HioUQM6dYKgoH9+58aqVKnCsmXL6NWrFyNGjGDYsGGYzeYyr+P333+nffv2JCcns2LFCqKjo8u8BiHEzUlOTub1118nKiqKM2fO8NVXX7FgwQLpF3JhEg7+LTgY7rkHmjVzhoTjx51TC5efs7Bvn1bVlSkvLy/effddpk+fzvLly+nUqRPHjh0rs+uvXLmSLl26UKVKFdasWUP9+vXL7NpCiJtnsViYOXMmTZs2JT4+ngkTJrB582aioqJk9M/FSTj4t2bNIDXVOVoQHw8nTjh7DlJTnSMGCQlaV1jmnnrqKVatWkV2djbR0dFs2LChVK+nqirTpk2jf//+REdHs3jxYipWrFiq1xRClBxVVVmxYgXNmzdnypQp9OjRg507d/L8889jNBq1Lk8UgjQkFpbJ5JxSmDULOnZ0jip4GJPJxJAhQ1i/fj2vvPIKw4cPR6/Xl+g1zGYzQ4cOZfny5YwcOZIhQ4bINwwhypG9e/cybtw4fv31V6Kiohg7diy1atXSuixRRHK+ZWGYTBAb61y9UK2aRwYDgKCgID7//HNmzZrFBx98QL169ejUqRM6XckMQGVlZdGzZ0/279/P3Llz6dSpU4k8rxCi9J0+fZp33nmHpUuXUq9ePRYuXMgjjzyidVmimGTkQBRLcnIyYWFhJRYMwLmPwZo1a7j11ltp2LBhiT2vEKL0ZGVlMWvWLGbPnk1AQAAjR46kR48eJT6qKMqWhAPhUlRVlWkEIcoBh8PBokWL+O9//8vFixfp168fgwcPJjAwUOvSRAmQaQXhUiQYCOH6fv75Z8aNG8e+ffvo3Lkzb731FrfeeqvWZYkSJKsViuDYsWPs3LkTh8OhdSlCCFHmjh07xgsvvMCTTz6JwWBgxYoVfPLJJxIM3JCEgyLIyMiga9eu7NixQ+tShBCizJhMJiZOnEiLFi3Yu3cvM2fOZOXKldx3331alyZKiUwrFMFdd91F5cqVWbt2rXThCiHcns1mY/78+bz33nv555u89NJL+Pr6al2aKGUyclAEiqLQrl071q5dq+lZAy5r3z7nPhDx8c6ln0KIcuvHH38kKiqKUaNGERUVxY4dOxg6dKgEAw8h4aCI2rdvz+nTpzlw4IDWpbiWax1YFR8P7doVvG9srHO3SQkQQricP//8kz59+tCrVy8qVKjA2rVrmTZtGpGRkVqXJsqQhIMievDBBwkKCmLt2rVal+JarnZgFTgPqwoJ+ed+eb9v1sx5e3x8WVYphLiG1NRU3nrrLVq1asVff/3FvHnzWLJkCQ0aNNC6NKEBCQdFZDQaiYqKYs2aNVqX4lqudmDV1ezb988Ok8HB8NtvZVWhEOIqrFYrc+bM4eGHH2bx4sWMGjWKLVu20KFDB1la7MEkHBRDu3btSEpK4sSJE1qX4jqudmDVtaSnl11dQoirUlWVtWvX0qJFCyZOnEiXLl3YsWMHL7/8Ml5eXlqXJzQmqxWK4dFHH8XLy4t169bx4osval2O6xg9+sb3adDgn1GF9HTnaIMQokwdOHCAcePGsWPHDh599FG++OIL6tatq3VZwoXIyEExBAQE0Lx5c+k7KIxt25yjCHm9Bc2aOZsV826Xw5WEKDPnzp1j2LBhtG3bluTkZGJjY/n2228lGIgryNkKxfTtt98yYsQIEhISCA0N1bocIYS4JrPZzJw5c5gxYwbe3t4MHz6cPn36YDQatS5NuCgZOSimqKgoVFVlw4YNWpcihBBXpaoqy5Yto1mzZkydOpVnnnmGnTt38uyzz0owENcl4aCYIiIiaNy4MevWrdO6FE2V1MCT3W4HYNeuXbLBlBAlYPfu3XTu3JkBAwbQsGFDtmzZwtixYwkKCtK6NFEOSDi4CdHR0fz444/k5ORoXYomEhMT+eGHHzh58iRWq/WmnktRFBYtWsTjjz/Oyy+/TGZmZglVKYRnOXnyJC+//DKPPfYYFouFxYsX89lnn1GjRg2tSxPliISDm9C+fXvMZjNbt27VupQy98UXX9CuXTs+//xzgoODb3qIUqfT0a1bN+bOncumTZvo2LEjf/75ZwlVK4T7y8zM5L///S/NmjVj586dTJs2jTVr1vDwww9rXZoohyQc3ITbbruN22+/3aNWLdhsNkaNGsVbb73F888/z1dffUVgYGCJPX+nTp3yN5jq0KEDK1euLLHnFsId2e12vvvuOx555BHmzJnDyy+/zPbt24mJiUGv12tdniinJBzcpOjoaNavX4/NZtO6lFKXnp5O7969iY2N5b333mP8+PGl8uZTu3ZtVq9eTevWrenfvz/jx4+/6WkLIdzVhAkTeO2112jatCk//fQTI0aMwN/fX+uyRDkn4eAmRUdHc/HiRX799VetSylVR48epVOnTuzbt48FCxbQu3fvUr2ev78/s2fPZuLEiXz++ed069aNc+fOleo1hSiPIiIiWLlyJR9//DFVqlTRuhzhJmSfg5vkcDho3Lgxjz/+OOPHj9e6nFKxfft2XnjhBSIiIvj666/LvLFp165d9OvXD4fDwZw5c3jooYfK9PpCuKq8t285A0GUNBk5uEk6nY527dqxbt06t1yCFxsbS8+ePbnnnnuIj4/XpOP5/vvvZ/369dx+++1069aNTz75xC3/XQtRVIqiSDAQpULCQQmIjo7m+PHj/PHHH1qXUmJsNhtjx45lxIgRPP3003zzzTearo+OiIhgwYIF9O/fn//85z/069ePjIwMzeoRolTs2wezZjm3G4+N1boa4cEkHJSApk2bEhgY6DarFkwmE//3f//HF198wTvvvMOkSZMwGLQ/o8tgMDB69Gg+++yz/CNlDx48qHVZQpQMkwmGD4cBA5wHlJlMztvj451nkcyapW19wqNIOCgBRqORli1bukU4OH78OJ07d+bXX3/l22+/5f/+7/+0LukK7du3Z+3atRiNRjp06MCyZcu0LkmIm7d1K1Sv7gwC4AwJx487Dyhr1gyqVfvnRFMhSpmEgxLSvn179u3bx+nTp7Uupdh+/vlnOnTogNVqZdWqVTRr1kzrkq6pZs2axMfH0759ewYMGMDo0aNluaMo34KDnUeYN2vmDAnHjzv//ttvEBPjDAnVq2tdpfAQEg5KSMuWLTEajeX2rIUFCxYQExPDnXfeyapVq6hVq5bWJd2Qn58fM2bMYNKkSXzzzTc8+eSTnD17VuuyhCieZs0gNdU5jRAf7wwDJpMzMAwaBN984+xJEKIMyFLGEtSrVy9sNhsLFy7UupRCs9vtvPPOO8yePZs+ffowadKkcnla2+7du+nXrx9Wq5XZs2fTtGlTrUsS4ubFxhYcSVi1yjndIEQpk5GDEtSuXTt+/vln0tPTtS6lUDIzM3nuueeYM2cOEydOZPLkyeUyGAA0btyY9evXc8cddxATE8PHH38syx2Fy7pw4ULh7ti5szMQbNvmHDXo06d0CxPiEhk5KEFnz56lUaNGzJw5kyeffFLrcq7r77//pm/fvpw6dYpPPvmEli1bal1SibDb7bz33ntMnz6d6OhoPvzwQzmiVriMnJwcZs2axcaNG/PPEBHCFcnIQQm65ZZbuPfee11+1cKuXbvo0KEDOTk5rFy50m2CAYBer+eNN97gyy+/ZMeOHURHR5OUlKR1WcLDORwOFi9eTNOmTZk+fTqPPvqojGwJlybhoIS1a9eOzZs3Y7FYtC7lqhYvXsxTTz3F7bffzqpVq6hTp47WJZWKtm3bsnbtWnx9fenYsSNLlizRuiThoXbt2kWnTp0YMmQI9913H1u3bmXkyJGys6FwaRIOSlh0dDTZ2dn89NNPWpdSgMPh4N1332XIkCF07dqVuLg4QkNDtS6rVNWoUYP4+Hgee+wxBg8ezKhRo8jNzdW6LOEhTpw4Qf/+/Xn88cdxOBx8//33zJ07l+qyHFGUA9JzUMJUVeWRRx7h4Ycf5r333tO6HACysrIYPHgw69atY+zYsfTr18+jvrWoqkpsbCyjR4+mQYMGzJ07l8qVK2tdlnBTGRkZTJ8+nU8//ZQKFSowatQounbtik4n38VE+SH/t5YwRVFo374969atw263a10Op0+f5oknnmDbtm18+eWX9O/f36OCATj/mzz99NMsX76cs2fP0rZtW7bl7UInRAmx2+3ExsbStGlTPvvsMwYPHsz27dvp1q2bBANR7sj/saWgXbt2XLhwgb1792pax549e2jfvj3p6emsWLGCqKgoTevR2j333MP69eu566676NmzJ9OnT8fhcGhdlnAD27Zto23btowYMYJHH32U7du389prr+Hn56d1aUIUi4SDUtCoUSPCw8M1XbWwbNkynnzySapXr87q1aupV6+eZrW4ktDQUObPn88rr7zCf//7X5599llMeQfcCFFEf/31F3379iUmJoaAgABWr17N9OnTqVSpktalCXFTJByUAr1eT9u2bVmzZk2ZL1dyOBy89957DBgwgMcff5zFixcTHh5epjW4Or1ez+uvv87XX3/N//73P9q1a8eBAwe0LkuUI2lpaYwZM4aWLVvyxx9/MGfOHJYtW8Y999yjdWlClAgJB6UkOjqao0ePcvjw4TK7Zk5ODi+99BIffvghb731Fh9++CFeXl5ldv3ypk2bNqxbt46AgAA6depUrra9FtqwWq3MmzePJk2aEBcXx8iRI9m6dSuPPfaYx/XyCPcm4aCUNGvWDD8/vzKbWjh79ixdunRh8+bNfPbZZwwcOFDerAqhevXqrFy5kieeeIJXX32VkSNHynJHcQVVVdmwYQMtW7Zk/PjxdO7cme3btzNw4EC8vb21Lk+IEifhoJR4e3vTsmXLMjml8ffff6d9+/ZcuHCB5cuXEx0dXerXdCc+Pj5MmzaN999/n7i4OB5//HFOnjypdVnCRSQlJRETE0Pfvn2pWrUqGzZsYPLkyURERGhdmhClRsJBKYqOjmbPnj2cO3eu1K6xcuVKunTpQpUqVVi9ejX169cvtWu5u169erFixQpSU1Np27YtP/74o9YlCQ0lJyfz+uuvExUVxZkzZ/j666/57rvvpLlXeATZBKkUpaWl0aBBA96e9A7tu/XkfI6N5Bw7WTYHdlVFryj4G3RE+Oqp6GsgzEePvpBTAaqq8uGHH/Lee+/RpUsXpk6dKsObJSQtLY1Bgwbxww8/8Nprr/Hqq6/KOnUPYrFYmDt3LtOnT8doNDJ8+HCefvrpcntiqRDFIeGgFJly7bz18ZeEN2xCYHgkDlVFpyg4LvtXnvezTlHwNyo0DPWhfqg3QV76az6v2Wxm6NChLF++nJEjRzJkyBDpLyhhDoeDadOmMXXqVFq1asWMGTMICQnRuixRilRVZeXKlbz99tucPXuWZ599lqFDh8p/d+GRJByUAovdwfYz2SSkWjDnWsnNtRDo749BUa76Ia6qKg7A5lBBAb2i0DDUm6aV/PDWF/zGeu7cOZ577jmSkpKYPn06nTp1KqNX5Zl++OEHBg4cSGBgIPPmzaNBgwZalyRKwd69exk3bhy//vorbdu2ZezYsdSsWVPrsoTQjIyVlrATGVa+OZTO3hQzqgo+Bj252VnYrbnX/HavKAp6RcFbr8NLUVBV2JtiJvZQOicyrPn3279/Px06dOD06dMsW7ZMgkEZyGsqrVChAo899hjfffed1iWJEnT69GkGDRpEx44dycrKYuHChXz55ZcSDITHk5GDEpSQYmbTqSwcqopRUdBdCgMpqSno9XpCgkMK/VwOVcV6abqhdRV/Tu/6kYEDB1KnTh2+/PJLIiMjS+lViKuxWCyMGTOG2NhYevbsyTvvvCM9HuVYVlYWs2bNYvbs2QQGBjJy5EhiYmLQ6689nSeEJ5FwUEISUsxsOukMBl66gtMHmVmZZGdlE1ExAoXC9waoqkquQ8VqzWXDjInU9nXw4Ycf4uvrWxovQRRCXFwcb7zxBnXq1OHTTz+lWrVqWpckisDhcLBo0SL++9//cvHiRfr378/gwYMJCAjQujQhXIqEgxJwIsPKkqMmHI4rgwGA1WYlJSWFChUq4O1V+G+bKiomkwk7OryMBnrcEU6NIPm2qrX9+/fzwgsvkJ6ezscff0yrVq20LkkUws8//8y4cePYt28fnTt35q233uLWW2/VuiwhXJL0HNwki93B+pOZVx0xyGM0GNDr9VgslkI/r8Nh52JqKmazGV8vI0ZvbzadysZil1MEtXbXXXexbt067r//fp5++mnef/99lzieW1zdsWPHeOGFF3jyyScxGAysWLGCTz75RIKBENchIwc3afPJTPammAv0GFxNRoYJs8VCeHj4DacWrDYraWlpoKqEVKiA0WDM70G4N8yHVlVlCNQVOBwOZsyYwZQpU2jRogUff/wxFSpU0LoscYnJZOKjjz5i3rx5hIeH89Zbb/HEE0/InhVCFIKEg5tgyrXz+R9pqCoYddf/wM+15pKamkpYWBhGw7U3U7FYLKSlp2EwGAgJCUGv+6dByupQURR47o6Q6+6DIMrW1q1befnll/Hz82PevHncfffdWpfk0Ww2G/Pnz+e9994jJyeHQYMG8dJLL0mvjhBFIBH6JhxItWBXVQyF6DE0Go3odDosZvM17qGSlZ3FxbSLeHt7E1ohtEAwADAoYFdVDqQWfnpClL7mzZuzfv16IiIi6Ny5M7GxsWV+VLdw+uGHH2jTpg2jRo0iKiqKHTt2MHToUAkGQhSRhINisqsqCalmUCnU7oQKCt7e3piv0negopJuMpGRkUGAvz/BwcFXfU5FUUCFhFQzdvnwcSlVqlRh2bJl9OrVixEjRjBs2DDM1wyCoqQdOnSI3r1707t3b0JDQ1m7di3Tpk2TJb9CFJOEg2JKMdvJsqoYbjCdcDlvb29sNhs2uy3/Nofq4OLFi5jNZoKDgwkICLxuT4JBp5BlVUkxSwOcq/Hy8uLdd99l+vTpLF++nE6dOnHs2DGty3JrqampjBo1itatW3PkyBHmzZvHkiVLZCdLIW6ShINiOp9jc56JcIP7Hd69k/1b1rErfiHe3t4oisJ3419lV/xCbHYbKSkp2Gw2KlSogK/PjYc+dTj3P0jOsd3wvkIbTz31FKtWrSI7O5vo6Gg2bNigdUlux2q18sknn/Dwww+zZMkSRo0axZYtW+jQoYOcMyJECZBwUEzJOXZ01zgrIU/q6b/xCwym8u13snXBZ86pBS8vIm6ry/kTR0lNSUWnKISFheFl9CrUdZVL1zyfIyMHrqxevXqsXbuWhx56iL59+zJ58mRZ7lgCVFVlzZo1tGjRgrfffpsuXbqwY8cOXn75Zby8CvdnSAhxYxIOiinL5ihwuuLVpJ45SeU6d7J/63pqNWoCgLePDzUaP4xXcChGLyMVQq9sPLwRh6qSbZP9DlxdUFAQn3/+OaNGjWLGjBn06tWLlJQUrcsqt/bv30+3bt14/vnnqVGjBps2beLdd98lLCxM69KEcDsSDoqpMA2BtRs7A8G+H9dwV4t2gLPvwGg0cutdjbBYLKSmpLDuixnsWreM3RtWYrVZUdUbf/DbpCGxXNDpdAwaNIgFCxaQmJhIu3bt2LNnj9ZllSvnzp1j6NChtGvXjgsXLjB//ny+/fZb6tatq3VpQrgtCQfFpC/kvGZOponTfybmBwWdoiP7/Glq3dmA4OBglk56jYZtH6dG46Zs/XYuKSkpnDt/nuQLyVxMu0hGZgY55hxyrbk4LgsNBplXLVceeeQR1q9fT6VKlejSpQtffvmlLHe8AbPZzIcffkjTpk1Zv349kyZNYuPGjbRs2VLr0oRwewatCyiv/A266+6ImOfi6ZOEViq4TauiKBiNXiQfTSQwJIyQ4BAunj7Jq5+vwGa3OVc0XPrLYjaTddlctV6vx8vXnz0//0rq1mTq1KlDnTp1ZGe+cqBSpUosXbqU8ePHM2rUKHbv3s2UKVNkDf6/qKrKsmXLmDRpEsnJyTz//PO8+uqrBAUFaV2aEB5DwkExRfjqcagq6g32OfAJCCzw8/4t6/KnGE4d2k/qmb+5ePokAMunTeCJYeOv2EFRRcVms2G32bDZ7Th0Og78/BNzF3+V3+QWHh6eHxRuv/126tSpQ926dQkLC5PubRdiNBqZNGkSjRs35vXXXycxMZF58+Zx2223aV2aS9i9ezfjxo1jz549tG/fnjFjxlCjRg2tyxLC40g4KKaKvgZ0ioIDuF47YWjlW6nfPIpd8QvxvbRyIU9OZobztjrO204d2s/pQ4n5P+dRUDAajBgNRuyqil2F6e+Mp8KUcRw5coRDhw5x6NAh/vzzT37++Wfmz5+P1WoFICQkJD80XP5XZGSkhAYNPfnkk9x555288MILREdHM336dNq1a6d1WZo5efIkb7/9NitWrOCuu+5i8eLFPPzww1qXJYTHknBQTGE+evyNCpm5DvT663/IRvcbftXbQytVLTDl4BsYTOqZv68IB5ezOVQCvHSE+ejRKwp169a9ojHLZrNx/Pjx/NBw6NAh9u7dy6JFi/JPhgwMDCwwypD3V+XKleVgmjJyxx13sGbNGoYOHcqzzz7LwIEDGTlyJAaD5/yxzMzMZMaMGcyZM4eQkBCmTZvGU089hV7//+3df3DUdX7H8ed3d5Psr5A0QCSQHyUklKJwCIcOh3IqUj0HHZ3qWWa4qldE0CkzBx1u9PwRlGqt1NHeH2CB0dY6N+jcH6XhD7Bc5/BXqZ6O+KMmiAgmgUAS2exmd7M/vp/+sYTz6yYQSEKyy+sxkz+yu+z3mxmSvPL5vD/vt2aHiIwmDV4agveOR3m3PUrhOfodDCQW6eY3G37Bz5/bDsA/Lb+JB7e8gS/Y/96qMYaEMfzoMj8LJvnP+3rpdJpvvvmGgwcPOoLDwYMHiUajAPj9/qzAUF9fT1VVlX5gjxBjDJs3b+bpp59mwYIFbN68mQkTJoz2bY2odDrNjh07ePbZZ+nu7mb16tU89NBDBAKB0b41EUHhYEjOZyrjQD79/W5i4RCxSJiyisoz9Qj9GampjLZt09bWlhUYmpubCYfDQOYIZl1dXdb2RE1NzSX1l+5Ievfdd1m1ahUej4etW7cyb9680b6lEfH222/T0NDA559/zh133MEjjzzClClTRvu2ROQ7FA6G6HctET7qjFNgWYM6vXChbGNIGsOV473cUBkcset8lzGG9vZ2R2hobm6mqamJUCgEZArspk2blrVFUVtbS0HBwKOppX/t7e2sXLmSjz76iIaGBu677768qQ05fPgwGzZsYM+ePcybN48NGzYwd+7c0b4tEemHwsEQ9aZt/r05xKlE+oK3F86lbzuhtNDN8uklFLlHtybAGENHR0fWKkNzczMdHR1A5sjl1KlTs1Yapk2bRlFR0aje/1iXTCbZuHEjW7du5fbbb2fTpk34/ee/jTRWhEIhnn/+eV5++WUmTZrEo48+yq233po3oUckHykcDIOj4SS/PdyNbRsKXcMbEIwxJGyDy2Xxl1PHUV08tv8a7+rqyqppaG5upr29Hch0DKyurnYEhjlz5lBXVzfKdz727Ny5k7Vr11JVVcX27dupra0d7Vs6L8lkkldffZVNmzaRTCZZs2YN999/P16vd7RvTUTOQeFgmBzojLO3pQfbDF9AOBMMLIvFlQFmj8/dH6rd3d39hobW1lbmzp1LY2PjaN/imNTc3MyKFSs4fvw4L7zwArfccst5v0faZEZ8n4ilOBlL05OySRuD27IIeFxM9Lkp93nOnIAZKmMMe/fu5cknn+TQoUMsW7aM9evXU15ePuT3FpGLQ+FgGB3ojLO3NRMQhlqD0Fdj4LIsFk/J7WBwNpFIhLa2NqZPn5795CefwFtvQXU1nDoFy5df9PsbCyKRCGvXrqWxsZHVq1fz8MMPD6oItDuR5rOuXg50xelJmsyIcctyDAzr+9xlWQQKLGaXebm8rOiCC16/+OILGhoa2LdvH9dccw0NDQ3MnDnw0VwRGZsUDobZ0XCSN1sinEqkcWHhsc7eQfH7jDGkDNhkagyWVAbH/FbCiOjuhrvugt274cgR2LULHnwQGhvh17/OPN6nv8fyjDGGrVu38tRTTzF//ny2bNky4F/ivWmbd45FOdDVmxkQZsDjsnDR//9FYww2mR4aWJm5IbPLilhY4R90fUtHRwfPPfccr732GjU1NTzxxBMsWbJEdQUiOUrhYASMxg/nvNPYCDt3ws9+llk5qKn543N33w07djhf399jZI5pfv311wQCAcrLy3P+l9X+/ft54IEHsCyLl156iauuusrx/NFwkj0tEUIXKZwmEgm2bdvGiy++iGVZrFu3jnvvvVcnVURynA6oj4Ait4sbKoP8sNznWNZNmUyfgu8v6xpjsCyLYKFryMu6eaOkBObMgWuvzXx+5IgzIAySMYZXXnmFbdu2MW7cuH5bSVdUVORMaLj66qvZvXs3q1at4s477+Sxxx5jxYoVWJY1LNtalmVRYIFt4FQizW8Pd/e7rWWMYdeuXWzcuJHW1lbuuece1q1bpwFgInlCKwcXQV9B2MlYihOxNNGUTcoYPJaF3+Oi3Odm4jAWhOWNjRszAQEyYaEvKJzHyoExhq6uLj744IOsJk/xeByAQCCQNbRq+vTpVFZWjtlW0slkkmeeeYYtW7Zw22238fPH/oF3OtIXpSD2448/pqGhgf3793PjjTfy+OOP67SJSJ5ROJDccx7hYCC2bdPS0tJvr4aenh4AvF5vv10hq6urx0xXyMbGRp79l3/jL375j3j9Abxu14gdpb2+JMnLzz/DG2+8wYwZM2hoaGDRokXDdi0RGTsUDiS3vPUWrF8Pv/oVLF068GMXyBjDsWPHskJDU1MT3d3dQKYrZF1dXdYMiqlTp170vfbetM32T0/SFUvQ2xOhpKQEb9HwnmyxbZtoIkln6xH+6+/XsHbN37Js2bIxE5BEZPgpHIgMgjGGkydPZq0yNDU10dXVBYDH4+m3K2Rtbe2IdYXsa9/tAcLhbuLxOAG/n2BxMRZDW0EwGOLxOJFIBGPAVzyOOeOL+Elt2fDcvIiMWQoHIkPU2dnZ76TL73aFrKmpyQoNdXV1+Hy+C75u9uAvQzQaIxwJU1BQQElJCW7XhRW2JpIJwuEwyWQSr9dLcTCIbblHZPCXiIw9CgciIyQUCvXbFbKtrQ3InAyoqqrKKoasr68nGDz3cK2BRoYnkglCoRDGGEpLSyksKBz0PafTKcKRCPF4nIKCAoqLi8/8+6GODBeR3KFwIHKRhcNhvvzyy6wtiqNHj555zeTJk7NWGurr6ykpKQEyJ2C2/d+3RBJ2v70wbDvNqVCIZCJJsDhIwO+Hs2wz2Mamp6eHaDSKy+UiGAzi9XqztiZ60zbBQhcr/vxPdLJGJI8pHIiMEdFolEOHDmWtNBw5cgTbtgG47LLLqK+vZ8YPf0TghrtxuywKPR5cVnZAMBg+eft3hDpPku6Ns+iuv8ZlufjNhl9QN28B85f+FIMhFoudriswBAIBAv7AgCce0saQNrB8egnlPhUkiuQrfXeLjBF+v59Zs2Yxa9Ysx+O9vb189dVXzpqG453MTKbo7QkDmboGj8fzxw+3m9CJY0won8TEyhr+9ZcruWLxUkpLS5nyZ1fQ2XaU3kQv4XCYVCqFz+cjGAyes0bBBaSM4WQspXAgkse0ciCSg/67tYcPO2K4jU0qlTrzkU6lSKXTGGM4+skf+NMfzOfD/9xBqL2V61esxbZtkuFTHPrwPWb8+CcUFhZSXFxMgWfwRzATtuHKCV6unxIYwa9QREbT2Gz/JiJn1ZOyMQY8bg/eIi/BQJDSklLGj59AeXk5EyZMYPa1iwn4/TS9s5f6BddhjMEYQzQaZcrMKyktLWX3Pz9JKh47r2vbxhBN2SP0lYnIWKB1QZEclD7Lgp+FhcftweP2EEt2c+LrZuZedzMGQzqdpv3zD/nBDbfwbVsLn+7bw5d/eA+AeE+Ym+5fx6K/+ptzXj+lBUeRvKZwIJKDBntS4Nu2FsoqqgBnaLCw6DrWwqP/8T/4guMAeL/xdeYv/emg3tejkwoieU3hQCQHBTyuQU1d9AaLHZ9/+vvdXPHjmwCom7fgzOPvN77OFdfdPKhru04PDBOR/KVwIJKDJvrc2MZgDGcdtFQ2uYrLFy3h/cbX8RWXMLl+ZtZrutq+IRYJn1lBOJu+uoVynzokiuQzhQORHFTu8+CyLGzgXL+mb175d2d9/n8bd1A3b+GgrmuTCSMTdYxRJK9pbVAkB433ugkUWKTsoRcGfrbvTcoqKgf12pRtCBRYjPdq5UAknykciOQgt2Uxu8wLVmapfyi8wWJ840rO+TpjDFgwu8yr1skieU5NkERyVPZUxpGVtI2mMopcIrRyIJKjxhW6mV1WhI3BHuGMbxuDjWF2WZGCgcglQOFAJIctrPBTWugmefoUwUgwxpA0htJCNwsrNKpZ5FKgcCCSw4rcLpZUBnFZFgl7+AOCMYaEbXBZFksqg/2OhxaR/KPvdJEcV11cwOIpgWEPCN8NBounBKguHvxwJhHJbTqsLJIHZo/3ArC3tYeEMRTAoDooDsQ+vZXgcmWCQd/7i8ilQacVRPLI0XCSN1sinEqkcWHhsc7eQfH7jDGkDNhkagyWVAa1YiByCVI4EMkzvWmbd45FOdDVm5neaMDjsnDRf1AwxmCTaXCE1ddDoYiFFX7VGIhcohQORPJUdyLNZ129HOiK05PM1CJYluU49uiyrDOPBwoyjZUu13FFkUuewoFInksbQ2c8zclYihOxNNGUTcoYPKenK5b73Ez0eRjvdavzoYgACgciIiLyPdpQFBEREQeFAxEREXFQOBAREREHhQMRERFxUDgQERERB4UDERERcVA4EBEREQeFAxEREXFQOBAREREHhQMRERFxUDgQERERB4UDERERcVA4EBEREQeFAxEREXFQOBAREREHhQMRERFxUDgQERERB4UDERERcVA4EBEREQeFAxEREXFQOBAREREHhQMRERFxUDgQERERB4UDERERcVA4EBEREQeFAxEREXFQOBAREREHhQMRERFxUDgQERERB4UDERERcVA4EBEREQeFAxEREXFQOBAREREHhQMRERFxUDgQERERh/8Hqb243be44m0AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Graph with 8 vertices and 12 edges.\n", + " - Features dimensions: [1, 0]\n", + " - There are 0 isolated nodes.\n", + "\n", + "\n", + "Dataset contains 5 samples.\n", + "\n", + "Providing more details about sample 1/5:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - The complex has 8 0-cells.\n", + " - The 0-cells have features dimension 1\n", + " - The complex has 28 1-cells.\n", + " - The 1-cells have features dimension 1\n", + " - The complex has 54 2-cells.\n", + " - The 2-cells have features dimension 1\n", + "\n", + "\n", + "Dataset contains 5 samples.\n", + "\n", + "Providing more details about sample 2/5:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Graph with 8 vertices and 12 edges.\n", + " - Features dimensions: [1, 0]\n", + " - There are 0 isolated nodes.\n", + "\n", + "\n", + "Dataset contains 5 samples.\n", + "\n", + "Providing more details about sample 2/5:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - The complex has 8 0-cells.\n", + " - The 0-cells have features dimension 1\n", + " - The complex has 28 1-cells.\n", + " - The 1-cells have features dimension 1\n", + " - The complex has 55 2-cells.\n", + " - The 2-cells have features dimension 1\n", + "\n", + "\n", + "Dataset contains 5 samples.\n", + "\n", + "Providing more details about sample 3/5:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Graph with 8 vertices and 12 edges.\n", + " - Features dimensions: [1, 0]\n", + " - There are 0 isolated nodes.\n", + "\n", + "\n", + "Dataset contains 5 samples.\n", + "\n", + "Providing more details about sample 3/5:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - The complex has 8 0-cells.\n", + " - The 0-cells have features dimension 1\n", + " - The complex has 28 1-cells.\n", + " - The 1-cells have features dimension 1\n", + " - The complex has 56 2-cells.\n", + " - The 2-cells have features dimension 1\n", + "\n", + "\n", + "Dataset contains 5 samples.\n", + "\n", + "Providing more details about sample 4/5:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Graph with 8 vertices and 12 edges.\n", + " - Features dimensions: [1, 0]\n", + " - There are 0 isolated nodes.\n", + "\n", + "\n", + "Dataset contains 5 samples.\n", + "\n", + "Providing more details about sample 4/5:\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgcAAAIbCAYAAAB/tT3bAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9e5wjV3nnj7/PqdKt1fee6e653zzj+21sE7AZLsEDycabbBKcfF8bOxAIdtZJNtmEtQMh12U3C7mxYTf5GXLb4CSAIckmJgRsA7YBg+0xxuPL+DLjmWHuM92tlloqSVV1zu+PktTqbnW3pNa1+7xfr/ZYUqnqqFSq+tTzPOfzCK21xmAwGAwGg6GAbPcADAaDwWAwdBZGHBgMBoPBYJiDEQcGg8FgMBjmYMSBwWAwGAyGORhxYDAYDAaDYQ5GHBgMBoPBYJiDEQcGg8FgMBjmYMSBwWAwGAyGORhxYGgK99xzD0NDQ0suc91113HnnXfOee6hhx5i165dCCG45557GjKWp59+GiFE1cvfeeedDA0NIYRg165d3HnnnRw5cqQhY1mK/fv389GPfrRp66+0v9sxjsW22ajvu1pqPS6azfx90I59YjAUMeLA0DY+8IEPcOutt5YeJxIJbr31Vu6//3601nzgAx9o6XiOHDnCrl27OHLkCPfffz9TU1Pce++9TE5O8rnPfa6lY2kG8/e3YXmKx+TQ0BC7du0yF2vDmsFu9wAMa5d3vvOdcx4/9NBDDA8Ps3fvXgAGBwd56KGHuPPOOzl8+HDTx3Prrbeyc+dOHnzwwdJzN998MzfffHPTt90KKu3vVu3bbuV973sf+/fv55Of/CRPPfVUKYp0//33t3toBkNTMeLAYAA+97nP8fTTT5sLpaHEkSNHSCQS3HHHHUAgFO+99172799PIpFgcHCwvQM0GJqISSsY2kZ5TvWee+7h1ltv5ciRIwghuPPOO7n11lvZv39/6TkhBIlEovT+Ym3Arl27+MQnPlF6PpFIsH//foQQXHfddTz00EPLjuUzn/kMe/fuZefOncsue+utt/KJT3yCT3ziE+zatau0/s997nNcd911pVqF+amIO++8k3vuuac07qGhoQXLTExMzPlcS4391ltvnVNDUMyhl9dHFPcrzN3fy+3bWsZRzkc/+tFSzcj8fX/PPfewa9cuhoaGqqp9WGr5xb4DaNxxsXPnTu699945z11//fUAPPXUU0u+d6n9sNj4lqNYx1PLcW0w1I02GJrA3XffrQcHB5dc5uabb9Z333136fH999+vd+7cOWeZSs9prfU73/lOffPNN+upqSl9+PBhPTg4qA8cOFBa7969e/Xhw4f11NSUfuc736mXO9T37t2r77jjjqo+W3H9O3fu1Pfff3/p+Xvvvbc0hgcffFADpcfF9w0ODuoHH3xQT01N6TvuuEMD+vDhw6XXgdLr73znOyt+9vJ9U76P7777br1z5079kY98pPRc+Rir2d/1jKPIHXfcoffu3asPHDigp6am9IMPPljadvH7Kv9Obr755jnbLB9bNctX+g4afVzMp/i9Tk1NrWg/LDa+8n1Q/vjBBx/UO3fuLG33wQcfnHNsGQyNxogDQ1Nopjg4fPjwghP0vffeq+++++7Sa8ULrtZaHzhwYNmLwM6dO+eMZblxDw4OLnmBKK6z/EI9//PO327x4lWkeCFajKmpqTmfde/evfojH/lI6SJafL04zlrEQS3jqDSWcor7f/7+Kgql+WOrdvn530Ezjov5VPoOy1lqPyw1vkrrLn88XwgaDM3GpBUMXcfTTz8NwI4dO0rh+XvuuYenn36ap59+msHBwarSA+Xs3LmztN4it956aynkvn///jmv3XzzzRVzzp/4xCe49dZbue6666qa/njzzTfPWa4YtgYYHh5e8r2Dg4Ps3bu3FF4+cuQId9xxR+nxZz/7WXbu3FlXbryWcUBQ3LjYfn/qqacqjuP666+fU/xZ6/Lzv4NmHBfl3Hrrrezdu5ePfOQjiy6z1H5YanzLcfPNNzM8PFw6FlfD7BlDZ2PEgaEr2bt3L1NTU3P+Kl1oqmX//v089NBDc/LuxSmVd99994LlK538r7vuOu6//37uvPNODhw4UJp1UQu1XshvvvlmHnzwQR566KHSxbIodB588MEFMxSaNY6lKN+njVy+0nfQ6OOiSHEmS7kwKNaXFP+q8Yaod3yDg4McPnyYe++9l8HBQW699daWe1EY1hZGHBi6jr179/L0009XvIjs3LmTRCJRs2nR3Xffzc6dO+uex37kyJHSBbmWqY8PPfQQN9xwQ13bBPjJn/xJHnroIR588MFSdOOd73wnDz30EA899NCCiEez2Lt376L7vRgdmf99PfXUUxU/e63Ll4+h0ccFzBZvzo8YHDhwAB2kZksicqn9sNT4quWOO+7g/vvv59577+Uzn/lM3esxGJbDiANDR7Nz587SheKhhx7iyJEj7Ny5kzvuuKM0uwGCmQIf/ehH2bt3L3v37uXWW28tnaTf9773VbWt+++/n89+9rPceuutpZP4008/XdUFpRh6L1afF6dGzucTn/hEad3F8RenytVD8WL0uc99riRK9u/fz2c+8xkSicSSQqXSvq2X+d9JcUz33HMPe/fu5eabb+Ztb3tb6bXinXilyEatyy82Blj5cXHrrbdyww038BM/8RMkEonSXz37YanxLUdxueL2H3zwwRWlSAyG5TDiwNA0EonEnLBrpSlzy1E8qe/YsWPOndu9997L3r17ue666xgaGuLee+8tXQgffvhhhoeHS1Pg7rzzzqpOpHv37uW1115jeHiY973vfQwNDZWmAS4XURgcHOTuu+8uTVMrRhDmh+dvvvlmfu/3fo8dO3Zw5MgRDhw4sOIQfvGCWfyMN998M08//fSyEYzF9m29FL+D/fv3l76Tn/zJnwQo7Y/rrruOHTt2MDw8zIEDBxZdV63Ll4+hUcfFkSNHShf2Yo1A8W+paYRL7YelxrcURXOuYr1CIpHgk5/85LLvMxjqRWitdbsHYTCsBfbv379sQZvBYDB0AiZyYDAYDAaDYQ5GHBgMBoPBYJiDEQcGg8FgMBjmYGoODAaDwWAwzMFEDgwGg8FgMMzBiAODwWAwGAxzMOLAYDAYDAbDHIw4MBgMBoPBMAcjDgwGg8FgMMzBiAODwWAwGAxzMOLAYDAYDAbDHIw4MBgMBoPBMAcjDgwGg8FgMMzBiAODwWAwGAxzMOLAYDAYDAbDHIw4MBgMBoPBMAcjDgwGg8FgMMzBiAODwWAwGAxzMOLAYDAYDAbDHIw4MBgMBoPBMAcjDgwGg8FgMMzBiAODwWAwGAxzMOLAYDAYDAbDHIw4MBgMBoPBMAcjDgwGg8FgMMzBiAODwWAwGAxzMOLAYDAYDAbDHIw4MBgMBoPBMAcjDgwGg8FgMMzBiAODwWAwGAxzMOLAYDAYDAbDHIw4MBgMBoPBMAcjDgwGg8FgMMzBiAODwWAwGAxzsNs9AIOhGfhaM5H1Oed4nHd80p7C1xpLCOK2ZH3MYjRmMxK1sIRo93ANBoOhozDiwLCqSOZ9np/M8exklrSrUVojhUBpXVqm+FgKQTwkuGo4yuXDEfrDVhtHbjAYDJ2D0LrsrGkwdCk5X/GN0xmenczhaw0abCmQgKgQGdBaowBPaRBgCcFVwxFu2tBDxDLZNoPBsLYx4sDQ9RxPuXz5xAzTeR+JwBaVBcFiaK3xNCg0g2GL/Zt72doXauKIDQaDobMx4sDQ1Tw7keXhk2mU1oSEQK6gfkBpjVtIN7xtU5yrRqINHKnBYDB0DyZ+auhanp3I8vCJNEppwisUBhDUIoSFQCnNwyfSPDuRbdBIDQaDobsw4sDQlRxPuaWIQViKmtIISyGEICyDgsWHT6Y5nnIbsl6DwWDoJow4MHQdOV/x5RMzDRcGRcoFwoMnZsj5qqHrNxgMhk7HiAND1/GN0xmm8z4h0XhhUEQIQUgIEnmfb5zONGUbBoPB0KkYcWDoKpJ5n2cnc0hWXmOwHFIIJIJnJ3Mk835Tt2UwGAydhBEHhq7i+YKPgd0iU0NbBG6Lz0/mWrNBg8Fg6ACMODB0Db7WPDuZBV2bj8FKEEKAhmcns4G5ksFgMKwBjDgwdA0TWZ+0q7Fla3sh2FKQdoNeDQaDwbAWMOLA0DWcc7ygJ8Iyy7164HGee+RLPPnAZ0vP/f3v/Jc5j2tBErgonne8ut5vMBgM3YYRB4au4bzjI5eZoTB56nv09A2wcfdlPPrpvyg9v+niK5g4dbyu7YrCNs85JnJgMBjWBkYcGLqGtKfmdFesxOTpE2zccxnPPfpldu19Q+n5y/bdzMDYRjT11Q0orcl4xu/AYDCsDYw4MHQN1RQEXnRdIAgOfu2LXPHmdwDgZB0SUwnGdl3JxPkJ/uoD/4lDB77FK999kgf+z//E9VyqaTHimYJEg8GwRrDbPQCDoVqsKmcoODNJTr3yAhdd9wayuSxOJsPEscNc9sa3oRRMnz3NZ37zFxnfdQn//v3/nWQihdYaIUFaEtu2Z/8su5TGsFs0Q8JgMBjajREHhq4hbsuqjI+mTp1geMMWsrksmXSakB0c5lprLGlx0zvfze7Xv7Vw0RdQTDZoDQq8nI+b89BaB6JBgB2L8d0nv0P621Ps2bOH3bt3E4/Hm/lxDQaDoW0YcWDoGtbHLJTW6GV8DqK9fSityKTThEMhXnjsIS6+8W3BxV4oTr/6AgLIpKZRGq59x48R6IRgnQIoqIWSaBBCcvJbr3Lg8cfJ+g4z2SRWD2zcvp5LLruE3bt3c/HFFxvRYDAYVgVCV5NsNRg6gHOOx30vT2OJpVMM2VyWL/7Z77Nu81ZivQOs27aHwfFNCIIogBQSIYJym/9z53/gpz/618R6+0viYAFSIixJ4m//Ae/8BJ7n4bounucF/++5ONmZBaLh4ksvZs+ePaU/IxoMBkO3YCIHhq5hJGoRDwlm8grLqnwhL6YS9r/3l5BC4iuF7wf6VwMvffMrnH71RW5+138GIYjG+0ifP01Pbx9KBREC5q1a2BZqJoM/mQgaMoVChEKhOctoPTpXNEx4vPS10zzzb6+Q9T/HTDaJ7NFs3BaIhosvvriUnujt7W3G7jIYDIa6MeLA0DVYQnDVcJRvns0UagHmXsWLwiAcCiGFBDRKzQ2MDYxtItrbh0YjEOTSKcYvuhQAqTWerxCIBVGE7MEXQS0+lXFZ0eC5eK6HN+nx8iNn+O6XXi2JBrsHxraOcMlll8yJNBjRYDAY2oVJKxi6imTe5y8PJdAaQmU2yguFAWit8DxdrDksCAJ46fGvIIDTrx5i7w/8GEPjm2c3oDW+UigNQkhEyAatmPqrz6Bm0g37HFrruaJhXnoinUtixQLRUIw07N69mz179tDX19ewcRgMBkMljDgwdB1fOTHDdyayhETQtjmXy5KeJwwAfN/HV4UgQJk4EGK2oFEKq+I2tNZ4SiMjYbLPPE/6a99swSdbXDRkc2mynsNMbhoZ1QsiDbt376a/v78lYzQYDKsfIw4MXUfOV9z38jSJvI92XTLpmQXCQKPxPBUUGswTBwhKUyIFolScWI4GCIXwpqZ47f/8NQM9PS3rBFmJiqLBd8lm54qG0S3DXHLZJXNqGoxoMBgMtWLEgaErOZ5y+czLE+RdF0v5c4QBgCqkFMqv51rrUq3hnOgBck6NQVEYCKWIPfwVMkeO8OqJC0R6eolGo839YDVSjWgQETUnPVFMURjRYDAYFsOIA0NX8tBDD/HprzzBRT/yrmCqoefOmWTg+T5KUZU4KI8elISB1sSeeJLI4cNorXFdl+PnJpiYcRkcHGxrFKEaqhUNxUjDnj17StEGIxoMBoMRB4au4+GHH+ZPPvL7vOna64hd8TpSF18PQoLnIdALUwoFSuKg8Fy526JEoqUE2w4iBk8+ReTw4Tnb9ZUimU53bBShGoqiYc60S9/FKRMNhBVjW4fnTLm8/vrrO14QGQyGxmHEgaGr+MpXvsL/+p8f5U3X7mVkeAQQ5IfGSF7yOvxYL2iFdl08Xy/wNNIaBLOzF8qjB9ghhLSQqRl6nniC0NmzFbffjVGEaigXDSXhUCYa/t83/h7Lqly8aTAYVh/G58DQNXz1q1/lY7/3Ed6897qSMAAIT51l+Il/Y2bXVTgbd6HtMNLSaN9b0psAKcEOBevxPeShF+k7+CLS9xZ9ixCCcDjMjo1jjKTTHDk5QSgW78ooQjmL+zQEomGBMxTAwYPw2GOwdSskEnDbbS0Zq8FgaD5GHBi6gq997Wv88f/4nwuEQRHpu/S/fABx6ACnezYRu+IarHgv2CIIGUiBKMbItEIIidYKnZlBHXoG9dJB3JkU8dhmZBV3yJaUDPb2cuXOSBBFmJpaNVGEcoqiYcGnSibh/e+HL30Jjh2DL3wheP6BB4J/n3kGPvSh4P/vuw+2bYNHHpl9zlAXvtZMZH3OOR7nHZ+0p/C1xhKCuC1ZH7MYjdmMRK2qu5gaDJUw4sDQ8TzyyCP80X//Pd60iDAoZ+bcOaZOHiX5xJPYwyOERkcJrx9F9vSAtNCeg8xm8M6fwT17ipgzjV0QAxrFTH6K/uhIVd0fV2sUoSoefTS44BcjB3fdFQiDgQHYtw+OHw9EwQ//cLD8vn3wqU8FQmLbttJqtNZMTU0hhGBoaKhNH6bzSeZ9np/M8exklrSrUVojhUCVZYWLj6UQxEOBm+jlwxH6wyYdZKgdIw4MHc2jjz7KH/y3/86br7uedcsIA8/3mUxkg7t3pfAunMe7cB6H5wFQSqHdJLGIjRCglSZvW9hRGUQWhCTrzxDzeomEqr/Ar5UowhwGBuCaa4KLPgQX/VtumX396FG4/Xbo7w/SDffdF4iIMmEAgIZDz77Kh37lt1C2y/qtw+y5eHepEPLiiy9e06Ih5yu+cTrDs5M5fK1Bgy0FISHKWo7PUug6zkxe8c2zGb59zuGq4Qg3beghYi308zAYFsOIA0PH8thjj/H7v/th3rx3eWEA4DgZMo5CLOJ6KITA13LOY9f3S30WECA0zLiT2NY4lqz+ZDo/inD45ATh1RxF2LcvSBMU0wgDA7MX/sceg6uugiuvnF3+ttvg7rsXRA4QEI/FuXTbNUER5IzH8W8neOnRr5J1v0Amn0TZHuu3DLLnkj1zplwODw+37vO2geMply+fmGE67yMRhIVAyKV/A0IILMCyRFAvouE7E1leS7ns39zL1r7Qku83GIqY2QqGjuTrX/86H/nt3w2EwcjywgDg+MnTnD6Tw7Iqa16tNW4uRW9k9iSrlKIvFsYuK8TTStEXWkdPuG/RLs5LsRpnNPz+fb+BrObO8+DB2ShC8f+LqYY//dNgmbvuKi2utebgk4f4v3/82QWrcl0X3/dLUy5dz8XJZci6GZx8Ct92Wbd5kIsvDZwgiwZPq0E0PDuR5eGTaZTWJZvwelFa4xbSDW/bFOeqkVUqWA0NxUQODB3H17/+dT7yO7UJg7ybJzGdr2iFXEQIgUYSBF5nDZDyrsK2gqLFYDnJjJsgYveU6hFqYTVGEaq6hzh2DO64I0gffPzjQfHhm94U1Cc88ECQavjoRxesd7F1F2dPzN9vc6ZbZoqRhkf4vPtFMvkUvp1n3eYh9lyyu9R74uKLL2ZkZKTej99Snp3I8vCJQBiEpVixsJRCEAbySvPwiaB5mBEIhuUwkQNDR/GNb3yD3/ut3+Yte2+oWhgATCeneenVKaRcWu/mchn6wh6imDLQwX/649HZ5wiiB1Grr+rixMVYLVGED338lxlaN9Dw9fqez9e//CT//KkvrXxdhShDydzJc3HyGbL5TEk0jGyaG2nYs2cP69ata8AnaQzHUy6ffy2JUo0RBuVorckrjZSCH9/Rb1IMhiUxkQNDx/DNb36T3/ut3+bNe28o3OVVe2LUTEym0bqK5YUsmCEVH4NSGt/3sWV5PUJ9xYkLNrdKogjPPP48b/53r68utVADlm1x8IkXGrMuy8KyrAX7do5ocDxOPDHNq19/lH/I/1tJNAxvGODiy/YsiDS0UsjlfMWXT8w0LGIwHyEEYQl5rXnwxAy37RkwRYqGRTGRA0NH8Pjjj/M/fuO3eFMhlSCqFgaQzWU59MpZXFcue0L1PJeodLCs8iiBJmxb9ETDpdQCAEpjywiD0bGaihMXoxhF+N65CS50WRQhHAnx3rv/Ixddtj2Y9aFWdtqQUiKk4F8/8xUe/qfHGjTK2iiJhlL/CZdsPoNTiDR4Vq4kGopRhmKkoRnf2/xW5M2iWINw7UiU79/c27TtGLobIw4Mbedb3/oW//1Dv8mb9l7PyMgIsgZhADAxOcGrr6UWLUQsx/c9QnqGUKhs2UVSC7Dy4sSKYyj0aOjGKMKWnRvZcfFWQpGVhaTTyTSHnnmVxGSyQSNrHEuKBjeNL3MMjvdyyeUXz4k0rEQ0JPM+f3kogdYQWmZGQiNwVWAv/p5LBo0PgqEiRhwY2sq3v/1tfvfXP8RbCqmEWoWBQvPK4ZMkEn5V3v++7yNVimh4rpCoNGsheEEjsBiObayrOHExujmKsFZZIBp8j2wuTdbNks6n8ESWoQ19CyIN69evX/a7ffxMhm+ezQTTFVtwHGityWvNjWM9vGG8p+nbM3QfRhwY2kZJGFx7PSPr1tUsDAAyToZDr5zH95dPKQAo5YOXIha253ZsXCy1QBA9iNn99EWGGx7u7eYogiGgomjIpsl6s6KhPNJw8cUXs3v3bkZHRwveG5o/f3GKmbxqaQ1Azlf0hiU/e+mQsVo2LMCIA0NbeOKJJ/idD/46b772etbVKQwAzp4/z9Hj6apSCjDrktgTmSsOlkotoIM7raHIBiKhSF3jXAoTRVidVExP5DIl0eDiMDjey+U3vZHBt98WTDm0rUJ9y8Lv/9UDj5OdSeKkprnhlp8A4O9/579w0XVvKD2uaXxa42u4bc8AozFTm26YizkiDC3nySef5Lc/8MFguuIKhIFSPhOT2ZoupMGdmkAz7/S7yKyF4mtCQ9qdwrZGG1KcOH9M4XCY7RvHGDZRhFVDafYEi8yeKIiGmcQAvZ7GdzJkUGg0Ukps28K2bSzbJnnuND19/Qxv2Mxf3f2zJTGw6eIrmDh1vK7xScDTmvOOZ8SBYQFmHouhpTz11FP81q99YMXCAIKUQibjL2l8VJlCp8YFzwaGSFSqxJeCvHLIuplKb20IxR4NV+3cSNzymJqaqs58yNBVFKdb9vX2MTQ0xNDO7YjC87YVwpYhJBa+B1nHJZ3M8L2XDxEeHuOJf/sntlyxl3QmTS6f49I3vo2RjVvqGoco1Decc/zGfkDDqsDIRUPLOHDgAL91z681RBgAJJMZfBX4yFeLEAK1xGtzei3Mfx1B2p0iYscaWpw4fwwmirC2kD2xoM5FFB06i+6dBbRm17U3orXmpW88zJtu/3lyTp6szpFMpFh/0RUAPPdIYCTlpKYZ2rCFi657w7LbVlqT8Rb7RRjWMiZyYGgJBw4c4Dfvvoc3X9sYYeB5LpOJXB1RA0BICkUG854PTpa+v8idlBQoPNL56TmtcpuBiSKsIZYTmiIQDrnMDGePvMSOK78PKcJYMsaFo6/ROzLGmWOHefXA41zx5ndwwy0/waOf/vOqN++Z48pQASMODE3n6aef5kP/9b8GwmD9yoUBQCaTwXEUso78vxBWJWkQvLZUaoHAOdHxk7ieW/N2a6U8irBn0xCpxCTZbLbp2zW0mMXEKIDWaKVQvmbqzBkGxzYjRASBRXDoa0JWiBce/xrR3llDo1hvP68eeLyqzdum+NVQASMODE3lO9/5Dr/+/vfz1r3f1zBhADCVSC92/V4WgaxYcwBzUwuLvBkBpN1JfNWacKyJIqxuVMaZFaOakiDQvkZrC4ggRYRozyDB0acRUvHiNx7ikjd8PwDTZ05jRWf9CmJ9A2RnljeYkkLQY5vLgGEhpubA0DSeeeYZPvirjRcGuXyORNJDyvry/tKy8PUiynipWQulFRSLEx3ikXhdY6gVU4uwenHPXSAqBFop0AKEBVizs3AK/wyNb2bP67+f7z70OaK9A4ztuLi0DikEnuvi+R52YVqvk5pecrvFjpijMeOQaFiIEQeGpvDMM8/wgV/5Vd7aoOLDcpyMQy6vlu3AuDhiyTvvSm2cKy2TdieJ2NGmFSdWYjaKEAl8EaamjC9CF6K1JpfLkck4RF4+T99+QEYRxWDU/K+z4MPxtp/5z6AFWltolQ9e0DC0YQvZmSTJ6SRDw0OlosSlUASic72ZxmiogIknGRrOd7/7XX7tV36Vt+y9nnXr1jfYVVBzodoOjEuwVJp32dQCzBYnusmmFyfOx9QidCdaa7LZLJMTU0ydBy+zi5h1M3byCtSMQoZkIAoWEQbSUoX1SLRWzBbVCrZfdQNnDr8ImmAbp7+37GwFT2niIcFI1EQODAsxDomGhvLss89y9y//F96y93pG161H1jObYAmcbGCX7HnV2SVXQikf5aaIz3dJnLPMIr0Wyik4Jw5HNhIOhesay0ox7oqdTVEQZDIO0h8iZG/FkmNIKxoU0xa+q943rqP3TevRuXl1LBWEAVqilYfALyyikRYc+uZX0Foxk5xi3YZNXPWWH1hyXKa3gmEpTDzJ0DAOHjzIPb/8K00TBgCpdIZ8XtfkbTAfISSaCi6J5ctUkVooOifOuFMM2qNNbbO7GKYWofPQWuNkHbJOHrwhwvYeeqxxZDgyRxCUk3k2Qe+N6xAhgXbLihPLhAFagC5Ow/WZPXqD5S+96W3BK74flC0sgafBEoLLhxtvB25YHZi0gqEhPPfcc7z/F3+JN++9rmnCQGnF5KTD4pf06tG6+J/KVJVagEJxYoZsPrPiMa0EM6OhvWityWQyTE5MkbhgobKXEJP7icduIhLZgR3uQVpWRWEAoJIemWemCmZIBNd7USYMKEQNoJBSKEeUJRiCY8FzfXL5XOVtaY1Cc9VwxLRrNiyKiRwYVszzzz/P+3/xl3jr9Tc0TRgAOI5Dpk5vgwXoZdZRzayF0qKBc2K4xcWJC8ZhoggtRWuN4zg4Tg7pryNkX0rUHsOSEWSZ42G1pL52nsiuPqzBEDrvI+V8YVBYn1YLHTzLwmBCCGzLJpVKER4Jz1lWa42rNYNhi5s2mHSCYXFM5MCwIp5//nl+9Rf+c1NTCUWSyTSuq1ecUxdCLO6SWL7cMoZIJaTAxyXThuLESpgoQvNQSpHJZJiYmCJxPozOXkYs9AP0xG4kEtlGKBRDWpVTB8uh84rEF06C0shI2e+olE6gEMmq5K8x9/uVUmJhkU6nZ5fQmrzSSCHYv7m3pe2hDd2HiRwY6uaFF16YFQbrmysMPN9nMlFbB8al0GLpmgNYvtfC3GUljpckasXbVpw4dzwmitAolO/jZLNkHQ9Lr8e2dtFjjyEjoaDOpFHHpFJ4J86hvpXGuvFSCNngeqV0QrBQ5Wk287VfsZFT1skSjUaxpFUSBm/bFGdr3xKFtgYDZraCoU5efPFFfumun+f7997QdGEAkJpJceiVCeaYw6wA183RY+WCu7wlqGrWwuzChGQPg7H2FCcuhpnRUDu+75N1smSdPJJxwtZmpD2KlHaQMmigbwcEwsCyZxgeTWBZErFnE+L1l4CQ6LwuBQa0yleY6ahBKKwKx7KvFD6K+MBASRhcNWIEomF5jDgw1MyLL77IL//8z/PWa69ndP1o04UBwPGTpzl9JodlNSbY5XkeUZmpeEItRytN2LboiYYXn7UwZ3lFf2iUnhY5J9aCrxRJE0VYFN/3cZwsOcfFKggCYa/HkjaiCYKgiFYK204xNJoszMIJWop7w2NYb7osqEFQGp33QbsLolhLiQNtWSghiOo8t16x2UQMDFVjkk6Gmjh06FDLhUHezZOYztfXgXERhBBV9UaoetZCcflCcaKvlnBZahOmFmEhvu8zMzPDxPkEqck+pHc1PZEfpCd2A6HoRmw7jJBlxYANRiuFHZ6ZKwzQKB+cl8OkP3WS/NNJUCAiEhEJQSVBq8uqDqSEUAjCYQTgPvMM//yr76Mnt7SdssFQjokcGKrm0KFD/PJdd/GWFgoDgOnkNC+9OrUCu+SF+L6PVCmi4eXXWVNqgeCEH7eH6I0MdGz4fi1HEXzfJ+NkyGc1th7HtjdjyXVIyyoIgdaglCIUTjG0rlwYAFqRmV6H7w6XyhlUDKxdk8RfvwfRF0NIgVZzPTgEhWJdrSGTgZdegldeRaeSHD1xAmu7xZ/+6Z+27PMZuhtTkGioipdeeolfvusu3txiYQCaiQbYJc+neA5dtiqRKg2R5qxbkvGmiVg9HVGcWIm11qOhXBBYbCBsX0o81HpBUEQpRTicZHh9au72tcZ1onj5Qcqfzp47jXX8RdyvP4c1Ooi1YQh7wzCiN4qwLHzXIWJlsaaTMDkBiQSiMMtGSIvxdet44sAzPPbYY+zbt6/Fn9bQjZjIgWFZXn75ZX7hjp/jrdddz9j69cjl7NcaSDaX5dArZ3Hd+u2SK6GUwndTxCPW8sXmBae6/ni06guJVoqwjDMYa3RvicazWqMInufhOA65LITFBmxrE1KOtE0QFFG+TzSaZHDdzLxxaJQHM1PbkGJWVCqlyEw8Q1QmF50Z4XopBrYqenoWq3XRnD9/gadOP8O/feWLq+Y7NjQPU3NgWJJXXnmFX7zzP7VFGACk02lyuZV7G8wnCL9WuU4RuMr5S3Vrmv8WKcmrNDnPqXOErWM11SK4rksqleL8+STpxDCWdwO9kR8gGr2WUGQcKxRquzCIxaYrCANAa7IzIwjmRps8L4flJ5acMimwljk+BUODQ2yJbeVP/uRP6v8AhjWDEQeGRXnllVf4hTt+jrdcu7ctwkChuTDVGLvkSgQBgeoLDasyRJr3npkOLU6cTzd3enRdl2QyycS5GTLTI1je6+iL/CCx6NWEImNYtt1WQVDE9z1iPQkG1qUrCoNiOqFcA2jATZ/Bspf7DUjUMsemHbLZNraBf/30v/Hyyy/X9RkMaweTVjBU5NVXX+Wu993BW669jvHR0ZYLA4CME3Rg9P3GphSK5LIz9EVUdReOOlILUChODA3RG+7c4sT5dIMvguu6OI6Dm7MIiU3Y9kakHEJK2RFCYD6+7xGPT9M/nKkw66ZyOgEKKYXz3yYayi+5ftdziYxOMTw8vPRAtObkmTMc9Y/xT//8T42xIjesSsyRYVjA4cOH+fk77myrMABIzTTGLnlRaimqrCO1AIXiRHcaz/NqHFz7KI8iXNxBUQTXzZNMJrlwLo2THMVWryceeTvR6JWEwus7JkIwH9/z6O1NMFBRGBTaOldIJwC4uRQhsXxqSiDx81Xc5wnBuuEhQtNRPv3pT1c1fsPapPN+SYa2EgiDO3jzNXvbKgyU8pmYbJxdckWErDarECxeR2oBARpFypvqiL4LtWBJyUCbaxHy+TzTyWkunMuQTY5jqRvpjb6daOSKjhYERXzPo69/iv4hp7IY1RqvQjoheEnjZk5VdXcvAOVW991EIlF2b9rG//mDP+X8+fNVvcew9jBpBUOJI0eOcNf73sebrioIA9m+DoMz6RSHXp5AN8guuRLVuiSWqDO1AEF6YSAyRizUnZ3wfKVIpdO82oIZDfl8Hifr4GUjhK3NWHIj0urr2JTBYvieR//gFL392UWiVIunE6Bg4Xz+60SqmA3r+z4qdJ4NO0eopkZHKZ+jJ04gt0n+7M/+bPkNGNYc3fNLMzSV1157rSAMrm27MABIJjP4iqZGDoQIcrrVv6G+1ELwVkE63x3FiZVodhQhn8szPT3NhXNZcqmNhNWbiEffRiRyGaHIUMdHCObjeS79g5NLCIOl0wkAeecCtqzueBFCgG9VfTzLgvfB0aeP8+ijj1b1HsPawkQODBw9epQ73vNe3nL1tYyPjrVdGHiey6FXTpNxaGrBVC0uiUVq7bUw972KuD1Mb6S/4wr8aqFRUYRcLofjOKh8DyFrM7a1ASF7kdIq9DLoTjzPZWBoit6+/OLTD7XGdSI4M5srHuNKKdITzxITiSp7emg8Jlm/o6dqJ0/QnL9wgadOGe8Dw0K6R4obmkKnCQOATCaD46imV1ILAVpBlW0TCu+prdfC3PdKMl6iq4oTK7GSKEI2lyWRSDBxziU/s5UIb6En+lYikUuww4OFCEE3C4M8g0OTSwuDYu+E9Piix7jvuVj+ZNUCVAAoWWNkSjA0MMS2nm38r//1v2p4n2EtYMTBGiaRSPDVhx7mP/7If+gYYQAwlUjXVPNXP6L2S/wKUgvF4sS0m+i64sT5VDujQWtNNhsIgsmzHt7MNsK8lXjsLUQjF2OHB7peEBQpCoN4n7ukYdFy6QQNuM4Z7GW9DcoQArBRNR6Xdshmy+g4X/rsl3nppZdqeq9hdWPSCmsUrTWe52FJibQsTr52jK98/p/qu+g1kFw+x6GXz5J3RdND71prvFySeLQKC+Xy960gtRC8XzEQGScWitX83k5kji9CyqV/oB/XdclkHLTXR9jaGqQMrCiWsOraZ52O5+UZGp6kp9dbUhgsl06AgrfBhSeJWtma/L9cL03fpjy9fX21Dd54HxgqYI6CNYoQglAohLSCaMHGbVu4/HXXt3lU4GQccnnVwpx8sQNTDe9YQWoh2GKxrXMNxZAdTHAshdm2YZQ9G4fIJSVeegcxeTPx2JuJRi7CDvdiWfaqFQbDI1UIgyrSCQBePk2IdB3GoFZ9x5TxPjBUwIgDQ4AQbL9kT5sHobnQhA6MiyGEoK7L80pSCwBS4Kkcjpvq2h4GEGgqXylc10OpKCFrCyNDr+PaS29i09hWhIxiWaszUlDE93KMjEwQiy8nDJZPJxSXcZ3qvA3ms3x/hcUx3geG+RhxYACCC2VPb29bx+BkHVJpr7VhTSGpqSKx+LZ6DJHK3y8kaTeB53dXcWK5INAqhi23EI1cSTi8G2mtQ4gQUgo2jlpcvM3Hlnn0KomQzEXje1mG100SjfvLCoOlzI7KUVpB/lydNRgSP1//vh7o7+eK8cv5zd/8zbrXYVg9GHFgKNHu6XWpdIZ8vol2yRWQwqorObDS1MJsceJ0xxcnFgWB5/lo1YMttxKNXE0ofBHSGgERYmEMXNATs7hku2T9YB7f86hHhHUmGs/LMTI6SbSnCmFQZToBIJ+ZxBZuXaMKXBLreisQeB9sMN4HhgJGHBg6AqUVk5PN68C4OLLmmgNg5akFgrbOWT+F6+XqXkezmCsI4thyK5HwVYTCu5DWMAiLar6rVRdF0BrfzzEyOkUkqqoQBtWlEyAoRPSd01griJwpD1YiwmI9PVy+ZQ+/+Wu/1RH9NAztw4gDQ0fgOA6ZFngbzEdaFn7dN/8rSy0U15FyJzuiOHE2ZVAUBNsKgmBnTYJgIaskilAUBusniEariRhQdToBQPseUk3UXaMhpABPrrCORTA0GHgffOxjH1vBegzdjhEHq4GDB+FP/xQeeADuu6/do6mLZLLJHRgXRdR9bV9xagFKxYlZN11XAGOlaK3LBEEvIbmNaKQoCIZWIAgW0tVRBK1Rfo51YxNEoro6YVBDOkEDWecs1bb5qIRAgLbwvZXtV9s23gcGIw66n2QS3v9+uOsuuPLK4DEEQuEd76i8/N13t3aMy+D5PpOJJndgXAJVf+hgxakFCIoTZ9zJlvVdKAoCz1Wg+7Gt7QVBsAPRYEGwkC6MImiN8rOMjE8QjlQrDKpPJ0DgfaGzK0spzLokrrzIta+vjyu3XM77f+X9tfUfMawajDjodh59FLZtg8ceCx7fdVfw7y23wOBg5eUTiVaNriocJ0PGURV73TcbIQimM7YxtVAsTpzJN6+tcyAIfDzXR6t+bLmDcOQq7NB2pBxssiBYSHkUIdTJUQSt0TrLug2TNQmDWtIJAG4+g83Myr6COl0SF1vXuuEhwskYf//3f7/y9Rm6DiMOup2BAbjmGti3LxAJx44tvuwDDwSiocOYmp5BNbkD42IIIdH12CiX3t+A1EJhHFl/pqHFiUVB4LoK9CAhayfhyNWEwtuR1kBBjLVzhkoQRbi4U6MISqO1w8joBKGwpvp9VX06AYJaD9c5jbVSPwgBIFF+Y4RWJBJlz6Zt/Okf/pnxPliDGHHQ7ezbB5OTwYX/gQfg+PHKyx08GKQdOoy8mycxnW9L1KCI1tQ3YwEallpABOf2mRUWJ6oyQaD1ILa1k0jkKuzQVoTsBEGwkI6MIiiNxmHd2CShCNSyz2pJJwTLK8ifbUhLaoGF18D919/fz5XjV/Abv/EbDVunoTuovletoXP50IeqW+7gweDv2LGOEQuO45DN6vY2fdIrOykXUwu2pVfmBigFbqE4sSfcV3UEW2mN1grlS2xrCNsaBLv4/s4SAotTjCJozlzIc3bSxrJbm+oooTTgMDI2iR2mtjGUpROqvdbnnSlCIg804jdgoRpYuyKlxfi6EZ78zrM88sgjvPnNb27Yug2djYkcrFYeeyyIIjzwQPD4yiuDlEIiMVu0OA+tW33HpplooV1yJYQQhbvpFUxHbFBqIViXZMZNLFucqEo1BBrBECHrokKEYAtC9hdSNN0iDGZpdxRBKw0iw8j4BKFahUGN6QQIvA28FXobzB2CWJFLYiViPT1cuuUifusDv228D9YQpiujAQhCoedPneZf72td45VsLsuhV87iurKt7oy5XIbecHW2zaMbx9m0fSu2PfcuT2lNNGQHvQTK0FozPTnF8VePVH2h00oRtfroj44gy/aL0jqoHNcWlhzGsgZBxLssQlA9SmnOXPBbFkXQSiPkDCNjiUK75Nq2p7XCmV6H7w5XHfXxPY/cxDcIh2ofb+X1+dB7nrHN6xqzwtJ6PV46eoRLb76EX/u1X2voug2diUkrGEoceeFQS7eXTqfJ5TSW1d4Lm5QW6KWnf0VjMd77X3+BnZfsrmsbmdQMf/fxezl1dJGakDKKxYkxr5eQHQkEgbKw7RHs0CBCxItL1jWWbqEYRRjs8zl22ifvhRqSl6+EVgppZRgZTWDVIQyCVsy1pRMAcs5ZLKloZBBXuY0/LizbZstY4H3woz/6o1x88cUN34ahszBphS6lkQEfrTWHvvNdDj39TMPWuRwKzYWpdtglL0QIa9kphD/+3p9i++6ddW8j2hPjtl++C8uuQo8HFZKk3TSCEcL2HiLRK7HsTQjRS7DP2r/fWkPzZzQEwiDNyOhUfcKgkE7I1pBOgCCloLJnGpdSoOCS6IumpAj7egPvg1/9L79qvA/WACZy0IWcP3+e//S+O3jnD93Chg0bsFZQzOfm85w7cRInnWngCJcn6zik037L7ZIrIYRYUhzYoRBX3nAt0qp/P0vLItoTY9dlF/Pys88vXEBpNBqtI1hiGEsM4es4ihFsGal7u6uFZkURtFJIuyAMrPpmcgSzE9ZVPTuhiOc6WP40rOC4mk9ghGShfIVlN/i3JQTrh4c5ffgcf/d3f8dtt93W2PUbOgojDrqM8+fP866f+ilef8nlzJy/wGuT0+0eUl2kZgK75HanFIosdS/aN9BPKLTypLBSiqH1ZbnggiCACJIRpBgG2TNnPMlcknX2OtZOpGApymY0TOQ5O7GyWgStFJY9w/Boom5hUG86IfA2OEvIbvT3KgKXRN+vLkpVI+FIhIs2buXP/uj/x9vf/nZGR0cbvg1DZ9D+2zZD1Vy4cIF333Ybr7/kcjaOj2NbDapiajFK+UxMts8ueT5CgFIsqhAaFt3QQe8IrRRahRBsxBJXYMmrEXIziJ4Fb/GURzqfbsz2VwlSCjauX9mMBq0Utp1amTCoM50AQfGizp1peOQs+E1ZTbXiNt4HawMjDrqEojB43Z7LuloYAGScDJmM31bjo7kIfF2/S2It2xEMYIkrC4JgU0VBMJ90bgbV8mmmnU5Zj4ah2moRtFKEwimGRpMrEAa1mx2V42aThEQTpgUKAKsxFsqLUPQ+OPHMKb72ta81bTuG9tIpZ2fDEkxMTPDu22/nht2XsmlDdwsDgGQyg98mu+RKCCGgVV4Loh9ErKa3KDTJ3DQdZS3cIYgaowhKKUKRJIPrkoWUVp3fe1k6odbDWGuF65xqWr2N0BZ+gyyUF6PoffDbH/htHMdp6rYM7cGIgw5nYmKCd912G9dfdPGqEAae5zKZyHVQ1CAgaL5U48W3ha2ys26WvOc2dRvdS3VRBKUUkcg0w+tSK4oYrCSdAKB8hfDOBzMLmoAWsqEuiZURDA8OsS2+nY997GNN3pahHXTWGdowh8nJSd71U7dz/UUXs3nDhq4XBgCZTAbHUR0xS6FIEMGo0SVxqVbZDzwAH/5ww8eZMtGDJVkqiqB8n2hkmqF1Myue5bCSdAJAzrmALZp38RZaBu24m0zR++DL9z/IoUOt9UgxNJ/OOUMb5jA5OclP/8fbuH73nlUjDACmEukVdTduGrVGMiq1yn7ggaBL5i23wPBww6MJrvJIu62dctp9LIwi+L5HLDbNYAOEwUrSCVD0NjhdiFw0ByEEfr5pq59D0fvg/b/yfuN9sMowUxk7kKmpKd71U7dz3a49bB5fPcIgl8+RSHrtbbK0GEKi9SKB5kpiprxVNgTNrMrbYR89Crff3vBhpnMpYnYM2WFpmU6jGEUY7PU5n5ohHM+UhEHvQIyxTUN1+AAU0gkz6xHYTE/mOX00U1M2yvfySDXVUG+DSuhWZaCM98GqxYiDDqMoDPbu3M2WjRuw7dUhDACcjEMur5Cy8w47S9poym63dBA+VlqhqVBAuG8fPPLIbGOrgYEgkgBBNOGqq5rS9VJpTTKXZDA6gPE+WJ6hoTzjGxUTSUkiAz/2vjex56rNDSuGnZ7M87d/8DLfe3X56aYayDtnCDXZ20MIgfJlUEPTgqLfovfBvX/8CeN9sIowtx8dRCKR4N23/TTX7ti16oQBaC60uQPjUggRiAGtNL7vo3UvQmzFltdgsYht8oc+FEQLbrllNoJw8CBMT8NttwX/3wSyrkPeW7oXhEETjTnE4jmkJVg/GOHW97yB3Vduaugsmb6BEO/9jUuJxJaPBGil0NnTTa+3EQJQFn4TpzPOp7+/n8vHLjPeB6sIIw46hEQiwe0/9VNcs30HmzduXGXCAJysQypdXefDVqK1Rikf31co1Y8Q27DltVhiD5L1CBFCiyrjxseOwR13wKc+Be94R9AeuxxR+4SIxUjlTXHi4gTCINqTLwVXpC3ZfuXWhh9/0hJEYhaXXj+47LJuboaQaMW0PwFa4rewBqDc++CrX/1qy7ZraB6dF99dg0xPT/PTt93G3u272LxxE6FVJgwAUukM+Xxn2CVrrdFa4fvge314agTPGyYUzSJZWHgwM+2gfIVcrohs2zZ4/PFFX5ZSkppqTEGh67tkXIee0PImSmsJrTU98QyRmDvne4z2RrFDzTnd+Z5i3YbosuNynVNEWiCOhQgslJtphFSJovfB73zwd3j9V15PLFabn4ehs+is27g1SFEYXLN9J5s3rE5hoLRicrK9HRiLEQLX9clm+8g4O0hn9uK4l+L5o2hh4y1yo5XPebzy/MkVGctorfE9n8PPn6p7HfOZySUb2p2z21lMGEBzDbc0QQRhKZRSCPdc07wN5lBwSfT9VqeeZr0P/viP/7jF2zY0GiMO2kgymeSnb7+dq7fuYMv4poY09+lEHMch0wZvg1lB4JHN9pF2djKT2UvWvRjPXw/CnnMNUWrx8X3uk4+QnAqKznzPx6vhr1jL8PlPPEY+27gycqW18T4oEAiDdEVh0AnkMxPYooUXa223ZWph0fvg4c9/hRdffLHl2zc0DpNWaBPJZJLbb7uNqzdvZ8uG1SsMAJLJ1nVgLKUMlMZ1h1D+CK4/UBICi91ACsBf4hqbmJjho7/6afZcuZlN29cVugFWMR6lcVJZXnn2FJlU4730M65DzI6vyohT9WjivWnCUa8jhYFSCi97mlgrxbGQTbdQXoy+3j4u33wp7/+V9/MvX/iXjqszMlSHEQdtYI4w2LhxVQsDz/eZTDS3A2MQIVAoJfC8QXx/GM8fRAtrSUEwHx8LWDxP67k+Lzx9jBeePrbgNcuSXHT5JkbG++eeDDXYlsXlN2yv+rNMnk1y9KUzqKXUShnJ/DQj9ggdeWVsOpp4X5pQuE5hcPBgMPV069aggLQJ8/R9z8XyJyDcOn+PwCWxtTUHsxuf9T7427/9W25vgt+HofkYcdBiisLgqi3b2LJhI6FQfRas3YLjZMg4CiEae2JcKAjW4akBNDK4RojarxVK1Xdx3bB1hDt//d8T74uilK48JaHKVQsEQgpmkg73/eGDXDg9vex7XN/FcR1ia644URHvy9QvDIoW2F/6UjDT5AtfCJ5/4AH4+MeD54sU/SyeeSaYwlolGnCdc9h2a4WbEAK/ja04it4Hn/jYJ3nHO95hvA+6EBPvaSGpVIqfvu02rtq8ja0bNq16YQAwNT2DalAHRq0DD4K8q8hmB8k4u0k715F1d+OpISgKgzpRqnYBIwS8955/R7Qn+C6lFEhLLvyT1f0VC9Zi8Qg/8fNvrXocqWxqjRUnKnpXEjGAyhbYEPhWDA7OLrcCW2ytFCp3ui2Oli1zSVyE/v5+Lh+/jA/VIKYMnYMRBy2iKAyu3LyNrRvXhjDIu3kS0/kVdWAsFwROdpCMs4eMcx1Z9yL8BgiCuduqfU1bdo0yMBRvuFe+ZUmGR/sY3TRY1fIKRSqXZG0UJwbCwA77K8uklFtgb9sWRA8qUW5ydfQoXH111Zvw8mlCzLQ+4yME2mugsUYdSGkxPjLCye+eNt4HXYgRBy0glUpx23/8Ka7YuHXNCAMIZilks7rmgqRZQaBxskOknT2kM9eRcy/CV4M0UhCUIyyx6HTGxRha19eEkcwyMNJb9bIZN4O76p0TGyQMILjgT07OdtI8fnzp5Wu0xS56G7SjIC9wSbRb0Lp5aYreB7/9wd/BcVphAGVoFKbmoMnMzMxw+0/9FFdt3saWTWtHGIBmoga75GINge9beN4wnhrB9/tAyJqKCldGIA6qnIgQvKPJA6t19cl8khF7mNVZnKjo7Z/BDqnGfbxqQ97zbbGrEAhaa8ifQ4Ra/12Iokuir2hvn7PA+2D79A7++I//mA9+8IPtHIyhBkzkoIkUhcGVmwJhEF4zwgCyuRzJGXfJu6ZihCCXFzjZdWScS0g715LzdqLUAEI0J0KwFH6dRYmdguvncdxVeIcmfHoHGiwMFuOxx4IoQrEIcTlbbKiYzck5E9iiPYl/ISiIg/ZGDqDgfTA6ZrwPugwTOWgSMzMz/PRtt3HZhi1rThgApNNpcrmF3gbFCIHnW8EMA38EX/VSuNdpUYRgcZQiONF3sUZI5VJE7VjToxqtQgifeH8a265fGOQyObTW1e2Tffvm2mAva4stSCXmigClFL5zhlC75vgLQXtcEucNQwoGhgcYGR+hZ6iPj3/sf/O//+zjxvugCzDioAmk02nedfvtXDq+mW2bN685YaDQXJiatUueTRnYeP46fG8YT5cJgnYOdh6+kizldVA1LZg/vxhKK1L5JP2Rfjpr79aOED69/TNY9sKeF7Xg5T3OHz/Pui3rGt98SQpeeHJyznPK95HeBITbt/+FtlAqv/yCTeLGf3cT17/tdcTipsdCN2LEQYMpCoNLxjatSWEAkHUc0mkf0ORyEl+N4Hkj+LqHThQERQSgGtFSeqn58zB3rnyd8+eXw8lniFk9Xe2c2ChhUOTpf3uat9z2FqLxKGqF7oGaoN5ESsET/+8IIc9BqWA6qgZyzllsq80hKNG+tMLr9n8f+374zW3ZtqExGHHQQDKZDO+6/XYuHt2wJoVB3s3jOA6JhEs6vQHXH8ZXnS0I5tMQcVA+f37r1mD+fHGu/L59QT77vvuCufTzn2tQhEEDqXyS4S4tThTCp29gBmk1RhgAzEzO8KV7v8SG3RsYGh8KLuQafDdGreVXWmucZJ7vvTDJ9DmH0WFBf1zxvbOKnCvRuTNY7Q6dawvfa4842PuW69uyXUPjMOKgQWQyGX7mXe8qCIMta0YY5N0cjpPFSYPnjuD5W5iYDpF13a4RBOUs1Xypasrnz0MQPbjlltnXjx6F22+fW/FefK6B5P08WTdLNNRdYV0pPXr70w0VBkXcnMvx545z/LnjoCGfGcB34yvfjoBoRHDRFs3ZCxlOnJ2CcIh2/gLa5ZIYCocYGBlo/YYNDcWIgwbgOA4/8+53s3NkdE1EDHL5HNmsQyYt8N0RXH8bWseRUqLQpJ1014mCIn4jRr5vHzzyyGzKYGAgiCRA5bnyNc6fr4VULknEjnZNcaIUHr0DaaRsvDCYgwaVjzRGGBQRQYxspC9FfPcAx0/M4HqircV37Sg5kA02BDO0ByMOVojjOLz7Xe9i5/B6dmzeTDgUafeQmoAml8/jZB2cGQvPH8Fzt6PpCWx/y04GeSdHzlVdKw4aEjmAyvUDlebK1zF/vhb8rilO1Ejpt04YKEHeGWzO+r1Jenoi7LkozNlzM5y/kMOyrNZPxREC5RdcErtEHBo6ByPxVsDqFgaaXC5LIpHg9OkZzp3pY2riMpzsNfj+dqTdj2XbiLK7Iq00yZnudugTUuLVYDlbdT+DSnPlq5g/3wj3Wyfv4LZ5StvSaKQVFB82XRgU8LL9aKzGbkuD56aRBLF8KQUbxvrYvXMAy1Io1doWykKA8K22uyQauhMTOaiTbDbLu9/9bnYOrWP7ptUiDDTZXC6wPc6E8L0RXH8nWseQ0kJaS59JlfJJZ72Ovj9dHhF0Z6xSNicmZqpbcLG58kvMnweYnkxXt/4l0GhS+RTDsSE6L3qgsSyPeH8aKal6eD39PfSN9JUaVdWwObQXws33o7UmNZElNZGtedSLodxJrPIPISDWE2LPRcMtjyIEZcCd4JJYoI3Tew21Y8RBHWSzWd71rnexc3CE7Zu3EAl3szDQOLkcWcfBSYfx/RFcbxcQrUoQlONkfTxfFU5K3Usts9yOv3qOZCJDb1+0oblW5SuSUxnOnZhqyPryXg7HyxKzO6k4sXZhEI6FufHHb2TdlnUNG8XU6TRf/ZtDpKdyK1uR1giVrPg5ilGEwf4ox04kW1KLIACU1fKIRUWqbY+dTMKHPxyk5fr72zdeg0kr1EopYjDQvcJAo3GyWSanJjl1MsP5M4NMTV5JNncVvtqKZfcWUgbVX+S1UqQyHp13Z1o7vl/D59aav/r9L5LLBqFk5Sv8FfwVT+RZJ89n/09jO9nNdFRb5/oiBm/4sTcwvGm4oSMZGO1h/89etrJDV4Obn0ayxIW4LIqwbjiE73nN7ZooBWgLrwMslKtuj33sGHz3u3DrrUGq7cMfbvlQDQEmclADuVyO97znPWzvH2L7lu4SBgpNLuuQcbLkMtFChOAiIIKUFpa9sou6rxSZrLsKpEFQrBYUcVW3/InXzvO7d/0NF1+1hZGx/qrvCC1LEprX5Un5momzSV578TR+rS0il8HXPjP5FH2RPtor4jSW7RLvSyOlqHoosb4Y67eub/hopCXoG4mxbnMvF75XZZqoAtqbqipd0NoogkT57XNJLFFpem9xBk85/f2zUYQHHpg7BdjQUow4qJJcLsd73v1utvYNsmPL1q4QBnMFQSxwKfTXoUUEKeSKBUEJDemMi9+CnjitoJ7pjJ7r8/yBozW9RwpBX7yn5m2thEw+Q08ojtW2JLTGtl16ahQGAH3DzW2P3b8+Vrc4UNpFqHT1sdiW1SJY+J1QkLjU9N5yis/ddx/88A+3bnyGBRhxUAW5XI73/szPsKULhIHSBUGQyZLLxvD8dXjeOhBhpJDIRgmC8m0qxUymA05ADUDQus6MSmmU8pEtvFBrNMnsNEM97ShO1IRCeXp6nSBlVePmay4+rJG616/Bz01Rz9ubHUUQWPhuh/w2a7EHf/RRU7DYZow4WIZ8Ps/73vteNvcOsKNDUwlKK7LZLBknS96J4XmjeP5wSRA0LEKwCJ7v4+S6fZbCLLpRXgdVkHd9opHW3sXn/BxZL0fUjrZwqwVh0OcgVmGlk/YS9WutJkYR2uWSWDXl7bGLKYRkcm4dgqEtGHGwBPl8np99z3vYEOtlx+YtRMKtPJkuTVEQpJ0s+Uwc3x/D84daJgiKaK1JZVxUa6antwSvVXW6AlzPIxppvaNmKpskEo+0yDlREwrn6OnNrj5hoMH3MljkWOkvoFlRBNViceDmXJSvqpu9M789NgR1Bx/9aHMGZ6gaIw4WoRgxGI/1snPLViKR9gsDpX2cbI5MJovrxPH8cVx/CCFCSNk6QTBnTEqRzjTEdLhjaGXkoB2pBSgUJ7oz9IWD1tnNQxMuCIOmaa42z5/381NzvQ1WQqOjCEKgvda6JCqlOHboKNsu2W6slLsY881VIJ/Pc8fP/ixj0Ti72iwMlPJJZ9KcvzDJ6ZM+E2fHSU5fS9a9HMU4th3Fsqy2eee7rk8238nue3VQ6BHRKvJtyglncmn8ps6B10SaLQyK8+fvuiuwnk4mg+cfeCD4mz8VLpmEu+9u3Pa1RqhEw/VVo9wVhQCUbLnXwdf+8Su4eRelVAdNnzXUgokczMN1Xe742Z9lNBxrmzBQysdxHDJOnnyuD8/biOcNIaSNlBK7DRGCSmilSaZdVk9CYRZf0RpXuTamFjSaVG6awaY4J2oi0RyxeLa5h0e17bGL0YRHH61oU10XGjw3WfA2aMKHbEAUQRB4Hfi+j7RaF506d+Icf/nhP+eK77uCDTs2EgqFanq/67kkMkmuvPoKIpHOq/NaC3S9OPC1ZiLrc87xOO/4pD2FrzWWEMRtyfqYxWjMZiRqYS3zo3Jdlzvf9z7Wh2Ls2rqtpcJAKZ+M45DJ5HFzffje5iBlIG2kFNihzrsAK6XIOKsrpRAg8H1BqEXn0nalFgCyXo6clyPS0OLEFgkDqL49NswWvf3zPzds88qdWva8slJWUovQTpfE5MQ03/zXb9T1XqV8jp88hdqouPeT9zZ4ZIZq6FpxkMz7PD+Z49nJLGlXo7RGCoEqC2EVH0shiIcEVw1HuXw4Qn944UnYdV1+7o47GLEi7NrWGmHgKx/HyZBJu+TzA/jeFjx/ECkDd8JOFATl5HIeec/vervkSigloMWphVbPWiiSzCVZb0dozJVcE4lmicVzrQkoVdseuwkdL7X2EHqmNZ+z3iiCFKBkZ3gd1ICUFmPrRnjq4LM8/PDDvO1tb2v3kNYcXScOcr7iG6czPDuZw9caNNhSEBKikHef+2PRGhQwk1d882yGb59zuGo4wk0beogUimVc1+U/3XknwzLMrm3biDZRGHi+TzYbCAI3N4intuF7A4guEQRFtNIkV4ldciU8RaANWnTib1dqAQKROpOfoXfFxYmaaMwh2pNv7WFRTXvs4nMHDwbRhZWKBQ1eLtHyoq36oggWfkfPZ6xMLBbj0s27+J0P/i5v+Oob6OlprWHYWqerChKPp1w+9fI035nIojWEhSBiSaySMFiIEAKrsFxYCLSG70xkue/laY6nXFzX5a6f+zmGRIidTRIGnu+Rmklx7twUZ08JJs5vI5W6jrx3MZp1WKEw0pJtKyqshyANsnq8DeajWjhjIdiebmtr3fSKixM1sZ42CINKVGqFfeWVQUohkZgtWpxPjYEi7Sfa81lr7NEgtIWqpZtYxyAYGhxiR/9O/uiP/qjdg1lzCN0lpaTPTmR5+GQapTUhIZAruJAqrXG1RgLfe/B+rBefYee2bcQaKAw838Vxsjhpj7w7iO+tw/P7SymDbhICC9CQnHE4M5Fr+3WgWYRlhpFev3Unfw2RcKht0QOAqB1lMDZIrR9aa01PPEMk5jZ1fw2MDrD/vfubtv6H/+oFTr2UWH5BDb6fRTuvtP93rMFx3CWjCJ7rEVp/gZF1jetk2UpmUim+eegp/vd9f8Kll17a7uGsGboicvDsRJaHT6RRShNeoTCAoBYhJMDJ5lj3xlvY/Mb9DREGnueSSiU5ezbBmVMhJi9sZ2bmOlx3D4h12F0YIaiE1qvHLnkxfN3in0YhtdBOsl6WnFdbk55WCQOA6XPTOCkHrRp7P6OVxnN9zh5eJKJQAeVOdUatTXkUYWSRKIIQqA7ovVQvvb29XLnlUu7+lbvxO6HD5Bqh48XB8ZRbihiEG3THrdEkk0m0m0NaFtnL30B+aKyudbnlguB0mMmJnaRn9uJ5u0GswwqFAiOQDjiPNArP88lkV29KAUC1WhzQ/tQCQDI3TbXx9UAYpFsiDIo88c9PoPxg7rzy1cr/lEYD3/jMqzV0wdSwErvkJiClYMNoZV8EAfjdbEUiBCPDQ8QycT71qU+1ezRrho5OK+R8xadenmY67xNeoq6gFjSa6elpBGBbFiDADmE5Mww/8UVkFb8i183jZB2ctMLND+Op9fh+H5YlEWJ1CYH5aK1JTGc5n1i9KQUArXw2DmZa+112QGoBoC/SRzzcu8xSmng8TSjqtfx4j/ZG2XzJZvpG+oJzgrLx/drnwmulSU1mOf7cBDOTuSrfBJ6bQuSOtsxxsFaU0pw7P8O588GMBl9pVOgcG3aMdOyYqyGRmOKxl7/F57/4OcbG6ruZM1RPR4uDr5yY4TsT2RXXGBSZLwyKYUGNANsmduJl+l8+UPG9eTeP4zg4GY2XH8bz1+GrtSEIylG+4uS5NNnc6g7vKV+xaSjd8u+1HW2cF4wBwbr46BJV8Jp4X5pQuPXCYN4wUEqQT42isVozFg35zDEsnWrBxlZAWS1CPg/KmmRsV39bvDQahVKK4ydP4m/w+cSff6Ldw1n1dGxaIZn3eXYyh6TBwkDPFQYAAg1a4WzchR+ZPTHn3TzTyWlOn57m3OkYUxf2kM5ch6d2IeQQdshGyLUjDAA8zyO3yoUBgLAEVUeZG0gnpBYUmmR+sfSC6gxhUMBz+lsnDAC0h1AzLdrYCiirRRhdHwYtcd3um85YjpSSsXUjnHruDA899FC7h7Pq6djIweNnMnzzbKYh6YQ5wsC2KhYSaQA7RPTV78Bz38ZJg+eO4Pkj+LoXS8pACKxhtNZMTDlMJvOdcF1oKhoY7kkRrc31tSEb7oTUAsBwbJiwXR6uV/T2pbHDLZzFsRgaVD5Kzhlu6YwSNzeBdE+3//PXgtZk3TTHEieIxHqIxbrZL0Bz4cIE3/7eAf7tq1803gdNpCOvdr7WPDuZBU2LhIFGa4XSmsyGS5icuoSMsxdP7UBYg9i2veaFARQ6MK5ib4P5+KoNn7QDZi0USeaSzEYPOkwYKEHeGWj9pr2p9n/+WhGCWCTC5Tu3EA9JEpMTbY9O1Y9gaHCQncb7oOl05BVvIuuTdjW2XLkwSE4nKwoDjUZpFRTr+BKtQkFr01gP1vAYlhEEC8jnPXJuN5qp1IcquiS2fLvtTy0AeMojnU8Dit7+DhEGBVqfTgDl55DaadEGG43Asi22bFjPzs2jpKYTOE6m3YOqC8u22TI6zlf/8RFeeOGFdg9n1dKRV79zjhf0RKhi2VcPPM5zj3yJJx/4bOm5v/+d/8ITD3yGZDIJWpeEQUVBoENAMGtBqKDnuRg2oar5aKVJznTGHW2r8FvsklhOu9o4zyeTTxLvS2GHOkQYFNIJvhdv+Xj8TvE2qAOtJVqDtCQDvb1cdlF3RxGK3gf3/Oo9xvugSXSkODjv+Mgqag0mT32Pnr4BNu6+jEc//Rel5zddfAWnjrwKSmNZEq314oJg/kq1NuKgAkr5pFe5t0E5AlC6TZ+2Q1ILAp/+gRnyJNo9lIA2phMA6MaUQhEd3BwBICEcCnV3FEEIRoaHjfdBE+lIcZD21JzuiosxefoEG/dcxnOPfplde98ABOmCTVfdwND4RqS00MpCLScIyhECEWt1FVrn42R9vK70Z6+ftokD2p9aEMJnaChNKKzIeQ6e77YlxTKflqcTILBLdlNI2i/Y6kUDzDucuj2KEA6H2bVhC3/5J3/F2bNn2z2cVUdHigO/ygkUF10XCIKDX/siV7z5HcF7PQ9LWWy/8o0oP8SL3/gKZw4f4pkvfZ7vfOnz1Q1ghbUOqw2tFKlV3IFxMVrdfGk+7UotSOEzPJTGDs3+DtNu9dbCTaGN6QQAz010tYGQoFBDM58ujyL09w9w+YbL+I1f/412D2XV0ZHiwKrhR+jMJDn1ygsloaC05syrL7J+3Rheaopvfe6vGN12OXve8AP825/9d5QvUCr40zqwIdfM/gHogj2rIcBXikzWXWPSAPx2fuI2pRak8BkaymDZc49/X7lkvUx7ogdtTido7SNVm8VRI1hCa3ZrFKHofXD6+bPG+6DBdKQ4iNuyauOjqVMnGN6wpfTYsiy0CKbdxWJx3vfRvyZCjvSZo2y/8nVoLdBKopVE+Vbw51koXwY1CT5kLwhS58OkE4Js2sdzPXzPw/d9tFJopdeOeNCQzrissYwC0P7IQatTC1IGqQTLrvxlO+4MSrfnQGhLOgEKdslJZCfkVFaEAC2WFneLRhE6+7PHYjEu2bSL3/ngfyOT6Z6oR6djt3sAlVgfs1Bao6vwOYj29s15/MJjD7Ln9W8pRAU0IHj6y//Aawef5Nb3/w8i5FBIFBY+ktLZpphfloKZYzapqXEojAGhsKSPbblYIRfL9rBtDysc/NkhHUQcSzbPhWLKVXCrrdTq78C4GEJKPK2x2xhOzrs+0UjzLW9locbAsha/EGitcNwU8fBAa6cQtjGdAHR3IWI5SqC1XvacOhtFiHD67CSTE5P0Dw12sPVy4H2wa3onf/iHf8hv/IZJMTSCjhQHozEbKQSKoIRwKYY3buHyN+3nyQc+S6xvgE27Ly9d55XSWJbguv0/ytDYJh7+1Mf5oZ/7ILIgD2xAIfGxUEiwBFpB/rQXlC0KUUgzSrS2cb0IrhecPDWUxIMQCsvysC0PabvYIRfL8rAiHlbIww4V0pVCFsoZukc8eL6Pk1s7sxTmEqSf2hZfK6QWmu2WaFkeg4NprCrO/TnPIWL1YFuh5h+/7Z6dACg/D6rFDbiagQgKbLWu8qNICMsgijDYH+e1k+cIR2PEYjE6cWcUvQ++9k+P8mM/9jyXX355u4fU9XSkfbKvNX/+4hQzeUXEqv3MPDkxQcizEEKQnUnR09ePAH7/3W/jx3/l99h59fdVPL79SBiV9Dj60TP4hAsKu9YfQgXxIBW25WFbLtJyA8FQFnmw7M4UD1prJqcdJhKr3y65EhoYiqWItdPJWENfPNq0uzbb8hgYzCwZMVjwHhmiPzrSEnGQTw+0L2qgwc2eQ3rn2v5bbARCukQGVNBCvhYU5H03iCJMpzs3iqA1p8+e5dXsEf7fF/4fVjVq17AoHRk5sITgquEo3zybqSoMNh9hSfDgmYf+iYkz32P/bf85aETSO0Cst79UL1C+Xk1wgR594ln2eM9wVo5ykk1cEKP4IlSDUBCz/y2LPPi+je9Hgy05c8WDlP7cyIPtBqIh5CNDLrYdrEcIWVifQLRgRoVSinSmrWV5bcf3Be3OuTYrtWBbHoNDaWo1AvWUG0QQ7FjzLpqdkE6A1ZNSgMDroJ57wW6JIhS8D04fPs/f/M3f8DM/8zPtHlFX05GRAwi6Mv7loQRaQ6jGC2EymQRH4WbSHDn4BJGeXo4dfIKevkFu/JHbS8sVBQFCoEI2Qmu2/8HnCU2ngeDC7Wk4K8Y4JTdxXo+iLbvglNDEs2Lhv7owlSIQDwXRYPtYxdRFyMeK+EgrEDqiLOKw0p4UANlcnuOn013rCrdSNNBrp+nvUW09BzajjbNtuQwOZWoWBrNjkvRH1yObIVLb0Yq5whh8Lw3ZI109hXEuPuEBFzu0AqHZBVGE6USCx176Fp/7t/sZGxtr93C6lo4VBwBfOTHDdyayhERtbZtn0jP4KRe7cNAWrZgrncg0oIWAWJiBb77A2L98u8IaZ4XCGbmBU2zigliHls0WCpUoiodCsaQGS3pBjYMdFEsGdQ4F8RCuTzxopTk/lSGRWntTGItoIGZnGOpps3Vwg1MLIdtlYLB+YVAkYvcQD/c3ft+0O51QHEPmBJZKdNTN8YrQmtBgjtBKxEEB5StS6QxHT50jFOmsKIJSiuMnT+KNe3zyLz7Z7uF0LR2ZVihy04YeXku5JPI+Yaq/G5ZyrpeZFAKlFEKLyjcB0RDW2QT9//RNtBAVGi4F7wsJ2MJpNuvTuEpyWo9zSmxkgvUg7fKEQhMpbqXwWQRownh+GM/XkAuW0qWZFhop/ELUwQv+DXnYto8V8ZC2HxSizRMPSvlknLWdUhC0qTNjBRqVWgjZeQYGnRULA4B8qTjRbtxhr8HvhHSC1gg13SnXu4YQuCQqaIA4KM1o2BXl1NmJjprRUPQ+OPDCQR588EH279/f7iF1JR0dOQA4nnL5/GtJlNKE5fL9FgByuRyZqTSh0gU7uNNGa6SUZc+BjoYRSjH6sS8QeuE4OqSJ9EWxQpXbO88luADnteSM3MgpNjIhRlooFGplYbEkQpciD3bIRRamaSqR4+z0DEJ6C+obOu1TNRObHOv7823/0I1ILYRCeQYHnYZGyW0Zpj863Jj90wnphMI4XHcamTu+ilIKgNZY8SyRnsbeE3ZmFEFzYWKCJ753gC9+5Yv09Jh+ObXS8eIA4NmJLA+fSKN0dQLB9VxmJlKExNwLvNIKWUhRFIUBWjN836P0ff3FwjIa3/cI9YUIxcKFVEQ1B3pwsc1pm1NyI2fEBiYZAWl1qFCoREE8aE0655H3g3C6wENabkEouMGflUeQR4R85n+2bvik1eOyoT/b/g+1wtRCuCAMmvE54uFBInZ05evuhHRCaRxHsZhp4yCagNZYsSyR3iYEjBW4vhdEETqkFsH3PF4+9hq73rTTeB/UQVeIAygIhJOBQFiuBsFXPtPnE4SFPUccaII+AdK2IBpC+Iqhv32sJAzmrMP30ZYmMlBtFKGcwEExp0OclJs4LTaQYASk7IriPqUUyWweteyRoQv1Cy6yKByEi7AC8YB0kVZ3iwetfDYOdsA8dw2RcKguz4NIOE//QGMjBuU0pDixkE7IOw2KQqwApVz8mZcaknrpKDRYkSyRvuZFZTotijCTSvHNQ0/xJ3/zMeN9UCNdIw4gSDE8eGKGRN5HIrAXKazTaCbPThAhtGC6ImEbLEnofJKRTz1C9KWTi25PafB9F7s3RKgnjFV1FGHeaLQmq0OclJs5JTaSZKhQ19DuK05lcq5HOt8IX39dqHkIog6yIB6wCgJC5hGWonw/dNoe0WjG+1M1FcQ2i3pSC9Fwjr6BbNOj41E7Tk+4r74vsFPSCYWxuNnzSO9s5x2MK0WDFcoS7pfNnQrdSVGEgvfBK85h/vlf/9l4H9RAV4kDgJyv+MbpDM9O5oLujRpsKQIj5LIz4MT5CcLKQggJlgxEgQBcH++LTzH+LwfoFdXdGvi+j5KKSH8UO2yvYJpgIBTSOsopuYkzYgPTDNWQumgFmpmsS74lzRQ0CIUUHsJykcKFUuoiD5aLbLN40GjW96YIWR3w/dSYWohGsvT151qSNhcI+qPrsGQdF3cN+cwgvtvT/p+BhvzMy1gi3+aBNAdp5Qn3g2zB8dwpUQQ3n+fg4Zf4gXe/3Xgf1EDXiYMiybzP85M5np3MknZ1ySxJFT5OLpdDehohLVAKMZ3B/upz2F9/AXUuQXY6xZbR4aDSugq0Bs93seI24XgYa8V3/gWhQA8nxUZOi42kGGi7UFDKZ9pxO6TVSiAeLOmBcJHSBZlHWoGA0FYeKYP+GUWaMKuO4ViKaDtdEovUkFqIRrL0D+RaMKhZ6ipO7KB0Ahp83wHn1dVViFhG3S6J9dIhUYSi98H9X/ws4+PjLd9+N9K14qCIrzUTWZ/zjsc5xyfjKTytefyxr9P7vEP83Azy+AXEqUlE2d1wKpViKBRmoC9eU8jYVwolfML9EULhUEPMhopCIUUPJ8VmzogNzNDfUKFgWbBpR5RIbOmTQt7zyXlBo6WZpM/xI05Dtt8cNEKoQDQUxYNV+FfkC7UPsBLxoIHByAw90c74mVSTWohFg4hBO4hHBolYVRYndlI6oTCefOYkllpFrojzEMIjPOBh2a29QLc7iqC14tiJk7hjLn/+l3/esu12M10vDhbjAx/4AHzyPBtH1ld8XWuYunCe7evXEQnXflvo+h5WVBLuizQgilA2LjQoTVL0clJs4gwbSIu+FQmFt/7ICD/6M2P09NZ+Qpi8kOfejxzjya8n6tp2e9EI4c8WSxb+sPIIXITtEmSWFhcPGugNzdAfq7ZjTZNZJrWwmDAQUrJu43rCkdCKNp/PuVw4dR6tKqedpLDoj66rrjixk9IJAFrjzhxCitXchVQRHsivzCWx/k23NYrgOBkOvHyQ//y7v2C8D6pg1YqDj33sYxz98HfYNbJx0WVy+TzSyTI2PFhXoYrSGl97QRQhYgf1DQ1Eo9FKkxJ9fK8QUXCI1yQUrrmxn1/43W11j0EpjVbw/nc/z7HDnRxFqB1NYBAlZBBtKImH4lRN6SEk9FgOg/GyC0abC+YWSy30xLL09i0UBpe+7gq+7+1vIByNNGQI+WyOb3/5cV584rmKr1dVnNhJ6QQADZ47jVht3gbzaaBLYr20L4qgmbgwwbdPHOBfH/5X4vF4C7bZvay2yTolxsfHyagcS0mfSDjMjO/jZJdebjGkEIRkCHc6jzPt4HsejWzSIxBIKRkQaS7nEN/vf4Ub1aNs9Q8TUSmUVstu740/OITv1z+m4h3gm94xUvc6OhWBQGsb5cfw3H7c3Ah5Z5x8egu55E6y03vITe3Ez23HFuNYYgRJP0LHQFuFubHz/po/aFxv4UySeCxTURhs2b2VfT/8loYJA4BwNMK+H34LW3Zvrfh6zsvgK3/x/VFIJ7htbMVcCZWfWt3CgMJXskjUp1XMuituJR6SJCYmUaoV0RrB4NAgO/t28od/+Ict2F5309H2ySthbGyMnHBRSmEtUXwzMDjAmYkptoVDhEL1hVxty0a5GmfCIdwfJhQNNTyKIAg6MY6QYpgXuNx/nkk5wCmxmTOMkxM9hdqJuSe3zTuiWCusTJYWbN4RW9E6ug8RXMQIkXd7ENglu+rZi55G44LwQLtoXLR2UdoF8lApPN2Aa49SGqX8Ukg2Hs8Qj7sVl9197SUov/EFaMr32X3tJXzvleMLXtNo0vnpoDhxEbzsQGfUGRTQ2kPomY4ZT7MQQEuuw8shISTtUqfHVkURLMtm8+g4j/y/x3jux57jiiuuaNq2up1VLQ6yMo/yPSxr8ZoCKSWheIzETJqRwYG657NLIZBWCDfp4Tkekf4I0q7VPKk6ikJhHSlG9AtcoZ5nQgwHNQpiA56IlFpMW/bKty+EwG7AeroV35t3YRWz/yMIA+GCk2TwmlUQDxoNwgXtAgXxQB6tPTR5oMIdXJW7Oe/6RMMWvb0ZehYRBgDD4+uaUpkuLYvh8XWLvu6pPHk/S3h+cWKxd0Kn1BlAkFLIJVZvGHU+7Q0czKEdPRp6e3u5csul3POr9xjvgyVYtb+HsbEx0jKHV0UIraenhwknSy6/8rnNtmUhfIkz4ZDP5BYt3GoUxdTDepHgap7j7f6XuUF9k43qKJZyqCtfYpiD69f4MylEGIJOmGGEiCPEIFKsx2ITtthGSOwu/G3HZjO2GMMSw0h6QUfQWiyetiikFvr6lhYGULkTaaNYbt2ZfIo5JU0dmk4AwEt0jlhpKgKUbE0KrFokhEJBFGHnllFmkgkcJ0PTBikE64aH6c328zd/8zfN2cYqYNWKg6GhIXJWHuVXF0PrHxjg3FQSr8rll0IKQcgK4ad8MokMnusFd5FNpigUxpjiGn2Q/f6DhFidZi6txPcbeNUQ5X8SRAQh54qHkNhOWOwhJC4KxIPYhC1GkXIIqXtBhYnHk4Sj2caNqwko7eN46Tnn+E5LJwTeBlkEq6vYdkmUoBPr0FtZixAKh9m1YQt/+Sd/xZkzZ5qyjW5n1aYVpJRYQyH8yeoOrlDIJmtLZtIO/TV6HyyGZVkoX5OddLB7Q4RrauS0MgQCS4JVSZQcPAiPPQZbt0IiAbfd1vTxdDNCgOeD3Ypfy5xDwwIsBJHSI6RmqDdLNLoelRVIm2BapghmWWjypX87obYu56aJWDEsaXVeOqGAyieQnTaoJqK1QHfIzNwFtLAWoX+gnys3Xc6HPvgh431QgVUrDgDiG3vxz1cf1u/t6+fshQlisTCRUGMs8Yq1CP6MT8ZJEx2I1dHIqYEkk/D+98OXvgTHjsEXvhA8/453wOAgXHklfOhDNa/WDgmuvK6P4fXhqi9Knqt55YU0J4919h0wCDyvReJgSTQDfTmikUDw+j5IEQFRmIkwbxKDFB7oCkW2LRSHGk3aTdIbGu7MdAIa/NVrerQAEYiDoPCgcz90eS3C6XMTTDShFkEIyejICAdePMiDDz5ovA/m0fbTXTMZ2jaC953qw1JCQLyvl8nEDKPDAw0tVLEsC6ktshccrF6bcDxSZyOnFfLoo7Bt2+zF4a67gud/8RfhllvqWuWV1/fxa/9zN7F4ffvr2SeT/N7dr5DLdlCl1Dw8X9LeSi7NQF+2JAwAFBqNQhSzg/MOJYW98MnFxOEDDwT/PvPMrDi8777gWDl2bEUCwvNzZPJhrE5KJ0DB22AGiUdnDazJ6M5MKyygEEXYPL6egb7mRBFisRiXbtrFf/vQf+PGG2803gdlrNqaAwiKEt0aT+iRaISk7+HkGp+rFwJCoRA6o3Am0rg5r/U/0oEBuOYa2Ldv9sQPcPx4IBg+/OGaVhfvs/j1P9izrC3zUly+t4+f+aUtdb+/Fbhee52PBvqdOcIACtPSlKqtbqtcHEIgDh94IDgubrkFhocDUVB8fd++IKJUFA914OUtUplUR16QlLv6vQ0W0l2ft7wWoTcsmWpoLULgfbCrfxd/8Ad/0KB1rg5WtTgYHx/HqaMgb2BggLOJaVx36UrwerEsC1uEyE1lyaacwDCmVeXD+/bB5GRwsn/ggUAUQHCR2LcPtm+v6UJw/U2DhMJiRVXxliV44/4RZAcfjV4jixJrQjPY7xANVxa5NZ8kK4nDW24JHgMcPQpXXx2kHrZtm33PM89UGFoI8lvAHUd4I+D3g4qBng1IaiXIZ6P4yiXrTXVWlbz2ECrV7lG0HK1E901iKsxo2Dy+nl1bRpmZbtyMBsuy2TI6zmP/8nWee66y6+daZFWnFcbGxni24JJYy82BZUmsWJTpGYfhQbshxYnzEUDIDuFnFU4u0+BGTsswv6ag/C4xmQzuFOfRS5IRzjPJcFBtXmBsYwTf09ihlY27J24Ri1ukU53g0LKQhs5YqBJRiBhEFhEGUCG1sBz79sEjj8wKwIGBWRHw2GNw1VVB3cljj8H09LIj9FWhCdT8c7TQSOHiuQILBXjkvBxhqZFCsKhHWKt2swY3n0R2lFppDRpRmGLdffP7S1GEi4JahAsTkww0oBYh3tvLlZsv5e5fuZt/+eK/GO8DVrk4GB8fJyddlO/X3IUs3hNnYmKC3p4I0UjjrGfnY0mJhSSfyONFXSK90YKjY6POklWc/PbtCy4WRZFQofYgphzeoL9FTtuckps5xUamGKKRXiXNnJO/UlodORBoBgccwqGl02LF1IIlZfWHTKWC04MHAzFw223B/1955WzKaXo6iDYsN5BytMD3Iyi/rCBSQyYnCcsgryuFQgqFEBpE0CQLoQr/X+V2VoB2E90WYW8IHeOSWC/zaxFOniMUXWEtghCMDA/TNzXA//2//5f3vOc9DR1yN7KqxUHRQtlXflAMVQsC+gb6OTeVZNP64aYryZBlo/Ia50KG8EDjGjnlpjJE1/UtH5EoCoJieLkM5flkExkAIsJjhz7KDo6S1SHW8e+BDSseZ6fjeQVToiV2o5SCnl4bsQKRo5UmO+PS3+cQWkYYFFHKx5KVf8pVhY+PHYM77ggKVD/+8UA87Ns3O6vh+PHZwtUa1u17C8fkk0fpKFLYKG2hdOXflSi141YINBSEhBYKIdTiocAqd73yc0jS1b9htaG6/3M3OopQ9D74q4//NT/4gz/Ihg2r/7y2FKtaHIyPj5OWOfw6jY1CoRCOJUk7Dr3xxngfLEXJgnk6jxdxifRGChGP+rd76hsv079rFLGC/grStvjeN15a8HxUuAzpRHDyXuV4S7gk2iHJD912EVffNEY0tvKfVM5xeenASR79x+fxveUFwlKpBSeVY3Bdz9KCZds2ePzxhc8XBUEFwaiVJpNa2OgpeBF8t8JMiQJ5nSEq+hcfD4XQt7ZQ/uLiQRaEgihFHxRIBajFxbAojm9teRvMRQTiYBmx2xU0OIpQ7n3wF3/1F40fbxfRwSVgK6e/v59sKFco+KuPvv4+zkzP4HnNKU6shG3ZCLdowZxH6/qn0B35/JNMv3oWCCIAyldV//lusN+OfvUFjn7txdo2fPAg/OmfBumK++6re/ydgr+EOPj/fvFybvj+jQ0RBgCRWIgrbtzGD/z03qqWX2rWwmvPn2/ImCpx9LkK69bFgrfF95fGw9Ur87bQCHxt4akQrh8h70XJuz3kc73kc/3ks714uR58N4rywmgvBL6FVgK0RntThcHSWUWSraKwH1YLs1GElc1oKHofnDt0gS9/+ctNGGn3sKojB0IIQsMR1Ln6L65CCGJ9cSaTadYPWi0rVClFEVIeXrb+Rk5uOsdjv/Qpxm/cw+jebVixwNzJ8/1lz4m5pMP3vvkKJ7/9KtqvYR8uNpe+OG/+kUfqMlpqJxrwFcz/+geGI1x23eINiOpFSsGuq8aJD0RJTy9/IV0stfDCt06w4/L1bNw1jO+rFd8oaoKC3dOvTfHCt09UXKZSOmE+nnawRaRpZmBF8UCFyIPUM/SFQ2hto5VCodBaobRGaYXPrMN16e6z2++w56F08Leq7g4bFEUoeh98+Dc+zE033bRmvQ9WtTgAiG7owT+9suqbaDTKVHqSvpxLvKe1Vax2wYLZmXAI9YYIxcLIGuf8+TmPk199gZNffQEImvbM5L3mnfAqGS0lk8Fr+/bBpz4ViIZilXxXIPA8gWXNlVQbd/Q1b4tCMLp5gNeqEQeLpBa8vOJfPvE0Wy9Zx+bdw4SjK/vJ57MeJ16Z5PihCyh/nrxcJp0wf2FXpwmL3hWNpx5CYipoiiUESLmgGklDEF3Qeq54UBofFVxUyzpzlv/TFQhAF029umng1VGxFmFwEFn1jV3B+2A68D74rd/6raaOt1NZ9eJgdPsY3oGVO9v1Dw5ydirB1oiNbbV2t5VbMLvZDNH+aN0WzBqN66vmnhPK59LDrBC47bYgerB1a5cJgwDPF0TmxVusFdRyVINlVycEl5q1oHzN0efPc7SJKYZq0gnz8XUehYcUrfw9+UREYsklgtbby4gHpQLxoDUKP/hXaRQKvxvEg17llUIrjCLM8T748ee44oormj/mDmPVi4OxsTFynFzxeixLIqJhplMZhgb6ml6cWHkMFkKtrJGTVhq3yW2kl5xLf9ttcPfdFSMHUTKkaExPi2bQPiOk6lhq1kIrqCadEOsLse3SYaLxYIqjQGKLaO3bchVnjqSZOr1IUeQiWDqJsFZ2/AsAOVvOaJWdRksX3HniQWmNLkQe5tYBtkc8aFZXzcFiSEsy0FdfFGEp7wNfayayPuccj/OOT9pT+FpjCUHclqyPWYzGbEaiFlaXOnCuenEwPj7OIY42ZF298V4uXLhAbyxKJNKei9hKGzl5SrWmQ8D8moKiRW/RhfELX1gwPe5N+jHOqBAnrC2c1eNkibVipFXjecsv005qNkRqFFWmE679/s3c9CM7EVKglK6/EFAEMxmFEBx/PsnDf3kc36tuZWExWedGqx5awFLiQQOFGget/ZKI8HUQeVggHppxbelGl8R6EbPuijVFEcq8D/76r/+a9773vSTzPs9P5nh2Mkva1SgdmHqpsp1ZfCyFIB4SXDUc5fLhCP3h7jJWWvXiYGxsjAMqi9Z65e6DAvoGBjg/nWLDyGBbXbRKjZwmHOy4TaiKRk4aTb6WwsJqqPYM86Y3BbUIDzwQWPR+9KMVVqUZEtMMqWmu1M8xIYc4KTZzVo+To/a7y0bj+hKosn6lDW2x6zJEWilVphM27OjnjT+6q/S4UYZXmy/t45q3j3LgX88uv7B2Cdnphmy3XkTxP6KYrph7DimPPCitQKuCaAjqH4plxCstluxml8R6qSeKEAqH2bVxK/f9xf2sf+MtHMnZ+DoQtrYUhIrpp3lfgtZBRcdMXvHNsxm+fc7hquEIN23oIWJ1RxnomhAHeeni+z52A3ruhsIhpp0MGSdLbzze1p4tQhQsmDM+TjZNpD+CvYQFs1IKr8EphfS5aWQ1B3t//6zRUgUHRi/r4qbLQsQCRvQUI3oK9EHOixFOyc2c1WPkaZ5j5VJUnVaopfNh0ab4+PFAQPQvPf9/OdqRWqgmnbDr2vX4viq4fzYOKQW7rhuoShyExFTHe3KURx6sQgSo/NJVLJakMLNidpZF4TG6LPKwuHgQgO5ml8R6qSOK0H/xHt76rp/muYRHLGoTFmJZozMhBBZBTZLWGk/DdyayvJZy2b+5l619FVqpdxirXhyMj4+TlR6+Ug37sH39fZy+MMWOSJhQqP1fsmVZSCxyUzm8Hp9wbzi4e5xzsGs8Xzf81Hj86y9xY0Em1+sMqDyfY4++uPh0SQHrmWC9mkApuCDXcVJs5hxjuC2sUfD9Ko1jKs3WKE+rHD8eFGYWazM+9KFAUKxQGECLUws1zE7oG4o0zR47Pljdb7DZKYVWUCyWRIiSeChnvngIBETx/wMRUfy6tAqKVaUQq2xO4/JUG0XQF++BN7yBkBC4joNvCUKR2qKYQghCIpg6msj7fP61JG/bFOeqkfZHQ5di1YuDsbExMsJBeT6Nuo5IIYn29jCZnGHd0EDhQtxeBEEUQS3SyElrcOt0ilyK7GSaR3/787zpt38cFKga0hZCBO6L09+b4Nt/9K9VvUdKGOUCo/oCSsF5a5QTYjPnWY+nmysUlnJJnEOl2Rrl0ZKjR+H22wPxkEwGwqE8mrACWpZaqHF2QjMbilWzbkkGW9ZWvNiNzBcPi0/TVAglIecV6hwUWmq0VAghSzUdIFaveFgmilAUBgiBcF1sKZlJzRAOh5F1WNtLIQgDeaV5+ESQ3upkgbDqxUFvby+5iF+3hfJixGIxJi9M0JfL0xPrnC9YSolE4iYKFsx9QSMnpRVukyqQjjx4kFMHjrDlpouJj/ZXfSHwXZ8LL5zg9NNHazNZKiAljOlzjOlzKAVn5TgnxSbOsx6fxkd0qu7MWG3nw+9+NyjOvOWWoC7hvvsaUpvQqtRCNemETsGm+6MGjWB2mqaFIIwspeg0+KD9IPKE9lEEdtQahRIKLXTQ20LOioeSX0R3FuQDi0QRLrsUURAGuIE7rpASW9uk02n6euvzNxFCEJYFgXAyzWDY6tgUQ/f8uutECEFoJIQ63fga/YHBQc5MTbM13Hrvg+WwLRvlFho59Ufw7eb+erOTaV75l6ebuo2lkBI2cIYN+gy+lpyVY5wUm7ig1+M36DBXhQrvqrRPNZ0Pr756thPm4GAgEBoxzmanFmoyO+oAtCZsTbd7FB1I8P3JYpVkqVpSUrw0aF2WqlBBUXNg5+6jhUILv3S8aanRQiOk6D7xUBZF6Bse5MJNNwatxV23fBGklOSzedyoS8iu76JeEgha8+CJGW7bM9CRRYqdN6ImEBuPNzxyAGDZFiISJjmTmTOVpVOQQhCyQuQTORKTmcB/fw1gCcVGfZob1FO8XX2JaznAKGeQrHwuouvVeZYrdj781KfgHe8IhMCVVwavFdMKDZrRUEwtNKX2rg6zo0VpUf8NSySxRIfPQ20D1RweQgTiQQqBlAJLSmzLxrYihGSMEL2E6SNCP1F/gKg3QDgfx87GkE4Y4UiUo/EzCjfn47oevufjF/q36JVMaW0C0pKo616HPTSE8FyUUnOGJ4XAtmySySQrqeAK6hAEibzPN05nVj7wJtBZt7tNYmz7ON6TzTk5xHt7OT9xnngsSiTcmQY+vtZknDyZrEt8IEIk0plhrGZgCcUmfYpNnMLTFqfkBk6JTUzoEXTN07gEni8Il50Usk6Vx9VynQ8rzOCAoENjPTQztdCQdMJSMzo+/vHg+SLFYs6DByu2jl6OsEkpLMHKWjPOBgXmRx4CVOmnosErRB7w0Vqh8UEUUxYKJQNrSVlW71CqfWhR5MGLxkht2wEFQyNhSXxfzTpmEtScSSVxMg49PT11b0sKgdTw7GSO60djHeeDsCYiB+Pj42RFc+btCAHx/gEuJFJNiU6sFKU1Gc8rxcLTiRypxNqJIpRjC5+t+gSvV9/m7erLXMkzjHAeUa13AQuNkI69PI3nNmdfeq7P6dem6npvMdTbUBqZTiif0QFzRdLg4Oxyx44Fszv27Qtmfhw7VuOGXEJyZuXjXZWIpt+1y0qRBxkiZEUIWz3YohB50APEvAGi+X5C2TiWE0Fm7VLkwXN83JyL5/r4pe6yhe5RDfwMqS3b0VIifB+EQAqJbVsIQSmKIEQwQyyTyayo4y+ALYKbt+cnO69Ydk2Ig7GxMRyVb9r6I+EwaRQZJ9txrmNK+eTKhYAAN69InM+Qc5q3TzqdkPDYpr/HG/S3uFl9mct5lmFxYVmh4Km5F0Y3p/jSpw8DBHcYDaC4nm/8y4t4bn0nn4anFhqZToC5Mzq2bVv8or9tW5By+cmfDERCjT05QiQQYu0J4eoQtDumXxIOQiClLKQtQoSsKGE5Kx6ieoCYN0gk1zcrHhwbnW2ceNBCkNq6AyiTv4XIhSUlliXRBVtsIQS2tEklUyv6/EIEAu3ZyWxgrtRBrIm0wvj4OE/pPEqruqagVMPAQD9nJ6aIdoj3QZGc5xdc1ebd7QlIJ/Pksh7xvgiW3VkhrVYSER479DF26GPktM1JuZnTbGSKIebrZ69CzcE3/u0E505muO5N6xnb3LOi+fxKaSbPzvDSUyc4dmhljZIanVpo6OyEpWZ0lJNMBiLiyiuDnhz79s3WalRBaBV4GzQLTee3VygVS0JZJbAFhKDgQlj6n0LjK7RG4wUpDOGjhUZJtWCmRTBNs7QR8n39+JFoEDWYjxBIBMIWHP7Ot3BSSbLpFFd8/78nm8vyj//zA1x03Ru44ZafqPkz2lKQdoNeDaOxzrkkd85ImsjY2Bg56eL7Cllll7takUIS6ukhkUozMtTfNBFSC0prnEJ4rCICPFcxPZGhpy9CNBaqshR/9RIRHjv1UXZyFEdHOCk3cVpsZFoPALKyS6KGEy+fYfr08Y4qym7YrIVmzU6oxtfhn/8ZfuiHAuHw6U8HtQlVigOhs4Ss5dtdr2U6XBssTcl+YbbeQZaO9dDsTIviNM1iqq1Q76AL9Q4QiAdnvI9C/mB2A2X/ICBx+iTx/kGGxjfxd7/5i1y9/z8wk5ph48WXM3HqeF0fQwKe1px3PCMOWs34+DiOzKN8HxpgobwYPT0xJi5MEM/F6Im2x+K3HKV88qqK9sxCkEnlyWVdevujazqKUE5M5LhIH+EifYSMjnBKbmbKHwUdnd2nGnp68vTG8x0lDKBBhkgNSifoam9RH3ssSB888EBQf/DDPxzMZLjyytlpoFWuu9MLEUM9YWIDPSvS48rXZCZn8OtIPwnocnWwNMsVS84XD6m+MdAaoed9IQVXSQ0kzpxkxzWv45v/8DfsvOZ1WFKglMW2vTdy/uXn6hxnUHh5zvG5vK41NIc1IQ5GR0dJi2zDcsJL0T84wPnENJvWD7fd+8DxFjaIXRQBvqeZnsgQi4eJxsNNdbXrNnpEjov0YaR7mKgeZkIMM6lHkD0W8bjbccKgSCNSC41IJ6Smciilsaxl9tS+fXNndfT3LztDIZ2oNKNDE7LqK+ZsNtG+GK/7qRsZvWi8bsvxcnzX5/jTr/H0559AeeX1RYKhLcNEexc3aRP4WMtEU33PJ3FyEjfTeUVzK2G+ePBjURByjqssxdcLrtM7rn49aM0Ljz3I2971i1jCQoYkKu+x89rvA8CZSfLkA/cD8Kb/771VjSUoHO+s2pg1IQ7i8ThezEflmz+bIGTbZEM2qXSWgb54YD3aBnzlky2bpVA1QuBkXHI5j97+CHZoTRwiVaN9TVTk2KROsyf+Glbc5oIYIaGHyRDrOJGg0MFUscEe/MEY/mAMHbXRlkD4GpH1sBIOVsJBTmcR5XeSDUwnHP7Oea596+YVr2c+SmmOPL3Q4Mgi1ZneBgLefNfN9K7ra4gwALBCFttv2IWwJE/+3TcBGNuzgdfddtOSwqAWtNIcP3CYZ/7h8cCboEuZjRZA6f8KfbSVKBZoFjpflsSDng0+ANl0kjNHDrF77w2lAubzR19i22U/BsDhA4+TSU7R0z9U09i8DisAWTNn/vC6GP6J1kw17O3t49yFC/REw23zPvB8Rb6syUqtKF+TnHSIxsPETBShhPKDE0xfPEtP3AM8NuuTbOYkDjEmxAiTepgs0bYLBd0Txtu1jtzuMXQ0FERUS4Gkwomw+FiBzLqEjkwSPjKJzLgNnZ1w+rUkX/+nw9z0IzuDsa3wJknIIBx78tAM3/nSuQWvhzo0pTCybT39YwMNX6+Qgq3Xbuc7n3+SUCzEG3/2LYgG9nwRUrD1+l1kUxle/NIzDVtv3ZSKEQsPyv5XoxGAJXykpbBQSOljSY1tKWzpYwkfy1KELB9b+tiWIhvdRUaMYsulDk5N4swJhsY3IQupBs8PKnssGaRjr3jzO3BS0zgztc1ksDvsHLtmxEF8Sy/+sdaEbQLvgz4mplOMDQ9iLdEvvFlkPX/l6UQhyGZc8lmXeKGR01pHAL0xh574QqEZw2GzPsFmTpAhXhAKg+RaLBR0yMK9ejP+7vWBrzSAr8HTFcehAaRAxULkLh8jf+koocMT2E9NNLTF8XcePsFLT5xl66XDxHprP5YENrYIxLbnKs4eyTB5qlLBoUdYrmyKWbMY2DhYmgrXaKQl6RvtZ93O0aAqv8FdMIUQbL3+ooaLg6Xu5jUghcKSCik0lvSxpMIWPlJqbMvHlgpLeoQsFTy2fGxZXKOoeMxX2v0xz0FWvHufjSSAIFboq6DR+Epz8LGHuObmH6rrsxeRQtDTpGL5elkz4mB00xiebl3OLBKJMJXO0J/NEY/3tPTi4Ps+WeU3rLhcKUhNZYnEfGJ9kbalSjqB9SMuPREflnFX7CFNj06zhePMEGdSjDClh8gRaeqx4I/1475+B7o3EszxLhSqibL/zkdAsKwKTsbaEuR3r8MdHyDyrdNYZxpn75pJuRx64mzd74/IgQq9Budi6emO9TaQlqT6Bh31rF/QN9qPVgohG39TEuvvQdpybm1DGYtd6OfczUuFJaq7m7elz2wApMKFflHzxNr372B6Ai1EIZg2VxCUr3J4w2Yuu/GtPPGv/0isr5912y4iGqm/AF1rjdaa0VhnFYKvGXEwPj5OkiMt3Wb/4ABnJqfYFg611PvA8/2gA2Mjzz9CkMt65HMe8f4I4TVkwVxkbCRPf59CaVGT8XIvaXp1mq0cZ4ZeJsQ6pvQgecIN/Yq8i9bj3rA9mLft+XVVogsAX6OVRveFyL5tK+EnzhB6JdHAkdaPqzJE5NId8cKiMwsRW4UM/Iebtn4FaO0tuJu3Cnf4Fe/mpY9t1X433wrf5EKQgr6Z8witQIrZ2pv5m9fBxfxt7/4FhAyslfMaxAqmriuCqMz6DprGCGtIHIyNjXFGv9jSbVpSEorFmJ7JMDzY35I7bqUp2CU3Z/1aw0wiSzjq0dMXQTYwr9nJjK3L0d9bOGOs4Ka0lxl69QzbgBT9TIhhpvQg7gqFgnfRetzXbQ/OsHW6KpYjNGhXQUiS/75xgI4QCAoXT+dL6YX5CHKErHSLR7W2uHzjcYRfdFdt7t18sygKgqBaQGNbgjE9TY/nkAn1IFWFGTA6mFWgNKV6Dtf3icV7VzQWT2l6w5KRqIkctIWxsTGy2m2qS2Ilenp6uDBxgd6e6IpCT9WilE+2Gm+DlSAE+ZxPPpch3h8hEl3NUQTN+Po8ffGy23C/MXn4PpL06STbgaToZ4IREnoIF7umr88f6w8iBksIg9lQafVrFpQJhNeNI1P5hqYY6sXVDpYIVbz/DDHZQZegGjh4MPB42Lo16NhZZ4dOKTSy0T015mFbgfdFt1FJENghiWVZpZuc3ZMv892xaxf+UuYIg+JUR43nqwVR4VcPPM6rBx7HmUkyvGEzV7z5HYuPqRDhvWo4itVh6do1Iw7Gx8fJWh6+p5ChFt7tCugfGODsVLLgfdBcdZj3vMp2yU0iPZ0LChb7Isg2FF42F83G0TzxnnlioEHioJx+naSfJOijTIsBJsQICT2Av8xPVIcs3NfvCFIJDYgYzKdcIORev4HYA68h2j4f28fVDmGxsCNeV6YUlupQCUFviaKbZKWulWWMDySIR3MsyCk1SHx0G9UIgnIumnqFg6NX4QsbW3ullSgdtDErL/L0fUU4Gl0gUi+67g1cdN0bqhqfp8ESgsuH22+aN5+1ERMmiBxkRBa1wi5a9RAKhfAsSTrjoJo4l3VZu+RmIAqNnCYcsquokZNYTBhQg9tfXRvWDJBgpz7MXv0dLhIvMywmkIs0hHKv3hwUH3rNO64FgKfQfSHy165v2nZqwde5oOVvGVLPYMn6Wlw3muJseYHGkoqQ9IjaecJWBe+FSh0qi22qb7kFhocDl0hY2LVyHhV/+UXxcdddgdNkMhk8/8AD8I55d7X33ReMo7i9LqTYM0JpBToobIxFJfF4mFhPhFAotGg6NO6m2TP5ElrIoISyXBiUnVe1BtfziUXr95EI1qu5ajjSce2aYQ1FDsbGxsjI1rgkVqKvv48zFyaIRcOEQ83xPih1YGxTdCqTzJNfBY2cBIqNYy49sUVEQBMiB5UHohnSCYZIoJEkCCIK03oAhYXqCQfTFavsPFdPaqFsKGil8XYPEnp+Aplpt8GQJj+vOLFZTZaK+02iETK42EsUlhU8Z8lC5b3QWFaxEl8RslTp3UX6Ys7CDZR3qIQgenDLLbOvHz0Kt99e/wcoFx9bt85tj/2pT80uVxQn+/YFVtVFC+suoNYIwVJce+ZpTvZtJhXuQ3jBDc/8qadaK5QQWHW64GqtcbVmMGxx04aFEbBOYM2Ig2g0iuoBlW195ACCgyve18fE9AyjQwNN8T7I1mKX3AzEbCOnWG+YWE+46xo5CRSbxlxiiwkDVm7gUw8CxRBTDOkpNJJJMcjxXa8jJ2VT0gkV8TWEJN5Fg4SfvdCabS6BwsXXeSwRBnwiYqFTYjnFb1SikTLIzUupsKSeO5e+MKXOlhpZnHpXNm++nOWP7iqWX6pD5WOPwVVX1dSJcgGVxEelDpgHD85uZ2AgGFMHi4NGCoJyQsrlhmOP8ZVdP4BvhbEqFCd6viIai9U3bq3JK42Ugv2be4lYnRnAXzPiACCyPop/rD3iACASjTCZTtOXy9PbU9+BtRhKqdanFBZDCJwZl3zO66pGTlIornzHNnb8yD7692xDLDXuZfezxk2lmTz4Iie+9DW8TIU7xjoJhEKCwxeNIvGReKjgktfUPjpFc1lv9yChgxfmWi23BY0SM/TYfUTEBDHp1HU3z4JHlWjy76pSh8qDB2ebTZVfuGul2vbYEGyvg2mWICjH8zxyx19mu+jj6K434lshLH+2f4rWGtfziffXXidQEgZC8LZNcbb2dW4x95oSB/HNffhH2icOAAYGBzk7NUU0EmpoYybf93HbmFJYgJht5NQNFsyWVFz1Q7u45gPvCqzUG6DmrZEwG/a9noE9uzj4R/ei3MblwzODw7ixHqTvBXfAKDQCjSg8Csb/2ne/TXYmSXYmybXv+HE08I8f+a/suOb1XPuOH699w75Gx2z0YAQx1ThTMSkKd++WX/hXIUXRBKc4l758Pr2PLMyb77F76PHOIggEWNsv9I3g2DG4444gDfDxj8+Kh/ldK6ulmvbYV14ZbBcCkXDNNTUPuxm0QhAUcV2XoxMzEO9lR+oo4e+FeHnL96GsMNJ3EWiU0shQqGZvA1VIJUgZCIOrRhrT96JZrClxML5lAy7tnQNtWRIrFmU6lWFooK9h3gdBB8YOpGjB3MGNnCyp2DTususn3gYIxHKdA2tAWJL4xjGGLt/DxDPPN2y96aERtJBz5mOLgjwoCoXJMyfp6e1lcGwTf/9b/6kkBjbsvozJ09+rb8NKgyVRQ1FkRXEQhOwtUbiQF/6KbnhSFC7yVtkFXyhWMrs4nU8QFSls0XnH1nx8J1tdz4Nt2+Z2pywyv2vlPDwnW7351XyhsW/f7KyG48cX74bZooiRLhMEliUI2RLLbrwgKJLPe7w2kcTqGyASDaICmyZeIZZL8dLWN+BE+kAr3LxTk7eB1hpPB03QBsMW+zf3dnTEoEjn/5oayOjoKJP6lXYPg3hPnPMTF4jHIg3xPmi0XXIzKDZyisRD9MQjHRNFKAqDaEzQv3trU7ahPJ/+XdsbLA7WIXTlXgkQCIXpsyfYefXr+Po/3MfOq29AolBILrnxZo5+94matlduJ6tRRDbAusmJRe/mW4nyE6RIMxga6OSfAADJ1442pbeCVgo3NUNuchI3nV7Eg3AelYRGURAU6xPmoVwX7TVvRkhFQWBZge10E8nlXI5MpggNDC5oljc8c4YbDj3AkY3XcGJ4NzoUQUsbX2skC4sVg88RzHDwVOBjYAnBtcNRbtrQ07E1BvPpjlE2iPHxcTKqA6bbFbwPziWS+P7K0xyeKnRg7HSEIJfxmJ5I4+bbP+XMlopN43kiYY2wm6iTBcgGN61yYz3oZS4wO69+HQDPf/3LXHHT92PjEcJF4rPj6tchhC6F8w9988sce/bxwp2+v+BPyiBnL0VgL2vHob8nTTyaJRrOEwp5bREGAFIlcFWenGpd75R68TIOp74WzApQvr/iabFaa7RSoDXHv/QQANOvHm5IWmzBtpRP5sihxq+3MO1Q66AQNBqR9PSE6ekJmr01VRhoyGZdXplMEakgDIrYymXP955g6F/+mNCJF+gNS3wNeRXUEGR9VforPudr6A1Lbhzr4T2XDPL9HVx8WIk1FTkYGxsjK/Iopdpu+xsKhchIQdpx6I33Um8DNa0h47Z7WlltzDZy8oj1RdvSyMm2fDZtcAl36S9ASauqSFE2neLM4ZdKQkEDp159mUvfuD+40BeW+ebn/pKbbv0ZqpsTqVEdYput/DSSQGjOuDNEIiFEh9/znP3Wk6RPnWbokosJD/SxkpyK9n2yFyaYfP5FshcmAMicOsOZx59g/A2vQytVlQBZ7lASloU3k2LiGw/WPdZy5kYIwLYtLMvCkrJ1EVANTi7H4Yk08ZEh7GVuEDJOlmeeOch/fd8vsXnrEBNZn/OOxznHJ+MpPK2xC90VR2MW62M2I1Gr45wPq6VLT431MT4+Tla6///2/js+kvu+78efn5nZhl3sLsoBuMK7I4+9iqQsiZJOjeRRtqjiLjty4tixv/kyib+/b6zIsi0nLvI3cU0iR7LjOI4LbUuyZdnyyTIlqpAniaIoieXYeeRVHO6AA7DYPuXz+fz+GOBQDmX7LoDP8/EAj1jMzsyWmXnNu7zeSCm7Lg4A0ul+zl2Y4fJYDKvBwUxKSTzdQ4WItSIEblXiuaWOD3KKOJLdYx4RZ7O9aYtYqrbBSrPnxhkY241GILU139UAIFDKwrIUzxz5AjccPFT7xoXAUr1R4aJl7uL/KxSloELKSXZvh2qkeOoMxVNn2rb+s185Qu75F8lcdQCnL8H6JwhNxAnWvEHRUlI9d4byiRfRfuOR154QBEv2pVJ1OTZbJD00VFNHVbFYYiqaZN98p8dIwmEk4XBDu3e2S2wrcRC6JPooqaAH6kGEsIj3p5jJFxkeSGM3MGLVlxJfq95oYWyAhUFOkVg47bHdoq1uYdCjtrORShlRwx1hLJlCA74OD/XnvvYg173hbgA0gvGXwqjCc1//Ys3bFlrheD2QntMKS+eXPVSWZeJ2bFMUJ7ab8rnzlM9tPB5bA8lYkRZnvsJ195AgWEBpqFRcXs6VQmFQg+eMlJLnTo7zfT/8Ix3Yw95gWx1BIyMjlEUZ2QUL5bVIxOPMlKbpr/r09dUnDpTW8xMYN6cwuIgQ+J4kd6FMsj9GLNEe5RaNSHaP+ji1CoN6PO/vuSe0tb3pptraxpokOXthyez51dEI0qP7ueaOu3j8gU8RT2UYO3DtsmVmz42z8w131bxdPb/eeKHQ8L63ChnksVfp0SkEm6M4sZfQesHFohXrWhQElg2RHhAECyitKZVdXpmrkB0eDsdb10C5XOFbx87w07/7jjbvYe+wrcRBNBqFfoEs9444AMhkBjg3N8ve2HBd3gfdtktuB6W8i+v6pFo8yCkakewe86nLj2k129kFz/uDB8N2r/vvD6MJ/+7fddRNLjk7jdAKbVmIVUL8Egupwxf7tn/x/6y6jkf+9k/Iju7m2a89yPiLzzFz7gwDY7vZeeC6tTcsBEJrEoX82st0CrX6kKWF4sS41XvDbHoVrS1YY35Hbc/vXUGwgFKaQrnKiXyV7PBQzcIAYDo3x46bbiWVam4882ZiW4kDgOhwAnmit8SB7ViIWIx8sUw2Xbv3gRvIjk5g7AgCgvlBTn39UeKJ5udQxCKSXTt9nHozFvV43p86FYqIhx7qSOSgLzdDtFLG7UtiLenA0QgCbbN2k+NioOmO7/vxi4+dfekZdl99/frCAFC2TdR1iZe66xeilYfN2uOji0GRWLT3ixN7AQEoLdC6viDkZhAECyilyRfLnCj7DA4PLZuuuBGu5/HksVP80L/5D23cw95j2x05mb2ZsOagx0glU0wWS/g1uuh1ZQJjhynnPfKzZWQTEwdjUcmeRoQBhKJgZiaMFhw+HAqABVZ63t93X7j8/v2LaYc2YmnF6LFngcVgsMTG1866wmA1jj/5KCeeepRnj3yB6Ymzay63IEMHz5ypqd6hnaglhYir/l0rSrJ1ltVbHl3bd2Zp26Fly4tth8lEnGg0gm33ojBQ5IplTpYDhobqEwYAlVKZp87luOOO2sYwbxW2XeRgdM8YHt3Pl16CgHQmzVSuwM6h7IZFMkpJvC2WUriEJgc5JWKSXaM+TdU41uJ5n8uFjx88GNYprDNSt5WMvvw8Z268HWlH0IGuWxQscPktr+Unf/evLv6utUKsMjhB2zZCKQbOri0gOoVQG88AKAcV4lYcR2yO2R7dROm1D5LNFCFYiZKK6UKZCU8yODRY//5qzalzU7zxe+7tiQ63TrK9Xi3z7Yx034BnNSLRKBWhKFeqbHRjVgmC+QmM24D5QU5zdUQRErGgeWGwGgue93/+52ERYi63OOJ2YeRth2oPnFKZ2AunUJazoSHSctZfVmlrvkBtEQ0gBIPjZ4i61br3tZVIWcailm4JTTEobpejpCnURQ/MkM0YIViJlIqpfJnzAQwMNCAMCL0Nvv3iSX7gB36g9TvY42y7yMHIyAjH1ROrDWbrCdLpNOemZ9kfixJZw/tAKkk12NophUuoY5BTXzxg56hfl7mSDmo0klrL835BEKxmO6tBtdgRclplOC4vw/32NOzeDekYeK2rpVHawiKMIGhAOw7RSoWxY8dato2G2SClsBTPFCfWhNYWaIWCTRkhWIkMFJNzRWawyWTTDa+nNO9tsH///tbt3CZh24mDsbExKtpHaoXdzLSXNmEJi1hfH7P5EsMD6VVDWYGct0veZAdsS9hgkFMyETA2Up8wANBSkX/pFP0H9tQ2GKcOLMcm//KJlqzL0xGOy8uYVgMACF9if/1l5KHrIGKDv5FAqP19UdpCoNARG0tr9jz7LHYL7L4X6BvoZ88tVzK4dxS7noFc+lKbZK9UZPLF5znznW8iV3gwlExx4pro+f8KDbatiUQ2ryBYIAgk53JFCnaUdH/j3QVSSp4/eXZbeRssZduJg9HRUVzHQ0kZHgA9SKIvwfSFaVJugr7EpXc81UBu+1DpxUFOfRH6UuEgp1Sfz9gO2fBQm9Of/iLXv/9foKVqmTe9lory+Slmn3mxyTUJzqlBTgZ7kCsOWzGRx3rkOOqOK2oUCLWxEDGwtGLX88+Rmp1pyXoBUsNZXvtj92BHnJZ452ulGNx/BWM33MRjf/ZHy8ZjS60oyypJu6/p7WwFFgSBhcZGYYvwRsOxbaLtcELqIEEgGZ8tUInGSSWbc8qslCs89soZ/uc28jZYyrYTB2HNgYuUigYdiztCJpvhfG6Oy6KDy7wPNsMExo4hBG4lwHcDRnc6jO1oLtMy853nePq//G92v/2NpK/Zj6jFFGHNDWr8QomZp57lzOcfWnaxqpeKjvGy3EterR0etV6cBEDdcTlE5wXCKgqy1rdHC8CxQGni3zpLanoSmu8qvcgVr78RO+q0rMhrIdozcNk+Rq+9gYmjTyz7eykInRNttmdx4iWCwNLh5EYBYIVTBHuviasugiDg1HQBP95HMtm8EJzOzTF03U3byttgKdtOHAwPD1O0XFQLw6PtwHEcdNShUKqS6U9eDJMHUuJv15TCamiIxwNsyyWXt8n0x+oyN1lJ7qmXyD1V21hvHdE4g/GGt7Xh+oGzapTTwU5UDRc168VJRKGKfP0BSMfDCVfBijP+Bm+NBrAFWAKr4JF4dBznfInz1hBjAxeIRloz5GvHgV1tqf5WUjJ84KpLxAFoin6JdCS9bQ6djQTBUgTQQ8axdeP7Pieni6hkir5E88ek5/k8cewUP7zNvA2Wsu3EQSQS4do3XMuO0u5V1WXgBuROXEC1KDTbDKlUP5MXpuiLR4lFoyjNvF1yt/esR9DQl/QZGlIIC6pVieuWyWRiJGId+Gq3MbdT1H0ck/soq/rugMREHvszT6Fuuwx9zShEnbD0XKrQVH4VNIAlQlEACKmJvDBN/InziHlxIZXF+VwoECJO88eG3aawnbAsnPjqFwdXuXjKJ2b1cMiwSeoRBJc8d5NGDjwv4PhsATvVT2KNz75eyqUST53L8cvbzNtgKdtOHAD83qd+f92/u8Uqj//xER776Jc6tEerIwQkMxmm5wqMDmbRQHWrexvUioZkymdwUC2beKs1zM64VBIBmXS0vXUlsvXqQGqLU3oXE8Fow+sQvsR+9AT66bPoK0dQ14xCXwSc0AUPQfjlChvYw981WGWfyLFZoi/PYpUvTYME0uZ8boidAxew7c15JSnKAlFrILxgbhGaEQTL1qMtlKbh8fHdwHV9js/kcTJZYtEW5b205vS5Kd7w3e/Ydt4GS9mW4mAjYqk4r/uZu/EKVZ78s693d1+iUWaLJdJVF8uxt55dciNoSPX7DAwsFwYLCAtcVzI5VSGTjtLXpkFOKFraEpvTaV729+LSmrY7UfIQT55BPDUO2QQMJbF3ZNHxCNoWCKkR1QB7toI9U8Waq7KK99Ey/MDh3HwEwbY2X1msVJKyrGz64sSVgsASOkw91ikILiJAqnnBuBlapHVoa3xsukgiO0CkhYWU5UqVb714kvf/TPtt0HsZIw7WQCvNje99bdfFAYTFiRPTMwxkM5vjwG0nGvrTPtns6sJgJbmcR6UakMnEcFp8FyCEhVbNdzb42uGE3MOUGmrRni1HaA2zZay5KolTzRsYeX6E87NDjA1OY22kJuqhQ+Oxy0GZuB3H3mStjS0XBMuYjypthpsPDVXX49h0gb7BgTX9YBqlVCwxGenblt4GS9lcR0cHEZZg4PImy99bhGVZBALOza09aGZboDXpOoQBhFEEz1NMTVYorRIqb5omUwtTapDH/evbJgyW0spQuutHmcwNtq7sYmE89n33hfMq8vNTHw8fDp0ol3LPPfDDPwwf/nBDm9Joiv7mcE4MR2RrBAqHgKgIiFgKxw7PC+H5qTWfq9ZWz9cdaA2VqseLMwVSQ0MtFwbb3dtgKUYcrIOwBJbdfXGgNRQqHmdzJfweKJTsClqTzgZk6hAGyxAwN+cxNVMhaOHgLbVGkd9GuDrGs8GVvBRcTkBnCuSsFt8RVtwYU7nB1qxs6XhsCEUChM6TK2dV/Lt/B5/4RFPTL13l4qvetFHfSBCIFgqCpSgt0D0smZSGcsXlpdkC6aEh7Lrmr9fGgrfBvR0cv96rGHGwCXBdl5KvsRybc7OltlbJ9yRak80GZNINCoN5hBUOcpqaqlAoea05Eda5Co3grBrhcf86cirT/PbrwGrDAKJSNc7UXLb5FS0dj71vXzjDYi0WxmM3GDlYoCB7J3rQLUGwFFXjZMZuoDSUy1Vemi2TGRrecDBdo0zn5hi89sZt622wFCMONgGlYhFfC4SwKLiSQvlS+9gti1ZkBwLSTQqDZQgo5n2mpqt4K30A6qWOtEJJx3nKv4YTwWU1+Ra0mnZlyIqVPqbzTQqd9cZjr6RF47GlCih3caxzLwiClfTiOHulNMVShZfnygzsGGqJo+ZqXPQ2eK9JKcB2KkjsULFTq1FaMVNyEfNXRtu2mZgtk4xH2naQ9AxaMTAo6U+p1stYKxzOcmGqQqo/Qn8y0pjtcg3iQGmLM2qUcTmG7qIeF22cJZIvJ7EtRTbVxDj0WtIEC2mHFo3HLgeleefEznwuqxUVCjFfDdL1WS+CXvOGU0qTL1U5XqwyNDyMaGOfZblc4smJWX759a9v2zY2E93+NnaGtYqdjhwJ7zw+9rHFx3qMaqVKJWCZEFBCMJUvb+30glYMDgbtEQZLEBaUCj6T0xXcBqYa6g1qDvI6xePBdZyRu7oqDCAc6tVOZov95EvN+dlfwpEjYRRhIULQ4vHYGk2pzWOd14wQWEsiBD1Q+CwA3UPiQClFrljhRMlluM3CAA2nJ6Z44/fcu629DZayPSIHS4ud9u4NRcLJk/DQQ+HdSj4P6cbHeraTQqmEBOwl4UUhLKYLLtlkjNgmH5SyKlozOByQ6tOdka9WOMhperpKX8ohnYrWPtVxDXEQaJsTcg+TariFO9o41pL/tpPpQgZLaFJ963fWaKmglsjXwYOXjsheZzy21hpV6/jtearSJW75RFvsnKh7NkKwNr0yX0EpxUy+wrgXMDQ01PbsSrlSMd4GK+jdb2krWa3Y6ciRUBQcPgwf+Ui393BVpFTMlnws69L8tO04jE+X0HqLhQ+0ZmjY75wwWIKwoFIMmLxQplprFGGVk+m0yvKd4IaeEQYAdPBu6EIhQ7m6vo3t3LnpDaMujSCAubNn6n5eQZZaEj1YiBDYPRwhWA+tF/wOuoeUiqm5EhO+YnBgsCNlF6WS8TZYyfYQB2sVO+3fH96F7N8P99/fzT1clUqljBssTpxbjsCVMFdo3tSmZ9CK4R0+yWTnhcFFrNBjfma6yuxcdeNWxSXiwNURng8O8EJwgED3VkTH6uAbqrVgai5L1V3bzvbkY88hLNFScauVInBdJo4+WfdzpfKpNFicuNkFwUUEKNXaz6ReZKCYnCtyQQmyA9mOCAMpJc+fMN4GK9keaQW4tNgpm13MW2azYZFij5EvlFEWa9a1W5bFubkKyb4YEWeT6zyt2DESkOjrjUhIrYOcBAKlNJPs4ESwpytdCLXQULFlEyhtMTk3yGh2mlj0Uj+B8y+e5snPfJUDr7+R1HC26e1ppZg+/jLPf/6zuIXG6odKQYlYjcWJCykDgcLeJCmDWtB6ftBGF1wSZSA5lyszZ0dIpzvXSrjgbfA/f9d4Gyxl+4iDldx002JB4hNPNGWo0g583ydXCVZNKSzDtjk/U2TPjnTPu56uiVbsGPVJJLq9I5ey0SCngkhxwr2Cst3bfdHtLkZcjYVJjjsHpohELk3TTDxznIlnjmNHI5cY2kj/LLauvfMhcKt11xqsZKE4sd9ZfazzVhUEi4jQCEl1PnIXBJLx2QLlSJz+VIuLWjdgOjfHwDU3GG+DFWxfcQDLXdhWwS97qGb74BukUq7gKTZsVxQI8m5AqeKR7GvRVLIOIlAM96gwWGC1QU4Sm5c4wAv+tQzIWWJ2D5V5r0I72xjXQyqLc7lhdg5cwFlj1LP0fKS3GF3QWiG888jVCjrazMrixK0vCJYTuiR29n0PgoDTM0W8WIJUsrMDsfx5b4P33vf+jm53M7A1v+EtQAWS419+vjsb1zBbLKNrbN2xbYezs6WeNDBZD4FkpMeFwUpyOY8XZxJ8wX8Tz8vr0cIKp9n1ODV3X7SBQNqcyw0hZW2nGxXMsWqlZ4coyhIChbWkhiCyGWsIGkDrzl4SfD/gxHQBP9FHX4eFAUCpXOKJszO83ngbXIIRBytQUqGVopor843//vmu7IPruRRdtXFKYQkSwXR+8xQnWkIxMhoQW7+ovafwtMPj6ma+UD7IK5MRivODnKTszTqDpbRy6FIjLIx6VrKG/VC5tu/Pekjl46rythEES9F0ziXR8wJOTOchmSLRjTsE422wLts2reC6Lo9/+dsMWf3LfLqlGzDxxCle+uyTlC8Uu7Jv5UoFT4NdxwlJCIupYoV0Mkos2tsfqyXCGoNYrNt7UhtawVnGeELegkt4d6M1zM35VMqKyKimv7Np0rrolMfBRnh+hPNzQ4wOrD3qWSsPm85PH11mVCygEFTps2N1HYNbA4HqQIbM83xemS7g9GeIxbuTDjXeBuvT21eRNhKJRPjQT/wCd1k3k0z2zplda5iZKzd0p2LbDmdnSlw+mu7ZOx1LSEZGA6KbQRhoKBPjSXULE3r3qot4vmRiskI85pPqi9GLVaGrt8J2h6oXjnoeHZhe9Z1SMtexfo+VgmApWmvmggqDkb6ePZbagYD2igMNrufz8nSeeHaASBdN3EqlEuedhPE2WIPeOWt0GMuysAccZI+ZiVerFcoSrIamjgmqgSZX7M30giUUo5tEGGgFx/VeHvTvXlMYLKC0Q75UYWq2gN9kxXw7ED12mK836lm0OaUgCE96FvPX/LVmGwmoBC6ekmxtn/JLaZtLooaq6/PSdIH4QHeFgfE22JhtGzkASO7sR071VhFfsVQmUGDbjd2tWJbFuVyZ/r4Ydg8NZrItxciYT6S3vIEuRUGeFE/IW7jASE2BACnDw8gPJFOzBVJ9MdLJBKs9OZmJc9nVw0TX8E1YDbfscfKFKaqlS/0CaqGbxYhrUarGuZDPMpzOXXxMyRIWjb3G9VgvQrDRE3N+mR1W/3YKHqC1hdatDZhoDVXX5dhMkdTgEI7T3TqdSrnCYy+f5g9+x3gbrMW2FgcD+waRT/RO5CAcNOIimp1Vbjmcny2xa6i/J6LcjiXZMRb0vDAIlOCYvpLn5XUoUftnoNTyw6hYdqm6AQP9CSJLXvRbvv9Gbr/zAELU50InRGi09NW/f5Zvfv6lmp+3+PzeEYlLKZT7sNAMpucA0DLXsnU3LAhW4KuAUuCRikSbW9FmQYQXcq11y4yztIZy1eWV2SL9Q0PLary6xcxcgYFrb6S/v7/bu9Kz9OZZo0OMjY3hdbFlaiWVSoWKBKvJ6WNCCHIVn7Lb+ruwenFsyUiPCwOtYFoO8GX5Vp5VN9YlDELsSyLPgZRM5Yrki2W01lz/2st49V1XXjzhCiFq/oHwO/Gm772BvdfuqPv19ao4AJgrJ8kV+9FaYenmJqPWnDKoc6UFWUa2YQ5Er6LUgktiC9aloVSpcmy2SP/QcE8IA9/zefylE7z3R36027vS0/TuWaMDjI6OUsHr9m5cpFAqEXZ6Na/Ybdvh7HSpLcNtamVBGDg9LAw8ZfOUvoGH1FsokGl4PcEaLXrFisvkTJ6rb9vVdIuYlIprb1+//mE1ejGtsJTZYj+FokQ0INTbIghWoJQmH1To+kSijjDvktiCl6qUpliu8HKuSHZ4R8+kOcvlsvE2qIHe+LS6xOjoKGXl9cQxHwQBueLqExgbXicwnW9smEyzRJx5YdCjiSutYEKO8EV5Fy+rq5teX7COwY9Uisxw34Zulxth2xaZ4fo7a3qtIHE1KlWJ69dWqdoJQbByg+VtVJwYTmZs7nUqpcmXK5yYq5IdHmk6GtoyNJw+d8F4G9TAtn53xsbGcIXfE86ClUoFV4mWhoCFsJjMV/C8zlbQR5ywXbFXhUFVRXlMvZpH1Buo0BpXNrWBEVKzwuDieuo8yVqi3VfO5rHwiVhFKm4GN1i9573jgmCVHcj55Z64kWg3qkmXRKUUc8UKJ4ouAzuGe0cYAJVqhW+9dJIf+qEf6vau9Dw9evruDKOjo1QtD6kCbLo7lyC3wQTGRrEdh3OzJfaOdMb7IBYJ2DEqaWEApGVoBafYw1PBLfiitZ+3VD34gmlsGuPuqwe49c597DyQxa512qeGatnnxNEpvvmPr1DO156us8UM1vwdecXNYIkcEdtvWVFhq/BVQDnwSG7x4sSLLokNdBQopZgplDlTlQwNDffc21QslpiyjbdBLWxrcTA2NkbJcpFta+ytDd/zKFRlS1MKiwhKniJf9kgn22swEIvI3hQGCor08bh6FVN6tC0nLKl6Mwhn1Rkc3HVllnv/9atAiPru+AQkUlGuec1Odl81yCd/81F8t7ZOoJidm/8/jQAqbhYrPkPEkr11cRGQl2USdqSn7oZbT2MuiVIqpgtlznmKocHB3vrsCL0NXjhxlnf9oIka1EJvntE6RCaToRpxUV02QipXKri6fVXllm1xdqaEbGP6JBYNGB4Lek4YKCV4UR/gweCuUBi0azuNzFc4ehQ+9rFwbPj997d+p6h/VPPNb9kL1CkMlm7PtkgPJ7j85o27KgQaxyoTtSpYlsayFrozBOXqAEEPCi6lQufErZxfEIRRtnqQgWJqrsRkAAMDAz0nDCD0Nvjmy6e5d40pvIbl9N7R10GEEDiDUWTQPXGgNczkS+0P+Vs2k7PlttRTxWMBw6OSHilGDlEwqzJ8Wb6Fp9XNDbQn1kfdaYV8Ht7//nBs+E03hb9DKBKOHGmZWKg3rbDryixWgwZcC0ipGLs8u/r+oLGEwrYUtq2JWjMXBcFSNBalXhQIy4oTty713EfIQHJursgMNplspieFAYTeBtlrbiCdTnd7VzYFPXbkdZ74WB+yiwe667qUfN2mlMIiQghmKx6VFnsfJOI+wyO9JQx8ZXFUXc+X/bcyR7Yj21xphLQhDz8M+/aFQgBCkbDw/wcPQjYbRhSapN5oVCvazQTgRKwlvy8XBJa1qIVj1tya69HYlKoDPTkSey6oNF3R38toZdUUHAkCyXiuSN6K0J/uXUMh421QPz10Su8OI/tHCbpYc1AqFvG1aKhwrF4WBjO15KSmIZHwGdqh6JWOIK1gUg7xpeBtvKSvgQ7mhetOK2Qy8KpXhUJg3z44eTJMM+zbt/j3J55oer+6aYC0liC4+HfyWGL9ThqtbUrVLD3lQSTAkz7lwGNLtjYucUlcjyAIODNToByJk+pPdWjnGsN4G9TPti5IhLBjwRNnu7JtpRUzJbejJ3Bfw0y+wlCmiRY+DX3JgKEhRa+Y71VVhKfVjZzS+7sS1pSqTqengwfhoYcWowOZeQOmubXvpOslDNZ35wOyhN5QNEbFTE3rUjpCsZolFc91Uu+tj4C8rGzZ4sRFl8TVX5vvB5yaLRLE+0j2JTq6b3Uz723whu9+R084NG4Wtr04GBsb4wV9sivbrlaqVAKwam0XawFCWJzPV0j3xYhEGjhQNCSTPoMNCgNhCWLZfqxIbV89rRRurojyV7/D1ArO6N08qW7GI17/DrUIywpdEh27jjvJD60yR/7k/Hdxbi6MLDRBy0Y1Hz0apjz27oVcDt73vqZXqbUk5hRqXl6pKOVqlmQ81zNDkJRS5IMq2Uhii411XnBJXP277Ps+J6aLkEzRl+jeMVcrC94G//7f/ny3d2VTse3FwejoKN9R1ZYOGqmVQqmEBOwO3+patsPEbIm9O/rrO6k1IwyE4MYffwcH3nWQWLa+EKR0fca/+iTf/m8fxy/OOz4qKJLgSXUL5/XOOnemPShpgb16/YqqJS5+8ODihfjUqbAOYQV1DWxqxfdqoXDygQdC4fLZz4aPf/jDoXhZYz83whGzdT8nUFFKbppkLN8b12IBJVklaUeJ2FvrVKq1WLVlwfN8jk/nsfszxOKbYPY6obfBpB3n8ssv7/aubCp6JCjcPcbGxvCtANnhdkYpFbOl1tol14pAUHQlhXIdcyU0pPobjxjc9JPv5Lofe3vdwgDAjkXY85ZbefNv/VsgDHm+zH4eDO7qGWEA63sdzE4VUbXUttx3XygSVrngykAxPVmoWSDU28a4KqsVTh4+DPv3w733Qjq9+Lc6iFn1iwOAQMapuKneSfVryPlbr7VRaeuSt9h1fV6eLuBkBjaNMFjwNnj3D/5wt3dl07HtxcHo6CgVy++4EVKlUsYNWhj6rRPbtjk7U6rNOlpr+tM+AwMNphJsiwPvflNTkRnLthm8dj/OgWt4WB7kSXkrSvTW3ZpcZ77Ck9840XRkynYsvvP140zOzOH6G3edtEQcrFY4mcsttl5CGO2oA4FLxGp85ocn+6h4yd4QCAI85VOWPr2xQ61Bw6KY1VCt+rw0UyCWyRKN9vAktRUYb4PGMeJgdJSyqHTcCCk/b5fcTbRlMzm3gfeB1qTTAdls48WHybEhoqnmi5a01ly48i5mGGp6Xe1gvY6FRx98kce/+kq4nNLIQNb8s5CS+Mo/PM0zj51CKs10rkiuUEKvI2pbklY4eBBmZsJoweHDYRrhfe8LHztyBJ56qu5VRpih2apRN0hS8RO9cT0WMBeUuzoBtfXMuyRqqLguL83kSQ4MENlEwgCMt0Ez9NatVxfo7+/HjXU2reD7PrlK0JWUwlKEEMwUXQb6YsTiqxz0WpPOBmTSzXUl1Fp8uBFagxPtXT27nhGSUpr7//vDfPHTR7nq5p3EV3u/16Bc8nj+8XEunMsvf7zqUfV8sqk+4rFLZ0XU3gWjsYRmzRlNqxVO/szPhCmFo0fhHe+ocTshi3bJzeH6KQSaeKTadeMdpRRzW6g4UQBaQrnqcmy2SHpwCLuBWQvdxPd8njp2ivf+6/+327uyKdn24kAIQWQoiproXFqhUq7gqdZN6msG23EYnylx+c7M8rC31mSzAf1NCoPthKzB62Di1CwTpxrLt6+GUpqZfIl4zCObSiwTnNa6F6lFQSCgvotrPh86OO7dG/4seDPUgEVhQ2+D2hFU/X6EpYnZbncFwhYrTtRA1ZWcqpbIDA+3xByr05TLZZ44N82HjLdBQ2z+b3EL6BtLIc90KHKgYbZYRvdMb7TAU5pcvspAZj70rxUD2YD+tDaJpzpQXZzMWHV9Jr2AdCpBXzw2/7Gt/PA2FgSBJ3E2anFNp9ftUNAafG/14ynSQJfC+ggqbhoRmyNqe90VCDp0Thy2Ups7eqA11YrilekKI9cObEphsOBt8Nq7v9t4GzTIJvzUW8+OfSMEdEYcuJ5L0VVdTyksRVgW5/NlfF+FwmDQ74ww6MDgoU7STXEAoLQmVygznSuyWIqwaF3sWEucCte4dp19aaa2ItV1sB2LiZdXEwGKmJ1f5fFmEZTdDL6MdLcGQYArfcpqExcnak2prHjltF2/sVcPseBt8EM/ZCYwNooRB4TtjG6HxEG5UsHT9Q/EaTuWw7nZAoODAf0p2v/NWGvw0MLfPvCBNu9A6+mVk6nr+0zninieh12DIFjKk186iZK6YYGgpOLCeJ6Tz0xd8jebHKJtF01Byc3iK6vrAiHvb9LiRK0pFhUnzlhYdgStbIIuT6xtlGKxxHkrxhVXXNHtXdm0mLQCYcfCs+pY27ejNczMlXsy5ChlgJUOULYNVgcuckv75/fuXR6mfvjhsF1ukyGEhVYCYXXnwhB+qxQCsIVFueTieT6pVAynxtDwhTN5PvN7j3Hjwb3sumogTDHU8HXVGqpFjxNHJ3nqKyeR/qXiolFvg9oRlKuDJOMzOHb35qVIpcgHLplIvCeP9VXRmrk5xalzNo4TFrcq6aA24fRJ423QGow4IIwcfFt7aK3aOuegWq1QlmHPfi8RBD4Dgz7JfovxmRKpRLb9w5SW9s9D2D+/b1+YYrj3XvjMZ9q8A+0hkBYRq3Mn1KWCIIxGWYDGsiwQEASKXK5CX1+ERDxa07VqerzAQx9/psV76hGxSrS7KGBh1HMqMYPdJZGGgKKs0GdHNkdxotbM5hRnzkdwHGfJww4yaO0U105QKVf45rFT/P5vv7Pbu7Kp2QTf3PYzOjqKa/kEUhFp45yDYqlMoMC2e+duQgYeg0OSZMoCBFLD+VyFndlEe1MLqw0eyufDFMMmRipBu+MuqwuCpWjsFSK3XPZxXUl/KobTwVkeC7TC26BWNDbF6iCpeBcFwmYpTtSa6RnFxFQUZ0WrotZ2V8fZN8rMXIGM8TZoGiMOCCMHFcsLjZCc9rwlSilyRRfRQ1EDGXgMDEuSyaUJacFU3iWbjJKItXlfV/bPHz26+LMwwniTiQUZ2BBrVaveIssFAWyk3Gxx6WcnZRhFSCQi9PXVFkVoFTEr17mNsTjqOZWY7c4kx/nixIrySdgRum7EsApaa6YuKCZnoqt6GCjlIP3ui4NofwY7WtuAp8APmAym+Fc/9dNt3qutjxEHwMjICCVRRTZZpb0elUqFigTL6Y2ThAw8hoYDEsnlJ4Xr73k1r37v2xi7/jIiNU9O1JTOXuDkg49x7O8fbtxn/qabwp/7719eoLiJWG++Qr3UKwguosXa1skCKlUf1wvoT8WJRNofRbAoYVsenb5Adn3Us4A5v0xcpBE907ocorXm/KRmei66ZqufQBBUu1e7kdl7gMtefxex/mxdz7vZlBq0BCMOgFQqRZAIUG1UyYVSCSk6P4HxUnQoDHZIEn3LTwrf9aN38s5f+3FUILHqdEOLZZIMXr+f9P4xvvPfPrHsb4V8nXfS73vfqmOBLUtQKrT+rryV1GKEtB4NC4KlWNaG3TBKaebmKsTjDslkrK1RhGgHUworUSpK2c2SjHVn1HMvFidqpTl7TpErxsLalDUQFqgulRz0DY9y4O7v65n3bDtiWhnniQwlmu7vXosgCMgVuzOBcTnzwmDkUmEgLMHb/t/vB6hbGITPDy9IB951kPhgmOvTCk7K3Xzm3Gs4e6pU29ji9fZeaZ7+9kxT62g361kor0WY1FFYKCyhsIQ1Xxjb2OHpYNV2LRZQdQNmcyW8NUyLmkWjiDhzbVl3rQQyHPXclcGJ88WJQY/k7rXSnBnfWBiECLQnutIaOnTVjYDuvZbvbYQRB/Mkd6ba1tNbqVRwlWhrJ8TGaKT0GB6RJBKXXsCGLt9JcrC/6a0IIdhx05UUVR9fU6/n2+o1+CLKn33kRZTSBEH9AkzOP+fTf3acuZk6xkx3gVqNkFotCJatu85WE6Ugn69SKLpNC7iVOMxx6fDfztPVUc/zxYndHuuslOLUaU2hUoswCG/alRRdKUpMDI0iun4ztb0xaYV5RvaNEnyjPRee3PwExu591UNhsGNEEYuvvhfRvtbNZ5+O7+HBYPeykcpPfGOaD/30Y7z5u3dy+TVpIjUOUFJSc+5MmW986Tzf/tqFlu1ju1Bq7UOqJSmDGrAbWa8A1w3wvIBUMkYs1ppTQ7Tt3ga148k+hK9JREqdzXIIqHa1OFGjJJw4Laj60drrH4SAwEZJ1XEL4l4q3N6uGHEwz9jYGAVxvOXr9T2PQlV2MaUwLwxGFbFYZyIXZ/RlKHH2ksdPvFjgxIuFjuxDt1gpDjolCBbRTfloaA2FokvVDehPxrCaabvVPlGr1Pjz24DrJwFFIlLpuECY88vErUyH0+gaGWiOnwHPj9UVphfMdyxISaTtDbqGXsOkFeYZHR2lrFofOShXKri6nvG5rUPPC4ORUdkxYWCwQeu2pQw2RjcWOViB70tmcmWq1cYLQCOiN+tDXD+FG8Q7nmKQSlEIqh1ML2gCX/PKKfCC+oRBiEBJB6m617Fg6B4mcjDP2NgY39QeSqu128DqRGuYyZe6UnGr0WjlMjKmiUabiFocPbpocZzLrdpFYABQ4cRDNEoKIpEuFVJpLjFAaoZiycX1fJLJOE6dUYRoh70NakdQ8fpBhKOe+3fuIp7J1nzxVFJSOD+Bm6+z0FJAIajQZ0Vx2h421/i+5pWTAkkU0WCYRGOjZI+4JJpzUUcx4mCe0dFRqnaADBRWi3q/Xdel5Gssq7Nvs0aDchkZVUSaEQYLw5EeeCA0JfrsZ8PHPvzh0MBo2zuQLQoCgQhbv5RAKosIXbrbEq0vfPV9RS5XJtkXJR6P1KR1BSUcy6UXzX9CBNGBK3jjT7ybvmy2oTVMvfQ8T/31XyD9Oi6e88WJQ1ayjTcNGt/VvHxSoK3GhQGAnk8rdJ3VzkWw6LD6xBPhOcmcn1qGiTXPMzo6SllUWzpopFQs4mvR0XYcrTVae+wY080JA1g+HAnC4UgnT8KTT8IP/iDcc094IG4rFBYSWwQ4QmNbof/CwvU4zNN277AKUxjt+b6Vyh5zcxWCGlp+I+ToXWEAlm3x5p/+QeL9jV9Ahg9czbXf8576niSgKj2q7RrrrDXVqubYSQttRWn2M1DKRgY9IA5WOxcdPhzart97LwwOhuZp2/781DpM5GCe0dFRylbrXBKVVsyU3I7WGmitAY+RsRbNiFhtOFI6Hap3WByStOVRWGiEmI8QLFYXXoqAIOiuOGjnNTmQNQxy0oqYk2vfTrSAkQN7iaf6mlqHsCzGbriZ5w5/GiXrqM2YL06Mtbo4UWuqVcXx09b8ZNXmVy6wCNweqDlY7Vy09Nxz4gT82I9t0/NTezDiYJ5EIoFMgHJbo5KrlSqVAKwODbkJhYEbRgxatc3VhiMtHJz33w/veldrttOT1CEIVj6zASOkVtHKeoP1WBjklErFLvm+2SKPJXrggrIO/TsG0ErV7QmxEjsSIZrqpzpXX8tmoBTFoEq/0yLnRK0plRUnzthYdrT59S1ggewFa5HVzkX79oX/f+QI3Hzz8jksW/781H6MOFhCbEcceao14qBQKiHpjF2y1hqBy3ArhcECK4cjLfDww1uwIKhxQbCAAKQMxyZ3I6zeqmLaWpBSMbfKIKeIyHVsHxpFWKJln1BDAuNicWKs+SmtWlMsak6OW1hOC4UB4XwF5dKtr/NyVjsXHT0Kc3PhuWjpoLYteX7qLKbmYAnJPcmWpBWkVMyWOmOXrLVGiCoj7RAGa5HPQ4NFXL3HOjUEjZwMBSht0x0rPtV5P435QU6zuTK+r4CAmL21vSxahdYwF5Sba23UmnxBcXzcwnJaZ2S2gBCAtHqznfHkSfjpn4Y///OwviCXCx/fUuen7mEiB0sYu2wXPuWm11OplHEDEG2eeKe1wrY9hkd00w5mfrWO2GE6Db/5m2v+2WtRaqZ9NB8hWHft2yCtsJKFQU6p+AzptO65KYQ9iYCK9HBVjJjtULca1ZrcnOb0OQfHaZNJkRAQOCgpse3OfbeCSmnjtM++ffDII5c+vsH5yVAbJnKwhNHRUao0P/UvP2+X3E5CYeCyY6Q11qbTx89RyTcvjABePNrdQTur0+IIwXpbUnbXPPwt0V3bWeVOMTNbwvN6e3rmmhw9Ch/7WJjbvv/+9m9vvjix7uCB1szMas6ci7RPGDCfJtN2x9sZ506/YiYydhkjDpbQCpdE3/fJVYK2hncXhUFzVrkLKK04WRngf3/sufD3BofvKKX5+oPnuHC+2vQ+tYZFQWC3WRAs26pyUN04tCyrozUHKxG6TNR2QQsK+Sr5QqXlg5zaykIv/X33hbnrfD58/PDhMGzdJnwlKdbhnKi15sIFzdmpCHYDE1TrQ6ACC9XhtMLMS89QPD8OgO6RiZbbDZNWWMLo6CguflMuiZVyBU+FfdTtQGuF47gMj9ACAaIpSYen5G2cE/v4zu+fYnbO4gf+2eVceXUa26m1Ol9z4XyVrz5wjk//aevnU9THYsoABFaLUwa1IIRASeiw9xVWraOa20SEpXbJAt+VzHolUqmFQU49fie4tJd+795QJEDYDvfnf96+7QooBNWaihO11kxOKqbmop0bhqQjSOV2ZlvzqMDnpX/8BAOXX016z+XYsfiS/YFCqYwb7ePKK6/s6H5tJ4w4WMLY2BgVy0MGsjGXRA2zxTK6TflWrRSRqMvQDmoauboeSilOyD08q25G2gms+RP33/zlCf7mL0/UtS4LzZW7+7G7lmfuviBYTuiS6HTYJbGrKQWtidlzLBcAAjQUCy6u65NKJbB6uRZhtV76hXa5NqO1Zi4oM7iOc6LWmolzitlCDLvJ478elHZQsjUpx3rQMmDm2LPMHHt22eOVSoW//tI3+Jnf+WjH92k7YcTBEkKXRB8lFY0MIXM9l6Kr2mKXrJQi2gJhoNHkgziPy9uYtceam7q3sG/A5GyVnUOJptdVz1Z7SxAsstjO2FlxYHfx9Vs6j21JVo8OCHxPMTtbIpmMEY/3aBRhvV76djNfnOipGNFVihO10oxPSOZK8aZvDOpFKZvA750akmKpzFkd5cCBA93elS2NEQdLCMVBGdlgjqtcqeDp1p+klVLEYy4Dw80JA19qjskreEHfgLAjF6MFzSOYKXpkU1ESsXbevWosVE8KgmUIkB23UNYdv2gsZeMJjGEUoVR0cas+qf54R6vfa2YtX49OICDnV9hh9S/7WiulOD0OpUrnhUG4WxbS641WRikVL544y7t+4Ae7vStbnh48OrtHNBqFlGjI60BrmJkrt/xipaQiHm9OGGgUF4IUDwVv5kXrVQi7ec/1lViWxfh0uQ1V+npJUaG6WFRotbmosFkC2QVx0K20ggqIWQVq+0AEQaDIzZaoVDy609ZRJ0eOwKlTixGFS2jda/BVEBYnogGNkpqTZ6BUjTbt5tgwFgSdLTlYk0q5zDePneLd7353t3dly2MiByuI7kggT9QfQqtWK5QlLekeWEBKSSLhMThMwzMaXAnPyes5rq/Gstv7cXtSM513Gco0a8aySSIEayCAsJe1s7ZyTpfEgcMs9V23BCAolzxcNyCViuG0vep+OZVCqXaxffDg6v30hHVAXqnUuh1bKE60YwgNx0+D68c6Orzt0l0S6AUd1+XDcGauQOrKa0mbiYttx4iDFaQvS6Nerj9yUCyVCRTNW6HOI2VAX8pnYKAxYaC14mwwzFF1G67d38IUwtoIBJNzFdLJSANujZtbECxDgJQOHT2b6s5aJy8lYuVo1E5SBoq5XJlEIkaiL9Kxi+C5F06gpEJYjU9NVUqSO3kC6bX2tlprzXS1zNxEH77qrjCA8JPVgY1Sqm1dWLXgez5PHTvFe3/qZ7q2D9sJk1ZYweieMbw6C8mUUuSKLqJFUQMpA1JNCIOytPmm/yq+qd+Ma6fpqNwXFhMztfocbM6UQS10fGyzZXfnIqJdYnYzlewCsKhUPOZyZfwOjQf2Ky7f/OQDoMO7fxnImn/U/D765QrPHv50y/et6iu+9Owck2XVdWEAgBBoaTVci9UqyuUyj49PcXChm8TQVkzkYAVjY2NM8nxdz6lUKlQkWDX6AqyHlAGpfo/MgEDUqd2UUpyUu3hGvWpZe2JnERSqAYVSQH9yta/XFooQrIPUnQ2TO13yOIgwTYvGFyGlZi5XJp6IkEzE2m7BfOrx55g+eZbdNxygbyBd84VYScns+BQTzx0jygyRForZiqt49CWPSuBwUubJxGLYnZ6XsQIhQKvQQplI+9wY10XD+PkLvObQd3fO32GbY8TBCkZHRzkpn6zrOYVSCSman8AoZUB/2iedrVcYaAoyypPBLUxZl7WkPbEZLCE4O1vmqkR6Phe9PQTBUrS0O5pV6EqxmoZYwymF1RAIBG4lwHclqf44kUh7LwSlmTlePPKdhp8fHdjHvu+6nOyunc1FDjUUc3N8+QtPUA2OIRCUpMdEucieVIejf5cgUNJqyVC6RqlUK3zr2Cn+3W9/oGv7sN0w4mAFo6OjVIUf5tdqOOEGQUCu6DftbSADn3QmoD8bniBrJVCKl+XlPK9vBDvapWjBUjRKKSSKqbk8uwb72C6CYBnCJlAWnaqzs7qQIbR0HscKaP2FS6AU5OcqxGIOyWT7owiNMHjZGG/56R/AijhhiWUz/iNaMyQVP/m6O/jy332Ff/jTw1jCYrxSYEe0j1i0S3fsC/unHGST1vLNsOBtYBwRO4epOVjB6OgoFduredBIpVLBVaLhbgKAIPBJZ/26hIFGMxP08VDwJp4Tt4EVo3t3F/OCQPkoVcWyXKKRgFy5guvLLVFDUD8CpTr1opufytkIG3sbNIvAdQNmZku4PTjI6dZ3vQUr4mBZVtORGyHExTkJb33PWxi9bBSAAM2J8hy6yyOTQ5fE7tQcGG+D7mDEwQrGxsao4oYuiTWQa3ICYxD4ZAcC+jNWzcLAl5qj3jU8JO+iaI3UFWloHSsFQZVoJCAWs4jFHBzHJuLYjM8UNtfwnRYiZefEQcc7FZSsw9ugGQRoQbHHBjlF4jGG9u1qiymRkorrb78OCBMtU16JObe7w8yUcpBdEiiVivE26AYmrbCCHTt2UBTVmiIHvudRqMqGByAFgc/AQEAyXVvEQGvFuWCAJ9XtuHamCykEjVIajUQQYFka2xZYlrW6Z74QeFIyW6wy2J/YXlkFFoyQOnBC1WB3WOfb5LCsTja+99Ygp2iiWS+PtVFa0dffd/F3S1icqOS5qavFiRZBtTuRg9mc8TboBkYcrCASiWBlLGRx4wOhXKngarAbuGsLAp+BQZ9Uf20x96qyeDq4kdNc1eGCwzoFwQps2+Z8rkR/Ikq0zcVlPYUA3bF2RtHxyEHUmqHzF+clg5yqPqn+Hh/k1CiXBEcERd/jXKXI7mR3ihOFBbLa+aiN7/k8abwNuoJJK6yCsyO+YeRAa5jJlxoqspOBx+BwbcJAKcVJb4QHg7sYt67q0Mlw45RBPfshbJtzs0W6nDbtKGHkoDNiSFhWZ/vhm/Y2aBaB7ytmZ4pUKj6bwoK5SSzL4ky5gNulAUgCgfI7v13jbdA9TORgFbKXDSBfXP9K5rouJV/X3aUgA4+BYUkyuZEw0BRlhCflLUyKvVhtP/mvjBAobNuqOUKwHpYlKLgBxapHOhHdHsWJArS26UQ/oy0663EQYZbuf4gLFswunttDg5yOHg1nMezdC7kcvO99LVu1j+ZkOc9V6YGmCqAbYdElUXcuWmO8DbqKEQersHPPTjzm1l2mVCzia1HXBEYZeAwNBySS63/RpdK8ElzGc9yMtmJtrC1YTxC09mB0HJuJmQLJXYNdHS3cSWTQvDjozyZ43V3XcM2tu0kkV89zC3GpdXKl6PHKU5M8/uXjlAstbEHTELN6QRwssDjIqS8ZI5GI0LV9y+fh/e+HBx6Akyfhs58NHz98GH7v98LHF/jwh+FVrwoHOt13X02rtxBMVUuMxvrIxDs5Hp3QJTGwkDLAsjrTVlmpVo23QRcx4mAVxsbGOKsvrPl3pRUzJbcO9a5DYbBDkuhb+6Kr0cwFCR5Xt5GzRtskCjonCFaiEEzlyowOJLdFcaJSzb2fqUycf/PhdzAwnKx7BoDWml1XDHDjGy7jz37tYSrF1ggEoQs4lk/viAPohUFOADz8MOzbtxg5WLjo33sv/PmfLy53+DDs3x8+fv/94fK1hs0twfHyHDdHo20/XpciRPh9VlJBhywXSqUS4ypivA26RA/E4XqP0dFRyspdM5VZrVSpBNQ4hGReGIysLwx8qXnWv4qvyLvIt1wYhIJgsYagsqSGIFJ3DUGjWLbFhWKFag/2rLcDpZ2m0uGvu+saBoaTWHb9NQVCCCzbIjuS5OaDexvfiRVExGzL1tV6Fgc5lUsuWne4FiGTCaMBBw+GIuHkydWXy+XCKMMCR4/WvAkxX5x4vlKis7UWAi3tmv1fmkVKxQvG26CrGHGwCqHXQbBmX2+hVCI8RDY6YWuk9BgekSQSqwsDjWLKT/Hl4K0cEzch7GgN662FlYKg3BVBsBLHsTm7bbwPbFQTn+VVt+xq2hlQAJffONLUOi6iJDErT29FDVayMMjJZ262c4OcgFAUzMyEkYHDh8OUwWq8733hckeOwFNP1b0Zy7I41YXiRK3DyYydwHgbdB+TVliC1JrpqsTfsY/Bn34X3sgeRNRBBBIxV8Y6dQF9fJLZ0+dqCOmFwmDHiCIWX33ZqrJ4JrieU1zTovZEjVKgCTqeMqgVIQRuIMkVqwxsA+8DKQWNOmsnks2P6xWWIJ5sTRzYJo9tKXpbHCwgkKqzg5wA+NCHalvuZ34G0ukwavCOd9S9GR/FqXKeK9ODHetUUcpBys6YMc3mCiQPXEMmk+nI9gyXYsQBkPckz8y4PDVTpeRrlB5g8J1vQdnOYj2ZUiAstJSMXihQ+MdvU/jcd5BT+VXWOC8MRhWx2KXBGa0VZ+UwT6rb8K3+JlMISwWBnBcEoqcEwUpsx+bcXIn+vhgRZysHrwRSWkScrdHDGemKt0EzLA5y8lxJfypGJNqFU96RI2EU4fDhsM4gnw9rDfbuDX/27at7lRaCSbfEqNtHukPFiUpFOuKS6Hs+R18+zXt/8t+2fVuGtdnW4sCViq9NlHlqxkVqDRocS+DYglKlgkNkmSrXgLbAGe5n4F+8leyPHqRw+NvM/PGD6LI3v4xGSY+RUUk0tvLirClJh6PyVibE/ibC+usJgs3xkQor9D7YPbQwuXHrEWrKDrkkthvlEnOKbM5MpEAryOerxGIOfclY0ym1usLrBw/CI48s/p5Or9uhIIRA1pIOEYIT5Tw3dqw4UXTEJbFcLvOd8Sl+4U1vavu2DGuzOa4kbeBUwefzZ4rMeRILQVSIJWFHARZotfI+SaN8BX54YhDxCOnvfS2J117Fhd/9DJXHX0Erl5ExTTS6/GBVSnFC7uFZdTPSTjQQLVgpCOSSlMHm+xgtS5CveAy4Hqn4FvU+EBAELb6YtrGPfj0ccp01WmoL4SAn1wtIpeLEYjaNfvGqhRJeuUq0L97aXSSMrE2cnNhwOYEg77tMVsqMJVO0+yASQqC8NtcKaRg/P82r77rHeBt0mc14G9A0T01X+dTxPHOeJCIEkVXaxEKhsPxAWFn9rKs+quIR2TXI2H/5Mfq/5xZGRhXR6OLbqtHkZZQjwet5UrwWaYcjjGtjaVGhu1hUGBVdLSpsFY5jMz5dQHW6qryDyFa6JC700d93H9x002LF++HDoWD42Mdat62l9Jy3QTPMD3IqVMnnqw0XxmqleeWbR1veESGlpJAr8Ny3n69pecuyOFnO43WgOFEIgXTbu43Q2+AkP/RDP9TeDRk2ZNuJg6emq3zxTAmlNFEh1nQeFKu0Ka56EVMaVXIRtsXIv/9e4vfccfFPvtQ871/Ol4JD5KydNUYLahAEHZ2t0EaEQCKYmiuzFfXBYlqhRS9uaR89hCLh5Mkwn33wYBhNWKt9rgmELhGxW2ik1BMIfE8yO1vCdRuzYD76ua/y0tceJ/Ba5ys8/so4/+MXP4bn1v5+LxQntrt1M3RJtNraabTgbXDVVVe1bRuG2th88egmOFXw+eJ4CaU10Q1MZWzbRi/JFWv0/AVstedocF1IxIj+i3dTPX+BqafO84S6nZI1hNjwYr5aykBgCRvL7pDjSJewbYupQoVsMkasG8Vi7USAaqWF8tI+egiFwL598MQT8MM/DG9+c1jw1mIizLR8nb1Bc4OctNY89FcP8Sv/8SmGdg41VFyrAccqM5Q5TTlfoDBbqHsdFoLz1RKjsST98danOS4iBFpaKCXbkso03ga9xRY7G6+NKxWfP1OsSRhAGK6TLBbfrK3KNQu1QLriQiKO+okf5ZEPPIPy1p+dcGlRIdtCEKwk9D4osm8ks6nTJKvRrEviMg4ehIceCtMIEIqFgYFQMNx0E3zgA+EyN93Uum0qScyZY2ukFNZicZBTXzJOIlHbOOjZguALT6YJlE3p5VzDW9dook6UXYNzjc+HmHdODIsT2xMQFgK0spGBxHFaf+moVCp889gpPvqbxtugF9g24uBrE+WLNQa1FFbZlkWw5IZv9VDaojAAUFj4VU10NMvNP3IFT/zp8UuWX1sQbJuP4hKEEJR9Sb7skknGt5T3gVJ2a2cvreyjv//+sE9+3z74+MdDP/8WigOLArbYLN4GzVDfIKcLc4IHn8qgdPNCXiDwgjTnZvcxNnCioUK8heLEqUqJ0bYVJwqUdNrWzjibyxtvgx5iW9Qc5D3JUzMuFmvXGKzEsu0wlQAX/11+wC0XBr6O4OkoWguUUlxx5yiJoSiLNQTBfA1Bhajjz9cQODiOs3VqCJrAcWwmciUCubWKD5RymnJJ3JB3vSsUBEeOhJ0MLe5eiFpbNaWwFouDnCoVj9VqEc7NWjz4ZLYlwmBxq4KqP8Bk7rKGXQgXihP9oH3FiVrZqDZYKF/0NviRH235ug2NsS3EwTPzPgZOHedoy1oYg6svjRqIRWEgsXB1DCnsi9pBugorItj3puElgsBbFAQRIwhWx2IyV0RvAVuABYQQKNnYZx14NZyEF3rmDx4M6w3S6UvX4zf4hiqfqCiy9aMGKwktmMslj9xsmWCJ58CZCzZfeiqDakPQVSAou8NM5XY1LBA8FKdKhbYVJ2rltEUcLHgbvMl4G/QMW14cSK15aqYKmrr6tG3LRhEaI4UH2vxzhcayQCPwdASfKHphvXrJD3Dl3WPEE5YRBDVi2YJc2aXs+p2dKdNWBFI1dpidfHESGTSnlKRUjL/U2N2/Q27LGlTVhkBKPT/Iqcor52y+8nQGRPtSgEIIitURpvOj4fmnThaKE8tee3oOlW5DWmHe2+D2Ow8Zb4MeYssf+tNVScnXOHUWui34HCymFLgoDCQ2ro6hhL1cEAiNEBohQHqKeDZG5rJkS1/PVmehOHGreB8IQMrGDrNvfvFFlFIN30UqpVGB4qkjDbQ3aohuGW+DZghrEb7xpMuffaZMuey1v2VQCPLlMWbnBhsSCNqCV0r5tgxJ0toicFsbOTDeBr3JlhcHk5UApfWGL/TYtx/h6Yce4LHDnwTCEN9n/tsv8fgXPh0enkIjhMDTUfyFXOMKQSDmTyQAWmqEJcjsS7XplW1RhMDXmun8FvE+EOHwpUaYODXLH/7aAxx/frLu3nKtNKefv8Bf/sbXmJ4o1r1tQZmo3ZkhO72N5tvPSb70eBykxalXLjBxdpogkG0NbglhMVvaw1whW7dAEAjm/CpTbRjrHBohtXadpVKJcelw9dVXt3S9hubY8iXyUxWJtUGHwszZ0/T1ZxjcuYf/84F/xXfdGyrYsSuvY+b8OEKAEg7Bwtsl9LwEWBQDq6G1Jr03BZxv1cvZFti2xWS+QjoZJxbZ/GHGQNlAY0Y5J56f5A/+0+ewHYtofOnhqkhG+ok6qxfFedUA1URxZ4TZhp+7ddB87UnFYy/EcebD3Y7jkJ91KcxNMLZngHR/X9tspS1hMV24DEtI0qnC/M1Hjc+1LE5VCgzG4kTW+I40ghAC1TrPJ6RUvHhqgncab4OeY8tHDkqB2jBEPTNxhl1XX8/TD3+eA7ctOhweeO1BsqN78EWUQNirRgjWQ1iCeCba7EvYlli2zcRMkQ6Nj28bAqAFLokyUFSK3rIfvyyplvxVf5oRBmhN1MqxnVMKSmm+8m3FYy/EsFcMNbIsC4HF+IkZxk9fwPf9tkURLGFzIb+PYjm5NMFZE66WnC4XW5oGEYDyWueSWKlUeOzl07znPe9pyfoMrWPLiwNZw4Fx5e2hIDj6lc9x45vvufh4NpNl1823YNkBxx79PEcf/Bse/MNf49TRRwgn7a2oQFwFa0uPJG4fliUoeQH5sru50wsCpHRoeYWlFliiPd8tS+dxrPZP3+tVlNI8+KjkyZcvFQaLCBzHoZj3eOXFc8zlWnsRXrYl4TCZ20+5Eq9LIFgIzlWKrS1OFAKk1bJ6htm5PIn9Vxlvgx5ky1+57BpDfpVinrMvPXtRKABMvvIiV9xwE1MnnwMCbn37e3jLj/9bDv/Xn8NxFI4TYNsBlhX+CBEghESgWBAPgScJAomUCiV124uZthKh90EB2UYv906gGuxWWA9hWW0LZ0fE9k0pBFLxua8rnjsdr2kMsmVZCGEzcTrHqZOTeJ5f9x1+LQgR4dzsAapuhHqEprbgeLmFxYki/D7LFrQz+p7P0WOn+eH3/kgLdszQara8OEg6Vk3GR7NnzzC487JLHndsBwfF2eefQCqPWKKPeCrD+eMvYFkWtm3hOBa2I3AcgeNo7IjCcRRCK2J6gp0jzzGYeYl06jjx6DiWmEKrAoHvEvjBMvGwuW+T24HNVK60qb0PpG593YSN1Z6ovwqIWXm2Y0rBl4rDX4VjZ2sTBosIbNumUpK8/OIEszMFVBu+sEJEODdzJVV3YV5HLXsmyHlVpqvl1uzDvEuiUs2LA+Nt0Nts+YLEHQkbpcOhSevdacVT/ct+f/qhBy6mGK68/fVcefvr0VpRLJWoFHKM7L8KrfXFdYol/1n4f2FZxCpV9l8xiNIaKSVB4CFlhSAIkFLiVhVu1cb3bIIgRhBE8YM4UkWRMgZYMF9QKYTAErCl/IU3wLIF06Uq2VSMRDSyKa9ZWrbYQhna5p+/Pb0NNFVPc/iIZnw63vB7awkBwuH82TxzuTI7dw8Si0XqKiTcCEWMc7NXsnPoJWKR2gSCZQlOlPMMRhPYTvNCVSsHKZt0YVzibdCOOQ2G5tnyn8pIwsESYaB/vcNicNdl3PCmu3ns8CdJ9GfYddX1lywjhMUX//B3eM/P/gqIACkFluUghHXp9dqyQCv8qTBEawmB5ThE1jgQlNJIGRBIFxmUCWRA4PlUPYHvCjw/gvSiBDIWiggZI1BRBPPh5S0sHiKOzZnpAgfGBmq2v+4phE2gLFpwXr6I1aagX2TbeRtoqq7mU1+CC8XGhcEiAtuy8SqK4y+eY3gszdBwumX1IQKQOsG56QPsHH6JaE22rwJXS06VC+xPZ5oWK1rbKNlcm+uCt8G/+c2fbWo9hvax5cXBUNwmGREUPYW9gUPh23/6/ev+/emHHuDK2+/gxjffg0ZTrVYpFYtYIoKw7PDufn5Z4djIYgV/Zq6m/bQsgWVFiERWbztSShPIACmrBEExjEJ4Pq4LrmvjBw6BHyPwQwEhZYxAxeb3SVwUEJtSPAiBLxWzhQqD6b5Nt/sgUEqA3aqUkcZqh5Ocdok5ZbZBtnEeTamq+ZsvQq4cb6nwFEJg2w7T54vkc2V2XTZEPB5tSRRBAIFOcm7mADuHjhGpYZKjhWCiWmAkFicZa26scxg5aC5tYrwNep8tLw5sIbh5MM7Xz5eXpQHq5di3HyGeSnPl7Xdw9sVniaf6Gdx1GbFYjGKhgOe5WFZ0madC6egxaFExnWUJolYEVhEPGtBKzYuHyqJ48H2qFYHv2bieE4oG38GXcWSQQOrIpeKhR0cm27bNubky/X0xopvQ+yCQFtFIqzoAdFhz0GIieprtEzXQ5EuKv/mSRbEaa1NESmBZNoGnOf7ieYZH+xnekWlJSkgAvkxxfuYKdg6+UtOoZy3gRDnPdZHmxjorbTc+rwNQxttgU7DlxQHADYMxHp2sEGiINHAOmDl7mr/6lf/fxd+rpQK//sVngdCoJJ3O4PkehXwBqQV2NAFSUn525cjm9iAI6xuiVhRWCTxoQClFEAQoWSWQJaSU+J5PtSrwXBvfd5Ayhu9HCWQcGcSQOnoxGiJEWADXTfFg2TbnZors2ZHZVHnx0EK5he+bBrvVbYwaYnaO7SEONLN5xd980aISxNrW9bGAEALHiTAzVSKfq7Br7yCJePPbFQjcOkY9CwSzXpXZapWhvr7GtysEstK4OCjPext85D+/u+F1GNrPthAH6ajNzYMxHp+uojR13yUM7rqMX/rMo+suE41EGRwapFyu4CvF5CPfJj95gb6+vq6fbgVgWxZ2dHVDJg0oKQmkRMoyQZBHSkXg+VSqNr4r8IMIQRDDDyLIIEGgIqiLaYvOiAfLEhS8gGLZJZ2MbZ7rmADdynZGYdVZTV/DKnUBxwrYPG9qo2gu5BSf+pKFJ9svDJZiWTYq0Jx4aZKBHUlGRrNYlt3UO7446lkyOnBmw4hAWJyYIxuNNVycKARNuSTOzuWJ77uSbDbb+EoMbWdbiAOAN+zs43jBJ+dJotQ3obFmNDjxOBlLc+rYFzg9/go7Bm4hnR1asxCxFxCEYfu17jyWiYegRCDzyCDA8yRu1cbzRFjrEETx/TDi4Ms4Ws2nLQQIWiMeHMfmbK5Asi9as4dFtxFAIFt3MW9HCDwqGpvcuLnQnJtWfOpLNkpEu1N7Mx9FmJuuUMhV2HXZEMlkvKnz0cVRz3OSHdmJDYofBRUtOV0usK/h4kSBCgTzLWB1PfOit8G/vK+B7Ro6idDbyJXnVMHnU8fzKKWJWuvPW6gXrTWe0liW4PsvT7O3P8JDDz3Ef/rQf6Jf7CGbvopUf//mrLbfAA1IKZGBnK97kMggwPckblWE9Q5+BH9ePCgVpi6UXiEerNoufEpqsn0RxrIp2mQS2HJsO8+OoQKtuDN3LId0vH/jBWtFSdLOs/RouUmL0IyfV/ztQzZYUXojQqIJAklmMMHI2ACO01wUQWtNuu8sQ9kprI3WpDW3ZkdIRGMNbScaP8/O69N1Rx/mcnP83j8e4a+/8GXTwtjjbCtxAPDUdJUvnimhdOsEwkVhIAR37kly89BiNbDrunz0ox/lU3/+t+wcfDXpzCiJeHPVwpsNjSYI1Hz0YVE8uJ7Eq1i4nk0QRAiCaNhxIWNImUBhLxMPwlqM+Ph+wIHRLInY5jjBWKLEyI5ZNuoE6M8mcKLrn3BjVoREdO2ccaXo4VVr70O39TT9zji9ccFsB5rj44rPfNXGsntFGCyilEJYuiWDnLRWZFNnGEjPrCsQNJpsJM516aG6ixM1mkhkipHrE8TWSFWu8USeO3acE+k9fOhDH6prm4bOs+3EAcwLhPFQIESEaOpuXmmNr+eFwe7lwmApJ06c4Bc++PNcOFFiMHsT6fQAkVY2vm9i9Pwd1EL0QarQNdJzJW7FwvMiBNImCOIEQQQ/SCBllJgT44qxbBgaFUuNqHoPoauMjl5gLXHwxu+5nre8+0Yyg8mmt6WV5vSL0/zTnz7J9NnChssneInYlh3PrHnxpOKzj0Tm71R79Asyfwz0Z+OM7cziRCIN76nSiuH+k2T659ZNGyiluD49zGCi/uJEy55m5DqbRCJR83MqlSp/++Vv8H/9l//GNddcU/c2DZ1lW4oDCFMMXzhTJOdJLASOqK8OQWtNoEGhyUZt7t6TYm//+qNRtdb84z/+I//fr/46w/FryaT3k+pPtdRBbSuitZ4vlpwXDzIUD+WSz2hsN/2xAQJl4UsHP3DwVYRAWWhtscyxcv7fbqBUwK7Rc6yWB7nj0DV830+9vrXbk4pqJeAPf+5BKkVv7QW1S8Z+Piwo3XJonj6m+MK3ojiOTe8Kg0XCGQiK0T0DZDN9DX8uSkt2pE9sMOpZExM2rxoY3bDT4VLmGLlOkkzVLmYvXJjmD7/2DJ86/Nk6t2XoBttWHAC4UvG1iTJPzbjh9EYNjiWwWF0oaK1RQKA0iAUPhRhv2NlHrIY+4wWKxSK/+7u/y4N//2VGBm4lkxklHjOjnetFAzOT0xxIX0EsEiP8CDWo+c8pgEBCoCwCaeMrm8CPEGgbXzro+dHbnRAPSmnGRs+uGqV6/3/9XkZ2Z1peJKu15p/+5Ame+MrJNZeJ6HMknUk2w4WzPjSPPy/5ypNxnHYYRrUVjZSKvv4IO3cNEok6Dd1AaB0wkn2ZVF9lzecrNHtj/VxWZ3Gi1iWGrymTzqRrWl5JxTeefJb+197Jj//4j9e8HUP32NbiYIG8J3lmxuWpmSolX180S1JL3hpLiIuPJyOhsdINgzHSG+SH1+O5557jP/zs+wlycQazN5BOp9cZEWtYDc/3UXOSyzKXrdttgVbzflQarfR8KkMQSJALwkE5+NLGl+H/az0vHubPmc2IB6U0O4YmLvGwsmzBb3z8xxtb6QbIQPHkwyd54E+fXH0BDSnrufkWxq2E5pGnFI8+F2vgjrh3CGfCBIzszDIwmGrIgllrn52Dx0jE3XUv/rdmdtRVnKhklcFr5hgYyNa0fLFY4n9/7mE+8sm/My2Mm4TNUc3VZtJRmzvG+njNaILpqmSqEjBZkZQDRaA1jhD0ORYjCZsdCYehuN2SNrrrrruOzxz+Bz75yU/yP377f7CjfAPpzGUkk8ktdx/XLqKRCLlImUK1QKZv9bvv8KJucdE9e/4cG5n/9ms06AClAxbEg1IKqSwCKfCkhZoXD560CGQEXzoX135RPKz7oQmksoiw3DymFme7hhHgRNZev6WLOJbP1ooaaB76tuLxlze3MIDFQU6TE3nyuTI799Q/yCmc5HiAnUMvkoit7mOh0Zwo57nWGULUWJyotIP0anf8NN4Gmw8jDpZgC8FIwmEk4XBDh7ZpWRbvfe97ueeee/j1X/91vvXlrzA6eBvp7BDRiEk11EI6nWZiaoJktI9IA+9ZWNAoLhEPC6wlHgIlCGSYspBKhDUPcr7m4aKvwaJ4UMoGemf2tLPFvA2U0nzxMc2zJ2NbKAI3P8ip2sQgJxHl3MxV7Bx8kXhMslIgCATTXoVZt1pzcaJAIN3ags7G22BzYsRBjzAwMMBv//Zv8+1vf5tf+MDPU5wYIJu5jnR/umfnHfQKlhDE0wmmSlOMpndit9hbeS3xsCBDQvGgUFqCroa1KUqFRZKBmI9A2Fi4WEKitIXWC6KhWxWSkpid7972W0wgFV/4hubF8VjL3SN7gZWDnHbuGSKRqH2QUzjq+cD8qOdL/24JwYnyHJlobREXYVGzOCiXy3xnfJKff/Oba1re0BtsxRLlTc3tt9/OZx/4R97zL+7i+NnPc37yZcrlMtu+MGQDEvE4OTVH1a2EF+sOEg6uskKLatvGcRyi0Sh9cYdMymYgDUOZgGTcpy+mSMUDUnGPvqhLIrJGJ8HRo/Cxj8Hhw3D//S3fZ5s8ttU7UYxm8KXi8FfZssJgkYVBTnDipfNMnp+d726o5ZkgdR/nZq7EC1Y7PgRl6TNeKdZ4/Cy4JG6wmIazUzPcfuc9xvRok2HEQQ/iOA4/9VM/xd9+7m8ZvMLl1PhXmZ6exA+2WuFYa0kPZDhbOosMWjX9sDUI5r00tIUQAmuJiHBWmzCZz8P73w/33Qc33RT+DqFQuOee5cseORI+/rGPLS5XAxFrtolX1Dt4vuLvv6I5eX6rC4NFFgY5zU6VefnFCUrlCrXUlQsgUOGoZ3+VkcuWsDhbKeB6Gw9OEEJAYCHl+sdapVrlOy+d5Ad/0Exg3GwYcdDDjI2N8Ud/9Ef80m/9HOcKjzBx7ij5fH5ZF4VhEce2oU8wV8mhdW/dFQshwu6HWj67hx+GffvCCz+EIgHg3nthaUHXyZPw0EPh4+97H6RraytDe8Ss1lg5dw9N1VV86kswPhNvyRjkzYZl2WgpOHnsAucmZpBKbngjv3TUs1xFIMj54kS9UURCgJL2hpGLcqnECU8Y06NNyPY7ojYhb3nLW/j8lx/gLe++hRNnH2Rq8hSV6lZ1tGuOVCrJOXcS11/H+KdLWLrGi3EmA696FRw8GIqEk2v4FBw5EkYLDh+Gj3zkkj8LIGYrMnGXVNQlbvtErICInp3XBXrFz2ZBU6pq/vpLMJmPN9Tit2UQAsdxmJup8PILE5SKG0cRFkc9773kzl8guOCVybnrn18EAq1sgnUiB0oqXjg1wTt/wEQNNiPb+KjaXMRiMX72Z3+WP//bP8canGB84hFmZi4Q9FgIvdsIBKlsisnieaTqrfdGCLu2S/DBgzAzE170Dx+GU6fWXnb//jBysH//qrUJji3I9NkMpCx2pGE0rdjbf46xhMdQrEomUiVlV0lYLlHhYeMDkrCrohfFgyZfUvz1FwSzxfiWHGTWCJZlg7Y49coFxs9cwA+CdT8xgaDqDTI5t+eSu/+wODG/4fGjpINaZ5lypcJjL5/mPe95Tx2vxNArmAqRTcb+/fv5xCc/zmc/+1n+86/+Ojsq15PO7CeVShob5nli0Si5yBylSpH+vnR7xnM3gMCqKasAQC2DaW65ZTH1kM1CLrfaRufdH8P3QMsiMTvAcSLEYNFVUoeOiuFdp0QqSaAgUCAVSG0RaIHSAom9ZOUrN9ZONLm84q+/aFEJYj3zufYOYRShOOdRKpzbcJCTEIJydQcX5hTDy0Y9C0rSY6JcZE8qzVqfq9YOMli7PmF2Lk9s7wEGBgaafF2GbmAiB5sQIQT33nsvD3zpC9z6tr2cGP8SU1PjuG7vhdK7Rbo/zdnKOQLZO0WcwrJoqhTiyJEwinD4cPj7TTeF/x4+DE88EdYdrINGE1Ezy/LzQoR3ipYlsG0Lx7FxHJtYNEoyHiWdiJJNRhhK2owkBaNJzc5kwI6Ex1C0SsYJIw9xyyMiPGwCwqhDqyMPmpk5xScetKgaYbAulmUhsBg/McOZ01P4vr/muy+EoFAZZWZuBLVkKUtYjFcKuN7ax4/W9prRBd/zefqVM/zwe3+kmZdi6CLGPnkL8Oyzz/Iffvb9yLmEsWFeQrlSoa8SZ0d6tOXeB40gpUQ6BaJLLbcF/MIf/SR2GyZ0Kql44cgxvvOZp+Z/lySDZ4hFW/de6PmIA4R2v+iwEU4qiZTgK5BaXPxR2kKyeIe6nLUHBJ2bVnz6KzaBim5kRWlYgtIK9MaDnLRWDKROk03PXhz1rNEMR/q4Oj2wzDlRWwIvm6EykMY6EMPODKCEjaUlMb9KqjIDk6f4k0/9Ax//py+YFsZNihEHWwSlFJ/4xCdCG+b0jWTSxoZZAzMXZri8bx+JePffC6kkgSgQiy8XAu/992/nwI17sNpgpfyl/3mEiRfOh2mDYJp+xnGczgmltcRDEEikZj51IVAsCAgLpa1lAuDMecWnH7LBirK5Oyy6xfwgp1SEnbvXHuQUjno+QaY/f/HvSktu7N9BNtFHkOwjf/XlFK49gOyLo4VAoGBpJAqNRqClRHlV3nLVrqZn0Bi6gxEHW4yZmRl+9Vd/lSeOPM3o0G2kM9vbhtkPAvzZCvsyl2N3+Q5GKoVPgXhi+cV5bO8Q//wX3kkk6rREICilEEIw/swED//JI+GgKaVx/GOkItWeCsmvJx4CrTk57vPph108GcHXMaSOEGgHhIOwFiZqivBut4deVy9SyyAnpSUjmeP0J4vzAkHTl0iy6663UbzuKrRtgQYhJSiFZclLvrNaQzWQRJOp0NOjwem1hu5ixMEW5bHHHuNDH/xFItVBMtlrt7UNc75QYEgNMpgaWDOs2gm0VlRlkXjfpSPBB0bS3HLwavZcOUokurqIidjWhukRraGSrzD+zAQnvnMKJecvvIFHSj1HdDXTpR5ESsXxU0Ueetylvz8d2lEHAVJKfN+n6mncANyAcJaFiuDrCAFRAhVFCGHEw6popFLEEw47dw8Si186yGnpqOfovr2k3n43kYEBhFaIQC5bWgiJtSISpZWm5PkMDg6htSbQ4WjobNTm7j0p9vav4t9s6DmMONjCBEHAH//xH/Nnf/CnjGZvJZ3ZRSKR2HaBWY1mdnKWK9IHiNcxlrbl+6E11aBIPKnrvntXSnFZJk0s2kAUSAPeOdLO5KYwCwqk4qVXCnzjGUl2g0p3rfVF0SAXxIPnU/E1rq9xAxtfOfg6gsTB11HkJeLBwurmnIsuoLVGKsmOsTRDQ/2XfC+09rnqriiD73gz2DZ4Hg7WJfpKCIXlLH/Q9wNENEbfkiFOSmt8rbGE4M7dSW4eirfttRlagxEH24CJiQn+0y/9R145eobhgVeRTg8S2WZFQq7rYRVhV2Z3V4s1y16JRCqoO4KhlWL/4EBDY4iV1MSC5+iLqJ6/eQ4CxbMv5Xn8JUhnMk2vTy+JOAQyQAYS3w+oeoqqH47j9lWYqvB1hEBHkTqybcSDUhInarHrsuWDnHbcsZt9P3Adlq3RnguAhcBZISIECiuy+L5orSm7HpmBwUvSFlprPDUvEPYYgdDrGHGwjfjyl7/ML//ir5B29pLNHCCV6t9WJjKzM7NcFttNMt7ftbx71SsRSwbLqr9rwdKavQODWHad+61BBUXSvIzTho6IVhIEkiefzfPMKZv+/v6ObFNLSSDlCvHgU/Wg6oMnrTBloWx8ogQ6jsIJvSPEFhEPWhPIgKHRFMM7smSvGeaa/+s2hC2QVR/bkiDCy0REWCuOHYXtiIsvXSlFVWqymewam5oXCJbg+y9PmxRDD2PEwTajWq3y0Y9+lE//xacZG3w16fQoifj2UPBKKQoXClyRPdC1yInrlYkk/brD+44QXJbNIuqsG9FaY3unSDn53q050RBIybeenOPYuQjJVKrbe3QRtSAcgiDsNlkiHio+SGnhKwdPRfAJCyYVkbDOYeHt3iTiQSlJPB3l3j94D4kdSWR1weNAY1vBRTOtyLLvrsZyFtNkrucT7UsSWyd9p7XG02ENwvuuzpgixR7FiINtyvHjx/nABz5I/kyFwcxNpDMD4eCiLU6pXCbl9bEjNdKV/LvreUSSlbq2rdH02Q5jmfrdHpWUJIJnSUR79MKkwQsCvvHtOU7PxOhLJru9R3WhFiIPK8RDZT7y4Es7jDqoKIpI+K9YKh5EGIHoEfFw+79+NVe/+zoCN8Be9l1bFAiOsJZEHBfFgdaaUtVjYGhoQ7fWhRqEW4fivG1P74hBwyJGHGxjtNYcPnyY3/y1/8JQ4tptYcOsgdkLs+xP7qMv1rfh8q3GDwJErFSX14DWmkw0xnB/qr7rhwYdzNLP6Y56G9SK1uD5AUcem2Uy30eir/OfR7uR85EHGQQXRYTnSyqewgsEnnTmxUNkvk0zhhLOMsHQKfHQtyPJO//43SAE0g2jBra9JI0gNLYIEAIcYc/v06I4CAKJtGz6U7WlhHylEQJ+4tqs8UHoQYw4MFAoFPjt3/5tvvQPDzE2dDuZ9Aix2Nb1RvCDgGDWY292X0MFfs0ggwAVKRKp42SotWIo0Ue2r6+u60PobfAyqUilp7wNYF4YeAFffGSGvNtPbJuktpahw7ZCebFgMhQPVTfADTSuJ/C0TaCc+VbNKIGOotskHm78Zzdz04/dgl9amJcQXhqEEFj2vG+iUNhCYon54kQNlhP6alQ8j77+NBGntjqChfTC60f7uGNs6wnDzY4RB4aLPPPMM3zwAx/En43O2zBnesJ2uB3kCwV26CGyyWxHvQ+kkkirQDRWhzhQirF0P8lYfW2YSnokg+eI9dhdmdZQqXp88es5yjJNtM7XtW1YKR7m/626AdVA43oWvg67LcKOi7DTohHxIGzBu//0+0gM9eGXVw5TCi8Rlh2mE4RQWEISsSwEAmFLhBAXvQ3qwZWKVNTiX103sCKNYeg226ufzbAuN9xwA3//D3/Pxz/+cT76Ox9lR2W5DfPY7kFue+3VDO5ozlBJScW5szN85xsvMnOh0LoXUAf9qRQTU+dJxVJEOuogKVCqzqJCIGrVeahqsOQMkXq7G9qM1lCpeDzw1Vl8kSW6hSNUTSMEtm2vHd2aFw+B789HHoooKam6Yc2DF1j4OkxZ+NLG1zGUjqKFvUwwWEKQ2ZclPpBAeqsNUgqdEpVUnHj6MbxKEa+U47Z73kNECP7mN36B/Te/mtve+cN1v0THEpR8zXRVMpIwl6NewnwahmVYlsWP/uiP8va3v51f+ZVf4cmvPcTo4K3c88438S//7TtQamHCXhMXHa0RluDeH3w9H/uNv+PFZ0+3avdrRghBX6aPydIkY+ldHYuQCAGosHir1lC/QNS9f0ppYjpXd8tkO9FaUyx5PPDVHMoZIBIxbWxNUYN4CJbVOxSQSlF1faqewJPiYr3D0OVjWLYgqMg1Dm1B7vwZYsl+0jt28un/72e45e7vw7Y1u668jgtnTxNvIDVkAYHWTFUCIw56jN45cxh6isHBQf77f//v/ObHfh038jw/9q/fDoQFSuEJyWr8x7FDz3Xb4p//3/d07TXGYzHmKFBxS+imRwrXRljDVZ+wchqJ0ugKMcvtGdMjpTX5gsdnH8qhI4NGGHQCIXAch1g8TjKZJJ3JMDAwwM6xES7fu4Nr9g9x7d4U11/mcNWrhhAoHHuhpkBiIQlHYoUjuPOTZxjdfy3HHv0yl934XQQBeBKuveNtZHddtuqsho13MUx7TFZWH/1s6B5GHBjW5TWveQ1/8/d/SyTitLyozbIsBob62bmnvjxlK8lk05wtnSUIOnRyEoJ6q3xsS9R1kdda46jpnrFKVkozN+fy2a/kcBJDZoRvryAETiRCLB4nPpRBWBaWJbBtC8e2cBwLxxY4tiBiaa645btwbMmLj3yea173VoQOkL6k6vlc/V1vvLjahz/+v3n6oQd4+qEHatoNpTXlQLXrVRoapDfOHoaept0n81Q60db1r4dt2djJCLPlaZRu/wkqbBO1qFUhaK1D05m6uhQgoud6wv1SKc3MbJV/eHiOWGqo490hhtoQa7hnivl5VcIK7/CrpSKTx1/g8ptvBcvHiilmz51k1+VXAfDH/+En+a57f5Ab33wPD/3V/6p5+4Gpi+85jIQ3dJ1u+yr0JfuYmrpAv58mEW2/UBHaqqtqw7Ht2t8jDag8EUtBFydQQigMJi9U+PzX86QyO3qq/sGwHL1a5EyHBlxaA1qiUeQmT5DduZvUQJpINJzoeHbeDfHsi8+SSKUv/v+/+YO/qXn7Tg8IWcNyzNFq2PYIIJ1Nc644gZTtTy/UlZvVmkgdg6I0moiaqX8GQ4tRSjNxvsw/fb1IKjtihEGPI/NltAqFgFYapRRK+SjlgRMQ64+RGc4ydtlebNsmGg2HND390APc+Oawbmj8xaeZmTjN7NkzAPzd7/5yTdu2hKCvB026tjsmcmBonKNH4cgR2LsXcjl43/u6vUcNE4lEKEcrFKp5Mn2ZtnofCGFRq72IBiK2XXOYQStJlDyW6F74XinNqfESX/52hWx2mJ6pijRcitZ4nsfci6dJv/UmtPLQQmNHHWLxPmLR2LLalcFde7nhTXfz2OFPkujPsOuq6y/+rVIshI9dHT42/uLTnH3x2Yu/r755jdaakYRJN/UaRhwYGiOfh/e/Hx54AE6ehM9+Nnz88GH4vd8LH1/g/vth3z546CH40Ie6s7810N/fz8TUOZLRZFu9DwQCpaDW9Huk1gXnvQ2cLkYNlFQcP1XiyJMu2eyQEQY9iNYat1ql6lZQ7iSuOsvc2ZfZZ3830YE08fl0wVq8/affv+rjgzv3MLjzsou/J/ozzEycXlccKMKOhR2mjbHnMLEcQ2M8/HB4wT9yJPz9vvvCf++9F7LZxeXy+fDfgwfh1KlQSPQolhDE0wmmSlNI1b7iRCEEtdY+Woia0xBKaSI617UuhUAqXjhe5OEnPTLZQSMMeggpJaVikdmZKWbOP8lk7itU9zzPG/79a/jPD3yUT/3TJxhMJbBsp+EaoAO338HMxKJnyezEGQ7cfse6zwmUJhkRDMVN5KDXMHLN0BiZDLzqVeFFH8KL/r59ly6XTofphvvvD9MPqy3TQyTicWZLM2S8DH3xNg2hEqB0bRfwujwOlEtUlBGi84d1ECieO5bn2y9osgODHd++4VJ8z6NSrSK9PIF/hoI9xc7XX82hd3wfd999N7t27Vq2/M2Dcb5+vlyXQddSEqk0r7n3h3js8CepFAvc81P//mKB4mporUGE2zXWyb2HEQeGxjh4MEwTHD4c/p7JrH/hf9/74AMfWFtE9BDpbIaz0+Nc7hxoSxunCNXBfMfC+idF27ZqajrQWmPr6a60CgaB5OhzeY6esMhkMx3fvmEeram6LtVKBR1cwPPHKaeK3PR9Bzl06P/hTW96E6nU2uORbxiM8ehkhUBDpMFr9UJxYi0EGmwhuGHQzNboRYw4MDROLfUDhw+HwuHgQdi/P6xNWEhB9Ci2bSP6HHKVGYZSwy0vThQCtBIbulBrrXFq7FQIvQ1ynfU20BBIybeOzvHSWYf+dG2jeg2tQ0lJtVrFdSso7yxVfQ72RHjDuw9xzz3/L7fddlvNgjEdtbl5MMbj01WUpq3fJaU1Cs2tg3EzrrlHMeLA0FqOHAlrCw4fDusP3vSmsD7h8GE4cQJ+8ze7vYc1kUwlmZyaJuWniUdbPE5YiHkL5Y07FiJWDR4HGlAFolYAnepS0OAFAY8+PsfJCzFSqWRntmvA933cahXfLSD9MxStKQZetZtD7/oeDh06xOWXX97wut+ws4/jBZ+cJ4lCW0Z9a63xtSYbtXnDTjOquVcxI5sNXee//uonOfb8eLd34xI830PPKfZkL8Ouw2ugFspekURSrtv/r5ViRypFOrG+ONFaY3snSDnFpqZl1orW4AcBX30sx7m5BIk+c4JvK1rjui7VahXlzxIEZyjE57jybbfy9nd8D29729vILi0CbpJTBZ9PHc+jlCY674zYKrTWeEpjWYLvvzzN3n4zY6NXMZEDQ1fRWnPm9FS3d2NVopEoucgcxUqRdF+6pSdJq4bhSxqI2hunNC56G7RYwKy6LQ2eF/DQo7NMV1Ik+locVTEAoTCsVqtU3SraO0dVncUflrzuPXdz6NBP8brXva5tw6v29ke4c3eSL54p4SlN1GpNBOGiMBCCO3cnjTDocYw4MHQNrTXffPSbvPTCN8lkDpBKpXpiHsBS0v1pJi6cpS/a19KTsRA2mmDDXogNPQ40WGq2I94GWkPV9Xnw67OU/P6GRvQa1iYIAqrVCn61hPLHKXCO5A07uPNd383dd9/Ntdde25Yw/2rcPBR+tl8cL+FpTYTmahDUfCrBskJhsLB+Q+9ixIGhawghuOVVt3DwnTfymb/6B0YHbyOTHu2pi45lCWLpOBdKFxhJj2K3yENAYG04e8kWArGBFYnSmpiaxY6019tAa6hUPD7/9VlcnSUWb59J1LZh3p2wWq0ivRyBf4ZidJbLDl7PPff+M+68805GRka6tns3D8XJRm2+cKZIzpNYGhxRXxRBa02gQRHWGNy9J2UiBpsEU3Ng6AlefvllPviBD5If9xgcuIl0OovTIxP8NDBzYYbL+/aRiPe1xPvADwJEtISzzkXdEYI92ey6dQQqcOlXzxGJtE/na60plX3+6eFZVGSgbeHs7cBFd8JqFeWdx1MTuJkqr3rnmzl06BAHDx7sKXEM4ErF1ybKPDXjIrUGHfpvWKwuFLTWKEKDI0Qocm8ejPGGnX3EakiTGXoDIw4MPYPWms985jP81od/g6Hk9WTS+0il2mREVCd+IHFnK+zP7G+J94GUEukUiK7RxqWBPttmLLNOrYMG/LOk7em2FSJqrSkUPT53JIcVHcAxwqBu5Hy7oeeWUd44FTWBdWU/b3nXPRw6dIibb765a66W9ZD3JM/MuDw1U6Xk64tmSWrJJcQS4uLjyYjg5sE4NwzGTLviJsSIA0PPkc/n+a3f+i0e/sevMjJ4G5nMCLFo98PYhWKRQZllMDXYtPeBVJJAFIitYRurtSYdjbKjv39NLwQlNfHgWRIR3RanYqU1c3Mun3t4jmhqqCsGS5sV/2K6IE/gj1O0pxh67QHefm9YP7Bnz55u72LDSK2ZrkqmKgGTFUk5UARa48xPVxxJ2OxIOAzFbeN8uIkx4sDQszz99NN88AMfRObiDGSvJ53OtCzn3wgazczkDAfSB5r2PpBK4VMgnlj99WitGUwkGOjrW10caFBBgTSv4Ditv2grpZnJVfmnr+dJ9A1h9aAwiCdjvOUHvotb3nwN6cHmfBa8qs8L3zrBQ596jInjF+pfwXy7YaVaRXsX8ORZSn15bnzHG7j77rt5y1veQn+/MYkybB6MODD0NEop/vIv/5Lf/93fZzRzM+n0HvqSfV1LNLieh5WHXdndTXkfaK2oyiLxvjXytkox2p8itUb+WWuN450i6eRbnlJQSjN1ocIDjxRJ9Q8ielAYROMR/sMf/jj7rtsFQrTkPZCBxHcDfuNf/TGnXzi34fJKynn/gTLam6CqzxHstjn47kPcfffdvPrVr26L/bbB0AmMODBsCi5cuMCv/uqv8tTXn2N08FbSmWGiXcp/z+bm2B3ZSX+8v+HWMq011aBIPLn6kBulFHuzmTVfo5KSZPAMsWhrIylKac5PlnngGyXS2eGOtc7Vy+u+52b+1Ye/v+XrlYHi8S8/xx/83CdX/Xvg+1TdKp5bQnmnKYlJ+m8e4+53v4NDhw5x4MCBlu+TwdANjKw1bAqGh4f5yEc+wqOPPsovffAXKU2MkslcRbo/3RFXwKVk0mkmLkyQiPQRafDOUAiB1hYQsFreQACOtca6NQiVo9WF30ppTp8t8eXHymQGhnt65PJ1r7kCGUjsFqdUbMfihjuWXODn2w0rlQrKz+HLcUrRWS5/2y28/R0/wZ133snAwEBL98Fg6AWMODBsKl772tfy2c9/jv/1v/4Xf/G//oLRwdvIpncSTyQ6lmqwLEEkFWG6fIGR1EjDleYWaw9fWq+2QmuNo2axGx2dtwpKKU6cLvHQ4y7ZHhcGAIlUbF3r6WaIJqJUymVcd6Hd8CzuoM9rfuQuDh36Ce644w6iPVAgazC0EyMODJuOSCTCfffdx7vf/W5+6Rc/xOlnv8rQ4C2k04MN38nXS6Kvj+nyDGk/TSLWWA3Ewuil1Z7rWGLN67NWPjFRQrRoyJKUipdPFPnqUz4DA4M9LwwWaNteas3U3FdIXjfEm955D/fccw/XXXddz6ZYDIZ2YMSBYdOye/du/vhP/g8PPvggv/Yff5Vy+fKO2TALIJ1Nc252gn32PuyGRIkD+Jc8qrXGEfaaXQqWmmmZXXIQKJ5/Oc+3ntcMDA62ZJ2bHWEJ/vyJw4yOjnZ7VwyGrtH7zhsGwwbcdddd/NMXH+CN997AifEHmZo6RdWttn27EcchiCvmqnNorep+vmVZqDWe5jirj2pWShPVs037LEAoDI4+n+fbL0CmhVP9usbRo/Cxj4Xjwe+/v+HVWJZlhIFh22PEgWFLkEgk+MAHPsCf/PX/QWTGOTP+DWZmp5FStnW7/akU56rn8fyg7udagFarNAtpTWS1fLoGVIWo5TUd+Q8CyeNPz/H0SYt0JtPcynqBfB7e/3647z646abwdwiFwj33LF92tccMBsMyjDgwbCkOHDjAJ//mk/zfH/yXnJn+CufOP0+hWETTno5dIQR9mRRTpfNIVacQscSqw5c089MYxcrHNbaabs5qV4fC4NHHc7xwNkIqtUWMeR5+GPbtgyNHwt/vuy/89957YWVUZLXHDAbDMow4MGw5hBC85z3v4bMP/iM3vnGMk+NfYmpqHNfz2rK9eCxKQRSpuOU6RYhAqdVDABH70hoGrRRRcg23bmoNXhDw1W/OcvJCnGSyOVfBniKTgVe9Cg4eDEXCyZPd3iODYVNjxIFhy5JOp/nwhz/M//iTj1BxnufsxLeYzc2i1kr0N7OtbIazpbMEQe3RAyEAHQ6qWYqFwF5ZU6BByDwRq7EIiNbgeQEPPzrDRL6PRF9fQ+vpFS7xbjt4EGZmwpTB4cNw6lR3dsxg2CKYbgXDluemm27i7w9/JrRh/q+/z1jllpbbW99S+AAADfpJREFUMNuWhZ2MMFOeZkf/DqwaCgYFgF5oaFy6rtXH4Dp6Btupf4+1Btf1+eIjsxS8fuKJ3hoJXCsL7oS+W8Jz57ikEfRDH+rWrhkMWw4TOTBsC2zb5sd+7Mf4zOc/w+4bHU6efYjpCxP4/qWthI3Sl+zjgn8B13Nre4JYvebAsaxLCg619olSrLvXXmuoVDwe+OosRT9NbI1ZDT2J1niuS35ujtmpE8xc+CYX3IfIvMXlspv31ubHcORIGEU4fHj9xwwGwzLMbAXDtuQb3/gGv/TBXyQWjLXUhtkPAoKcx97MvppGHFf8EvG+4KLbn9aaVDTCSP+SuQ0a8M/Tb53HrsMzWWtNqezzwFdnkVaWyCZw9dNaU61UcN0q2jtPVU1QzVZ5zXvu4tChQ7z+9a8nFot1ezcNhi2PEQeGbYvv+22xYc7n8+wQO8j2ZTb0I6h6FaJJ72IHgtaagXicwWTyYsRcSU0seIG+SFBzC6PWmkLR44Gv5cAZwOnSkKpakFJSrVTw3DLKG6fEOeJXZ3jzu97OPffcww033GDcCQ2GDmPEgWHbMz4+zod+4Rc589xkS2yYldbMTeW4MnOASGT9u3XPd3H6qoviQCl2pFKk4/FFcRCUSeuXcGocMqS0Jj/n8o9fzRHtG64pgtFp/PlhRoFfQPpnKNpT7HzDNRx6x3dz9913s3Pnzm7vosGwrTHiwGCY5wtf+AK/9h9/lWz0CjLpA/SnUg3fsVbdKtGSw2h617pDlPzAx4qXLl7AlVLszqRJzKcAtNbY/hlSdm0tjEppZudcPvfVOeLJod4RBlpTdV2qlQrKv4AfjFPuL3HzvQc5dOgQb3rTm7ZWa6XBsMkx4sBgWEKlUuEjH/kIhz/xWUYHbyOTGSPeYI57emaGfbHLSCZSq1ohAwRBgI4WiUQWxcH+wQGcBbEgNYngGRIRNpw0pJTmwkyFf/pagVT/EKLLwkBJSaVanU8XTFDV59D74xy89y7uuecebr311t4RLwaDYRlGHBgMq3Ds2DF+/ud+nsJ4QDZ7I9lMpu4LmZSS0nSRy7MH1kxTSCmRdoFoLFy30Jp9A4NYdjjOWQVzpDmxYUpBKc35yQpfeLRAKrOjazl63/epVqsE7ny6wJpi8NY93PWu7+HQoUPs37+/K/tlMBjqw4gDg2ENtNb83d/9Hb/zn3+H4b7rSKf3kkol14wCrEaxVCIT9DOcGl5enGgJGEqih/vQI3Ei6ThYFkIp+iVE58o4MwUSU8+ScgrrTplUSjN+rswXv1EiPTjcWWGgNa7rUq1Wkf4sMjhDIZHnqrfdynff+w7e+ta3ktkKsxsMhm2GEQcGwwbk83l+4zd+g6/+0zcYGbiNTHaYWI1tgRqYmZzmQPoK4tEE9MewbtiJddMuSMbCVIHWoVgg/FVowt+VxqkUGHz5eQZeeZ5IuXTJ+pVSnDpT4svfqZLNDtXW+98kWsqwfqBaQfvnqaqzBDsUr3vP3Rw6dIjXvva1RHq4O8JgMGyMEQcGQ4089dRT/PwHPoguJMmmryOTydQ0BMnzfaha7PueN2PfshtsK1QNgQKl0OiL13QhBJYQoWei0OCE67ekZODl5xh58jHsIDRuklJx/FSRh5/wGRgYaKswWOpOqLxxCuI8qRt2cOe7vptDhw5x9dVXm3ZDg2ELYcSBwVAHUkr+4i/+gj/4yP9kLH0z6f6NbZhje0ZIv+3VRAcyCKXBXzrbQS8TB5YQFy+yQoe+BhrQtgOWRaQ4x65vPkz87BleeqXAN55VZNsxYVBrPM8L0wVejsA/QzE6w9433cg9934Pd955Jzt27Gj9dg0GQ09gxIHB0ABTU1P88i//Ms9+8yV2DNxGNjO4aig9eeMBMm+9HWFZyKqHLexLahY0ahVxoLF0sCwaoIVAOw4ohfyHL/D4x58k3cJ8vtYat1ql6lZQ7iSemqCSqXD7u97KoUOHeOMb30h8M9kvGwyGhjHiwGBogkceeYQP/fwvkQhGL7FhTt54gOxbXw2WQHt+OElQL0xcXHLRXyIObCFCQaAlllCs7F/UaAIrgpSa6U98lcLXnmtq/y+6E3oVlDdORU1gX5Xmre9+O3fffTc33XRTTakTg8GwtTDiwGBoEt/3+cM//EP+6o//itHMbWSyY2Su3Mfw974FYVlob3G4k1JqSfQgvPCHaYXwMFwwTFpIKSxH4/kaKcHui6GlYuJ/fJbqi2fr21/Po1Ktorw8vn+Gkn2BkTuuvOhOuHv37gbfCYPBsFUw4sBgaBFnzpzhQ7/wi5w7WeK1H/wwscHMMmEAYWOCVhrHsllbHGgsApZFF7TG9zVSc7EmwYpH8S/kOfOf/wZdXWe65Hy7YaVSQfvTeMEZyqkSN77jDRw6dIg3v/nNpFKpVr4VBoNhk2PEgcHQYv74a89w1kqjPB+BjbCWVxkopbEQWPPpBY0GobEAy7IQWiKWpBS01ni+QmmxvCNACKxYhLmvPM30X39t2T4oKalWq7huBe1NUNETqD0RDr77EIcOHeL222837oQGg2FNGp8uYzAYLiHvSfL9Y/RpjYvCrbpYOhJe9Be6ECyBkgohrIvJhVChL1z4VxMG1qVpBq3RSpF+43XkHnyC6mQOt1rFdwtIf5yiOE/mll0cevc7OHToEFdccUUn3gKDwbAFMOLAYGghz8y4SK2JCkE01U8ikSCfzyOlxLKcUBAIwBIoLbHF/N27BixALxYnaq1xPYVmFWEwj3IDrHgU56YRZj/5eYrRGQ7cdStvf8dP8ra3vS30PzAYDIY6MWkFg6FFSK35o+dmKXqKmL20wl9TqVYpFUtYwkGIMNWglcYmjChoNLYlsJAIodGa1YWBnndG0ICWaBR2XxwrcHk9E7zhjjuMO6HBYGgaEzkwGFrEdFVS8jXOJaOVBYl4glgsRrFY5KXHvoZXLuOWitxy1/diC5tP/9bPceBVr+P2e96F1lD1FCwIAx1GETT6oiAQjkU0HiMWi2HZNlInuf7qy4lEzCFtMBiaxzQwGwwtYrISoLRe86CyhEVQmGN45y5GrriSRz/9p2ihUVqx88obmD13KhQGblhzoLVGSYlSHkp7iKgmkU6Q3THI4NAQqWSKiBPBml92qhJ08uUaDIYtjBEHBkOLmKrIZfbHqzEzcYZ9193M+FOPceC216GUi9IB19zxNgbGdoepBK1RykfjYScsktl+BkeHGcgOkEj0YVvLuwzE/DYnK7LdL9FgMGwTjDgwGFpEKVCoDUp4rrz9DgCOfuVzvOrOexkcHETYGiU9dl57C8oKOPx7v0Q0ZjE4MkwmnSEWi204JlppTTlQ6y5jMBgMtWISlAZDi5A11vZWinnOvvTsRaEwkB3g9BOPcv3Bu8ifn+CFR77Ef/vnjwFQLRW456d+lje99yc3XG9gaosNBkOLMOLAYGgRdo0ji2fPnmFw52XLHrOEwLEdZibO8KG//waJVBqAxw5/ku+694dqWq9jRiYbDIYWYcSBwdAiko6FVcMFOp7qX/b70w89wI1vvgdYTDtAKAxufMvba9q2JQR9jskSGgyG1mDEgcHQInYkbJQOPQjWK0oc3HUZN7zpbh47/EkS/Rl2XXX9JcvMnD1NpVi4GEFYD601WmtGEsYO2WAwtAYjDgyGFjGScLCEQAEbXabf/tPvX/fv3zz8Ca68/Q01bVcRipEdCXM4GwyG1mDikAZDixiK2yQjgkA1Xxj4zMNfYHDnnpqWDZQmGREMxU3kwGAwtAYjDgyGFmELwc2DcRBhqL8Z4ql+EunMhstprUHAzYPxmgsiDQaDYSPMbAWDoYXkPckfP59Da4hcYqPcenylEQJ+4tos6aiJHBgMhtZgIgcGQwtJR21uHoyh0BsaIjWL0hqF5ubBmBEGBoOhpRhxYDC0mDfs7CMbtfHnuwjagdYaX2uyUZs37OxryzYMBsP2xYgDg6HFxGyLu/eksITAU60XCFprPKWxhODuPakV46ENBoOhecxZxWBoA3v7I9y5O9lygbBUGNy5O8ne/khL1mswGAxLMY3RBkObuHkoDsAXx0t4WhOBmhwU10LNpxIsKxQGC+s3GAyGVmO6FQyGNnOq4POFM0VynsRC4Ij1HRRXorUm0KAIawzu3pMyEQODwdBWjDgwGDqAKxVfmyjz1IwbTm/U4FgCi9WFgtYaRWhwhFjwUIjxhp19psbAYDC0HSMODIYOkvckz8y4PDVTpeSHtQhCiGVtj5YQFx9PRkJjpRtMu6LBYOggRhwYDF1Aas10VTJVCZisSMqBItAaZ3664kjCZkfCYShuG+dDg8HQcYw4MBgMBoPBsAyTvDQYDAaDwbAMIw4MBoPBYDAsw4gDg8FgMBgMyzDiwGAwGAwGwzKMODAYDAaDwbAMIw4MBoPBYDAsw4gDg8FgMBgMyzDiwGAwGAwGwzKMODAYDAaDwbAMIw4MBoPBYDAsw4gDg8FgMBgMyzDiwGAwGAwGwzKMODAYDAaDwbAMIw4MBoPBYDAsw4gDg8FgMBgMyzDiwGAwGAwGwzKMODAYDAaDwbAMIw4MBoPBYDAsw4gDg8FgMBgMyzDiwGAwGAwGwzKMODAYDAaDwbAMIw4MBoPBYDAsw4gDg8FgMBgMyzDiwGAwGAwGwzKMODAYDAaDwbAMIw4MBoPBYDAsw4gDg8FgMBgMyzDiwGAwGAwGwzKMODAYDAaDwbAMIw4MBoPBYDAsw4gDg8FgMBgMyzDiwGAwGAwGwzKMODAYDAaDwbAMIw4MBoPBYDAsw4gDg8FgMBgMy/j/Ay4tLLLLq8X2AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - The complex has 8 0-cells.\n", + " - The 0-cells have features dimension 1\n", + " - The complex has 28 1-cells.\n", + " - The 1-cells have features dimension 1\n", + " - The complex has 56 2-cells.\n", + " - The 2-cells have features dimension 1\n", + "\n" + ] + } + ], + "source": [ + "for i in range(5):\n", + " describe_data(dataset, i)\n", + " describe_data(lifted_dataset, i)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "# disable max_rank, meaning we are not limited to 2-cells.\n", + "transform_config[\"lifting\"][\"max_rank\"] = None" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Transform parameters are the same, using existing data_dir: /Users/gescalona/Desktop/challenge-icml-2024/datasets/graph/trivalent/graphs_8vertices/lifting/1488677257\n" + ] + } + ], + "source": [ + "lifted_dataset = PreProcessor(dataset, transform_config, loader.data_dir)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Dataset contains 5 samples.\n", + "\n", + "Providing more details about sample 0/5:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Graph with 8 vertices and 12 edges.\n", + " - Features dimensions: [1, 0]\n", + " - There are 0 isolated nodes.\n", + "\n", + "\n", + "Dataset contains 5 samples.\n", + "\n", + "Providing more details about sample 0/5:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - The complex has 8 0-cells.\n", + " - The 0-cells have features dimension 1\n", + " - The complex has 28 1-cells.\n", + " - The 1-cells have features dimension 1\n", + " - The complex has 48 2-cells.\n", + " - The 2-cells have features dimension 1\n", + " - The complex has 36 3-cells.\n", + " - The 3-cells have features dimension 1\n", + "\n", + "\n", + "Dataset contains 5 samples.\n", + "\n", + "Providing more details about sample 1/5:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Graph with 8 vertices and 12 edges.\n", + " - Features dimensions: [1, 0]\n", + " - There are 0 isolated nodes.\n", + "\n", + "\n", + "Dataset contains 5 samples.\n", + "\n", + "Providing more details about sample 1/5:\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgcAAAIbCAYAAAB/tT3bAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9eZwcV3mv/5xaep1dy4wWa7Uly7slG2IbAYklHBJCIFhAwCQhYBsMSchmh4RfcnMv9yZws3NDrkluNkhYTEhCTBKQTLCFbcCWF8mrZK3WNjOamZ7pvavqnN8f1d0zPeqZ6e7pbWbO8/m0remurjpdXV31rfd9z/cVSimFRqPRaDQaTR6j1QPQaDQajUbTXmhxoNFoNBqNpgQtDjQajUaj0ZSgxYFGo9FoNJoStDjQaDQajUZTghYHGo1Go9FoStDiQKPRaDQaTQlaHGg0Go1GoylBi4Mlzn333Udvb++sy+zYsYO777675Ll9+/axefNmhBDcd999dRnLU089hRCi4uXvvvtuent7EUKwefNm7r77bo4dO1aXsczG7t27+fSnP92w9Zfb360Yx0zbrNf3XSnVHhetpB3HOv07a8V3qFl4aHGgmZOPf/zj7Nmzp/h3LBZjz549PPDAAyil+PjHP97U8Rw7dozNmzdz7NgxHnjgAcbGxrj//vsZHR3lq1/9alPH0gim72/N3BSOyd7eXjZv3rwgLn4Fcdvb21uRGNRomokWB5o5uf3229m1a1fx73379tHX18f27dsB6OnpKUYSmsGePXvYtGkTe/fuZdeuXfT09LBr1y4eeOAB7r333qaMoZGU29/N2rcLlTvvvJPdu3dz/Phx7r//fr761a+2tcDavXs3PT09jI2Ncfz4cY4dO9bW49UsPaxWD0CjqYavfvWrPPXUUxw9erTVQ9G0CceOHSMWi3HXXXcBsGvXLu6//352795NLBajp6entQMsw549e4rj7enpYc+ePQsi2qFZOujIgWZOpuYo77vvPvbs2cOxY8cQQnD33XezZ88edu/eXXxOCEEsFiu+vxA+3bx5M5/73OeKz8diMXbv3o0Qgh07drBv3745x/LlL3+Z7du3s2nTpjmX3bNnD5/73Of43Oc+x+bNm4vr/+pXv8qOHTuKtQrTUxF333039913X0nYd/oyIyMjJZ9rtrHv2bOnJGxcyEtPrY8o7Fco3d9z7dtqxjGVT3/608Waken7/r777mPz5s0Vh7tnW36m7wDqd1xs2rSJ+++/v+S5G264AYAnn3xy1vfOdSzs2bOHT3/60zPu41qOYaAoDArs3bu3OObZmO17m2l/zkWh7qjaz6BZ5CjNkubee+9VPT09sy6za9cude+99xb/fuCBB9SmTZtKlin3nFJK3X777WrXrl1qbGxMHT16VPX09KgDBw4U17t9+3Z19OhRNTY2pm6//XY11yG5fft2ddddd1X02Qrr37Rpk3rggQeKz99///3FMezdu1cBxb8L7+vp6VF79+5VY2Nj6q677lKAOnr0aPF1oPj67bffXvazT903U/fxvffeqzZt2qQ+9alPFZ+bOsZK9nct4yhw1113qe3bt6sDBw6osbExtXfv3uK2C9/X1O9k165dJducOrZKli/3HdT7uJhO4XsdGxubdblKjoXZ9vF8xzo2NqY+9alPFY+32ajke5tpf079zqb+vXfvXrVp06biftq7d2/J59csXbQ4WOI0UhwcPXr0ohP0/fffr+69997ia4ULrlJKHThwYM4T66ZNm0rGMte4e3p65rxATL9QT/+807dbuCAUKFxUZmJsbKzks27fvl196lOfKl5EC68XxlmNOKhmHOXGMpXC/p++v6ZeuKaOrdLlp38HjTguplPuO6yEcsfCTPt4vmMtrAuYc6yzfW+z7c/CZ5hJHEwXrhpNAZ1W0DSMp556CoCNGzcWw/P33XcfTz31FE899RQ9PT0VpQemsmnTpuJ6C+zZs6cYct+9e3fJa4WCxel87nOfY8+ePezYsaOi6Y+7du0qWW5qCLivr2/W9/b09LB9+/ZiuPbYsWPcddddxb+/8pWvsGnTpppy49WMA/zixpn2+5NPPll2HDfccAN79+6tefnp30Ejjoup7Nmzh+3bt/OpT32qouXnOhZm2sfzHeuuXbtQSnH06FGeeuqpi47dqcz2vc22PysZQ19fX/G3sxhm+2jqgxYHmoayfft2xsbGSh7lLjSVsnv3bvbt21eSdy9MqSw3U6HcyXTHjh088MAD3H333Rw4cKA466Iaqr2Q79q1i71797Jv377ixbIgdPbu3cvtt99e9RhqGcdsTN2n9Vy+3HdQ7+OiQGEmS6XCoJJjodEFjZs2beKBBx5g3759JTUQhUclXha17s+enh6OHj3K/fffXyyMbLZ3hqY90eJA0zC2b9/OU089VfYismnTJmKxWNWmRffeey+bNm2qubL72LFjxQvy1OmCc7Fv3z5uvPHGmrYJ8K53vYt9+/axd+/e4h3i7bffzr59+9i3b9+sd431ZPv27TPu90J0ZPr39eSTT5b97NUuP3UM9T4uYLJ4s1JhUOuxUKDWscZisVmF1YEDB1B+yrcoemf73mbbn5Vy11138cADD3D//ffz5S9/ueb1aBYPWhxo6sKmTZuKF4p9+/Zx7NgxNm3axF133VWc3QB+dfinP/1ptm/fzvbt29mzZ0/xpHfnnXdWtK0HHniAr3zlK+zZs6d4UnzqqacqOkkXwsKFau7C1MjpfO5znyuuuzD+6RXm1VA4uX/1q18tXoh2797Nl7/8ZWKx2KwXp3L7tlamfyeFMd13331s376dXbt2ceuttxZfK9yJl4tsVLv8TGOA+R8Xe/bs4cYbb+Sd73xn8eI718Wy0mNhJmod6+joKDt27OCrX/1qcZx33nnnrPtttu9ttv05F4XlCuPYu3fvvFI6msWDFgcaYrFYSRiz3JS5uSicKDdu3Fhy53b//fezfft2duzYQW9vL/fff3/xQvjQQw/R19dXnAJ39913V3Ri2r59O8ePH6evr48777yT3t7e4jTAuSIKPT093HvvvcVpX1ONlKaya9cufu/3fo+NGzdy7NgxDhw4MO/wcuHEX/iMu3bt4qmnnprzrnWmfVsrhe9g9+7dxe/kXe96F0Bxf+zYsYONGzfS19fHgQMHZlxXtctPHUO9jotjx44VL5SFnHvhMdu0vEqPhdmo5RguGHh9+ctfZuPGjWzcuBFgzv022/c22/6sZCyFeoVYLMZf/uVfVvjpNYsZoZRSrR6ERtNO7N69u6qCNo1Go1ls6MiBRqPRaDSaErQ40Gg0Go1GU4IWBxqNRqPRaErQNQcajUaj0WhK0JEDjUaj0Wg0JWhxoNFoNBqNpgQtDjQajUaj0ZSgxYFGo9FoNJoStDjQaDQajUZTghYHGo1Go9FoStDiQKPRaDQaTQlaHGg0Go1GoylBiwONRqPRaDQlaHGg0Wg0Go2mBC0ONBqNRqPRlKDFgUaj0Wg0mhK0ONBoNBqNRlOCFgcajUaj0WhK0OJAo9FoNBpNCVocaDQajUajKUGLA41Go9FoNCVocaDRaDQajaYELQ40Go1Go9GUoMWBRqPRaDSaErQ40Gg0Go1GU4IWBxqNRqPRaErQ4kCj0Wg0Gk0JWhxoNBqNRqMpQYsDjUaj0Wg0JWhxoNFoNBqNpgQtDjQajUaj0ZSgxYFGo9FoNJoStDjQaDQajUZTghYHGo1Go9FoSrBaPQCNphF4SjGS8RhKuwynPZKuxFMKUwiilsGKsMnKsMWykIkpRKuHq9FoNG2FFgeaRcVEzuP50SwHRzMkHYVUCkMIpFLFZQp/G0IQtQXX9IW4si9IV8Bs4cg1Go2mfRBKTTlrajQLlKwnefRcioOjWTylQIFlCAxAlIkMKKWQgCsVCDCF4Jq+ILesihA0dbZNo9EsbbQ40Cx4TsUdvnU6wXjOw0BgifKCYCaUUrgKJIqegMnutR2s67QbOGKNRqNpb7Q40CxoDo5keOhMEqkUthAY86gfkErh5NMNt66Jcs2yUB1HqtFoNAsHHT/VLFgOjmR46HQSKRWBeQoD8GsRAkIgpeKh00kOjmTqNFKNRqNZWGhxoFmQnIo7xYhBwBBVpRFmQwhBwPALFh86k+RU3KnLejUajWYhocWBZsGR9STfOp2ouzAoMFUg7D2dIOvJuq5fo9Fo2h0tDjQLjkfPpRjPedii/sKggBACWwhiOY9Hz6Uasg2NRqNpV7Q40CwoJnIeB0ezGMy/xmAuDCEwEBwczTKR8xq6LY1Go2kntDjQLCiez/sYWE0yNbSE77b4/Gi2ORvUaDSaNkCLA82CwVOKg6MZUNX5GMwHIQQoODia8c2VNBqNZgmgxYFmwTCS8Ug6Cstobi8EyxAkHb9Xg0aj0SwFtDjQLBiG0q7fE2GO5V458DjPPfxNnnjwK8Xnvvi7v1zydzUY+C6Kw2m3pvdrNBrNQkOLA82CYTjtYcwxQ2H07KtEOrtZfdkVPPKl/1d8fs3Wqxg5e6qm7Yr8NofSOnKg0WiWBlocaBYMSVeWdFcsx+i506zecgXPPfItNm+/qfj8FTt30d2/GkVtdQNSKVKu9jvQaDRLAy0ONAuGSgoCL93hC4JD3/kPrnrDbQCkM2niY6OsvnQb4yOD/O3HP8RLB77HkWef4ME//30c16GSFiOuLkjUaDRLBKvVA9BoKsWscIZCOjHB2SMvcOmOm8hkM+SS44yeeoVtN9+KQBIfOstXfuejrL50Kz/16/+d7MQoKQUSA2FamJaFVXiYVjGNYTVphoRGo9G0Gi0ONAuGqGVUZHw0dvY0fasuKQqDcABAIIRCKpOb3/EzXHXL6zGK1ssKPyigUMpBeQ6eq8gqSElfNBihKM8+8TTJ74+xZcsWLrvsMqLRaGM/sEaj0bQILQ40C4YVYROp/Av5bEWJoY5OpJJFYfDc/kfYdvNuhJAIFGePvAQIMokYhlDc+Oa34a9OUFitCRREg0Lhmop1J76O+9R/8F9Jyd+PSy4YvZirLmfztiu57LLL2Lp1qxYNGo1mUaDFgWbBsDJsYQiBpHDxLk9k2Qq23Pg6Xvj21wl3dtG/aVvxNYHi1p/9COCrgD//8Du44pYfIdLZWUZw+GJBCQtDSbYGRum6cgDXcXFdB9dxyTkHmTj9NIMvuBeJhk2XX8GWLVuKDy0aNBrNQkGLA82CYVnIJGoLEjmJaZaPHGSyGbLJcX78gx/CMASep3C8gP+ighcf+y/OHnmRH/6ZjyIQBCOdXDg3xOpIF6YhMYyLa3Q9M0A4O0ZX8gyGEAQCNoGAXXx9ObBBqRLR4LgHGT/zNIMvunwnKfn8uGTY6MEc8EXD1q1bi+mJjo6ORuwujUajqRktDjQLBlMIrukL8dhgCqXURXf6BWEQDYBhCJQCT01e7BXQO7CKULQTgQIE2VSCVZsvRwGulJjKnVKLQHHi46bTD2GomX0OyomGZctgo1I4JaLhEONnn2HwpUnRMGb2IlduYfO2K0siDVo0aDSaViFUJXO4NJo2YSLn8dcvxVAK7Ck2ytOFAQiklDiejULk+zFIDKF47rvfAeDMkZfYcdvb6R1YM2ULCoFXjCK4ZhBDedz26K8QyYzU7XOoi0SDy3jSYzDuMpiQnIlLLtCD6t9ajDRcdtllbNmyhc7OzrqNQ6PRaMqhxYFmwfHt0wmeHslgC79tczabITNNGAC4nsT1AoU/ESgMIVEIlPJjB6iZrD4khiFRgTCXnvom1738d034ZL5o8MVCqWgYTjgMxRWn4pJh1Y3q31oSabjsssvo6upqyhg1Gs3iR4sDzYIj60m+cHicWM5DOQ7ZZIxIAMwpwkApheMaSGWWEQeg8qJAqcn3TEUBKhAkMDHILfvuZnlnoGw9QrMoJxomUpKheK5ENBTSE1NrGrRo0Gg01aLFgWZBciru8OXDIzhOlpBK5Ts1Tl7kpZQ4ro2aWpegFKbhWyBL5dcVKJX/95T3FoSBkB5dX/97ImcOckn0MKtWBAiFgk36hJVRIhpcF8cpJxq6kCsn0xOFFIUWDRqNZia0ONAsSPbt28fevf/Cinf8Khgmtpcuuby7LrjSLg0KTBEHCl9MKEXeACkfSSAvDJSk85FvEHnxKaSSSNehxz7Nxr5Benq7WxpFqIRKRYO3YrIQshBt0KJBo9FocaBZcDz00EP86//8eT78Rhjd9m6+v+FDSGFheRkM5GRKYbobggLT8PATDAqlDN/HIB89QBhgB0B6dO7/dyIvPlXyds/zsIi3bRShEoqiwXNxHcdPTyQlQ3GHobjkVFwyJDtLIg1btmzhhhtumNV4SqPRLC60ONAsKL797W/zL598Px9+Iyxf1gtCcK7rGh7f8BHioVX+dEM3jevaMP1ipsAwvHwKQU2mFgBpBlDCxJoYo+vhfyNw5njZ7S/EKEIlKKX8CINbXjR89GuHMUw981mjWSpocaBZMPzXf/0X//Q/3s9H3qiKwqBAzozw9No7OLLiTTgE/Au/54L0JjMLCgxD5qWBQhkW0vQNkoTnEjz0A6JPPIzlOnOOpRBFWBs9wuoV9oKMIlRCQTRc9v89ijCmRWIOHYL9+2HdOojF4I47WjJGjUZTf7Q40CwIvvOd7/DV//5zZYXBVC64ER61303s8l144Q4wTFAShJG3PVIIpP9+KTHTE/QceYyuo9/DGx0jkenFqvAOebFGEcqx4Te+UyoOJiZgzx745jfh5En4xjfgnnvgwQfhM5/xn5/KxAR88pPw6U83d+CLDE8pRjIeQ2mX4bRH0pV4SmEKQdQyWBE2WRm2WBYyK+5iqtGUQ8cJNW3Pww8/XJEwAHAunCVw6jEGnn4Kp2clzvLVOMtW4YU7UIaFTYKIFyMcO0V49ATOYAwrf0H3Agorm0CqLgwx90XeEAaGHWTc28Bzw8tYm1rcUYQSHnkE1q+fjBzcc4///FveAp//fPnlY7GLnlZKMTY2hhCC3t7exo55ATOR83h+NMvB0QxJRyGV8vuMTLm3K/xtCEHU9t1Er+wL0hWYrROJRlMeLQ40bc0jjzzCF//bz/JLFQgDz3UZjPUhDAshJYHR8wRGzxdfV1IRDozR3ZmGfHIhJSykCiOEwDQMopEcsbiDYVd+gTdNE091cTx+DWOZ02zoG6R3EUcRAOjuhuuug507/b9PnvTFQjkefNAXDV//epkXFaOHn+Bzv3U3g24HzootbNy6rVgIuXXr1iUtGrKe5NFzKQ6OZvH8FqFYhsAWBYvv0t+DUiCBRE7y2GCK7w+luaYvyC2rIgTNRXw8auqOFgeatmX//v384+/8jC8Mls8uDABS6RRjqXUzXpSFKO21AALLdMm4ElP4d1e2JQgHEmRdC9Os/I5rahTh+aUQRdi5Ex5+2L/wgy8WyomDQ4fg6qtnXVV/d5Cfu3k5juPgui8Tj73I0LccfvDPkq9NSC7IKJm+LWzMd7ksCIe+vr4GfLD24VTc4VunE4znPAwEASEQxuy/ASEEJmCawq8XUfD0SIbjcYfdaztY12nP+n6NpoAWB5q25Lvf/S7/8Nvvq1gYoGBsXJF2e7BmOqqFQErf26CwOttUZJzJJtBCCMJhl8xEBkkEo4x74mwsqSjCJz5R2XKHDvmPkyfLigXDEITDYcLhMAB9wPrV+DMnXCcvGg4Tj73E0F6HH/yL5OtxxXkvQrr3MjZtu5LLLrusaPC0GETDwZEMD51JIpUq2oRXixACW4BUEMt5/NPxCW5dE+WaZaEGjFiz2NDiQNN2fPe73+Uf/r/38YuVCgPAcXIMT/RjTq+on4aUpa8LQ2AZDlJZxXn8pmnSEU6RyARrmr63KKMIldYt798Pp05NphKuvtp/fOELflHiReudYd0CbNvCtq2ZRYPr4DpHiMdeZmifw1P/Kvm3uOKcGy6JNBSiDcuWLav54zeTgyMZHjrtC4PAlA6htWIIQQDIScVDp5MAWiBo5kTPVtC0FY8++ih//1t38Es/LFlRoTAAGB8f54kj1yCN7lmXk16agWUjiCkFhzlHkXGjJcLCk5KJiSDS6KyoOHHG7U2Z0bCQowiXfOQBrO6Buq9XeS4TB77G6L7PzHNFTDF28vtPxNOSCxNOvsul4qwTJtt3GRunRBq2bNnC8uXL6/Nh6sCpuMM/HZ9AyvoIg6kopchJhWEI3rGxS6cYNLOixYGmbXjsscf4u998L7/4w5KVVQgDlOKVkykOD78Ga446Ac/NMrBsuOQCraQknolgmqUny5wjGYt3EbDnf5e10H0Ren/kHrpf886LvQ7qwNm/v4fs6UN1Xy8wi2hwGUx4RdHgLN/Iui3XXBRpaKYrZNaTfP7wOOM5z68vaMC2lVLklKInYHLHlm5dpKiZES0ONG3B448/zt/+5nv5xTd61QkDIJvJ8MyRFcRyG+Y8obquy6pl56fdvStSGQtJuOT9SiniSYOc21NVceJMTEYRzrCh7/yCiiIIO0T/Oz9NeP31KCl974j5YBgIYTD6nc8x/liZqY+NZopo8HtPOCQyiuFxpygazuRCRdFQiDIUIg2NuHBPb0XeKKRSOEpx/bIQP7K2o2Hb0SxstDjQtJzvfe97/M3H38MvvtFlxfLekpB/JYyMjHLg+I1gROdc1nU9VvYOYk8rJSiXWgBwPY+x8U4MO1x1ceJMLOQoQmDV5YTWXoOoYqpnOWQqRuro9/HiQ3UaWZ2YQzScTSjOOSHSvRtYv/XakkjDfETDRM7jr1+KoRTYc8xIqAeOVAgBP395j/ZB0JRFiwNNS/n+97/PX93703zsR2oTBkpKXjrmcXLseowKQqTSk/R0DhEOlt75zpRaUArSGUUyW7lzYiUs5CjCkqSMaEhmFEPjDsNJj9NxxblckHTfxZGGFStWzCkaHj+f4rHBVMPSCRd9nHx64eb+CDcNRBq+Pc3CQ4sDTcuYrzAASKVSPHVkLSlvDdMNYcohpaQrfIFoxJ32SvnUAvjFiePxEEp0zKs4sRwLOYqgARS4npufbum3xk5mJMMTOYYSsigaUlMiDVu3buWyyy5j5cqVCCHwlOKvXhwjkZNNrQHIepKOgMEHt/Vqq2XNRWhxoGkJP/jBD/jLX3/3vIQBwODgKE+fugnDrOyiKqUiGhylqyPDdDExU2oBIJfziMW7sQP1nwKmowiLkKJoKEy7dEmmPYYnnEnRkA2S7F3PptfuoudNd/hTDi0T0zAoJ3RfOfA4mcQE6fg4N77lnQB88Xd/mUt33FT8uxo8pfAU3LGlm5VhPatdU4o+IjRN54knnuD+X38PvzJPYeB5HoOxPhCVT8kSTHdJnGS6IVLJa7ZBKJgi5wYw63x3N+mLsJ7nh/sWhy/CUkeAZVlYlgX4grKvFy5ZNV00nOFE5DSvSBcvkyCpQCqBMkxM03+/aVlMDJ0j0tlF36q1/M29HyyKgTVbr2Lk7KmahmgArlIMp10tDjQXoW9PNE3lySef5P/+2k/zyz+cm5cwAEin04yl+6u6yxaGQHp+h8Zyr1mGQ7lgmhCCSMhFyQyq7Lvnj2maeIbvrvj8q12MjIwh5TxnBWjai7xoCIdDdHZ20tfbi3nJlZhCEbINwrZBNABR0yNIFpFL4CZjnHvleSLLVvDEf/4zl1y1nWQqSTaXZdvrbmXZ6ktqG0q+vmEo7dX5Q2oWA1ouaprGgQMH+ItffTcf++EcK1fMTxgAxCZckrllM9slz4AnDfL9m6dxca+FqZimQTScJJkN1LU4cSo6irD0yAR6UMIERH4GryjO5PWDVIptO14DwOHH9rHrZz+EkUvgZiAZG2XFpVcB8NzDfpvsdHyc3lWXcOmOm+bctlSKlKsFqOZidORA0xQOHDjAZ3/lXXzsh3P010EYOI7D0PgKjBpMeaQyYYa7f9tUM87hFwKCQYVJCjnfef5zoKMISwdp2HPYU/t3+NlkgvNHD7P5mhswhMAyDYZPnCDSvYbzJ4/yyoHHueoNt3HjW97JI1/6q4q37+qyM00ZtDjQNJynnnqK//Mr7+Zjb8zRP89UQoF0Kk0sNYBRw5xwVYgclGG21AKAaRh0RDJ4jlP1dqvFEAZWMYpwBSfOpMhksg3frqa5GNKZ0fRLKYWSEulJLpw9Q+/A6vyyAscNAGCKAC88+gihjklDo3BHF68ceLyi7Vt6poKmDFocaBrK008/zWd++V38yhuzfsSgHlX4CkbGIeN11fR2qcxZ6gb81MJskQHbFoSCKTyvOXfyOoqwuAnlYgg1mfefKgiUzB+pQhDOX/yVgpwb4MXHH2LbzbcihCJ27jxmaNKvINzZTSZRptHVNAwhiFj6MqC5GF1zoGkYzzzzDJ/55XfWVxgA2VyW4fhAfspXDQgDTxkzKuPZZi1Avq1zKEc2nkYRQdTJOXE2ytciWIRCurveQqd74iQKA09KREGzCkCUHll9A2vYdtMb+f5//DvhaBcDmy7PL+oX0DgZieu5xXqYdHx81u0qpVBKsTKsHRI1F6PFgaYhPPPMM/zZx/bwy2+orzAASKXSjKcvR9RoM2sIkJ4BZvnoQbk2ztOxTJNoMEUyF2xYcWI5TNPEU34UYSyjfREWKkopMpkM6XSKXPoZuMJDGRZCejNKTang9e/9JVACBIi8khACegfWkUlOMD4+QV9fb7EocTYkvtBdoacxasqgzyiauvPss8/yx7/4Tj7WAGGAUgyNhvDUfCxfBa4325jmTi0IAcGQxGhCceJ0ytciZJo6Bk31SKVIp9OMjI5w9uwFRkcyuLkAfakhgpkYygzMLAykIOcGi8KgpGhGKNZf/VoGj72AzNpkMhlGz70652wFVyqitmBZSEcONBejJaOmrhw8eJA/+oU9/OobMwzUWxgA6UyG0dTA/O6UBUhpAjPP754rtQBgGiYdkTSxeIhAIFD7eGpERxHaH1mIEKRSZNISsLAtm3DQNzkqRKbWHt/L0SveVXaGrZSCnBco1QNTXhcCevrXcvlNb+LI979DKnmBne/+4KzjUkqBgGv6Qto6WVMWLQ40dePQoUOTwmBl/YUBQCKRZiKzEmHWfkITCN/roLzZgb9MBakFgIBlEAokcZVV974LlaBrEdoPqRSZdJpUOk0mLTGwsK0A4ZBRIgimsvr4tzl++U8hzSCmNzkjxZMCxwv4EQPU5OE6ZRUCBUqx9Yd2owApPezI7LNpXAWmEFzZp/0zNOXRtxiauvDcc8/x6Xtu51den26YMJBSMjjWjWJ+JzRh5GsOZl9qztSCvy5BJJRDuo1zTqyE0hkN3XpGQ5ORUpJKpbhw4QLnzlwgNppFOQEioSjRaIRgKIhl2TMKzXB6hDXH9qIME5UXmUVhQKkwENOOMyEmgwoCXzDm0oJsrvy0V6kUEsU1fUHdrlkzI1ocaObN888/z6fveQe//sY0A/2NEQYAmYJd8rx7Gwg8ZczuO8PshkhTsSyTaCiJ57XWhlbXIjQX6UmSySTDwyOcOztCbDSL9IKEQ1E6ioJg9sjTVC577ouEk+fxrBCuLPgYiIs9OS5a3XSxIDCwiY8nLxKsSikcpegJmNyySrdq1syMFgeaefH888/zqQ//FL/2hlRDhQHAeNwhkV1el3X5NQezM2mINMdy+eJEk3TTixPLoaMIjUN6ni8Ihi5w7twosVEHZIBw2BcEoaAvCGYyNZoNy02z7YnPojwP1+qYEhJQM2W/gMKmpgsEA9wgyWSy+JxSipxUGEKwe21HU9tDaxYe+ujQ1MwLL7wwRRj0NVQYeK7LYKwPYdSnTGY2C+VJCqmFuSMCpmESDadxHbcu45svOopQP7y8IBgausDZs2OMj+VABYmEI3R2hAkG89NZ51nYJ6VH4tnTZB94zJ+3GLSZLgympxQmmSYOACFMUnEX13NLhMGta6Ks66y8k6lmaaILEjU18eKLL/LJu9/OfW9svDAASKVTjKXW1a0SXykDpdSc5/NKZi0Ul7UFIbt1xYnlmD6jYX3fefp6uuuQmlnceJ5HJp0mmcyQy4EQFkE7SDRiYhrmvIXAdKTnceJsH8+efC3GiSN4wsR8+y0QCkDOmey9MMNmhbhYNBhCoGSQ8fE4HT3dGIYvDK5ZpotVNXOjxYGmagrC4N43pFnVBGGAgrFxRdrtqboD48yrNFBq7hP85KwFe87rgWEIIuEcY/Eswg43wTexMqbOaHhBz2iYkaIgSGXIZcEQFoEGCoIC0vM4dmY5h07diCH8A9x7/EW84REC7/phWNYNnoRZ+nnMFFGwwiYYEUjFecdVa3XEQFMx+vZBUxUvvfQSn7z77fz665OsHmhsjUEBx8kxPNHvn6DrhZjLCKm4YMWpBWif4sRyTK9FuDAyhmxSf4h2xXU94okEQ4MXOHd2jPFxF0OF6IhE6IiGCQSDmHVIGcyE9FyOnl7BoZOvKQoD8FMMxrFX4U8fgEcPgVKIUBCCASjzmyuZsWAKjLCBETFBwtl/HeYf7vhtItnZ7ZQ1mqkINVP7OY1mGi+99BKfvOvt/NrrE6wa6Gua2c74+DhPHLkGaXTXbZ3Sk/R0DBMOzX0RV1ISz0QwzcruujzpEZuIghFpm/TCdDzPwyLO2ujSiyK4rkc6kyaVzODkwDAsApaJZZl+C/AmmQJ5nssrr67ihVe3l7Qel1IhRAbLtjDy8Se3K0Tg5kvhhutRHVHfA1wpf14uCqkEyjP85z2FE/MY3Rdj7DsTZIdznL9wlKt+7ik+e/9nmvLZNAsfLQ40FfHyyy/zP+58W9OFAUrxyskUh4dfg2XWL3IgpaQjNEJntJLWy4pUxkISqei6oYBsTjIe72mJc2KlSCWRrkOPvfhrERzX9Y2JUhncnIEwTAKWhWUZGKbJrNMBGoDruRw5uYaXzlxXIgz8ZkhZLEtMiZQpEEkCUQPDtlDL+1D9K5EDKyAaRZkmyQnB2Jk+nNMe6RNZMqezJQagqVSKU+l9fOabP8HOnTub+lk1CxMtDjRzcvjwYX7ng2/jvtfHmysMgGwmwzNHVhDLbah4vnglKKkIBUbp6cxQyYUh5ygybrTi1IaUkomEjUd320YPCizWKILjuKQzKVLJLK5jYBomtmX5EQLToNmCoIDrurx0ch1Hzl5dIgzAjyaYloNtWsXxeUoSCMaxQ8Gy4lQBg4NBXnjl9UQiM3kXKC6MDJHY/AW+88QXF813rGkc7X3W0rScI0eO8N/ufHtLhAFAIpliPLuyrsIA/MixP52xMio1RCpgGAaRSA7pZlvom1gZi6kWwXEcJiYmOH9umMHz4yTjCssI0xGJEI2GCQQDLYkUFHBdhxeObygrDKRUGIbj1zhMHZ9yEZYxY9RKAIGAhydnS5EJerqXYRzexZ/92Z/N92NolgBaHGhm5MiRI/zOB9/Gr71ugoH+5gsDJSVDY51IFa7/yoVASjGnwVFx8QoNkaZimybhNi1OnM5UX4QXhq/gxNkU6fTC8EVwcnlBcH6YwfMTviAw84Ig4jfFaqUgKOC6Ds8d28zR81ddJAz8AG4W0zSKdQYAEoVlZfOCYWYCQRdvDkFnWRa94U18/n8d5vDhwzV/Ds3SQIsDTVleeeUVPvHzb+XXXjfB6oE+zBbkotOZDCPJfox5NFmajUpcEiepbtYC+NGJcNBDqOa3da6VySjCtbxwun2jCLmcw8T4BOfODzM4GCeZUNhGmI5ohGi0fQRBAddxOHh0C8cHrywrsqX0MEyFOe01JSWGpRDG7J8jYHnIWSMHPh0dHazI7uJj93xCu2ZqZkWLA81FHD16lE/8/Fu57/WJlgkDgHg8QyK3gkad4D1ZiUviJNWmFgAM06QjnMZ128M5sRL8KEJg0l2xHaIICrK5HOPjE5w9O8zw0ATJhCJghOmIholGQtiBQP6OvD0EQQHXcXj2la2cHLoco8xFXkqFYeYuTiegECKHYZtzfiIhwDZSc45FCEFP5wqG91/Hl770pao+h2ZpocWBpoSCMLh3Z7ylwsDzPAZjfSAaZ9qiKmi+NJVaUgt+PhiCdnLBRA8KmKaJbGUUoSgIxjl7bpgLQwnSSUXQChON+BGCdhUEPgrXyfH0kSs4dWFrWWFQTCcYZkk6AXwHZcvO5SMgsyMMsO25xQFAIBhkmX01v/er/8Lw8HBF79EsPbQ40BQ5duwYn/j5t/LrLUwlFEgXOjA2sM5BVWCJXEr1qQXIFyeGsrhe+xcnTqfpUQQF2WyW8ViMc+eGGB5MkE5CyA4TjYSJtHGEoBSFk3N48uVrOD1yaVlhADOnE4qv2aKi6bMCCAVTVBoJ6+rupnf0x/jt3/rdipbXLD20ONAAcPz4cX7r/T/Br94SZ/VAb0uFAUBswiWZW9bgrQg8Wd3nrCW1AGBbFtHAwihOLEdDowgKspkssViMs+eGuDCcJJMyCNoROqMRIpEQlr0QBEEBRSbj8OThazkX2ziLMJgpneCvw7IyGObcKQUAgUE4lEPKysSBYRj0dKzm8S9EeOSRRyp6j2ZpocWBhhMnTnDvz76VX70lztpVPZh1NBuqBcdxGBpfcVFFd70xKrZQnqSW1ALkixNDHqJN2jrXQl2jCAVBMBbjzNkhhocTZFOCkB2lIxIhHAli2YG8PfdCEAQFfGFw4PD1nI9twJjhtn+2dAKApxSm7VX+GzAEwWAOWYX4jETCrOAm7v3IH+uOnZqL0OJgiXPixAl+/Wd+gvteF2sLYQCQTqWJpQZmvOOqGwK8KsVBrakFyBcnhlILqjixHDVHERRkMlliY2OcPTvE8IUk2YxBOBCls6ODcCSMZdsLUBAUUKQzLk++vIOhiXUzCgOYPZ3gr8qFWbwNpuOnFXJzTmec/q7u7l6Mw7v40z/90yrep1kKaHGwhInFYjy+91/57+/ZzNpVfW0hDFAwMg4Zr6sJGxP56YzVhQFqTS0IwA5A0Fo4UxtnotIoglKKTCbL2NgYZ84OM3IhSTZjEgpE6YxGCYdDviBoUj+DxuELgx+8eAPD8bVzCIPZ0gm+t4FtZatrNCYgGHDmMEK6mIL3wT/+r6O8/PLLVb1Xs7jR9slLFKUUnutimgJhWORefZzxf/8YeLmWjiubzfLsK72MpTfPObd7viipCAZi9HamqO5OtbpeC9PJ5Vxi8R7swOKwsPV7NLj02KdZ33ee3p4ucjmHdDpFOu2BsrBNv7GRaVmLQAhMR5FKuXz/pdf4Ea9ZPl/53gmleNIjEE74dslVjGJk1OLp599AR0dHdaNXiuGRM4Ru+RoPfutLTTc707Qn+ihYoggh8iFc33nNXvMaItf9TItHBalUmvF0f8OFAfj1A9IzaphBUHtqAcC2fedEd4EWJ07HEAambRPz1nHo/DZeOZlm5EIKN2sRDkboiEYILZoIwXQUqZTD91587ZzCACpIJ6BAuAjLqjqxEgy4NRW8au8DTTm0OND4CEFw8+7WjkEphkZDeGqm5jH1x5NGtVkFoPbUAvgn40jIBbVwixMBFArPkziOQybtkcsZ5Oji1cx1DOfWIYSBZS7GSEEepYinPB5/4WbG0/0VCIPZ0wngexvYdramFJ9te3g1uh5q7wPNdLQ40AAghIERXdHSMaQzGUZTjfU2mI7ffKmG2EGNsxYKGKZJZ3jhFSdKFJ7n4TgO6bRHNgcSA8sWBAJgmQJhmIw6q3kxdjmjCaOqCvoFg1LEk5LvvXATE5kVcwqDuWYnFJDSQ9jUlK4yDDCpzAipHNr7QDMVLQ40k7S4tXAikWYis7K2M2ONKFVb5GC+qYVCcWLAbP/ixIIgyOUcshmPbE6gMLDzgsA0RJnogMAhytH4No7HVpDN5KhZSbUbShFPSB5/4WaSmeVzCgOoJJ0AoDBNP2pQyy9AGBAI1i4OtPeBZipaHGjaAiklg2PdKIJN3q6JqtG3cD6pBQDTMIhGsniOU/M6GoVUk4Igk/HIOgKEgWX5gsAoKwjKsNiiCEoxkZA89uItpHJ9Fe2DStIJAJ4Cy3Zr9veo1iWxHNr7QFNAiwNNW5Ap2CU325lRGHiqtm3ON7UAYFsGkVC8LYoTpZKTEYKsR84BhCBgCQJ2FYLgIhZJFEEpYnF4/IXXkc71VrQvKk0nACBdRIV2yeURhIJZ5Lz2raC7uw/j8C7+5E/+ZB7r0Sx0tDhYDBw6BJ/9LDz4IHzhC60eTU2Mxx0S2eVN364hwPNq9XeYX2oB/OLEUMhDyMw8T+q1IZXEnRIhyDkChMC2/YdhGPVL8yzgKIJSirEJwWMvvI6001OxSKosneAXd5p2FiM/e6gWhCEIBZ1521pblul7H/ye9j5YymhxsNCZmIBf+zW45x64+mr/b/CFwoMPwic/ObnsF74A+/eXPtcGeK7LYKyvOK2yuQg8r/aL33xTC+A7DkYjKWSVBja1UhAEWcclk5Xkcr4gCAQMbJt8QWij6j4WXhRBKUVswuDxF19Hzu2qQhhUlk7wl5UYljevyJlAEKrSQnkmOjo6WJ67lY/d8wlkjTMgNAsbLQ4WOo88AuvX+xd98EXCgw9Cdze85S3Q1+eLgoJo2LkTTp2CkydbN+ZppNIpxlIDrTFfEeRdEmt8ex1SC35bZ4UlEg0rTiwKgpxDJitxHOFv1y7UEDTZsrgkimC2bRRBKcXImMljL1QnDKpKJ6AQuBg1eBuUICAYdOqSohJC0NO1ggvfvZ4vfvGL816fZuGhxcFCp7sbrrvOv+ivX+9f9N/yFv9vgBMn4NproasL7rjDFwrr1vnLtgMKxsYVabenJZsXxc6MtV7d559agEJxYg7PrV9xYqkgUDg5v2YgYIsmRAgqoRBFuLwtowhKKS6MmnzvpZ24srOq7Eql6QQACViB7Lw7ofozYNy63ekHAr73we//2r9q74MliBYHC52dO2F0dDKNcOrU5Gv798M11/jphgJ33OFHEdokcuA4OYYn+qvzka8jwgBZdfOlUuqRWgCwLUE4kJhXW+fpEYKcQ14Q+FMnWy8IytCGUQTfUtjmey+/Hk9Fq3pvNekEACUlWKourqDBgFfXtuC+98GP8//95n+r2zo1C4NWJHk19eYTn7j4uUOHYHzcFwOHDvlioLvbFxMbNsA3vuGnIFpMKp1mLHVZU+ySyyPwlIFStdfdFVILUtnzqt0TQhAOu2QmMkgiFYSjfaSSSKnwXIknBUIYmKYfIfAvTm0mBsoyGUXoy51nbfQ8wWCNbkDzRCnF0EiAH7z8OiThqt9beToBQGEYWb/nRE2jLSVouTW7JJbD9z5YxQ++0MnDdzzMG97whrqtW9Pe6MjBYuTkSbjrLvj85+G22yAWg9e/3hcLDz7opxrKCYNmm/EoxfCYRU5V1yim3vguifOhPqkF8IsTO8KpOe+e/QiBS6ZYQ+CLlECgXVIGNdLiKIKSknPDIb7/8s6qhQFUl04A3y7ZtJ26Rc4MU2KQrsu6CkQiYZaJ13LfR/9Eex8sIXRXRg0ASkncweeIfe1nm7bNbCbDM0dWEMttaKn/vvQyDCy7gKjAITKych2dqzdjWHbJ80opMk4AQ0w7yStFamyY0WMv+uHjCvCkZCIeQooOjClj8iMEEteVSGUiBJiGwjAWSnSgSqRHX7B5UQQlJWeGohx45WYQ1ZtxSakQRhrLsiuO+rjSJRRNYQcCVW+v7Po8j/2PX0M4emld1ldcr+txdvQ53vq7cX7jN36jruvWtCc6raDJI8gc/vembjGRTDGeXdnClIKPUgZKqVmvPWYownXv/yS9m66eeaFZyCYm+N7//SSxU6/MuaxpGETDacYSASwrMCkIpIFhCEzDwDJg4aQMaiQfRYjHelgXPUFPxMGooSFRJUjpcWawk6eO3lSTMFBKgagmnQCgsK00hlm/07AAgqH6Rg5gqvfB13j7219m69atdd+Gpr3QaYUFSj0DPkpJMs89QOa5r9RtnXNuU0qGxjqRqvrQbd3HgoGcwyVx2099jJ4NV9S8DTsc5eaP/M5FEYey41FgmhCyUn7KwPUFQSAgsCyBWKgpg5po/IwGKT1On++uOWJQWIdhVJ5OAPCUwrBknafwCkLBdF3PDwV874Nd/NKHf0t7HywBdORgATI8PMyv3fUefuMn17Fqzep5GacoJ4Vz9mlUeqSOI5ybdCbDSHIthtkGFznhGyFZM9yUGlaAlVfdgphHXtgwTYxwlBWXX8vgc09e9LpSIJWH54GSBsIQRCMOjueiRIClIwZmoEFRBCk9Tp3r5enjr8Uw5hZu5ddRmJ1gU/n3pBDKRVhmXbMlQgiCAYd0VtbU9nmudfd0reDVR2/gH//xH7njjjvqun5Ne6HFwQJjeHiYD737rfzq9tP0TJzHSS3MrzAez5DIrWgLcWAgkNLAn3F+MYHOXgx7/jlhJSXR5QOTfyvl9zNwQSoDwzAwDQWmopAy6IgkmUjZLa3JaB+mzmgYYm307LxqEaTnceJsH8+efC2GqO13VFs6Ie9tYGfz0x3rhxCCcDDHSMyruzgACAQCLLOv5FO//nne9KY3sXLlyrpvQ9Me6LTCAuLChQt8+Kd/kl/dfpqNl/RgWQtTGHiex2CsD0Rtd2p1R4A7S38FUaewr1/XIPCkR87xGxtJz592aNsK0yR/oZu8yNiWR8Csfw55QWOYjDoD85rRID2XY2eW8+yJH6pZGEBt6QTwhaKwZf3rbfIuiZ7n1ne9U9DeB0sDLQ4WCAVh8CvXv7qghQFAutCBsRV2yWWYv0ti5biuQHoC0xBYlsIoIwhKByeIhNKoBp7sFyZTaxH6q6pFkJ7LK6cHOHTyNTW3R4Z8P4QqzI4mURgiN3+75BkI2O68my/NRsH74Il/6OI73/lOw7ajaS3tcXbWzMrIyAj3vOdtfOzaU2y8pHtBCwOA2IRLMres1cMoIkQ9vA4qwzCVn0qZTRBMw7QUkVCKZoiXBUeVUQTPczn86iqeP7VjXsLATyfkqk4nQN7bIJBriCuoAIJBF7eB4gBKvQ/SaR3ZWoxocdDmjIyM8OGf/kl+8ZoTbFrXjVVBtXs74zgOQ+Mr5nVirjvCjxxUXeDdtFbZfrc9yDVwGwuZyqIIrufy8sm1vPjq9nkff7WmE8AvPBWWaJhtg217TejwKeju7sM8sps/+ZM/afC2NK1Ai4M2ZnR0lA+952384jUn2LyuZ8ELA4B0Kk0sNZA37mkflKzyp1BNq+w6IAxBRyjVkClqi4ZZogiu6/LSiXW8fObaOgiDWtMJAArTzDSkWLCAZUpQ2Yatv7idvPfBF3//GC+99FLDt6dpLloctCmjo6Pc/dM/yS9dfXzRCAMUjIxDxutq9UguwpMmVYXtK22VXUcCtoetixPn4OIogus4vHB8A0fOXj1vYTCfdAL43gaW5TU0ciaEIBRKNmz9Uyl4H3zsnk9o74NFxsJOXi9SxsbG/IjBlcfZdMkiEQZANpdlOD5QUyi20ahqmy9NbZUNk62yC5w4Ae97X30HKQSRcJrxiQCizlPgFh35KEI81kVmxOLsyMbi3XrH8g4GLh3AmMnYYhb83gkepjBIXIhz/si56kyZpAu20VAnaCEgYKcat4GSbWnvg8WKPsO0GQVh8AtXHGPz+h5se3EIA4BUKs14+vKW2yWXQ3HxhUIp5feccMvcEe3cCQ8/7EcLwBcL69f7/y7XKrtOWKYiHEqTcTpY8sZIc6AUHD19GecvDBCxkizryrDnf+xh686tdfONiA9P8LX/74ucffH0nMtKFJadwarRbKlyBKFglpynmuKPEQgEWBa4kk//+j9o74NFRPvdwi1hYrEYH37v2/nItqOLThigFEOjITwVafVIZsB3SVRKIaWH6yo8148ozGhA+YlP+NGCt7xlMoIwvVV2A8YZDmbRxYmzo5Ti5KtrOX9hFcIwSLkd/Mgv/RRbbtlS1wtmtK+Dn/6jnyMYndt2WUmJYYNosPGXEIJwKNvUMH9XVzc9o2/W3geLCC0O2oRYLMYH3/k27rn8FS5dbMIA3y55NNU+3gZTkVIipUfOtfHtBHynQtMCo9jgqALKtcqeiqAufQGEIYiGGuOfvxhQSnHi1CUMjQwUo1R20OTGN2+dl9V4OQzTIBAJcunNl881KoTIYVhmw+M9BQtlr4ntrqd6H/zXf/1X07araRw6rdAGjI+Pc+e73s4vXrU4hQFAIpFmIrOy4XdNlSKlxHMlnvQbL1m+PSGTqfzJceYSYyjpzd1bYf16ePzxGV82DJN0rD49LIK2SzabwW2DxlXthOdKTpzewMjYipL0VfeKKIFwY053nuPRd8nsvh1SgWU7GGZ9WjPPhS8OmlsgGImEWZZ+Lb/xC3/Kd574IcJhfWwuZNrvNm6JURAGH71i8QoDKSWDY90oaut4V89x5HIumYxvXYwQBGxBMACmIZCy/MXfy2UYOfIUch4uhUpJpOsw+OLTNa+jBCGIhtM1WQcvVjxPcvzUpouEAdDgOhc1Z0RCSg/DqrkNRHUICARdpGy2q+ak98Ef//EfN3nbmnqjxUELmZiY4K53/xQf2XaEyzZ0L0phAJAp2CXXOaRbCSWCIOenCQK2/zCLToWAKExnLM+LD/wx2YlRf52ei3Sdih9KKZRUfP+v/wA3U7+piKYliQS1cyL4EYPjJzYxOr6sDQteFaaZbUpKAfIuibaLV66QtsFYlklvZBNf/P1TvPjii03fvqZ+6LRCi5iYmODOd/8U91x+eFELA4DxuEMyuxyjSUebnzLwfNdDIbBN/HbMAmbTw56c+dSdiQ3x2Kd+lmVbbqBzzaUVTyVUSjI+FOPcoQNkE+PVfZA5EYRCWTLxUPs0sWoBrqs4dvJSYhN9iDa83fGUIhBwMYzmRc4CQRev4S6J5emIdrBi5If52D2f4D8eeqAt64w0c6PFQQuYmJjgrp9+B/dsfXnRCwPPdf0OjA1WBtKTuJ5ESt+axrAFgQoEwVTUHP0VpOsw/MLjDL8wc10BQKhnJX2XXY8Z9GdmBEI2a2/YOet7nHSSoZeeJTM+WtFYCxiGIBpKksh0L8m2zq6rOHr8UsYTvbUJg0OH/Kmn69b5BaSNmKevGu9tMB3LlKgmuCSWo+h98NiN/MM//APvq7ffh6YpaHHQZArC4ENbXlr0wgAglU4xllrXgLsHhfRUXhAIEH50wDILTkY1eN5Lk+qckC5my1s/zPrXv8Mf4ZQ7t9kC/wKKxY4vf+ufeP7r1TkrBgMu2dzSK050c4pXTmxhItVdmzAoWGB/85v+TJNvfMN//sEH4TOf8Z8vUHC/PHTId8OsEIXCtBrTZGk2hBCEAs0xQipHwfvgf9/7D9x2223a+2ABouM9TSQej3P3e27nQ5e9yJYlIAxQMDauSLs9dVuh9Ao1BArHnVpDIHwBMo8Lu6eMeWXvB67/kaIwAP+CX3gYszymzoLY+qZ3sOrq11S3YSGIRFJLqjjRzSmOFIRBrV95OQts8H0renomlzt5Ek6d8r0s1q3z/64QKSWm5TW93kYICARba7Vd8D74xMd/p6Xj0NSGFgdNoiAM7r70BbZsXALCAHCcHMMT/fO8a5oqCCQ5V+UFgcK2mbcgmIqstvnSNPqvfcO8L9DSc1lz/c1Vv88yl05bZycHh49fTjw9D2EApRbY69fPfNFfvx6eeQbe9S5fJBScMOdEgXARttUCL0tBKNhaL4yC98GT/9itvQ8WIFocNIF4PM7Pv+en+OCm5/PCoDlznVtNKp1mLNVfQ/X4FEGQzkcITFG3CMGMCIFUta83vGw1xjy77RmmRXT5QA3v9C1zUc2evtZcnJzg8PGtJDKd87/g7twJo6OTnTRPnSq/3MSELyI++lHf4KpC50upwLZzDe3AOBNC+G2+W90MKRIJs0y8lvs+8n9Ip3XTsIWEFgcNJpFI8IH3voMPb3qRy5eQMEAphscscqqj4uWlJ8nmIwSOo3xBEMhHCIRo+CRxAXhe7SfyehUEihpD0IXixMXqnOjkBC8f3UqyHsKgQDkL7Ol8/evw4z/uv/6lL02mIeZAKomwVVMLEQv4NQdOy2YsTBkJPT19WK/cqr0PFhhaHDSQgjD40MYXfGEQWCLCAMhms4zM1YFRFSIEHumMwnEVpukbE9kB0RRBMBXB7F4HC4FgwMUyWlOl3kgyGYOXjl5OKtdRmzCoRjDt3+9HEQpNtd76Vr9Ycf9+P2pw0YwGUWb1CtPIYJrN8TYoRzDotMTrYDqmadIb3ai9DxYYerZCg0gkEnzwjtu5c8PzbN3YtaSEAUAimWI8u/LilIJSSClxPZBKIPB7GPg+BK2eiifmXXfQcoSgI5xkLG7PO8XRLmQyBoePbSPjhGu+0CZiGaRUGJWkuHbuLLXB7uqadYaCMAXJ0XjJc56CQNDBMEI1jnieCAgEHGTLIwc+HdEONnpv4k9+/3P8xd/8ofY+WABocdAAkskkd75vDx9c9xzbNnYRCLTWNrjZKCkZGutEqjAGoKTf+thxFQrfh8C08gdfywXBFOZwSayJZsyjn4ZpKsKBNFkvykJv65zJGLx89AqybmhenySTdDhy4CyXXr8K06pz8yXD4PCjL5U8p6QLhtmyw1sAwYDXFjNYVq4L8qE/3MLlr+nCMH6q1cPRVIiWb3WmIAw+cMkhtm1aesIA/A6MI8l+pFJksh7ZnMJxBablFxXadiFl0OqRXoycxSWxagrz6O+5B66+2v8b/I6N73oXfPKT9dvWVIQgEs4glNOY9TeJdMquizAo8A//4xGS4xkAXMeb9pBVPwqNjf76fz3Nc0dCOI6H72ygsOwMptXayE0w6Da1M2M57JDBf/una9h6Q1dlURtN26AjB3UklUpx5/v28PNrDi49YaAg52TJpDOMxtLEkv0oAywLJs8J7X9ycOsZOZg6j37dusnQ9C/8gl8A10CEIQgHUySz9oJ0TkymbI4cu5ycF6zbUTN4cpzf/skvce0bNrBu23JM20QpyBKg2vskJRWjwxl+8NAZTh+Lg+pn3O1mXfQ4HXaGYFBimK2drmyZHpLW1p9c98Ze+gaW0HlwEaHFQZ1IpVJ84I738IE1B9m2eYkIg7wgSKczpFJZpDQxTIukewmGbfjRgQWGUvN3SSwydR49+PPo16/3i93274eHH/ar5RtEKOiSyWWRtCjvXSOJRIAjx7fiyPoJgwLpeI7vPXiY7z14GCUVCaJkVWT+KxaCnArzysTlrAyfY3045VtOtPInIARBu7XTB9dfEcV1JJatg9QLDS0O6kA6neaD73svP7/mycUvDBRkc1kymTSppIMnDSzLIhCIYpgGylOMJVcuSGEAoPIuiXUZ/c6dvgAoVL13d/vioBBBOHnSf61RUQQh6IikiC2g4sREIsDh45fjykBDr6sKcLDIynB9L+DCYMxdRjYW4ZLO43SHchhma34LhoCg1VpxYNliKfhyLUq0OJgn6XSaD9zxHt6/+gmuWKzCQCmy2RyZTJpkKoeSFqZlEghGME2zpH4gnpbEs/N0rmsh3jxMkMoyPTJQmCO/c6dfgzDVprcBWKYkHEyTddu/ODGeCHCkScJAKYjLzgYUxCqEoch6EV6JbWNZeJA1HWcJ2K0oThQEQ2m8ekXCNEsKLQ7mQTqd5gPve68vDBZbjUFeEKTzggBlYVoWwWD0IkEw5S1ciK9ALOA6V6VMlBI1nUsrMh/audOPFhREQrmoQT1d7YQgHMyQdYJt3dZ5YiLEkROX46kmWA1LRZIoStT/9GcId8r0XYOR9ADxXDfrWhBFEEIQDDjE07IlLo2ahY0WBzWSyWT44Pvey88M/MAXBsFFIAyUIpvNkkpnSKdyKCwsyyJUEARzVBu7rstoclm736DOiScNDKP6C3Rm9DzRlevmDuEXBEEZRz7peSQuDFa97dkwTEE0lCKR6WrD4kTF+HiUV05uqUkYGJbBhitXEOmq/PeXSHg8+2wOnDrHu5XCtN1p4liQa1UUQQjC4SzjyTYUBy2Y4qupDi0OaiCTyfCBO97D+wZ+wFWbF7gwUIpsNuMLgrSDkhaWbREMRbEss/KLiYJE2ibtdrCQZywZ+F4HNtWLg8FnH2bFlTfNb/umydlnHp97wSoJBhzSuRxStdOxqojFohw9VZsweO1bLuPdv/E6Ip3Vf6ZM2uVLn3mef/v7I1W/d2YUhjGT4Gh+FMH3OnDwPK+9Gr3N1Cr7C1+YbIClxULLWbjx3xZRiBgUhEFwIQoDpcik04yNjnD27DAXLqTJ5UyCwSgdnRHC4SC2bVV1l+kpyYX4wi1EnEqtLonnnn6IVx/7OuCnGKTnIT13lodXfBRSEkce+lfOPvu9un2WIkLQEUq2hSmOj2J0rINXTm6tSRhsvHol7/8fP0I4WpvzaChs8XP3XstrfmR1Te8vh2nmEGK2Y2cyinBifIBszqvK1blqhG+n3Wqvg4so1yp7ai1OT89kEa+mZejIQRVks1nu+pk7eO+K73PVpoUlDJSSZDJZ0ukU6bREYGJaAYIhf7bBfK/p0pPE0svqM9hWIkTtLolK8dLX/oyTD3+VZVu2YwZnnyLneiae8n+CTjrJ0EvPkhoZqm3bFWBZklAgQ86L0Nrcj2J0tJNjp7YghVHTSF7745chpZqX26HnSt7w1vX84Ntna15HEaWwTAlUcuw0J4og8I2QWt2Z8SLKTfE9dMg3Ciu8/vDDDfcC0cyOFgcVks1mufNn38dPL/8eV1/aRTDU/sKgKAhSKTIZiRImlmkTCln5lEG9NgSjiSg5L7QoiqK9efZXSI+c5fTjc19wPNcg5USaV0kuBJFQmlw8AEarwsyKCyPdnHj10pqFAcDAxt552yCblsG6y7rmtY5JJEqIKj5Pc2oRAgEXz2uzNt7lpvgCjI+3bkyai9DioAKy2Sx3/dzP8NN9j7W9MFBSks5HCDJpD4SNbdsE6y0IpuBJyVhyeRsWu9WG5zUn22aYHriV3m3Wa5uCSChFKtdF86MHiuHhHk6cubTKC+nF1OtO26yxPfZ0bMupMaVWGkXoCuUw6xhFsE2J57WhjXY586+TJ/3/j4/7kQVNS9E1B3OQy+X40M//HO/ufbRthYGSklQqxYULFzhzboSxsTSeFyAc7qCjI0IoFMRuYIV0zpHEUosgpZBHKrMpxi1CCGyj+SfuUNBBNN1WVzE03MeJM5fCPIVB26EUwpyPddZkFOFkvWsRDAgGUnVaWQMp+H4U2mXrlELL0ZGDWcjlctz9/p/l9u79bScM/AhBhlQqRSarMLCw7CCRsOn3kG/W2VfBWKIbqawFP4WxgF+Q2BzvW9vwcLwmm9QIQUc4xXjSxjCaEbVQDA4u49S5jYvSjMcQXp2iZvWPIggBQTtTh7HVRiLmIir9DAXn0DJTfDXNR4uDGShEDG7v2s+1bSIMpJRk0mlfEORACAvbaoEgmILnSUaTyxfVSb+uFspz0IrUAoBtSUJ2Nl+c2EgU586v4NVz66eYAzWIVsydV2BZTh2Nv+pbiyDyLomyRY0enn14jDs+sbHp29XMH51WKEMul+PDH3g/7+h8hGsv62ypMPA8SSqZZHj4AufOjTAWyyFViGi4g45ohFAo0LBagkrI5GAi09eajTcIiUmzTqStSi0UihOVbFyxmlKKs2dXNkcYzNQee/9+v/Dts5+dfK6uyAbpOj+K8NLoNmIpG8+rLc8ghCAUyCK91sxYePWlFP/5N35xrutWN4aKHEc1DUNHDqbhOA4f/sD7eVv04bwwaH5HO8/zyKQzpFJpcjnlRwgCQSJhC8M02uYmXSkYifexaPIJU/CkwDKbc3JqSWoBMExFNJRsSHGiUoozZ/s5O3RJ44UBlG+PffLkZOfLiQnoqtfMhElMs9ZCxEqoQxRBCEIhh/GkbFnzrb/97WMc+m6MG29bRt9AoKJiUtdxGHdeZcdNW+jo6GjCKDXTWfDiwFOKkYzHUNplOO2RdCWeUphCELUMVoRNVoYtloVMzDl+VY7jcM8Hf563Rb/D9Vu6mioMPM8lnc6SSqXI5cAwLGw7SCTSXoJgKq7rMZJasahSCjDpkmiZzZkC1qrUAgiCQd85UVG/6JhSitNnV3FuaE1zhAGUnzu/f78vCh58EJ55pv7tsZXCNCSND8DWXosggFAg23KXxAPfGuXAt0YrXl5KyeDwCbbc8f/4y7/+8waOTDMTC1YcTOQ8nh/NcnA0Q9JRSKUwhEBOCUUV/jaEIGoLrukLcWVfkK7AxSdhx3H4yJ0f4K3hbzdNGBQEQTKZwnEFhrAI2CGiUQvTMNr+hjyVNUnmOhe0XfJMeJ4JdnPEQSG14NRqvjTPbXeEk0ykAnUpqlNK8erpNZy/sKp5wgBmnju/YYNf+R6L+fa8da1DkMxqiFhXaowiCAgEPLx2M0KaA8Mw6Okc4MkvdvPQex/i1ltvbfWQlhwLThxkPcmj51IcHM36rUgVWIbAFiJ/civ9tSgFEkjkJI8Npvj+UJpr+oLcsipCMD/H2XEcPnrXB/nxYOOFgee6fqfDZGaKIAgTiJgLQhAUkFJxYWJx2CVfjKjZQrlWWpVaAL84MWCmcGR0XutRSnHy1bUMjQw0VxgUmB4Z6OmZtOXt6fEFQh2xLKcF3h7VRRGKLontZqFcAeFImOXpG/n4R/8P3zlwE5FIo4tnNVNZUAWJp+IOnz88ztMjGZSCgBAETQOzKAwuRgiBmV8uIARKwdMjGb5weJxTcQfHcfiFu+/kxwIPsWNrR0OEgeu6JBJxBgeHOXc+xsSEh2mGiUaidETDBIK2b8aygK6znucxthjsksshqN1CuUYM0wPRors7IYiGM/MqTlRKcfzkuqYJg4pq1Qp2vIW0QpmoQc1Fb0phGq2ZAVCtL0KgHfsrVISgp6cP++hu/uiP/qjVg1lyLJjIwcGRDA+dSSKVwhaipjtWIQS2AKkglvP4p2PjnNn7Zd5s78sLg3Ddxuu6Lul0ilQqi+MKTMPCtsMEAgsrQlAWBROpEBk3sihTCuAXJDaTVqYWwC9OjIRSpHOdVHtwep7kxKsbGBlb0bSIwcSFFJ4r57ZQLsydL2OqI6VidKg2DwAhPFp/8FcWRQhYHtLLtWB888c0TXqiG/nKpw7xjne8yLZt21o9pCXDgogcHBzJ8NDpJFIqAjUKg6kYeZGQzmRZ+bofo/sN76yLMHAch/jEBOfPDzM4GCOekMUIQTQSJhBYeBGCcnhSciG+YpGmFHyUav5F2ja8Cm+JG4EgFMwhRHUXEc+THD+5qanCAODgwyfn3VsB4AffPlP9m4reBu3AlChCbIYoggG2nW7J6OpBZ7SD5c4P8ysf/u0FGgFZmLS9ODgVd4oRg4Axc/qgGhSKiYkJLGccwzR56rJf4FzXNbWsCMdxmMgLgqHBCRJJiWWFiUSidCwiQTAV11kkHRhnQUqz6RfqlqYWyBcnBpMVh9o9V3L8xCZGx5c1vcbgwN6jPPGfrwDgOh6uI6t6ADz/xDDf/PKx6jeuFIYB7fWjNhjJlPdF8F0SF644QAh6upcz8viNfP7zn2/1aJYMQrWx00TWk3z+8DjjOY/ALHUF1aBQjI+PEyRDwDJACBwzQmfmHG957mME5Bw/IgWO65BOpUmmMkjPxDBNbNsXAQs+ZTAXCs6Phjl2Yduim8JYikt/71DTC84yORtHNt9bo4hSxJPhOYsTXVdx7MRmYvG+JlbslyIMwWU7VnH5zesJdHVW/L50wuXQ94c4+Pggrlv96c8UDnbAo31/6JJloUHWdPozGqSUPPnsBpS4jvYd89zEYmOciX6Bfc/+Gf39/a0ezqKnrcXBt08neHokU3ONwXSmC4PCiV9i4JohLh/8N1578i/LvRHHyZFOp0mmsnjSzNcQWEtDEEzB8yQvn91ALL2i1UNpKFJKVi0733Rx0PQ2zmXHALFEN8IoX5Lkuoqjxy9lPNHbMmEAfvcLpWDM60GJJpVPKYVtZ+rWzbFxKAJmmnWdx+kMZXjhpdUkMq/BMNp93DMjlWRw6ASXvfd7/NXffLbVw1n0tO2RMpHzODiaxaDewiBbIgwADCSG8jiy4kdJBpYX3kAul2VifJxz54YYGo6TTAkCgSjRSIRoJEQgYC26lMFcZLOS8XRvq4fReIRAquZ/sa1OLQCYliIcSlOuNaWbU7xybAvjydYKAwCkIimjzRMG/kYRrakZrZLJWoRTsdWYtoPrtGHr5iowhEFP1wAHvtTDvn37Wj2cRU+rf94z8nzex8Cqw/lZoZgoCoPy6QlTZvEMm5d738j4+Djnzg8xPJwglYZAMEokEiEaCRajBUtJEBRQCkaTvS0p1ms2grwRUrO326peC6WjIBzMIlTpONyc4siJLUykulueUVJATthkVXNTMJbpYCyoH79fi/Bq7gpOD2dIpxdw7QEQDodZbtzIb/7Cn5NKLYBW1AuYthQHnlIcHM2AYt5h3YIwCJCZURgopVBSoqTk5RU/SjJjEghEiUQjRMKhJS0IpuJ5HqPJxWeXXA5B870OCrR21oKPEIKOyGRxopODw8cvJ55uD2GgFCS8juYei0phmq3yNpgPAkyDM1zB4ZEOLlwYRS4wx8RJBD3dfVhHb9PeBw2mLcXBSMYj6SiseVZAlwqDqakEhVIKKSWe5yGlQikwZY5caBne8q2+IFhCtQSVkM4K4tnuVg+jSTTfJbFAO6QWAGzLI2CmyeUELx+7nESmsz1+Di1JJ7SLt0Ft2KaDYZgkrbW8ktnCyXPJBRtFME2T3uh6vvKpM7zwwgutHs6ipS3FwVDa9XsiVLDsKwce57mHv8kTD36l+NwXf/eX+cGDX54mDJgiCGRREIj8LAghBEJ5KGES69rcuA+3QFEKLsRX1LFvfZvTApfE4qbbIrUACEHAznD46GWksh1tIQxalU5AgWW6bbEPaiEYcFEoTMNA2R2c4fIFHUUoeB/86j2/o70PGkRbnumH0x5GBVMXR8++SqSzm9WXXcEjX/p/xefXbL2Ks8eOECCDbQqUUjMKgqmhAf8vyXinFgfTcV2X0eSyJRVJ8VoUOYD2SC24juDCSD8dobRvK9piiukEt8nphPzWxYJMKfhYllOsLzWEwLYDCzuKoL0PGk5bioOkK0u6K87E6LnTrN5yBc898i02b78J8FMJa665geUD/ViGfzKZTRBMRwmDbKCnTp9kkaAgkbZJu0urr3orxUGrUwuOIxgcHsB1g/T1jGJb2TJzF5pMIZ0wwxTLRmIabguaLNUPQ0hsM1vy3EKPIgQCAfoCV/BH9+1lcHCw1cNZdLSlOPAqvGO6dIcvCA595z+46g23+e91XUypuPS6HYDg+Ue/w9ljh3nyP7/Ok//59blXqgSeEah16IsST0kuxBdrB8aZUar5LokFWplacByDoaEBXDdQHMvA8sGWRg9alk6AfCGii1igUQMfgW1nL3p2oUcRurq76B27jd/6jd9t9VAWHW0pDswqLkLpxARnj7xQFApSKc4cOUbX8g0kJ9Lsf+AfWLVxK1feciv/9ud/kI8kqNKHH7AE/MiD4eXKTfFeskhv8dsll0Mpo6WHQStSC7msweDQAK5XKpA7wik6IhMt2R+tTSfkR7DAZ+8KIFhGHBRYqFGEovfBF/u090GdaUtxELWMiu9Sx86epm/VJcW/TdP07zIcm0C4iw/+wd8gPYORs+fYeO0N+XOtKH0ogVJ+O2ehJEZilGTSIZ3MkUlnyeUcHMfFdT08T/rTu5aKeFAwmoiS81po6dsiPK+1d4rNTi3ksiZDFwbwPLvMq4L+ZUMI1YLirxamE2AhehuUJxjIzpqunTmK0N4nu3A4zHJzBx//6P/R3gd1pC3FwYqwiczf1c9FqKPUU/2F/XvZctMP40krPxXN4MA3/43v/tMXuP3X/ydSmkjPQEkx7aZMoBAgTDpjp1BuBDcXxclEyCSCZBIW6YQglVQkE54vHlJZMpksuZyL47h4rsyLB9r991QxnpSMJZcv6HxrrShholrgkligmamFXNZkaHgmYeATsDyWdY+gmnhD2dJ0AuRTCu3cR6FyArZT0Xnp4ijCWJtHEXzvA/vYj/KHf/iHrR7MoqEtxcHKsIUhBJUcjn2rL+HK1+/miQe/wnMPf5M1l12J8PspkXNtlFJsv+1tbH/T29j3d5/N/zgEShlIaUwRCgolTITy6Bo/jjAMDNPAMC1My8YwgxhGGIMQyLAvHrIdOOkImWSAdNIilYB0UpFMuCSTOV88pHMLWjzkHEkstfRSClAwQmrtT6QZqYVsxmRweABPzn1nvrxnBNvKNOXwbX06wfc2UItCGAuCduXtuBdaFME0Tfqi63ng02d5/vnnWz2cRUFbNl7ylOKvXhwjkZMEa2hwcuHCGIYbQgiBkx6hszsCwP9+35t4x699ks3X3nDRuUahkIEwgfQIt3zj/diG9NuyVmsgr6T/81GFc7qfhhCGBCQYCiEUQkgMQ2EYAmH4PgyFpiiGkQ9itvqcpODsSJQTI1uXhCviRShFT+cIoUDrPAeUUiSyURqV9M5mLIYuDPgtqisknopwevCShrdpVlKRUB1kCTd0OzMPACwrg2VB63+M8+fCeDcvnri26qZRUik816FTnWdNaJi+vp72bOCkFEMj5wi85it849tfxjQXeKFIi2nDb9gvSLymL+SXA9SgXcz8DdCz+77Go//09xQiYuGOLsId3SgEskxaAQR9B/czcmYZIxc6mJiwcRwvH1KrMKwmDIQwLo48GPnIgypEHqK42Q5y6TCZZIBM0iIVvzjykJ2atvAknmxe5MHzJKPJ5UtTGORplUtigUamFjJpi8Hh6oQBQGckSUck3tBDsOXphPwojAXsbTCdgOXUdD5dMFEEIejpWs7o917L3//937d6NAuetowcgN+V8a9fiqEU2FXeoUxMTOCkLHKpFCcPPU4wGuXM848S7uzh5rffUVxOofxKAwHKCoCSXPGF3ySQGM3f+Suk8ggEMwQjGcLhnH/BN2b3SpgXJZEHP/yg8pEGhEQIBcKPRBjCjzwYpgEIPwpR8HNg/kNMpjyeffWG6qMni4hoaJzOSGuLnOrfxlmRTgUYHumvuYlWzrE4dnojGPW/Oyu2YnZ7WlaECCBEjkBALvApjJNkcjbff+G12Fbt+3QhRBFisRhnIv/IvoN/TH9/f6uHs2BpW3EA8O3TCZ4eyWCL6to2J5IJshMGRv7EpZTCtrJYZrm7f18iEAyy/OA+Ltn/xXKLFIWCHUwTjmYIhRxM08iHVpvZ/EUWIx5TxYMvHAoPBYbEEGCYIv/jnSYe5hiyUvDqUA+nY5uWdOQgFIjT05Fo6Rjqm1pQpFNBhkdWzru75vDYMi7EVtRdO7Y8nQCgFIFApu0ufPPBk/DdZ1+Hbc9fcHlSYrhJVorjrOqzCIdDtEuERSrJ4PAJLv3px/l/f/sXrR7OgqV1srwCblkV4XjcIZbzCFB5h0bDMFBICidTIQSOa2Ma2TK1BgIVDGGNDdP10L8iTemfEKYuJ/x1mFhIp5PEaAcTyiUYSRMM5QiFc80TCsIofoYy/SV9sSBBeb7KL3g4+E1jFALPr3kwZL7OwY88CATCEEXbatf1GEktjQ6Ms+F5rb84FFILzrx7PShSyRAXRlei1Pw/17LuEcbjXTgqWLejvphOkKEWX2v82qDFhGFITDNLPU77pmEg7Q7OutuIj5zzowi9PfkoZmsxhEFP5wBPfWkZe9+7l927d7d6SAuS1n+TsxA0DXav7cAQgpysbGojgGmYJcZGAEIYOG7pj0IBKhBEeB4r930NNxdgNB4lk1UzF4gLEKbAtGzcbBeJsWUMn13B6HCEZNzAdVyUlCXbbh7CFw+GgWEYGKaJaVqYpo1hhDAIIVQY5UXwnA7cbJRsKkwmESCdnDpNM0c8YZLMdCBl3sp6KXk7TEEqsy0+9/xnLSiSiRAXRuojDAAMA/qXDdXNObEdZicUME0XsejSaYJAFTMW5sKvRbCLtQgnzrdPLULB++A3P/oX2vugRtr+6F/XaXPrmmhVAsFXr9OXE3jSwpP+SacoDJRixbf/mcirR7FtCysYIZ7tYiJpIz05+3GeFwqGaePmuoiPLmf47HLGRiIkkwaeWxAK7UIZ8WBZGKadn6YZRqgw0okyElsNjgE5A3IC6YB0FdKV/sOTReGgFrF4kNLIC83WMj9DJEUyEWZkdCWV9TqtnM5ogkg4UZ891GKzoyJKYS0Sb4OpzOWSWCsFX4SzbJv0RfBafd7Lex8cf5P2PqiRthcHANcsC3Hr2iiGIcgpNWdTJj8tcPEyQggcx0YCKhhCSMmKh75G16EfTHmvIBgK4tHBSDxKJqdQldwZFYVCACfTRfzCMobOLGd0JEIySRsKhXKIfPGhIpbu9e/eCo2qlAHSAM8EzwDX8MVDVqCcCsXDAqRed9nzpfZZC4pkPOKnEhrycxesWjaIkPNzTmyP2QkFJC30vmooQTvbkBYZ7RhF0N4H86OtCxKncyrusPd0gljOw0BgifJ1CArF8PkYFuGLXhdBgWlJAhPDrNz7T0RePTrj9pRU5JwcAZGhI5zx581We9JQoKRECpdgOEMkkiYQ9HwvgzYtdoonbV65sJXa75xU6T+N/D8Ek6Kt6F4tiv9sdSi5HFIpVvWdb4uhVT1rQSkSiSgjY8tp9F3w0OhyRiaW17SfFKAkjHmtnZ1QwDIXj7dBKYpj5y7h7PDm/IyrxuDPaHDpVG1Qi5D3PrBv/DL//l9f0d4HVdCeV6cZWNdpc8eWbq5fFvIdEJUi60m8aVbLfnEdFC5SwhQYYQMzYoCEc/98lo7PfIbIqZmFAYAwBMFgEGl0MJroIp2tMIpQshIQpoFp+BGF2IUVDJ9bxthoiFRSIb32iigoKRlL9TG/E+OUvhXC710xGXkwSiMPuSmRB6c9Iw+FVFSrqSq1oBTxeHOEAcDyngtYIlfbfaJUJFUbpBMA1OLyNiilOpfEWmmrKIIQ9HQvZ+z7P6S9D6pkQUUOpjKR83h+NMvB0QxJx7+ACCGKKYdsNotyTAxToDzwYg6xfWNMfGeMzFAayzvIj97yBLY9s5f8VJSEXC6HKdJ0hbNYljGv84fKRxSE4RCIpAmHswSDXt4tsXWazXVcXjx/Ja5sVdvqModjSbTh4shDcW814vZeKXq7LhC03fqvuwYyORtHzhF6V4qJiQ7GxpfRzIvcRKKDM8NrqnJOVEBOWcS97raIHAkcAkFv0XgbTGc41sNLJ6+p2iWxVtolilDwPtj77B8xMDDQ9O0vRBasOCjgKcVIxmM47TKU9ki5ElcpHt//KIlnVmAMCrInMmRPZ2BKWjSeiLP90n1s2TBaVYjN8zycXI6OQIpwUCLM+Z9EpgqFUDRNMJwlGKiPULC7VmL3rq5wPYp4KsT5+GqmXlSk5zFx7jzZRGvn+/tMS1lcJBjqLB6Uois6RiRU/0KuWpgztaAU4+OdxCbmG/2pBcXJc5eQynVUtOV2SyegIGClMawFFVCtivFklGePbMeymhteb7UvQsH7YPO7H+Ov/+7/Nm27C5k2+EXOD1MIVoYtVoYtrpzy/Pfuf4RX/uJKBpatKvu+zmgHB166njUr99HZUflBapomRjBM0jHJuBk6Qxks25jXTY/Ipx4gSCYZJB2XCDNHKJImGMkRtCXCEFUJBbu7n3Xv+d9EL7m69oFNQUnJ6Wee5ZE//wvcTKYu66wNcfE/C9Vjqvifyb8FyKJgkJPvKezKongQM5yrRMstlKdimB64kx4eJShFLNbFeLyX6R/GMA1Wbr6EQDg4r+3n0lmGjr46QzW6YGDZIMfPhCtzTpSKpOpoD2EAoBTCWND3SnMSsHItmX3Tal8E3/tgFU9/eTl779DeB5XQJr/K+tPf348j0zMvIATByCoOvLCF113/MpZduZIWBgSDATzPYixlEw2kiAS9/AV+fkwKhRCZZIh0XGKYOULRDKFQBjug5hYKQrDpA58j0Lt63uMprtIwWHPtNbz+Ix/m23/4x3Vbb/2pUDx4TBMPvi31ZHUkxciDJ00/vNMOYW8hsA33YkMkpRgb62Yi0cN0YXDNm2/hdT/7FoKR+jgOZlNpvvt3D3LwPx696LVgwKG3K8ZofNmsu6t9zI4mMU2nbYuE64Vtuy2bQGAIgWHbJOVaXsn0svL8cVb1mYTDYZpxEITDIZanbuA3P/oX3PzUzUSj0YZvcyGzaH8JAwMDZL3krIVswUCQV4evYHAkUlOPetM0CIbCZGQXY4kwTk7WtW5OiIJnQ4h0oofRoZUMD/YwHguSzXhIz6PcwCOXXENw+TqEWV/tZ5gma6+7lmBnZ13X21ymFUsWpmkqA+SUaZrupMeD5xgoT6E8iZISpfxOm6pYLNncT2AbbulxrRSjMwiDDdu3ceuH99RNGAAEI2Fu/fAeNmzfVvb1Fb2zFycW0gntYHZURCnMRehtMB3T8DCMxhclzj6Gqb4InU30RRD09PRq74MKWbTioL+/H8dI4c0xE6Cru5fHDl5PLldb5zshwLZthB1lLN1FImXObZ5U43YM0wAZJpPoZXSwnwvne4jFAmSzMr9N/7OGVm6q78anjsMw6F5VPlWzOLhYPHiuCRQERGHGhcg/yAuH5omHklkLSjE62ku8jDAAuOJHbsTz5udBUA7P9dj2IzeWH5+hWDmbc2I7zU4oIpdIfzFB0G5dC/IC5Wc0pGi00va9Dzbw1f99jueee66h21roLNqfQ39/P65I4s1hzmIYJtJYzwvH1uHNQ72apkEoGCKnOhhLRMg5s1gwz5OCUFAqTCbRx8j5lVw438XEeIBc1kNhoGoJhVS6/TbwT28mataeBoXow/Tpmr5wKC8e1LzEQyG1oJRiZKSPeLKLme54l29Y3ZC53aZlsmLDzGmr7o444WDqoo/WXmZHk1iWU3HvloWMAAJ2K2uGSmlFFKEjGmW5+8P86j2/0xDhvFhYtGf5/v5+XHOioi8/Eony3LHrGZ+Yp49+PopgBqKMpzuJJxsTRSjZpPCFiZIRUhO9XDjfTzI+v6IzTSmyZpfEKVGIEvEgykce5MXiYSaFaQqXkQt9JFIzCwOgoQVfs69bMLDsPEyJ3LVlOgF8bwNDsthTCgWCgVxDXBJrpelRBO19UBGLVhz09vbi2RN+Xr4Col3L+P5zV+K48w+5+RbMIRw6527kVC+Eb9rkCwUtDupJY2crTBEPcrp48LtrKrdUPHie5MLICpLpDtq5oUUo6NDbOTp57LdlOgGE8BZ9IeJUAna2Le3MmxlFCNgB+gLb+KPf2Mv58+cbso2FzqL9RRiGQccyp+JUgW3ZjKYu5+SZZcg6yWrbtrCraeTUaA4dgs9+Fh58EL7whRYOZIEhBLIlLonTIg/SQLmCwfOriCe6MPEQSL8NNx4gpzxKu5K2ihW9I1hGDqXaM52AyqcUWj2OptEcl8RaaWYUoau7i77xN/Ob9/23uq97MdBeEr7O9K0Db7DynFJXRydPvLidVSseIhqtT55W5Bs5uY7FyIRFZyRF0KYqF7m6MDEBv/Zr8M1vwsmT8I1v+M8/+KD//2eegU98YubnZqBrYIDll27CtOfhqKgUmYkJzj3/PG62PU9cnjQxjNa6JEoJ54dWk8x0AH7h39TSEjHlBDrrXPZDh2D/fli3DmIxuOOOBo0YTFOxoneYMxdWk/A6oNnH/VwohR80aLNxNZCgXfA6aN/PXOqLcJ41oaG6+yIYwqCnY0B7H8zAohYHqzdHOP/9KgpOhMAOreGply7j5muPYNbRRcyyTUwzQjxjk86l6aq1kVOtPPIIrF8/eVG45x5fBHR3w86dcOqUH03o6bn4uTIXD9O2eePHfpG1111btyF6jsOj9/8lxx//Xt3WWS88z8Bu4a/FFwarisIASsXAdGY8rGYTiZ/5jP98gS98wT9mTp6cl4Do7pzg1PgalGy/041pukuiEHEqtu36PWLaPG486YuwhlcyPQ3xRQiHQ6xI3cDHP/JZbn5aex9Mpc0Pj/nR39+PS3V3osFgkGPnr2J4NFyT98Fs+FGEAMynkVOtdHfDddf5F/3CCf8tb/H/BjhxAq69tvxzZdj+rney+pr6uC8WMCyLnfd8iK429D6Xs85YaPC2PTg7uKZEGBQwqPIgnSoSwReJ4H/vPT2TyxVe37nTf74QTbqIuY9fR9r09Yw3dAZNTSiFabm08x10Iwi2yCWxVkprEbrqXIsg6O7pJXDiNv7gD/6gTutcHCxqcTAwMEDOq37aTk9XL48dvI6c05gwsmmZBIJhErluxuJBXKcJtQg7d8LoqH+Sf/BBPypQYP9+uOYauPrq2Z+bwqZbbsKocxGXEAKlFOtec0Nd1zt/BF6LLJSlB2eH1pDORsq+XrXdbzmRWI5Dh/zXC+955pny2y/WPEytd5iseZBA3OsgFMzS2zHWDmUQU5CL/AxYHsty2ux7mJvJWoQ1da9FKHgf/NMfDGnvgyks6p9Gf38/GZmoujLXME1yaiMvHls9L++D2ShYMAs7ymiyk2RGoLwG/2I/8Qn/DnFqdODQIRgf98PGhw7N/NwUDNMg1NXVmDEqRefKlY1Z9zzwvOZHDqQHZwZnFgYwe2qhLLOJxOmMj8+5usmSSYUx5eGLBknaDfuu1ErS3z2ISc7Pkcj8NM0WOEwWsEwXY4lFDQAs00OI9ugyWi2NiiJ0RKMsd97Ir3z4t7X3QZ5FLQ4GBgZwjRTuHEZI5YhGozx3/Dom4vP0PpgD0zQJhsKknE7GEiFcp14WzBWc9E6ehLvugs9/Hm67zS9OK/fcNGKxnnoMsDyiugZTzaLZkQPPE5w+fwmZ3MzCoEDVqYVyInE6V189+d2Pj/vRhioQ+OmEnAwg8E80lumxqucsNi4WDqZyMZWHoVyEdBHSmxQOjRYPSvlOk0tQHIAgFGiPLqO10JAoghD09Cwj9oOb+bu/+7u6jXUh034VQnWkv78fT/gWyrXUFkai/Tzx/DZ++DXPYtt2/QeYR4jJRk6jSZtoIDmvRk65+HhlRVbr18Pjj1/8fLnnpjB6dumdUKutOTCDYazg3Bf2Am42hZf1G4V5ruDM+UvIupX5VQhDMaM+qFRp7t/vRxEefHBSNBRmNZw6NVmbUOG6JYKkG6X04ivo7kgQS6TJOpH8K4V1lK5LAUoZk68q//2qaG09demZOmrOjO9tsPSOY/B3lW1ncReuPgDqP6PB9z64nD/++D/y5je/mVWL2iZ+bha1OBgYGMA1x5GuCzVMtbNtm+HxbZw+f4oNa+INP5mYpoEZCpFxTdKJDN3hdE3toEeffwrpugjTrGsltvQk8QtxRo5fqNs6FwqqQpfE3kuvZctP3En3+sur3kbsxIu89C9/xcHvxnDcyo/X2VILydgEPatXzG3ys3PnxaKwIAjKRBeUlCTHJmZcXcqNIMu1lRbQ3zvIqaENTBcO0xab9rmmiQdFPoEx+XfF4kGBZbmIJRk18AnaWZKZ9ptZWi31ntHQ1d1F+oLvffA3f39//Qe8gGi/+G0d6erqwguMz9l8aTY6u7r43vPbSWWaVGmdt2C27ChjqdoaObnpFC/93WcQQiA9v3ujkqUP/3lZ0cNzJ5f919/915k3vIhNljxv7p9K55rN7PjQ79N1yZaattG9bis3fuT36Vyzoer3zpRaOPb9Q42JyufXXY6ctMnO4tIZCmXpjsaq3KIoeQgEBgoz/7CQWHjYuNg4WMrJpyw8xLS0hVIKYRT2V3uYRTWbYKA9XRJrpV61CAXvg2e+soJvfetbDRjpwmFRRw6EEHSs8JDnay8wEUJgBtZy8OWNvObq43X1PpgNwzQIhULkXJNsPEtXJIVdRRThzMP/yfixw/S/Zifh5f0ld45KQSzZjSsrS5VITzJ8bJjn9z7P2Jkx7FCZ91VjsrR/v5/HPnXKL3psVHFjPREGSs3eEmD1a3/Ur5mocRaHMAyEVGy79WYe/euvVvne8qmFQ//5KJteezVrr7oMz83fLdd6t6h8cyXTsjj7wlEOffPRixYpn064aLQs77nARKoDpeqVrqs88mAIF0MqkB6q8DZRWFrkb5mmxxUW+C12CYKA1frOjPWmXlGEgvfBb370L7jl6VuWrPfBohYHAMsvkXhn53fXHw6FeOXcNWxae46Vy53m9YzJRxGkaTGetghmM3REcv4UwgrGkHj1GIlXj138fMri6eM3YNTzg1RqsrRzJzz8sC8UJiYWhjDI43kmljWz0OxZvw3DnN9PyrBMBrZurPp9M6UW3GyOf/ntz7J+xzYuuXYrgcj87ItzqQyvPvsyJw+8iOdeXPGenCmdMA3TlKzsHmYwtormXHgL2/ALEUU+aCpK8xKAL7KKf00XD6IgrqaKh4UnHIKB9ndJrJXytQjdGBV3J/W9DxJ574Pf+Z3faeh425VFLw7WXNrNmcfnPzWls3MZjx+6lh+/5XHsYOOKE8tRaOTkOhaj8SwdoRTBoKhJpCgFw+Mr659vnTp/HiZNlgqcOAHve58vHiYmfOFQgT1zO+FJE4uZjyXDqs9xYdZY/GogkWUyhZ7rcuz7h2ZMA9SLnLTJVdH0q7szTizRS9YNN3BU01EVHftFTVBOPDAlGVEiHsRk5qPNxYNtOgvCJbFW5htFmPQ+OMQ73vEcV111VeMH3WYsenHQ39/PCTX/slzTNElkNvHSyZNcuXmwoa1wZ8KyLZRpEs9aZJ00HZEcZoVRhAJKSkbiK+of/ShEBApphO7uSROdqYZKzz4LGzb4wiEWm9GeuR1pbHfG+TPrrIUGU1k6AaI9US674VIiXf5Mjhsdi7FEb9XbczIeLz01zKtH5vZimIppunVpF13UACXiYVI4wNSog/+fdhIPAdtZUC6JtTKfKEJHNMryC773wX985wHf7j6PpxQjGY+htMtw2iPpSjylMIUgahmsCJusDFssC5mYC9See9GLg4GBAXIyVZd1dUSjHHzlOtYPfLNl0fCpjZxGJzJ0htMEA6qymRQKJlIRMk64MamRclGA6YZK1147ac3b03ORj4JSkM3a5ByDgN1e89BbYYRUDVUbItWRStIJt7zjZnZ/YBeGYZQUi9UyasMQCCF4+uEz/NEvfRcnV4kqUvl91Nhj6uKoQ+E/7SMeAnZuydRh1hxFyHsfnP7Bzfzt3/4tH/jAB5jIeTw/muXgaIako5BKYQiBnFLcWfjbEIKoLbimL8SVfUG6Au19/phOe98K1YH+/n6yKomqS2WuIBzt54kXtuE2yFq5UizbJBDy20HHkgE815vzx66UYnh85bzvnCrel+UMlQp2zIW0wvSogYJsOsirR9dz+uQaxkY7cRyT1p/JarRQbvIMjqoNkepAJemEdVdcwm13vqlouW2YRvFh1vAoTNG99nWrefuHrqxonEKotpi7V7j+Gyr/kGBIhSklpicxXInheuDlH9L1iyelRFF4FMRGbb8Ly/RALC0nwPIzGmbfB773wTb+/L8/xtdfHuSvX4rx2GCKRE5iCggagoAhCJlG8REwBEFDYApI5CSPDab465difPt0gmyDHHcbwaKPHPT39+OKF/Cki2XOPyds2wHOjV3JmaFXWbcq2VIjlUIjJ881GYkH6AglCQdnjiJ4nmQ0sXze9yFu1iWTyBDqmKO4bSaTpanNfqYjID40gSEETibEWDrE6JAiFMkQ7YwT7UxhW62JKFQtDmaawVHodlgozKwjzU4tVJpOuOJ1V+C5Xt1n+xim4OYfW89X/mzuegrTcNsoDjUzs0YeZiuWLM608P89e+RBEApk8KqoEVkM1BJFWH1LPzs++Amei7mEQxYBIeY87wshMAHT9PvFuAqeHslwPO6we20H6zqbW7dWC4s+cjAwMIBjpOraI6Gzq5PvPX89mWx7KG/T8i2Yk04XY4kZGjkpGEv04njVm0GV44WHXkC69b8KmZbJi//1YvFvIfwfdC4dZnRwBadeWceZU6uIxTpwXYNmRhSq7sxYrgPiRN44qDCDY6bGRzXS7NRCpbMTuld2171RV4FlA5U4USqEWDh3bbNxceRBYRYiD265yEPB36Q06mCbWaRUyGZ1hm0jKo0i9N3azabfuoTI6gjZuIvnZKs2lhNCYBsCWwhiOY9/Oj7BwZHqGwI2m6UROTBic4aPqsEQJsK8hENHNrLjyhMlhSqtotDIqWjBHEwRCUiE6R/ISimGJ5bXpRgLYO+f7mXV5atYtXUV0pXzTtsYpoEwBP/5R//J4JHBsssI4ZvfZNMRsqkwI+QjCl1xOjpTWKakkRGFqsVBuRkc69f7qZQvfMGf8lko2qwjM81aqDfVzE4QxSmA9aeSk7UhPP9HsgSYdabFlPuGqJ0mkcwAIj8Hx2+ZJQz/d1b4P3mBvtiYK4rQd2s3az64EgTIlMRQFvHxFIEVAYwajiVDCAJATioeOp0E4Jpl85ta3EgWvTjo6OhAhBN1764YDkd46dQ1bFxzhuV9snneB3NgmgZGKEwmZ5FxfAtm0zJwHIgll9Xt/JyeSPO5932O9devZ+3Va7EC8zuUEiMJDn/3MBODM1vyFvDrtaYJhfOKcDRNtDNOR0ca06q/UJCyyvXNNoPjjjvg3nsnBUMdaUZqodJ0QnugMEyXJRAorYjCNxa2MgTzUy58ce9LBCX977fw/4J4UBj+705MFw+iHUo5aqbcjIZ1O1ex+gN5YZD2f0xCGAgvSDKZpLOjs6ZtCSEIGHmBcCZJT8Bs2xTDohcHvkuigzxT/xRAZ7fvffDmW37Q0MZM1SIE2EEbzzMZTdpE7BQTqR6kMusqYpRUnDhwghMHTtRvpVUyVShkUlEyyYgfUehI09EVJ9qRwjTqU6GuVL5DZzWrml5TMNUYasMGvw6hXFOjedCM1EKl6YS2QTUucrFQCdi+S6IhyEcUL95BKu+KWRQP+UaZElDSb8ytpogHP0K08MTD1CjCSbOXG+8MI0w/YlDA300m6YRDKORg1+hrUhQISrH3dII7tnQTbMHU+LlY9OIAoO8ScF+t/62UZVok0pfyyskTbN00itFmv4BCI6d01mAs3Vt0RGuvUdaPglAAQSYZJZOIcAFFuDNFtDNBR0cKYz5CQfhFiaY5j2Pp9a/3axEefNA3hvr0p8ssNP+LeyNTC9WaHc1IoevjunX+TJYG+V2YhrtkOzDOhm3nmEvtThpCXiweCnWSikKbeV88SJUvn5wmHsDwUzuCvHgwiutul6/HNAx23N1NeLVJLuVhSJUXOT6GECgZZGI8Tt+y3prPpkIIbCCW83j0XIofWdtRt89QL5aEOLhkcy+nvtuYqYcd0Q6eOrKdtQN76exokyN8KgI8JcAy6e4aJ5WM4HqBunZrbEemntDSiQ7S8SgXDEmkI0W0M0k0msQwiktWjCfNGcWBk4r7TX1m27ddXZOzNMrM1lBSkU3M35ejUamFuqUTqunFcdttvifG1VfXMLtDYRgeOqVwMUHL8S/qtWvl4oW++AcU40lKFWTuxeJBIqCQvigrHozJm60miofoSrj8J0yU59cYSQSG9DDFZG2LYRh4uQDpVJpIpPK27NMxhMBQcHA0yw0rw23ng7AkfjEDAwO4dXBJLIsQBMMDHHhhK67THrMXpiKlIuOEEEJgWdDVlSAcTqDwFlNTtlnxw4ECoUxS8U6Gz/Rz8sgGzp9dSSIRzldrV7YzZuvOeOGlJ/2E7TxQKE4eeH5e64DGpRbqlk4oN5OjkHJ5y1ugr2/SF+IXfgG+/OWapn02w/RooWJZjfVq8Wca+RdB0xCYhoFpGNiG4fsDCEFQQEhIgkiCOARUFltmMWQa3DSem8FzMji5LE4uh+O4uK6L68niTIt6nscu+1ET0wa3OJnAQGLhKsPfFvmZIsIiEc/iyfmd8y3huy0+P9qg69M8WBLioL+/n6xMN2z9wUCQVy9cxbnhjvleG+qO57l573qRv0gahMMO3V3jWHYWpZaCieokBaEAvlAYOj3AyVfWM3RuBclEaE6hMNuMhTPf+3fig+eRsvrZG0oqpJTEzgzy4rfLeEPUQL0NkeqWToDSmRzr10/24ijM7DhxwnfTBH/K5/798MlPVr0Z03DqNkNnsTGZVmgN5cSDVRQPBgEhCAkICkkQrygeLJnF8NIoN4N0M7hziYcKx2OYsPUtRhmxIVCYuJh4UhWjg4YMMjERn+c+EKDg4GgGr83u1pZEWmFgYICcOopUsqYpKJXQ1d3F956/jrf2PkIw3D7FidkcuCpQEpYTCEwTujoSZLM2qVQEhbXkzqHF1IOySEx0kRjvRBge0a4k0c4kkXA6P/utODkMbxZxMHxG8MC9f8y2XTez7vorCXZWHnLMxlOcevp5Xtj3GNl4ch6fapJ6phbqPjuh0l4cMFmwefKkv3w586yyKISpIwczYZte3vuhPe8RJ2e/lqYtChTSFqo4P9OPIhQLJjHyr/vpxULB5NQHUExf9GwURPoEXm6mERlIBCcPPkYuOU42OcFVt/4EmXCGf/79j3Ppjpu48S3vrPpzWoYg6fi9GlaG2+eS3D4jaSC+S+IhpOdhWI35IRjCRIr1HDq6nuu3ncZsg+pTz5NknUjZHLj/WzMIhlxse5xkKkIun35YiqfSEqEw3k0i1oVhuX59QmeScCiDMGZ2SRyL9XAhtgJI8vQ/7+Xpf97bzOGXpZ6phYbMTqikF0eh98bOnX6dQk9Pxav3M9mt/x22MwEri+stzMtAxeKhGM51S8SDX7A7We/QvcH2ZyikZxaUscHTBDt66Vy5ln/+vbu5+tafIj6eYvXWKxk5e6qmz2EArlIMp10tDprNwMAArpHAk7KhHzgSifDiievYuPo8y3ply29YpOuR9cKzhlUFAsMUdHakyeYcP4qgzEVfsDgbBaGgPJt4rIf4WDdmXij0LlP0do2XLD861svI+PKWjHUu6jFrIVuHdIIqnKlnO6wKvTjWrYPPfMYXDzt3+tGCQm1CuSLOsuFYhWm2V+Ou6US7AvSujMxrlpPrSi6cTZDL1Jb7Dtg5XC9a8/bbmdKZFlBePBSmaUr6L7X8Ntb+qxetTwETQ6dZd/UP8eS//Q3rrroJiYnwgqzffjPDh5+rcZwCIWAo7VFZl5DmsCTEwcqVK8kZMb85UX3cg2eko3sZ33/uKnbfdKC13gcK0o6JhzXnpaHwAwoGXQL2OIlkGCcXBmNpRhGmUtg30rOZiPWQToawlUc4kiUYThFPdjE2sazVw5yR+aYWJIJUHdIJ40PjSCkxjVmiDzP14igIgkI9wjRGB8vXE7Wrvu1eHuZD//N1XPGaVXWZ/uzkPB7792P83f/83ozdKTt7g6y/fBl2oPRssHJbB4n0xekvpWDwjMuLz8wYY1/wTBcPkWVmftpiaffM4vLAuqt/CIDDj/8nr/vpX86nLgJkU7Dp+tcCkE5M8MSDDwDw+nd/oKKxSKVINcCOfj4sCXEQjUYxOlLIitq6zg/LtBmLb+HY6ZNctj7WMu8DT3pk3fIphZkQvk8qnR0ZHMchkYqi5NKOIkxFANK1UK5FasJicKiflBPBtFxs28Uw2uvHDX5qQRkGasVyZH8/qr8fFY2iTBPheYhkEjE4iDE4iBi+gJCln6Fe6YQXvvsCN//UTfNez3Skp3js309e9LxpuG2pDoSA3/yr2+i/pLNu5wY7YLLzJy7FtAzu/63vlrxmWgZ3/u7N3PTmTRhm9ds796rDR95xnucOtF81fbUUAkyTsQE1RQEohD2tpXbxnaLk72wywdDxF1l79c3IfEXD0PGXuPSanwTg6IHHSU2MEenqrWp8ri5IbA09K128k82ZatjV0cmTL25n7cp9RKOtmbvqOB45L1x9kxAAIbADkh5rnFQ6TDajowgFXOkXOcXTHSRz/h21zAVwcjaGoTAtB9v22kIoyM4unGuvw7n2elRHBxiGf4acekwU/pYSkUhiPvMM1rPPIibidUknFDj1wqt886++xZs+sNvfbJXNfoqNCfMYhu/Ad/Cxc3ztL6aHc5XfS6EN6w0uvXYFqzd21329hin4ods28nf/6/tkkk7x+Xf+4nZu+rFNNQuRlass/n7fGnZecpxkon0uXqUX+qnTGQvOCuBhohC4GCgMZL6gUGKgMPGTCWbea8EgkfMbU8k5znTjQ6fo7l+bjzAoDDxMezIqdtUbbiMdHyedqG4mg9VmYnbJiIMVm8E53iQfAiEIhldz4MUt3HLtYUy7uQJBScjkAn51bo3rEIAwDKLRDAE7RzIVRUpLRxGAsXgvWRmgNNQukFIgc0GcnMIwZD6i0HyhoAJBsm94I85128HKWz47Lkhn5jcZBqqzA3fnTtybb8J4+hlS33qGejopPfrVx3j2oYNcumMzka7qzWNSmTDJTAcgyGVcXn7qAqcOx8osqdoyagCw7rK+uY2yasSyDVZt6OL48yOAvwt2vnXzvCIUpiXo6BK88cejfOPLiXoNtchcd/Pgd3zwL/QmHgIPgcxf+P16GgMv3zSqIAIKtzL5CdwXZ8XExX+mxpxZpqKr4ltCkc7icwYeh7/3n+x4849X+9FLMIQg0qBi+VpZMuJg1dplHJeNNf2YSjAY5PjglVw6+iqrVuSa2hDO8zyyXkddTpACgR1QdNsTpFIhstkwiNpFx0LG8xTD8ZUYIQiHZvPNEL67Ws7AyYFpSEzbxbIaLxTc9RvIvvktyN5ekB5kswhAqTm+MSn9ea8Ato13ww0ENm0h92+PII+frdv4EmMJntn3bG1vlnDs7AbcOaIZptm+3gamLVBSFbul1htrygUm3GHT2Tv/rn9OTrFxy9z1U5XfzYOLWdHd/OQNzuTlfq4Lfa2n2qFXDIQx9QZSTZP/Pt39l3Dpa3bx3ENfIdLRzcrNmwkFa4+wKeUXRa4Mt5dD4pIRBwMDAxxulEviDPR09/L4oet5y87vEgw2rzjRcSWODNXt7qRgnhSNZgkGciRSUaRnL6kogucphsf7mch2sdwdrfBd/v7xpImXNchlpwgF28UQ9Q3TOtddT+ZNbwbTgFwWoaZmTdW0U91sK3JQwkD0dRG848fI/fujeAderOtYa8KA/r4hzlxYy8wFkqptfPpbjWHU747EMMGbYhA2/W5e5u/mCxf6et3NN+WrzH+swcMK5SlMCwr3kdO3XxA+b3jPL2EYBlJ6BKJZxDzu/iT+jIUVbTSNEZaQOPBdEufvWV8NhmHisIEXj53g6i3nmuJ9oKQi7QRpRL5VILBs6O6Kk8kESafDIMxFH0XwPMXQeD+JbBcCcGqaFz5dKAQwTYlluZh1EArOddeTue3H/DvmfLTgos1XuAmF79qmsg4iaBP48deRg7YQCNFIkmhwgmS2fN5eCNm2UYOFigJShBlkWdPv5htGXhAoPExymLhkjnukRoNEl/lZuHJvEUgM4Zvp+atwCIfD8xqKKxUdAYNlofaKHLTdd9Yo+vv7cVQaqZrb/yAaiXLw2PVMxM2mOJW6nkvOnd3bYD4IwBAG4XCOrq4JLCNbtVXwQsLzYDC2ikS2q/ic48w3CuTfE3meSTYbIJWIkE6FyeXsmnzi3fUb/IiBEH7EYB4j8+/0Jtegsg4YgsCP3YKxcfU81lwvBCv7LqAo9ztWmGbzUod15dAh+OxnfU+HQk+JGshKi6QTYtzpIJbrnPsNFaKEBUYAYVgYhuF3VPS9j8l7CZU+2hE/Z4GSHoZKYxOngzgdpkvUFpiGxUsPlvenmRQGquiyq5RCWM5FU9ZfOfB4/vEYzz38zdmHpBQIuKYvhNlmonbJRA4GBgZwxDN4nsSwmqvQOjpW8P3nruDW1z7TcO+DXA4cFWx4aFUw2cgpnQmQyYRRanFZMHue4nxsNalcqUmMHzmoly1vPqLgmXhePqJgSSzLwbLcOfenCgTJvvkt/kyEOYRBJamFsnZChQjCT7yezP/9J8jNUtjYBGzbYXnnKCPx5Uz/DhZko6XZOlR+5jP+8wX27/cdJE+d8l0ku7pKVnUutZZTyR4Auu0ZTu9NapXdFkyJEBg4WDgE8DBN0y/UFKX76KX/UFz/XrBCk82XSoXB1Jk+HuFIgOnzuC7dcROX7qhs2q6rwBSCK/vq1LOkjiypyIFnxpFe86eY2bbNSHwbJ88uq3oKVzVIT5Fxq5++WCuFWoRw2PGjCHYWuQgaOSnA9RTnyggDAM9tlMDLRxRck2wmSDIRJZ0O4zjWjBGF7BveiOztASc39yVxLqExy22fyrmIvi7sW2+caytNQNDbPeo3VZqC723QXqc0VxpkpF28m0+54YsFWrkOleCbP021iz550u9H8Za3lBUGFVEQIvfc4/eumJjwH/fe6/9/MTAlQiBUBpsJOojTaTpEbYEdsHzPhzKHenIYXnhQYZj+oVQQBuY0YaCUQokc4VDtBZ9SKSSKa/qCbdeuGZZQ5KC/v5+cMY7ntaatcmdXJ0+8sJ1VKx4iGmnMgeB3YOxues51MTVyUviphHOja8i45afb5eadVqiEfETBNfFcgyxBTMvDsl0s048oyK4uf7qilCXFh7UwPZ1w8QIKJRXWjm24jz6LmqhPc6haMQwY6BucUpyoEIakUVEDKcFVFp4ycJWFVCauMpHKwlUmnjTwpvwtlYFU/nS7qSOayJWplZjaoRJ8EVBoQjWV/fv9C/iDD8Izz9TUwrpEiKxb54uEQ4fg2Wdhzx5/mZ07a1t3KylGCCQGOSxyBJCYpuEXZlYhGp/4f5J1rzXpWg1O0hcG02+4FAorIDHN2i6hSikcpegJmNyyqvppvc1gyYiDUCiE1ZnEq9GDfL4IIbCCq3n25U289upjmPVObSjI5oyK7JIbgW+etLAbOZUKg5mLjDyv2Sq/IBQsP6qQFwrcnPcxyFY+C2em1EJF0sJxIWhjXr8V9+GnKt5mo4hGkkQCCVK5TqZPO5sNVxp++13Ptxf3pImHiSctZP7iX7zYY+Yv+rVN363oPbN1qJzOhg1+5CAW82sTqk0JlBMiXV2TqYuqul62mIsEQSFlUL0gmIqTgv/6VI63/qFFMCrwysxaVsolHKktaqCUIicVhiHYvbaDYBs06SvHkhEHAF39EnmsNeIAfIFy5Oy1bFpzjv7l9fU+8KQk3cSUwkxc1MgpHVkQFsx+KgH6rnwtt7//Gi67YQVWYOYvyBBzp6dSsQSHv/scj/3DQ2Qm6jVTxt+PrgzAddfne9PmM+2VzHgoM2thtnRCOawbrsDd/4x/O90Uyn8upWB53wVePtObn2ERruluvhIafvRWcqd+7bWTqYeensmOldVQTogUhMIXvgBvfWv162wmcwqCeV7SFLiuS+zAWV66v4sr7unDDAu89OQxqJQCI0coWL3TZVEYCMGta6Ks62xh/505WFLioH+TQfaV1okDgO6uXh47dC0/8brHsOvofeA6Ls4cHRibhR9FmGzklExFyGVDbWvBrADXEazYcRO/+Je7Uai6TDvtHuhjx9tvYcOOy/j7j3wGN1vHQr7+ZdAZBdctXjuVmsyjFoTC8WefIJOMk0lMcP2b3gbA1/7gN9l4zWu4/k1vmzudMA3leIiOMGJFL2pwpIaBl7/QSyVQKm+KowRS+fPnwUAqf768zL9emDtfGHcuEGJwvL/iItxWH4MVb3//fr/wsHA3f/XV/nPzSSvAzO975JH2LE5stCCYsh3XdYmqM6xZbjGyX/JKIMGlH+jAjAi8jN/ETClJMGJU7W0g86kEw/CFwTXL5m9Q1UiWlDhYs24FR5o8lXE6pmmSkRt58fhJrrzsfF0uQkpBxrH99qF1GGO9KDRy6oimcQIFC+b2iiIowHEEZ8fW8v6PbgcBZl3NY0xWbFzF5tdu4+VHDtZtvaxa4U8jm15gO0UojA2eIdTRRU//ar74u79UFAerL93G2PnTUxevHCnBsDBW9eENXrjoZb8NroGnDJTKG+Oogt0t/oW+eOEXxQv/fETt2mWvEkv14LjtV/E9nYlxt/IGSDt3XtylcmqxYhnGY5NTOauaYjwxUVr8OI2WzFaWIJGYeUFg42HVWxAUyAuDTnWa1cuDBEP+sXTuoQzp8x5b7u4g1G+iPPDS1XkbKKVwFUj8GoPdazvaOmJQoD2THQ1i5cqV5GSm1cMgGo3y7NFrSSRFXbwPpOeRbZOowXT8GQ1+I6furnGCoTRK/f/s/XecJVd9542/z6lw8+00HaYnK6ORBmWQ0EggWRIggXFAYCO8/hmb3/PIXq+9BnbXae013nVaB1izu9jGu2s5scbGeABjEBgJlEaywiiHyd0TO99YVeec54/q7unu6XBv39jd9X69Wpq+oer0DVWf+obPV7dFR0MoDCTDY9vQIs5F12xqyBRN5Su27dlV341u7oUVOl/GTw0xsOsyXnrkW+zcc/2shfJlN76DroGtcyIGZomfBZjpk782+H2DTPgdjHldjHg9nPU2ccbr44zfz1m/l7Ggh3HVzaTqIKezFHSKok5RNgk8XFR4qMcIWfPn1pGKHZuO1LSNZvHYQxPoBnQsaW04OVzmyBvnjm/5vMardBJtNgu/9VuL3mXbcOpkk1JIGrTWCF2a9iGYJGN5pByB69pIS9Y/9GMg8D06OMrWvvisMJhh/AWfp/7dOEP/WEQrg5uxMNJGTdseL7pJY1DGUFYazxiEgKt74tx3SceaEAawwcTBwMAAJdVcl8TFEaTSAzzx/G78oHbTFj9QeCq+ikxq8xCEdq6pZIlMehIp/JaaJxnA8yVDo1vxlYvdyFYiAU7cre8206mwZH8Zdu25AYCXvvsNLrvxtvDkrgXGCLbvuWH6Kj78eemRb3Ho2SfD0L6xpn/k/J9pdzykxKTSlE18OsBrzw7CaQVCGHoyo2QT4y3ZfzWMjQT84W+GUZvA1zV/B4wxBIFBKcN/+fnD8+5TgeG73xonCGrbh5SCr+xrYMTVtEAQzKAh8Mt0ymMM9qVw3MW/p6poeP1zU/zjfY/gDr1A2pUoA54OawhKSs/+zNymDKRdyU39SX7ssk5ua+Piw8XYUGmF/v5+Al5Ea4WUre0rdRyHUxOXcfzkUXZumQrdxlbBzARGaL8+2cVoh0FOoTCwGB7dSqDXhoo/D9uikrBTKT/FyUOvzAoFg2D44GtcdtPts5GEUn6Kx/72f/HW7//Rik/wok0myAnMTJELO3qP8NzRjrYWyQD/+3+c4Plnctx+dzebt8Swavjq+p7hjVeL/OMXRzj42vll9b/7n45y+ZUp+gdj+P7SV/+LDeaSEmxb8PF/U2boeJ2FvAFtNBY+Nl4YR5JyWgg06bSkQQUluuUQA31pbHv5Y0GpWGai9DAfuP7fsHV7FyMlxZliwOmiohBoAmOwp6cr9iUsehM2PXGr7ZwPK2VDiYOBgQEC8WTokthicQCQyXbwxAtXM7DpWyRWOXRDqYBSkG3LlMJSzJgnpVJl4rFwkJMKmjPIyQBlz2J4dBvKrOGPf6Co5HJq/NQQnf1bwkSBkPNO/jNtjS8/8nUue9udVe3eBM03E1sMIc69DslYkc2dJzg53g42z8vz1GNTPPXYVMP3c+K4x713HGDv93Sx+80p3EU6cAwwkc8y9wJDaxge0uz7e8VLL9bpvTZhMZ9spSCYWYoGHRTpso6zua+jIr+CYnGKC24eZsd0m2lfwqYvYbO70YttEWv46Fg9/f39+NZk6JLYBheMUgiEu5XnXr2A63YfWpX3gRcYAhNfS9pgFoHAsiGbmaJUjFEsNXaQkwG8ss3w2NbKhUG7Ws3m8hW1EsamZ8/r6QP/y488yGU33R7eKeDUGy+x88obeOWxb1a+b23QueZOOF0UYxa0Awu29gwxkutZE8WJzSKf0/zjF0f4xy8u3V1y6OR2ykG6/jufFyHwcQhCQSAlyNacfkJhUKDbHmJzb1coTlZAKYUXvMSHP/J9TVhhe9AescEm0dfXhy/HUbp9hrMk4gleOX4lI2Nu1RXBWhtKfnxNRQ0WMjvIKemRzU5gW+Egp3pXI4QRA4fj1QiDxaxmIWwlu+uu+Y/dty/8+eQn67ruJTlxhpV69wyCjoFtXPLW23jm63/Ly488SP8Fl857zPipIboGtlS3bynwToxXueD6s5ivgyU1OzYdbcFq1jaOXcc2WwNGa4Qu45hcWEMgy6RswhoCW7bszKM1mCBPrzPE5r7KhAFAsVhAZx/j7rvvbvAK24cNJQ5c18XtKKKaZt5SGdlsD48eeDOBX90XNLRLTtD6zu3aCQc5CbKZHIlkDkFQt/YpA5Q8h6HRrehqUgmVet7v2xeaydxzD3R31zRVr2JOnAm7FZY4uJlwVAxGCN7xIz/NVXd+P5fddDtdA1tnH/P4F/8PAC8/+iAnX3+Bw88+zsmDLy+/X0uAMnjDE3X7U1ZLaER1/me/JzNCOt769a0lHKtGcbBAEKTaSBDMoLWBYIped5i+vq4welERhlJphNs/1Ek63YDoSpuyodIKAB0DGvVaa70OFmJZNrniRbx29AiX7TpbcR902YPAuA2fwNgsZiyYE3Ef1/EpFFN4nluTBbMxUCy7DI9vwZgq0zaVet7P7Tk/fBg+/OFVrrYKTo3AVD40QlLe7M0GgRaVOR6+5X0/MvvvE6+/wOaLdjNwwWXLPkfaFmqqhH+6tUN6zhUiLn7vrr4jPHf0yrYvTmwXbCuoftDovBqC9kgZLIXWBhFM0hc7zaZNXVUZGPmej2+e5d57723gCtuPDRU5ABi4wEXr9hIHAOl0in955Wryxcoul5XSlP1kWxkK1YtwkJMgk8qRTk4BalVRhFAYxBge31q9MIBQFIyOnksZHF0hXP3ww7BnT5iCaDBCa9h/YF5KSRO2G1YbSTr83BMcObCflx/5OuMnj62wY8g9cWhFj4VGI1ZIPCVjBQY6TjRpNWsfx67wmLgGIgQL0doggwkG4qfp3dRdtbNhvlAgseNJbryxsjHM64X2kndNYHDbJl7WrZ1HvziCRHqA/c9fxi3XvoTtLH8y00H7Gh/Vg/mDnMbJF1J4fqziKIIxUCjHGR4bpKajVaUWtQcOwMREWLB44EBTBAJPvQC33oBxHHQN3QM799zAj/72n527wSw+nEk4FibQ5J5qA8OhFScwCrb2DDOS20Sg6uwxsQ6x5DLiYJEIgSVl6CTaZhGChWilkWqcgcQY3T3dVCucjdF43lHu+4kbq0hDrA821l9L2M7oGW/lB7YA13EZGr2C4TNpzHJXZgaKfjhRbn1Kg3OEg5wkmXSBTHoSIYIVjWOMgXypDsJgKeZ63kOYbvjoR+HP/iwsVFzNQJzVMDFF+clXMJZVX5EoFrkyFwJhCXJPHEJNLDKmrolUOg3CthQ7eqLixEqwrGC+R/IiEYL0nAiB1YYRgoWoQGOrUQbT43T3dLKa2qxSsYxnP8EP/uAP1n197U57y74G0NfXh6ca31+8WrIdGR57/mp6ux5a0vtAaUU5WJ8phcWYGeTkugrHnqBQSITmSYsMcjLGkCsmOTkxSDUHg8CrItW00PN+x47zPfDnLQr8Uj0FqaEk4ozRgfnGy2y6ZAdWdxpTz8FOAsScCIKMWQQjeca//mL99rFKBJV5PABs6jjLqck+cqVsYxe1xrGlQmMQ2qzJCMFCVKBx9Vk2ZwpkOzpYbdH2jLfBzp0767q+tcDaesfrwMDAAJ441RYuiYshhQXWdp5/fSfXXH500cFMvq/wVOvHMzcbgUBIQSpdwnU98oX0vEFOxhimiilOTWym2oOBCgyv/8tZLriqp+7zFSzH4thzh+qwJYMWFuMiS5EUAKIcMPn3++n6kVsRMafuAgFjkDEHowwjf/c0ply/NuDewSw33305l7x5C2688kPRwhZGA+TGixx47DCPfOUFysW5r4FgV+9hnjsWFScuR8Ip4FLAXcOCYIYgUMT1GQY7y6TTqxeFobfBKxvK22Aua/Pdr4H+/n6UKLSNS+JiJBJJXj7yZi7YMkxPl553npuxSzY013K4nZi1YLYnKBQTlMtxQDBZSHNqYmDVoumLnzrAv/2Tt6MCHYZN64BWipGjp3nj8Zdq3JKhIJKM03nee+8dPM3kvqfIvue6ugsEGXdAG8a+9Azlg2fqtt3Bnd187A++j1jCqctrrbXh4jdv4ZpbL+JTH/8i/hwRk4wX6M+e4vTkQM37WS8YIGaXidlF4nYZKQxpuwAy2eql1UQQKBL6FINdAalUpqZtFYsFVOZx7r77U3Va3dpiw4mDgYEBPDmFUgrHaQObxCVId/TwyHN7eOfb9s9bp1KKskqv20LEShGAkJJUqoTreJwa7a1JGAA8/fUhfuu+b3LXRy7jkut7sRexmp2/BrOoEc8MhfEcr37neR758wcJVn3CNihhMyY6KROf3u/5FJ88CED2nmtDgeAtyCFXixAI1walmfiHJ8nvP0Y9k8zv+tA1xJJOXUaWA9PRHsEFl2/mqrddwP5vvjrnXsG2TccZyfegVPt+5xvNeYJgzjwjg8B1y3jBGhUH0yOXk+YkW7ohkazVjyD0NnjHj2Y2lLfBXDacONi0aRO+NYZqw3bGudiWzVTxYt44doRLdo7Ohrr9QOPr+IZLKSyJAYUklSnRx2nOjm1aXdviNAceOsGBhyprgUunJrlg20EaaUKVF2kmyFYUKSo+eRA1miP7vddjdadBa4xf/edcOBZIiRrNMfn3+/EOncaxDL5y6zZ5cfcNO+omDOaiAs1l125fIA7C4sSdPUd54/SFdd9nO7OcIJiLAFzbx2sf89jKmRYGKTPMYI9FIpGoeZMz3gY/dN/G8jaYy4YTB47jcM2tW9mcz5BKppZ8nDEwccZj/GTrPOQzqTRPvXw1W/q+QSYtMNpQ9GO0fZlwkzBGU/JcikEKIaArO0EqkefUSB+FUrrhaRc/aNRVqMEXDmOiCx+XyiyNQryDpxn5zD+R/p4rSV53ISIWrtH4avlZDFKGogAg0BSeeI3cN54LIxCAEALH8vGVHY5trhF3lYPGVkJagkR68bkKm7JnOTnRR75cW7i53TFAzCoTc5YXBAtxHA+KrC3D1WlhkDHHGdzkEovH67LZc94G/64u21uLbDhxAPDAvl+r+LFHnp/ksz/zIkOv5Bu4oiUQglhyM0+9eAk3X/0KBo0XRCkFOF8YzOA6AVv7h5nIZTkz1ovRjasrUUFjtj0hsuREWEi1mnfalH2mvvwv5L/zMomrd5G8/kJkJh4WmGk9PZNBEE7FIfxda/RkkcKTb1B8+hB6onDedoUARwb4ysHU+BlsySdYwK6+wzx/rAkeFE1mtYJgLq7jYcwaOrwYCAKPLENs7osTc+szbCv0NjjGh378rRvO22AuG1IcVMPWy9L8h/97LR9/23cpTjU/FRFzYxw7czmnRo7Rmcnhm9i6sUteLcZoil6MUpBc9EAmBHRmJkkncpwe6WeqmGnIycgPHDCiTmc6Q1nEGKUTLZy6bFJPFMj/8wvkH3oRu68De3Mn9uZOrHQCYUtMoNG5Ev6JMYKT4wSnJ1Z0PhQSbHx85ayhs8g5UvE8vdlTnJnsb/VSasYArlUm7pSmBUFtSR/HVtNDvNfA+2og8Mt0yiE29yZxnPoZXYXeBo/z/vf/dN22uRaJxMEKWLYk3SW5+o5eHvnbky1ZQ7aji+8+dzXvuP7JDV1rYJiOGJRjlNXiwmAutq0Z7DvBVGGSUyN9aF3nNIAQBMrGtmtL1GoEk6KTvJhuT6zH2ubtwBCcHMc/OY54ploD/fOR0wIhqLdAaMp4bMG2nuOM5npQeu0d/uotCObi2P50EWubH2M0qKBElxxioDdd98LyYnGKXW8b2pDeBnPZuDGTKgg8zdbLWlexKqVFvtTLC4euaNkaWs2MMChOC4OKj18CMqk8u7YcIZOaqPso6NrqDgxFEeeU6CcvUlXVFqye+uzBkmBbPnV7QZcbj71wFPYDD4QiYpXTLx07YPsack40gGOVycQn6Eufpjs1TsotYdVRGADYdv0moTaMWWFwnM39mboLg43ubTCXSBxUiOW0UE0bQ9ETPPPG1eQL8bqf4Nqdc8IgjleNMJiDZWk2bzrF1v5j2FZ93AoFEASrufo0KCEZET2Mih60sBouChrxmQkFglefE8pi47EXG4U9c//eveHY7BkL6yrp6zhDMparw8IbgwEc6ZGJTdDbQEEwF8cKMG18dDEaVFCk2zrG5v4ObKv+kZ8Zb4N75k5a3aBE4mANUCqX8XUSrDhPv7oHY1Y/ZGetcU4YJPBUorYLXwGpRJGdg0foyIyuOKOhEnxV/QEqL5Kcop+SSDQpWtA4LAlOPcTW3PHYO3aE8yruuefcuOzDh+HNbw5TDzNjszs64JlnVrc/Abt622CA1BzCCMEcQZAeIxUrYTdQEMzFtlVjVGQdMBpMkGeTfZzN/V1YViOKgUNvg7e/P71hvQ3mEomDNUA+n0eRwpKSE6PbGT490NYKv14YwChFsZzE0/G6nUWlZejvOcu2gWM4dm2tqr5faVjTEAiL02IT46IbxPpxuLQkWLJGV8blxmMvHIU9MVHbvqZJJ6boyZyqy7ZWy4wgSMcmpyMEzRUEcxECZJ2iavVEa4MJcvS6w/T3dzWsgyDyNpjP2qvIqZamFDk1Dm00+aJATvuc25bNU69eTV/313EcvW5OMAuZEQYFP4Wv69OitJBkosTOwSOcHe9hbLL6ca4wEzlYuYhrSmSZIo1ZR6JgLrY0QFBbkd9i47EXG4V9ZPqKf2IijDasGsGOTccZzze3ODEsKvRCYyKn3NBUQbXEnDK+qt1EqF5obRDBFH2xU2za1IUQjbuezRcKxHfs56abNq63wVzWd+SgmiKnmcd/4hPNX+cylIpFfFLn5kAI8FWWFw5eVps9bhszIwzyDRQGMwgJvd0jbN98BNetfhRxsGzkwFAWDqdEH5Mi2wbRgsZ+XmypsUQdLfYWG4W9d2/4PZ0Zm11jbtixA7Z2H6vPepfhXIRggt5UGCFItyhCsBSC6Y6FNkFrgwwm6I+fondTd0OFgTEGzzvGvT9+44b2NpjL+o4czC1y2r59fpHT3r3hweWBB85FEx56KDwAtRH5XBEt+rDmmBtIKXnt+KXs2nyUjmyubQ4u9eCcMEgT6Pr1Lq9EPOaxY+AYY5NdnB3fRKVRhKW6FTQwKTvJE+Yu2+I9asIiLEuBAmWWP7QEgcayV8gbLzUK+/77w//P1CPMwWhDUKVl9EDnaU5P9lH0lnZMXQ3zIgR2GctqHyGwFK7jUSjR8g+sVhqpxulPjNLT3d1wT41SqRR5GyxgfUukSoucIBQNbVahqpQi7zlIef4JyLIcnnj5GvQKpjVriVlh4DVXGMwgJHR3jrFz8BDx2PkOgYuh1MITnKEkYmF7Ium2KjhshrmNQGBJhWT5E/SRV06jl7NzXv0COPJKlXUEAnb1Hq7L7g1gSz+sIZgbIVgDwgDAdfyWByR1oLHVGIPpcXp6uppitlUsTrHrpsjbYC7rWxxUWuQ0k8tsM4rFIgHJRcNcQgomcv0cPL5jXRQnGsKrhbyXITDNFwZzcd2AbQPH6e0+hRDLn+Q8f2atBj3dnjgiNqGF3TYng2Z/OoQQ2FaAZOmT/zf/9gBSyrp0jMyglKZU8HlywdClSsgkp+hJr24k9XxBcIae9CjpWHHNCIK5OLbf0uOJCjSOHmUwM0lnZwfNkNZaaTw/8jZYyPpOK0BlRU4ztx04EEYX2kQsTOVLGNG5pHC2bMmBQ3sY7D1JMuGtuQPRDLPCoJxG0R4jdecOcjo92ke+uPggJ4NEaYuyFWOcznVbcFgtoUAIbZYXG9T0zMMH+dyvf5133Xctm3d017w/rTSvPXOcL/yP7zAxspo5KILtm44xVuhCV1icaEufuDOTMlgfxcGOE7SsnTEIFHF9hs0dJTKZLM2KuRWK+Wlvg081ZX9rhfUvDhYyU+S0fTt8+tOheNi7NxQDDzxwrmixxfi+T8mPIVfIyxqT4JnXruSmK/eHcfE1hiG84iu0kTCYi+sEbOkbZjKX4fRYL2bBicPDYVgPIm3TVimEduDcJMfFBcITD77GEw++Rjzp4MTmv64WQVXh5GLeq7rWYCGu47Ot6zhHRnYu+Zj1KAjm4ljBdDSnuX9ZECgS+hSbOwPS6WwT9xx6G9z6I6nI22ABG08cLFXkBGEkYZFWRyEFubHmVvEWCwUUGewVTvhCSobO7uTkyGEGNp1dG0NTppkRBvlyGt2GwmAGIaAjMzU7DjpXzKKNYNzq5Aw9pIM8HW57iMp2IxQI05Mcl/hslgo+pcKc75cxYWFjCz7L/V2nOTXZR8lPzt42Iwhidhl7HQqCucwMX2omgR+QMKfY0q1JJpt7gvb90Nvghz/8gabudy2w9i41W4BlC5598GxT95nL+yBjFR0fbctm/8vXEARyzVQfnBMGmbYWBnOZGeTU3XeGE84gZ0QvCEk5iK2B1711KwxHPfuICusLhGjlWjU7+45gy4BUbIqeOTUEzjoXBgCWXcd5GSthQmGQMsNs7YFksr7dIpWQzxeIbX+Cm266qen7bncicbAExhgCPyyo+vrnjnH0heb5sJe9MiWdqLzfVoAXdPLioUvWhPeBwcwRBmsneKUNjNJFIZFh5+ZDdCVHAfBWNV9hYyFmBzWt/PmUQtP8qIHBEoqYXWJL5xAX9L5GJlbYEIJgLhKQsgkuiQaCICBjhti6ySaRaL7xUuRtsDwb9qhWLpd55OuvkLb6FvfpNjB+uszT/3SGA/882tS1FQsFNF3YVXxgpZS8euxN7Og/Rke20LYHtFAYQK6cxdAIf/T6YwwUiTNCN1qEUQ7LMmzvPk5Xcgxl1sDf0QYfiEpGPQtME9dqsITGtjwcGSClnk3LDXafYGoog1kjUa26IcC1fQLTwJO1gSDwyXCcwd44sVhjjc6WYsbb4N57I2+Dxdiw4sBxHP71fb/Dm+QPkEq1USGKMUzlNSzibbASUro8+co13HbdQw11E1st54RBZs0IA2UkI3RRJHX+CU0IMokCmcQ4mXiOyVJYYd0G5+HzaJdVWRLAJ1DuoiJA0OiowYwg8HGkP08QzN2vawf0d57m5PiWBq6lPXFdj6C2kSNLYyDwPTrFcTb3JXGc1rUtF4tT7LzxeORtsATtdwZpElJKUj0+qhFGLDVQLBXxTDhkqVqEFIxNbebQ0Pa28z4IhYFZM8LAGMOUSTLEIEWRXrZyXiuLnvQomztO4EivrV75dlrLDLOjnhe7UzZixedSBmk3RyqWI2570zMNlnpfBZuyIzh29ZbaaxkBuE65MR8cDYFfplMeY3NfqqXCIPI2WJkNGzkA6N4G6lRt7U/1JpcvokXvqsQBhN4Hz72xhy29J4nFgra4XjQYggDy3tpIJfjGYoQeysQraqfzp9sb447Hlu5hxvMdjBc7mblel1Jw4Z4t9GzuqCm3qZXm1LFRDr94Yi2UlizLbARBn4uQiSX7GVbDdIRA+jjW0hGC5ZACtnYf5+Dpi9vie9QsHDvAmDobE2pQQYlueZyBviy23dpTT+ht8FjkbbAMG1ocDF6Y5NQT7SMOtFYUStaidslVbcekePa13dyw++mWex8YDIEvyPvpthcGxsAkacZNV5ggr5BAnfsaCaArNU4qludsrpee7Vv4yd/8fjKdyel9rP6sLqaP1iMnJvhvn/gCoyfXdvukJQ1mziTH2lMKtQuChaQTBToSY0wWu2pY19rCdTwMy0VVqsNo0EGRbmuIgb4sltXq046hVBrj1h9Jk8lkWryW9mXDphUABgYGCGif+eXn7JJr+1IKKTly+iJOj/W0NL1gMPi+IO+3eSrBQMnYnKCfcdFdlTAA0NpecM0rcO2Awa6T/NRvvI9kJn7uHiFW/TNDZ2+aH/+V99T6V7cFttRYMgBjEKtKKUynDKw5KQNnpZRB5QgEm7tOIGifaYWNxnHqN1nTaDBBnk32cTb3dbaBMJjxNng68jZYgQ0tDvr7+/FUqdXLmCWXL6FFElGjOIDQ++Cpl65Bq9YEROcLg/b9mIXtiR2cYhBfxFntFaavzj/obbl0F+muNJZV37/fsi22XNjLpsGOCp/R3jkIS6qwzbFiDHJWEOTrLggWEnN8+jpO13277YolA0wdBrrpaWHQ6wzT39eFrPP3YLVE3gaV0R7vVovo7++nrPNt4Q0QqICi5yJlna6wBeT9bl46fHHTowehMJDk/Qxt+xEzUDAxhtnMlOisOcG62OjmbG9PTdtciZ6BCsVBmyfMBeEcBksolhYy8wVBelYQ6IYIgoUr3NQxgmu1z4VEI3Gc2l0StTaIYJI+d5i+vq628REIvQ2GIm+DCtjQr87AwACBLKB06+sOCsUCAavrUlgKS0peOnI5U/lkE03PZoRBmnb9eCkjOEs3Z+hHiTpUTIv5dQezN9chArTsbhu8/aYhNEIIrPMmObZSEMzHEjDYfbzNYzD1wbFqG740Kwzip+jt7W6rtupSqYRvPcG9997b6qW0Pa1PALWQ/v5+ApEn0JrFfJCaSW7KA9Fd96s8KWM89fJV3HrNdxv+JZ0fMWi/E5cxkCfBGN1oUc+PvsBX7WuWU+2J9JKrtnH7B67jwiu2YDuVfTEMUJgqceCRN/jK/36UydHKJyMK9HTgRmDbPlprLKGwrQBLqpqLCutFJpknEx8nV+ps6ToajRQaIQJYRZ2QVgapxulPjNDT3V3nlofaKRan2HFT5G1QCe0j6VrAwMAAgTWBDupXgLMafN+jpBLIBigUIQVnJwY5emJLQ9ML7S4MfCM5zSZG6K2zMJjevmq/gsvVvNsX7dnK//Ofv49LrtqGE7MRUlT0I6Ug3ZHghjsu59/83r3EkpVFZAwGIUCiiNlFOuJT9KTPknQL2C2IECyHQLCl+wSY1h4vGo4QxJzqXZB0oJFqjIHkKD09XW0nDGa8De77sfVRzNtoNrQ46OjoQLkT6BYbIRUKBTTJhuXALMvmmdffTNm3GyIPDAbPt9pSGBgDEybFsNlCSSziclgngsCh4tPxgQPwmc/Avn3hmPA24u3ffzUIVl08ZtmSTZs72HPThSs+VghF0smTjU/SkZgk6ZRmIwWuXUaI1qf7FhJzPPo6zrR6GQ3Hcavr4lKBxtajbMmM093dSbsdB2Cut8E9rV7KmmBDiwMhBKlehQpaKA6MYTIfgGygW5iAQGc48NrlYW9RHTEYPM+m4KdptwNCebY9safq9sRqWazmYFEmJ+FjH4P774crrwx/h1Ao3HXX/MfedRd84APwyU/Wd7HLcNGerTV3V6hAsWv34KL3CRFGCDLxCToSEyRjBWx5vggQQhCzy0C7CQRBX+cZHGv9OicKwLW9irVuEGhcfYYtHTk6Ojpot+NASOhtcMsPpMhms61ezJpgQ4sDgE1bVUsLEkvlMr5O1rUQcTGklBw6eQkj4111Sy8YYyh7Nnk/RTsdELSBMZPlpNlcU3tiNfi6wpqDhx6CHTvg4YfD3++/P/z/PfdAZ+f8x/7rfw1//dfwi79Yw8qqe6+tCmsMlkfguOe2M1cQdCYmSLrFRQXBeVsRTIe320sgSAGDXSfWdXGi61Q2ujkIFHF9ii2dZTKZcLZIOxJ5G1TPhhcHWy7qaKk4yOfzKFKIJrTVWJbNky9dTT3+XGMMJd+m4KfmGfS0FAMl43KCzUyK6lwOa6XiyEFHB1x1FezdG4qEI0eWfuzRo6GIaGLkoC4IEMLg2kUy8cklBYEUasWaAjkrENprBko2NUUmPt7qZTQMxw5WfMUDPyChT7K1KyCdbqPhdYsQeRtUz4YXB/39/QQ0agTZ8mijyRcFUjanaUQImCr38srRi2qKHswIg2IbCQNlYIQuTjFAUI/2xCoJVIX1HHv3wuhomEbYty8UAEtx//3h43fuDB+7Glr09riWT8otYsuli/eEqOyELwW4TglT55RYLQgEg+u4ONGxfZYMHZhQGKTMMFu7IZlKNXVt1TLjbfD+j7wVq9VtaWuIDd3KCGHHQlm1Jn9YKhbxSdXP+KgCLEvy4qHL2d4/RCpZqvrcYYym5LkUg9SqavuEFKS6Ulh2hS1yxpAfy6P8xcMdxkCBBKN0oUXr2gkFAqVsbKuCsEwlaYKZtMPevWFdwsKUQxXrqpkDB8L1bN8O4+Nw330r7LMSmVSdm6ElIOaWKPuJtulgiDsevR2nOTO5eH3FWsa2gzA/t9BLw0AQBKTMEFs32cTiidYssArOeRvc3+qlrCk2vDjo7++nbI5gjGn6VXA+V0SLPqwmm9kIGedfXtnDzVc9VpX3QSgMYhSDZPXCQAje8ePv4Nr3XU+qs7orDb/s8/JDL/GV/7qP0tQ5lzrfSMbopkiyLdqm/IXioBrnzYcfDqMI+/aF9Qd794b/nhEJi1RYLzfEqW758JkCyq99LUyBfPnL4e379sGnPx3evgqkrH7IkiUgZpcpB7E2EQiCvo4RxnLdBDq+8sPXEGFaYYHxuYEg8MmYIQZ7Y8RisVYtryqKxSl23HiMXbt2tXopa4oNn1YYGBggEKWm1x0opch7Ts0TGFeDkJJTY9sYOjVQcXrBGE1xtcIAuP3/fzt7/9WtVQsDACfmsPu2K7jvd39kei0wZZIMM0ixge2J1bLQCCk3OlH5k/fuhUcfnS8CZkTC/Ytf8YyfmVrNMqujmgLKqlhdisCSmpjttXSg2FwsadjSPdwmq6kf9kKXRAOB79HBMbb2xdeMMJj1NvjIe1u9lDXHhhcH/f39+DKHUs0VB+cmMLbmLbAsm3957Rp831r2wGYIayOK5RjlVQoDaUmu+74baorMSEuy5fKtbLp4KyfpY1RsAtFG+cNFLJSPv/QG5XwRreqbK9dKcXZ4jJNHxxp/UqqmgLJiDKKGQ48lFa7VPgIhm5oiFatCCK4BLKlBTNdTaAj8Mp3yGIN9KRy3+TU9q6VQLETeBqskEgf9/QRyHN1kcTCVL2FEonUXvQJ8leG5g29aMvxtmI4YlGOUVXLVxW2dmzuJp2sPuxpjSF16GZ5I0H4tU+dbKGul+Pvf+SPUtAOnChQqCFb/M/0Z9YplvvoHn2VT+gwSVddT5HmvajUFlBUiK2hjXAnbUjhtIhAEgq3dwxjTXi2XNTHjkqhBBSW65TEG+9I4TvvahJ+PoVQajbwNVsmGrznIZDKIRA7VRJdE3/cp+TFkhUV5jUJKycHjl3DBwBG6OnLzTgznhEEcTyVqOhfXp3c+1DC2274f2UBZhK/cuRdr6OWDfPb//SV2Xb2bjr6emlpWtVKMDZ/m8LMvEXg+mbgh4RY5O9VD0Q/TNfPfJnPeLYshhMaxysSWqlCvyWdhMSpb10o4lgLjE2inLturhbjr0Zs9w9mpgZauo57Yto9XLtJtDTHQl8Wy2ve7txi+7+PpZyJvg1Wytt7tBiCEIN3ro4eap/qLhQKKDHYbTCuzbIf9L13H99zwrdnCyBlhUCgn8FW81cfdNcNiY5shvNJ/5ZF/acAeBbbUDHScJldKMZLvRhu7orcrFAQeru1hy6D6t3hhAeUclruWF6iaUgoLcewAEwiUtmntB1XQ33mGsXw3Sq+dsPtypGNTJMqjDPR2rdpOu5Xk8wXi25/ipps+3uqlrEk2vDgA6NkqCY41L3KQy/sgY21x0hVCMFns5Y3jO7l4+2FAYJSi6CfxdSQMqqFiI6S6I0jHCyTcIiO5bvJeZubm+Y+qQBD4no8TqyB0PFNAuRgGvNLi3vxCauqdzXRsHxOArtSlskFY0jDYNczRkZ1r/msTt/Ns7zhDzrl2TQoDpr0NPviRayNvg1WyBt/1+rPlwixKN8fMpOyVKelEywoRF8OyJAfe2EOhGMMoRcFP4TWjNauNBxCthkC3Vmtb0tCXPUt/5iSW9IFQELh2iXR8ko7EOCm3gLNMpODgcwdrrr+xbIvDzx9e9L5GtCCGswB8pGi9IVFneoKkO9nqZdREwsmzq/sNUnGPOjbFNpXirLfBva1eypqlfc5QLWRgYIDAVDeFbLUUCwU0qbYSBwCIOE+9dAV5P4Wvm9CmtNQAopn7PvGJxq+hziwsSGwVqViBHV1H6U2dJhtfWRDM5ZG//U5YOLlKgaCV5sTBE7y6/5Xz7pNC0ahQlABcp4xosUAQCLb2DLeVm2M1JN1JdnUfJOZaxGM+QbA2iyyLhRw73nqUCy64oNVLWbNEaQVmjJAKjd+RMUzlNbTA22BZDPhBwPHRXfSdmaC/52zj9zm3f3779vm9/A89FDrxrTWMRBuJFM2+2jIIDEIopNBIDBhBd3KccuCSK6fRVBZaHX5jmM/9hz/hLfe8lV1XXoATq+wQYQzkJ/K8/NhLPPL338X3/PMfJOqfUpi3ecS0SZLAmNaFkhNumU3Z04ysseLEdGyc7V3HcBwLIcB1fXQL586sFq00XvAyH4q8DWoiEgeEkQNPH0Qbg2xgb2GxVMQzqZpH4tYVA57voZEgHF44eDmbOr+DZTX4ymdu/zyE/fM7dpwrcPvSlxq7/wbhBQ5xpxlRqPMFQfjRDT+/2oT/itkerhwl56UoqmRF1+0nDp7gi5/6uwast/Gf+5lRzyU/BhUKogasgv7OM4yvoeLEjvgoWzuPYzv2bHu166i6e3Q0g0KxQJB+lPe851OtXsqapo3OUq2jv7+fQBTQDa47yOWLaJFsygTGipgjDIRwkELgBSleO3Zh4/e9WP/8gQNhimEN09iiRINAI4WPLT0c6eFIhSWYNphaeOoPbxNSkInn6YyNTYf2m08z99sOo55tadjcOdyy/VeKAToTZ9jWNTRPGADE3KDp5nC1E3kb1IsocsB0zYHMoZSmUdYDWisKJasldsmLYsCfIwxm3AuFEBwavoDBTSfIpnONXcPC/vkDB879HDmy9sSCaETdwbkIgSX09L+nd7ZMHOD8ewSuHdBtjZL3UhSDJhtJifp4G1TKzKjnsh+nVddAXZkJRvJTFMuZlux/JQzQkzzFls7Tiw5Cc2yNoTm1WMsxsM0h3VHZgTkIfDomT/DR//cjDV7V+icSB0BfXx+eHG+oSj5nl9z6JiezQBj0bnH54Z8b5OZ7ush0hV9CwfXhZLYq8Us+B598g8c//yinXj9V3ZOvvDL8eeCB+QWKawZRp8jB6gRBJesTAtKxPDG7xKSXaVL7X329DSplZtRz2YtXNWCsXggEW7qGeO3EJS3Z/3IYoC81zEDHyDITUgWu04RarCV46/ekuf8/DTCwrdrUzKUNWc9GIxIHQDqdRqbyaL9x+bVcvoQWnU2fwLgQM51KMFgIYdPd5/A/H95N75YYtrNwbavIl3bAnrvezO7bruBz/88fcer1U+Qny9Vt4777Fh0LLKWgkGv9lcxy+IHN6hwAZwSBRgq1oIagum2ZFXcvcCxFT2KcXDlBMUitYr2VIxvgbVAp1kwEIYi3ZJJjIlamJ3OW0Vxf0/e9NIbNmeP0ZiaWHZ0uBLh2a8bZX3xlnF/+o220SwZ2IxK99NN09DUuvxaogKLnImVrzTiMMXh+eVYYCCF453299G9bTBisHsu2sByLt957EzmT4JWzGU4enUDr2qr4jTa8+GR753GrixwYOK+GIFimhqCehNtPx4p0xcew5SLdBXXdV+uwpCFml1oyh0EgGOg6hSWqFMiNwhg2Z4/Sm53Aslc4/AtBLFasbvR4nbjjBzsA2iLSulGJxME03dusho1tLhQLBKSwWiiDjTbTEQNnVhgAXH1rpiHHbsu22HnDxYzQixY2f/kHj6G1QQXVR2dmnrPv/zzD5GhrrmQqZeWaAwOYWUHgrlhU2GgEtqXoSoyTcnLU2/RGSNWSK/aFhAKhNYOabGkY6DrZ9P2ej2ZL5xF6M1MVdUwJIBHzaxb1q+GC3XFsu/Wfm41MlFaYZusFnRz+dmO6FXJTHojull1AGW3wAx+DjRDWvNHJyYzVMHXuxB1myp8PPHacT/7El3jbuy5m52U92BUOY9LacPr4JPu/eYhnvlP7RMBGs7hLYnhwlSJYpO2wAa991VmN8MFJt0jMLjNVzuDXqQVPGg1tkm+fGfXsKbfpgqU7M8Foboqi15riRIFma+chulLFiu2QhQA35qPyAdJqbkumU8dIZsTqiMTBNAMDA7zWAJdE3/coqUTLJjAabfACb1oY2POEQbM5+uoIR18dadn+m8G5tEKTBcEstXQFCCxp6ExMUPRi5Pw0tQUXDUa0Q9zgHLalMPj4ymmqQBDAlq5hXjt1adNfDykDtnUcojNZRlTlsSKIO35op90mTVYRzaM9JH0b0N/fj6fzdd9uoVBAk2yJXbLReloYOPPaFSMahDFobSHQ0ymDcktSBqEsqa2rIeGW6UmM4crV58plm6QUFuJYwXSNRXPD5Yl4ie7UmabuUwqfHZ0HVyEMmK458AnWoBFSRO1EkYNpBgYG8MxraKOQok5X+cYwmQ9ANt8lzWg9nUqYqTGo4skHDpyzNR4fX7RzIGIaMxMh8LGlwhIBQkM4CK41J8b67FUgpaEjMUk5cJkqpzFVOg6KmqIYjSXb6dB/wU4sJ0Yta8xPFjj2ylBFtTQCweauU0wUOtCm8ccES3rs6jpIKqFWZbwWWiir9rFQjo5LTSUSB9P09/fji2dQStctBVAql/F1cuWq4DoTRgxWKQxmBiJ97WuhEdGXvxzevm8ffPrT4e0zj/vkJ0Mjo43mRHaeIFAIKZACtJH4ysZxWjMAyECdz8eCmO3hWGPkymlKKl7Z5oWiLQOTQvCun3gP19x5fd2ieaVCmb/71Jc58J2XVnysbWkGuk4yPLq9Lvtecj+yzM7uN0jFDaKGmiLXCVDtEDmo9Li01G0RVdOG397W0N/fj7Km6uolns/nUaSaapc8Iww0DkJWKQxg/kAkODcQ6Z57oLPz3OOOHIFnn4X3vx/uuisUCusaA8Yg8XBliYSVJ277uLbGsuT0TI7wxW6shfLKy6w/ofDJxqfoiI1XZIXc/OFTlXHT+27m2rtuqGuaL5Zw+cAn3kf/jt6KHt+TGSfm1D+FOYNrFadHLtcmDAAcW6FUI9tcK6TS49JSt0VUTRQ5mKa/vx9PTtTN60AbTb4okLJ5L/G5VELoqbCqw8JSA5EWks2eU+Yzw5LWHQbMnAgBYYRACJZ0/BO0z+jm+iOI2T6uNUqunKKklrFgFjQ7pV8Re95+TW01m4sghEBrw569l/P1I99e+fHA1p4hXj95Sd2TLjG7wM6ug8RjomZhANNzKtw2aB+u9LgUUTcicTBNIpHATufQ5fqIg1KxiE+qacZHWmv8wMMQQ6xWGED45fv2t8MTPoRfysW+hDO3PfAAvHc9jUatXhDMQ0CgWmt21VjC1yITzxMLykz5GfSC9k2BQpj2rDXo3txdl5PmQoSAnsHuih+fjBXpTp5lrLCpbmuI23l2dr9BzLXr1j0qRGstlGep9LgUUTcicTCHbJ9AHa6POMjnimjR1xS75LnCoC5iZOFApOV46KF1UBg0IwgCLBlgoxGSygXBAnxtUffL04pp1j5nBjmNkfeSFIPk7L6lbN9CxEbNOBBCVOwfANPOid0nGS90YOrQJ5h0JtnZfQTHXUUqcTmEIO4W0e1QXFrNcSmiZqKagzn0XmDq4pKolCLvOU2ZwKhnUwl1EgZL8fDD4VjlGeUOYZHQms3tzdQQ+DiyRMIqELc9XEtjWQIpxKra8ETdhi+tBtNkp1uBEIJ0rEBnfAxLNL89cC3jWJrNdXBOTLkT7Ow5jONa9RUGhHIgFi+jVZu+r4sdlxa7LaJqosjBHLbu6OV1U7s4mJnA2Gi75PnCYHX7KuY1WpuVXRL37oVHH51/WzYLv/VbSz7Fr1OKpn4sFyGo31E1aGHNgZjz32bu1bEU3clxin6s+eOg1zA92TFGct2U/dSqnp+Nj7Kt8zi2U+eIwTQCiDkBk3lVVWSkVsZHFEoZLGsVx6XFbouomihyMIfQCKlU83am8iWMSDTkyzpDPYQBwIFHphpytakCzSvPnKj/hqumMRGC5VCt7FZoGeFrmIrn6E6NYMv2np45jwMH4DOfCa80H3igqbuecU5czVewI3GW7V2NEwZAmFaIeWjV3NbcJ76Za+jxM2JlInEwh/7+fkqqtuIb3/cp+TGk1bgQv6qTMAD46p+dZXI0IAjqpxCUCqMR3/j8i3XbZnWcEwSuLBFvgiCYS6CtlgTXVx7V3Gg0lgDHMvSkxkjHJhG0W/RoATP98/ffD1deGf4OoVC46675j33ggTBkXee23VSiQFeycltxA3QnT7G980RjhQHMuiQq3Vyvgwe/MM6LT4bH4noemyIqZyNe4ixJf38/AS/V5JJYLBRQZLAbVPiklCZQM+2Kte3DGMPxYx53v+00P/3LvbzzHodMlUMaDcw7OPnlgJefPsFXHniON144XdP6qmN+ysBCIxuQMqgEISRK2dhWm58Y64pBCn3uwyMEqViRuF1mspTBU/GWrm5J5vbPb98+v3/+z/7s3ONmRMPeveHtdWylC50TTzJRyK5YnGiATakTDHacxWrCvBYhwHVUw8bZL0WpaPj3HzrK3ndlufbWFOmOOfUUBjxvis2XFLjooouauq6NRCQO5jAwMEAgnkIFGlnh1MCF5PI+yFhDruDmC4PVHxgMoSfCKB2cZADzustH/5UHVB8KNoBrTfGuq/8J1262K2D7CIKFBMEGEwcGhLUwdCGwLENXcoKCVyJfzqLbLVhZja/HffeF0YPt2+veRufYioGuk5wY27bkYwwwkDpOX8dYU4TBDDG3NS6JXsnw4N9N8ODfTcy7vVgsMlL4PP9w4KNNX9NGos2+qa2lv78f35pctUti2StT0omGDFlSwYwwqK0rQRtDSUveYCfDbMPIWE0DmQTgBWmeO7yb5pTKz68hmJsysJuQMqgUf0PVHRiEUCxZ0yoEyViZ7vQIrlN7TU9d2bsXRkfDNMK+fWGV+3Lcd18YRThypO5L6cmMEbOXSGsaw+bMUfo6x5sqDCAULrodXBKnKRZy7HzLIS688MJWL2Vds5GOYCvS39+PL8dROgBiVT+/WCig6cKuszhQgSbQtdUYGAPKaM7SzWkGEMJe+mBeJUIIDp6+mF19R+jJjtdno/OYGyEIjYnaJUKwFC1pZzSiZTUHQmqWT36H46C7EhOUrBJT5QzatIlZVCX98/v2hVGGvXth587Q238mBVEnpIAt3cO8cfqiBW+jZkvnUbrTOawmdgzMIATYThu4JAJaabzgVX7ox97T6qWse6LIwRxc18XpKKyu+MYYpvIa6uxtoIKAQAc1CQOtDTnj8DoXcFoMIlczc2EFhLTY/8a11K9uaW6EoDwnQqDaKkKwGKGFcrPFwUzUpjWvSeVCUxB3PXpSI8TtYtMLN02le1zYK3/LLTAxEf5++PB5wsAYQz08HlKJPB2J0dnfBZptHYfoaZEwgFD8x9rBJREoFAsEqUf53u/93lYvZd0TRQ4W0DlgUK9Vnysulop4JlXXL3AoDPSqiw+NMQQGTtLLGJsQ0m6YGhTAZKmb105cyKVb3ljlVtZehGBR1r2F8lxMaJdc5QdLSuhIThL3ikyWs2jTnENRYSJPpruCKaILe+Wz2XPzQxaZI2K0YWqs9mFKAsFg9wmmhjKAZFvnQbpSZUSLhMHMqmJuida5fs5gKJdGufmHY2Q32iTYFhBFDhbQv8tZ1fzyXL6IFsm6TWAMahQGWmsmTILXuIhx0R9GC+qysqWRQnLg6B4KpUQVz5oTIRBrK0KwFAKBr202ilugkJrVnTQEMTdgU2qUhJOnGa/Xy4+9iG5A5b1lW7z0+Kt12ZZrBwx2nWB79xttIAxCcZ6IeWjd2s+z7/uU9TP88Ic/0NJ1bBQicbCAwW2bCHR1xTdaKwolCynqk1KoRRgYYyhrOMogR7kAJRM1FRxWi8HhqUNvXqE4cQlBYK9dQbCQZhshtc7jQFPruUtIyCZydCXGsGRjC9++/Vff4MzxMwCoQKH8ABWs7ifwg9kWv0f/YT+vP32oLmuUQnPJwIt0JMbCEEuLEYAb85rezriQQr6As3U/e2c6SyIaSpRWWMDAwAAHTHUtfTN2yStaEFdAEAQobYBY1dvTWjNKlpNsxggX2QKLMSEEJ8a2MTR6mC09c33j56QMhMKSazRlUCHrd2zzXBZ4G9SEwHUCeqxR8uUUBT+JacC1SzFX5E8+8d+58KqL2HbZDuxYbe/T1FiZl/cfZOj1+riBSunTkzhD3NWQHuPsVLLp3QnnIQTxmB9GXJwWfa6NoewNce9HrsVqoMFcxDkicbCA/v5+yipX1XNy+RJadNY8gXEmYlCtMDDGUDIWw2whTwdCypaeboWU/MvBq+nr/CccGSCFwpquI1jPgmAuSm+Mr5ao8wRGIQXpRJ6YXWKynCXQbt22PYPyA17d/zKv7n+55m1lN3Vy+c3Xcuv7b6zpJG4M5MYmGHr6UU6+fBqBJBHTxItjeLqnIWOmK0YIYo5fl6F0q6VYKuFZT3LvvT/RsjVsNDbGEawKQpfEM2itKvITCFRA0XNrtkv2PQ+NABGr+IrfEEYLztLFaQZAOHVrT1wNBsBojIGiTvDK0Qu57sJ/QUqxIQTBfCSBsrCtJpnHNL2N0QDLeBvUhMBxND32GLlygryXph0zoIMXbeXDv/pj2K4Dgpr8TYwxaKW54V3X88xXvsFjf/V3CEvSlZlieCSL7dZfJFWKEOC6AbrJFspzmfE2iBwRm0f7feNaTH9/P4HMVewIVigWCEjVNIFxRhhUkwrQxlDQNq+zi1NiC0I6LRlUYgBjNFprjPYRpoxDgZgMeP3kxUwUOpAbThiENK/uoDWFYmFKoYHvqxCk48XpQU7lxu1nldz1kbuxXQdpyZqNz4QQs5GHq979PXRt2YwAHFvQkRxZtTFbvYi1wEJ5Bq00noq8DZpNJA4WMDAwgCenKv4i5KY8EKu0SzbgeR6qCmFgDATacMJs4g0uwpMZZIPmOCy5BhYTBCViMiBmS1zXxbYtbMvhsVevR+mNJwwgHMDUXJr5Opsm1cqJ6UFO4201yCmWjLP10u0NGWOslWb7m3cDYYounSohTL45BqRL4DpBy8RBoVggSEbeBs0mEgcL6O3txZdjFbUz+r5HSSVWl1Iw4PkeGomoUBhorZk0MV7jIkab1J44w+KCoDhHENjYtjWvVkJIwUShn9dO7Jo2idlY+MF6LUo0CHTV3gY1MT3IqSc1imu13oI5ka6mXbc6jNHE06nZ321b0p0eb0gLZqUICbbVCpfEaW+D74+8DZpNJA4W4DgOiS6PoAJxUCgU0CSrDynOEwbOiq2Gxhg8DcfYzBEuJJAJRBOOzCsLAuc8QbAQy5Y8e/jN5EttOpWvQQiabITU5OCMXLW3QS2cG+SUiY0jaW2ovVkIBIm4ImaNY1rkNSCEIOZWV6hdDyJvg9YRiYNFyA4G6GCFA48xTOYDkFUWClUpDLTWjJkUr3Exk2ITssGdCIsJArtKQbAQTZKnDl6F3kjRA8G0EVLjaf7L2qyUwhJMD3LqSZ0l1pKr2eYjLElXdgoVtGoAksB1yzS7vqVQiLwNWkXUrbAIm3e6TL2w/PjhUrmMr5NYdhVHSROmIioRBsYYykYyzBZydDW0PXFulwEoJAE2Ginl9E9tV8BSCo6P7uLE6EEGe05viOJEwUxBYqstZ+tNOIGx9X+SQFrQmZqk5JWY8jLodmgfPXAgnMuwfTuMj4dTHOuAAFwbsslRcuW+htQ6LLt/AfFYmaJn6uLnUhHGUC5H3gatog2+Te3H4LZ+XtDLi4N8Po9iE06Fl1CmQmEw0544QienZtsT6/9lbLQgWIhtWTzx2vXc3fFVXHsjRBBEXYYvJTqy7L5tL9vffDmxZHLFfYYYyrkCR559gRe++TDFyfqGg2WdvQ1qQxB3fVx7lKlSmmKQaJ34nJyEj30Mvva1cKTzl78c3j4zvOmZZ8IJkJOT8MlPhv+uIo8upCSbLJIrFTEm1dTuJAHEYx65omrISPrFiLwNWkskDhZhYGCAZ8zSRU/aaPJFgZSVvXxmOpVgsBDCXlIYaGMoGYchBimKNELUN1qwmCCw0FgNEgTzEFBSnbxw9E28edcLLXFvbDa1jm1OZDN8/3/8OJme6chRFa+ZMYa+C3dw6c038IVf+R1KudqHAs0UIrbSS2MpwkFOU8T9ElOlLKpJg5zm8dBDsGPHucjB/ffPH/V89Cg88AC8+c3w7LPw/veHz9u7t7Kx0YQ1PN3pUUZy8eY6JwpBzAnClsom1dmWCjl23HAw8jZoEZE4WITQJXF8yftLxSI+qYpOpsaYaWFgLykMjAFlNKfp4Sz9CGHX7QDcUkGwACkFLw1dzo6+o3Snp2ifq8/GEOjajqKX33YzmZ6uVXXDCCEQlkW2v5c33XojT3/5GzWt5dx2VWO9DWoiPIG51ihT5RRFP0lTP2MdHXDVVeHJHsLowdwJjocPw4c/HEYLvva18LZ9+xad8rgUQgiSccVUcYJAdzXPOVEIYq63qqF0q0ErTTnyNmgpUUHiIgwMDOCLwpKtQ/lcES0SK34xjZ4RBs6SwkBrw5RxeZ0LGRGbw/bEGr/vKxUVxlZRVFgvhHR5/NXraPGAt6agjYWpweNh2xWX1zzlUyDYduWbatrGXNpgDtCKzA5ySjZ+kNM89u6F0dHwhL9vXxgpmOHhh2HPHrjyyjC6AGEU4ZZbqt5N6Jw42dTiRCEg5gZNs1COvA1aTxQ5mIMyhpGSwu/dwZt+UtE3sB3pWhAYgvGA8pEihTcKFE66SLn8VaHRBj/wpyMG1nnCwBiDbwQn6WOc3poLDsMIgZn2E2hthGA5pBSM5TfzxomdXLT5cFMnRjYbAQTaxpHL168sRSxV+0RNIQWx1Eq1CpVgEKjmehvUhMC1A3qSo+S9JHkvRVOuhRZLDxw4ABMTYXHigQOhQIAwDbGKgkUBuA5kk2Pkyr1NK0503Wa5JIbeBm/7IZeOjo4m7C9iMSJxAEx6ihdGyzw3WiLvG7Tp4oLvvxJp2WFxkwCjDEIKtNIMnN3F0JenGP7qFOUz5x/4jTZ4wdyIwfz7tdZMkmKIQbSIrzr/vlAQiOmiwnYTBAuxbMnTh65iy6Yhku7qTpxrBT+wcewW/4110l+iJd4GtSGkIB0vELPLTJYaM8hpWY4cgY9+NKxB+PSnz4mHyUno7Fz1ZqWUZFKFphYnuk6AasJ8hdDb4EDkbdBiNrQ4KCvNd08UeG60jDLhSGFbCmxLMFksYXP+lZuRhvgmhwt/tIddH+pmaN8Er//JCKoQxsmN1niBv6gwMMbgGcEwg0zRvapowVqJEKyEIsXTb+zhxsueWtfFibUWJbYPBmvNvk0Cx9b0pMJBTgUvXfM46IqvoHfsgEcfPf/2bBZ+67eWfFolboi2JelOjzWtOFFKkBSA7obup1AoENuyn1tu+bcN3U/E8qyXI1fVHJ3y+afjOSY8hUTgCjGnhkCE4VO9sGXLoAMzbZAksOKCbd/Xyaa3pHjxv55m9Kn8dCphvjAwhKJhlA5OMlDVgKWZ568HQTAXKQWHz17CBWNHGOg+uy69DwTgqzqXdjeoj355DELotV+hND3IKeaUmSpm8XVs1ZvKjeUo5ooNsVG2bJuRo0MrPk4IQSIe4BYmCXRnw4sTBYJ4vMGmU8ZQLg/z/o+8OfI2aDFr/eu+Kp4bKfGFQ5NMeApHCBwpzosQLFZ4FZ6cJTOCQZUMQVGTGLS55jcHGXh3Gr1AGGhjKGnJG2xnmG0YGasoj2ym93euqLCE1SZFhfXCtiyeeP06lFq7f8OyCPDrOXxppo/+/vvDvPXkZHj7Jz8ZFsB95jP129cCWmOX3AjCQU7dqXEysUnEKi2YjdY8/fX9dZ8ZopWiMDnF0WdfqOjx0pJ0ZScImlGcKCDmFGmkS2LobbCfe++9t2H7iKiMDScOnhsp8eDxPFobXCGWvIJfzMJg0eOAhiCvERZc8XOb2fG9XQgxMz1Rc9p08RqXUBKdK1ofryQI4utAEMxDQN7v5vmjl61ba+VwvkKd/ra5ffRwro9+586wHS6bPXdfXWlPb4OaEIJkrEhPagTXXt0gp2/++T/xxFcexS97dVvW2SPH+PtP/i6BV9k2Z4sTE2ONH+ssBPFYuaHf1VIxz44bDnLxxRc3bB8RlbGh0gpHp3weHMqjjcFdJFowF8uy8DFzTuZm3m/MuR3ALxicpGT3z24id9zn2FOKIbZQFsllRyovljKQaOw1nDKoBktKXjx+Bbv6jtKRyrM+rk5DBKK+NQeL9dGPj5+LIECYdqirD71BCr2e3pY5TA9ySkxQ9ErkvAzaVP59M9rwrf/1t7z8pT9m02Af0l7Fe23ADwxFP0FpMk9xYnLl5yxASEk2VSBfKmFksmHFiZLQJTFfVshqbOMrRCtNOXgl8jZoEzaMOCgrzT8dz1UkDCCsBsaY2YPiwpTC9K3T/w0z5kFBY6UEl39igEf/fzH8krNoaOZ8QRD+bBRBsBAhXfa/fg237Xl43V2hBvWsOdi7F7797XN2vB0dYc3BJz8ZRgyeey6MItQZ0VZ2yQ1ACBIxj5gzwmQpQzmorI7Atcr0ZU5iGxgfPr76/RvwfEPBSyEtp+pXWgC2LehMjzKWjzWuOFEIXNdHKc1qdNBKnPM2+L36bzyiajaMOPjuicJsjUElOX9LSsycfOT5kbT5wsBM/zsoSjJbBLd8FL75qQWPXlYQNMmTtA2RUnBqciuHT21l18DxdVWcqOrdrbBYH/1P/3SYUjhwAO6+u447m/6sbpDko5TQmaxskFPMLtKfPoVti9p1kwDHgQR5il56uoW6yk0ISSoRkCtOohpVnDjjktiQ9EXkbdBubIiv/aSneG60jGTpGoOFSMvCTJ/yz08pnC8MwlN96IinFex5ryLdZxbUEJTn1BCI9VdDUAO2ZfHUwWso++tLJAXaauyQ28nJ0Glv376wg2HGfa9OrJ9CxEoJBzn1JEdJOPnpY8B84k6B/kydhMHMXoXAdSDu5Fd98pWWpCszQaAa46shBMQc1RCXxMjboP3YEOLghWkfA7uKL3I4eSw8MOjZlkbBXGEAoKeth+b2TfslsF244p1eJAgqRUBgMjz9xpXrqjhRCLnq6IHyK6hAz2bDwsR77lnSoz/wVlvJbtZdmqdS5IwFc2IMS5w72SadPP3p09hW/YTBDEIIYo4h7uRWJRAEEHMhEx/DNKg40XUDdAPExzlvg+rtpCMaw7oXB8oYnhstgaEqK1pLWhhhmPZGmma+MFBYKBbP7xljuOp7NYkYkSCoECkFB89cytmJrkWv2NYqQbA6cXDytUMVmeEsh1aKk68dWsUzwwmMa8cuuRGEg5x6UmEUIeVO0ps+jdUAYTC7RylwHY1r59GrcCMUUtKRyqN1afHuqhpxXVV/l8Rpb4Pv+7E9kbdBG7Huv/ojJUXeN9hVnpjDnJ0mFARzexbmRgsWbtMgpm9VniDVI+i5IBIE1WBZFo+/dj26hoFF7Ya/ysjBS//8XbTSqzpJQGjTrQLFy99exKGvAqS10VIKiyOEoTtxlv7kMMbosG6ogdpVSkHMVTiyUPV7P1Oc2JVqTGujJQ1CrK71cykib4P2ZN2Lg9PFAG1WNkt9/alHef7bX2P/vs8DYRval3//F3jmG1+AOSkEFU4vmPPMc4JAzKYeQAcgLeiNRpFXhRAwVd7Ey8cvqrvBTKtYrTgYOTbEl37jDzjxyuuYKk8SRmuGX36Nv//Pv8/Y8MlV7H0dehusBmNwZZFMrEQ8ZpOwfIzyw6vnRgoEIYjHAmxZrPq9F0KSSno4chJT5/GnAkHczdd1m6Vinu3Xv8Ell1xS1+1G1Ma671Y4U1TIFToURoePkcx00L15K3/6iR/n+ntCBTtw8ZsYP3V8OlpgoWclxkzM4JwYWAytYdNFBr4WHWWrwbIkzx15M9t7j5NJ1PcqpdkIapuvcPLVN/j7X/89pGXhxOfa/Rq0Xvpz7ZfKNaQk1rO3QRUYgysLpFwPa7q92LZtpGXwPI9A2wjLCouc6/1aCZAI4o5H0RNoE0dUkeORlkVXZoKT4ymcenZCCXDd+n0ntdJ4/muRt0Ebsu4jB/lAr1jgNnriOIOXXM7zD/0TF15z4+ztF77lZrL926ejBWLRCMFySAnJrhr/gI2KjLH/tWvWfnGimHFJrA2tFOV8Yd6Pt+D3uT811SqYDeBtsBLGEJP5ecJgBikEsZhF3A5AeSjVoCiCCIVyMlZGUMaYyiMIYXGiIROrc3GiEMTcUlVrWY5CsYCffJT3ve99ddleRP1Y9+JAVXByuejaUBAc+OevcsWtd83e3tnRybYr9iAIeP2xf+TAg5/nwT/+FY4eeISZFsdzP4tjNXlC7HpBSsGJie0cPTO4posTBQJf2zQ0Bl1XDEKojZ1SMIaYzJF0/fOEwQyCsP024QocyqggCLua6v02i7BzKumUEcarTiBISUc6V9fixNAlMTRCqh1DuTTO277fjrwN2pB1Lw6sCjsUirlJhl97cVYoAJw++CoXXnkZY0NPIwh48/f8ALf+8M/wld//OaTQSKHDim40oAgLGGd+QtHglwxBoFBKo7Wpew5wPWNbFk++cS2ev7YrmOtuhMS0KVejKuaFpmEevO2OMSSsKZIxvaQwmIsUgphrk3AChPJQQQOiCAIsW5CIFUF7FYvlsDhR0pUeW3VR6/kbFcRcvy5eB74fUNbP8kP3RYWI7ci6FwcpW1ZkfDQ2fJzuzdvOu922bGyhOfn6foTM4SYTxDMdnDn8ElIILBn+2FJgSbAkSBHmbI02qPEpEgxjq1PI4CwmGEd5UwReicD3CQIVigcdiYfzEODrLM8d2b2m0wt1H9vcYDaKI+J5GE3CmiThmoovKmawpEU8JnBFCeU3IIogwLYkyVgJo6oQCEKSinvYIkddMgEiNImqRydEoZCPvA3amHVfkNibsNAm9CtYrigxns7M+/35b39tNsVw0bU3cdG1N2GMJpfPU5oao3fHpSy8eJv598x+pCVQZ2JsH7QxxhAEAYFSaOWhAkWgA8pl8JUgCGwMDhoLhQPYICxmGs2FFAgEQlTn17DWkVLw6vCb2NV3hJ7sxJq0VlbL2PC2FwaB2pjeBkaTsKZIuFTsoroQicB1HSwdUPIUgbSxLFm/76sI2xRTFMmXBVhuRd8GaUu602OcmkhiLzZutpoliNAISdXovzHjbfCDP7YHuxGDGiJqZt2/K30JGynCwP9yQcLuwW3svuUO9u/7PIlMB4MXX37eY4SQPPjZ/8r7PvYrWG4e5bkYEUOI809ZwgKjYPKwnn6uwHEcHGfxq0htDGpaPChVDiMKfoAfiAXiwUZjY4SNwZ498JwTD2LdRYQt2+axV6/nXdc8iLUmT1ySQFnYVh0LwxqUVhAbzi4ZMJqUNUHMrSzKuBKWtEjEDYHv4fk2wrbr19EwLRCSFCiUBVQwqEkgiMU0qdgYJb8HUeOXKOYGNZtznfM2+EhN24loHOteHPTELVKOIOfp0NlsGd750Y8te//z3/4aF117I1fcehcGQ6lUYmpiCqOTGGHNO7BYrqA0Zsgdryz8J4VAViQeAlRQIlAz4gE8ZaGCUCzo6ejDfPEgZt0Z16J4EEIwWerjleELeNOWN9Zk5EQpG9vy6rQ1MzvXo77oNSq+asAoUvZkKAzq+IpKBK5jY1kKz1cobKRt1eezK8CxBQnyFMqVTXIMnRNzFEbSSJmo6RjgOEHNNQyRt0H7s+7FgSUEe7rjPHKqgDFm1V/O1596lHg6y0XX3sjwqy8ST2foHtxGLBYjNzVFqSDQOo6Q04cYAUe/EWDqNKNkefFg0BqUCggCbzr6EIoHLxB4gUTrpcWDQMxOcWtIz3YdsCzJc4ffzPaeIdKJcquXUzVeYBNz6yUOZt6ier5RG8/bQBAKA7fOwmAuYS2CIQjCKIKx7HBuSx0mObq2wJgCRS+5okAQgOMIOlJjTJRiWDWoQNsyYFb/HYy8DdYG614cAOzujvH46SKBAWcVX8rR4WP85a/+zOzvpfwUv/7giwBIIclmO4gnPCYncmg/joy7aB+O/3P9p5ctjkBKkHJp8aC0RimFmhEPQUDgK8qBwFfzxYOZTVtYbSUejEjw5BtXc8vuR+sS/m0ma6HuYON4G4S1FSlripgrG17HIhA4toOUCs8PzZMs2wr3W8uuBbiOAfIUvQzSspYXCEKSSZbJl6bQuqOG2hKBG1+9S+KMt8H3fu/vrHobEY2n/Y9YdSDrWuzpjvH0SAltqi846h7cxi996fFlH+M6Lj2buigUinjK5+UvjDF6zCaZTND6A67AklbYmrVo1sKglEZphQrKBKqAChS+p/CUxFcCrecWSzoYYQEWNFE8SCkYGtvJ8ZFDbNt0cs0UJ4YuifVrx6x/G+P00PG18XLWSCgM0vYUrtN4YTCXc1EEn7KvQ3dFadX0Xoajng3G5Cj5mRUjAtKWdGUnOD2exq6gVXPxfULMKa7quTPeBjd90KKzs3OV24hoBhtCHAC8bXOSQ1M+457CpUEV/wbseJwOaTiW+yyFwiZKxXeSzW7Cdtr5pRZYlhVORHMWc22aFg9KEQRllF4oHsLIg5pJWeBghA3IuosH27LY/9p1DHR+BddeI+2NgmkjpPZFbghvA4PEJ23ncBy7JdIyjCLMWDD7KG3CK/4avhczo54NOTw/jVxGIISzETQpd5SS6kGspm9VCOJuGU/rqiydIfI2WEsIs16m21TA0SmfLxyaRGuDK5eft1Atxhg8bZBS8AO7smzPOHz729/mP/zr32PklffjxN5MJptZk8V0KxOKh5l0RSgiAnxf48+IB+zpqMMi4mHO7ItKxIPWhksHnuWqC55fI+kFQzI+zvZNw9Tjkt/Mhg7q9bdrbCuYFXDrk2lh4ORw7NYIg4UYQAUBZWWBsJBWbVEErQ1lz8JTqbCuYZn9+r7ixNnNWG68+v0ozSsHexnL3YBtVSd6JybG8Xt+jyde+8uohbHN2VDvzvaMw+1bUjx4PI+nDa6sTwRhVhgIwe1bUmzPhLH7W2+9lW/tfyt/+Id/yGd/7fcZPfshkpktJOLVfyHbmzmRB3eRyIMxBHpO5EHlUYHC8/V0q2YoGNR0m6bGhqXEgww7L14c2s2OvqP0ZCZpfdpmJUTVLol2zCWeTi96wl5MHCg/oDAxSfU+uSZ0+VzXXQoGC4+Uk8dtoxNS6GAYRhF838MPnJoGOc2MetblAoFOLikQBGG3Q2d6lPHiQNXFiWGkYtoIqZrMxIy3wUfeHAmDNcCGihzM8NxIiQeH8mhjcISo6epTG4NvzgmDPT2Ln/gPHz7Mv//4L/P0P1yJtG4n09GFba1tW+C6MSMeZnwepv/v+xovkARazooHM/2DsOlKneGuq795zmdC0NQccjVYssjFgwdZ6aif6urg1o98iO1XXh5eSVZBYXySZ//xm/zLP/xTFc8yWNJHrtDmu3Yx2JRJOQWcNj4hGUApRdkXaOlgW6vsaDDhMalYdlA6sWzaQAUBJ0c3oUW2KnFoNAyfTPL6sZtIJBIVP69YLDJS+Bv+7ukf5dJLL618hxEtoX2/LQ1kT0+cTtfi68dzjHsKacCu0nnQGENgQGPodC3u2JqejRgsxs6dO/nLz/9vvvKVr/BLP/NJJo78MG7qcjKp1AbI9a6AENiWhW1ZxBa52xiD0mFrplLFaXdJRbHgMzricMnWYwTKITAOgbFR2kEbe86IbVouHgK9soWytCze94s/R2ZTd9XCACDZmeXGD74PrRTPfOXBCp9l1nEhosGmRNotVR3+bjaCsJ5GyjCK4PmhL0LVUQRR+ahnaVt0pcc4PZmqqjhRSHBdH13lfIVSMc+2616LhMEaob2/MQ1ke8bhvks6+O6JAs+NlvGMAW2wpUCyuFAwxqCBQJtwGIoQXN0d522bk8QqCM0JIbj77ru59dZb+d3f/V3+/Le/w8jID5DODBCLLXZajIDwdbMt+/wDfJfhwJGruHz7QTZlyxgDRms0BqM1vrbwfRtfO/jKQRkH3zhobROY6bTFzD6m/9Mo8WCMhdFi2Su0rbsvo6O/t+Z97bnrHRWKg3AC47qcsGIMjiyScsprKkIXDnKysKctmJVwsOwqowji3KjnXFlgTGxRgSAQxOOaZHGMsu6uqjjRdVU4ZKpCznkb3FPxcyJay4YVBwAxS3Lb1jTX9SV4YbTMc6Ml8r4hMAYhmDfsRwoxa6KUdiV7uuPs7o6Rdas/8KTTaX75l3+Z97//JX72J3+JQ999BwXnbWSzHWHePqJCBIl0Pw8/fzXvvn5/2BFiydk0qAuQAIyHMWWMCQdbacKhWF5g4ysLXzsEyp0TebBRDRAPvnJwpb/k/b07t6GVWlXUYC6ZTd24iThesbTiY+V69DYwBlcWSLleRZMV25FZC2avhO87UK0FswhHPaecMnkPDEsIBCnpzExxYiRdVXFizAmqihzMeBu8732Rt8FaYUOLgxmyrsWNA0lu6E8wUlKcKQacLioKgSYwBlsIkrakL2HRm7DpiVtVT21bjDe96U185Ruf5/Of/zz/+WO/wfiZ+4inLiSVSrLuDtgNwnEchibezOGTB7lwy9jiVz8zRY0A1rkaKncmWLOIeNDK4CsLTzkE2jmXttAOytgofW4o1vQuVnQtDJSF6ywtDqRtU68SILlifj0sRFx3KQVjiMk8Sddfs8JghnODnBRlXxEIp7pBTiIc9ZwSZfJliRHueeL2nHPiKBOlyosTbVtjTKWOn5G3wVokEgdzsISgL2HTl7DZ3aR9Sin54Ac/yF133cWv//qv86XPfJdS8XvJdPTiLjFnIWI+2WyGb7/wVrZs2kcisbq+7fPEg8N0/UNoFWtMCWM0RoM2oXjwtI2vbALlhtEHHdY7BDhobZ1XSxK0mdeBEGp91bsYQ0zmSLrBmhcGc5k1T/I9vMBGWFVEEQRYliDpFsmXmZ7kuEAgCEk6WSZXymNMpsKPhMB1K3NJjLwN1ibtdbTawHR1dfE7v/M7/NAPPcXHfvI/M/z0u7HcG8h2ZNdIL3/rEEKAu4P9r17GzVe8gqx38dmseJDzIg+z4kGXMKaIQaP1dN2DNnjKwdMOSoV1D5bxsaWH0hbmvER/89/j1fjftC3GELdyJNwAS6wfYTDD7CAnvYpBTmJm1HOBXFkgFxn1bNmSrvQYZyeTWM7Kr58QEI8VKlp7oZDHHXyCW2/92YoeH9EeROKgzbj22mv5+nf+mj/90z/l937htxg9/WGSme1tYsPcviTicQ4cv55LB4/Sv8lr7hXxzLhsJHMvWEPxoDA6QOs8MWeU7mQOCA1rlLYItIU2NspIpFgi5XDgADz8MGzfDuPjcN99NS44tBBeN94GxpCwJkm4INehMJjL3EFOZW96HHQlg5wE2LYktcSoZ4EgEdPEnQk83bWyIZYQuHYZZczy3zVjKJdPRN4Ga5D1cnhYV9i2zU/8xE/wzed+m1s+9AUKhc8zOnKaIAhavbS2Jpvt4ZsH3oLvL53XbwVCCqS0UCq80pNChm2bDqRiiky8TGeiQML1zj/GT07Cxz4G998PV14Z/g6wb18oGD7zmVWuSbMuxKbRc4TBOvh7KmBmkFMippHGQwUqrFVZqVxFTI96juXRKjjv4cKSdGYmUWrlWgIBJBIeaoWixFK5hGc9yfvf//4VtxnRXkTioI0ZGBjgj//0f/LZr95Cx4X/hYnRx5mcmKxb0dp6w7IspoJLeOnoNoyqbd58vRFSoJVcxsBwiT6Ihx6CHTtCIQChSDhyBI4ehb17w2jCkSOLPNEs8RPety48j4wmtcGEwVwsaRF3JXHLw/jTvgMVCQRIuHm08uc9XACuDR3J0dD9cLnNCHAdH62Xf1yxmGfrtZG3wVokEgdrgLe//e089ORf8tH/PIyy/hujZw9SLK3cprYRSadTPPrKjUwV209AKSxWPnovoKMDrroqFAI7doRCYMcOeOYZ+MAHQpGwY8d5T9uUOk1X8gzZ2BgpZ5K4lcexSkjhIcV0BMosFA1rCKNIWRPEYrU5nK51BALbtknEQGofFQQYvXwUYWaSY8IpoJWaLxCkJJ0sAYUVnLgl8ZhPECwdOdBK43mv8UM/dneVf1VEOxCJgzVCLBbj537u5/jq0/+ePe/+HPmpf2Bs7CxKVedStv4RxNIDfPf5q1B+e6VhjLaqPw/v3Qujo2EaYd++UAxMToaC4ad+Cv7sz8KahAXYtkXChXQiIJss0ZXKsyk1QW/6LJuzx+jLnKA7eZqsO0rKmSBu5bBFEYkH6FA4tKl4EChS9iSxmESuh9RIHZBCEI9ZxO0AE3hotXwUQQiB6xriTv68KIFtS3rSo+E2lnp+BS6J57wN3lftnxPRBkQVImuMnTt38vkv/B++/OUv80s/82uMHfswseRlkQ3zHFzH5dDo1Rw7c5AdA7m2mTZosFaXEvrFX5z/+wMPwN13hxGDv/or+PKXw3qEJTg3DlhA4GPZNo5tTa8pwGgfMy0CjAaDRmlJoCwCFRpCBdpCaQttwgLK2XqF2Ze2Ga9xWEiZsqaIubJt52i0ivMsmAMHucwgp3CAkj5v1PNscWJxDE/3LPn9cV21TPoh9Da48QOSrq6u+vyBEU0lihysQYQQ3HPPPTz8zJ/xoZ8/gBd8lpGzxyh7lZqSrH+yHR388/M3USq3T/RAIFG6Dl+59743FAQPPxxGDSrsXjDaIGWAJec7P0opsKTEkha2beHYDnHXIp2AjlRAV6rIpswU/R1jDGTPsrljmN70CbpmIw+TxGYjD344mafukYdQGKTtSBishBQC17VJ2AEoj0DpJd8CIUOB4Nr5efUDwpJ0ZaZQwdLFvTEnWDJy6fsBnn4u8jZYw2zIqYzrjRdffJGf/clf4vAjtyEjG+ZZisUil/V9gxsvf71mS+J64PsBvR3DJOOLX21deNvd7PmBf1WVx/1iGK350s9+CL3gwK5UgGOXiC02Vnu1+zLhzBFDKAbC3zXBdORBTc+xUDr8dxh5sKgu8mCQ+KTtHI5jR7KgCrQx+L7GN9bS5kmzkxzteaOejdaM5+JMlfpmowoASIHs7cT0dnJcXUl2II2wBSYweOOa3JGAkwfGGJn8HZ549YGohXGNEr1r64DLL7+crz74f/nrv/5r/vPH/gvjZ3+EeOqCDW/DnEjEefbI9Vyy5Si9XUHL0y4SCAIJLC4OTr/4LOL9tQuDs2+8dJ4wCK+8/boPIRKz00znvrYWM96exgQY4y8iHix8JVHaQRkLpWzUdMoiFA/nkCISBqvl3CAnRdnTiw9ymp7kmIgFFEvF2VHPYXFikVwxdE6UHUnsqy7CueYSRDoBUnCBL5C2DCMTAowKoxEXBykcPsn+sx67u8WqZtBEtJYocrDOGB0d5T/9x1/nK3/iIsz3ku3oxdnANsyBUqTMk7z3xu+0/HXQKiAVO0NXtrzkY6764I9zwa3vRKugaqdHrRRaBXznD36FscOvzb9PayxRwI05bVXdvzDyoA1gNL6SBNrGokxKjhGYGIGJo4yLMi4gQ60npg2oWjiOe62gMQRegKed0DxpYRTBgFKaohdDE456NhjyfoL8W9+Ne92lYIUdN8ZXoDWebyMWXGMaDFgeqc44UkosIdjTHat4em1EexCJg3XK/v37+fhP/QbDT9+DHb+ObHbj2jBP5aa4+aJ/4PKdp2sO2deCURrXOUNvZ3HpBwnBlqvfyuBVbyHZvWl2veG31Cxpl6t8j7HDr3HksW+ROzV8/v2Bj+t4uO7aEIpKKxxG2dJxkmw2g1aaQAWoIMDzFSXPoujb+EECT8UIVIzAxFDaRTFXPIT9DLOzMyJQWlH2QS9mwWxAaU2+HAdiqK27KLzjblS2K2yRXNAB5PsWMP8zpY1GOgV6erowxhCYUJh0uhZ3bE2zPbM2PoMbnUgcrGOCIOBzn/scv/8L3yGYvI9UejuJjWjDbAy5iUP80C1fIpNuoTjQBkuM0N8zVfVVrjYaY/Sq8rehe16JWEzMK0ZsV5RSxMRZtnSepau7c9nHGqNRgUapgEApgiDA9xVFz6Hk2Xgqhq/i+MpFmVBAaOMwTzxMRx020rdCYwh8ha8tkAssmA2owDB28c0U335POITD89CLFNMGgYUx80/2SvukOyGZSJ7bnzH4xiCF4PYtKfb0VD4eOqI1ROJgA3DixAl+6ed/jYf+ahAp7iLb0bPhioTKnseW5EPcfvVzWE6L/nYDRo0y2DdR9alIaYUQBmsVQ6W0VliiSCzmtrrsYkWCQJGQp9jWM062o6Pm7WmtUUpNRx1CERFGHmyKZScUDjqGr9zptMWMeJhOVYjwpLlexYPSCs/nvEFOuUtuYPxt34cRErwyAtBGYMx8gaCUROlzg5yMMWgKbOrPIhcM7zDG4OlpgbA1EgjtTiQONhDf+ta3+Pc//WnGX30/TvxKMplM5bPh1wFjY6O899ovsLWv0DLvAxVMsKV35LwD50oEgULarGoUsVIeMTfAaXNBGASKlHWCrZtyZDKZpuxTa40KwqjDjIjwfU2xHEYezomH+GzaQhtnelLn+hAPBkMQBJR9G2FbeFsu4ey7PoIREuGVmRtpDFtx5/w+XVQ689drrXASJTo7Oxff14xAkIIf2JWNUgxtTCQONhilUok//MM/5I9+7VVM6YMkM1tIxDeGgtfaoEvP84Gb/4lYvDUHpcDLsbX/9CrEQYBly9k2s0ox2gAFYjGrrVMKfhCQsYfY2lsmnUq1ejmzaK0JgrCfXwWhePB8TansUPRcfO0S6Di+iuHrGNrEQpOoBeJhLTg5Kq0oiTinfuATqGwP+KVw1SbsdQEwRqDnRA+0FgSBixACA2hdpqPHIebGltyPMQbPhDUI913SERUptimRONigHDp0iI//21/iua9ejWW/g2y2a0N4IxQKBa4c/BrXX3pkfu92k/DKJbb1D1UdAfCDAMe2qo54NMLboJ4YIAh8ss5xtm3ySbaRMKiE+eIhjEB4vqZQdil7Dp6O4asYgQo7LQITwxh79n1sN/Fw+i3fx8Sbbga/PH9FcwSC1nKeWPD9UBxoY0Dm2NTXtWIcZaYG4eqeOLdtTTfor4mohUgcbGCMMezbt49f/pn/Rf74hzaIDbNhYmyYe2/6O3o6ddNrM72yx5be4zh2NcLE4AcKx7GqTAMZlCoTdw223X7CzxgIlEenc5StfZBIJFq9pLqjprss9HTUQSlFuazDgknfnS6WDKMOysRQxm2ZePBTnRz5gZ/HCIEMQrdVY8S8QkWDwBhmvSiMAc+PIYVA64B4JiCTriwl5GuDEPBjl3VGPghtSCQOIpiamuJ3fud3+MvfnUD4P0i6Y6BtrzTrQRAEZMR+7nnrozhNLk70fZ++zmESscq/dgaDChSOW91ajdYICsRiDrJN5kvMYAwEgUdP7DBb+mxi8aXD0OuZmVSFVhpfBahAUfYMJc+h5DvnxIOJoXQcpV0MVkPEw+hVdzJy9TsRXnG+/YHh3AXDtEDQWmCm3ffL3kzkoETXpgSOXVnKbia9cFN/khsHkis/IaKpROIgYpYXXniBn/up/8ShR24JbZg7OlZVALcWmJya5O2XfolLt59tqvdB4Ad0pU+QSVU+TVMbjda6aiGjlI9je8TazNsgjBiU6YkdYkufSyy2MYVBJcwrlgwUSgWUPcK0ReAQqBieihPoGMrMFQ/h88WcVs3lMEJy+P2/RJDMIv3Fx8HPRhFM+G9lwuJEz3MwCKSTp6enu6q/r6w0aVfy42/qwlrXEcu1RyQOIuahteav/uqv+C8f/3u8BTbMOy+2ue3uJJu32TVdiSplOPyazzf3FTg51JqR08YYCpMH+dCtf08y2bzogQoCMonTdGYqH5KltcZQnceBMQZ0iVi8vbwNtDFoVWZT7BCD/XHcdRyhagbz6x3CzouyJyh4DmU/Nht1CFSYtgi0C4uIB697C8fe+29BBYhlxjAffGY/pXyOYm6Sq+74frSRfOG3fp5tV7yFm37g++d5G1SCMgZl4L5LOuhLtHc3zUYjejci5iGl5Id/+Id55zvfya/+8if56uceoVR6Dx/8yC7+4x/0zQ7cqymKaUJflY9+vJOf+5HTPPXI0nbCjUIIgR3fymMv7+bWPS9gNanNTwhJoKrsOFjGGXHJ5xiDLRVStM/JVxuDUSX64gcZ7E9jt8pvYh1h23YoGheJvoTpqDJKFaZFRCgeip6g6Ll4vjtb75Dr3h22Li4jDMZODpHIZOkaGOTPf+VnuObO96GNYODCy5k4dZj4KrqeJBAYw5liEImDNqN9Liki2oru7m7+4L/9Lg/88/ey64ZP8Qv/dRNCgGULbEdg2zX8OAJpCSwbfvH3elr2N8ZiMV46cR2nRlOEpv6NRwhQOvSnrxSjq68RNSZA2qJtaku1NhhVpC/5BoMDkTBoBgKBbdvEYjFSqRTZbIau7i4GBzq5cHuSyy6wuPyCMlfsHCO7sxOLAMfysaSPJQKkCBAoBBqBYfzUEJsvvJSXHv1ndu25DjBYUnHpW99Bz9YtVbfnwrSttRCcLrYmghixNJE4iFiWG264gX3f+D+4brWV8itjWYL+QZsLLm1dTjyb7eTB526kvMAzvlEIIVBKViENpiMHVYRqjDZIESDbpF5Ea4PReQZSbzDYl91w7pztihDT4iEeI0j1YqSFFBJLSixLYFsCxzY4tsa2FJdcczW29HnxO19n9823YslpASE8Lrnh5tntPvRXf8Lz3/4az3/7axWtQxtDIVh8UmlE64jEQcSKNPpg3tnduo+hZVmUzIU8f3AnWjXhACUE2lhUX+pTuTjQRmNZui1qDbQ2oHMMpg+xub8Tqw1bKiNAi6UEejiOe+YKv1zIcfKNV9l+xbUUfENRW4yeOMzgrosB+NzHP8L197yfK269i2//5R9VvP8gKn1rOyIJH9FyWh36TqWS7D/0Fi7YPExXh2m494EylZ8gzUyMoYo1Cfy26DJRWmPpKQYyR+nr7aza3TGieUjjL3r7zDhtpSBQcPzoCToGtuKkuki6oW3y8LQb4vCrL5JIZ2f//ZP/428q3r/d6oNAxHlE39aICASJVD8Pv3ANQdD49ILRVsUlB2Zaq1Sa0jFaI4Rq+Yk4FAYTbM4epb+vq+XriViehDeOMBow4fAkrUOnR8+Q82yUkybe0UPflu1YloXruggEz3/7a1xx610ADL36PKMnjjE2fByAL/7ur1S0bykEyapMwSKaQRQ5iFg9Bw7Aww/D9u0wPg733dfqFa0ax3EYnriSwydf58ItYw32PrDQxlSozE1VkRVtFK5tWmp6pLTGZowtncP09HRtqOFea5FyuUz87Ivoze+h5Bl8DVgusXictBubJ+y6B7ez+5Y72L/v8yQyHQxefPnsfcXcVHjbJeFtQ68+z/CrL87+vhjGhGKkL9H6SFfEfCJxELE6JifhYx+Dr30NjhyBL385vH3fvvD/zzwDv/iL52779KfDx7YxmWyGf37hJgZ7/oFksnHiQAhBEFhUkn43pvI0hzEGQdDSvL7SGodRtnScrNoQJ6I5GKMplcoUi2WGz/o8c1zwUuIYF10hsVNddLjOsgWw7/zoxxa9vXvzVro3b5v9PZHpYPTEsWXFgSb8PvRGbYxtRxTLiVgdDz0EO3aEkQOA++8PRUBHB9xzD3R3wwMPhPfdcw8sMcK1nRBCINxt7H/1TagGpheEkAS6whO4qSKlYMLWMilaIw6UUricYVvnKXp6ulqyhojFUYEin89z+swojx0Y5Y+/lePXntjGs7v+DXf+p3/gf/7539GdTiAte9XDpy+89kZGTxyb/X3sxHEuvPbGZZ8TaEPKEfTEo8hBuxHJtYjV0dEBV10Fe/eGvx85EoqAGQ4fhg9/uBUrq4lEPM7zw9dxyZYjbN5Ubki1pBAQBBJYubfbGFNx/7gxCqtF3gZBoEjIU2ztGaejo7P5C4g4D8/zKJXKjOd8Xj6meHxIktv8Fm5757v5yTvuYHBwcN7j93THeeRUIYxAreJDlEhnueGee9m/7/MUc1Pc9RP/drZAcTFmomJ7uuORdXIbEomDiNWxdy98+9vn0ggdHWEkAcJowp49cOWVrVtfDWQz3XzrwFt4/9sexInV32FQCInWFrB4hfh5j6/gMaG3gY9swdjtIFCkrBNs6cmRzXY0ff8RIcYYvHKZYqnEiRHF80OaJ8+m6Lrq3dz5oTv5zVtuIZ1eejzy7u4Yj58uEhhwVnmunilOrITAgCUEu7uj2RrtSCQOIlbPTE3BXA4cgImJsDjxwIE1KRAsyyJXupjnj7zOVRcOIaz6Zt+EYDqtsLIPddjUsPKRWqNxpMaSTZ4yGSgy9hBbNxVJVziqN6J+aK0pFYsUih6HTgY8MwQve5t5063v4a777uL+a67BqlAwZl2LPd0xnh4poU3YRdCwdRuDxnB1dzwa19ymROIgon4cOQIf/WjYvfDpT58TDw8/DEePhlGGuamHNiadSvHE62/hwoG/I7t0ZHSVnHNJXO7wO+NxUNEx2gQVnwTqhR/4ZO3jbO31SaWWviKNqC+BH1AsFZnKebw0pHlqSHK66wr23vEe7vsPd7Jr165Vb/ttm5McmvIZ9xQulde7VIMxBt8YOl2Lt22ORjW3K9FUxoiWc/8PnuKZx5s/fGklPN+nL/YId177VN1nARh/jM1948tenWmj0UrjuMvv22gNFInHapuWWSkGCAKfTucoW/sMiUSi4fvc6JTLZUqlEmfGAw4c0zx5KoZz6a3c+c53c9ttt9FZx4Lfo1M+Xzg0idYGV4q6CgRjDJ4OW21/YFeW7Zn2GicecY4ochDRUrQ2HHylRMNtCVeB6zgcHruKY6cPsnPzJKKOJ15FZWmFSmoRtdG4Ns0RBgaCwKPLPcq2fkEsHgmDRqC1plwK6weOnlY8c9zw7FQPF918D3f+6zv58be+FcdpzIl1e8bh9i0pHjyex9MGV9YngjArDITg9i2pSBi0OVHkIKJlGGN47LvP8K9ufxU3sZtMOtN2hjnaGPz8K3xw75dJJOp3MPPLBbb1n1zWOVBphRAGy1pGwxuD1iXiMRqeVjAGAlWmJ3aILX0usUXGBEesniAIKJXK5AtlXh1SPHkMjsQv46Y77+GOO+7gsssua+r347mREg8O5dHG4AhRUw2Cnk4lzAiDPT3Vj3eOaC6ROIhoKaVSiU9/+tP88a8fhPIHSaU3r2oufCMpFotc2vsgN+1+rW7dAF65xLa+oWVP6EophMWycxK01lgUcONOQwvIjAGlSmyKHWawP4br1r+LYyNS9jzKxRIjUz4vHVPsP+Hgb7+J2991N7fffjt9fX0tXd/RKZ+vH88x7ikkAltUF0UwxhAY0IQ1BndsTUcRgzVCJA4i2oI33niDT/zcL3Lgq9djOW8nm+1qeoHd0hjGRk/z/hu/QF+3XxfvA7/ssXnTEO4yPWNBEGDZcvnogvKI2T6O27gDrjYGrcr0xt9gS38Ku0Hh7I3AjDthqVRi6IziwLDh6fEO+q99J3feeSd79+5tO3FcVprvnijw3GgZZQwYsKVAsrhQMMagCQ2OEGG74p7uGG/bnCRW586fiMYRiYOItsEYw5e+9CX+48/+bwpDP0IseQmZVKr1YxuBQCkS6ine97aHcJzar5p9P6C3Y5hkfOkx0X4Q4NhyyTkPxhjQRWJx2bDxzFobjC7SmzjEYH+64eO71yMqUJTKJfKFMm+c0Dx9HF5hB9fedg933nkne/bsWRODqSY9xQujZZ4bLZH3zaxZkp5zCpFCzN6ecgR7uuPs7o5F7YprkEgcRLQdk5OT/PZv/zZ//fs5RPCDpLP9xNogjD2Vy/G2C/6B3Recqnkwk/IDOlInyaaXdBDLTgAAE9VJREFUsmk2+IHCcawlw7hKKxxZxI25DSnnDIVBnoHUIQZ6O1o6s2Gt4XsexVKZiZzPy0MB+4/bjG26htveHdYPbN26tdVLXDXKGEZKijPFgNNFRSHQBMZgT09X7EtY9CZseuJW5Hy4honEQUTb8vzzz/Oxn/o1Dj76diznRjo6Olt7hWUMU5NH+OG9XySTrm0dWgWkYmfoyi7ewmkwBIHCdS2W6mhQqkzM1TgNOGlrbUDnGEgfYaCvoy2vbIWbInnlDxLbdQsy0V1Tw4vxS3hDT1E48DeoscPVP98YvLJHsVTk1GjA80Ow/1Sc7FV3cccdd/D2t7+dTCYyiYpYO0TiIKKt0VrzF3/xF/zGJ76MN/IjJNI7SSWTtKr10fM8BpLf4Y6rn8GqwfvAKI3rnKG3s7jo/St5HBhtgEJDvA2U1kg9xebMUfp6WyzIlkDYcbq+/7M4fZeBEIgK508sh9EBJigz+oWfIDjzyoqP11pTKpUoFMscPhXw7DAcyPWz+x3v5Y477uC6666L0jARa5ZIHESsCc6ePct/+o+/zj/+aRLBe8hmexvW570S4+Pj3HP137CtP79q7wOjDZYYob9natEpeFprDHrJk4tSAY5dqnu6RWmNpafYnA2FQT1Ouo0gfum76Lzrk3XfrtEBpTe+xcRX//2i9wd+QKlUZCrv8/KQ4qlhwVD6cm65873ceeedXHjhhXVfU0REK4jEQcSa4vHHH+fjP/WbnHz2e7Hj15DNZhvawrcYWhtU8QU+ePPXiK3W+8CAUaMM9k0sKg5Cj4OlvAsMWpWIuWDXMaWgtMY242zpGKKnp6vtPCfm0vE9v0L8snchGjBLQpdznP6ft87+PuNOODIR8PxxzZMnXLj4Fu5857u5/fbb6eqKxlNHrD+imFfEmuItb3kLDz7y1/zRH/0Rn/7l/8rY2ftIpreRSMRpVqpBSkFJXMAzBy/i+ssOIVfTniVAaWvJ8bhGG4S9+N+jtcGSGrmcOVKVKK1xzCiDnSfZ1NNdt+02CuGmKrOPXM22nQTFYpFiscTxMwFPH4MDuS523HgPd/6/d/KjN94Y+TxErHuiyEHEmmVoaIhf+Pe/yqP/dyfCupNsRzd2HU+Yy2MYHz3FB972N/R0qlW1WwZejq39p5GLnOSW8zhQyse1Pdw6eRsorXAZYUvnabq718ZVcOe7f5vYhW9vSNpDq4Cff9cFHItfwnXvuJu77rqLN73pTW0dSYmIqDeROIhY83zjG9/gP/z0f2fijXubasMcBAEpnuK9N34XZxXFiV65xLb+oUUdEEOPA+u8mobQ26BELC7q4m2glCImzrC1Z4TOjs6at9csGioOtObMmTP09/fXfdsREWuF9qw2ioiogu/5nu/hoace4Md/7Qg+f8joyGFKpVLD92vbNmeKl/Pa8f7pyYjVItF6kZTC9KjmxbIkxmikVItGG6olCBQJeZLtm8bXlDBYkgMH4DOfCUeDP/DAqjcjpYyEQcSGJxIHEeuCRCLBJz7xCb7y1Me44q7/QW5yH2NjZ1FKNXS/mXSa77x0I/li9QE4IQWBOj9qYELX2SVqERSWLWs2jfQDRdoeZvumHNnsOui/n5yEj30M7r8frrwy/B1CoXDXXfMf+8lPhrd/5jPNX2dExBohEgcR64oLL7yQv/m7v+C3/voC4r2/wdjIs+RyufCM2wCEEDiJLTz28hUofym3wyWeiyAIFvsKmsWjBtogpV+z74AfBGTtY2zrLZLOpGvaVtvw0EOwYwc8/HD4+/33h/+/5x7o7Dz3uH37YOfO8PZs9tzjIyIi5hGJg4h1hxCC973vfXz72T/m3o8/SSn4I0ZHjuN5XkP2F4vFeOXktZwYzUybE1W6zrBj4TzM4vWN2igsy6y61sAAfuDT6Rxle19AKpVa1Xbako4OuOoq2Ls3FAlHjiz+uPHxc1EFCFMRERER5xGJg4h1Szab5ZOf/CRfeOTH2HnDp5gcf5Dx8dHQGrjOdHR08q0Db8GrInoghCRQ538FF29vNECw7Pjm5TAGgsCjyz3C1n5NIplY1Xbahdm6jBn27oXR0TAysG8fHD26+BPvuy983MMPw3PPNX6hERFrlMjnIGLdc+WVV/Llb/7FtA3zbzB29keJp3fU1YZZSkmei3j24Otcd8nRirwPzkUOzLx1GMN5xk6ho6JCrsL0xxgIVJme2GG29DrE4rGqt9EOhO6EJaYKHsG4x5aFD/jFX6xsQz/902FK4cABuPvuei8zImJdEEUOIjYElmXx4Q9/mG8f+G/c+ZF/pFT8S0ZGTuD7ft32kUomePLgW5iYslh4YbsYQgiUkuc91GDOkyzaKKRF1XMUjAGlSvTGDrGl311zwqBcLjM5McHBYyP84/4xfvsbAX944lYYuJKKhN3DD4dRhH37wt8nJ8NOhn37YPv2MAURERFxHpHPQcSG5LHHHuPjP/WbnDrwPpzYtWSymbrYMAe+T4f1BHe/5XHsCrwPdDDOYO/ovNbEhR4H57wNqCqtoI1BqzK98YMM9iVw1oCrnzGaUqlMsVjm+Fmf544LnhrPsPPG93DnnXdy0003EYutLYETEbEWicRBxIbF9/1pG+Yn0Ln62TBPTkxy2+4vcvHWUcQKxYO+P8W2vjOz4mBmVLPjWLN1B1prLFEgFnMrbmHU2mB0kd7EIQb70hUJlVahgoBSuUy+UOaNE5onjxsOWhdy3W33cNddd7F79+7InTAioslE4iBiwzM0NMTP/7tf4bG/2TVtw9yDvejAo8owxlCcep0fvuUfSCaXPyl75QLb+0/OtieGV/tq3qhmpTxiro9jV2aXPCMM+pMHGejLtOXYYM/zKJXKjE95vHxc8/iwJL/5rdz2zndzxx13sHnz5lYvMSJiQxOJg4iIab7+9a/zH/7Nf2fyjQ/gJq4gk06v+oq1VCpxQdc/s/fKF7GWOTl75TJb+47PihFtNMacG9UctkYWicVkRS2MWhvQOQbSR+jv7cBazVCoBmCMoVwuUSqVOTES8PyQ4cmRNN1X3cWdd97JLbfcsr5aKyMi1jiROIiImEOxWORTn/oUn/svh6H8QVLpzcTj8VVta3TsLN9//RcY3FSCJQoJfc+jv2uYmTpBpRVgZsWBUgrHKhKLrVwvoLRG6ByD6SP09XXWbJZUK1ppiqUixaLHwZMBzw7B88E29tzybu666y6uvvrqJUZSR0REtJpIHERELMLrr7/Ov/vYL3Hgq2/Fcm4hm+2s+kSmlEJ6B7j35m/gLHFyD/yAnuwwqYSefY6QzO5LqxIx12Dby+9baY2lp9icPUpfb2dDBhJVQuD7FEslJnMeLw9pnhqSnOm+kr13hAWFO3fubMm6IiIiqiMSBxERS2CM4Ytf/CK/+rN/QeHEh4knLyKdTlFNwWI+n+fabV/l6ouPI+aE+I2U6J4egp4enMEUdkcaY1mYwMcpTREbHyZ29hju2CESrli2hTEUBuNs6RxiU09X04v3yqUyxXKRs+MBB44ZnjoVx7nsVu5619284x3voKOjo6nriYiIqJ1IHERErMDk5CS/+Zu/yd/8gQfB95Hp6MOtuC3QMDk2xAf3/h2dGYPOZgh278bfsweTSoEQCKNBSmbNEYwGIRFGYxfH6Tn4XboOPopbGDtv60prHEYZzJ5g06buuv3Ny6G1plwqUyiVOHZa8cxxw3O5TVx08z3ceeedvOUtb8FxKiuejIiIaE8icRARUSHPPfccH/+pT3Lo8dux3RvJZjsqMiXyfZ9N2f3c9m9SqKuvAsua8TMGrRFopJz/NTQAUmJsB4FA6IDu17/DwHNfwgrCcdRKKxxG2dp5iu7urvr/wXMIgml3wrzH68MBTx4XHI2/iZvuDAXBJZdcErUbRkSsIyJxEBFRBUop/vzP/5zf/HdfIxj9MPH0TlLJBMulGnp2Sy7/CYuOLSCNAt9f8OjzxQGAmJ7AZABjuSAlbu4MW5/4cxInXiImzrK1+yydc6cO1pFyuUy5VGZk0uel44rHT7joHTdx+7vu5vbbb6e3t7ch+42IiGg9kTiIiFgFZ86c4Vd+6df4xv/pBO4hm+1ZNJS+7XaL3R9xkRb4xYCEXVrEyMggpT7vuWLBeEYjBMaOgVZsf/J/cM3Y35DtyNbtb5p1JyyVGT7jc2AYnhztYMsN7+LOO+/k5ptvXnXnRkRExNoiEgcRETXw6KOP8vGf+h1OP/9e3Ni1pOfYMG+73eKKHw9dDYNiOEfQkmVi9vzJjQaDdZ44MNO6QJz3WOPEkCjecuizXHzqn2pavwoUpXJp1p3w6ePwqtjJdbe/hzvuuIMrr7yy5S2RERERzScSBxERNeL7Pp/97Gf5b7/8L6j8h0ilt7D1uiTX/0IcKUNhMIM2mrhTwpqTRlhMHCyMGsw8UqCQEpSdRBrFbS/9KgMTB6pa74w74UTO56VjiieHLcb7r591J9yy5bx5hxERERuMSBxERNSJ48eP8/P/7lf4l69ezt2f/SDpQQdVOL/QUOATd73ZmEAYUVDzHnV+1CAUBpYMpzkaILCSpMsnufvZn8VRxSXXZYzBK3sUS0VOjQY8d9zwL2eSZKfdCW+99VbS6XQ9XoKIiIh1QiQOIiLqzOe++wLDsgM/LzDGPm/aozYG1y7jWKEgWFkczBcG5x4lCew4l57Yx/WH/nj+PrSmVCxSKHkcPhXw9DF4sTTA7ne8lzvvvJNrr702cieMiIhYkvabyBIRsYaZ9BSTmQGSxlAmTzFXRusEQlqzp3opBF7gYEk166ps5mQRxJz/hhJAEZ7H54sMgUZoxev9d3H50BeJ5U9SKhWZzHm8MqzZf1xwsmM3t9z5Xj70iTu54IILGv3nR0RErBMicRARUUdeGC2jjMEVAjedIZEImJyYIig7GBFDCIEAhLDwAoeY408/UxDGEMwcDWCQBFiWYKlWSUuX8K0kT7hvZeqf/5THT8SwL7mdO9/7bn7pttvo6mqs/0FERMT6JEorRETUCWUMf/zSGDlPE5s3DdFQLJXITRYxKgnCQgqBNoaYU8SSBik0QpjpQsTwWUsJA2MMBoNSEChQbgrhl7mJE7ztxhsjd8KIiIiaiSIHERF1YqSkyPsG+zzXREEiniAWi5HL5Xj1sccp5TzKhSn23P4+Em6ZL/z2L3DBVddz7V3vBUCKAEvOCAODMaEoCBT4GhQ2TixGLBVDWhbKpLj8kl04TvSVjoiIqJ2ogTkiok6cLgZoY5b8UkkhCaYm6N3az+ZLtrP/S3+CMRJf2Wy+6E2MnTwOwiBFgBQCYwxKacq+IVc25JULsQypzk10dfeQTqVxbAdJ+NgzxWCJPUdERERURyQOIiLqxJmiQgqx7IyB0RPH2fGmPQwdeIKLrr0BZB4vkFzy1tvoGhhEojAGSr5hqiwoEsdKdNLR00dnZxeJRBJLzu8yENP7PF1US+w1IiIiojoicRARUSfygUavUMJz0bU3AnDgn7/KVbffw6beLG6ihB9otuy+mlwg+evf+jWMcOjs6aUj20EsFkOsMCZaG0MhON+COSIiImI1RAnKiIg6oSqs7S3mJhl+7cVZodDV2cWxZx7n8r3fw+SpE7zy6Df5/R/ZD0ApP8VdP/Fz3PLBj6y43SCqLY6IiKgTkTiIiKgTVoUji8eGj9O9edu826QQ2JbN6Inj/OLfP0YiHQ5U2r/v81x/z70VbdeORiZHRETUiUgcRETUiZQtz3NDXIx4OjPv9+e//TWuuPUu4FzaAUJhcMXb31nRvqUQJO0oSxgREVEfInEQEVEnehMW2phpt8OlRUL34DZ233IH+/d9nkSmg8GLLz/vMaPDxyjmpmYjCMthjMEYQ18iskOOiIioD5E4iIioE32JcI6CBlY6Tb/zox9b9v4n9v01F137tor2qwnFSG8i+jpHRETUhygOGRFRJ3riFilHEOjaCwNfeOjrdG/eWtFjA21IOYKeeBQ5iIiIqA+ROIiIqBOWEOzpjoMIQ/21EE9nSGQ7VnycMaHd8p7ueMUFkRERERErEc1WiIioI5Oe4nMvj2MMOOfZKNcfX4fjnX/ssk6ybhQ5iIiIqA9R5CAioo5kXYs93TE0ZkVDpFrRxqAx7OmORcIgIiKirkTiICKizrxtc5JO18Kf7iJoBMYYfGPodC3etjnZkH1ERERsXCJxEBFRZ2KW5I6taaQQeLr+AsEYg6cNUgju2JpeMB46IiIionaio0pERAPYnnG4fUuq7gJhrjC4fUuK7RmnLtuNiIiImEvUGB0R0SD29MQBeHAoj2cMDlTkoLgUejqVIGUoDGa2HxEREVFvom6FiIgGc3TK5+vHc4x7ConAFss7KC7EGENgQBPWGNyxNR1FDCIiIhpKJA4iIppAWWm+e6LAc6PlcHqjAVv+f+3dQUoDQRCG0eokotGlKHiGHMH7X0DIJRSzEDRRZ9Iuxgg/uHXcvLfsE3zQ1dWtFvV7KPTe61jTgqNqpx0K53V/d2nGAPhz4gBm9PIx1nb3Xg+7Q71+TrMIrbV49rho7ef86mxarLTxXBGYkTiAfzD2Xs+HsZ72Qz3ux3objjX0Xqvv3xVv18u6Wa/q+mJp8yEwO3EAAASXlwBAEAcAQBAHAEAQBwBAEAcAQBAHAEAQBwBAEAcAQBAHAEAQBwBAEAcAQBAHAEAQBwBAEAcAQBAHAEAQBwBAEAcAQBAHAEAQBwBAEAcAQBAHAEAQBwBAEAcAQBAHAEAQBwBAEAcAQBAHAEAQBwBAEAcAQBAHAEAQBwBAEAcAQBAHAEAQBwBAEAcAQPgCxrTVhwsEi90AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - The complex has 8 0-cells.\n", + " - The 0-cells have features dimension 1\n", + " - The complex has 28 1-cells.\n", + " - The 1-cells have features dimension 1\n", + " - The complex has 54 2-cells.\n", + " - The 2-cells have features dimension 1\n", + " - The complex has 54 3-cells.\n", + " - The 3-cells have features dimension 1\n", + "\n", + "\n", + "Dataset contains 5 samples.\n", + "\n", + "Providing more details about sample 2/5:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Graph with 8 vertices and 12 edges.\n", + " - Features dimensions: [1, 0]\n", + " - There are 0 isolated nodes.\n", + "\n", + "\n", + "Dataset contains 5 samples.\n", + "\n", + "Providing more details about sample 2/5:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - The complex has 8 0-cells.\n", + " - The 0-cells have features dimension 1\n", + " - The complex has 28 1-cells.\n", + " - The 1-cells have features dimension 1\n", + " - The complex has 55 2-cells.\n", + " - The 2-cells have features dimension 1\n", + " - The complex has 60 3-cells.\n", + " - The 3-cells have features dimension 1\n", + "\n", + "\n", + "Dataset contains 5 samples.\n", + "\n", + "Providing more details about sample 3/5:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Graph with 8 vertices and 12 edges.\n", + " - Features dimensions: [1, 0]\n", + " - There are 0 isolated nodes.\n", + "\n", + "\n", + "Dataset contains 5 samples.\n", + "\n", + "Providing more details about sample 3/5:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - The complex has 8 0-cells.\n", + " - The 0-cells have features dimension 1\n", + " - The complex has 28 1-cells.\n", + " - The 1-cells have features dimension 1\n", + " - The complex has 56 2-cells.\n", + " - The 2-cells have features dimension 1\n", + " - The complex has 64 3-cells.\n", + " - The 3-cells have features dimension 1\n", + "\n", + "\n", + "Dataset contains 5 samples.\n", + "\n", + "Providing more details about sample 4/5:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Graph with 8 vertices and 12 edges.\n", + " - Features dimensions: [1, 0]\n", + " - There are 0 isolated nodes.\n", + "\n", + "\n", + "Dataset contains 5 samples.\n", + "\n", + "Providing more details about sample 4/5:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - The complex has 8 0-cells.\n", + " - The 0-cells have features dimension 1\n", + " - The complex has 28 1-cells.\n", + " - The 1-cells have features dimension 1\n", + " - The complex has 56 2-cells.\n", + " - The 2-cells have features dimension 1\n", + " - The complex has 66 3-cells.\n", + " - The 3-cells have features dimension 1\n", + "\n" + ] + } + ], + "source": [ + "for i in range(5):\n", + " describe_data(dataset, i)\n", + " describe_data(lifted_dataset, i)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}