diff --git a/.gitignore b/.gitignore index c203e4b..d18d753 100644 --- a/.gitignore +++ b/.gitignore @@ -4,5 +4,5 @@ internal_saves/ __pycache__/ results/ data/ -config.ini +config2.ini configs/ diff --git a/LICENSE.txt b/LICENSE.txt new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/LICENSE.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/README.md b/README.md index fcf2dfb..12d0fe8 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,6 @@ -# dependency parsetree +# STARK: a tool for statisical analysis of dependency-parsed corpora +STARK is a python-based command-line tool for extraction of dependency trees from parsed corpora based on various user-defined criteria. It is primarily aimed at processing corpora based on the [Universal Dependencies](https://universaldependencies.org/) annotation scheme, but it also takes any other corpus in the [CONLL-U](https://universaldependencies.org/format.html) format as input. + ## Linux installation and execution ### Installation Install python 3 on your sistem. @@ -24,8 +26,37 @@ python3 dependency-parsetree.py --config_file= Example: ```bash -python3 dependency-parsetree.py --config_file=official_config.ini +python3 dependency-parsetree.py --config_file=config.ini ``` +## Parameter settings +The type of trees to be extracted can be defined through several parameters in the `config.ini` configuration file. + +- `input`: location of the input file or directory (parsed corpus in .conllu) +- `output`: location of the output file (extraction results) +- `internal_saves`: location of the folder with files for optimization during processing +- `cpu_cores`: number of CPU cores to be used during processing +- `tree_size`: number of nodes in the tree (integer or range) +- `tree_type`: extraction of all possible subtrees or full subtrees only (values *all* or *complete*) +- `dependency_type`: extraction of labeled or unlabeled trees (values *labeled* or *unlabeled*) +- `node_order`: extraction of trees by taking surface word order into account (values *free* or *fixed*) +- `node_type`: type of nodes under investigation (values *form*, *lemma*, *upos*, *xpos*, *feats* or *deprel*) +- `label_whitelist`: predefined list of dependency labels allowed in the extracted tree +- `root_whitelist`: predefined characteristics of the root node +- `query`: predefined tree structure based on the modified Turku NLP [query language](http://bionlp.utu.fi/searchexpressions-new.html). +- `print_root`: print root node information in the output file (values *yes* or *no*) +- `nodes_number`: print the number of nodes in the tree in the output file (values *yes* or *no*) +- `association_measures`: calculate the strength of association between nodes by MI, MI3, t-test, logDice, Dice and simple-LL scores (values *yes* or *no*) +- `frequency_threshold`: minimum frequency of occurrences of the tree in the corpus +- `lines_threshold`: maximum number of trees in the output + +## Output +The tool returns the resulting list of all relevant trees in the form of a tab-separated `.tsv` file with information on the tree structure, its frequency and other relevant information in relation to specific parameter settings. The tool does not support any data visualization, however, the output structure of the tree is directly trasnferable to the [Dep_Search](http://bionlp-www.utu.fi/dep_search/) concordancing service giving access to specific examples in many corpora. + +## Credits +This program was developed by Luka Krsnik in collaboration with Kaja Dobrovoljc and Marko Robnik Šikonja and with financial support from [CLARIN.SI](https://www.clarin.si/). -[![alt text](https://gitea.cjvt.si/lkrsnik/dependency_parsing/raw/branch/master/Clarin-SI-logo.png)](http://www.clarin.si/info/about/) \ No newline at end of file +[![alt text](https://gitea.cjvt.si/lkrsnik/dependency_parsing/raw/branch/master/logos/CLARIN.png)](http://www.clarin.si/info/about/) +[![alt text](https://gitea.cjvt.si/lkrsnik/dependency_parsing/raw/branch/master/logos/CJVT.png)](https://www.cjvt.si/en/) +[![alt text](https://gitea.cjvt.si/lkrsnik/dependency_parsing/raw/branch/master/logos/FRI.png)](https://www.fri.uni-lj.si/en/about) +[![alt text](https://gitea.cjvt.si/lkrsnik/dependency_parsing/raw/branch/master/logos/FF.png)](http://www.ff.uni-lj.si/an/aboutFaculty/about_faculty) \ No newline at end of file diff --git a/Result.py b/Result.py deleted file mode 100644 index a4240f4..0000000 --- a/Result.py +++ /dev/null @@ -1,140 +0,0 @@ -import copy -import string - -from generic import create_output_string_form, create_output_string_deprel, create_output_string_lemma, \ - create_output_string_upos, create_output_string_xpos, create_output_string_feats, generate_key - - -class Result(object): - def __init__(self, node, architecture_order, create_output_strings): - # self.array = [[create_output_string(node) for create_output_string in create_output_strings]] - # if create_output_string_lemma in create_output_strings: - # key_array = [[create_output_string(node) if create_output_string != create_output_string_lemma else 'L=' + create_output_string(node) for create_output_string in create_output_strings]] - # else: - # key_array = self.array - # if len(self.array[0]) > 1: - # self.key = '&'.join(key_array[0]) - # else: - # # output_string = create_output_strings[0](node) - # self.key = key_array[0][0] - - self.array, self.key = generate_key(node, create_output_strings) - self.key_free = self.key - # self.array = [[output_string]] - self.order_key = str(architecture_order) - self.order = [architecture_order] - self.deprel = node.deprel.get_value() - # order with original numbers in sentences - # self.order = str([architecture_order]) - # order with numbers from 0 to n of n-gram - self.root = '' - self.final_order = '' - self.separators = [] - - def __repr__(self): - return self.key - - def add(self, string, architecture_order, separator, is_left): - if is_left: - self.array = [string] + self.array - self.order = [architecture_order] + self.order - # self.order = [architecture_order] + self.order - self.separators = [separator] + self.separators - self.key = string + ' ' + separator + ' ' + self.key - self.order_key = architecture_order + ' ' + separator + ' ' + self.order_key - - else: - self.array += [string] - self.order += [architecture_order] - # self.order += [architecture_order] - self.separators += [separator] - - self.key += ' ' + separator + ' ' + string - self.order_key += ' ' + separator + ' ' + architecture_order - - def add_separator(self, separator, left=True): - self_copy = copy.copy(self) - if left: - self_copy.separators += [separator] - self_copy.key += separator - self_copy.order_key += separator - else: - self_copy.separators = [separator] + self_copy.separators - self_copy.key = separator + self_copy.key - self_copy.order_key = separator + self_copy.order_key - return self_copy - - # def merge_results2(self): - - - def merge_results(self, right_t, separator, left=True): - left_tree = copy.copy(self) - right_tree = copy.copy(right_t) - - if separator: - if left: - # merged_results.append(left_part + right_part + separator) - left_tree.key = left_tree.key + right_tree.key + separator - left_tree.order_key = left_tree.order_key + right_tree.order_key + separator - left_tree.array = left_tree.array + right_tree.array - left_tree.order = left_tree.order + right_tree.order - # left_tree.order = str([architecture_order]) - left_tree.separators = left_tree.separators + right_tree.separators + [separator] - else: - # merged_results.append(left_part + separator + right_part) - left_tree.key = left_tree.key + separator + right_tree.key - left_tree.order_key = left_tree.order_key + separator + right_tree.order_key - left_tree.array = left_tree.array + right_tree.array - left_tree.order = left_tree.order + right_tree.order - # left_tree.order = str([architecture_order]) - left_tree.separators = left_tree.separators + [separator] + right_tree.separators - else: - # merged_results.append(left_part + right_part) - left_tree.key = left_tree.key + right_tree.key - left_tree.order_key = left_tree.order_key + right_tree.order_key - left_tree.array = left_tree.array + right_tree.array - left_tree.order = left_tree.order + right_tree.order - # left_tree.order = str([architecture_order]) - left_tree.separators = left_tree.separators + right_tree.separators - - return left_tree - - def extend_answer(self, other_answer, separator): - self.array.extend(other_answer.array) - self.order.extend(other_answer.order) - self.key += separator + other_answer.key - self.order_key += separator + other_answer.order_key - self.separators.extend(separator) - - def put_in_bracelets(self, inplace=False): - if inplace: - self.key = ('(' + self.key + ')') - self.order_key = ('(' + self.order_key + ')') - return - result = copy.copy(self) - result.key = ('(' + result.key + ')') - result.order_key = ('(' + result.order_key + ')') - return result - - def finalize_result(self): - result = copy.copy(self) - result.key = result.key[1:-1] - result.set_root() - - # create order letters - order_letters = [''] * len(result.order) - for i in range(len(result.order)): - ind = result.order.index(min(result.order)) - result.order[ind] = 10000 - order_letters[ind] = string.ascii_uppercase[i] - result.order = ''.join(order_letters) - # result.order_key = result.order_key[1:-1] - # TODO When tree is finalized create relative word order (alphabet)! - return result - - def set_root(self): - if len(self.array[0]) > 1: - self.root = '&'.join(self.array[0]) - else: - # output_string = create_output_strings[0](node) - self.root = self.array[0][0] \ No newline at end of file diff --git a/ResultNode.py b/ResultNode.py index 02df3a5..37a54b2 100644 --- a/ResultNode.py +++ b/ResultNode.py @@ -1,3 +1,17 @@ +# Copyright 2019 CJVT +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + from generic import generate_key, generate_name diff --git a/ResultTree.py b/ResultTree.py index 4eff77d..6b75f38 100644 --- a/ResultTree.py +++ b/ResultTree.py @@ -1,3 +1,17 @@ +# Copyright 2019 CJVT +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + import copy import string diff --git a/Tree.py b/Tree.py index 069ede5..91c209e 100644 --- a/Tree.py +++ b/Tree.py @@ -1,7 +1,6 @@ import sys from copy import copy -from Result import Result from ResultNode import ResultNode from ResultTree import ResultTree from Value import Value @@ -270,7 +269,7 @@ class Tree(object): # TODO add order rearagement (TO KEY) complete_answers[i].extend(new_complete_answers[i]) - # if create_output_string_form(self) == 'Dogodek': + # if create_output_string_lemma(self) == 'drama': # print('HERE!@@!') # if create_output_string_form(self) == 'vpiti': # print('HERE!@@!') diff --git a/Value.py b/Value.py index a3080ff..39fed9b 100644 --- a/Value.py +++ b/Value.py @@ -1,3 +1,17 @@ +# Copyright 2019 CJVT +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + class Value(object): def __init__(self, value): self.value = value diff --git a/official_config.ini b/config.ini similarity index 100% rename from official_config.ini rename to config.ini diff --git a/dependency-parsetree.py b/dependency-parsetree.py index f1e5945..798e581 100644 --- a/dependency-parsetree.py +++ b/dependency-parsetree.py @@ -1,4 +1,18 @@ #!/usr/bin/env python +# Copyright 2019 CJVT +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + import argparse import configparser import copy @@ -11,6 +25,16 @@ import string import time import timeit from multiprocessing import Pool +import gzip + +def save_zipped_pickle(obj, filename, protocol=-1): + with gzip.open(filename, 'wb') as f: + pickle.dump(obj, f, protocol) + +def load_zipped_pickle(filename): + with gzip.open(filename, 'rb') as f: + loaded_object = pickle.load(f) + return loaded_object import pyconll @@ -123,6 +147,8 @@ def decode_query(orig_query, dependency_type, feats_detailed_list): def create_trees(config): internal_saves = config.get('settings', 'internal_saves') input_path = config.get('settings', 'input') + # internal_saves = filters['internal_saves'] + # input_path = filters['input'] hash_object = hashlib.sha1(input_path.encode('utf-8')) hex_dig = hash_object.hexdigest() trees_read_outputfile = os.path.join(internal_saves, hex_dig) @@ -183,14 +209,16 @@ def create_trees(config): raise Exception('No root element in sentence!') all_trees.append(root) - - with open(trees_read_outputfile, 'wb') as output: - pickle.dump((all_trees, form_dict, lemma_dict, upos_dict, xpos_dict, deprel_dict, corpus_size, feats_detailed_dict), output) + save_zipped_pickle((all_trees, form_dict, lemma_dict, upos_dict, xpos_dict, deprel_dict, corpus_size, feats_detailed_dict), trees_read_outputfile, protocol=2) + # with open(trees_read_outputfile, 'wb') as output: + # + # pickle.dump((all_trees, form_dict, lemma_dict, upos_dict, xpos_dict, deprel_dict, corpus_size, feats_detailed_dict), output) else: print('Reading trees:') print('Completed') - with open(trees_read_outputfile, 'rb') as pkl_file: - (all_trees, form_dict, lemma_dict, upos_dict, xpos_dict, deprel_dict, corpus_size, feats_detailed_dict) = pickle.load(pkl_file) + all_trees, form_dict, lemma_dict, upos_dict, xpos_dict, deprel_dict, corpus_size, feats_detailed_dict = load_zipped_pickle(trees_read_outputfile) + # with open(trees_read_outputfile, 'rb') as pkl_file: + # (all_trees, form_dict, lemma_dict, upos_dict, xpos_dict, deprel_dict, corpus_size, feats_detailed_dict) = pickle.load(pkl_file) return all_trees, form_dict, lemma_dict, upos_dict, xpos_dict, deprel_dict, corpus_size, feats_detailed_dict @@ -333,123 +361,8 @@ def create_ngrams_query_trees(n, trees): # tree['children'] = [{}] return trees - -def main(): - parser = argparse.ArgumentParser() - - ## Required parameters - parser.add_argument("--config_file", - default=None, - type=str, - required=True, - help="The input config file.") - args = parser.parse_args() - - config = configparser.ConfigParser() - config.read(args.config_file) - # a = args.config_file - # config.read('config.ini') - # create queries - tree_size = 0 - - # 261 - 9 grams - # 647 - 10 grams - # 1622 - 11 grams - # 4126 - 12 grams - # 10598 - 13 grams - (all_trees, form_dict, lemma_dict, upos_dict, xpos_dict, deprel_dict, corpus_size, - feats_detailed_list) = create_trees(config) - - - - # if config.getint('settings', 'tree_size') == 2: - # tree_size = 2 - # query_tree = [{"children": [{}]}] - # elif config.getint('settings', 'tree_size') == 3: - # tree_size = 3 - # query_tree = [{"children": [{}, {}]}, {"children": [{"children": [{}]}]}] - # elif config.getint('settings', 'tree_size') == 4: - # tree_size = 4 - # query_tree = [{"children": [{}, {}, {}]}, {"children": [{"children": [{}, {}]}]}, {"children": [{"children": [{}]}, {}]}, {"children": [{"children": [{"children": [{}]}]}]}] - # elif config.getint('settings', 'tree_size') == 5: - # tree_size = 5 - # query_tree = [{"children": [{}, {}, {}, {}]}, {"children": [{"children": [{}]}, {}, {}]}, {"children": [{"children": [{}, {}]}, {}]}, {"children": [{"children": [{}]}, {"children": [{}]}]}, - # {"children": [{"children": [{"children": [{}]}]}, {}]}, {"children": [{"children": [{"children": [{}]}, {}]}]}, {"children": [{"children": [{"children": [{}, {}]}]}]}, - # {"children": [{"children": [{"children": [{"children": [{}]}]}]}]}, {'children': [{'children': [{}, {}, {}]}]}] - tree_size_range = config.get('settings', 'tree_size', fallback='0').split('-') - tree_size_range = [int(r) for r in tree_size_range] - - if tree_size_range[0] > 1: - if len(tree_size_range) == 1: - query_tree = create_ngrams_query_trees(tree_size_range[0], [{}]) - elif len(tree_size_range) == 2: - query_tree = [] - for i in range(tree_size_range[0], tree_size_range[1] + 1): - query_tree.extend(create_ngrams_query_trees(i, [{}])) - else: - query_tree = [decode_query('(' + config.get('settings', 'query') + ')', '', feats_detailed_list)] - # order_independent_queries(query_tree) - - - # set filters - node_types = config.get('settings', 'node_type').split('+') - create_output_string_functs = [] - for node_type in node_types: - assert node_type in ['deprel', 'lemma', 'upos', 'xpos', 'form', 'feats'], '"node_type" is not set up correctly' - cpu_cores = config.getint('settings', 'cpu_cores') - if node_type == 'deprel': - create_output_string_funct = create_output_string_deprel - elif node_type == 'lemma': - create_output_string_funct = create_output_string_lemma - elif node_type == 'upos': - create_output_string_funct = create_output_string_upos - elif node_type == 'xpos': - create_output_string_funct = create_output_string_xpos - elif node_type == 'feats': - create_output_string_funct = create_output_string_feats - else: - create_output_string_funct = create_output_string_form - create_output_string_functs.append(create_output_string_funct) - - result_dict = {} - unigrams_dict = {} - filters = {} - filters['node_order'] = config.get('settings', 'node_order') == 'fixed' - # filters['caching'] = config.getboolean('settings', 'caching') - filters['dependency_type'] = config.get('settings', 'dependency_type') == 'labeled' - if config.has_option('settings', 'label_whitelist'): - filters['label_whitelist'] = config.get('settings', 'label_whitelist').split('|') - else: - filters['label_whitelist'] = [] - - if config.has_option('settings', 'root_whitelist'): - # test - filters['root_whitelist'] = [] - - for option in config.get('settings', 'root_whitelist'). split('|'): - attribute_dict = {} - for attribute in option.split('&'): - value = attribute.split('=') - # assert value[0] in ['deprel', 'lemma', 'upos', 'xpos', 'form', - # 'feats'], '"root_whitelist" is not set up correctly' - attribute_dict[value[0]] = value[1] - filters['root_whitelist'].append(attribute_dict) - # filters['root_whitelist'] = [{'upos': 'NOUN', 'Case': 'Nom'}, {'upos': 'ADJ', 'Degree': 'Sup'}] - else: - filters['root_whitelist'] = [] - - filters['complete_tree_type'] = config.get('settings', 'tree_type') == 'complete' - filters['association_measures'] = config.getboolean('settings', 'association_measures') - filters['nodes_number'] = config.getboolean('settings', 'nodes_number') - filters['frequency_threshold'] = config.getfloat('settings', 'frequency_threshold', fallback=0) - filters['lines_threshold'] = config.getint('settings', 'lines_threshold', fallback=0) - filters['print_root'] = config.getboolean('settings', 'print_root') - - - # for tree in all_trees[2:]: - # for tree in all_trees[1205:]: +def count_trees(cpu_cores, all_trees, query_tree, create_output_string_functs, filters, unigrams_dict, result_dict): with Pool(cpu_cores) as p: - start_exe_time = time.time() # 1.25 s (16 cores) # chunked_trees = list(chunkify(all_trees, cpu_cores)) # if cpu_cores > 1: @@ -531,8 +444,133 @@ def main(): else: result_dict[key] = {'object': r, 'number': 1} - print("Execution time:") - print("--- %s seconds ---" % (time.time() - start_exe_time)) +def read_filters(config, feats_detailed_list): + tree_size_range = config.get('settings', 'tree_size', fallback='0').split('-') + tree_size_range = [int(r) for r in tree_size_range] + + if tree_size_range[0] > 1: + if len(tree_size_range) == 1: + query_tree = create_ngrams_query_trees(tree_size_range[0], [{}]) + elif len(tree_size_range) == 2: + query_tree = [] + for i in range(tree_size_range[0], tree_size_range[1] + 1): + query_tree.extend(create_ngrams_query_trees(i, [{}])) + else: + query_tree = [decode_query('(' + config.get('settings', 'query') + ')', '', feats_detailed_list)] + # order_independent_queries(query_tree) + + # set filters + node_types = config.get('settings', 'node_type').split('+') + create_output_string_functs = [] + for node_type in node_types: + assert node_type in ['deprel', 'lemma', 'upos', 'xpos', 'form', 'feats'], '"node_type" is not set up correctly' + cpu_cores = config.getint('settings', 'cpu_cores') + if node_type == 'deprel': + create_output_string_funct = create_output_string_deprel + elif node_type == 'lemma': + create_output_string_funct = create_output_string_lemma + elif node_type == 'upos': + create_output_string_funct = create_output_string_upos + elif node_type == 'xpos': + create_output_string_funct = create_output_string_xpos + elif node_type == 'feats': + create_output_string_funct = create_output_string_feats + else: + create_output_string_funct = create_output_string_form + create_output_string_functs.append(create_output_string_funct) + + result_dict = {} + unigrams_dict = {} + filters = {} + filters['internal_saves'] = config.get('settings', 'internal_saves') + filters['input'] = config.get('settings', 'input') + filters['node_order'] = config.get('settings', 'node_order') == 'fixed' + # filters['caching'] = config.getboolean('settings', 'caching') + filters['dependency_type'] = config.get('settings', 'dependency_type') == 'labeled' + if config.has_option('settings', 'label_whitelist'): + filters['label_whitelist'] = config.get('settings', 'label_whitelist').split('|') + else: + filters['label_whitelist'] = [] + + if config.has_option('settings', 'root_whitelist'): + # test + filters['root_whitelist'] = [] + + for option in config.get('settings', 'root_whitelist').split('|'): + attribute_dict = {} + for attribute in option.split('&'): + value = attribute.split('=') + # assert value[0] in ['deprel', 'lemma', 'upos', 'xpos', 'form', + # 'feats'], '"root_whitelist" is not set up correctly' + attribute_dict[value[0]] = value[1] + filters['root_whitelist'].append(attribute_dict) + # filters['root_whitelist'] = [{'upos': 'NOUN', 'Case': 'Nom'}, {'upos': 'ADJ', 'Degree': 'Sup'}] + else: + filters['root_whitelist'] = [] + + filters['complete_tree_type'] = config.get('settings', 'tree_type') == 'complete' + filters['association_measures'] = config.getboolean('settings', 'association_measures') + filters['nodes_number'] = config.getboolean('settings', 'nodes_number') + filters['frequency_threshold'] = config.getfloat('settings', 'frequency_threshold', fallback=0) + filters['lines_threshold'] = config.getint('settings', 'lines_threshold', fallback=0) + filters['print_root'] = config.getboolean('settings', 'print_root') + + return filters, query_tree, create_output_string_functs, cpu_cores, unigrams_dict, result_dict, tree_size_range, node_types + +def main(): + parser = argparse.ArgumentParser() + + ## Required parameters + parser.add_argument("--config_file", + default=None, + type=str, + required=True, + help="The input config file.") + args = parser.parse_args() + + config = configparser.ConfigParser() + config.read(args.config_file) + + + + # a = args.config_file + # config.read('config.ini') + # create queries + + # 261 - 9 grams + # 647 - 10 grams + # 1622 - 11 grams + # 4126 - 12 grams + # 10598 - 13 grams + (all_trees, form_dict, lemma_dict, upos_dict, xpos_dict, deprel_dict, corpus_size, + feats_detailed_list) = create_trees(config) + + filters, query_tree, create_output_string_functs, cpu_cores, unigrams_dict, result_dict, tree_size_range, node_types = read_filters(config, feats_detailed_list) + + # if config.getint('settings', 'tree_size') == 2: + # tree_size = 2 + # query_tree = [{"children": [{}]}] + # elif config.getint('settings', 'tree_size') == 3: + # tree_size = 3 + # query_tree = [{"children": [{}, {}]}, {"children": [{"children": [{}]}]}] + # elif config.getint('settings', 'tree_size') == 4: + # tree_size = 4 + # query_tree = [{"children": [{}, {}, {}]}, {"children": [{"children": [{}, {}]}]}, {"children": [{"children": [{}]}, {}]}, {"children": [{"children": [{"children": [{}]}]}]}] + # elif config.getint('settings', 'tree_size') == 5: + # tree_size = 5 + # query_tree = [{"children": [{}, {}, {}, {}]}, {"children": [{"children": [{}]}, {}, {}]}, {"children": [{"children": [{}, {}]}, {}]}, {"children": [{"children": [{}]}, {"children": [{}]}]}, + # {"children": [{"children": [{"children": [{}]}]}, {}]}, {"children": [{"children": [{"children": [{}]}, {}]}]}, {"children": [{"children": [{"children": [{}, {}]}]}]}, + # {"children": [{"children": [{"children": [{"children": [{}]}]}]}]}, {'children': [{'children': [{}, {}, {}]}]}] + + + + # for tree in all_trees[2:]: + # for tree in all_trees[1205:]: + start_exe_time = time.time() + count_trees(cpu_cores, all_trees, query_tree, create_output_string_functs, filters, unigrams_dict, result_dict) + + print("Execution time:") + print("--- %s seconds ---" % (time.time() - start_exe_time)) # test 1 layer queries # # tree.r_children = [] # # tree.children[1].children = [] diff --git a/generic.py b/generic.py index 4c3899e..1e3156e 100644 --- a/generic.py +++ b/generic.py @@ -1,3 +1,17 @@ +# Copyright 2019 CJVT +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + import math import sys diff --git a/logos/CJVT.png b/logos/CJVT.png new file mode 100644 index 0000000..c534425 Binary files /dev/null and b/logos/CJVT.png differ diff --git a/Clarin-SI-logo.png b/logos/CLARIN.png similarity index 100% rename from Clarin-SI-logo.png rename to logos/CLARIN.png diff --git a/logos/FF.svg b/logos/FF.svg new file mode 100644 index 0000000..0ffebd0 --- /dev/null +++ b/logos/FF.svg @@ -0,0 +1,3773 @@ + + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + eJzsvWuvJMeRpvmdAP/D2Q8CRGBZHfcLd7HAufZop9UidJnpQWNAVJMldU0Xq4hisXs1v37dzN/H +3C3z8KKenlELGAYk0v1kRGZGeDxhZuFPxs/+j89/8+ntV+/+4dWn84vh5uOPfvaz+/evXn549/6z +G++++cWbN999++G9df3815/cjOVl9qrbXxxf6JX/6dX7b1+/e/uZ/63+9cnW//l/f/3PLz+5+fkn +1vPb1x/evCp9v3v7wf7rq0+nT+LNysoPLz+Uv47DXx1/NQ3jXP7rs3G8uf2lvebu3Xdvv3r99g93 +7/6/z24+3ZebT8dxvRnLPzfHdtor/sPrX7/69uJl84ttPjd77fJiXKfZVhheHMd0lLWOF8s5TLbq +w7svv/v61dsPn79/9+Wrb7+9f/fm3ftvP7u5/+PLtze/fPmH8peXN//l1Zs37/7l5u7Nyy//qaxz ++4v1i6fXb16VL/n1yw83p3/l21+M0xd3371+89Xffvf1P7wqX38ZNu+fv/CN/u7bsrWyYftv79+/ ++MXXpes3rz58KJ+6vKfvuftf/pf/2H+WslO0/Pzvf/3qD6/9UJQd9l8/YePv333z9cv3/1Q28Om8 +60vvh77zsC/6zvPEd7a1fvvq62/elH3uO2uZxhfrzXRuL/Z9XS6arFC+sL94XIYX87EctmfHF9M2 +7Tf7UFYYlrP8x/ZinXe+d9u3r/759at/+ezmb9+9faUdePv+w29e//eyQ45lLJ/wPG7Wc30x7eum +F/z6uzev3v/u7esP5YuN3nfWHfnLd1+9evPZzdQ29PTmpe8/X8b2/3rFb1++/8OrD2WEvHvz3Qcf +qMfA38rB+puXf3z1vnuTX33z6u1v3/0n/8CfrmVvjsO52CdbboayX8Zhnm+OcbkZj/pO43kzlkFZ +33X0dx61dduUbYi32O0If14O+q/ev/7D67ef8Rn3L/76/euv2kiYjhfzstl79f/p3+nF0f3v5H/6 +6GVHfPjw6i3fpYzI+19242t48cvf2Cd4fPvV/buv7ch86+dXGVZvy5h78+4P+mtr+N/KJr77Rl/J +O74oB/Lz96/f2oY//uhv69+OLz5/813541+/f/fdN794+/t3H3/084qQz19++Mdy9rx6+9W3BQe1 +rzZv6iql929e/zOdL16+/uaTH9nkb/749T+8e/P6269jg31P/PdP2dRv37/8snyPm1/9w3979eWH +srY62n/95rvXH179lE19brv//dtfva3f+P133/7jzW/fvXsTH1Iv0J/iy5cxXNf5d/Mm8eLn3qD8 +8d/vxu9fvnnz+g/vX37zj6+/fG77z/w93uh71v0pb1tOvfev2pa8Wf79e/v3TxrQX/pRe+4T5z/F +W1yv8e/jfexA/f7126/KKn7itD3/7utv7Bp985t/fPmNddsrn7pX/pTP//Dq9+Wy240N7318+8+v +3rz7pjsA0fOyvOF/fvn+m590ar15+fbl+xv/Q2zbyfT5y0K7C1p5X9vs+kUhZ0/GTz/9YWauN3dv ++1f89fuXX70uUP7Mtv/2lX+Q2nMzlrd4prNcEKabu68+/ujvP/7o//74o6enp8enh6f7p7un26fz +6Xjan7an9Wl5mp+mp/FpeHx6fHx8eLx/vHu8fTwfj8f9cXtcH5fH+XF6HB+Hh6eHx4eHh/uHu4fb +h/Ph+Pijh/1he1gflof5YXoYH4b7p/vH+4f7+/u7+9v78/643++3+/V+uZ/vp/vxfrh7unu8e7i7 +v7u7u7077467/W67W++Wu/luuhvvytXu9un28fbh9v727vb29rw9bvfb7Xa9XW7n2+l2vB3Op/Px +fDjvz7vz9jzP49zP7VzP5ZzP6RzP4Xg6Ho+H4/64O25L1FA+47GXeG4tEclc4pzxGPan/XF/2O/3 +u/12P/dj3/dtX/dln/dpH0uI8rQ9bg/b/Xa33W7ndmz7tm3rtmzzNm3jVj7j+rQ+rg/r/Xq33pao +5FhLVLKu67LO67SOJdJ5Wh6Xh+V+uVtul3M5ln3ZlnVZlnmZlhIfzU/z4/ww38938+18zuUzzvu8 +zeu8zPM8zeM8TE/T4/Qw3U930+10Tse0l0BqnZZpnqZpLBHw0/g4Poz34914O57jMe7jNq7jMs7j +ZHHsxx8N5XAO5YAMd0PZaUP52sM2lI82lI0Po8U3/0950c3Pvrh778PDwpO1xBCD91kY8EXXdVcC +gbE229+jw/5699AGOSPwJw7e6bnBO9ngXbrBWz785stelqMspy+3Zbkry70vD2V59OVpeBrL9xzr +P2WflV1jS9n/ZUetYwkjyy7byo7by+6zpYyesjNtKSOx7FpbypguO9qWcn5Mgy+2sfpPOVblkNiy +2vLxR+UglXjXl8OXMibLAbSljO9yOG158OXRl3LezYMv9eP5Jmf7Z7GlDIzVl82X3ZfDl9OXW1/u +fLn35cGXR1+ebFkGLf7VP/6ofuBl1lL/WbVsvuxaDi2nllstd7GUM7ts8V7Lgw+qcqy0/ubDfvWh +v+j9Jj8FbBn8RHjyk+HRT4gHfYc7PzFu/eQ4dYIc+vabnyirnyyLnzCz9lrdg743bb9qD9e9Xff8 +nZ9OtpSA2I9NPUr1iG1+iq1+mi1+qs1+uk1+ytnix99Ggp9+j34KPvhpWJYynu58qWPo9KWOrF3L +5svqS90J+tB18yP/2Lgdhic/iZ/8RH70k7ku91rutNxqObUcseyx1DOnjHmHgC8cq2sI/48h+OOP +nsPwBYS/D8PPgbiMqisYdzh2GGcc90DukRxQLiP07MDc0NzgDJ4d0Bp5q0ZcHWuDxpiPrjKe6tg6 +NZ42jaRZyB41dhg19zFWTgF8j9HhH6SMpxgZFdaG4MprO8V+0pXlJ1xXdFUpX+AnXFeev6owlBzR +u6P51pFsMH5yCE+O3tWBezho7wTYRwfr6Dg1kG4OT8PmXflM947KJwfk5FhcHYSHw+/OgffokBsF +tcUxtvOZIpYhmiGeIaIhpiGqKXGNRzXENYpsiG0+/ijiGyIcYhyiHOIcIh1ineOZw3jWfw5fdi2b +ltUX8Fth6NiqcIkT/skX/44l3Hnw5V7LnS+3vtS3qf/svmy++CkD7OvlpYLRztSyxVE4efLl0ZcH +X/zblzP4zs/iWz+TTz+bDz+jd53Vdl6vfm6X5eOPHOUVuxWNFVJPvjz64kegnPf3fu7f+fl/6ww4 +nQOHs8BoUP4phFhFhcXJMDsdJieELY6/QorKCqPFgxPj3qlx5+S4dXqclSAlyKsfuW64/lMvZpUp +k3PFFsdp4cuTGGOUedAVsV4lb404dTiK+z+8zD+6TCxli9Ozy4/9M3zfUrao68+PLI8/uDy0pYz5 +h6vl/geXux9cyt6Mq95zy/mDy/HcUrZ4fdW8XrYfXNa2BBJrRPrUYRAQ9ii861DYwzDhUNeZDMRr +JF5DcVFst3ssd+tx20MZp0/2UctIH8sbzeUlaxnpexn9ZzkT7vzceCjnylP5amM5k+ZyZq3lZNvL +mXeWM/HOz82Hcq4+lV0zlnN5Lmf3atXdctYfhQK3hQr3hRKPxo2ya8dCFCsNr+Xk3Q8r6t4WNt0X +Wj0eT+XQjIVscyHdWk7xvaDqLPFFIedZvnXh8uP5VA7uWC6yczmh1gKDvUDtLDHKXWHxQ4lZnsrg +GEsMM5eTbi3I2Av6zgLfu4Lhh4LjpzK0xrIT5/vCoPL1tgKvo0D8tuD8vmD98f6pHK6xAH8up/Ba +ALQXlJ7lsnBXLg8P5ULxVIb2WC4dcznN14KpvSD3LBeYu0u0W0b1Yr4ZXgyT/d/uxd/L/Or7XmD5 +lP4wWRl3n/yvy/ximI+bfXwxF0p3m/mxV9btTSfvdk682zy8sGtCt60felXdzmYvsDcb1vqC6YWN +n5v+i33/a/7EXPHX5b9evrkodFx3lrf434WO/13o+CmFjh8uY/x4GeR/YPBOzw3e6XLw/uCl7acs +F5fLssUfvpz+ycuPbvGHL+7PLGWLf/I6P7B8X9DRhST/yozlB/OVZy7PP5avLN97YdZFuZyEl5fl +H7soP3NJ7i/I5fLsl+R/9QX5/vJiXGD2/ZfjmX3tg3P0dSZfb1Y9afW1N9/CXjOVsh3b0q1vzbZ3 +79u0rdryZNsup+Lg72CX/Mkv+7PqUqtf/real3gG5HGEbequ/nPvIcGDhwUlMLDlvmzRA4TRg4Sp +1qI8jq+ZwuYBw+5Bg4UNp4cOFjzceQBhIcSDhxElkLDloWzRA4rRg4qp1uYsO6j5h+c4NZM6PNA4 +Pdi4rR/MN1b/ebTQw5bHskUPQUYPQ6ZaOfOsw/Ka7dkwZJhPjzHG0y7LZbyuXNj7S/YPvUoByWoR +Rr2lbEHG9mLY9uUipPmBF/2J9Pzd27cvv3711c0fIOWxGT+f674k6A+c+T8h+fifTSe2+L+WyT++ +XFxH/g2uRNqOCo3z9xYX/1WBTwl4ni8uXgc+PzH08TJCLizm4Of7wp/nA6DJy+05CLqsyuUwKAdC +fSgUwVA5t1tA1EIigiKFRVGpe9A4u1Xquys8igQ1amKLWFIrY7YMqo89OX8enUT3qpTdOaeolx1e +M/OqWSHe5mzzKoiIN3nQPEYd7cnD50fxsv5zp5rarch6qLa2FyrXOtCqKtsiMk+qto2qGTyp6vYo +slcw1/rbrYfhJ3U4D8j3Wleq9R9dOeq9lHo9qfX8uvuefNw++th98PF772O4LmWM+7Xq9KVewWo9 +bNPorku93unehq6Dul9QT5bn+f08Un8CdYPc38v2C3j/4Ot+hN9/4t1tnwFWpxbV+SgF+Z+/e/NP +L28e3n1gjooB/7rzZnoxTuvNWLLSbfE015q7Zal2Ev/si+9qXH/7TY3fR039+rs/1vb/W/77v5Xe +f7lZbn558/f/dbj56mPr/7tf29+1Obb+tfXlN/yb1qU3rV35g6S+tOrb+jF+9Wz2/k//az7D72M/ +DbGf6uIfYBtf7LttZ3yxrfNcP4F1nta1HuN44y85ffeXKHjx9rJt1l626bz5Uqtsp0oR2zTbi7YC +Pn/RMPhKZWP+PvO8xjprIZn12f0Je81yTIu1hxKp+jqDtctwL5S8uddKs23BOse6zulTD+1DjXUb ++2xt+xi8j8Xd1rfu8+SvWbbD2+O+1XZ9n7KJ9oWWedqsszD+8BeVq4O1y1njX3AdB3+jEj8fbS8M +5XzcznII5q3uumO29lYuTtY+y1XF2uuy807l6M61cz7PsvL0Yi5kv9mO8rXXzdrrOu/eHvdYZ5/9 +JUc5d0vrnO3fZxlktlPm8pm23ds2cbGuMpe9vJ3WOQ6Tv6hcyUZ/0VIOb2lvZafYn8fYc7NNydy8 +8xwXe81+rv79lrLbrX2um29jLdcwrbS8sEuPf+nZPsXyomRAk79ot6GxaIiUv4/zHCuVLXjfUfZ6 +ae7D6O1jr81yOfWdbUeQVfZ19sM6rqtvd1/8qE7jfnjTvq+1S0gR65RR6Id6ttPG2g== + + + xzH5oV9tZ5T2tnu7jMBupRJT+JgqA+mm20i5zHpz0BDc56V9uJJ4+flZopL6osVfdJ57faOhfBM7 +ZcehrXQMg58QZQTUTzfWM28p48m/UglI/GTdhrYb5mUtWyrDZrF3Kse1fCdrr+Xg2eDYSxxgbT9m +jJ91H/xFy+gDqIRDp29jskNV/j2UM7C0S1wydeP08Dcq3362F43b6SsN++an1XkO/vdhPLY4I0pA +4t/zPKepnhGLn+NHORVqe/X2XkK/WKkeuvI9S1znLzrqfinrViIde90PZbDABYvtvK+k1P6aEuV5 +ex5Ob6/bUUFXhrKv9GT/ty7lhFgvEGid0xwMtOY4NQaW9lDC1cxA65zqx/YBvpazY9sbA609Llti +YOk7tqUx0Nrj2hho7Xm9YOBqp+oWDLTXTGtjoLeHzEDf7t4YWNoV6mKgt9cLBlqn70Mx0Nrn1Bho +Gy3BbWagfctlaAz0XTc2Bq42h/q4YGDpLERuDCztslcaA1c7T7fMwHUtnFlg4GqTxofGwNJepvOC +gaVzG87GwNIuAXhj4FriqWHMDCx9JSrfg4GlXUZCY6D9/TgvGFg6Z78AiIGlve5bY2Bpl1zngoGl +8zjXYOC6lzhtCQZacx8vGGidx9YY6O0yXoFgaY/2hRMErdM4BgRL29KOgKC1h+ECgrbSOTQIdhsx +CFpzXi8gaJ3j3CDoL9obBL29XUDQO+cGQWuvU4OgfcVyTmYI2v7cjwZBP7Bjg6CNlWO+gGAZVKff +PqkQLE3LQAOCPgbHCwjaQN3HBsHSLjFKg2Bp+8oJgjbkbQtA0ImzNwh6+7iAoHeeDYJ+Hs0Ngk6o +IUPQCHSeDYLePhoErX2cz0GwZBLLfGYGWt+6rQFBa5fLREDQ2iURzRAsnfM2LAFBaw/DERAs7anG +8sHA0jWW7D0YaO1yqIOB1t6OMzNw2cCf/Xk9p8Cft+uoC/x537gE/qw9VnI5/qw91Ldo+LPs6jzH +wJ+9qEaETj9r7jWMbPSzr7fPZ9DP99lyBP1KexvHI9OvdB5D7XT6lfZZLmZBv8VO0DLUe/qVvvm0 +mK/irzS3Cl2nX2nuW425Gv1K57nMS9BvOV7YjImgX2nP87Jm/JXOVZGZ46+0fQ+Bv9LepmnL+Cud +u7jq+CvtEgXsgb/FPuZxZPyVzmk6Gv9Ku6y7w7/SLJeVI/PPOqdKJeeftcc6NJx/1ravnPhnnSWu +Cv6V9rrW2Mz5Z+153jP/rHOq0abzr9uI8c+amwZh8M/fvSYjzj9r7xW0zr+60p755501UHH++RvV +s875Z7vlHLfMP9uhYxka8M8Ore0P+FcO/VL/3PBno2reZ/C3GHdtVwp/Pggt2Ozx5yN12QN/1p63 +JfBnw3vd9oy/xS5+6x7483NiOAN/3h7PjD/vnJfAX4XPEfhzOM1bwp9DrALJ8eftaQz8WXuqCL3A +33w8kwZbZ0uD/SVdGmztqzS4dKY02Np9GlzaV2mw9fVpcGmnNNj+fpUGz0dKg22dPg32bVykwd7X +pcHW7tNgb1+mwdbZp8HW7tNg+3BXabB96z4N9l3XpcGlfZ0Gz2dOg0s7pcHzeZ0Gl74uDS6tlAYv +wzNpcOlMaXBppzS4tK/S4GXIaXBppzS4tK/T4GXMaXBppzR4GZ9Jg0tnnwaXZp8GW/MqDbbOPg22 +dpcGL+MzabCpln0a7OpllwZb+yoNts4+De424gQcn0mDlzGnwf6iLg329mUa7J1dGuxv1KXBttGr +NNh2Z58G23Ht02AbKldpsI2pLg2ez5wG2xC8SoN9nHZpsLX7NNgG91UaPB85DfYzokuDvX2ZBntn +lwZbu0+DvX2RBltfnwZ7u0uDrf18GjyPz6TB1tmlwdbs0+DSvk6DrbNPg+chp8HWvkyDbeZRnwZb +u0+DrX2VBs9DSoPtNX0a7O2LNNi326XB85DTYG9fpsHW2afB1u7TYNvoVRps37JPg33XdWnwPD6T +Bs9jToNLO6XB83idBs9TnwaXVkqDzfa+SoNLZ0qDSzulwfN8nQaXvpQGl3ZKg+3vV2lw6UxpcGmn +NLi0r9Pg0tmnwfOS0mBrXqXB1tmnwd7u0uB5eSYNts4+DS7tlAZb+yoNtpX6NLjbiEHQmldp8Lzk +NNhf1KXB3r5Mg72zS4PnJafB9hWv0mDbn30a7Ae2S4NtrFylwfOY0uB5zGmwj8HLNNgGap8Gz2NO +g0v7Og22Id+nwU6cLg329mUa7J1dGuznUZcGO6Eu0mAjUJ8Ge7tLg639fBo8zddpsPX1abC1+zTY +2ldpcOlMabC1+zS4tC/T4NKV0mBr92mwta/S4GkGf/bnPg329kUa7H1dGmztPg229lUaPM05DbYX +dWmwNa/SYPt6fRrs+6xLg0v7Og0unSkNLu2UBk/LdRpc+vo0uDT7NLg0r9Pg0pnS4GnNaXBpX6fB +pTOlwaWd0uDSvk6DS2dKg0s7pcHT9kwaPG05DZ62lAaX5nUabJ19GmztPg2etmfSYOvs0+DSTmmw +ta/SYOvs0+BuI8Y/a16lwf7uXRps7T4NritdpMHe2aXB/kZdGmy75SoNth3ap8F2aPs0uBz6qzTY +RlWXBk9LToN9EF6mwT5SuzTY2n0abMP7Kg2e5pwG+znRpcHevkyDvbNLgyt8WhrscLpIgx1iXRrs +7S4NtvbzafC4PpMGW2dLg/0lXRps7as0uHSmNNjafRpc2ldpsPX1aXBppzTY/n6VBo9rSoNtnT4N +9m1cpMHe16XB1u7TYG9fpsHW2afB1u7TYPtwV2mwfes+DfZd16XBpX2dBo9bToNLO6XB43adBpe+ +Lg0urZQGj/szaXDpTGlwaac0uLSv0uDSl9Lg0k5pcGlfp8HjkdPg0k5pcGlfp8Gls0+DS7NPg615 +lQZbZ58GW7tLg8fjmTS4dKY02Np9GmztqzTYOvs0uNuIEdCaV2nweOQ02F/UpcHevkyDvbNLg/2N +ujTYNnqVBtvu7NNgO659GmxD5SoNtjHVpcHjltNgG4JXabCP0y4NtnafBtvgvkqDxzWnwX5GdGmw +ty/TYO/s0mBr92mwty/SYOvr02Bvd2mwtZ9Pgw/Lgpc9I/CwLHhoIeBhZ4WgaBA8LA1ezwzBw9Lg +GnX6CN8tDZ7OgOBuafCaIbhbGjxtAcHdx9YcENw9DV4zBPeUBu+WBVeeOQN3z4LHxEDbrBEIBu7G +dKXFxkBr62RqDNx9F87BQDv7p3qKOQN3y4IrIxsDd8+C52Dg4VlwY+DhWfCUGWi3GI4aTDkDD8uC +hz0YeHgWnAPBwi3/yTNB8PQ0eAwI2n2Cs/KuQfC0NPjYAoKnp8Frg+BwnQeXvpQHl3bKg+3vV3nw +OOQ8eBxyHlza13mw/UpdlwePY8qDrXmVB1tnnwd7u8uDx/GZPNg6+zzYfs2tz4OtfZUH20p9Htxt +xCk4PpMHj2POg/1FXR7s7cs82Du7PNjafR48js/kwbY/+zzYDqx9fyh4PpMGH54Fj0DQav9bBadD +8HgmCz4sjh3PYKAX6s85GHj4qktmoF3/phrmOQMPT4KnYODxTBJsfSSwhkA7i+apRYGH58BTQuDh +OXCLAg/PgedA4OE58PIMAstxn31SYWLg4Fnw0oqBg8VN+74HBQfLg4fjIhYcLBE+WiY8WCLse0kc +HCwTHipyA4TGlH3aGgkHT4YrGh2Fg2fDlywcwKCdAWW0jsHBwdPh4UwgtM7RzkhIONQ9OwYKBzsc +R2VlY+FQd2aDoVFgPetgdhoOlhXv60VePHhaXNHmPBw8L56WAOLgifG4ZSIOlhnb1kCifWenccSF +nhuPOS603HgJJo4pN7b5UXPNtruw0FLjuRFx8tR4abmxpcbLfpEbW2pcsVlzY99RY8uNLTVeL3Nj +S427uHCyyGBrufHsqfF4URr01FiBoRVVy5DSvvLaoKXG9TLW1QY9NR5bbdBS43VttUFLsObtojZo +WW0dW7U2aKlxBWutDVpqXNtdbdBT47nVBj2BmaI26KnxclEbtNR4X1ttEKRQG/TUeL6oDebUePbM +uKXG8zOZ8eyJcSOiEWud9hYXlr2i8K2LC1NmbCAe5j2IaENwHc4jM9FG6iJwOhQHT42nLag4eG5c +C44Ni3b+lbBlCS7amTEuwxZg9A67IiY0Wq//DCls7LHkcBw8Q66ZZdBx8BS5hnSOx8Fz5BqeOR8H +T5IbH78MPv7V7fsPD6+/tJ8Qffn+jzefWd/P/SwvA+qTm7/6zYf39juSP7+7u/3yy+++/vW7D/5L +rZ/c/J/+ytvuJf4LeP5rl/YbeL944DX/8Xtf89s/2k/m+av+L/s/+9/vKvlG/d4p09/Lf31l/7Xd +/PyTm7/7z/afmgj+K14Q88AvJ8/buXtZCLW+vhDq5/fWTQw/nymEGrC2oZsYbvfUhm5i+HlVCHWO +7N288DMXQq19VQitJ+MpDK1HNyX8vC6Eel9XCHWedYVQ599lIdQg6FdhpoSfqRBqzatCqH29vhDq ++6wrhDreLguh9uK+EFr+nQqhhqrLQqiTqhVC7ct2sLd9cVUItf3VF0KNMX0h1I/JZSHUDnZfCPWD +3RVC/SS7LITaqdgXQvcxF0KNBFeFUMNKFEJn50ehfQTARqWrQqh19oVQR1dXCHW8XRZCrfMYWwBs +TOwLoda+KoRaZ18I9Y1MEQBb86oQ6u++twDY2n0htK50UQj1zo72/kZdIdR2yxXuHa1dIdS22BdC +7atdFkJtn3S4t13YF0J9EF4WQn2kdoVQa/eFUDt2V4VQP+pdIdSHztjNCT+fKYR659ww38Gnzgk/ +rwuhDrGuEOrtrhBq7b4Q+m+G+Ls/I+J/Ct1tzsvq4yNH+Gvh2dkAP5DPtAC/jOl6EPoA30OHqY/w +121Z1i7CLwNprDfxugh/WudlbPe7SsewDvUGmCL8EjYO9e58F+GXP/rRjEB/ssxz6QL9SZlPCvSn +Ya8rEedvp0hAnL+tw2XNwzBSzti1j/OPGiZEnF9Ojppm9GH+XC5y+9GF+eswnPUuDmH+tqsgkcL8 +da+Rcy3+lpTfudmC/ILxi+JvDW+6IH8bakisMP8Yzwr5FOafZ62OKMyfxlrtJco/B13Ruih/G+v1 +W0H+agZuH+R7Fe4yyFdxhxh/W4/u9n9JQZdaUE4x/rHUREAx/kLBWDH+NpzLVYzPDA1ifIdwC/H9 +616E+PYL9V2Ev9W8u0X4NT2+iPCPodZxFeGXwEJlDo/w7bcczssI34bV2EX4Je6uA08RflnpOC4j +/HWa6pmoEH9dFCYpxFfacBHj+9hqMf40jsvcx/j7PC5XMX4ZHlsX5B+b6sde+y0j0D3Dixi/pvQt +xD+ntV5eFeKXy5pVwS5CfEs4K6MJ8cuwXtstMOugFNCH+GsX3QeSFNwXQuxb5r5N/Sof6OiDe3v4 +QSN/6bDtT38J6P8u/k9BuQl2w5hjcjPxpoPL4mztY28huTVtHHUhebX5RgXk7v/tNQ== + + + MLWBZjagVR27gLx2TiqIWkBuqhmc2Gp7thlXBOSmHG6qla5VFxzstiARuXmLdt6kkNw6p3pxrpXi +6YWPSEJyaw9n+2Q+N6F0bmeNdy0kN71tqVG3h+Tmt81n+/o1JLchPU4tJLcgtKYxNSS3QbmuXaBT +O/el7rUakjPRhZDcHoWxtAC7xuRjrRkTlNt1UpWpTT7qsLcorAblxvVhakH5WLcVQbldgi9CcvNp +z7GF5MzkISQvp90YESIheek86i2YGpLbi3Qfx0Py0i7AvQjJyx/nocaePjfB+ucWk28ehnfhtcXk +dlA0R8hjcmtv6xIxuR1DK7F2MXm1FxfF4BaT+9HXjCaLyV19XdpKHpNbpwcAbKSMu3VpQflmM1hK +fNMF5X7GTLM+jgXlNpiXWKl6levR1vHbo3afv9aZPSbffB7AGTG5n6l7W8lj8tLpxX5i8tIuIcJK +TL5JQ0oxuXXWJ6zUoNy2sdeTxINy02dtRlMKyjd3kyImL81lqmefx+Tu4W4tkPeY3Drn86gnxXBW +eTdidG+PS8eFeuRMfNzniMmtfdb81WNyg9M+XwTl1mkxJEG5v6imex6UW7uMw1aWfhbM//a4DWe7 +p6ydSevZKGvTmtctKGtTsKflgrJmxNdxU0+zbRnGoKxF2PtygVk7f/exYdYu9sfcMGuT7Gq7w6zx +4Fwaa02IPxtqrVmN3g611jnsDbXGmorNiloT4o/pArUmxNdzv6LWKLPOjbUmxG/jBWvHGtkFa23H +LVNjbaHLWvs71pawYtEPDzhrTYhfz2CtC/HnllnrRvx2BGvtu4mjDls75wf9yEDA1nbaoZ3mp0qJ +s4K0dhh27cLm0PvHhLSbz1ibg7Q+pit5G2ndh9d3NdL6KXUGaP00PKYMWtfh9zNA6z5846yr7suY +Oes+/HkEZ/Hj4awr6XXPNM6aYj6Nc3DW2vU3COrlrjT3OVPWHfl6TJ2ysQlR1i32Y8uU9TfftqCs +q+3DGpT1leoeDcp63zYFZf2N1j0o678KMGbI2t5cxzEgW3/lYAvIug2/zZmybsNXIjplN5APZW0A +LusFZW2ULgHZ0vL7M0B2jJ3TQXasBUoYK609GGvtcb5g7KijBmOtXTdcGWtDb75ArH7UIxBr7fq7 +EBWxo77nJWLdMa17Oti3akoz7HPvdF1hnyum05zZZ51+M97ZZ0Z4xJfWmPYpk89E8vrTBQ4+F9iP +McDnnnltN/CZBL/Xi7mDz035o5HP23MGn/cNW4APoR3wWdtvOvXgczX+mAN8tpFhnQJ81q4/09G4 +Z99yncfgnu+0JbBnQvA5ZuqZWXw06Jl9vK5HQM8MeK8F99AzrdkHrqBnEvxRI0qH3qq5bAl66xrh +oEPPXGkNR+eeSfDjvPfcM8fdz1pxzxx4CG1nkenuio4b99YtLlvOPXPg/QcpBL7StklHiXulr1yY +9uCeyd523w3wud++ZO5Zn832hnvertmFc88E8qle3Rr3rHMbx+CeOe/zfAb4rG1lnkQ+F+PrUfWT +OzYi8uHEJ/L529cMzfeh++w1+3Ly1ZXORD7v2wJ8/j465Qx8/lMAw5HJ5z8pUCM2J58f1gotJ5+N +lXObMvlMgR/r76A4EdalDnzI56NwmTP5fKTWPNTHT/nXuG6BPlPg5/XM6LMRvy5nsA97HfZ5u3K7 +sc8766/BOPu8vQX6nEzTkdlXf6ljDvbFz0+Ifa7Vi42JfS6U7mtin/V5eC32WXur2bGxz/3Sccvs +M+F9r8dzd011HiufjX6mh2/1MtjoZ51jzR4cf+671wDETyBrH7Xd8Gdy+livso4/t9GPlmN7uyKn +8W/RJD34Z22fAyD+ueG+L5l/7srXc9L553r+sgb/XN+vgWADoH0nkdUB6HtubgQ0UXiuUWRDoNnE +9gVhoCnIXqYUA91YrjlpY6CrzVsg0ER40c0RaCb8Me4ZgWbCK05zBJou7dcSIdBM+HXuCWga/L7s +QUDT4I9hDQIuPj9ozAQ0DX5ZtyCgafCTQj0joFnbS80fGgJNg1fU6wg03/vYpkDgQn7UM3BRZUgI +XMixhEB3yms23RBoRvswrIFAa+/zFAh0LX6aMgKtc6nH1REYGxEC3VavpaKGQH/79QgE+otqauQI +9LYSHRDofesSDPQ3Ws5goJv+w5QZaDtU4bIz0I/rfAQDbazM65oZaKNqrbxyBi4AWQz0UTjvmYE+ +VOcJBlqzbtcRaKN7X+eMQNPgz2UKBDpwzjUQ6KdIze0bAr2z5t2OQG/XLTsDnVDTlBnoWx73YKC3 +hz0YiHB/xUA33vclMXC2acdLy31nzV0WA11SrbFlY6B1jschBpoOrvKfMdDt8O0i9535mQkx0KX3 +veW+1p72i9zXJPj1aLmvy+g1TnQGenu6SH59yzVNcgbOPotvDwZae6s5T2Oga+97S36rS78EA93h +rzFhY6DL/1NLfmfN8oaBJgXvw0Xy6zpx7XQGmoM8r4FAN5aPi9zX3eaaIDsDTYTfppb7LjY7rTKy +Y+AQMVtloN0IOxsCbUpqzR3i3Je4GwwcGq6dgeXvxyUCbQbq2pJfs+A3XmQILG937BfZr1nwx9ay +Xxe+a2mhInBU4TQh0Os2Lf319tTSX7fK67WuY2DpXIaW/i72seaxMdAOzTReMNAs3KklwLERGDja +POKLBNjfvqZRlYH2opoiVQaOLecJBlrf2hJgf6OlJcCu/l8QsOzPfWj5rx/VCi8noA2VXcWAIKAN +qnNt+e98VmkAAvoYnC/yXx+oNf224WPNc2kJ8Gy/SLJeJMA24udaZXAEOm/OlgHPUh4SAr2z1iIc +gd5ep0CgA+qCgL7hsWXA3h5aBuzq/PhMBjz7HOQ9E3DU5AYIONbMXwD0+3bHBQA1K1kAtFt9xxoA +tBL/enGPxZ+9UWP8CkCTyre9AdBuutV2B0A7SevVtgJwqG5KANDa43YBQNtyvWdSAWhO/Nj4ZzP4 +tu2Cf4MKXPDPTv1afq/8G2xfrBf8s9v2layVf2M9qsG/MlaHWsfr+Of1y7Xxz278LXMDoJ2hFyGg +ac1nrVtW/k2BNuefSfCb6pzBv3mKiM35Z660X0wEQJPg51qVifeZX/j9XQA4u3K7BwBnHZtEwNlv +YB9BQHO0BwV9RsDS9onOiYCzDbVtDgKa7e01PBFwJovpCThTvREBZ1IhEdBd9XqkGwGt0+fTiIBm +va9TqwBae9ZtuSBgVeX3IGBsRAS0dh2rDYD+7i0N9pfonuESq6yJf97X5cHWPpYx+Oea/7lkAtr+ +HGpY5QT049ruspTmOC4Xt1lsUM0VVhWAwBgA2iCsJdUOgPp5WgBog6KGdxWAZRytNf/uAGgzOOod +kwpAw82xNwBau+bfHQBHHTcAOCoBA4Cj7pwmAvp03bMR0Dz5emOgEnBUwn1JwMknU2yJgBO/FSsC +WtsrABWBLqHW+LIh0Ix3c4oqAq0111DNEGh+uG6gNARO1IaFQDPLj63lwfb3YbvIg81On/eWB1eL +fg4Eenu8yIN9yy0Ndi2+1nkdgW7e12JxQ6B1+pVBCHQdf273mu3TjTUkbAi0rz2OLQ2e6pzwQKCJ +wst5kQa7TXwugcCpHIlxmQKBZizbbIvEQFOb55orOwMn/XohDJz8t2WPzEBT4Y+GQNOlz6OlwWbC +79PYI9A8eN1XcgSaBw+u7XQyD17ha0OgefDb0vJg8+CXfQ4EmrbNHZJA4OSlkpYHu/heywyOQLfK +p4taoHWuLQb05tTy4GqrZwCa0T6eLQ229jnNAUBr7+PFPRDr3MaWBsdGBEBrD9tFGuzvXjMpH+f+ +opolOQK9vec02PuWlgbj34NAN//PizTY9udytjTYj2vFlzPQxspab4o0Btqo2peWBk8O6ECgD8Lp +Igu2kbrUn3T28aPboSKgDe5zuciC/Zcf5jkI6Lg5Whbs7YrvRkA/bRoAvVnvvTgAHU+XIeCkSWAA +cJrjPr4DcJoVFFwCcFxNuszTbKzPI2AB0Nqe/tdvXBX5hD/rmuvB3N1RdSdB+LNmrUE2+plCvi/t +Joi1p7VNsrH2sl5MsjH/vW7W4ecOfS0vOvy8PVxMtPEN1/sZTj+X5ustLKefC/L1JGr0s859axNt +qo1/Bv2svdaAsNHPvqa46vQb9aus0M904OO4mGkzeiFzD/qZfbx2GbDJyud+MdPGtGYTiaGfOfAV +bA6/0Uo6uqMe8CudRGtOv9L2GYHQz/T2cVx6+pnh7nU10c+M+PloM23s76Jho99o9l7LgE2APxTv +GfxKu3Dt4j7IaDWStU20cZu9zplx+I3kLz38Rqo3ot9IEiT6mUA+1WS34c919qNNtBktRRu3wJ+1 +R90yC/xZ5zC0iTaxEeHP2st2MdHG336ZAn/+It3VW2KlPNHG++Y20caN/LlNtLGvaI51wp858MfR +Jtr4gZ2mwJ8NlrPev2j4G+2HWZc202YExuKfD8PpYqaNjdWjzvPxEWSF/LkBsLSHeb6YaWODfq13 +MRyAjpu9zbTxdk2+GwD9zKmJsROw8mcPAjqfhouZNr6loc20sbbusTsBvT08M9PGfzx0zyGgV1Ln +JQhovx2r+NIIaAbqeVxkwabFqza4m6QqhbEy0ErwulnWIIgTDwTNh1/r3WKHoP0ChRLcBkE7T7eW +BO82T3hpELT2UNHVIGgbPsZ2J9hO5GFod0Kw6BME3cY/p4CgGe/T3rLg3SZ7rxdZsCHBmAMEbceN +W6sCmiR8bBc3g72QubYs2H9WdG7TDe0k3SvQGgRtwuQytVshp+2jlgXbj8+e50UEeDJdXBC0SdYC +aYWgTbcf060QM9z3qWXBZsADbIfgoBlJCYLV02sUtLn529ooOLRbJY2Cg34gBQpaMbFWGSoFR9U1 +EwXdKm9ZsLfHlgWPowqsiYKmsx8tCzbnfR/XRsHSXof1goL2e2ZDy4JjI1DQJ1NfQNDevWZSFYL2 +mhYC1lVyFux9c8uC3cefWxY86mfTMgPtKTNHy4LtuE5DqwPaj1jO+wUDy6jSQzAcgcbefWzTYGwQ +jsdFFmx1+bHW/Wz8WBlfrHUEltG9a75PQ+Bh9wbrOo5A482+t5vBR3W3MwL9x6rHdjPYAbQ2BBqg +BuWogcDSqdlwTsDD7+y0m8GHhwXLNQFDkOkRGH4MDPTJ6IsKEnvnxyQKuh+zxnxrt2POOVLhkGMS +CN2OOSvRnYRhx4DCsGMSC8OOgYamQKzz3G4Mhx6TeIgfAw/DjwGI4cckIg5VI26TY8KPgYn4MYmJ +zY8RFJsfIyo2P6bHYvgxxIb4McSG+DEpNkSQITZsyKvBIYZMCg4xZEiNZciQGWPIdJmx/BgSY/wY +EmP8mJQYy48hL8aPoTSIH5NKg/gxlAb9RGt5MYJMLg1KkInSoHIjKoMSZHJl8EX9vYSoDMqQicqg +DJlcGZQhE5VBNkJlUIpMLg2aItNFhigyURuUIpNqgzJkojYoQyZqgzJkcm1Qhkwkxg== + + + MmQiMpQhkyNDGTIRGUqRichQikzCIoqMsBiGDFwMQyaBMQwZyOiGzNDqgyHIJDQO9fBNwUYsGdgY +lkyCY2gy4DE0GfgYmswVIJ+djP2XZLbblDWTpJJFY/Pcdn7RbPPHtEyTJDe7LWjz3ta9TZl3jcbm +y63bFiKNtc/6Gxk2IK1px4J13KRZSxLA76st9fkkhb5nmDQ2R29rZnt9bs0SIo3P65PuYiJNac/j +vrT3sHKwTQbc5LJbxcXa43iGSLPajyNu7YO5SGOzxObqt9hUK591WJVwF2nWpc4+ZR0XaWwC2LGf +IdLYBLB9Do+Gp5+wTp1ft4QK5APTH2mkXyYyj2b1HwjFBJdHUzrt0olHYxMzx/oLK3472Nrr3MwJ +v375FM8qwbhHY20XSuTR+GzO7cKksc6jGso++8ImjS3IxXW3eHbASm7S+Ly3cQyTxl7kv0Emk8b+ +PuxNVXGTxvfVHiKN7cq9ijUu0tj+3rp1XKSxg2KXBUQan8Q3jSHSWNum08RK5sD49L/6G28u0tjR +l7fuIo1PHR3bSl5ltHHlP/XVNuLxEiKNtbfOb3GRZrUfd5zCo7Gxe8Y69dE8RrBYx84Df/DScoZI +Yycazr+JNHa22s0UVnKRxieHTuHR2OzMo6pYy6h5lXMzsdyjqc9DWsKjsU3o9x7co7H5p3YhaGN1 +8Yc3HUv93QkXaWziKj9ds9aHO+1j93sXLtLYdEyP5CXSxOxXiTQ2O/bosFCPnM0dXMKjsdfMUmLM +o7E/d35dnePlc2+rROsejb9IsrvNE3PQrfufT6TJpJVJE6SVSROklUqTSSuVJkgrmSZIK5smo1Y2 +TaBWNk2gVjZNQq1kmuBtlWkCt5JpMm4l0wRuJdMEbiXTZNxKpgncSqYJ3kqmybyVTBO8lUwDb+XS +ZN7KpQneyqWBt5tcmsTbTS4NvN2mxtKxxgv18Wk9cDe5NAB3M5cG2m5yaRJtN9k00HaTTQNtN9k0 +ibabbBpou1WbBthusmkSbDfZNILtVmUaWLst8UCtxtpNMg2s3STTwNpNMk1i7SYTBtZuVaYBtVuV +aRJpN8k0kLbbRM1MJdMk0m6SaUTaTS4NpN3k0iTSbpJpIO0mmQbSblWmSaDdJNMItJtcGkC7yaVJ +pN3k0kDaDexDWrk0mbTVpQnQSqYJ0EqmyaCtMk1wVjJNZxm4TJM5K5kGzsqlCc5WlyZjVi5NYFYu +TWBWLs01ZpFpEv+waeAfNg38Q6dJ/EOngX9VqIF+GDWJfjJqgB9GDfDDqOnhh1AD/BBqoJ+EmgQ/ +hBrgh1AD/BBqEvwQaoAfQg3wk1CT2IdQA/sk1Ah98mkS+eTTAD58GsCHT5PAh08D+PBpAB8+TQIf +Pg3gw6eBffg0iX0YNbAPowb2YdQk9mHUwD7GOvCTUZPYh1Ej9iHUAD8JNYl9CDWwD6EG9iHUJPbh +wsA+hBrgh1CT6IdQA/26jTj9EGoS/RBqRD98GuiHT5PoJ6EG+CHUAD+EmkQ/hBrRD58G+uHTJPrh +00A/fBroh0+T6IdPA/4QasAfQk3CH0IN/EOo6caEF1gS/xBqxD/5NOAPnybxD58G/uHTwD98mmv+ +IdQk/mHUwD+MGviHUpP4h1ID/5BqICBWTSIgVg0IxKoBgVg1PQKRakAgUg0IRKpJDESqgYFINTAQ +qSYxEKkGBiLVwECkmgRBpBogiFQjCuLUJAzi1MBBnBo4iFOTOCinBgzi1IBBnJqEQZwaMIhTAwbl +1CQKYtVAQawaKIhVkyiIVQMFsWqgIFZNwiBWjTCIVAMGkWoSByXVgEGkGjCIVJMwiA8DBpFqwCBS +TcIgUg0Y7DbiGESqSRhEqhEGcWrAIE5NwiBSDRxEqoGDSDWJg0g14iBODRzEqUkcxKmBgzg1cBCn +JnEQpwYOSqoBg0g1CYNINWAQqQYMItUkDCLVCIM4NXAQpyZxEKcGDuLUwEGcmmsOItUkDmLVwEGs +GjiIVpM4iFYDBxFr4CBmTeIgZg0cxKyBg5g1PQcRa+AgYg0cRKxJHESsgYOINXAQsSZxELEGDiLW +wEHEmsRBxBo4iFgjDuLVJA7i1cBBeTVgEK8mYRCvBg7i1QQH5dVkDsqrCQ5WryYwKK8mc1BmTXBw +CGhXDlazJmNQZk1gUGZNYFBmTcagzBowKLEmMCixJmNQYk1wUGJNcHCMkm7HQTkxwUGJNcFBiTWZ +gxJrgoNtI5WDEmsyByXWwEF5NcHBMTKfjoMSa4KDEmuCgy7WZApKrIGC8mqgIF5NoiBeDRTEq4GC +eDWJgng1UBCxBgwi1iQMItaAQcQaMIhYkzCIWCMM4tWAQXk1iYJ4NVAQrwYK4tU8Q0GJNZmCMmuC +giN1gApBqTUZglJrAoKSawKCsmsyBGXXBARl1wQEZdckCEquCQhKrgkISq7JEJRcExCsck0wUHJN +ZuAQiWNloOSaYKDkmsxAyTXBQMk1MHCMcD0/tc+mJwYD5dYEBKtbkxkotyYYODW8GQNxaxIDcWtg +IG4NEMStSRDErgGC2DVAELsmURC7Bgpi10BB7JpEQewaURC5Bgoi1yQKItdAQeQaKIhckyiIFwMF +kWugIHJNoiByDRTsNuIUlFyTICi5RgzErYGBuDWJgcg1MBC5BgYi1yQKIteIgnJrAoJyazIE5dYE +BAEyEJRbkyEotyYgKLkmICi5JkNQck1AUHJNQFByTYag5BogKLcmICi3JlNQbk1QUG5NUHCM3PuC +gsg1iYLYNVAQuwYMotckDKLXgEEEGzCIYZMwiGEDBjFswCCGTY9BBBswiGADBhFsEgYl2EBBBBsw +iGCTMIhgAwYRbMAggk3CIIINGESwEQbxaxIG8WvAIH4NGMSvSRzEr4GD+DVwEL8mcVB+DRjErwGD ++DUJgxg2YBDDBgxi2CQMYtiAQQwbMIhhkzCIYSMMItiAQQSbhEEJNlAQwQYKSrBJEMSNAYIINkAQ +wSZBEMEGCHYbcQgi2CQKItgIg/g1YBC/JmEQwQYMItiAQQSbhEEEG2EQvwYO4tckDuLXwEH5NWAQ +vyZhEL8GDEqwgYIINomCCDZQEMEGCiLYJApKsBEE8WuAIH5NgiB+DRDErwGC+DXXEESwSRDEsAGC +GDZAsCo2CYEoNiAQyQYEyrJJBMSygYBYNhAQy6YnoCQbAIhkAwCRbBIAkWwgIJINBESySQREsoGA +SDYQEMkmERDJBgIi2YiAODaJgDg2EBDHBgLi2CQC4thAQDk2ABDHJgEQxwYC4thAQBybREAsGwiI +ZQMBsWwSAWXZAEAsGwCIZZMAiGUjACLZAEAkmwRAJBsIiGQDAZFsEgLxY0Agkg0IRLJJCESyAYHd +RhyBSDYJgUg2QiCODQjEsUkIRLIBgUg2IBDJJiEQyUYIxLEBgTg2CYE4NiAQxwYG4tgkBuLYwEAk +GyCIZJMgiGQDBJFsgCCSTYIgko0oiGMDBXFsEgVxbKAgjg0UxLG5piCSTaIglg0UxLKBgmg2iYNo +NnAQ0QYOYtokEGLaAEJMG0CIadODUKINIES0AYSINgmEiDaAENEGECLaJBAi2gBCRBtAiGiTQIho +AwgRbQRCPJsEQjwbQIhnAwjxbBII8WwAoTwbQIhnk0CIZwMI8WwChPJsMghl2gQIh8B2BaFMmwxC +mTZBQpk2QcKh3T5pJJRpAwkl2gQJJdpkEkq0CRJKtAkSjlFx7UgoRyZIKNEmSCjRJpNQok2QsG2k +krCKNhmEEm0AYfVsgoNjJD4dByXaBAcl2gQHJdpkDkq0EQfxbOAgnk3ioDwbMIhnAwbxbBIG8WzA +IKINGES0SRhEtAGDiDZgENEmYRDRRhjEswGDeDYJg/JsoCCeDRTEs7mmYIg2CYNh2sDBMG0AYag2 +iYSh2oDCkG1gYdg2CYZh20DDsG3AYdg2PQ9DtoGIIduAxJBtEhORbWBiyDZAMWSbRMWQbcBiyDZw +EdkmcTFkG8AYso3IGK5NQiOuTcSIcm0iRpRrk2NEuTYRI3bY8yBRrk0OEuXaRJpcXZvIkuXa5Cy5 +2jaRJMu2iSRZtk1OkqttEzmybJsoFcq2yaVC2TaUCiXbRKlQsk0uFUq2iVKhEiUqhZJtcqVQnkxU +CiXbRKVQsk2uFEq2iUph20itFEq2yaVCyTbUCuXaRK1Qrk2uFUq2iVqhZJuoFUq2ybVCyTYkyXJt +IkKUa5MjRLk2ESHKtYkIUa5NQiOuDWgM2QY2hmyT4BiyDXREtoGOIdskPIZsIz7i2sDHcG0SIMO1 +AZHh2sDIcG2uIfkXL9vYPA6bzZJkG+uc5nBtbC7IdrRH1lh76J7+5q6NTRDR48Q9irT2MsVTJG2O +yd49T8Zu31jfuLSnSNr8hWFoT5FcLFxe4uEUNlXBfwtPqo3PdTnaUyRtLkwnCHhx2Pr0fDk3bUq7 +PqBApo21h7l9FTdtSqc/t1SmTZ2H054iaTMm5vniKZI2bcIFc5k2pb3LT3LVxmZD5MeA6CdC7fF6 +qDY+yWlvT5FcLFdq1kz99cfVHzAm0cbW2Ob2FEmbnDTEk1ok2jCDCdHGVjrH9hRJ+7vd66srSbSx +GU16yKrPyLDPeo7tKZI252MI70OijU8EOdpTJBellYg21jYhpK4k0cZ31bKFaWO7sj5HxkUb2912 +CFnHRRvrPPf2FEmf1XK2p0jaIZxj18mR8fkwR3uKpLX1MBoXbXwy1XHxFEnrPIflptvILh1mq4Ow +JETpKZI+ys7pbE+RtIE8n+0pkjbQ16ntBhdtfBbW1J4iaWeZBe2INja5yh4jzUou2vhsqXML02Y5 +61O0ZNrYrCE7aAwHN22sc20PrLFN6ClOLtrYfCxzF9pIrb8DzJNUXbSx9ni0p0jaTKSte4qVizY+ +PWmZQrSx6WAz4s3obRdCWakeufI1/QfsZNpY+9jaUySNTaX7PhhWgVR/i0KijbX3qT1F0iE3L38+ +0SZTVqINlJVnE5SVZ5MpK88mKCvPJigrzyZhVppNYFaaTWBWmk3GrDwbWFs1m0CtNJuEWlk2gVpZ +NoFaWTYZtbJsArWybIK1smwya2XZBGtl2QRrpdlk1kqzCdZKs4G1aDY9a7FsxFokG2CLZJNgi2QT +v8Fukg2kRbJJpEWygbRINpAWySaRFskG0kqyWdpv5Lhkk0CLZANoZdmIs0g2ibNINnAWyQbOItkk +zmLIwFlJNmBWkk2iLJINlO02oV88c8cmURbHBsoi2UBZJJtEWSQbKItkA2Ul2STIItkAWSwbIItl +kyiLZSPKItkEZSXZZMpWySYgK8kmIDvGL7p3kK2STTBWkk0wVpJNZqwkm2CsLJtgbLVsEmIl2QRi +JdkEYiXZXCN21bSMxL5Vko3Yt8qxgX2rHJvEvlWODeyrjg3kw7HpySfFBvCh2AA+FJsEPhwbgQ/F +BvJJsenBh2ED+DBsAB+GTQIfhg3gw7ABfDJsEvcwbODeWg0bsLdWxSZRb62KDdBbpQ== + + + 2AC9VYpND71Vho2gt0qwAXqrBJsEvXWNYLDOzZBgA/dWCTaJe6sEG7i3bo3Q3MtUdNy4t27xxI2a +urZZxPXGRRVsEvdWCTZwD8NG4JNgk7iHYAP3EGzgHoJN4h5uDNxDsAF8CDaJfAg2kK/bCPeil/rp +GvnwayAfgg3kQ7BJ5JNgA/gQbAAfgk0i3yrBBvKtMmwg3yrDJpFvlWEj8q0SbCDfKsEmkW+VYAP6 +Vgk2oG+VYJPQt0qwgX2rBBvYt0qwSexbJdjAvrUaNqBvlWHTs2/VRDLYt0qwgX2rZqNdsw/BJrEP +wUbsw6+Bffg1iX34NbAPvwb64df09EOvAX/oNeAPvSbhD79G+EOvAX/oNT3/sGvgH3YN/MOuSfzD +roF/kAP+YdckAGLXAEDsGgiIXpMQiF4DA9FrYCB6Tc9A2TVCIHINCESuSQhErokvIrkGBEquSQRE +roGAyDUQELkmERC5BgIi10BA5JqEQOQaEIhdIwQi1yQGSq4Bgcg1IBC5JiEQLwYEIteAQOSahEDk +GhDYbWSvp7e7NQmBuDUgELkGBCLXJAQi18BA5BoYiFyTGIhcAwOxa2Agdk1iIHaNGIhcAwORaxID +kWtgoOQaEIhckxCIXAMCkWtAIHJNQiByDQjEroGB2DU9A5FrYCByDQxErrlmIHJNYiByjRiIWwMD +cWsSA3FrYCBuDQzErekZiFoDA1FrYCBqTWIgbo0YiFoDA1FregZi1sBAzBoYiFmTGIhZAwMxa2Ag +Zk1iIGYNDMSsgYGoNYmBqDUwUGoNCESt6RGIWSMGItYEAyXWZAYOEbFVBlaxJhAosSYzUGJNMHBo +uHYGVrEmI1BiTSBQYk0gUGJNRqDEmkCgzBoQKLEmI1BiTTBQYk0wUGJNZqCcmGCgxJpgoMSazECJ +NcHAtpFd+su0XyTAeDXBQIk1wcCx5TuNgRJrgoESa4KBLtZkAkqsCQLKrIGAmDWJgJg1IiBiDQRE +rEkERKyBgIg1IBCxJiEQsQYEItaAQMSahEDEGhCIWQMCZdb0BESsgYCINRAQseYZAkqsyQSUWAMB +q1cTAJRXkwEoryYAKK8mACivJgFQWk0AUFpNAFBaTQagvBoAKK0mACitJgFQVk0AsFo1wT9ZNZl/ +smqCf7Jqgn+yajL/ZNUE/2TVBP/GsD/Tg0B8hnbwT1pNALBqNYl/smrg3xRoc/4h1ST+IdXAP6Qa +AIhUkwCIVAMAkWoAIFJNIiBSDQREqoGASDWJgEg1EBCrRgREqkkERKqBgEg1EBCpJhEQHwYCItVA +QKSaRECkGgjYbWSX/LLtGYByauAfUg38Q6pJ/EOqgX9INfAPqSYREKkGAsqqCQDKqskAlFUDAIEx +AJRUkwEoqSYAKKkmACipJgNQUk0AUFJNAFBSTQagpJoA4BhpSwWgrJpEQEk1QUBJNUHAMfLtCwIi +1SQCItWIgDg1IBCnJiEQpwYE4tSAQJyaHoEoNSAQpQYEotQkBOLUCIEoNSAQpaZHoIwaCIhRAwIx +ahICMWpAIEYNCMSoSQjEqAGBGDUgEKUmIRClBgSi1IBAlJqegRg1YiBCDQxEqEkMlFADAhFqQCBC +TUIgQg0IRKgBgQg1CYEINSAQoQYEItQkBCLUgECMGiEQoSYhUEINBESogYASahIAcWEAIEINAESo +SQBEqAGA3UZ2aS/DdpEG49OAQIQaEIhQkxCIUAMCEWpAIEJNQiBCDQjEqIGBGDWJgRg1YqCEGhCI +UJMQiFADAiXUQECEmkRAhBoIiFADARFqEgEl1ABAjBoAiFHTAxChBgAi1ABAhJprACLUJAAi1AiA ++DQAsPo0CX/4NOAPnwb8yafp6YdOA/3QaaAfOk2in3wawQ+dBvih0/Tww6aBftg00A+bJtEPmwb6 +YdNAP2yaRD9sGuiHTQP90GkS/dBpoB86DfRDp+nph00j+kmmAX7INAl+yDTQD5kG+iHTJPoh00A/ +ZBroh0yT6CeZBvgh0wA/ZJoEP2Qa4IdNI/gh0yT4IdNAP2Qa6IdMk/CHBwP+kGnAHzJNwh8yDfjr +NrJLeTGXJuEPlwb8IdOAP2SahD9kGvCHTAP+kGkS/pBpwB82DfjDpkn4G1tJ1vCHTAP/kGkS/5Bp +4B8yDQBEpkkARKYBgMg0ABCZJgEQmQYCYtNAQGyanoDINBAQmQYCItNcExCZJhEQmUYExKWBgLg0 +iYG4NDAQlwYG4tL0EESlAYKoNEAQlSZBUC6NIIhKAwRRaXoIYtIAQUwaIIhJkyCISQMEMWmAICZN +giAmDRDEpAGCqDQJgqg0QBCVBgii0vQQxKQRBCXSAEFEmgRBRBogiEgTEJRIkyEokSYgODRgOwQl +0mQISqQJCkqkCQoO7VZJo6BEmqCgTBooKJEmU1AiTVBQIk1QUCJNpqAcmKCgRJqgoESaTEGJNEHB +tpG9Ci/j5TwYPJqAYBVpgoFjS3caAyXSBAMl0gQDJdJkBkqkgYGYNDAQkyYxUCaNEIhIAwIRaRIC +EWlAICINCESkSQhEpAGBiDQgEJEmIRCRBgRi0oBATJoegRJpICAiDQREpLkmYIg0CYEh0oiB4dEA +wfBoEgXDowGD4dHAwfBoehCGRgMJQ6MBhaHRJBaGRyMahkYDDkOj6XmIRQMPw6IBiGHRJCKGRQMS +w6KBiVg0iYlh0QDFsGigYmg0CYtoNBEbSqOJ2FAaTYoNZdEQGzbk1eBQEk0ODiXRRGpcJZrIjCXR +5My4SjSRGEuiicRYEk1OjKtEE3mxJJooDUqiyaVBSTRRGpRFQ2lQEk0uDUqiidKgkiMqg5JocmVQ +/ktUBiXRRGVQEk2uDEqiicpg28heVZdJcxK70qAcmqgNSqKJ2qAkmlwblEQTtUFJNFEblESTa4OS +aCIxlkUTkaEsmhwZyqIhMpREE5GhJJqERSQasBgSDVwMiSaBMSQayIhEAxlDokloDIkGNmLRwMaw +aHo4hkQDHkOigY8h0VwD8i9fohndo8oOTQk3/KG2SDSDz9cMh0b3Ur7UOtWhKUdyHZtCU5r+ICIp +NHYZntsq1aExto1jc2iGqiCEQ1PouI1zc2js8jB3Eo1ZAHJdXKIZqlgQb7LW28Y+xwWLxtpDtQHc +ointYx3aJ3OLxu4OzlVusYlWdl+wPjDDJRq/L9gJAy7RzDbspykkGrvvt9WnbrhEMx+XzwCpnWhA +PiztLv62zCHRWNvultb4WRZN6ZyM7dJo7A68TQBBo7G2zVlnHb94WacMGNdorO06iTQanwuAnyGL +xvqOYQyLxu4vWqiERWPfaA1BQxaNfe1pXcKisRdZeQmLxv4+NCHGJRrr22WLmERju3KrUo1bNLNm +7bCSWzR2TPzpmLJoSttnUmDRWLs9AFQCjB3XY53CorGDryfRuEUzu0fSVqolxkE/F4BFM9hdtr1p +NBYRdHJL1WgsN9DH2euUgPmIlfy3OC0ii3XcorFbmOfULBq7l7ifzaKxU/Voz8WpFs1o8/3nZtGU +HW+8x6IZ60FjNFSLxm7Cz51GM1qJ52wazVgvA22sLr6ldeksmrFOAQyLpn/OXVg0NqlhOJtFM+oZ +D1g0CulZqVo05Wui7LlFM9bpjWHRjEmt0wyv0unPEUSjsReda9NobN/9GSWanrI4NFAWiUaUxaFJ +lMWhEWVRaKAsCk3CLA4NmMWhAbM4NAmzODSwVhINqEWiSaiVRROolUUTqJVFk1EriyZQK4sG1kqi +yayVRBOslUQTrJVEk1kriSZYK4kG1iLRJNZi0cBaNBpgi0aTYItGA2xdo4G0aDQ9abFoIC0WDaTF +okmkxaKBtLJoAC0WTQ9aJBpAK4kGzmLRJM5i0cBZLBo4i0WTOIsCA2dl0YBZWTSJsmHRiLJh0Yiy +odH0lA2NRpQNjUaUDY2mo2xYNKJsWDSiLBZND9mwaATZsGgE2bBoesqGRSPKhkYDZdFoEmWl0Qiy +WDRAFosmQVYWDYzFooGxWDSJsVg0MBaLBsbKohmzVlc1GhCLRgNi0WguEBsSTce+cGjEvpBoKvvC +oenZFw5NZZ8UGpEvFJqefDg0Al84NAJfODQ9+MKhEfhCohH5kGh68GHRAD4sGsCHRZPAh0UD+LBo +BD5JNIl7SDRwTxIN2JNEk6gniQboIdEAPSSaBD0sGqCHRgP00GgS9NBogB4aDdxDo+m5h0UD97Bo +4B4WTeIeFg3ci99fFfhk0fTcQ6KBe0g0gE8WTeIeFg3cw6KBe1g0iXsIMHAPiwbwYdEk8oVFI/KF +RSPyhUbTky80GpEvNBqRLzSajnxYNAJfWDQCX1g0PfnCohH5wqIR+cKi6ckXFo3IFxqNyBcaTU++ +0Ggq+sKiEfrCounRFxaN2BcWjdgXFk3PvrBoxD4sGqEvLJqefaHRiH2h0Yh9odFcsG9BounYt+DQ +iH0LEk1l34JD07NvwaGp7FtQaES/BYWmp9+CQyP8LTg0wt+CQ9Pjb8GhEf4WJBrhb0Gi6fm3yKKB +f4ssGvi3yKJJ/Ftk0cC/mHhY+bdIokkAXCTRAMBFEg0EXCTRJAQukmhg4CKJBgYukmgSA5dq0YDA +ZW90GweVjuvc24bAZY8wjekXrtGAwKVqND0BF1k0EHCRRQMBF1k0iYCLLBoIuMiigYBYND0CkWhA +IBINCMSiSQyURQMCsWhAIBZNQiACDAjEogGBWDQJgWHRCIFh0QiBodH0CAyNRggMjUYIDI2mQ2BY +NGJgWDRiYFg0PQPDohEDFywaMTAsmp6BYdGIgaHRiIELGk3PwAWNpjJwkUUjBC5YND0CFywaIXDB +ohnDfa0WTY/ABYtGCFywaMTABYtmzHpd1WjEwAWNRgxctkjmh2clmo6B4dCIgSHRVAaGQ9MzMBya +ysBQaMTAUGh6BoZDIwaGQyMGhkPTMzAcGjEwJBoxMCSanoFYNDAQiwYGYtEkBmLRwEAsGjEQiSYx +EIkGBiLRwEAkmsRAJBoYKIkGBCLRJARi0cBANJpgoDSazMAhQjYUmFV7wxEojSYxUBZNMHAIXlcG +VosmI1AWTSBQFk0gUBZNQqAkmkCgJJpAoCyajEBZNMFAWTTBQFk0mYESYIKBsmiCgbJoMgOxaGAg +Fg0MRKNJDESjgYFoNDBwbCnP2b5StWhgIBYNDKwWTSIgFg0ExKIRAcOi6QkYFo0IGBqNCBgaTU/A +0GgqAcOiEQLDoukRGBaNEBgWzRh5S53Y0yMwLBohMCwaIRCLpidgaDQiYGg0ImBoNJcERKLpCYhD +AwEl0QiAODQJgDg0AiAKDQBEoUkAxKEBgDg0ABCHJgEQhwYAItEAQCSaBEBZNAHAatEE/2TRZP7J +ogn+yaKBf5JoMv8k0QT/JNEE/8Z4eFB64ofPyg7+SaIJAFaJJvNPFk3wb2poM/6h0ST+odHAPzQa +AIhG0wMQiwYAYtEAQCyaREAsGgiIRQMBsWh6AiLRQEAkGgiIRZMIiEUDAbFoICAWTQ== + + + IiACDATEooGAWDSJgGHRiIBh0YiAaDQ9ANFoxL/QaMS/0Gg6/oVFI/6FRSP+hUXTEzAsGhEQiwYA +YtEkAGLRAEBgDADRaBIA0WgEQCwaAIhFkwCIRQMAsWgAIBZNAiAWDQDEogGAWDSJgGg0EBCNBgKO +kXAPz0o0HQHDoREBQ6KpCAyHpkdgODQVgaHQCIGh0PQIDIdGCAyHRggMh6ZHYDg0QmBINEJgSDQ9 +AmXRQEAsGhCIRZMQiEUDArFohEAkmoRAJBoQiEQDApFoEgKRaEAgEg0IRKJJDMSigYFoNDAQjSYx +UBoNCESjAYFoND0CsWhAIBYNCMSiSQjEogGBWDQgEIumRyASDQhEogGBWDQJgbJoICAWDQSURZMA +iAADALFoACAWTQJgWDQCYFg0AmBoND0BQ6MRAkOjEQJDo+kQGBaNEBgWjRAYFk2PwLBohMCwaMTA +sGh6BoZFIwai0QiBodH0CAyNpiIQi0YEDIumJ2BYNCJgWDQiYFg0PQGxaATAsGgEwLBoegCGRiMA +hkYjAIZGcwHAkGg6AIZDIwCGRFMBKIemx184NBV/odAIfyg0Pf3CoRH9wqER/cKh6emHQyP4hUQj ++IVE08MPiwb6YdFAPyyaRD8sGuiHRSP6IdEk+iHRQD8kGuiHRJPoh0QD/ZBooB8STaIfFg30k0YD +/NBoEvzQaKAfGg30Q6Pp6YdFA/2waKAfFk2inywa4IdFA/ywaHr4IdEAPyQa4IdFk+CHRQP9sGig +HxZNwh8CDPjDogF/WDQJf2HRCH9h0Qh/odH0+AuNRvgLjUb4C42mw19YNMJfWDTCX1g0Pf7CohH+ +wqIR/sKi6fE3tl/1cPyFRiP+hUbT8y80msq/sGgEwLBoegCGRSMAhkUjAIZF0wMwLBoRMCwaETAs +mp6AodGIgKHRiICh0VwQMCSajoDh0IiAIdFUAoZD0zMwHJrKwFBoxMBQaHoIhkMjCIZDIwiGQ9ND +EIdGEAyJRhAMiaaHIBYNEMSiAYJYNAmCWDRAEItGEESiSRBEogGCSDRAEIkmQRCJBggi0QBBJJoE +QSwaICiNBgii0SQIotEAQTSagKA0mgRBWTQBwSGIXSEoiyZDUBZNUFAWTVBwaLdKhraOSzRBQUk0 +QUFZNJmCsmiCgrJogoKyaDIFJcAEBWXRBAVl0WQKYtFAQSwaKCiNJkEQjQYISqOBgWPLeM7uCx1z +y4LDooGBWDSJgVg0YmBYNGJgWDQ9A7FohMDQaITA0Gh6BIZGUxEYFo0QGBZNj8CwaITAsGiEwLBo +egSGRSMEhkUjBIZF0yMQjUYEDI1GBAyN5oKATaLpENgcGjGwSTQVgs2h6SnYHJqKwabQiINNoelB +2BwakbA5NEJhc2h6FjaHRjRsEo1w2CSanodYNPAwLBqAGBZNImJYNCAxLBoxEYkmMTEkGqAYEg1U +DIkmYRGJJmJDSTQRG0qiybGhLJqIDTvkeXAojSYHh9JoIjWuGk1kxtJoUmZcLZpIjGXRRGIsiyYn +xtWiibxYFk2UBmXRpNKgJJooDUqiidKgLJpcGpRFE6XBmhtFZVAWTa4MSoCJyqAsmqgMyqLJlUEs +GiqDWDRUBtFoUmkQjYbaIBoNtUE0mr42iEVDbRCLhtogFk2qDWLRkBhj0RAZYtGkyBCLhsgQjYbI +EI2mx2JoNBWLzaIRF5tF04OxWTQiY1g0ImOzaHo0NotGbAyLRmxsFk0Px6bRCI9NoxEfm0bzUyZj +/yVJNFapN48qWTTWOe5LWDRW7rd5kmg0Vu63sfalVnKNxu4TnMcWHs2sMqE8GvvzzoOa8Gis0yo/ +eDRz4cC5nOHRWLsc/fu6jjW3VXKLh59TrSKi0dj9jvVc2nu4RjPVuyuh0Uz13kVoNFMt9rFS1Wim +8mmrBOQajdXFp615NKqLs071aMwuOc/m0ZQRXd2jqtGMl0/4qJ0+qzQ0mqGeS6HRlDOhXLQUQaPR +DPUJY2g0dj0tOzM0mqHO0medevUaaoIeGs1Qp8+GRjPUZ0XVlfBoBpuiujePxk62dW0ejSEhtA48 +mtEfohYajd3cOram0ZS2obyug0dju+o4m0cz1mtIeDRjnY7HStWjsXvS49Y8mrGGbeHRTHUSTKzk +Hs1USRAejR39+qCZ6tGUT2AVLVbyIqN1+o8FtI34O+DRlLYHIPFOXtMtg3VqGo0N5TnW8Tfyy1es +Yx6NnQ82zROPxk68kn2FR2Mn5hm/fyCPxu/+LKHRlKY/P0sajd8rWtcYDa7RWKedG2g0tgk9oMk1 +GrvtZsXINlYX/9U7f6geHo21jfd4NHbDae0eUOUejd/UO9bwaOym34xXM3rbZU9Wqkdu9qlsaDTW +tJAJjcb2gsnb98GxyqR51Uqm0fiL9HQanyZmoNt/9Cli//NEmkxamTRBWpk0QVqpNJm0UmmCtHJp +grRyaTJq5dIEauXSBGrl0iTUSqUJ3laVJnArlSbjFpUG3KLSgFtUmoRbVBpwi0oDb3FpEm9xaeAt +Lo14i0qTeItKA29RaYYwG/jlzMbbUGnE21BpBNxQaXrghkoj4FaVRrQNlaanbbg0om24NKJtuDQ9 +bcOlqbRFpRFsQ6XpYRsujWCLSyPWhkvTszZcGrE2XBqxNlyanrXh0oi1uDRCLS5NT1pcGkjbbcKJ +gEuTSItLI9Ki0kBaVJpEWlwaSItLA2nl0iTQ4tIItKg0gBaVJpEWlQbSotIEaaXSZNJWlSZAK5cm +QCuXJoO2ujTBWbk0wVm5NJmzcmngrFSa4GxVaTJmpdIEZqXSBGal0lxjFpkm8Q+bBv5h08A/dJrE +P3Qa+Fd9GuiHT5PoJ58G+OHTAD98mh5+6DTAD50G+kmnSfALnUbwC51G8Audpodf6DSCX+g0gh8+ +Tc++8GnEPnyaij50mp586DQCX+g0Q4gNVafpwRc6jcAXOo3AFzpND77QaQS+0GnEvtBpevaFTyP2 +hU8j9oVP07MvfJrKvtBpBD90mp594dOIfeHTCH74ND37wqcR+8KnGdvjqqd6hWvsC59G7AufRvAL +n6anHz4N9Os24vTDp0n0w6cR/dBpoB86TaKffBrgh08D/PBpEv3waUQ/dBroh06T6IdOA/3QaaAf +Ok2iHzoN+MOnAX/4NAl/+DTwD58G/uHTJP7h04h/0mnAHzpN4h86DfxDp4F/6DTX/EOoSfzDqIF/ +GDXwD6Um8Q+lBv7h1EBAnJpEQJwaEIhTAwJxanoEotSAQJQaEIhSkxgYSs0UPwlelZopfnG7KjU9 +A0OpEQNDqREDw6npIRhOjSAYTk2lYCg1PQZDqREHQ6kRB0Op6TmIUiMMhlIjDIZS02MwlBphMJSa +IZ765kpNT8FwakTBcGpEwXBqegqGU1MpGEqNKBhKTY/BcGqEwXBqhMFwanoO4tQIg+HUjO23xraa +FDcMhlMjDIZTIwyGU9NjEKcGDHYbqT+vIKcmYRCnRhhEqQGDKDUJgzg1cBCnBg7i1CQO4tSIgyg1 +cBClJnEQpQYOotTAQZSaxEGUGjgopwYM4tQkDOLUgEGcGjCIU5MwiFMjDKLUwEGUmsRBlBo4iFID +B1FqrjmIVJM4iFUDB7Fq4CBaTeIgWg0cxKuBg3g1iYN4NXAQrwYO4tX0HESrgYNoNXAQrSZxMLSa +KWZ1V61mijnTVavpORhajTgYWo04GF5Nz8HwasTB8GoqB0Or6TkYWo04iFYzhOFQtZoeg6HViIOh +1cBBtJrEQbQaOCitBgyi1SQO4tXAwaFB+5Brf1xiEK9GGESrAYNoNQmDeDVgEK8GDOLVJAzi1cBB +vJqxu1tcr3cdB/Fq4CBeDRzEq0kclFcTHGwb4Wdm3KvJHJRXAwel1QQHx8h8Og7KqwkOyqsJDrpX +kykorwYKSquBgmg1iYJoNVAQrQYKotUkCqLVQEG8GjCIV5MwiFcDBvFqwCBeTcIgXo0wiFYDBqXV +JAqi1UBBtBooiFbzDAUl1mQKyqwJCo7UASoEpdZkCEqtCQjKrQkIyq3JEJRbExCUWxMQlFuTICi1 +JiAotSYgqJv8GYKoNUBQag0MRK1JDEStgYGoNTAQtyYxELcGBuLWiIGoNYmBqDUwELVmCMvhHC9C +wVBrYOAUeHMGhlrTMzDUmiFKCFWtGaLgUtWaHoLzHPvIITjj1giCM25NT8EZt6ZScEatEQVn1Jqe +gjNujSgYbo0oGG5NT8Fwa0TBcGtEwXBregqGWyMKhlsjCoZb01MQtwYKdhupNwmqW5MgKLdGDESt +gYGoNYmBuDUwELcGBuLWJArOcmtEQak1AUGpNRmCUmsCggAZCEqtyRCUWhMQlFsTEJRbkyEotyYg +KLcmICi3JkNQbg0QlFoTEJRakykotSYoKLUmKDhG7n1BQeSaREHsGiiIXQMG0WsSBtFrwCB+DRjE +r0kYxK8Bg/g1YBC/pscgeg0YRK8Bg+g1CYPoNaJg6DXCYOg1PQZDrxEGQ68RBsOv6TEYfo0wGH5N +xWDoNT0GQ68RBkOvGcJ0qHpNz8HQa8TB0GvEwdBreg6i1wiDodcIg6HX9BgMv0YYDL9GGAy/psdg ++DUVg6HXCIOh1/QYDL9GGAy/RhgMv6bHIH6NKBh+jSiIX9NDMPwaQTD8GkEw/Joegvg1QLDbiEMQ +vyZREL9GGESvAYPoNQmD+DVgEL8GDOLXJAzi1wiD6DVwEL0mcRC9Bg5KrwGD6DUJg+g1YFB+DRTE +r0kUxK+Bgvg1UBC/JlFQfo0giF4DBNFrEgTRa4Ageg0QRK+5hiCCTYIghg0QxLABglWxSQhEsQGB +ODYgUI5NIiCODQTEsYGAODY9AaXYAEAUGwCIYpMAGIqNCBiKjQgYik1PwFBsRMBQbETAcGx6AoZj +IwKGY1MJGIpNT8BQbETAUGyGcB2qYtMTMBQbERDFRgAMxaYHYCg2ImAoNiJgKDY9AcOxEQHDsREB +w7HpCYhjUwEYio0AGIpND8BwbATAcGwEwHBsegCGYyMChmMjAoZj0yMwHBshMBwbITAcmx6BODYg +sNuIIxDHJiEQx0YIRLEBgSg2CYE4NiAQxwYE4tgkBOLYCIEoNiAQxSYhEMUGBKLYwEAUm8RAFBsY +iGMDBHFsEgRxbIAgjg0QxLFJEMSxEQVRbKAgik2iIIoNFESxgYIoNtcURLJJFMSygYJYNlAQzSZx +EM0GDuLZwEE8mwRCPBtAiGcDCPFsehBKswGEaDaAEM0mgTA0G4EwNBuBMDSbHoSh2QiEodkIhOHZ +9CAMz0YgDM+mgjA0mx6EodkIhKHZDBgP0mx6EIZmIxCi2QiEodn0IAzNRiAMzQYQotkkEOLZAMKh +YdtBiGeTQIhnIxKi2UDCod09aSTEs4GEeDaQEM8mkRDPBhLi2UBCPJtEQjwbSIhnAwnxbBIJ5dkE +CdtGKgmrZ5NBKM8GEFbNJjg4RuLTcVBTqoOD8myCg/JsMgfl2YiDaDZwEM0mcfBoJQ== + + + g9UfkFQ1GzCIZpMwiGYDBvFswCCeTcIgng0YxLMBg3g2CYN4NsIgmg0YRLNJGJRmAwXRbKAgms01 +BUO0SRgM0wYOhmkDCEO1SSQM1QYUhmsDC8O1STAM1wYahmsDDsO16XkYqg1EDNUGJIZqk5gYqo2Y +2FQbQbGpNj0Vm2ojLDbVRlwM16bnYnNtBMbm2lQyNtWmR2OoNsSIqDbEiKg2KUZEtSFGbNirQSKq +TQoSUW1Ik6XakCWj2qQsWaU6kmRcG5JkXJuUJMu1UY6MakOpENUmlQpxbSgV4tpQKsS1SaVCXBtK +hUqUqBTi2qRKIa4NlUJcGyqFuDapUijXJiqFbSO1UijXJpcK5dpQK5RqE7VCqTa5VijXJmqFcm2i +VijXJtcK5dqQJEu1iQhRqk2OEKXaRIQo1SYiRKk2CY2oNqAxXBvYGK5NgmO4NtAR1wY6hmuT8Biu +jfiIagMfQ7VJgAzVBkSGagMjQ7W5huRfvGxj5SnTrZJs44WsZQzZxtp2LiHbTErFv9RKLttYNcwi +FWQbax/zgmxjzfGIVdy1sSrbuq7h2li1RrPsvUpe2iUL3EO2saLdeYRrY4W9SUaMuTaTzR7emgJD +MWdb9YgaK75Ye6jKgLs2pb0unSLgro2ViWxIyLXxAtE5h2tjBaJ9aV/GXZtprr4Mrk1p79u4h2wz +zZfPAamd6EK+spV0V1NTJNvwYCo8m6mwcT3QbKwOa0/9QrPx4m08pkWajRd8qyHjmo0Xc003kWbj +VWIeA4ZmYxVdC4LRbKa5JpFoNl69DYVDmo1943Jcw7OxF5n+gWfjRbGt2S+TimCOZDwb243rGZqN +7eq1W8c1Gzse/mRMaTal7UMOzcbae+exHLV07MU1LBs77noQjVs2Ni627iEyXmqcFv2YQNtIfYSM +OzY2/tZtae/jP4S1vHBUIdnYGPYH/2i2tVck524lk2zsRDjnLSQbO8H2Khu5ZGNn6dIpQC7ZWP1z +HvawbCabhVNFraX+2Q8Zg8EtG1vnPEKymTRtFcmmtP0K0Mbo4hvydZFspq2efkg2U/+MOyQbq8Na +IIVkY3Vvf8iDJJvSdheUlepxW+uMbSwbe5ENLCwb+3tz7+qcL2OTxWFINvaaUc+usXljDrjlz/i0 +mkxYSTZBWEk2QVhJNpmwkmyCsJJsgrCSbBJi5dgEYuXYBGLl2GTESrKBs9WxCczKscmYlWMTmJVj +E5iVY5MxK8cmMCvHJjgrxyZzVo5NcFaOTXBWkk3mrCSb4KwkGziLZANn8WvEWfQaQItek0CLXgNo +Xa+Bsug1ibLoNVAWvQbKotckyqLXQFn5NUAWvyZBFr8GyMqvEWPRaxJj0WtgLHoNjEWv6RmLGgNj +ZdeAWNk1ibDYNRC220R9fIy7NYmwuDUQFrkGwiLXJMIi10BY5BoIK7kmARa5BsBi1wBY7JpEWOwa +ERa5JggruSYTtso1AVjJNQFYyTUZsFWuCb5Krgm+Sq7JfJVcE3wd4y5n5Wu1axJeJdcEXiXXBF4l +11zjFbkmcQ+5Bu4h18A95JrEPeQauFflGqiHXNNTT24N0MOtAXq4NQl6yDWCHm4N1JNbk6CHWwP0 +cGuAHm5Ngh5uDdDDrQF6cmsS83BrYJ7cGpAnuSYRT3INwEOuAXjINQAPr0bAQ6sBeGg1CXhoNQAP +rQbmodUk5qHVwDy0GpiHVpOYh1YD8/BqgJ68msQ8vBqYh1cj6EmrScxDq4F5aDUwD62mZx5CDMzD +qgF6WDWJelg1UK/bSH12jDs1iXo4NVAPqQbqIdUk6kmqAXpINUAPqSZRD6kG6mHVQD2smkQ9rBpR +D6kG6iHVJOoh1YA9pBqwh1STsIdUA/eQauAeUk3iHlIN3JNVA/awanruIdXAPaQauIdUc809pJrE +PaQauIdUA/eQahL3kGrgHlIN5EOq6cmHUwP6cGpAH05NQh9SjdCHUwP6cGoS+3BqYB9ODezDqUns +w6mBffEEbLEPpybBD6cG+OHUQD+kmoQ/pBr4h1QD/5Bq4J98GuEPnQb8odMk/KHTgD90GvAnnSbR +D50G+qHTQD90mkQ/dBroh08D/fBpEv7wacAfPo3wh06T+CedBvyh04A/dJoef4gw4A+bBvxh0yT8 +YdOAv24jemzMoflagT9cGvCHTAP+kGkS/pBp4B8yDfxDpkn8Q6aBf9g08A+bJvEPm0b8Q6aBf8g0 +iX/INPBPMg34Q6ZJ+EOmAX/INOAPmSbhD5kG/GHTwD9smp5/yDTwD5kG/iHTXPMPmSbxD5kG/iHT +wD9kmsQ/ZBr4h0wD/5Bpev7h0sA/XBr4h0uT+IdMI/7h0sA/XJrEP1wa+IdLA/9waRL/cGngHy4N +/MOlSfzDpYF/uDTwD5km8Q+Zpvs1c5u7Bf6QaeKB9/JoxD80muCfNJrMvyEiNRSYVTh0/EmjyfyT +RhP8GwLTlX9Vo8n4k0YT+JNHE/iTR5PxJ48m8CePBvxJo8n4k0YT/JNGE/yTRpP4JwEm+CeLJvgn +iybzTxZN8K9tRL/3aA5N5p8cmuCfJJrg39hSnMY/STTBP0k0wT+XaDL9JNEE/WTRQD8smkQ/LBrR +D4kG+iHRJPoh0UA/JBrwh0ST8IdEA/6QaMAfEk3CHxIN+MOiAX+yaHr6IdFAPyQa6IdE8wz9JNFk ++kmiCfpViSbgJ4kmw08STcBPEk3ATxJNgp8cmoCfHJqAnxyaDD9JNMBPDk3ATw5Nhp8cmoBfdWiC +fXJoMvvk0AT75NAE++TQZPbJoQn2yaEJ9o0xfT099cPnY3czzV2iCfhViSbYJ38G9k0Na0M1NnyW +bGIf+gzsQ58BfugzCX7oM8APfQb4oc8k+qHPQD/8GeiHP5Pohz8D/fBnRD/0mUQ/9Bnohz4D/dBn +evohvkA/7Bnohz2T6Ic9A/26jWgazrZn+MmdgX3IM7APeSaxD3kG9iHPwD7kmUQ/5BnoJ3sm4Cd7 +JsNP9gzwA8Ttl0BcnsnwkzwT8JM8E/CTPJPhJ3km4Cd5JuAneSbDT/JMwE/2TMBP9kyin+SZoJ/k +maDfGDn2Bf0myTOJfpPkGeg3SZ4Bf9McoWXD3yR5BvxNkmfA3yR5psffJHcG/E1yZ8DfJHcm4W+S +PCP8TXJnwN8kdybhb6ruDPSb5M6Av0nuTMLfhPUj/E1yZ8DfJHcm4W+SOwP+IBr4myTPJPxNkmfi +xZJnwN8keQb+TfJmxL9J2gz8m6TNJP5NC3EaxotPggJ/k7SZhL9J2gz4m9bAtJ9Nk7SZhL9J2gz4 +m+TNgD+8mYQ/vBnwhzcj/KHNJPxJm4F+aDPQT9pMDz+EF+CHNQP8sGYS/LBmgF+3kfqoGHdmEv1w +ZsAf0gz4Q5pJ+EOaAX9IM+APaSbhD2kG/E2yZuDfJGsm8W+SNSP+TVWaAX+TpJmEv0nSDPibqjQD +/SZJM4l+k6QZ6DdJmoF+k6SZRL+pSjPAb5I1A/ymOR6q1Mt0PhcM+E1z3K93+E2SZq7hhzST4Ic0 +A/yQZoBflWYS+pBmQB/SDOiTNNOTD2cG8uHMQD6cmUQ+STMCH84M4MOZSeDDmYF8ODOQD2cmkQ9n +BvLhzEA+nJlEPpwZyIczA/mQZhL5kGYgH9IM5EOagXz4MiKfdBnAhy6TwIcuA/nQZSAfukwiH7oM +5EOXgXzoMol80mUAH74M4MOXSeDDlwF8+DICH7pMAh+6DORDl4F86DI9+hBdQB+2DOjDlknow5YB +fd1G6mNi3JVJ6MOVAX3IMqAPWSahD1kG9CHLgD5kmYQ+ZBnQhy0D+rBlEvqwZYQ+ZBnYhyyT2Ics +A/uQZYAfskyCH7IM8EOWAX7IMgl+yDLQD1sG+mHL9PRDloF+yDLQD1nmmn7IMol+yDLQD1kG+iHL +JP4hy8A/ZBn4hyzTAxBXBgDiygBAXJkEQMkyAiCuDADElUkAxJUBgLgyABBXJgEQVwYA4soAQFyZ +BEBcGQCIKwMAkWUSAJFlACCyDABElgGAeDICoDQZAIgmkwCIJgMA0WQCgNJkMgClyQQAhwB1BaA0 +mQxAaTJBQHkyQcAhbot0BJQnEwSUJwMBpclkAkqTCQJKkwkCSpNJBJTgEgSUJRMElCWTCShLJgjY +NqKHxFzOdcGRCQBWSSb4N7YMp/FPkkzwT5JM8E+STOafJBn4hyUD/7BkEv+OppSfR0gy4A9JJuEP +SQb8IcmAPySZhD8kGfCHJAP+kGQS/pBkwB+WDPjDkunxJ0kG+iHJQD8kmWv6hSST8BeSDPwLSQYA +hiSTCBiSDAgMSQYGhiTTQzAcGSgYjgwYDEcmcTAkGZEwHBlQGI5MYiGODCwMRwYYhiOTaBiODDgM +RwYe4sgkHoYjAxDDkYGIIckkJCLJREwoSSZiQkkyERPKjyEm7HDnQaH0mBwUSo+JdLjqMZENS4/J +2bB+woFkWHpMJMPSY3IyXPWYyIXlx0QpUH5MLgXKj4lSoPwYSoHSY3IpUHpMlAKVElEJlB6TKoES +W6ISKDsmKoGyY3IlUHZMVALbRvzxMNWNyaVAuTFRC5QcE7VAyTG5Fig5JmqBkmOiFig5JtcCJcdE +Miw7JiJC2TE5IpQdQ0QoOSYiQskxCYnIMSAx5BiYGHJMgmLIMVAROQYqhhyTsBhyDFzEjoGLYcf0 +YAw5BjSGHAMbQ465huNfvBxTkgM7QMmNsb5x3MONsRxubc+hGT2oa5PhXY2x5PBsZoyngeOIGWN/ +3da2iqsx1mkXb9SY0vZLEmqMtUu+EGqM5adL/Rw1ndirqoIbU9qDJdvxJu5w7fXhQrgxlggvdS69 +uzGlXY5++2TuxnjyXL0em0xluVCdsu/vZ7lQudbEKq7GWEJk6RxqjOVC8olcjbE0Jz/bY+S5mWOo +MVZO8Kc/So2xMsYSlof8GOu026USZGwdy8QQZKhbsI5ftrziMU8hyHgxY1hDkPEiyoUf47WYaQw/ +xj5siZnDj7FvdIawIT/GUjx7gBp+jLWtIIIfY20bdnUl+TG2r+zY4MfYvrR7bAgynnx2K7kgY52H +LBq77W4HyVInBBk7htPSPbzmqKmugwBDxtp6xIwbMjZayjGOlbyuaJ3+OwBsZLeYeg9HZrQZj8vY +3skfl1wG63i0B9HYYJ5ipZqE9+uYImMnxFJeiyJj550FQigydl6eQ3vgjZ+klvLbnFsUmfGsD8+S +ImMVgj2cHykyXkaoQ8gdGduGHs7kjozVWiynaYN18S2t9ZEyrshYc6hnnysyVrRZuqdTuSJjneXy +FIqMlSImlJnR265wshI/LTJaeQhFxtoWK6HI2G5Yty07MtZpQSaOjLW3+hwonwzmnJv+fIpM4qwM +meCsDBk4K0Emc1aCDJyVHxOclR+TQStBJkArQSZAK0Emg1aCTNC2GjIBWxkyGbYyZAK2MmQCtjJk +MmxlyARsZchAWwkymbYSZIK2EmSCthJkMm0lyARtJchAWwSZRFssGWiLJgNu0WQSbg== + + + 0WTArWsysBZNpmctlgysxZKBtVgyibVYMrBWlgyoxZJJqMWSAbWyZCAtmkwiLZoMpEWTgbRoMom0 +SC6QVp4MoJUnkziLJwNnYxPiLKZM4iymDJzFlIGzmDI9ZxFl4CyiDJyVKJMwiygDZhFlwCyiTOIs +ogycxZQJzsqUyZytpgyYlSgTmJUokzFbRZmgrESZoKxEmUxZiTJBWYkyQdkqymTIypQJyMqUCcjK +lLmCLKJMTz88GeiHJyP6ockk+qHJiH7VkoF9WDKJfdJkQB+aDOhDk0noQ5MBfXgysE+eTEIfngzo +w5MBfXgyCX14MqAPT0bokyaTyIcmA/mkyQA+aTKJe9JkwB6aDNhDk0nYw5UBe8gyYA9ZJmEPWQbs +IctAPmSZnny4MpAPVwby4cok8q3t7oOTD1cG9MmVSeTDlYF8uDKgT7JMIh+yDORDloF8yDKJfIgu +kA9bBvRhyyT2YcvAvtiI2Icvk9iHLwP78GVgH75Mzz7pMqAPXQb0ocsk9qHLwD50GdiHLpPYhy4D ++/5/6t6u15Imuc67H2D+Q19KAvpF5XeW7sgWL2wfywIFjj0wDIFokv4QemRInOHfd0XEWisz9z49 +I8mkBUOEyI63Tu6qrKyVmZHxRJCXofaRlzm0j7wMxI+4DMWPuMwhfsRlqH7EZah+xGUO9SMuQ/UD +LkPxIy5zqB95GaofeRmqH3mZN/UjLrOrH2kZqh9pGagfYZlD/QjLQP3IylD/yMoc+kdYhgJIWIYC +SFjmEEDCMhRA0jIUQNIyhwKSlqECkpahApKWORSQtAwVkLQMFJCwzCGBhGUogYRlqIGEZQ4RJCxD +FSQsQxUkLHOoIIgZiiCRGYogkZlDBInMUASJzFAEgczsGkhihhpIYoYaSGLm0EASM9RAEjPUQBIz +hwiSmKEIkpihCBKZOVQQyAxFkMgMRZDIzCGCxF0ogmRmKIJkZg4RJDNDEVQjEEFSM4cIkpqhCJKa +oQiSmtlFkNAMVZDQDFWQ0MyhgoRmqIKEZqiChGYOFSQ0QxUkNUMVJDVzqCCpGaggoBmKIKGZQwQJ +zVAECc1QBAnNHCJIaIYiSGiGKkho5lBBUjNUQVIzVEFSM28qSGhmV0EyM1RBMjNQQSIzhwoSmYEK +kpihCpKYOVSQyAxVkMgMVZDIzKGCRGaogmRmqIJkZg4VJDNDFSQzQxUkM3OoIJkZqiCZGaggkZlD +BYnMUAWJzFAFicwcKkhkhioIZIYiSGTmEEFyM1RBgjNSQYAzpwpeWraFCgY4IxEEOHOoILgZqeC1 +FNtVMLiZUwTBzUgEwc1IBMHNnCIIbkYiCG5GIghw5hRBgDNSQYAzUkGAM6cKAnqRCoKckQqCnDlV +EOSMVJCNUAXBzpwqCHZGKgh2RiqYtO9p+994DjSqINAZqaCjM6cGAp2RBgKdoQYSnTk0kOgMNZDs +DDWQ7MyhgWRnoIFEZyiCRGcOESQ6QxEkOkMRJDpziCDRGYog0RmKINCZQwPJzlADyc5QA8nOvGsg +0JlDA0HOSAODnKEEApw5JRDgDCUQ3IwkENzMKYEAZySBAGckgQBnTgkEOCMJBDkjCQQ5c0ogyBlJ +YJAzUkCQM6cCgpyRAoKcoQICnDkVEOCMFBDgjBQwKev5UdPDI7KlgABnJIEBzpwKCHpGCpglblF3 +APjMoYDEZ6iAxGcogcRndgkkPUMJJD1DCSQ9c2gg6RlqIOkZaiDpmUMDSc9QA0nPUAOJzxwaSHyG +Gkh8hhpIfObQQKIv1EDyM9RA8jOHBpKfoQaqEWggCJpDAkHQUAFJ0FABSdDsCkiAhgpIgIYKSIDm +0EACNNRAADSSQAA0pwQCoJEEUo4pgSBoTgkEQUMJBEAjCQRAc0ogABpJIAAaSSAAmlMCAdBIAgHQ +SAIB0JwaCIJGGgiCRhqYtO0+NZAAza6B5GeogeRnIILEZw4RJD4DESQ9QxEkPXOIIPEZiiDxGYog +8ZlDBInPUATJz1AEyc8cIgh+hhpIfoYiSH7mEEHyMxRB8jMQQeIzhwgSn6EIbnHh6WK44f2yGSY+ +QxEkPkMRJD5zqCAZGqogIRqqICGaQwUB0VAECdFQBAnR7CJIhoYiSIaGIkiG5hBBMjQUQTI0FEEy +NIcIkqGhCJKhoQgSojlEEBANNZAQDTUQEM0hgQRgKIGkaCiBpGgOCSRFQwlUI5BAcjSHBpKjoQiS +o6EIkqPZRZAYDUWQGA1FkBjNIYLEaCiCxGiogsRoDhUkRkMVBEdDESRHc4ggORqIIDAaaiAxmkMD +idFQA4nRUAOJ0RwaCIyGEkiMhhJIjOaQQHI0lEByNJRAcjRvEkiMZpdAUjSUQFI0kMCAaA4BJEQD +ASRDQwEEQ3PoHyEa6h8hGuofIZpD/wDRUP5I0VD+SNEc8keKhvpHUaD+kaI59I8UDfWPFA30jxDN +oX+EaKh/hGiof4RoDv1LgGiofwkQDfUvAaI59C+BpKH+pU5pCwEASnPIXxpasLn+JaA01L8ElGbX +vwSShvqXQNJQ/xJImkP/UpA0lL8Ekobyl0DSHPKXQNJQ/hJIGspf4i5ml79ELw70L3ErBP1LQGkO +AUzAYCiACSwNBTCBpTkEMIGloQCqEQhgAk1zCGACTUMBTHOd72X90Rl2kwDTUADT1Dm0C2ACTHMI +YAJMQwFMgGkogAkwzSGACTANBTBRjqdO1J2mORQwgaaBAibANJTABJjmkMAEmIYSmADTUAITYJpD +AhNgGmpgAkxDDUyAaQ4NTKBpqIEJNA01MDXtuU8NJEyzayBZGmogWRpoIFGaQwWJ0kAFSdJQBUnS +HDJIlIYySJSGMkiU5pBBoDSUQbI0lEGyNIcMkqWhDJKloQySpTlkkCwNZZAsDWSQKM0hg0RpKINE +aSiDRGkOGSRKQxkkSkMZJEpzyCB5GsoggBrKIIGaQwYJ1FAGCdRIBgHUHDIInkYyeC3NdhkET3PK +IHga6SB4GungtQ5Nlg6Cp5EOgqeRDgKoOXUQQI10EECNdBBAzamDgGGkgyBqpIMgak4dBFEjHWQj +1MFgak4ZBFMjGQymRiqYtO1p+59YqLVUMOlEOlQQSM2pgkBqqIJEaqiCRGoOFZyrRln1rzqYGoog +mZpDBMnUQASJ1FAEidQcIkikhiJIpIYiSKTmEEEiNRRBIjUUQSI1hwiCqaEGkqmhBpKpedNAITW7 +CIqooQqKqIEMCqg5dFBADYRQPA2VUDzNIYUCaqiFAmoohgJqDjUUUEM9FFFDQRRRcygiiRoqooga +SqKImkMTRdRQFEXUQBUJ1ByqKKCGsiighroooOYQRgI1Wh8CqNH6EEDNuT4EVaP14RK9WCACqzkX +iMBqtEEOrEb7Y2A1x/4Y1bC4PQZVo+0xqJpzexxUjXbHoGrkIgRVc7oIQdXIRQiqRi5CYDWnixBY +jVyE2CHRQwis5vQQAomRhxBcjTyE4GpODyG4GnkI2Qg9hCBrThchyBr5CEHWyEcIsubwEQKskY8Q +YI18hABrTh8hwBptjwHWaHUIsOZcHQKs0eoQZI1WhyBrDmEkWQNhFFhDZRRYc0ijwBpqI8EaaqPA +mkMcBdZQHQnWUB0F1hzyKLKGAimyhgopsuZNIv//D9ZcwVadZM0VR8sia0ycy4bWXDbnryD6QGuu +8N2KrbEV0Rhia67wxvNvgq25zE8zxdZY0H4LHMW943a2K7Dm/iXmFYI1tzmCahVY89zctaKCAdY8 +N/MsWRZY89yMv0mCNc+/yxtYc3uIViZYY0fVpa+iM7YBM48q/8bJGhv11y2wxo7M+9UE1szXch4p +Jus+uriaYQH19+Jqxi8x98QSGlzNY7THJldjs6nFj5Crsdn0uTn9jTdgi3/bmZCrGa5ki6uxDYVK +UhGssa2JhV4RrLEvzcvDAKyZtsCdVX80Aumtz2KiC6yZXicsCayZmDHijwDWWF9ZHCPBmunF0rLA +GttZXyRzCdZMr+aWBdbMX+LbJ1hzW+m6vP3RDIZ6oFyNgzW3H+40gTU2lFfZHoA1FnRkmrUaqb4h +J1hjsUI2i+uXzLNrewpb7hCsud07s4rPPENg7oVxHKx5voaJqjYzPjuPmBNYY9/qaPqjcMTZ8r8t +ruZ5pd26BVxNsre26hAFV2NL9FwXV2Nr56svribFNLAGa3X2350iAmtsFVLaAmv2anUCa2xU3m2B +NRfqNhCsuQL/5B8FWHP9An4uuJrLFtdtcTXXwdsh2su+jtwXV2MXoRaNR4w9/87zT9YL+ycEaw6d +JVlDnSVZQ50lWnPoLNEa6izZGuos2ZpDaMnWUGjB1khowdZsQguwRmobYI3EFmDNKbYAayS2AGsk +tgBrTrEFWCOxBVgjtQVZc6otyBqqLcAaqS3AmkNtwdVIbcHVUG3J1RxqS66GakuuhnJLruaQW3I1 +lFvnaqi15GoOrSVYQ60lWEOtJVhzaC3BGmotwBpKLcGaQ2oJ1lBqAdZQaQnWHEpLsIZKS7CGSkuw +5lBaUjFUWoA1FFqANYfOEqyhzq4mQmcJ1hw6S7CGOkuwhjpLsGbXWYE10FmBNdBZgjW7zAqsCZkV +VwOZFVez66y4GuisuBrqLLmaQ2fB1VBmCdZQZgnWHDILsIYqS7CGKkuw5lBZgjVQWXI1VFlwNdfJ +2gVXQ5ElV0ORJVfzJrICa3b1E1kD9RNZA/UTWrOrn9AaqB/YGmif2Jpd+8jWQPrI1lD6yNYs6SNY +Q+kjWEPtA1hzSB/BGkofwRpKH8GaQ/oI1lD6CNZQ+kDWHMpHsgbKB7CGwgewZtc9cDWUPXI1lD1y +NYfskauh7JGroeyRqzlkj1wNZY9cDZWPXM2hfARrqHwEa6h8BGsO5WvKaxPKR7CG0gew5lA+gjVU +PoI1lD6ANYfyEayh8hGsofIRrDmUj0wMlY9gDaWPYM2hfQRrqH2rkdA+gjWH9hGsofYRrKH2EazZ +tY9gDaRPYA2kT2DNrn0Ca0L7xNVA+8TV7NonrgbaJ64G2ieuZtc+cTUQP4E1ED+BNbv4CayB+gms +gfoJrNnVT2BNqB+5GoifuJpd/cTVQP3E1UD9xNW8qZ/Aml39RNZA/UTWQP2E1uzqJ7QG6ie2Bvon +tmbXP7E1EECyNRRAsjVLAAnWUAAJ1lAACdYcCkiwhgpIsIYKSLDmUECCNVRAgjVUQJI1hwSSrIEE +EqyhBhKs2UWQXA1VkFwNVZBczaGC4GooguRqKILkag4RJFdDESRXQxEEV3NoIMEaaiDBGmogwZpD +AwnWUAMJ1lADCdYcIkiwhiJIsIYiSLDmUEGANRRBgjUUQYI1hwiSiaEIEqyhCBKsOUSQYA1FcDUS +Ikiw5hBBgjUUQYI1FEGCNbsICqyBCgqsgQoKrNlVUGBNqKC4GqiguJpdBcXVQAXF1UAFxdXsKiiu +BipIsAYiKLBmF0GBNRBBgTUQQYE1uwgKrAkRFFcDFRRXc53MXXA1UEFxNVBBcTVvKg== + + + KLBmV0GRNVBBkTVQQaE1uwoKrYEKiq2BCoqt2VVQbA1UkGwNVZBszVJBgjVUQYI1VEGCNYcKEqyh +ChKsoQoSrDlUkGANVZBgDVWQZM2hgiRroIIEa6iCBGt2FSRXQxUEV0MRJFdziCC5GqoguRqpILia +UwXB1UgFg6uRCIKrOVUQYI1U8KJkQwUDrDlFEGCNRBBgjUQQYM0pggBrJIIAaySCAGtOEQRYIxUE +WCMVBFhzqiCYGKkgwBqpIMCaUwUB1kgF1QhUEGDNqYIAa6SCAGukgkmbnqWCBGuoggRrqIIB1hwa +SLAGGkiuBhoormbXQHE10EBxNdBAcTW7BoqrgQYKrIEICqzZRVBgDURQYA1EUGDNLoICa0IExdVA +BMnVXCdxN7Df9m9YXA00UFzNuwYSrDk0kGQNNTDRAxASSLTmkECiNZRAsjWUQLI1hwSSraEEgq2R +BIKt2SQQYI0kEGCNJBBgzSmBAGskgQHWSAEB1pwKCLBGCgiwRgoIsuZUQJA1VECANVJAgDWHAoKr +kQKCq5EEBldzKiC4GilgpriFApKrORSQXA0VkFwNJZBczSGBBGsogQRrKIEEaw4NJFhDDSRYQw0k +WHNoIMEaaiDBGmogwZpDAwnWUAMJ1lADCdYcGkgmhhpIsIYaSLDm0ECCNdTA1UhoIMCaQwIB1lAB +CdZQAQnW7AoosAYKKLAGCiiwZtdAgTWhgeRqKIHkag4JJFdDCSRXQwkkV3NIILkaSiDBGkogwZpD +AgnWUAIJ1lACCdYcEkiwBhJIroYSSK7m0EByNdRAcjXUwKRd94sGCqzZNVBkDTRQZA1EUGjNLoJC +ayCCYmsggmJrdhEUWwMRJFtDESRbs0SQYA1FkGANRZBgzSGCAGuogQRrKIIEaw4RJFhDESRYQxEk +WXOIIMkaiODKNx4iSLBmF0FyNRRBcjUUQXI1hwqSq6EKkquhCpKrOVQQXA1FkFwNRZBczSGCBGso +ggRrKIIEaw4RJFhDESRYQxEkWHOIIMEaiiDBGoogwZpDBAHWUAMJ1lADAdYcEkgmhhJIsIYSSLDm +kECCNZTA1UhIIMGaQwMJ1lAECdZQBAnW7CIosAYiKLAGIiiwZhdBgTUhguJqoILianYVFFcDFSRX +AxEUV7OLoLgaiCDBGmigwJpdAwXWQAMF1kADBdbsGkiwJiRQXA0kUFzNdQJ3ETUGCRRXAwkUV/Mm +gQJrdgkUWQMJFFkDCQRaswug0BoIoNgaCCDZml3/xNZA/8jWUP/I1iz9A1hD+SNYQ/kjWHPIH8Ea +6h+jCal/BGsO/SNYQ/0jWEP9I1lz6B/JGugfwRrqH8GaXf/I1VD/yNVQ/8jVHPpHrob6B66G8keu +5pA/cjXUP3I11D9yNYf+Eayh/hGsof4RrDn0D2AN5Y9gDeWPYM0hfwRrKH8Eayh/BGsO+SNYQ/0j +WEP9I1hzCCCZGAogwRoKIMGaQwAJ1lAAVyMhgARrDgEkWEMBJFhDASRYswugwBoIoMAaCKDAml0A +BdaEAIqrgQCKq9kFUFwNBFBcDRRQXM2ugOJqLsFIAdZAAgXW7BIosAYSKLAGEiiwZpdAgTWhgeJq +oIHianYNFFcDDRRXAw0UV/OmgQJrdg0UWQMNFFkDDRRas6ug0BqooNgaqKDYml0GxdZABsnWUAbJ +1iwZBFhDGSRYQxkkWHPIIMEayiDBGsogwZpDBgnWUAYJ1lAGSdYcMkiyBjJIsIYySLBml0FyNZRB +cjWUQXI1hwySq6EMgquhDJKrOWSQXA1lkFyNZBBczSmDAGskgxdFGzIIsOaUQYA10kGANdLBi4cm +uw4CrJEOAqyRDgKsOXUQYI10EGCNdBBgzamDYGKkgwBrpIMAa04dBFgjHVQj0MEAa04ZBFgjGQyw +RiqYtOdZKkiwhipIsIYqSLDmUEGCNaGC4mqgguJqdhUkVwMRFFcDERRXs4uguBqIoMAaiKDAml0E +BdZABAXWQAQF1uwiKLAmRFBcDURQXM0uguRqoIHiaqCB4mreNHCBNbsILrIGKrjIGsjgQmt2HVxo +DYRwsTVQwsXW7FK42BpoodgaiqHYmqWGAmuohwJrKIgCaw5FJFhDRRRYQ0kUWHNoosAaiqLAGqoi +yZpDFUXWQBYF1lAXBdbswkiuRutDcDVaH4KrOdeH4Gq0PpToYYEIruZcIIKr0QY5uBrtjyFT5/44 +wBptjwHWaHsMsObcHgdYo90xwBq5CAHWnC5CgDVyEQKskYsQYM3pIgRYIxdhbJHkIQRYc3oIwcTI +QwiwRh5CgDWnhxBgjTyEagQeQoA1p4sQYI18hABr5CMEWHP4CAnW0EdIsIY+QoI1h4+QYA22x+Rq +uDokV3OsDsnVcHVIroarQ3I1uzCKq4EwLrAGyrjAml0aF1gDbRRYA21cYM0ujgusCXUUVwN1XFzN +Lo+Lq4FALq4GCrm4mv+88Oz/lmCNX3n/14M22UP+8gnaZCvmdTXFuj8fsR+sEbTJFtI9V1B96Var +yaIhWMPG4K0Y8eBsMj5b/knU0jaHae3ibLLN+aBivI77L/H+vsUf2b8f7QZaY+P50akUdEvUsHmW +Uxapoh9xP7HXJaqrhs0v3auLqYaNH78m/dEzsdjorh2UkEdiPXKcohJHZO8IYeSfRA0bC1JqTaiN +nSuVEVV8nLWxsfysTl5oGxurz8dehdtc9n1ZATLyNjYNPrPkKkrjwM1F1OYy163XbgFrY3ORfQ68 +3CcFa8vDpAnbXM6ebVVsgsK4XnCb59eepVugMx6dYR9gzWlVsnnuYo71VyNKRVnhtbjIgRs/uMsB +jThx81xR/KOLvwNyY302fb+TUYbhl+uymV7FbNxjW/VXUczmmRquPFYxm2ceYbUYJzesEt69AJVn +B27GWMOpmM0vDWVqopaNuULudXvhg3SKNuiZKBk3w6HCWja/2Myw3V01T2n4EUncZIv0u1Ypm2z+ +/7LdXPcPrka1UiA3Nsn6NgfIjU2gLS0gKFIgWnxM72JurBicHbaAuSn+4tYocubGpg/7osjcFCci +qpibYuhTeqllU6IaH5EbO6FAwStHbuwsobT1FTpyUyywToiN/dHlkXREbrJzoevbiAKf9nv93nQo +FlNkbizK3UbHNwmai9N41qBFzI1dZJ8TmRtTvE6w+uei/nx197PPGptu//mf/9n377//8Zf/4e// +2q6ltP/T0TmnOIPOkTiDzpE4g845xRl0DsUZcI7EGXDOqc6Ac6TOgHOkzoBzTnUGnyOJtpNt24pR +oln55pBoVr6hRLPyDSWalW8OiWblG0o0K99Qo1n6ZtdoVr6hRgPQWRoNQudFo8HoLI0GpCONJqVz +ajQxnUuAjkSahM4h0iR0JNKO6EihyeicCk1IRwpNSkcKTUxnV2hSOlJoYDoSaHI6p0AT1LEO85qa +LIEDfVYJnF2fVQIH+qwSONBnlcDZ9Vn1a6DPLIET8swKOLs6qwIO1Hm1EOqsCji7OhPUgTqT06E6 +k9M51JmgDtWZoA7VGaDOIc4EdSjOJHUoziR1DnUmqUN1JqkjdQapc6pzkDoUZ4A6EmeAOqc4B6gj +bQaoI20GqHNqM0AdaTNIHWlzkDqnNIPUkTSD1JE0g9ShNK/1NkmdQwlJ6lAJSepQCUnqHEpIUgdK +GKAOdZCgzqGDAHUogwR1KIMEdQ4ZJKtDGQxWp0oGWQRnV0EVwYEKqggOVFBFcHYVVBEcqKCK4EAF +WQVnE0EVwYEIgtWRBgLWOSUQuI4UkLyOFJDAzqmAJHYusTpSQMI6hwIS1pECktaRCBLXOUWQvI5E +kMCORJDEzi6CBHYkgiR2pIJAdk4RJLMjEVQ1HKggq+HsIqhqOBBBVcOBCKoazi6CKmQDEVQ1nFBB +FcPZZVDFcCCDq42QQRXD2WWQzA5kkMgOZZDIziGDYHaogmR2qIJkdg4ZJLNDGSS0QxkktHPIIKEd +yiChHcogoZ1DBgntQAfJ7FAHyewcOkhmh0JIZodCSGbnEEIyOxRCQDvUQUI7hxAS2qEQEtqhEBLa +eRdCQjuHEBLaoRAS2qEQEto5hJDQDoSQzA6lkMzOIYVkdqiFZHaohWR2Di0ktkMtdExnrF276uHs +Yqh6OBBD1cOBGKoezi6GqocDMVQ9HIihCuJsaqh6OFBDYjuSQ3I7px6S3JEgEt2RIJLdOQUR8M4l +bEd6SG7n0ENyO9JDgjvSQ5A7pxwS3ZEckt2RHBLe2eWQ7I7kkPCO5JD0zqmHxHekhyqMAz1UYZxd +EFkYB3qowjjQQxXG2fVQNW2ghyqME3qouji7HqouDvRwtRF6qLo4ux4S34Eekt6hHpLeOfSQ+A4F +kfgOBZH4ziGIxHcoiOR3KIjkdw5BJL9DQSS/Q0Ekv3MIIvkdCCLwHeoh8Z1DD4nvUA+J71APie8c +ekh8h3pIfoeCSH7nEETyOxRE8jsURPI774JIfucQRPI7FETyOxRE8juHIJLfgSAS36EgEt85BJH4 +DgWR+A4FkfjOIYgkeCiITuz4gU4Iokrj7IKo0jgQRJXGgSCqNM4uiCqNA0FUaRwIomrjbIKo0jgQ +RBI8EkQiPKcgEuKRIILikR4S4zn1kBzPJYJnCSIQnlMQLy7jKIjB8Cw9BMTzIoigeJYgXtJvCGJw +PIceAuNZegiOZ+khQJ4XPQTJs/SQNXKoh6yRc+gha+RQEFkjh4LIGjmHILK8DQWRNXIgiCyRcwgi +S+RQENUGBJElcg5BBMlDQQTII0FM3BTtggiSR4IIkkeC6CTPKYcgeSSHQHkoh0R5DjkkykM5JMpD +OSTKc8ghUR7IIUke6iFJnkMPSfJQD0nyUA9J8hx6SJKHekiUh3oIlOeQQ6I8lEOiPJRDojyfyCFQ +nlMOgfJIDgPlkRoC5TnVECgP1RAkj9QQJM+phiB5pIYgeaSGIHlONQTMIzW0I0LfTEENWSXnUENW +yaEaokoOxZBVcg4xZJUciiGr5FAMWSZnF0NWyaEYAuZZYgia50UMwfMsMQTQs9QwiJ4XMQTScwnm +kRiS5jnEkDSPxJA4j9SQPM+phgR6pIYkeqSGRHp2OSTRIzkk0iM5JNNzyiGhHsmhyuVADlUuZ5dD +lcuBHKpcDuRQ5XJ2OVSlG8ihyuWEHKpazi6HqpYDOVxthByyWs6uhoB6IIZkeiiGZHoOMSTUQzEk +1EMxJNRzyCGhHsohqB6pIaieUw1B9UgNIc1SQ1A9pxqC6qEaAuqRGgLqOdUQUI/UEFCP1BBQz6mG +gHqkhqB6pIagek45BNUjOQTVIzlM3Je/yiGpnkMOSfVQDkn1UA9J9Rx6SKoHekioh3pIqOfQQ0I9 +1ENCPdRDQj2HHpLroR46x+NnzaGHKpiz6yEL5kAOVTAHeqiCObseqmAO9FAFc6CHqpiz6aEK5kAP +yfVIDwn2nHpItEd6SLZHeki45xRE0j2XuB4JIsGeQxAB9kgPSfZID4n2nHpItkd6SA== + + + uEd6SLpn10PCPdJD0j3SQ+I9px6S75EeqnIO9FCVc3Y9ZOUcyKEq50AOWTlnV0MVvYEaqnJOqKEK +5+xqqMI5UMPVRqihCufscki+B3pIvId6SLzn0EPyPdRD8j3UQ/I9hx6S76EeEvChIBLwOQSRgA8F +EYAP9ZCAz6GHBHygh+B7KIfkew45JN9DOSTfQzkk33PIIfgeqiEBH6ohAZ9DDQn4UA0J+FANCfi8 +qyEBn0MNCfhQDQn4UA0D8Dm0kIAPtJB8D7UQfM8hheR7KIXkeyiF5HsOKQTiQyUMxCdJCVU7Z1dC +1c6BFKp2DqRQtXN2KVTtHEihaudAClU8Z5NC1c6BFBLxkRSS8TmlkJSPpJCYj6SQnM8phQR9LiI+ +UkIyPocSkvGRFBLykRSS8jmlkJiPpJCcj6SQoM8uheB8pIQEfaSEJH1OJSTqIyVUER0ooYro7Eqo +IjqQQhXRgRSqiM6uhap/s0ohBLcSWqgaOrsWqoYOtHC1EVqoGjq7FhL1ySrHhdPB0EKSPocWEvWh +FhL1oRYS9Tm0kKgPtZCsD7WQrM+hhWR9qIVkfSiGZH0OMSTrAzEk6kM1JOpzqCFRH6ohUR+qIVGf +Qw2J+lAOyfpQDsn6HHJI1odySNaHckjW510OyfocckjWh3JI1odySNbnEESyPhBEoj4URKI+hyIS +9aEiEvWhIhL1ORQRtA8V0QK0I7IiFFFldHZFVBkdKKLK6EARVUZnV0SV0YEiqowOFFF1dDZFVBkd +KCJpHykicZ9TEQn8SBFJ/EgRifycikjm5yLtI0Uk7nMoInEfKSJ5n6WIAH5eFBHEz1LESwoORQTz +cygikJ8liWB+liReOm3ZJRHUz5JE1tOhJLKeziGJrKdDSWQ9HUoi6+kckshSOJRE1tOBJLKcziGJ +LKdDSVQbkESU0zkUEdQPFTGgHwli4p5oF0RQPxJEUD8SRFA/pyCC+qEgEvuhIBL7OQQR2A/1kNgP +9ZDYz6GHxH6gh6R+qIekfg49JPVDPST1Qz0k9XPoIakf6iGxH+ohsZ9DD4H9UA6J/VAOif28y6Gw +n0MPhf1QEBldT0EU9XMoolM/t6/fXRId+omNfqPvKaCfQxQd+qnuLQ1VFPRDWRT0c+iiuB8qo3E/ +OOoIaVwFdXZtVEEdaOMqqANxXAV1dnU07ifgfcjjKqgDfVRFnU0fV0EdCKS4HymkwJ9TIon+rEUj +2J+1aAT887JoBP1zfUlSP64aAf6cq0aAP2sDHbe/9s9AcV72z8H+rO0z4J+1fQb9c2yfA/5Zu2fQ +P8ubCPznxZsI/kch4u6VLOuwWZV1Dm8iK+vQm4gcCXQmsrLO4UxEtUl97SisA18i6+ocvkTW1aEv +0fCftvkSuUM6nIleAUj6SPpH3kTQP6c3EfiPvInAf+RNBP5zehOB/2j3DP5HK0bwP+eKEfyPVozg +f7RiBP9zKCT5Hyik8B9KpPCfQyOF/1AkHf+Jg+5QSfE/h0w+w0wSudQpJFLsz6GRYn+okmJ/KJNi +f/7Rw8T/G1NCf/H87z/778q/+wtv7+//9j/+DoY//9v//f/8HUz/8ss/+5//+g9/+5++4N///Ne/ +ejFEqTBLpw1w0AL85/SYVIvBsV/7/bqva7uv//75v/+vx/oPX+qX//HL//q/XV/+5tdm/1/+EpuN +o90fuxGNf/nw5zp/8TTyzz8+a9ONv4u7CULKXnJz8Swhqr56dD703/9/eld/F3f1l3yF9v/+B3yH +7cs/PB3VrfjaiNhwi28PKMDCNyLX/ewWWfssQqJoRbFI5deb8o+gG3eZPXbd3GPddrvdQ54f7b8d +KzKMw6PHG5f4xSfM+PHmmMxtUQf9ioNww4Wqpar2XTDD2u081mMru0UkW4W35DFvjvK0EkEl3c5U +Cubzf+t6ZREDo59PalEBddx60prCRcBHrY9WNBuP+6PyyBuPWp9pbES5B3/UWiP68XhUj4jpRY/q +QXRdT1rbo0kWTrk/6dPwbScHfNaIM9Gj5h7xVHzU73rUVKy2Vz0fNdmU04ce9dnJ5hZFEPxRfQBZ +6PX+qOYza1fio9rut5aiRzUvgR0xHo+aLz8P5pOm+xkJVtkCj2rOG0v+vj/p89vPVNn0pCnHxoCP +anRaN7bv/VmnNds8RavF0/ijDtsaWqT7iM38sL96/tmeZVjzOHc7Mn/6vMzCGEoLWS0eZtXtbKPl +CEl4/n1brFa7okmLhasKSTBPimVgHXGcUH3n3q3lUUfEyWWLoDJEoa2c1h5OVcFsNNvKPTvz5203 +e2nN4LY87b8X27HH7V2BwNUSXsCWguJ7fsnf8HO7t3Fgz7+fFe6qVWDxa/7rFfUNLo/q8B/0YO7G +jou/cBqoeseZ18MezMYMeu75X8OgRPZcrAMuW7tU9ZwdSJhDjT2XLfC8tLPnsq0/LAYGPZftS3/u +gj2XbU3zvLmj57KdWlt3oufM127hvew5O47p9s72njP/vDn12XN29GPJetFxdjBQ7vvsuDzjWvZc +NkfibOq5bO7QPI+ue348WxQOx1zGThtdZ0GNuc+z63wAG1jn0dBWPLNAgJt9T5ER1EIfOw787ZDU +wvBv31h8yXeser9jBD8r1dtuds7kCnk7mWYO3qi24AdFdq50s4pgG0ESPL3iG6V2I5yuBAbWza3Q +/UCt3RSF56LnK/VMd3Y33XvBH8CXVyYwqd9x8NRWCZvSbbNpv16daknZNnA5gjiejzKQMlOjSirk +QtWnOw5qmgcDshplsffT0xzsum+QeT/kY9c9/Z9sGkbXeZCDvZ696yw6xb5bdl1xhjup6yzWo9T7 +7LoC3WTXFYOy4kTVu84iATy6ee86i6CocXLod1OCC2XXFftE6zi7zkaURbWz68qIOEp2XekYDXvX +eRSERTyj657nvXMUsvau8+KOo7LrQoWfJ7jSra4zf/odB+L+nn2l8NJ1MYTv6BfzDVp0eogwYKeU +YzocV2QWT8Bau/k1eySCyipFZQeRyGZpZ/DdTkUjLdgwZs1Csj0r7fMXs+tvusU+PF+0V4j11YqV +/Xjata2OLVfsoJIro7VcsUn6uZlpyxa47M3r6Hlube/s/+6zXX1br9zNf95OMQZVFz3j6xU/oX9U +o26V3qazcNnCmVIsWZ7556s5E5qvWHpUS/DO+4ZJ4tnrTHWeq1ef6ryaotGj8yzmMUdue++8Yskl +vIRj9J6tgGZqZ+/ZCshCHtl7vgKyEjroPVsB9ZfO8wWQyRI6z1dAnvc3Os9WQMVzHW2dZyug6YUe +o/MqlRed50sgP+rYOs+XQOG4ic7zNdDzpaDz7AstqBpvnRdSnGISYedZSVkfVASqKxKH7Z2XLCIj +crlGTlf3UDV1nq+pvB791nm2pjL3KTvP11Q2h6PzXhfla031qAt7zxdVnokves8XVXc6ey9jocre +81WVxXGi92xVNc+++7d/fI/WzPDv/vV/+N2/eXaGf/9sDr9+hd33bvt/+fWv/vX/7f9txn/78//4 ++//0f6itf/ZXv/vdX//427/5kv/5r68vf/brXz2br3/49a9+7/9zbtg+367FZu3r81gjIqoekX9m +zRQ7o6/P0ELw9LJ/vNprxL58vLbzM/tq53e4z//J/r/Ld73//pPWjUPV3YA0OVo3e+SuN3sx7vOz +u7R2HvvfxX+6IzLK/1M1D+UP2Q2GDrtFF8GYncd5jC0/wyyMTn6GsT6S8I0/ek91wTM0Pthw1r1f +82LD5hJDGzYrfHpr37e77gG32H+y8wXddUzL3gHPBxi223IPRNsWNP0Y78uoO7Td7HT/Gxtwd2k0 +3CpbiMW1X2yRuZ/ewjfc3byGReDl7Rd/yH5ltmO+5jB60Z8w2j4dRr0wT/vzjS2k+6q0J1y7OtSv +/fQWdHfJVtgdbdzmy/5B+6wVQ/yyE/kYsnaCYzB7XG8uszBe2Smr5+Jkjlj7UUsq0tgCfhR2dNVj +t6QU0fJlNd0r7bZCMaPD07hzc0G5MUcEjhu9LDhaDrmBvaDzjF3v6OY5VguPTsNohcS/s4U6+cLd +ERvG8izrwujx2WF0/imMRtnrHvI12LLFzsI41OyjvGzW6znEb8WKzOzmTi3ozMumLTNe2IT5z5lm +hLFfamEUNmBnFoPd83yYuBalYvwhcAvX9rjjGXgY9/ejKHby4vY+/NeeURLgfRhLjPvbBs0tYciZ +LdRYumHExbd315im8ZnFd21XGjeEZi8Kxm0uV/6c9YfZkkXmTH6PaeDjtRxoaJV/fQUcHVeakz6M +UQHEjdtfz8Gf2f6+d3ZXtt+Mn79uDoSWZfTgmWjAhhJaSJsQehD1B+2zJPRt7riLFLKDZwjLM/vj +z+uV1awdAXHclRjj3uYYmb/VO1uoVFw/ElcLzjajhfwlOtuPzXBThe/2GlLcyvFlds9/FxdPtGBj +mH3jhzhmNDXourJqdDRjsPlu691xsQezHi/c4qb6vbWqAXrZ6iOutSOC189Bgmphn42j45JU2PaP +c6MdFfm1Fgt26xlC21w78+CE1jfxzSVTfO0YisY1JZbVwqv6hn3NGY++h1zNbdh3CwMO4530EPOe +S0p98x7fb66dIv2sFVPTg8zsIt0D942W7RjFjHfEKa4hHUJokbD17mcLtitMHHvu7nmMxdSm3Px+ +J2XM7Jq0np3LzYslF/4gYURVKzOOyXdU4sSGNxyzipECjSsRfIPTYvdH05Rc2D9u17uzDyz6p9jO +lY14DI4ZH9HLmmXRck0RNbzkPFp2n+qgcs4QaaMZ7dj00H5zp6WGe3AfUrRg9mtyTrBJLO6t2fEQ +BQlNtG1eswwSZpubDvh5VzRrLgrMutbDPgC7vcy4hRa7bDO2bW3jiQ7RwLDkfefia1rSo2djES1k +cz09RnMUDWr8s5nnmx91m+1cN8w4LPkL558Wveu+0pjVWuQYiBbms6+tXI/ZtspsPTIM+LV2EuvG +aSFBiZ3VOAXefmKNi32NZMYU6F90I5p9lO/SSsDOytGA7a74GfpW6oP2ZnDHGmlmtGU3twMeiRJG +V4XXkXPXyMwVP/h8Cx80j8b36Wf9Zmy2YUTDOZUbRkvaiU7TeHrMPh3gJd+TDVv4aoM9rYZNsrnq +uweM/v2GsUmnbouH7WXr5D/S7ESzzXxwbbWAkpb2zJdvH54h9/yfekfQIzNmfsk+16OFbkfAebPH +9ulKnHqbEVJxZb84v3qiTbWwxAtred+AaVT6puJ1t+Yu5G/arY1bqnEnXOyx9OjJWWBMbXBA5Hmv +Fq7Jb97DNT54bzeUDtfj4qjO6Z0Zyzi7st2NQy1vT+dQbdgHXiii6OOTie/wRqYBt/l/VQOpVNoh ++G4cg8a2WuD61HNUrZecKjVi3Bom6arnLbRI2hm2pTw2KDt7zQMYNIJ9neR29kMNFAz9wM/wxorL +fqFsX9w1uRF5fmHwu4fE2I1d8eYtbV+v25VoIWkj2SJvRBhzvQtbGLD5jcdtzcibig== + + + a1Nnnz0//CVESnfbYfBXh3eTxq5m982OyRkXPzMwutvHOYy102ijEYJ6P98axxK3MLZnjXqY9lTZ +V6JmdPFwYxtlrBb8QDCeFlPmtJAtfsK9xQpmWpgmO8tzZqKFEcmn4t5iNp+WFYK/ViEtfmHGhYxq +iBngeW34NWzd5zTJmegbC+AKW4IE2PDrFPVpvE3XwIvPbJbYt0TXWCiMGfMjWBd73EY1WkC2Q7yJ +mAfnM6/MxF64Mo1X1PP0N5ErW0jbYGwWTRiDfF6bfGMvP27t2VokXzDjjNk63tqtOXPMONCNBjBD +zwDbwoYlzWN8dpX8nNLNZxtDDpbt18xhyEEOH88zc7LeKUczWmiepRgXW3K9MAYO7Z1e4zsx41V4 +Y+pe9183TgnxVVsmUDkisjFqth6xg02qWJuaBLtH6rNdm54/uKjxKXh9F2F0siRabjG79hGZWTCv +aex0xxB4ayUmfjcW3W+DjQ6AsOHvLV4971NCGD1jL9Y0c3JhNtnlvr1CC7ZoZQvF8j/81NgtSEBd +3sZqAbWb/YFv/pxn24guc0uVS8hP27W0NMcBRaTa7v6Ddi57bQ2itZLZJ5cIxb5cGO8hhYqJqtdt +4FQ7DsUvpl2M4ApplmOGn1u+YrVlicJa5qNxE25mTyodt3Dpa7NF9uCX5W0suz5l396FMSc+Rw6B +MFvlJ5BtTY4fzNtSm9NKS9t3zNVouyJ3BtZ2WumYXZ8nl9q2WcAutoUrF1dWvfv1muvtmcu5Fghf +UV1+2RbJpcOYuroh0ffids37niwbxsTp2fsSxskvwOOP0cKITAfr6cxoykb1zDkEvBY7huFvreFe +8+aYuVvMb/XS7s+Gbca+bTk/brmg3D7ZZ5eRENj89UB+jmVcqfL3WE437AizvA92gKJXZIxx72oZ +F6dICBa3MaLPyiVfpxnXvV3aVqKFuLc8IwdmLHNrLJTzCModfRxb8bZtNW+D6KLh7NrPoWae2A/a +qaLP9Vb1wIy2vG37YjKMTr9F91ifoOVqwQ633gf30sbjWWBVjT12iEq2nksUwfAVzpwikVKV0xUt +W1JV7st834GWrzjtrrurOV+RfSQaaeFWyNfegnn7vrGFZxbqfOpYc5gxSnr7z+GpLZE8vXWelD1a +SHeEbuBrjFGYPJydnRm+rpmGJnw0ixZGRKzHq7bjTvhoulZf2D2bscXRMIZhCJ7vgfktrQ2f/ZnW +29dybribis4NH4jLboG4cf3m0X+2tPekXMBR4x6ksm0yv352VLDOON582T+WvX3iT0/aR23GTAe3 +H1vJn+5TEN53bby4rEGQZXzzp/8dNzfPp8Dp376bH7JrovSFO4w3JdyH/Nc/vm3KmrmwIPRmizYy +mXupl3uI86u/+vWvlNj+5f/2A86/+N3fnMebf/LY080Wyvp6/PlfcPY5xri+PJ+oyYmjEl/H8xkY +CZeX+ePFbOLzzGlhjwY+Ma0/3k86f3H2wmKn78jl/1xuEVv9+YthGMuMuxiWzdX8jY+5Pp+hTWSP +0dYEtxtHYOt/iIvN1201N8zu2TweY5uBHT9Gy9z2zHq42ILLJuy2zuQNm/o8v6Or/JD+sT+7RcuA +Zsbn/s1x+RhLOPvjYltPmPp5I92i0R/jMwE9c00zo0VVNL8pZhPyZj2O/Vv0genA7S0nuMofo7lO +uhvN3WeOj7feisFv/dqac1gWze+oA3v3CheE3/O0tAfRwR7NZuV+7E4S+6zEdOS3EWvlx5hRa8d6 +17/z7/HUNhUanFNHsZ2xX2yxh7bwMwLJaLv55bfxc6aDVtHE7cV7qFo+Aot1cJufZ/h9PS+khNF3 +s+ghSzfVetxauqOP3x/uN+qP93H2zLrdH67j5DF6ol0xK/ovevh/GP28ykIknnERP/feE9/YQrVQ +JY+niGdwMuL5t60E74xxUp5JIvlbHjO646sRl5EKw0e6YzNfLWVWHJLFvTbsrr2FXPkMnt84usYv +cSPv9f1p/+RQsWjOYsWcqqfZG2l1kCdjt7xXcH7hYuMjawvuiN/CHY7y53ct/U7J+Bb5gV6RIiPG +j7tInyvv52PLDeOq2jlWta+pm99gJHRIIGe1MwrBsjBHqqbHaCV5UkIv5RGLpefekJnNus4D4/2G +W+TyNGOOdC/Po7VIL/WNmoR7s8A+nzI+658//HS0NT9W49fhe82QV5MTr5brdj/5ecR1fR0zyjz8 +IS5GJrHH3iNLrhltkzRh9G8iLh4WzZwhF7ZGfRXzbPg1rjWvY7vja/JICWu4RN54N3oClLj4vsIX +EeLkb/QRWQuszPHlNfMBm9FOxTtv94JT1uDeSNbsQ9wQFfu1e0RZKDdmE/NPe+1Pjdp+FT6iTQoD +oQ2P/YoVsH+Esav0R3EgLb7gEb1/e/EPCMCzeyoxEJ8lWnhhn+HlftfhF6MxH9/+4L+Ni0cE6RpM +bxu2L/Hc7j13m+NRcV+OWT/GFCmkvsX95vA5+qPPPqKb3x7u5wLX3LNa7NYs47PNODHkbmvPAivt +NoY9fhihRY8+TEuA+WlPfGMLVnkrvr7r8uFiD3JZ5I93T7ajgz/Eg3jpjBLftWei/moJ0eNcx5+a +48VOdQ0/e264xOkCuqLHbT52y2vSOgaXL3Pd6CcVnz7ynxovzY/3rY6hffIOnquX3Cvs9pp8to2L +fWa3OHJLyYEPEwfarjB2IG42Lxs2o5Nuy30TN+ipoR6jRR+NcBX70zhMF2p0+9cari/vUcvs7E60 +xzgjw40BjnE+Gp3kB71Wu7ZaCPz07wfRDXdIlH8/ZvQEinazFr+Z2+RbrbFqe+zPduuOp3jvnhC5 +338+6OxdRQVN+0X/yuPze7ZaHj7sk4aTlY+xNJR/fNbWXFX1aoki4m33X1Ao7jGbC8mEKb6T5kui +/izZPF7eR62zoI/xrpER2Y25Rji92e84oXS77RkeDb/MpRjfAj4Am4IfLcA8ckUC5JiJCnLxe9e7 +xyhWMrX5LVjKbnP+x8Kpxbdgqd1H56rFL3HptGdz199j7FEIx40eG/CbuHgNe1uZxoLK4uftLXg3 +PDvuggWVZ/CvOebfObvPUNcdTp+YOj3qxLvHYz18lkycZq1/7+6Llo5cI/aCsH3xVr1UWrzifDeM +NHelhD5OpEx2ux9Tx1fgqSWeFma4ikIfzd2fveMtPX502yMOEYDh48FX+b/hjOPI6WO/Io1UjMyZ +4gO1kjnPRPVbyh5eqWWftsgOM96/eME7H5Z+uvfpWEVwoS+s3FdhS9Zn4ZS49smYsB67RQlOX86k +FHnYDUoKh/DT9XZm72PFF/6Vg/B57kfAG2QlGniGNd9TRbLDx9iyM7Sx5kid37nlofa6q9US39qS +y3dZ3RMQungWTao2X/RYz+ThyReo6pdPTZ79sOv7vyJNltufRVPDK3Hi2Jt1//9v+P6cJ/CLHR6O +pQh62RMQxgzpBzgXe6cEdRIzZFRCfNbKUSIDAy72WRbykWNmsdmgxqN1O1uqHLJ3hPa5YHmpyuhg +V2vvS8/Jbm/D1p4JN/Zs1Aa+6DTDK/TcAzI8x5LVsys9xuCtfa9nbJmvwJ8Xn20VGi105Hhzu3+B +cbHX3YpRknPsFnOERTz3cMULCk0wjRm+MbQl6YXF8DNeU/y9x2X8lorQp69AsgUMxS74GRCOBfk7 +9rwEn47f75wIPXGmJ/HIWiq8v+UfPx8S7+Pnt1x5vQ22z4fl+xiOsf025GNof/p5fPYh/eyr+/QL +/fRT/rTfftbJn76O1zf3R17y+4j4DS/27Lr+EZToSNszQfiN5bJDe0wR2Iq1OMn/zoGCXjdtNOQ7 +jH4M4csrTJafTD5/bKZ6m9a0m3+fAz+dLX82tX42D382Yf90cv90JfDpmuEn64tP1yKfrlo+nTZ+ +Msf8ZDZ6m7q+/Xye+9mkOO8owuFrUc+vH8a7+DirnmqCm5wcg/+Omhnf+Wvu/faPBc4Da2BM3weU +FiF+n8rDt39qL+Y7xvFf4ceEo+0H/QheE3PZP17sPW8TajTxiWn76+fO/8XyZfZIb2fL4bK8TBbH +64PFADHbB+lu/Bg/NpMDUl6jdqgb3eFw3l8XKnzaS2idnuf5nFrcvB+LhG/N8witJ4rPtg3fdNAI +sRuRN/y82LJjsZs8IUh4lTAGuw03hDy53TFUt8dBYPgCw11rRhtFYWyj5c34nS2Mkt8vnp2b7a1Z +PxGBdOSyJBt7NdvmxmLEHTklZCJrwjcf6qXn7ZHwIxxdjswcF5sG5gJXnMcBvBr90Oo7V+W096iJ +EUb2w2OctHnNStn099eVXy71zDR07/nhgxuzwWbhCGR8iNudcQlZtNw4dGbecJ75dIeHxavc4Ai3 +YxN6XhyJ5PZmbY7M7mGhUS+Cfb5dbAWxL/zcsDxYYbxGeAVqpGjVgDT1C7tv8MPoG+UY//CeEudb +xu90qDsCd15cI0jXm02YEDej7cQz++Gw06lvS4/sC5mO6lLn4B9x1KohzcFg5cw7V29z+DxrxpHp +bU6xsOCVehcNw2FoSDf4kty4Oem9EFLc2OhzDag19uCUcOM924uxxcy0jGjBD3LeL3ZO9edGz/2o +Fja7eelhLAUfgCcrxG+1RvHMkpcmx4i7mu6Ci9eYHFyx7EbmNDrtBac+thJK7UUin6WL53l/lUhb +otX8IpGbsUaZ2lejHQi+t2Cn1IMtYAHs0TxxBPKsKL2C1zLiGWasMM+Lp3b3Wy/sxnqt8bTbE486 +rDR9uKjqcu+bTPu6toPcUQseVhHqcOke7krnfB91vhk9La5aWPYc3sjz5/wwI4zPErdsRrRgnuOe +Xy72uY1yVvKLrUVOYq2WaX92td1XTb5izxf8IR6V5qeQqcVEMX1/gldprsJWYeZ7r3pr99pF1sg9 +5g5VS0e2dpEpvGxWjhnXWo4Gn31Gp7vKvvDuSzbYvvN0Em9hu9TS1fpcaYF7ODY5jGua2cw1Vohh +vO44nSoaB/ZLuCkYdQdeKfP14h7d5alPGh+hRWfxt76xBac23A43sT/v7fvPx8ipw85iQ4FoxD30 +SFZ9Xtyj5kkcK4zYuG3GEiGJaoH2hMgRNz7fEU4gsSL2u618kW5UT7rb+bjYl43rxcY/ES7yfS0s +h5VgjFnBmvEHHCES6MyZ8mZ8e+rt4h6Bam70E8IYUNjb2i81NWB+3YrBE7EWbsRRhRmvmGnMmF0Z +aFQLHjH1enHD4J3zug+ThTYtD8qy+oY7TDjBnJe2r5sRUbb6+2Uf7eXSgehe70Cu/2HUK7tGfr14 +Rk3gx9h/ufub6Rolr7+nvQE6jLcV3vhZeb5hxpI6jE5l6RWOcKhaWHLiG6Qtx6nmb1+vjTxvuNhD +XyKMgJ1oLznRaEUR9KHd3T1WM4MV9ofwVYIb4Xc7jammvp6Y9qQ1i30RoZfzig02PtXiOwwLWZil +b09cfeJ57H7ocIzkxxjx9sfwtrLtd3sf9vf+saPZcQMQjPcengwal+hdcbi1XQx/XQ== + + + HITOOFfejDny3aOF3X5zmBo0FYEUJRyFYXRpm8jRqL9PEfBgh6Y58Q48gaEbOyNddqO71lYLsls+ +5i9nsxhmuIObYy83Ho37kVzBtXV73hA3i6mfd3szPpPF3gmw9yhZGkYvouffFFcAJmqxP+AW+ptU +t5b3jbltb0pEn8yIN4WIlQtG7Ii6Nrd25jZaX8pQMdK3L7tFwFjcWkpsIYW40ri0JSar/WIjG+VI +SDDVoeCetNYFvlHeL1wmk7vyakSR07e/7zFBwxgua5MbDrrdaJH7qwGZrziqNyOmKIY4hbHHuSSN +aqEV35GdF9cIhrFmqSCWF3Ny0PSiTsgR/usPwRM2uuO8G/wc9auvc32/9To+fBM95tv4sD1O63g5 +M4XGWhRJrehgV+mvEbFSKqQ7XzWtQB0voxkXm8f+a3gDUun8OWxXB0+bafxOz+cdnuz9Yj/E4Ezj +Ec8R3XRx+nBBlxsHUU+za6Yw30660JmNN7aM7lTiBLTZs4JTKoLyXcgmJhWvSnsPCLcdqSjczMPX +XHkjtNWb9Sx4brzwjpbTyYgUpDc77cUrbcsXNeMVDUsiHKcjXoXXF7F+gNPRvxm+g3tfkXlE+cDS ++h6FF8PdbEeVPYbUYRz3+vtl9Vyv8bie/daNZfBpR+1p2dS3cI8fl2Lc9Rl4yGkcsYxb0Uuya9Nf +g1SLDUcENOwOhhG0ilpwWDnsWFJWWz42bPoRnXAaXS/UwrLLS2HRZRO7R18QfP3MWxnHRunLv2J3 +4jR31nj9P2QvsFaMVvM7VBoLfYipRkhS2PQReb3349IeWEAoWm79zejR02pgs090shljUPsEQ9t9 +Q4w8AOWbPuMZmmh+tlA0G3sRJ2Mf4X33N6MnRFgDVXYeO5oxu1fOhbKy2Zc+/MZTZ3tRaXI2thHy +493OQ8bqOziIe0mTQ9vTW7qx9y2e1LOeeQM8PDJf2d2g7VesJO3m4gwftuWAy5QeXmqTcsWfR0qL +F2OzGAD5vjb7fG/Ay0TA2C6sU9wP9G01EDN0jdqJMN43jDdO5TZji2Jg6xZkj+QP/mB9RH910OHe +MdNIl1j8M/8Ehm/FdJEbOwzuMDt4jsg5ny3alTfj8oTG57VfjJx4MftjQt+M5m1cWr/bpWc3XRU2 +JiMs0B2L4caxsXdEMjb2Y730a+mKmbSASghnexrYlbhXRG+itoogW+6ofX4sCB/2QhcY/jV0IUcG +iNWP4+J6mk54+wQrjQ0OYYtoHH0zyp17l9JfLl5ficWG1f5ixCelGA9rPHcG+tqp5Q+dZsaBAu2H +Oj8beW5oN2MPWufVV2xh2Te/NmoB6tlGx7fRMCHfROBgn5i9NSGb8VYLKb0ZPW3k99UC7aNpqI3R +sUe7SuPiaN6JUchD50vt4ldgdiy/PQNskTG2BuvogMZ1D3H4sF1sgcgRGDmWs20z9ogm0TdLe0Pm +kP08wXxNPNy2fLVyTNVbDsrKJc9+sdNp8o01GjFTD4vLThytdi5+0c79vSfiqFgH1S4XJ4zmtkCy +stO+9onmbo5Dp1n0glrj0KNRT4Fzhv3iwsBocxGMGA+b0b0hcvsvq4N3NE4MERxuuzFVBPe6gK+D +pNn5edIrfMXyNu7giol/HVLQqMOLp7vT28Xwo7mxyRiHFG4cfVuud0qah6PGDSNc3xbbfTCqobTU +N6PeRK+lnxd76mlus3DysNmcodOWfdmN35rhuLi22dWTJYax9Dw3o/z+npTxuLjdPGm0Zs3DgICf +O0DsZQ/jknCsnw/bUFjEaW/p4v0+nQp/RKtx/GFbsvhYadQTezn182LPgwa/Q6QhiHCWQTeHzUfa +ANIVViJh3FffLTofF7JFp+NudMBFm9Bl93kkjNeg288D3eO37jjDoVH3MK7RXi42sq2i2cjq4kY6 +oWBcr63kl4vtZCbc+RZiD1/PMppfCTU+Xu2JJ3135LxxHeEa09Mfh/8XRrWALeR58Q2/+R0FUeNu +k3xbbnx9ivPiki5cfK3jDxpnHE+phc3OnoySM2HMXaNsGVPTjmizW5xB4c/NiOba/cUWEC+/8rz2 +IRmHd+fFM0L8zOVtuVJfjUOTwmFmiMQaDpYrgT7JFPEu8WQXDyDXKLFtMKJtt9vdOnc37ocVsu8u +7mxx6nCLjoufmp+RyqZv4pmI03lpjUiJeJEc0Ms4to3tZu6BkUejOIw2MIM+XEN9L2ztnezRN8WB +l5ejMsUEF8ahb6q1BmO7dzFFOJnbcfGll2uFeRLFNNeEFpxe0hcxY1FldBg8fPaZxEJ/XLEGppHI +kcfarW8KtBfQfBgnvREl9nJ2JBnxYX3Gkkynj88H3MPuh4ox/1zX5EEhggXszPk0anLGRnW/OIXf +1I106W9GRHajBdktb4ZJDlZEQWQ9xhtrZAseueNlXlvs2hZ/sl+suIBxxbExF1QNv5W3cEFEY5o1 +Y7EIeNyNPAJtNdiCZdSJfMIntV3ceB4+PLHcm21/hGW3ej6DYQXpTjAq1sCCk2fbjGutmEt7udhc +9n6M4gAiY4A8L5Jsa5WVePi3LmXHpjVF7MY7jfeXkCPTYRjHLPjM6Ok5jK3m1cAyD2zNPJHFha+M +p3MWWKRPcjvKs2Ue3s52sU1uQZmukOrNeEWggZZ5yx4ZEt14Ryfa8cjo883o+T/UwrIXvoYr0gC5 +MZfKQKaB+AUY1QIwqe1i28+Gk9OOLBBwsYyWNX3tOmjMv3hJqq/7nt4I0JK5w+3heqVxuR2vPF8u +Nj/bheGhfeXbJlT7U9uQ5IGp1iPNftCeY9XtU/PNMQ04zeYZBDhZNC6g3stjGPSx9sJpxssYwtiL +rk0ywkUDo741T0N+XtwYbWtpjeCQeoxO7U6d9H1jC1Anm7+wZLAI5cp74Pxja/kI76BxRW1MzqDb +xdbnYfQ6vK9GP69QC7CPiVQTId0R8m55lDDW396EXHYNiV19HnV/4A9+SJ43BfNrZagWovQM1aQY +LOOIr0uf4rLz9MeMWLc4uYVfmgXXNblpWg4kPv6867NnkMVYoTIOiWGD63idhokvU+PRsjaNHb/W +dLjYPNPxvRk1L9V63S8XJ60gW2xVXo1eqlst0N511GTN3hluF/fwffoi1juqkYgolnt2PvhD9jZv +2isnrZLreDMi4IxGvSMcbu0XXzxKsE9xhfR59v/Y8Nylr9fkJ7+xr7g4RXrEfTTAMfj2EPF8/+Kv +/nHiret7vPW/+i8MurbjnBl7pxkZcYP9G8jbu+wfr3agxh+v7fzMvtr53SdZ83EKH8vjFlFy8cqZ +i8JdqnEdwG5zCiN+bfudFpHVOiyfhZEeDcuRbj61zPNYrKPffp1j0TiF1Acu97rH0UcW8hAkh3mB +Y6ffmWMuLvYFRXdfTxzs9UAhvkUDFirMo40cqI5fXOgxwYLArgRO5Wn0kL3psdfND4JzxO6Hth3e +6RS9ZuyNR+eigy6CuubVDqLAOwjvzczPHY+9i7qd3ueJPp5gW+eM+T5u99ajmbmoz3yVb0acGNo9 +BF7ixghDsxsYNW8ttMFH9kxabhw3bwEOTjPSX/xcabU40cKtSJZGz5Eb1Q+ekC6MKTItTOS2Vguc +x6B7H7TTKdsjlbhhLpeiaTCBmtHqUna8es8RHy2b/eq4N/ciRwt3rFHNmAL9NePNe9uezrKG4zPo +kezssRU5N3os+QO/KVm+sjTVgAXX8SGw/ndjifvqnG28BXnWPBexWvAgHLTQ2YKfmYYxENh+I+FX +3EMrpMc8by5biNSpbvRMrW7sBItaZCCKkd7u1cBMehO2cYw3dCPeK9q473gZnazGFCBlxno1GNvq +nR6ebtxx2xrGPnMidUMYkVbC+t0z5D5GO7hNakHU972OpPpOg1o2hVpxyy08/WZ0UC4ayeiLYYHX +fKP3umcL3jx+ES1b2A2PSkMDzVYKYxtcmGGMRZPdglA4s7u+4Z2WG3dxX3zRtWD8zIgaxQu99KJt +88v3YbV7TXOvZNUG+fLsQzMjKjvAtUsM+8rBZ8UtAD64vJoq+x2rYjNOPsQ6RbPkA4UvjtlyHDKd +VGbgBJdVgpz8qa7F1bViaHo4hMPYWipvLeAMhGfTamHOOfjVV7bgZ0vox0EW2bMdrh5HCzXaQzfc +uDbKcsctNDbAd47zdTXAIBOkfAhjb4N9c8t4V30tY2wteFTRrhtmhDPQW4jTr6tG0cfohltk5YXk +2/GK8Saa1BNCGUZ4gPyDXX/uHqm4NCu46LLXzamIuJOVCsgdB8N0I182L2ZOvJq1vAX+GhbPZooM +C/5pxw7JjEvVxxqkPdIkx4/hpPbqcQywC+Kw5CsR/s3bQgsWb8qRU5gTYEQaHnwSDUC+2UcExXg/ +ouUZ9fHwbOGrvSbdef5zt4bT9LLRbFktwCuz5qZxrUm2RyiwWrgvvmNPrfTVkxggCYl1Gk4Rrzvu +MST54kRm9lF4Dy1yEIxkCFN+6cl0ReDZUshoIdm5zZ22SSCM4+L3jvtK8Imt2U0N8LyjRXavD9pb +8Gi23IBr1H7tvnlxrPSt4bFWNooUs4YjU9laExjZzDW01lFmZJwXYv/RQorD8rjlFNsVS/B3VUlG +9K8VLZNC1vXFp0S+1HoHYWVWJzW2mj6CY1vrZc8K33Eq3PgnD1vmnMfqFW73pK1htwynuHjozSEg +3woEagbyd6iWfQsWYyI2vMnrg+NaxnekEmn9MO3qfNHsc7Tt1sLIHGg9lkxhnBel3itjqYU5+NAF +USqpbLM/u6xEPZ/4sLY3VAn8+fcdPVlJJfjfd9iy5qXK3Jdh11A3X+IHzXBictkWRpyCsB/D2DNf +/ChXWw23K7WX11NjIEcLOF2035qTAcG2Y1ALPVE25nq2uyQaZ5ynenZeDlNPVYMWzEV8odNmUbq0 +nDrvN2abJJbbbqEo1ULyiFl0A9bEZvTiTNODQPkQPeByN6aigx+zt4Rwn4JD7NQVuNoViJo8IoS/ +da0vqJNps3uLQyLLFpqIIMTy22ytfhIvamUEB+cgur3sYmz+BteMbkwVh93XrcCOZEffnXagx2Zs +DJFF+hczPjpNCsLWFWqBzjutWy2Xxlp+e66MMOa7Ikb3urR4scQbM/GGEXtgxsIPhUFE1uzNL8Vc +02rAMYVoOM5MLG0rpHuIGU63VkSI8UUDt1YeQxkl86XwNwurjIWh55NlhEG9Mt+k2TGTjgDwP2j3 +lVf8YhlsxL+auBinntn91xj9981ns6K92GsOpYpMNrPVyj6PcLt8kXG2BoZWl1kA6ewKcLEkuje7 +J4pIhTFzQF9LTO3WRn59iBTFUuPGYuluRk8lHlcyK7vbwV34Kw5/i7XQuHdD0pdogWNvrBVURljK +MSYtbzCivpdi2JWarnwtrBYmluT28icnG7MXfi/0rWab88beFWG89BFtC1ezt7l/XGH0QrrRw9iY +WL3om2PKuSW1ULUkHvKKmZ1Oe8/ugTbGxYBCvY0s/R7KOR/mqk+roINyFItfLwnGUQ== + + + 9Y618jT7feOjrSDMc2Gkgo/VONfJZfsKfUihhaK91Ihc2F894QqgtDm0Q8s1Pil8x4o3sizV2H4O +wR+WsmVMGD2DzFfP+rgCgPJ69S22L2G+cL9NXqftK7T8j/w0mRoTLdycbpAU0Yy5SNAmGyg3B45H +OqgBr4SBa282MFrZdT2MTgNiLKyvsCtmtSvEy4yAfhCoBmO58RCekUgtMDGjzU244S5H5vBCDF89 +SaZXnF1TCBoYESmIh8j4+9Hoa7xBi1kR3N40C/a6GsAR7LaxyAilw6/hSxFE6s3eY7XQb44yl50P +2n1BFreGwJVsruECI/G2PGMnim9iDZIZqyHMGDGRWeafTOHylWsY26TKsYru10hEOjXJ4h48tyjF +s+GYxaqgace/TaZmv/XUIyTRan1rqcMwm3IJFbGBqqmsXEwsEP3DX+tUFx7o+y1UStGk5zduIekL +QC7US+DO0D7ejGsGqG17iHHxI6TzxLIaVWoklcgeYnCF67wqWkgKMIxi4GFL18WZtw4a6Q8ZEcCo +BvpV+BXiTNKMCvijO6OkSKcXxpVWoNjhN+ddq7OHcWapyAq7p2TcW47ahhAuJJXN2/J7S8NhLWhr +MjH1WhF4eRAnojZKjlQ8a/ChBXPva/196UykZM1k61O0JFfy3TFYvhTU4daQUssvF3/IPnnPPKcr +hfmb/COPKCvLAHfx7MLnHrW8lqqcMuw2ehrblIzfUmS94z9qARERNtwQ2W73oLmMgR5+D/o+l/rY +PfTFg+HdlYhtWFoXRrqosF5BC5WBKf6Fx+rejKVq4sPbrzZTcYGVZ9pamENTUWzcS1UY/UD1Tjfi +8PFlZFq01tw/XDQbqbAWjlCq0nhDV1cDEQSyj9YagTYYgGrBT5bjpa2df7G4nc5bg8vT7lfL+Arv +juWIuqgRHkysFrpmGCYqMaOmaZ878VuFK9VroQdl9wF6DNaH7CIB00qFZPY1Ma97ntolbH1J7wNG +pX4Reds2aUXl9Km9YRjpchzhNkIDOIeKHorNf2lyKYw4qg4j0iT6UNcUZfau0W7vG8+2HJTbsIQH +Er0ZEQ3FPAQ3V6WXHFWlb3Pw8lOVrsO9oeAZyxCmBR23VlZTZVBxHUZBwyMO+9FCZgtez8XfXYtc +bJ6/PHOfMtf6sRgBRz0Jn1YZcgNqj1zGtnnx9bb+HBFEewdPnQWMmCnCeF+X+kDLJrNjMTOYeteN +mR99xaaz3NtGgOV43Pxs2djpZBQv0ohzBAsdRp69jVUKx+2ao8hOXEwp7O/8knHI0VAUWWBFTAsf +zbN0wdjpWhkZOfatTh3vdfvczH7Vl/30cXHpoLZsx8qNj58xqYVnhs9cCOHn8rYI34xr572tryyJ +Z1nIFFihHNlFo4UM6jYLZ9jjYOxaTaiMg3mMSKLMjy2M49ZoWvJtSSczv0D/tQ/atzFiV8BusXVr +GYHGzUjVGfgmKgCqaNlCYb+xhTx5MWW1Gq5BrWVgrBm12fN5SC0Q3h0K0H+MS2JIPxi5qw72jSda +QKHpNaEK6UXs4/ZlGPCUqQSuHrhSfpCz5bVsr6TN2jZa6fo3ULdzce1LOrTQmNDfHyQTtuQB4KoT +4Fnr9MhVjlqzd+5qPJEtnm5GBXH0/EVi85ZyOFAfV3pKjGhZxwfWQOeOglCNJTtLXN4wV6nnzuvc +sS3PgvF1Xd+tGkBCWbtdHGhZijyUwMAzqIG1vFUZDp49DFQ8DbiqcEb3CE79PVfoW0feOivcsK17 +e4QVTmB2z86HXm9swSsqnM9wy6ULh5ta2D5me/QP2nlCun24M6o6YFkw2LI7c+fLKYH94s0jYZ+a +1XLpOh5cCQfpZMex9ojqaTwg1Tb58z+/WZrB9jS3MD56BeDVUgtj8FjjXmgncrL7h1WUoeDmomTj +Ki1tnOZdEcF3ZIk/x94d2XyxIr3XLdyFByBbOBvDhZbbsF2MGTznTb+FoW3yIGFYLjpKFcu+e0nH +Wu940TtOOg2HSZ6EEI9QFnSYOBL8UO+P/z2iY+3HcOBvcXqa3rYXYaHGkYvfwomwXLfqNoUrcJEG +KTYlfuV1afniUYvcovKwpF2bC47OQWth68e+tZAG3TkNJ3Ue5q+sKqzRY0gUN//3feXVwlovYbYw +2/bFZ0ZTtsLlelsO8sc+5EgpcFR5PsnG9Cuou+JsIMddW3vW5g5VCsnQaZSFi+JqfhRmurkm6Eps +WJYb0sgKNcvwj8FQOS/GgkHObBdmqhScqkijwclLsEbZ3Heksr3UIweHv0L9+C1vrifCO38c3rS2 +rxk2Z8/x5wrT9rqUeC0bfIGU5dbT22spEU4cF5tMfNC+Vvk8frFo3czdFb0DZsTPzf1cyOyJ4ZWK +tbXEMOwcxUgXxQqMyOyoFuYVm50ZnlTcm6V/izc5pdpepZNzUoeP2NEMrtzdT6qW704HnpMvatlL +BWG6TUJUNMy5UvIQXg7Guo4ILK52S1U0GWwLAm/iqCuMKPVi+YjWesbqjyivke/QwtiTpsZ+MR6f +foe5H5VYy9pDzLw/3drf4CjAf628rA2b1/yjcVTdWtsWdwyHsGj2yeHmCSh4ZcErvY8WHOiDfZKq +qYUTEDdorSkIDN+1WlhjkIeFnsGTq0sSeEbwKE54H/Ityg/hY8qkDdbqm7BNDxdCPO6Swra7Acwd +iO61qDLtls1Z8qHrFR7I9Z61PTOdWbxjJN6MCT5p12IXI/nJyu5sIIPCC5UW0+IaFA6xDXiLM6FL +w1nbMM7ERVhVAveR2A9bRp42NqeTXtzYFkWDaTGH3Hfn4Nl99ITvrehMozfsJoIwtkxMvvZUC+vF +Dd4Bj79nMH1hvK9U+eJn3/+eQ2eKw0uD71hf/Ijg7alNiRoAFODbIGizKa+8yo1lVVqVK0MeTLu0 +19PpYJcmZQeBv95+KOnoeizMZcptOxRx46n82eEXtq9m1HvM20CwNQi/tXZ13sNdeBKAYFn/raZN +OIuPu70mtTAuJnRlFOY6oTM8vkgL1zGJp4S9ORJwPmDGyimOgTFu7FS4daRoLePMasZRwAftrWeN +0muzM8YXZULQCE61VwnFduucD1AAfvFWnLFnLtc8aYUCOMMo68HTMlyp27Jmkv31hZGSBVmeMp4v +VSLfXrptLXRwA5OTpKe3WTemM2lyCJ7j99JeuZFZ9cqG8VO9bo+W5aiQqtvPDbmBEuHwMbiGy2uj +IGbcF9SF16Iiz/ZZ3Nv3swXSGI+rrSfnbkPDb32tyNLd7biHK665XHRmT5qZcERm+XU7+5Ezk6Hh +OkVta5HdgR3uE4BlNtAJjtKT3NvH4oehauBS6Oe9ir88GwX2Ql5GKeR2KGPd0+hduK6y+owxYFql +ozr3jLi5sbVwTwYRIiTbb2wyrJb7HUP6C9+vf7p6Ci4eV9CatbDCLPJK+1AZZrFpVL+YjYyRSuj1 +SycOlXD3Wmx51AQaSBFAE1rSkZM0xdl0tCqM+27cX26BXT0p4UdfaSwT8/pvA7pnFuzxqVmznZHz +msozEqQYOr+OC1oiY7/mpM3datkrdDZakKXCNiqcAZmhym5BLre5XG49K+5t6Giso2ZxtMDMrJl1 +7lyQ+3YL64x5ILzG7nfeL1JvTybPu0v6uodGx1hF3qC++zURstBR6TkGyFBQimXVWJNbVTes6Ffq +TffSBHUzqoVyNY3HzMQCXYOUc4Vl607ruF97X0umWTgaelHuYI+gOJZfnuCTMbyb67u3LafiwERh +eYYLv4m6WhiVLh7fB6iFW9gI/RjWQud3yW19X6moejBAaoGLzh6yBYit736pW9l+mUVseY8sBd+d +9Y7kIPSCIYNaIkzFr6/8xcJO7ltQNo/Qzdj5dJ7MRy2vcFvWWehdSUQt+JF/XxnKsLhiSySowGUW +nrVUhJmfMdKFjO003GPj8fdDnBfu9YN2xs5ZaADTm1/IjNOVCM0yMFQuu3eNnBE8jEcYehdzG5bu +kln2RGce0CczzipSoCih+j2anm51hYUyElnrKzaQCeJnYAURP9qnQtGbsn3ZPSeO4STGzltW1C5D +jC3npBx3nEVsySx6ZijE2HuOL1l5TvbuJHnSp3DsHhWc1AIjeixona+ZR1NNZULsFhpJw628dV/x +o00uoL6yZLVwZ8PYk65sZWtBKWj95ATjJGqxmZH5lIcCA9runPJyG4TmmBKxwwk9I8S+reEqZPPe +bqE2mrdfIzTXxN/Yd3Hxpe+3YCHp/DUGgFiRn6zMU8h+YCIDrHIhWnYp0/YtoqA74kNwBfwCC9bG +O19huHaxIq5YzMaMXZ/xzVZ5wAfkeukkEpO1NUnb/lmkQ1ri2QhQ1lsONZflmrc3rOzPqH/rwyEx +efMycpzX2IdG76yllZXbwDzdlvIV0QeHEXS3E5trYeQpjTlEbMP+oUlSLCj3sD71ZqKn2Ol1ywJA +ZMOPCLXgWZ3R0uDqCPn5LXFlnlzRtpsd7LGYWjg+nVK2lr/GjiWphSj36nvYwSGZ1xGYbVkb4WIP +t/hYe15+nGp5RIjqXCRy7JmJnnTFn7b9K+TxnpUtVRdzbjIXBabpFotY+T7omG86CzSXCk6KrDS3 +8sNwZVJjhbc8RpMgsp86ybPjqaH8+gGeyTxqgwrBKBFzFyLEsanyNOwXB5Cq7dT4O4yqyrwrz2ju +7Ie0uTIJTTRFDkeOa7xOBkt7FeTOp1sRW+ZcVh0B+cOyWDzjYwsd08xf3iK8cx1xYHFSA+D+GodC +lflgPWHw1zg5hLPdYI/9kJGr3erLe5yiDcXGVKUMsuNahDrVla/ZMrYWPIRvk3S2ew3lzE3ig2rV +VrYdWZcnkwzfPDWuESgQLS+nnJ10N3bnQFGMWrYRxFWhnZ5fHQ831qnMY2fElYrKmA3uzboORjNL +bHvaPSm+Rzlk9mZn2AEXhDX22F8ROJGRpN1jJBRQQZYI3ugP2pGCcyLKisbJB8Z+oqZQ33iG7fgx +PZ9G5qeh0JSuDL3KC3sJ0qv7sYrVYFVeeW5EveIg06/S81+swDCTDLd1AGH2waIZPHwvUzkmqyot +lRmj1o1li7qZqvFRdVbpUUJMokiPYRnaT9Tw06CFoW1Njb3U1yNM6WzhqhxmyoTlQVH8Avx8+aet +WsgT32XRl1WawP2qacCqU2LKWYOkKE8Ihx5ayFuGfy4hSmLCN39tseaymrWTn8S2ssgLjqkRPvJB +ey1sBL6zPOWUrpFOIoy19sJbWMHgU/vhlX44r1wQOIwJY7pujvQNDBiawVe9KAtSHxxRHnf71QPS +Wy0aThJgs9/8Vpg8OHcFJ9ZYA8A4xuBnLM/4FmxfY1786jH89BWvgWpsAQIvauxl0YJNS/yImCPG +2ILGfuAptRn1MueK3rOWG1tmxaVcRXHVOOQJY0esat2jNLIhfSsTqSAN5OTzUc1WeZRc90oyuQjC +rYvPsdRl/LAYCmQ0ke5rI5TTvSlBX1QUQe0WRV3jSh4A1tiPqgUmDqhx3AsjCrPUhQ== + + + 2i4QrO4uj2R88c2LS7ia0y1gskXhlDDyVbSD+L11/FGFZqVbIc11kY13OL/jSjuARwtT8WhVp6yG +uGmDwYD2NJXmpe65yc1eVerj1oYzrdOKGuPzqzOI3D1V7RFSFzFwaIHhq4OfiwflfA0g+uZQZWWR +a+gUsuw0miH6kwVpLhxAWGoGxEIWJYC5722krRzMlgnibpxGAJq68WJnMuUEuecah5H683xJ+6KK +iRu3MTlpQ+hy3Vbb3nDnGEFcrWfIuDnKsJdwY2ZBnUWaeAqQwRUBDokt4QhjWCrpBEtvQoisbrHw +ZuequJKmcONkfRast7yF2aUC6x5smuFSxd0aH7JXJjXOFhcoOyokzbpSnFiNPd4zqg5GVWbVIdI6 +3PLK1Dlgj/WOZdjxEgZxd4GBeZqhwb5cXEn33T2700PNI1ERHV2Vzt7uBZDYggfMogWlwXRBizxD +lh6XwoW0yns2qrrlQTc7j221z/8kjdNvmG3MUg4uL4Tt7X7Q7udsc0tY5P6jKlJ/rBJQcPW3PaTH +Czsl+guK8k/lmVXxoara03kP33R7Oc46pvuTTV1/yN5EyiAQ3/3MCrrm7VkRdhnXaa+XG1ZkMB3g +y028ws/M2BkPWVb8SF9k/1i+LQ+ZEYFZ6L9+eYr1gGkLzy8WbvFD9sFjIN1JUuzGWHXakpwaXt1h +bdpfGv5Qhrl76xL3fP6gfWQFfKzssgPT/IwTqK84pMqdRs0tZq86mUQAoJ8m8fBMcXpv9/Btuz3u +7BA9o9tbRAb3LuZZUKQyC3pZSmqFHG6AYpyM8XyDp6m3kuaMIAE/vYd1ez2iGOPObbX5Q/bE27tX +at1ceX7LU8bWFZSJ81t5EtaxqnbKti68j7Jc73fwbUseuEJrxionbvY8GIM8FZxzXzRu6WbXKeG2 +8DC/g0JrJvKlNCzF4k7oSlhZEoZXbvz2k1vTgHS+kjE+roY/aG+Kb3YOSyhlU9iy+x8+ftKOfiI1 +5VQb4R3+Qfs6tSb1mtoWTqcEFE3O0oMetpY7W2BlvrRjvjxkfL8HvbdrCj7sscr/IfutbByNHWDm +yZwg7l76+Ekz0QH/GCkX2z9BiXtCBq8l7mH388jE7RxL3L+a3kvcp0gG+Ufr3D/6gEIOjk2vOveJ +BR4yqivY/YyEchYXXOfmtmkZhRPtmPI7G2AxniJWz6u6xPRbNFGYh2h2XOk+ZbXQOy9WqfGqMHBP +bsXb6mV3VshxxEOI5cTYLu6Rx+7dWLcKXL7uPcTC7ksn0YwH8wJOd99egvxtdH+er3aFB03F8Zjx +vjlpsJzVnnJjy2Fq4f4rymQqLfLgd1VR5sIi6i9GXrkRDdw7orMuTnMFz8SuwbkAxeytshxml6bf +qwQSa56sudOi2ZG6B0a1QIfbNtHaMo/C6/7OV2Nf5aEOe1KGakaz1xU+e207KjeqAQKSx8VM3LBK +JZr3tXAdt5VKtPDsS3nPUCrRM3Uzzl2lEs01Ot5HiZ0WoCbYWUozWcAHJ6s8uI67b55dDhZxHJUJ +LbdiA03hdTlyx3zFQXas41cNpn6UfFrJ2c/6srz41jniKti0GVEf+rsWvzp0ZNJfPyRNTGiFihhe +dppJGK9VPsML4ubXiy01ow4YEXh1GLcib4dd99AVbFBVcf0w9q107m5XVfCuoJbDuPw+W558O3Gb +3OPqYktMxw1u4xH5Mh6F0A47lat35SlcWZC8irESLKRVuHbKd78uZmpdrw2rfx+VKsOU1lmnr3tq +GFV4XTXOaVydD05hu/h5ae2qL83aWUfcdt6TFGzVXHOk7vmK40MWIys4iVuccdhwB35W0l8vbXDM +Zi8Jf9rSUbdkt7No1Cqmatm3r5vBfM8Ofzd+15ldiuIY28WNIXa2hc29nsaXWlTLvtWiGixcsJeX +mgrkOWtRWfQhq1XzYoshQ+GdVYtqM261qDbrtUfYlZyQO14pvT0d4G7EHcw4U3m9+IIL7VIqD4uT +hdfwzD4/BFVfEZX4FWecLPGj0rFDm4W0V/1uXq4+v1xsuDJT1fPLOozu0v7OvQnsllQe5QDWI4+h +eqe2+QrumMbva0Na2nmxhVrdjZ2G7AibMR+1z5e9ayFmgZWNQaOqqDW0aT0ralVWR9svtpIx9Grc +/R5vRg+mQwu7XeOhvhbEejX6Rmrdg+wKZy3izYvOYYzqyVoijrqlmWfC7u3iC0EXFvB398N01Kfa +rKxOFbgYjdx4Ju2MjupUhnBdpbxcbEkVOcBUcMpyRrW5GdWHF9Ye28WWfjlRXcvNig6s/n7t06ux +F+F6GXdk7AwjMg1Zwak5aQSWNUZkzlstRKKggRR1McgRmOQ1BDLLPGAi9rKJOzXBikLI96uIBPQb +7RCBQC9G02muex58TWIFjK6+hWyjwqzZWSrPjJ7KaVQVBNmMtmAbm+rR3vfgjKmc/HTOWHGpyU/Y +jd/p3EK2rf1iP1dCmQiedWzGEqz4mj9gN7dVYmjlFY7lccVpFe4h07jR9Fa3KqCQfiuq9+I2pA/d +gon/OIx6yfflA3C/uAXsFfWYkQN/M94vwwR2K8SUVXsRhLUVxKHXw3J2RE2htG+m2uDW7bwYsTpj +Vcx0LuVG9Z8toZT7kKKeh4X+ULtxbjU8H9h4M6Z1Rtsaz59HW+xDI/QzIk/nH6hOgEHHUKSiAWY3 +64oxxZojaqHnR9U2kzIAHBdTHJtqRqr9rWjbZjyKtp32VUMISVa2om2H0SMV1QLtK3GawYyRG2+r +w2YVpuaVNyNayEwntF+cmFFjK9p2GFfRtsMsACupKs9cBU0Si7V70bathGVSmVJHD8/bXUXbDuNW +tG3Zt6JtFmPTKoxDz0W8LWzftEu9OFUklOHc9rk5uvYPvJhTSFECu+3iIqzQiHKFHGzlV7ZdvIXV ++6VDRz1bCoge9ZDftuUelfiaL6KJ/O46Nd6M2FKohWVH+pxqmy8eIDXE0VZ9kX7ImLfK3vQ/VhXx +9nx+8Of4mi+MFe7YHMetaGDokDvrjNoSOlzsclX2nurvHOk35HlhKG8KTA3Gyvmdm746lcklxfGj +nBOtRi8oEwISzF0xvH6r91Vi36JqZ5aBYDqHMe5Vx3c3Oj+uF0771Km11+4umJcZauBlq1n6xo3q +rtpYLXC7uDTOXKO9mfxr/qa/DzfgmGKzD6PFA//h/dqOZbxV1IJf7oo1DYydHebPu34NZ8hXhI6H +ET64p3N4+lA7syCMew/Gq40LYFNG4IzV9tCsRuyr29NY99p7mz0xJDUqq6eYEFVu/SYcTaNEpcRX +tl3sVDKr5LnP4TQ+w9YKNWn9S3vhHtTA6DjNtOmM84N+ikZJK6I794ttjxqVk6tK4xxGL4GzlrCy +FxbjSsx9NWpMJvitOK+0gsxbWKSFwYVoW4kpCTFLUJU1PyxjjuCPNcPIrrpLSlhuBd5I9l1a7MKo +DxXJ4raLPQIypr4cOOppLPvL3OyVqILJ82SVcO1ME6k2Gte7RO257eKmmlRVGcc2o5XqU+XvZTdU +gHD2xQ2O+VxQzsBrUvmUTONyhXbvs+1iyw2CSzsiizeTQyTqRFkR4GX1+CLDqvkHV5VnROB1ZMX7 +Jj/q5TEDva9a1RdzVvemUMbD+AzQrfwf7TWCHc9mceCBiSDyU9GoaQfg/X5xY75nK0iMk/bNiHCn +NfPBvhAHqwF/+0Rt7ras7ELIwkejpNj3uOfFShrUu07BNmPwGBqLy6zwz91Ycaa6RJdG3QJStp8X +835tzzj4ENddd6M6Er7G/eLOpCfmqUNm0c2Il6YWaC9RqQZLgAgKtVeBzKJVFDmNGpDYBewX3zzv +6zUixF+N9zxOF2DvEc2IWb3fMEosOnPHGtQjp21tDEW0kpYFE7NcJ75Ju3SCFEd1tsc7jqAa198+ +061sXDHTjMnqY9VjCyfnOp0rTaSkgVtoTaGlwauKeD9fMxX4Sbmofj/g++4HoV4m7qvvQxEmM5Dh +88e7nStW27S2zpkhizIMvyJs2jb3FE+zX1pjFzpqHISEMQ1//fZD173BpXRBmG+nMe4DSQ5HCfY0 +jICzaJSfDbkxXi4O7tyMq4Y0nJBu1El9T1zGmlZ33QMO3qysKvKGeBXqji1rvdIGuCL5iNUJLfId +s2+zmIj3F/FdsQwmKTFk70CMf3xiv5STIfzSfW41kEfkAIdNHl0MuHWpexViwrnlDXKouGLv76E8 +W5BL5pfApcbND9+WQAgkNVAfY9uSC19bhgKcs5kXZDlTR6Qh81K0I70ZPUxXTuVlv0CUedFn/2qs +pB+wOHeMX+item+5Iu6ecK2yzuw9qyqcb6/h+xYKA5jJHA5Nx+jm3oiT05EViW/O4sG1DfOTmfcW +dT9h1Esad3m/GPnx3ZgXcF8KjWU7XASJbIOYdbUnU/GNGtzPp0/x7R+1VuX4fxU4kW5VBzmiJ5bd +J/3yFiRRfhIj8WmbK3bij4VNWM2Be2AouJ78oB2ufSdMqyoJlIxthbLB70ajE7+zgWVGyKuXhYha +Gv6hMtL5uTgv23c+UO3vl6LId0fyw9M4IvhJDSx7xzmltQpRsbjkzhZQEbwjnZ1amPjOho7LLIq7 +sAX6yg+jJyZQC8vOGh9Jnlw7EMbhhN1tOG1t0blS+HvId8HFPBiwKO7Bi7ks2kZPj/X+t9dRVSI+ +UyMG8KfHTcb8kT0lXQ8j8dGcGJJPo14xJrz9YnmZ+yrgnQuxGJt4p9JKW02H4k5TQx3hxbCo/ps3 +zD1XLgQWafzOFsY13i/Gse7ZLDJg2CosqYxzViyQLQCADVlVCIyTrFfv1R/uuhnRgvG7rbxc/Cg3 +Fphw6i2LrxLxtzB6sR7CKMhiYsZVUyDy/MGGPx7U3+3SEcvc+CE4QLIYeF+J941EwVm+bxJUjmLi +BmrQOXjGiFimUc8Oque8GCUb9mYNsAilabtPc+vq7WKtIfpGohQmu+rIS6ZxiFx3fe39DQPpnct2 +JLrLiUe/NKKFi0Xitos3WUAc/GkE5qAvfdl9zxLN4qRq+/y3MT+iaIxGMjzym17lytwHfeyYDrBV +Xql3UQe3zRrJg0ku+kpMkofU/Sj5fYw9nh8bSjX8kGkzWsWGcHfSGC1YfYY23i/u2jR+atzKqp92 ++NTMGDCWpX4ojS1gSWqaWVba/4uQbe8r+/bFKof2CUATDuPmuN7sxU8Avjq/ViKT76Z2JWvLd0ij +JU2PdFz7xctYV6r53eg/8NbCOhy0JO+RNMs++DaYsx9wII1owZDeXl8uLtEjZzfsxrocWoc9jVX9 +YFz4Ch0OwG9FmtgOIlgtzMioYfJw6R4QPNmrTgwPo2PdamHZM5IBHz/HFBJWwwFjBEa0YHm5c365 +2Oa0gYtRym2zmbdBXrnNvqLUi9Kr2FoEZS8My4sBGTb8fWf+s+NSkH2WYQJBygZkzo7lwpZwpdxE +fK3D6CsoEWeIteHglr5Vmurau+/Gj2VcHia5mD+15c22vM7Bxbxc+qnt/vSWdvOH3A== + + + XnHcybxFX+EN5AjwjExfw9eK2QRdJR8simJu/WrHZr2fL8DODiPa93hX7v4c6bwUGeBCvu6WXoyH +dGx2jOMwtnSVcyqx+JvIcEXjd27BnjnqZd6xRAOp1PMzOIzuhpEHdtl5vGRJJfXduk/s9bfmSj/k +qSKL+nxBCvgUt8QBu3E7ODvsBIsaOrEwAqJy+0ejTns7bmu7WNUxPb3SeLHVlwNn2teEvr3bHCvk +uE9+iDBqO97xLW8Xm8ttcJ3Ao5JlxFpFERu0bz0wY8nvT7aFjvVI7WmL/DWUzJc/+za/wShV52nv +YevXHqcmO6v+2I9dnOPpCvJUg9d4m4ybjg62i7vOOcybLh7q+Xr7sn2n861GeqLtUjHcn9pa5KLH +3y/7IsntmGrS+cqSYiYDN7cSbkQLg0X19ost7Qw/PYUQKmtMPw6nfAmf8aUzDakJcb52Yxyh2ocY +JzjnxWXS5+0xpDDCK9wiEOobW8hxFmZtJUbppJYwxOCJt8eJiHPY1ONIJr1dmuNW4ith3GeOyNj4 +cJv8UJZzbmidjk22+TBvLRvI4alwL41yV3K+Oy6+4mDqbHYZ9xjjZa8KTbSlGD5exa7aI2q7unZk +XXVh94tVZm/b6HXBQueu0IYhxvPaQlpHDe0rsdmMtG5jM6oFeKvOiznGjmaBUZ27494jTfm2ke5e +OetlEWqrkggcOBehfcVQbRffTKW6bfvDxQT3wLfN69QjWuODH6OnOHE7o08suOqihHv29jDCG3p6 +M7bPOWqp4oZKg5owkPUweg0Y6cGy88jC7qvwGJHZTw/j5hba7BELgFbnzKdtkh+BTX16aX3RJD10 +x8xI8RdGEBI0fudLdcE5L+4sKeeZ31J5M44DAlh2zwiHZqEay1/X13oSzj1p4vN3sCOtsRO7GX5/ +Fsf0QYAQtW1YWPhSU0Jbe6ngplC9NvqpxWn6TCuh4FCiT+QF0ufK8n+VJR7twx8TNo+GOY1I7KUG +aO9Kb2IicLOEAdPqd8B1y6hOnaqDoIuHSPGVafkwpu2caNmbDp59hruUTEh5Fe/OLFnXOrL1KTbN +t4trZbYmHj9ZcsSel02Ks3Kh8dJlqysp6G7c4zt3u6dPOeZK59oFqPBWYVQn9M48Cbp42pZdqZpK +ejH2QMT0gdG+ZRCVwrl3u3IST0Kx3KgZsCEN9XZxUVa6rnrPmxEZyNQC7VunrWZLBAKG8R4RkFci +hlqTOFl+a2tytiLhVdZ522FMcx/SF1kPVgCwOf8O3Civ7I1FFexgfF0JbBfbQg/lY3Mg+ofRgqlW +C5u9r4hqCwPzTeJA2gYsCeNbo/F1It4vtt11QoizB6ydRmTx1JikfZWV8G1NR3wkqwmvteZYp1q4 +t1iq7RcnSqM1W2p/M/oEpuXIsnNbahl/Y7c71lymtZMFbk3l6/HUvA12zZxalY2+Z/FbRs9Er4eg +vSnBUN/DqRhg3/dYqn1QKwZmu9gAfLy39bVtRuyhtRmgoK4TyvVzFp2IvF0daTGWUfLQer1fLr6Z +EOx5P44BncYe+V3WhuBm9JZS4E6WwBuJLK3NvxEdAduaPGMlvV3aFSaW1iZnGXPkK1UDy54y51mc +mgxbWT673N9qrpedoap2B/Fh20lqUcrLGjpCo34tFx278mLbIjHOjAlxNmPat9Kb/Yo0ADBG1olx +6XzCd9Dh573/H/berDmu40oXfVeE/gNeFGFHNOich9aTBNm+vk0P17K7feLECQYEghKOMLBB0LL6 +199cY+auDZJVtSkBBe3b58rS2omsHFeu+RtteKgiOfYrq7LkqdYwEh0bZIHjsHQ7CQtFWTeEWWMG +SQHxi+28E2IYDs5I1yQDcBJg2DC410XXGomjUtLpTm3xcKusnCa29iRLRkKl6fVhe9/Q1ECkm/w5 +p4YPREfysnbQ6SqlGvKjIlG8iRMiVgjvQ1C6TqG71V0XnyHazqWBqD0w/tLQGEvAyxmzvLZY4cPU +gahPAptjx8ZqUoCwxejnRFz6blhhuiGJibvlMCKjZVDAgMIRmUzsfCikOGucs8ZaFE1j5CMNURk2 +DZX3EyWzyyGZLi8PmE4D67LTWXQbyNjYiXwLYSRSHlaJ7egOKV8DvfTK7Eat/oXUUZqFqdUORDU1 +2qBmTWns1WjUfs5RBGgnQtxLHGB/uNAZRCZxES0sABL4fUdZWdNIuNAZPOUd1IgTcXNQmEfIsOHY +biaqWZLBOMfGSa9bV3PB/EiB6EJUoyIa2DYbI7eiuKsQN4mBAkS0B6GXjmYS5EBBlSgpIsOFtigj +INjBQmzIG4ClCaV6aq1SIzJxctaEiJEpapvs9Jp0CPJrKruDvbJIGeMu5kPqTvJ12lStzpCWkZ2d +EbG48qaJGkRLrp8NMUEU9wXSooAyjUREa9UeOl0qLUECLMNTOc1Q6zZMIW4aFsfGvVin63GzIxGB +x7WHTlcgtN6t7wWIR2K2YyJxpws8A3SbtCysRP9WRaScKkxGhNNRs7EKMB61DuOEmKvKVAM9abA0 +VFEwoozmXIXRS8EQJuospD5pbzyI+VFhGzGnTpTR2BMDAdGIXouxMeLTCayf1Zg8ExQtx5rhVnVE +VW2MotZGeZEJEU+O9pAUBD4L3JQyuKGe/4Q4zmKkS8h0RDxhVokVp0h5gBB1DFJocGgcqe5YoVrz +Wa62nGoerXqf2CtVuJA7EC1VBproo0EDkabKK8Tvxl5mJYgTTWCoOtbAQGQFUT1zQgdpNkupF8HW +MZq5CXG6VuJ00e/GPUCqFAU+FkrMOmbXXGSlLUkZnE4MhIams+h0wbSDpJRgJYGFUTwwutqPRO2B +q46MjWFgkgJTNh2MSIszByOTB6+nj538PpobaIPX097T9D7avUOaDchLzaBhSl5q3Y9zd1LEa2Oh +HO3GZmO2l4zrPxLHzer0YWf9kMmlZ0CtHRsHpqt7w+kKWqp3cg6FuHlohT6ccJWQhrvgOyueXByA +XOeKwUNjNYAO99FH5a6Ty9tjFYab7p14bgee4DHwrc4YiHcKKDM01vDvgS9NiAMTm9CF43kMpRy5 +zZQ4YaQTunBd7yRdYeDPMNr7mHkPdxgbG/EeY3lX8lv2UB0hcg9G63xOGkvhWESYoGCoOoBJYiFG +6sFVRR3oQFwOTNSReaNhC4YrivvBRO4B1AypRDQ0dl4TTfmtnBDxkGgPna6FnssAfSZySw+bEjux +rkOv9i+F/aHkNcOoOwJc5MVhGDo3prt7owgFVqAwIPSKwrzgYlWyCXijWNxM1M10LAgMjTvRKdrc +QJxIixO6iJYe3Z9SQYpkUB+GssldXPVBC0v2pqohDCLwhDjIyxN6GuuRJxaiWQoffmkisfuOA9/F ++36HB0VgIE60hoHeVQyIK1IVWZQRKH0e1OTTNRfvJQp3bOwlxgALQJDB3wcqhNKJOgsO8xobd1XL +EiwvEfn6gdZbtW4BRI9Ruh0mNBhpzNwQdFa2UU2Irp9GJQ+6ZWdZgxYK9dtJL5yqrHB96JiOjVXm +GTThgThRmzt90LEhjpXKcGWjyBFOk3aF2MdgxSKmjTXIEbIyTJZZWP2trja7SjkiRHaUIomV6TP/ +GtrCmY1xbi4T9VobCtIdGvd7DUNIM9IwhYFuyU054RVgxrRkFgGeyRozE5XBmiomU21cqIw0Ejm2 +BGjOhk7ri0h8cNJUFtaS9LBJrHonBzI8Q0VipjNhngzWsAkxhuEkdbKY06Bmf8kbt8ypXjq9khAZ +y5szNI6avdLtWwPRULle7mGkS36Pi4RbNzFVToiDXXNCFyMoBGCnMppR+bfoNZraViHW2miCjzQG +6S2KKZd5RSeClU6f+4HsNC/HOU2g6XZn5yS0fGqkhlyRLNYabdyz3qDmixKb/JgGIvdgBRF6aNxD +qmF/qPT2SJz4BQZ6JTAH7lbLu4m7wY360eCbcFmFuqGxYqhCIQ557jtx4iaa0C1L3cBDqPBgZgQc ++i0XB5KyNkZcG5siQpaWGcpzItpQtQehJyoexN2ShASVgzg9ziWpqCjOpxO9FCR45UTG/OMxfSAD +anO1G0Sera5jp0euLu16GaaiuKg9p0CI3EOAou1lo7EXeS53EOGByNiHeqaF3qOweqIBJP6zEw7W +gfeMiX0vqejG0BjkWiq6kZOWNR2IE/Gx0yGxtSgcB+dWDD7ZHrc/deBCnD9lS42Ng1QqGvzCA3Hi +RJ7S2ePcszMG37RTW8DUke2ilgzsXm/gRVXq0Yp/fCBO/I4DvXveh267tuac1secqHY9/2hsjMsr +ReDZkT0QWX3iHjqd7XfHYzIIRJ1wxTEHmpKgEyFReRwnB4+NPaXAF8It6LlOSkRgYT2Tna6sZCRK +1Sj4LcoEFaKOIQVF2OqN+4AL+6Zdh30LY+0r4L9Rig5rYwtIYxsq7oSI+Z7ag9BTP9V9DD14pj8h +00gbFwZYam0cpKzXEMAzECfRPgO9hwYBboyC6nAMURusFDiexBtBuk+Sd0GCk2wVYXwIY+rJcxLz +dCLPjdApOkpz6riw7hBEBUvGWRQabTVPuzzDBFXLyexQFsZLgSA0vF9t0jsoIRZEEKuj6VVD5GTl +ce5QoocS5obGWJ3DsIVBKksMRE+Vi9jIOdKl9nXUBJ3RfdCrATuy/WkPnLgzsMZotEI71LHxUuGD +xmpw5XgKKmoXo/COUEXakSZU1RQ/IaJUoIsg9EJeWepWxPr+fPd5TV85KLBFZa/HxppnMEZTuKF2 +UOwS8ECHNBspHNYr40oEGFaxkbAwRPw7kSGEKhiDWumkESmTfbTlT4jDEEa6FFWZdCvGvNhtQkzU +SYiXYGgMKTtJtl2s4EqEohBDMb1O73w8okRZpzIpVLlkFc2NieVwHCiJcWjcLwrWh3JlShzcWa+m +xllKR7m6j7iZOJPvSZzJ9yTO5PsTZ/I9iTObtNppM7v2ZFBRqzP0xBmo9uJFwREUKqi1RpC4wLm6 +LhMgKNEzXa8ESINOCk8Yrc7B3F6I3EOW52lsXCWBcZDsB6IZQ887nWBpHA9YDAGZguqGncGYY62q +O1JdHqAJ2TkF0ZicouqrRtlXrdfeidNxDfRhElYCM8fpWomL3Fgbq1UKhsY9MG1Yckcmhdn+aILF +uJkQkygq0lDWZTy1J3LEfZSqSnIDrzbow3X1GKUkQMR8sQHI0KeRNajtnYPTpo254tnAXCbEgRNN +6cy2Jt0KgwOiFbihgRt6RuqYsM6eedd57ECb8ONOh7eCA9m7AwHYPLlGfKH4KqXx3xcpktmbhl7n +CwBkuNBQJxYyqPIOd3ofQFAPMxST4/o44AOhgwNT6KK2H+v6SZEOXyhhFt9Vqd/vweZpxd4MXPdE +JtFjRtV7UAgxpYxO9QkR8wZ0GYTecQwBLjMKQoMW9DEKPsZEvSspS4i2NvYQN7kB7T4QJ+EJnT4w +fw8WAom/kmfCK6rF9E3xigA8Nu4XqD9V81t1tlWpkQjUF3+6uf7L7cX13cX1t8fHTA== + + + xxIk45dPP/nTa/xmDX38+j9//7uLy9bVp5/8Rv/96N/bf/3jj8//dPPyHP/9q4uzu4ub69PbHz/w +6fOjX/3r6vK6fTxuA7y9+Obt3fmbXx/9W2v4xe3t6Wabs+8uLl/enl9jC3f0mz9c3/WP8I+7H1+f +48dfmc9+ffSbv19fnDXq163n62+nLf95evmWm/7r/S2hAgs2hIHQ2B75hH7cfkI/PtyErNlhSj9c +vLz7bvtpcfODmNp35xfffne3/dyk/UNN7os/vPji8vV3py/s1lO8eNmafmhe0Oih5nTzzf89P7v7 +8ubt9cs2xi9vPsAShqm9Qg7Y2t692X4LJ3/0b9tN7LEx2Lu3t9+8vTy/Pjvfeq3oj7ddJP2pB5ve +1hO7PX/z9nKHKyztH+wtacLN1pP75vTN+e9uz//7bdvrHV6WjT97qKm6red5/fbqz2d3p/883+Ei +j3/zUDO8vvn67uLu7AOv4zDRN9j8bxeXu8x08kdbsqx3zce+bz73PxQjxz3/28h6PjDw9+/K42ct +F9cfOMGTJxQaP9Q5/Prm7e3Z+e9vT19/d3G2w/x2md7Dze5D4xymdPP6/Pb07uZ2+4n1v3jgm3Vy +c/X65s3F3XYX6ycaBQpHHx7Ab746f3X0+aqHPt4JrXroqof+DHpoWPXQX7Ae+ur2tEngl3+6uXiz +aqIHqIlub0U6bEV0ey61KqKrIvr4OMuqiK6K6KqI3jeAw1BEj92TU0V3mtKBKKPh6Sqju0ztAJXR +L8//eX759XenL29++Ilco4eontFjjIr6k3uKv7l8+4G39YA1s+31lTd3L786/+fFKQxrFzl+/KsH +Fjd+f/r2zZuL0+svaUcPT5Tffrde7vC2v3zAx32HGe3wtL98wLd9J3ZxKDzw5tWrN+d3X/5MnPAh +ecSfcaYHyR2e5Mm7BIkPolfPbi5vbv/9h+9IW9z2zfrxcgcLMDd/qKm+eX1+9ue3H7gyByxrbB+M +9Obt7avTs/Ovz0532r7JXz2YAmS2n2bb8LeXp7e//dfrm+vz6x22cv6XDzbdnWd7cnP95u50n9n2 +vzxQNek4GrP98TgQ84w1u0zqMAw0x26nSf3P9pP6nweXcP5yc3F995wNLw9mdT3/mi/1c37gD1Lk +2s/ucSgull0FkkORKZ+6oLU6jx4/59j+cfn+AzaScXOg7UOduh1m9AGhcTIjewiy7fd+hxn5g5jR +Do/U9wf1Rh3K6/u0AxwuL+7+cnrxIS3wgB/h09uLu++uzu922Lv1MT5MtX4P6/ge1/Qht/eP57ff +nsO6HqSstTOvedK785OOYg3k+mimws+emqFwl8igwzATWrvGcf3bYcZxndzcXH55e37+P9t7E9e8 +oqeXV7SD2fblDjLBAx4C+2z7Ygi3py8v3u6w49L+YVXipxlmuP2MDk0TfnlxebpD0MYBa8F/vLl9 +/d3N5c23Px6knrRDmtDKDB+cGT49Fvh0E2BXFngoLHDHnI4D4IHHTzDG+umxvu3P3RpY/XNvzpMv +PvHN9lLSoXC9XRj5ofCIHWTZA5OPzA5y+mEXCNk+CH4tEPL+XI21QMhH2rAPxC6NO7VjQsbDZmJ8 +s/3EDuZV2+GhPphAp6f4VG9/9A7tqf5iex/uyXen19fnl1+fX56f7WTNmP/lQ832r9s74fee7fwv +H/g9++rizevL07Pzq/Pruz+evj7IR+3qtHW3vQP0kLQ1cyT/dzT7Vzv5162nj/+6g/Ql7R+Mv+5Y +DfQQnvYdpJVDeQW336UDNWqdQFL6H4XVHB6X/GZ7dfRg7tEOrOFQ7tH2u3Ro0uQO6eM/X/2hx3ZL +X+0Wp/bq4vJypyiuyweUZT4gdIx2P0Cm28HeR80f/8F+dXtztcN2YeuHmtX2jOjuZgdx+uYBZ7T9 +AXz5ofyOiXv07QNqraeXP5z+uP3E2iNwd3q726tBf/BQE9z+MRimqWP4E05l28lu/NlDTfny4vr8 +dPsEo7PTy7M/3rzcYZ79Lx5qitc319u/cqdnZ2+v3n44rGaylcPfPNQkb8/RtrL9PF++vLi7+Ocu +s9S/eFDt6PT64ur0YUs7H37Fx7MnGI9U1nikR69y7nDuDtR0s8YjPV4L99nTi0fahZEfCo94yvFI +vxjo3B3qVa4RSWtE0s+yYdtLiIcVkXT29CKSdnmqDyYi6Sk+1mtE0hqRtEYkrRFJP4m4/P4wpF9C +RNLZ04tI2kVaOZRXcI1IeuRc8uzpRSTtwhoO5R6tEUkrItoTqNy5C7fZ/Wo+5M4edsXOXeJS1315 +IjVnDmdbftJRPOQInlQJ1S/+8OIrrLvzYkez65bC5CE+eDtYAQ+sHNbTLpe/FpBaGeFHYIRpZYQ8 +v+1XYmWEKyNcGeFTYYS/vW2UVSBcBcID54PncI5XNriywSVscBUHV3FwZYMrG/zFssHR//VixwiO +J8wNt1+JX6IPdL1bu9+tvN4tnt/2K7HerfVuveNu/eXiX+eXf7k8/fHFjvnBjzlOKpqjuH2AKO3p +X3eJER3+5KHmuEK07bxkt+dXNx8qf7BWP9qY10NXP9phZmtZHTUVPHRZHXtkP3fmyMb2T3PU/v/P +27+3//28fTh6sqH7F9cvz19dXF/s4Fa6PX99fnr31S4nd/iTh5rolk/mkymZ9OY1FE3aerJryaT7 +tnItmfQ4SyY9NjHtm8sPccMDTN14yoCzO23YoWVxrFaWQ+Id+/qoDqWewG688UD4x9nN1eubN01q +/vPbDzCGA+YjH9qMp+FcPJGtPEjusb3N8PsPOLbGzYG2D2YX2n5GH7D/TmZkH9CysP2MPhCRNpmR +P4gZ7fBMff+Ar9R+wu6hvMF7PVeH+Bb/LJU7H8b+entx993V+d0OMuL6KB+m02e/A70mne47itU5 +/1M453csY/uYLWGrc351zt+zZKtz/t9W57zMa3XO/+QcGNzzzny+GzdeHfL3b+jqkF8xjFaH/F6v +/uqQv3nsZvHVIX9gRrzVIY8tV4f8w/OOlxevXr3dAVzoUNjHk3TE77pZh8Y6trf/8kqc3Fw3Xe16 +hynO/vDxz5V25evd8E8mf/RQc/zx/PLy5oetJ3p58e13d63B8RmUtt5+rpt/92B6+/Yv39vbV02s +3nFPp3+15cv32B6c1Y74b4dnR1yxsw/Rjkjs9/Nvb8/Prz9vAtH55xfXLy++vfn8nxc3l+d3n9+e +v/z85vb0+tvtr+NqYLx/px/cwLjL27laGVcr42pl3G8iv1wroy3b+6FO/+fi6u3dB2A4J/sjf/BQ +RzBtP7nzy/Zfu9mshj95YIPVVxeo9z6H5+JBg5G+IkX8Ob9bB3klnqSR6c3r87P2Htw+5WSPJvn+ +YqwS9mc3Szz6afIJ/+2/Xjfpahfr4fwvH2y6279XMujdjaXzv1yNTqvRaTU6rUan91pcwMRERie2 +QKHtaTU6rUan1ei0xTxXo9NqdFqNTr8Eo9MlW2GeVujNakp7x+X6qQbyNatpB21Le9o56fsY1VaD +4eMxGK7VYR4/B3l61WF2qDxyINVhdtijA6kOs8OMDqQ6zM4h4QfzCj9thKTLi7u/nF58yL5/wI/w +WhVmfYwPgtEfyGO8lmp7/I/xforjoTzIOz9Zh/YWryXa1sf44Eu07X6Y1/Js+47iIUfw1Mqzff3d +6cubH54ScNpat2xPnX+tI3FwAsb2JRXXOhIPf822BxJ++QGmNQnV+9fDnb8dZvTjDjP68UDYxaHw +wJtXr96c38G9uT1/uRubX8ARH5JX/Bln/EtURBbs9ZPWSB7bPv1sfpbD2aJVaTwEpfHYxs+2Pq87 +yDEPKMbsNKUdBJkHlGNsMNtP6YeLl7vEhHLzB5ua32Fq351/OH50nJu0f6jJdZPMEyqXv5pkVpPM +L8Ukk1aTzAFJ4eXJmWR2mNFqkllNMqtJ5lHv9ZPW9x/bPq0mmdkWrSaZQzDJgNJ4d7pLmNGqMj49 +lfHV7enZ3enln24udkhMoD/fdpn0xx5kgmc7mkQOIA/47CeNF3vsu3Rour15tn0BrW9O35z/7vb8 +v9+eX5/toGht/NlDzXSH0lnXb6/+3PjOP3epPjP+zUNN8frm67uLu7MP2L0n9hpo/reLy11mOvmj +A31YnnJlsB1u9Kvbm6sd5oWtH25e20MM3d3sIADcPNyc1lpnB1rr7JdR6GuHB3+t87XtPNc6X2ud +r4eq8/VT2b7+9vb2m7eXjUscspX0qRYh2sXGcCAK+VqX52e720/KqrxDlNVhhPntMKEDCfIzTzfI +b5epHWCQXxcCXnygbsTqtXmf7ejgvTZ3ozT49Hw2ML0n7A8wvxSHwPZhZas/4GP7A1ZF9BeoiO7E +OFdVdFVF75OnVlV0VUUfob62qqKPVBXdXppdVdGnp4o++QDCJ66Mbl+N5bB10e3nueqiqy666qKr +Lrrqoqsu+vGKhTw5bXSnKR2IPhqfrj66y9QOUB/9r5ubl9/enu7An1dl9Okpo7tl/R9IutfTBtd5 +0nVdtlc617ouD889bqTYxNPiH2sF4S1ntJareTQlTH7R5WoeJob95vJDtooD5H2vLptecIxz+/dv +Lk/Pvv/8iEg3r0/PLu5+/PddDOBv7n683MFtwc0fauq7beiBXrjfwWYe5H17gwU7T57krVtUu+pQ +7Ns7Msz1zX4PC1lt+Y/Elv/YuOTOkMkHwiGfpLy/62YdGsPYvuwSr8TJzfWbu9MPoXBOdNDNP3z8 +c6Vd+frsdBfZePJHDzXHH77bpcDEJfg4WoPjLR7+caqbf/dQs90+TO/N29tXp2fnO27p9K+2fPUe +23tj/fbLdPo/F1dvd3EB6h881BHAo/j06uGl7euOnV+2/9rNxj78yQOLcl9d4KPwnJ2zDxaZ0QaC +r9Rz5mwHKVk+SQlsH1DzQ5PC1lf7J321H3vlSDniv/3X65vr811k6/lfPn7hWsa8uyYx/8tVJHus +Itkqka0S2bKBfM23/aBFsqcdD7+PbLbKnY9H7lzdBY+fg2z/7Hz/Abf/uDnQ9vGLit9/oOlkRvbh +ZrTDHn2gyNVkRv4gZrTDY/X9A75VO7vdDuYVftrB1JcXd385vfiQmnjAj/Dp7cXdd1fnu6AWrY/x +42eLB/IY7zCjA3mMdxAvDuQx3mFGB/IY76c4HsqDvPOTtb7F61t8yG/xIdrgVzDawxC5fg5meji7 +85OO4iDPx5Mv1rWfC+EwBIq/7V70+9BEil9OaewVK3M+0bUe2cO+Dlenrbvtq4wc0rtgjwz/333/ +ppSt547/usMplfYH9HYcyrP4+/bXbz4c9Hb4ua6YK/pHuaOHx16esmz2i0iYXKvZHNJ1O356dV+O +t9cODqXwy89lU3uQyf15LQBzOPxiwWYdjrdpd2HxUO4a+Cdg8/72lMvVrzGYj5+P7HUQD/GWbZ9I +e2jXzD7bIe1sFfUf/Mo97VftH6/Ob393cfto7DuPbffvTr/ZYecPyWrrjrb3kuAq/A== + + + 545m2ckfPTAX+t3b67O/HiT7eboH8Fk+Mke/rCP4+/UIPq4jaH9pTPDLBw3uQeULygP87fb0+s2r +bSBoHuF92DfN5VDsOHvJhYck9NIG/lxi72rMWY059+4Rhjp+cXm56l4f9aquYbf7juIhR7AjIt1n +X/zBmhe/vX6pyHRIi0B68aeb67+0XrDE1DHTvzz/9uJ6/PLpJ396Lf3gx69/vPrm5pLchudHX17c +vvz1p+boi08/MUf/+OHTT97O/p85+gr+8ef2j2c5p3hknpngm0j5zJpa4L+Mr0ffQxsJh/rHj/Bf +/2/7t//baD8chaM/Hv3v/2OOXrZf+sdfP/3kOOdcnrlU41EJJT/LvvqjK6LXZyGV0ug1PksxuyMg +hmfOx3BUonHPUskRiKn9nTMZiOlZqMkenWEPyT/zMUag1zbSXKFxDM9sDb4RrW9/5jIQQ30WUw7U +spSUuYdonuGf52cleY9/3n42ZCYGYwL3WULMRLQ1evlz/6x6w3SXYuIePDduo/VeiM47HEB4lmoa +e0i5AN23RXA0hvjM18KL0NaEiG04iUg+FSd/30ZeSmZ6xsnG9rPROqJZGx0Trc1MNDXrCsRn2RYc +gG1rlAIPoO1WIqJJJjLRVSC1NStR/jw9K9nD5tbSlos2MbadLTYAMbfptd5hs9pYYH7Y0iQX+wyy +SwnoPG5qXOAANmLbxGRxXim0FYiFiC77cHTyjgP2/NNPXsEh9nBmHfwDVPPvsXVpM/LVQi+wOlaO +Y2n7EoMnuvd0mEp6FgMNLcLZb6QKXWZPxOJlI2r7c0MLkWlwQGwzCj7QiK3Dk9AaOhtgFqU+S8nK +Ya72WTW4Pu1HDW9EafvvsYMCt4+uSHlWXGg7Gdq/Zdv2hDrIrv0YrnpOzxJMjNYsGw+zzW1P4VDB +kpc2QWuph2ii9BBtW3UD9LZIlg9juzq5tia4urXdNyTGZ9bXRIsVoyncQ2jTDA7p4Vn0NIbQDkyk +Hc5t7YnoS1uQWuk44DZQD77dz0THpN3ZyNe3TQ3vGTSu7aoisS2kC9xtCXYYA51o6KGdSGrsnwVb +K53omovMIqTAZ792vhLaDsJi012xPIY2e5sjd8v7E9oOVPqt9rnqaWgrKaehrUPbgSO+6y7w+W1/ +yre6Groqrl2VJJNIwgJCOxetE8vMMTZuQUfH+oLjaltVaozDeW634nfIzz97gf8wR3/F/2mbG5Cn +wwI2nt4uG/L0xn7+AxpQZ6lWxwcW2O+VfGkDspGPcrAeB1RkoWD6sR1hviDtyvNNqNbhqmIfjc+7 +RDvWTmC7P9i8cVQTeKmciZYvidz/9hR5YpfURztvyfNlx7MG42gPQcU+4HbnTKsFXCjgfYAjrD3k +NjPjoHHObaSVnpg2vZQcXR45H+2e4J5iD7HthnTRuHn0+KEwX6e3JMRoaXeM9ZmPWDGG9zy50ofR +TmQxPvPzx9c12MYcUuFbYWrgq5IrnTtbbR8F3CvnA7Hk5F3hg26qLURENktXpZTA3VZnhlGE9mpU +ZusW+B8RTXGRHiUjd7A9IC4KMdNRpz7g9bSevzQmwzcDDwR13Pg285IQq9whuBbDirqkq8HN27Pb +XppKR6MNyPGmxGT5vDTxRLtIjW3GIjyJ733jei7SBTW0tMRVm9iQh1N+An18Df/4O/yjHv3q10f/ ++C8Qbb54jf8chKadhJ97L9Ty67T8Mi29Sosv0vJrtPQSLb9Cyy/Q8uuz+PIsvzp/mugQqD68+6lh +KawJeCbLL6Z2JK6E3kZemQ5P73OhxxCDCBxhoG/0Q7IfXz0jDyPK4VdK977ITzShXbvy1XBXKEkp +3TapnR/YShpB66SJudJJpds3/8WTYTDBWZ4Xqgc6GMu329HlZxE1OCFWkp+bAFhTzdyDaxfzROXZ +IiPhbYZf81ZWBQS8e4ego2vHIrHYBteriYBXQm+KF3OvWHXV5+111ZuQY23hswi36ErJzrKUb0Lb +4edd/3GBmrsSnGga3lUiGpJ9mqKBk8aTm1Ib1IkoIA70A6Sj3McdV9g1Pv5yBVOTlQIJl57kKxaR +XeXVzqB8Us+Nnrzh9SpNj+KeoX2KrEC0O8l9VFN4c0SNa6zQpMIHB4/cich2jVOVeWPihUCsXobW +BslDQFFfe2jMinWVXAquULvEoBzwQSjEuZvqjLeUNj0ZnVxuqnOSw2CN6NnBOR6wY9UZWtokx79d +NumhEsNFCbVxQDykTQcxheReSzogia3tMUhE9CnL1qE467gHX0mzaMTWbeEeAum+0DJX7iGCLYJ7 +AEWHdLnG830Ioh9Zw8TGqxLfnmJE63PWykrCrdKNs6CNETE5uce4hdxDe+iYCCqP9uBslnXwtHHt +mUsmsfjetkJeUeMcLw6I+idiB7E2cAf4V89FrU2ZfhBUACvKX62Gie23PRMbR+RfS9b5rhh7fvjb +SjhdnmREs4guCRG/8wL3sYEckvjnfKH3sa16rLJFsmbttRAxxY4HrdHb0HjrLAsJsMnZ8c+1gyym +H++cdAsvqR4To2NwcAlI9iheNtmynagR2zvPPbjqZZNzEylclIPWDzvaRpBYE6ljqXXrUpaH0MtR +Te2SRJPk2aOjmowo3EDMpI4ha8xsucDLffJulkl0FDGQXhzJfLELgm3ytiQx65AQ1ojDRWzcsvKt +ZQOJstZMZpEayLRwTIopb1Pjw4VehiZy2ZRZxGzyiDwtTQjxxbMubi1r0m3AJbNxypnCoo23JO84 +miZ30Bi5K0wvdBNBkFLbUvK07o3Y3tDE1qVsZdUaHeUZHEEBgZl+rUm2PKwapYO21mxOiKGU3oGx +maVkfLFJwGsyBncg9xukPk8PSW3HTP6+3XVDckcl0yNJjaK0V5W3fBtLMixiush/7+Hf6e/bzQWR +4LnQ0TSB9BKzXHoPwqWY2drSOe66MYjE+1BIUAdiQiNOZUOq/iKaTXge+iAGQ5Y8+kWwIBIxOeqk +qMYR7DA2FH14LUDSkLnIeW/EJqUJsek60gOvZWnzV3YS0AbI5hKfaHZt4fGtwSOZSAlo22ajZQkA +bcO6nfgbRIeV4MmBXdixoIKyDZ3UGpInATYFNsSCehFQvWhyt9enBOy+HnlEATmCrTMRNCs2iKGE +TJKF85aVoQimwBOROFyIiemliIiTQCzDYYChMpA4017wdicCEYWHJrDnRW6Jb8KJWPYMHgqgexOy +MFxXuYfgmC2CbbDwGBKwN32kUHZq/9vm7VnRa0yx0Nzk7WxzrxG5dWG7Hv89KFJkGYxkRz5Gi2V0 +eB7aUoqmBjzIoLTc1Dc0jlMPsOHBs8gSIzcG47PlWyuvGfBu5ltN4Y0q6bX+ggl8LHEHjlFlro50 +vUSM95istsbzKYkwMO4B6Fk8DjCL50K31jBd7H0wUU9cBoU7J+uTHTPmAMQTUeebnMq8NvigOgWo +XoWl1iYZcR9NwOE+PMiVRGxzE8WsH6q2S03sLtKBPhsFWFhhSbY6YoLQOIq4XrPJTGz6uOUHxvQt +hR7k4WkvjvSAu87dJiE2xsXvXG4ntPcQXGFdEJ/HY9KiXOV3DkU1Jma6tp5Y2YmoVqjME52F3gI2 +18SiGho8iNi0LCHCq6s9hBBY6C1J1Z8moLPIihI9EdvQuWV1XQKEV0gGbA097Y3oo2ViY05CBJGc +iGHSA6q7tA4mDQqlMWL9D4kXE8zPkbcDLS0yZZ9l0VRwwUsYeEOFgwGxpCobyqcVlsqz4d30O+PU +aN32sxTfj4+zhvuo7HSBzbeJ+0AvFx+falmPQl1UN78Ju1Vuggm9ZzBUEF2l79bEFrkerBbAPQhO +NDqjTyZevMwaJN4UvqKs8QzekSycGFwxXeZs9BCEKaB7jFiY4WXLfTeyXq8mDnYVDRtH9mCJ5Az2 +KL7khTQA5kq26vuXOrNqI4vyVmbRnMl7xGakxCIV2FeY45VnTqx+bVv4BY0pyOJUeIcqyzNOOGa7 +XoZE2dYpWyhIt+Rfck1FkR7AwuJ4wI7UV6BVkZ5EdQRidjwqH5RxwOFgxtimxiy3dn9FphESsR0Y +3gfjjTC19l/OiudXntVGzF6kaby+3NKI+lpSmPQgtox2wAv/XMlk5GurVI0QXXVs/PQgeJ6I+bQd +ssD0diVlgwIMo9L7ha84ENslMeR4KeTYIWJTKioRUUXmnj298uQw44cDhl8dE1PsWxQsE9H4oVtk +yMjWjj2KMLzzJLSCfxBeAjomtuJmtlvTZFrdI7C5IWMFQ3OkAcNRJSEJrhjbRWGWidx7gURPvUOm +oh0XHwo6J61Je9FZHopFmG02joWLxgcGrtjEssT0wZIH6iGeyyaiKHtvyrWtQsykJYKwYslNWSeC +QNuwYrUHsY7hJiKtVCtKfyBeCw373LC7xHR2xIHMRpe7/Rvqr0RsUg8TXXK5d9Dkf7Znu67z30u0 +pG0D0WW5x6BwVxSHoEVKLLxZH1j8a6ybtOIMZlDx9saoc2hMrOKTAQo9BBQ8Fzp7AIAOdrJOJ38r +/jRdUCCmIkRDhsYMornlYeANUCmUTSjQolAPTYsu9NxjX2S/TGDHLiyaon7FWjTcGMsOgyZH5S4h +UxwHSsjAc5TeZCn2U6PVnulgB6hO2lvRxtmMAjYST0cowgYa3cCuM4MZJVjZFm1sfeUN1LiJ1jJb +IYK6qj002Zc3NrHdv+ntyNNJBWDnSSP6qhekdI0jEz8ieiWpHjT/gtsKRN97CEXOMRiBVfNvJyrQ +dXSBGzdZg56udnENC2ARRJHC2g3aAriHxlQccuLGVFK2pL1VsPU6ZmyxiKc78otohncOyJ48B7D+ +VeRTdKEnMYWDXnxMWn5O/OLLM9N0whozWyQG2RB0RbZTJeUTAayKZARva5I1vKDKQ2fAP37SfTvy +foHiwBp2+0NnxZGTSO4FPRjOF6rd1VWJOkjesJpfwUenI0O3AfmHQJV5LnS0xbKxokrgQTtYbGto +d1qIaHlDIjJX7rkJdEVsCCijPBc7SrEiu+REgj00jo5dRNpzIE8chTSYMBhSYqWgJAt9yVUK8tyh +NQf8ifRz3cTTXighNnmPiSXqcwc2nurFxkNcD9oa8qB1qRwaYigKEq3a2Zvung0tJ0gWTvxfJBzi +PDwJGXDYgok0Y5RN+iGEy0a7B6/Hc6HnLN49NEPQ6Q5enGiieUe4gZXtIAF64PsBoW9i3UAx7LnQ +fcwSvRKVM5F1QcQzp76lCPbIxOKRT0FCzUyxfPKjpV2d+U/USTN3BlwpnTgU0ruXApeNqKzBJFXv +kegkrGruZHglwjyzB9Q+Y3fSTZWN5/e3JqfQ3z/9RP3p2/z7r754efPN+dEXt3d/vv7L6d13R1/e +vn3z3dHfbm4uf42u97aj//jLp598ZkKTKZ2xjcM3ecj/zkz/P0tfGvtvjCj9Nvn2Sp44475yJob2 +56lpA+m3xoDD/zft16ZRwJ+96KGbOKAXOIzzly9gTBi8+dkLiNt8MZ0GxgW8/PST1A== + + + Qwg+HE/J77xH5gFCFsgfV0In0yr400WSywaOBhKN2tHQdo09QLwknPszsUuRMzqAm1disirHWQZ4 +rFkEh2ubkOElFlLP5IYiF2j0Sq4culzttkciokeW3xMKrkuVXD1neo+cY3ogqzPcTpLtMwSIFem1 +WjRhZEf2T+2gCf0oqUxeNZw8EsX7HzVKMLMBnntQB36ja6CjZ1Ye0MugL6gt+HblQI4IdbOX6rkx +XajYQyDA1K2xnikEJjYB2/YRsEce4iW6yECBoUh0zI4q+CkLEdFqeyYPPqtkEJHhiTEncKGgvAbO +ZBHBnHiLUd72vouNG8eMLuk90WLvPrH/QQ3a5x8+lcCuTIIIqFuZQnzhSzEaUgjGCu+OLiWOq2lw +wTHXwpCDy58qBufe0b1jbO8a2T0hDh+60SjOCAfG6MKrTTowTPUrAz0nMVCpG2fejfraYaQ5sJ0L +vYz6C2gaIDrEBPSuivigOt9GshcLmKVzOekbA0Dv/cGTcSwl8dOC16SPpRYeS5MqRa0XZz7LEkz0 +RfztPcAB6DbWoWcmGnGXI2e4dwx9eKBAODZ44RyulF7EHOeyGsjm7Z8PXUmIih8eRSDnKOQeVgIm +mRjZUmv5gpO3hUeKF5WIgSM8/GDDA3IRW8cg3aD5xjiZLRkuwWRe1MqZSKAHodHpEUpquERvn0Qy +oLX3udBTlTiAWlzo9GwkUqIGFamhPR8gR8IlEUlYo068Ep2cBozD15GEKts5/UXHhimnkeRgYeIg +Ax4G7X2B94aviXP99IhRyJHmo4e+yddyC8UfkchkTY1Zh4SjFqKsc1MThnPpJAij5r7hCRgu29BN +4DFDbLvJcnOkY7Fc16yWAaAmsRobCE7TbltLOR0clYZECX9CcZ9n4aysDzjftecmZXoZWO9XvPle +NU5cHeUUtVvoONQGlrj0bjP5t9CArpe5BF0EqysJ8rxchTRuUZUZcwAcEKtwSTHLoyYofgQcqx4f +m4tEWXJEDZypnOXXhK1ltX564nraQ1tcJ+M1ciFFoPXdLAqcIQsxqq3+Xo7B15QMBUBnZwRYVL04 +X8S/AMSSeIddymlgAFGSIdBL8rxzHBlJUyLJ0NiUmux5N4JYH8FRKWPDmE/uGcximX+R/EUFVaUq +LiCPzmYgZhd4LdFZdEJPqBEZDuhwU58LvXgvdDJTF1St5UyUTL9m1e8F6mwN0jEIkiVpW+3YggOU +9ylTUCIQ2QQJtmmyS+LrDq5SagmcXXuW5BR49fHlAKJ14sKpAa1/OLmaJYRMgxKQXqo49UCg1kmL +LSSIfxyXU+PWRPqGdVc3Ig5Y96PxMP5FdEcQkQNiwaPi+OJXigotFPShHnYMTk2sg7Vfk4OV+Q1u +gisHFcATVDKHjSS1COGDaDieDk2qfDuM414TO/mrGrvAQerdcJVcFpdl6T0YT6YfCCsVHlNIGY3E +Yzqb4nsb6SJNmXCgWGIWXCqFXsVhg8g7ENi/YHusDbR3kp2iTxJ4loh3RLV2gb8iGu55MEohXSJt +0VbxXETMWmXM6L7lxhyWFZ+xFYUa8qRRv+kdm8guax8mHWfP7VGhYmJJRTphJ1AjRmmJlhx1dOAb +OV3Od3XLPDtOHD6xPdVRFkMYaSOmlGVyLNbEIRzbgtTTe3DeCd3KGJoaGnnNkhc/UrszNIb+x1kj +PPGdZaIJsuCSmhXJ28sDtePPW1lcDLbXxS1GhuVBd+507SeYKqtTODwtUgYeEzmgtLV0apkFevV2 +oPP6OjHtxKj+KfEHR3qI+7ZlJ41LGM+DkENWQQKfWGrrSj99Voh+FFuaRmlnHSeyQSM5cXAPtq08 +PfTgb7ZsjGmQAxrj5AUKPdQJ6XJ8MDdABBfjZEu058A2KzAgqrtlkHKgZ5UFhH81YnQqt1g9lb4O +QlWyMmbM+dKxZSs3KXkrogfr76IvipQjgcqhbe4g/Ti9SRy/h8Ko3Ll23EV8KhxTECnosYs/xQxs +QkVfDJecHdrMMXXESVUkFm9mpPgTJlblCK4vRpYQqGkPEtgPqSlZxHWJFWXzhvaQjPyc02Bu1APk +LKOHlyWuone/eBmaxOhGis7WjovOQ/wyw+sz6UEc5JHCl/r7leTmAYcY9LmoT4JqYc7JM4zRESKv +dSZiho4l2iWodR9eVi/REfKgVL2NYG6Ntj/uxkosUE1eVw3CChL3kSCrr9P5DeJHt9M54B/apyzy +QJKI0cyuIMx1qUK0XVStz9qjKPQ4jsR5wyPXOIJKQUo8RZEnm3DCskMGM7d2zC4t7DiX3rFPIjFl +SEvq9CwSFqqiTKyWGxcTZX4+CxH1ff1FCcbXHkDmshxDHihEl6UzjrEJ9KsqzUlQWCBO1KW5JHP0 +fhTykqy+l7hNIIsKHISfoaAYpev2vIgUjBYPIuYU+jgkiiiAc2HouWrsDG4Pi8dO481ySEI0Egjs +IM+ry9J6IBuPC12WFvFJ431QwK5FRFBSpYCYNK3ManwvCt4uqsRradaunWcjEdDWag9FFYjJ2FIN +rK50NzZK6cFIzFkViV4MHv4ZCWo0Z9GuMLWpy+jBStthLXOUoWEgZN/UINl4HEUIREqjHxQ3FOe9 +GH+C+gSRnnoAasq9ZwlUUR0Nz2eSsDcO8kWiFw00ZJ96zyjC8i/a4e5UHR4mqjDRi1XD6X3KfWh6 +8JFerCTDgCKkHeMGET050VhSEUXPF/21bkPxamPGtqKvYriqdpyM6PlWomjAkC2Nm+aSlOfIKmMo +xcBfsur50Q+MKyWx4vkiQ7ZZGzvlzUWH0EOboa0RfRwj3UceXKR9cQM9JbUB2uGZmdoGu9VwZju7 +UrqGNebBoja3tL3qqobl9xTTza66ZDgRJJ+/o/3qlvuvxQ4PcKOoKQ2MverwaOzaS74Lxt+ox6MH +O1vyz/10Ho/7hveuwb1raPu4PFo/TlzRkBty1ckS0YveLj2aoq9B8lUY9K9pN+Phz0Xs5gaKSvRf +KFHoYL7rPQWxj7pB8IiaG+O6mSSqBd9288DsF0+GwWD4LX1q2kEfDAezwbScUdXYBWnsVWcvLvN+ +DBbVri73/DMYCHlAoW3WsMuNIZwMDKfJAKX3fdXJ4k3AcL3n9zcfOZc8/paEnKtOlwGlgWdmrpkC +AYAUxIYahySHadQrRJHFLIexDl4JXyTZD4Oe+wiNlfYiwmfNNLFdggTjs2SMoRGwa1pREvBySoOG +il4yau8HF0HPMQMZpOuMpcj4shPVtSmSnGKGTgJWJEvVa1UGnTGxH84Oxk1Uab0eB6sqrS+SJTn4 +JJpEUuQ0jWYkx54eO/HQJLKh05EcbFHZ6DHLcswwK4Z77maDKC5p7CHFfpMK7yLcMLHDVCvBX2r8 +jxJ0OdQpEbpLwgS6VxKMXOI/wuA/aaz33Ce5WrUIGzEQ2th7LtVLz4OfVcxyjmx7skBVs1yTrLJN +kkaNQee6yjZLKqjtJ0DK0QyXFnzJkt5thzMOnko3Ln23lRTxj2E4HR+XKp4i9U0k8PcoMQ4WynZ7 +o5z9pGUhnE4kVFHMnZcji5UaTt7JCZicfZCjlfUOO7kLmFTBxBzi0LLbHayRYw+2/sFsIO5J45Vl +1KQ/x3W40OUpt732nDewZces7N+L96Z4TVyOSYVClrLx6g3yn9dLZgeJtc1JGElWfdg4yRsN2m3T +h+XvjR0FVq4aweujHYvxyo7qerHCOqsP4nnBLe8tByeEd8KF8qBwdHrPh0dlL8m5iEH05Kh9o5Oa +1Z4kybJoHOsajlfGboroLKHqzQuiqlejvCmWwTggMq0lN54Q5YI0wV08HtF2eSENioVNesV8lVUz +VoIdULvlvQ9a46HEwUkXlVXEpI0bP1A3OB9iTnEsQZIjun3JSx6beu6xipOG0ImFyyQNUBjuACb5 +Irn4PDy/2YvLHWUxbmzFFYcVQ0RhkHIUJbvBBzrQkxlvl8aPSOwohpGKM1kdTeD2l3wu07Psseck +w0hx7JntB77nW3ApGO4kqqtIGenonIc4qKS/6I7e12tSF/HAifMQR1F6ERxJ3/daJgsjD6TgQalh +4HY9TEFyhTBDKEuYgsnSbchyVFHUGMypWj/CqXkyOCke0eSyqt0m6TZOxlDymB7XJSmu1gKz7pFC +IHlJSt84wSIuTHXZg49uor/2hQ+aeEc3n5ROsa9gQhITg6SmeZMHE3BWYwzmhfWDbMVnbmvSnpN4 +bSUFdjAMg63CDfKf3BzoOQ5XpGhOHkqO3El2OussxCbPqSO9W5cLyEoS6DR474oWZvBdEOJg8jIJ +HyhapcOT4tO5gpHUQMyzEBYi98YGyo9EQ7RGS7g8CR+Q4J8hohiCAqxRY0rRTooG7mSNVsDv1MPo +Ee7xB0Z8EQV8u7L/pccfBMmEnMQf+SoGKLyQPbDJySlE7jTQzZydtqWQxsp3sVojX70wjDhXjRwS +91vj6LloJJCRXpt8LZd6CM0p7e+E/ZfqhlisGkUwRQmEHxDnhXE6Iw960zV4EhgMNRiK/LyHXtBF +qhQMFnk3JieCTMEeTkf1H7stnMI4gWP4qnKFldjsZPTnfJJKldmF4YEVU5rrbrJuo3NajRSfaHnc +4qA+VFpvovcqPSCZJBXyXU+Wq2qzduRJ6vQqb46ExVLQw1jAiIlVBHpXhxALKbvgpsZ3TrGC1sSh +UAjRLQnGeSX2Ekqjtd/apIMQly9ZWeWFwqSaTg9Cx2BjpQcnKgCGqLETwOWpAYHs96qSqWhI0TBi +c8HAyG7vDypzxhgHehTxCR8wFezEus+VIIcQHEnY4VRuMgBJRRguvoEti1TyQR9XFzGz5ca9sAjR +DdMxE6/TVVoONYuM2e49C/0oyzGR70Zrmd3wiylKD2gE6PZ566TnHqjE0eo4vKrhNqyx4w3ox4ld +ZrZnX1YQ36XSUFKTdnFGWsIToTej02Opw0lPUZQoNXdUyTvExlF67noDmi8GjiJGgik/sN28Ysrw +IIhWa6kslci7YvGQwHDgoxy0ZcciGuS0DDq8wXZtpQZQkpcbole9zJtLLAMxRbGj+DLEDnGeAFqK +7MB2Y5IDU70+QRLWakdR3HMoIBdT6m9QEaUElcX+Oka5ccgKmejEsKSyV9HAMVBrhn6tHHGMeuhB +e3qUo5EXyDq5OxhvJgKBnExctC5qBO14Yhzr6nm2KhdWqxul1jFxE25ax0qU8k3J1VE6UmMVul86 +XU2M6LQfZMiJVW8MK5/ava462SrZD1armZms+zyiyIIeXtbu85jKlM/f0X51VfzXTvZ3WM4oMQq+ +G309FWMu5HNmAcVTWYBCnt7GHv5JjSG7S1ztGr/s9OEIZPwiYqHcJKyxF3IvLJqKKGBVuBHcRR4B +VEr/kZpCPQNx1WMdDiIWLz5ovNU6MlHsgla+QOlcwmdQSbp3Ic7wJO3s8nEFDqR4fe5bXvmy5QJL +EeMlSyx9bLXI1HjrZda+Fyz0Zy/e/BROrfVwv2fNr/fw1oGaKGHTGB6kCyqV+iFaJw== + + + qUQCVe7MGPXz/B399BfAD9HEGGnUf4K14ECeuOf3/DQ8j53OdoxA1k7eYyNxLQKTMP/Fk3EwbEQK +WLizj6VoNFSvPjBr3mcFZXnkxKEH86rTg/Tke6D+rP3YlfcSTgRJLVedLOWgSuoZXE7j/ELPtHEU +6E9Eic1wFG7CPfTgjF4wKaBJWzseAtmGsFA3RPhMmwclh17exqlKvzluifUN3fbrNFqYOxGihJCV +0qNLWTfnhcrDyZAAoGksmx+Cniatg1zqzLZFr/GsQaqB4N4HOdKxOxrAbiQ3Gi9v75eNRbDDZjhD +RoswT88zV8jYOCme4th5fGNzpwH8ENeky4pqJl2LXgRkQkczXaezaT480yo/heuyAduxwhCzck8M +vtZNkFy2QO5AJnL9UmYLfORD1RF3Y+l9V4GPZZY0iRx6KIDTICy4nHWYoXdy1ZLsGnjjvEzPJJkg +ZgpRy6DFSIAPcz1XqI3Apw98ZhKjqYgfduDMsXTNDTREuXdxcOJZNc928AdUnxQRglOggZglqyEO ++Uygl2ljH1zvORotruW9lOGTcOXQFotKyZPSINGLUJtN178HDtrSTc1Al4OKwaFKF3tJoLJcRHR6 +y7H+kLAsuVqYsTowHIlK5BhBPAaaWaWhFpA3LetselUMtJPp8+yVv7WLJRXMknZbkuSpYIH0k34f +pDKB6y+FFATTrCEq3qSZOT7mfvFdLCpkGHmI2x2QSn4xi+TRWTRku2kHwnWjJO9B8J+wuqGqlOeI +jkDmAP177+SopCFWBgYmRyIleRglEj9o/TuJxeNraoeZeWOUJ/SYXVgJZaDWV+25jteRe2C7MXCL +7iKAlfD6PvfcWj88bhv0pPLF4FJgIz73zy5t6NzpC6Ss3CXhCsjM+u4ZFQomT7xEc4axxDeORBjJ +6Kn2FOLf+V+nZ5XdYhj6CUnOftGoUKRHiektIYx0jfVVU7TXanahW5ehB32ATR3WXGptb85IDs/Q +r2fjeSBvoPy9rlR14+kVeQ2LKgwTkUOiEq7XdI1AZTZlFrK5SNSeJVQtUOXfPmC5RLnLEV4LRvbq +gpNBRAkKgUqWylp7DVCcidPrWeXcxOSUhWoPIWtId+imHU8pHUT3edzsXt0ojm99MLJ2TkKUPKSn +CPMRh5GXyltAnN59DcHHeNR+7KwmKIZR9nE9cdF0xmazcFy9ue0wpKGDfl+s+IyUufohwbXmIGtv +izjl6mSRDC8//FwetlVUImhfZWxG01Orbol4ZaBhtwSC21weKo0t8uou8D07EBQ4eWOGUA+neVx+ +Q6K1+ntlFDSyFQCXMcsbRSFNkw0jPemC2EEwTl4ybTWKC3w64oXVoDEIWBBnJAaBdckpi3euDAUL +IZBBXHnVdoOgI9lDpj/Qg9V6sJKe6Sj2mlc1iAxnbR11ZR1Jo0tjb4alwugroqdRhzA1u/nxBSdJ +ZV6D4vNAl146B7OMlIeXo5cgFudK0Mq9aGSWnBDbiyBjCI48i0MtXbTciu6DHttOzzI+pwJbEslH +ymUhUZiV7+FOVgtxg3RQB/EwWhFIOTslk79CZMY+kZBFDEfuOoiHRrEw7DARQjlEejHDgnZhUCMn +YXYi+GOeMxGhgrgICXkoOyo5BKAPjUuUiz7NVhepGGHpmm4MzgqjmpcbRN2iPAzdEtpz0fc9SYSK +lSqa0zHX6IU4RAtx8BmPuccRjMdu1BjRZ6fvYR5FY9UkC1dgAmLWTCcxOjlG+KGJZzteGDXYOD8I +1866UZvvdKNiwGhGcO6+t91pAfWplLFpWxitDhtq+lWni5y8ob7P1Ho1qnSBAUUitaq8U/SZtl9t +/Mtp7+2bjd4b/0Aj4ftt4N8LYt59CK70ZRmGK+G2LUNxJfi4BTiu1MEyJFftY28sV+phEZordbEA +z5U6WIboKvNYgun6jkP3HL68okM7Q3YV+Mo5tit9WYDuSi6RRfiu4oRZgPBKi7IM45U2ZxnKq4BX +LsF5xT4WIr3KOJZgvQp85RK0V1nTBXivxAaXIb5+9uJ3m/x9RX1dUV9X1Nc9UF/h8oCzGv+X/gcc +1nqxRqc1/Pd9bmv8o7+uF2y9YL/0C/an9ykf78WJpRtyH1KsfJljxcqXOVrsO3rrUuXxfQiuV8OX +GWqsdDnHjZUvS5BjJ8Oao8fKlyX4sSo1748g20d5L4qsfJnjyL7jbyb7cR+arH6Y4cl2LWxvRFlR +geaYsvRlGaosXaj7cGXlywJkWZEil2DLSh9L0GWpj2X4stTHMoRZepWWYcxSH8tQZumOLcOZlT4W +IM2KvWaONSvq9hK0WeljCd4s9bEMcZb6WIY5KwdnCeos9bEMd5YuwTLk2fcx2ePF6LNicZrjzwor +XoJAS1LQIgxa6mIRCq3IcwtwaKWL/ZFoqYclWLRicpmj0cqXOR4tfVmGSCu9zzFpRdhegkpLfSzD +pZW1XYBMKxs8x6alL8vQaUWSX4JPK9LLHKFWuMwSjFqxTS5BqZUnbn+cWuphGVKtVHdaglVL41iG +Vkt93IdXK1+WINaK6WGOWSvG8gWotdTFfbi18mUJcm3vY3/sWuljCXqtKHhL8GuljyUItl053R/D +VvqYo9jKCJfg2KpGvj+SrXQxx7KVrVyCZit9zPFs9csCRFu5a0swbamPZai2wh0X4NoKY5sj2xLb +XIJtKx6yJei2YslcgG8rvr4lCLfUxzKM297H/ii3Yhye49zKLJcg3VIfy7BuZcOWoN3K0VuCdyv3 +awHirfDQOeatfFmCeivC0QLcW9H/FyDfShdLsG/FULAA/VbsBGGGfytf5gi4+mUBBq5IuUtQcEna +vg8Ht2v7m0i48mWOhUtflqHhih1gCR6u9LEEEZf6WIaJK/aIJai41MciXFwxXMyRccWxswQbV/XV +/dFxu59rAx+XtPVlCLkyvjlGrnxZgpJLfdyHkyu2niVIuaLIz7Fy5csStFy1Ru2Plyv2hCWIuXo8 +Z5i58mUJai7dn/twc+XLHDlXvsyxc+U2LkDP7d6kexF09csGhq7SF6DoDh68e5B0u1azgaV7/190 +x9hmtMKu/7117OyLpdGzLz5i/Ox8ShLp+tmLIdb1eA23OFrDLY5/2eEWtl2n65vro6bq9JCm7eO9 +78Oili9L0KjFCr0Ej1pewCWI1PpG7Y9JLV0sQaWmPpbhUsu52x+ZWkaxBJtaBO8l6NTvOHr92XvE +GNUfPWLw4432veFXH+YF96JYb37pONb6ZRPJ+h2dTaJ97sWz1i8zRGvtchPTun/YH9V6OqoZsrV+ +WYBtLX0sQbcehnkfwrV+mWFcv+Nvnm90OUO61g8zrGv5sgDtWrqY413LlyWI1+Lbm2Ney5c56rX+ +zQyNR/9mAfK19BFm2NfyZQn6tZyvOf61fFmCgK2nd4aBrV/2RcGWDuY42PplARK29LGJha30/dGw +pYsFeNh90/ZHxJbDswQTW/pYgor9Ph7D13kBMrYyixk2dudR+6NjUx+L8LHpub4PIVu+LMDIFllg +jpItX5bgZEsfS5CydfozrGz5sgQtW/ZnCV62nJMFiNn9gd0fM1t5fd4XNVtZ1wLcbJVoZsjZKk4t +wM6WPubo2SLuLsDP1s5nCNra+QIMbe1jAYq29LEER1v72A9JW9WKBVjaOoQZmrZ+meFp65cFiNra +xwJM7X4UNlC15x92x9XWE7iJrK0fFmBrq9AzQ9fuX/bH1+4i1f4I2ypPzjC2VSJagLKtfSzA2Vax +ahNpW2WlGda2suUFaNsq4C/A21ZFYxNxu2sg+2NuSx9LULf1DdzE3e7y3/7I2yrl7Y+9LaLCHH1b +v8zwt/XLDIFbvyzA4JY+5ijc+mV/HG7pYo7ErV9mWNz6Je+Pxi19LMHjVslwhsitXzYxufuHDVRu ++bAEl1sF9Rkyt3xZgs2tMvwMnVu+LMHnlj6WIHRLH3OMbtUQ9kbpVv1gA6db6TOkbt3qBVjd0scc +rVu/LMDrlj7miN2qT+6P2a0XbIbarV/2x+1WfWqG3K1fFmB3d560id6tDG9//G7pYo7gPXDxEQNt +/DJD8b7f8jm1i96H5a1fNtC832dB1A7vw/Tucukmqvc7/mYNENg2QOAje1e6tzXNK249Pnjxj++s ++njDXeqtugeAvH/YhCDXLzMQ8vs727yzcyjy/mUTjFy/zODIu2K+PyD5ZFhzUPKut+8NS75pfdgH +mHzCQWfg5P3DJjz5/X+yyZLnIOX9yyZMuR5bzgfeHahcephDletoF4CVq7o6gyvXL5uA5fphE4tJ +1ecFoOWq4M9gy9X0uAC4XBnsDLpcTY8LwMv15M7gywernCD57Qpgrk/xDMJcvywAMe99bMCYq1lp +AZC5ru0CKHPduRmYuZqVFsCZSx9LAM3fwzv4wwJQczXvzGDNu21mf2BzkUQXQJuraLwJbq5i9/7w +5irTzwDO5csSiHPVAmcg5/MvY4mWhUDnqgTuD3WuytgCsHPdtwVw53p8FgCeqwVvX8hztS/OQM9V +L1oAe951rk3gc71/C6DPe++b4Ofa+wL4c+1jfwB0lWIWQKB3SWh/EPRu5d4fBl3HMQNC1y8zKPQu +3+0Pht4Pyv5w6HpQZoDo/QjtD4muV2gGiq5fFsCiyw2fA6PrlwXQ6Mo/FoCjax8zeHT5sgAgXbpY +AJGuo5iBpMuXOUx6/7I3ULraqRZApUsfc7B0/bIALr3b5fYHTFc5ZQaZruLHAtB06WMJbLoadmfA +6fJlDp2uX2bg6fplf/h0EWFmAOr6YQGEuhq4ZyDq3fS9CaOuX2ZA6vJlCZS62plmYOr6ZQanrl9m +gOoiQs4h1eVvloCqq+g6g1XvXzaB1fXLAmh16WMOri5f9odX11O1AGBdT/0MYl2+LAFZ73xoE2a9 +f9kEWlf+twBqXTn0Jti6flgAt64vyAxwXeX+BZDr+qbNQNf1y96w6/3V3gRe18d4f+h1FVpm4Osi +LC2AX+/y1iYAu36ZQbB3BWgThP0ddsupWfMeKPb+YROM/T0mwNF1NYNk7/LrJij7O/5m9TRt7Wn6 +yK6Rd7madvGRrCjmW6KYr4DxP9tS3wMY//HdlOtubLkb17rM+3lh7wOW1y8zaHn9MgOXf0dv0xft +Poh5/TIDmb9nGAzLrV8WAM1Ph7UJNt/Huwk3f/+fTOd5H+h8/7IJO/+Ov9nscgY+3z9sws/rl7w/ +AL30MYOglw9zEHr9sglDrx9mQPS9s03Muv43+4PRSx9zOHrZxTkgvX7ZgKRX+t6g9HpyZrD02vcM +mF6/zKDp+5dNcHr9sglPrx9mAPXKK2cQ9fMvAlKvX/aGqVcOuACo/n2Xhw/wDKxev8zg6vXiLACs +l2dgCWS99DEHrdcvC2DrpY85cL1+WQBdL2s4B6/vXzbh6+XLEgD7zrD2h7DXE7kAxL7fmP1h7OWm +LgCyly72h7JXSWwGZt+HtzecfRfzNgHttfMFkPba+wzUXr/MYO31ywzYXke0ANpe+w== + + + mIHb65cZvH0f0SbAfd+aTYj7PvNNkHs9EDOsV/0yA7rXLwug7rWPGdi9CvT7wt33M74JeN+ntD/k +fdc3NkHv9YtcuTzKLMuA7/ucnF5oxVmPySkL1j5C1qyJMJrWPOVZ0Refp4egFzCMU3kiGFlLJ2Fv +HrLHhG2JU9BL2U0gbnIMzX4RDPH+RXOPw1Tecj0r2XTGaLNwbb3t7ZCkoYvxblnxDCqD9kNGe81B +9sIWxX3fWDLDGwI/mSebLWod/E2VERrNRq+6SeJzg4ajjRYCKuTh00g1r84f35N+QRWV92oSHuQ0 +DdPPZGurv1qmwky2UmBtWvYBBS/Njg/TL0kXyE4E9eQlyV7jBMFzJx55DU2E4BZxRmOY4SirZfHL +lkmVYwh7ETdutaO51pGUIwsy+RKsFp6XXGxHKQ680kGkR2vraAkYRtS+SHNvJouH8X30JU21HFOz +u++Qj5jlKNBPvkhfIwe0DEaMV6njIIgDLShsADoIJGXLjmgMGNIlD++kiD9a3EVTQz/++CXLSBUP +PiaRtqRqJhKF1fkxnM4qVgjIInUioEYrgjGnkWXyRInU2qcUsigGyKMnAqpR0C87mRKBS+OXYiZL +3AVSjeWFeYpCMkDRA9iJCCV5UtlcEnpAd5suWC4qAlhdsmLkgdD6A+CEMqonuonYXZQHortp6L2o +LJEk2slKge7p2Gv0QpzEoXHAI499jD0Zj+VU10Wvrb62eSqqqxZcuIQcELOmK4oBznGtPlqEbKeX +S81Wzk/EfWfdaJ8YvxgVOKZGEufulyKc4r9syjWblpNNu8qG6eFq/CIS/MwocY+5YjAndUEFxbLB +nvQe4Wv6N6vfZmu/zWor3sVW3N1S+cPLu+eX/huFqH9/14Hg3e57/cUfrHnx2+uXX/949c3NpRC+ +PP/24lpIv/ry8u350e8ub344v/31p+hxIH/DW/x/aP028KAx7nyTfhB3Hj1Dsw//AR9GB4W4JwCd +IU9cFOSgOCYYTgK4ioYMOVdIj1lMeFDgslKt2AiBEBht5ypBSv0nNs5e0EWd00Iq857/16effPOu +1fvVMdj4a7uPv+4368svvzg7e3v115u7U2g8vVZ/H9Ya1upZQkhX+EekVbJHP3zaBmId1+NqGgqV +taQpGi6xW5qcoJhAFvQCOLMRyklmOpnOSG3ubMhEfII9OEsxl40OUgIJkU7MaxGwqdh45cDCECsR +PQfCUWMKu42FU26BGKVbqNPL4XieQ7waMVGw2xn24AvlXiPds8waOEq7ER1Z844Jqw5NKzAGTPug +MUANWkjpxR4EdTVaLr0dq9eahckws4iVU4loDKlwjdAIVecdgXokCNmrODUrhZygJT4zbQyRMFm1 +B6qiGnMHekqFrQIwYKkykTJn48fEMYE0ixyHjZN4V0DRsbSSkLovWBwJMdpwbRxVNwZOAyVGaZOh +wFOSoi5UoTTCCBmFp61SRMC+6BWUkNgdQbE1TZmK7QERYARwDglAaAvlHojBtgmjVAoAh9D+hTUu ++LVM8F3FRsaFheNbKTalGAjWwxUPDKF5Qj1U1mWbNEv1dRrRaU13qLNM2UZAxCIPrQcw1jWOTWNo +dCxU0egGiq7gzznHuTnRqwhf2lVxDl766AqVvOIxAO4J6FzRQbUgyma3UIAWJNfojJh0m1wJ+ZHQ +0nKaE43BwF3AvTShRzu5AV6wMqhbZzJiu6DNjE4qYwOCSuBLTO43/DGOuLSMLdUmBlADRf7eGsr6 +aXQocEV4viaTuImLLrgzc+7SVuHVu9icOfrNH67v2pvSnoKjs5ur1zdvr18evfnu9PX50dXNy/Mp +i2ts7Vd/ubn8/vToq5u7oyZZ3J3fNi4I7N0qo4f/+99WiIGCWCnd1P2fo9d0NIHNgGciAigiw1mz +rAmhXW1GmTaAuDmvPuJoUFhdSoQF1Ih12CpA6LRoe4bz7di9EfAAFs1Y8RLsCj+DMXnMuyJDaMGx +EptjKIxs3TZLq5zEylJl47Jk6KAesmFY42iT/jwkb3k6gEGZauXKCrgEUMuGb70XtoH4j6rdoRku +Bo78ZQnH0OaDXYJqif/unc8Z3J0cbN72NftveMHe6+Q+xkrr9DBQOGuVlyyHwR4jCaSI5iY1rdDc +zcyPLgFkLMHG8TJEijdr9CgG+mICW7ujNVQKEYiFRTdY8WBsEN7FgiZuW034mgI7wlqqbdHbS1aD +5x54L4MFRJ7SGTAFXAJHEgQQNIQS0ZIx8hgBxai+X1Pk1AXHe0RvJJRhF8xf2V9LNeyOGbkZVCy8 +DpAip68QP3o+aiV7QM4GBweyOZSyj7HANLrCGtFRpRAaQfJS6d1j+Q5+NQlYFEaFPIreV5lXJnsM +DQFebsAfbvSquB4wSjqhAoztM/l/2+94Qrik3/ew/54vuoSme7a246MgxZBckIcpQqWZKhfCRipH +hAMoHJhorV6erBiZVrzR0VVKwdYeWHyBE+LI6egyRTsjrkhlpxvMq3oGMsOiWbwIhdIRC6KNmaSw +o1VCICVra34jWg//z6ef/Bfezf9vEBH/DuIwyfhpFBtJkm6HhYTodgdJkm7XA2zbIEE2maeJQHSu +DF05ONlkT8P9o4c6U72cxgqNrH17RChVEplpf2ap/CcKfjH0/HVHfjDsFF16xwgUQTAIwI0KV4D8 ++qMxnnt/QV8HjKqms1g4ar+IRJRNx0jzFJGP4hueD5plCQKzAGXbuZZdtuSUaevExY/p6qWMjBwq +9XN1yI85S9hEgkKGq4HmG9pJuMAYiAvXkzPO2g1krB98AnCIBXSeGoU7VJVWXBXe6Z1cDhSj0EsE +QlA1mYSgQtoRCkF4Mz72VrpAAAL4HONVp62EX0b7F4jSgnfRbjU/3J6rm1modojCdbuC4oL5qAME +3KJI96aSFftK6JQ710RrjYRBZoNAQknMut6QaQBJeBDppDlP9makK9vKwsuAeXAyoXMi2kVLFYvO +PvIcQX4w+Mj6gk4Pvk5BZPPgRazAPBQ4SrgenHVTQNBMCLUELyGUaToTyZoSV+EpIJTJYkEHDfwS +YA1kvqQkrLhEzuuPPccSqIYXYsngA8STTM8kG1OkiKTlyjIVgmfdATFLYhsqGoD4LhlCgW1vR9HG +jWhABG+zyZwx3k5FeyJQcHeJHP4qyJDbD5UP4i1FEpWjzaoig+ZAeqS1BC1GL2iRmijQuBovgfms +fMOR5Jr7c7bJMmkWrQYuUSKHf/IieHlL/I2Iwg8cOT1OVM5zlaUIqdWQdKNjT2wBMSLgLKIlnV7F +CCrzB09+qARO6xNB1CMDY5BSOKGk0re1lRLaxwiQ4wteHQ81DSn5wVthD7En56IARC+cJbWWhmCq +KLmhat6H9QTMhctg+YVrC01FdEF0xPwTvdMCllYoRZXEAJoEoI4IFOL8NLYe3nzM8x69yFDtcUc0 +J+ZblbRZMuyw4SJwtT00JRgOavIAKUomjkrxSzzLRDUjSwSgwcTKahRZAqBYGB8STjqmhwDLhnvw +cZjzbjrp+9cCTRFomuGUNJDlmIcDDDAjzTQe7TGmDOwyERJX+epYgjZD2wxWOT5G8Eu2+OTQRXgn +PBaE9qDmMNiFgBhOoLEyfGRW1T85VQh/Koljt+UcrZjvNPeyIRPwIgO6xuHfapS3E3P9CFM3E0QV +sSwB4raqjxmrAR1Z8eJIGnVcoTmJtEKVeIMwbinyyth/2BKxlpjvQsV5cuQlYdwEHi3BlkEgsgOl +8+AjgQ5+3jnIqqVkc0O8kjVbNAbA1DCThbaT8R9K0IK1tPecDwgo82x7yEEK8ZWipWmyGB4Abwwi +cJRzhxDHlGfSIBlZCUvOFAFIa+9GJmMUWi7O1JxuBSSR88gAtBx7xbfO0+kDFF6yNloqWKlWTNY0 +Wlt5JuBWQNVbhnVkiKPKlg+qCG1812F7NSJ+g8FoyslmJZLS9iM1rmyyRLjQShYtsKsG0anwuPxT +e9aFQFxTVplJesZqqFZ+LpJyBCaEvjrtSlKIQwT7Ja8EiHZkBLKsSYHGzHp8e/oHSzWAykFWNEoH +mX36sTCUANj1UJ0koiXrpuWo+zN1a3jLeyERTbEvOijF/M4krX1cCaFXe/BV4+QYgj6JfQ3WF8My +fxTrGEkuofatj5ZTCwDzDct8/FPs8AK9mRXHLXBSH05ELgA+JfjogBxFAWRE5ucZ3ku+sMGSK58O +D7/ZAClaBEMTXYFnMgREaylUAdQJ6C3HRgizpskFT1UMsRM02VHPpAmOaLBWy5MAYKuowD5zVASs +Q8kqYhDsGeyFRNG5LDqnKaOQ4jIDfoLVSurSixhMKH7slAGBJwoWu+kihi+aBh5IAuPxJi1GBh5W +UlA4LqCUQfuDJUtoGEUgcY7IBbxRMsgBJyI2EL1AeADSNxw9PlBBar0Up0ZQMKtSjHbplQAi1pyp +ZNRWS0KsIl8D8jBzXiASogcQKcYL0JmJYwCsNciXfCuNlH7JXHOXLhCfELB/sd2tjYorIUfWJ3UK +iXIEEIaOWHf0Enseksb4RfGYhcAodmciOlRCTQdDIZu9QAnHF8FDbBQL0k0IIh7tAWk9qdzezkJl +etF4XVdZD/IlUA8/insAEeVL23wI0BT4O7J7g3czgP2J7iWwB/RzBC9WxQj3BIMLfSX4TFpzjjiE +SwChqry+ViqARCN1oED05xD32I9NioK1Bzo5FNVXvslPI8Aa8m5mqSaK4OCMB1uougLhhNs6PAq+ +yNZ7eUEK8xuE3+ZaWalI5fBiKKCyu/iYw1myY7EIRWXfiqEqffwiEA8BRPjghHkXLtKH558t7XOJ +5p/vcZ7sLLd3+15yR2Lk8+wpfxZJqgJli+AzS5TqnfQsCdMyarWFbYkkEvUzDZaWQKjLVvXAj6ps +w7mg8LbCN03HSL7fgJ7bIJom37sCePPkPwEg9+T4oY9GXozkKDIc20rYBhxNivsEjzIzJJikxccf +5LcusCSQVzERANgf64no+pEKleMrazWg3o3MgyzeCKnMvNLxQ6/vE/EOidNl0/iJdsD5UlF9QOC6 +MjaJNBmFK5KCgs80h3JyY55cFkcHjFdAyaxcOlB7uciN1RA/GoJhQ7ahJA9+/FGKGZHbGxFLsNKW +ca4G9cCYzzAE5+XJ4CKn0APrLVHslUAUw/3HPW5VShqCh7wG391MlULLCxUApVvNkdwlqcBakiQk +wbhtFe8IMARmAVnRiXKUlDDgCxwzmqqoGYW1vxNREBlvBx5WWtIMRmaSQ4zWIstBC/1zGLHqCIwu +Cu56PlkQ/0G3A7SMqLy0UuA6vNdc3o7FYDRRge4gEBWIlcv+N3a1gSWcxX6WrU/EZSm13ZL4xDL6 ++zFBBqQLrnbXWDznlBSvln8Wo/msJKmg2FhE4TwJQ5gY1IGzEtWN1bC4g6zai1UbSuuV/evt10SL +TP0Me6qS+NEPm5ExwvbDrb5SxzKpqiVplhriuNODk0WsCdoQbroN8uYhErNWOuJ6Rg== + + + wWqdiqDqCnh+Wd5LWl6NZdkkMfSpKLi9ZDBalVTA+OYi89HSn/4oVj8Yb+HySREeyMDqK0JC0DIY +ikxuBzuyP/DjLjRnEdNbC4z2Sh4XFr3wxefhSGwH4gMXefw4kyNNJgmPCDH25ImJ0XwYdAD1M34C +KqXWNSJujqxSYdc6CEj4cND+s0kPNpg9FlHlBTBwAiCWrjNKd2DmVRbgi0Cmm6LgPT7JCTKMyv5R +1/nvU4/j+O/vDAj58ubmEs1FniM8fnt9+s3l+e/fXrw8f8Pdu25U0lb/en1ze/e3H1+LRcnO2/z1 +/NuLN3e3ONCh5V6hiieXN29fbgYpssnKZA5E+f5dIYj2/vBDmwWP1XrybeChTMUTEFPbpiRlw1Pm +ulhtlxvbAm0apfmULIFnNcE9SDnhBO4lqqVmK0VHNKLPUmLZJVKG8PwkcKJ7PO5O5aAEgUqULxXA +l+aRlqkEFWo6WBmNOoCYBopjB+hvynJKoMZTVawM7BcV5NRGEwh4tb1sgoYNPUepV4gyCJ735J1C +DXqJz0kQhoBElDfF7Z7A9Ycg1qgkZ2RtTVwSc6ipVPkaiBBKmFhDxoxD6sGCa5fCrhylC9AqkNuB +kizxtYEeOnwjJjLyMoAJQ2q8RrJWJChKVsWOiGiZx40TVC6uBL/Vw0giOMmK5eABhPuBn0uctgce +VtS9aSuKReXfJaqxxuvgxNzm2RbBi8ORIYBkm+k0BA5axlAHeNP5NEAsFP5cNGIUSIGRfKgxCWiN +uzzL5MYKEYvPUgcQMovIoeAZsmTJSRD6lCPH0EWqQJ3gPaL98YXye7gHTPQo5AFkDxCc0uzRXeQz +hZNSy/b88Np0T1rCsBKkuyosMaEqS2NQXPQEtgKyqnmOYKMeQAPC5GFwmAdSUYFIhT/bCaLAN7qY +AcFkMDAu6yyy1LMiVytKjAlebqx7CQvJwH8JUzGyJd8oxh+eCR/AtHV0eQgyrk1cmRHCJw2rZhYO +TmaPVwxqr4O4JCxlDZvpSViCC5Bp47Mm6lswukcJvgCNgf1YgWp5Il0g40ylJxRnJnCf4OkMFNOB +YUDSQZt7jOzaFhQbYGspR9pgMY0biCTIHOojxcWISzbZwNP6agiQZVRZ9LsVCnj1VWyLwVANVbZz +Oa7xim73HOWRb6ImBuMaknRIkrXVcJBj7D1kVObRXVI6sigooOS1Z+xrim4lVQYji8CJyFGdEO2T +HF8WqvfnQGNGR5A36r32Ik1BzBaCTVAHHhAYI18KroxXgHVXuqxB4lGKE/sMrA0Go7J7OXDVUfRJ +HlHwRim4igFEeKqt6AJXTgMiRkucSahI4yd83dk4Cd5pjI/GBUPxhogcVwrB700MEQ8+gJI7Oc+k +aRQYIxbBbgxekvzaqYRwwECLUIPG2cHhNGg1bRcQg+ugBylXD/PCHKFGBHnNUtRlImGMeoC4HeM4 +8peq2APNlsKBejSAzGVKMLBAMkOADpwbrcwOlDSKCixol2I3MqJENGJl0Cbc3KzssULoIVZHQD+0 +p+gaaJzxMAYtOV+weAn6kD1LqTQGeCIpRBVDbihMAHR6LB0NZ59c/wV8jugSAr6C3hDqoKkKgXhe +gJHTIiDWdRQ2RgVJK7xeWNwRWxaJUasQEmkqnxGT0ARYIZQAa9LAuDB2EnrIXFoDwlGHDgqLErA6 +lTINmnoNOYSOLPuewmAqBDkiHCS+11mM141pay3RSH6cRnTgO6hcLDRULFtZIS0jSEAdGjh4DBgu +JO81qtMVuCuKzfBr6HeiDiguA239Tt6I6iDvAfkKzJICw3FpLJnrEb4BFwFgPKhCaKUXhM8C4EVI +5dBKhu7GfqD6TCRlCIsYQK9R6hk0PQXDY3gIWRKjwTiQ8YmoYCUmIyRsJTFH2AjO/od3Hdi3roKn +XGTgN6R/wCENDrUdl8QsUTCyuIikCaZPPo9RIMxsVs6UtXQBpIRQedKmxbNsgSk0VpSokiB8AzNn +rRG4TuSOBc1K4C9LRvIBELe79RDJOcqsxZP9DeQJQZVAZKmElmOIpxEUUGBeqFrZQm5Odl6CBQDz +zm0luyDZbLgmpQtaGD4HqcUCbFuvFThQE+0FxJY5smojE8dD1hi7ALaBjEXLC9wlq6kbmhhU2nzS +OFHgplQXIcCLwu81GPyxLjKE7rsh+pRrVDpGRzjGsDiSnIDICwnZO4xf4ApVKdIhUNAyDA2RXo8x +htZRwqxTyeke7eUM407Z6Pzesn1gBWo3+Yej/82AN/w/qB8dY1gNPkd4pDDJnzUjEO7R/mA0rCZl +BcnxnLnLmlGiND30c3AScYpwUFBIdwosmOC5IWcA+EzgGWVZGAqj4rn04F1HPxDoKpReBLp5JKMf +6CqOsHJjongE1iq8lL2JIOkU1h8CJffmRMIayeiOiheXRAZIFugrJaCRfY8Eb3qlUKNAWwr9Ptmv +wBmIFnD9cyr7AoFe7BUFVQcrvTeiU9kWosOwzjI6ZquIkMlJTRrkZyZaXgPDZQEKPY/UA8LlUXRE +FAtHgneBbCyV02tAL4q8acBoOdQ7GagXQE7gSGI760XiqYcECBY9EuSfoTEZslRC0HWg4q7wrvTI +ONCXOHjQZ8l2xsXB24JyiugZhfM2Y2RfKqsUUMIMYxVjYN8uqNnOkLDnVesEmTgaFrNcEMkDTp5o +NZz9BUQn+U3AExKrVVjjFmWfkPQogSORthiUqYJPE4y2PawcFMkpT9Ay0pvbVkZ4A4wLl5RiJSum +pDUNnY2hoJeJggvGMsptwu5FfmtyL2BSJ5JSOCk2YShGZeGajbdwJZ3DvQGDfb8OmJCHkkdUIRbV +n0BJRE5Ar5PiTONswW5+JhyAcq8hxEkEfwfhjJkT1YTzWpD1UXuC1LGqKlGRAGyI5HIaK+tj4fBC +x+HAMEIU4FCM9qrRVIayhVPDYj80bjy2HHFEO6EfWA1dAd9x1gh/UH8oFLFpn4KgbuFVDiyUCUiR +BaYROBYW0TnY3+uoGgMuGdchBzd/RRkBx8Bu88BlTlAGxMyTHn+Q8ZRGJxWYE8yMIvfa0lhy7OZK +ySAUZNk7AKM/B5VZW6RmdDsVjkR5di9gOC9lz8G98eL0Lqiyku5RBQCkgLQRcc9A3Tf4ABafKFqL +UkiMRD2XIMZzkFgdYc0UYNmIBAhKGQPIF+AK1fPKxFBVpamQBlhpEURqgIuQDYeBZ2J42BKdZKi3 +6wsBupbBZA287Fzb30UuyQZLxqIE5iFSZEb0g5mgAH/FgmRwoEmfgX2kVIpADIA0n7Y1kbiH73ol +OPNZ84eoeqoZnzTsJbKZDYiFS+6gLaCq+JYlHAYPHi8C6D9kr2mrzNl+oPxkYneQF2iENRZwmdjI +VpiIiUOFysMgD7IE+AVESA2tbAXCChAsB0fRTNv2YVF1alxTYuWUQ36BSD5bNMuAP45VGgBIS5Ke +QGZ40HMyG1s8AYhSS0JeR4uGlXeuoPsUmR6wAJbbrTxSsMyk3cJgY6ls13FedFMQ0SlpHG0Hog0k +zT2Mz8hYA3pScYFzqlyR4LUKAgnFf7bV4UzVioo5JinaTP5QUpQiB9p5UjhZJyrwRrGikgj8rYKS +qJDB6MIkFaEnzeG/8SQwtZ3D3Bg/DfQcNhWaQNIYaR5NBUDlx9KLyrNI7LeDvDnetopZsXh6wcpD ++cmwDgHr5cAs8G/4NCStoxMFQBmVNR/Zq8oulQpZrYQ2BbGQ1qtuyBV60DmKbz2QLEU0wCND1fmr +deKPBt5US+irwMgFwHFIQqso/pBkbCSWt3awbwjT0rgmVLGpnBeIKQmjqAqk4yWU5YBDUDHJAqEs +VE4VzFTQknWixvUymp5BvGaDUeKoXaAx8A5YW7iKjmPzh1pbuLwJ6K81Sj4CZSLDuDrsBBd+cliP +UYJaxbaKkjJHyICuF7zMN/AD4al4oueEc1aoHNUstP1BBMMRnS7PcV/HGK3PuG3AVeDx5hcK0ZYz +6T2BH0TgolTuB2PtyK3loJALOiDBqN3fWQcOLKyxCOvNuf0g4TtcVzyprCIliSf1bgwJhKcn4YXy +WQPcPYe1o1LIMtM9Ggu51p6A7+v3t6dv3txToOPtFpU6tveGFYDKQKsh6FUI9EIpauApoipC8PR6 +fswCYWyhd0nqAkCFBor6LvBiyAtpuD5HhKvImYnRSpnhJsd4cpABsVLRUTCta2A+CBr4XxhYhrD0 +ZKcNGGQIxp9C9mMQagg3BMJx0Y/F1l+u6YesDh0+ZGhlzy+Yl12hK57JWAjx0QNjhosbqQAuBiPR +KqDtBgN6QVBkEFhwMaCJBF6MVDW+G8yGgdxWWeKlsFsqZQrJGpWBFznToI2hUj0/FvkqZwiDW1sw +2zDLER9Zx9kHxxQnnNESj6J5GlzVkYsWJ3JbQrftpamO+XV7rhITHXsUMTaE/74ScBuq2S5KZCfH +rReLNbyPMaLSJIGRQZh5DYtgkwCo3pySGa2gYKVKNqVjDDTCBwV/CR2D3AM4S5GHJ0NGMIqhQIA4 +7KGSfwFCOcmFnwuFkTBLCUIHXsqR/mDEoaoRkD8c2MBSxeKPWWRG1YeigfqFkq2Ig7UTg9GTRVbB +c54l7mOuXlOLqoBDKkt0FJQTo0b+u6J/HAkjin8dcpnxkkH5AYbAtYYyydHAmcnSlrCqFoqmkC/s +ZBMTBFySDAeByxwwBPVoKGQCXknxE4H8S8EVUP9ZXWuQsUHRxL5KeETCZHeKUa6MQtr0bQ1NB1OO +6qGQPklljYlTgGIZxekes2CSgR7Lfmk4eV7epjYrCbsB/yGBQyUMSETDkGRNkHsefbbsBvejNo6L +AzZatnUDkaUGyOShULwEFnaLbxDsrCqy4JOlZNKAga9FjAdcIr9dUUeBwAkz9AJPLUZ1eYN/lspA +wpStJ/tHlKrsUd9HcBZzWUIwb2Wp+nIPz36OIaz35ZtvlCzahPmYB6l+9gJKgVqB9qgg65I5F3Pq +ghbPL4V1FBTu2EVYtKoO8AVMi+MCXOAwQmhSFFHZelVQ8ce4AKdFlsnfhOYksHgNhaELRMRX1MCd +ZoIXdFxGZr2GFHtoKcJ6ocjqMxmHIYWY3AJk2W26N1mSMBQis0YJsUNJgg9FecQ+khQnAI6GjjSy +s3PoJAQlJYJHS5H9q3CZMKpE5gIvSiHjZeEK0DgMinwAXk/Fs+9/IGk5EuGH4ck1hKJV0E2QOEgh +Ra7oU6SOjOOcJxkG2PDJJ+S83EAgWipYhPnjmkCbECcvYuENp8OwEIaJYSDDzjZOxocXArUplgVM +Aui+w3VjoRe7aOffh5KmM4FaHXzXDN26H6W5JYxOfKnYDQX1EcgnwxFwcvBMVtS3RDXCyWoiVVwy +KYDHWFOgYjlNIOJzz6sERUw85ay2pcEU3GNMQENwYxRGvFapJyi1iLB73soUsZ5elbJyGOUjS5fc +dMNNJeMOcgiMqJBlMk4eTTBXkBOShmH5zaiceAv10QrtCRTUHgp7Z02zdUaLvmroOQ== + + + HBqMupYye5h5SVU0IqEXkJbBBerhjQMFXsrsQdJDjZyXgd5kEisQ/6/PUpon8UgGDPULFLAc2WAB +984zEjpwCkapDVPoZ1D8jeO0ND4MKHNUAXWUEujALulZgGCv6PrmhCoYuDmQykrjMNEzp0bbsSxK +sISoPJklZjijsJjJsymThCsXBVJbspYgrItMhLYqkqBNUrIEXPxhwF21rEvh5ZMKSSC2OPWbch6O +TVRcmCwPhnwa1EcRNbRkjWyBDC7KL2jTZTswDI7YBcphjoIeN/qQNWGDqUHsPwjd5Ihs8RWhmQDZ +svRhAltoh5uQDRipBV0ehU9e7FQ1pBgydDk93kTR/CCHBs7zf/beWf+MnpB6oQ9DWXbIhmtAyxqE +BSWSM7CWXufvCcJVHTr6IEGaHLwgQSUn9WQYIhhlEoPsE4R6sETxjiWs3kZxv/rOgN2eowERQYPM +9lZq8GOKgJbDhL4ZJRm0fTLJQHgSBwPDg0rGWhgalsrHTUyZJC7qI/E7CMYWCTOEdEu6MZDmE9n/ +EKV0ZjZqcqaZOI6IArUtskMOCs5kjIsFTQKO5v/i5pDyUFSespgOmrA2COUZGYGnADGNCgIBG8EC +eme9DwluLJQTRIIal6kF1Y0CHtFKiecge/I2Sxdezx+qOl6aY4kSHAYXnQLPnp9Jap+9wBDdaT1Y +AurajEfdXt2+X5raSZZaLkktl6OWS1HLZajFEtRy+Wmx9LRYdtpJctpBblouNS2WmZZLTMvlpZ2k +pZ1kpZ0kpeVy0nIpaScZaRcJabl8tFw6Wi4bLZeMdpKLdpKKlstEyyWipfLQcmlouSy0kyS0XA5a +LAUtl4H+NHc3bBiMvqefSQKGAqEVsB9XQq+Udhar1vqnH7MVDxPQyUkGRA4MBWKhs+AxtDfLQ2a4 +XBU2tmj6BKZKUDtANEY5LXm/7xnbCRrLYCEM1c5DsQDTxq+EzuckKasEYqJy+FJAmYkENQ+ChRFm +C3S6A5hVz6FTvgpueNIaDxBKxDBUid+XEwmCw9hhMsJS0A9WR6ZXHR5UWqH5JMb5caJsylQ7YZgf +MnjMeY2SFmIC/mBWQQSInKieDblkdX7FJDbeI+oF90ApnhAkVDldZTYGGR5wNsyowrsLHlquka75 +kpE58XNpbgm2D8r1UVgAENm1gPe/Ht3Xb/9FrjREeepwyK+EzlI5VDOCd/a5hgxxghTXzwIivBtS +sUfCRSF7yViOKbaaNmssx6hjjq20tRKJCEnLXPLVgPge5U0ADq09MOAkBMGbKI3lWrOwyusT8cVN +7D860XUrJD2Tm0SXM9EDDVm4lFNqvERepp6PCyoLJctDgmWSM4BJKg6fNqzRQQgk9AYFTPFA9z4I +Wkp3BjkfiEns7zAQRIh1pDBElBcoSJgtBAjVvhZQmZvYoZeICCBSDAo+eZzyDmO25FbwBL9D5xZc +N0HM7CzNJYTxQv4NEzRVHsdkaXkiaQEn8g4GQjNvL0ClsnxAtDVwLi7HkIBnxBmKIa0UHEo9gJsi +JC7Qw1BbSLSEElQEqQaIUkGhUJSR9mDImQ51gjjDDuKgObvNSN4vvHjsDDJWwbqIjoEq+HBjkQ0i +0oZCY0auhG6t1erNkBGkPXhKhcMeDD39kC3j2eHKMSDtveRgXIhjQdg+7oETnFFYZpSjlAUrFYhc +owSIjQs5lijA48U9QCVCjCSFi1qiJoblwNGshsIPgEjQZFhuSTQUePtzjpyVyAC5GFoZJHcQs4+J +yM4ciGQX7YDIAnElGw8d0KMAOAZB5BzcQBLtYh06wDBwKrNB+d6wYr7ijc3iJ4PaKsHwbTWMc8pH +odKr5CUsEojFozwNdWDIOYz+vyQ+Kqx7ciJ+wfYwF2K3fAOxsZHAannsMqaR8uXBWnvag6WXERhB +4BXPEn4MRYipTgseJgKqht8ajiPEPuN1BUmIEu9hz9rBi/ywJUoNBT2IopRS7UVFmu5P1ZzwneLI +TCAyRikQyaaCRIfiNHND7oBZGIq9iOtLUiD650g15lD2JDoebI4req1BLwsoYucowVZANFRyR3ya +JEQ2Ua4QEXEdT0S4ZH82XE9yQzYaS6dwlVlABvGBq+hwhTruwMohg4UOBBsr4mXh9pgsq3TESiA6 +CFFKpyAzpKcw9EP5nUjPPnQ6pgghHScEYmqhmhAkKkdOBq1S5wX4B2Nls6BL2KStMaLgPRe6DSSH +M4gvE6n8Vfb0khLRYcISCtteJTGwPmUMKoNyQmRlwvjriIcTxHFRBCCwFQ8n/BvgZvKqGomUSpom +Q0saJVjD8HlpTKQaFkorxF/rvjhCEYTilZSSCjSHAgOsKpltcEOsSLsYY6BDoKBofKHYSw4RGOym +t1JID4gMpw3l4kMelyGh8QhOmeUNSh71VVD/MiVOY5WpKPwkZOES4IAmwFIsf05h7BDwTM57ECH+ +f/a+tM1u4tr6/ZznyX84kMkOdFtSqaQSYzxgcDBgbAOBMB13H9uNe8o53RDur3+11tq7pDP0YAKE +JFzuzQ3VOlKpVMMe1l5LLmhDXgR1ywKGNz313tnBWTjGsUEUUbFBeJvmVSJSof0EpwEq0M3oBLQ4 +eqTKliPKoeXx4pzpgjk4Vq/SSlPcfh9cEg8rVEAaWrg1BU0xmSrzkPoJ3ZUWp6DfNZi92lhxyrjR +m1qaH5ihVglQOKUdKEPbPJNgIIfa4FOV6OTRqMJg3KARzAldLVNtXc3GIMAHSWq2IG1U6Sre1kg2 +UEcr4gwVIxAt50INeQzF14d246tk7bgohoCWUGAHVRaIK9mCAiIhf8c2VOYamwARPrpFXUlxao4q +KKS4I2J6ZEpFThuJMzZWIWSLHQCpzjwZGRSE9TNG1jQO28F1qgkBTxzBHXZflsD7qm58PreVVnpt +1Ya4znSEG+NQymvEtPmaymBOWJGki7e26MvUsCGM6OVlCgK7WJkh2fopBKCUo2lMD52hAQE6G+OE +GfbBKtqKqiWUyv1OgqLgVBOXNDsrViJEKDOBDPrQ2RlQeuk4R6btap/PbfJGgxRZzGC4g5RvcSxb +0Q4bS6NA9k2QhkSwgGAa9QGIwdZs5CJF76+QxJjRqnLgm1WVXdhUo1GoFAdD1KIJcTgN+hVupynR +drmd9FU6VZKUAa09FIY740k+aq/tPrXhZ+x9YmERdi+64lcrHV8k3j5u1NL6wYkH2yTv9CaGynbp +RNpuXxd2Mo+eiEByoS2JlOVmoYA/XF+WMtBmJ1aa80mMjWY5FQZ9pHudBtIS1tVgIcVS3jmyAwZo +qkVulG0v1XHXQ00JEVhlYydZsEhDmzIQsR19LfJNd2YrehgRITojIMx1NQ0ZbJN58KSjGBmxTet3 +qN3atFOeunCFo82A0bbbDodL3+4skV1eN4Cm6cvRcFGcC25S21rQk1XLdgfnuYddaFXyGBtSaWjS +WsgSEcG6NZ5L+m85vtnJlSUb5GCDttlvsA2IzoDKBoMKHLMz0FSVFRh0VmtGdKTcJPBgWIy1cLQp +Eg1FtoM5Y8Q120ji425u5/GPrAuzSEO7pF/Q3uZ52WYuAdRYN8HdElPWANtLY0MEMUe5UO3orEWz +xNXQHLKpiBOdhh4JZ2GO3fVZKNFStNcxm6IoiVIpPDoC+Oxd/1wk/dQAtK07sLVozYusWNmQYLly +hpnBrMMMbeXmdYbJb1DlrYQKgbJ6Q+RvUmkiyVWZXQbU31iapBFF1BbxjFZFgTC5mBAbskA7KQ/l ++SwaYeRX3O2rRicWGAmDW3DOFocwV/I1FkfRIeRL3E8zIkOS2xQelzGw6aaYmOIkZamcRcyCm3DT +VRSLckGjAARoVJZ4NAn2IQrU1RZT71e338HI7aKJY+sORddZ9IblRjdzXKjkiQXTEWjUu7lvAnYi +g2SVEEhk0OWvWftpkS+TZlZcqBoiX7UfnGiHS3bX24eeEFeZn9i1lUWuGHXL7UaCC5MG+cShh01l +kco6rzZ+gdoDSq6NVZh8oYK39llLY2TBBKBe4RD0UyAblZWylVuEKETBh9Vfl95oFUVtKc/A7lD4 +nbEoVEnWkDe8Nto1s/hxpbJkZIFLoxs0bWeh0kLUQWgMpfiEu0xdrPnGaFSluo2bHjxtsnp85XDj +IqoDXa62BCu2As9AC2dm6ZJT01aScx4C31829roW8aHKXg6LE8GgO1QYkcLcLs94grpB6TSybYtF +B/n22FiepcgHExKTraYmXFwrREFiUlYPV23rQHCLfbfFyGOg8osCkQjKVLXX8DsFauMoZL6ajJIO +rKU+CrVqFBSh6lwv1CSbqPTUORdRf5gxfw27z0/ndgQ7CMKfq9GKacF41Yj/EtViQfTwScHfnFtl +OaQy4KaubO3k5iNjerZ12N6xoA5VCJVv/Wonww0r24KvOlGA1YJQWDl3SyYuJXrLTG8JWErLOCDZ +Ldo8VVx3AO00Fe56e/8v1hN+YGvvT/gyNX7zvJ6hBCMyFvSwtTKnUoXyfM2qCF77pDmL5DR9rjxh +lPVmGV5pkmOsz+EXzE2V5+uQLijcCqFsWkb8JGPJDKSXiJr05vW1tYWqac4xdmNp/qCUAid9FEcM +CcNjstifM0mw1oK+BtghyzIz01YWFGW7JQEQW5fni0ZRvBDukCq7Q0ztiFi2rFu7A+VO1ViL+gJu +UmGsvdjOPcHZDsuGderJknZM8Opx5rfF6LEw9UF7c6u6ULtDcD14tMNhuZvbxS2CahmE3If2ysOg +g4VOPlzLqLeCIeR2k5Mm83DrsxlMYOZElhKztvbCax9gJ4ZxuxnVZLhMzuVepWRBSieZxx2axiNZ +Q1U62GZqB/C4+kL/xcsosFByyqZWHFgWbA5dOSId7aSsDuyDjXZNWUfnFzaoT40scrTQdjmc4c4L +pfC2HBkiTlg8rR1N85Z0qsM2l7NJ4DAUGSnKT42EH+TlIXrhUmeErJUOfpE6D+eNKuoN2UGKgfyl +fGM1up/cXsvPBRVC4ZtDNAoyJtwsswxOWrO/4GbZzoDgawo2BZhLM8iQLRtOGYpXb5HTplLYBIlK +1wXut2oVe8LxKfLZl0jRZxF1V8JOpYcy4OOYmCws1srPOJIF5j50pVIAIS9iRIWTR1NcUqqNLojY +mOiE3QG1MPzU9M3F+It6fIFAyjxZGyol1Dq/WZ+jG4C2r5bOgeknbUm1grkR8p04AXyVgWLVeA3D +IRVJWWmWvRplXEVnQdsiT6wXd9djM6gxP4D4Rz9pQTYugq5qxIYczcpHI2uO7A6NpUQzglLTBKGY +mhm0Smp91gy6byl3FsSubBFC1iU6U+VAhAd3XNXdQNK1WW8EniyVL5BvM3I4QMj6+WyIrKy2U8j7 +VL4XxAO6Q5ej92QO8Y1MCSqbEVlvJ+WJZnJjW9Q5649OaxxS0UAEGk9/tINYyLt+/7J5TYkmNXY8 +6nnetB4egfiy+CgxhUm3ootT47AIik3ZbS3P01tQnR+QFHKNhRlfIqdCtyxons8KvA== + + + gwN1KvXVfg97rLFojlGoUQVW0Q6QXtup2xEsVMpWJfOoDW8wbh+K4Ahni2/RnwGeZzXDFo2EPsBf +Hk1K2L7Mo1EGzsxwlK5Xjc2HttYBiycw+0MVuaLKfUjO7oEyby2MlE1+3JaoJ71vUXsfmrw4MT69 +32vIrSCwjVRyndzNMvQQ+4sthxfiFyEXocGw7FwuhGmALeqRNrG0dJWJFaQqV3rScXFTBUDbplZq +pjbsFxg/PIXSZsHCwBPZLZWsv5FQjG5Fc8kdVVCRkMNV0V2bpQDyhWQ80mWWDVc9vAfqjfMj9C+c +SnOdvIIf9eshu07DKHBb6Rr3aEKwF25UDogMvyJiSdxhlsSmHWnjSBegMgBwKDWOQVrskmoS8ASN +MUbD2XY5+Yl2Y/VDLbBCq6BsIzG5xArL6CjmslaBMBXp/SVYHU0Lv7X8FNoGtWGLboAJQcc/djI6 ++3YDeE1kaQIVmrQ+SHMpJp+yyqSNGFyJ8RWm2WFfImUcoCt1JJDoyH8Dqat8JzCviIKXB1vjASfQ +txgfAnxuqfwBes4TTfg5heTIUSk6PLLQug2D4nbTYkGWToiYRACY4qultFzVaP5bU4oIxO4QkWu0 +vlWlgdcxx5Jl1MwT57OkMcapH0eI9qb2gIChKghzVya1SeImNaB84RiuzhMIicIvnaV6vbodcfPo +dbeFUrEcMDueS5Gp20AaSJ+T18JHqc4EMIgDBd22rs2rIMtZcp8V362qfTZYnBAX91ZbJ+/S12pt +sQk5boUrU/BxrQ5dcA+5MY52StQYraV2B9i/JNJGowPCyQvEsoXKaL3t7QolqOVCiiY5UUQymovn +7EUDxQ/dYXdNUjTqNa5jC4zge3K/5GCKLy4h/6I0VYvElo8OtBhSbamA1Lk5mkj+FA0pTJMDjdiB +koFTLZKfiNgobd/MvmeimF1hKVrKYujGEGUn7xxnpRHmpiDZEiFOVU8OSsky+zQ8CXTnFI2kTlH3 +ovM7J6fejtG1eHBxb+wYINyIbxIjoK0ZurT/7c6ItZcWf1T9PO8aGD1Dm6pQIDCRSovM0XDQ72Hr +KKAUY14vIMcj2Sw4N6sgSVhYOmVh3AbUK7Y7ZLC7cw+IX8bhY4VgLFuiURJIEB4yCuHtDp3pHPMO +0WhrapcpikWm3mFUP1pjnbVgcLHhfQCxV84OxDdtYEq1ThYv7EhzPJByuFWDdnIFsH3IqIJItn90 +rfZY5JcTfQUv5grAhaALUhtL/vPoGOMgBkKsh+Rs0sUg+Ugqy6DiI7e5OI7NpC4DWNie2aCKoNlX +5dnHK4PFezlb7A6oUFLNSs5Hgo23DK19eJOpSckFnRUld2hOvzIdPgEbtSryyggut0OhdNUwQWuq +i7a5uxwwfC+RecJwLfPbtaToNHPUz2mkwHVmwEMUHSh3CJNwQZwiheHUEZsts0b2OGI3grnTBhFM +xBIVBpXv8vTDjl815mY5iyvDmELMoa6DTcAPecakztl4tourEhyW8unYSHxvFGpTdyDYyNIrYKb2 +OwTjFwLNlH8g1IW0buRG448BdoAQXpwMZI7NZ06/Lzbm6Bm3MiZXU1k80iBZiVzTjQcdy2xF1YAd +sHYNob4qs7cZ92N/CBj6nWeIeJwRbixGR45qUBSFrOvRkROH6KTnBFbbu9xuvNd6ppXhcfGodzGX +uuGIIvQvOgup9QRIpsa4m8c96YwJi+2146IT2dUbOyypdTC0l4W1I7d210dKoRp0EMDx3Cw5E/Yb +sbzc7tTbleDzenlLM4KAqfC2mokgfoHaHWi09yeqBWGdL7B2maGstqlGobJwJSsU7A6FY0JLKth5 +SZ9gKMz1NVE2Dco6KosXtdmcICfhROzU5izhKDS9uCQheq6vojUgTsgpdtpkKVn4lYQwWraSGGaG +xgooYRcaUiyOUMeJcjdqrx2aC6YxlnQKxWKWCFAulrJWkshu0L+N/H80B4tXs7kuDPBC0PCovcrt +YWg2BCjF/cSdBMGnLlu90iVAo8lsUlMnd6PVfLTmMvcDKMFoNQw88of2qh3XNuT2Mhb2zITCmNxB +kRoxYVM1Q7MX93W5ILMxCJcAeHXrH8A00QjlaIcvWBRuv0SRbYO2qpIdNjDPYN+sDF9gJMQ2g7oc +6jM4g7qGPGFbWS+cRp+0tqqDYLGPGalRZFaNoRlu+nbRGJCkMBR+AvVMag2+VitIAiJSqTohiOf5 +WzD2O7IzuUw9lkvj4p4UIugbQyfmR7oAZcbuwrX24GjOspG4M5WGXGc6e4vuHOsOmYn3s7lKKmqT +O2eeLspmxe/Zr1crs4Kj3NXKjARVueUgAGeuUlG1XQzQPiHjnqrZkhKCIALM2mTnFazfWdBe1Zxg +5yMeiXtfEG8hGgti4rALMzJt/nPnGvWMB8pLRFFskE/ciNZzi/6zubTmKNsNkkPvQc8nCRo0mgQH +5Ak688qTAiBsJOlWvoNqNyJd6danPtq5obG9rkbNlXJS5o1Ye2vlDby9CTVUADOqd8nTR3g94+MF +41SZ40IULqrtYtJc3/X2fj+1dtqaub22FFsrz9/aEbkKfjyaDV4GLxdEJk/Mz+hzv2caVzY3IPuu +VZZY7MCUqABEK/CTMhW1okNYg84TxyStTe3gTPbA/ABJoK6F6AWVAFyaRQrKQatMLbe94Bpj6Jir +IgsCIlYh2QisZT89ghXoqdGiRtR+inZK1NlkQ7CjaYJ7dXYkFs5QRhEc823hQwaD7bKmMa/7fmwM +2sQC07veHgtHIFJGcWhXlS7aixBH7ZZTKuhK5mZ3aVqn/USjoeFRn2eCA9iAjJCLhAKjbckBkjTl +833tXGF73uHroYrLOMeH9sJDNWU1ehuv80tjfxQKRqLUjEZoe9cNiBh9V3eX3VV0dSgUspvxaUNn +WcOQC0XY3nl1JK13a0w+SpVSOrhtUTmhGfNYOdTI0Bx9EKu4wfZpugqIk4vTkjzGco4IOR0CjcaM +h2wJoCJ3ff90ZjzThNX+aUnRJteHJRLdOmyW+hQ5+leWrcFhrfQIq49xZcUYjLaQ8RUvNqEemG0a +xt7JlJmpoYLjUAX1jCMJjksZCAt2gjrWw9lRxUJ0C8xOb6Xy5RrrKnJCEkMIWzoQIaNVUMst8maE +nCwp1NGQt6JwS1aBh7jwMv8m49WQNLHCcvAEW265s/9Kx4boCt1BLrEgcynH5KtMNjkwMna1TxEy +9hsFQpO9u6CTx2LyOaXvDuuWkjHBC0DE3UpVo7J2YHXO3JMFofJaB7JO3vW0izEQwBKVQVAOJQVB +XPFbjPVbiR4BzEU+IRFVjJZlzIdhdjxZ39B4tqCKjVXyxFynhHb6dbxDZTyapXJZWsatbI+yNHkn ++uSFJ034btLWY6SnU/IJh2JjwCzTuifZbuqskblouwPniFWFu5MJBJaMe6fYUz6IqaGUNcftE9fC +KAiaZxlNyogJdR5F6KAUj/NvdGB8z2q0mEfR2mtLyzPA0VnFRKm6Blw5QACYfrc7IDuZrASg6QQN +AE9DW5usdtnYHVDaIt6VStuB3aFyCR9ckROMFiNEYLC17HTGLkEQd3iJNtuSJCvWYiNzaGcZMEen +oaSiJPl5WVDPOKeWCWqw1erqu6yIoMnnwuusdYu1O6VZQrp2jbfKCFjventVkYgEudo6DM0kQ5X3 +3ZU5VxucdqSyOPXQbi58FGdmbo9t7e32ivBlZOxCGsdkXuicJOsIqSCs49Fq0dkO4O/d3M5MGNsx +m3J73fkLcYnldtojcvmV6qPYaqzdg5cv0jK85F45FQvzEAqiz0yOKjWZRVdOG0QuUsBUoxLVJlCR +k/P9YFiSy9WjW6I4OI9KTWpLaXfRc7ajeZScQBqeqUN7Mb2sogbeq0qrWgaxvaQxdoKZYloqKQf0 +UON1cJz5Ay7TUK0OqNIGEpX1B7SwTYY8L0Y5eED2bVMwdVkE8UUFjNPeJzhgao37hV2G7bUkKC/V +XdIFCTJQmLEV3W7kB6qdjpgQXRvecuQEkuNziwS/XVEab3DbNC5ybuhiHBtNxgGMlLxbZz8WPEka +1TgUWqfiNauRLDBlRmGVqiMX2ic2jsnppzlTHbVHPtgold3OVHztDoVz3EJkU1lI8MjY5thlYnui +mFJpz+oGIAtSQeJT7wYgC9BNZW0l+GQx3iIGyQC20OzJthvaY5MMr5+BZ4Xn9YB/MXhr9COcAZIu +LxbE+5u29Ik6goZVsTYry40OjnrMdpqGbCmzOIhqAxLXunlrWpX4nCYjFs0z05XGsQ2rssnvhtBr +5kooDc1KBjEBhRqpiOhbWgEJGnMCu61bF7IlLkkkOSg/U+UWDOnWGOMLk8DEnB4CfMAsSj+OtV8G +pwlB+xKdL+YGt6hyZYXRSBIld+FbJoVDLoLO2Di0i/uALNoyykCbPPAbGbwdskNUT2TJdQ5N4+Le +ieX8a5SQMaQnABSlxccrJewA7A2xtVKGICgLqO/FmIUs9mhOwMRmFT+2RTM9KBDDoudImS6pmSHs +0AULZlQoVdAdcM5RIYIER4YSZ3JUznrhwrVoNI2Lqhiq11uybbXWbLoTAM6aPCxiIKYmA9qkojQE +UjNABxFtFyYBjxBWglKnZmM3woVuEbzbSXEFuI9Uje4gAS1a6W0m64BinPKv1Ce0l4uGgWQISYls +iqdVhdEDMAN60+9gA1yMyLmj1aaxuN8+PvtWOWfAEnBZwpeYKYXCMvxEkqwDw73B+ypnPmDRXLZT +EPlphTavVNFjs4ciy2abGVONSKw8VVuoLpLzsnSkQJND2mjPXOCyzdRo0QIkPs0Iq3K9EvzGNGgR +IVlT5DNKixyqNp0fR60y73hjhb3kXI/EjMxSxxrvMoINUfrUWtcs2io1PA8IWy6mpWJfMGxEavPL +YWJL85A8NxlwCZxKUvF3oRjSFtWaJD7GghlVeG/gabnpnDbrfBQHuT2VZn8SSXrX2wWIIAmYUxNU +0jQesT5s5LngI5GAVLaDiV8gJcTZ2EHYIFhqMyoF0ME66SydHAyzcmZutPR6jGjM5mosm87SoNHw +QOtduOmM32dpv2/871eu7x49mk2uz08+OLw3PXk6uTE/XTydPDw62r9KGsv+8/zt3m9/84ei7udM +bwEW/f/0ntPtYvl/Sv2l6F3afpW/1fRHUnOzKqpbVRHr/ucNWDHeKoqzZDgGaXt26Ct2Y7b7Ffp0 +hmjGJnLzXwnKfyUo/5Wg/FeC8l8Jyn8lKF+/x68E5ZOtXwnKtZX/VxKUv//b35S9BXV4dDjp7Z6z +zaQz2v7TFdLuz3Ynt/ePvpvNN8iknUlX+jx07ThbCoorB2BIkJc/8HYebn17Moo3xuGQQk2hNQEl +NDZWmBRQANa4UiGqzJiq7tujit63qKklNEkA+2Bt5VWlTeOAMirA2XZybFhhfKxr2TSMolMbvFXJ +ik5TowOoLPyg37cZ7hSja1SjMeaiDuN9Q6MVVznuL99BWwVO8E4EfpBpp39Ca80rAQ== + + + W0u4UKq0g7qW3QG4ptZFUAUvRfS1ICozgjvVmClJ1MJYB7y3bqhSQ/EQ4w/Ugc+xfdj2Kk4mL1uT +o72JHUZUUWksVsoFYikAewku09RSNrIxs5Oo8y0GgVVcQhSLj4+jpTg+OGDtDoAoJAfitEprtq4n +zexUv8/4CAeayZVVCu14oqShAnfN0medQ9SjogmOIid5jcwIMBMWcGLBCdrxnIVqxQNSUq3V25X9 +AYRBCzCG9Imw6ZHqJGArL/MNoktdB1itVoiNICTzy8GREZrqiiIHlujJg77NxbilnJqSnlUpBWmt +pC5jxGDsKR6NPJtsnXIowcShK/BZmRSU3/FgfyviNwTi7G1gXJbSwUTENXn8ve4YqGTdVU4eNySV +QRfKalwgSjOdKwfZS1N2RoWYKjdgGRfKcPR9C5IVo5JrnkMe9ObLGbdXS41tBniRkrFVyoouLl0E +qEIO86wP2901x//U889yZ0IyzfkDTzkKFI32QuA3ZBFZxcFtqewqz/cpyBOY4csjjO0saQq0Mr23 +VBdJaEagfKAF0BPqFBs0wqvMlblObhpIbFjmfF3fC9orgVyqwTcQASUCJeka75oYodTf6JsY7BEG +y/FyOfHZSQeub6zcNsLwsBSXjcwq3Txj2NYHeIvqo17uXcgy1egGbFaFgf/9FShKWxkA0GhkGDBW +XRoq24DA0ytULpRJS12kU1RhlXpwzAye7VDZhpqCRvKKt3OOQ/s2KrTxbHUPhHEqukftt4kWQhpa +5irRhwq5AS0lIpHagnnqXmjksVCLtbEcEGwakk3UELmzslrkXxQOhOBslObebU+gMGnB6zEvDnJe +Rau0rnPvUO1QVjmGqTRmDJnk11aP7U6NyiLZbhVXbKwqr95QxRVO50aOKfTF8+6G8A0jcHUjbost +0RcIk4kKp2A3rRxVWQehA/Lb0V7ka4QkO/rAp71cVgydE1vgsNV+F1oXCacLq9fAlZ3Lj7LUXeyw +oXEMITxBE1ENjXgvNGpSrew3C5rtukEd3Zrn923dyQwFka8MQzMsxmHXFoacCfKNeYRYVk413yR8 +JgRBjaERupoCHbWEjDAKRDnx0AwjhFL/1vdB5gXy5q+zF7teJ6pd6tnzqKdUsMFVULSiarXKCNN3 +BOqoLDtdV12OlqLAMjC0HYaqFfBQKYAGbxfhiB0HL0khvvbScfUhCa1VtqoW0ltYZRwglUjX5ReE +oyYeJTi3yZnk25Qc3ov7WGgiOSk+AuWiL+WeRbQoTwocznaCFEq8coSsqBfHjfBSNdP/FtepPNRW +NXLAdhwa1QRmQarWHUsMfFAWJIRsPHo2lnOIdSs7foJY6Qp4+1X8hxOkEcM9VFSVeASdubgHKVPt +WwggK+JGh0lo+3E/YuSx0pQQJaGGi1GzkZzzbUetNFpk4KlJzmVPIVztfEgv4Ol6Z1mFOLmDGRWl +Ctx7s6lVtmzHP5FxVRVhoFUILnQMqjMLzgBBUNJfKwuZ/ztua0pZFfYDMZxqNCh6GZ2Yfv0d8usN +ZmFZCYR34O029mXtJUpE8IhfqorZT8DRmmcKk2vZSm941NcktSncpK9VZo1acSNXWu/DMPqdbVA4 +JVnNc+Cnp3KYNC5kDRFoBe9c9oIKG6A1zwkXwGAQgotAgQCPXyWgLEqQCJiEzECxzfbNfvEVPL0b +BjLz3KaeOb0oB990ldgQzLoNbj16R02QIa8vZoBoFjTRWBEKE5mmVWFiwcBLyLxlMVg3Xv2lEpQ0 +nGivHvic1SjDajG9WtpjnFoBXPGqm4cdI/ZimOmEPeepFUjXGgjXCC79To+RPWlsPcIRQkadZlOX +tWLh8+gwRN9qg8IUFmVEW+5XaUQ06Gyo5WfedgOQnMz8oGTDOXAHxwa1HdCNqbCTCMaeUYRh5ZB9 +DsZiNRKrD0J29u2lVxJy7dExhXPhhx5CW9wZAlxcHDODB0nfC+1WIEsvljHrwFi9PLdKRx270A6O +OAhRWSuD7rqxAN9YjjiwS8HoXjyQQ8M0VqMJAENWvUM0C7uhBojgPz20yRl6OHWpMdff4RkN9ubO +J3jI4t/IyQSZp42XhhKgxi0LdrMVpaMPtB75LFqUw/yM+qDChaJs+sDbEwPtxB512kcwK5U5SqXn +SlpfNAxVcbfO87PWWQbuYTMEMCuj0x9XvrVnVkLSPw/bb6UQsAqp9K2AAhF+i3hV+ZxLL8EPNZgX +pdertFZscODuF1lcxU/bygywo01VAVrwlF7X3gle5y6rv9c+FBi3yvaBzkgm2WjmFyPAReedK+ph +gzLDjkT/sp6RZxHciloFmgBd5VyQJGYuhs9HCLAcfnwbLFzlnwHhTa46YUzMpFhRUAaEg2KnS6xU +Tyb3ELP2HK6IrECE8EfngFgLSsJPtToGhJPFbgcbIbtfaKcdJByWJcUK4z4QDisYH0stN4Y8GWWV +b0A+P2OeMo4g9Fb+JuFAVsBUJFfUwVxEssLu0HkNHKudhH9nIrC1vKjzPpTN+A5wEM0AbF26BdLw +wVhPajdv0qh6J4u8JJOA3/EPYemTlOMVTOrJM0SR+0CtoySJEE2lf+XT/KEFvUhGnq8PjdxJSCYY +00a34CqxfuM4ajo/JBmiEevXEGfrMsdvO8rKVV7t32aiFHLTRC92HOFFU/Zl2kLO7V3fwQuT9zHo +ljbrUDhLrzvgrUUvVeQ+AJpJcB7GNe13c9QheFE8ORtyu9GdE8PnpM5k3ZJRhBi5QU9z3IC09eZM +QuPHIvLlmDoPkOuanxfpsVxVpehOaVzq7ZCJVaIfO6KnmRC40krlYdtlG7xx5EuqMqUM+Hqq2qYY +a8ptgogimeukHfH1rEyNs+JA8MhLlfJbEUwOBdjkRUWuTZg6G43w2UvjjrMtjP4v2ccymJMRKLYv +wSANsEjPOHowUMFwhBNc14c1knw5iFaVOcYAYLX4AllypQ2xtdxv3wizuWnt7DQKfzgzmT4GeFvm +vNnOdXXX2z262Gri53YPqyXV8+R2Qw7DzTRzC/fo7NqRph6o+Sqmo0YdhLZHGcyTr40ICjFUuR5I ++WTpTsYC5DFTfKt2AKmxV9RVPlJjLg6rg04iQ28mZxUEWU6TAeJ148oe4PYLqlQYakjBu2KwaJRY +EXePaUFeFoscFH4O1IPuFIqbytYiUFbL3SJkQXubUIdcsYF2C2nGSvm3ux5Ko0ml663cAYVuNjsB +/7YU+dpU3jkX9WSZn/6An/Q7JnI+rlAH6z2SRCJ2haqRDjwyYXhLbOnRDisDtPcX57WdiC1EgKQh +h1iqhzNQKjMN6xeDB4R1mjeFOYdbBtEgQB9Hay5UVLEIUaP9pu57aDLrpG908A19bkLDYteJxTZv +zkRV8GlMrWsvUg1CUxKE6JRkYnFuSjO9dzx+0W99vDjmkCBKQVjFhzdzpG2qrN6hAQgk5VQFCukb +uDVNYQasORpkcGqKILJ1mYdiZW5wrhXD9stEtrd3uXag34FKNVaWCmi9CjR25hbczAmXtm71OPWg +pYPM7ibZ9LaLVE2nFyuzNUJznXWFDfBDIowXjSE2LTQSTaNlLoZ9DC5POLsDpkBdaRRagzgioR+x +k2HmGIKdvFKk64WEF07QHfckrD6tG04x8sUTVNa1QuNoW6opVhARXRtOMbSX5NLo4mgLE/FjJAug +ZaLgsZM3orO3veldENUrb2z0r9BhIDQapoRXIyQHNsMs6bocMsQ5Tnpd1iVpOjaeSUUjoTnmN1F7 +KrLsKNbDhygJekV7dLcXjNQsngGLlTfiZoTnUUvPiWvoAtasVk8xfwgiZzgM8LfNMUH6ghw5EZiK +lMJwh9Ao49jlLRT0juS0jkyKyB2T6hk61hZis8kZRGVoI0qCLUqOJaFvSYe18UKWWn3A1Byyd6k2 +iyQCIeCRM6fBRcfcqUTJS6x9JAdhXPJF+kgGi5Ck2lQU0Ni0FtCLpu6FRrpkNz16J4W+iCUeW3cS +Q8EdEmuuaH3Ts29BiQ8XYcZOJFkNvJ27YXk/bi0jbEGiikXp9MWb7CWASJYbJ6J9lZmv0co6uHO7 +VVaYcE+kMZcXBfLpgUD31CkPYP1l2UEkU6MMFwSKpHwARE6X3EIvJvd5tIQJrM4J7tcfLu/6VNGO +xuVVZv+6JUogaSX5htZ4YTyYp6JvcqI6x/rmVMp7qr0Nqkf981eO2e+SNi/7oizG4h2Qe82h145Q +7Hzk6LzRRhu7OD6cGlEDdkGAyhwgC2TnxHjkx6FAivMS5PD2+RPDh7WWYrD8j01N8VJiYtl2wOw6 +979EymtbR0YKg+AwFnjOPyoag6c1Fu4GYWNX2hd1xk3KLXHFIVvspgxbtddWw8ECsoho38xMcqaN +xZ/QDUDWB0DZXD/OkJKVKfDMB7poNUy1XNqD1faQj2aMT+JIMThf+/D19se4MR/NKuNcupiUJeXK +bYdG60O+w9CeS0aH29aSA1zugzXmaeQdXrp4eOV827Vx2HHxVe7ahEl0FrY8WG8PxlCfXMILjUXy +IGkURa+15RywZJ/GlzYKli/fc9zIDuS3G9o9hzu6a5XxlqMeVDmAv9zbpYuH9xrddmUQhvGpTJmQ +Q4eVdLDaHlTfp0VVkKUajSaOyHCqwjzemI8RYwMbX4ytKsaV2w6N1od8h6E9HwLDbTPz2LgPcaRE +Pe7w6OLxK+fbro3DMETBz8lk8j8HOY5sO8SA+UyGcWejgZ+Th6HQxiBTfj+RdOoGpY+Q2Pb4NNu4 +sF1VMm7SyghZRRnVf5JvyyFf3MXcrUgId0qyCoZYOI1X3sBhzEGMyHpanRyCsjIKGqDNeL4rW8AR +ApF+dai6uHHj+s7O6cH9oxMi8ZZReOcddYDKC4bdiTDkIFv/EilCpiiaC4M4sD5Al8toEQAhR2pM +RrsznBIqCsAd3FgKZqjjaSO3RCIkXNv5lEghH6JVNt7xNJHwdFU2RXMtMRpHVifLRep8B9kDSGew +LpVP8xN0dRT6Gyx+zA9w9kGDMuRQ2b5EEuici7ESckC4DZKOtIzq50djgpRGUde+WQ1gM6M5tTvU +nlYyFBwBNJqVUPyq/ahienp0B9lOVipvVrAOauwz5oe2yY90HGrdcIfWp0w3pIqRZipL2wDp9m4c +hx93EdgjZKrBc4fnl4faV2rnJRH0SUNrK5XsKj7+PtmLUU425W1odAekA5M1OggfjQrnLy8X3kG+ +V+dhej1Ox1Nh7EjqV2EWsW8W/hI0Asc3YLm8m8kec1sbhp9vu8H0q6OdGmk4Eylm7EeP6b0xR9hp +qUYhnLRUBeahO1wNeafC6N3Hd4Cagtk/0TWasNZDa8EggsGHG1ir8bsygtEpLtEMgNisCNAZFnhn +eAViX7sm476wsmzDa1zBbMMg/LjbjUxsqXJglyMbzEEOwqfaNmA7wOgw86zEpuwh/2jS7GgcomNo +T6J34w0KZ03wTaUc+BUaRP9bM5eKHJRBxkLk5NiWzIPF4yghikY3itGxSLYRYGHAdg== + + + m/0H34EqIejUWFE4A49jFnTjMPx8G3tyJj4uSKCBD9bbKbKjxliX1mj0t2jsT7h61JgRLkXdhZWL +UbXgF+fbjhvZh3wHa+8KV40d3dY95aU+jNznpQ4vX2yvNr7t2jhk8w95JYVkEK9EuPhgtX1pKXmT +H2aE4Cv+Y415Kbs7O7q4NNb18U1HjdaDnAcf2kfbwchL7trVPlhj3g7advnSpdf1m66PgYanMBdV +eykLHsoJENXaS/vNavLdb7fo94o0ADFSZv0OcgaFCxXtjpppoX5bJwuoWvoMpUhk02ygrzekYJAc +rRpFOfNHCLbLMqbr5kPtigdAN8dipDhjQVUoZRmtUGkClYydGhaopSCRhZWBM8uRT8krN0xsZz8/ +1urtEL9oqSnCPSXJgLE7YMC003ZKam0p+hr1DgPdUdNaFCYPoyIFW0z2FXYy0Q7LWAQP20Qvc0IS +0bgPgdqPlRdo2iGMdOKgRINNjaXlPLEc1xQ8KIoDQ+TuLYkxksWTxlGwTKmGo6jOuEHfCBsZy+pD +SSY9HjmpSkMfesvEwtOOXmXWubMhNnpbIgwtcA9zO4zGB6gMjwfRVzjw3rU600FR6lDHyi1YRBZi +Lmu13Aighc7tTxiIHEd4bgbloYXqIWY/KVh3KM8EyIZqicOtsxgopT51WxZy87ZuFJGeS9HSqGWY +A42ky9bjrDiD4Ajt1lYZYd8+yeEpZDbnt7DkE2u6Ow/ZNcyQMiBudDWJ6Nlq1LGcTzJXO1U569Jl +0yYNMEBSrnMLb4dkzoNsntR0flvL4x244ZnkfcHat3dphycWQ2DdJajwxJhVT9Eu+nhc7NjatvVa +ojblqQnbVcsRNmg1hOZbg/2p2zmiaAZdKgY/A8IhpX3oMFBUECypDz3g6wFtkugKZYYrt1XEw8bC +o7oe3cHSL3h5cxYR3DXPALHw3GiqtMA6jSS6sA8UNj55JKPnTtxH0IZpQSOMXVuOPlPT+BfEwYGY +qSHPgJ33YyYmp1jzkGkSeESbZlm7556VcXht4b57adW8TZbl4BRTjAM9sMSOfbmb3oPeSrQeGAwI +tw1KbyWSh9huHkWoCGd6oAdjeWoyU8JBK8iPSW4YE9pQDOCzVOrCG3Mmy/IGXRZh4G2VZMAmZ74X +eFzIZUgTMeaMIsqbzHDMKaDGSLHouhqPWMNIlfutpRy9Bx5d9COwFkAphz37Y6BSew5NRNuMcdyV +EshiFInJloZshbk2KLG6qNPFvnMzQ9L4OR5y0Ko3jBs9i455voMieDxITQ2LoMzK+sByni0GUoYU +M53AnF9SysaPYrXVZEpripz2SCYL2Le1YhbVAH2E4Pp3v/3XSlZ/WPXo0WJ2cjLbWDoqIwqlo/3J +AYU9M6Kep3QU2EfBH5Jl9Q/cVIxVYWRXViZKcIGYxzrT37ATwvS2WxGRDrZ0EHNCKeEQ2ZWEC0lY +u3F3vgi1sVyNUgrIg5ZixDcJGttkeEgRy+d7V8iV7Y2qP3JKxYqZujZz9GF7ELk1aFxte0DdjAo3 +kcVLuSyhDlYFgaJJoztGaYsJFdFXtuIYQKJK05zk2WdJYhSBV0Zl11S+uJ2ashgS3UHvwy9B+h27 +QbStDxe3VjxUexEc1YitwhM4KPHptktBBOBooss1GcEM+mt9ANW7gYdJkaoK9YIVCTt5f6krw+C5 +NCAJP2tjl/DDnsjWxqgRRqNAQXWXMmDWTau1MfYHBCJaP+y1rtnZIewJoEFbGvjVIcYwV8XA1B9v +GfsBTzEYgnKEm0hGLEAEZShbr+OrMmjRLVMk2KRahU9hhNEP3HqvBIZKxgF94Da5wYiwCZtaXlOL +xkykBjbG4MtTzS+lsstcaw2WBb44K3g0nk3rVTgw2SxYBIhBlxzgGbP/2zSOfoRPajEIcB6qJCnV +oiO0yWrY3lZrM2MiuppyBVSDVGioSc5DAJBCWbrHY7wRzK0OATurQRVbRVV7aKgw9sg616/B8ixE +cN4ImrWTLUtV1rUpl9u1ub6P6KLa3TZ5XSQbwuDkoCHpLSRiY4uDBQ2VceyR7NsOslKCYRYkyq42 +62ClNuPRHFjmBAePQzyVq6jC1i6H6d4aOtJIi7kCYhZqBHHS0saFtHUjw+/BkGkQIUZiBj47aP0H +YR14MO4GIlxk11JFzERQMag08XGUNdKIeOCmrdhvYsagt1kbAAKMofR6CBXEglqlK6tyaW2Ad4+s +chkMw9CxtlWx5rOxIF0S4FYSzURjK5sdMG+zl9WzGsFfTTSOy4HvXwaGx/lcGJdiZ/RoXM0GcA9G +7ajNNmaAQTAMAj8+Kad1WxJJ8XQwKTOiR/WZOooMj/qGLE9nxQUsfrHa2lo4VUMta8ZDuDCR7xwu +mkMQKy8YYFa18Pk6kDZ1XZaLhz6G4DpAqgfjJE2mTIrjiCORuxcHQcmkSKGVdza+wZEDInplvGFn +wUlSazFETmAyehDun7FiRYhGosTCK51JVgcIctAin2rGbAq9kdHe3zgoGFtcsurnwgtdQelvxSFA +7UnhtLEql2HOwlwIRgpETYg8cVVPIjJxc9OiFKZFeFVnoz4J/t5QTqAedk0Wp4gf1ZTTsXOrJwwu +xbC0pGoyIYzmBkIWnSPa6ZMZJL7MpR0mSadaABmeIh0V3xvkZVU3QhG6cgTaLzqWtHTRYai4rXGE +d10WFwZ6WxWCncmdDHtJ5+c3aQjaHMtA4Xm0mgJnfIKYiqikhh0cQKhaB0OyML9hngrLxokPt3D6 +e2MK7zJzEAsbTcc6bBu57Mrg5Z0qg147aT2VGY6O3pVd6yR1joaqhceWeFOZ634QNKLyHzbGzrMn +jW8/FK4q3fUwyVAUzZpW5uAZicWaDHg56SDJOO6Ohet+MiomJBPqRYtcE2TRIejjNkvT2s0JiaJm +QA5IIFhvBJ65fsSceIWk5/3eX25nuXrTJABJ3QDqA3NIVRg5mUcvIF5eBtMqMD27ZcsX58zNkdOu +ojV0OzXOYYkdwcm6GxddQEfEASJtNKNxbh22DKnlul2ekhSi46cZVZKiXXyDoXARJIaQOPsiVFGM +4wuuBCtGI4r/uzEOi6QpbHdvEdBG1gaCPqUNhplNSM+1ehGXaLfuVcY9gu/SL85mgHCIDg2UiqYl +Kagj8+zoc9V47lg1C/iCIyOtjUr6sD0bnLWzu4Aqvsk4UONjBLVLIZ0o2+wtSzX8yU7K6FLkkDwy +iQqMWac5VqpcaItECozFSQsXVpSdRZURqWDRtUY5DLpBY+wyMijdwbWZGyn17fh5yHJxnlFuJoXW +2ERgaCXjkA7JcUoo5wptuekFy0bJIHvBMpPbl2Ij3CL5gy1/QOLNuQBxZSHTbvWoBBuGkZa3Qt3a +SV74UddYIfGWyhFqEZ2mDP4BD1Aqa/eTqnHPjevfFHaSr2gWDEgRGFFClaKDIVyVUE6qtEXfLtrz +yJWdTRjuA3SWgnPx1jZM9KCMdA6bQ5SwaLc94J2hRdtJXLrJsxQM0+IBR2VkO0wY8ZYz3VOMDjoQ +KUi7w/+kt2Mxf+PtUmcBaa77ViHjOsrK1EpYpIfQs7oH2DqrsfC9SltZodTK5sTjgTz+fOvTJtRG +LQc7j6m6A5/VXhnYSXxhi9TCQl7hwCQn4hb5T8yrRUge/omNXvA6L8YPtS+RqqqwRo9BhcqHAi4w +eA/zytK6UCGVEZDjvKhLD79oNwi5vMdjMsNZGXvbwT1Kht3zWcmYJNtd+gTmdeiMT9QKllii1Sja +gnBN0w4Viv2519qyTY1Xk6RCmplFrlBEGK8TDWOrOqehe63RzeWTzrqXpN4uRWRJ15PSQhs1qEMb +yaeV2WUug4p9zQ5KeKgFjnhkil61qb0nJofDshjJAGOClUunbfZdQlQcIzvvdjqgwMcYt2Dj8jVj +3eRKNO4BTIfU1biiAtQoSoeAXMW2IDDvF8EPHeO5jrWRRkeSQ479MkRURC4bCnm+uT5bvE24uau/ +wFpP/I7BUjuyEORJUETNUmoP3FxxdUezrc1ErVw3knxYwn8yXKaqxlbR+C1m0pXPIntPVY8gbUbv +i+OnCe4mWowsFrmQIp9o1LGoYr3ByqLUeIij4mhTqUVphhWVJLcM0b3O2DSIP5FEQFYxWxlXOCBx +oB1qMhsN3LWQNz9jga0LSc6Ot+RWUrzDrYMiSaohLTPODZaPyJFZHWbeG8Bi2sLrXLOOslHZ8v7i +wydLbomDxhGpBftktlXLJRORJ9aClfQ5oY+KiUPL/RCFpd2wltq2NoZKY9ZJFJ9qrfgzpVIBXyyr +0rR1PK2U88fmboDir8p046Trra0qvhSZWGI0vTCqKXLB+kINcXSI2k6UnBAfZlFpLo9TGbK030Tr +SYzeeKjI9BQe6B2jkuCSSa2cCgQyYkVVG1m+CQ+ATtmomACDalxdsuhK365zaAiUydor4JBlJchS ++hMyb0zxvaxNjwON/NxD74It3proi6L1WvnoAtfE2UqACh4JMd6IfVFm3vbDWHlUOPMlJmolsIaX +IOosmNV7vpUiVxbdoccp3SRvzN2rgLqvLVxCQVB1LzBcZvF/A1pAMq5JiiZZ+eMWZThNhJkMhLmK +HYa2tI9gdsbSdTRVJE6frtPRU6EcsO1GR4m9IMQMG3OmvOqxJILZglJWgsI6+NSaXHMaG2nUiSzF +nGsqLzY7ogMKkO0STwy9RGlKlG6YpEF9ojCG1XzvPK6R36it/dsmN0gD6tyDu8pkpeMh43hYsApT +2AtXUkRsuHkYkU4HpCvt5kSXlvIqTOGboAJVr4xIvFj+VLn724UNlmskh1rl/h7qX0lVjNORZ5d2 +RFFqxLpQSGGLMblaVntotCDM9Gm3dd8g5nM1laZmGlXgJ+u+d0/aTX1DdKGNa0cjRWz54ftnm0Iz +QmfcTpa8IJxZ5ndFcTwPVmNpIr1U5ugyYAsGonkySWRjW1S0UOiMUlWtmdzBBBkxrUkGNtwcU1pH +sm0NB/7QTiIsHAATYSmtMh8eqXsyZetzhHKohY8q46ya9LXr37aUXunM7bGsJgYzSPMvjha5c9Vg +iQ7lYNAY7QrJnjWe28cib0u9daswmu4QVVkJCZzOfUismEDe8cjDNPkStVhAiNJe0sbUkpOKznBd +jmY6OMOEvvTVe5D3pqSPW4voTJuCi5GbKN7S+l+dTflghUFFlJMZG53RkUfwDFixCQWd2BgHavUU +PSgETYyBpks6HngmyA9TZoUVbVKEYlERHEjab28evmjSBkttZR3CFCqSG6SGukXIVGGGuso6VwiT +MwCX7dyxwSLeQvSFic4c1CkqGbaDNh89Te42MWQMbe3cGxGCXG4E1tERXk4CoIXIednftJb88WBL +Yd8wIMeDbDJpgkCIAkQTtsRNV0dbpMkr1bXR7IAjl8I8Sy4/eTC7brTh+369bF7ilGnL1pRvokKV +kFyogwQqu2wK5fkIT5malPnmUFHoyjSyknTzOujXIhMyQQ3IzldiMsiUyoPzRZc9hQ== + + + sWHsgTJY3QSCZM6+3jNuZKdS12JL8Cker6TBrHLwTHR3oRrXP6eYySXaoeiycE7QCrZ65jptOtI0 +VCY5b5Fzd2XAmOf00p3ofPqnlTqTzWsi1SmYJciZO7we0HD0daFWgnT/gD/oyP5YZ24cgdxp+AYT +W5enYcZbiOOsCtOWdGywC7m4HQwF8Vp2WZKtyVZXHeTiDEmfNpOJBC0Li+ZUwkKRWrK2M7E/miz3 +SbVqBX9JqNoaqwZ9Bdu9czqCJ5OiqIjmtS7p6TJyoZCKrXTrrXj8gXdDvHSkniiy11T5QYyHetoY +UTzlpCDdUmaxBW5fG3ybKg9gY1aK3bzUYSiFtaiMUunHGWVWLc1UID4i2p1uDJaHC18FS/06mWFZ +uHQqqG91QFDIQdTEKDI3Op4H/o72OiD+H4ouKLzRWabIS/goFJysJ7XElMhpWytzB9q13L2yc3ll +1vqWfjQbHSmgBha/47wvx3Z87h7iXKS0RhiCseQDf/fQetbR8LENci5KGxCfxNlUlAokMHpD5JUN +XvAIOW19LfyykrqWbIRmUMEoN+cdhj+5b2K9wzGsrHHQStGX4XHDmHC/3dRmlfTWqMkQucaxzUqr +U+cBxtPJTJ7Ggo04qywrVyXzZXke1TkGF3VsLJGwIQtdF3bfxtJV8COK2kNLQmQiC9RsPPmH2GEo +xhxsfdfEgRihgO3RVWqsRx3R1GbdkqSHTLQQhoQ/bBHla0KR8wtVo+y/TM7OmqSPjZ61o5i0Zb6j +RC4H65Zh0xT7LYpY6S1T76NV35+MVjAK+TUiQmgFwNwcbhw96VMDxePv27lcajQVGL2vghk4aVvT +3M0h1Sjd8vHRlCEKyCwVOXEn+q9a3XbCPio/MpzWtEMjKjY6sxpGXK7gnpapg60qVRnmoIkfCylE +LVkNNnLjjLEgIzDmCCUeCpVr/aKRnq7dm8T0GI+qzFK1FpKG+dLGsXVaSKNTPk3ngNbE8Kb7SiEp +TFEFz0jVxlFr0QHhi5GByzW+kqYO3hMPuUYDkaGxMxnsHIeFdZbaHMiF/cUuRE7QLUaHJePADpgS +INOrWmWdNFYHa6nyLBdIuKshPIHUDsWeQuOMo3TIldqpkfdNnuNulRIDt3OdvXeErsjmFqkhZE5w +Z9kU7AHu9Yxs9E7kkoO9RSKYcs3DxllXZ/El06mvW6N+YxbZPJc6eiV2YbmjHbfY+m3A8gQGdoBD +pJIv7OTGkw4bsSlJSom8PEqCh+4hUFmaRl/MJOwpmEq3JCSVXkKjaV8NKEnGnlLhspTV+N0rKJY2 +aRRCtZsXnvngC0uVHQeZAoVM93Uuqd4vv04WWmpHHIe0b0S3beg4BAuEE0OXWosgWJJTxkURx3EV +D3mt9K5ssjWXtPosei/7og7OeseMg7gawSvWOjegchmVMbU5CI2KhbKl65zWIYugM8jRohyiJ1ES +GTlEfODROJXzwjDyExU5oS5YBNcT0SRDaYxZLKbxrZNL3OIA6HJghpGDZJoLBmLFy1TKuiHqaiKc +HGvxM9eK8mc73ZCFpRXnbFm1KyEWiIIZsTXKBaQvBKPT5HdXQ8nIDqaYo/+k3zLT3pgtSZFChCI0 +LHyjJalE4Zxz1RjAkYECmXz9wP0D2l+phllhyFU8Xzx1iGtYUCVngmFO8zfDzQvBfTgFq5S3cchV +SWsYHpVVZ9bOcYQJ74eMg8pwfrXt2ILM1ltIqqMxI6iBJULPqPFsVUNNNAXj2yxEA+SHjHsPgg83 +rxwgie21y4MCkQ45TThUDMEHkjKxX8PEL1bMN2ptxVFwpMWsKmJYs32x93eFcbYa3q5JncWJyKCp +s74hI4AoPmu9Dmdbw+okiWmX+agAoD/n2ZxPCjH9UuDqJBjR0L3OheeW4FANosmFwtuFqXZBr8zk +qVFZ1eYkcZD4SBcyv6QWGkzHtrCUJPkYNZNB9VcbqFEGMhqDYX3wNsHyjtBzUKNTvmuLgfa0lCHI +lK0gMtxEadcBy9ia/GJ0yZzWkMTD5h+tkA/nAllhLRaAohFh/NosD1m74CND8JazQWgjluPs746/ +eNO1lovpJJSOs0kszRhRo2Ecjo81rwQ37xfTuOc2emGs22dCnAhhFcrJ5T0XfRZZCLW8m1AOR6ed +H64trghhpfAKYBSVCWs2VihOJdRunBcZDex4XvO8rlsjSDWthWBS4symMfmqY1km+2oScHTrpfWI +EUFl2sS4RWU0IGgbS5NmkKeihFBtgg8DbQ1THaqUAMisI4xAhyzfkXAos+JylAehY2MszcFYGW04 +IFnIlG0GWk8WOWmU2EjG1Mc4Q2fZjiicKbc+5maGswnShDRWo50stvkDn8AUMlDMTXTQr9npqIyz +cOdgS/v+NE75W5B8yQkARtG4M2I3kKI06lp/nyq7HQM8DgqtII4eNn+PzOB6ghIO/MSRbibo6VoL +hUbTPiPrnasFQDAl6nUCw6w72f9h0CgCsG4cCAEsAERhNWDsn8gvbIpgzkJnalEZcKugFvww2ooH +fmBJF4BOm2cfaosjRZKwG6lpjlcCj2tqSjm4wbNqGJOcktCCwqf0MC1SbFFN7iuVhWIUtLPpQw6R +F30AutAKUZWG82S42BH3Zcp+biV9xKFzraFas19knYs6iBUUly2BMh+qU8G2zyJDpeAQQ4R7ODpK +50Zbyko0yQFGCHCUIkSHvGQp6SscVrR5cU5HhTVXj47RvZfyPA3L5jqDtyXV6DTIzBk6CHEaPwdN +WsXhRcO9qwxJGC9gdEdOK3dAscJAe9KIrmsTc0ZjZRV71AotPd7TZBkEyiGrsqQBxXoQAXZwZSx0 +2UnjV44lBI1Mhs/DfNa9YqRKbaHu3p0V4Jxnnlf2DC84otx+4N/GtDsagtzs3iyWbePQLDFPIsMV +cms6qW4WTqDrQT69OSQIpJHaZRA2hqlRNLQzxVWZOJ1kLgGQSl3wsescNEeIcOsXuzUTpZqtAWXO +Yd2fo6mkuiHUtWbbmVPS7CoqhE30zlY2hyyBjSdEL2JhxQBllT9smVHZuYxs3I/SbwrodFIQNMnC +Xz/Pl8HJ8HpjUBwviWPZzvM0KIfLARVyqZUrnAbBIcpaORm/maSJIYnWgOfOec+Z01md3hIeLEEN +SNW1SzsFc4+N53RMewVM1E1nUZJCwa7R+9UmvbTj9kp/SnXasmoRd8NKqMtgwGQJasB+o3QI941Q +t2NjI4cRPCNsZy4Of2K5kD52HfTK6Q4QIJReAQ4HVQlRD8stIfj/pS7tfMnDMOmNFetwRklEZ8Na +S/SXyei8V45VBLIFvsZCFq4KUaf+bEo6DqPU3JHxEtMbiGXqgaU0M3O0zh1O5zqK0bRWxaRcxlrR +VuDPjAd6FeIQbUsaHGnlNKFYZtm0khrJPFWNolxXtqpXbzScFvxCDoCBj6YdvGUnm48UGY3qMqUy +xpbBOGOmdQWiW7qvlj8t3T4Ycd8hXyV97zSQIQ0wOiCTimLk1uV8VXSxjUwtJ4mISNGi1tl7lAMA +1WxROFlJqUx6W6p2wtJVreUFOdwGPobYSEUSI+C3zIMeYOtrrz6A/Eo7vvKri60h+Bmh0Gk/rpBB +7AbS6ayZCfechdnDq3uNBHShmPc58Pa2jObmGxMzmI+UbwFi3KInKKWRonRpSpQ72ZqTsDwVWhsv +tlEFBIMQllCC9a/KPsZUq9EdTBO+GlS9WQJPDF5/cWOcKqNYRWD0fDUCT2m0Ohc7QI/AVLOYm6Pd +FvwQI65WtZ4oNlB9ITbXkLuGIBuNSoyEE69XrRdEYngM/VJVZhxjeEbqgWVtkA50zaNFyMnoYtYu +WGOUbg5TnkvRCPLky0mpVCScIe+qMoOYVrTarJKJAkZzgkEXc4Jh7c5lxsMhvROyplzROrIZyUgB +0Wih1J0JIFh6GfLhrSIAoRJE3c7HysW4AUnpKpl8pefsIBUpDo8mRZdAXfUoEcuRIm8O/5jhA67M +xuQJzeFtKJ4VTOHB6sYacrsUlqFmBdZg+CB6xpMvmpJ5tnx6+zjZT4SIbZrGBcdxYGpcIedt0Y+Y +FA/Xu2On09xtgqdiqIQusGk7GAytx+pZWzuuXMIASkg4owqse8kV9GLnrOO4j9m2sfMaXSqnSxHR +41uDZcaTD1V3Ro3Wv77KbQzP2Zo9VCXZSJAscqpe2oZCiYLpSak8aKwbUgEXy/VEo1UVekhgbJgR +oT+UF5lhljyzUXaetxvU4SMzs3IWULIokp+izUzK+laygClPJJYoXGwRPdbN8XRr2ux2e8XpMPxu +yiHezw3jwA164xCF1o98ONjAXr2X9f0a8p5zM141SpEL1cDCPascoQlXsEv0xsPAC4A0BLXcIkUt +tJA6wyvrBoPRTfLKaEkUA600JGJKlnMOtciFqMYkYKS2xh33hFLnetvUnFCjnahotNRtdqeozG1c +7vn1WHzEXrDozd6vyXm3YnBVC9NtjQTVJfM7DR6PGG6WUWoprEUKlIpc9B7KtNghUJWWPcd23akS +wcrfhonXiV6axiBrye3LRllxzLVGsRdh2pSMyuM+VgUwuEzA7tXF0qz2QBWgdsxPZi+VJhU/mCGs ++ETx4sCWtLmEjEFTWDFjnXW68dBSWWJqU2uOkVirsY/Auj5NAi3lDV+mAa+txXuGVHVppGM0/TwB +ThIWRTEylQ/mksEWUTNYOAF7Q+onBhxiMfZzWRXDfKqlItBlCeethw8opFlb3nGU9C2Chw+YFG3c +zzUCMuIRDLNSWlib4EWTT1U7Q6Ay4DubI7lCHrEj4dsASk+KpqwA+wbwQRNFymCHcJTomleXwVxp +XdPBsxhl484baQ+8boexdtaVRRqLjc/dlgAbBt8sFFZactUyzuOPip5avn3J+oEcL+FSMIRdthRW +RsWl1RSZ6H6AXETgE0ZQ/FEavTX0V4YcKntHCkXdJrpMOjVEgsEIgxPEkH8u89PCE9Om0lWZ/QMR +YKGVwTpRrIIYWkt/DWE8U+8d/pTr5lW1DpUHqnNtEQqtKm2SZBl3GzPZIqwiDZwjIkv3nxBStWpb +1C9qHiJuY4xX8I0tcLnauwFYnEwWKdttiteDHqpSYTMqIhsxXdaZ2IYmofNUjrKKAMe2zs7tBnpZ +eoY6Dboh1AsSO3ipPM+OLzXLobeUqpalas4UQHlBO3E2SuFcLuf2sJEpONguJeAgfSxkw8CJDp9D +EVSYgFa2DZNZSBOU/EM4fcM+1dqrZoSTmHPwTFMlbqiWKJ0HgFwaD6eVPH3zZ8kblTKhWMa+EcOe +lIoKanI6BVZz1A2bYjeuEhjMZsJhQt6nSkeXwxgywwo1i8KPxEGuJ6cAc/h5OEEaEy1ejvejXflO +7AplLD24VKv0OHaeN2vI0kYTJXajzaYhKpMAfbA2KLYNC02GLRpt3tEsTd6HIrPcNv3b2mlYeyZH +RmJtsRXjYGN0jYk3bK2D9BDaO1VAhswlgxPPIrghCoM59grWUNCDTZ+xLzkcanmFWA== + + + eaUdXtqQKGgsLPRs5Rc86gf2mqb16kNivUXkyIhjJShS4ZAjNBr+vjZ5p9w9lCWHYKwAQ/U5bm7d +Qx5APKVNazBiNrYyJoPlX8l7sGS2WxYCNQeqnm5omFdmKRn0rSHHEg8xKM8Nb1cZb1AkyMWelpzD +AHVUReWDZjwNbqgNg5+ccKOywFI2cELRWkafGCiNc0zJoBLGsiCfx8XQyUOWzXbhnIBycLekye5l +HR0qwSknPU7PBg5me+dcMUtQCZpaJrrX5TQ6470KJzRe0tdQUVjo26AXsdGLrkMaclAWAyVFZOC4 +29Ic2mCrBOATmsvrhn+GiWTLv1H+tTDkirxfGfl1QQU5201CR9xsaeI0tq0N4Z3WK/9hjNZFMoi3 +MVjhA0bFP6qVyOBgYyDOwJLfbB4aMAFQVOHiYIsTKwSBea3ZFrXHoTMIC43l7FR0UgJHIFUuDG35 +trIsbWFn2ABLCOa8DsuqycxvZtXasiqytVt66XODksvMKWJGWNOA3ZfxOGDmuyJPvNorjkLWH8Dn +TrJFASJoSk28TkxVG6xDTzUigBSzu4hUpWrboPxe1YLMITKNOzKgl9RlIkPJDhRg2cZMg1dGw/ME ++hAqa2EAqbGLie7WiFLRiCHBEdK/cOHvGuXCJjVeZAQOfmZY+sIJhBkGK8dI1CGGtPKCpceg6DrK +lMBnZC4xoBbZ8P9DrMnvMMR5oot8dwYXzJuKIhVQaS+qJmdpDD1VOldVQ6khBvBWs/N4U5Ir9D1s +ZWhmuE0Ufw55MFNnB6ppCPNnZeWRJbosCPgxlrWTQxWqBimjBwLhlxjXEcBdZWgn40Ody6UcvfpQ +g4zv0AwcMk5XFFirK8hcbyywCI0S7lnB0uksQmfFfGbCOlQ24KUsJo2AJs1/zJG6ERBqmLyIdYyR +5hmgi+2GsQmzrzupMfEDOwciaEJKCcl3qg/cGhNvlZZtGMKabnqjg2Rys6htMCa8QLO5c96IlDXm +k8H6gZuk7FfgMZ/Z+JBSqeCgB/CE2u5UlVYfFkhuKe8kJ7MDRULGEAGseym8d9QS8AnfynaiWroV +eRAUExp9AqdYySgAjFE5Di4NoAlOvSJruVMXvbIRNBATifHpnOHmKUMxFKHHu1TtuJpf1k5AQjqT +1IvuKzD9MUgTkN0AjSzB0g1aP7E5oj7tSmO9CTAtrUwt5xoCZYrHDukAZSzMID/w1yaOlVtZaTVH +yI0U+oYDswlyIwiRDhvCcHNn3cMr0n83GghsLyUnCBJEnTMPN2SJg4q9g2RIMYxwegCkDkaz5SGi +OTQBbJ620+IkYaWWLjYiicZIowNTQ5lwFB4mo06B0VBV7oDAs9HoNbmkxfIVWrLjoqCm8nlOBUUv +fUfnRLgYGFaITmih3DLeuTf0so4m90cOUJFPYaR/K82ZqEmnRsHmsKN4IRO2mc53DpbrDzkqpzDB +llePiOe7oG0iZmIfkB1Gz3ywPFSNcnNxZTOUXnKTqy0BY6wGZA1tiFUuYAZWLv1udXmFEVPm1GhN +yRDcoVTUJA0QTyTEVDlEnXhrNDmiIXGbS/ttn7bUaEaJ4ReqDUMVQSz4QJwKRS08vWd+uZ3XnlUu +jfZAR3BdOoWKstt1YaetZ2db2wJY+2GvV+VdvhEgYUu0bMKMUPpAVPKV57cKI9Aeth1AxriTMGvT +5ARj8IkPyQHRRDP7XxZJE9HogofcMY4PruUNN1/aLsHBXckUqGTO2tQotSRq3wgo18n6cewyA3cS +PpfKTLi5ulIy8EXcp0gtK5sGkV34Sxy7lRLSpe+Sj1kWhhKHiF6bVCowjr0FYVPJAmfk3RC3ELIN +S+jE0qjo2EM+JhNCiAsDKz/zJSCnxT2e9LTK4aNKUN0gF5FvScA99pZJreXpNQCoj6UvEyiKKHAH +qu/52fO76w7A1rOOGtZSYwjYwkl2quhR49EIVYUQquPBs1cvjaI0D56cVywLi18nllQyrQYr0PCN +oE8Sa2JRqaJevQO7WiMrJzhfCzAHTWztTLaICTEHrfYCatqPkCDGyLXau7pyKlqEyxQ1JspEmKKy +yF2uka8oxjaK4VQqr4BE/EpEmUDRGH0jNgAZzol8zCzdJYlrzEiX6Cl95Gka4ZoBGyOxIRKVDJXp +oxq62uHswwt6xDzvV7nWPyWlf5OfNkDyWoFI31iKjx6NxuDCgtZM1gKATq55TcoMJVbVM+nKarhm +BTRdwfyKY1Qyk7SVkrGsecqoZGFL2W4MUQw6E/vOKm9hih0ZMsDv1D2chU1l5TLRyCxR8haIyQPF +mmI0CdSq8nSdbGcYvTywXh+cp4fEKuqhvB0ochl36J6xMqBRatesSck5D7QrNA6ReRNXINi54FuD +rqgQCwmoN9roJKrYJYfRyz1vTBX4wGeOY/4696sS8rVlae9uhfNoFM0akHqunYb21h8KzTDJfKeI +RERt6PIMj0pOKLtKGYelEWgKLBPiYWn0x5gR5RkQCexARbR6is6eZ+IZhDpyf7GxM8JLwvIymq1w +qnNmo1UGVTMk0OgO9Gpz5yIKDepxoYF1DuzCE+Nq1hhFeX7Ew9kphOlVSqADcIfWDaUUk4dEga2t +rWelyg7LKhsXXFWMO+MkH9GGYAnRChoAvHlJFI2CraXnL4moD8p5ZIGEoVIMkGMCTwZYnqPNcfOY +q3+x8UYpw9WtW4iJiWThmQsdENr/+49sUeNUFBkMDww9K1bh3xmTT2WlrZVbvyBBsOjgWu1hCK6G +ARGNLDCGBeC5gt7Va5va+lZHssiA2LaznqnUDICuErQu1rPgiGgy5hs2rTbHHqkbQ9HQguuUozFo +iFlgiCcxXQhPoDUGE0wbYhDaxuqXR8QjrUFihpE3T5zZuiEXxjJAJc0Rux3OeQXNmG0Spypsxlrp +xdZiDrr5GeJvBbJhvbNweZW9gUAP71llSwT+FnPbIHMs7EitfJZSR7kQw2BpxzdUmeJIo7sybonI +OiAxubXmaVAk1tWHM+MuoBLA/Q7OQ642aKyUNjO3uDBPcBuF4UVeS2ER0xLKDIVsHFjnrejR2nOl +o/x3jER0ImO3jjkRR5HZgTM2Meg0eOSVEscQewilU8ay9/1p1mSmGYS1y8KUUoqUwW21F03Qnjdk +YIVMSa3p7AUFQ7lEGiRYVhzqmIwVynze5K+YDHAnf5+OnFTATOMqe83Mtg7RRWSGy6x3HcXkjbKM +pLEIvtvBlZYh7wM0nBG+Q2cg7IHv8ToPkEUIfloFL6vHSanwGHbi3uUbF0zYEVY4CRvshiL6gWBp +7aYe9mI/YbF11WM6tLpxyVnP1Bz46W2lMgiUaZjQkSIJgeBiyikOmfegZMuOvzYdBib2GHhVP0zf +CSVtssgKZyfw/Xo4wAiUMUw3Iz8HfnSnzmPaxsecqIciyqfoHBZo7DdWpyRAakGdg4CesZDltE7C +XJT0PCn1ZW0jjqNNfxWPwYJqZUCdGOvAbZa2VVV2kw8VEFCSjxHxeXJ4qFFmAtJbjBNmy66VwBF5 +lOV2xVIRciKBCuUnR59vlRSTrxNKR9QVjrVJAA5LXKC1bRqNyasaId1le3SbXKQG7lXjxklrUogs +PAgGZEacKjD1XAQnj8ZsZphunbYdBly/58SRUXXg1oW+OeoJkpXDEbJWGwNvaGzwGounZnrZbNiV +jTRlKhG12VIJpaHNGqEWsQL7ydNNNrAEAs4t4YMlZqIEJmEinGEBW6AChR2qeIalLou7SS5Xssr2 +z64w/ZitXZvVSewWqiMXY2diqasrF1j4b/RlMavGvlBTu3BEXUv7YPjmhFXjdQzbgcXRFCqWR1GM +LSMAfFuHtub0Kno3VAgaHiURX6K66dLRfviyqWqs7DqNQY38uB1fHZtNFmTiQ2u1FxJcsvu0yRKh +rVV5IIrJahzgigbOzh9dqyri3796/+jwXm9XnPSmxdaWtVPCavyX3/7m/WP+Lelv9/ZP+//84NE3 +s52T3/7myvXdo0ezyY356eLp5L3p4fTJbD75YL47m1+96I8T/fXmdH9/78l8evx0b8cufXh0tH9t +Uk2OT7YnH3w77f/7+qVXJ1u4x/gH8dwfLF0aeKnucXt/enLhD3TvDZfqHmc94f7R6eHuhTfXPdr1 +X/Rf94PDe9OTp0uX35sd7uztT7YmD5/uHfqlusfmH9x8Op3vHA3DsvmqG1Pd4/BwNvcr+4tOZvPD +DVd/MD+cHswOT6b7kxtH+KTXrk62bZ70c2t5lvwEM+6MwcTEGiYO/q3sJ1L/TzPpD8/evur/10TW +zu/vD3x2yPNEzw79P13/jz+5+ImfzOkzPLosCv7f6J+f5OFx5bXjRC/b8X9/+icPHxtPLvnUrf5E +D/ra5U/08HZ1zNv+n+ce8x97aWxa3ujejSmWtlbItclHh1jAu3bNPWxs/k+EtnPvt7TQd257C66F +knhoWe7g2xUXkf/fv/R1z+qvb1tn9nhSD31GP65N+K172+an7NbS9rvat2pzjy7bnx97Kpy1f6Pb +azv42ePcbmqM642aGSc+CphHvdmP1B0SnZg9KLXrJ1KjkXmOCfRDRqbT3/oP+eDk+/3Z4re/ufbu +4dF3h/w3GEtXrh8eHU56V+nq5Nr7/ZsgnHLtem9OfTvL11y7eXRwjBV+e2+/H0v+rJ+Ze4cTXaLm +q3yHa3bNy5t/9uBkuvPsgp/dmC72dka/OWcucuBGvx1O/+3p3nH/ShrE/oKZvxwu0S36Pz/cO9ln +a8W77H8wf3AyP3qmURhblf3gHJ3cn+1gluzir/1j78/6eXPlwfF0px9xxqHK3Lgz3ffGa2/33/D+ +7HF/k5WFMzn31a6NJ8Dk1ckV6zRuqV7aB5qYlmoDLVWp0ofztFQRCek9oXVB1dIM7Gu3+t6+Ovnt +b/oXGR501V77zuHJ5MpHx4u93dmtfib5i7P55tH+0Xzv/4bIXH/9jf5t+jefHx0fzTme+/zL6lhc +++hwb+dod+Zxvlt7i+P96ff616WHXN/95nRxgnW71KWb/VTrp8HO/tHOs+/2FurvqxN+xknvEfQD +Ou0//aYZdvPocPd07+SsGXn+jzFvLpjRF80kDdFHi9lb384OP9jd1UfGjYdPfFlV3GL9I+YbnT0k +57/ijf3Z4e6/8o7XeIfnf5nRSwx3OPct+t+89c/Zzin6oj/yFmfue/HXfe8/fd8jTBUZvqbf9lD+ +B5uNpAPPJSf96+736+73v7b7Nb/ufv/pux/yZrT7Ara9EulI4wE4c/dDqfevG+CvG+CvG2DT/roB +/k9ugBWQB7/ugf9Ze+AH53/uZ89j7ePKX/fJS++T6ZezT/7Ap61+LNvxzv3Rc2+PazvUv3Bsr+47 +l1vHP8kcrH6SOfhj7UY/0oT4rzDk/jvmw//eNntrung6w0thzf9y9tr/jTXy8xwFP9xYbaEka29f +iuvV/t/zWa4/viX4P7hQeyN+8uDpdPfou1/uMv0vtW3+Y3wUJWGRjm3bvu3f7pjI3w== + + + Xpq6qxGE0R/PjiEsT/4cRTh/4FKOGexO58/4CtFbHu2fzt2x1egeT/fUEvyab2fzkyXnd2cx35Hb +u934RUfH053lnz09mv/f0s8e7R+e+cX4Zcp/+UMtdvbn/27b7N+8P769/0veGH/GTcA+xc+w9n8s +B0i7xAePHy9mJ4A3PV3fJUZ/PHuXWLrDZXeJ2tftwf7eAd+1yk1HjxfaASpbyt8cnhw/xzr7Ob/6 +837qG4+GuXLjKV7xikPKnsynu3uz/n1Tc3XiW1Rp/5/XP8Fvb9z4lw1gffnbp//3f99P3psunq1/ +eP7trcePZzsnZ3/427P+k2N0L/3R89Fwv3/V08UPPd9+tXf+By3xBzvzvUeP9n/B3vKv0/I/LThH +6x3gyd58jz/T6b15M/bZjdfdkPDzP5+9GY+Wx/MewePcXt6hrx8+GRJgnu7jI/YOZ4uFn8/2F06s +T/Z2T56apZ5N/rd2n8w+6G36/enx8t1Gf/h4Ot8bJdC2i27lkbOVK1Z6vvzXH3Cg/JzTDYUFRKz9 +TBPuf/CkeLo3P3p8uvN079ez4ic+K/4Dt/t/a0L5jN2f9VSTm0fzw9l8sb77L/357CNg5S6XPQcy +nGP+XEb5f4MXWq57odslmLNWPdHiF++JbrPkqKgsEvnznyz/nfOhHiyZ/6TJAONiu8Vc+Ldatb+c +EDR0xC4Rha6Gz53j0MV6HDrEtUD06Jc5FF38UkLRv8Ydfrg1+fe+fXq6f/LF2Jh8sHdwvD8Yk+sh +4PvDp33OqhT7tPf6rfNkqWMs73zrcHdU3Hlxlei96f7s5GSm3tx7pAfgnyt/v9//fXEyp+P0Bb7T +3xZ43eXm3/7m3s7Sq1355OneyWypnbO3H/feCs7tilyi/eZ7n747uT/bHf1k6U+fzvaRQ9Bfy9W/ +vj2fzQ5HfyzGf7z5/XT4W7n8txv7p7NRb5b+9t70CaqA/c/boCrQXrmtd7n5et/03uuoaf/09a6Y +vNv/16H/vDBFv+PrRX9phyv7tndfH1+YRoEFuzDxlqsXxuGteVXEVXj88mUo7l99ct+2+mT5lnnz +7y/E2+R3Ga6rxsP9elXYVSsP3o5Ll8WzLmuXr2vjGdfhBbb5wfJwJw13vngYbg52sHHs/4uu7/jm +eSjDSifs/630o10epGSOeD1cmgrvRr18LY5SY7Owm/JKDP2GdxtfyDfj5xxfWPoLFcPD8ebv4X0+ +fT0uXYqLq6j/GF+q6Vnh4iqOB6Acd3SYyKsfdXxZLM64LGhthDj6WmG4Z4jLX0u9Hb9UvjSuzmYO +QLW8jPD21cokjf7+9TBV0YMKF9fLF9f2QbdtcHV5jXvX0TsRxzOb/9eMRzfmFdgUy2Mb/dpG3bHr +0ZmG12M06pWu13b9uOt1vno00taXdmmoc1/alZEO3pc07nvIfUkrffduaEEtjUwTfWsIy9e39jVH +17bDIo1LOwTXSOL/Hw1jm7vS+tVIgVWTK3f3DmfTeb/BW9arvCjpteEXww1XcmrIL/Wm2HPcfP0X +5/a2eu7eVpfv7cU3X/+Fbn7lk+m3s4WTYFxduon++fvojl9Mjtd+Yve5d7T/bDq5dXTyfPda/5lv +Yldon0xYLtH3++j0GB7BvSd2sGn+jI81zvli7VgbezV2sLUbTrbCZ/roIIh+TrdrC2/5nA5+wi2f +01xtuvFwbcMFun6tblqu37Ms1u45Dgf7LXkKrR9YRVy6a/Knl8uny5V+Zny/2JnCCPZR7v/jCnaQ +0WZdFJBY0B+60bbVN5eVtafRO+H6YO3taNNFe2ftzXhXUNNoo2jGjxztlO34kaPjPI0fWY2sgvEj +x9ZCHN3HN7N7NwZTORvEz8ekcre3iZecgXHKxXEwv10F9q44sMux6XWLXg/5gdQvZaE/ivMOt/p/ +tMpPZ5Mbe3OyNd3cPzrlf+nN8cntvsdiwOE1w7/2U2ex4FVHCwzV1TVCPbv5OR210bt1tHOKqqVb +05Mpyfu8Qbx9S74gG/723t33j3ZnZ/z51cmVfx7sH/YXbPW7Sz/4pyezhTECX7s+76f8z3mbH+kp +o+v6WbG/O585ybHDX/zP+I+T749n9ucrfzxcfPXtdL54dUSXPL722yl8ILsYf1iccSHwJ3ad9Wax +/K//8UN1eHQ4u8wooZKud1UvM0x+6cu/iBd8tHe423e4vMxL9nPmwezkfb7NJV50fPmPOSn+9UEp +zx+Uyw3F3rTfwi+1Mi7zpf/tEwGbws7p4uTo4CfcFn4Rb/l8W98r317+LXHtc830n3SKvrKYItiI +M7Rfh5efqT/Huuk79Evrz3/XUl48/u6Xf7z/EpbJYn9v579nGwe/uqeTzv7ml/vev5A9u6q7trjw +nb6/1Dt9/wt5p61QtU1z4Ut9J2DcJV7suwyh+495uaezvSdPL3UK5Et/Ea+Xk79nvtmjo5PejLo7 +e3zywXzvCRk7Ln7H9R/9YiwJbpEPjk7nO7MbQGr8MkyJ/oT7RfTjYHYy3e1trB+hM92/3Jnf7Vqg +5FJzbnQ1m2qnjbnTkaH8ZHaIO3x4Ot3fO/l+cnf27Wzfn/T392a7e6cHk/uzxdH+qeWCV5lprt8p +y0mO3fRG1umx33g2n9ybzwC1GXmIa6s55H3keLrrTnMGtBywBmV5VS6Oj05Wr+u772smFA6u2D3e +27bG6EiNIwNDcHSu35lcPz05mtyfLk5m873/m63eFsN0PD3u32Sxd3C6P9aZKkcjOZ2fPDqazncn +O4hhr/YXEbLJ4zwmO/t7x/2FMNz/OZnPnvS3XFzwk2MM4/zb2eTo29n8GPG0i35xdHoCNPZkwWjj +Yv29Nl59Mvunj2wb8/stXTrnUG19O9s5OZpPHk33p4c7G4atnxQ+8ybPDo92nvWPmDxRbP+8a/f6 +qTY9mU0eAarhyPP+NeOAPu/H+73Z4mn+aPwoo0lqP2kilIrO+kaTsn9EXlScMsPtPzg9Oe67+68+ +4AkBCssnDi48mU8PF8fTflPY+b6/aG+3n1x56sWqrtLZd63G3b7w2nEPLrx4nkNWF77ZcGm59Bnv ++Tx92E+kyVu7eyfTR3vYWIaP7nNqbdO4Oz18cjp9MpvcOzrOs2Td+l4+EB/M9t+ZnvR3ugO2qzu3 +Fvzz5sMzX3v3aGe6jy1p6erxFQ/hMOLRK/2+OT86vj6fTQUY3/CYK0MGrNwu+D+TLYhJhY6SzhB/ +7Sh6UxZtvZ1S1V3l7yTwuF1CPGukcec9yw8edTiDyt7eP+rX4f3Z8en+YqSDhz8P8KmVsVyDV40+ +5YOP37735PHqOu1b/zY9XhmQvvHWw1srO2Lf+NbBo9mu1o8vseGP/SzZ2Vss7aR5DlWTfk/+wLaj +B2duXkuXPRx2rWFTtktW98vlbeetew8uuItds3qbi8bSx+faYNFd++bo0Xa/gLC9rZ32q9cdQx2o +XxCzlR6tXrd4tnf8qN+Cn109/7nz/lyfL2ZSNhgdf1yzSL7+9ejRncPHR5PRpC/Hh+Dh0XD2TPYO +eX4dLfbyq5xhLIysBH6P8yyDtWlwEwflTTso7y8dlOPTiddqrl37WMfSjaVjaWl31+XIwIN1cDI9 +3NVmtba9Lx05+lXOqeNXOoNWf3XxOGhGXXYgdPU5I7F+8ebVMx4xXXfekC2/vK6/xNsvj7R+domh +/iGr6fh4vq1g9jlLBBftKi3rm2YXt3Nt2uqlYxcb8oXprAuXvNUrt2aP+3fcnTz6fnJr3p8L83Ur +efUGIyO92PSQndXunH3VUl82jRSvos3hHT6/f9gvlvu3fsv9+fZB//NzOzff3T6aP9k+/w3sIo+q +l8WZlxGykO924YXfntd9XnW8v/P9OXNHF+0cLs4d2/6ik739wVDdOFWfHDzbXmTY8TkX9VbHbPei +i3Z6W+Ccfj8+PNne3V/+OhsvWpw+yu8WNj1ssb0/cgc3rq/F9qM9LNvz+rzYPpw9mY4MpjOu2jk6 +PGEu9ryL9kucPNOT9Q1n5cLF02l/1s1G2+TGy+DY5KLV0S45vuyfx9vLfs6moegvgmN3Tu/7K46O +d44uumJx3gjwit3T5/LQV35/wdKe7877UTk93LncZsHLp4eH2SPfbNPwsgu3652D8a5y5aPtB9uT +T2aP+pOvt5l2J59fefDJB/c+vzr5tjq/U/19judHj/fygqs2P6y3ZWZ7OTSyBOc/7+69DTfjebV8 +Zq89YXGy76cP7aZsel0wpvid/WD0sS7zo+NdjN/+4eX7dbx7+dvr+w0/KVvQW51xRO4d9CZsv4E8 +zubkmceuLj3Ju1qEI9Scf/V8dOhBBv7Mo1qXK/R68Yl7xNKwi8/c1es2Gt27s8Xek8NxzOisK/m1 +H1ng9eIrx1P73Auni0d7JwdrXtvqtbpovmqWnXXy9xs1KqAQhjuvu7g0+wyPWAJy/kF6NId5edF4 +4crH/U6bS6mG4N7qZfRQlu52hgUiroFLmCp24XnGBc/o2SEiCJdcWzrVubhGH/YyP+o/3gnq3rw7 +AHtvWge4tl/xcAtWjMrN3Yf7ude7gxddNx8VBF1otiB29Gg6X5w3yIMV1K+w8e5xiauHDeQSF8+X +jeaLLl/aPzZvTbj+YDp/tljp+SWuHnp+iYvHPb/E5as73xn24vH88dHhucuZFtoBdonFBV+7N75m +JyuG1RCUXzFH5mvbDn3PTZc+udQOBUNMG9TJekRn84UL49o93yhaXtMbDUoZT+baLxbnPJwmioKl +Owffn7szDlceiVNrQ/jmul8/2RC1vHS01c0kBPAO+41nya3JUcCHs4PjURBr+U//NCGH9ZDg7X5+ +IfJ6siHw1/8ZeZh3WUyw6YcPhxRZPfyFyOjRn35IHGHv8Nn+4qQ3BZ+VcJKPNybjNv+g2MYROLKV +N5mZq/cfh+AuekC5+oBNM2ncn9UHnP/CxfO+cFjtT7Nx6xy/wOP57B+nSHSc42gO11fP+QbV6htc +1KFqrUMX/aJY+8X5XQrPO6jV6qDWl7j/5YeolCV42Qkx9Puikd9bLG9c5w/7dP+ktwcrt23uzY92 ++g1SZboXr7OLwmXj4dGTyksOjp0APvQbzadxT6aZ++riiXD5gQ+r/Tj76h0Iu1zyaz7PJyrXB+4y +4+xftNxuL/rB7uxwMaQC8xTwiuuLN8MLIhfjN18a+u12o500vvVy387fZsuVVXKZUa1X39pK2y/e +HC4/9auVZ124sS1/8Ivmfrk897ebjRbQ+P7Lg3rRJ1teAZfsfHi+z1Bdcm9b7sv5Z1YYT4fzLYDq +8vtreK7FW6y830XfMjzHPlY+V0/C803CcuU75vUhyoiLDZLLL49itWdnxJjGn2t5Bl80qtVzjGq1 +ejpcZmX7Ur3IZgmbbJbLfLVLLqdq5XL3Re4cPpugAHDshFyIOtjo7eF2927d/oo1wRBWU6HDepL2 +nN++d3R4tPN0fnQwG27w7t6hO3BnpA4uj/8579mosb05eMsGrzvPa/dfipzqdt/t6w== + + + 85PvjubPbowd+DOeeTHy64wfVnjkPcXK7xzu7J+it/eO9vd2flhnH+ZIxiYTZv3LjMZo9GkuCH15 +v/WZgPw5PLF3uCAi7x1wnNL1nfnRo+nJ3en3sxyXqqpN4cTxhx2m0x0El68/Ovr2Mg/lXD5zUpz/ +2JV1sPbc5/tK90chpPPX3/LrrqMdnudDgUuK4dg7/bZ6svd4L3swzXOM2miaXGIxnIO1rM99cUzR +c8b7+TNvfuMBdCvgx8UzthoNA8yStSU6Amus7mSXAko+19y5O8ronNPfM9bmUr83JlufA266OaZ4 +3va/Aa5zZ7/f9BDC7m//L+T/zvgC6soNhJHvXwDTyBOkf+NPZo8+3pt9d4lxvjVbnOwpx7Q0thf3 +5+G5KIK8AeArTE9mD5+eHjw6nO7tZxDJw6f99J1M57PJydPZxPKJE9AC9CO2mHz3dHY4WUy/xfBN +DyfjYcZkmEwXaBYXYP+gjADenny04C37/1y+2fdHp5Pj/vtP+kk8w07S3xmP1u2egE9yb+lBL0/6 +h+WfHvbvPDk5wi12ZpM9otimk/3p90AmT4+P+8HTAlmc7jxF9+4c3mICb7iNnnbYD+tp37ujx8Pj +9xaT08NnYIfbvtyW2N96Z753fEEs26/uh4Rx3odjqMl5ny0DFi8z4bTYHo5QyZf4FTekG0M6p4rn +7eI4R/rOzx4sYezPfN++L8fHYyTMBXN5vCmduyk8OH2E7ezo8OQ+PvY5Dt7wnoCb7G2EMW+6/uF8 +7+A9JF8usXgfnEwPd6fz5zR7jIXv+/fPD4dcDPG/eFyXbM/zvzDnw+U+sZlgBDhgqEYR/EsOwWjX +u6TF5xbE9fkFp9cGs+eHWqbZ4LnMcPQGxp1RxvWMTO7qLPtkDP670Pjc+Ern9aqfauO5fNEKfy4z +bbR69w6fXeJaN9pHO/xbOgZuTo9VZ7CX/Z3eJe1/IxPrZj6wV54CC2klL3Y8PRwj3ob0FA4q1gwc +T9dwYJak0uZyMuzQr27wd0dsnSsUOHhPceMgjeZ/BD19/4dxE/zo6w9u3rmT4q0ZpiLv/NIb8ev2 +pTc/fnStuPbSe39+6c2nJwH/rapf+/CVkP/wYf5v/MOr4c2HJzduPe7efvbO7+6/Pr31uPj0jfzX +6qXX7zdPX7ga3nn9ha1rf7rfP+aFl9549toLV9//rHvh5ad7/d++frz9wkunrzx44eX3/nbrha3i +vaq49vqnV/j8+MLNqx/Wi2rxXt+7W8/qNz/4+o1wI4XUfNYcfPba1te3j9pPQrE7/LV456vZzf4x +8/kbrz+6/vLx+3/9y7vd4o30zmufbN8++qz++K35558Vtz67/enD269ff32n/PP19tAeE37/4Us3 +t/58v3/g3easF9YrbYe73e8xaGtX3V3M568uHvZPeflOca1+oBcZ+rZIt08+rr48evbHYvePJR/9 +wXDf+RfF4rX+5un0pTfefuGPfHV9m1vPtq8t0tt1+ser3/T/+vZ+//NPby0/9fP5F+99/uHmp77d +fhlfufPl9sanfvn79+/2j1l58PDUZu/dt/+w+amvvXBlvij/MN/81Hvl5/WL1St/Hp7aP2Z48OJP +L7+3dcZT49Mr0z99+tbmp9ZXP3/pterJ5nd98faXdf+Y3310vH930+sWt2+8+5czntr87veH86uv +n/HUT78sbj9+/8HwVLzN6MFvv/DaH8u/fvVw41Pffqd6eOYIV5+98fBrPrWfkY/eWv6un2BCf376 +xl08+Or6p73yafj7fnm1f2p9tDah7hY37Kn3/vSnlafGePDV8fDU0YTWg7+af/H08OEZT/3LtGlv +/77c+NQv3/z6/llPfad/zO/DlVc/3/y6r73wxeJ3T2f3Nz/1w5tX3/jH7w/ubnrqS6/uv/LG8FR8 +m+UJ9ec3P/vLB5ufWn/6aXG7K97f+NQXbz9pf3//oPpg01P7xxS3v/ji9hmv2/zuD88O37t51lOn +xdsvf/3x5qe+XVz/0+xK+ymf2j9mdZBPfvfym/bUT7eurAzym+/Xr9sIv/X5s9tLT/3steJuu1Xi +qX9eeWr/mMWL78yOmvvTrap/cHu8Oo3v/v2z6RlPbX7XPtu9/eVZT71VvPfnLzo+lTNt5XXv/OOV +v3wzf//+xqc+ePVP4cynvjt7EIpNT+VBUP99q3jw1dUXN73u4sV335m9//fPrl7Z+NSP/3T45Myn +Pnj64deP+NT+Meuv+/e3i4/fPX5t81Pvhj98dPsvr72++anHf31x01OxQ+PBH3/19osnZwzy3z8o +Pnnz3Vubn/reG2999eWHX3yx8alffPDsDp/K82b9db/5NO7ePuOpn6fii8X+1uanvv/N8cEHXQor +T8Vj+OCv7mwdnjnI8z88eOmFM5766UfFW3sHf9341PT+1osv/OWLLexp/YNf+cfq4jn9qv3Knvoo +XF1ZPFc/uzv9M59a/emNK+8sv+vd4us/v3IdT315eCoegwf39/3mH34GvD5fferi6I+v21NP3nxp +5V1f+Hz696t66o1PyzvLm+LL88VHb7yAx/QP3l7foe5s8XX7p948WdsX33mx0VPfLN/dWtkUXz6u +39fJE37/ys13+VQ+xh78+/l8+ugQTy1WnjqfX58d+TT+6wsrT13Eb16xk+fNVz7cXhnhF49mXz+U +ZdMftLPpV81yt9756I9fHr1y5l8//bA8+Pisvz4t3vn6D6fDX9cPgn4jvvXHM37ef4c/vnTTO/bN +rF35a5PKrx7aXxfP0vrybA6fvvi3TRdoh7x355XPz/xrqv58/+uz//p0+uWfhkFbv+B69cfPds78 +693/X9t7NkeRLGGj3zdC/0FCgCSERu0Ni5XHexALixNaWBASMtxzT9y4729/88mqzKru6e7p0cyJ +PcGRUtVls9Jn1vLhraj9r58f//On+2t907L5xxf2Pu+0fF7sXN65/vLU/PWfheOy9u3L5X9FbP0n +vHBteNNefr73/LCpgaF4G8s/Tlr/+vrS59W59r++27h2QzetocHHS+/zi61//X725NdO619/vIrW +nrq/Dm/azx9bN9+3fU5zevpn2vrXe1Fyc7dj0y7tHX5+/qDt88tzl+++u9L61807Dz/vt/71XnTr +QtixaXfmootL11r+mu4EmzeuyKqvLf5Z++vyi6ent+xf1wfXh67nzouP21fuuAbJaXL1WVVHWw++ +LLxdt6To46UD/PWXVVm3PqSGCq0dnT4yP1VpWnR2EVro+tzKvfINaaHfX+CfAWBbc1c3nq3jn9es +4ql+Z6iFHfDTszWhgicXooUbT1YsdSc9qCqn3ZyPF+jLez/5jkAV8m7G6sPicIGU3d3fRGcvXKYB +/7muA86v/nvj8xIRqgubJ78/DlYqtPfkAg3jBmZVqGXUbB560NvmUZM3f7WOSjzle1iX0/zlsirU +Oip44F7bqF/8UZPn0KS9gYtHa8+9Ub9cvjzvRmXdQEeNazsM3UDXun1QGXXpjVFx/YErm3wjah2V +dYOWUUllJN3gvRsVq6ks9+/WUWmTT5P2UaEbtI5Kw0A9+Na83Otzg65RHyy0jsqChhuVqUBlYAga +LypHu1/K+PyTPYyl9b++/OzT7v3vn4cVKtDSNJs/fr+5+3hku/SbxT5LN9Zo1e/uCOkcusQfF39i +g555xpybW79PLJ25/Px27e6v/jt/7ar75+avxS8vrE4P8mTtAjd/LV3/pV0uch83y52L33keN8vt +txtExD5tYujYkSk7/s3NS/afqw+P7AgsHcsITuqkGdH6bvwyrWrGKqKBa6vf9jcu6T/PfGna2tge +a+MNDLPtL/jjvVtigaJJv3xCkMuQdX9fkQ0yUr0lzt4anlyu7qGa6GjGwb300iX+B2j5uqZGNU3r +R3m3Ni1/Th9+LxAGP7waLdwKPLtbzYDIuw7S+ffvtfujNh7/2Okbpb9hhQtzrSvE2egi+Z/WY5Qz +fH5h9BnO6wqvCKY1LRJy7cuO/ep/hkeMpVbx6LlfHb2FV9a+b7V2xZg2Eu1lv/5cGQu/HHJVmbTB +r+13x+PvfuPWk8jzlyD0xLsfrf1V3uveet60lv2qUqGlYSr0frNKheJWKsQ0rfNENt/dPfH3UCdd +2cPLhgo1b9/7TZZs7Ca3zOjq5lXzj92+8LB5+96szLUS8dbryQa8xsW9uTD+4ipsjdcX33r14uGo +7d6+f9m6IhpnsrFcW1eFrXnr2n8yuGxRYIimbtIwr47GWlIjsSEMIo1v19tfvY8+un9cukyz291o +Oaqrv8JPFxd2eBLWR3DOvQnaGfe3o+Ubgj4+QrMFqLm3sG9vTV3x1vtuoivDF/DTVt8L2H37wD0/ +Xdj93Xmg8+HVl+FV/PN22XNxDOEGkcnFzftNR4pN808V/9CpOgv2MILQCpUkDiPI46c6J29iZjVn +241zu7n9+bRtmbeD/bOXq0PS2fCxeErhw+XhY/myPUo660uFfhSwQ7dyqh7SpGtMMs7bs1Y2BcVj +jEPexrbsjC9UNVKBL9tVqt2wXw+PHC/umNPZrXvt3PPxMzujPrIezald0JPjM9yzxzGWF7uljZEa +QeUYDy91ShtjnOH2k5+uK4vQE/T2/LDHxHA9e/VWZTDjTkydxba3N91KzjjL9KW9yTftw8k0N61K +3cac2K+azeZjfjKk3Z7dPD2n5Fz139CMdpoUxjZZt5FnR2u73+ZG0TRP+m6+nme3Lkzveq7tHl8c +T502nt2h09yBx+WB2x1W2MffoDcXLvfVTZzUWd+gm6fKqUfaG5olxp0aeWi+N6OP6uZptxZYm4kg +9PBkRtCDXjOpS53n25YRBMCbidWkl1t41tcd2LzfjqG6G99mNX7JRQ1Ff59+HnimcPrpLnB/c4wR +WswfJCLOdUk2jZSk5aLc7ZZFzL3pPa35c5KCGunE3fv77FI3p+5LCu46UtDbLtC+woUeu26t6iM3 +viJAjLZ81MV8zzr4/S5cg6+ngVobZ+Hm36fbjkZUo+0aNaMW1Z2uwLe4L5aK06trv/pf9la1yKhR +tF9jXvbKfull5y/ii+WP1epNv8erqV72RuV8tC2KkPdCT2NKl9HhXt2QW59OlyG3bkz5ea8q37eo +zqMNubQ470IJCoxtUbmHSIeHfQ0hTo2qT+be7yqnPochhJDhOOIlmQCYoSPrf141LttiJLJyWptd +7+c9+InfTGQkwsb0sA7WiEKLbQcblPVDaI+IVkwSvypi9u3fdTGbkKHd/igUuoekjZ2+Xxezx9k+ +K6fxjC51z6ivISK+9TJfqKGFr62NxRrv16Tkc96ba0+Xuhc3Gt3vO27o+M05zNi/7tcZYduSjAuv +DeMJg6ps8Dyk4NbLS2ldTjvn3nwYYd8XC5Te0TYxlzaoxvlG8SVfzLWr8Zgf/F0LflAI1kWwPhjR +evt8hF6nGQ3Gs5YPr3r3eRP7q7lXe7syqbc2K22TidYqHm1WWvQ2xi1sVqjo8tAwEw== + + + uzj45Lp5oPMUjuyoqmyONx3xsJuOJr2KphfVOF0vSqHH6Wh8RujsAg29VRyN47HVqpdxwYgcVxer +wug6R8ROxT2xzmGu6r/puo892A96iwbjewpbJAsEjV7ptZueYHrtuMrW6tTt9MfSEHU7/VF3A/ag +bs3GlHXam9vHk1K3l466qYo7jnxf7200dXN2gRE+KPR2furmruf2q6MpUDc6uSbqNj4VoI7Gp27D +Vg7T0eTUDb1MwYvLHXW4k66uLaoXaNWTbCqWMJ8rvTrq0rN9D2Sz4JJcfVaL6ySlaMiqDtikrlzl +N/8sHLeTpJ4S2zrd+MdnTbfaGu/HI7rU26u5sSguPB5tRPecARXVW/2KNe6qwn4esYVOrhYw1Ups +RnfUT/Bv7cXYbKijyaMquJcWtbvuyB/dUdWH39Ms3eSK4N6mYeQ2zJFWuMwiR5U/EnhlEunfQ9VP +F56dTq4U7r7ua/zyrRyt/PH1WNL/CMsteptc+n933MQcx2ZrOLnxLWANbA0dTSL9e70oc5yArXFH +DdJ/Uy9OxW3pqC9/7GaOhti8O56YP1aY44e6y9kMQ+CphDqBFDVGeQn3rIRmudCOVvngw0nHsfi7 +ebWPC293dxIjd91HQL1Nes+9iTVc8hHR3R2b1ksSltPkYdpUJjrQQa8b3+GGXactfeWLg+eJ2KvN +qRUtTNTQyHtW51Trg5UhNrU+WO2ne/bgVNHa7pfWCMD20Lg2uwDNLeq3mz0u2efTKYb2Um+tvh9n +Guobx0+9xRf/vP9gKsYU2rR8PLmjJdARp/lh0M9ya3prufZvOiN9DVqws5gxo9e0eqLF0CUTJm0u +sWNwN9OHh42Khz0Hzts7/Tq3cvj0w9zVV+8351buxO+RwbfZlMs3YwrNTJ7O57O14Vy+mVrS0rnT ++bpz+QyFnkI6X+uonMs305q6OGY6X3cu34yfujhJOl93Ll9VHJwgna87l2+mkro4QTpfdy7fTEfq +4ljpfN25fDOcujiFdL7udjM263vidL6hG1zJ5XOKx4TpfN25fEZOG53OVwmA7sh0e7Kw1SSJd0Te +tycj1YJoesyp2UC8MTpW/Eq/pK2tuiZ97sDbjbpg3GBE6G0gfrtRlQDGOz7fU7hRjwI591b9eaWC +tLXsVeX7i32S0va/778aZW+peQq7euuO8uq3QmMdHJXE13uFNUNXw73pv/Gr48+pMSsC0+o2dHXN +qSl5j1czVv5eL7KzWYsv8aKGxkvjOhsrvsTGpzWGmIxvbm6zNZvCZhObt96szHcvTrW1UWl31YDL +cU2JBqHp4Ce1NJu0uza3T02NGpV2167EdnsrfNK52RliUtFfR2kpm7U8iplKAnO/3qoBXuGwx+dz +dDwyEbMf/fq0NZZmbK5nm3L8OW4P1Rwr6XWGs/Ae9syBHG0DoP1qcow7OW3Y1jbK1vij+FWzqNC3 +LxsDdM/j9NpuFcdak9F8AaqejzZSHOudU/h7ZOT9GDmFn0fm38xXbFztOXLtSTjdYnZD5P3CjW/z +bdO63ZQz2n6GoyPve4clfNmuWj0bz3Cmb05hcTIqJ6cLI2oh8ehtajmrJ85v0poYM05voxF/jE2r +mmUn3bSRiav9l+mo2/k2rWovjtZ236xUg6h2auH8Mw0JZf3E3CFT8bAepnf+WYutszt1r9ZHSwc/ +LtSYdEMfH6P3If752HnPd3rog04pHKEPft3prQ+2dTAUCXmOPkbVcaGzntHyH/2y9s51Sh+CHvxG +BJ3m64Fku9HWiJk/Om3ZSI9r0fOGsL8rW68WO9ixI13yDC2puz6LnE0/CfPa6VAKweLGWY9d9x0r +bQj9/e54tqAGXcoKUCNy9YYIUHta1lkjgz+PnHa37913F79dTvt+dzxbUHvG31Bw0rm36tsIk4S9 +N4s98GBM601lThX9BtOKxrGUdMypeqt7sLWOrUr6zmlESPzo9LyuOQ1VGRnU7MYmLWoa1pt7bL2Z +NAyOpOSLPaw34ikckSB08drg8iTWG98ucG9y6w11sNgVMjJGPtx5rDczQ6mLk1tvkA9Xs97UhNv+ +uYLJWNabZh/BvR4JQv2yg5AtSBevB0L3CxHEIyVBVZC+7wTpjlj1PoJ0fOvl8nwPjJjpzpD8dX86 +sRF8NteeLkzHAkSLu7Y4KoK4Tz7cOaPmK/wGmWzttqgx0tiGgiFmGlMXR6X4jR2g2xAMyyl+PWMC +O1P8vGTWmsgxZtjJ/c76Wt419qXOznDAJ8P1VQHryflkNa1BT9PJzONhphG2152Z1+HFnWZmXmPY +9ZOf087MmyTHY4zMvM5g2Oll5rG5e8Kr2CMzzzlWRgchTpCZVw21ko8Wpp2ZN1OvpWqS86admec5 +JEczs/Nn5lWdXj1COs+XmTekrbX5hZBTN4XEf7C8qYVeUlfV0MtWqbNP6OWro16hlyOpwOmPeFLR +YJ1jLvoFXI7u6OpIFOjZUZ8sltZerJzGHU0hoWwoNqIr8n40dUOeX7sBbTi+esZ7zaclxHrh+MpQ +iPXC8YjDqF3GdtPQ7qtJ7qPLf/LND5PeR+qtswxOI01rvY9vfvW9j12iOvZ8PJ2yEd2mVOqYOxrv +GjWruNzRVPIyN1Z7srWRHbXXO24rBdYW2D1c73hkObeqNbvmxf24dHXY5IUsuO6KVCPVbrXZ/BNe +OG/YibfqtqrJ57FDo7cPPdJa+ybJfrrwuY9tYUTa4XSSZN8dTylJFh1NJUkWeWuTJ8mil6kkyaKj +foWua3pzY+wgX5T2UrBjxy8trQgKVO/j7sT3sZaU10LTpp2UZ/IIOmOFppGU13w2U0/Km8DWWd20 +bhV/HN1zgqQ8355m8vL+J0l5TeaH/0FSXos9racG96ZLYvSJwoxfH7or++pba1hsn+r3NTltfTBC +b+obR4au0n5GyB6GZ/TWXp9vXMlmqITyuJ6JGS9V/k1PH1BX5WEi7E080BtmdNZ1PcXvXWsBnzqv +UJNqA7twNxlP6V1tGtCeAz8BevPxt+2DV58+bMx/+b25VV68/X7rxc0nm7dXzxbACLZe3Mrf8HPr +G39tnty+s5O9uLe+NthbX19bvY9nF57/Ev506aA6aWufqmaENWW/sRplE6XetifAFU+vPfGRrJp2 +9+fe44e+0dobNf125dL1uaOZtmS/5M1uV9rdl9XWUYOtF2udyX6XHv/78FPbqB87Rt1eKb1R6xlh +15ZPfbNdPe0u2f32QB9trKWiXVjsSrsLB7VRZ6rvFP75sy3ZL5ufP85+v2tLu3vblf32c0Sy39GL +F62jXn6w/+1L26j7I94pfLrbPurmo7fbrTt88TD+80PbqBBuh46Wrq5dOP9k0f1az3Z/NrWz5odK +0+Tdg15dJktPTDvLTB9kDSLqI1Wjbm79Pqjz2C6bc4/43qpwu3xoV1PxMj25fDSd5KIewbB1A0v7 +m17HPebk+9Y6pjUqDnZU8IhVcaf5vF7TkyszDRVgetiiup7XG89s93ajdyTmiORMU+FyjNjBUS/r +dccO9seqES/rta5wyH+z0eOhlb4r7PG6Qu+NH/XGSr0a3ASP6o1xb7b3299jag2t7fsq3wgD8XkS ++85psxk3sa9JSxCz3RQT+/rWs5kwsa/Jijh0byZP7GvK6ps5byJme2Jfkxm/JcB/ksS+ysbYy+s8 +hVNL7GvqamZEMZNzJPadl0mPmdjX5Odx3HNqiX1NWX0Vu8B0Evuasvr6Rg2NkdjXZKUXFXeKiX1N +J2wMxFNN7GsSeSpRqtNJ7GvK6ptpKa0/QWLf8Jy+zXcIUOdN7GsSW3nTppvY13SGTaFWEyb21bsa +/QLzuRL7WqXO6Sb2jbFpkyT21boa8rBPKbHvfJs2dmJfd6bX1BL7WrK+p53Y19QBhplyYl+Ts6Ue +eT+FxL4mQlFTcaeR2DfKsTKlxL4e/GYaiX1N2+GJ6tNK7BuZUDadxL6mrL7mkJGdqeiIK05H9Dbt ++93xak61v2k2/IZnTY3qnX11POLaV/Y/OWoTOSZ4xW9oTmfsJpr2K34dIke/rTpbXhhrq9w+VQMu +kSQ6UtroiQeV1IiZlnTstmnV5tSXKKg3qmNaVd/WuebEm0bTGuud6q45NcdmtBObjq3qeKe6hX4y +W6uqTLfCe6c1lSm+WP4a8SJ8tylP2Vrn+38TP/4349Xo6imvn+fxv1ZiU3n/77yL07JvM20JZf1y ++nrFXIyIh3bv/012Xttvfs30eWan06jV6/G/0UZI7M3Ej/+JZNP9/t/Ej//NmCy8Ee//9XM//bo/ +jRpd8a2XYfdBjpHjcX9q4U+/7jtxvCmcp/fibiz1xdJ2NxGe7RsZ4TgKS5HQBxW723jfK6evTwQ1 +hhmV79geGdI72RHDdAQ3jhGkhg1qNRbWELrfe2M09PxCPaUJpWBbVz3TVNWqzWG0/eTnOfPLqqFW +hFojYtB7h1pRV6Pj03qHWlFvPYPIuyOpmRBOJxFzck8K3lrsqHouKNCzo15v4Db14geOPZ/GVeRe +htLsZxoTmEdn2nNvvbJ9W1++qGf7Pj8czvZ9fjjF8obobSrvPhtMo/n2IWw+M2vdzRdNu9l8Nr6y +2RW1fWXYO4ykwOGQ7W6FvS1qe//0x3QSY7Sy8/jixXBXD373kjr7pJDSH560e5v7U4GXYz3u3erC +w1t0E8sYppfO8NExOppGGQPT0aQvfJte5DI67jnWY0S17NmRKRTjOYuXlhvu46seKRT9jPcTv/s3 +I/mebU//neM+NsRrjKZpU3n3r11Ut0//TYhu9t2/HskX03j3r0eczTTe/ZvRBwQnv48d7/7NVHOj ++mSnnOfdv5mud3Hx9N/47/71Lt+OFKzJs33fHTvhp1XF7Z3tS72NFn5UjRqV7fvu+JzZvkOJmOmk +1iYkOz5szNOueKN6dnQOIjpk5eCOppJg+jDoqa2N7Kg9P7eWSKUCVHsuFV4RHCf7vimRquJeBa24 +OnQfry2OOIweZrAZeQuvZy5Vn0SqhRvv69qqz9b65FJVlznC4Oq6cmfTmkt1bbFX+nyndu+u57XF +PtezTyLVwo3DumB+bt1zd6xEqtbgJLwr2cF8x5MYd2dsZvEErxDUJMaGuo+7b8wwU8m7XR+0F0Vj +/Wbcd/rGegyTd7NDTnszvapab4wLb0p5t29aq2qdQ7L5fDrWY5ijHhBcPWferXdRNbRjpkc69ui8 +W5pT/3Tsrrxbay7CYTzImwcUmRC5dzs3Xmz8CNfXVu+93pjfvwfr4Mat5ecvbhx9XM7op+0nnGq4 +tftu60u0cPPChmFEbBH2bM72p0o+4KNbz/xRK5l5NMzp/Ks3T3zLVvVpumvrb9+0ZOYttecDnvz+ +eC2sUehaSmBwpS0RMZu/mD9b+rstH/Bd66hYzYWtX3HrcoPt+b9eto66cPfz4Gvb03RLbtQZTShz +m/wkjbxRqzlypwv5ZffCYlxLulxavPX2oGlUGgabXH+Jr5IS+KmeiOjv8P3rT1pGzQ== + + + 5i8ljzY+epbbenLeh45Rty9m7aNuP53/q2nUGX4Lr9ippHrWR33W9cLi/Vfto25uvtyqBo7RwBfR +4Kr+ZLNCf1+5sVpFgZZ28XrQ2m7Gz/cMPl65dqdHl8vXjs42HeOkVb9J6uKoOnvENFTlp+sd9mXl +fD2jM2lf0yV2J/mSzUaPAM0e7Jo6v1FPrhptTGlPixoO3GqdEyN0+7TW++RXjU6uOp2Z1sM0bAce +9TBNX7vTRnfgVuvxiWRTmdbzcWLcuhIA64U0J0iPGxEJavZp5o9+WFVznI27QmfuRg7g2E9Qtsxp +KAZs6N703vixYsBomK5ptduXx5sTSGd7GJid0VAcbo10bb67eaXqCd9seDHmfJoGdX63R3nvUZbb +95vTqkT5ZmWuTmzOnxHVaZbu7SZ6vzlJid0ZlyE5VPfuXGl3zf5vP0SxV0ri+SzS1ShVTkmctLpu +U727mda8tVFazXC9uw4FqcWeVg1FaXDWftoa64mHDmKzNTVN+tPWELE5rw/d5P61XWjj9Br9qF9l +bnUfwWgb3wy/U9hqgUmOhyISfhQn4wspLQo7rWu33cc4XkLb8DseE7xU151NNTNWplc5VikGb071 +/Jsv210255GiemVOXoaAuL69+ztmXuKPiz1yS2f8Gl0deYmjXoAecYaeI//L9uhUod4YUXsGeqbx +mZ0xehv1kNDCUMpvR281LjPhpo3MJuq/zKoHdNJNG/mk0Hib9iB519LbUBZzk9gom3bOlMS++Yij +8m9GJ6r1ykfsConvkZLYNx+xwQ49Tkpi33xEFwx7rpTEvvmIxtx97pTECr50aKFDMbfjpST2zUfk +TTt/SqLb0m4KMlPN9Bo3JbFvPqLTpM+Vktgyp6F8xIrf08xoeF2TP1Y40/+RukkeK/RX8z98rHDY +/PA/eaxwZtQjddN5rNBmrHSLLZM/Vjjzx6UGeXHqjxUOm+3+J48VNoYoTv+xwple73tO8lhhxfyA +aWWt07K7NCpjuf21w+7EmDEePOw2SYyOtuv54GG/qlYTP3joLW4aVa3aHjwcMwbqvA8edr922GSE +PNeDh90mpBaFffwHD5tRsLuq1TkePOyB0NN48LA73MQZuiZ88HBkQtmU7MCdrx0Kv5n4wcPuxdWt +HOd+8LAyk6HXDiu2zkkePOxeUmMw7HkePGxMjuws395/b3pn74o9beIHD7vrljkP+4QPHnZyvnXD +1qbw4GG3NXlmrOJZHQ8eduvDzWHX53jwsClr013B82Na7cHD7l66zA9jPXjY3Qv7CKbx4GG3P8aZ +HyZ88LA7mXemniR73gcPG4RQ77VDX1sD1Tj3g4e1+xhUXzv0hdtzZMcE+uDh6FzcqTx42P3aoUPo +CR887A7x9oTbyR48dGlkTRjpjCnjpVwMPXjYvYdGuJ3Cg4cdd+70R9zT9T36wcPuXlSAmvTBw/7v +FE704KH20niNxk4lGXrwsCPlYnRo7/64Dx52i/lYzVQePGxj668aHJLnSyPrIeurQ3LUfRz14GG3 +77oWlnD+Bw+rG15XKM8jqjc+eNjdix9nM9GDh2299H1+t+eDhxOWmBgOABnvicKhJNnJHjysWMSH +Xjs0jpUpPHio+Vqdb69O/OBht/DThmljP3jY/drhzMTlpuyDh5NaB3s+eNgnF3cKDx52v3Y4M/Y7 +hedKDa6TzuEHD8+fqu+9dugPM9GDh8MmaP+1Q6XQ572P8uBhd/RYna2d+8HD7iCqugXq3A8eNpyN +99ph66aN++DhBLbO6qaNn3jVpntO8OChI2JNrx2eP0Sx9uBhJ1r4j59M9uBht8RoVdzJHzzsTtIV +Jj3xg4fVZdZfOxyW03pX4ao+eNguGlnJZkQVrp4PHvaTbCZ+8NA/zWEHUHPGyjkePOzmFe1B5GM+ +eNjNK6wssNrALv7qkt0ev2wOI6lXxPpmqkPWuSeB2y3C3fH+tSTKCkoppjn3z80bv/wsfWPKsmMt +Vnjm4MjtTbD6eD/TLX1U0VYfIM3n5CQ6/TZHbObe3PLbRxeD1d0fuWmFrK65iw9v3h0Ei4dzq3tv +fyXxybd7WzcP/i6fvryyuPJzaWHteC3Y+frozvzx77Vs7t2nLzH99PH2pbT4c+fyw8fHz9LjH2/w +jkeeDpK94uHW7uD+4GQufbCdfFx79uPlrS/PH2avv73Yf5Qev1rc/+fi6ztLycb3Cy+e3f9x7eD6 +7tH+rcXD4w/58aWT24fZo7nXj24tXIwXt7NL/7y9e3fp97f5t8nRu/1rQgU42/TmyxfPX80Nlt/f +nou+Hr9avh4v3A621u6vBVv/7N0LtrPLz05OPpaLJ6fF67un8++zz6fp57dPNPPzxfKN1ZXXg/hB +eUES8L6vnpy+O8ILfOW8EQcbyEkl5fXPvx58KO/sPf0FtVsfyMRzm78/hpeu3Ln94F7TfvF20ILP +LvPZxBfnWpfLCZaLnxb2n8y/+uvFzYuHJ6tbl6Pk6+/5gy9zX5Dbek/SVed+X/2VPEJA3MNDzpCc +u7P14sWl4OL+F2MXeHJUFeh/1a4RLe7Jupe/56y03uKIxDXtxM3s0jpiBzf+2trf5SdG1//efrab +PVr/cuH26tn1e7dXT7/8uVXO/3iy+fp2/J527vDm9sGr3Xd3drK5z9TRq2Pp17wvuhgu/8iRWPnm +/e0/H8yd8Lru/DxihL5z//XrD8ubr3Z38BOt+cnBAKnEV436fzN9c8KqVbB6toj4hg9nhi6vpoMF ++SlcZJsz7Ul+SL/mVzgXmWjP3V/0642rhtjMLxBbe3tCkPWBfLm1urUZPSyo351geePqpd9bizt3 +74ZXF759kKneX/L/UJ590j8s+394sLxHw+jfVvy/vc/39Q+r/h9+rX/VP4TeH7bXjpHW8OiKD3u5 ++JkbGxR4dNX/29fki3T0aMBPP4Y7F28H4BAXw52VrRh/CIkoHf0Id249w69P/c4/f13G5j69aprs +XcyvOd8a0UUg2Vq4t3IjRKtVJE/9DPdu3cXOPbX97j19yf0i0fb6PDZ8GSnPzKYuRksrCXSDF97G +REu3bv9ph/kT7vNnaweDr1fuPNn758HG/btzzx1man7oelW7bdJM16Klna3rtU6BaZP3+/TBDe13 +LT17cnF/+++/iq93nv+++O/mX1+eBOZsXoQOoaO/f7+/vf7vp9UwWH3zPhZ0e5F4+7BxK9+T43u9 +wrsZbTxdB3N8vSr34HVAMtbfeLjudejcROlr5hRH+Ck2P1W5YtUrerlCCvSitpACsDVQgxopuPb3 +46PFzddrD++tLR2coBhAtrO2GQxeDJOC+lPDCwYjr9wpuILsknN6EU2zl3L3x7JBmbXd96fB6o8L +g9V/Lzy5HF8sf54FweLgdHPvx3HJBIAjqNnWSL8mS3ya4ea72/j12jJdge83cbWv8nFYYvOOPnoV +ADxgsQWRKQPWvMPt9wMo1jurLXaUnUBR5bKHIHR5FxEsehxeDQ4/+lTgirkZV9cvfVaYvWIkdeHG +3R/49ODrjdWNe9ePgmD15oMgSD/fv9VAGSAffH1sqQCN8OaICSZW/+6Of/pWdln3FQ86BydtMFYP +meEEBZimWuH2kS9jbL5P6SyfnUEWeVopgPDgFLAVghW/TePLe8V9TzBj2NzZ4ql2YN609eQ09JFc +2R4kO3d+Bl8uHW6cnNw4uuIzbn4E+/rKQ2WrO9Fi+SZ20pbhmZfWLm5IB3uXa7on97G26vURbu1u +hyrmYVsGP8GzFpldrf578+UmY+nqv1ev3WTUFtirY4G9OVn99/EhZOj44vXrH7c+LL1FUMqj+5Vb +gIUnSygdUc65R5rx9PecVLIo5+0T2QcvH/lyLb/piyWRFBLPuGer029X3p7Enwn3l7fMm9CY6nBN +B6F4pijDWva4+bVneSCTN5KGQQ2MR1Ln4WtQkaL4KT+zpPf+kqKvlWe2+W05mfly9ZnvhqwI08fG +6XMV82qlNlacUIU+PorsdCMSsYmkrc8Xn70jMSDZdu9ke+GjN86aZ86j2sN4034Yt649OWtcEk6C +4wVGHob17Jo+roVeH7dfX/kkHQxWWjtw3ijTB6++qY+uSZiKfl2TgHDbOQ9bhez8C2ELCXs8Wja0 +10JeXltt7IAm8auyaRDkrnTjo7ktRLqXe3QJcr7C7czr867KSDZ/8dnP6L3f9Nd60NZln/MKVy7e +De1Y2ztrHhXI5rFVx15TYhdLMq3v4XJDyRWLh58+ZP6v3/dzf18fJDcqts7gn/e3b/lLWviW+78G +h4X/64PlP/1f3+c3/F+/3rhZPZvtBxdKfw0vF6/5v74f+L2R6Hvd//XXNb9zEoJv+r+ubN2qEJtw +J3tw229w69kd79fP7y/5MyEp2Z/J51+hPxMSmv2ZkLBc3bRwL1u/aWUyUlmitTfhXT6RvtpSq6pk +VNxpaUutqhINM0VtqVVV8gWoybWlVlXJClBT0pZaVSUeZmraUquqNONnSE6sLbWqSmLrnI621Koq +sbl7atpSq6oktk5w+1TMdkcQfFcv40QW5cuHh/YWPN6/Yg5o4cbzK9ZMQeiD7I0VbFDAHcS3Xm9+ +YuEPhHVgMG1nkfEALB9O6x2jG7CHOdpYebvMd0/v1wrjEl9AWD137bq27y/ZMES6jzUvkPFJw5OS +3g1gSH1q/YniVCStIlmEeDUIviwuXrNK6c1rvJDFcPP9tesCu81UAH6OZ8f069ZACdDfCCL/+/Tz +j7WDC4dbzMxEZXkcaqv3Bm/M5m7fuCKq2KNlFuCcgvJ/bs78ked5MFskRTGI8jSZXX32+2D/5PHJ +v1//PZwl2vbnzB+rd+6G4cvDL0dbJ/v7L/b/37ONo73fP/cPz2avza7eeb5+926RbuzvHX3ZnzXE +MP2YewUizDSsY9M3+VY8ngZPN/4pt3/szD+78Wnjn+DNTc8fyrrLUrxzY25ldQGWZZhhr89d2g/v +z1399v05ft0ycqQx/jbaGz/S8WZX5jf2T9Z+by4/fPC6ds1YF0kPPm8ek9bNKvidnfQaCvB9e7v2 +8VH0PL9/+9ZV+nVvhZmHNfVVLOyeVbjBikxa19nluaXrjxIs5BWmjUCDuYsbxerc1aXbtwG+N7f8 +9MKjueW9wSP84dbcyp34y9zVh7s7c1eO54kzfDouKjcmWraq/Xr4p8WirQ/KFp4cMWabs3n+i5j+ +15usOVluBSUfn6uSv8q/4vos2p++74PI7yzZa7NwjKrwO8v212uLK/ba0K8sFT9IbB8kFZ6JyeBu +4BCZ7sRZKQifL7k/+Gu4eWPZ+8Oni+s35A/rEFfd36K1v17ekr/dXXV/iC/++fWO/KF2RcDx6XY4 +mD/09vpV30j63h99++4ATPwK3eZ3y6z90538/pv+8CzkX+NbL+fo1ye3XecfrKHkyRZf7iskau6v +Mc7B61EYWeVBQYLAYzrfJ49XQdCu0gjHF+nXl9zvFXNAq0/exqsPn/8AB3ux7HEwow== + + + NL95sKKjfpRhGPH/wqZtrH66fvna18OFl1vXN5Pvnp3aWLEN5VLftji41ftS0hQP112XTf3ZuNPe +XUodS+5y6V7xtCy2t24v7L/YuPvlxpy9VW92Q+VIEXMkiESGOR98mLdI9uZToqv/5CPZ58crzDKs +5PX55arF/s+7Qfj5wd0l+ultaDnN5/fRzfJuROf1+RP7l/BLX8OOdz17EgBc8uuWpt3DP7cMFbh6 +/OtxMwFQEjM2y2QqMJJrTswynVTcxTUnZpk0TA+uOTHLnKmWYmYrbpPH0XdTpvWQnvpNE38RM53l +G883v6gKrjazitHt/utlZ3Rbf/E5qRjd0p354+z3Q+ng46V6B78/Pzlm4yDOxtgH/4ruDdkHb7z5 +qfbBl0MGxuTNE9/AmB5t1TuI7741HViH6XPTh43JoG1hCdzcwq0PC9HSz7UciLpIyuXXAKi9ZGGf +jq9Y2I8LyzjDVMXVL27rGdP4FkxgAOGsiWGz13vn2MQwsEFhqhfEOOWZxBadza7LYDc4ErPXm7+c +2cuVaHWOn89EfkbbSEx50ZEGu6uewU4sZA3leaXMwfmNpOZN1omMpCaXs/MwaicBY09luQvO0Mq2 +UO3jb7+PvccP205zwRQWrE5ixtThbZ9HvY9PF7aXx5+EHzax4J/vuRbSZtF9bzat10JI7vix2tDH +37Ur4O96bdPe1Zs27G9Tl279nRbzRbb6t8+yzzIXHeIFOxvPP+tYh7WKz8sPl9hMY6f1Yk2P5c3f +SuzWITSvWo6i9X17yuuesed/Ka8r6fzfyuu8aSSy/4/ldV8j+B/K6zOmpkvxP5bX+Wxa5OspyusV +YvO/k9cxjGdM+1/J64xpJLKrvL7mzs1cWSsgk+puviSR11zFTxfu8a1eliZ03QhpBhBgwdvfneKv +qxVnNkHyEzbqGuc3Sl1XjLrPE3urri0ey626vcLFzHHn/iKh+ZW1Ge8/yS3doCv4tpaPqpk9/7y/ +/U7l6suapLMOM/BqgwV4ucH4u2LsvsYRPmTyvZm/2ln/+OPOF5DTAyM0r1y8+03tuUtqRFqDs2Bg +lYHt28sQIR6KiHwK4xICTGA9+rB5+MW3HBH4EoGe75/9/sVN0g9r+1//PXzw6b/7JzN/hLPmv4D+ +w795ORtGxWyUpvRLCugDkmAWufVsuDT74JA6+bB65+Rs49+9s3+PDj+d/Hf2GsN2Hz54eXdj9tqs +af2BWv85u0hzCj5Qc/rTEhutPmCmH2b+CGbv4J/d/+BfEsaCQU5jDrIC/+T0Tzn7A38yc6OG/8Vv +9+in7wT7z2wy+3D27d/B7JeZcHb3Ga0kT6kH+jxMskEUFsXsz5k/iiwcJHmWOeADD1jE0SApgwhA +/VyBB019Ust/Zv648htzMf/RJLMwGERxkM7GeT7IwzzG0FlSDsKcvk3jfBAnUYxvsywbhAUttAKM +w0FQhOFsXMaDII9zBkblIInKfDYuMppPzPPJomJQ5EVJwHgQlvTXLKIRizSioctBnJYlQyLqiSDp +II3C2T1MMBsUQZnNxkkyiLCgLEgHRRIUszGNUxYpTTOnJUYRDRjSoqMwwocpzSjPI1oZz7FI+MMI +vafxIM3zcHZ48eszf2wBszZm/kiCcEA7Ta1oz2moEDsT59EgTOPYATGtPIqz2Sylcw8KmkQU059C +mmhMP9hlxFFEQ4W0RjqjIkginmtAH9CqM5ooZhEmgzSNIoZEIW0RTQfAIKC/ZlFKyBXzttM+DOIy +oU+yfFDEtKsAluEgDbELBe2UAdFeR0VIIEKCskxDAwwHWZzQPiTRgPYkHQIGqTnIiPY1K+hg4ogQ +m04CwDhKBiUdMbWkDQ6oTzrdOC7QkmCEOWVQ8h4nJUZOw0EZp2aqeRrjT4SlOSEStqWkn9Moc8CE +1lsmQcLdhyldp4TOLy7p/GIgTEknStuSAKsD2ts4pL/SijGLJCsGYULTjApCpIDwICkJ6zLCsYhR +pAT20ibHYUwQ+gGoa3ElipLMATMeHdOg+RBeEvak+YDmRTtEo9CKQkwjy+g0y4xWR5tf8h3LaMg0 +DaqXJ6f9SUtaTAWYEOEgfEwTwoQ4jgyMMDiOk9mUrluZmxOjXabdDfIqkJAkpQOmidFUgxgbkNMO +0WQJy4AgBU02p2sX5rhtKZ1MkhCgHES4FsBgvpB7mF4wiGkts1hPWdDwgJTA4SzBvY48AE0wpGH3 +zAKihGCEcHQzwtk8pYkGGW0WHQCNmBMkGIRhgguT0/dxaL6jCxgX2OWU1kMLywlRgxionxTUPWFJ +XgSE2Sktha5cHBBC4kOiFPQxNSsK0Nw8K2kNOK4yxbYWNB5ubZ45CI9HOJJg8gQsSmpPKxoEEW5V +yViGjaI1cM9EjEJaAr4LiZAFhASuVUjXOKPJuAED2rEkTioDYm/pZEs3YJbktGQsULY9I5SI+PrT +DhO1BToRVaLB04QJUpjRrTkAkNAkBpD2JouJFKaE/HTxQAEzHCphNRETzF4BNImE7palkxaY5LTL +JU0xJiykk81mEzrvMCDsphtKN8AgNV1IM/uYRk4LxqwkJoSKCENioDdRxSQg4lviB96kDESbEBLT +S4CFcconFtP5RwFdkISIYZaVCZNH3gDc6wTIHAd01Og7iUBdwwSTiMoSqy4ckEkcdgA0wQPGhIVF +QVcqC2iPCXmYINFtjeOANj4KiQSC3uaF6RDsKQ1psxyFFwh2jfC8SLLca5YSDYmArWBFJaFwQihJ +dCSaTctkkIQRn11SRGYfUhooKYlH4+wIO0Jcezp+YlAgPzQmoews0XnsFv0gx6sQECTC/iDFUWsz +4CWReoIkxIcTgtBmhLQ8ghBViIntgyAFBV0k9E/3jaaf8yxKOpCQWEdKRICIII1FNzahyRGEyG2A +Geo0BIJpCKK5ZjQ63VpaCF29EOdJp0DsiyhLWtKcA2LQQGSiWAmtlc6ERICCeYRuEOEwLQWnSLyT +blXquOkw0zUcOQBHVo4JLhxFxFx+NgGZR9FUYogWuH8hEWbmUXRHygCD0FIzoASYTkD3AcPSBuZM +2wuIIjFtWQIuBxwugLqxEXIyyJeE5USccG1EwkkI94qAp2FvLnO3lLghWCVx1zTFfOiHJKM9Qp+E ++z5bFAg+BBslku5axeigyFhWInqSzQ6v2+wUiQhEQuLU8QoIdGAHYZhWGEjGMwVtcgwElDwigkVk +kBCXxCeib7mhi3S6JU40x+4lkJ48ip7RbSU2Gzv24EGI2EdgKfRhSF24s+UPCXtCyEVEKGJCKh4I +YiZRWYgShpekReoI5V7TKq10+9JKuI0SORH8QRnl+Sx6DA3+OBjRm5CYmQJwxqDnAMQgWHTfkiJn +zhcFdDAkGszSKulmohExlIKmT4AA9zWi1RJ+F9qCviKxl1gEoUGIrYjpXgHCJCUE4hNS8ndlQZxT +ITyc7d1rRmdGko0PwdHFEUMizG3PW50CieUMQpKNfAitPEvD6ogkGlP33jQi3POARySGDHroQbDL +ZW4+tEDdmZCYDslUHiAyhNXbGQzHXNftZ2lEYNl0zDsjhoxjicCcwCMEJuf5wINBUs8SpjwKI4zl +Th2AFhdnsTtjYhsk8FY3nWhfQHIyHRaJwwEINd0EOgvirxFEFfs7DpjIAclWmTYhMp6VtMfaBfHI +gq4AsZQEQi6+IZEzDCGcRJDV41kAaOchipg9UQAhfZSapSuMSEyeFEbjsyA9spBoekQ3VfYwBM0m ++cnhH8anYQJoQ4oQaJZDnRrqyMeQMKdbTCfttyJySkqE1xPNOM18ZMPUaVNIKXUwzL2AwBSk3qey +la57OuUiSqo3gxRbmkVc+VAhcskE4l9F6V73hgheTDqVP56F2C3mqVsQ7RD0jAMfRCprTmgOQAHu +lhEPKnGDCijO4LUOtzClklBxFgJzSQjokEkB1B+4qQB8+kHkPGJSZYmA9AwaUMQg6RavGY2JReWk ++dAEg4gJhaUJ4HVE5x1ArsxeA6k09DWCzgckpaas+/30YQW4HQ2QxEbXAjPBHpN6TEIDzU8AGACC +UEi8URuRpkIaUjwLFlkQB1EA5MqEdXMFyd4eeDDaKBYJI1a7iTnrrhCgJBT3t9LB6NKQqOB9Za9q +FEPUD3IF8Fc0bgZ5WxqRqEtn7XXDWjptqgDwFUm8JAOVXiOw0CBy3ZAMzYK5P1aYGwHbNSKRJDEY +YRaqLbx1hSSe03HPpoZtk2RAGOFtjv1dNpA31YBIHCCVIDV7akAw1ZA44Eaiq0tqJWi4HYaQnbHe +HxriErTViGRXbl0QcY2ghMtGEKDIDZGNrMINQSrEULSjpCcV4MchhC7dYgHwV5DNYQYjOh6GBldI +EWEMY2HUYZOdzJ7BFNMoMtIhjpOE+sh9RUjJIpEA+MwTI8rSWEHGmEL3JsHuiMSg+G5b4CvWY/MC +6yozsByYhyC46eACIPQOjPCuIB+9BaYnCE2t9NE7hT2srKKBwgTl9CvBJvqBZI0qehPbCkIPFpEc +WoQG3003CQwMRVlBb1LikygtvEZ2P1w3IdacVa8SCbJJVHr3jYgbVGV3j6WFty7S9YhcF4reQnv0 +IwHIFu41EC1Ly3KYJkijEokCtIxlWpIdIYQGJGsSBTD6WpmY2xGxOEuI5UsvEHphAyQp2tgziFmS +BFoUTjQaGs2I6wqW+fIkqOsscmuCUUpXbH7xtiQnus43XrafmG6Zhh51IQCbMfztp3GztPQaETeg +9cWuG5Kso6x60mwM8rEKxozCo1sRKZg0sSohS2H7CvxGAlCUdgCHwbBXAR3sumGZAhvTjwTgkzKB ++bSMYEmMiye0SwHCaGTSAvAn7RoJQGiifuVRGBlfKR5hBqFTIRRP8UsI15457iAkdVTpieCEUjcF +WGa814A4BqnZdG1sJ1C5YPIo2aYflTCfB04MOPBhROJymD+h4JZFXgEYe7f9CpuMKGCSGmdJFY1w +NdATzYy1Ct0uontsYFPSCosd2KlsDdZQWluz7A4s2LAQyDppn4n2h3Fl4dqzUNYC9v00cQA6/Sgh +OaayXSSCQDjRrvkeKU03v1kexO0ZIJOHf6CMXYsot64HQSreF1gOI4ehBwbGC9AbowAiI6Qo0pqh +V+f6u78tro0ApJcSlnuPKcBRQOoKMdfEP5aYpLg8A5+0q45JGDTM1CJtTHoWnYrPkmPSxZi32rW6 +JtpJiYtc2V/XsTYitSaOHAPU+VW+Ih2iCFzXEVHHJC5LdzBsQE0rR8mGVtJz9Lw9gDkdBTg5Q/qR +i6kDeYASDosKfhbwHLlGsFRGcFn5ACsoCQ1QkOXz+g2dC7tqhm5nxcRFqEsE1hOvBST6BWxbMMqK +CsleEZANT70w5qJQ2aQxfcWh+4hkmBDuHk9RIC2GWB1MPREvwP1OQlEBqxcBWMXyeGscw75X5oqJ +7JSDm8SqwMZdBEajWrKihjRRVLH0jraWTrvIfCqpSxIxEDbstMgSh6cyX9noPWMbjg== + + + CTdFh3C/k8xCc+degjh3gHWz40VMPQsMNynMzGHph3JSMQkKaT5bPznPk4gtSCLcTMuVcKoR0SNS +FRXGXkpcdgeAaT50MjdvQsyqqOhMMZyqEFP0klG3QZY5Wqiux8TBSCc29lclArpgb+c8GJMTXaDF +WtfAqn2Vj2QR7Aslnd0BanvhIz9wKKHDkeX99GFynQiFy7x0uELyWMyEx8MV2HmIJThcIXEsSEqn +icRQ4IMo9lk+bL8xjlI2PCYJKIM2INsSgwuGURXDcFugr7hGobEsSNcxrgturkgO7BYpDBrpSfJN +TbQNScuEzGVYmSCLR5E7JgewR+AAqjIryNMpFKaXVuYsNMQBbAu7UhiBRIzTdSnAHo0n++kyhHPF +9ENqNV0LIBEyDUNfzoT5my1Z2iiBNT4oPQCpM3Bg+WMlREaywo0PD3IGocR9JQAnZzqYLD2B/7Zw +eogCPEFTYYTGQZmYXVWYHI8AFBMSeCNwO71DlVm7RrCIl7lDBf3KYzKyIYo/7DFIncgCx1ueJokv +1OheKyUABU4IUYTd4niIeFfkU8UWklRI6C1m3Z2U21S/uD7xo6tHH2W+gqMwYEeJHuV+6p4TWWUX +pH++oER5xvbWJMjhTEmtV0MBxAFYp/WwlmRc9pPo+UIBA0FjwsE+IkKPuHD21j0bl5DAipwMaCcz +HqvIYo/+47zyOKyQP2pdlD6xkinr/sqU/VPBXgepCCu6CKXOrItmWYURlKGxBCp1lgkr8SJAWUK2 +9nBNYdZqA4dWmoRubO3FYx987JCchZhidXTMHnWtrdJuRYxLoNwZvuQgcmgujFI21P+I2xaFG0pM +lXoMCEYSWiqLUDlFGjG6A8A8CzKTsZv6RwWaVUY4KgtQtBAUFNWHv4qpA7j/RRiTVfiAEHxNNKg9 +/wqQYh7FBt0NQGZcvyQeV0xIHKd7XPpmiiSgWcNxKWYK4zelDsRMkcASkVXdT3RD6VoUuTNTJCFN +n/5xZoqh0cxMFOzdYoXJbaMzoLON1Pbofnfk1sEsTeZ4nzh3xqIkjCFDVK5+Eoa0LM/uiuiDJPHM +rPC/RiwWOzaSkPYTZH4bYtVZmXm9BCakyqcy2LA8c4YRAALE2Sht0hbesuBriBJdOW1wAteobo0A +vANWmGesUJhcYwew90bnXLnXdkZ6uRRgeYj7yvEQRREh49gv4imqCyqWecyADl3tFIoA8ncHcNra +EOYYOwUCOIKscLbYnz7MspGEVJ0yDyMHCEtEoeS+I4GoCzhe6TXKSZ0InC0YLSJILk4ddB9ZQoeh +kggbpABE02WhT9SogfVZyA6QNMvBiSDHKTGXhOTvhBYJkpQaDQnRMEFAag4zohw9E8cIiKhZv1IS +IWaOcFka8EelcbIjrBJagX4k09EW/l5zpFziTCPEyUn0j53OjTCeIs+rJ0QqEIdrukY5bXuSed1I +C8e1XCOLUa6RnIMO7h1WDFXPO0BdvB6WAizqrpvdYJhQ2QMfZjVYBYhQgYgjxA3YO2lHz4i2qCyg +iyDkNHFFiNMDsfcctA6mHWfUY6z3XxfqiR06uJAaORqr8+I8s9Q5k/nMLcZpE/u73BwHSNXpMnSP +PDMggrs4bsUzAxJymtBefytpYTZq0HC6RkBQBG5kHApx15Dw3bc3JSR0phCHlXyRWMp6l9AhahAk +aVnBCf1I6BDiz9Cj4kQaQ9qp2GYAKxAPJcSKdjpBnKngqA8QWcZ9JLdIxxbc1wl6F4RjTRMnNpOI +RBJ5mjTcGP9a1a6aoI1OUC+MI0vaj6w8Jk0oikK3N4gZRTS3v4FJBBU4UrGOJHoTvCSaCAKtSKQs +fK1bz08koAMfZvmYnISiehqZCG3PXOlgVtzSPaR947BQ4tSkZvDnxj1tN5XjnmiuAfgaLaIM0Tgz +QpKuijabLq5dqd142H6gRerROEBhfB0ISBbmLIfM9iuMJcuUsen3rEx4fhzdyR9Z9HGrspdCSAOt +0MSMeLbxhORS3hfhxDYqmaeiB58jVhi+STlljiesMigFCc4pQNApx77kFdNoktEKaTWuUUYHHgQe +KafJkshVZRskqxbgXu4S2JW5a4IQSLgovK/SwgQS6wWUjwRViW7R2ovKrSVqnbJ9SpZOMnEUGkVW +ASS55BVJRWGC4PKVInid1FmxtcxNaL2QblDAErEbTkdMSXRm6UXERDo/Y9LzyHka2ItjNYiU5M8i +KZ3AnoaW/oqMj49C3NHCaS9piFCbIFbymJKsyyEq3hbR/hLqeOY6jAXDm/sdNoci87kx5hyluesI +q+KjU7kRkfAIlRYSgH1FQBNEENFiOGQYsczCU+v75+slJdC+dHIx9hZRNSUdOeECI6sCCFk51SAp +0TWCOizX2DOnxOkbboXQqek+ilhFXI9IZVDRSzkSFQGGghQKEO0xDUsOvrX2bP9EhJ7pviFMGZLd +0KrMijVrQND0J2Cx9SNKACziC8owUtR1AL3XDmRlZvTCEfdytVKSJrKo4iZJYwQrBblKg2lcGMoq +0YYpEcs8RcQZdBwTI4m0AkRB0YLyCOhN9zNGkhTUwAymvQgETX/HJ3Snsyz3mpRmWzSWiighjRy6 +kfkrhCzCQJSbVA8FyGy8sWnPojz352d1UV2CmJkAiByhWscXhTWKWhhim6VrRR4PwNfDAdwpeCBz +XbRnOUsCRLFHo/dMNHRals7MpVN2X4WI5XNfrZvDYwOf53hV1FGag0gURL3CHcHOfCEVAmDsTY23 +3TWy5EO4H6hQCjmNXSHmdillEj6qjSz3Qy9ZQZOBJdJGcZqgbpb8DEfUG+gAufHRVL4CUmMo6Vl+ +16FFcQqMoYdvREA8HTHOpUTGizJlGwGA1BOO8y/08ocBUhrAFXGAUYpwFmT8GJs9guIjkCzh33sN +t9gIyymhEzMNIXu43EVmCb6VjhzAiEaIxzfIruoFsgEY2y2xTBHcC+uMbUInTV0Uie90y+D7AiWy +RAq/s0VGJG0E0MdllPlCP2BsthUrGDIfiNTG3lcCcGYoB7MWLk2kkzVKgpznSdT5yKIcwKKursqz +vGQIYvYjTpCrYJyUgvBlZsJovK80C0tZs+Y8KCCtmpzwFdH/CJdQGyH/InQxSylc+b5FBx8RjC+j +ThAxMrlnhkqJJ5Z+VBN/RSJpnnoj6e/MTf5rmpjPBAl0JAXQ1yFotgXseXk/glw5otf0HNK8NPRO +1FSQFURhlKFaGg4MCP5PsQHq79aUp7/ncAYbgi8g4SOC5T6AHRw+vafrU5ZeALdmk2gQrh6UH6ur +nStQL5H7ECEgRS1iGBeJWYIfMgwcYzKhvWX0Q4J8Sw8Smd3xpwGEDYM49ZvZS6j9K1L7kdL6ofI5 +ycBR8ykybVjssradvQbq4mnoGdG+EPlyIhAiV4PIcwmx2YqaWGoYckoEkbKoRIqE5K2KgoWsH0PS +Q3OT97xMICG+ev+Fripp8aixLlyIrQPYsZSqecqS3mb4rswxpixkixamR+OxM+1ZYDofYWe6LE+Z +I35C/CYs3bKIEcWIqNHNQDAt8mBFR13HRmcmEN8zVmj+sZhONG9ZHBvIOEmQNesZQJFPlnsgjJam +iRNedT6e5IBJ56EXK6aHTAdPVzFlAGmkhSowewYTBMYuJgewMrx24wn1GSesJl4bO7boSkhjY9+p +jM0fFdafaA01ukwjMw0hqqcI6C7Jtfjp7beKd0iGLsIyVpkQqeMZyaVCnfa8xHERATOELkB9EEVg +aCwzj4wIY8jJRo6DZwjYg81DOZckZSq7g66GdHlxw2AKxDBJitOONOtdGCmynqICRjiPs8JzmCOB +XRsJQFgt8rQ5h1B1EWRKcZakTkcnLNc8RWZIXmFcSJPijoTnZAjshUFIclsAyHnzSkRAG8qFJOwo +KlU7zZBMj0RauSOcbRWAizvDTkZCKQmmsdfIHJlodzjTiJNtbbe4aQjjZQ+nxS7cNETtIiZIrgRG +y5BPq/eBhOQAHM7zamQkrZUQ4PWOCArpfYhJ/o5IT/HRH2EzrNMK/ttJD/3u/LYKkhsiAylliBOj +9XghHJgyJy/KFaGFEzVxFnpNIfepB/RMsBzxIGQwd7EtSIZKkMmbljq/dW//ZJ8PzD7zcCI42nRi +kRnwDfHtqjAnfWsjOtkgguvU5LMoMolBgKds895tTAkSyYPUhMmYY5HL5xM8hdnNQRg1xHPR3PQy +emquJtPrDmYIukoSD2AvX+Ure9eUAMtd07Hlo4b5NTHlHEFVUa6X96fJlSRtLHSoL41EFsy4rEUa ++6IpUhnjKHaR3EgHN+njIqcjzRSx2l7qDQoIYKtypNzyR6Vx/SgGS4UBLyDAwSLpOTP5LHrFJNPS +M6wh2Z2Jhn5VIGsRCTbWZDW0GT7hB86CT/uEX7ZBRSJAOGdf8wZ1EIXsebvumsmeOx7ChUISSG5E +pSNLEYGHZekMHTotD6JTsBD+DpGLbKTQZkiNzBkADqrHB3MI31beaNq+MMLkCc1CLiGAfEbOVLOz +ylAMAqRXzR3r3m5JSAmn29KFLEKPN9vkV0V4RKUGReTTkJyGCWLgs6UhOaZXBM4lDACbuQSF/K+E +XsCWlOWJBs9kyFFOQs8h5ZDegJB0y8U0rGSqSbiilvA3RDmy0uOX2ihH0jUAibFAI+ZHuFodk8x1 +zIn9sxThIVgOH2zpidwOYPGGZECSJ5Oygl5aysE1g1e4tDYpU4QiRMJJGVXQy+vNoonOyoPIFBx6 +aXkOrxWJdhEnPhr8kpIaPnrlKJMA8VbRC6Uq0izykF6LV/jo5WpVODOTLlFSS0kONGYTIUhYHand +Lotgz+x6iDoOIhZpaQzLffIIVTuI7XoikKtGYmEoRWJchpZwuBYqAqFjdseJCJST7AyvvEW4PIyN +C8jhJNLRC0SMaxOaZB74S4yqJHavAY88ai9FWDwNTM/AaWC65SKbacUU0Tr0dD0VTIuviK6i9VlE +49JN8VQw2W7RwPR3GUnQ1FPAcLBs+xYFLCepP0UBCVGd9FQ9DUx6FpCemShgWizGU8ByxJIjHE0X +hdYcoyATjEvD7D0FLE9yNpV4+hdAJbQZEX20VozoXyiGExZRJQ48TyLr9rIwHU34v87H4/eYdJEW +jhvqGYsUAwAP7ilgevVEFnONLCvWbjwJlCQWI4C7RnZwofIkcZgMLU8D0wpBImK6hRoxpo6oHiPW +ffLpJJ1GYXK2hbylyAtLQ9XAtFaOp4LpGYgKhmmUsBqICjY02LoL9tT6PLLNP32YXQdtZgCyJ/b5 +PE9NxoDnz8pzJLgULnoVlX5iFsmt7Z0mPggjJzfjoyw2JYP0uIjMBdDNhRbkRGjipEbuiHKwkCkU +hTY4ovuliDC0KH/nae4xpHDxOfGC6VSz2ClbOZzCueObmEVRwn7kdC09HDFX60EoqU5KU93G47aA +BWHphs9TLpHlsBru3rxIfQejzk+vmSxCBQqpveSJ2VqhyTUaAqTGnCYA/gpBEIEnqw== + + + FAimSRIPgJCHKPf9PHoEQtQP/NJPVmIHIOTaCsI85CsB8PioPlam6rR3habsLgKQVm3yOeFYxjEy +hlPpwoS16qp8HlMgmoMLmVhck4U1ASSg1MFkVTphiyuybM8MrTdI8EdvkKAwQleDooJfcuiKTnLD +dPtyqKt5xRoyhN5WLkMcMY9nJwWsJ/pgHEMWBgALMLKSEvEcsVNIcdAlMlFKTc85MCASSFK9fgX8 +8yhyIAiSl4gciSo3n/Qq4wsWvCfpNkGZKiUFMrpPqGWGSqhlDe4raeExBVm8jI8JhnFSKMksgtRU +vPHYFoksRgwSLlWQNMcnLzJ6Edi6WJ4qWAQFcnAd2yxCkpiS3FnIiihmJ64/VAQXWBCpEkFsYJBA +HdEZk9QRZ0ns2xgKuOGKPPdtDAX8d0Xm3P8YzSQA2+ukPTmhzoFsRzq8eKswwTCMKkHcOmm/kQHY +2+IATup0XVt6jlXEcVmoVlOgMBr7UNxdwFmU0EAEVdGIbSWioxQhJCLFemwPPJeFSe4QAUYHE6wr +olCzeljywFcRrrUniuhgrhEdeBgkrpuQ9GOPjfGULUoJcuitUHkbYS0wZnpuJb1eSijA6YMg8i5p +7SZ7zLzIIhP47DFzV3/UMPMiLU1El/BpknNM1SaPmRcpQuvjzGuEaJDEFQgpECbIaq6700UCTAjd +FS5QOhHbLQS1SAJjQfW4eYFailGq3ByLYBeCkpP6qjxuXqQoXAeR23HzIkXIv2PmJHpZV50hawVc +/hzs4SFYjL/ljplzYVasT6gv7Rn9hV1PyswBY8FaRsf6giJ3MmqBKnJhWgkXkvkJM8caAmh0wmBJ +dqN9jCo2syID7sWJ12gIgNZB7jPzgku+OTGBWKBNTPIAEaoeeLxc99vj5Q5muZ6ilTAjPTaPl2Mh +pAy6ADxCfyQXOl4OQMFlLB0zL1AgDLGQlkIVKHcEmV7pCsLzuEKlY+ayUsU0VEQK8qbfhZPr2t2a +EuvNtogii/Y4eZFBmI8cp1YMFPQlhCHqFVawy5644hJ1GCMWTTdP7pvHyYdQ29VLQ/1Hw3lWSHtk +PflnBYo0yJidqBiSJP8VXMmUbWBxYqorKmgPn8L7g2gvryHp6RFK3qyA1QdsG0NyOnZsBZ4KRMPw +t0FsdC5vWLhnUaRyBdp3zoaPALFeaUxTJnnSxl/4UITacr00HQRxKgmXqwpyo30piL8NUaqLsGoF +anXM1kkHKk2VY28ZSK+LMvk2M/U/ViA4l+zhBk1CoCO2IEeEqgeCPydM7bcKJd7KAStlySXtqDfY +h1BNgqacGdJQcr2a0I4aG81MAmfgoCPGgYqakQlDIkhuIumQUQ2yaIbMTToUknOhjxKkMJoprZMU +vmjWteGyn4ZqOCDk4ZwLfWUID0DNT7qaOW8ako/sL+abyIqBzAm5BSo/IXiTVhdnFhKiGElleakt +iwzDVsk5SmlkqgVEuSmqQUwzMCUXBGKwrzTqlWsWISyL6EJk434dJAxMRof50AJXUIgZtTMJ61Db +hqjpCmImAp7s0G0xHKTMpB6PjZn+CVhqbO4CK+mE2HrMOdl0Hg4QmPIi6/jKwlZSLL0EyXQw+qEk +cYC/ZPvpCk4FqFiiJAiqQuBCsUuEVlWiPCRtLV8y0KGSEJKZh7YiHDMFfFaQhpaZEDkaw8R3rUCZ +4NQymINhZl7BDuAoS5TpBoNSCD5EORO+6KnheWVmohdcR/AyQZZSCD5DBB6Mza4ZcVZWm11P8AiW +3Lc3XmyTA9y0UKUrwZ3XrlDXCXSoskIU+EKwtNuI2OK32yx43vgu+luKOMCgLLydRx3jDDuop6MQ +e4Y4V4HJWR/4sMSYcnWNijKyPgFgBhFiiIrIoRH881BZEXwQIFwnNPfNIHjBN4Nw1aC/3PIytEkp +UIG5wiUCb6EUmoIMZizUlIPlBbkznNvEBeUgGhBJAYMrEZBsHCBmLKwVQYZcu8ReQqwVlSBxLqha +EIUwKVlAbMO5ddbwt9qazyXKnkEjjlNj4C5RZyzmShikECAINkSSBOqno46OwSbZj6g0ZtoSZYC5 +jGVhWEiJWmSoxCoAxojABHjKpEuU+oJ4qwA9LkdwSvg289DRG70WYIMRFw610eL+WPAaobqkTqhk +56zbnDI3MTX+slA6JOKyFawCO9YoFlvHP+WzdWaMJoJSDv7Ag8FsYbiHBSgywO8I26YAeAISgqqN +zKyFcpcoKYQrFIbeUuGK5sKAFsfh68sTjyrWSKehqCjkqrKM3KOfBsYCjxIGCHmo760yg5HyyuqF +F6lOyYJ+JpRDZTafwKhK45qJ/uJ6QiwzjHM+SVP9xDWLkSjPtFC6Eq22MqKotW6Bonh7H4Ymxrry +YZiYOsZuxAB1RvLIQdTAgg85UsMaUCBlOGBemipAOgW1gvkDqjnNdV+kxveInWeqYCxjOSYFYhoZ +c6I14qxktrh2EYBoh95nYtNZgVwLz+S6WNnQFwrYBNbNJea4FTgy4MF1k3CQxMTxKQS9iTlYgegN +FSqQr7mC0jYZ22sjo/JB6DOxJRBEQ6bukYlRscZYgwOQ+AOYzo3PYwUusLg0APZ4KJ76Nly3cjFb +KxtyE5U2bLhGZq33GZJiGEVAF9lmHhr9sXJiuEeoV6+CuDcB20wn7n9na/07BOGC7pGHkurMUpzx +fEwOj5BpixAuoEyErAZxn/p3VX2Mbg8gDUexJ6XA0YLvlQ2zG8U6f1agq8Wl8UaFCDNcgZoI8UiX +gmjbwCRji8nUY1eE7BxYoN4xsS9H9hVktdVyRXvD40nDRdmNkoV8niXb0TKmXToDNaxh6syn6CaT +6MHSnF2vmNJyD0Y3xZy1B7G2NF9AUfsDbpcJN0JSCcIygHnsV1GAk08UFqYmN/XA60o2RgcUWbpA +hXrwKaHue55lTNQOpVayd2K3lN/5o8LsmHDAgs6XZH7XiFQU6iVJKl+JYqsTJGabZGBbiTG+lMTX +UoS1y7JYqElNtqGTYSxgxVRUCCHnkMLONAolgiFUYTiU0i/AIULrtC/K0KhAKyg6z0o8KgCzhgCf +a2lGLJAJxSQDF8JEORV2SCwHk3Bdwd2MmAFIUog6Bs2A8h2Yh07KwGbhKG2EDJamfF8ssSlRUjsI +C4djLEyFJhPTybyEsCmyzp3MG2YmSsyn1yqFKbkpuRw780p7H1XG8jmLCGe4/0iUF2lS25QolE4S +SJWR4WGFIPJISVFGHJDqAQKTV69LWTdWGK6VojvI5iZr4VkBjnCdGmH8KE7G9W8ymNiwGIEwapXW +uKHNVBrRQ3SQXI0JQ0KLH2+QluYlHnzAyeg/faIMeRVmXgXEgQmJdcRcIOuee0uBB4Ynw6PlPhUA +QhQK9pQJ15Y5rBuXK7sL8P4FqA6TwNCENqF0H8Q+fXAFHUDQYL8s3u6AJpGaiMHhJZr167aEFpN/ ++luF0BSEhB74QLlAal1zlwxl0xEVt4JqZpl1fRSItQELFg2+KGwYzQoK5sBaUhT4U5mqMMzfIROA +CIrYGrR3IWpqRRVaz8ecmSQHEVt13kob6yu2gu1LjaCjSwGHwUqcmrcUfpo3GIqYT9oC9VUGFUk8 +SG7Cz9e9xxuUBhxUgPKMiYPYG48wQNZgfPFCg9j0fmtIoRIGDU9TmYM/tDGNeqERehhWhFyOPsuT +qtgrDz24VhIWpsRC36zwSUyG5NI89ZtJ4KjrSuJNKwNKVKprJjHYTRAoqaFZogPKTkgsuW6hxndX +NpXaB3B/u713EKnM4CD2GNcrHyJhx77WoUCUbWIjN79NBROQsjE3MwVVVoCLRbtecmBvBl1SLjvi +cdnyIJd9z8XHC0j3Xj+SIEEB7Hk4GPLTXrGLRRWAvnDlfZWj/AxEQCU+EtqlxEfC2bwJIoTMVATQ +RjYwznVjAULo1r3ouZUwMj6FgxqQA2YcQGL6JMJOIXsmGIunxTSNIyzwVzhEVpAxhWdiELfGbyzo +efKKbSAnEauSqZyG9XrnSfcyQSy/UrQ9n2YI0N3yiIlx5EGQygU7aoVmCP+q0AyYUjmPwdGb0Ma4 +FrlJCFMIepP4ZgUeeG/DqD1bT1ub4awTlsmhQ1jNQc5/JUpN4pIHsTE7eRhYgs+cwsZvwG4f8vRD +k2GkmNME8T+MLTkTW7xrJvKEB4nVBOQBRd8EyrDOiLfOUEPWtUFklg3b9oC0STG/JyZrFM+G2xvx +aux54byYBqf3OLLr2Eaduzi7iol0l9Qg1d45b8bmBDi6L89BitEH+WhsHvSYvmZZOkyVREwr+g2P +5rlekbXE+ytWRswkLkwgncA0al9vG5IT4hIqEqIlUyN+aRbDCnyOHDME22HG1D83FkcdTyFYA8mY +YZR7zSTDU3vCM1mcD+QPiLe2jHAs8+K8Sk4st16PofU5SQCp1RwJwnoApD+uUhFIEDvXMOD3s+D3 +xOstCGVBARIproCELn7tsIDCRIQqLIxYuI6vYmOs9mx/ChPbnwLkhBPouqF35HsoSZIbW7g2yqGe +OqcU/ZGIEHI3ne3P1DopnXaIMiElEslFaOLiMKln8MZXMEBAd3GNUlOuXgzeDuD8Jgrz/CYOJpZ5 +D2LNBlr+xdehTamgzNOLuMBJVnr+Aq1wYq6KXbGUOFE01+opKlRoFSZfGtGyOariaB0f15WtIeSb +GbkSmGeLRJUyY+aUbgg/AmOD8UaDqbDw1S4tsud6QmRKGSXV9Ul9PrcNUpXNbVVk6XplRyOIqrFn +r9HSaO5wFOLMEgrz3CYOJmgVZiw7KsLI8nysAnuFf1KRCOm+/G6D9ZqYd91S32mCN9z4XTy5P1pE +U64BCnaG8Dp7ThMtQSnXPYZsC3lLDA5S9dPzmWghS88IpeVLxSii1UrFZ6L1TD2fScyvGsWJ+kyk +PqG4TLQeoOdc0N0Qn4nWSxQXhRRU9NwYiiIyZyADzcb5UPTYPZeJqeNUeF9JcSVxmSRQ5JELLGOt +G1rCApvADnz6InPEG5cQZ2XDEqhyBT8KawBMlSyl0qUKbUP18hC90DmBXPv7UwQmOsw6X5IiNQGT +WnsKcaMIe/BcLwrz5yw1cLhyO529lCSS3dAKP96WoSYOB4LKR1wNxLOWcUGOyPjCBXm1AIdsq5YV +kXujzMfTa7VAiNydNEiM4icBA6YkEZJirEltHcU1IvYEqT5u65xwcRtV21HdJmAxATwqRKEOW+9m +BbXDUUsRfSHsBTJuGBu+jb5InzKWSLuTWsRF6ILWZ/GCHUg/JxWjiNw2SW0aB8Azb6mP1Fr2Rg8E +fnxwWgVImQd/s0UC0hPC62/QA3QoKVXhf1XEplQGKrfjGTbXSI5I3gL1j0gKRuiJ6OAKCLmyAwTe +IlYxpeRICmvl0C0V80Sa4a0+2krh4HyuSKeEUiJWsAMDjMAiIK+b90YdxBp9PIgxaq373zkW7WBs +sketFQex9uuUOKFxbHkMxRQQUqajJ6ttSDQ177TCPMGZ1Hy45rzVWKB4pJwQr7Vyug== + + + i88wUxL4+AlO10yxWxhmSmsvifVU+DPXs8l8pq1lqFxXUl+sMmKQDSrWCbwmi1wnN3UuX4VIBH+B +clvF1q+X3gri7nfHZB3MM5x6QGtKVCIjZzosvBrBVgvIe35bBxNTBz9+mgVewIWWYfb9IOCVnHKs +5hZli5AcWPROOK+PF2WRmVlaYt4JQ+SYCWJAOVo8I4EwL67+wKWEUZpCPTZ7XoFl+Ig4zdo88Bp7 +5hwtp6yOrD1Tc5hr6DrpS8rsehCZqucnU4lBT1vfKFC8Qbl2Yu1lBb1QZZ5VTtfMvhKh3cc4vjQN +K9ilT0W47+QlEXcakBcQY1g5DWS4QY13zVCFSWxYLNmhqr5RrxyKKcxzLzmYJUkKgIzG4pY8OiKE +bc97dEQooj4OIo34FRJwF9AszJUXjGD6yLFZfXJDZSuo9Lj3nqigT6eIz0nfHVGAvCniUXV9n0AY +r5bj18HhJLZCgPD4GNnl8FRpI5hVOXxPZigV0j0PWIxbjTfRdEL8EDc/MWf4YMw11jPfQ6cVx8VU +rZdTexGA5zYbutXGsM8vBIXsT7G2pp8eUGx85l0hI23zC9sxCtKEkI3sHPbM2zAkmLp4KH0+R47W +vORTlP5q9JkqOW59AUhWY573SbLKxmnXsrtBbIr/6R4gehR8UABA49DGTwgMaIwVxJH3odw4/D80 +OINrCDeybH7PPGljYILGkX072gGwnrjidYhxVcB1tBE8kbgqwuoBCPEymdgF9swz2Xi4UnR1+V2V +GPu7nuC6+0a9DgceTIxYOrq6InGs/PSi75fXvdawA30yTIOE8ZIdy29+MLE+qeaaJai6xCRWuuKn +A1NlePiMX++EzisEXF/81LBfB0EgQWqUMAV6VMo8AZkrnuBhSw7IF8TF+52ZvWFCbvQ5TLnMeFQT +kZiuF/sapkdtIlStc2jEr1iiALoC+IHKuEJr9HVVHQiBk2UYewDSJ3KjOwit0XcltZFstM6PXzXM +U//K4P06IkruGjmApTX8bCCi9P3ryS/uJY7Y4KFJfhdYu+EnyPOKQqGwlcTYGc1zmAKUWHAHQSIn +x2fIcD4CmvcNy8iZNc2TcCzlWedVVMC0wVFQTpxS2qIfKplw7E4omV6CPXlHjb3AkfHWOzoJLkez +8SBiot1rIqfWf0w0LEjBEy1R+Wme22bjgx4jQiiz0Kl8ChDLA+OmhYkBULsRe4W+2i2h3vgKWh+W +i3ArmB70uWF4WxF84N4ptwaVPcw6MZmtcjdCOGDj1Kn2+kq0TBlfkRSXpM4AGNKlTfDgnoaeE1Lk +CQdieK9Bo352AEuUCKyEbsRsOCjLBuyHsL0FJlCCE97wHRJHitBDBXmkWmUofaDZj4qIgtBYbITy +6DvijuzIQ+qaRMD7H+JVBxj5bQ1wPQCNKscZcSIX2pSFfc+dqC1HSjr012YSzaSHq+FG/olrXJQH +sUqWm6rnsdR37GETZ/egvmftUhvkCXNtgz2l9ZYSsUFEPUSkY86hJ/aehggKKnP4J0qO7cBXIQ6g +9BxqISp7FpmLLg6RgYXMdo8phnDPJ6hcYE0vcn5i8Bq6O84VgrA94CzH8iEQhQsZm1fBJZQPykKS +etE1YH949duP5EtMjoDbPuR0g3s7FRV6bZpVNhgUg5mQOo5Dm8QiuIgMkSCvaaMwsrBuYHkgkMR3 +b6Mweul7wNks6NzwrD9yVYvSM0PD05bkVc0EVzCIQv8qmCdJVO+BCy3NPdKKrxIjpenaUUrCBP0L +GY1NMpEvJdgEQUXS2BaZVVTWJfixezZOy4/dAzXNXegejc2GX0txkKaDOkJe4B4QD5kkftxeiGzb +jA3bdvgQiaGwxagKGyIyF/l2vooUcjQfR0JaYhES3kVR0QRwyqODSY4UYuuS1DvFMLKVVf1zdZdG +VDnUimFTj5e9QftVeAG+e4h3N4H8CivY5Zh7QVaJjRKsBBlDLfXceHAelT7ZQKQwc1ovfoz4OvJW +NQoFUcj+N1DoOQjVi/aVfrxYXwT2cv6VOFp1cA/AJiw/0FfvnRfnm8bWqyrSbRoY8VmjfIcIw7pL +jtX750VxgeSHLoZLflXbCewMfqwWVogYPUipXvwWYrqMH9fCFID4rdK88sMH4EdvUVuSQvzgLYRq +Id5BIzMK8wykC90YMKfzfLj1RbkkQXbSwrVbcBInO+ATo+itmNDOyAFXOFgdXhzxo3sQa0SkOTug +MwY6mBDWFQ4v5aQcizomf9JLYILPl3aGHbxyC+F/Z1FOvkItIebMnmwXJqY6hrteiNjPPZMbAk7L +qJoQQDumsfLGZJOyhdTLXULEiDkzz1KzEtrica4ZSTxcC9h1BYZV1qIhoZ/E0Ji9ZnkttBuQLC6r +sqtrJrsA5KTr4hlvcNjE/avbiTiJPPY/w9uPuWdvcxBn4VGYpzspTJxuwIkY76II8dUpefxcVyNa +BOTjJMmcnwcbRWJ54WtP6ClBRK3A2O3g2fY5aLeMKsZ+xThRqVBRqnAalrBE75OYS/A4UMzJ054d +yTIp3+OE6jmZ8zogKkRDm9krbd5+EvMAXEcW5DvuLUj99vZ3iTJAyaA0DlWK93i+KvqWo6KkMPgd +FzDy1F2w7tyUF5ETgzkhivV4OJ05SH2DnJIAEdfdplqNTwHi0anc/9CVdfaANoTTg+TGqAY/HPNM +hWCHieyHECYFhpwizmoUABSFWLDA5rSj4FgGIVVgyDsoUy++O+LCARgrMMEhrBNC+itcJJUCUlhe +YO8JzWPXKwmXz7YWV7jVMgeD2SHiGB6OI40UkVa4grc1t4pMBBE0MnHt5itxmDmAtWSzAdLCJFAZ +ZsyIg7Bs2JKOJTzRfGXHt8EtgukioasQ530U8XMpkfPxKVVVfjDMNwwrfbA288elO3fTD5uHXx58 ++u/+ycoKA+IPa/tf/z1cPzn6dTrzx+/T/ZMv/+6dza7iL4dHAD/8dPLjdPbH4dF/DmcPj85m/z+w +qDv4Z/c/9AX/L5h9Bm5t/lt8+4y6PD07+XT279Hh30uz1PI52oT0E/7b/S9+u0c/fScES2f/M5vM +Ppx9+3cw+2WG/kpdweZlSaw1RYH7ES2vAolpPvco2ArsXNJYgSHre9qaOGw5u7g0u/uaZ64jceEI +BG/6IymwNhJKUWhjBcLu4RrXBgoDmDwgHfgjkS4X1KDma5P8zH/wxvKgPQfzN9ANVttB162/hR60 +Yw/9n///2X//sVhFaGZx6tKlJ5++7r84+fTvwf7JzB9fTz/9P/uznw4JlT6d7f+iP81+Pdk/PTs6 +2Z89/Xb0H0DwkX5w6dLmY0Lg/wtaFrGb + + + diff --git a/logos/FRI.png b/logos/FRI.png new file mode 100644 index 0000000..556d698 Binary files /dev/null and b/logos/FRI.png differ