From f2f1bccf639cea93851e7b54f1f90cc58874de70 Mon Sep 17 00:00:00 2001 From: "Rose K. Cersonsky" <47536110+rosecers@users.noreply.github.com> Date: Tue, 5 Mar 2024 15:24:13 -0600 Subject: [PATCH 1/7] Making rascaline edits --- anisoap/reference/projection_coefficients.py | 26 ++-- .../ellipsoidal_density_projection.py | 116 +++++++++--------- anisoap/representations/radial_basis.py | 16 +-- anisoap/utils/metatensor_utils.py | 6 +- 4 files changed, 81 insertions(+), 83 deletions(-) diff --git a/anisoap/reference/projection_coefficients.py b/anisoap/reference/projection_coefficients.py index 48c6f8f..0ec09d7 100644 --- a/anisoap/reference/projection_coefficients.py +++ b/anisoap/reference/projection_coefficients.py @@ -95,26 +95,26 @@ def transform(self, frames, show_progress=False): """ self.frames = frames - # Generate a dictionary to map atomic species to array indices - # In general, the species are sorted according to atomic number + # Generate a dictionary to map atomic types to array indices + # In general, the types are sorted according to atomic number # and assigned the array indices 0, 1, 2,... # Example: for H2O: H is mapped to 0 and O is mapped to 1. - species = set() + types = set() for frame in frames: for atom in frame: - species.add(atom.number) - species = sorted(species) - self.species_dict = {} + types.add(atom.number) + types = sorted(types) + self.types_dict = {} for frame in frames: - # Get atomic species in dataset - self.species_dict.update( - {atom.symbol: species.index(atom.number) for atom in frame} + # Get atomic types in dataset + self.types_dict.update( + {atom.symbol: types.index(atom.number) for atom in frame} ) # Define variables determining size of feature vector coming from frames self.num_atoms_per_frame = np.array([len(frame) for frame in frames]) num_atoms_total = np.sum(self.num_atoms_per_frame) - num_particle_types = len(self.species_dict) + num_particle_types = len(self.types_dict) num_features_total = (self.max_angular + 1) ** 2 # Initialize arrays in which to store all features @@ -144,10 +144,10 @@ def _transform_single_frame(self, frame): # Define useful shortcuts lmax = self.max_angular num_atoms = len(frame) - num_chem_species = len(self.species_dict) - iterator_species = np.zeros(num_atoms, dtype=int) + num_chem_types = len(self.types_dict) + iterator_types = np.zeros(num_atoms, dtype=int) for i, symbol in enumerate(frame.get_chemical_symbols()): - iterator_species[i] = self.species_dict[symbol] + iterator_types[i] = self.types_dict[symbol] # Get the arrays with all # TODO: update with correct expressions diff --git a/anisoap/representations/ellipsoidal_density_projection.py b/anisoap/representations/ellipsoidal_density_projection.py index b65fbff..33c3c19 100644 --- a/anisoap/representations/ellipsoidal_density_projection.py +++ b/anisoap/representations/ellipsoidal_density_projection.py @@ -23,7 +23,7 @@ def pairwise_ellip_expansion( lmax, neighbor_list, - species, + types, frame_to_global_atom_idx, rotation_matrices, ellipsoid_lengths, @@ -40,14 +40,14 @@ def pairwise_ellip_expansion( Maximum angular neighbor_list : Equistore TensorMap - Full neighborlist with keys (species_1, species_2) enumerating the possible species pairs. + Full neighborlist with keys (types_1, types_2) enumerating the possible types pairs. Each block contains as samples, the atom indices of (first_atom, second_atom) that correspond to the key, and block.value is a 3D array of the form (num_samples, num_components,properties), with num_components=3 corresponding to the (x,y,z) components of the vector from first_atom to second_atom. - Depending on the cutoff some species pairs may not appear. Self pairs are not present but in PBC, + Depending on the cutoff some types pairs may not appear. Self pairs are not present but in PBC, pairs between copies of the same atom are accounted for. - species: list of ints + types: list of ints List of atomic numbers present across the data frames frame_to_global_atom_idx: list of ints @@ -66,7 +66,7 @@ def pairwise_ellip_expansion( Show progress bar for frame analysis and feature generation ----------------------------------------------------------- Returns: - An Equistore TensorMap with keys (species_1, species_2, l) where ("species_1", "species_2") is key in the + An Equistore TensorMap with keys (types_1, types_2, l) where ("types_1", "types_2") is key in the neighbor_list and "l" is the angular channel. Each block of this tensormap has the same samples as the corresponding block of the neighbor_list. block.value is a 3D array of the form (num_samples, num_components, properties) where num_components @@ -79,13 +79,13 @@ def pairwise_ellip_expansion( keys = [tuple(i) + (l,) for i in keys for l in range(lmax + 1)] num_ns = radial_basis.get_num_radial_functions() maxdeg = np.max(np.arange(lmax + 1) + 2 * np.array(num_ns)) - for center_species in species: - for neighbor_species in species: - if (center_species, neighbor_species) in neighbor_list.keys: + for center_types in types: + for neighbor_types in types: + if (center_types, neighbor_types) in neighbor_list.keys: values_ldict = {l: [] for l in range(lmax + 1)} nl_block = neighbor_list.block( - species_first_atom=center_species, - species_second_atom=neighbor_species, + first_atom_type=center_types, + second_atom_type=neighbor_types, ) for isample, nl_sample in enumerate( @@ -93,13 +93,13 @@ def pairwise_ellip_expansion( nl_block.samples, disable=(not show_progress), desc="Iterating samples for ({}, {})".format( - center_species, neighbor_species + center_types, neighbor_types ), leave=False, ) ): frame_idx, i, j = ( - nl_sample["structure"], + nl_sample["system"], nl_sample["first_atom"], nl_sample["second_atom"], ) @@ -158,7 +158,7 @@ def pairwise_ellip_expansion( pairwise_ellip_feat = TensorMap( Labels( - ["species_center", "species_neighbor", "angular_channel"], + ["types_center", "types_neighbor", "angular_channel"], np.asarray(keys, dtype=np.int32), ), tensorblock_list, @@ -166,17 +166,17 @@ def pairwise_ellip_expansion( return pairwise_ellip_feat -def contract_pairwise_feat(pair_ellip_feat, species, show_progress=False): +def contract_pairwise_feat(pair_ellip_feat, types, show_progress=False): """ Function to sum over the pairwise expansion \sum_{j in a} = -------------------------------------------------------- Parameters: pair_ellip_feat : Equistore TensorMap - TensorMap returned from "pairwise_ellip_expansion()" with keys (species_1, species_2,l) enumerating - the possible species pairs and the angular channels. + TensorMap returned from "pairwise_ellip_expansion()" with keys (types_1, types_2,l) enumerating + the possible types pairs and the angular channels. - species: list of ints + types: list of ints List of atomic numbers present across the data frames show_progress : bool @@ -184,24 +184,24 @@ def contract_pairwise_feat(pair_ellip_feat, species, show_progress=False): ----------------------------------------------------------- Returns: - An Equistore TensorMap with keys (species, l) "species" takes the value of the atomic numbers present + An Equistore TensorMap with keys (types, l) "types" takes the value of the atomic numbers present in the dataset and "l" is the angular channel. - Each block of this tensormap has as samples ("structure", "center") yielding the indices of the frames - and atoms that correspond to "species" are present. + Each block of this tensormap has as samples ("type", "center") yielding the indices of the frames + and atoms that correspond to "types" are present. block.value is a 3D array of the form (num_samples, num_components, properties) where num_components take on the same values as in the pair_ellip_feat_feat.block . block.properties now has an additional index - for neighbor_species that corresponds to "a" in + for neighbor_types that corresponds to "a" in """ ellip_keys = list( set([tuple(list(x)[:1] + list(x)[2:]) for x in pair_ellip_feat.keys]) ) - # Select the unique combinations of pair_ellip_feat.keys["species_center"] and + # Select the unique combinations of pair_ellip_feat.keys["types_center"] and # pair_ellip_feat.keys["angular_channel"] to form the keys of the single particle centered feature ellip_keys.sort() ellip_blocks = [] property_names = pair_ellip_feat.property_names + [ - "neighbor_species", + "neighbor_types", ] for key in tqdm( @@ -210,18 +210,18 @@ def contract_pairwise_feat(pair_ellip_feat, species, show_progress=False): contract_blocks = [] contract_properties = [] contract_samples = [] - # these collect the values, properties and samples of the blocks when contracted over neighbor_species. - # All these lists have as many entries as len(species). + # these collect the values, properties and samples of the blocks when contracted over neighbor_types. + # All these lists have as many entries as len(types). for ele in tqdm( - species, + types, disable=(not show_progress), - desc="Iterating neighbor species", + desc="Iterating neighbor types", leave=False, ): - selection = Labels(names=["species_neighbor"], values=np.array([[ele]])) + selection = Labels(names=["types_neighbor"], values=np.array([[ele]])) blockidx = pair_ellip_feat.blocks_matching(selection=selection) - # indices of the blocks in pair_ellip_feat with neighbor species = ele + # indices of the blocks in pair_ellip_feat with neighbor types = ele sel_blocks = [ pair_ellip_feat.block(i) for i in blockidx @@ -237,24 +237,24 @@ def contract_pairwise_feat(pair_ellip_feat, species, show_progress=False): continue assert len(sel_blocks) == 1 - # sel_blocks is the corresponding block in the pairwise feat with the same (species_center, l) and - # species_neighbor = ele thus there can be only one block corresponding to the triplet (species_center, species_neighbor, l) + # sel_blocks is the corresponding block in the pairwise feat with the same (types_center, l) and + # types_neighbor = ele thus there can be only one block corresponding to the triplet (types_center, types_neighbor, l) block = sel_blocks[0] pair_block_sample = list( - zip(block.samples["structure"], block.samples["first_atom"]) + zip(block.samples["system"], block.samples["first_atom"]) ) - # Takes the structure and first atom index from the current pair_block sample. There might be repeated + # Takes the system and first atom index from the current pair_block sample. There might be repeated # entries here because for example (0,0,1) (0,0,2) might be samples of the pair block (the index of the - # neighbor atom is changing but for both of these we are keeping (0,0) corresponding to the structure and + # neighbor atom is changing but for both of these we are keeping (0,0) corresponding to the system and # first atom. - struct, center = np.unique(block.samples["structure"]), np.unique( + struct, center = np.unique(block.samples["system"]), np.unique( block.samples["first_atom"] ) possible_block_samples = list(product(struct, center)) - # possible block samples contains all *unique* possible pairwise products between structure and atom index + # possible block samples contains all *unique* possible pairwise products between system and atom index # From here we choose the entries that are actually present in the block to form the final sample block_samples = [] @@ -290,20 +290,20 @@ def contract_pairwise_feat(pair_ellip_feat, species, show_progress=False): block.values[sample_idx].sum(axis=0) ) # sum over "j" for given ele - # block_values has as many entries as samples satisfying (key, neighbor_species=ele). - # When we iterate over neighbor species, not all (structure, center) would be present - # Example: (0,0,1) might be present in a block with neighbor_species = 1 but no other pair block + # block_values has as many entries as samples satisfying (key, neighbor_types=ele). + # When we iterate over neighbor types, not all (type, center) would be present + # Example: (0,0,1) might be present in a block with neighbor_types = 1 but no other pair block # ever has (0,0,x) present as a sample- so (0,0) doesnt show up in a block_sample for all ele # so in general we have a ragged list of contract_blocks contract_blocks.append(block_values) contract_samples.append(block_samples) contract_properties.append([tuple(p) + (ele,) for p in block.properties]) - # this adds the "ele" (i.e. neighbor_species) to the properties dimension + # this adds the "ele" (i.e. neighbor_types) to the properties dimension # print(len(contract_samples)) all_block_samples = sorted(list(set().union(*contract_samples))) - # Selects the set of samples from all the block_samples we collected by iterating over the neighbor_species + # Selects the set of samples from all the block_samples we collected by iterating over the neighbor_types # These form the final samples of the block! all_block_values = np.zeros( @@ -316,9 +316,9 @@ def contract_pairwise_feat(pair_ellip_feat, species, show_progress=False): # Create storage for the final values - we need as many rows as all_block_samples, # block.values.shape[1:] accounts for "components" and "properties" that are already part of the pair blocks # and we dont alter these - # len(contract_blocks) - adds the additional dimension for the neighbor_species since we accumulated + # len(contract_blocks) - adds the additional dimension for the neighbor_types since we accumulated # values for each of them as \sum_{j in ele} <|rho_ij> - # Thus - all_block_values.shape = (num_final_samples, components_pair, properties_pair, num_species) + # Thus - all_block_values.shape = (num_final_samples, components_pair, properties_pair, num_types) indexed_elem_cont_samples = {} for i, val in enumerate(all_block_samples): @@ -337,8 +337,8 @@ def contract_pairwise_feat(pair_ellip_feat, species, show_progress=False): leave=False, ) ): - # This effectively loops over the species of the neighbors - # Now we just need to add the contributions to the final samples and values from this species to the right + # This effectively loops over the types of the neighbors + # Now we just need to add the contributions to the final samples and values from this types to the right # samples nzidx = list( sorted( @@ -350,7 +350,7 @@ def contract_pairwise_feat(pair_ellip_feat, species, show_progress=False): ) ) - # identifies where the samples that this species contributes to, are present in the final samples + # identifies where the samples that this types contributes to, are present in the final samples # print(apecies[ib],key, bb, all_block_samples) all_block_values[nzidx, :, :, iele] = contract_blocks[iele] @@ -358,9 +358,7 @@ def contract_pairwise_feat(pair_ellip_feat, species, show_progress=False): values=all_block_values.reshape( all_block_values.shape[0], all_block_values.shape[1], -1 ), - samples=Labels( - ["structure", "center"], np.asarray(all_block_samples, np.int32) - ), + samples=Labels(["type", "center"], np.asarray(all_block_samples, np.int32)), components=block.components, properties=Labels( list(property_names), @@ -371,7 +369,7 @@ def contract_pairwise_feat(pair_ellip_feat, species, show_progress=False): ellip_blocks.append(new_block) ellip = TensorMap( Labels( - ["species_center", "angular_channel"], + ["types_center", "angular_channel"], np.asarray(ellip_keys, dtype=np.int32), ), ellip_blocks, @@ -495,7 +493,7 @@ def transform(self, frames, show_progress=False, normalize=True): Parameters ---------- frames : ase.Atoms - List containing all ase.Atoms structures + List containing all ase.Atoms types show_progress : bool Show progress bar for frame analysis and feature generation normalize: bool @@ -508,26 +506,26 @@ def transform(self, frames, show_progress=False, normalize=True): """ self.frames = frames - # Generate a dictionary to map atomic species to array indices - # In general, the species are sorted according to atomic number + # Generate a dictionary to map atomic types to array indices + # In general, the types are sorted according to atomic number # and assigned the array indices 0, 1, 2,... # Example: for H2O: H is mapped to 0 and O is mapped to 1. num_frames = len(frames) - species = set() + types = set() self.num_atoms_per_frame = np.zeros((num_frames), int) for i, f in enumerate(self.frames): self.num_atoms_per_frame[i] = len(f) for atom in f: - species.add(atom.number) + types.add(atom.number) self.num_atoms_total = sum(self.num_atoms_per_frame) - species = sorted(species) + types = sorted(types) # Define variables determining size of feature vector coming from frames self.num_atoms_per_frame = np.array([len(frame) for frame in frames]) - num_particle_types = len(species) + num_particle_types = len(types) # Initialize arrays in which to store all features self.feature_gradients = 0 @@ -570,7 +568,7 @@ def transform(self, frames, show_progress=False, normalize=True): pairwise_ellip_feat = pairwise_ellip_expansion( self.max_angular, self.nl, - species, + types, self.frame_to_global_atom_idx, rotation_matrices, ellipsoid_lengths, @@ -579,7 +577,7 @@ def transform(self, frames, show_progress=False, normalize=True): show_progress, ) - features = contract_pairwise_feat(pairwise_ellip_feat, species, show_progress) + features = contract_pairwise_feat(pairwise_ellip_feat, types, show_progress) if normalize: normalized_features = self.radial_basis.orthonormalize_basis(features) return normalized_features diff --git a/anisoap/representations/radial_basis.py b/anisoap/representations/radial_basis.py index 87d560d..673ba2b 100644 --- a/anisoap/representations/radial_basis.py +++ b/anisoap/representations/radial_basis.py @@ -313,13 +313,13 @@ def orthonormalize_basis(self, features: TensorMap): # In-place modification. for label, block in features.items(): - # Each block's `properties` dimension contains radial channels for each neighbor species - # Hence we have to iterate through each neighbor species and orthonormalize the block in subblocks + # Each block's `properties` dimension contains radial channels for each neighbor types + # Hence we have to iterate through each neighbor types and orthonormalize the block in subblocks # Each subblock is indexed using the neighbor_mask boolean array. - neighbors = np.unique(block.properties["neighbor_species"]) + neighbors = np.unique(block.properties["neighbor_types"]) for neighbor in neighbors: l = label["angular_channel"] - neighbor_mask = block.properties["neighbor_species"] == neighbor + neighbor_mask = block.properties["neighbor_types"] == neighbor n_arr = block.properties["n"][neighbor_mask].flatten() l_2n_arr = l + 2 * n_arr # normalize all the GTOs by the appropriate prefactor first, since the overlap matrix is in terms of @@ -477,13 +477,13 @@ def orthonormalize_basis(self, features: TensorMap): radial_basis_name = self.radial_basis for label, block in features.items(): - # Each block's `properties` dimension contains radial channels for each neighbor species - # Hence we have to iterate through each neighbor species and orthonormalize the block in subblocks + # Each block's `properties` dimension contains radial channels for each neighbor types + # Hence we have to iterate through each neighbor types and orthonormalize the block in subblocks # Each subblock is indexed using the neighbor_mask boolean array. - neighbors = np.unique(block.properties["neighbor_species"]) + neighbors = np.unique(block.properties["neighbor_types"]) for neighbor in neighbors: l = label["angular_channel"] - neighbor_mask = block.properties["neighbor_species"] == neighbor + neighbor_mask = block.properties["neighbor_types"] == neighbor n_arr = block.properties["n"][neighbor_mask].flatten() l_2n_arr = l + 2 * n_arr # normalize all the GTOs by the appropriate prefactor first, since the overlap matrix is in terms of diff --git a/anisoap/utils/metatensor_utils.py b/anisoap/utils/metatensor_utils.py index 9763eba..a04bbd4 100644 --- a/anisoap/utils/metatensor_utils.py +++ b/anisoap/utils/metatensor_utils.py @@ -189,10 +189,10 @@ def cg_combine( sparse indices are labeled as ("inversion_sigma", "spherical_harmonics_l", "order_nu"). The automatically-determined naming of output features can be overridden by giving a list of "feature_names". By defaults, all other key labels are combined in an "outer product" mode, i.e. if there is a key-side - neighbor_species in both x_a and x_b, the returned keys will have two neighbor_species labels, + neighbor_types in both x_a and x_b, the returned keys will have two neighbor_types labels, corresponding to the parent features. By providing a list `other_keys_match` of keys that should match, these are - not outer-producted, but combined together. for instance, passing `["species center"]` means that the keys with the - same species center will be combined together, but yield a single key with the same species_center in the results. + not outer-producted, but combined together. for instance, passing `["types center"]` means that the keys with the + same types center will be combined together, but yield a single key with the same types_center in the results. """ # determines the cutoff in the new features From aaa7afbe2ac05c15b002ada3a7328046916cdea4 Mon Sep 17 00:00:00 2001 From: "Rose K. Cersonsky" <47536110+rosecers@users.noreply.github.com> Date: Tue, 5 Mar 2024 11:59:11 -0600 Subject: [PATCH 2/7] Adding gaussian normalization --- .../ellipsoidal_density_projection.py | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/anisoap/representations/ellipsoidal_density_projection.py b/anisoap/representations/ellipsoidal_density_projection.py index 33c3c19..df25c50 100644 --- a/anisoap/representations/ellipsoidal_density_projection.py +++ b/anisoap/representations/ellipsoidal_density_projection.py @@ -118,11 +118,18 @@ def pairwise_ellip_expansion( rot = rotation_matrices[j_global] lengths = ellipsoid_lengths[j_global] - precision, center = radial_basis.compute_gaussian_parameters( - r_ij, lengths, rot - ) + volume = 4.0 / 3.0 * np.pi * np.product(lengths / 2.0) + + length_norm = ( + np.product(lengths) * volume * (2.0 * np.pi) ** (3.0 / 2.0) + ) ** -1.0 + + ( + precision, + center, + ) = radial_basis.compute_gaussian_parameters(r_ij, lengths, rot) - moments = compute_moments_inefficient_implementation( + moments = length_norm * compute_moments_inefficient_implementation( precision, center, maxdeg=maxdeg ) for l in range(lmax + 1): From 4fdfe4767d189b01fc91816a92a6e56ad0278af1 Mon Sep 17 00:00:00 2001 From: "Rose K. Cersonsky" <47536110+rosecers@users.noreply.github.com> Date: Tue, 5 Mar 2024 15:05:30 -0600 Subject: [PATCH 3/7] Updating re: metatensor --- anisoap/representations/Untitled.ipynb | 184 +++++++++++++++++++++++++ 1 file changed, 184 insertions(+) create mode 100644 anisoap/representations/Untitled.ipynb diff --git a/anisoap/representations/Untitled.ipynb b/anisoap/representations/Untitled.ipynb new file mode 100644 index 0000000..37db375 --- /dev/null +++ b/anisoap/representations/Untitled.ipynb @@ -0,0 +1,184 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 32, + "id": "56f31f63-3d5b-4f44-8e6e-912ea57675de", + "metadata": {}, + "outputs": [], + "source": [ + "from radial_basis import GTORadialBasis, MonomialBasis, ShiftedGTORadialBasis" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "121a7472-d5e2-47e0-a54c-33a892d149d5", + "metadata": {}, + "outputs": [], + "source": [ + "n = 4\n", + "l = 4\n", + "shift = 1.0\n", + "width = 0.5\n", + "cutoff = 5\n", + "\n", + "shared_params = dict(max_radial=n, max_angular=l, cutoff_radius=cutoff)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "56bb998b-5eec-45b0-bab0-a7074810d335", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "monomial = MonomialBasis(**shared_params)\n", + "monomial.plot_basis()" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "4a556e9f-4dc0-451e-a970-124439da95e8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "shiftedgto = ShiftedGTORadialBasis(\n", + " radial_gaussian_width=width,\n", + " # radial_gaussian_shift = shift,\n", + " tol=1e-1,\n", + " **shared_params\n", + ")\n", + "shiftedgto.plot_basis()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "d6229528-3307-4182-9959-eb9f5aa4b4e0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAGdCAYAAAAvwBgXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACo2UlEQVR4nOzddXhcVcLH8e+9d1zibk0aqaTuCnWgQou7L7LIIgu7sC+wLIssiy7uUopLoUCLtKXubmnaRhr3ZCYZn7n3/WPatKWFOgV6Ps8zz5SZe889MxMyvxyVNE3TEARBEARBOAHkE10BQRAEQRBOXiKICIIgCIJwwoggIgiCIAjCCSOCiCAIgiAIJ4wIIoIgCIIgnDAiiAiCIAiCcMKIICIIgiAIwgkjgoggCIIgCCeM7kRX4JeoqkpVVRV2ux1Jkk50dQRBEARBOASaptHa2kpKSgqy/MttHr/pIFJVVUV6evqJroYgCIIgCEegvLyctLS0XzzmuAaRYDDIAw88wHvvvUdNTQ3JyclceeWV3HvvvQdNSAB2ux0Iv5CIiIjjWVVBEARBEI4Rp9NJenp6+/f4LzmuQeSxxx7j5Zdf5p133iE/P59Vq1Zx1VVXERkZya233nrQ83d3x0RERIggIgiCIAi/M4cyrOK4BpGlS5cyefJkJkyYAEBmZiYffPABq1atOp6XFQRBEAThd+K4zpoZNmwYc+bMYdu2bQCsX7+eRYsWMX78+AMe7/P5cDqd+9wEQRAEQfjjOq4tIn//+99xOBx07twZRVEIhUI8/PDDXHTRRQc8/tFHH+Vf//rX8aySIAiCIAi/Ice1ReSjjz5i2rRpvP/++6xZs4Z33nmHJ554gnfeeeeAx99zzz04HI72W3l5+fGsniAIgiAIJ5ikaZp2vApPT0/n7rvv5qabbmp/7KGHHmLatGls3br1oOc7nU4iIyNxOBxisKogCIIg/E4czvf3cW0Rcbvd+03TVRQFVVWP52UFQRAEQfidOK5jRCZNmsTDDz9MRkYG+fn5rF27lqeeeoqrr776eF5WEARBEITfiePaNdPa2sp9993H9OnTqaurIyUlhYsuuoj7778fg8Fw0PNF14wgCIIg/P4czvf3cQ0iR0sEEUEQBEH4/fnNjBERBEEQBEH4JSKICIIgCIJwwoggIgiCIAjCCXNSBhGPP8TVb69k+toKPP7Qia6OIAiCIJy0juv03d+qbzdXM3drHXO31nG/cTMTe6ZwXr80eqdHHdJOgYIgCIIgHBsnZYvIwKxYbh+TR3qMmVZfkA9WlHH2i0s4438L2VHXdqKrJwiCIAgnjZN6+q6qaiwvaeKTVeXM3FSNN6CSGmXm8xuHkBhhOubXEwRBEISTgZi+e4hkWWJwdixPXdCLRX8fRcc4K5UtHq58ayVOb+BEV08QBEEQ/vBO6iCytzibkXeuHkCczUhBtZMb3l2NLygGsgqCIAjC8SSCyF7SYyy8fVV/rAaFJUWN3PXJBlT1N9tzJQiCIAi/eyKI/ES31EhevqwvOllixvoq/vtd4YmukiAIgiD8YYkgcgDDc+N5/LweALyyoIgtVc4TXCNBEARB+GMSQeRnnNU7jYk9ktE0eGRmAb/hyUWCIAiC8Lslgsgv+PvpnTEoMot2NDBvW/2Jro4gCIIg/OGIIPIL0mMsXDk0E4BHvikgGFJPbIUEQRAE4Q9GBJGDuGlkDlEWPdvr2vhoVfmJro4gCIIg/KGIIHIQkWY9t47OBeDpH7bR5gue4BoJgiAIwh+HCCKH4JKBHciKs9LQ5ufleUUnujqCIAiC8IchgsghMOhk7j6jMwCvLSymqsVzgmskCIIgCH8MIogconFdExmQGYMvqPLqguITXR1BEARB+EMQQeQQSZLEzaNyAPhsdYUYKyIIgiAIx4AIIodhWE4cHeOstPqCTF9beaKrIwiCIAi/eyKIHAZZlrhscAcApi4pFautCoIgCMJREkHkMJ3TNw2LQWF7XRtLixpPdHUEQRAE4XdNBJHDFGHSc3afVADeWVp6YisjCIIgCL9zIogcgSsGZwLww5ZaKsVUXkEQBEE4YiKIHIHcRDtDsmNRNXhv2c4TXR1BEARB+N0SQeQIXb6rVeTDleV4A6ETWxlBEARB+J0SQeQIjemSQEqkiSaXn282VJ/o6giCIAjC75IIIkdIp8hcMig8lVcMWhUEQRCEIyOCyFG4sH86BkVmQ4WDwprWE10dQRAEQfjdEUHkKMTajIzoFA/AF+vESquCIAiCcLhEEDlKU3qH1xT5cm0lqipWWhUEQRCEw3Hcg0hlZSWXXnopsbGxWCwWevXqxerVq4/3ZQ9qa9NWAmrgqMsZ1TkBu1FHlcPLytKmY1AzQRAEQTh5HNcg0tzczNChQ9Hr9cyaNYstW7bw5JNPEhUVdTwve1Dr69dz+azLue3H2/AGvUdVlkmvcHq3JAC+WFd1LKonCIIgCCeN4xpEHnvsMdLT03nrrbcYMGAAmZmZjB49muzs7ON52YNy+pyomsqCigVc/8P1tPqPbqDp7u6ZmRur8QfVY1FFQRAEQTgpHNcgMmPGDPr168d5551HQkICvXv35rXXXjuelzwkw9OG8+rYV7Hr7aypW8PV311Ng6fhiMsb1DGWBLsRhyfAvMK6Y1hTQRAEQfhjO65BpLi4mJdeeonc3Fy+++47brjhBv7yl78wderUAx7v8/lwOp373I6XPol9ePP0N4kxxbC1aStXfnsllW1HNvNFkSXO7JkCwJeie0YQBEEQDtlxDSKqqtKnTx8eeeQRevfuzfXXX8+1117LSy+9dMDjH330USIjI9tv6enpx7N6dI7pzNQzppJiTWGncyeXz7qcWlftEZW1u3tmdkEtrd6jHwQrCIIgCCeD4xpEkpOT6dq16z6PdenShbKysgMef8899+BwONpv5eXlx7N6AHSI6MDUM6aSFZlFnbuOD7Z+cETl5KdEkB1vxRdU+XZTzTGupSAIgiD8MR3XIDJ06FAKCwv3eWzbtm106NDhgMcbjUYiIiL2uf0aEq2J3NL7FgC+KvqKkHr4m9hJksSUXrvWFBHdM4IgCIJwSI5rELn99ttZtmwZjzzyCDt27OD999/n1Vdf5aabbjqelz0ip6adSqQxkjpPHcurlx9RGZN3BZElRQ3UOY9uWrAgCIIgnAyOaxDp378/06dP54MPPqBbt278+9//5plnnuGSSy45npc9IgbFwBmZZwDwRdEXR1RGRqyFPhlRqBrMWC9aRQRBEAThYI77yqoTJ05k48aNeL1eCgoKuPbaa4/3JY/YlJwpAMwtm3vEa4vsbhWZJcaJCIIgCMJBib1m9tI1tivZkdn4Qj6+K/3uiMo4LT+8yurqnc2ie0YQBEEQDkIEkb1IksTknMkAzCiacURlJEWa6J0RBcB3m0WriCAIgiD8EhFEfmJix4nIkszaurXsdO48ojLO2LX3zLciiAiCIAjCLxJB5CfiLfEMSRkCHHmryO7umWXFTTS7/MesboIgCILwRyOCyAFMzg53z3xV9BWqdvib2HWItdIlOYKQqvFDwZGt1CoIgiAIJwMRRA5gZMZI7Ho71a5qVtasPKIyTt/VKvKdmD0jCIIgCD9LBJEDMCpGTs86HYAvd3x5RGWc0T0cRBZub6DNFzxmdRMEQRCEPxIRRH7GmdlnAjC3fC5B9fCDRG6CjY5xVvwhlR+31h3r6gmCIAjCH4IIIj+je1x37Ho7roCLwubCg5/wE5Ikcdru2TOie0YQBEEQDkgEkZ+hyAq9E3sDsLpm9RGVsXucyI+FdXgDh7+RniAIgiD80Ykg8gv6JvYFYHXtkQWRHmmRpESacPtDLNzecCyrJgiCIAh/CCKI/ILdQWRN3Zojmsa7d/fMrE3Vx7RugiAIgvBHIILIL+ga0xWzzkyLr4USR8kRlbG7e2b2lloCocMPM4IgCILwRyaCyC/QK3p6xPUAjrx7pl9mDHE2A05vkBUlTceyeoIgCILwuyeCyEHs7p5ZVbvqiM5XZIlRnRMA+GGLWGVVEARBEPYmgshB7D1gVdO0IypjbNdw98wPW2qPuAxBEARB+CMSQeQgusd3RyfrqHPXUdlWeURlDMuJw6SXqWzxUFDdeoxrKAiCIAi/XyKIHIRZZyY/Nh848nEiZoPCsJx4AGaLTfAEQRAEoZ0IIofgaNcTARjbVYwTEQRBEISfEkHkEByLIDKqcyKSBBsrHVQ7PMeqaoIgCILwuyaCyCHondAbCYmy1jLq3fVHVEa83Ujv9CgAZheITfAEQRAEAUQQOSR2g53OMZ0BWF13NN0zexY3EwRBEARBBJFD1iexD3DkG+DBnnEiS4saafMFj0m9BEEQBOH3TASRQ9Q+TuQoWkSy421kxVnxh1QWbDuyLh5BEARB+CMRQeQQ9UkIt4jsaN6Bw+c4ojIkSWJMFzF7RhAEQRB2E0HkEMWaY8mKzEJDY23d2iMuZ/c4kblb6wiKTfAEQRCEk5wIIodhd6vIurp1R15GRhTRFj0OT4CVpc3HqGaCIAiC8Pskgshh6BrbFYCtTVuPuAydIjOqcyIgumcEQRAEQQSRw9AlpgsABU0FR7V53diu4SAyu0BsgicIgiCc3EQQOQy50bkokkKTt4k695EvSjY8Nw6DTqasyc32urZjWENBEARB+H0RQeQwmHQmsiKzgKPrnrEadQzNjgVE94wgCIJwchNB5DDt7p7Z0rTlqMrZPXtGBBFBEAThZCaCyGHqEhsOIlsbj7xFBGD0rvVE1pW3UOf0HnW9BEEQBOH3SASRw7R7z5mCpoKjKicxwkTPXZvgzdkqNsETBEEQTk6/WhB59NFHkSSJ22677de65HGxO4hUu6pp8bYcVVljxSqrgiAIwknuVwkiK1eu5NVXX6VHjx6/xuWOK7vBTro9HTj6VpHd40QW7WjA7Reb4AmCIAgnn+MeRNra2rjkkkt47bXXiI6OPt6X+1XsHrB6NDNnAPISbaTHmPEHVRZsazgWVRMEQRCE35XjHkRuuukmJkyYwJgxYw56rM/nw+l07nP7Ldo9YLWg8ehaRCRJYmyXcKvI7ALRPSMIgiCcfI5rEPnwww9Zs2YNjz766CEd/+ijjxIZGdl+S09PP57VO2J7r7B6tMZ0DY8Tmbu1jpAqVlkVBEEQTi7HLYiUl5dz6623Mm3aNEwm0yGdc8899+BwONpv5eXlx6t6R2X3gNWdzp24Aq6jKqt/ZgyRZj1NLj9rysQmeIIgCMLJ5bgFkdWrV1NXV0ffvn3R6XTodDrmz5/Ps88+i06nIxQK7XeO0WgkIiJin9tvUaw5lgRLAhoahU2FR1WWXpEZ2SkegNli9owgCIJwkjluQWT06NFs3LiRdevWtd/69evHJZdcwrp161AU5Xhd+ldxLLtnxCqrgiAIwslKd7wKttvtdOvWbZ/HrFYrsbGx+z3+e9QltgvzK+Yf9YBVgFPy4tArEsUNLnbUtZGTYDsGNRQEQRCE3z6xsuoR2j1O5Gin8ALYTXoGZ8cB8P2WmqMuTxAEQRB+L37VIDJv3jyeeeaZX/OSx03XmK4AFLUU4Q/5j7q80/PD3TPfbRJBRBAEQTh5iBaRI5RkTSLSGElQC7K9ZftRlze2ayKSBOsrHFS1eI5BDQVBEATht08EkSMkSdKeAavHYJxIvN1Ivw7hlWe/3yxaRQRBEISTgwgiR+FIlnoP+Lys/2EmH//rHr559nE2zPmW5poqNE3jtF3dM9+KICIIgiCcJI7brJmTweEs9e52tLD2u29Y//03eFr3LF2/dfF8AGwxsSR07Y0xlMGKkiaaXH5irIbjU3FBEARB+I0QQeQo7J45s615G0E1iE7e/+3UNI0ln7zHyhmfEQoEAIiIT6TXaRPwezxUbNlI9fattDU10rZoNpeYY/g09gxmb6nl/P6/zSXuBUEQBOFYEUHkKHSI6IBZZ8YT9FDeWk5WZNZ+x6yZOYNln30IQFJ2Lv0mnUPugMHIey3oFvB5qdiyie9fex4aGziv6jMWLDKKICIIgiD84YkxIkdBlmSyI7OBcKvIT5WuX8P8d98A4JRLr+bih5+i0+Bh+4QQAL3RRFbvflzy0JNEpmVhUb2kL3+HdfPnHffXIAiCIAgnkggiRyk3OheA7c37TuFtqqrk6/89hqap5I8YQ7+JZyFJ0i+WZYuJ5fKH/ktNVDY6LcScF59gzcwvj1vdBUEQBOFEE0HkKB0oiHhdbXzx+L/xuVyk5HVhzJ9uOmgI2c1gNhNz5nWsjegBwLypb1C2acOxr7ggCIIg/AaIIHKU2oPIrkXNVDXEN88+TnNVBfbYeM786z/Q6fWHVebp3VNYFDuUbZFd0DSVb579L66W5mNed0EQBEE40UQQOUp50XkAVLRW4A64Wf31F5SuW43OYGTyXfdijYo+7DJ7pkWRGGFkTtRQTAmpuB0tfPPs46hq6FhXXxAEQRBOKBFEjlKMKYZYUywaGoXVm1nx5acAjLrqehKzso+oTFmWGNc1iaCsp6L3eeiNJso3b2Dppx8ey6oLgiAIwgkngsgxsLt7Zs23X+FtayU6OZX8U0cfVZmndwuvsjqrQmXUn24CYNnnH1K6Ye3RVVYQBEEQfkNEEDkGcqNz0QckmheHB5UOPvei/aboHq6BWTHE2Qy0uAPUJ+bTY/TpoGnMfO4J2pqbjkW1BUEQBOGEE0HkGMiNyqVLaQSSN0hMajqdhgw/6jJ1isz47skAfLW+ihFXXkt8hyw8Tkf72iSCIAiC8HsngsgxkGVKJ7/EDsCgcy5Elo+uNWS3ST1TAPh+cy0hScdpN9yKJMlsXTyfnRvXHZNrCIIgCMKJJILIMeBcshljUKHZ5ie2V5djVm7fjGiSI020+YLMK6wnsWMOPcedAcDcN18mFAwcs2sJgiAIwokggshR8ra1sX7WNwCsz3Wwo2XHMStbliUm9gh3z3y9oQqAoRdchiUyiqaqClZ9/cUxu5YgCIIgnAgiiByl1TO/wO9xE4gxUJrkbl/Y7FjZ3T0zp6AOtz+IyWrjlEuuAsKzaJwNdcf0eoIgCILwaxJB5Cj4vR7WzJwBgPXUbiAdePO7o9E9NZIOsRY8gRCzC8Kho+spo0jtnE/Q5+PHt187ptcTBEEQhF+TCCJHYfvyJfg9bqKTU+gy8JTwY83HtkVEkiQm9Qi3iny1vqr9sdHX/BlJltmxcinFa1ce02sKgiAIwq9FBJGjsHn+HAC6njKavNjwUu/FjmJCx3gp9t3dM/ML63F4wgNU4zMy6XPGmQD8+NarYuCqIAiC8LskgsgRctbXUb55A0gSXU8ZSZo9DbPOjC/ko6y17Jheq1OSnbxEG/6QygMzNvHV+iqWFzeSMmoKSmQcLbXVrP/h22N6TUEQBEH4NehOdAV+r7YsmAtARn53IuISAMiOyGZLwxYK6grIisw6JtfxBkJ8vaEapycIwPS1VUxfW7XngJjzSLDWUv/lHPJPHYXRYj0m1xUEQRCEX4OkaZp2oivxc5xOJ5GRkTgcDiIiIk50ddppmsabt11Hc00NkaeMw+Hx4ff78fl9SEgAjB49muHDj3yFVW8gxP/mbOeDFWW0uPftdumdEUWzy09dqw+3f083UN8IP49fO5aO8bYjvq4gCIIgHK3D+f4WLSJHoKqwgJaaakKJ6VTWN7Y/vjuEAMyZM4fU1FQ6dux42OW3egP86Z1VLC8J7ymTGmXmkkEZfLWuioKaVs7qncrlgzMBqHN6+feHi/i6yMNqp4FxTy/g0kEduOu0TliN4uMVBEEQftvEGJEjsHnBHEJGM96YRADGjx/PLbfcwshLR/Jlhy+pj64H4LPPPqO1tfWwym5o83HRa8tYXtKEzajjxUv6sOBvI7lxRA7n908H4JNVFe3HJ0SYePba0dxmWE2mu5SgqvH2klIueX05LW7/MXrFgiAIgnB8iCBymAJ+H1uXLMSbkoUGdOnShf79+xMbG0v3tO4E5SBLIpYQFx+Hy+Xis88+Q1XVQyq7otnN+S8vZVOlk1irgQ+vG8T47skocrilZUqvVAyKzMZKB1uqnO3nSZLEeZddyKTaWUyu+YZIo8K68hYueGUZdU7v8XgbBEEQBOGYEEHkMBWtXEabLQrVZMFisTBhwgQkKRwUYkwxxJpiCcpBeo/tjV6vp7S0lPnz5x+03B11rZz38lKKG1ykRpn55IbBdEuN3OeYaKuBsV3DrTCfrC7f57mUvM7kDRxKhqeM6w3rSLAbKaxt5bxXllLe5D5Gr14QBEEQji0RRA7Tqnlz8ceG93+ZMGECNtu+A0Nzo3MBqKGGSZMmATB//nyKiop+tkyHO8Dlb6yg2uElJ8HGp38e/LMDTs/rlwbAF2sr8QX3Xa9k2EWXIysKng2LeHZUNOkxZnY2ujnv5aXsqDu8LiJBEARB+DWIIHIYWurqKG7zgiSRl92R/Pz8/Y7Jiw4vbLa9ZTs9evSgT58+AHz++ed4vft3k2iaxt2fb6DK4SUz1sLH1w8mOdL8s3UYnhtPUoSJZneAOQX77jMTnZxKjzHh3XmLvprGJ9cPJjfBRo3Ty4WvLqOiWbSMCIIgCL8tIogchpnTP0M1mlE0jclnn3PAY3a3iOxe6v2MM84gJiYGl8vFxo0b9zv+w5XlzNpUg16RePai3sRYDb9YB0WWOLdvuFXk41Xl+z0/6OwL0BtN1BRtx1mwmo+vH0yX5Aga2vxcO3U1Ll/wsF6zIAiCIBxPIogcIk3TKK6qBqBXXjZW64EXDtvdIrKteRuapqHX6xkwYAAAK1euZO9lW3bUtfKvrzYDcOe4TvRIizqkuuwOIgu21VPt8OzznDUqmr4TzwJg0YfvEmlSeOWsdOLNEgXVTv768XpU9Te7dIwgCIJwkjmuQeTRRx+lf//+2O12EhISmDJlCoWFhcfzksfNtoItBCUZQiGGjT3tZ4/LjspGlmRafC3Ue8LTeHv27IlOp6Ouro7y8nArhjcQ4pYP1uENqAzPjePa4Ye+3khmnJWBWTGoGny+pnKf55wN9ciKgqLX01xdyUtXnc0nd93ExQXPM7nmK2oXz+Lp/z6Kuvpd8LuO4J0QBEEQhGPnuAaR+fPnc9NNN7Fs2TJ++OEHgsEg48aNw+X6/X0BLlu4AAA7IaITEn/2OKNipENEB2BP94zZbKZ79+4ArFq1CoDHvt1KQbWTGKuBJ8/riSxLBy7wZ5zfL7ymyMerytE0Da+rjQXvvcWbt13Hko+nEQqEV2P1+kKAhKrJZHgqGNa8DNYu4X9PfMiy+yYRrPl9BkNBEAThj+G4BpFvv/2WK6+8kvz8fHr27Mlbb71FWVkZq1evPp6XPeaCwSBl1bUAdMrOPujxe3fP7NavXz8ANm/ezOyN5by1uBSAJ87rQUKE6bDrdEb3JGxGHeUNrUx/933e+Mu1rJzxGaFAgNQYmQGxZZiU8IJmA4b14fL//I8R50wmFJ+OX9KjqhKLSy1M/dvNlM5647CvLwiCIAjHwq86RsThcAAQExNzwOd9Ph9Op3Of229B4dYCQoAU9NP/1BEHPf5AQSQ1NZXk5GQCQZX7v9wEwGWDOjCq88+3rvwSi0HH5I56Lq74iJJvPsDb1kpsajpTege4IGE+w5OqGDGsEwDr1xRii0+g7/nX8tdnX6Rw7N/5Ln40XsVEs8/IZ29P5+t7r6atseGI6iIIgiAIR+pXCyKapnHHHXcwbNgwunXrdsBjHn30USIjI9tv6enpv1b1ftGKJUsAsAS8JGQefCxHbtS+M2d269+/P4WheKraVGIseu4c1+mI61RbvIPE+a8RHXTgUiwMvfLPXH5+L7K9y5CMNrh+AV1ueIa49A743C5WfPEJEJ5187+L+uJK68k7aRfTmtARCY3C7XW8fetVlG9ce8R1EgRBEITD9asFkZtvvpkNGzbwwQcf/Owx99xzDw6Ho/22e2DnieTz+SjfNVsmLyurfRXVX5IXE24RKXIUEVD37Jyb2jGPdaFUAC7rHUOkRX9EdSrfvIGPH7yHgKuVVmsi76eez1YtAnnug+EDxjwAiV2RZYVhF10BwNpvv8LZEF53JNKi59mLehHSmXjbehpJY84g0dSGL6Dx2SP3s3XxwVeCFQRBEIRj4VcJIrfccgszZszgxx9/JC0t7WePMxqNRERE7HM70Qq2bEEFJJ+XnoOHHdI5KdYUrHorQTVIqaO0/fEX5pfi03RES24S23YcUX12rFzGZ4/+E7/HQ3rX7vS47h68iomclf8EfxukD4R+17Qf37FPf9K6dCMUCLD4w3fbH+/bIYbbx4Rbbh4qz2HgtbeSa28gpGp88+zjrPrq832mGguCIAjC8XBcg4imadx88818/vnnzJ07l6ysrON5ueNi1YrlAJjcTtLzD9yl9FOSJO3XPVNY08q0ZTsBGKArY/u2wsMeA1OwaB4znnqEUCBATv9BnH3Pv5jYryOXWlcxTFtNSNbDmc+BvOdjlSSJUy8LB5MtC3+ktnhPAPrziBwGd4zF7Q9x25o4xl50Dr2jw9OB5097kx/feRVV3XcZeUEQBEE4lo5rELnpppuYNm0a77//Pna7nZqaGmpqavB4PAc/+TegtbWViuoaALIz0lF0h96V8tOFzR78ejOqBkO7emjLXsOs1Fnc+v2tVLRWHFJ5lYUFfPviM2iqSv6IMUy6/R50BgMGfwv/kN8G4H3D+Whxefudm5SdS5dhIwCY/+4b7S0diizxzIW9iLEa2Fzl5L+u8Ywc3Yvh8VUArJ31FV/e9S9al1QQqHWJFhJBEAThmDuuQeSll17C4XAwYsQIkpOT228fffTR8bzsMbNpU3h2i+xpI3/g4MM6d+8g8tXGElY0zMSa9RwbtH+xQdqAS+9ilWsVk76YxGMrHqPZ2/yzZTkb6pnx5MOooSC5A4Zw2vV/QVaU8JPf/QNLoJltWjoPtpzGsuKmA5Yx7MLLUfR6yrdspHjNyvbHEyNMPHFeDwDeWlLK1803kWJ/gsHxk5CQKa5Yw9w3X6XmqdVUP7ycpo8LCbX5D+u9EARBEISfc9y7Zg50u/LKK4/nZY+ZdWvWAGBwNpPVq99hnbt7z5mtjdu4b+WfMCVPRzZVopf1jMsYx6D6QSS4EwiqQaYVTGP85+N5c9ObqJq6TzkBv48ZTz6M29FCfEYmp990O9LurpeajbD+A0BiTu69BNDxxqKSA9YnIj6BPuMnA7Bg2puooT1dLiNz4rkw2g7AP4vraNYUsqMsjEoKtwDtaF3DJuci1LYA7jV11P5vLb4Sx2G9H4IgCIJwIGKvmZ/R1NREbX09aBoZiQmYbLbDOn93EKltdaPq6iEYwV96/5U5583hyZFPcmrSqQyvHc4tSbfQJaYLbYE2nl79NO8XvN9ehqZpfP/ys9QW78Bsj2DyXfdhMO21M++aqeH7/CmMO20iAHO21lLacOCVawdOOQ+zPYKmqgo2zPmu/RrN03dwbTNkIdOExjNZRuKv60yv2HmMSQqPcdnStITyzuXoEsyorX7qX9tA6/xy0V0jCIIgHBURRH5GUVERAIqnjU79Bx72+Ta9DbNiRda3ooWMXJb1CNf2uJJoUzQAnTt3Dh+4Ez6c+CG39rkVgKdXP01RS/jaK778lK2L5yMrCpPuuIfIvZeWD3hhw8fhf/e+jOx4GyM7xaNp8NbiA7eKGC1WBp93MQBLPnkPn9tN28JK3KtrMUoST0/ujkGRmVPSyEc1iTDyH/SMrmFYUnjMyJJZ71ObX4+lVzyo4JhVSuPULajuwAGvJwiCIAgHI4LIz9ixPdwSoLicZPc9/CDyYeGHeEIuNE1CaryAvwzfd+pvp07hxcyqqqpodbZyTbdrGJY6DL/q556F91C8fjWLPgy3eIy88nrSu3bf9wJbvwZvC0SmQ8cRAFwzLLzY2serKnD8TDjoMfp0opNT8TgdbHznKxyzwqElamJHeg1O467TwvV68KstlHS6FjIGMzC6iP6Z4a6cOW+9RFN2C1Fn5YAO1K1LcL7wEur6L2HrN+Fb6SJQw11MQTVIubOcNn/bYb+HgiAIwh+fCCIHoKoqpSXhL+hos4mopOTDOn9Z9TIeW/EYAP660+mWasWkV/Y5xm63t68cW1hYiCRJPDjkQaKMURTVFDL92UdA0+g2chy9xo3f/yJrd60J0utikMNlD82JpXOSHU8gxLvLSg9YN0Wn49TLriZSH09cSRxoYB2YhHVICgDXDMtiSHYsnkCI2z7eQODMl8EYwXDTErp3SULTVL557nFcpiJSsp4mwXgnUa77kKdfDh9eHL69PYHqp3L4z9RTGDhtAOOnj2fExyO4e+HdrKhesd84GEEQBOHkJYLIAdTW1uILBCAUIrdr/mGdW95azl/n/ZWQFiLQ0ptAazeIWHrAY3d3zxQUFAAQb4nnvkH3MWRTDLT5sCTEMerK6/Y/sXknFO9a/bTXJe0PS5LEn0eEN+V7ZUExLe4Dz27JzOvNyIyL0ckGWuQGIid1bF8xVpYlnjy/JxEmHesrHPxvtQ/GP4EkwWim0yGvI0Gfj+n//TdtxYvQZAN+OuNTO+HRd2KTyUyrJJHc1sjdxet5q7KcoV4/vqCXb4q/4Zrvr2HC5xN4bcNruAPuw3pvBUEQhD8eEUQOoLi4GADF3UpWz96Hde7Dyx/G6XeCLwNvzdkY4+ZS7Nh2wFaA3UGktLQUtzv8pZy6UyGzxooqaczv1oCXA3SxrHsf0CDrVIjusM9Tk3qk0DnJTqs3yMvziw9YR8e3pRhVE62BJuaWTKNw2cJ9nk+ONPPI2eGuoBfm7WCpbTTkn41CkEnKx8QZXbiCeqbX9Md/5WzUK76jJvQ4ja1PslK7g1t7jGRdp1GEdEZ6+Py8XF3DYtK5uOOZWPVWKtoqeHbts1w26zIq2yoP6/0VBEEQ/lh0J7oCv0Xbtm4FQO9p239sxi9YVLmIxZWLkdHhLD+frNhIWqI34Q76qGyrJN2+7yZ+sbGxJCQkUFdXx/bt2+mQlMj3U9/AF5NEW2IUnattPPnUkwzqM4hevXqRlJQUHnux7r1wAX0u368Osixx57hO/GnqKt5eUsLVQzNJiDC1Px9s9OBeWwuAp2eIQIWP+e++Qcc+/TFarO3HTeyRwoJt9Xy8qoLbPlrHt5fcQfSWLzBqHs7qUMj7lYNpaPPx5dSPWTXUT1NyJfdVXMdYx2AmG84m5qwcaKtDW/AMrmU7UbencH15IlcnPkdzWxu1bTUsaFjNDc3XckXa1TQXN+Pz+YiPjychIWGf+0PZ30cQBEH4fRJB5CeCwSAVleG/0pPiYzGYLYd2nhrkiZVPAKC2DEELxHH72E5MK+tIQVMB25q37RdEINwqUldXx7Jly5hZVYEvPbwQmmH3AX5YtmwZy5YtIykpiT4ZNvo6KlBMkdB5wgHrMrpLAn0yolhT1sKzc7fz0JQ9Ycr5YzmoYMyLpsdFg1i35juaqytZ/PE0Rl15/T7lPHBmPqt2NrOz3kndBzcSvatVJ0JxcdaV5/Lha59SvnE9LS2trO7upGiYk7xF0bgXVmOItWBIs9O87VwC/l3TiV1AsRcbOmykke1O4/L6SRQV1lKra6VBdtLQ0NDeVQXQsWNHJk6cSExMzCF9DoIgCMLvi+ia+YnKykpCqooUDJDXrechn/fptk8pchRhlOy01o6kc5Kdid2T29cT2b3nzE/tnj1TXV2NT1LC65akpTFhwgQq+1SyOHExSpKCoijU1NQwc8UOZjAWtdv5oDcfsExJkvjb6eFunw9XlLOzMRwEgk1e3GvCO/BGjMlAp9cz6uobAFj37TfUlhTtU47FoOO5i3pzh/5zOnk3EFAs0P08ABJX/Zv6kTGoaHQqt3Of7gpGTTyTiNMyAWj5soi6F9YRqHEhW3XYB9qIjJhOtO4ZIo2Ps1m3hHrJiYJMnprMZH9/xhv7cMbwsfTu3Zu0tDQURaG4uJgXX3yRhQsXUtxczMKKhWxu2Ex1WzXeoPeQPx9BEATht0m0iPxEUVF4UzjF1UrmIY4PcfqdvLDuBQA8daNBNXP72DxkWdpnqfefUlWVdevWtf+3vrGGM6acRZ/RpwHgq/Tx5+Y/85XuK2ZcMIPi9Zv4Yd4C1pOPxZ/DOE372W6LQR1jOSUvngXb6nn6h208c2FvWn8sB1XDmBuFMSO8s3Fmj97kDR7OtqULmfPGi1z04ON7Vm4F8t2r6Kp8AcDf/Ndwbf9b6Fqxiln+Wr5UlpHfNZL+W6IomTGbbdn96JDbE+lHBc0fnu5r6hpD9Nm5KDYD6phUWl46nRh3EaN1i1iReyuhLhdRu3Y78aVmUhzReBZ46XnZKZhyomlsbOSrr79iRfUKHtz0IDXFNfu9TrvezrjMcdzY60YSLAmH9HkJgiAIvx2iReQnthWEx4eYgj6SsvffQO5AXl3/Ki2+FiKUVFwN/emeGsm4ruHFx36uRSQYDPLpp5+ycuVK0DSMNWXEGnX0HjWu/ZihKUPpFN0JT9DDF2VfMMRczJn8AMDSDTtYvHjxL9brb7vWBPlyfRWFhQ24VofHhkSM2XeA64jLr0FvMlO9vZBV33yx5wlnNXx+HRIa82wTmR4YzC2fFFA69lEeig0vzHbK0H70Pn0SAPNeepX619eHQ4gcDkhqWwDZpENVVWbMWcJL7jPYSjY6Qgwpf4kOSc0MuH4C287zUGyswOwzUP/GRhzzyljpWMms2FksTF5IjaUGNIj0RxKjj0Evh5efbw208tn2z5jw+QSeXfMsJRUlbNy4kZKSEhoaGvD5fIf0GQqCIAgnhmgR2YvP5wsv6w5kpKft2VjuF5Q7y3lva3jwaFP5aYDCHWPz2lsqdreIlLWW4Ql6MOvM+Hw+PvjgA0pLS5EAY2UxirsVR1oWqqqi7LquJElc3e1q/r7w77xf8D5XtBnozRbcnc7lh8JWZs+ejcVioU+fPgesW7fUSCZ0T+abjdUUTN9GP1XDmBOFsUPEPsfZY+IYcfk1/PDq8yz+cCqZPXoTn5YOn10D7gZI7E6Pi18i8YUVFNW7uPC7KtqiFfJ9Pq5d+zXKDf/AWVtHVm0eeDXkBCNxF3Sh/rVN+Mtaaf5yBwuULaxbtw5JMhA8603Y8BDs+AHePw+u+pbT+kxgmvIuxTOXMcYxiNZvd+K0bac0pRiTwcSEzAkkVSRRUxpuFZk0aRJ53fPY2rSV51Y9R8POBrZ9t413fO/s9z4Y9Xry8vIYOXq0GGsiCILwGyNaRPayc+dONEDy+8g9xG6Zp1Y/RVANkqjriceRR6/0KEZ0im9/PtYUS4wpBlVT2d68HU3T+OKLLygtLUWv02Eu246+tRktIxdPMERZWdk+5Y/LHEeqLZVmXzPTneHWmqFnnM/QoUMB+Oqrr/YZ3PlTd4zLI0WS6dkSBMJjQw6k+6jT6Nh3AKFgkJnPP0lo+WuwczEYbHD+O8RERvD8xX2QJY2a2hTU5pE8EoxC76pH/uZ2hnU8l1hjCr6Qh/kVH6NGSsRe1AlN0vh27Y+7QojEOeecQ7ceveD8dyBtAHgdMO1saN7JpT0vo2WsnmeT3icgBRjS1ovXGx7iuwmzeGDYA1x3/nX07du3/XWvX7SS6mnz6bK8AwPqBxDni0NFpdHYSFB1oguEpz77AgE2bt7M888+y9fTp9PWJlZ5FQRB+K0QQWQvRbuWdde5nHTofvAgsqF+A7PLZiMjU75jNAB/HZe3z7gNSZLoEtsFgC2NW1i0aBEFBQXIskxMSy2Ky0HnoaeSM2AwANu379uFo5N1XJF/BQBTI+wE43IhKp0xY8bQu3dvNE1j+vTptLa2HrCO2fE2HkqKQ4/EBkXFm3jgWUCSJDHuulswR0TSXF5McM6j4SfGPACx4UXSkmJcWJJnAeCpG0d13+dA1uPa5Me7pgGAdd75VFVuZfp/H0TJtFDW3c82XTWSJnHmqePp1q1buFyDFS7+COK7QGs1vDsFtbWWJl8Ts6IXcWeHp3AqbUQ3WQhMK0d1B5BlmYkTJzJo0CAAZi9YwJq2NnyKgsXlontJMfGmHSxMXsCX2T9QkDSfSVvXM3bRIpKqqlGBVevX8/STj/He1D+zdu21bNp8O1u33sv2Hf+hpvYrQiExAFYQBOHXJILIXrYVFgJgUyA6OeWgx+8eoJqmH47Pk8CAzBiG5cTtd1zXmK4AbCncwpw5cwDIiY3EXV6CNTqGUVffQF5euAvnp0EEYErOFKIlPZV6Hd+lhmfDSJLExIkTSUlJwe/3M3v27APWMdTmJ68uPE7ilZCH/8z6+dYTa1Q04667he5RNRhDDoKWBOhzRfvz/1r2L4hYQFJSKZomcct3Dsrzn6A5+GcAIoZaOOWuazFarVQVbuGLJx5h4c6VAPQPZpO4RCXUutdqr5YYuOxziMxAbSrm3x+PZ/qO6ciSjCHNzt8znsGhayNQ2Ub9axsJuQKEWlroOHcuRu+ewJBns3HL9Tdw9tvvcMvd7/Pi2Jew6q1siHDw7ws1Il79EwPPbqZHp9nY7A2ENIXtxYnMm6dQUfEtlVUfUFb2Gps338aixYPYWngfzeWLcC1fgWfDBnzFJQTr61G9XrHbsCAIwjEmgsguLpeLZqcTgOyc3IMuorWmdg1LqpagSArbC8N/od/xk9aQ3fJj87EGrKgbwutwdOqYRfXCcHAYd90tmG12srOzkSSJ+vp6mpub9znfrJi4xBXuZngzWNf+ZagoChMmhNcSWb9+/X7dOgCejQ0Q0vDHmVhPiA9WlLNkR8PPvq6cXr0YmhKe4ru0NgWfP3zdlTUrWV69HIOi570rJtE9NZKgO0DzmmxAj0leir3sL8QnJzHlb/ej0xso27AGSraSlJhEr5g8VKefxvcK0EJ7rTIbkQKXf8Fjicl8qvMjAQ8P+Tdvnf4WltQo/pbxFE69i0C1i9qnl7Dhoiv4UlXxmUzodxWxra2Nra3O9vd+SOoQ3jn9HeLNsRQ5irhh8b/ZwBoiE6vp12shvWI2olMDOBxJbFw6iSjlMlJTL8Val4DpaxfeOz6metyfKLviCkrPv4Di8ePZPvwUCnv1pmjsOOqffRZ/aSkAwaBLhBNBEISjIILILiW7NrmTvW5yeh148OfedreGpCin4vdFMzQnlkEdYw94bK49l0F1g9CFdCQlJ9K6Yj5oGvkjxtCxT38AzGZz+yZ4+7WKNBVzYX0FZlVlm7uaJVVL2p9KTU1tH6w6c+ZMVHXfpeTda8OhIn5QCpcNCs+Wufvzjbj9wQO/sDVTMamttIXMrK608v0rz6FpGq9seAWAs3LOIjs6g5cv68sNOgsxIWgyQFTku0j1m+CH+0jrnE+v8y5BA/SORjLkAPGXd0MyKvhLnThmluxzye9bi3jfokfSNP5d38jEgjmYFCP/G/k/3FFB/pr+BB6pjUaXm9n9B+Cy2YiyWvnzX/7CsGHhXY1nzJjBjh3hqdeapmH3beQvcc0k61WcqszLjZFEZT/OKSNXM+Uvn3Fxr75Y3R5cWPjuWx/1t68i8oEWImboMBbJSJpEMFYjGKOhWXQgSWiKhkspo7TgeVZ+PJb5X3Zh/oIe/DivC4uXnMqq1eezcdNfKCl9Aa+36sDvryAIgrAPEUR22b2su+JuJeMgC5mtqF7BipoV6CQ92woHAnDH2ANP9dU0jZU/riTKH4VX8WJ2VNJaX0dkYhIjr9h3Q7vc3F1TfX8aRIrmEqmqnCVFAuHF0/Y2evRoTCYTNTU1rF69uv3xYIMHf1krSGDpGc/fz+hMSqSJsiY3T36//7omBLyw6OnwPwfegibr2bZsEdOnPs3y6uXoJB3XdL8GgERV4kw1POnq334Xj6Y8jqYBK17Fu+krVu0oxZucCUDB3O9Yt3QWMeeHpxO3La7CtSsgNXubeXj5wwD8KXUUk9vcsPptWPQ0SdYknhn5DNlF9bTNf5KZ+jW4lSDRsp2rrvgTMTExjB49mh49eqBpGh999BFlZRvZsPF6Cgr+jp02/i87l/yYPNqCfu5a/jyVbdUAdDz7bK668EJiHQ78RiM/9u1DaVYm1uHDSXrgn2R+/yXmd66i/mGV6ifc1LwIdS8YaPh7EOd5Ibz9VIJ2/67POIDXW4HDsZq6um8oLn6KxUtOZd36P1Ff/wOq+jOhTxAEQTg5g0jQH6Jup5OAL9T+WMmuje5ibVYsEZE/e66maTy/7nkAYtRTCPojGdMlgb4dDjwtdM2aNWzcuBFN0tgpr6Nh9TokWWb8zX/FaNl34OjucSIlJSUEAnttdrcjPK7knPRRAMwrn0eDZ0/3itVqZeTIkQDMmTMHlyu8kqp7XfjL3pgbjWI3YDPq2jeze3NxCat37tsFxNp3obUKIlKJPv1ORl9zY7g+M+fSodrC5JzJpNjCY2ec35ciqeBINLGSEG9sDvFyaniA65zp79Ha2oo9K5chF1wKwIL33mJT8Xzso8KtPi2fb8df2cZ/VvyHJm8TOVE53DDqCTjjsXBd5vwLNnxC1spK/vxVgJX5WXjkAJFYmODuje/Tnai+EJIkceaZZ5KVlYWiNLF5y6U0NMxBkgxkd7yL4f0/5ZVxb5IbnUu9p55rf7iWmtZqmj/5hMYbbmDE9z+QXlaGqigsHzCAQr8P2/DhmDPyyM7+GznZdyPLRlTNR0h1IUk6YqKHkplwPdm1l5L6eBoJ9+qJe0JH8vJedEy4iaioQYBKY+OPbNh4A4sWD6e05B00LYQgCIKwr5NyHZH68jY+fzzccmCPMWFP1NG6a/fb7NxOv3ju0qqlrK1bi142UFw4EJ0scc/4Lgc8tq6ujlmzwrNMLFl6enwXzn2Dzr6AlLz9z0lISCAiIgKn00lJSQm5HTuiulph20LwS3RMPZ3u7iI2Nm1iRtEMru52dfu5/fr1Y82aNdTW1jJ37lwmTpzY3i1j6b1nxdERnRI4u08qn6+p5Mb3VjPj5mEkRpgg6IOFT4UPGn4H6Iz0GH0ahdvXUPbjYoavj+X0CWMA8Fe24V4XXm8l97zO3FsSy0PfFPBYcQeIupZab3jzvImnj6FjXlfUYJBln33IgmlvErogQE6nfLyFzXz10XvMjJ2JLMk8OORBDIoBBl4PLWWw9Hm06TfQ/GM0xVmdqUpNJUSI1QlrOLd2CP6yVhqnbibuym7o9DrOnDyY5cufRq9vw+eLZkD/N4iLC7dsRRojeXXsq1w+63JqmspYfPmZdC0IT+G1de3KRXfcwey1a1lTVMSSDh3Q/nIrfe+9mlLtXVpaVgCgKBZUNYCmBXC5i8nufhfWTvnUdLueltdeQZn9GVLxFlzTiqjMnEhN5/FEZS8mMnMxUEdRyYNsXvMuzu3XoJPzkOMMRKTaiEixYkuyIJsV7DqFeIMOo3xS/n0gCMJJ6qQMIj53ALNdj6c1QGuTl/q2BogB2eehaJWJyLhiuo9Mw2wz7HPe3q0hRvcwtGAElwzOIDvett81AoEAn3zyCcFgkOzsbNo2L8IdlGmNkxh09oUHrJckSeTm5rJ69Wq2zJsHl19BqKUFiAjfPr+WoX30bDwNPt/2GVflX9U+QFNRFMaPH89bb73F6tWr6Z7aGV2jF0kvY+6679iVB87MZ0OFgx11bVw3dRUfXT8Y09qp7a0h9L6s/dj52RXoN3lIqzez7IVXyX6kC55vw+MfzD3jMaTZ+VOanYY2Py/PL+K/LSMYqd/BmcpistcXQ+7bDD3/UmRFYcnH77H4o3cJTbmAhIQMno14F4DLO11G9/i9djke+2+CO9agq1+CcWiI9brwGBh3lpv1bObBrFf5Z/H1+IocNL5XgPkcC5s3X4Ve34rXG826taOprVnDZZflo9OFf8TjzHG8OuQZ1lx5HrmlbQR0EvG330bSFVcj6XRM7NoV7ZNPWFtQwNbhkcg1tyIZVWTZSHr61WR2uB6fr45166/D6y1lxYrzqVt7Bc1FA4BTsfbJpdP2D4lyFJFb9BlRLd0paLmckh1TULotoWv6p5iiS9D3v5/vmMCn0gX4pBA0OGCvscOSqpHshwyfRHJQJs2oJ91oIM2kJ8mgx2LRY40yYo0yYrbpkWSxM7EgCL9vkvYbHvLvdDqJjIzE4XAQERFx8BMOk7ctQFONi9k/fE1x7Q70zQ1EeichSXp0epkuQ5LpNS6DiNjw5nLzy+dz89yb0UtGmgvvwqaPYv5dI4mxGvYr+6uvvmL16tVYrVYGdkhl5WfvE1BUvhlex+zrFmNUjAes09atW/nwww+xtrmY8PXX/PRrxquH625R8BolXu3/JIO7jtvn+c8++4yNGzeSGZHKmLrOWHrFE3Nh5/2us7PRxeQXFtPiDjC5RwLP1FyJ5KyACU9C/z8BUNBYwPlfn48xqHDdxn60VtfQOWsIPRkOikTSHX3R7XpvNE3j+jcX8v32VhRUXjA8z+nyMhhxD4y4G4AVX37KwvffBsDTO4GPklaS6k/gdd3jpF7RG0kJv1p/eTml551NYp8yPkg4hxoSyE5PZvKlF3HprEspcZQwWXcaNxRMgaCGK3kjFfnPYLFlkZH+DO+8Mx2/30/Pnj2ZMmUKkiQRbGqi/E/X4t2yBY9B4j/nyUQOHMyLo19Er4Tn34RCIb6deQdGyzdIkoa200Q3000kXPBnSjc0sHFeBdVFlSQPfB1bykYAnCWnoff8iejkCGISzRjXfo/31WeQAn7qE5K4+9rbKE7rQJTWxGW8xSDCA43riefl0O34G7LoUBckrSFIpFslwq2iHOD/SI9eoiZawWmRcRll3CYJl0kmYFUwG3VYzTpsVj12m4EEq4F0s5F0k4F0k4E0kwGzIlpZBEH49RzO9/dJ2SKym8mmJyUnCseM8B4ssVERjDmzN2u+20l9WSsb51dSsKyGYefmkDckgadXhwdyao6haCEbfzkt94AhZPPmze2DRof17snSN8KtKBt7emmx+NjevJ1ucd32O09TVexffYUcCuGyWdHOPYfOSQugdj3S5Oeh10U4vvySoUv/xZzuGtPe+zvdxuix7xofAjBixAg2bdpEqbOSBimFzr3zD/jaO8RaeemSvlz2xnKcm75DMlSAJXaf1pDdM2VG557G+RNu473/u4MMXy4Ywdw3rj2E7NYnuJUC2UK5Gs3NgVt4QqcwZd6jEN8J8s9iwORzUXQ65k19HfPaOoakx3JW5KXgctEyYwdRU3LQfD4qbr2VUEsbP+jOpYZ4zHiY0vIadu9Enh/1PBd9cxFf+r8js3c0p60egrW6O+nSnWRcexYmczznn6/nvffeY/369cTExDAkL4+yq6/BX1KCEh2N8cl7KC35N57qZdy7+F4eHf4oaCG2b/8XJuvXANRU51Bc0pfGgu14ln6Hy7/7c7bgKbmb6NivCRg/ICLrO+JiA1iyH+eDGjcf9e5P7F//yb9efZqkuhpe+O/9fHLNjQTPGE+c5UkCjmXoa/5DvFzLvdJ91FaeT8uOkbBX5FSBqhiFoiQ91TE6aqMVnJaDbTcQBH8QmjzQtO8zEpBjMdLTbqFXhIVedgv5NrMIJ4Ig/Cac1EEEwpvPNTnDq5J2zMklp28C2X3iqdzWwoqviqne4WDee4V8WPARRcYijLKdhuphZMRYuHxIh/3Ka25uZsaMGQD0792LNe+/iaaqdD1lFNtyt0J1PVsat+wXRFSfj+p77sE5cxYJp55CTXIyLaNPQZ7/PChAp7Gg0xF1zjlcnmNjzro7WdoxwNbbb6TD5deRcMftAMTGxtIlI48tOwtZZyqjZ874n33tg7NjeXByN2K/fhKAktRJZOnCLTXbmrcxp2wOEhLX9biOqKhkppx3N9o8JwHVx+IVb3Lm2Hsx28NJd/v27dRUVzHWYqC2Qye+2VzHbYGbaNLsXD39zxCdCSm96XXGJF7f8ibZq0LkldtoljfjIwWW16CLMdP6w8v4thTQkN2RTTHhpfIn2zdib90O084m46pZPDXiKW6ZfR1G61tU9lxN6vpbsFR1wfVZPcaLYsnJyWHChAl8/fXXLP/6a+KXLkNqaECXnEzGG69j7NiRZzrEctOcm5hZMpNEUxQj9Ftobl4CSHRIu5PCdXpCcjkFXU1ENXmwyjL5YzqSPzyVyHgzMIiK2qFM3fIJcxqHs7mpdM8bm5PH10+/yIXPP4lt5XIueu1l3PUy1bF9KdpuQ1b+j6T+7xCRvpqkPh+QkFdJnP1uKuMjWYSf2Y5WKvx7DVbeJcIVwqxKaBaFVkVD9atYvSp2j4bdoxLp19D5VNxGmRarjMMq02JV8Osltrt9bHf7+LQ2PEDZKEv0j7Byaoyd4dF2utvNKAdZO0cQBOF4OOmDSHV1dXh/mWCAzr3DYxEkSSKtUzSpuX1YN6ec+V9v5Fv5YwBc1aNBtXD3GZ0x6vb9K9Xv9/Phhx/i8/lITUmhbsH3eF1tJOXkMfbam9m26SWWVC9lS+OW/epR+de/0jZ7Duh0dO7Xj5rKSrZvWc9QNEjIB3tS+7G9e4wjrzSXbS3bWdBNYvyrr6KkJMDYNOrqvyc6civQjVKtlpq6SpKT03729V/c1Uho1loAbt7ajTu31jGycwLvF7wPwJgOY8iOykZTNZRNAYLADs86Kuq28PGD/+C8ex/CHBHJ/PnzARg0oB9jxvQj4ZstvLW4lAeDl9PoieDOaecjXTmDr53bWJRQQt3gWE5dG0/Vzq3MiWhgqP1MmAXeDU2ossy6ESPA5aJPnz50PuVqePN0qN8K085hwKWf8UB2BkbvFqpjNsC4VtJ+iMGzqZGmD7YSc1Fn+vXrR3NFBfZHHkVyOpHSUsmcOhV9SnjWz5DUITw49EH+ufgezA1v0mxSUWQrRt/d/PhiKqo3gCG6Db+xmdbItfSb+yOZkcOJOPNBAqrGJzVNPLOzA2X8BSSQNJXeylZuyBnA+ORsdLJEc/pzLH/uW0oa7KiNBmhsASApK5mcDk9iSJjJmtppzLFlsJA6HPWe9s/FLEsMi7bTx2YmqTGIcYuDxrUO/N7wzBsNCOTaqe8ZwbpkWOvyoAG6oEZaY5ABzRp5xQGoduIySFTH6KiKUaiN01MTr8eBxqKWNha1tAHVROkURsbYOS0ukpExdiL1J/2vBkEQfiUn/W+brZvCff2K173fTBZJlug9NoOvddPwlrnQeRNobepPns3EaV0T9zl292Z2tbW1WK1WolrqKKsowxodw+S//h86g4GusbuWev9JEGlbsCAcQvR6Ml59hYS8POY99xxl9W14MWDKHrnP8ZIkcU7euTy64lF+HBvJoO4NVNvvR1sffl6Ogri4CBoaOjB9+v0MHaYjOelsEhJO3/8NWP8BCiF2GLuy2ZHCn6au4sEp2cwsmQnAxZ0vBsBb2ESwwYNk0tH7unMpemw9DWWlfPTA3fS97FoqKyvR6XQMGTIEWZa4f2JX4mxGHv+ukBdCU6huieH+t87mhcxwoJo45gomnTOKL/77II66Wua4pzEodhIpPS6iZGgPGl01mM1mxo4dC2YzXDY9HEaq1uB/bRD2TgG8Bh1vNOipCT3I25NeJOorfziMvL+VqHM6kvvZ53icTtxmMwsHD+YiRWHvT21C1mlQ/RwWfxFeFdZvOIPIrUlAiLi0CE6fcD4L1s6irKyMhacMRZo7l0/jUpg6eCQVvnCLRZxex0XxMvkN92D3bUJXFEtp48tsW6yjZEMDaLGggMVdS1LNcjpEtpD1r8eYJxuZWjWGHxnY3itjo43R0QampOZxakwElt1dJx2B/ukELw6xc2Mjhctr2LmpEWl7K6nbW0mT4KLuMdT0jGB1lMoifRuliUBnMPqNjG6V6V+nkl/Uhn+zFw1otMvsTDFQnWNlmw1agiGm17Uwva4FnQSDIm2cFhfJGfGRpJn2734UBEE4Vk7qwaoArzz7P6qbmkmQgtz4z4f2e77MWcbkLycTVIO4y65Ca+vEJW1GBnaNZ9zV+RjM4Sw3f/58fvzxR2RZpm+HFLbO/AJFp+P8f/6HlLzwYNHKtkpO/+x0dLKO5Rcvx6AY0AIBiidPwV9cTMw1V5N4110APPfcczQ2NnI+X9H1ssche9Q+9XJ4HYz65FT8aojbErxkGlVkp0ys/XSUzcnURlWwoDgBUOnbbwYWSyspKRfQKe+fSJKBQGUVupho5DeGQ+MOghOf5a6inkxfW4k+eimmpC/Jjsxm+uTp4aXnX9+Ib0cLtlNSiRrfkebqSj759704G+vxZXcjYDAxePBgTjvttH3q+eGKMv4xfSOqBskxM2lLXECCMZpvzv0ek86E2+lgxhMPUVkY3gOnQ2QvtiWb8EtBJkyYQP/+/fcUVruZ0DvjUdwtuE0yLVMe4pHKAuZXzMdusDM19xVM0x0Q0kBtoHXWQ8hGmTXnnEOhz4vNZuOaa64hOjoaVQ2yafOt1Nd/S1CVebFeT6lXz5SaG7hk9Fnk9ktEkiW8Xi9vv/02NTU1uPUGPu8zgjaThXidwk0dErk8NQ6LIuPz1bJg1gOUr+qFpyG3vcqZPeLoPTadSGcJxbfdzldde/LJaZOpjg7PZJKAU6KMDPe9R577IxQgL/de0tIu/8VtBryuAEVr6ihcXkP1Dkf743qjQkLfOMq62lmg+FnS0sbutXYVVeMMv55BdRq6QieupvAeRKoENQl6anpEsDlOofQnC7D1tJuZEB/F+PhIciymn62TIAjCbmKw6iHSNI36Xfu6ZGZlHfCYp1Y/RVANgrsTIVcnruyWQtIKBzs3NvLZ46uZcGMPqhp28uOPPwLQOy+HrdN3dWtce3N7CAFIsaYQaYzE4XOwvXk7+XH5NH/0Mf7iYpSYGOJuuKH92Ny0OBobG9km5dA1Y/BP6q1SvfNJeph8rHLr2KDmMfjjIMzfiW10P2RbR9LzO1CjW8S2bdtobjobi2kqDQs/xv/SPMzr9YRqwmuM6C1BDFEJGJRS/tknntghGbxfHR6UGxU6BU2DYK0L344WkMA2ONy1EZ2cygUP/If3n3iUNoMJVBVDYy2qGkKW93RZXTggg4xYC7d9tBRn7GpkoGelHWPtFkjtgyUikqFBHSvqWyiNj6LQ1ERASsAeNJDriN/ndbdaFTZ1N9NrvROLV8XyzfM8cfEHXOd3srZuLdcV38rUC16BDypBjsNy6t1ET0llytDevPXWW9TV1TF16lSuvvoqSorvp77xW9SQjqpFN6GPXosavYqv017n9LRe5Mnhlpv13iDfdB9CR+f3RLvbmLxuIZGVdZzXWE3uiy+gU2SqdrSwYkYlldvOA0CSA0RmLqP/Gb3J6z4KZzDEG5WpvPrwszSEwrk/sq2VCyOMXD2gJx3MRlT1PrZu9VFd8znbtj+Iy11EXu59yLKeAzFZ9eQPTyV/eCqOejeFy2spXFaNs8FL5ZJalCW1TIg0cEX/eIryLMwOeFjldPO1KcjXGWDIsDIhFMPA6hBSoRO51kvKD430ARzROup7R1GQpGN9yM/6Vg/rWz08UlxNnsXEhPhIxsdH0s1mPuieTIIgCAdzUreINDY08Nzzz4OqcuUF55KZ32Of51dUr+Ca768BTcZVfCu9kzvz0XWDaCxvY+ZLG3A7/CgRPhoj1hAIBuiYkkT93G9A0+gzfjIjr7h2v2te9/11LK1eyn2D7uOcpNMoGncaIYeDpAf+SfSFe9YXKf72RaYuq8MqB/jrvf9G3rXIlar62bLlLmrrvqbIq/BcvRGzzsz3w96j7uI/YR5yP5JiIOHW3tSFWnj99deRgImLFmCpqN5TEUWGkMpPqZ068s+BpfgzFZKcI+kQl8YFUja6dSZsnToQd+meWTiapvH6669TWVmJvrEWU1056V27M/6WO7HF7Lt2yVMrn+etLa+g+uJwFd/OGN1mHrpgINY6jYqbbgZJovXeu5m5rQgkCfPOQjrrchl8+gXET+5CUGtlxcrJeL3lJJr6kr+2FKm+EMwxtJ37Bpdteo4dLTu4cHMU584zYh50C7IlBtmqJ/aKrvii4M0336SlpZmuXdYTG78RTVWoXPxn0rJOZ8DkDO5d/Q/mls/FrDPzz+HP8bkzgW/qw60NcQEv561fhOZqw+ZyMXL2HKQOvagYdj3lO8Ir2co6ifxhSVg7vk1L26e4sLIs+lE+aU2nddd7nWZQuHD+94z54B2Mqhr+3M87r/39LCt7lR1FjwMa0dFD6N7tefT6n1/pd2+aplFT5GDbilq2r67F59rTshGZYMbeN44tWUa+87rZ6tqze7FJgomqif5VQdjqpK1hz3Mem0J9nygKUvWs1QIE9vp1kW4yMD4uktPiIhkQaUUn1jQRBGGXw/n+PqmDyMI5s5mzcBGK18U/HnoERbfnr8+gGuSiby5ia9NW/E2D0TWfzaxbTyEjNrwse1uzjy9eXEaxZymqzkuE3oy6YRESGj3Hjmf01TcgHWCFzGdWP8Mbm97gnNxz+PN8I03vTMWYm0vW9M+RdHsaqELTb+K/6+34MHH11VeTkZFBKORh46abaGycjyTp6NLlca5b+hqlzlL+NeRfjNqSTNvSIKq7CWu/ViJOG8tbjz9Blc1K9o4d9N9agL+ngrN7E8FcjSFLnARbwNfjbzjb6qmr/gZflg9/Rw3tAMuc6OQI7JHd6JBxLTExwykpKWHq1KnodDrGD+rHonffIOD1YLZHMOzCy+k2ciyyotDkbWL85+NxBVxMjL+dzxbG4td0mPBxTvFizt4yh9TLLub75CSKi4uJMRkIrA2vt2GUzXTLGoF98lpaXD9iMqUzoP8X6AMqTDsHqtaArKN1+F/5v+Xfct079Sga2P98M3ppMIEqF+hkYs7NpdroY8HSO8nIXIWmgaPwZoaMu4rknCgA/CE/N835C8uqF6NJJloS7kE1duSSlFjuykxC727jnXfeoaWlBYNfxtbSH0U1IsnQZUgK/cZnYo8x0eIP8J8NX/CRMwWPFF5lNs9i5JYOiUxJiEYJBqi+916cM74CIPbaa4m//bb2n5f6+h/YvOUOQiE3ZnMmPXu8itWafVg/26GgStmWJrYtr6FkQwOhwJ7QGZVoQd83hk1pBub4PRR5fO3P6YHTQwYGVIXQF7biatwTSvwmmYbekRRmGFklBfDu9asjWqcwOjaC0+IiGRFjx6472HRjQRD+yEQQOURvvfAcO+sbiZNVbr7/wX2ee2zFY0wrmIYWMuEquovHpgzm1B5JLG1po8Lrp7q2DmnuTHReD35koretQQ4F0YaPI/msixkQZSPHYtyv6fr70u/56/y/MizYkb88XQzBIOlvvI5t6NB9K/f8AD5t6MgmOjNkyBDGjh3Lho030NAwG1k20b37C8TFjuCNjW/wzJpn6Bnfk+f8D+BaVo2/ZB6+gk9RrFZqdApzR49GliT+cvPN2KOsFG77J/Lqd+m8w4UvJpXy8VdQVv7GPnuhyK1gKNXRlpSByeYgaG7cp3qRkX0pKe7O5s0h+vfvz4QJE2iqquTr/z1GfWl4356YlDSGX3IVn6vzebfgXbrEdOHDiR9SWN7Afe9+x6rW8P480f5WbhgUQfWWFSiKwk033YSzvJTZL7+Aoym8xoveGiCpTzPjLn6VqJhe4Ur4WuHLm2HLF/hbFUrmJKN6VeZ3k/ju0jxePPVF9F82490aXlijNGEhvl5vALBj+wAUZTQXX3wxFosFVdP4sKaJR3eU4q/8DwbfVhTFzsOnvsCE9N4AuBw+Fn25mRXbvyekeJGDJnK2aXSpWkDeEw8Q6NuX1yrqea2iHmdwVwuItpNz+Jgz4iLpnv8EihIOspqm0fD8CzS8EN7FOWL8GSQ/+iiyMZwAW1sL2LDhOry+KnQ6O93ynyU29pTD+Onew+8NsnNjIztW17FzUyOh4J5QYoowIPeJpqCDkcX4KfL625+TNI3hAT1DalUidrjw1O2Z1RNQoLarnZIcM2uNKg5tT5k6CfpHWhkVE8GIGDv5NjOy6MIRhJOKCCKH6D8PPoBXhT6Z6Zx55TXtj3++/XP+ueSfAHgqLiEzbjiGvnGsaQ3/Ik50NHHGpqWYggG8kkTstnXIwQBL+o5gcb/RsOuXbppJz8iYCEbuWqvBrlOoaK3gjM/P4O+fqvTdrmIbMYL0l1/at2KeFnisA5vI41MmEBsby9lnx7O18P+QJAN9er9LVFQ/ABo8DYz5ZAwhLcRr9f8mtT4G/6YX8ReFp9AY8/L48YzTKa+tZciQIYwbNw5N0/A+l4dLa2ZTlwhCunB9PfosZtZVENecwVU/ROPdsBnruEeQzdE8rjhYba7i1PSVjEhbhCyFv7BaWhIZ0P8x0tOHAxAKBlj/wyyWfvYh3lYnLlOQz0dUE5JVXh7zMkNTw4Gr+dPP+eyFD3gzfwI1tlimGDYRIfuwdcjnmvMnE201oIZCrJj+GitmTifgCrdW2Wwx9DjtDLqNHos9Ng40jdDCVyi96yn8DgVTvMpLl9uZZfCRZE3iofSnCHzpIDZqI1V9ngY5RETobOasjsXr9RIfH0/ulHN5orqFDbs+3yyjSmz9f9nZshmLzsLjA59CvzGRDT9WEPSrhGQvbUmb8asu7H4/vRYuZubQUXwxbhIuKdyq0dlq4q+ZSfQNLWDr1r+jaX7stnx69HgFkym5/aNumf4F1fffD4EApp49SHv2WfSJ4bk9fn8DGzbeiMOxGpDJzf0H6WlXHtW4DL83SOmGBkrWN7BzcyMB717hU5HQukZSkmNmtU1ji9+/z7kd3RojmyTSyn1oFS52Zw9VguokPRVd7GyOk6mU9u3yizfoGBJla78dKKALgvDHIoLIIXC7XPz38ccBuOzsKWT36AXAmto1XPPdNQS1IL76Mfic4/ANTQBDuKn5FE8LXVYvQgoFUUJBzDs2IqkhQgMnsMrQi1aThCveSGmEhOxTsfo0LD4ViwoD4+ycnhjFp59fyzXTWzAEW8mbMR1jx58MlC2aC++ehTcqh/86J2MwtDBw0PeoqoecnHvokPGnfQ7/y9y/8GP5j5zdMIrLfgwR2LVbL0DcLbfQPHYM77//PgaDgdtvvx2lcQ2Fiy6gLmF3/4tETs7d3LDyMyraKnhwyINMyZ5M7ePvEWzORPU6cYfmcm/uJFZVuYgyOrg6+zO6pGxAllUkSU9Ozt/3+ZL0uV2s+OITni96nS0ZDhIbjVxU1ofuI8eRm9uVussuR3W5iLruCj72NNEcsODRdHzm64GsKEzokcr5faMJ1lyC112DZ1M/ylaq+NTw5oSSJJHZsy/dRo7B8Oa7eBYsQGeVyBxTjd6sssSWzIKmc7E3jcIYVUbmqMeRdF7s1YNI3ngdcn4UbzSv5OuUNMpiwwNT7YrMHZlJXJMWhy/o4s7v/oZ/vZ0e1SMwhMKzRRKzIhh8Vja2RJnnpr3PQnscW5KzCOzqVsv1tHFX365MTIhubwVoaVnFho1/JhBowmCIp0ePV4iM6Nn+GbmWLafi1ltRHQ6U+DjS/vc/LH3Ca9qoqo+tW++juuYzAJKTz6VT3r9QlKOfvRIKqlRta6FkYwM7Nzbg3GtsCIAnUkddvp0dyXrW60O49vpVYfKp9GlQ6VOvEl3hhb3GozRbZUrTjZRnmSm0g/cnmSPeoGNApJU+EVb6RFjoYTdjVURXjiD8kYggcghWLFzAzDlzkQM+7n3wIWRFYWdrJefOuABv0EHA2R1PwyWE+iUwJD2a02PspJQWsmLePFRVRedyYirfgdFopN+ZlxOV3JfSDY2UbKhH238M6M/QiIgzY0uwYEwyY0u0kNYxgsQdr2Ga/zBK93N41z0Mm+1lIiLriYoaSJ/e05CkfceezCufxy1zb+H8xTrOXRD+MomYOBHn11+DXk/mJ5/w1tw51NXVMXJkN/TBf+OR2kADoykZn68aFDsPVwTwSpHMPm82Fr2FuhfX4S9rxbftG/xbvsQyYAAlf7mfV1dW0LFmHhZTG9bMQrolbgbAGjmGfj2fQKezA1Dvruf0z07DrwYYvyaNhJrwl40ExDtcpEXFkf/4E7zz4Ue4XG4S1Uq+CfRkk7YnmEUaHfRKLOfcIefR2yuz87MfKKpbQ723vP0YJaQS6/GRN+UsckybiN7xIbKkoWoyG7XhVA4uwmj0EhU5kKzq+3EvCu8c7JPhy1Q973bQkdhWxRND+tAtIw2308/G+RVs/LECnzv8BdtgqSBppI5rJ1zIRpeXV8vr+bK2md1fv/GtLVz4wwymzP6WyNNOI/mhh1Bs1vY6ejwVrN9wLS7XNmTZSJcuj5GUOKn9eX9ZGRU33Yxv+3bQ60n6v/8j+sILwj8lmkZZ+Rvs2PEfQMNm60z3bs9jsRx4pteRctR7KC9oomJrExVbm9tfO0BIgso4HTVZZsqSDOwwaQR2BwxNI8ERIqcuSLd6lfg6P7I//D9BSIaKWB0743VUphrZGaUQ+MnQKUUKtyDl28zk28x0tZrpajMTazipJ/UJwu/aby6IvPjiizz++ONUV1eTn5/PM888w/Dhww963vEMItNefpEdNXVEK3DT//2Ttysq+N/CGyBYRsibjKfuZq6Y3JNbOqdQVbiVOXPm0NLSAoDO0YSpqgRzRA4oIwD7Aa8RksEZqcOdZKTBLFOnqDQbJFwmCZdRxqeX8OklQsqBm6kVTcOu+YiVyoimhe7Jp5Jpi6aT1URXq5l4gy68oZsa5B9/G8xVX4e3tk+8526iL7+ciptupm3uXIxdutB63738MPctunX/Eb3eg8kbIifydlrNk6louoGQvB2PJ4Kd628j1dQdsy9IvsOHCtTaa7F+8iiS140usyM1N1zL7HXr8Jqi+cidw8ikBVyYNx2dHKLZl0CVfC+d0vqypPlNPi/6gN4JvXltxMtsW7aItR9Mo96xZzMUX1wy/vhUTIrMpP5dSaj9gYodq3nNPJo5roH4QntGzSqyRI/USDrJCh1Kqogq+45G/058P1kFVJHNJJpayYwpxz/CQ9AqEfKoFAfHsKXjXRTtaOXGQi89W8Jflioa25UqtkqNxEZ1o6VUJRQM/28RnWyhrutmXne/iM/SG2v8hdRoce3X6m8306tsG/KG1UhAl62FdF+3DmOHDqQ+/RSmrl3bjw0GW9m0+XYaG8NTvdNSLyMn5+721g3V5aLq/+6l9dtvAYg67zwS/+8fyKbw801Ni9m0+TYCgSYUxUqXzo+QmDixvfyAGsAX9BFUg2hoqJpKSA3h9XhRgypaUCMUDKGFNFBB1VTaAm04Ag6cASd+zU9ACxAggC/kp83hxtMcwNMSwOvwE/KpyJqMrMlIyHgNSvhmMuA26vArejRJhyrrMfkNRLplotogrk3D7JWRNIUQCjXRZqpizFRFG6iK0+M0H3jPm3i9jmyLkSyLkY5mI9kWY/smflE6RXTvCMJv2G8qiHz00UdcdtllvPjiiwwdOpRXXnmF119/nS1btpCRkfGL5x7PIPL4gw/gUoG8bGZGNtDW8A0KtahBK+aWO/noirH4a6v5/ttvaW5tAUAK+DHWV6JztmEwj0Q2dCGgl/DEGfFnmHHHG2mO0FGn0yhq9dCoB+04TmmM0St0sZrp3NJEyusv0bVkBxU9jFz28mwAgvX1FE86k1BLC7o7T6ekw0wUJYjcpqPvhlbeq3gLFT2K0UmHUY9hsNfhacyibN6ddDeayTLIbNDDW4k6TO4Krv/0aWKdzVTGJ3LbbffSEBP+QlZCGj08hVxjfJpoXQNBVceiHZdRWxNAp+mIVHsSZ4ojUvUSseZHmi0yTV2zadX5qDH6CSk6lOY69O5W9AE/0TFOOg4sQUeAxhWJFDVms17XiTJpzzL3Peu389CS11A0lVmdhlOenEm8pwyjtwoJFdkQImfSTixxPvytenbOSMUaDGIyqtRFJtKS0o1TUgaRWRWJVLvnL39XSKMmqOKJNpJ5ehZVHc1Mr29hRm0DPm1Xi44WZFSUjr/l5tHTbkFVVX788UcWLlwIQGpjI30XLsISCpHwt78Rfekl7V+amhaiqOgJdpa9CoDVmke3/P9hs+Xtel6j8fXXqX/qadA0tMw0Gu68mPJUA7XuWtrcFXTyLyROCoe5tW2RLKxNRPIZMQfMWINWTEETRtWIIWQgKAdp1bfi0rlw6V24dC7cOjcexYNf9mMJWYjwR2AP2LEGrViDVixBC5agBUX7FbpLNAmX3kq9LYYmWySNNjsNNjsOq/kXTzMByYpCslFPstlIssVAglFPgkFPjF5HlF4hWq8jWqdgVWQRWgThV/abCiIDBw6kT58+vPTSngGZXbp0YcqUKTz66KO/eO7xCiLlxcV8/P7/2GS3ENQcSJqEFlIwBGyYQ4lIBvDpJEKKQkDR45MVggEfgRD4rMn44lJx2Y0066GNX3779EGNmNYQCSGJ/MwoYmZ8SExJMYs6N7OqUzLdOt7MMuee6ZPZMpyz/jPyGlyUWHtS25qKw2ik1SzjsMi02BWa4vTUGyXUA/xulUMtDItNYFB0DL1sZmzfLqd20zTMY5YiySrNzUlUbenNmLZyFnnvIDrJQqOpmlXybDLzmymRs6kMDeDZeXYsIbhmgJn10eEWh6T6eh55+RXMQQs18bms6zyESLdChEdFAmSDi6iB79Ga3EwNSZTUjaDC05Vmm0yrWabNJP9s688vMXtc2FxOzG4XsieI1elmyrpFZNZWUqxP5Jme56Ht6q7SqwFSg5VcPfA9UuNr8Xv07PgiA7/z55cpjzWm0jlyAEnmjlTYDayJVlgbrbAsVqHZuOev9Ri3i6zqDaRVLUUONpLlt9HbY8ckqRgljRqDhXWmWFRJRq+p9PW10DnoQSfrkRUjEkYgfK9J4dYDNANgBM2Mhh4NGQ0FLSSDXw6HEU1F02uEDKASIiQFaMn+AVdWeH8f2RWLUjABlyMZp85Di+LCoWvDoXPgUtx4JR8eyYumySghI6agBXPIijVoQznImoYhQgSlICGChKQgIVRUQmiSiiqF/0tDA0lrvweQUXa1nigoKOF7TYei6dARvpf4+Z+FgKzQYrHRYrbh2H1vttFmMuMxHN74GElVMYSC6IPB9nt9KIRODaHb+15TUVQVnaqiaCF0qoZM+L9lTUXRtF03FUlVw5+UpiJrhB8DZC2EpGkoaEiSiqSp4X+jIWkasqQhARIqoLW/A9KuYyA8W2n3+7jnOfY8t/vfEr/wDgrCoTPrDNx4673HtMzfTBDx+/1YLBY++eQTzjrrrPbHb731VtatW9e+UdpuPp8Pn2/Pl7LT6SQ9Pf2YB5G7X/o3b3eedPADD1GkTiHTbCDTbCTLbKSD2UDHXf/2l7by/Rtb8DjDMxCSapaRW/UdD98ZxRZPMU+NeIqO8cN5vaKBT2qaaNu18JVeC9CPZYxgEx1qprBjVQNWNRHVG/7iCCjQEKHQaAvQaHVRnmSnNCGq/Qt5bwlaDZkUE98SQqoGi8vPlOxY3MMns6SljQ/KtuBR9uzCMqXcz71bfFSZJN7NtpDqULE3+KHeByENvwItNoVmq0yzTabJrtBgV2iIUHD9TDP73nRBDVMghCHkQtFU9H4z+pCCKoFfJ4VvegnvL3Rb7c3o9WB0uZF9KlJQoW/sUvIs29CHfMzYPAFvQwxpfheJwTYSQk4U1YdP8eGw6HHaTDhsZhz2KKoT03GbrfuUHeVXGVsT5LTqID1aQhzs1TVKrSzUF9Agh3d0TlAjGRboTIxmO+jrOFxtcRuo6fomIVMLAJHlI4jffj5K0EKAILWyg1q5hRrJQYPsJCCF9itD1iQiVTMRqhGLqsccUjCFZIwhCX0I0MLBQ9VUVC0UDkXhjh/UXf8O2/UvjfAmgABI7WFDkuRd/yXtap2QUCWJkBwef6LKEJTC3ZlBSSMkawSlvW6ySlAK3zwyNJuMtJhNtBpNeAxG3AYT7l33Pp0er96AV29AlcUgWEE4mK7+AuaedtExLfM3E0SqqqpITU1l8eLFDBkypP3xRx55hHfeeYfCwsJ9jn/ggQf417/+tV85xzqIPPz8v3il62ntf5ns/otDQkVPED1+dATRE8CEBxttROr1xJvjSLSlkRWRRorJQLLRQIpRf9DFmzxtfpZ9UcyWRZWAhE4K0tq/gnel/3FB1wv4x8B/AOAKhpg+5zXe8Uez0dap/XyTJJFUX0VWUx3/N3o8oZ1eyjY3ULG5HlXa8xdtQIHKaJUdSR6ctgRqEwM0mA78BShpKpImoQuBIaBiCmjE+MHuD5DtkzAjUR/UqJXBbZDwGGU8Bok2s4zL9Mtfx0a/G6u0k266KpKoJtYtEVicTqsE7lMGUBQTRfKqReTWVVAeHc/szoOJcqnEtKmktrhJdXqIcpqxtqr49RJOc7hFxWkJtwo122SabQrNNhmP8eDB53AYQn46txSR37iVng21dG/0otcS0ElJ6OREFMmGLBmRJD06ad9WlpAWQtVCBLUAW3SVbDRUEpRUJA2SfGaSPHpMvhAh1U9Q8xNSAwS18C2kBsMtDZoabmXY9SUv7frJlCQJCRlZklEkHbKkoEg6dAYVS+/N6HN3ABD0WijfPoDKpjS0n3RH6DSZONVOghZFnGonRrMRoZmRDxqvfls0VEIGJwFTE35TI35jM35jE0FjCyGjk5C+Fc3Qhqp34dNJuLDixYwHC55d9z6M7Tf/rvvw//F7bkF0hNDtulcIokNFJoSyz3243URGC3cK7m7/aL+pyLCrvUPbq31j92+d8L/3bx/Z/3X/1IGOEW0kwuHr7NvBd2dcekzL/M0FkSVLljB48J79Uh5++GHeffddtm7dus/xv1aLiBoM8fp7V3NK8xziNhrw1ujwOq0E5Fi0zGTomIyaaMZvaMAdvRVfZOk+59vt3ejQ4QYS4schSYf2F1ewuZnV4y+jMOscWiM6AODWt9KQWsSdl1xLXJot/JfiqyPYYtvOkqSuLDZcwDppMNX+wD5lReoU/vrJOwyZ/T0N8fkUDLicoGpGc6souz7NqI7zSeo3jTZsrC8/l21No6iP0FEfKVEfKRHQHXgPk0MVKUskVZaTVFVBhzYHvSZPpEt2FlFBFxd8MxGP6uZq90Tys75GMbgJuGKoXHID3uYsNIubhohV4fcgZxTFcTHsMLRSi3GfFh1Z1YhpU4lzhkhs9jNyzRasfgWPKQa/IQKJcKtJi1XGGRGA/OU47BpNxNLg6IxLs+MxSngMMpoMiiShkyR0ioRJkYmQfbhcRTS3FaKEGtH5y7AEK+kZ35X+Sf3pYulCXUEd2zdtJxgI7vrs7WRlZZHWIQ19rI7PSz7n+/LvcasekMAg69FLelwBN+aAmZ7NPUn1pLa/JktrG1FNzXhirbgTk/C4g6ghFaPRSVbmOqKiqmkJaVT7TJR7OlAnyVSEqjA2u7litkrvEg1VkqiLi2RNvxS86ZkYvDZMxlpycpdisYRbYtraoqmv6E2kL4dUo0KaUSJGF0RRg2hBf3jAagjQJLQQaCEJTZNBk3fdS2iaAru+aNsfR0ZT2XW+hhZU0ULqrvsQWlANdydJGpoSQtOHUHUqmi6Iqg+hGULhe0kFn4rmATwquDTwaEju8L9VzU8wyk0w0kUw2kMg2kMw2ksowk8wwg/6w/i1pUrIQT1KyICsGlA0I7JkRsGEIpuQFSuKYg7fdGZknRlFZ0XRW5AVI4rOjKQzoeiMyIoRWWdElo1IOiOypEfW6ZFkHZKsIEk6JEWHJOtAkpFlHbS3Asn7/FuMWxH+yH4zQeRwu2Z+6ngOVi1+cxolmf9EUQ0Ms9+CbulLODfVUbsmlqB718Zk5/4JJXEEnvoqXHGbcKdtpi16LaoWniJrsWTRIeN6kpImI8u/vFV60zvvUPvofzB07YrntmdZ/lUR3tY9gyRjU61k94zGvPlGageWANC3z6fYbT1YXdfGa2vWsTwUot4ezeiVi/m/t8Ircv7jz3eytEdfACRVI6N8OuO0FYzosB2A0vJx1K4/H1NAwxL0oWkyDnsZjdGN+HUxuNQkWixBIhJSMUTYsHgCyA4/AXsbjtjFWKUgndPPwqZGsXDWTMwBH3+97FI6JsYTqKuj/Jo/4du+HdlmI+2FF3jbuJKX179Mp+hOfDzhIwr+fj01A5dCrBdN1VG34SJK6iMJGB0YPfFEOLpgS1lH6pCX8Ms6thReQXHTMBrt4VYPr0FCrwtw4/tP03XbZvx6Ay//30O4OnUlzq8R49XoqDhJDt6DqhYhYSHB+gixscOxRBow2w0YTL88DmJz42beL3ifJVVLaPA07Pe8IWQg25lNrjMXvbpvgHPpXDj0DiqsFdRYaggoe0KjpElEhaLIdGcS3xqP1W9tb33Q0AhIAbw6Lx69B3+EH6fJSX2oDq/mQ0NDRsYcNGMJWohQI0jRpRDrMBPwSKgH2D4gISGKjh23YTDOR9v1M2q35ZOVdQtxcaP3m/b9SzS/H39ZGb7iYvzFJfhLivEVl+AvK0N1ONpfgxoNgSSN4O5bYvim7toeR/KCrkba56avkVAaQFIlQjaNYPKuW+KeMkIxB6uhhEGJxWhMwmROxmhKwmCIw2hMQG+IxaCPQa+PRq+PQaeziy99QfiV/WaCCIQHq/bt25cXX3yx/bGuXbsyefLkEzZYFaBp+ja2SNfhiygnO/tvZMadCy8PJdRYQ11lP1qWVwKgT0sj/q9P41rZiuoOEtS34hm9mjr5c4JBJwAmUzqd8u4nLm7UAa+laRrFkybh31FE0j/vJ/qiiwiFVK5/4w4idqaT09ILLSQBGhkj/4slfgeO0kHUrvkTakgDDfz6FhyxG7C3uBj3w3foQgEWDZjEojPOxy9p6FJs6KNNZDqnMtQ3FYB620QSsx8k02wio2IhyvvnEAro2fBNKt+cOZmgLLM0YSm6JB1fn/U1BDWqHlmO5gkSfUUehZ47aG5Zhk4XgdNxLatX19G5c2cu3GtzvpDDQflNN+FZtRr0el6YrGd+rp8nT32S3jMKaXjxRbRIA76nutHkWwZAbW1HiosGM6b/RWjaJtz6+0AKgGs05uBdmG1GzHY9FruBmMgQ9XfcgnfDBmSLhbSXXsI6cED79dtc21m37ip8vmoMhjh69nyDCHu3I/qZ0DSNUmcpq2pXsbJmJVsat9DsbcbpD3/OsioT64slwZNAvDeeaF/0Pt0aIUJU2CqoMdfQYGrAq9t3gTB9SE+Htg5ktWYRETi6n2ejohDV0EB0TQ1x9Q3EORzEn3oKUedfgL5PLuXlb1JeMZVQKLwhn9GYTFLimSQlTca2V7ef6nLhKynFX1yEr6gYX9EO/EXF+MvKIBQeU6KhEYomHBaSNIIpGsEMHYGEcAsHgOTbFTiqJfRVu+5rFJTG8K8X1awRSAmfG0jeVUYyqPaf//Wj10djNnfAbM7AbM7AYs7AZErDZErFaEz82Z2JBUE48X5TQWT39N2XX36ZwYMH8+qrr/Laa6+xefNmOnTo8IvnHs8g0ra8mp3L36Km2xsYjUkMGTwPuXQJTJ0MaLi7PkDVqzMJVFSgxMSQ+uzL+EqMuFeH9z6xn5VCS/JcysrewO8PL5AVFzeGvNz7MZtT97mWe81adl58MZLZTO6C+Sj28LojDy17iI8KP+KSjpczUbuY6q2vIudMQw0aKPn23wTc4T8LJQlMETrqlDmM+n4m9rY29H0HkvHMC9Q9uQYkSLlvEGV1r1NU/AQA81p1GBMu5d7B94Ur8cVNsG4awZxz2PHYKjZ07sSW/HyceiddJnXh2h7X4l5XR9OHhShRRpL+1p+Q6mbd+qtwOFYTCBjZsH4cF154x37TrlWvl6q77qL1h9mowMwpyVw39h9U3XQLACmP/YeIM8+ktPQVioqfQJI0NC2Vzp1uYPuOh1FVLwnxZ5Cf/8yupuywQG0d5X+6Bt/2HShRUaS/9hrm7uGQoWkqNTVfsG37vwkGnVgsHenV803M5vRj90OyS1AN4vQ7afG1gAY2gw2b3oYckqmursblcuF2u/F4PLjdblRVxWQy0aZrY2dwJzv9O/HLfgJSAHfITZu/DcWnEOeNxlarYWyR0EkRyJoOGQkkBXQ6JEXGapHRGZvQ6WoxGF1YLE6iIgOkpvYh1j4E/VI3bZ/PwrtxY3t9dUlJWAcNwjA4n6bMHVS1TCcUamt/3uiKxrojEt1GN/KaZuRdS5+qBo1QvEYwAYIJGqFUhVC6jkCsH1UXBA3kNtDVSnvdZPQ1OuSGEKChRrCnZSNJI5CkEUqRCEX83Cp/EmZTOlZbLlZLNhZLNhZrFlZLR/T66GP+WQqC8Ov4TQURCC9o9t///pfq6mq6devG008/zSmnHHwDr+MZRPwVrdS8uILiU+4kZHDSLf9ZEhMnwOx/waKnwBRJ8LyvKbvrAXxbCpAtFlKe/R+h1lTa5leABDEXdMLQzUpp6fOUlb+JpgWRZRNZmTeTkXFNe3dN1d334PjiCyLPOouURx9pr8N3pd9x5/w7yYvO4+MJ77Fsbh+8io8suT8dhr2Pq8WHzqBgsumRNJVV556HraCAQFQUXWfNxFfko/nT7egzbLSO+4GdZa8AYIg7ixvXfotJMfPDuT8QpbPAEzngdcAVX9O0oJjyJ57k64kTCBiNjBo/ilMGnEL9qxvwFTuIGJNBxJhwSAwGW5m/YDKwk2DQyrChX2K17r+iZ11rDR/fMJbRq3d1NykKhEJEX3opSff+HwBLlixh+fKpdOm6CL1+zwZqUVED6d3r7X26t7xbt1Jx8y0EKirQJSSQ8eYbGHNyAHA417Nt24M4nesAiIzoTc+er/1uv7hCra04vvqKtnnzcC9bjvaTPV4wGtAGJ9A2xIcrqR5Vt+/zupAFc7Ed86IQyvo2JP++X/qqScXTS8PTT8XfSYO9hzVp4e4TKSiBqiF5QHaD3CYht4LcIqFzSsi7bsgaqg1U2677SI1grEYoTiMUB9ovNFKYjClYbXlYrbnYrLlYrXlYrdntGwEKgvDHcTjf37/KGso33ngjN954469xqUOmT7QiYySqfASN2TMor3g7HERG/gNKFkDlKnTz/0aHtz6k4rbbcS9dRsWfbyT50UexDuqEa1k1TR8XEqvvQk7+30lKOovCbf+kpWUFRcVPUFP7JV06P4rd0Bnnd98B4ZUy99Y3MTy2Y3vzdraVvIBX8WH0heiQdw2KTiYibs+iTnVP/g9bQQEhWWbhkMHkmc14d9SioVKb9zb1ZV8DkJNzDxnp19BlZxkFTQV8su0TrjWmh0OILRE6DCH68mGsWfoFXQq2sqFXT1bPW87ADn3wFTtAAku/PVN5VdXI2jWnkpv3FTZbM2vXXUr3bi8QGdlrn9fy+pY3+WCshpSQzKhZ1eFmfUXBmJeHpmm43W7mz5+Pz5eEzfZ3/P6H0bTweIqWllVs2/4QHTKuRe+z0/Dc8zR/8AGoKvqMDDLefAN9aioeTxklJc+377uiKFYyM28iI/1KZNnI75VitxNz8cXEXHwxqseDa/ly2ubPx7N6Df7SUjSfH2leBfZ5YJM1/Fk6fF1VfPkagQyNoOKmNddNay5IfjAUSRgKZYzbJPQ7JWSvjHUZWJcpqBYNT28Vf56GP0sNhwdz++RbiAyPYd0zR+Nw/06RMZvTsFpysFizsVpysFqzsVpz2pf+FwRB2NtJu9cMQO3/1uBprKR4xJ1oBOnfbzoRET2gqQReHg7+VhhxD+qQO6j6+99pnRVeejvx/vtB1wf3mjpQJOKuyMeUF42madTUfMH2HY8QCDQBEgnqCOS/LsIYl0b27B/2GzQ3+YvJNLQW8WBaCDQ/+VvbSLpmBxj3/NJ2fPU1VXfdBcDGsWPYEhvLpEmTSPyulaoOr9CavAKQ6Nz5YVJTwvuTfFX0Ff9Y9A/izHF8p2Rj2PgJDLgexv+XkBri9I/GcuW0esq7jcdrNjMiuSc5JXEY86KJv3rPGIsVK1Ywc+ZM4uKM9O33I253EZKkkJX5FzIz/4wkKVS1VTFh+gSCapBH1ncmZ+Ym0OkgGG4dsQwexNqRI1lXXExMjEJ+t/eAADZbFwyGeJqaFrRfT26T+P/27jw8yvre+/j7npnMTPaVhAQSkrDJvgREBBUQKIiIWGjxaRVPrUdaabUc27r1yNN6Du2jre2xrdUuuLRVj3VXpFBRQNnDIkb2NZB93yeZmfv5404CgbAnDEk+r+uaayaTe/lm9Lrmw+/+3r9f0BEIyjYISxiK8yvDqfIeoLIyq/EztXTvPps+vX+EyxXflv9LXHFMn4+G48ebm0Z9ZWX4a2qaHz5vNQ0xXhpiPDRE1lIfVo3P3YDpMjAdJmZ9A/YjHhzFDuzFBvYiP7ZCL0aVD8Nvw+/2U5/kpaGHF3+MHX+UDX+EH1+oD7/TB4bNmgPEZgebgyBnBEHOOJxB0QQ5Y3AGxRIcnExwc/9Gkno3ROTKGxG5UgUlhdGQG0W0fwIltn+Rnf0Cgwb9CmLS4Oan4c1vw9pfYht5Jz1++UvyY2Ip/dvfyP/pT+n24x8TPGQMtTuLKP7rlyR8fySOuGASE2cTG3sD+/b/N3l5b1Fg+xj7Y9Cz+KpWO/dHJYzCsO0C00dERQMJpLcIIbU7d5L7mDXjXew995A05mq+/Ne/yNqxjJohy6kPzcMwghg08JfWiE6jaanT+HXmrymoLWB5yRFuARh8GwDrctaRV1/IC3Mj+MHaIjYlJ7Px+Jf0Yhwxo09Mo+73+1m/fj0Ao0dPYuTI+9iz5yfkF7zPwUNPU1yylkEDf8UfdjyH1+9laFEIfZZ9gREcTMqf/kjttm0UPvNbcr7cxY7kZLDZuOrz5YSU+wgbNp7k+q/ScPAYocVeCpK34ulRhz/MxDMIPINMqtgOBdub6zEMB5GRGfTp/aPTRmQ6K8Nux5mSgjMlBSZMCHQ5IiJtrksHEWePMGoy84ktmE5J93+RX7CMPn1+jMuVAEPnwpa/wNF1sO4ZjGlLSHjsUWwhIRT/8Y8U/uIXxP1gEc60MdQfKqfk9b10u3cohs3A6Yxh0MCniI+ZTtanC/DF+jkS+yGV2+bTu88PW9zVMTomCXuNNRje92A1Rp/Rzb9ryC/g2H0LMT0ewiZMoNsD9+OurmL37v8hMWUb9TY/Dm8MQ0b/DzHRY1v8bUH2IG4fcDu/2fobXgoNYqbZA6OndbfJP/b+A4DJA29h0tQ7yHrm91S7IMt2kJ7xg5qPsWfPHkpLS3G73YwYMYKgICeDBv2a2NgJ7Nm7mPLyLbz32XTesW4wYu6HFdgjI0l+/jmChw0jeORwjGvTWfXS+5g2Gz2PZpO8rgQ+dcDfNpHLpuZzxQJGZBQh99+GbXwKlTW7qKk5TEhwL8IjhhARPpjQ0P7Y7R33EoyIiJyuSweRoB7WrKOOw4lE9s+gvDyTo0f/TN++1kyn3PBDeHk2bFkK4xdhhHWj26IfYLhcFP32txQ9/Sti730AwzWE+iMVVK09RvgNJ+7acH9po9vP7FTPDaVqXB0lpZ9SsvlTEhJuoXf6IoKDk4mu+ogqA3bU2BlV5YOeowDw19Zy7Hvfw1tQgLNPb5KeepK6+uMcOPAT0tIzAWgo7M+I7k8SEz2I1sztN5fntz7DHpeTzQljuNpmI686j9XHrPlb5vSbgzsqiTFxI1lV+Tmf246Q/LW5pD36CBFTp7Ju3ToARo8ejdNpNZIahkFi4myiojLIylrEi4ey8ONgkNtHxKIGqqP7cjz0n1Ru+yXlFTs4fqw7Be6xGIaPAROqiBpyJ57NX+DZvx9ncjKuvn2tR79+BA8dgj0ysu3/Q4uIyBWraweRxFAwwF9RT0rCvews/3eOHf8rKSnftnoP0idCjww4ngnrfwtT/i+GYdBt4X0YLieFv/wVxc/9mqhv/BifpzflK47g6heDM9Far6RyxQpsHoMU5hJ5zZ0cPPg0efnvkJ//LgUFHxIRMYyq8i34THi3LIgRbjcTk0biq6wke8F3qPv8c4yYCNy/mMPn+75LSelnjZU72bd3BOW5g5gw7sy3q0bag5lVXcuroS5etNVwNfDWvrfwmT4yEjLoHdUbX4WH1OI4YhxhlDiq2NC/H0Hfv5+62beS7XJht9u5+uqrTzu2oyyIus/6sS3KmqZ/RrAX021SUruOkqNWgKmpieDAAWuEZ/ToJK6d/lNNLCUiIi10rEUm2pjNacfRzbozJaxqOJERI/D7PRw+8gdrA8OA660mUTb/CWpONEvG3XMPCY88DEDZ336B2XAcfCalr+2xpruur6dy1SoAIr4yleDgZAYN+hVXj36XmJjrMM0Gysutac5tBnw9pp5jKSHsK3qbbX+YSl7qRsr+zSD/v+rYnf+z5hASE3Mdw5P+RlnuIGqNBo5U5Z75Dzy0mm+WFGOYJmtKdrIhZwNv7LPuOPlav68BUJ1ZgM1vMCXuaux2O7lJSezr15cNZWUA9LXZ8H74IdXr11N/7BjVGzdx7HvfZ/eUyfyi7l0AbsiJ4vbr1jN61Fv0Tn+QpKSv07v3/+Xokfn4/Q7S09OZNu1ehRARETlNlx4RAXAmheEtqMWbU0368B+wbfud5OS8Qq+Ue3C7E6HfNEgYAvk7YeNzMPHh5n1j7rwTe2QkuT/5T6r/9StCp/yMhjyo+NdR7KHH8FdUYI+NJXjkyOZ9wsMHMWL4Cxw48BSHjzwL2DDw08/tB7fB0YKlkNG0tQdMDy5XdxIT55CUOIfg4GTKVx6hj687Xziy2bZ9G/2v6k+rvnybXl4vc4KTeb3uGI999hj5NflEu6KZ3Gsypt+kekseACnX9meK18ny5cvZkZGB3zSx+Xz0efc98mpqTjv0u9caHO5uI8IIYfHCf+AIjyWCWOuuI2DZsmUUFu4nJCSE2bNnY2tlSnIREZEu/+3Q1CfScLyK6OhriYq6Gr+//pRRkf+wXm98FuoqWuwfOWsWvf76MvaoEOoyXwSg8pNsKpZvBCB88mQMe8uF8bzeKo7n/C8Affs+Qn/fTFbmBMEmG6Gf2AhfH0bPyHmkpX6PYcP+zLhr19A7/QfNs4Z69pfRz5cEwN69e6mqquI0vgbY/QEA9494gBh3DPk11qywt/a9FafdiedQOb7iOgyXneChcYwZM4bevXvjb7yje3BMDD1nzyb0hutxpqdjOJ0YwcFUfHM6b0ywmkYfGvcYceEJLU69e/duNm2yGlFnz55NeLjmjxARkdYpiCRZQaQ+pwrDMEhPewCAnJzXqK1tvB1kwCyI629NCrb5j6cdI3joUNL+8TpB3aHhqHW7a0NpEmAQ8ZWpp21/8NCvaWgoJji4F91DbiLolW3c/nNIesFByJoEhs//gP4Z/0V6+gPExU5oscKvv85LfXYFMWYYSQmJ+P1+dp40vXezw2uhthRC4ojsM5m7B9/d/KvxSeMBqNlsjYaEDO+GzWnHMAwGDBhw4rPp04fuP3mMlOeeo/eyD+i/fRt9Nq7nmZEFNJherutxHTen39zitBUVFbzzzjsAjB07lr59+57t4xcRkS6uywcRZ2MQ8ZV68FU3EB09hujosZhmA4ePWCvcYrPBdY2jIut/B/XVpx3H0a0bKS++gCvdg1lfjT2iJ0G9xlPy0svUZGbSNG9cWXkm2dkvYNRCjzUjOTR1BiXrCnB6DXb3hJcX9sfZs+cZ6/UcKgc/OGLdjBhlXfLZsmULvsYFypp9aYUBBswEm52SuhP9LX/J+gu+mgZqvrBWmg1tnDvE5/M13ykDkJmZya5du5p/Nmw2Xt3/OjsKdxAaFMp/jv3PFn0fRUVFvPzyy9TW1pKYmMiNN954xr9DREQEFESwBTuwx7oBaMixLnE0jYrk5r5Bbe1Ra8PBX4XoVKgphq0vtX4sp5OkJ36CYe4FwDnwVqo+28iRb3yT/RMnsW/CRI5/5U4SfuSg+0NuapZ+gL+6Gld0PUGTyvjPb9pZWZPZ6lL0TTz7ywBw9YliyJAhBAcHU1xcTGZm5omNfF7YZU35zsBZNPgaeGv/WwDYDTufHf+MravWgNckqHto8+WprVu3UlJSQmhoKCMb+1pee+01VqxYgdfrJbsym//Z9j8ALMpYRPfQE5Of7dq1i+eff57CwkLCwsKYM2cODkeXb0ESEZFz6PJBBE6MijQFkaioUY13tng5dOgZayO7A661VpNl85/gDDPjm34/tZlv4qvIweYKJ2LmIgynE29eHt68PGxlfuxVBkaDH2ef3vR49F7SphbRp18cg+OG4DN9/PPwP89Ya91JQcTtdjNx4kQAPv74Y2qamkqProOaIgiOgdTxfJT9ESV1JcQHx/OtId8CE+ozrRGS0NEJGIZBfX09q1db84tcf/313HTTTYwaZc1psm7dOp7/4/M89s/HqPXWMiphFHP6zQGs2Vc/+ugjXnvtNerr60lJSeHee+8lNjb2Iv5LiIhIV6MgwomG1frjJ5o+m0dF8t6kqOhj682hXwdnGBTvh0OrWz1W7fbteAvyadhv3dpqkkrqm/8k7k9PUPRjHwUPNxD14o/pvfxD0t99l4g+TgwD6D6Um3tb/RbvHXiv1WP7Kuvx5teAAa70KAAyMjKIj4+ntraWTz75xNqw6bLMVTPAHsTre14H4LZ+t3Hv0HsZZx9Nr9ruNNh81A+wJirbsGEDVVVVREVFkZGRgcPh4Oabb2bevHm4g90U5BeQnJXM8IrhzAmaw8erPmbZsmUsXbqUtWvXAjBmzBjmz5+v5lQRETlvCiKcPCJyovcjMnI4yT3vAuDLXT+kzpNnrQEzbJ61weY/tXqsyhUrAQge1gP3gBjwm1SuKeCg8y/U9/IRkzGdxDF34UxNxbDZIK+x0bT7EKanTcdhOMgqzuJg+cHTjt10WSYoKQx7qLWwmN1uZ9q0aVZJmzeTn5sDuxqDzMBbySrOYlPeJmyGja/2/Souu4v/ML4NwKdhW7l91Tf5dO+nzWFi0qRJLS6p2BPsfJL8CfnufBymg97Fvdm8djNr165l06ZNZGdn43A4uO2225g+fTr2U+4QEhERORsFESAoyZoJ1VtUi7/O2/x+nz4/IjxsEA0NpWRlLcI0fTCq8e6T3cug/HiL45im2TyJWfjkyUTNSAe7gWdvOeYhJ0FB0fTv93jLk58URGLcMYzrMQ6A9w+8f1qdTZdl3H2iWryfnp7OgAEDME2Tre/+AarywRUJadfzu21Ww+2MtBl0D+2Or7qB4N3WZaXNPXaTU53DwnULOeA8QFpaGoMHn1gHZ0veFuYvn8/xhuPk9M/husnXMWDAAIYNG8bVV1/Nddddx5QpU1iwYAFDhw49z09bRETkBHUTAvYwJ/ZIF75yDw051bjSrfVObDYXgwf/hk2bZ1FWtpFDh39Hetr3odc4OPIZbH0RJj7SfJz6gwdpOHoUIyiI0HHjsIcFw/BKyAwjfs/tBI9343TGnTixtx4Kd1uvE6wAcHPvm1l9bDXvH3yfhSMWYjOsrGiaJp79pYDVH3KqqVOnsnfvXmJyGy8jXXUT20u+ZO3xtdgNOwuGLQCgelMueP0E9Qhj8Zyfc/gfd3HIOMTm+M04ujtY/9F6SupKKPWUUlhTiM/0MSJ+BM9MeoZIl9aBERGRtqURkUbNfSLHKlu8HxKSxlX9fwbAoUPPUFq6EUY3jopkvmBNHNao8iNrNCTkmmuwh4Vy/Pgr7It8EK+zHGdNImGHRrY4NkV7wN9gjV5EpQAwoecEwoLCyK3OJTP/xJ0w3qJafOX14DBwpUacVn90dDTjr72GQVh37Hj7z+R3263RkFl9ZpESkYLp81O93poSPmxcEpvWbmLEoREMrBgIwPq89XyW8xm7SnaRV52Hz/QxpdcUnp/yvEKIiIi0C42INHImh1P3ZTH12ZWn/a5791mUlHxGbt4bZGX9gFEj/o47NN66BLL7fRg0G4CqpssykyZy7Pjf2bPnJ+AA3+g8HJ9FUvFRNqEjE7CFWP0dJ1+WoXE+DrfDzdTUqby5703eP/g+o7tbi8Z5DpQB4EqJwAhqvQ9jfE+TIGqowc2fV+9hZ9BOHC4H9w69F4DaL4rxVdRjCwtin5nDhg0bMDB4/MbHqY2tZWfhTqLcUcS4Y4h2RRMXHEdiWGKbfL4iIiKt0YhII2eydadHa0EEoH//xYSEpOOpz2f95psp7W2NIrD5zwB4i4qo3bEDgIphJVYIAZKTv0XaTd8iqHsIZq2XilXZJw56chA5SdNspSsOr8Dj8wDg2VcGtH5ZpknQrrcB2G27iuL8CiYfn8xs12wSQ60wUfWZ1dNSnNjAe8usHpQbbriBgQMHkpGQwV2D7+LWPrdyfc/rGdJtiEKIiIi0OwWRRs7kMDDAV+bBV1F/2u/t9hCGDf0jkZEj8ftryXLvwAQ4vJaGnC0cW/cs5bMbKFpsZ3/erwBISfk2ffs8gs1uI/KmdACq1ufgLaq1DnqGIJKRkEFiaCJVDVV8kv0Jpt+k7mA5cJYg0lDXfLeMOXEOBe4CHKYD/5d+/vrXv5L54Trqj1biw8+yo2vx+XxcddVV3HDDDZfysYmIiFwSBZFGNpcDR3wIAPXZFa1uExKSSsbI/2XQwKchsgeFsdYcHHnvz+BA2AtUT/ZTH2+FjNRe36FP74eap0B394vG1S8afCblHx6yJkRrDiKDW5zHZtiYkT4DgP/d87/U51Rh1noxXHacPc4wR8e+FeCpwIzoydPl61nbfS2OAQ4cDgcHDhygcu0xAA7a8ume3oOZM2cyZ84crYorIiIBpR6RkziTw/Hm11CfXUnwoLhWtzEMg+7db6Fbt8kUmD+Gf71EYr6Hw2FhOPbZ6DnzP4gfNBuXK+G0faNmpJG/r5TarGI8O/fjqisDmwO6XXXatrf1uY2Xsl5iU94mNlZ8TDrRuNIjMezGadsCsNOatCy719XsKN6C2+FmwS0LoBo++eBfpO+ypmMfPv96Jvbv3voxRERELjP9c/gkzpTGPpGjrfeJnMxuDyHx2t9gxqTh8Jn0+VsDcauT6Tni3lZDCEBQQiihV1shoOyfxzFNwwohDtdp2yZHJPPg6AetbXdbq+S6eke1XkxdOey1poX/z8rPAZh31TziguOIi4tjSuI12DBw9oogWiFERESuIAoiJ3GlWLfF1h+rwvS3vpZMCzYbxuh/ByC6bzXhEya2WI22NRGTe2G47DQU26nxTzitP+Rk8/rPY3KPGxlY0xsAM9Xd+oa73gefh8OuYDLxMCRuCN8Z9h0A/PU+qjdaQSZsXNK5/yYREZHLSEHkJI74EAynHbPeh7eg5rz2MYfdjt9n4I7yEjEy/pzb28OdhE9IBqC84Vv4o4edcVvDMHi0x4O4TScl9nKePPzrVrdr2PEKAO+GOEmNTON3N/6OkCCr36Vq7XH81Q3YY9xnvNwkIiISKAoiJzFsBs6ejRObncflGYC6fUcpPxwMQHD1uvPaJ/y6HjjsefiJpvzwoLNuG5RtTTn/eeg+3j7wNssOLmvx+9qyI9gPW+vEbIpN4bkpzxHtjgasRfIqV1u3C0d+JfXM/SUiIiIBombVUzhTwvEcLKc+u7K5n+NsKld9TNW+UKJ712DseR8q8yD87PsZ3iqi7U9T6PsF1bsNQg6WN08rf6qmhe4i+ydAFSxev5hXdr+C2+Em2BHMiEMb+TfgC3cwj89YSlLYicsvFSuPYNb7cSaHEzxUoyEiInLl0YjIKZomNvMcbf0W3lNVrfoIT1kQ3tC+4PdC5ovn3ik/C5cti1C3NZJR+tY+TK//tM38dd7mKeenTpjFqIRR1Hpr2V64nQ25G/g4+2NGFlir9EaO+jZ9o/s279uQX031Zqs3JHJG2jl7V0RERAJBIyKncCZbDaveghr8Hi8215k/ovojR/Ds2w92O7brvwcffh8yl8J1i8AedOaT5H8BQGT6bmqPTsJbWEvlJ9lETO7VYjPPoXLwgz3WjSs2lD9O/SOZ+ZlU1VdR66vFXnKIYYcewzRsJF/z/Rb7ln94GExwD4rFlap1YkRE5MqkEZFT2COslXgxrbtnzqZy5UoAQsdcjS1jHoR2g8pc2LPsrPtR8CUAtqTeRN1i3RFT8XE2Dac0yDZdlnE33rbrsDkYkziGG3vdyM3pNzO90JqkzOg7FcJONMrW7S+lbncJ2Awip6Wez58tIiISEAoirWieT+QM6840qVhhBZHwqVOtuUBGzrd+semPZz9BwS7rOX4gwUPicF8VAz6T0jf3tbhtuK4xiLQ6rbunErb9zXp99b83v236Tco/OARA2DWJBHULOXstIiIiAaQg0ormBfDOcudMQ24udZ9/DoZB+I03Wm+O+jcwbHB4LRTsbn1H02weESF+AIZhEDWrN4bTRv3hCsqXWyHCV1mPN98aIWm1kXX7K1BfCXH9oPek5rert+TRkFuN4bITfmPKBf7lIiIil5eCSCtOjIhUYJqtT2xWufJfAASPHImjWzfrzcie0P8m6/WG37d+8MpcayZUww5xVnOpI9pN1GzrddWa41R+erz5skxQYij2MGfLY/j9sOl56/XV/w6Njah1+8soe+cAABGTUrCHnqVPRURE5ArQbkHk8OHD3H333aSlpREcHEzv3r15/PHHqa8/fWXbK01QUhjYDPyVDfjKPa1uU7liBQDhUya3/MXYhdbz9r9D2dHTd2waDYnt02Jq99AR8UQ09nOUf3CQyg05ALj7R59+jIOroHgfOMNh2DwA6nOqKH75S/CZBA+JI+y6Huf514qIiAROuwWR3bt34/f7ee6558jKyuLpp5/mD3/4A4888kh7nbLN2Jx2ghJDgdYvz3iLiqjJzAQgYsqUlr/sNRbSbgB/A6z91ekHb+4POX2hu/AbehI6NhFMaDhindfdL+b0Y2xsHA0Z8U1wheMtqaNo6ReYHh/OtEhivtYfw6bbdUVE5MrXbkFk2rRpLF26lKlTp5Kens4tt9zCgw8+yJtvvtlep2xTZ+sTqfxoFZgm7sGDCerRysjDhIes521/hbLslr9r6h2JH3jaboZhEDWzN86Te0IcpwSK4gOwzxqN4ep78FU3UPSXL/BXNhDUPYS4OwdiBOmKm4iIdAyX9RurvLycmJhW/oXfyOPxUFFR0eIRKM1BpJU7Z05clply2u8A6HUtpF1vjYp8esqoyEmNqq0xbEZzjwpA4bM7KHr5SzxHGj+LzX8CTPzpM6k+EkbRn3biLarFHuUi7t8GYwvW1DAiItJxXLYgcuDAAZ555hkWLFhwxm2WLFlCZGRk8yM5OflylXea5obV45X4633N7/vKy6neuBGA8KlnCCIANzSOimx9+cSoiN8PhWceEWnS3KiaFAom1GUVU/jsDgp+v5XKDWUU1v+UnF3/Tun/7qUhtxpbiIO4bw225j8RERHpQC44iCxevBjDMM762LJlS4t9cnJymDZtGnPnzuXb3/72GY/98MMPU15e3vzIzs4+47btzREXjD3SCV6T+sMnRmYqP/4YvF5cffvgSks78wFSx50+KlJ2BBpqwO6C6Nb39VXW09A4kVrcXYNJ+MFIQkYlgN2g/mg15XX/B49/JJgGjoQQwm9MIf57IwiK13whIiLS8VzwOP7ChQuZN2/eWbdJTU1tfp2Tk8PEiRMZO3Yszz///Fn3c7lcuFxXxr/qDcPA1Seamsx86vaX4u5n3b3SdNtu+JSp5z7IDQ/BoTXWqMj4RScaVbv1A3vrH33d3lLAGg2xRzixRziJmdOPyOujqXr2V9R74nFdlUzw9Js0WZmIiHR4FxxE4uLiiIs7v5Vcjx8/zsSJE8nIyGDp0qXYbB2ridLdN4qazHw8+8oA8FdXU/3ppwCEf+U8gkjTqMihNdaoSERjY+tZLsvU7Smxzt2/ZS+NfeN/EWkuhcQ+cPtnEOS+8D9IRETkCtNuySAnJ4cJEyaQnJzMU089RWFhIXl5eeTl5bXXKdtc09TqDbnV+CrrqVqzBtPjISglBVe/fud3kJN7RY6st16foVHV9JnUNYYe91UnBZEj66zF9ABm/kYhREREOo12u8VixYoV7N+/n/3799OzZ88WvzvTbKVXGnuYk6DEUBpyq/EcKKNimbWYXcTUKRjGec7TkTrOmm11zzI4tNp67wwjIvXZFZi1XoxgR/NdOzTUwXv3W69H3gmp4y/lTxIREbmitNuIyF133YVpmq0+OhJX3ygAanfmUfnxJwBE3HLLhR1k1u8gMtlqXAXo1r/Vzer2WP0h7n7RJyYkW/tLKNoLofEw5acXWr6IiMgVrWM1bQSAu4/VpFq7uwi8XoKHDcN9vpdlmoTEwNQnTvz8ReuTup3oD2mc1r1gF3z6tPX6pichuJXp3kVERDowBZFzcKVFWLOb+oKwhXUn6mtzL/JIJ40ErfqZ1cB6El9FPQ051YA1IoK3Ht79vjWK0v8mGDjrIs8rIiJy5VIQOQcjyI6jcSDC0XM4EdOmXdyBmm7djekNph/+8S0oPdL867q91mhIUM8w7MWZ8Nx1cGyTtbDdTU81r7ArIiLSmSiInAdvXhYArgHXYQsNvbiDNE3tPvJOSBgC1YXwzEh45f/Arvep212AQRXR9mdg6TRrBtaQWJjzZ4jUSroiItI5aWGSc/CVlVGz/l1Cxg/EsHfD9Pkx7BeR35pGRBKHwaBb4Y17rBGPPR/Ang+IMiPAZWDPL7e2G3GH1Zwacua1eURERDo6BZFzKH/3PXxFhzC9NUAI9dmVuFIjz7lfCw21UHLQeh0/EMIT4NsrrZV4d/wd/5ZXsHsKADDj+mPM/LW1cJ6IiEgnpyByFqZpUvb664CJI9bEVw51+8ouPIgU7bX6QoJjICz+xPvxV8GUn1J8ZDYcXE3okBBC5s4Hx5Uxzb2IiEh7U4/IWdR9/jmeffswXC7Cxllzf3j2lV74gZouy8QPPK3p1FdRj+dAFR5/Bs6pdyiEiIhIl6Igchalr78OQMS0rxA8NBGA+mOV+Ou8F3agpkbVVqZ2r9lRACY4e0XgiA2+pHpFREQ6GgWRM/BVVFCx7EMAoubOxRHlxhEXDH7wHCi7sIMV7LaeWwsiW63ekJAR3S6lXBERkQ5JQeQMCv/nGcyaGlx9+xCckQE0TjQG1OwovLCDnXxp5iQNedU05FaD3SB4iIKIiIh0PQoirajbvZvSv/8dgISHH25e4C5kVAIAtV8U46usP7+DeSqh/Kj1+pQ1Zmq2WaMh7v4x2EOD2qByERGRjkVB5BSmaZL3syfA7yd82jRCrz1xG60zKcxaFddvUp2Zf34HLNxjPYd1bzEniOk3qdluBZHQkfGt7SkiItLpKYicouLdd6nNzMQIDibhxz867fehY7oDUL0pD9N/HisJN1+WuarF256D5fjK6zHcDtxXadIyERHpmhRETuKrrCT/yacAiPvOdwhKTDxtm+Ch3TDcdnwldXj2l537oIWNjardWjaqNl2WCRkah+HQfwYREema9A14ksJnnsFXVIQzNZXYu+a3uo3NaSd0pNUrUrUx99wHbWVExF/vo/aLIgBCdFlGRES6MAWRRnV79lL6t8YG1ccew3A6z7ht0+WZul3F+Co8Zz9wK3fM1O4oxPT4sEe7cKZEXFrhIiIiHViXDyKm10vJ3/7GkTvvBJ+P8KlTCRs/7qz7BCWE4kyNAD9Ubz5L02ptGVTmWK8b75jx13kp/+dhAMLGJmHYjNb3FRER6QK6dBCp3rCBQ7NvI/9nT+AvL8fVvz8Jjz56XvuGjrH6R87atNp0x0xED3Bb69NUfHQUf1UDjrhgwq5NuuS/QUREpCPrkove1R87TsEvfkHlypUA2CMj6fbA/UTNnYvhOL+PJGRwHOXvHcBX7qFuTwnBA2JP36iw8bJMN6s/pKGghqrPrBGSqJnpalIVEZEur0t+E9Zs3myFELud6G98g97/XE707befdwgBMIJshDQ2rVZvzGt9o5OmdjdNk7L3DoDfxD0gBnd/3bIrIiLSJUdEImfdQt2XXxI1dw7ufv0u+jihY7pT9elx6naXULU+h7Cxp1xqOWlEpO7LYjz7ysBuEHVz+sUXLyIi0ol0yRERw2aj+6OPXFIIAQjqFkL4pGQAyt45QPXWUxpXG0dEzJirKHv/IADh1/fUKrsiIiKNumQQaUsRU3o1N52W/mNv8/wg1JZCVR6m6aD883B8pR7sEU7CJyYHsFoREZEri4LIJTIMg8ib0wnJSAA/FL+ym7q9pTTs3kVZw93k1r9M1Tprtd7IGWnYnPYAVywiInLl6JI9Im3NsBlEf7UvZr2P2p1FFL3wBfgBZgNgC3cSNi6J4KHdAlqniIjIlUZBpI0YNoOYr/enuN5H3Z5SMPy4jY2EDnbh/vr3MeyauExERORUCiJtyHDYiL1jIHX7SnF+9h3sx/4JA58FhRAREZFWqUekjRkOG8EDYrGXbrXe6HbV2XcQERHpwhRE2kN1MVRbDapNa8yIiIjI6RRE2kPTRGZRvcAZGthaRERErmAKIu2hoDGIxA8IbB0iIiJXOAWR9lDYuMaM+kNERETOSkGkPZy02J2IiIic2WUJIh6Ph+HDh2MYBtu3b78cpwwc04SCL63XGhERERE5q8sSRH70ox+RlJR07g07g+pCqC0BDIi7tEX1REREOrt2DyIffvghK1as4KmnnmrvU10ZmhpVo1PBGRLQUkRERK507Tqzan5+Pvfccw9vv/02ISHn/lL2eDx4PJ7mnysqKtqzvPbR1KgaPzCwdYiIiHQA7TYiYpomd911FwsWLGDUqFHntc+SJUuIjIxsfiQnJ7dXee2nqT8kXv0hIiIi53LBQWTx4sUYhnHWx5YtW3jmmWeoqKjg4YcfPu9jP/zww5SXlzc/srOzL7S8wMvPsp4TBgW2DhERkQ7AME3TvJAdioqKKCoqOus2qampzJs3j/feew/DOLHgm8/nw263841vfIMXX3zxnOeqqKggMjKS8vJyIiIiLqTMwPD74efJUF8F392oUREREemSLuT7+4KDyPk6evRoix6PnJwcvvKVr/CPf/yDMWPG0LNnz3Meo8MFkdLD8JthYHfCI7lg1+LGIiLS9VzI93e7fVOmpKS0+DksLAyA3r17n1cI6ZCaLst0668QIiIich40s2pbym9qVFV/iIiIyPm4bP9sT01NpZ2uAl058r+wntWoKiIicl40ItKWmm7dTdAcIiIiIudDQaStNNRC8X7rdcLgwNYiIiLSQSiItJXCPWD6ITgGwhICXY2IiEiHoCDSVpovywyCk+ZOERERkTNTEGkrmlFVRETkgimItJWmIKLF7kRERM6bgkhbaR4RUaOqiIjI+VIQaQtVhVBdABhaX0ZEROQCKIi0hYLG0ZDoVHCGBrQUERGRjkRBpC3kn3THjIiIiJw3BZG2UKA7ZkRERC6Ggkhb0K27IiIiF0VB5FL5fVCw23qtVXdFREQuiILIpSo5BN5acARDTFqgqxEREelQFEQuVVN/SPxVYLMHthYREZEORkHkUjXPqKrLMiIiIhdKQeRSqVFVRETkoimIXKrmVXe1xoyIiMiFUhC5FJ4qq1kVdGlGRETkIiiIXIq8nYAJ4UkQ1i3Q1YiIiHQ4CiKXImeb9Zw0IrB1iIiIdFAKIpdCQUREROSSKIhcCgURERGRS6IgcrHqKqB4n/U6aXhASxEREemoFEQuVu4O6zkyBULjAluLiIhIB6UgcrGaL8sMD2gZIiIiHZmCyMVSf4iIiMglUxC5WAoiIiIil0xB5GLUlkJp44yqujQjIiJy0RRELkbOdus5Og2CowNaioiISEemIHIxdFlGRESkTSiIXAwFERERkTahIHIxcrdbzwoiIiIil6Tdg8gHH3zAmDFjCA4OJi4ujttuu629T9m+qouh7Kj1OnFYYGsRERHp4BztefA33niDe+65h//+7/9m0qRJmKbJzp072/OU7S+38bJMbF9wRwS2FhERkQ6u3YKI1+vl/vvv58knn+Tuu+9ufr9///7tdcrLQ/0hIiIibabdLs1s3bqV48ePY7PZGDFiBImJiUyfPp2srKwz7uPxeKioqGjxuOI03bqr+UNEREQuWbsFkYMHDwKwePFiHnvsMd5//32io6O54YYbKCkpaXWfJUuWEBkZ2fxITk5ur/IunkZERERE2swFB5HFixdjGMZZH1u2bMHv9wPw6KOP8tWvfpWMjAyWLl2KYRi8/vrrrR774Ycfpry8vPmRnZ19aX9dW6vMh4rjgAHdhwa6GhERkQ7vgntEFi5cyLx58866TWpqKpWVlQAMHDiw+X2Xy0V6ejpHjx5tdT+Xy4XL5brQki6fptt2u/UHV1hASxEREekMLjiIxMXFERcXd87tMjIycLlc7Nmzh/HjxwPQ0NDA4cOH6dWr14VXeiXQZRkREZE21W53zURERLBgwQIef/xxkpOT6dWrF08++SQAc+fOba/Ttq8j66znHhmBrUNERKSTaNd5RJ588kkcDgd33HEHtbW1jBkzhlWrVhEd3QEXimuog+yN1uu06wNbi4iISCdhmKZpBrqIM6moqCAyMpLy8nIiIgI8edihNfDiTAjrDv+xGwwjsPWIiIhcoS7k+1trzZyvg6ut5/QbFEJERETaiILI+TrUGETSbghsHSIiIp2Igsj5qKuA41ut1+oPERERaTMKIufjyGdg+iAmHaKuwNleRUREOigFkfNxUJdlRERE2oOCyPk4dFKjqoiIiLQZBZFzqSqAgi+t16nXBbYWERGRTkZB5FwOrbGeE4ZA6LmnthcREZHzpyByLrosIyIi0m4URM5FjaoiIiLtRkHkbEoPQ9kRsDmg19hAVyMiItLpKIicTdNoSI8McIUHthYREZFOSEHkbDStu4iISLtSEDkT0zxxx4waVUVERNqFgsiZHN8K1YXgCIaeowNdjYiISKekIHImW/5iPQ+YCQ5XYGsRERHppBREWlNbCl+8Yb0e/e3A1iIiItKJKYi0Zvsr4K2FhMGQfHWgqxEREem0FEROZZqw5c/W69F3g2EEth4REZFOTEHkVIdWQ/F+cIbDkK8FuhoREZFOTUHkVJsbR0OGfR1cYYGtRUREpJNTEDlZRQ7s/sB6PeruwNYiIiLSBSiInGzrS2D6IOVaSBgY6GpEREQ6PQWRJr4GyHzBej1aoyEiIiKXg4JIkz0fQmUuhHazJjETERGRdqcgApCzHT78sfV6xB2aSVVEROQycQS6gIDLehveWmBNYBbXH8beF+iKREREuoyuG0RME1b/P/jkv62f+0yBOX8Gd2Rg6xIREelCumYQaaiFt78LWW9aP19zH0z9Gdjsga1LRESki+maQWTTH60QYnPAzU/DyDsDXZGIiEiX1DWDyDXfhdwdMOrfIHV8oKsRERHpsrpmELE7rH4QERERCSjdvisiIiIB065BZO/evcyaNYu4uDgiIiIYN24cH3/8cXueUkRERDqQdg0iM2bMwOv1smrVKjIzMxk+fDg333wzeXl57XlaERER6SDaLYgUFRWxf/9+HnroIYYOHUrfvn35+c9/Tk1NDVlZWe11WhEREelA2i2IxMbGMmDAAF566SWqq6vxer0899xzJCQkkJGR0V6nFRERkQ6k3e6aMQyDlStXMmvWLMLDw7HZbCQkJLB8+XKioqJa3cfj8eDxeJp/rqioaK/yRERE5ApwwSMiixcvxjCMsz62bNmCaZp897vfJT4+nrVr17Jp0yZmzZrFzTffTG5ubqvHXrJkCZGRkc2P5OTkS/4DRURE5MplmKZpXsgORUVFFBUVnXWb1NRUPvvsM6ZOnUppaSkRERHNv+vbty933303Dz300Gn7tTYikpycTHl5eYtjiIiIyJWroqKCyMjI8/r+vuBLM3FxccTFxZ1zu5qaGgBstpaDLjabDb/f3+o+LpcLl8t1oSWJiIhIB9Vuzapjx44lOjqa+fPns2PHDvbu3csPf/hDDh06xIwZM9rrtCIiItKBtFsQiYuLY/ny5VRVVTFp0iRGjRrFp59+yjvvvMOwYcPa67QiIiLSgVxwj8jldCHXmEREROTKcCHf31prRkRERALmil59t2mwRvOJiIiIdBxN39vnc9Hlig4ilZWVAJpPREREpAOqrKwkMjLyrNtc0T0ifr+fnJwcwsPDMQyjTY/dNEdJdna2+k/akT7ny0Of8+Whz/ny0Od8+bTXZ22aJpWVlSQlJZ02jceprugREZvNRs+ePdv1HBEREfof/TLQ53x56HO+PPQ5Xx76nC+f9viszzUS0kTNqiIiIhIwCiIiIiISMF02iLhcLh5//HFNKd/O9DlfHvqcLw99zpeHPufL50r4rK/oZlURERHp3LrsiIiIiIgEnoKIiIiIBIyCiIiIiASMgoiIiIgETJcMIr///e9JS0vD7XaTkZHB2rVrA11Sp7NmzRpmzpxJUlIShmHw9ttvB7qkTmnJkiWMHj2a8PBw4uPjufXWW9mzZ0+gy+p0nn32WYYOHdo86dPYsWP58MMPA11Wp7dkyRIMw+CBBx4IdCmdyuLFizEMo8Wje/fuAaunywWR1157jQceeIBHH32Ubdu2cd111zF9+nSOHj0a6NI6lerqaoYNG8Zvf/vbQJfSqa1evZr77ruPDRs2sHLlSrxeL1OnTqW6ujrQpXUqPXv25Oc//zlbtmxhy5YtTJo0iVmzZpGVlRXo0jqtzZs38/zzzzN06NBAl9IpDRo0iNzc3ObHzp07A1ZLl7t9d8yYMYwcOZJnn322+b0BAwZw6623smTJkgBW1nkZhsFbb73FrbfeGuhSOr3CwkLi4+NZvXo1119/faDL6dRiYmJ48sknufvuuwNdSqdTVVXFyJEj+f3vf88TTzzB8OHD+fWvfx3osjqNxYsX8/bbb7N9+/ZAlwJ0sRGR+vp6MjMzmTp1aov3p06dyrp16wJUlUjbKS8vB6wvSWkfPp+PV199lerqasaOHRvocjql++67jxkzZjB58uRAl9Jp7du3j6SkJNLS0pg3bx4HDx4MWC1X9KJ3ba2oqAifz0dCQkKL9xMSEsjLywtQVSJtwzRNFi1axPjx4xk8eHCgy+l0du7cydixY6mrqyMsLIy33nqLgQMHBrqsTufVV19l69atbN68OdCldFpjxozhpZdeol+/fuTn5/PEE09w7bXXkpWVRWxs7GWvp0sFkSaGYbT42TTN094T6WgWLlzI559/zqeffhroUjql/v37s337dsrKynjjjTeYP38+q1evVhhpQ9nZ2dx///2sWLECt9sd6HI6renTpze/HjJkCGPHjqV37968+OKLLFq06LLX06WCSFxcHHa7/bTRj4KCgtNGSUQ6ku9973u8++67rFmzhp49ewa6nE7J6XTSp08fAEaNGsXmzZv5zW9+w3PPPRfgyjqPzMxMCgoKyMjIaH7P5/OxZs0afvvb3+LxeLDb7QGssHMKDQ1lyJAh7Nu3LyDn71I9Ik6nk4yMDFauXNni/ZUrV3LttdcGqCqRi2eaJgsXLuTNN99k1apVpKWlBbqkLsM0TTweT6DL6FRuvPFGdu7cyfbt25sfo0aN4hvf+Abbt29XCGknHo+HXbt2kZiYGJDzd6kREYBFixZxxx13MGrUKMaOHcvzzz/P0aNHWbBgQaBL61SqqqrYv39/88+HDh1i+/btxMTEkJKSEsDKOpf77ruPv//977zzzjuEh4c3j/ZFRkYSHBwc4Oo6j0ceeYTp06eTnJxMZWUlr776Kp988gnLly8PdGmdSnh4+Gn9TaGhocTGxqrvqQ09+OCDzJw5k5SUFAoKCnjiiSeoqKhg/vz5AamnywWRr3/96xQXF/PTn/6U3NxcBg8ezLJly+jVq1egS+tUtmzZwsSJE5t/brruOH/+fF544YUAVdX5NN2GPmHChBbvL126lLvuuuvyF9RJ5efnc8cdd5Cbm0tkZCRDhw5l+fLlTJkyJdCliVywY8eOcfvtt1NUVES3bt245ppr2LBhQ8C+B7vcPCIiIiJy5ehSPSIiIiJyZVEQERERkYBREBEREZGAURARERGRgFEQERERkYBREBEREZGAURARERGRgFEQERERkYBREBEREZGAURARERGRgFEQERERkYBREBEREZGA+f+yHtZ+jF5kpwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gto = GTORadialBasis(radial_gaussian_width=width, **shared_params)\n", + "gto.plot_basis()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "fe008b9e-40a9-4d2d-a4ee-496198779e44", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gto = GTORadialBasis(**shared_params)\n", + "gto.plot_basis()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "0421646e-8619-4c32-ab47-687ba84f9be3", + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[11], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43marange\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43marray\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m6\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[0;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()" + ] + } + ], + "source": [ + "np.arange(np.array([0, 1, 6]))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "2ae38153-2614-43e3-bd49-6f685ab1ba9f", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "be6ee255-846f-4d8d-8b4d-ab92d0aca55c", + "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.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 522470a50d533a26ee9cf07b7a2dd5e80d8aa042 Mon Sep 17 00:00:00 2001 From: Patron Date: Thu, 7 Mar 2024 10:48:20 -0600 Subject: [PATCH 4/7] incorporated the other constant term when evaluating new gaussian parameters --- .../representations/ellipsoidal_density_projection.py | 3 ++- anisoap/representations/radial_basis.py | 9 +++++---- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/anisoap/representations/ellipsoidal_density_projection.py b/anisoap/representations/ellipsoidal_density_projection.py index df25c50..926bb5e 100644 --- a/anisoap/representations/ellipsoidal_density_projection.py +++ b/anisoap/representations/ellipsoidal_density_projection.py @@ -127,9 +127,10 @@ def pairwise_ellip_expansion( ( precision, center, + constant ) = radial_basis.compute_gaussian_parameters(r_ij, lengths, rot) - moments = length_norm * compute_moments_inefficient_implementation( + moments = np.exp(constant) * length_norm * compute_moments_inefficient_implementation( precision, center, maxdeg=maxdeg ) for l in range(lmax + 1): diff --git a/anisoap/representations/radial_basis.py b/anisoap/representations/radial_basis.py index 673ba2b..0df72db 100644 --- a/anisoap/representations/radial_basis.py +++ b/anisoap/representations/radial_basis.py @@ -421,13 +421,14 @@ def compute_gaussian_parameters(self, r_ij, lengths, rotation_matrix): center = r_ij diag = np.diag(1 / lengths**2) precision = rotation_matrix @ diag @ rotation_matrix.T - # GTO basis with uniform Gaussian width in the basis functions sigma = self.radial_gaussian_width - precision += np.eye(3) / sigma**2 - center -= 1 / sigma**2 * np.linalg.solve(precision, r_ij) + new_precision = precision + np.eye(3) / sigma**2 + new_center = center - 1 / sigma**2 * np.linalg.solve(new_precision, r_ij) + constant = 1 / sigma**2 * r_ij @ np.linalg.solve(new_precision, precision@r_ij) + + return new_precision, new_center, constant - return precision, center def calc_overlap_matrix(self): """ From 4ba8f028ac4a5ea0775e2cc8e503625bf79ef67c Mon Sep 17 00:00:00 2001 From: Patron Date: Fri, 8 Mar 2024 17:45:16 -0600 Subject: [PATCH 5/7] slight but likely important change in constant factor --- anisoap/representations/ellipsoidal_density_projection.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/anisoap/representations/ellipsoidal_density_projection.py b/anisoap/representations/ellipsoidal_density_projection.py index 926bb5e..4415d76 100644 --- a/anisoap/representations/ellipsoidal_density_projection.py +++ b/anisoap/representations/ellipsoidal_density_projection.py @@ -130,7 +130,7 @@ def pairwise_ellip_expansion( constant ) = radial_basis.compute_gaussian_parameters(r_ij, lengths, rot) - moments = np.exp(constant) * length_norm * compute_moments_inefficient_implementation( + moments = np.exp(-0.5 * constant) * length_norm * compute_moments_inefficient_implementation( precision, center, maxdeg=maxdeg ) for l in range(lmax + 1): From bebf2e55b5e5fbafc3d64708d0e3b8e66e941137 Mon Sep 17 00:00:00 2001 From: "Rose K. Cersonsky" <47536110+rosecers@users.noreply.github.com> Date: Fri, 15 Mar 2024 17:19:00 -0500 Subject: [PATCH 6/7] linting --- anisoap/representations/Untitled.ipynb | 184 ------------------ .../ellipsoidal_density_projection.py | 10 +- anisoap/representations/radial_basis.py | 5 +- 3 files changed, 10 insertions(+), 189 deletions(-) delete mode 100644 anisoap/representations/Untitled.ipynb diff --git a/anisoap/representations/Untitled.ipynb b/anisoap/representations/Untitled.ipynb deleted file mode 100644 index 37db375..0000000 --- a/anisoap/representations/Untitled.ipynb +++ /dev/null @@ -1,184 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 32, - "id": "56f31f63-3d5b-4f44-8e6e-912ea57675de", - "metadata": {}, - "outputs": [], - "source": [ - "from radial_basis import GTORadialBasis, MonomialBasis, ShiftedGTORadialBasis" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "121a7472-d5e2-47e0-a54c-33a892d149d5", - "metadata": {}, - "outputs": [], - "source": [ - "n = 4\n", - "l = 4\n", - "shift = 1.0\n", - "width = 0.5\n", - "cutoff = 5\n", - "\n", - "shared_params = dict(max_radial=n, max_angular=l, cutoff_radius=cutoff)" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "id": "56bb998b-5eec-45b0-bab0-a7074810d335", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "monomial = MonomialBasis(**shared_params)\n", - "monomial.plot_basis()" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "4a556e9f-4dc0-451e-a970-124439da95e8", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAGgCAYAAACnqB1FAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3hUVfrA8e+dkknvvYeQhITee1NAQVFsYMWCYtu1oD937W3tqyj2VREroiII0kHpvYQa0kN6L5M69f7+uEkgppBAGnA+zzOPMvfcc88EdF5OeV9JlmUZQRAEQRCEi4iqqwcgCIIgCILQ3kSAIwiCIAjCRUcEOIIgCIIgXHREgCMIgiAIwkVHBDiCIAiCIFx0RIAjCIIgCMJFRwQ4giAIgiBcdESAIwiCIAjCRUcEOIIgCIIgXHREgCMIgiAIwkWnQwOcrVu3Mn36dPz9/ZEkieXLl7fY/rfffmPy5Ml4eXnh7OzMyJEjWbduXYM2ixYtQpKkRq+ampoO/CSCIAiCIFxINB3ZeWVlJf379+fuu+/mhhtuOGv7rVu3MnnyZF5//XVcXV35+uuvmT59Onv27GHgwIH17ZydnYmPj29wr62tbavHZbVayc7OxsnJCUmSWv+BBEEQBEHoMrIsU15ejr+/PyrVWeZo5E4CyMuWLWvzfTExMfLLL79c/+uvv/5adnFxOa+xZGRkyIB4iZd4iZd4iZd4XYCvjIyMs37Xd+gMzvmyWq2Ul5fj7u7e4P2KigpCQkKwWCwMGDCAV199tcEMz98ZDAYMBkP9r+XaAuoZGRk4Ozt3zOAFQRAEQWhXer2eoKAgnJycztq2Wwc47777LpWVlcycObP+vV69erFo0SL69u2LXq/ngw8+YPTo0Rw+fJiIiIgm+3njjTd4+eWXG73v7OwsAhxBEARBuMC0ZnuJJNdNZ3QwSZJYtmwZM2bMaFX7xYsXc++99/L7778zadKkZttZrVYGDRrEuHHjWLBgQZNt/j6DUxcBlpWViQBHEARBEC4Qer0eFxeXVn1/d8sZnCVLljBnzhx++eWXFoMbAJVKxdChQ0lMTGy2jU6nQ6fTtfcwBUEQBEHoprpdHpzFixdz11138eOPP3LVVVedtb0sy8TGxuLn59cJoxMEQRAE4ULQoTM4FRUVJCUl1f86NTWV2NhY3N3dCQ4O5umnnyYrK4tvv/0WUIKb2bNn88EHHzBixAhyc3MBsLOzw8XFBYCXX36ZESNGEBERgV6vZ8GCBcTGxvLxxx935EcRBEEQBOEC0qEzOPv372fgwIH1J5zmzZvHwIEDeeGFFwDIyckhPT29vv3nn3+O2Wzm4Ycfxs/Pr/716KOP1rcpLS1l7ty5REdHM2XKFLKysti6dSvDhg3ryI8iCIIgCMIFpNM2GXcnbdmkJAiCIAhC99CW7+9utwdHEARBEAThfIkARxAEQRCEi44IcARBEARBuOiIAEcQBEEQhIuOCHAEQRAEQbjoiABHEARBEISLTrcs1SBcGgxmCydzyjmcWUpJpYnp/f3o4eXY1cMSBEEQLgIiwBE6VYXBzEd/JrErpYi4bD1Gi7X+2vyNCVzey5s5Y8MY2cOjVdViBUEQBKEpIsAROk1WaTVzFu3jZG55/Xtu9lr6BboiSbA5voBNJ/PZdDKfaD9n/u+KSC7r5dOFIxYEQRAuVCLAETrFwfQS5n57gMIKA56OOp6Z1oshIe4EudvVz9SkFFTw9Y40fj2QSVyOnnu/2c/ndwxhcowIcgRBEIS2EaUaRKmGDrficDZP/nIYo9lKL18nvrprKAGuds22L60y8vLKEyw7lIWNRsV39wxjeA+PThyxIAiC0B2JUg1Ct/HF1hQeWXwIo9nKpGhvfn1wVIvBDYCrvQ3v3NiPSdE+GM1W7v1mPyey9Z00YkEQBOFiIAIcocPsSyvmjTVxAMwd14PP7xiCo651q6IatYqPbh3IsFB3yg1mZi/cS3pRVUcOVxAEQbiIiABH6BDlNSYeXxKLVYYbBwfyzLRo1Kq2nYqy1ar54s4h9PJ1orDCwO1f7aGg3NBBIxYEQRAuJiLAETrEyytPkFlSTaCbHS9OjznnflzstHx7zzCC3e1JL67ilT9OtOMoBUEQhIuVCHCEdrf2WA6/HshEkuC9mQNwstWeV3/ezrZ8ctsgJAlWHs5mb2pxO41UEARBuFiJAEdoV/n6Gp7+7SgAD4wPZ1iYe7v02yfAhZuHBgPw4orjWKyX3OE/QRAEoQ1EgCO0G1mWeWrpEUqqTMT4OfP4pMh27f/JKZE42WqIy9Hz0770du1bEARBuLiIAEdoN8tjs9gcX4CNRsX7Nw/ARtO+f7w8HHXMm6wETf9dF09Zlald+xcEQRAuHiLAEdqFyWLl/Y2JADx6eQSRPk4d8pzbR4QQ4e1ISZWJ+RsTOuQZgiAIwoVPBDhCu/jtYCaniqrwcLDhrlGhHfYcrVrFi9N7A/Dd7lPEn1HXShAEQRDqiABHOG9Gs5UFm5IAeHBCOA6tTOZ3rsZEeDIlxgeLVeaVP4536LMEQRCEC5MIcITz9vP+DLJKq/Fy0nHb8JBOeeZzV8Vgo1axI6mIg+klnfJMQRAE4cIhAhzhvNSYLHz0pzJ78/CEcOxs1J3y3GAPe6b39wfg6x1pnfJMQRAE4cIhAhzhvPy0N51cfQ1+LrbcPCy4U5999+hQANYczSGnrLpTny0IgiB0byLAEc5ZtdHCx5uTAXh4Yk9stZ0ze1OnT4ALw8PcMVtlvtt1qlOfLQiCIHRvIsARztkPe05RUG4gwNWOmUOCumQM94wJA+DHvelUGy1dMgZBEASh+xEBjnBODGYLn21JAeCRy3u2e1K/1poU7UOQux2lVSaWHcrqkjEIgiAI3Y8IcIRzsvZYLoUVBnycdVw/KLDLxqFWSdw5MhSAr3ekIsuiRpUgCIIgAhzhHH2/W9nzcuuwELTqrv1jNHNoEA42ahLzK9ieVNilYxEEQRC6BxHgCG0Wl6NnX1oJGpXEzcO6Zu/NmZxttdxUuwdo4fbULh6NIAiC0B2IAEdos7rZmyt6++LjbNvFo1HcNSoUSYK/4gtILqjo6uEIgiAIXUwEOEKblNec3sx7+4jOyVrcGqGeDlzeywdAHBkXBEEQRIAjtM2yQ1lUGS309HZkRA/3rh5OA7cNVxIN/nEkG7PF2sWjEQRBELqSCHCEVpPl0wn17hgRgiRJXTyihsZEeOLhYENhhVFsNhYEQbjEiQBHaLU9qcUk5ldgb6PmukEBXT2cRrRqFVf38wNguciJIwiCcEkTAY7Qat/Vbi6eMTAAZ1ttF4+maTMGKoHXuuN5VBrMXTwaQRAEoat0aICzdetWpk+fjr+/P5IksXz58rPes2XLFgYPHoytrS09evTgs88+a9Rm6dKlxMTEoNPpiImJYdmyZR0weuFM+foa1h3LBeD24d1nc/HfDQhyJdTDnmqThQ0n8rp6OIIgCEIX6dAAp7Kykv79+/PRRx+1qn1qairTpk1j7NixHDp0iGeeeYZHHnmEpUuX1rfZtWsXs2bN4o477uDw4cPccccdzJw5kz179nTUxxCAXw5kYrbKDAlxI8bfuauH0yxJkrh2gDKLI0o3CIIgXLokuZNy20uSxLJly5gxY0azbf71r3+xYsUK4uLi6t974IEHOHz4MLt27QJg1qxZ6PV61qxZU9/myiuvxM3NjcWLF7dqLHq9HhcXF8rKynB27r5f1t2FLMtMem8LyQWVvHNjv/qket1VamElE/+7GZUEe56ZhJeTrquHJAiCILSDtnx/d6s9OLt27WLKlCkN3rviiivYv38/JpOpxTY7d+5stl+DwYBer2/wElrvWJae5IJKbLUqruzj29XDOaswTwcGBLlilZUj44IgCMKlp1sFOLm5ufj4+DR4z8fHB7PZTGFhYYttcnNzm+33jTfewMXFpf4VFNS9ZyC6m7qlnskxvjh1083FfzdjgD8gTlMJgiBcqrpVgAM0yq1St4J25vtNtWkpJ8vTTz9NWVlZ/SsjI6MdR3xxM1usrDiszIJcN9C/i0fTelf390etkjicWUaKKN0gCIJwyelWAY6vr2+jmZj8/Hw0Gg0eHh4ttvn7rM6ZdDodzs7ODV5C6+xILqKwwoC7gw1jI7y6ejit5umoY2yEJwDLY8UylSAIwqWmWwU4I0eOZMOGDQ3eW79+PUOGDEGr1bbYZtSoUZ02zktJ3RLP9H5+aNXd6o/LWV1XmxNn+aEsOmkvvSAIgtBNdOg3VkVFBbGxscTGxgLKMfDY2FjS09MBZelo9uzZ9e0feOABTp06xbx584iLi2PhwoV89dVXPPnkk/VtHn30UdavX89bb73FyZMneeutt9i4cSOPPfZYR36US1Klwcza2tw3dQn0LiSTY3ywt1GTXlzFkcyyrh6OIAiC0Ik6NMDZv38/AwcOZODAgQDMmzePgQMH8sILLwCQk5NTH+wAhIWFsXr1ajZv3syAAQN49dVXWbBgATfccEN9m1GjRvHTTz/x9ddf069fPxYtWsSSJUsYPnx4R36US9L6E7lUmyyEetgzIMi1q4fTZvY2GiZEKctqIumfIAjCpaXT8uB0JyIPTuvMXriXrQkFPDYpgscmRXb1cM7JskOZPL7kMJE+jqx/fHxXD0cQBEE4DxdsHhyh+8gvr2F7YgEAMwZceMtTdS6L8kGtkkjIqyCtsLKrhyMIgiB0EhHgCE1aeTgHqwwDg10J9XTo6uGcMxd7LSN6uANimUoQBOFSIgIcoUl1p6euuwA3F//dlBgl+/L6E80ngxQEQRAuLiLAERpJLazkaFYZapXEVX39uno4521yjJIjaf+pEgorDF08GkEQBKEziABHaGTNsRwARoV74OF44Req9He1o2+AC7IMf8bld/VwBEEQhE4gAhyhkTVHlaWcqX0u/NmbOnWzOGKZShAE4dIgAhyhgYziKo5mlaGSYErv5stfXGjqPsvWxEIqDeYuHo0gCILQ0TRdPQChe6nLXDw8zAPPC2h5qigznQOrfydp327snV3wCAjCPTAI94AgAiKjifLxItjdnvTiKrYlFnDlRTQ7JQiCIDQmAhyhgdW1+2+m9vXt4pGcnSzLnDoay4FVy0mLPVD/frW+jKLMdNij/Fql1jD+jjlMie7BlzvSWH8iTwQ4giAIFzkR4Aj1skurOZReiiTBFb27d4BTXVHO8rdeITshTnlDkug5ZAT9p0xDtlgoysqgOCuD/LQU8lKS+GvR5wT1HYbW2pdNcfmYLVY0F1jxUEEQBKH1RIAj1KtbnhoS4oaPs20Xj6Z5NZUVLH3tefJSktDqbOkzcTKDpl6Dq+/pWZmwgUMAZZbn0NqVbPnuKwqP7uVWmwT+8JrC3rRiRoV7dtVHEARBEDqYCHCEenXHw7vz6SlDVRW/vf4ieSlJ2Dk5M/PFN/AMCmm2vSRJDJp6Db7hEax8/y0oKuSm7N/4c60tox6e2YkjFwRBEDqTmKMXAMjX17D/VAkAV/bpnstTxppqlr31EjlJ8dg6OHLjc/9pMbg5k39kNHe8+QGOPXqjlc1oty+mODurg0csCIIgdBUR4AgArDueiyzDgCBX/F3tuno4jZgMNSx/+1WyTp5AZ+/Ajc/9B+/QHm3qw97ZhVteeIUsO380VhO/vfsGZqOxg0YsCIIgdCUR4AgArK5N7jetm56e2vTVZ2QcP4KNnR03PPMKPj16nlM/znY6CgffRLXKlrLMNLZ8/1U7j1QQBEHoDkSAI1BYYWBPahHQPfffpB05xPEtG0GSmPF/z+MXEXVe/Y3q14P1XpcDELtuFQl7drTHMAVBEIRuRAQ4AuuP52GVoW+AC0Hu9l09nAZMNTVs/OIjAAZeeTVBvfudd58TorxItw8m1m0QAOs/W0BZvijhIAiCcDERAY7AuuPKl3t33Fy845cfKMvPw8nTizGz7miXPqN8nPB1tmWHyxAcgsIxVFXyx/tvYTGb2qV/QRAEoeuJAOcSV15jYmdyIQBXdLPaU7nJiRxc9TsAk+99GBu79pldkiSJ8ZFeWCU1BUNmYuvgSG5yIkc2rWuX/gVBEISuJwKcS9yWhAJMFpkwTwfCvRy7ejj1LGYz6z9fgCxb6TV6fH3ivvYyIcoLgM1ZJkbfPBuA3Ut/wlhT3a7PEQRBELqGCHAucRtO5AEwOcYHSZK6eDSn7f9jGQWnUrF1dGLinfe1e/+jenqiVkkkF1TiNnAMrj5+VJWVcnD1inZ/liAIgtD5RIBzCTNZrPx1Mh+AKTHdZ3lKX5jP7l8XAzBh9r3Yu7i2+zNc7LQMDnYDYFtyCaNm3Q7AvhVLqS7Xt/vzBEEQhM4lApxL2N7UYvQ1ZjwcbBhY+2XfHez9fSlmk5HA6D7EjLusw54zvm6ZKr6AXiPH4hUShrG6ir2//9phzxQEQRA6hwhwLmF1y1OXR3ujVnWP5anyokKO/als9h0187YOXTYbH6kEODuTCzFaZcbecicAh9aupLyosMOeKwiCIHQ8EeBcomRZZn3t8fDJMd3nePi+FUuxmM0ERvchKKZvhz4rxs8ZT0cdVUYLB9JKCB0wmMDoPlhMJnb9+mOHPlsQBEHoWCLAuUQdz9aTXVaDnVbN2AjPrh4OABUlxRzZtBaAETfc3OHPU6mk+lmczQkFSJLEmNpZnGN/baQoK6PDxyAIgiB0DBHgXKLqlqfGRnhiq1V38WgU+1cuxWIy4R8ZTXCf/p3yzLp9OFviCwAIiIomfMhwZNnKzl/ELI4gCMKFSgQ4l6gzj4d3B5WlJRzeoMzejLzh5k47sj4uwhOVBPF55WSXKjlwRs9UTlQl7t6BvjC/U8YhCIIgtC8R4FyCMkuqOJGjRyXB5dHdI8DZ/8cyzEYDvj0jCek/qNOe62pvQ/8gVwC2Jyobi71Cwgjq3Q9ZtnJ4/epOG4sgCILQfkSAcwnaWDt7MyTEHXcHmy4eDVTpy4hdvwqAkTfc0ukJB8f2VPYgbU86fXJq4JVXA3Dkz/WYjIZOHY8gCIJw/kSAcwlaXxvgTOkmtacOrv4ds8GAT4+e7V6SoTVG1wY4O5IKsVplAMIHD8fJ04uacj3xO7Z2+pgEQRCE8yMCnEtMWZWJPanFQPfYf2MyGji8YQ0Aw6+b2SXlIgYGu2Fvo6ao0sjJ3HIAVGo1A6ZcBcChtX8gy3Knj0sQBEE4dyLAucRsTsjHYpWJ8HYkxMOhq4dDwq7t1FSU4+TpRfiQ4V0yBhuNiuFh7gBsTyqof7/vZVPQaG3IT0smOz6uS8YmCIIgnBsR4FxiNsUpp4ImdYPZG6B+E2//SVNRqbruuPqYCOW4+LbE0/tw7Jyc6TVmPKBkNxYEQRAuHCLAuYSYLFY2x9cGONHeXTwayEtJIicpHpVaQ9/LpnTpWMbU7sPZl1ZMjclS//7AK6cDkLh3JxXFRV0yNkEQBKHtRIBzCdmfVoK+xoy7gw0Dgrq+uObhDcrsTeSI0R1SMbwtIn0c8XLSUWOycvBUSf373qE9COgVg9Vi4fDGNV04QkEQBKEtRIBzCdkUp5yemhjV9cU1ayoriNu+BYD+U6Z16VgApUxDE8fF4fQszpGNazGbTJ0+NkEQBKHtRIBziZBlmY21AU53WJ46sWUTZqMBz+BQAqJiuno4AM0GOD2HjsTR3YOqslIS9+7siqEJgiAIbdQpAc4nn3xCWFgYtra2DB48mG3btjXb9q677kKSpEav3r1717dZtGhRk21qamo64+NckJILKkkrqsJGrWJsbYHJriLLMrG1R8P7T57WJUfDm1KXD+doVhmlVcb699UaDX0mTgbgxNY/u2RsgiAIQtt0eICzZMkSHnvsMZ599lkOHTrE2LFjmTp1Kunp6U22/+CDD8jJyal/ZWRk4O7uzk033dSgnbOzc4N2OTk52NradvTHuWDVLU8N7+GOo07TpWPJOH6EkuxMtLZ2xIyd0KVjOZOviy0R3o7IMuxMbrihOGbsRABOHT5EZWlJU7cLgiAI3UiHBzjvvfcec+bM4d577yU6Opr333+foKAgPv300ybbu7i44OvrW//av38/JSUl3H333Q3aSZLUoJ2vr29Hf5QLWv3x8G5Qe6quLEPMuMuwsbPv4tE0NCai6WUqN78A/CJ7IctW4rZv7oKRCYIgCG3RoQGO0WjkwIEDTJnS8AjwlClT2LmzdXsZvvrqKyZNmkRISEiD9ysqKggJCSEwMJCrr76aQ4cONduHwWBAr9c3eF1KSiqN7D+lZC++vIv331QUF5G0bzcAAyZP7dKxNKV+H05iYaNrvcddBohlKkEQhAtBhwY4hYWFWCwWfHwazhr4+PiQm5t71vtzcnJYs2YN9957b4P3e/XqxaJFi1ixYgWLFy/G1taW0aNHk5iY2GQ/b7zxBi4uLvWvoKCgc/9QF6DNCflYZejl60SgW9fOmBzf+iey1UpArxg8g0O7dCxNGd7DA41KIr24ivSiqgbXIkeORa3RUHAqlfy0lC4aoSAIgtAanbLJ+O+bSGVZbtXG0kWLFuHq6sqMGTMavD9ixAhuv/12+vfvz9ixY/n555+JjIzkww8/bLKfp59+mrKysvpXRkbGOX+WC9HG2uWprp69kWW5fvaj9/hJXTqW5jjqNAwMdgUaL1PZOTrRY9AwAE5s+6uzhyYIgiC0QYcGOJ6enqjV6kazNfn5+Y1mdf5OlmUWLlzIHXfcgY2NTYttVSoVQ4cObXYGR6fT4ezs3OB1qTCarWyNV+orXd7F+2/yUpIozspAo7UhcsToLh1LS8b0VE6ZnVmXqk5M7TLVye2bsVosja4LgiAI3UOHBjg2NjYMHjyYDRs2NHh/w4YNjBo1qsV7t2zZQlJSEnPmzDnrc2RZJjY2Fj8/v/Ma78VoX1ox5QYzno42DAh07dKx1M3e9Bw2Ep191xf6bM6YCA8AdiUXYbU2rCIeNnAwtk7OVJaWkH40tgtGJwiCILRGhy9RzZs3jy+//JKFCxcSFxfH448/Tnp6Og888ACgLB/Nnj270X1fffUVw4cPp0+fPo2uvfzyy6xbt46UlBRiY2OZM2cOsbGx9X0Kp208I3uxqguzF1vMJuJ2KJmL62ZBuqt+ga442KgpqTJxIqfhhnS1RkuvUWMBZT+RIAiC0D11eEKUWbNmUVRUxCuvvEJOTg59+vRh9erV9aeicnJyGuXEKSsrY+nSpXzwwQdN9llaWsrcuXPJzc3FxcWFgQMHsnXrVoYNG9bRH+eCIsty/fHwrl6eSj10gJpyPQ6uboT0HdClYzkbrVrFsDB3/oovYGdyIX0CXBpcjxl3GbHrVpG0bzeGqip09t3rqLsgCILQCQEOwEMPPcRDDz3U5LVFixY1es/FxYWqqqrGjWvNnz+f+fPnt9fwLlpJ+RWkF9dmL67N79JV6paneo2ZgEqt7tKxtMbonp78FV/AjqQi5o4Lb3DNNzwSN/9ASrIzSdyzoz7LsSAIgtB9iFpUF7G601Mjwz1w6MLsxdUV5SQf2AucziXT3Q0PU/bh7Esrxmi2NrgmSZLIiSMIgtDNdW3OfqFDbeomxTXjd2zFajHjFdoDr5CwLh3L3ylFSPP582QeOWU15OkN5OlrKK40opYkqowWticVcFmvhkt80WMmsP2nb8mIO0ZFSTGObu5d9AkEQRCEpogA5yJVXGnkYLpSM+myLt5/U5/7ppvN3iQXVPDSiuNsayJrMYBFVk5Q3fftAa7p789tw4MZEqoEMs5e3vj1jCInKZ7EvTsZeMXVnTZuQRAE4exEgHOR+uukkr042s+ZAFe7LhtHcXYmOUnxSCoVvUaP77JxnKnSYObDP5P4ansKJouMjVrFrcODifZzwsfZFh9nW1zstLy55iQrDmdjscosO5TFskNZPDA+nKeuiEKlkogcMZqcpHgSdm8XAY4gCEI3IwKci9Smk91jeerEViXjb2j/QTi4unXpWACOZZVx37f7ySmrAeCyXt68cHUMoZ6N8/LMmxzJisPZqFUwvZ8/y2Oz+WxLMnn6Gt66oR+RI8aw5fuFZMYdp7K0pFt8PkEQBEEhNhlfhIxmK1sTlGWXrjweLssycduVAKc75L5JzCtn9sK95JTVEORux5ezh7DwrqFNBjcAIR72BLjaYbHCdYMCeefGfqhVEssOZTHnm32onN3x7RkJskzintYVjxUEQRA6hwhwLkJ7UouoMJjxctLR7285XDpTTmI8+oJ8tLZ2hA/u2hxF6UVV3P7VHoorjfQLdGH1I2OZFNNy8CdJEqPCldNUO5MKuWlIEF/eOQR7GzXbEguZ9fkuvAaNASBh9/YO/wyCIAhC64kA5yJUl9zvsi7OXhy/cysAPYcMR6uz7bJx5JbVcNtXu8nTG4jyceKbu4fhZKtt1b2jeyr5g3YkKzNiE6O8+WnuCDwdbTiereeNZBeMkqZ+mUoQBEHoHkSAc5FRjj0r+2+6snq41WohvnZWI2rUuC4bR1GFgdu+3E1GcTWhHvZ8N2cYbg4tF289U90MzvFsPaVVRkAp5bD0wVH4OtuSWlzD3tCrkGUriXt3dchnEARBENpOBDgXmYS8CjJLqrHRqBjThdmLs+KOU1lSjM7BgdD+A7tkDEazlXsW7SO5oBI/F1u+v3c43s5tm0nydralp7cjsgy7U4rq3w/xcGDBLQNRSXAIf+Ico8QylSAIQjciApyLTN3szehwD+xtuu6Q3Mna5amIYaNQa1q3HNTePvwzkcOZZbjaa/nh3uEEup1bzajRtbM4O5KKGrw/LMydxydFArDZYyxHEjOpKis9rzELgiAI7UMEOBeZTfXLU113espiNtefKuqq5anYjFI+2ZwMwGsz+tLDy/Gc+xr1t304Z3poYk9GhXtgVmlZ43k5x3btOOfnCIIgCO1HBDgXkcIKA4cySoGu3X+Tceww1eV67JxdCO7dr9OfX2Oy8MTPsVisMtf09+eqfn7n1d+IHh6oJEgpqCS3Nn9OHbVK4v1ZA3DWyBTpPHlve855PUsQBEFoHyLAuYj8eTIfWYbe/s74uXRd9uKTO7cBEDliTJdUDn97bTzJBZV4O+l45dre592fi52WvrXH7XckNZ7F8Xa25c3pEQDsNvvxx/7k836mIAiCcH5EgHMR2XBCWZ6afJb8Lh3JbDKRtE85TdRr5NhOf/6u5CIW7kgF4K0b+uFq3/oTUy0ZGd78MhXAtOFRjCYNgP+sOonBbGmX5wqCIAjnRgQ4F4lqo4VtiQUATOrC/Tdphw9iqKrE0c2dgF4xnfrsCoOZJ385DMAtw4KY2Kv9lulG96xL+FeEXFuE8+/mDvHCwVxJbjV8szOt3Z4tCIIgtJ0IcC4SO5IKqTFZCXC1o7e/c5eNoy65X9SosUiqzv3jNX9DAlml1QS62fHsVe0bXA0JccdGrSJXX0NKYWWTbfqMGMmIkj0ALNiUSFGFoV3HIAiCILSeCHAuEnXLU5OivZGkrslebKqpIWn/bqDzT0+dKqrk211pALx2XV8cde17RN7ORs2gEFdAKdvQFPeAQEY5VeBlKKDCYGH+xoR2HYMgCILQeiLAuQhYrHJ99fDJMb5dNo6UQ/swGwy4ePvgGx7Zqc9+e208JovMuEgvxkd6dcgzRtftw/lbPpw6kiQRMWwkY4uVo+I/7kknIa+8Q8YiCIIgtEwEOBeB2IwSCiuMOOk0DAtz77JxJOxSMvlGjhzbqbNIB06VsOpoDpIET0/t1WHPqcuHsyulCIu16X04PYeMIKAmh541p7DK8J9VcR02HkEQBKF5IsC5CGw4oRTXnNDLGxtN1/yWmmpqSDm0H4CoEWM67bmyLPP6aiWIuGlwINF+Hbf/qH+gC446DWXVJk5k65ts49czEgdXN0YWbEejgq0JBfwVn99hYxIEQRCaJgKci8CGE7lA1x4PT43dj9moLE95h4V32nPXHsvlwKkS7LRq5k2O6tBnadQqhtfOkDV3XFxSqQgfMhxXs57LnMoAeG1VXLMzPoIgCELHEAHOBS6loILkgko0KokJUR2z96Q14ncr+04iR4zptOUpo9nKW2tPAnDf2DB8XdpWSPNc1JdtaGajMUDPoSMBiDm1ERc7LUn5Faw9ltvhYxMEQRBOEwHOBa7u9NSIHh4423ZNUUuToYaUg3sBiBw+utOe+8OeU6QVVeHpqGPu+M6ZNarLh7MvrbjZZH7BffphY2ePpSSfG6KUGlgf/5XUbP4cQRAEof2JAOcCV1c9vGuXpw5gNhhw9vLBJzyiU55ZYTCzYFMiAPMmR7b7sfDmRPk44eloQ43JyqH00ibbqDVawgYOAWCwMRF7GzUncvRsSSjolDEKgiAIIsC5oBVVGDhwqgSASV0Y4NSfnhoxutOWp77ffYqSKhM9PB2YOSSwU54JylHwurINzeXDAeg5dAQAeQd3csvQIID66uaCIAhCxxMBzgVs08l8rLXFNQNcu6a4psloIOXgPkAJcDpDjcnCl9uUelMPTghHo+7cP8ajw5Vlqh3JTefDAQgbMASVWkNJThY3RtihVUvsTS1mf1pxZw1TEAThkiYCnAtYdyiumRZ7AJOhBidPr05L7rdkXwaFFQYCXO2YMTCgU555ptG1G40PZ5RSYTA32UZnb09w3/4A6OP2c8MgZZZJzOIIgiB0DhHgXKCqjOZuUVwzoe701PDOWZ4ymq18tkUJEh6YEI62k2dvAILc7Qlyt8Nsldmb2vwsTkTtaaqk/bu5f3w4Kgn+PJnfbA4dQRAEof2IAOcCtSW+gBqTlSD3riuuaTIaSD5Qe3qqk5L7LTuUSU5ZDd5OOm4a3Hl7b/7ubGUbAMKHDAcgNykBT1U10/r6AfDpFjGLIwiC0NFEgHOBWntcyatyZW/fLiuumXb4IKaaapw8vPCL6NgkewBmi5VPa5d45o7rga1W3eHPbE5r8uE4uLrh11P5uaQc2MeDE5Sj7KuOZJPWTEVyQRAEoX2IAOcCZDBb+DNOSf9/ZZ+uK655+vTUqE4JslYdzSGtqAo3ey23Dg/u8Oe1ZFTtRuOTueUUlBuabVc3i5O8fze9/V2YGOWFVYYvt6d0yjgFQRAuVSLAuQDtTC6i3GDG20nHwCC3LhmD2WisT+4XMbzjl6esVpmP/0oC4J7RYdjbdE7em+Z4OuqIqa171dIsTl2Ak37sMMaaau4b1wOA3w5moa8xdfxABUEQLlEiwLkArT2qLE9d0dsXlaqLlqeOHMJYXY2juwf+nbA8tSEuj4S8Cpx0GmaPCu3w57XG2AhlmWpbYvMBjkdgMK4+fljMZtIOH2RkDw8ivB2pMlpYeiCzs4YqCIJwyREBzgXGbLGyoTZ7cVcuTyXurl2eGj4aSdXxf4z+t1VZ0pk9KgQXu64pSfF3Y2oDnO1JBc2WYZAkifAhwwBI3r8HSZKYPTIEgO92ncIqinAKgiB0CBHgXGD2pZVQXGnE1V7LsNrK1p3NbDKRtH8PABGdkNzvUHoJB06VYKNWcWc3mb0BGBrqjo1GRZ7eQFJ+RbPtwocoWY1TDu3HarFw3aBAHHUaUgorm61KLgiCIJyfrt3IILTZutrTU5OifbokBwxA+tFYjNVVOLi5ExAZ3eHP+2q7krV4en9/vJ06vmJ4a+gLCzj653puKj9KWVk5q9/cgJvWgmy1EtJvAFEjx+HbMxJJkgiIisHW0Ymacj3Z8XEExvThxsGBLNqZxjc7TzE2ouuqwAuCIFysOuUb8pNPPiEsLAxbW1sGDx7Mtm3bmm27efNmJElq9Dp58mSDdkuXLiUmJgadTkdMTAzLli3r6I/R5axWmbXHlABnaleenqpdnooYNqrDl6eySqtZU/uZ54wJ69BntUZOUjx/fPA2X/5zDruXLsY99xhh1acwZydRcCqVwoxTHFj1Oz8+9wRf/vNetv7wNSU52fSoLb6ZdECZ+bp9hLJMtelkHhnFVV32eQRBEC5WHR7gLFmyhMcee4xnn32WQ4cOMXbsWKZOnUp6enqL98XHx5OTk1P/iog4XaV6165dzJo1izvuuIPDhw9zxx13MHPmTPbs2dPRH6dLHc4sJVdfg4ONur5cQGezmE0k7d8NQFQnJPf7dmcaFqvMqHAPYroooSFA5snjLH7hKX589gnid25FtloJiulL5NW38KfHeP70u4Jr/vUS0+c9Ta/R49HqbNEX5LFvxVK+feqfULsXPHn/bmRZpqe3I2MjPJFl+GFPy/8tCIIgCG0nyc3tjmwnw4cPZ9CgQXz66af170VHRzNjxgzeeOONRu03b97MxIkTKSkpwdXVtck+Z82ahV6vZ82aNfXvXXnllbi5ubF48eKzjkmv1+Pi4kJZWRnOzl33pdlWb6yJ4/MtKVzdz4+Pbh3UJWNIPbSf3958CTt7B24aPQWMBux698a2b1807ue2J0iWZWpqsqisTKCiMpHKygSqKlOwqPy49/dpVBglvrpzCJd3QUkKWZY5tPYPNn/7BbLVikqtodfocQyadi0+YeFYrTJDX9tIUaWRJXNHMLyHkh/HZKgh9dB+jv65nrTDB5XOJAlkmbve/RSPwCDWH89l7ncHcLPXsuvpy7s0caEgCMKFoC3f3x26B8doNHLgwAH+/e9/N3h/ypQp7Ny5s8V7Bw4cSE1NDTExMTz33HNMnDix/tquXbt4/PHHG7S/4ooreP/995vsy2AwYDCcTsam1194tYBkWWZd7VJNV5yeMqalUfztd+w/ug9U4JWeTeGu/zZoow0MxK5fX1xn3YzD8GGt6reyMoWT8c9RWtp49m1TugsVRgkf+3zcjS+Qm3sV3t7TUKk6Z+uY2Whk45efcHzLRgCiRo1jwh1zcHT3qG+jUkmM6unJysPZbE8qrA9wtDpbIkeMIWL4aI5sXMvmb77AbDICsG/lb1z54KNcHu1DgKsdWaXVrDyczU1DgjrlcwmCIFwKOnSJqrCwEIvFgo9Pw795+/j4kJub2+Q9fn5+/O9//2Pp0qX89ttvREVFcfnll7N169b6Nrm5uW3q84033sDFxaX+FRR04X2RnMwtJ62oChuNiolR3p32XGt1Nfnvv0/K9Gso+vFHcqxKcrpANDhNnozLtddg00NJXmfKzES/eg3pd95JzssvY61svhyB1WokNfVD9uy9itLSPUiSBkeHKHy8r6ZH2ONEx3zIluxrAZgUvJnioo0cP/E4h4/ci9lc3uGfu7yokCUv/YvjWzYiSSrG334PVz3yfw2CmzpjezafD0eSJPpPnsptb8zHwVWZ4Tq+eQMH16xErZLq9+J8syut2aPmgiAIQtt1yl+F/57GX5blZlP7R0VFERV1OnHcyJEjycjI4L///S/jxo07pz6ffvpp5s2bV/9rvV5/wQU5q4/mADAuwgsHXcf/tsmyTMWff5L32uuYsrMBqBwxFFN1MXaOTgz7cTlq9elxWPR6ao4fR796NaW//Erp4p+o3LoNv9f+g8OIEQ36Li07wMmTz1JZmQiAh/s4oqJexc7udPHM9cdzydIfwMVOy6PX/Jvy0jWkpy+kuHgb+w/cRP9+XzZo356KMjP4+ZWnqSorxdbRiasf/Rch/QY0274uH86RzFLKqky42DfO0+MZFMKsl95k4WNzAfhr0efYOToya+ho5m9M4FiWniOZZfQPcu2IjyQIgnDJ6dAZHE9PT9RqdaOZlfz8/EYzMC0ZMWIEiYmJ9b/29fVtU586nQ5nZ+cGrwuJLMv8cUQJcKb39+vw51mrqsh65BEyH/4HpuxsNH5+BHy4gJKRykmgyJFjGgQ3AGpnZxxGjsTv1VcJ/nohWn9/TFlZpN91Nzkvv4xsUmZ+cnNXcODAzVRWJqLVetC79/v077+wUbBSdzT8lmHBeLtHE95jHoMH/4TOxofKykT27b+esrLYdv/s5cWFLH39BarKSvEMDuX2N+a3GNwA+Lva0cPLAasMu1Kaz2vj5uePd1h4/a/Xfvo+ZQlHmFa75PjTvox2+QyCIAhCBwc4NjY2DB48mA0bNjR4f8OGDYwaNarV/Rw6dAg/v9Nf7CNHjmzU5/r169vU54XkeLae1MJKdBpVh2+0tZSVkX7PHMo3bAStFo+5cwlf9QcOEyeStE85PRUxvOXkfg4jRxK2YgWut9wMQOnin8h57nny8tdyIu5JwIqPz3RGjliPr8/0RjNvJ7L17EktRqOSuHNUSP37zk59GDJkKY6O0ZhMRRw8dCv5+Wvb7bMbqir57Y2XKC8qwM0/kJkvvI6Ld+v2O42rzWXTUtkGgJ5DldksR3cPrBYLK957g2k+yt6cFbFZVBrM5/EJBEEQhDodfkx83rx5fPnllyxcuJC4uDgef/xx0tPTeeCBBwBl+Wj27Nn17d9//32WL19OYmIix48f5+mnn2bp0qX84x//qG/z6KOPsn79et566y1OnjzJW2+9xcaNG3nsscc6+uN0iZVHlCWiy6O9cezA5SlzQQGn7phNdWwsKhcXQr/7Fu95j6OytyfzxDFqyvXYOTkTFNP3rH2pHR3we/FFAj/+CNRq8pKWcfzIP5FlC36+N9A75j20Wtcm7/1mZxqgbKb2c7FrcM3W1o/Bg5bg6XEZVquBY8cfpazs0Pl+dMwmE7+/8x8K09NwcHXjhqdfxs6p9TN9Y3rWlW04S4BTm9W4Wq8npN9AzEYDCd/Np499FZVGC6tqZ+oEQRCE89PhAc6sWbN4//33eeWVVxgwYABbt25l9erVhIQofzPPyclpkBPHaDTy5JNP0q9fP8aOHcv27dtZtWoV119/fX2bUaNG8dNPP/H111/Tr18/Fi1axJIlSxg+fHhHf5xOJ8syfxxWvvSu7uffYc8xZmaRdtvtGBISUHt5EvLtt9gNGFB/PX63kpyx57CRqNStP87sdPnlOLx2O8X3mZFVVtxq+hId/QaS1PQfvdIqI8tjswC4q5myDBqNA/36fYa39zRk2cyx449hMp37yTjZamXNx++RceIoNnZ2XP/0y7h4t22mbES4BxqVxKmiqhYT93kGh+Ls5YPFbKL3hEn4RURhqKzgsrTfsbVU89M+kRNHEAShPXRKJuOHHnqItLQ0DAYDBw4caLBZeNGiRWzevLn+10899RRJSUlUV1dTXFzMtm3bmDZtWqM+b7zxRk6ePInRaCQuLq5BAHQxOZRRSlZpNQ426g47PWVISeXUbbdhSk9HGxhI6A8/YBsVWX/dYjaTuHcXAFEjx7ap79KyA6S4/QA2YHtYwvapBCr+3Nxs+5/3Z2AwW4nxc2ZwiFuz7SRJTXSv17GzDaamJpOTJ58551NIW39cRMKubajUGq554lm8Q3u0uQ9HnYaBwa5Kf4kFLYxboucQJRA/dfgg1/37Jdz8A5ErS5lUuIWDp0pIyOv4U2KCIAgXO1Fss5tbeVhZnpoU44OdTfsngjOXlJAxdy7mvDxseoYT8sP32AQHN2iTceywsjzl7NKq5ak6BkM+R448gMVShbvbGEJLZiKZZbLmPUHVocbLSharzHe7TwFw56iQZk/F1dFonOjT5wMkSUN+wRqyss+e5PHvUg7uY//K3wC48sFHCek7oM191KmrKbUlvvkAB07vw0k+uA+dnT1XP/oUKrWGsKpUYiri+Gmv2GwsCIJwvkSA041ZrHL9nozpHbA8JRuNZP3zEUyZmWiDggj59lu0TZxEO7lLWZ6KHD661ctTsmzlxIn/w2QqxtGxF/36fYb/C6/gOH48ssFA1uPzsFQ0zJPz18l8MoqrcbXXcu2AgFY9x9m5H+Hh/4eqArLnv0ri1MkkXXY5iRMvI3H8BBLHjiN15izK/liFbG64gbeipJi1n8wHYNDUa4geO7GpR7TahCglwNmRVIjRbG22XUCv3g2Kb3qH9mDMLco+tHFFO9iw+xg1Jst5jUUQBOFSJwKcbmxfWjH55QacbDWMjWzf2lOyLJP76qtU7d+PysGBoE8+brLUgsVsImlf3fJU62tPpad/SXHJdlQqW/r0/gC12g5JoyFg/ntog4Mx5+ZS8LfM09/sSgNg1pCgVpctMGZkYLMoG5/nbHH6A8ypmZiyszHn5GDOy8NcUEDNkSNkP/kkyVOnUfLTEqwGQ/2+m+pyPV4hYYy97e5Wf7bm9PF3wdPRhkqjhf2nipttp1KrTxffrK3rNeSqGQTG9EMrmxmRsZZ1R7POezyCIAiXMhHgdGN/1J6eurK3LzpN+y5PlXz3HaW//AoqFQHvvYvujGKmZzp1JBZDZSUOrm4ERPduVd96/RGSU94FIDLieRwcetZfU9nb4/fSi8oYfviB6sOHAUguqGBbYiGSdLrSdkusVVVkP/0MyVdcSemPi5GMVkwhakruNqN690pCf/2VsN+WEvbbUrwefQS1mxumjAxyX3qJ5EmT2f7uW6QfjUVjo+OqR55Co22cnK+tVCqJcZGtW6YKr1um2rMN+fDPSPGrmPrAP8DGDl9DPlt//vG8xyMIgnApEwFON2W2WFlzVElmeHX/9l2eqti2jbw33wLA+//+D8fx45ttG1+3PDViDCrV2YMss7mCY8cfRZbNeHtNxd9/VqM2DqNG4XLttSDL5Dz/ArLJxHe7lL03l/fyIcjdvuVnFBRwavadlC1bBlYrDmPHErzoa/x/+IjqoVay7NdAuBO2MTHYxsTg+eCD9Ny0EZ9nnkHj50dhhZ59+7YDMPGu+/AIbL+s1hNqN4Jvbi7AyTsBv84hdPc81JKV0sIiihY/Cktux/nbcYwcrgR3vqk7OLD3YLuNSxAE4VIjApxualdKEUWVRtwdbBgV3rj+0bkyZmSQ9fg8sFpxuf563O+6s9m2ZqOxPrlfZCuXp+ITXqK6Oh1bnT+9er3W7EZh73//C7WbG4aEBNK/XMSvBzIBGiT2a4ohMZHUWbOoOXYMtasrId99S/AX/8NhxAg8PSfg7j4WWTaRnPJeg/tU9va4z76D4OXLONI7HFmS8C2tICC75bw1bTUuwhOVBPF55WSXVje8ePRX+PJyOPYrNiUnCXEoASBJPQCc/KCygFGFX1Ds6IUKmb+++ACLWST+EwRBOBciwOmm6k5PXdnHF626fX6bZLOZ7P97CmtFBXYDBuD70ostnlRKO3wQY3UVju4eBERGn7X/vPw15OYuA1T07j0frdal2bYaNzd8nlaqzP+8ah8VBjM9vBwYHd78XqPKnTtJu+VWzNk52ISEELrkJ+yHDm3Qpmf4U4BEXt5K9PojjfrYvnQxFSYD9lodfTMLyH/tNYq++uqsn621XO1tGFBbT2pLQu0sjsUM656FpXPAVAU9JsDtSwm/7jEAkuVe8NhRuOkbCBnDCJ9MqlS2SPoiDi75tN3GJgiCcCkRAU43VGOysPZY7fJUv/arPVX42edKlmJHR/z/+19UNjYttq9bnooaOQZJ1fIfFbO5nMSEVwEIDX0QV9chZx2P8/Tp2I8ezYpgZT/KHSNCUKmaDrj0a9eSPvd+JTgbMpiQnxZjE9J4tsfJKQZfX6UKeWLSmw1y4+QkxhO7fhUAU596Dt+5SuHL/Hf+S8GHH511vK1Vt0z118l8qCiA72bArtr+xzwOt/8GPScRPmYKSBK5yYlUlOmh9wy4exVTHp5PrMdgALb/sZaK45vabWyCIAiXChHgdEOb4vLR15jxc7FleFj7LE9VHTxE4SefAOD74ovYBLZ8DNtkNJB8YC8AkSPOntwvJXUBBmMednbBhIY83KoxSZJE2r1PkOHsg52phimFJ5psV334MNlP/QvMZpyvvprghQvRuDWfBLBH2DxUKhtKS/dQVLQZUJIVbvjfhyDLxIydSGi/gXg/+ihejz8OQOHHH1P2+++tGvfZ1B0XP5aUhvzl5ZC2DWwcYea3MOklqN3L5ODqhl9EFADJB/bU368L6EPfy6aQq/PGapXYtuA5SNveLmMTBEG4VIgApxtaelDZj3LdwADUzcxotIWlooLsp54CqxXna6bjMv3qs96Temg/pppqnDy96r+Em1NeHkdm5jcAREW+jFqta/XYFicpZQ0uyzhIzeefIFsa5n8x5eSQ8fA/kI1GHC+/HP+33zrrzJOdXQCBgcreoqTkt5FlCwdWLacgPQ1bJ2fGz763vq3n/XPxfOghAHJf/Q/GzPM/nt3H3wVPBy3Pyp8jlZ4C1xC470+IubZR27raVHV7nercNKInWzzGIgMnSj3I/PwuSBIzOYIgCK0lApxupqDcUL934/pBge3SZ96r/1GS+QUE4Pv88626J36XMmMQNXJsi/t0ZNlKfPzzyLIFb+9peHiMa7bt32WXVrMhLg+AawuOYExJQb96df11a1UVGQ89jKWwEF2vXgS8/dZZl8rqhIY8iEbjQmVlAglHv2HXr0qW4wl3zMHeueHeIM+HHsRu4ECsFRVk//tfjYKstlKpJJ7wPsBV6r1YJDXM/Aa8mg4Sw2vLNqQfO4Kh6nQNq97+LniG9uSEo7L36c+sQKw/3gzZ519YVBAE4VIgApxu5vfYLCxWmf5BrvT0djzv/vSrVytLLyoV/u+8jdrJ6az3GGuqSTmoLE+drfZUds4vlOkPoVY7EBHxbJvG9uOedCxWmRE93Bk0S5lVKvz4E2SzGdlqJftf/8IQF4faw4OgTz5G5eDQ6r61WhdCQx9ClmHrt0swGw0E9+lPzLjLGrWVNBplZsjenur9Byj6amGbPkcjxSncVLAAgEU2t4H/wGabegQE4eYfiNViJuXQvgbXZg4JZKf7cExqHQUGR44UesBvc8FU3UxvgiAIQh0R4HQzSw8qSyQ3DmpdqYKWmIuKyH35FQA8H7gf+0GDWnVf8r7dmA0GXH388OnRs9l2RmMxSUlvA9Aj7DFsdb6tHpvBbKmvnD17ZChut9+O2tUVY1oa+lWrKPhgAeUbNiJptQR+9CFa/7bnAgoMuIOKtGD0GVrUWjWT7nu42dkom6AgfJ57DoCCBQuoPn68zc8DwGKCpfehMVexx9qL18qmND4u/jeRw0cBkLRnZ4P3rx0QgNXGgR2uwwDYXhhGVW4KbHzp3MYmCIJwCREBTjdyIltPXI4eG7WK6e2Q3C/vtdewlJWh69ULzwcfbPV9cds3A9BrzIQWl6eSkt/GbC7F0bEXgYGz2zS2tcdyKaww4utsy+QYH9SODrjfc48y7nffpejzzwHwe+0/2A9sfgakJaYaE5k7lM3IAcOMuPq0fCLN5boZOE2ZAnXH6avPYaZk6zuQtR90Lnzl9W+sqE4fF29GxDAlwEmJ3Y/JUFP/vpuDDZNivDnmFIPF1Q+DRc3eoiDY8xkk/9n2sQmCIFxCRIDTjdRtLr482htX+5Y30p5N+aZN6FevAbUav9f+g9TKUgRVZaWkHVH2eUSPmdBsO335MXJyfgUgKuoVVCpNm8b3zc40AG4dHlyf58ft1ltROTtjyVcCArfZd+ByzTVt6vdMu5cuxlBpxNbVhGt0AkXFW1psL0kSvi+/hMbLC2NKCvnvzW/bAzP2KgEOwNXv0SemDwCb4/NbvM07LBxnL2/MBgNphxtmL75pcBCypGKLs5LvJ7Y0CL3JBpY/DNUlbRufIAjCJUQEON2E2WLl91hleeqG89xcbNHr65emPO65G7verashBUruG9lqxadHBO7+TS+TybJMUuIbgIyPzzW4ugxu0/iOZZVxML0UrVri5mGnyySoHR3Q+tYuc2k1eD3ySJv6PVNRVgaH1v4BwIBr+6FSQ0b62ffWaNzc8Hv9dQBKfvwRQ0pq6x4oy7DmXyBbod8s6HvjGdXFi1qsLi5JEhHDRgKQuHdXg2tjIzzxcdZxXOWPfXAkFqvM7vI+UJ4Nq55s3dgEQRAuQSLA6Sa2JhZQWGHEw8GG8bVfjOcq/513MOfnYxMSgufDrctJU6dueaql2Zuios2UlO5GkmwI7/FEm8dXV3dqah8/vJ1s698vW7UKQ0KC8guTmfL1G9rcNygB2OZvv8RqsdBj8DAGTXwMSVJTXLKD8vK4s97vOHYMjhMngsVCwfz3ztoegMQNkH0QNHYw5TVAOS7u5aSjwmBmd0pRi7dHDBsNQMqBvVjMpvr3NWqVcppOkjjmr5TLOJbvSJHREY79qpR/EARBEBoRAU43sfSAMntz7YCA8yrNULlrl1IlHPD7z6uobG3Pcsdppbk55CTGI0kqeo1u+ri31WomKVkp1BkUdCd2dm2bbSqtMrK8dqZq9sjTmYhNefnkvqJkQrYfpcxmFH722Tkd2U45uI+02AOo1BomzL4XO7sAvLyuBCAjo/EsjixbqKnJpqoqlYqKePT6I9j+4wqsDhLlGzZSdfAsR7NlGba8qfz7sHvBUQlQVSqJSdE+AKw/kdtiF/6RvXBwdcNQVUn6sYYlJm4arPyM1+TrCOw/BFmW2SlPUi6ufRoMFS2PTxAE4RIkApxuoKzKxIYTSj6Y68/j9JS1upqcF14EwPWWmxvVaTqbutmb4L79cXBtOlNwTs4vVFYmotG4EhryUJvHuGRfBgazlWg/ZwaHKM+QZZmc557DWlaGbe/eBM6fj8rZGVN6OhVbt7apf4vZxOZvvwBg8FXX4uarbNYODp4DQG7eSgwGZU+MwZBHSuqH7Ng5jh07x7Jr9yT27J3Gvv3XcSRvHnlvmSieYyb1p2exWlsoepm0EbIOKLM3ox5tcGlKbyXA2XgiH6tVbupuACSVip5Da5ep9uxocK2HlyNDQtywylAYdTlIEgkpReRqI6Ey/3QZCEEQBKGeCHC6gRVHsjFarPTydaK3v/M591P4ySeYMjLQ+Pri/UTblo5kWT7r8pTZXEFK6vsA9Aj7J1pt28Zqscp8W7s8dfeo0PoTWqU//0Lltm1INjb4v/0WahcXXG+8EYCS739o0zMOrl5BaW4ODq5ujLh+Vv37Ls79cXEZjCybSEx8nSNHH2LHzrGkpr6PwZCLJGlQqx3Raj2w1fmj0/kiq6zUDLaSe2U82/8aTnLyfzGbKxs+UJZh8xvKv58xe1NnVLgHDjZqcvU1HM0qa3HsEXXHxfftxmptOHN10xBlFmdpmqX+92d7Re3psh0LoKLljcyCIAiXGhHgdDFZlvlxj5IP5sbBgS0ey25JTUICRV8vAsD3hedRO7YtSWBeShIlOVlotDb1Mwl/l57+JUZjIXZ2IQQE3NrmMW6MyyOrtBo3ey3XDFBmVswFBeS/o5w88pr3OLrwcADcbr0FJInKHTswpKS0qv/K0hJ2//YTAGNvvQsbO/sG1wMCblM+a/5KCgrWIcsWXFyG0DvmPSaMP8KE8YcZN3Yvo0dvY/So7QwbugKPgn5IFWCSSkk79Sn7D9xAVdUZG4+TNp0xe9N4U7ROo67fU1U3S9ecwOg+2Do6UV2uJyuuYR6eq/r5Y6dVk1JQifPoq1GpNZxKySbdbiiYKmHzm636GQmCIFwqRIDTxQ5llBKXo0enUXHj4HM7PSVbreS++BKYzThOuhynyxpn6z2butmbHkOGo7O3b3S9xpDLqXRl6adn+FOoVG0/xr5oRxoANw8LxlarFJzMe/sdrBUV2Pbpg/sdd9S3tQkMVDb60vpZnO0/fYexuhrfnpHEjJ3Y4Fp5+XFSUz+o/7Wry1CGD1vNkMFL8PW9FpWqYf0sSZJwcupN32nfEvCWF25faNBanKisTGTvvhkUFv7ZcPZm6Bxw9G5yXFNilJNhZ9uHo9Zo6ks3/P00laNOw1W1leVXJhvoP3mq8pkLeiDLwIFFUJjYYv+CIAiXEhHgdLHvdytLNlf38z/n3DelS5dSfegQkr09vs+2rVwCgNVqIX6nstelueWp1NQFWK01uLgMwsvrijY/42Sunl0pRahVErePUDYXV+7eg37lSpAkfF98EUmtbnCP+x23A1C6fDmW8vIW+y84lcqxzcqpq4l33ldfs0qWZTIyv2Xf/huprj6FRqMsq5nMpTg4RJ513GonJ7zmPojdIRXe7zng4jQQi6WCw0fuI+XAY8hZ+5XZm9GPNtvHxChv1CqJhLwK0gorm20Hp5P+Je7diWxteLS8brPxH0ey6Xf1DWhsdORkZHPKbRLIFtj08lk/jyAIwqVCBDhdqLTKyB9HcgC4fUTwOfVhLioi/7/vAuD1z3+i9Ws5W29T0o8dobK0BFtHJ8IGNC7nUFWVWp/Ur2f4v85pGe2bnUogd0VvHwJc7ZCNRnJfUXL1uN1yM3Z9+zS6x37ECGx6hiNXVVG2bFmzfcuyzJbvF4IsEzlyLP6RSoFKq9XEseOPkpDwMrJsxNNzEkOHrEClsqWyMhG9PrZVY3e95Ra0AQHIqcWEHJtKYIAy05Sq/4Nj0U7IQ+9udvYGwMVey4ge7sDZl6lC+g7Axs6OiuIicpISGlwbFuZOqIc9lUYLm9Nr6D9ZORm2M9cXGRXErVSSDQqCIAgiwOlKvx7IxGi2EuPnzIAg13PqI//tt7GWlaGLjq6f8WiruK1K2v+okWNQaxpnPE5OeQ9ZtuDhMRFX1yFt7r+0ysiyQ0qW5rtGhQFQ9PUijCkpqD088HrssSbvkyQJ99uUfTPFP/zQaEajTlrsAU4dOYRao2HcrXcCdcHNY+Tnr0KStEREPEe/vp9hbx+Et7eyvJOd/XOrxq+yscHj/rnKZ/n2ByJ7PEuM11wkq0y+l46koLNniZ5ce1z8bAGOxsaGsIHK6bfEvQ1rU0mSxE1DlMSIP+/PYOg1N6LR2pCTeopTvtcrjdY/ryydCYIgXOJEgNNFZFnmh9rNxbePCDmnWZHK3bsp+30FSBJ+L7+EpGlbuQQAQ1UVCbVFHmPGXd7our78GPn5qwGJ8PBzy5y7ZF8GNSblaPjQUDeMmZkUfvopAD7/egq1c/OnsVyuuQaVkxOmU+lUbtvW6LrVYmHzd18BMHDqNbh4+2K1mjl+Yh4FBWuRJBv69fuM4KC763/G/v7K6aq8/D8wm1uXQ8bl2mtRe3hgzslBv3YtfokpxMQry2bpuT+Qnd1ywr3JvZV9OPtPFVNUYWixbeQIJelf/K5tyH8LVq4fFIBKgr2pxRSYbeg3SZnF2ZXhiKy2g4zdkLCuVZ9JEAThYiYCnC6yK7mI1MJKHHUarh3Q9sKaVqOxvhyD2y03Y9ev3zmNI37nVsxGA+4BQfhFRDW6npKsLH/5+EzHybFXm/tv6mh43muvI9fUYD9sGM7Tp7d4v8rBAdfrldmJ4iY2Gx/9cx3FWRnYOjkz/LqZyLKFE3FPkp+/GknS0q/vx3h6TGhwj6vLEOztw7BYqsjLX9Wqz6HS6XC/XZlNKvriC+Tjy/EtMBLqfgMAJ+Ofo6R0X7P3B7ja0dvfGasMm062fKQ7bOAQtLZ2lBcWkJ1wssE1Pxc7xkYop7J+PZDJ0GtuQK3Vkp2UTHrQzUqj7W2soSUIgnAREgFOF/l+j/Klf93AABx0bZ95Kf7qK4ypqag9PZtd4mmNY38pG3P7TJzcaBappGQvRcVbkSQNPcLO7Rl/Pxpe/tdfVPz1F2g0+L74Qqtmrtxuu1U5Mr5tG4bU00e0DVVV7PhZCXpG3nALOns7Tpx4iry8lUiShr59PsTTs/GJMkmS8PebCbR+mQrA9eabkezsMCQkUpklg3cMPfq9gbfXVGTZxNGjD1Jdnd7s/fWnqY63vEyltdHRc+gIAE7uaFwgdGbtMtWvBzKxc3Wn3+W1szhJErLKRpnFObWr0X0XA4vFQH7BOo4ee4St24aybfsIdu6ayJ69V7F//40cP/EExSW7Gs18CYJw6REBThfI19fUf8nddg6bi40ZGRR+9jkAPv/6V4tLPC0pzDhFTlI8kkrV6Fi1LMskpyj5afz9Z2JvH9JUF2f19Q4lILllWDA62UL+m0qZB/c7Z9fnvDkbm+BgHMePB6D0pyX17+/9/Req9WW4+QXQf/JUEhNfJzdvOZKkpk/vBXh5TW62T1+/65EkDXp9LBUV8a0ah8bNDdcbameT4hxg0J1IKjUxMe/g5NQHk6mEw0fmYjY3feJrcoyyD2d7UgHVxpZLUNSVykjYvR3r38pVTIrxxtVeS66+hu1JhQy9VpnFyUpMJMPvOqXRRTaLU1Kyl+MnnmTb9mEcPfoQ+fmrMJmKMRoLqK5Op6LiJGX6Q+TmLufQodvZvWcK6elfYTKJiuuCcKkSAU4XWLIvA7NVZkiIG7182xacyLJM7quvIhsM2I8cgfPVV53zOI5t3ghAj0HDGpVmKCz6k7Kyg6hUtoSF/uPc+s8qY3dKMZrao+HF3/+A8dQp1J6eeD74YJv6cp2pzLiUrVyJbDKhL8zn4KrfARh3293k5S8jI3MRADEx7+Lt3fJRdp2NJ56eyp6jtsziuE8dCpJMZZ4tNboBAKjVdvTr9zk6Gx8qKxNJSHytyXuj/ZwIcLWjxmRla2JBi88J6TsQWydnqspKyTh+tOHYNWpmDFBKevy8LwMnd0/6XqZ83l2n7AEJEtdB3vG/d9ttyRYLppwcqvbto3TZcooWLaJi2zaMhbkkJLzKwUO3kJu7DIulAp3Ol+CgOQwe/DPDhv7B4ME/M2DAN/Tt+wkBAbeiVjtQVZVCYtLr7Ng4isQ/n6N853bKVv5B0deLKP72OwwpKWKWRxAucm1fGxHOi9liZfFeZRnjXGZvytdvoHLrNiStFt/nW7fE0xSL2cyJ2tNTfS9rONMhy9b6vTdBgXei0/mc0zO+2KZkIL66nx/e5kqSP/kEAO/HH29zpmXHcWNRe3liKSikYssWtp88jNlkJDCmDx49NRyKfR6AsLBH8fVpeV9PHX//mRQUrCMndznh4U+hVuvOeo9N9hqcg2rQp9tRtPg3AgYqS0m2Ol/69FnAgYOzyMn5BV+fa3B3H9XgXkmSmNLbh693pLH2WC5X1G48bopaoyFy+CiObFzLyZ1bCOk3oMH1mwYFsmhnGuuP51JYVs2wa2/k6Ka1ZCYmkTFuGkEFq2DHB3D9/1r1s+gKsslE2apVlHz7HTWJiWAyNbhu9pIpmWPGFKwEIu5VAwkZNg83rxFIUtN/N/P2uoKe4f8ie//XlP7vOzS79JjlpWSytFFbbXAwjhPG4zRhAvbDhp3TJn1BELovMYPTyVYfyyW7rAYPBxum9mlbzhpLRSV5r78OgMd996LrEXbO40g5uJdqfRkOrm6EDWh49Dsv7w8qKuPRaJwICZl7Tv1nlVbX5/i5d2wPCj74QMlY3Ls3LtfNaHN/kkaDyzXXKGNfspi4bX8BMOqWazh67CFk2YSX15Vtmm3ycB+LTueL2VxKQeH6s99grISjv+LeSzl5pV+9BlNOTv1lV9chBAQoR/VPxj+LxVLTqIur+iq/5+uP51JjOssy1ShlmSpx707MJhOyVcaQVkbpymTcvztJL1SYrDJfv7GDii9T6Omr/D7uyvRUOjj6K5ScOvvn6mTW6mqKv/uepCuuIOffT1Nz4oQS3Gg0aIODsR85AvmePhQ8Y8EULKOqAPdPNNg+eZzC6/9F8dffYK2qarJvQ2oqec+8QuU9n6HdWY4kS1jtweQrY4yS0F7eH4dRo5C0Wkzp6ZR8+x3p98whZcYMqmNjO/cHIQhChxIBTieSZZn/bU0GYPbI0PpyBa1V+OGHmPPy0AYF4TH33AKPOnWbi2PGXYbqjAzCVquJlFRl/0ZI8Fy0Wtdz6n/RjlQsVpmRPTwIL82k9Fflb9A+zz5bn2W4rVyvvx4ZOJijfGlHjxtDTumbmExFODpG0zvmnWb/Zt8USVLj73cT0MplquPLwFiOXXgg9sOHgdlM8TffNmjSM/xJdDpfqqvTSU1d0KiLQcFuBLjaUWm08OdZTlMFRPfG0c0dQ2UlGT/vI+eNvRR8doSKHdlYyoxcUzvjtBIT5pIaIhiAhIqMlBQSpYeRrepuV2m8dOlvJF0+ibzXXsOcnaPkQZo3j56bNtLrcCw916/D/FwfcoYcRNZZcXEazADfTwie+hRaf38shYXkv/02SZdPovB/X2CtrgaU2aDcV14h5aqr0a9YCVYrjhMnEvrrr4Tv3ITx3f4UPmrg1A37KH/SjfAdmwn4cAEuN1yP2sUFY1IyabfcSu7rr2OtbDnbtCAIFwYR4HSiXclFHMvSY6tVccfItm3arTl5kuLvvweUYpoqW9tzHkdFcRGphw4A0HvCpAbXsnN+obo6Ha3Wg8DAO8+pf32NicV7MwCYOzaMvNffAFnG+aqrsB808JzHrQsPp7R/b4odbFGrJPxGpFJecRyt1p1+fT9HrW5cQ+ts/PxuBCRKSna2eAIKgIO1wcyg2XjMmQNA6S+/NPhC1GiciIpUSiakZ3xJeXnDfTAqlcTV/ZVZnBWx2S0+TqVS02v4eEZ5z0B71IK13Ihkq8Z+kDces2O44+kx2NuoScfKqWtCCbxlCD38lJ/v/tRKco2fUL03Hrmi5f0+nUE2mch99T/kPPssluJitAEB+L74Aj03bcRz7n1oAwKQ1GoyMr4h7ZSylBka+g8GDf4Rt2FX4DFnDuHr1uL32mtog4OxlJRQ8N57pN50E9VHj5Lx4EOU/LhYCWwmTCD0118J+vQT7Pr0xtbWn0EDfyAs7FFARW7uMo6nPIHDZePwf+01eqxdg8u114IsU/Ltd6Rccy0VO3Z07Q9MEITzJgKcTvT5VmVPyswhQbg7tL7ulGyxkPPCi2Cx4HTFFTiOHXte4zix7S9k2Yp/ZDQeAUH171ssNaSlKn/jDwt9CI3G4Zz6X7I3gwqDmZ7ejgxMOUD1gQNItrZ4P/nEeY3bYjZz3FH5uUVFFFFctlE5Dt73E+zsAs6pTzu7QNzdlL0yubm/N98w/yRk7AFJDQNuxWHMGGxCQrBWVlK2qmEuHS+vSXh7T0OWLcSdfBqr1dzg+jX9lbxHf8bno69puO/kTOaiasLzowlyiMIim3G6KgT/50bgPjMKuxgPnBxt6vv6Nb0IhyG+jHtqLpIkkV2dTGGNRFHN/1H0v+3IpqazQHcGS2kp6ffNpeQH5Ui/5yP/JHzdWtxuuaVBoJ6Xv4aExFcBCO/xBOE9HkelOr0vRtJqcb3hesJXr8L/rTdRe3kqMy8zZ1G5fTuSrS2Bn35C0GefYtend4MxqFQaeoQ9wsABi1CpbCkq3sqRo/djsdSgcXPD/603Cfrif2j8/TBlZZEx516KvlrYCT8dQRA6ighwOsnJXD1bEgpQSXDvmB5turdk8U/UHDmCytERn2eeOa9xyLLcIPfNmTKzvsNgzMNW509AwC3n1L/JYq0/Gn7fMH8K/vtfQNkzdC51ss50ZOMa9BV6nFwrsRmtHLPvGf4v3FyHnle/vr4zAMjN+735kzWHvlP+GXklOPkiqVS4zlIyIpf89FOj+yIjX0SjcaG8/DgZmV83uBbj50y4lwNGs5UNzeTEqUkoIe+jWCixUGOt4q+cxeSoUpE0Df+TvXmYslF99bFcSquMuPsHEFW7dydB3gYYqcn3pHDRUeSz7PnpCIakJFJnzqJq924ke3sCP/oQr4cearSht6RkLydOzANkAgJuIySk+VN2kkaDy7XXEvTpZ0h2dvWlKeyGDMZh2LAWx+PuPpoB/ReiVttTXLyNI0fmYrEoy1yOY8fSY8VKXG9Wfl/z33mHggULxGkrQbhAiQCnk/yvdvZmah8/gj1av5RiysujYL6yJ8Zr3uNofZov6tgamSeOUpKThVZnS9TIMfXvm83lpKV9BignkVSqs58oasrqozlkl9Xg6WjDuNgNmHNy0Pj54XHPPec1bkNVJTt/XYxKYyV8WiFowbEwgKCgu8+rXwAvrymoVLZUVaVSXn60cQOrVdmwCzDojvq3Xa6bgWRjg+FEHDVHjjS4RWfjSURPJRhNSXkfg+F0ICNJEtf0V2acVhxuvExVfayQwq+PIVebsQl2oqBvEUWGbE7WVnw/U/9AF6L9nDGarSw7lAXA8OuUI/VpOcmo7D5EohpDsp7Cb05gPUv+nfZUffQoabNuxpSejjYggNDFi3GaNKlRu4qKBI4cvR+r1YiX52SiIl886+lAQ2oqmQ8/jFxdjcrRESSJqu07SL1pJqbslpf+3NyG07//QtRqB4pLdnDw4O3k5f3BqVP/IyHzNbKvSaDkPTdKbzWTfuAjMt57ulEuIkEQuj8R4HSCnLLq+v0Wc8e1bfYm7z+vYa2sxLZ/P9xqZwzOx6F1fwAQPXYCNnanA6309IWYzaXY24fXz2i0lSzL9UfD74t2ouyrLwHwfvIJVHZ25zXuPct+pqZcT48penCqQlUCTh9WINc0PqnUVhqNI15eUwDIyV3euEHGHqjIBZ0LhJ/OjKxxc8N5qpJFuOSMBIR1/PxuwMVlEFZrDampHza4Nr12H872pMIGtalM+VUU/5wAMtgP9MZrbj8ixitLaKmHDlBT0bB2liRJ3DJMWWZcvDcdWZbxDAohYphyT6zFC0+bF5EkA4akUgq/Po7V0PFf1qasLDIefAhrZSV2gwcT+svP2EZFNmpnNBYRe/gezGY9Li6D6N37fSSp5c33lopKMh/+B+a8PGzCw+mxcgUh332LxscHY0oKabffjvFUy6fH3FyH0ivqdSXZY3ksx44/SlLyW2RnL6G0dA/VtnlUjbFSeqeFxIG/sHV9P+LjXxaJAwXhAtIpAc4nn3xCWFgYtra2DB48mG1NFE2s89tvvzF58mS8vLxwdnZm5MiRrFvXsHjgokWLkCSp0aumHb7sOsLXO9IwW2WGh7nTvw1Vw8v//JPyDRtArcbvlVeQ1G07dfV3+sICkvbtBmDAFVfXv280FpGeoRSs7PG3fQ9tsSvl9CbqKTt/Q66uxm7AAJynTTuvcZfm5nBw9e+4RZTiGJQDqPD6wx+poJry9a043t0Kvr7XApCXtxKr9W/7Yk4sV/4ZNRU0DWe2XG9W6j/pV6/GUlra4JokSfQM/xcA2Tk/U1V1usxEDy9H+gQ4Y7HKrD6WC4C1xkzRdyeQjRZ0PVxwuzESSaPCMzgUz+BQrBYz8bsaz+JcOyAAW62KhLwKDqYrY6ibxTmZkEuVnI2n9lkkLRhTyyj8+hhWg7lRP+3FUl5OxgMPYCksRBcVRdDnn6Fxd2/UTpZl4uNfxGDIwd4+jP79/oda3fLmeVmWyXn+OYwpKWi8vQn5ZhFaPz/shwwh9KfF2ISGYs7OIe3226lJSGiyD6OxkPj4lzgR9wSyfPrnYGcXSljoP4mJeZe+fT4hOPg+HMwhYAaLrobMrG/ZuetyMjIWNf4zIghCt9PhAc6SJUt47LHHePbZZzl06BBjx45l6tSppKc3fWJl69atTJ48mdWrV3PgwAEmTpzI9OnTOXToUIN2zs7O5OTkNHjZnsfJoo6irzHxY23V8PvHt372xlJRSe4ryoZLj7vvwjaqcSHMtjqycQ2y1UpQTF+8gkPr30879RkWSyVOTr3x9mo5A3BLPvozCYD7vQ3UrFoJgM+zz5xzMsI6W75fiMahkuDxymmgHmGP4DNU2SNU+tuy8+q7jrvbGLRad0ymYopLzjhBY7XCidrNx71nNLrPbsAAdFFRyAYDZb833qTs6joED4+JyLKF5JT3Glyr2yC8MjYbWZYp/iUBc0E1ahcb3G/thaQ+/XPrPV7July3f+pMLnZaruqr9PVTbRJJnx49CRs4BFmW2WsZhU51Es8ey5Fs1RjT9JT8mtghe0tkk4msRx/DkJiExtuboM8/azapY17+H+QXrEGSNPSOmY9W69ZkuzOVfPst5WvWgkZDwPvvo/H0rL+m9fMj5Pvv0EVFYSkoJP2O2VQfPdbg/oyMb9i56zIys75Dls14eIwnoudzgER1dRpaG3f8fGfg7X0FET3/zYgpfzKYBbh/rkOTKWE2l5GQ+Cp79l5NUVHjOmGCIHQfHR7gvPfee8yZM4d7772X6Oho3n//fYKCgvj000+bbP/+++/z1FNPMXToUCIiInj99deJiIhg5cqVDdpJkoSvr2+DV3f04550KgxmIrwdmRDZ+v0zhR8uwJybizYwEM+HHz7vcZiNRo5sXAvAgCtPz95UV2eSmakcPw/v8USb8sic6cCpYnYmF6GRYNrWnwBwufZa7Pr2Pa9xpx87QvKBnYRMykZSm3FzG0lo6EO4zpih7LvYswdTVtZ5PQOUUzY+tRmQc89cpsrcB+U5oHNusDxVR5Ik3G5RZnFKflrSZNDQM/z/AIn8/NXo9af36lzdTwlK9qYVk702lZrjRaCWcL8tGrVjw1N2dfmKcpMTKUhPa/SMumWqlUey609mjbheWdI8kVqJ3qRDl/41njd5g1qi+mghlTtb3qvSVrIsk/vKK1Tu3KlsKP70E7TN/HdpMOQTH/8iAKGhD+PsfPY/J1UHDpD3jrJp3eepp5pMOaDx9CTkm0XY9u+HpayM9LvuourgQWRZJinpLRISX6kN5vsycOD3DOi/kODgu2t/jyAh4VWKihrOkrlOuYqwm1/H6w0NLj+q0VgdqKpKIvbwPSQkvIosi/05gtAddWiAYzQaOXDgAFOmTGnw/pQpU9i5c2er+rBarZSXl+P+tynuiooKQkJCCAwM5Oqrr240w3Mmg8GAXq9v8OoM5TUmPt+iJPa7f3w4KlXrZjKqY2Mp/q42582LL5z3/hWA+F3bqC7X4+jhSc8hI+rfT0mZjywbcXMbibv7uHPu/8Pa2ZsnbDKwHj2MZGeH17zHz2vMVquFzd/8D98hBdh71qDRuNI75l0kSY3W3x/72hMzZatWn9dz6vjV7j0qKNiA2Vy716WF5ak6zldPR2VvjzE1lao9extdd3SMql8CS0p+p/59f1c7hoW6MwQ11i1KkOZ6TTi64Mb1yeydXQgfPBxoehZncIgbEd6O1JisLDuo9OUfGU1wn/5YrVb2GoaBbEGX8wMuU5UM2KWrUzFmNF0Y9FwUL/ya0l9+BZWKgHf/i13v3k22k2WZuJPPYDaX4eTUm9AWTkzVMRcWkvXY42A24zxtKm533N5sW7WrK8FfLcR+2DCslZWkP3A/x/f8g1PpStmK8PCnGDrkN9zdRtbfExw8tzYnkpWjx/5JRWVigz5dr5uB5/0P4LBdjeczMr7aqQBkZC7iyNGHsFiazqwsCELX6dAAp7CwEIvFgo9Pw1pGPj4+5ObmtqqPd999l8rKSmbWFlsE6NWrF4sWLWLFihUsXrwYW1tbRo8eTWJiYpN9vPHGG7i4uNS/goKCmmzX3hZuT6OkykQPLwdmDPBv1T1Wg4HsZ58DqxXna6afd86bOrG1m4sHTJ5Wn7m4vPwEuXnKskrP8H+d81LSkcxSNscXYGs1MXGzstnW47570fqcWw2rOsf+3ECV6QTeA4oAiO71eoO6WC7TlZko/coV7bLc4uTUF3v7MKzWGgoK1jdcnoq5ttn71I4OOF+jzP6U/PRTk216hD2OJNlQUrKTouLt9e9fF+PLi9ghAfZDfHAY1vxMZN2x/hPb/sJibrgHRJKUgqYA3+xKw2pVfh4jb1CW8o5lqyg32cDBb3Ac5o5tbw+wyBT9EIe16vz3k1QfO07+e8oSnM/TT+M0cWKzbXNyllJU9BeSZENM9H9RqbQt9i1brWQ98STmggJswsPxe/XVs/5ZVTs6EPS/z7EdOpCim0rJq1oLqOjV63VCQ+5vNFMpSRK9ol7B1WUoFksFhw/f12hDsdcjj+B05ZWo9GY0T+4nyutZVCobCgs3cuDgrRgMXZ9QURCE0zplk/Hf/2cky3KrvkwXL17MSy+9xJIlS/D2Pr28M2LECG6//Xb69+/P2LFj+fnnn4mMjOTDDz9ssp+nn36asrKy+ldGRsb5faBWKKk01p8omjc5Eo26dT/qwo8/wZicjNrTE9/zzHlTJycpntzkRNQaDX0vOz2blpT8NiDj4311q5YImlM3e/Ns+QHkvNz2Oxb+29eETMxCksDP76ZGFcKdpkxB0moxJCZhiI8/r+dB7bKnjxLI5Ob+Dln7QZ8FNk4QfnmL97rVbjYu37gRc0HjLzo7u0ACA24FIDn5bWRZSbw3ocCEGypSsVA8yqfF/y5C+w/Cwc2dmnI9yQcazxTdMDgQR52GlIJKticVAhAY04fAmD5YLFb2lfeCqiKk47/hfmMkandbLKUGin9JOGuAWFxTTGx+LFszt7IyeSU/xP3A54c/5+f4n9mRuplTTz2hJKKceiXuLcyuVFdnnZHM7zEcHRufrPq70p9/oWrPHmXZa8EHqBxal4BS1sqUPqqmZrAVzOC13Acf28nNtlepdPTt+wm2tkHU1GRw/MT/1f8+AUgqFf5vvoFt/35Yy8owPPkz/Xt+ilbrRnn5Ufbvv56KiqY3NguC0Pk6NMDx9PRErVY3mq3Jz89vNKvzd0uWLGHOnDn8/PPPTGoid8aZVCoVQ4cObXYGR6fT4ezs3ODV0T7bmkyFwUy0nzPTWllUs/rYcYq+Uk4z+b74AmpX13YZy6G1yuxN1Mix2LsofRYX76C4eBuSpKVHj3nn3Hdcjp4NJ/LwqS5myI7ajcX/9+R5lZIA2LX0Jzz6J2DjZMbWNojIiOcatVE7O+M4YQIAZX/bo3Wu6paSikt2YjhROxsTdSVoW/48tr16YTdgAJjNlC79rck2oaEPoVY7Ul5+nPz81ZhyK7EcUPLjfEANPx5oeS+RSq1ucbOxo07DjYMDAfh2V1r9+yOuV4KvI4VuVJi0sPdzVLZqPG6LBrVETVwxFdsaPrvaXM2OrB28u/9dblp5E+OXjOeONXfw8KaHeWb7M7y5900+iv2IV3e/ytaXH0JOOUWpPTw68Biv7X6NnVk7MVkazwzFJzyPxVKBi/NAgoPvbfHzgrI0VTcz5P3Yo+jCw896Dyh/iTp58jmK9TtRSbZ4/+yDdn0RGfc/0GKtKRsbd/r1/RSVyoaior9IT/+ywXWVrS1BH3+M1t8f46lTVL76E4MH/oKdXSg1hmwOHLxZBDmC0E10aIBjY2PD4MGD2bCh4f+MN2zYwKhRo5q9b/Hixdx11138+OOPXHXVVWd9jizLxMbG4neemXLbS76+hm92pgHw5JTIVu29kY1Gcp55pv5vwc6Tm/+bZltUlpaQsEs5lj/wSmUZRZattbM3EBBwC/b2bauLdaa6k1PPpW8EowH7YcNwmjr1vMZcnJ1Javx3uEfoARV9er+HRtP0SRznumWqVauRredfjsDOLhgXl0GAlbz82hIMMTNada9r7TJq6W+/NTkjYmPjQXCwUsMqNe1jSlYkghUqQhzZj4WlBzPPWmG8T23tsLTYg5QXFza6XlfjbNPJfNKLlH0hwX364x8ZjcViZX9pKOQchow92AQ44jpdCRjK1qZhyqsktSyVF3e+yJjFY3hg4wMsOr6Ik8UnAfB38CfGI4YRfiOYEjKF63pex0zjAK7Zo3zW/01VkSDn8lP8T9y/8X7GLhnLk1ueZGvmVmRZpqhoC0VFW5AkLdHRb5813w0o2YStej26mGjcbr31rO3rZGX9QG7eciRJTf8BXxL5zA+oXV2pOXqUzEceRTY1vyzn5BRNZMQLACSn/JfS0v0Nrms8PQn8+CMkGxsqtmyhZslfDB3yK87O/TGby4iNvYvq6sxWj1UQhI7R4UtU8+bN48svv2ThwoXExcXx+OOPk56ezgMPPAAoy0ezZ8+ub7948WJmz57Nu+++y4gRI8jNzSU3N5eysrL6Ni+//DLr1q0jJSWF2NhY5syZQ2xsbH2fXe3jv5KoMVkZFOzKZb1ad3Kq8H9fYEhIQO3mhu/zz7fbWI5uWofFbMa3ZyS+PZXlgPz81ZSXH0OtdiAs9NxPaCXll7P6WA4DChLpGbcX1GqlWvh5HAuXZZm/vn+XgNHKjEJY6D9qA46mOY4fj8rZGXNuLlX79jfbri18fWYAkOtcAzaO0LPl5ak6zldMQWVvjyk9nap9+5psExR4F2q1I5WVCRSXbwWNirCZvQhwtaOs2sSaYzktPsPNL4CAXr2RZSsntvzZ6Hq4lyNjIzyRZfhudxqgLL2NvEGZxTlc4keVWQv7lJlCh+G+2Ea7g1Xm4NfrmbFsBr8l/obRasTXwZfrel7HW2Pf4q+Zf7HuxnUsuXoJX0z5gncnvMtLg57m1l8LUMngfM01vPv8Nj667CNuiLgBD1sPKk2VrEtbx8ObHubGlddz8ISy5BoYeAcODmdPmVC5ew9lv68AScLvpZcalXdoTllZLAmJ/1F+HuFP4e42El2PMIL+9zmSnR2VO3aQ+5/XWlyW8/e/GR+fa5BlC8eOP4rRWNzgum10dH3ZlPz33sN0NI0B/Rfi4BCBwZjHodg7MRobB6CCIHSeDg9wZs2axfvvv88rr7zCgAED2Lp1K6tXryYkRPmbZk5OToOcOJ9//jlms5mHH34YPz+/+tejjz5a36a0tJS5c+cSHR3NlClTyMrKYuvWrQw7Sx2azpBRXMWPtblInrwiqlVf9jXx8RR+ppRJ8Hnu2SaTop0Lk9FQn7m4bvbGajWSnPIuACHB92Fj49ns/Wfz0Z9JqCwWnoxXnuF2yy1NZqtti5M7t6D224haZ8XeLobQ0IdabK/S6XC+QtlXpP+jfZapvL2nIskS5U4aKnuNBW3rTrGpHBxwvkpJaljWzDKVVutMgJ8yE1HUYyWO4wPQedgxa2htNuI9Z98fVrfZ+NhfG5r8kr5rVCgAS/ZlUGVUEtmF9B+Eb3gEZovM/uIA5XRYZSGZ5Zm85f4lVaoaAko9uaJ0FBODJvLd1O9Yf8N6Xhn9CtN6TMPTrvGfk/z58zGeOoXG2xvfZ5/B3dad8UHjeWnUS/w5809+mPYDd8Tcgb3GHk9jHCpTLtVWFYdM/pjOkijPajSS+7JSld315lnY9et31p8LKEkrjx57GFk24eV1JcFBc+qv2fXrR8B774IkUbpkCSXf/9BsP8qm41extw/DYMjlRFzD/TgArrNmKkksLRaynngCqUJmwIBF2NoGUF2dRmzsPZjN7XdKTRCEtumUTcYPPfQQaWlpGAwGDhw4wLhxp48jL1q0iM2bN9f/evPmzciy3Oi1aNGi+jbz58/n1KlTGAwG8vPzWbduHSNHjqQ7WLApEZNFZnRPD0aFnz14sBoMZD/5f2A24zjp8vPO+numY3+up6qsFGcvb6JGKqexMjO/o7o6HRsbr/rlknMRn1vOisPZXJ26E4/CLNRubnj98x/nNV5DVRWH976KU0AVyDb077/grCdsQDmmDaBfuw6rwXCW1mdno3XDvVwJTPMC2xZsulx/vTKWdeuw/K2sQh23tMlIFi01LilYBihLGTOHBKFWSexNKyYxr+UvxcgRo9Ha2lGal0NW3PFG1ydEeRPsbo++xsy6XYcgbiXS1ncY4aPs94kt9qfKYCXtqwmsXTQeOf13Vngop9/+WXIb84f8lwHeA1oMzqsOHKDkW6UAqd9r/0Ht4tLgukpS0c+rH08NfYrVM5Zyg4fy+7i6TM1/9r3HzJUz2Z/b/Ixb8cKFGFNTUXt44P1469INyLKF48cfx2DIxd4+jJjoNxt9BqeJE+ur2ue98QYV23c01RWglPDo0+cjVCodRUWbOZX+RYPrkiTh+8rL2ISEYM7JIeffT6PTejNwwDdote6UVxzn8JH7sVjO/8+kIAhtJ2pRtaPkggqWHlS+sJ6c0rrMwwXvvYchMRG1h4cyDX+eWX/rWMwm9q1QZhGGTr8BtUaD0VhISuoCQEnqp1a3vujn37299iRONeXcnaDsr/J6/LFGX3JttfP39/DokwZAZMRz2NuHteo++6FD0Pj6Yi0vp2JLO2SXzT6ET7ayJJpnOfsJozPZDRiATXg4ck0N+iby85iLa6jZWoVLlhLkn8r8HABfF9v65czFe1uexbGxtaPXKCVgPfrnukbX1SqJf/SHd7Wfcs1fU2DJ7fDXa/QoXoW3rgKTrOZAcSChxRncV1zEfwuKeKLiNzxc3kdrTKV0ZXKLz5ctFnJfew0AlxuuP2sqg5KcH1HLVdjahTI25jncdG4klSZx97q7eXb7sxRVFzVob0xPp/DT2hnNf/8bdSsPBaSkfkBxyQ5UKjv69vkYjcapyXbu99yDy4wZYLWS9fjjGFJSmu3TybEXkZFKQsKUlPcaJGoEUDs6EvD+/Pr9OMVff429fRgDBnyNWu1Iaeke4k7+W1QkF4QuIAKcdmS2yAwJdWdStA8Dg8+edr5i+w6Kv/kWAP/XX2uQdv58xW3bTHlRAfYurvSeqGxMTU6Zj8VSgZNTH/z8bjjnvvekFLHpZD73nFiDzlCFbUwMrjece38AeanxVGp/RKUGe+0QAoNav6FUUqnql4b0K/84r3EAkLAWryIjKllFVXUqFRUnWj8WScK1dhan9Lelja7rN54Cs4wvs5AkDSUlOykriwXg1uHBAK3bbDxRWZaL37WNytIz8rUUp8CyB7lp9w3coN6GGiuVbjHQ/xakKa/getkAAHaXBPCBgzspfr2R/QciyRbsDBvx1f0D+5P/xLC98SmtOmXLl2M4EYfK0RHvJ55ocZzV1RmkZ3wNQGTEM9wSfTsrr1vJTZE3ISGxInkF05dPZ2nC0vogIO/tt5ENBuxHjsD56rMfMgDQ64+QlqZkR4/u9RqOjs3/BaNu5sVu0CCs5eVkPPhgozpiZ/L3m4m39zRk2cyx449jNjc8haXsx3kagPz571N97DjOTn3o1+8zJElDXt4K0jO+bKprQRA6kAhw2lGUrxNL5o5gwS0DztrWXFJCztPK/xTdbr0Fx/Hj220cVquFvb//CsCQq69Da6OjvPwE2dnKMkRkxPPnXJJBlmXeWHOS3kWpTDml5GLxee658yoEKlut7N36CHbuBqwmOwYP/6TNM1ku05VlqorNm7Gcb6bqhLVoLDKeNtEA5Oa1bW+Py7XXgEZDzeEjGM5IXWAuqqYqNh8Ar0nD6nPupJ1SvpjHRXi1erOxX0QUvj0jsZjNHN6wBqwW2PgyfDgEDv+IJFs46TSSawyv8qTHR1iu/Zj/2ph4hk0UuBhQWVWEp7rRwyUMae5mmLsZYmYgI2Gn3odu443Iv94PxoZf5paKSvLnvw+A50MPnXW/WFLy27WZskfh6aGUunDRufDCyBf4ftr3RLtHU24s56VdL/HElico2LeDio2bQKXCt5Ub1q1WMydPPgdY8fG5pv6of0tUNjYEfrgArb8/plPpZD7+OLK56QKkyn6c/6DT+VJdnUZi7QbmM7nOmoXTlClgNpP9f/+Htboad7eRRNSmN0hKepuiouaLDAuC0P5EgNPOJEnC3qbl0x6yLJP7wgtKZtYePfD+v/9r1zEk7tlJSU4Wtg6O9J88FVmWa0+VyHh7X4Wr65Bz7nvtsVyOnSrkkcNKAOV6041N1gRqi4ObP8Q+SDluHhXxGjY2Hm3uQxcVhS4iAtlkQr+u8bJNq+lzlGPUSPiE3AZAXt4fjTaYtkTj6YnjBCVgPTMnTvnWTLCCLtINm0AnQkLuByQKCzdSURGPWiVxcys3G0uSxOBpyhd53Mbfsf4wE7a/B7IFek6Gezehuv0XjsjhrDuey32rn+GbE9+ABIFTlSWlpGJfyo9tgrIs8B8IM79Bvn8PVeorkWUV0rGf4IvLIP9k/XOL/vc/LIWFaEOCcb/9thbHWFYWS37+akAiomfjoqv9vPqx+KrFzBs8D41Kw4a09ex6QTnV5zJjBrqePc/+wwYyM7+hvOI4Go0LkRHPtuoeAI2HB4GffoJkb0/Vrt3kvze/2bZarQu9Y94DJLJzfiY/f22D65Ik4fvyS2i8vDCmppL/jlKSIzDgdvz8bgKsHDv+KFVVp1o9PkEQzo8IcLpA2dKllG/YCFotAf99p11qTdWRZZk9y34GYODU6djY2ZNfsJbS0j2oVDoiev77nPs2Way8vS6eGxM3E6zPUzaAnmWJ4mxK8pMorFZmMLTGkQT3OPvfvpsiSRLOtbM4Te19abXE9co/AwbhEXAtarUjBkMOZWUH29RN3ZJd2e+/IxuNWMoMVO5XNvk6T1SCGAeHcLy9rgTg1CmlTtLMoa3fbBwxfDT+3rbMcN+CKnkjaGzhhq/g9l8hcAiRPk6MjnDBKsO2YzpsVDa8Pe5tHp7xPAG9emORVewp8IdD39X3qfKLQrrxEwqMr2GR3aHgJHwxEWIXY8zMpLh2s7/PU08h2dg0MzJFauoHAPj5XoeTU3STbdQqNXf3uZvvp37PpDwvIlINmNSw9nIXLNazF7Gsrs4iOUUJTCJ6/rvNpwJto6Lwf13ZT1S8cCFlf6xqtq2b23BCQpRUFHEnn6GmpuEsm8bNDb833gCg5MfFVGzZUjv78zLOzgMxm8s4cvSBRktcgiB0DBHgdDJDUhK5ryv/E/R+9BFsY2Latf/UQ/spOJWKVmfLwCunY7HUkJT0JgAhwXOxtW1dTaym/LQvA0NaGrfEbwRqN4CeR7Zlq9XC3h33oLEzYapwZMTEpivMt5bzNCXBYNWePZjy88+tk7oAJ/JK1GpbvLyUI9l5eW3b2+M4diwaLy8sJSWUb96szN5YZGzCnNGFnd6MHRKqfGHm5a+kujoTH2dbLq/dbPzDnvQm+66jPrWVm7x34KGrptJqj3z3Wuh7Y/31lNIUUiVls66pbAjvjP6CqWFTkSSJMbPuAOBoqS9lO38Ay+nlGdte7kjhY8kzfIDRfiiYqmD5Axg/vg7ZZMB+xAgcL2tcWf1MZWWxFBVvRZLUhIae/XRdjHs0D+92BWD9IIn5md/xjz//gd7Y/HKjLMvEJ7yI1VqNq8vQ2mKZbed85ZV43HcfADnPPUfNyZPNtu0R9ghOTn0xm8uaPDruOGY0brOVn232s89hLi5GpdLRr+/H2Nh4UVmZUHuf2HQsCB1NBDidyFJRQeY/H0GuqsJ+5Ajc7767XfuXZZndy5R9Nv2nTMPOyZn09C+pqclEp/MlJGTuOfddaTDzwYYE/nH4N2ysZhxGj271BtDmHNj2PBqXLKxmid695mOja/rUS2vZBAZi178/yDLla89hmcpsgOS/lH+PUDbx+voos0J5+auxWpveo9EUSaNRTuoApT//SuVepVyJ82XBDdo5O/XB3W0MsmwhI3MRcDob8ZJ9GRRXGpt+wMlV8P2NaCxV5NS48F1yXzJKTv/nnFqWypz1cyhXH8bBKQdkNTtPnC43ERjTh5A+/bGiYleaDhJOL7lIkoTLVT2wSm7kFz+HeeATyEg46hJwu9xA9o3XsW3bNtavX8/WrVuJjY0lOTmZ/Px8DLXH9FPTFtT+/Ga0KlN2+fr1mOJOorK3J/rx57FV27I9azu3rbqN1LLUJu/JL1hbW7RTS69e/znnfWUAXo89isOYMcg1NWQ+/A/MJSVNtlOpbOjTez4qlR0lJbtIz/iqURvvefOw6RmOpbCQnOdfQJZldDof+vX9BEnSUlCwjoyMhec8VkEQWkcEOJ1ElmVynnkWY2oqGl9fAt5997w25jYl/ehhchJOotZqGXzVDKqq0kg79QmgVAs/n2Phn21Jpu/JXQwsSETS6fB98YXzOtKel72TMqOylKYzTCcosuUZgdaqP021+hyWqdK2g6kSHH3Brz8Abm6j0GrdMJmKKCnZ1abuXK6/DoDKHTuw6IvQBjqi6+naqF1dPqLs7J8xmfSM6elJ3wAXqk0Wvt7RxJf7qV3w6z3Kfps+N3Iy4kkqzTYcWLVc+RhlacxZN4fC6kIi3SJ56xolE/OPe9MpOSNgGn2zkkH8RJkPxZv/dsrHQ0tBlIXdmmQ+OeLAT0zHggpfz2Kc97/C5j83sHPnTv7880+WL1/Od999xyeffMKbb77Jt9+9QlHRFkBFYODZg2rZZKKgduOy+z33cNWgW/hm6jf4OviSpk/jtlW3sS2z4QZds7mchIRXAAgJuR8Hh9bt12mOpFYT8N930AYFYcrKIvuJJ5rddGxvH1ZfGy05+V3Ky+MaXFfZ2hLwzjug1VKxaROlvyr71VxcBhEZoWQpT0p+u83LnoIgtI0IcDpJ8deLKF+/HrRaAj94v92yFdexWi1s+V7522S/SVfi4OrGyfjnsVoNuLuNxqd2JuJcJOVX8MP6I9x/dAUAng8/jE1w8Fnuap7JVM6R2IeR1DLVub6MuvLtc+7r75yuvBIkierYWIyZLRevbCShdtYncgrUBm8qlRZvb2XpK6+Np6l0YWHYDRgIshVTxm6cLwtuMih0dx+Lg0MEFksl2TlLkCSJhycqNaIW7UyjvOaMrL/5cbB4FphrIHIqXPc5A6Yp+31SDu7jeMI+5qybQ0F1AT1de/LFlC+4qk8oMX7OVBktfHNGEU6/iCh69O2DjMTOg9lQnEJRURErVqzgrbfe4ve0zRzTZFBsKSde7sGK6klYUNObROa47GLksCEMGDCAHj164OXlha2tLbIsY2erLGHm5YayYMFPLFmyhKSkJKzN1AorXbYM46lTqN3ccL/rLgBiPGJYfNViBnkPotxUzsObHmbRsUX1SzspqQswGvOxtw8jNKTlbNetpXZ1JfCjj5Ds7ancuYv8+c1vOvb3n4Wn5yRk2cTxE49jsdQ0uG4bHY33Y0r29fw33sSYoWwaDwi4FW/vq5BlM0eP/bNRCQhBENqPCHA6QdW+feS/q5RH8Hn638oySjuL27aZglOp6OwdGHH9zeTmLqOkZCcqlY6oqFfPebZFlmWeX36Me2OX4WKsRBcRgcfdd53XWPfvfBCVrR5juZbBwz9Boz17tuLW0np7Y19bskO/pg2zOLIMibUBTsQVDS75eCvBYX7BujZnpdX1ngCAOWsXuqimcyNJklRfUiAjYxFWq4kpMb709HakvMbM97tr9+KUZcH3N0BNGQQOgxsXglqDm18APQYNBeDzRc+TX51PuEs4X075EndbdyRJ4sEJpwOmSsPpmYnRtyszLPF6b374/BM++ugjDh48iMViwcXFhT6+kVxm7MOtpX0Z5TsG9a2LQW1DQNk+rihfwozpVzF79mwefvhh/v3vf3PffZNx98hCllUUFo3AbDYTFxfH999/z4IFC9i2bRvl5ac3T1traij8WJll9HzgftSODvXXPO08+XLKl9wYeSMyMu8eeJfX9rxGeWUKmZnKxujIiBdQq3Vt+j1piW1U5OlNx18tpGxV05uOJUkiutfrtftqEuuL157J/a67sB8yBGtVFdn/+jeyxVJ/3+kSEE+26YSeIAitJwKcDmbKyyfz8XlgseA8fTput9zS/s8w1LD9JyVh4LAZN6GxtZCY9DoAYaGPnFe18OWxWWi2bWJi5iFQq/F77T9I5xGQpCZ9TZVlF7IVHC2z8Qtv/2Dv9DLVmtbfVJgIJWmgtoEeExpccnUdgk7ni8VSQVHx5lZ3aTVasBp7gtoGa1kuNYcPN9vW1/cabGw8MRhyyc9fg0ol8VBtUPLV9hRq9EVKcKPPAs9IuHUJ2JxecoyYrCxD+aepiLQN48srvsTD7vRx+2l9/Qj1sKe0ysTivac3L9u6e2Ln6wtAVkIWLmZbRnn3557+NzBn0I2MV3sTWu2AvZ0PWv9JyOGTYdYPys8pbgUsf0gJDmsVFCpJ/fz9ZvDPf7zC/fffz7Bhw9DpdJSWlrJp0ybmz5/PH3/8QVlZGaW/LsWcl4fGzw/Xm29u9HPRqrW8MOIF/j3s30hILIlfwm+7ZyPLJtzdx+LhMa7RPedL2XR8LwA5zza/6djGxoOY6LcA5ah6UdHWBtcltRq/N99E5eBA9cGDFC1U9t00LAGxpf4EnSAI7UsEOB3IWlVF5sMPYyksRBcRgd/L7VeK4UwHV6+gorgIJ08vBk29hsSk1zGZSnB0iDqvelNlVSY+/nkX/4xVMvJ63n9/q4seNtlfaSzJaUrgpU+MZNQ17Zv/p47T5Mmg0WCIi2sxDX8DdZtsQ8eAzrHBJUlS4eOtbKhuy2mqqth8ZJMWbZgyo1S2rOkCnAAqlY7AgNsBSM/4ElmWuaa/P4FudhRX1FDy9SwoiAMnP7h9KdifXuKsMdfwZs6nFDsZ0VpUPGiZ3qg4plolcf94JWD6YlsKNSYzRw4f5ucF3xJhP4EpAXcxy3suN5pGEZPuiWpPKfo1aRiSdahqfx5Vh4rJfnkXBdv9KYv+iVR1bxLjlpO28TmyKrJIzttCTsFfgIrQ0IeQJAk/Pz+mTZvGE088wYwZMwgMDMRqtbJ//34+nD+frI8+BMBz7n2odE3PxEiSxG3RtzF/wnzCbdUESjnIMngG3t/q34u28nrsMRxGj1Y2Hf/jn81uOvbwGE9goHJq6kTcU42WnGwCA+qrjhcs+JCaOGW/jpNjL6IiXwIgOeVdSkr2dtAnEYRLlwhwOohssZD1xJPUHDtWu7b/ISr7c9/k25zK0hL2LP8FgLG33Im+Yh+5ucsAiV69Xm9VscrmvLU2jjt3/ICTqRpd7954PvjAOfdlNBZxYP89SCor+lPOjL3qE9Sa9luaOpPGzQ2H0aOANuTEOeN4eFPq9jAVFm7CbG66iOaZZFmmcpeSJ8W19jSVfvUarFVVzd4TEHAbKpWO8vLjlJbuRaNW8cD4cP6pXoZfyT5kG0e47VdwPb3/ySpbeWb7MxwuPEJCL2UD8Yl166nSlzXq//pBAfg46zDqjSz973r+n72zjo/i3P7/e2bWJe4eSCAJ7u5UoFCg3t66e29763br3tJboULdKDVKBWiB4u4SEkiIu2c36yO/PzYNpECh/bb39t5fPnnNaze7zzzzjOw8nznnc84RPq3m1LZ+ZGuphBtikQQdsupHn2TFMiAGXYyfQNV25Mb9aHqQkdH8Kr4DzTi3GtC7nqbeP4dXchuY/vk0Zi65kbsqzbzUGMNr+75iVfmqjjBvg8FA//79ufLKK7n00ktJTU0l5eBBdC2teMxmtoaGdkRgHQsTUyZya2oSAJvdEleteviYEVb/VwiSROLzzwVFxxUVVP3j9mOKjjO6343FkoHfX09+/r1HhICHnjEL2+RJEAhQdeddHQVh4+PPJi5uFqCSm/t3/P6GP2VfutCF/1/RRXD+BGiaRu0TT9K2YgWCwUDSnFcxpP5+N9GvYcMX8wh4PcR2yyRz2BDy9wejO5KSLiQ0tP/v7nd7WTOO+Z8yuG4/msFA4rPP/G7XlKrKbNt8JZrYirfFQLfUh4hOObFCmr8XoacFLS6O778/fs4RTwuUrg++bw8P/yXs9t5YLOmoqo/6+mPXafoZ/lIHgWoXgl4k/PyT0Ccno7pcOJcee12DIYL4uGAdq5/Dj8+OKuVm/QIANuXcD3G9O63z4vYXWVq6FJ2o446/PUNstwwCXk9HssfDofMqPGO2sAAb41rthGtWVFHD3D+a0NMjWFb5Ml+WzqYyZhvhZ2XgWvo8TTtfZ8HQDZyXdRenZ93CDelP8EbMF2y07cYjeknxx/H3mgv5oPAxLqg/Fbtso8jt4L3c97hp+U1M+ngS1/x4DWsq1qC2a03S0tK45MILGVIeLEybn9WTdZs38/LLL7N79+5jnq+GhuXI7jwEwcBOOZXKtkouXnwxe+r3HPd8/B50iI7NZlzr1x8z07Ekmejda3YwBLxhKZVV8zp9LwgC8Y88ghQZia+ggPp/vdTxeVbPR7BaM/H5a8nd16XH6UIX/kh0EZw/AU3vv0/zxx8DkPDM01gGDvxTttNYUc7u5UHXyriLLqew6Bk8njKMxji6d/v9GYb9ssqL7y7nir1Bd0zc7bdj7Nbtd/e3P/9J3P7dKAEBsfEM+k44/Xf3daKwTZyEYDTiLynBl5f3640P/hQMuY7qCRFHJ16CIHSIjWvrjh9N1ba+CgBL/xgkq4HQWTOBzqUbjobk5MuB4GTubtiOceHVSKh8Lo/lnsJsFPXQ5P/Z/s94d29Q8/LIyEcYGj+U0e2h37t+/B5HQzDZoSarOFdXUPn0JrrXKugQ2IvM+nQDSQ+OJPK8LOwjezEwJ9j3hm+/o+TLT/g0voQbb9DxjmEzDtlJNBGk+RJIj+tOn+snk3b/WEKnpiHpnSiqQEZLT84vPZuLKv/GmeVnckbJGZxWehpRG6KY99E8rp9zPXOXzaWuuQ7nokVQU4MUHs7Au+8mPDyctrY2vvrqK959911qamo6HRdVlTuEvCkpV/D6lPn0iuxFi6+FK368gvWV6497Tn4POomO33mHlq+/Pmo7uz2HjO5Bl2tBwWO0tR3o9L0uIoL4Rx8N9vPuu7g2bgJAkiz07vUSomiiqWkNpaVv/Cn70YUu/P+ILoLzB8Pxw4/UPR28EcfccTshpx7d5fF/haZprPrwLTRVpfvgYZhi6qis/AiA7Kyn0Ol+f9K85xftZdaSNzEpAfRDhxF+nJpDv4ba2kVU1bwHQNPO3ky68MQKKP5fIdms2MaPBzhmJEwHDg8P/xX87KZqalqL3994zHaKw49nb/B764h4oN1NJQi4N2/uCBk+GqzWbh1FKcs2XAfOatSIDF7QX0lxg4vPtgbX3Vi9kSc2BfVMN/S/gendg2NL7TuA5Jw+KLLMhi8+xZPfRM3sbbQuKkYMQIPg4Ov4Fq7FzcOVzTQeVrW89xlXE2V04fUrPLV5Lp+Ok2gzQXpoOk+PeZrvJn7NHVWXcvKeAXQLJKGIGvnmGhbGF7LAuJlcXQUNohO33wuHeXP0mp4Ybwxx9XFUrq3k1X+9yqdLl9AYEUHEZZeR1a8f119/PRMnTkSn01FWVsYbb7zBjz/+iN8fdLtVVX+G230QvT6CtNRriDBF8PYpbzMifgQe2cMNy2/g+6LjnOffiZApU4i8Jqj3qXngQTw7dx61XXLyZURGjEVVfezNveWI0HH7xAmEnXMOaBpVd93VUcFcIo3kuKBO52DRC+zZ+AMHttRQtq+R+jInziYvAf/xy1Z0oQtd6AxB+/8wZ7jD4SA0NJTW1lZCQkL+sH49u3ZRevElaD4fYeefR9yD/7dkeL+GvDUrWPTK84iSjvOffIgDZVcRCDSRnHz5byo4+EusPlDPhlvu4fTidagWKz2+/xZ9fPzv6svh2M2WLeeAEKB+TxQTZ8wjJu33W4J+8/Z/+JHKW25BlxBPxrJlCOJR+LyqwnOZ4G6AS76D9DG/2ufmLafjdObSs8cjJCUdnfg5lpXiWFaGIS2EmGsPRYmVXX45rvUbiLr+eqJvvumY22hq3sCOHRciKhqjt7ahv2w5bxfaePS7fYRb9Hx6fU+uWnYRzb5mpnebzuOjH+90nVUdyOOzB+9hQOQkutv7A+DGx1bdQaLGpDNx0iTOfH0DuypauXB4Co/N7ANAIODj+edGo98ZiyJorO9XwxUz7mNq1gwkMZiUsvGjfbj3NnAgsYmNjlwCgWCOHkFQ6EkJGbIRQZuCQbFiQk/48GQCA22U1JSyIW8DNVU1WLyHtGjhMaFMmXwamZmZCIJAS0sLP/74I/v27QMgIiKCadNOorLqUvz+Bnr0+CfJSRd3rB9QAty39j4WlwQj5u4achcX5lz4q+fw90BTVSpuupm25cuRoqJI//yzo/4ufP4GNm8+Db+/gcTEC8nq+XCn7/0tTorPPAu1sgxXxjBye19JW4sf0Igf+g6haRsJuMMoWfogiq/zQ4ot3EhUsp3oFDvRyTZiUkOwhv1xIfJd6MJ/A37L/N1lwfkDIUVGoU9KwjZuHHH3/XmWCldLMz+9FwwtHX7mOVQ3v0gg0ITNlk1G99t/d78NbT6+fGoupxevAyDl+Wd/N7nxeMrYvu1SEAI4yqz0zL7/30puAGzjxiJarchV1cd86qZ2T5DcGGyQPOy4fcbGBt1rx0r6p8kqbZuC4mLbiM51v0JnBfU1rV9/jXaMpHcA4R4ztjYFVRKoHDMN4vpwyYhUesbaafa4uXLJzTT7msmOyObBEUeS6OjwVKZ2v6aD3OyRSvncuIFu0/px8ikno9NJ3DM1WPxy3uZyDta3Ueuq5bKlV/BxgpeKaA+SJnBueV+mZc/qIDcA4uhofjDsYk3jTgKBANHRkXTP2MXQYV8y5YxRDNZ9RX/pNhKSFMyaAe+GWoRPKxmU1JfbLr6NJ25/nPG7NpNWVAyaQnNdK5988glz3phDbW0tYWFhnHPOOZx//vnY7Xaampr4acUD+P0NmEzJJCZ0DiXXS3qeGvsUF2RdAMDTW57mpe0v/eG1ngRRJPGZpzH27InS0ED5DTccVTBuNESRkx2sJF5Z+RH19UuDmrwSBys/zuf9h7azKe58VEHEWrgJe95KEMBo0eMquQLZnYDe0kL6hA+ITDRjCTUgSsHz29bso2R3A1u+K2bRa3t47+51zHtkE+u/KqTyQDOK0qXf6UIXDkeXBecPtOAAKK2tCDodotV6/Ma/E9++8CQHNq0jOq0bY6/ry8GiJxFFI0OGLMRmzfxdfaqqxt3PfMEFHzyCUZUJu/Za4tszsf5WBALNbNo4C1+gHHeDEX3TpZxyzR3/FtfUL1F11120LvyG8AsuIO7BB45ssHY2LHsomBX4gk+P25/XW8269WMAjVEj12AyJaCqGlUHminYVoec30R2QMEHbNRLaIKAPcJE9wHRpGWHUHnaZFSnk5R338E6YsSRG1ACMHcC1eoB9mXZMRpiGTlyJaJoYGNRI5d8cweG8C3Y9CF8cfpnJNoSO63u2lFHy4ICNL+KR/Oy0pBHjb6FM886i5xfFHa98v0tLMurY3hOM9XGuTR5m7AJRq7+PECLKRFVFJl68x1kjxoHwIEDB/j6669xu91ImsjI0D6kzaygpORFbLYchg75BmHDK/Dj/SAZ8E76nuZVoLT6QCcSPjMD1ZFLxfU3IFgsfPv4dHbmF5DmSEOv6RFEgfHjxjN69GgkScLr9bJ06bfoDQ+i1/spK53MuHF30e0oejBN05i7Zy4v7wiGnZ+ZeSYPDH+gEzn7I+CvqKTk7LNRmpuxn3IKibNfOKplsKDwScrK3kLQQmjY+jj1xYfqgFlCDPRoXEHEuk/AZCZ5/ufYegZD+Nva9rNl6yxU1Ue39FtJT78RTdPwuWWaqlzUlzlpKHdSX+6kqcp1eAoiDCaJ1D5R9BgaS3JOBJLU9fzahf89dFlw/oOQQkP/VHJzYONaDmxahyhJjLt8OkXFwQzJmRn3/m5yA/Dhj3uY8tlsjKoMw0cS9ysulF+DovjYsf1KfIFy/E4d3qJTOOnKW/8j5AYgZNo0ABxLlhw9zPfgT8HX7idWC8tkiicsLJjXpjDvC1bN2897d61l4Ys72bemihhP0GVT7FVoqffSWuehIr+ZVfMO8ME/t9KUFFy3af7nR9/AhlegZg+xTjMGfSQ+fy11dUH3S6W8EkP4FjRNIMR5KfGWQxYiTdFo/rqQ5vn70fwqztAAX5m2UCk2kCQEyM7OPmJTd52ahd62n73qczR5m+gZ3pPnlyUyvMBPH60WgBXvvYnb0coPP/zAJ598gtvtJiYqmpnKUDIbQqgsex+A1JSrgud4xI2QNQ0UP6bNVxBzdTqmnuEgqzR/cYDmLw6AqCfibxdwx5SHePjSh6kZUEO1uRpN1VixYgWvv/k6NTU1mEwmevWuQa/34/WGU1oaywcffMCiRYs6tDk/QxAEru57Nf8c8U9EQeTLgi+5fdXt+H5j5unjwZCUSNLLL4Fej/OHHzoiog6Hqmr4qs7H15qGJjgwp7+IZFDpMTSWGbcO4NKnRjFy7n1Yhg0Dr4f6++9Ba3f12Ww96dkjWGOrqPhFGpvWIggCJque+IxQksfGE3dWOpHXZRF2Vx/Ei9NxTIihpJuJvFCBNQUNLHhjN+/dtY5V8/ZTU9TaVbm8C//fosuC8wdbcP5MuB2tvH/7DbhbWxh25ulIKZ/hdhcTFTWJvn3e+N0kYm9ZE7suupyBtfvxRsfR97uvkUJDf3M/mqayZ/dN1DcuQfGJ1K4fxtl3vY7JZjv+yn8StECAgrHjUJqbSZ47F9uY0Ye+9Lvg6TRQ/HDjNog6sYKNJcUfcrD4IbzNyZQsfRAAo1VHdlYEqQebQQDxvCwEqx5Ng5riVg5uq6Ou1IndUcqQ7c+gijosby0kfeRh1ojGg/DayGCdqZmvURzaRFHx7GCIetrjXLLkEvyqH7XxVFx143nu7H6cNSgJ1afQNC8fb34TCNCQLrOwchWaAJbqYqSWRqbccBs5YzuTuC01W7jyh2tQCWCVB/Btz8tpuPI6BIOe9CkVzKseQIPPjHXgSGo9QUIxfPhwJk2ahOuHcspLPqQu5wNMpiRGDF+OKOqCHXta4M1xwczQPaeinfMxzpUVOJaWAqA4yom7fQLGbkH3p6qpfJD7AV+t/oreDb0xqAYEQeDkk0fh8/8DRWmjZ4/n2blTx9atW4GgNmfWrFkkJycfcX6WlS7jztV3ElADDIkbwksTXsJm+GOvwZYvv6L6vqDWLe6hhwg/71wAyvY1su6LQpqqXOitdaSf/Dii3k1C3MVk5/yzUx+B6mqKZs5CbW0l8qqriPnHbR3f5eXfS1XVfDQplNVRb7KizUq5149XPbHbtdWrEt6mEOFUyZRFJmVEccrQRKw2wx90BLrQhf8Muiw4/6NY+f5c3K0tRCYnYclYi9tdjNEYT3bWk7+b3NQ6vCz7+wMMrN1PQGcga+5rv5vc5OffT33jElQFKtf0YPoNz/5HyQ2AoNdjPzVYW8rxy2iq0vVBchOaApHdT6i/kj0NrH4nGk2VMIWX02NUgGk39eOyZ0aTExUUfJr7RJHQL5r4jDASMsMYeHIqZ98zhIseH0GfSyfiDk1GVGV2P/EuP761F7fDHxQ7f3NzkNx0nwj9zicx8YL2xH97mb3uevyqn/HJ47lpYLB+1FOL82ipd1H/5u4gudGJ1A8W+boqSG6mTZvGuFOD+YBWvPcmbc2Hsuzuqd/DjctvRCWA5sqmpuAsPv5kLQBhZ5+NMS2bk+L244tJ6iA3M2fO5NRTT0Wv12MdH09zejBFQZzu3EPkBsAcBme/D5IR9i9C2PgyIZNSUFt+RPU5kUKSaZxXir8ymDBRFEQu7X0pz5//PMW9i6m0VKJpGvn7X0ZR2rBaepCYeDrTpk3jwgsv7NDmvPPOOyxbtgz5F5a5yamTeX3y61j1VrbUbOGyHy6j3l1/Quf3RBF25hlE3XADADWPPELd9z/x/au7+PalXTRVuTBadAybOoq+/YIW1qqaD6j5hW5LHx9P/MNBEXLj3Lk4V66kxhfgueIabm49j2K6ISitJNbeT7GrrYPcROl19LGZGRduZ1SYjaGhVvrbLWRbTUTogy45l0mkIkrP7nQjX2bquV5oJXt9LpMX7eKxHaXkOt1dlp0u/M+ji+D8l2D/hrXkrV2JIIj0O8dMc8s6RNFMv75vYDBEHr+Do6DNJ/PBzY9yyr6gmyb64YcxZ2X95n40TSUv716qquejqVCxOpmTLn6GsLjfJ1D+oxHa7qZyLl2K6j0sdLfDPTWho3r4seBzB1j+3j6+f3U3znoDvuZg5FH3UXmk9opEUDTcO4OTqHXY0fc7JNLMgJNTSbk+GAWUUL2egi21fPLwRmq+fAlK14LeAtNmgyBgMEQQFzsTgF66GpJsSTwx+gkuH92d7tFWLG0yVa/sJFDZhmjV0TrBxMI9wUSCkyZNYvDgwQyefgYx6d3xutpY/vYcNE1jf9N+rl12LW7ZzbC4Ydza9zFA4nVLDjW2KCIvvxyGXMl+S28CkcE6VeGuZnrlHHJzNbl+ImCuQ/LbMK/th6b8YrJM6A9Tngq+X/4I3hVf4lr5Be7VTyJF6FGdAerf2IUn/xDpygzP5IMZH9B7Um/2R28jMTFYAyq/oAcOR7BAZ0ZGBtdffz19+/ZF0zTWrl3LW2+9RW1tbafND40fyjunvEOEKYL8pnwuWnzRH571OOrGGwg98wwaQ3vw9ZdOSvY0IkoC/SYlc+GjI+g3KZnYuJNJTQ1mAM/Pv5c2V0GnPkJOPYWwvwUF0oW338Fp367kuZIa9rhV/sXteLCRQQHvRn7JpuHZlI7ry97RvVk6pCfz+3fnywEZfDMwkyWDe7BiaBb7RvfhwJg+/Di4B2/2SuPvidEMRI9R1vDrBfaaNV5paWbS1gP0XbWHO/LKWNrQiu9XRO9d6MJ/K7oIzn8BGspK+OG1FwEYeG4aTW3fANAr53ns9l6/q09ZUXnzzheYtjGYeM5w49+JP3Pmb+5H01T25d1Ndc3naCqUrUhk5NRHScr6feP6M2AeMABdfDyqy0XbqsMKIp6g/sbV6uPLZ7eTv7EGBOg3OZl+I4KhyDW1C9E0Dc+eBjSfghRpwtjt1y1gETOnIxiN2FxVJFvqkDx1hO8JFm3UJtwH4WkdbfcpQbLUx6zw5PB/YDfYMehEnhzRndewEOJT8dn0qLPi+Gp9sCzFiBEjGD066IqTdDpOufYWREmicMtGVq76kmuWXoPD76BfdD9emvgSl43MpL/ShFdn5OVJ1yLFJ7DKkcxqhgMQ0lKLXHaQjV8EM/RqmkZZ2VsAhNechFqn4t5Rd+SODroMes0CVabx+aArzz5hOLE3D8aYEYbmV2n8ILcj6gyCUVG3DLqF60alI0kyjrZwSg6G8fJrL1NaGnRxmc1mzjjjDM455xzMZjM1NTW8+eabrF+/HvWwiTonMoePpnxEij2lI+vxrvpjFzz9rVBVjZKBl7Cr300EDHZsnhrOuDyJ0WdnYrIeyvrdLf1WwsNHoChu9uy5oaPUh6Zp/NjQyiUTZ5KX2h1TWxv3zf0XIy0GXs5O4afRExne90UAxMbPMbQswni0VAeAIqvUFLWyf1MNhcsraFlUgX5BOT2+qeHKbV5e3K3x1Hofty91cslyBydvd5Ge72bLlhruXFlAvxV7uDmvlOWNDgIn6AbrQhf+6ujS4PzFNTjetjY+vvdWWmqr6TYyjtC+a9A0uSPC4vdA0zRef+QtxsybjYSGfN7F9Hnont/Rj8K+vLupqfkqSG5WJjFy6qNkjfzjKzz/X1H77LM0vf0O9pNPJumlf0FrJczOAUGEOw52Kl55OJxNXhbO3kFrvQdrmJFTrupNfPdQZNnF2nXDURQ3gwd9jm+ehL/EQcgpqYRMSDlqX4ej8s47cXzzLSFnnok5OpeIlp+o9WeS2/M9xl+YgyiJHGg+wAXfX8Cl4a1km1WSky6lR48H8JU6aHhnL5pPIReZJ/QuTgvJx+1qo2fPnpx77rmIv5gI13/+MasXfMyiMXU0W3xkRWTx9ilvE2IIwVdUxNqzL+H6Cbfh0xm4Y5Ce+txgZuCTWE2sLYyFW/wIosi5Dz2NJcbJ9h3nI4pG+gmf4V7cjBRmJO72wQi6X0zAnhb8T4/m4HwZNIH0hV9j6tkTTVZpXlCIe1vQ8mIfn0zIKakIgoDPV8/6DeNRVS+r3H1x7E4lzB8GAsyYOYMB/QYcOj9OJ9988w0FBUHLSGpqKjNnziQ8PLyjTaOnkRuX38jexr2YJBPPjXuOccnjjnuOfg3OJi8/zN1LbXGw1laKew/pW9/GlBRP6ocfoo+N6dTe729g85YZ+Hw1xERPwdTtWf5ZWMVPTUHLVGpzI288cQ/GNifhf/sbcQ/c37HuwaLZlJS8gigaGDhgHqGh/VECKtUHW6gqaKGqsIWaIgdK4PdbYTSg0S5SE66jNVJP9+5hnNYvnmFR9v9YgEAXunA0/Jb5u4vg/IUJjqoqLHj6EUp2biMy3Ub6lAPISiuxMdPo1evF333j+XTOF+S8/BB6TaHtpGkMfumZ39yXqvrYt+9uauu+abfcJDFq2uP0HDH6+Cv/B+Ddt4/iM85EMBjIXL8OqeBrWHgDJA6Gq5YfdZ3WejcLZ+/E2eTFHmlixt8HEBpt7vg+d9/t1NQsID7iHEI+nQoCxN89FCn0+MnX3Fu2UHrRxQgmA5mnlSIaJOY3PEdjIJW0vlGMuaQbFy39G0WtRZyZmMUYcTuSZGVI4iJaPihF86sY0kO4U2vDVLWRONFJeEQk11x9FSaT6YjtyQE/F8yZQl5YHSGqmYXnLeqoOF517320fvUVi0+9nI/MqZxmyEMSNMYN7cuEzZcBAt/b/k7+lq3YI6MZcLGEw72CxMQL6NntIaqf3Yrq8BN2endsIxOO2Hb1P66j5fuVWOO9pLz4JPQL5rLRNA3n8jIcy8oAsA6NI2xmBgcKH6Wi4n0s1r4Q9QYf7J1LYH8JSe5gSHyFPZEyIROXX8WoEzHrRRLkGuLb9iNqCog64nKGktO9GxG4setU3D4Xb++cy/6GPBAEzux7HtN6zcQcEorZHoIonXg4eUNFG9++vBN3qx+DWcfEi7JITRYoOf8CAhUVGNLTSf3wA3RRnSu6t7ZuZ832y1mgzWKJMB0FEb0gcHVyNDelxCCtW0vFtdcBkPjC84RMndp+nBR2776Whsaf0ElRCPUvULBBxesKdOrfZNMTmWDFFm7CGmbEFm7EbDd0HGtNDS5el0xbsxdnk5fGijYcjV7UX7oYAVmEhhgDkd1DGTMglv5ZUUi/JLBd6MK/Gb9l/tb96rdd+I9i3fyPKNm5DUuURvqUg8hKK3Z7H7Kzn/7d5ObzV+fTc87j6DWFxsGjGfXiU7+5L7+/iV27r8Xh2NZObpIZc/oTZA4b+bvG9O+AMTsbQ7du+IuKcC5bRpj86+6p5hoXC2fvwNXqJyzWwum39Mce0Zk4xMfNoqZmAXWNi7AJJ2HpEXNC5AbAPHgwhtQU/KVlOMvMhF14OUNjp/HjW7nk5zWy/PVKimJNhNiyuWjoK9TnXYzLVcDBn+YQ4Z+CMSOMyItzmLFkMbtqnPg1kf2WPhiNR9/+V0VfkxdWh6DCqE0h1HXfTdTYiQRqamj9Nih+vfSCcdT/sAJJ0XCZYhh36kxo/BAO/sRJWT5qKxJprq5k55dtpJ8qkJJ8OYJeImRiCi1fF+L4qQzL4FhEwyGyEKiro/XHYOLIqOw2+P4fkDQEIrsjCAIhk1ORQow0LyjAtbmGAzXFtPb8BEmAR1eNZl/TFqA/ksXMMNtuerSlkeSsxCnUccDTDxAwKD7afA34An6SQhUMJqjZu576jYsxVZcgykEiEA/EEw1A4/ZlvM+y4CAFgZCoGKJSUolOSSMqOZXotG5EJCQd8duo3N/Motd24/cqRCRYOe36voREBUlvynvvUXrRRfiLiym77DJS3n8fXcQhy2C+1oP7dHOplYPuqzE2N0/3GkQ3S/s5Gz+eyKuvpvHNN6m+/wEMGRmYevRAlQWEljuR3QVgKccr3IfPexeWEDuJPcNJyAyK2cPjLL/6W3bKCvkuL1U+Py0BM62yQnMggjZFxdPso7nMiafBiwqY/RoRbQqhbgXP9gbWr69nrU7AnBHCkAGx9OgXjfUEr/UudOE/hS6C8xfFgY1r2fz15xhC/GSd2YistGC1ZtK/31tI0pFP6MeDpmnMe2QOfT+dg6Sp1GUNYMw7ryL8hidXgDZXATt3XI7PX4XiEyldkcz4sx8nc8hRktb9hSAIAiGnTaXh5VdwfPcdYZkrgl8cheC01LlZ8Px2PM4AEQlWTr+l/1Fv5uHhwzEa4/D5anBF7yR6yMVHtPm18YQNjqOutIzmklB+7HkVG70eNp4bTVHA3y56vod6YNS2Ki53TGKSvYDmpB+xC2eQeEkvdu/bw67twbDpjUp3igpdvLbqINeP7xzuntuYy1Obg4LfWYbxhDQX88PrL2GLiMK4+AcIBDAPHsyykhKMigeXZmBhSyK9N5ZxydCr4eBPGHLnMf2mJXz04B04ymy4CoZimRQsTGodHItzdQVKk5e29VWEjD8Uut384YdogQDmAf0xD26FsnXwxeVwxVKcssBP+XUsOVCDqPdxu9+AzvIFkhCgsLkb+5p6khhmpnuMjYzodKzWkezJf5e0uniytQDpYStJrnHhrang54x3WhMEwmPwxSSh2EJxdetNoKGJQJsbVRBRBBGdrgWz5sDoFzEGJARNw1Ffi6O+lqJtmzvGbgkNIymnD8k5fUju1YemagPL3tuHKmskZIYx9bo+GC2HtDaGpERS33uX0osuxldQSNnlV5D63rsIoaG8UlbH08XVKJqeRJ2bCwKzGdC2l3D/B2AZ0tFH9M034dm1C/emTZRfez3+u+ewdWU9bU0+9JbrSZ38BKbwcgZe8CVDhr+BdIzfr6xqbG51sbbFyb42D/vavJR5/Udte2jjAhxmoex0vaoaEW0qMS0yy3eWEb2qmFSjgbE5UXTvH0tkorXLldWFvxy6XFR/QRdVya7tfP3so0hmFznn1IHkxGrNZOCAjzAYoo7fwS8gKyqf3/wQ/ZcHk8vVDJvA+LkvIhh+W06MxsZV7N59I6rmxteqp3JNFqdc/ggpvfv+5jH9J+AvKeHgqVNAFMk8vQpdiBXuKgbp0CTl98h88fRWmmvcRCXbOP2W/ph/JXdI/qZHqHS9j61pIENnzj9Sg3IstFbif3YIB78MAU3g8vufpjjxkHYnxCUjIOAzSfRrlnl+p4OKUXegmFqYq91ItfkkIvN3k1lVwskjhlFry+TeBXsQBXjhnP7MHBB057T6Wjn3u3OpbKtkYvJEZo97ge9fepYDG9diMFsYfqAMW1MrDfffx/LCQkRRJGrQqTyzph5JFHjvkkGMWTQZWsvwT3+ahZveoWxVDIIocM4/n+oQk7t21NE8fz+CSUf8nYMRLXoUp5PCCRNR29pImjMH+6AeqK+NQvQ2syT0bG5uOBP/YeUFpljbOGvEgyDKxBc9SMrZ52ILDZJ5ORCgbO9O9m1czTeNG4mTsxERaZUaiCgoISE8nsSsXsR170FYXDyqwcTyNWuprKwEwBgeR1VoL7ZV+6lq9aKz78GUMB8RGbM7gYnihfQ0GZCdLVTWNlBX14QqBxBQETUNAQ0jOuxCDFk9+jDr1ikYTEe/LnxFxZRefDFKQwPuwUN5+u/3strpAeCs2HCeykygKP/v1NcvQacLY8jgL7BYDlWxDzQ1seWKBzlgG4HLGhSZW8OM9J+cTHxOFbn7L0PT/KSlXk/37v/oWM8hK/zU6GBpo4PljQ5a5CMLdCYY9aSYDITrdYTqJML0EnZJQkHDr2r4VBWfqtEckCludFPl8dOsB008Onkx+1SSGmVS3TAyKoTJ2dFk9IhAPEb7LnTh/4ouDc5x8FcmOCU7t/H1c48hmV1knVmNaHD/n8iN1+vju8tupdeOoMWidvq5jHvmn7/paUtVA5SUvkZx0UsgaLRVm3HmjmT63x8lNCb2N4/pP4nis87Gu3cvsYNaiJg2Ac7/pOM7VdVY9NpuSvc0Yg0zcvY9g49rhq/4ZAn7424ATWLMmPUndI7q/QFqPr6IPqWL2b0xDX2Jn1WnTKfuplvYXPQexbWLGK0NZcDm0wnTYGSIDlGDykHLaIv8iHJSuJsXQBAwqzKPZKVyQXwk93+dy7zNQT3LfVOzuXJMOjevuJmV5StJsiUxf/p8QgwhyH4/Xzx+P5X5+zD5A/TVh7KyTx8UReGUU05h+PDh/OOzXXy1oxK7SceCYYVkbLqXol7pFEU4qV7Ti7o8FVtEJBc9/RKWkFA0VaP2X9uRa93YxycRemo6DW+8Sf3s2RgyMqh6/i2+2FFFIPdb5kjB3DAX+e+mMnIEp/WJZ2JWDEbX81RXz8PckkXy5rswJNoRTw5h74bl7FuzAm+bs+MYVmdYMRoy0Gt6nEYnZ5x3BqPSR3U6zoqisHHjRlasWIEsy+h0OsaNn4AnvBuL9tSwobSEBm8lqj8KTelc2PJ4MKk+Io3QIz6UgT2SyUoIJSvOTlK4OSiULijgu/sf5oHzr6ApNByTIPBkzyTOi4tAEAQUxcP2HX/D4diF2ZzKkMFfoteH01rvYcWHeVQeaAFAF3DR01rGqGevQW8MGtyrq79kX96dAGT1fJzmkNN5u7KBBbXNnRIBRuglJkaE0D8kmCMn22YmQv/bjfY1pQ7WrqtgU3Ez1RaBkhgd1RE63EYB7Rf3EUHVSGxV6a8zMCExjKk5cYSb9cfouQtd+O3oIjjHwV+V4BTv3MbC5x7DGNFKxml1iHoPFksGAwd+jPF3kJvSvCL23vQPulXkoyLQdOXNjLn92t/UR5urgL17bsXlzgOgMT8Us+8MTr3udvRHEbP+1dH47nvUPf005kg/abPvhqFXdXy3YcFBtv9QiqQXOeP2gcSk/vq1oTj9VD+5idIhD+MNLaZH5gMkJ1/6q+t8XNXI91u+5ZMdt6AgMjvyPk579W3E0FA2vX4Vz+5+EbPOzOfTP0feANJPpegEAV+EieSbM1m/aSyK4mJR5fn8EHEKDZbgxDws1MpTmUl8vrKYd9YF871MHFzMFtcbGEQDH079kJzIQ7Wo3E2NfHjVRTj1OrwZfZB1enr27Ml5550XnKBlhQvf2sSWkmaSw4x8GbiG/KEqAb1Iz8wX+PGFxTRXVZCYlcOZ9z6C3mjCk9dI4/v7QCcSe1MvCmdMhZZm3hx9MQuiDln5XrZ/wPTAEmRzNNIN6xFsMXg8lWzYOAlNC5AT9zqBeUbEgECrv4GVNfPxKm1YwyPIHDqSHsNGkpjdi62F21j42UL0sp42fRsZkzK4etjViEJnK9rOwkrmfruGPfUy1aqdwDE98yoIMmh6QMCgE4mQJASXjIqGbNRoVTTkX8muEWbWMzgtHFuUmQU+F75QA2k1FTz6zaeMfeoxjOmHLDU+fwNbt56B11uJ3d4Po/NZNi6sQPYp6PQiOdkSoW/8A73PSdQNNxB906Goyf2Fz/Nl2Q5+YCr7hUPnNcNi5JSoUE6ODGFwqBXpD3Qb+T0yBzbXsHdNFY0VbXh1sDXDSF66CZcOZEnAY+x8bARNI90nMMJmZWr3KEbGhmLuqpHVhf8DugjOcfBXJDg/k5vQbvUkj61FEFVs1p707/8+RmP0b+5vxeufYHv1OWwBD17JgO/OBxl+yZknvL6mKZSVvUPhwecAGdkrUrk+geyB1zF81rn/tf72QEUxhSdNAU2g+/w3MfQbA8CBzTUsfWcfACddkUOPIXHH7cu5qpzWxSU4+q2hOvZt7PbeDB2y8KhtvYrKvQUVfFZZx9LtV5LtKqaiz8UkzJjNwZNPRq6q5o1pepb30fjniH9yuvkU6t/ag+ZTqAuobHIpTLo8h1bhBRzOL2lpiSW717usNofz0v4qomr9pNXLDAxI6L0KhQ2tSJZCNFEmMyWNU0eNIT4jDKM5OLm3LlxI4QP3s2zMSDzR8ejQuOGGGwmPPnStNbn8zHx1HWVNbvqE1HDDkGewIzFy8h4ay8v59J934XO7SOs/iJl33I8o6ah9fTdyqYOCyp+I2/Ip1ZYIrpx8FzaLkRn9Ezl7cBJ9YvQIcydCfT5kngwXfEbe/vuoqpoP3lTyPo/GEDAyPu48LDo7XtGDdFo4qSMGIv6ieGZFTQVz35uL4BXwSB5cfV08dNJD1LUY+GZXFYv3VlPa2Lnqtx6ZCMFDzzgbkwdlkZVk55PCV1hWsRBB0IgVh1NdOJ00p4Epbj0CAiXREn2npjK9bwKqqrBnVy7btu9hV0ElNZqVBn0EzYZwVKHz+AQR+jnKGVSykyHeGsa+8AiWvofIXlvbATauuZ7yDTNx1wWJSmKPMCZenE1IlJmWL76g+v5gkdiEZ54mZPp0Fje08vjBag56gnW2JGROClW5oXsvBof8utD4j8DP1dHz11dTsLUOv0fGZRTYm2IgL9OMR1UxBTScJpFWW+fjoVM1egt6xseGclJSBP3sFnRd7qwu/AZ0EZzj4K9GcPZvWMPiOc8TN7iC6D7NAERHn0xO9nPodL+tcKezsYWV199Jxq41AFTEptHjpdmk9jvxDMWtrdvJy3sEl3sPAI4yK66DwzjpsruI7XZi9Zr+sti/hLJrrsNVY+p4Kq4rdfDVc9tRAioDT0llxKzjl23QNI3aF7Yh13uwzYpmu3sGmiYzbOhibLYendqWe/1csbeY3U4PV1V8waMHX0YzRyDctA0sEdS8PofmF1+mKA5+eGAyz2Y9QcPcvWheGUN6CAVhZnauqACdjL/7Onr3+RhR1JCa/0XV3miaq10ntOuCANEpwcgb+4eP4Kgu4Jvp03GYrOgaqogTVaZfejUZ3bpjFgUEQaCwro0z5qzD4ZUZFreVp82vk3bWWojsTuX+PL54/H5kn4+YvkM52Gsm+TvqeNYj4Vp6H5qnmcUnX0qPKy9icnYsJv1hk11tLrw5ARQfVf0uYZ99EYKoUbAwFVeNhbDYePqPmkp8UTxqawAp1EDUlX3QR1uO2K/W1lbmvDMHX6sPv+hnffROyhsmo7h6AqATBQalhjO2RzSDEiyU79lA7t7gtW02m5k8eTIDBgxg3v55PLflOWRNZoTnVPrtmgIabDcE2KprJER2EK656Beu0d0iY1PcBHwe3C0tuB2t+D0ePAYTbr0ZRdOhqAIB9LglM26dBZdkRVAFMlPiGT1pBOP7pVO3r4WfPsgl4NMQJB+pQ7dyygW3odMf+t3/nMNpb0YW7956D9vFoPYnQi8xVb+N4a5XiBQ99O//HuFhQ444Pn8mZL9C8e4G8jdUU76vCU2DJqtIboqB/AwTmi9YE0sRBWrCdTgtna03FhUGmc1MTAhjdKSdHJv5D7U6deF/D10E5zj4qxAcRQ6w+qN32b3yK1InVWJPDD5ppqf/nfS0GxCEEzflqorChrc/Q3vzFSLbmlAQKDrlbKY8fS9604mFc7pchezPf5Lm1pXB8flFqjfF06PP9Qw9/Swk3f9A0N3iu2md/x5VG8PRJyWR9M0i5j+2mbYmH2l9IplyXd8TEkj6Sh3Uv7YLQS8Sf98w9hy4gYaGZaSmXENGxp0d7VY3Obl2XwlNAYV0rY3Vmy5A72sNlmMYfDkAs5c/zMSbP8WgQNhLr6NtMqC6ZAwpdqKu6I2gl1j85h52lqxClbxkZ20hLHEbjrLBVG28BoDwOAuBJAtfi14C3kLMbSsQ0aE1TSLMHUKKLKI3SOQnGiiO1dNsE2myQ+AY59QsCgwMsTIuwo5Qs4fZX7tRNYkJ4nZeHubENuMZypvcfPXtT/gWz0XSFPbZslgeNZ63K3aTsO1DBGs4PdavQDxK6LrH6aDus7tJLf+Y3EwbNfEmHOVWtKpZ9D91Gun9BiGIInKrj4a39iDXexBteqIu740h4VB9M29A4YfcGuZvLCSseh0xgh9FUNgcvRnNmsP1/W5hcnYSNmPn/SwpKeH777+nvj5YXiMuLo6TTjqJZmszL3/0KgP29Qe5AYw1CP4WZK/nuNfEb4UiGNGJ4QhSOOaIaKJylmJLKCMqYSAD+r+DJAUjmio9Xu78einL44LRaSZN47q0OK5PicEqquzecx2NjSuQJBsDB35MiL33Hz7WE4Gr1cfB7fUUbqul+mAraFAfIpKXZKAg3YRb00itD2AIaDisEqXROry/cGnZNIEhNgtj40IZHmajt82MvsvC04XD0EVwjoO/AsFxNjbw7YtP4hM2kTC8Fp1JRZKs9Mp5jujok39TXzsXLqXh+edJrAumsq+3RWL+56MMmT7hhNZ3u0soLHiJ+oZvQNDQVGjaH4rWMpLJl9xJZNLxM/P+1+DV4ajV+RR8l4rq9VN65ZscLAwQEmXi3PuGYjCfGIlrXlCAa1MNloExRJzTk7q6H9iz93qMxjhGjVyNIEgsqm/h6twSZA362c18UfUG9u1vQ2xvuGY1iBLrq9ZzzdJruO57hYkHo7FNvh8EE/pEG9FX9UE0Bcez4ruN7PixAqM/AmNoBemnPIymiSSHfk5KVk5HpNemxmquXHwWKA6U8DO5p8/1fLqniu0BH1q44ciaW5pGuAx2k44mrxuXpEMTjww9NqlulFoNocRFjvMg+ogU9jQGv+vmKmJK3Y+IaEQPncTwxUtQKsow9jqLxOdvx5gWLF2hqSqV+/exd8VS8tevRgn4Oa3HPqrGB8WqPRJfILnnjCO2rbT5aXh7L4FqF4JJIurSXpSaRT7ZVMaCHZW0eoJ5bnSCwqzQMqzeBjQ0dkTuQEqReGL0E2RHZh/Zr6KwefNmVvz4A2pLI5LLidHnRvO6j2gr6fWExcYj2COokk3ktgo0qCYCop6AoEOfE01TmAkRuCkhnCGal5JdOyjbuxt3a9AqqwKyaARVQ4+fY07bRo3weAPd+p7GtrQ+vCabaFM1RE1lyrqVXLbka/o/+Ri2sWPb98PLzl2X0dKyGZ0uhH4p/yRMi4S2WnA3Bgu4yv7gq+IDBJAMwUVnCBZFNYWAKRRMYcFXSwRYo0H3+3LdtDX7OLi9juJd9VQVtqKpGk1WkfwkAweTDNTaRVLqZGJaZTQBasN1lEbr8es7HxWjBv3MJkbFhDA4zEZ/u4VIw//Ag1YXfje6Ev39xVGyewdL332E6IGFxLZbbez2XuRkP4vN1vOE+tA0jfxlayl74SVSiveSCHh0Rkonz2L8A38nPPLX6yGpaoD6+mUUFczF7W+vzyNAS7EduWYoQ0+7hrR+A/9rtTZHhbMW6vMQdQL2kyZzYFMtBwsDCAKcdHmvEyY3WkDFvasBAMvAYBRZVNR4dLpQfL4ampo3sE3twzW5pcgazIoJ48UIF8bv3wt2cOqTIEq0+lp5YF1QX2GaNgvL1qEgmNBFGYi6vDeiSYeiqKz7Kp/c5S6MRKCh4WtNAu9ABNN2sH+N2da/Y2xf73sJFAeCuS9NttO5o6QK7ADtlc4b2zhn4xIaEuOx+T3E1cUT4ooHAbqNjgNlKzuXLsRhDaEyNYvK3jkUWSPwiNb2THlWdjWFYi1pQkNlVPdIZg3oS7eWnqyc+xL1m5ezRfLRz2JHnz6W1sUlaKfa2L9+NfnrVuNsPFTVOyYtg8ZxJjRhJ5FNfpKbv4Mepx9BwiSbgeir+1L33l7kUieVb+zmQc3NRoJVxBNCTZwzJJlzBicTazfw/fffs337dgY2DmSfso/zW87nkt6XcF2/6zDpgsL45upKCjZvoHjLBowF+w+dW0BDQLCEY+gRzkq2Umf3oI8K5eHRtzEmKajZ8skKK/Lr+HxbJT/o/MgJFlA1TLubWeM1Et4/ncnXjMdikKgu2M++1cvJX78av9eMPuR0BNGKqjTS6t9DQ5QVX2sDkb4GwgKtiD4oabTyuhpOmd8IaCQ2VHFZVT6ZJTtR/W0U33wz6Q9ciy1JQKrNpV99HTujVFrtDnYU3EafPAdRTZ0zHXfsowYaZlQtDIUwVC0EDSOapkfDgIYeEBGQQW8EoxXBZEWwWhHtIQj2MMSwSISIWMSYJISwmCPyadnCjfSblEy/Scl4XQHK9zVRvLuB+NxGRu734tULHIzTUxivpyheh9mn0a/IR5hLIaAXqIzQUR4VtPBs9nrZXOaFsmC9s0RRYmCIlUGRNvrYzfSymQn7HdFhXfjfR5cF599owWmtq2X1vNdx+BYR078RUachCia6db+V5KRLEcXj/0gdNfVsefNjpCXfEttUBUBAkDgw7CRG/PN2EtMTj7mupqk4HLupKP2a2rqv0URn++dBnY1SN4jBp9z4v0dsfsbuz+CrqyC+H3UZT7Pgk0ZkvYVBpyQzfFbmCXfj3l1P0yf5SKFG4u4agtBuQs/f/08qKz+iOPRqHnGeil/TmBkTxqvZKUgfnxks7pk1Dc77GIA7V9/J4uLF9DP15pmSW1GbfSjOGswZDcTceh1NVS6WvZtLfXmwOKMY3sawiX3Z8GURlpg8Usa/gCgaGTliJUZjDKsrVnPtygfxhJ5OwDaxffoPYkZMGPd3i6fm5tvZqXmoTEqiTrWyyZPDSK+erEDw2qsXVbaJ5fRvXkqY7KDblDKsKR5WlI/jM87HnRSO1l7nSnTJXBAWypPDu6HXSez56UeWvv4SmgA2nYHRcRcRqo9iTe2XVLkLATCYLWQOG0m/yVOwxils2TIdgKHbHdjb/DD9XzDo0k7He1+Vgy+3V/Ddtgpu9+gYgR4ZjYWJBvqe3I2xmdFIh7kxNE1j5cqVrFq1CoASWwk7onbQgyTOVsfizi2lsaKs0zaiUtJxuSJxSOANV6DdipXcPZll0jL2BvYCMCVtCncOvZMocxSqpnFrfjnza5oQgbRSD1WHVUc36yUm58RyWp84xvaIpi6/kSVv5qLIoKmt+NsWoikNoGnYIxNwD53GfjWc9Z4W6nsmoOp0SLLM6M1LGbxnPeIvbtUWn594q5PkyBbiTG1EWtrI72WjMdKAoEFWQyJR7sEEArHIvggC3jBkjx3Fa0JTf1uCz1+HH1F0I+n8iCYF0SIi2Y2IoTakyDCk6GjEyHAkux5MOhor26jIb6Yiv4nqwlYCAZWGEJGSGD0lMXrKoiXC2zSS6wOEuVQUCWrCdVRG6GgKOfq44wSRHIuZPhEWsuwWelhNdDMbuyK2/gfxl3NRzZkzh2effZbq6mp69erFiy++yJgxY47ZftWqVdx2223k5uaSkJDAnXfeybXXdg5v/vLLL3nggQc4ePAg3bt35/HHH2fWrFknNJ5/N8Hxez1s/uY9yivfJzKrEckYTG4WHjaK7OzHMZuTf3X9prIqcr9ZinPlSpL2bUGvBhN4+SQ9hb1H0vuuv5M18OgiYr+/kbraNVQUf02bdxuC7pD5PeCWaCmMItw2hV4jZ5GY3et/k9j8jK9vgJ0foY24mYX7ZlG5v4UQRwnTL0wgbOqpJ9xNw3u5ePObsE9IJvSUtI7Pnc483tpyHy8IdxPAwPToMF7LSUVXuBQ+ORtEPdy4GSK6sahoEXetuYtIJYz3G55CalIRTCrOr+9GsOnxPPA+G78tRZFVVCGAO6yIy287i+joaFbP28+eVRWkTX4WU0QByUmXEpN2O2OXvUmdaRQIQbIyOsxGqE7i+4ZWBODFODsRN1/HulEjEQWBIVPOZWeDxrqDDRirvYxoFjFrAgoaG40B7FFbOWfUu2gq5H3aHb/TgNMWyq5+w9mUNQK1/anZ1OjhzLJcJu9fT+iW7WxPi8On1yEiMTJmBnZDBIUJeWSPHkf6gMHo2hNM7tx1JY2NK4iJOY0+zWmw/OGgu+Sq5TTYerBwZxVfbKsgr9rRcYyTQ0w8YwkhucYLAoRO64Z91NFJ/datW/n++++DdZj8TmwlBxGVIO0TJImUXn3JGDyc9IFDWfVJBeV5zVhCDYy5LImtOzeSn5/f0ZcYLbJaWk2tqRa7wc7NA//ORm0Yn9Y0IwnwWk4ap8eEUVjn5JudVSzcVdUpequPouPkNj2iBrEZoUy6qBslm35i96cf06AEMwz7DEaWjJvFge5BDU2Uux7zvmqa6kOJ9jcQ46sj1ldHgq+akPaK5IdDEATCY+KIH1aKPv4gAOH5ZxBTdvpRj49gEBFtBiSrHkEnIOrciGodErWIciNCoBnR34ygtCDIjqB7SwuAKiNoMkF7l4iGCAjB95qu3QpkAPRomhEVExpmNM2MSrtrzGBCMFnBEoJHF4lDCafBZaGu3kezM0ClTaQ0UkdFlI7KCAkBgYRGmZhWBUkFl0mgNkxHbZhEi+3opEfQgsQnWa8n3WokM9RCd7uJZJOBBJOBcJ30v32/+x/FX4rgzJ8/n4suuog5c+YwatQo3njjDd566y327dtHSsqR2o7i4mJ69+7NVVddxTXXXMO6deu4/vrrmTdvHmeeGQxz3rBhA2PGjOHRRx9l1qxZLFiwgAcffJC1a9cybNiw447p30VwPG1Odq/6kIqKTwhJr0HUBQ+1UZ9GZo/biImZesQPTJVlKvcdpHz7Hpo3bsGyZxtxjZWd2pRGpeA7eRrDrjqPuPhgWK+mKXi81bTU76W2agMOx24CajGCwdlpXcUn4qywIQV6k9nrInoMG/tfmc/mN0PTYHZvcFSwM+sr1q0UkASVIRsfIWZYL5Jff+2Euvk59w0qxP5jUKeonnXNTs7fmY8fPeMsjXw0ZCJ6TYY5I6CxAEbeDCc/So2rhjO+OQPRrfFm7SOEOEzBKKErcjh41gz2RE2hLmYQALK5hVZbPhNOHtPxUKAEVBa8sB2nayMp42eTJwxgjngbTWpwLCNCzdzZLZERYTY0TeOuAxV8UNWITpG5+qcFqAY9o0ePZvLkyZ32ze3ws2refop2BN1IYUkNRA96lPCwwdRsyqJi3x7crS0AePQmFg2dSVFODkgiqBrTVizlxoUfURJppyw1gUC7MDczZBDDzzmfmJMOkfCWlq1s234ugiAxfNgPmE0puN87C2vZT1RLiZzqeZRWNXhdGiSRSdkxnDUoifE9YxCBlm8O4tpYDYBtVAKhp3XrsKQ5mxo4sGEd+9evpry6Gk9iN5B0CAEfrW17ORhbT0O8xoUDL+Xi7IvZPL+Mfeuq0RlEzrh9ENEpwdxCdXV1rF27lj179vDzbdJv9JNnzWd36mhcIRMRgTk5qcyMPVS9PHi5aeyuaOXbXVUUb6hhYLteKV8vs8QaoE9KGGN7RDM2I5LIH79k0apVvHzWZTSFRSEqMmM3/ciw/LVknFKKO9zM3vociiuy2OXJxqkYsARcXL5/IT0dRbRYTDTY7ajiz1mhNRKG1xHTL2hNchRG4z8wksiYdKLT04hKsBNhcWBuK4TavVCXDy1l4O98rzgeNE1AaycvqtZOYtADunaiowN+Jh+H3+c0QEFAJahMUhAEGTQluC561HaXmYoeWTPiwkSd0UalyUq52U6pJZQGIhE9NiSPBT9GvHodLTaJ+pDg8ksB8y9hUCFKE4iVdMTqdcSY9MSbDSTYTcRZDUQYdITrdUTodVi6LEF/GfylCM6wYcMYOHAgr712aALJzs5m5syZPPnkk0e0v+uuu/jmm2/Iy8vr+Ozaa69l165dbNiwAYBzzz0Xh8PB4sWLO9qceuqphIeHM2/evOOO6c8kOAFvgIqDqziw921k3S5M4cFcFZoKor87CQlXYxJ646htpLWiGnd1NYG6erTaWsxVpUQ2VmLQAqh6UA0CslkgYBapi47Al5ZISK8kwuN0+P2NBORmZLURTWxCNLYhiEc/ld5mA/6mOEKsw0nJOI2U3gMwWn5b+Pl/PRoK4ZVBNKrd+azxeVRFY/TJkRjuPQ90OjJXrUQXGXncbpxrKmn9vghDsp2YG/p3fF7k9jFl2wFaZYWB2hbuNM5j3MilCJvehCV3gyUKbt6OarRzzdJryCvfy4uVdxHnjkQKMRB9TV8CRolvHvyRBrcFQVOx9HRR0rqD+IR4rrzyyk51h5xNXt57ahOrx+ezxhwk9aLcxI3xGvf2ntRpzKqm8Y89B8nduZORRXvRGYzc8Y/bjlqYU9M0CrbUsuLjPGSfht5Wy5TrsknuHtxXt6OVxoP7aPzwWprdImX9/8aLCSOptgfJVXx9LVKhj4EJsfSrXoN350oAdKKBQdNmMmTWWeiMJjZtPRePaztO8TQ2Nl7J2sIGXM21fG+8lwShiW+UEbwdcx9nDk5met8Ewq2GI8bpXFWBY0lJsP8MG9XxFRzYuo6KvNyO2lQIArE5fagxhtDm8SLpJMrSytiobAQgVAynX8HJZNcP47TrBpDe98iEms3Nzaxfv55du3bh9/vZmtqTrWnZoGkkVX/CqFg/Nw26iYzwzikUNE1j49cH2f5D0B0md7exWOchv/aQ9UUDDN1DcHWzoYoCsY11XPPZW4S462i0mlFEkaQx1URmtQLgqo+iuvECquQc9jZqpOcu57K93yKisSU2g09yJhKiOkhTm8jJ3E3SwDIEETxNBkqXJeFtPnTOLZKfcIOHMIOHUL0Pu95LiN2IPTwWc0gG6OJRtBhkJRwlYEPx6/H4oM0v4/QH8MgyPiGAn+CrDxlZUJBpXwQVGQUVLbgIKioaGke/TwkdfyBoAiI/LyICAhICIiBpQZuRhIaIhtSxqAga7e90OPQWasx2GkwWGiwWGswmGi0GWsx62oy/TbOjU1RMsoZJUTEpGmZVw6wFlW0mQcAsilhEEaMkYdZLWHQSZoMOq0HCbNBjkSRMBgmrTsKoEzFKImadhEknYJQkJEnAIIroJAGdICBJIpIAEgKSQJel6TD8ZQiO3+/HYrHw+eefd3If3XLLLezcubPDR344xo4dy4ABA/jXv/7V8dmCBQs455xzcLvd6PV6UlJSuPXWW7n11ls72syePZsXX3yR0tLSI/r0+Xz4fL6O/x0OB8nJyX84wZkz51Fe6XmUitrCkYc4eLkGa9wEFxBR2t+riO2LDgUJuf29jJ4AevwY8He8mvFgxo1J9WHyqdg8ImF+OzG6BNKje5OSmUNIQmzHE+7/l9jyFup3d/Bl2yvUueJJ6xPJ1Ov7UnLOuXj37CH23nuJuPii43ZT+6/tBKpdhM3sjm14AgCtAZnTthdQ6PYx0G7iVtdFiEoT/XvMJvKjG8HbCtNehMGX8XHex8xZ/zJPl91Kmi8BMSQooHWpGt+9sovWOg862UPvvW+ydWgqrVFRXH311cTFdU48uLbZybW7imnQgk/tE9QlmP37ePvU9496MyybM4e5dfVIaKzu2Z97T57I5MhjX/vb1j3P1i+Tkd1RGMw6TrmqFyk5hxHAxXfDptcgbQzqxd/w1p0P8NLIiTSER4KqoSt0IBW3keIuZ2TzRmL8QVG2VzLRlB3F1FFL8St67ln7AC2+MAAMOpELE2u4v+52RE2GKc/AsGuOOj5VUagtKqR62V6iSiIRBYlGXxVrar7Ep7pJ6JlDzxFj6DF8FLbwCNxuN59//jnFxcEsz/G94vlSXkC1P2gdjZHiuXLwZczoPgOL/shcOxC8jzyzbS+v+oJEc3TBLnpXFeMTfVRbq0nKSOLqcVeTEpaCpmqs/GQ/+9YGdXLDZ3Zj4CmpCIJAVYuH1Qfq+amwnh+kAL6YoKVqav1qHlnxIp6NOmSPhCII1CYl0DygH2pCPuHZBxD1KkLATGz+RYRUj0AGimo2Eb31I/Syn1pbJC/3n0V0jINTpC30Cc2lIkdCMQkgg3NzGNX7InArRkQkQg1RhBtisRsiCdFHYNaHEdDrcIpeHIIH58+L6MWND/Uo97L/RsiiSJvRjMtops1oxm0wtucwMuI2mvDqDHj1Brx6I6r4n7feCJqK0E4MRX5+HyR4P38GdHwudLyn43OhE7HUOkfxaVonI5twFBJ6xF3lBKhDtNLE6pPPPm6734K/TBRVQ0MDiqIQG9u5XlFsbCw1NTVHXaempuao7WVZpqGhgfj4+GO2OVafTz75JA8//PD/YU9ODO6ASJN4fCvAnwYJsLQvh8GUV03sziriApCgicSLEqkGPZl2Ez0irIRGW9GFmxD0//kf8p+GopXscU+lzhWPwSQx/m9ZCIJA6IwZePfsoXXhwuMSHH9VG4FqF0gClr5B16CsalyTW0qh20eiUc97fbrTUjaD8vJ30X56JEhuYnvDwIs52HKQtza9wRNlNwfJjd1A9FV9aGj1s2jObryuAPYIE4NcKxFbDtBjvw/jzJmdyI2iafyrtJbnimtQgchAgJnqo0w05GKMPe2o5Eb1+Vi3ZQtSaioBi4282FSuzi1hwYAM+tmPnMwDgWYcgXdJm6yjZddsGkplvnt5F6PPyaTvhHa92IgbYMtbULIG1/w5jPnuKwauX8Wbr7zDN61u5B6h2JNtVG/VMd+cRIa7iOHNmwgPtDCh52oAavNimRYoIzw7jF59chjTKwmrUQ/rXfDjfbDkHojOIpAwDFdLM/VlxVQX7Ke6YD81RQXI7Q8tUcZERseeSaQxgWk9rif07G6E9+7s/rZYLFx44YX8+OOPbNq0iercasYqk6mSHGxPW0adUs0Tm57g1Z2vck6Pc7gg+wKizJ2tOcscHl5rJzdXRJgZkRDJ3pZqcEOaMw12wBs734Bw6OYajbfUiCDA+AuzyBmV0NFPQpiZUX3jeEtpweeV0KkyDxXN4bLKBSyPG85rk08m42AFZxauIqG8ksSmAEqvMzC0XkJdn7l4w4qo6fMm1WFLKVsfRbOnjfBukQwprSG2rZHH1s4loqeL6D4OxDaI3mFiW88ItAg/9pEtkJ6Bff/ZRPtttIhtNIpOSgUXLUItTqH0KDNZZ4iKiijLCHIAlOAiKDKoCoKqIKgqqCqCFnylvVhpMHwrOAHDoRegfZvtGxbap2chmGxSECREUdfpVRCl4KsgIYgiCFIwb5gggSgEU0gLYrBWVvuiQfv/wddon4wmOEFoQTK6kQwedAYPktGNTu9Fp/ci6n0oevAadPgkHX6dIZgZXjLixYQXEz7MHe+Dj5wGAh2vwUdSueNVh4IOGan90TX4/y8zYP8SmiB2HC6VP1Igfvjx/+PXMXKcCvZ/Mv4tsXW/vOlqmvarJrejtf/l57+lz3vuuYfbbrut4/+fLTh/NE47aRry0i+Q0SNrIAOyKKAKoP3swxUEQENUNURFQBRERE1C1UQUVY+s6tFUI2gGBNWCJuhQRFBEDUXUCEjg12n4RQjoNPw68OgEfJKOgKTDr9Ph0xnw6A14DUYUUcKrEyjVCRyybSnBRfZCXQuxpSrpLpWcgEg/vYH+YVaSYm0Yk+xI4cb/fvOoquAo2MfGtkcBGHFGBtawoKk+5LSp1D71FN7cXLwHDmDq0eOY3bi3B8NUzdkRiJZgAcGHD1aystmJWRR5r086MUY91oTzacqfS0RRQXDFU58koKk8sfxRHi2+IUhubHqir+pDXZOP717ZhRxQiUm1M/X6vqz5aAepP0BqWRlpaWkd26/3B7hxXxmrmoNaiXPjwqksvJd8VyETY8DbtBSvtxaTqTP5L/3scwqSkgC4aPo0Cn16VjU7uXB3Ed8NzCTV3NlVVV7xIarqITyqF5P+MZZVn+wnf2MNa+YX4Hb4GXZ6N4SwZBh4EdqWd6ifMxeAlLPP4o0BmUysaeKeA5U0myF8QgIvZiaR9UMaLfv6UJ/0DYaofBS/SMtWM+G+dXBwHbmLIE+SMNtDMNtD0Lsm4nE6cN33FIFjRPwYLVZS+w6g+6ChxKb2oe2zEmj04vq0DP3peqxD4jpdu5IkMWXKFJISU1jw1dfIUhtx6PlXr9kU2Yv4cN+HlDvLmbtnLu/mvsuohFFMSZ/ChOQJ7GxTuX5fKSpwYXwkj/VMQujXk6lTp1JaWsrqraspPFCI3q/HXpSF12tEQ8MVXcDO8hoa1ySTkJBAQkIC2x2tXJVbSpNgJNLfzFt5DzOiWx84YysnRXSje4OL3RUtbN1/PgM2HSTFEBecvD2Q8OPf2J+6EGnIXsSkInqdXIi50EQPdz363gq1O0NoLbLStN9GfXMmFb37Idl6ELs1gZZuS/F3X4I9fitKzE62lPWmoiIHTet8fP2iD6fOiU9wE8CDqnhB9iL4FUQ/GP0ShoCEXhbQKQJ6VUCngE7RELXgve2PmoIVBFRBRG5/VYV227Zw6H9NCN5jRTR0qopeldErCkZFxqAGMBt9mK1eTDY/ulAZya4g2hTEEAXBriBafr9VSlNB84toAQEtIKEpAposoikiqiKhqcH3miqiqe3/a+2LKgaPvSYG7/+aDhUJRdC12+8lVK39vSi1a56Com5VCPahakEyqCK2kzgBTWi3z2jBOedwW42miUGCd/hnQtAl+DPUdvvPr+43wtGb/OJQ6jQNJk35rYf1D8OfSnCioqKQJOkIy0pdXd0RFpifERcXd9T2Op2OyHaNxLHaHKtPo9F4VL3BH43snH5k5/Tr+F9TNfwVThpy61lxsJL15gB7wvUUh1iRD9NTmAI+ujXXcapZx5m9epCalkqLr4Xy+r3sL91KSUUFtU1eXG16TJ4Y4tzxhLvjMSrBTKcaGpogo0p+jHYX1kQdkj2AK+CgqrGJFk2gzRQ0xbYZLThNZjy2cJrNVhw6HbVmkVqzSFCVIAOtRFY103efwrA2GGWx0CPejiktFEOyHUH332Xp0ap2sqrufGTNTHz3EHqNPvQ0rQsPxz5hPM6ly2j5/Avi7rv36H0oGu6dQYLzc+6bj6oamVsRdL28kpNCn3ZriNXSjZwyHSLgSsnGmj6W91a/xrU7Tyc+EA12HdFX9aWu+RC5SekVwalX96GqpoKN9fXo4+NJqK6m5e23sTz+OBta2rg2t4Rav4xZFHmqRxKGtlU82LQbi2SjrTEBW2QxOza+wIjxTx82boWVmzehRkaSYjaTlZ3FW7LCzB0F5LZ5uXB3Ed8MzCS8PSIqEHBQXv4uAKmp16AzSEy8JJvQGAubvili2+JS/B6FMedkIoy+DeeCz/DV+xEtZiIvuxRBEDgvPpLBoVauzS1lb5uHq/JKuX1oFGcerMfdbT0BIC39OlKuGUTxjq2U7N6Bu7UFVVFwtTTjamluH7350HkyGAiLSyA+sycJmVnEZ2YRkZAYfHpvh+WGMJo+P4A3r4mWrwrxlzgIm5mBaDj0W9M0jcqNKmF1A3FF7scntbD4+8Xk5OTw8ckfs611G+/lvseu+l2sqljFqopVGCUTbtMAMA1kcsJQnuqR1EGcRFEkPT2d9PR0An6Zz15aR0utgoZKS9g+ZLGJA/k1HMg/gAbkJqSzLqMPmmAkxVnFfVXLCR3+ABVJPbGKVqyBAGlGAxFlXlx7vGAMXquaxYVz9wKEvatJ16nY8jyIPb00CALleh8bwyyU6iJQI4YyrG8m2b7uNJjBITZTK7awXtiBVhWFzTGF7t23EBJaT1r6TmLi97O9ohuFLTZ8goYPCVmzgGoDJQxVtqIqVhTFiooexSCgGIJOEqVjUjzkGOlwuasKkqag02RETUGnKujUADpVQVIV9JqMXpHRKTIGJYBR9mMQfJhNXowmHyaLB4PNhyksgCHMg97mwyAGMAb8WBr8WOoVTA0KugaQ6kCQBdQQkGM0lGgNuX1RIjmhWU5QRXSqDb0QikEXgV4fjsEYid4chcESi8EShd4Qhk5n77QIguG//wHwfxj/FpHxoEGDmDNnTsdnOTk5zJgx45gi42+//ZZ9+/Z1fHbdddexc+fOTiJjp9PJokWLOtpMmTKFsLCw/7jI+FjQVA1fQTOubbW05DWyLlRjcZzG5hgLrsOSVIW7HAxqruHchChG9u/XQeoAVE2lqKWILWUr2VK2kn21NRgdccQ7uhPn7EaUK7FdhheEwQgpvaOJ6WlCtTqpqCintLSUpqZDuTq8Oj26lHSExHSazGHk+mQKNAXlF7/ZWI/K0CaFsU0KY+1WIjLCMWWGo4v984v7/V9x4MN3WbouFVFQOO+fIwmP6yywbluzhvKrrkYMCSFz9SrEo0SVefKbaHwvF9GqJ/7eoWxv8zBjRwGyBnelx3Fr2mEamf2LYd55qAJsG5GBPulV+KSOKDkcf4hKyrXDqK33HEZuIplybW8EEV5//XXq6+sZGRlJ8qtz0HQ61n+6gIca2pA16GExMbd3Gol6mWkLptHobeQfg/5BTk0oTvF2VEVH355LiE0JVq3O//JLPt2zB0HTuPqyy4hvtwhV+/yctq2AKl+A4aFWPu3XHZMkUlT8MsXFL2K1ZjJs6KJO5UL2rKxg9acHAOg5PI4JF/SgZPJw/HUuosZEED13Xadj5lNVHiyo5P2qYAjRGLWKS4Q7sPstjBq/Ap3pUMmFgN+H1+nE43TgcTjwe92YJRnr4uux+qrQZ52EcP48OI4eQlM1nKsrcPxQAhro46xE/C2rI9pt25ISNn5dhCgJnH5LPwqr97By5Uo0TUOv1zNu3DiGDx9OaVspi4oX8V3RIqraKjptIy0kjSFxQxgUO4iMsAxSQ1LRY2DJm3sp2d2AqBMYc2k666UfWbZ7GUqLQkgggsKEkyiID1oIM2vLGXdgBzpV/eUuoNckDOhQBQWfxY8vTMZj9uJWawj4DtJCK1V6iTZRJMYfwYi2fgxx9CbKF0mN2EqV2Eyj4DziCVvvc+PWy/gMAomRVfRM24PRGIx0c7lCqa7qSV1dNxQlaJ3U0EDQUJHR1ACa4gHZgxjwoff7Mfn8WNw+Qtr8hDr9hLd5Mfr86BUVSVWR1KBFp1P8lE4jkKBDybCipRlRYwUC4T78ZieK5O1oJ7hAXy2gqxLQVQvoawSkBgHNoCHHQSBBRY4FOU5DjtGgswa9EwRNxCBFYzYlYbanYbIkYTLGYTTGYTTGYjTGotOF/uXvY10I4i8jMoZDYeKvv/46I0aM4M0332Tu3Lnk5uaSmprKPffcQ2VlJR988AFwKEz8mmuu4aqrrmLDhg1ce+21ncLE169fz9ixY3n88ceZMWMGCxcu5P777//LhYkfC0qbH+eaSlzrqwjIKjvDRBZ2l1gebsDffgPXKTI9ass5U68yY+QwktpdDIdD0zR2N+xmSeE3/FC8mFZPgDhnd9KaepHR1BuDfCibsdEi0XN4PDmjEtDbVfbv309ubi6lpaUdLkBJkujTpw/9hg6jzmJnfZOT1bWtbPV6OTwnqlHRGNkgM7FWZqxHJKZnBOZeURi7hf7lrDueNj+f3P0jXtnCsAENDL7mnCPaaKrKwcknEaiqIv6pJwmbOfOINo2f5OHZ3YBtVALaqalM3rKfSl+A6dFhvNkr9dDNUfbDnOHQdJCy1HDKwrsRs/UOLLKNJpuTXjdPoqbafQS50ekl1q5dy7Jly7BYLNx4441U33wzT6Zk8d2YYDj3rJgwnstKxipJvLLjFd7Y/QapIaksOH0BEhLLFk1HsubjrR/LqWe+jSDCa3ffQ73FTLbBwLn3drZO5bV5OH17AU5F5fSYMF7pEcGGDeOQZQe9e71EbOxpRxyH/ZtqWP5+HpqqkRwboPtnt6PX++k+vRbp6kWQeqTI/uOqRu45UI5fg0StnCfzyhmWOZXQk9OOfwIrtsG7U4I5WEbfCpMfOv46gPdgC03z8lHbAqATCT0pheYIM9/O2Q0ajP9bT3qNCebPqamp4fvvv6e8vBwIWp6nTJlCXGoaM7cXkNeUS6x/KynaAQ62FBwRBSSpOqYXXUtcfSaaqKKeUkZohkSoMZQQvZ0DB37gNV9faq29QVMJb/yamMbVGFQ9JkwYBSOKJuPBi1c6tCiictR9S/HFMap1AH3bshBkA5ViIzViyxECYJPJicnvJmFfHRn5RZi9XlRBoC4xkYakeJwxNkK7FxCSXoKoCxIt1S/gyzUgbhEJLZAJ8QjojuRgx4bZhBQXg5QehZpuRokTCET48ZsdeKU6vEodcKhDwQe66nYSUyVgqDaiqwXF4EdO0AjEacjx7UsMHMv3JaDDbE7Fau2G2ZKGxZyG2ZKKxZyK0RiLcByNSxf+e/CXIjgQTPT3zDPPUF1dTe/evZk9ezZj2+uoXHrppZSUlLBy5cqO9qtWreLWW2/tSPR31113HZHo74svvuD++++nqKioI9HfGWeccULj+bMIjqzKXLrkUgbEDGBs0lj6x/RHL+qP2V5p8+NcXYFrQzVaQKVNDz8OD+djm0xp+z1AVFWyakqZrrg4bfhQMjMzj/qkoagK2+u2803hQr4v+p6AqhDblkrf+t5kNg5AlQ8JJmPTQ+gzLpGMIbF4PG7y8/PZsWMHlZWH8u2kpaUxcuRIMjMz8agaW1pd/NToYFFtM+WBQzlyDYrGhDqZ6ZUBhrnAkhWBpU80pp7hfwmys+ydPezfXE+ErpRz7h2OlHBkTSKAhtdfp/7Ff2EeMIC0eZ90+k71yFQ9vhFkjegb+nFlcwNLGx2kmw38OLgndt1hN8/1rwQFstYYigfcirgiA0kxU2ypou9NJ+NqgG9fOpLcNDc38+qrryLLMjNnziQxpxeXbtjDNlVEUFXuiQvhppzuCIJAg6eBqV9NxSN7mD1+NpNTgwSopnIzufvPB8Do+hd2NBZs24Yky9x41VWEp6Yesd9rm52cv6uIgKZxWWgZk1tuPar15nAU76rnh7l7UWSNiKZ9TEhYTlzYT5A+Di755qjrzN/+EP9sGUuLEIEtoPHEHi8zL+iLIf4E0hXsmg8Lrg6+P/VpGH7tr7dvh9Lqo+mLA/gKWgBoVTW2t8kkjYhnwkWdrwNN09i1axdLly7F5QpWZ/dERLMqPh1HXBKLBvckzWyk1dfKttptbKnZwp6GPZQ0lzJ875mkN/dFFgIsyZpLRdih0g+yLg5H9D9Q9HEIqgd7wxyM3p0nNH6AUBWS/D56e+Lp6xyMzp9FIwqVYiNeoXMpBr0oYNM7iLAXE5l6AKP1UIFQw36BkAUShrJD51RrdyqpJg33cBX3WAX5MEOk2ArGPBFjnoC+UI9kCEcXFY0pNg4pLhwt3ogaIxIIVZCtbny6FryBKtzuElS1c3FSwQO6WgFdjYChzoih1oTgkFHwBF1KcRpybJDQKFEck8hIohWrLROrNQOrpTtWawYWSzdMpqQTygTfhf9+/OUIzl8NfxbB2V67nUuWXNLxv91gZ1TCKMYmjWV88njsBvtR11OcflqXlODeVguAGGbkwNQk/uVtZYMrGCkiqipZ1SVM8zs4a/LEoyZJ/BkNngY+yfuE+fs/xeF3ImgCgxoymFg1hDb3INR2p7Q9wsSAk1PIHhmPziBRXl7Oxo0b2bdvX4dVJz09nZNPPpn4+HggOBHsbfPwfX0r39W1UOg5FH4f51GZXhlgRmWAeEHC0icKS/9oDGmh/5EQ9cr9zXw9ewegcmbSs8Tdt+TIYpPtCNTVUThxEsgy6d8s7CQ2dm2uofmrAnSxFhacmcTDB6sxigLfD8yk9+FRSK4GeGkgmreVtuwPaNkVjqAJuML34TgjljTjJBa8sJ2AV+lEbjRNY968eRw4cIDU1FQGnXkOl+0todIXwOr3cf+bLzJlQG/i7r8PgMc2Psb8/fPpG9WXj6Z+1Inwblx7Ey7/IjxNaezfPhKnQWIAMOOhh455nD6tbuTv+UHrxfXabK7pdTaxsdN+9djmzfmClTusqJKRpG5GprrPRo8LLlt8hBWnsWktO3deQosQydvWt9juUhE1jVtr4R9n90M8ESK88mlY+UTw/czXoP8Fx1+H9nw5m6pp+vogOoK2A/u4JEInpiAaj5xFPR4PK1asYNPWrcFoIMAaHs6EUaPo168fev2hBxZFUflh7l6KdzYgSBAyw4EjpooWXwstTYUUNLrYEnczsmTFqDTR2/sFFq0eSZCw6q0YPBK6KhmL30iIYqPF3MZayw7CAy1c3OpksjOBUmU0xaRSKQZoFl2d9w2VBlMDlZYqas21tOnbOtxSBkGjv1lhoEkmzaRiat9VfamAeZOIebuI5DhMaCpBIE6Pf5geX38FX4QLxM6mG0HQEcxWLHO4FQYV8IHoAdEBkkNAbBPReY1IPgktEEDR+1FDQAnVUCJAjvp1t1KQyPTAZs3Eam0nNNZMjMa4LlfS/+foIjjHwZ9FcFwBF2sr17KqfBVrKtfQ4mvp+E4v6hmdOJop6VMYlzTuqLk2vAXNNH9VgNIcJA2WgTHsnxDP06VVbHQG/dN6OcDgknzODTNxyuTJhIeHH9HPz3AH3CwoXMCbu9+kyRvU3Yxr1TGjchDlzql41DAAzHY9/Sen0HtcIgaTjtbWVjZu3MjmzZtRlKCZfMCAAUyYMKHT8dI0jV1OD/OqG/m6roVWOdhW0jQm1MqcVxqgX4uCLtSIZVAM1sFx6CL+PVmTFVll/mObaa5x09u8mHFjHHDGG7+6TsVNN+NcupTwv/2NuAfu7/i87vVd+EscFJ2ayAU4kDV4pkcSFyf+IincNzejbfuIFv19uNqGAnAwdjVyn/cJMZ3HnoUn4XEGSOwRxrSb+qHTB2edvLw85s+fjyiKZF5wKfdWtuBRVbqbjbymtKK/4jIEo5HuS3+k2uRlxtczkDWZd055hyFxQzoNweerY+2aiSB62L9/JM3lKdx4xRWEdu/2q/t++7bv+MiRhJ4AXw3oyZCwY/8u5OZmik6dQiNR7B70d2RVJDGyntN0N6LvNqKTFUdV/WzaPA23+yBJSZeQlnE/d+0t5dPGYOK6MwQjs8f2xHi8XCOaBj/cBxtfDYYAn/MBZE//9XUIXqM/fZhP8YZqBtj1xLZvRrTqsI9LxjYiHkHfmei8UV7H07lF9Kk8yODaUhR/MNRVr9eTmZlJVlYW3btnsOajgxzcUY+oE5h6XV9Se0WCqqKtfZG39u/jn92vQxUkhpoF3h6YQ7QhSI5Ud4CWb4tw7wiK1nWxFsLPzKTNf5CSJfMpr1WpEMJpEHxH6Gh0RpHWCAetYQ7aLG3odXp0og69GHy16CzYDfZOS6QpnDDBid5XguLOw+spxuOqRL8/gHmriGm3iNT2i6hUnYa/m4YvW8XbS0U+0kP+B0DEZIjHbE3FaumOxdodq6UbFmt3jIbYLiLThaOii+AcB/8ODY6iKuxp2MOqilUsL1tOcWtxx3cmycSE5AnMypzFsPhhiIe5AlS/guPHUtrWVYIWvPlFXpTDFknh4YJydrVbdCLaWhlXtJcze/Vk7NixGAzHfhxq87fx5u43+TDvQ2RVRgdc1ORhQtVg9rhn4VSCOV0soQaGnd6NrBHxiKJAc3Mzy5YtIzc3Fwje4CdOnMiwYcMQfzEheRWVJQ2tfFjVyLqWQ5lacxwK55f4OalGRqeBsXso1iFxmHtF/al5d34Wk5p1bVwQcS2mM5477lN/29p1lF95JaLdHhQbm83IjR5qnt1KiwEuPjmcqoDMzJhgjalON+DKbahvzqAxcDc+tR8qGm/FfElTj2KmUUXpT3cjuyOITrEz89YBHZXLfT4fr776Kq0OB01jTuZzMUh8x4XbeaNXKqE6idLzL8CzcycRl17KcyMaWFKyhDGJY5gzec7RdoPCwtcoLXsOv99E+apLufrJO351v2XZyZp143lOuYZtwlCi9DoWD+5Bsuno11T1Px+iZf58jD16YHr2Hb6bs5eATyHRsJfTwh5Df+nn0G0cAKVlb1FY+CR6fQQjhi9Hrw9B0zReXV/EEz4HqiAwyGLi3f7diTEe250LBEnOwhth50fBekYXfAbdJ/zqKrlrKln58X4EAabf1I9IRcOxpBi5MfjAINoNhExIDoaU60UW1bdwxd4SNODB7glcERvK9u3b2bhxI62trR39CgjofKHoFRsDx2aRM7Ab0VYd6nc3c7fQh3nxQf3SuTF2nslO7yBwnvxGKr7cS7OrhVbBjTtJpJVWqupq8GpHil3C9XZSk1LI6NeT9MzuWK1/TAZyTVPx+WrxeMrxeCuRK6uQ80pR8itQ9lejVTugxQtKuzbHHBTzyrHtrzGghmloBlCNGpoRNGNQ0CtqekTBgCiZ0OlsGMxxmMJSMFkTMBijMRkTMJtTMJkSEH/Fhd+FLhwNXQTnOPh3i4w1TeNA8wF+KPmBJSVLKHeWd3yXaEtkRsYMZmXMIs56yAHuK2ml8eM8VGcAwSQRcV4Wxp7hfFrdxCOFFbQowdPWo6aM05oqOH/6tF91WwGUOkp5dsuzrKoIZpDOUiWerKxCdo5ki/sCHIGgRSIy0caoMzNIzokAoLy8nB9++IGKimA0SXp6OjNnziQ0NPSo29nX5uGtinq+rG3GpwbHmRiAiwu8TK8IYNBAMOuwDozBOiwefczRM8f+XjgaPcx7aBNyQGVy6Ev0NK+AW/dB6LErrUO72PiUUwmUlxP/+OOEnXkGjmWltC4r447RdlZaoZvZyA+De3TW3agK3pevpLl6OgrRyDqFR+PeYG94ER9PnM/qf23H0xKGJdzFefeegtl+iDgsXbqUVes3sKHPMHLDg+HnVyRG8XBGIrp2t97PUV6aycjVV8s4rCKfT/+cnhE9j7ofmxd/S63yIBaLg4b9kxk4+BEyhxw9hQJAcfErFBXPRjDn8Lj0LLkuL9lWE98OzMSm62zd8OTmUnLW2aBppH74AZYhQ6g+2Mq3L+8k4FVI0OdyWo8vMVy/DJ/cyIaNJ6MobWRnPUlCwiGBt6ZpfPPxbm6PUXHqBeINet7uncbA0ONM4IoMX1wGed+A3gIXfnlUYTNAbbGDr57fhiprDJ/ZjUGnpgW3rWi4d9TiWFaG0hJ8YBDMOlzZYdxqcLMtROTixCiePiwcXNM0qqqqyMvLY9vG3XhkxxHbc+sNLOs1hKrQaARNY0pjOWNcTQT8fjweDx6HC5/sRzuGYULUBKI0G3Eh4aT07EHm8F6ERh/bQvtnQ1NVlNZWlIYG5MYmUDuLngW9HjE0FCksDCk0FPHfkIqjC13oIjjHwX8yikrTNPY17mNB4QIWFS3CGQgmbRMQGJc8jguzL2Ro3FAEQUBx+Gj8KA9/WTDkM2RyKvYJyTQrCk8crOLj6iY0wOLzMDF/O2dnZzBx4sROOoGj4aeyn3ho/UM0+5oxCjrucPo5s66Gve6pbPX8DZ8cnIBTe0cy9rwehESZ0TSNrVu38uOPPxIIBDCZTJx22mn06dPnmNtp8Mt8WNXAWxUNNLYLk2M1gYvKAsw84MHU/sBqSA/BNiwec++oP0SY/P2c3ZTsbiAhUWGmfBZCVCbctPWE1m14cy71L7yAuV8/Uj+dR82zW5lvVXgqx4RBEFg0qLPuRpNVHB9+h3N/KCCihGrcEvkUB43lPDb0Cfxfx1FX6kRnbiJt0guMP+lrjMYYAOrr63nu7XdYnD2EupAIJAGeyEzikl+4vjRNo+Tc8/Du3s2q3gJlt8zkiTFPHHX8sizzr0ceQRdZTe8+P6GpEhWrHuWMv59OSKT5iPaBQCvrN0xAllvp1etF5NBTmLLtAPV+mcmRIbzfJx3p50leVSm94G94du4kZNo0Ep97tqOfmqJWvn1pB36vSrw+j9PONbLPuoam5rWE2PsyePCXR4iW5UYPW97Ywa19jJTYJAyCwBM9krgw4TjZwGUfzDsPDv4UrD5+5lzImdGpidvh5/Mnt9DW7CO9XxRTru1zZHJQWcW1tQbnigqU1kNasnq7RPrQREzdgnmffs6joygqP76VS9GOelSDhx6TrCh6N3XF+9jpVfk2ZzQukwWDHOCkfVtIbq476vAFDeyamVDNQqhmIUwTSTC1kDxqMLYxI49wmXWhC104hC6Ccxz8p8PEf4ZX9rKsbBkLChawuWZzx+eZ4Zn8LetvnNbtNIwYaPn2IK5NwcSG5n7RRJzTA0ES2dbq4sZ9JRR7g9EUfSoOMqW1hnNmzjhqWPnhqHfXc/+6+1lftR6AccZYHivYgSlgZqvvYvY4J6GqAjq9yJDp6fSflIwoiTQ0NLBgwYKOiKvevXtz+umn/6qLzK2ofFzVyJzyOqp9wbFGiSJXNsD07a0Y2x8MRYsOy6BYrEPjOlXp/i0o3lXPotf2IIoC545dRUT+bBhyFZz23AmtL9fXUzBhIsgySW9+xvZVDi4eYcEnCTySkcDVyTEdbQN1bprm5RKoDro7jCn1XBH1LsWeEqamnMbI3edSkdeMyaqnx9QP8QvLSUm5ksyMe9A0jUc//YL3wpNwG82E6STe6p3G6PCjC9E3Lf8I2w2PIwKWN18gdezRs4NuXLKEJRs3YvJ4mDy9hFb/Vlw12ciV/2TmbYMQf1EV+UDBY5SXv9seOfU9giCxvdXFGTsL8aoaVydF80hm0PLV8vXXVN99D4LFQvfFi9D/IrFmbbGDb2dvwueXSMmZh6X3T4iiiaFDFmK1di5E+TOcqyuo/KGYh/uZWREddNtdGB/J4z0Sf12X43fDV1dB/neAAKc8ASOuB0BVVL75104qD7QQFmvh7LsHd7gEj4YWX4B7f8yjX7GLybVyx/UIgBjMpaNPtlNY0EpluZOAKDD0rEyS+0SgrnuNdyoqeTTjfGRRR6qm8ZhDJrrJjbfFhb/Fg04WMWg6jOgwaHpMSJiEg5jEbZgi6jFMuRwhe8oxBfBd6EIXDqGL4BwHfybBqS12EJlk7RCQniiKWov4JO8Tvjn4DR45GGIZbgznopyLOC/rPMSdLpoXFoKiYcqOIPKCbAS9iEtReKSwqiOZWrjLwUn7t3PBqOEMGzbsV4V6qqbycd7HzN42m4AaIMUcy6sNDtLq9tMsJ7BKvp/KlmD0VFSyjfF/yyI2LQRFUVizZg2rVq1C0zTi4uI4//zzj+my+hk+VeXzmmZeKq2lzBsUbsbrdVznM3DqlmbElkN1S4zdQrEOjcPcK/KEn2gDfoV5D23C2eRl4CkpjKg8HxoOwLkfnZAg9WdU3PJ3nD/8gPHsh7hkSAYFdokJEXY+7tsNURBQfTLOlRU411SCrCLiICxqAY8MCuP7sh9ItCZyc/NTFG9rQmcQmXnrQCT7NnbtvhJJsjBq5Bpe3FnGbEcAVZTIMOn5qH8Gaeajm/g1TePc785l9Cd7OWmHhjEzg/SvvkL4haUuEAjw4mOP4RIEhre1MfaRG9i4aSqa5qdu11l0y7iGYdMPiY1driI2bZ6Cpsn07/8+kRGjO75bWNfMNbnB4h5P90jiwhAjB6dMRWloIOb2fxB55ZVHHWt9cTOL584nfsJsREmmW9pDpHc7do0vTdGof2s33mIHH/a18kp8sObOALuFN3unHVMHBARdJovvgi3BUhEMvwFOfoy1Xx1k17Jy9EaJs+4eTMSvhKL7VZW/7S5iTXMbcQY93/fuRliBA+/+JvylDhTHsWvptEnwWG8Ty+KC52FSTYAH9nqxHZG+RkMyuDEbN2H0rsUg5iOFWGH8PdD/byB1hTd3oQsnii6Ccxz8WQSnrdnLvIc3YQk1MuGiLBIywn5zH62+VhYULGBe/jyqXMFKxHa9nfOyzuN83Ux8n5WDrGLMCCPy4pwO8/nyRgd/zyulPqAgKQpjC3ZyRlQIp59++nHLVOQ35XPLT7dQ5aoixBDCi6GDGLL1YzRFJl84m3WtF+DzBB8w+01OYdjp6ej0EmVlZXz66ae43W5sNhvnnXfecS1HAAFV49OaRmaX1FLVbtFJMRm4xWhj8m4Hgf3NHTVNBJOEpV80lkGxwTIRv0LYNnx9kO1LSrFFGLngtlT0r/QKRtzcWQTmE9cyuDZsoOyKq3njH6/zaTcrkaLIyhHZROl0uLfW0vpjSTCBHGAUtxOhf5GVk67g78Xz0Qk6HuRVqtZ7EUWBqTcEo2s0TWPzlum0tB1goe0FvnIFj9MQ/MwbM+gIrcvhWFa6jFtX3kp0wMyctyW05hZi7riDyCsu79Ru3ZIlLN24EbPbzfUXXIC9f38qKj9h//4H0FSRshV3cuqlZ5GQGTwWO3ddSWPjCqIiJ9Kv39wjtju7pIani2uQBFi48lusn36CIS2Nbt8sRDiGxU5RPGxYPRmfVoOzsj++opuZ8Y+RmGy/kg/K4aP2pR2obQF2jIzijnCZFlkhRCfydI9kZsX+yrnTNFj/Eix9EABn3MnM33URPs3Gqdf0pvuAmGOuqmoaN+eV8UVtM1ZJZOGAjM5h/4C3zs3md3NRq11YdCLxCVb0SoD8gIs7+4ZRZpXQqRq3lilc0ASSVY9o0eMvaUV1y+jEAiIjP0Tv3B7s0BgKo26G4deD4Y/VnnWhC/8/oIvgHAd/FsGpLmxhyZt7cTv8IECfcUkMn9kNg+m3P6HJqszi4sW8vedtDrYeBMCsM3NT+FVM2JADARVDaghRl/VCbO+/0S9zc14py5uCup5elUWc3lrNBeecQ3R09K9ur8HTwC0/3cLuht3BSTr7EmatfxeaS3BrEayzPMeB4uBEE5FgZfJlOUQn22lubmbevHkd9cJmzJjxq7qcw+FVVD6qbuSl0lrq/EGNTk+riTtjohhV0IZnW12HCBRAF2PG0jcac9/oI4TJTdUu5j+2GVXRmHJtH7qxDL6+FhIGwtUrTmg8P0PTNObd+y9uO3k8AB9mpzGqXsa5vJRAjTs4lkgTofp3MDV/QmvWKUyUCwmoAW4WH8a/LgyAyZfl0HPYIeH4jvLF3FTgoFAIioPH1BTz0ZmnYfwV956iKpz17VkUthRyTd9ruLAoger77gu6ib7/Dn17fqJAIMDsxx7DLQiMbGrm5Jf+1bEve3Nvoa7uewKuCOo2P8Y5d0/E5d3Azl2XIQg6hg1djNV6ZBi5pmnclFdGwZp1/6+9+w6PqtoaOPyblkmf9N5ooYZAqKFJ7yBFqjRBRAW99vKpF6965V7LtYCgIE1EpVjoCChNeosEQgkQUkjvk0ymn++PA9FIQggCwbjf55knQ+aUPYeEWeyz9lq8/+FbqCSJ0EWLcO3a5bptrzl79lWupH+N2qolafPLlBqD8Qp0YciTrXD1rDrQNl4oIHfxKZCgZGR9nlWWcqxYvtYP+HvydmQI7jcIAolfi/T9oyjsFkpsXqQ2+hdNJ02qenvgjQvpzE/NRq2AL6Lq09O74r8FJoOFjfNOknmpCLWDkoGPtiTAI5W5O1fxQcBwLEoNQSqJhdGRtNW5IEkShiNZFKy/gNZ+AnftGrTSr/LB1E7QYQZ0/gc4e91wXIIgVE0EONW4k7eojKUW9n17gbP7MwC5mF6PCU3KVyTVlF2yszNlJwvjF5KQJ/fnamVuyr9SHpc7+ga74jutRXl3a7sk8b/LWbx/ORMJ8C/KY2DiCSYPGUyTJk1uPHarkdf2vcbWy1sBeLjpRJ68nIAi4XsAkjynszN1KGUlVpQqBe2H1KN133AsFjPffvst58/LfYp69epF165db/o9Gmx2lqTlMDclu7yWTht3Z/6vXiBt8q0YjmZhOJUH1t+W0ar9nXGO8sGxuQ9qfyc55+JcIRFR3gx8vCWK7x+Fk9/UqLz/NTlmC/ftikdjhf87kU1XyaN8xkbhpMa9Vxiuqo0ofnwBycGVB+s3Jt6Uw/22SQQebgNAp5ENad3nt1VtW3IKeepsCkVWO85SKcMzNzKj7UNE3qB7OcCmS5t4ae9LuDm4sXXkVtzUriRPmEjZ8eO49e1LyNVA5pfNm9lx+DDOpaU8NmoUbu3blx/DatVz6PD9GI3J6K9Eoy19Dc9WL1FquEBo6FQiG71S5flLs7M5NXQY7oUF7OnSk+GffFjlcu6cnO2cjJerDLdu8F9Y/Bbrc1+h1O6Nm5cjQ56Mvq4P2O8V/5RC8fZkFBolno9HM8+o58PLWdiBUEcH5jUNo4OHa6X7Gkss7PzPCjryLp5qeeaTmEnQ99/geP3v+Gep2cy+IG/3cdMwRgdU/P00FJtZ/3EceWklaJ3VDJ4VTUHZEf5xqYCTro0AGOCu5t2oJvg4qLGbrBR+l4g9fhNu6tVolVerGSvVEDMZuj0P7oFVvndBEG6OCHCqcTeSjFMT8tn55Vn0+XICaov7guk8siFqh1tbISFJEnuv7GXuibmczT9LPWMwc1L/gc7qiibcDb+HoyrkqmzPLWJmQjLFNjtOZiP9Ew4zpVOHant12SU7n8R9wsKTCwEY32Q8L6kCUGx9CaxGylyaslPzLkln5Q/8gPo6+kxthquXlu3bt5c3RO3WrRs9evSoUbGuQouV+SnZLErLoezq8vL7PN14qX4g0Q4OlJ3KpSw+F+OFQrD99mMraVVc0VvIl6DTzJbo6utQfNAM9BkwaR3U735T55fsEuaMEhbvvYRXWimdcm3lrUuVrhpc2gbg1i0YpSkd5seCpZTVDTvypi2dGMN9dIgfgWSHVr1D6fyA/CFostt582I6n1/tOh5uyeEp9T/xsRfStetOHLUBVYxGnsW7/4f7SdGn8GTrJ5necjoAxnPnSBoxEmw2QhctRNuxIx+8+SYGpZJORUX0/eCD646l15/myJGRSFgoTmuNe8gJNBrPq7VpKs+dkmw2UqdPp3T/AdKCQ3n4hTdp5OXB960bVlwmDxQWHSMu7iFsttLyRGp2vE7x7i/ZUPgmhRZ/HF01DHkiGr/wyn/nJLtE7tJTmBILUfs64TerFUfLjMw8k0Lq1Zyt0QGevFI/CP/fBVk2q50NH8tJxZ4+MLrDVtTHFgIS6EKhz7+g6f3luS4/ZBXwaIKcX/RK/UCeCK+YLF2cV8b6j+Ioyi7Dyd2BfrNasiZlN++bArAoNXjYDLzdOIzhIcEoFArMl9IwfrMAJ+N6NMoU+b2oHVHETIZOT4BHaJV/x4Ig1IwIcKpxt1ZRmY1WDq67RPxOuX6Md7ALfae1wCvo1ot12SU725K38cmJTyDbzLvJz+Bqd6Y4wkqTh++rUPb+cpmJh+KTOFNqRGW30ePscSY0CKVv377XFer7ozXn1/DGgTcAGNN4DP8XcT/K1ZMg/xKSyomzjReyd78Oi9GGg5OaHhOa0LCNX3nDSIAuXbrQq1evGlckzTJZ+CA5i5XpeViu/ngO8NHxQr0Amro6YTdYKDuTLwc7FwvB8oeS8g4K1JazaFRX0PSciMrHDYWDCqWDEoWDCoVaib3Mik1vxqY3Y9ebsWQZMCUVIxmtFY5lzTmLvSieiC/fQ+noIOd8rBgGl3aR6dOQvq4mQkqaMvjsY0hWaNIxgJ6TmqJQKojXG3j6bCqnSuSk8VFOCjx+/J420Vtxc8/B328wLVp8VOV1+D7xe/65/594aj3ZOnJrherXWXP+Q/7y5ah9fUl/dAY7ExNxLi1l5kMP4dKsWaXHS0v7knPnZyNJcj5VgNdLNG81vcrz5y5YQM5HH6NwckKz4kuGFtrJs1jp4uHKyuj65auciopOcCJuCjZbCZ6enWgV/TlKpRZMJfBpF8ry8tho/B/Zxd5otCoGPBpFaNPKZzRtJWayPz6BrdiMtqEHPpObo1dIzL5wha8z5GrcLiolz0QEMD3EB41Cwa6vzpGwNx2NVsXIF9vgHeQKl/fBuseh4LJ8YM8IiJ3FvvD7GXsmA4sk8XCID282DK7w85mZVMSWBfEYis04eWuRJkbwSfpl0hXy72w/y2Xe6dIHfydnpJSDWLcuQJ2+BYVCDsAkjSuK9g9D7ExwrTr/RxCEWyMCnGrc7WXiyafz+GlZAmV6C2qNki6jG9GsS9CfKkVutVtZf3E92/du4PnEiThIGo4EnKXB+Pa09Isu367UauOxhGS25cmFydonJTDOWcnIESNuuLQb5A/Y2ftnIyExKnIUr0bPRPndI3BBDmCKo19g2/m+ZCXJOT/NugTRZXQjjh47zI8//ghAx44d6dev3y291+QyE+9fzmRtZgF25Kr1Q/w8eDrcn6auck2XPV+d48q+dEI9HIgMccWcpq8wu1NTpSqI81ThapXo3NKf7DcnYSsoIOi999ANHgTHV8D6WdhVDgwP8kdvDOOBc88gmZXUi/ah/yMtMAHvX85kQWo2Ngk81SrebxjIma+Wo9fr6d69Pjb7m4Cd1q2+wMur83XjMNvMDP5+MBmlGTzX9jkmN59c4XVbSSnJ48ZiuHiJTUMGU+bkRGezmT5vV14fB+RZwP0HemA0piJJkHfyUQZPfRIX3fW5MaWHD5My5SGw2wmcMweP4cP4VW9gxIkLlNrsDPH14NPm4ZTq4zl+YiI2WwkeHh1oFb0Ylep39XbSjsLivphtGrY4LCctzQGlSkG3sZHl3byve++penIWxSOZbfKKwQlNUaiUHC8q5ZXEK5zQy7k59Z20jDCo0axNRS3BoMdaEtHydzWETCWwfy4cXghlcnCUp9HxZcBgLPV78EyXwSg1v4313KFMdq44i9Vq50qUG3taOXHxam5YsDGLV7TpDPfVobj4E1LidhSlWeX7WjUNUN73CMo2Y8HJo8q/A0EQ/hwR4FSjNurglBaZ+GlZAqlnCgBo2MaPHhOb3FIC8u8ZLAZ+/PE7Yn4JRYWSr723kNfRzjNtnsHPWf4fpE2S+NeFdBam5QDQODOZcaW5TH5wPE5O1xd/+731F9fz6i+vIiExotEIZnd4FeXOf8Mv8m0QW73eHHZ5g+M/ZYEEngHO9JvegotXEti8eTMA7dq1Y+DAgbcc0J0vNfLfpAw25fxWKn+gj45JWlcSPohHkmDoU60IbeKFZLVj/fJJLBcvYa03EYtTa2zFJiSzHclskx8WO0onNUo3B1RXHzadA8+WFbJdYyU218YH8SaCX+lA3tKF5H48F22TJtT74hMUn3QEUxHzfQP5WhnCqLPPoTI5ENzYg8GzojlYYuC5c6lcLpP/3YHsyQAAT2FJREFURz/E14N/NwombvdO9u/fj6enJ48//jiXkv5NWtoKnJ0b0KH9RpTKisHmN2e/4d+H/o2fkx+bRmzCUX19Dy9z2hV+fPopjjVvjpPBwKxHH8WlftU9p3JydnAyfkb5nyVJgTHtIQZMeBnV7+rjWHNzSRo+AmtODrphwwj6z5zy13bn65lwUu4+/g/fPDrlP4fVWoyHrh2tWi1BpapkZdDVRpk2By92eKziwkm5lUezLkF0GxOJqpKWHcaLheQuPQ1Wu1z7aUxjFEoFdklidWY+/76UQc7V4MPJZGew2pnnO9cjrLKl9mYDKQeWwIF5hBkzfvu+ygGC2yKFdeLghSh2nvcgPtyBM5FaMq92p/S0FPGPlJVMKT2GY+El+F07BbukpUzqBh2n4ty/P4rq+mkJgvCniQCnGrVV6E+yS5zYkcKhHy5ht0t4BbkwYEYUHv5/frloxi/nsW2U/0c5338VP/kd4dHoR5nQdAIalZyvsPRKLq+cT8MOBBfkMDH3MtMfHF9tf5uNlzbyyi+vYJfsjIocxWsdX0Nx+ntYNxMsBvCJJLX9MnasLcBQbEalUdJ1dCOMzpls2LABkG9X9e7d+0+9x4SSMj5MzmJDduG1VeQ0TDczTOHEM+NaoFQo5FL+79QHUxE8/DOEtLmpY794LpXl6Xn42BV8vUtPUDMfvMc1wVZYSGLPXkiGUhrNCkede5BEZ3emujdg2NlncDS64hfuRrMZTfkoI5f12YUABGo1zGkUQn9fHdnZ2Xz66afY7XYefPBBGjVqhMVSzIGDvbFY8mjQ4AUiwn8LPIxWIwO/G0hOWQ6vdniVMU3GVDpmi8XCB7NnY3BwIOboMTp07oT/yy9Xuq3JlM2hw4OwWPIJDXkIY2kZOQXfAKAqG819A99GoVBguXKFlIenY05KwqFBA+qtWY3SueLP5w+Z+SxJWMU0PsWVEnS6NrSKXoJaXXkCMDYrLB0AaYeRQjtxPHA+BzckgQR+Ee4MmNECV8/rA7iys/nkrUgAm4RzW388RzQq70qfklbMK+sSOByuochFDkaUQFdPN2I9XGinc6G1uwvOKiUnig2MjruAwWrmGcMR/lF2GHXyfsoM+ZxybMoa9SPsDmpMsv9veT3ONgMz0tbwWOoq3G2/dfG2aetjKG2J0d4Gm2dbvMZF4RBSeXFGQRBuPxHgVKO2KxlnXipiy2fxGIrMODip6TO1GRFRPtXvWI3in1Mo3paMHTuvhM0lzuUcEe4RvNz+ZToFy/16fsorZvqpJAx2CW99IRPTz/H4+HHVXoctSVt4cc+LSEg8Hv04j7V6DDJOwldjQJ8OTl6UDV3Jjh3OpJyWbwc0auuHR4syNm/dBEC/fv2IjY390+/zfKmR1w9fYqfdhHT1A6+hs5apwT6MtqfguqSnXG/kxSRQVp/U/WNuEZPj5Wao806a6JhhxmdaCxyv1ovJmjMHy8+fEdK5AKtCySTvZrROfA5nkw5rhAtnBvqxPq+Ia/+3nxzkzSsNgnBXq5AkieXLl3P58mWaNGnC2LFjy8+bkfEdCWeeR6l0IrbjNhwdgwBYfno57x19jyCXIDYO31geoP7RnmXL+PnyZZzKyhi0YSMqux3/f76G1/iKTUUlyU5c3EPkF/yCq2sz2rVdi0LhwIkD71Fg/BQAJ/V9RHqOpGDmO1izs1EHBBC2ZAna+vUqHKu4OJ7ExH9TWHQEgEQiKQqbywsNGtx4hi4/CT7tAuYS6PVPUrymsG3xaUwGK05uGvpOa05Ik+vzcgzxOeR/dRYkcOkYiMeQBpQUmfju3WOUFJjwb6jDeUJ9lmXmsaegpMK+aoV8G+tSmQmrBN4aFd293DHa7ZwtMZJUZsL+h/N1LjnDA2nrGJy7GzelApoOhoAoLBY/8g+6YCmQE7JdOwXh3j+ivA6VIAh3hwhwqlHbAQ7It6y2fnaKzEtFoIAOQ+rRpn9E+f9Qb4UkSRSsTcRwLAur1s5zDT7gnCTX0Okb3pcX27+In7MfJ/UGxsZdIN9qx62slPHJp3hq7Gg8PW9cDG/V2VW8degtAP4Z+09GRY6C4gy5L1BGHKgckIbM5URWLAfXXUKyS7j7OuHbvpSDx34BYOTIkTddJ6cq+ny5oGKWWiJjcADbVWb0V7seu2FlSMZWhjka6DTs3+UNK6uSZjTT58g5Cqw2pjm68Ni6TFQ6LQEvtiv/u7CcO4JyeR9UDhIrpYakFrxCgbsPCc1dOB6g4lrh2oE+Op6/mgh9TXx8PN9++y1qtZqZM2dWuMaSJHHs+FiKio7i69uPllHzMVgM9P+2PwWmAt7o9AbDGw2vdNyWsjI+eOMNDFotXZ1diHZ3J+fDD0GlwveJWXhPm1Ze6TglZTGJF96utG3C3o3zMTl+gEIpXz9NkgLduUCaPPUl2qBw7HYzFksBJnMOaalfkJH5HSChVDqSoxvPcwW9MSu0PBrqy+wG1eSVnVgpJ/4q1TBpPUUuMWz5LJ68NDkwado5kE4jGuLoUjGgKz2WRcEauQSBOtydvZkGsrPK8PB3ZsTzMTi5yrf3LhqM7MzXc7iolCNFpeVtQW7E2WgnsExiYD1vJuevIWSv/PNNg57wwFJsdheKf7xM6ZFMkEClc8BzVCSODWuvCaYg/J2JAKca90KAA/Ly1l9WJ3Jqj9zXqUGML72nNLvlpeQAksVO9me/YkkrQenvyFcddrLiwkrskh0XjQtPtH6CMY3HkGayMep4IqlmK45mE6MvneTF0SPw9r5xo8O5J+ay8ORClAol/+v+P3qF9ZL7An3/CJyRb0fR9Tkyw2fx45IESvJNKNTg1jKXi+kJKJVKxo8fT8OGlfcmqvb9SRKb55/kcnweAfV1jHguhlK7nVWZ+SxJy+Vi2W+FAb01aob4eTDIR0eMzhkXVcXrarbbGX7iAseKDbR0c2LpryakxCLceoai6xshb2Q1w9L+cOUYh8ra8l7wK8TX01Ho+tuxenm580L9AKL/WAXXaGTevHmUlJTQs2dPunXrdt37KSk5x+EjQ5AkG5GNXuPHQisfHf+IMLcw1g1bh1pZeY7Wro8/Zld+Pk5GI0+99DIOOncy/zmbwjVrANA2a0rQv/+NJUTiyNGRSJKZxo3fJCS44uyOzWpjz79ex8F1FcbWNrh6OpXKFYVCgdWqv+7cAf7306DBczg6BrE4LYdXEuWf36nBPrzVKFi+VVgZSYK1U+H0d6B1hymbsHg3Z9+aRE7vlWvSOLlp6PxAIyLb+1cIlgwncyhYcx7JYsdolzilVNLrhba4eV1/awtga04hM04nY5Ikwh0deCjYBwWQnVVK6vEc3NKN+BXZiI0NInaAH5qNj8J5uf4TnZ5E6jmb0iPZFG1LRiqTc32cY/zwGNIA5Q36WgmCcGeJAKca90qAc03CvnR2f3UOu03CL8KdgY9FVbqy5WZZi0xkz5VL3ztF+ZDdT+KtQ//mZO5JAJp6NeWfsf/E370xY44nklBmRmO1MPzyKf71wLAbzuRIksS/DvyLbxO/RavSsrDPQmL8Y8Buh5/fKE8+pvkIjH0+4uevL5P0ay4SEvbwJPJNaWg0GqZMmUJwcOWraG7kwrFsflx0CqVKwZhX2ldYcm83G9j/6f2s9+7CxtD7yf9dTyC1Apq7OtFe50I7nSv1nBz4Ij2PFel5uKuVbI2sh8OHcSCB/3NtKPPQklBSRtyRtcTl53HErQVXnH6rl+KqVDLYz4OJQd600VWew7R582YOHz6Ml5cXjz/+OGp15R+MycmfceHiO5TZFbyd7YXeUsacrnMYXH9wpdsbklOY98k8DM7O3BcQQI9H5eJ6kiRRvHEjWW/9G1tREahVGAe6kN8rF5/A3rSM+rQ8aLAWFFD0/Q8UrlqFOVmuCZMd3oy8ERH4NjuI2ZL5uzMq0Wg8cHNtSv36z6DTtaownhXpubxwLg0JuVHmfyJDqp45s5TBihGQsh9cfGHqj+DdgIwLhez66hz56XK+S0gTT9oNrkdgAx0KhQKbxc6Oj04QllWKm0oBCtANrIdrl+DrZo2WpOXwauIV7EAPLzcWNgsn/3wRRzclkXlJXk3o5uVIz8lNCfHIgDWT5Z5lKi3SkLmYnPtStCUJS4Y8Fk2gCx5DG6Ctd+Nea4Ig3HkiwKnGvRbgAKQnFrD503hMpVZcvbQMnhmNd3AVSZs3wZRcTM7Ck2CTcO8Xjmv3ENaeX8uHxz9Eb9ajQMG4JuOYEjWTmWcy2F9chtJuY2jyGf4zYjAeHh5VHttqt/L0zqfZlbYLNwc3Vg5cST3d1VyNE1/ChqfAboGQdkhjvuLUMTP71l7AarVS4puAUZWPi4sLjzzySLUNOn/PWGrhq38doqzYTNtBERUaRwJwcadco8YtCMtTp9lbWMK67EL2FujLe15VRqdW4WWRKDFZMWiUGFTlrbAqUNglIq+U8MCRzTw051VcXatOzr5y5QqLFsn9nSZOnEiDBg2q3FaSJM6ee5UlZ9aytdiBCLdgfhi2CVUl+UOSJLH9qafZ7+mBk9XKM7Nno/lD001rbi7pr79G6Y5d8j5K0Pj7owkOQRMUBFYb+h07kMzySi+liwtuo8eys6QThTlGvIMd6fOoM47Objg4eKFW61AobrxCaFVGPk+fTcEOdPV05dNmEXg7VDHTYSyCpYMgKx48wmDqNnAPxGa1E7cjhSObLmO7WtvIO8SVFt2CSEnIJykuF61WxYAoL6QLhQBogl1x7xGKYzNvJAW8eTGdBanyasEH/Tx51OJM3JbLZCfLM1EqjZIWXYNpPzgCh1PLYNurYDUiuYZiaLWYklPq8nYcCkc1un7huLQPRKESnb4F4V4gApxq3NEAx5APNgu4+Ve/7R8UZhnYNP8khVkGNI4q+k1vQXjzG98yupGSwxkUfncBFOAzpTmOjb3ILcvl/aPvs/HSRgD8nP14vt3/8U1hGFsLSlFIEv2vnOej+wfc8NqUWcuYvm06v+b8SoR7BF8O/BKd9mqwkrQXVk0AY6H8ATZ+DXmWELYtPk1uRhGFXr9i05QSEBDA1KlTq63Hc83OFWdI2JeBh78zY19tf/3y4u2zYd+HED0Ohn9a4aU0o5kjRaUcLirlYGEJZ0uNlQYxvxdgziOyIANVdjhBeRLNtRo67HwbZeoFfGbOxPeJWZXuZ7fbWbRoERkZGURFRTFy5Mhq31tBWR791vaizG5jmp8DM7r/gJPT9RVw8zds4PM9ezC4uNC7XXu6DBp43TYmcy4nTkzEtjcR3RoHVEWVv1Nts6Z4jh2LbtAglC4uFOeW8e07xzAUmwlq5MGQJ6NR32Qnd4CN2YU8eTYFg81OsFbDkqh61922K1eSDUv6Qf4l8G0KD20u79FUlGPg+NZkzh/Owvr7Io4KaNk9hEbt/XFM01O6LRnp6uulQc683dqZIwUG6mda6FesRJtahsUkT+OpHZS06BZMqz5huKhLYP0TSGc3YZXCKfN4kJKybtj18q0ohYMSl3YBuPUIReV6cz+bgiDcHSLAqcYdC3AyfoVvJsil2SetLy8NXxPGUgtbP4vnyvlCFEoF3cc3plmXoFseUsH3iZQeykTposH/H61Rucu3vg6kH+DNg2+Sqk8F4L7Qnpg8p7OhUP5HvkdmEp8N6nXD65Nblsu4TePILM2kU1AnPun1yW85I7mJsHIUFCTJ+RYPLMUS3oN9ay9wct9FCrxPICktNIiIZMLkcdXWyLlyvoAf/ncCgOHPxhDUyOP6jT7rJv8dDF8I0ZUvrTbb7Qw9foE4vYFWrk4sbBFB9uUirqy/gItCQcSMaNw14PDlMJIS/dmvnwwoCW6uY+D0aIy7dnDlqadRODrSYMvm8maXv3fw4EG2bt2KVqvliSeewNW1+pm4j45/xOfxnxOi1fCMbxGuLg1p22Z1hTYKtsJCtj4ygyPNmuKsVPL0yy9fN3tjNGVy4sREDIZLODj40Tp6OVqDB5b0K1jS07Gkp2MvKcWtV08co6Kuu+65aXq+f+84ZqONkCaeDJgRhUMNck7OlJQx9VQSSWVmtEoF/40MYWxgFUF6QbIc5OgzwD8KRi8H799muopyDKz7MA59nvG6XRVKBTofR+wGKyVGKwYFqG0S6j8si3Jy1dC4vT8tOwXi6KBCunQIy0/LMZXWwyi1wi79tnJL6eaAa+cgXNsHlPd2EwTh3iICnGrcsQAn9wIs7A5mPXR5BnrPvqXD2Kx2dn15lrMH5TyItoMiaD+43i0VypMsdrLnx2HJKEVbX4fPw1Hlq4OMViMLTy5k6amlWCUrTmpn6of/i10WuT9Sx9w0VgzojtsNPqDP5J1h8tbJlFnLmNB0Ai+2f/G3F0vz5JmclP2gUEKfNyB2Fpfj89jy9QGyHI6DQqJhQEvGTru/ytkCs9HKqrcOU5xrpFnXIHo8WEnT0NJcePfqh+Oz5yudQZMkiWfPpfJVRj4eahXb2zUm1NGB/DXnMRzLwrmtP14jGmJaM5WDh3w5ZRgAQIPOXvR9MBqlUoEkSSRPnEjZ0WO4DxpE8PvvVThHcXEx8+bNw2w2M2jQINq1a1fltbsmryyPAd8NoMxaxntd/oVL5vuYTJk4OobQOHI2Pj49AUh99VW+NpkwuLjQv08fOnauWAHZYEgm7tcplJWloNUGEtP6S5ydI6o9/x9dOVfAxvknsZps+IS6MnhWdI1ywoosVp44k1JePfsBf09ebRBEQGVNOrMSYPlgMOSBgxsM/QhajKS0yMSGub+Sl1aCxlFFu0ERmEqt5KTqyUnRU6av+pajj1qBn1qBn1qJu4ob/96olWjrueMc7YdzK18UalGsTxDuZSLAqcYdvUV16jtY+5D8fPwaiOx7S4eRJInDG5I4uvkyAE07BXLfg40rVJy9WZYcA9lzTyCZ7bj3DsO9d3iF1y8UXOBfB/5FXE4cAB4+00h07g5AdHEua/t0xs256orH2y5v49ndzwJcv7TZaoZNz8CJFfKfo8fB4A8xmlWsWbyVi/nHAAikNYPHdyM48voE52u3ply9tIx9rQPaymYU4tfCt9PkmYDHfql0nNc6SCuBFS3r08vbHXuZlYy3DyFZ7PjOiKLg0Pvs+SWUHGtDJOw0G+xDj0HRFT4kjQkJJI18ACSJ8K9W4hwTU/7a6tWrSUhIICQkhKlTp1bb8wvg3SPv8kXCFzT3bs7Xg76mtPQ8cb9Ow2SSq+76+vQhxDCU/W9+wtF27XDRannquefKZ29KSy+RnPIZmZk/IElWHB1DiWn9JU5OIdWeuyrZycVsnPcrZXoL7j6ODHmiVY0KUtoliQ+Ts3g3Se5q76RUMivMj8fC/HD+489w0RX57y5FbtRa2GQWG04NpDjXhJO7A0OfjMbnd8X0LDY76y/lsOJkOulWKxa1gvuDPXk83A+XEiv2TAPmND2WND3W8tkfC0rKUCiMKF01OEY3QdvEF224DkUllZQFQbg3iQCnGnc8yXjz83L/GydPmLH3T3UTPrXnCnu+PockQVhzb/pNb35L7R1KT2RTsOqcnI/zcBSODTwqvG6X7Hyb+C0fHPsAvVkPjn3I9Z2ApFDSuKyY9T07oHOs+n/xC+IWMP/X+aiVahb3XSyvrLpGkuTrsfVlkGwQ3BbGfAnugXzzxXecvXQS7Eo881vRuGV9Oo1sgLu3HFAlncxl8/yToIBhT7UmuHEVK7x+mAlxX8rdm/u+dd3L268W87MDbzQM4pFQuY1Fyb4rFG64hMrPiSuucRw7HowVLXZVKa3GhdC1S+tKT5fx2msUrlmLtkkTIlZ9g1Kr5fz583z11VcoFApmzJhBQEDVncKvySrNYtD3gzDZTCzovYAuwV0AsFpLuXx5HimpS5AkK5JRxdGD92NUutC5cygxMY0ABenpq8jO2cq1tGhPz040a/oOjo7X3zqrqcJsAxvm/kpxThmOrhoGz4zGv17Nfl+OF5cyOzGdI8XyiqRArYaX6gUy1M8Dp98HOjYr0s45nN9+lN3F07FIzrjrJIY+0wGdvzyDaLDJ5QA+Tckm+Wp38WCtho+ahtHF8w/VhEty4NevsB9ciqI4FYXCChFdYcB/wb/5rV8UQRBqlQhwqnHHAxyrCZb0h/Tj8of5Q1tAfevJikknc9m26BRWix2/cDcGzYzG2b3mx7t2K0bp5iDn41SSQJlblss7R95hS9IWNKrOZAU8jE2lJsxsYNN9bfCtIsixS3ae2/0c25O34+Pkw+rBq/F19q240cWdsGaKnHzs4gcjF2EL78qKL77kcnISKqsjHnkxaNQOxPQNo2mnQNb85yhlegvRvUPp8kCjyt+YJMH/mskVlSd+Lxdp+50zJWUMOZ5Iic3OhEBv3m0cgkIh327K+uAYJZkGTqrzyMi/mu/ieoYeT/ahWVhkldfSmpvLpcFDsBUWohsxAq9/vsb8+fMpLi4mNjaWfv36Vbnv7/3rwL9Ye34tMX4xLOu/7LrbKfrC05zcPIEkyY8LibFoHAy0a/cDKpWtwnY+Pr2JCH/suiXcf5ah2MzGeb+Sk6JHpVHSfnA9WvUORVmDmURJklifU8ibF9NJM8q3lpyUSnp6uzHAR0cfb3ccrbD7q3MkHpHbjQRqEujn8R56/zBOtHyEw36xrMo1kG+R37eXRsVDwT48GuqHm/rqrU27HZJ2w7FlcHaTvJIPQBcK/f4NTYfKbdQFQfjLEgFONe7KMvGCZPisq7wktuPj0H9O9fvcQGZSEZs+OYmxxIK7rxNDn4xG51uzHlZ2s43seSewZpfh2NgT7ynNq8xP2HdlH28fepvcYl8ygx7DpNHiazWyqXMrwpwrL65msBh4cPODXCi8QIxfDJ/3+xyN8g95F3kX5byc7ARAAd2ex9DuCT77fLH896EOwCGtEQoUqNQKbFYJjwBnxrzSruoVPdlnYX4HUDvCi5fhdx2ic81WBhw7T6rRTKyHC6uiG+Bw9bZR0ak8Di6KJ8lkwYYKFWYcA3+gxz9eJtwjvPJz/U7p/v2kPDwd7HYSHp1BfGEhHh4ePP744ze1Miy5OJn7f7gfm2Rjef/lFWe9rsp4/XVyV69m84jBlKmdiWpZREREJlarHputFJ17DOHhj+Dq2rja890qs9HKtsWnSY7PA8A3zI0eE5vgG1qzHkxGm51FaTksu5LLld8t21cDnqV21CY7WotEgJcDbsornLI5kOFQsYVJmF3Po8pUxrrbcXb2gMJkyDkLOefkr8bfGrIS3AbaTIGoURV+JgRB+OsSAU417lodnLOb4Ztx8vOxX0GTQX/qcIVZBtZ/LK8qcXLTMHhWNH7hNRu/JbOUrHlxYLXjcX8DXGOrXqFlsplYcmoJq48dICXwUUodnXG2mfiidQO6eFfeO+ty0WXGbRpHiaWESc0m8Xy75ysZRBlseRGOL5f/HN6ZK53fZsmqDdhsNlo3jSX3sDPGUvlDUK1R0qxLENG9QnH3qeSD6uAC2PqSPHMz8fvyb5dabYz99RJHikuJcHJgc5tIvDRqjKUW4nak8Ou2FKw2+cffX3MOp9CvaP3Y1wS53XzuSt7ixZxavpydPeVZo0mTJlH/Bh29f++F3S+w5fIWugZ3ZX7v+de9nv/VV2S98SaJjRpxvE0Mbm5uPPnkk9etnLobJEni7IEM9q29gMlgRaFUENM3jDYDI9DUsPK2JEnEl5Sx+nw2m7MLSa88XgZAiUQTUzqt809wX/4RBubuRY2t6h207tByNMRMhsCWNRqXIAj3PhHgVOOuFvrb9irsnwvOPjDzELj8uaaapUUmNs77ldzUEtRaFQNmtCCsWc1q5ej3XaFowyVQK/F/sjUavxvPBKUWp/LmlgXsc+5LnqsHSruVqb75vBHVG2UlBeB+Sv6Jp3Y9BcB7971Hv4gqbtfEr4UN/5AbMDp7czTyRTbGZaBQKPAsbomqVIezuwOGYjnfQqGAgPo6wqO8iYjywSvIRZ6BWjkKErdBnzeh85OAnK8x4eQl9heW4K5W8n2T+miSSrh8MpfLp/KwGOUPSR/1RTq4fkNSYBrNp/6Mn1vNqiubTCbmvfUWepWKhleuMObf/0bj51ftfmfzzzJqwygA1gxZQxOviivDSg8eJGXaw1iBLWNGY7Dbb3pV1p1UWmRi7zfnuXhCLqancVTRMMaPJrEBBDb0qHalnyRJpJzO59jWy2RckGdbClyVeLTzpX7XQEwqBSU2Gxa7RDNXJ6LcnHBRKiH9BGSdguJ0KL4ify3Nless+TYB38byV59GoL71KuCCINzbRIBTjbsa4FhN8tLx7AQ5B2D0F386D8BcZmXLZ/GknS1AqVTQY1ITmnS8+aRSyS6Ru/QUpsRCNMGu+D0WXe3yWEmSWPLj1yws8SLZW06ejTDvYX6rrsT4X5+I+79j/2PpqaU4q535etDX1PeoYlYj76Kcl5N5Egn4wWUSv5Z6o7BpaOJ2Hw8824n0c4Wc2J5M6pmCCru6eTsSWN8Nt7OLcFVk4jr4RZzDG6EvsfC/hDTS8srwNEv0MqrRXy5Bsv/2o67TZNDJZTn1tIfY3KAdPcauw9mh6srEVdm6dSsHDx7E2Wym34aN6KKiCF+2FEU1t6ge3/E4e6/sZUDEAN65750KrxnPniVl8hRsRUVcGjGcIw4OeHh4MGvWrCrbPdxtF09ks//bCxTn/lajxt3HkfqtfHH1dMTRVYOzmwNaFzVFOWXkpOjJTpaXeJuv9nZSqhQ06RhA677hNVqhJQjC35cIcKpx11s1ZPwKi3qC3QojF0PUA3/6kDarnZ+WnylPyuwwtB5tBkTcdK0cW7GJrA+PYzdYcesRiq5fxE3tt+3nHbx3pZCTIXKzTG3pPgY6J/JUq8do7PVbHojVbmXG9hkczjxMfV19vh70Nc6aKj7ErGbY/xHSnvewWK18Lo0jW+FDUEAQ06ZPQ3W1SaY+30jyqTwun8wl7WwBNqu98uNVwSvIBb/gIvxS36aFFIeEA3H1ptJ68pxbqjGUmprK4sWLARjVqxfqp5/BXlKCU5s2BP/vfTT+lVezPpZ1jClbp6BSqFg3bB3h7r/l+xT+8AOZs19HMplQtmrF962iMRqNDBs2jFatWtV4jHeSZJfIuFjI2QOZXDieXT4rVh2NVkWzrkG06hWGq6eYbREE4eaJAKcatdKLatd/Ydfb4Ogh36pyq34JcXUku8TBdRc5/mMKAM06B9Jt/M3XyjHE55C/8iwowHdGS7QR1feFkiSJzZs3sywth18atURSKFGZ09DlzmNIaDQzW80kzD0MkFdkjdkwhuyybAbVH8ScLjcOJE6v34frgVdw1V5iIQ9iQkvnCCf6jH0MHCv+PVlMNq6cKyB/zzpKLp1B79ISvWMT0vPLKFZBmaOS6EA3Qr2d0fk6ExpSQvGexwhPPQ6AVfIhm9cIfHUiihq0Iyg/v8XCZ599Rm5uLtHR0QwfPpySX/Zx5R//wF5aisrTk6B3/otr167XXb/JWydzIvsEoyJH8c/YfwJgN5vJevttCr9ZBYBLt64kDh/O3kOH8PHx4fHHH7+pmjq1xWK2celEDllJxZSVmCnTWyjTmzGWWHD11OIb5oZfuDu+4W54BbncUj0nQRAEEeBUo1YCHJsFPu8NGXHQqB+MX3XblqzG70pj76rzV2vleNFveoubrpWTv/ochuPZqDy1+P8jBuVN7Ge32/nuu+/4MS2Tn5q2xeDgCHYTbgXLcDEcYFD9QUxuPplIz0hOZJ/goa0PYZNszI6dzQORlc9epZ3NZ/1HcUiSxOAeSZQmfc1qoxwcjFNvo3H7XtDhUdD9IUfms/sgI46s+z/nYXsrjhSX4qRU8GXL+nT2dIPSPAp/mo3LiZVoJDt2IEMdi6LkcZy7tMBj8M0lBP/RtU7hLi4uzJw5E2dneXbKnJxM2lNPYzpzBgDvGTPwfWIWiqu3lvak7WHmTzPRqrRsGr4Jfxd/zGlpXHnmWYwnT4JCgc/MmThPmcxHH3+M2Wxm1KhRNG8uarcIgiCIAKcatdZNPPuM3C/JZoah8yBm4m07dNKvOWz7/DRWix2fUFcGPtYSN68bLE+5ym60kvXRcWwFJpzb+OM1quraL79ntVr5+uuviU9JY2fzdqTq5ORpbcle3AqWo5BMdA7uzJTmUzide5oPj3+Ig9KBlYNWXpdQq883svrtIxhLLDTuGECvyU1RWI1s/mo+h5P0OFHGDFbioTBAYDSEd4LwzuDTGOa14ah7M6a1/5Qsix0vpZ2vvQuJzjmINXEbyvQ4lFeL4B1ydqGk7fM03t4WJPB/tg2aGi61B8oL+gE8+OCDNGpUsT6P3WQi6z//ofDrbwBwqFcP544dcGjVkofMi0gypDLBbzBTLwRTsns3xlOnAFDqdAS/9y6uXbvy448/cuDAAQIDA5k+ffo9PXsjCIJwt4gApxq1FuAA7PsItv9T7rsz6wi4//mKs9dkJRWzab5cXt/JTcOAR1sS2KD6206mpCJyFp4ECbwnNcPpJldlmc1mVqxYQXJqKqcbRnEguAF2wIUS1Dmfoyk7hgKI9IjEJtm4WHSRMLcwVg1ehauDXJ3WWGLh+/8dJz+9FJ9QV0Y+3wb11WXHVquVJUuWkJ6eTohDCQ+ZF6OiYt6NUeGAQSUHcmoFuEpmlNaKzRkTHDTsbNSVkQMX4LinjJLdaWgb6PCdXvNlxHq9ngULFmAwGOjQoQMDBgyoctvizZvJeO2f2EvlKr7bWiv4vL8KtzL4eIEVF9Nv2zq3a0fgnLdxCAmhuLiYjz/+GKvVWmkAJQiC8HclApxq1GqAY7fB4r5w5Sg0Hw6jlt3Ww+vzjWxecJLc1BKUagXdxzehaafqg6jCzUmU7ElD6arB/6mYSqscV6asrIxly5aRlZVFcXA4O5u2JeNqtdkIZRam9A+xmtMq7BPtG82iPotQWjWs++AEOSl6nHUOjHy+zXV1bgoKCvj0008xmUzExrSgX4QdkvdhvbwPdV5ipWMqUCo56OTIfidHcgNb8EDbp+gZ1hPJZCNjzmEkkw3vKc1xauJV6f5VsdvtrFy5kosXL+Lv78/DDz9cbU0aa0EBhkOHyfn1MJM8v6VYa2PqjzYGnnXCpXNnXO/rhku3bhWWlq9bt44TJ04QGhrK1KlTbykBWhAEoS4SAU41ajXAAciMl3NHJBs8+C006n1bD28x2fhpWUJ5rZLoXqF0GtHghuX1JYudrHknsGYZcGzujfeEpjf9wVpSUsKSJUvIz89H5+dPUc+BLM4sxCJJOCjgPudsDNlfcT7vWPk+GsmBMeefxzXfD7WzguHPtsYv2KPS4585c4ZVq+Tk25Gjx7DbxYuPkrNwKMvHx5xPC/sp9MVbKDQWYFVAmlpNK/8YpkdNp0twl/L3od+dRtGWJNR+zvg/FVPeVf1mHThwgB9//BG1Ws0jjzyC303Uu7nm2rL5eu4RfN38XZwj6le6lDw9PZ2FCxcCMG3aNEJDb72PmSAIQl0jApxq1HqAA/DjK3BgHniEy6uqbnMpeckucWRTEkc2XQYgsKGOPlOb3zAvx5xeQvYncWCT8BwdiUtM5cucK1NQUMCSJUvQ6/UEBgbSedQYXk/O5ZfCEgAclQp6eagpyZhPQtYelHYlw049jc7ow/rm8yhxzyXENYRQt1BC3OSvbg5yKwAJiZQjqeSezcGsVrOmTQ/0ji6ozZdxKViJg+ksAC4aF7oFd2N049G0DWhb8XpY7WS8cwR7sRnPByJxaXvz7w0gIyODzz//HJvNVuOCe2n6NIb+MBSL3cInvT6hW0i3SreTJIlly5aRnJxMixYteOCBP19OQBAEoS4RAU417okAx1QCn7SXq7J2fQ56vXZHTnPxeDY/fXEGi9GG1llNz4lNqd/at8rti3emUPxjMgpHFf5PtUHtcfN1SnJycli6dCkGg4Hg4GAmTJjAdr2JuclZxJeUyRtJEoFZH2E1H8PJ4kUnjx4cs/5EoanwuuPZFc6YnVpidmqF1aEFQ+Pj8NcXkO3qyk9hF9CU7ccPJT0iR9IzrCftAtrhoKr81lrp0UwK1iaidHcg8IV21RY2/D2DwcCiRYsoKCigcePGjB07tka3jZ7d9SzbkrfRMbAjC/ssrHLfazNVarWaWbNm4eHhcdPnEARB+Duoyef3HV2aUVBQwMSJE9HpdOh0OiZOnEhhYWGV21ssFl588UWioqJwcXEhKCiISZMmkZ6eXmG77t27o1AoKjzGjh17J9/K7ad1hQFXK9ju+0huFngHNIjxY8wr7fELd8NkkCsg7/76HFZL5UXZ3LqF4hDmhmS0UbD2fIXqv9Xx9fVl0qRJODk5ceXKFb766iv66ZzY1jaSjTGNGOLhhkqCTL/p2FS+lGny2WxPgojPiGq5inpNl+LV8FMcIuZiCfuI/JAF6H1mYnLpjE2jY1fTllg1KvxKSngp1cbPKWn81ORxXot9jc7BnasMbiS7hH6PnAfk1iW4RsGNzWZjzZo1FBQU4OHhwf3331+j4OZE9gm2JW9DqVDyfLvnq9zXarWybds2ADp16iSCG0EQhD/pjgY448ePJy4ujq1bt7J161bi4uKYOLHqpdEGg4Hjx4/z2muvcfz4cb777jvOnz/P0KFDr9t2+vTpZGRklD8+++yzO/lW7owmgyByANgtsPFpuEOTaTpfJ0Y834bWfeQCfKd2X2H1v4+Qdq7gum0VKgWeoyJRaJSYLhRSsj/9um1uJCAggIkTJ+Lo6EhqaiorV67EYrHgn2Gi45fpPLmhkH7nVDQKfg4UarRlx0nL+oGfC80cLlVzzuzCFbsHhXghKZQ0dnFkZpgfP7RuSHz/7kwaNQaAZH0wObb6KCL7Vjsm49l8rNllKLQqXNrXrMDitm3bSEpKQqPRMG7cuPJ6NzfDLtl598i7AAxvOJxIz6qX4B86dIiCggJcXV3p3LlzjcYoCIIgXO+ONbY5c+ZMeZ+eDh06ALBo0SJiY2M5d+4cjRs3vm4fnU7H9u3bK3xv7ty5tG/fnpSUFMLCwsq/7+zsTEDAn68GXKsUChj4DiTthuR98OvX0Gr8HTmVSq2k08iGhDTxZMeyBAoyDaz74ASN2vnTeWRDXH53K0rj64xuUD0Kf7hI0dYkHBt6oAm4+T5NQUFBTJw4kS+++IKUlBQWzluCIrEBSCrqhbnx+Ngo3LwcWXVWz1uH3sK9aDUPNYilvldLnJQKHFVKnJRKGjprCXOqeIssMjKSLo19+eVcDusU/Qiwu1HdovZrszeuHQNvqpDhNceOHePQoUMAjBgxAv8qWi9UZe35tcTnxuOsdmZW61lVbldSUsKePXsA6NWrF1qtaF8gCILwZ92xGZwDBw6g0+nKgxuAjh07otPp2L9//00fp6ioCIVCcd2U/cqVK/Hx8aF58+Y899xz6PX6Ko9hMpkoLi6u8LhneITBfS/Kz7fPBuOdHVtYc2/Gv96RqPuCUSgg8UgWK2cfJG5HSoXbVi4dAnFs7AlWifxV55Bq2PcpODiYIf1GokRNbnEmBZ7xNGjvxYjnYsoTnUc3Hs2AegOwSzZ2n3mLgV4KRgZ4McjXg57e7tcFN9f00MYTRhpmScPq1asxm81VjsOUXIz5cjGoFLh2Drrp8ScnJ7Np0yb5fD160LRp0xq8e7lNxYfHPgTgidZP4ONUdRf5Xbt2YTKZCAwMJDo6ukbnEQRBECp3xwKczMzMSpfR+vn5kZmZeVPHMBqNvPTSS4wfP75CMtGDDz7I119/za5du3jttdf49ttvGTFiRJXHmTNnTnkekE6nu/eW3nZ8HLwaQGk27H3vjp/O0UVDt3GNGfVyO/zruWMx2di39gJf/N9+Dq2/RGmhCYVCgecDkShd1FgySinalnzTxy/KKWP7ktPsXpSGe14LFHY1VodikkwHKDMZyrdTKBTMjp1NhHsE2YZsXtj9Ala79cYHt9tRXdjOA2zGxVFDVlYWGzZsoKpcef1uefbGubUfKvebmxnJy8tj1apV2O12mjVrRrdula96upH/Hv4veoue5t7NGddkXJXbpaamcvToUQD69esnKhYLgiDcJjX+1/T111+/LsH3j49r/2BXllApSdJNJWlaLBbGjh2L3W5n/vz5FV6bPn06vXv3pkWLFowdO5a1a9eyY8cOjh8/XumxXn75ZYqKisofqampNX3bd5baAfrPkZ8fmA95F+/KaX3D3Bj5fBt6TGyCq6eWMr2Fo5sv88X/7Wfb4tOkXynBbajcNbxkbxqmS4VVHstqsZF6Np9dK8/y1eyDnD+cBRI0bdmQB8dOxNXVlaysLJYuXUpBwW+5Py4aFz7s8SFOaicOZR7io+Mf3XjQ6cfBkIu7VsWo0WNRKpXEx8dz8ODB6zY1p+oxJuSBAty6hdzUNcnPz2f58uUYDAYCAgIYNmxYjQvt7U3by9bLW1EqlMyOnY1KWXkzT6vVyrp16wCIjo4mIiKiRucRBEEQqlbjHJxZs2ZVu2IpIiKCkydPkpWVdd1rOTk51eYyWCwWRo8eTVJSEj///HO1S8FiYmLQaDQkJiYSExNz3etarfbez2to1Bca9oYLO2DbqzDu67tyWoVSQbPOQTTpGMCluFxO7kwl40IRiUeySDyShUKpoIO3Fn+LjawVZ7AOqAcaFZIkIUlQmG0g7WwBmReLsP3uNlZYMy86DmuAb5hcy2ZqwFS++OIL8vPzWbJkCRMnTiyf4Wvg0YC3Or/Fs7ufZdnpZTT3bk7/ev0rH3CivNKIBj2IqN+Afv36sWXLFrZt20ZAQAD16tUD5EC6cHMSIM/eaPyqTw4uKChg+fLlFBcX4+Pjw4QJE3CopBjfjRgsBt46+BYAE5pOoKl31be29uzZQ25uLi4uLvTr169G5xEEQRBurMYBjo+PDz4+VecTXBMbG0tRURGHDx+mffv2gLxSpKioiE6dOlW537XgJjExkZ07d+LtXX1fpNOnT2OxWAgMvH19ne46hQL6vQ2XdsG5zXDxZ2jQ866dXqlS0rCNHw3b+JGToid+VxqpZ/IpKTBxJMdIdzc1rmVWcr45x1FD5UvMXXQOhDTxommnQIIbe1Z4zcvLi6lTp7JixQpycnJYvHgxI0aMKE827xvRl6l5U1lyagn/3P9P6nvUr3zV0fkf5a+N5ICgffv2XLlyhZMnT7JmzRoeeeQRPDw8MJ7Nx5xUBGoF7n3Dq33/hYWFLF++nKKiIry9vZk8eTKurq41uIKyT3/9lPTSdAJdApnZamaV22VmZvLLL78AMGjQoBqtzhIEQRCqd0cL/Q0YMID09PTyJdyPPPII4eHhbNiwoXybJk2aMGfOHIYPH47VamXkyJEcP36cjRs3Vpjp8fLywsHBgYsXL7Jy5UoGDhyIj48PCQkJPPvsszg5OXHkyBFUqspvB/zePVHorypbXoJDC8C3CTy6D1R3bKHbTdHnG8m8VETByRwCzhegBJJcNOQ4aVAoFDi6agiO9CSkiSeeAc7V3s4xGAx88803pKSkAHICb9euXVEqldjsNh7b8RgHMg4Q6hbK14O+Rqf9XbNQfSa8f3X13bPnwU3++bBYLCxevJjMzEwCAwN5aPJD5M+Px5ptwO2+EHQD6t1wTEVFRSxdupTCwkK8vLyYMmXKLf1cnMs/x5iNY7BJNub1nMd9ofdVup3NZuPzzz8nIyODpk2bMmbMmBqfSxAE4e/onin0t3LlSqKioujbty99+/alZcuWrFixosI2586do6ioCIC0tDTWr19PWloarVq1IjAwsPxxbeWVg4MDP/30E/369aNx48Y8+eST9O3blx07dtxUcHPP6/4iOHlBzlk4uqS2R4OblyON2vrTfmoLPAfKgUI9k5XB4xsz/NkYBsyIomWPELwCXW4qV8XZ2ZnJkyeXtzrYuXMnq1evxmQyoVKqeKfbOwS7BpOqT+XFvS9WTDpOvFpCIKh1eXADoNFoGDt2LE5OTmRkZPDd8lVYsktROqtx637jhPK0tDQWL15MYWEhnp6etxzcGK1GXtr7EjbJRp/wPlUGNyCvMMzIyMDR0ZGBAwfW+FyCIAhC9USrhnttBgfgyGLY9Aw4esCTJ8C5Zl2v7xRJkshbnoDxbD5qHyf8ZrWqUV2ZPzp+/DibNm3CZrPh4+PDiBEjCAoK4kzeGSZtmYTRZmR05Ghe7fiqHDytmghn1sN9L0GPl687XlJSEitWrMButxNlDaNv/364dQmu8r0cO3aMLVu2YLPZ8Pb2ZtKkSeh0ukq3r86bB95k9fnVeDl68e3Qb6tcFp6bm8uCBQuw2WwMGzaMVq1a3dL5BEEQ/o7umRkc4Ra1mQJ+zcFYCHvu/LLxm6VQyFWOVTot1twyCr5LrHJ59s2IiYnhoYcews3NjdzcXBYtWsS2bdto4NaA/3T7DwoUrD6/mqWnl4LVDBd3yjtWUb24Xr169G0oVwGOV6eQoKp8tZzFYmHdunVs3LgRm81G06ZNmT59+i0HNz9e/pHV51cDMKfrnCqDG5PJxKpVq7DZbDRo0EDUvBEEQbiDRIBzL1KqoO+b8vPDCyH/Uu2O53dULhq8xjcBpYKyk7mUHr65mkZVCQkJYcaMGTRv3hxJkti/fz8LFiwgwhLBC+1eAOCDYx+w9dg8MOvBxRcCW1d6LJveTOhZJ9pY6gOw5cetnDlzpsI2V65cYfHixcTFxaFQKOjduzejR4/G0bHqLus3kqZP4/X9rwMwrcU0OgVVnkAvSRLr1q0jJycHV1fXGve0EgRBEGpGBDj3qoa95FVUdgv89EZtj6YCbbg7uv4RABRuuIgp+c9VX3Z1dWXUqFGMGzcOd3d3CgoKWLFiBQ6nHLg/9H4A/u/sco5rtdCwD1RRDK9w4yUks412AS3KywV8++23pKamkpeXx+rVq1m0aBGZmZk4OzszceJEunTpcsuBhsVu4YU9L1BiKSHaN5qZrateNbVv3z4SEhJQKpWMHj363rw1KgiCUIfU7hId4cb6vCnfljn9PXScCaHtantE5Vy7BGO6XIwxIY+8LxLwm9kKtdetzYJc07hxYyIiIvjpp584fPgwCQkJqFDRILwBF5UXedLfhy/CYqhfyb6GuGzKfs0BJXje35BBwdHo9XoSExNZtmwZNttvS9tbtmxJr169bvmW1DVzj88lPjceNwc33un2DhqlptLtLly4wI4dOwAYOHBghZ5qgiAIwp0hZnDuZQEtoPWD8vNtr96xbuO3QqFU4DWmMZpAF+ylFnKXncZurKbNwk3QarUMHDiQRx99lOjoaFRKFS1SWuBl9KJIpeLB04tZ98s6MjMzy4MWa6GRgh8uAODcPZg0Sw47duygsLAQoHy7kJAQHn30UUaMGPGng5v1F9fLuUHAG53eIMi18j5X+fn5rF27FpBzjtq0afOnzisIgiDcHLGK6l6/VVCcDh/HgLUMRq+AZkNre0QVWItMZH8Sh73YjLaRBz5TmqNQ3b64Wa/Xc2T1+/xypZBtAUcp0hahtWnpmtEVH3xwc3PDUmTEarViV0pYFDbs9oqNQbVaLSaTCY1Gw/jx48urHd+qnSk7eXrX09gkG5ObTea5ds9Vul1paSnLly8nOzub4OBgHnroIdRqMWkqCIJwq8QqqrrEPQg6PSE/3zFbXk10D1HrtPhMbo5Co8SUWEjh+ot/amXVH7m5utLTsIGX7V/wYeh4QjQhmFQm9gbuJUeRQ35+PnqbgTKFGZNkwW634+rqSqtWrXjggQd44YUXePbZZ6lfvz4Wi4WVK1dy/vz5Wx7PkcwjPLf7OWySjaENhvJM22cq3a6wsJAlS5aQnZ2Nq6srY8aMEcGNIAjCXSRmcO71GRwAkx4+bg2lOTDgHegwo7ZHdJ2yhDzyViSABO59w3HveZvyTLISYEEsqBzg+YsUKSRmbJ/B6bzTuKnceDZpMvUMwXj0isAt2h+NRoNOp7sucdhisbB27VrOnTuHUqlk6NChNa5BczrvNNN+nEappZTuod35oPsHqJXXBy25ubl88cUXFBcX4+7uzqRJk26qvYkgCIJwY2IGp67RukGP/5Of7/4vGP/cqqU7wamZN7qBcvpv8bZkin68fHtmcs6sl7826AWO7ui0Ohb2XUiUVwv0Nj3/Df6cy01yqNerOb6+vnh4eFS6Kkqj0TB69GhatGiB3W7nhx9+4LvvvsNoNN7UMC4VXeKx7Y9RaimlXUA73rvvvUqDm4yMDJYsWUJxcTHe3t5MmzZNBDeCIAi1QAQ4fxWtJ4FPJBjyYN9HtT2aSrl1Dcb96vJx/c5U+XaV/U8GOQnr5K+/yz1ysTjx1qVZRJU2okxlZDb/4/2j72OxW254KJVKxYgRI+jevTsKhYKTJ0/y6aefkppaeUHAa3al7mLC5gkUmApo5t2Mj3t8jFZVsTu9JEmcPXuWZcuWYTAYCAwMZOrUqX86mVkQBEG4NeIW1V/hFtU1ZzbCqgdB7QRPHpfzc+5BJQfTKVx3ESRwjvHDc2QkCtUt1JrJvQDz2oBSDc9fACdPbKUWcj+Px5JRit1VwTddf2HF5ZUAxPjF8O597+Ln7FftoVNSUvj2228pKipCoVBw3333ERsbi1b7W+BitVuZe2IuS07JPcFa+rZkbs+5eDlWbJ2Rm5vL1q1buXBBXskVHh7OuHHjbrl4oCAIglC5mnx+iwDnrxTgSBIs6Q+pByFmEgydW9sjqpLhRDb5a86BHRybeeM1OrLmfav2vi8XOWzQEyZ+Lwc3i+KxZJaidNXgOz0Kjb8LPyX/xKv7XqXEUoKXoxcvtnuR/vX6o1TceIKyrKyMTZs2cerUKUBebRUTE0P79u2xOdp4fvfzHM06CsCEphN4ps0zaFS/1boxGo3s2bOHgwcPYrfbUSqVxMbG0r17dzSaymviCIIgCLdOBDjV+MsGOAAph2BJX1Ao4bED4NektkdUpbKEPPK+OgNWCZW7Ax7DGuLUzPvmD/DZfZARB0M+whY5ntzFp34Lbh5picbPuXzT5OJkntn1DOcL5BVSDT0a8lj0Y/QO733DQEeSJOLj49m1axf5+fnl389xyyHFIQW71s60dtMY2HQgSqWStLQ0UlNTSUlJITU1FbNZXtUWGRlJv3798PauwfsTBEEQakQEONX4Swc4AN88CGc3QuQAGP9NbY/mhkyXiyhYcx5rnpzM69TSB48hDVC5Odx4x4Jk+Kgldhwp6bgb/f58JLMNpZsG3+kVg5trjFYjy04v44uEL9Cb9QA09mzMlBZTaOvfFn9n/yrbMlwqvMSXe74k62wWvgbfm35/Xl5e9O/fn8jIyJveRxAEQbg1IsCpxl8+wMlNhE86gGSDh7ZAeOUNHu8VksVG8Y4U9HvTwA4KJzVunYNwbOKFJsgVhfL6oEPaNxfDlt0UMRW71Q0ATYirXD3Z9/rg5veKzcWsSFjBioQVlFpKy7/v4+RDC58WNPNqhtluJtuQTVZpFlmGLC4XXy7fLsoxis50RmfVoS/WU1RUVL7ayt3dnbCwMEJDQwkLC8Pf3x9lFb2xBEEQhNtLBDjV+MsHOAAbn4ajSyCkHUzbDn+BztTmKyUUfHseS/pvQYfSVYNjpCcOoW7YSizYCk3YikxYLydjs8orkFSeWnT9InBq6VtpMFSVIlMRKxJWsCdtD+cLzmOTbFVuq0DBfSH3MbHZRNoFtLtupsdkMmGxWHB1da3huxYEQRBuFxHgVKNOBDj6LLn4n6UURi2D5sNre0Q3RbJJGE5kUZaQj+lCIZL5RkGHHvdeEbj2aIJC/edmScqsZZzNP0t8TjznCs7honHBz9kPf2d/AlwCCHMLw9/F/0+dQxAEQbizRIBTjToR4ADs+g/smgOe9WDmYVBXk9dyj5Gsdrkj+fl8rNllqNwdUOm0qLJ+RnXmcxzCfVA+/ENtD1MQBEG4R9Tk81s0x/kri50l36YqSIKji6HjY7U9ohpRqJU4NvTAsaHHb9+UJJj7EaguQZv5tTY2QRAE4a9NZEf+lWldoccr8vPd/4Wygtodz+2QchDyL4HGBZrdX9ujEQRBEP6iRIDzV9d6Avg1k4Obve/X9mj+vLgv5a/Nh8sBnCAIgiDcAhHg/NUpVdDnDfn5oc/k+jF/VaYSOPW9/Lz1g7U7FkEQBOEvTQQ4dUHD3lC/O9jMcmuDv6qEdfKqMK/6EBZb26MRBEEQ/sJEgFMXKBTQ501AAafWQtqx2h7RrYmTm2bS6sG/RF0fQRAE4d4lApy6IrAlRI+Tn297RV6N9FeSfwmS98k9tq69D0EQBEG4RSLAqUt6vgoaZ0g5AKe+re3R1EzcV/LX+j1AF1y7YxEEQRD+8kSAU5fogqHrM/Lzba+BufTG298r7LbfAhyRXCwIgiDcBiLAqWtinwCPcNCnw97/1fZobs6lXVB8BRw9oPGg2h6NIAiCUAeIAKeu0ThC/zny8/0fy7kt97rjX8hfo0bJ4xcEQRCEP0kEOHVR44FyLovNDD++WtujubG8i3Bmvfy8zZRaHYogCIJQd4gApy5SKGDAf0GphnOb4MKO2h5R1fbPBckOjfpCQIvaHo0gCIJQR4gAp67ybQztZ8jPt7wEVnPtjqcy+szfat90ebp2xyIIgiDUKSLAqcu6vwguvpCXCAfm1vZorndwvnwbLbSDqFwsCIIg3FYiwKnLHHXQ9y35+a7/Qs752h3P75UVwpEl8vMuz4jKxYIgCMJtJQKcuq7lGGjYB2wmWD9LrjlzLzjyOZj1cif0Rn1rezSCIAhCHSMCnLpOoYDBH4CDK6QegsOLantEYCmDgwvk552fAqX4MRQEQRBuL/HJ8nfgEQp9/iU//+lfUHC5VofDiS/BkAseYdBiZO2ORRAEQaiT7miAU1BQwMSJE9HpdOh0OiZOnEhhYeEN95kyZQoKhaLCo2PHjhW2MZlMPPHEE/j4+ODi4sLQoUNJS0u7g++kDmgzFcI7g8UAG/5Re804bRbY97H8vNOToFLXzjgEQRCEOu2OBjjjx48nLi6OrVu3snXrVuLi4pg4cWK1+/Xv35+MjIzyx+bNmyu8/tRTT/H999/zzTff8Msvv1BSUsLgwYOx2e6R/JJ7kVIJQ+eC2lFujXBiRe2M48hiKEoBZx9oJfpOCYIgCHfGHfvv85kzZ9i6dSsHDx6kQ4cOACxatIjY2FjOnTtH48aNq9xXq9USEBBQ6WtFRUUsXryYFStW0Lt3bwC+/PJLQkND2bFjB/369bv9b6au8G4APV6B7a/B1pchtCP4Rt698xemwk9vyM97vAwOznfv3IIgCMLfyh2bwTlw4AA6na48uAHo2LEjOp2O/fv333DfXbt24efnR2RkJNOnTyc7O7v8tWPHjmGxWOjb97eVN0FBQbRo0aLK45pMJoqLiys8/rZiZ0J4FzCXwKoJYNLfnfNKEmx+Diylct2bNlPvznkFQRCEv6U7FuBkZmbi5+d33ff9/PzIzMyscr8BAwawcuVKfv75Z95//32OHDlCz549MZlM5cd1cHDA09Ozwn7+/v5VHnfOnDnleUA6nY7Q0NA/8c7+4pQqGLUU3AIh9xysm3V38nES1sH5raDUwJCPxMopQRAE4Y6q8afM66+/fl0S8B8fR48eBUBRSfE2SZIq/f41Y8aMYdCgQbRo0YIhQ4awZcsWzp8/z6ZNm244rhsd9+WXX6aoqKj8kZqaWoN3XAe5+sHoL+RgI+EHODDvzp6vrBC2vCA/7/I0+DW9s+cTBEEQ/vZqnIMza9Ysxo4de8NtIiIiOHnyJFlZWde9lpOTg7+//02fLzAwkPDwcBITEwEICAjAbDZTUFBQYRYnOzubTp06VXoMrVaLVqu96XP+LYS2h/5z5NtG22dDYCuo1/XOnGvH61CSBd6NoOuzd+YcgiAIgvA7NQ5wfHx88PHxqXa72NhYioqKOHz4MO3btwfg0KFDFBUVVRmIVCYvL4/U1FQCAwMBaNOmDRqNhu3btzN69GgAMjIyOHXqFO+8805N387fW7uHIe0InFwFax+C6Tvlmjm3U/IBOLZUfj7kQ9A43t7jC4IgCEIl7lgiRNOmTenfvz/Tp0/n4MGDHDx4kOnTpzN48OAKK6iaNGnC999/D0BJSQnPPfccBw4c4PLly+zatYshQ4bg4+PD8OHDAdDpdEybNo1nn32Wn376iRMnTjBhwgSioqLKV1UJN0mhgMEfgn8LKM2BZQMh/9LtO35BMnw3XX4eMwkiuty+YwuCIAjCDdzRTM+VK1cSFRVF37596du3Ly1btmTFior1V86dO0dRUREAKpWK+Ph47r//fiIjI5k8eTKRkZEcOHAANze38n0++OADhg0bxujRo+ncuTPOzs5s2LABlUp1J99O3eTgDOO+Aa/6UJgCSwZA9pk/f9zCVFg+GIpSwbsh9Hnjzx9TEARBEG6SQpJqq6Rt7SkuLkan01FUVIS7u3ttD+feoM+CFcMgOwGcPGHCdxAcc2vHKroizwYVXAavBjBlE7gH3s7RCoIgCH9DNfn8Fmt1BZmbvxyIBLeBsgJYPhQu/1Lz4xRnyDM3BZfBMwImbxDBjSAIgnDXiQBH+I2zF0xaBxFdwayHZYPhh8fl203VkSRI3i8HN/mXwCMcJm8EXfCdH7cgCIIg/IEIcISKtG7w4BqIGg1IELcS5raBH18BQ/7129vtcGYDLO4DSwdA3gXQhcGUjbd/RZYgCIIg3CSRgyNycKqWdgx2zIbLe+U/O7iCTyNw1MkPrTukHJCDGgCVFlqNg/teBPeg2hu3IAiCUCfV5PP7jjXbFOqAkDZyDs3Fn+RifZnxkH7i+u0cdXJNnfYz5FweQRAEQahlIsARbkyhgIa9oX5PObgpzQFTMRiLwFgIzt4QNUq+tSUIgiAI9wgR4Ag3R6mUZ3QEQRAE4S9AJBkLgiAIglDniABHEARBEIQ6RwQ4giAIgiDUOSLAEQRBEAShzhEBjiAIgiAIdY4IcARBEARBqHNEgCMIgiAIQp0jAhxBEARBEOocEeAIgiAIglDniABHEARBEIQ6RwQ4giAIgiDUOSLAEQRBEAShzhEBjiAIgiAIdc7fspu4JEkAFBcX1/JIBEEQBEG4Wdc+t699jt/I3zLA0ev1AISGhtbySARBEARBqCm9Xo9Op7vhNgrpZsKgOsZut5Oeno6bmxsKheK2Hru4uJjQ0FBSU1Nxd3e/rccWfiOu890hrvPdIa7z3SOu9d1xp66zJEno9XqCgoJQKm+cZfO3nMFRKpWEhITc0XO4u7uLX567QFznu0Nc57tDXOe7R1zru+NOXOfqZm6uEUnGgiAIgiDUOSLAEQRBEAShzhEBzm2m1WqZPXs2Wq22todSp4nrfHeI63x3iOt894hrfXfcC9f5b5lkLAiCIAhC3SZmcARBEARBqHNEgCMIgiAIQp0jAhxBEARBEOocEeAIgiAIglDniABHEARBEIQ6RwQ4t9H8+fOpV68ejo6OtGnThr1799b2kOqcPXv2MGTIEIKCglAoFPzwww+1PaQ6ac6cObRr1w43Nzf8/PwYNmwY586dq+1h1TkLFiygZcuW5dVeY2Nj2bJlS20Pq86bM2cOCoWCp556qraHUqe8/vrrKBSKCo+AgIBaG48IcG6TVatW8dRTT/HKK69w4sQJunbtyoABA0hJSantodUppaWlREdHM2/evNoeSp22e/duZs6cycGDB9m+fTtWq5W+fftSWlpa20OrU0JCQvjPf/7D0aNHOXr0KD179uT+++/n9OnTtT20OuvIkSMsXLiQli1b1vZQ6qTmzZuTkZFR/oiPj6+1sYg6OLdJhw4diImJYcGCBeXfa9q0KcOGDWPOnDm1OLK6S6FQ8P333zNs2LDaHkqdl5OTg5+fH7t376Zbt261PZw6zcvLi3fffZdp06bV9lDqnJKSEmJiYpg/fz5vvfUWrVq14sMPP6ztYdUZr7/+Oj/88ANxcXG1PRRAzODcFmazmWPHjtG3b98K3+/bty/79++vpVEJwu1TVFQEyB++wp1hs9n45ptvKC0tJTY2traHUyfNnDmTQYMG0bt379oeSp2VmJhIUFAQ9erVY+zYsVy6dKnWxvK37CZ+u+Xm5mKz2fD396/wfX9/fzIzM2tpVIJwe0iSxDPPPEOXLl1o0aJFbQ+nzomPjyc2Nhaj0Yirqyvff/89zZo1q+1h1TnffPMNx48f58iRI7U9lDqrQ4cOfPHFF0RGRpKVlcVbb71Fp06dOH36NN7e3nd9PCLAuY0UCkWFP0uSdN33BOGvZtasWZw8eZJffvmltodSJzVu3Ji4uDgKCwv59ttvmTx5Mrt37xZBzm2UmprKP/7xD7Zt24ajo2NtD6fOGjBgQPnzqKgoYmNjadCgAcuXL+eZZ5656+MRAc5t4OPjg0qlum62Jjs7+7pZHUH4K3niiSdYv349e/bsISQkpLaHUyc5ODjQsGFDANq2bcuRI0f46KOP+Oyzz2p5ZHXHsWPHyM7Opk2bNuXfs9ls7Nmzh3nz5mEymVCpVLU4wrrJxcWFqKgoEhMTa+X8IgfnNnBwcKBNmzZs3769wve3b99Op06damlUgnDrJEli1qxZfPfdd/z888/Uq1evtof0tyFJEiaTqbaHUaf06tWL+Ph44uLiyh9t27blwQcfJC4uTgQ3d4jJZOLMmTMEBgbWyvnFDM5t8swzzzBx4kTatm1LbGwsCxcuJCUlhUcffbS2h1anlJSUcOHChfI/JyUlERcXh5eXF2FhYbU4srpl5syZfPXVV6xbtw43N7fy2UmdToeTk1Mtj67u+L//+z8GDBhAaGgoer2eb775hl27drF169baHlqd4ubmdl3+mIuLC97e3iKv7DZ67rnnGDJkCGFhYWRnZ/PWW29RXFzM5MmTa2U8IsC5TcaMGUNeXh5vvPEGGRkZtGjRgs2bNxMeHl7bQ6tTjh49So8ePcr/fO2+7uTJk1m2bFktjaruuVbuoHv37hW+v3TpUqZMmXL3B1RHZWVlMXHiRDIyMtDpdLRs2ZKtW7fSp0+f2h6aINRYWloa48aNIzc3F19fXzp27MjBgwdr7XNQ1MERBEEQBKHOETk4giAIgiDUOSLAEQRBEAShzhEBjiAIgiAIdY4IcARBEARBqHNEgCMIgiAIQp0jAhxBEARBEOocEeAIgiAIglDniABHEARBEIQ6RwQ4giAIgiDUOSLAEQRBEAShzhEBjiAIgiAIdc7/A9+7HKlqYpPNAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "shiftedgto = ShiftedGTORadialBasis(\n", - " radial_gaussian_width=width,\n", - " # radial_gaussian_shift = shift,\n", - " tol=1e-1,\n", - " **shared_params\n", - ")\n", - "shiftedgto.plot_basis()" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "d6229528-3307-4182-9959-eb9f5aa4b4e0", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "gto = GTORadialBasis(radial_gaussian_width=width, **shared_params)\n", - "gto.plot_basis()" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "fe008b9e-40a9-4d2d-a4ee-496198779e44", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "gto = GTORadialBasis(**shared_params)\n", - "gto.plot_basis()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "0421646e-8619-4c32-ab47-687ba84f9be3", - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[11], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43marange\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43marray\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m6\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[0;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()" - ] - } - ], - "source": [ - "np.arange(np.array([0, 1, 6]))" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "2ae38153-2614-43e3-bd49-6f685ab1ba9f", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "be6ee255-846f-4d8d-8b4d-ab92d0aca55c", - "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.6" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/anisoap/representations/ellipsoidal_density_projection.py b/anisoap/representations/ellipsoidal_density_projection.py index 4415d76..229ccb8 100644 --- a/anisoap/representations/ellipsoidal_density_projection.py +++ b/anisoap/representations/ellipsoidal_density_projection.py @@ -127,11 +127,15 @@ def pairwise_ellip_expansion( ( precision, center, - constant + constant, ) = radial_basis.compute_gaussian_parameters(r_ij, lengths, rot) - moments = np.exp(-0.5 * constant) * length_norm * compute_moments_inefficient_implementation( - precision, center, maxdeg=maxdeg + moments = ( + np.exp(-0.5 * constant) + * length_norm + * compute_moments_inefficient_implementation( + precision, center, maxdeg=maxdeg + ) ) for l in range(lmax + 1): deg = l + 2 * (num_ns[l] - 1) diff --git a/anisoap/representations/radial_basis.py b/anisoap/representations/radial_basis.py index 0df72db..8313793 100644 --- a/anisoap/representations/radial_basis.py +++ b/anisoap/representations/radial_basis.py @@ -425,11 +425,12 @@ def compute_gaussian_parameters(self, r_ij, lengths, rotation_matrix): sigma = self.radial_gaussian_width new_precision = precision + np.eye(3) / sigma**2 new_center = center - 1 / sigma**2 * np.linalg.solve(new_precision, r_ij) - constant = 1 / sigma**2 * r_ij @ np.linalg.solve(new_precision, precision@r_ij) + constant = ( + 1 / sigma**2 * r_ij @ np.linalg.solve(new_precision, precision @ r_ij) + ) return new_precision, new_center, constant - def calc_overlap_matrix(self): """ Computes the overlap matrix for GTOs. From 5a029402c0c55cb94a9481685f74e532d513186e Mon Sep 17 00:00:00 2001 From: "Rose K. Cersonsky" <47536110+rosecers@users.noreply.github.com> Date: Fri, 15 Mar 2024 17:43:04 -0500 Subject: [PATCH 7/7] I think this might be more correct -- I thought lengths were diameters before --- .../ellipsoidal_density_projection.py | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-) diff --git a/anisoap/representations/ellipsoidal_density_projection.py b/anisoap/representations/ellipsoidal_density_projection.py index 229ccb8..70d5cfa 100644 --- a/anisoap/representations/ellipsoidal_density_projection.py +++ b/anisoap/representations/ellipsoidal_density_projection.py @@ -118,24 +118,20 @@ def pairwise_ellip_expansion( rot = rotation_matrices[j_global] lengths = ellipsoid_lengths[j_global] - volume = 4.0 / 3.0 * np.pi * np.product(lengths / 2.0) + volume = 4.0 / 3.0 * np.pi * np.product(lengths) length_norm = ( - np.product(lengths) * volume * (2.0 * np.pi) ** (3.0 / 2.0) + np.product(lengths * 2) * volume * (2.0 * np.pi) ** (3.0 / 2.0) ) ** -1.0 ( precision, center, - constant, + constant ) = radial_basis.compute_gaussian_parameters(r_ij, lengths, rot) - moments = ( - np.exp(-0.5 * constant) - * length_norm - * compute_moments_inefficient_implementation( - precision, center, maxdeg=maxdeg - ) + moments = np.exp(-0.5 * constant) * length_norm * compute_moments_inefficient_implementation( + precision, center, maxdeg=maxdeg ) for l in range(lmax + 1): deg = l + 2 * (num_ns[l] - 1)