From acba0a81fd12ac298d695f6141d9876098f6e088 Mon Sep 17 00:00:00 2001 From: Dragorn421 Date: Sun, 12 Jun 2022 14:53:02 -0700 Subject: [PATCH] Updater (#91) * Unconfigured updater from CGCookie/blender-addon-updater Using revision b12d8e202b55a4b7191fccc4e74a77f0cbc45a46 from 2021-06-21 (latest as of 2022-04-04). https://github.com/CGCookie/blender-addon-updater/tree/b12d8e202b55a4b7191fccc4e74a77f0cbc45a46 * Configure and setup updater * updater really wants a version number to work, welcome to Fast64 1.0.0 * Add updater's folder to .gitignore * Add .gif files to `overwrite_patterns` * Revert "Add updater's folder to .gitignore" This reverts commit f30cd4d7cc1a08435dda4d80d0cc3b3663ad3779. The updater's folder name depends on the name of the folder fast64 is installed in, which can be anything * Add updater instructions and notes --- README.md | 32 + __init__.py | 19 + addon_updater.py | 1744 ++++++++++++++++++++++++++++ addon_updater_ops.py | 1532 ++++++++++++++++++++++++ images/updater_after_check.png | Bin 0 -> 88170 bytes images/updater_initially.png | Bin 0 -> 81896 bytes images/updater_install_main.png | Bin 0 -> 90668 bytes images/updater_success_restart.png | Bin 0 -> 96913 bytes 8 files changed, 3327 insertions(+) create mode 100644 addon_updater.py create mode 100644 addon_updater_ops.py create mode 100644 images/updater_after_check.png create mode 100644 images/updater_initially.png create mode 100644 images/updater_install_main.png create mode 100644 images/updater_success_restart.png diff --git a/README.md b/README.md index 8b70e8f75..dc8165dba 100644 --- a/README.md +++ b/README.md @@ -48,6 +48,28 @@ There may occur cases where code is formatted differently based on the code use ### Converting To F3D v4 Materials A new optimized shader graph was introduced to decrease processing times for material creation and exporting. If you have a project that still uses old materials, you may want to convert them to v4. To convert an old project, click the "Recreate F3D Materials As V4" operator near the top of the Fast64 tab in 3D view. This may take a while depending on the number of materials in the project. Then go to the outliner, change the display mode to "Orphan Data" (broken heart icon), then click "Purge" in the top right corner. Purge multiple times until all of the old node groups are gone. +### Updater + +Fast64 features an updater ([CGCookie/blender-addon-updater](https://github.com/CGCookie/blender-addon-updater)). + +It can be found in the addon preferences: + +![How the updater in the addon preferences looks, right after addon install](/images/updater_initially.png) + +Click the "Check now for fast64 update" button to check for updates. + +![Updater preferences after clicking the "check for updates" button](/images/updater_after_check.png) + +Click "Install main / old version" and choose "Main" if it isn't already selected: + +![Updater: install main](/images/updater_install_main.png) + +Click OK, there should be a message "Addon successfully installed" and prompting you to restart Blender: + +![Updater: successful install, must restart](/images/updater_success_restart.png) + +Clicking the red button will close Blender. After restarting, fast64 will be up-to-date with the latest main revision. + ### Fast64 Development If you'd like to develop in VSCode, follow this tutorial to get proper autocomplete. Skip the linter for now, we'll need to make sure the entire project gets linted before enabling autosave linting because the changes will be massive. https://b3d.interplanety.org/en/using-microsoft-visual-studio-code-as-external-ide-for-writing-blender-scripts-add-ons/ @@ -61,3 +83,13 @@ To make VS Code use it, change the `python.formatting.provider` setting to "blac To format the whole repo, run `black .` (or `python3 -m black .` depending on how it is installed) from the root of the repo. The (minimal) configuration for Black is in `/pyproject.toml`. + +#### Updater notes + +Be careful if testing the updater when using git, it may mess up the .git folder in some cases. + +Also see the extensive documentation in the https://github.com/CGCookie/blender-addon-updater README. + +The "Update directly to main" button uses `bl_info["version"]` as the current version, and versions parsed from git tags as other versions. This means that to create a new version, the `bl_info` version should be bumped and a corresponding tag should be created (for example `"version": (1, 0, 2),` and a `v1.0.2` tag). This tag will then be available to update to, if it denotes a version that is more recent than the current version. + +The "Install main / old version" button will install the latest revision from the `main` branch. diff --git a/__init__.py b/__init__.py index 113619fa3..3f3ee111f 100644 --- a/__init__.py +++ b/__init__.py @@ -13,9 +13,12 @@ import cProfile import pstats +from . import addon_updater_ops + # info about add on bl_info = { "name": "Fast64", + "version": (1, 0, 0), "author": "kurethedead", "location": "3DView", "description": "Plugin for exporting F3D display lists and other game data related to Super Mario 64.", @@ -246,6 +249,7 @@ def draw(self, context): col = self.layout.column() col.operator(ArmatureApplyWithMesh.bl_idname) #col.operator(CreateMetarig.bl_idname) + addon_updater_ops.update_notice_box_ui(self, context) class Fast64Settings_Properties(bpy.types.PropertyGroup): '''Settings affecting exports for all games found in scene.fast64.settings''' @@ -326,6 +330,13 @@ class Fast64_ObjectProperties(bpy.types.PropertyGroup): # # scene.currentGameEditorMode = scene.gameEditorMode +class ExampleAddonPreferences(bpy.types.AddonPreferences, addon_updater_ops.AddonUpdaterPreferences): + bl_idname = __package__ + + def draw(self, context): + addon_updater_ops.update_settings_ui(self, context) + + classes = ( Fast64Settings_Properties, Fast64_Properties, @@ -372,6 +383,11 @@ def register(): blender_3_1_0_and_later_unsupported = Exception("\n\n" + msg) raise blender_3_1_0_and_later_unsupported + # Register addon updater first, + # this way if a broken version fails to register the user can still pick another version. + register_class(ExampleAddonPreferences) + addon_updater_ops.register(bl_info) + mat_register() render_engine_register() bsdf_conv_register() @@ -435,3 +451,6 @@ def unregister(): unregister_class(cls) bpy.app.handlers.load_post.remove(after_load) + + addon_updater_ops.unregister() + unregister_class(ExampleAddonPreferences) diff --git a/addon_updater.py b/addon_updater.py new file mode 100644 index 000000000..54149ab3a --- /dev/null +++ b/addon_updater.py @@ -0,0 +1,1744 @@ +# ##### BEGIN GPL LICENSE BLOCK ##### +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +# +# ##### END GPL LICENSE BLOCK ##### + + +""" +See documentation for usage +https://github.com/CGCookie/blender-addon-updater +""" + +__version__ = "1.1.0" + +import errno +import traceback +import platform +import ssl +import urllib.request +import urllib +import os +import json +import zipfile +import shutil +import threading +import fnmatch +from datetime import datetime, timedelta + +# Blender imports, used in limited cases. +import bpy +import addon_utils + +# ----------------------------------------------------------------------------- +# The main class +# ----------------------------------------------------------------------------- + + +class SingletonUpdater: + """Addon updater service class. + + This is the singleton class to instance once and then reference where + needed throughout the addon. It implements all the interfaces for running + updates. + """ + def __init__(self): + + self._engine = GithubEngine() + self._user = None + self._repo = None + self._website = None + self._current_version = None + self._subfolder_path = None + self._tags = list() + self._tag_latest = None + self._tag_names = list() + self._latest_release = None + self._use_releases = False + self._include_branches = False + self._include_branch_list = ['master'] + self._include_branch_auto_check = False + self._manual_only = False + self._version_min_update = None + self._version_max_update = None + + # By default, backup current addon on update/target install. + self._backup_current = True + self._backup_ignore_patterns = None + + # Set patterns the files to overwrite during an update. + self._overwrite_patterns = ["*.py", "*.pyc"] + self._remove_pre_update_patterns = list() + + # By default, don't auto disable+re-enable the addon after an update, + # as this is less stable/often won't fully reload all modules anyways. + self._auto_reload_post_update = False + + # Settings for the frequency of automated background checks. + self._check_interval_enabled = False + self._check_interval_months = 0 + self._check_interval_days = 7 + self._check_interval_hours = 0 + self._check_interval_minutes = 0 + + # runtime variables, initial conditions + self._verbose = False + self._use_print_traces = True + self._fake_install = False + self._async_checking = False # only true when async daemon started + self._update_ready = None + self._update_link = None + self._update_version = None + self._source_zip = None + self._check_thread = None + self._select_link = None + self.skip_tag = None + + # Get data from the running blender module (addon). + self._addon = __package__.lower() + self._addon_package = __package__ # Must not change. + self._updater_path = os.path.join( + os.path.dirname(__file__), self._addon + "_updater") + self._addon_root = os.path.dirname(__file__) + self._json = dict() + self._error = None + self._error_msg = None + self._prefiltered_tag_count = 0 + + # UI properties, not used within this module but still useful to have. + + # to verify a valid import, in place of placeholder import + self.show_popups = True # UI uses to show popups or not. + self.invalid_updater = False + + # pre-assign basic select-link function + def select_link_function(self, tag): + return tag["zipball_url"] + + self._select_link = select_link_function + + def print_trace(self): + """Print handled exception details when use_print_traces is set""" + if self._use_print_traces: + traceback.print_exc() + + def print_verbose(self, msg): + """Print out a verbose logging message if verbose is true.""" + if not self._verbose: + return + print("{} addon: ".format(self.addon) + msg) + + # ------------------------------------------------------------------------- + # Getters and setters + # ------------------------------------------------------------------------- + @property + def addon(self): + return self._addon + + @addon.setter + def addon(self, value): + self._addon = str(value) + + @property + def api_url(self): + return self._engine.api_url + + @api_url.setter + def api_url(self, value): + if not self.check_is_url(value): + raise ValueError("Not a valid URL: " + value) + self._engine.api_url = value + + @property + def async_checking(self): + return self._async_checking + + @property + def auto_reload_post_update(self): + return self._auto_reload_post_update + + @auto_reload_post_update.setter + def auto_reload_post_update(self, value): + try: + self._auto_reload_post_update = bool(value) + except: + raise ValueError("auto_reload_post_update must be a boolean value") + + @property + def backup_current(self): + return self._backup_current + + @backup_current.setter + def backup_current(self, value): + if value is None: + self._backup_current = False + else: + self._backup_current = value + + @property + def backup_ignore_patterns(self): + return self._backup_ignore_patterns + + @backup_ignore_patterns.setter + def backup_ignore_patterns(self, value): + if value is None: + self._backup_ignore_patterns = None + elif not isinstance(value, list): + raise ValueError("Backup pattern must be in list format") + else: + self._backup_ignore_patterns = value + + @property + def check_interval(self): + return (self._check_interval_enabled, + self._check_interval_months, + self._check_interval_days, + self._check_interval_hours, + self._check_interval_minutes) + + @property + def current_version(self): + return self._current_version + + @current_version.setter + def current_version(self, tuple_values): + if tuple_values is None: + self._current_version = None + return + elif type(tuple_values) is not tuple: + try: + tuple(tuple_values) + except: + raise ValueError( + "current_version must be a tuple of integers") + for i in tuple_values: + if type(i) is not int: + raise ValueError( + "current_version must be a tuple of integers") + self._current_version = tuple(tuple_values) + + @property + def engine(self): + return self._engine.name + + @engine.setter + def engine(self, value): + engine = value.lower() + if engine == "github": + self._engine = GithubEngine() + elif engine == "gitlab": + self._engine = GitlabEngine() + elif engine == "bitbucket": + self._engine = BitbucketEngine() + else: + raise ValueError("Invalid engine selection") + + @property + def error(self): + return self._error + + @property + def error_msg(self): + return self._error_msg + + @property + def fake_install(self): + return self._fake_install + + @fake_install.setter + def fake_install(self, value): + if not isinstance(value, bool): + raise ValueError("fake_install must be a boolean value") + self._fake_install = bool(value) + + # not currently used + @property + def include_branch_auto_check(self): + return self._include_branch_auto_check + + @include_branch_auto_check.setter + def include_branch_auto_check(self, value): + try: + self._include_branch_auto_check = bool(value) + except: + raise ValueError("include_branch_autocheck must be a boolean") + + @property + def include_branch_list(self): + return self._include_branch_list + + @include_branch_list.setter + def include_branch_list(self, value): + try: + if value is None: + self._include_branch_list = ['master'] + elif not isinstance(value, list) or len(value) == 0: + raise ValueError( + "include_branch_list should be a list of valid branches") + else: + self._include_branch_list = value + except: + raise ValueError( + "include_branch_list should be a list of valid branches") + + @property + def include_branches(self): + return self._include_branches + + @include_branches.setter + def include_branches(self, value): + try: + self._include_branches = bool(value) + except: + raise ValueError("include_branches must be a boolean value") + + @property + def json(self): + if len(self._json) == 0: + self.set_updater_json() + return self._json + + @property + def latest_release(self): + if self._latest_release is None: + return None + return self._latest_release + + @property + def manual_only(self): + return self._manual_only + + @manual_only.setter + def manual_only(self, value): + try: + self._manual_only = bool(value) + except: + raise ValueError("manual_only must be a boolean value") + + @property + def overwrite_patterns(self): + return self._overwrite_patterns + + @overwrite_patterns.setter + def overwrite_patterns(self, value): + if value is None: + self._overwrite_patterns = ["*.py", "*.pyc"] + elif not isinstance(value, list): + raise ValueError("overwrite_patterns needs to be in a list format") + else: + self._overwrite_patterns = value + + @property + def private_token(self): + return self._engine.token + + @private_token.setter + def private_token(self, value): + if value is None: + self._engine.token = None + else: + self._engine.token = str(value) + + @property + def remove_pre_update_patterns(self): + return self._remove_pre_update_patterns + + @remove_pre_update_patterns.setter + def remove_pre_update_patterns(self, value): + if value is None: + self._remove_pre_update_patterns = list() + elif not isinstance(value, list): + raise ValueError( + "remove_pre_update_patterns needs to be in a list format") + else: + self._remove_pre_update_patterns = value + + @property + def repo(self): + return self._repo + + @repo.setter + def repo(self, value): + try: + self._repo = str(value) + except: + raise ValueError("repo must be a string value") + + @property + def select_link(self): + return self._select_link + + @select_link.setter + def select_link(self, value): + # ensure it is a function assignment, with signature: + # input self, tag; returns link name + if not hasattr(value, "__call__"): + raise ValueError("select_link must be a function") + self._select_link = value + + @property + def stage_path(self): + return self._updater_path + + @stage_path.setter + def stage_path(self, value): + if value is None: + self.print_verbose("Aborting assigning stage_path, it's null") + return + elif value is not None and not os.path.exists(value): + try: + os.makedirs(value) + except: + self.print_verbose("Error trying to staging path") + self.print_trace() + return + self._updater_path = value + + @property + def subfolder_path(self): + return self._subfolder_path + + @subfolder_path.setter + def subfolder_path(self, value): + self._subfolder_path = value + + @property + def tags(self): + if len(self._tags) == 0: + return list() + tag_names = list() + for tag in self._tags: + tag_names.append(tag["name"]) + return tag_names + + @property + def tag_latest(self): + if self._tag_latest is None: + return None + return self._tag_latest["name"] + + @property + def update_link(self): + return self._update_link + + @property + def update_ready(self): + return self._update_ready + + @property + def update_version(self): + return self._update_version + + @property + def use_releases(self): + return self._use_releases + + @use_releases.setter + def use_releases(self, value): + try: + self._use_releases = bool(value) + except: + raise ValueError("use_releases must be a boolean value") + + @property + def user(self): + return self._user + + @user.setter + def user(self, value): + try: + self._user = str(value) + except: + raise ValueError("User must be a string value") + + @property + def verbose(self): + return self._verbose + + @verbose.setter + def verbose(self, value): + try: + self._verbose = bool(value) + self.print_verbose("Verbose is enabled") + except: + raise ValueError("Verbose must be a boolean value") + + @property + def use_print_traces(self): + return self._use_print_traces + + @use_print_traces.setter + def use_print_traces(self, value): + try: + self._use_print_traces = bool(value) + except: + raise ValueError("use_print_traces must be a boolean value") + + @property + def version_max_update(self): + return self._version_max_update + + @version_max_update.setter + def version_max_update(self, value): + if value is None: + self._version_max_update = None + return + if not isinstance(value, tuple): + raise ValueError("Version maximum must be a tuple") + for subvalue in value: + if type(subvalue) is not int: + raise ValueError("Version elements must be integers") + self._version_max_update = value + + @property + def version_min_update(self): + return self._version_min_update + + @version_min_update.setter + def version_min_update(self, value): + if value is None: + self._version_min_update = None + return + if not isinstance(value, tuple): + raise ValueError("Version minimum must be a tuple") + for subvalue in value: + if type(subvalue) != int: + raise ValueError("Version elements must be integers") + self._version_min_update = value + + @property + def website(self): + return self._website + + @website.setter + def website(self, value): + if not self.check_is_url(value): + raise ValueError("Not a valid URL: " + value) + self._website = value + + # ------------------------------------------------------------------------- + # Parameter validation related functions + # ------------------------------------------------------------------------- + @staticmethod + def check_is_url(url): + if not ("http://" in url or "https://" in url): + return False + if "." not in url: + return False + return True + + def _get_tag_names(self): + tag_names = list() + self.get_tags() + for tag in self._tags: + tag_names.append(tag["name"]) + return tag_names + + def set_check_interval(self, enabled=False, + months=0, days=14, hours=0, minutes=0): + """Set the time interval between automated checks, and if enabled. + + Has enabled = False as default to not check against frequency, + if enabled, default is 2 weeks. + """ + + if type(enabled) is not bool: + raise ValueError("Enable must be a boolean value") + if type(months) is not int: + raise ValueError("Months must be an integer value") + if type(days) is not int: + raise ValueError("Days must be an integer value") + if type(hours) is not int: + raise ValueError("Hours must be an integer value") + if type(minutes) is not int: + raise ValueError("Minutes must be an integer value") + + if not enabled: + self._check_interval_enabled = False + else: + self._check_interval_enabled = True + + self._check_interval_months = months + self._check_interval_days = days + self._check_interval_hours = hours + self._check_interval_minutes = minutes + + def __repr__(self): + return "".format(a=__file__) + + def __str__(self): + return "Updater, with user: {a}, repository: {b}, url: {c}".format( + a=self._user, b=self._repo, c=self.form_repo_url()) + + # ------------------------------------------------------------------------- + # API-related functions + # ------------------------------------------------------------------------- + def form_repo_url(self): + return self._engine.form_repo_url(self) + + def form_tags_url(self): + return self._engine.form_tags_url(self) + + def form_branch_url(self, branch): + return self._engine.form_branch_url(branch, self) + + def get_tags(self): + request = self.form_tags_url() + self.print_verbose("Getting tags from server") + + # get all tags, internet call + all_tags = self._engine.parse_tags(self.get_api(request), self) + if all_tags is not None: + self._prefiltered_tag_count = len(all_tags) + else: + self._prefiltered_tag_count = 0 + all_tags = list() + + # pre-process to skip tags + if self.skip_tag is not None: + self._tags = [tg for tg in all_tags if not self.skip_tag(self, tg)] + else: + self._tags = all_tags + + # get additional branches too, if needed, and place in front + # Does NO checking here whether branch is valid + if self._include_branches: + temp_branches = self._include_branch_list.copy() + temp_branches.reverse() + for branch in temp_branches: + request = self.form_branch_url(branch) + include = { + "name": branch.title(), + "zipball_url": request + } + self._tags = [include] + self._tags # append to front + + if self._tags is None: + # some error occurred + self._tag_latest = None + self._tags = list() + + elif self._prefiltered_tag_count == 0 and not self._include_branches: + self._tag_latest = None + if self._error is None: # if not None, could have had no internet + self._error = "No releases found" + self._error_msg = "No releases or tags found in repository" + self.print_verbose("No releases or tags found in repository") + + elif self._prefiltered_tag_count == 0 and self._include_branches: + if not self._error: + self._tag_latest = self._tags[0] + branch = self._include_branch_list[0] + self.print_verbose("{} branch found, no releases: {}".format( + branch, self._tags[0])) + + elif ((len(self._tags) - len(self._include_branch_list) == 0 + and self._include_branches) + or (len(self._tags) == 0 and not self._include_branches) + and self._prefiltered_tag_count > 0): + self._tag_latest = None + self._error = "No releases available" + self._error_msg = "No versions found within compatible version range" + self.print_verbose(self._error_msg) + + else: + if not self._include_branches: + self._tag_latest = self._tags[0] + self.print_verbose( + "Most recent tag found:" + str(self._tags[0]['name'])) + else: + # Don't return branch if in list. + n = len(self._include_branch_list) + self._tag_latest = self._tags[n] # guaranteed at least len()=n+1 + self.print_verbose( + "Most recent tag found:" + str(self._tags[n]['name'])) + + def get_raw(self, url): + """All API calls to base url.""" + request = urllib.request.Request(url) + try: + context = ssl._create_unverified_context() + except: + # Some blender packaged python versions don't have this, largely + # useful for local network setups otherwise minimal impact. + context = None + + # Setup private request headers if appropriate. + if self._engine.token is not None: + if self._engine.name == "gitlab": + request.add_header('PRIVATE-TOKEN', self._engine.token) + else: + self.print_verbose("Tokens not setup for engine yet") + + # Always set user agent. + request.add_header( + 'User-Agent', "Python/" + str(platform.python_version())) + + # Run the request. + try: + if context: + result = urllib.request.urlopen(request, context=context) + else: + result = urllib.request.urlopen(request) + except urllib.error.HTTPError as e: + if str(e.code) == "403": + self._error = "HTTP error (access denied)" + self._error_msg = str(e.code) + " - server error response" + print(self._error, self._error_msg) + else: + self._error = "HTTP error" + self._error_msg = str(e.code) + print(self._error, self._error_msg) + self.print_trace() + self._update_ready = None + except urllib.error.URLError as e: + reason = str(e.reason) + if "TLSV1_ALERT" in reason or "SSL" in reason.upper(): + self._error = "Connection rejected, download manually" + self._error_msg = reason + print(self._error, self._error_msg) + else: + self._error = "URL error, check internet connection" + self._error_msg = reason + print(self._error, self._error_msg) + self.print_trace() + self._update_ready = None + return None + else: + result_string = result.read() + result.close() + return result_string.decode() + + def get_api(self, url): + """Result of all api calls, decoded into json format.""" + get = None + get = self.get_raw(url) + if get is not None: + try: + return json.JSONDecoder().decode(get) + except Exception as e: + self._error = "API response has invalid JSON format" + self._error_msg = str(e.reason) + self._update_ready = None + print(self._error, self._error_msg) + self.print_trace() + return None + else: + return None + + def stage_repository(self, url): + """Create a working directory and download the new files""" + + local = os.path.join(self._updater_path, "update_staging") + error = None + + # Make/clear the staging folder, to ensure the folder is always clean. + self.print_verbose( + "Preparing staging folder for download:\n" + str(local)) + if os.path.isdir(local): + try: + shutil.rmtree(local) + os.makedirs(local) + except: + error = "failed to remove existing staging directory" + self.print_trace() + else: + try: + os.makedirs(local) + except: + error = "failed to create staging directory" + self.print_trace() + + if error is not None: + self.print_verbose("Error: Aborting update, " + error) + self._error = "Update aborted, staging path error" + self._error_msg = "Error: {}".format(error) + return False + + if self._backup_current: + self.create_backup() + + self.print_verbose("Now retrieving the new source zip") + self._source_zip = os.path.join(local, "source.zip") + self.print_verbose("Starting download update zip") + try: + request = urllib.request.Request(url) + context = ssl._create_unverified_context() + + # Setup private token if appropriate. + if self._engine.token is not None: + if self._engine.name == "gitlab": + request.add_header('PRIVATE-TOKEN', self._engine.token) + else: + self.print_verbose( + "Tokens not setup for selected engine yet") + + # Always set user agent + request.add_header( + 'User-Agent', "Python/" + str(platform.python_version())) + + self.url_retrieve(urllib.request.urlopen(request, context=context), + self._source_zip) + # Add additional checks on file size being non-zero. + self.print_verbose("Successfully downloaded update zip") + return True + except Exception as e: + self._error = "Error retrieving download, bad link?" + self._error_msg = "Error: {}".format(e) + print("Error retrieving download, bad link?") + print("Error: {}".format(e)) + self.print_trace() + return False + + def create_backup(self): + """Save a backup of the current installed addon prior to an update.""" + self.print_verbose("Backing up current addon folder") + local = os.path.join(self._updater_path, "backup") + tempdest = os.path.join( + self._addon_root, os.pardir, self._addon + "_updater_backup_temp") + + self.print_verbose("Backup destination path: " + str(local)) + + if os.path.isdir(local): + try: + shutil.rmtree(local) + except: + self.print_verbose( + "Failed to removed previous backup folder, continuing") + self.print_trace() + + # Remove the temp folder. + # Shouldn't exist but could if previously interrupted. + if os.path.isdir(tempdest): + try: + shutil.rmtree(tempdest) + except: + self.print_verbose( + "Failed to remove existing temp folder, continuing") + self.print_trace() + + # Make a full addon copy, temporarily placed outside the addon folder. + if self._backup_ignore_patterns is not None: + try: + shutil.copytree(self._addon_root, tempdest, + ignore=shutil.ignore_patterns( + *self._backup_ignore_patterns)) + except: + print("Failed to create backup, still attempting update.") + self.print_trace() + return + else: + try: + shutil.copytree(self._addon_root, tempdest) + except: + print("Failed to create backup, still attempting update.") + self.print_trace() + return + shutil.move(tempdest, local) + + # Save the date for future reference. + now = datetime.now() + self._json["backup_date"] = "{m}-{d}-{yr}".format( + m=now.strftime("%B"), d=now.day, yr=now.year) + self.save_updater_json() + + def restore_backup(self): + """Restore the last backed up addon version, user initiated only""" + self.print_verbose("Restoring backup, backing up current addon folder") + backuploc = os.path.join(self._updater_path, "backup") + tempdest = os.path.join( + self._addon_root, os.pardir, self._addon + "_updater_backup_temp") + tempdest = os.path.abspath(tempdest) + + # Move instead contents back in place, instead of copy. + shutil.move(backuploc, tempdest) + shutil.rmtree(self._addon_root) + os.rename(tempdest, self._addon_root) + + self._json["backup_date"] = "" + self._json["just_restored"] = True + self._json["just_updated"] = True + self.save_updater_json() + + self.reload_addon() + + def unpack_staged_zip(self, clean=False): + """Unzip the downloaded file, and validate contents""" + if not os.path.isfile(self._source_zip): + self.print_verbose("Error, update zip not found") + self._error = "Install failed" + self._error_msg = "Downloaded zip not found" + return -1 + + # Clear the existing source folder in case previous files remain. + outdir = os.path.join(self._updater_path, "source") + try: + shutil.rmtree(outdir) + self.print_verbose("Source folder cleared") + except: + self.print_trace() + + # Create parent directories if needed, would not be relevant unless + # installing addon into another location or via an addon manager. + try: + os.mkdir(outdir) + except Exception as err: + print("Error occurred while making extract dir:") + print(str(err)) + self.print_trace() + self._error = "Install failed" + self._error_msg = "Failed to make extract directory" + return -1 + + if not os.path.isdir(outdir): + print("Failed to create source directory") + self._error = "Install failed" + self._error_msg = "Failed to create extract directory" + return -1 + + self.print_verbose( + "Begin extracting source from zip:" + str(self._source_zip)) + zfile = zipfile.ZipFile(self._source_zip, "r") + + if not zfile: + self._error = "Install failed" + self._error_msg = "Resulting file is not a zip, cannot extract" + self.print_verbose(self._error_msg) + return -1 + + # Now extract directly from the first subfolder (not root) + # this avoids adding the first subfolder to the path length, + # which can be too long if the download has the SHA in the name. + zsep = '/' # Not using os.sep, always the / value even on windows. + for name in zfile.namelist(): + if zsep not in name: + continue + top_folder = name[:name.index(zsep) + 1] + if name == top_folder + zsep: + continue # skip top level folder + sub_path = name[name.index(zsep) + 1:] + if name.endswith(zsep): + try: + os.mkdir(os.path.join(outdir, sub_path)) + self.print_verbose( + "Extract - mkdir: " + os.path.join(outdir, sub_path)) + except OSError as exc: + if exc.errno != errno.EEXIST: + self._error = "Install failed" + self._error_msg = "Could not create folder from zip" + self.print_trace() + return -1 + else: + with open(os.path.join(outdir, sub_path), "wb") as outfile: + data = zfile.read(name) + outfile.write(data) + self.print_verbose( + "Extract - create: " + os.path.join(outdir, sub_path)) + + self.print_verbose("Extracted source") + + unpath = os.path.join(self._updater_path, "source") + if not os.path.isdir(unpath): + self._error = "Install failed" + self._error_msg = "Extracted path does not exist" + print("Extracted path does not exist: ", unpath) + return -1 + + if self._subfolder_path: + self._subfolder_path.replace('/', os.path.sep) + self._subfolder_path.replace('\\', os.path.sep) + + # Either directly in root of zip/one subfolder, or use specified path. + if not os.path.isfile(os.path.join(unpath, "__init__.py")): + dirlist = os.listdir(unpath) + if len(dirlist) > 0: + if self._subfolder_path == "" or self._subfolder_path is None: + unpath = os.path.join(unpath, dirlist[0]) + else: + unpath = os.path.join(unpath, self._subfolder_path) + + # Smarter check for additional sub folders for a single folder + # containing the __init__.py file. + if not os.path.isfile(os.path.join(unpath, "__init__.py")): + print("Not a valid addon found") + print("Paths:") + print(dirlist) + self._error = "Install failed" + self._error_msg = "No __init__ file found in new source" + return -1 + + # Merge code with the addon directory, using blender default behavior, + # plus any modifiers indicated by user (e.g. force remove/keep). + self.deep_merge_directory(self._addon_root, unpath, clean) + + # Now save the json state. + # Change to True to trigger the handler on other side if allowing + # reloading within same blender session. + self._json["just_updated"] = True + self.save_updater_json() + self.reload_addon() + self._update_ready = False + return 0 + + def deep_merge_directory(self, base, merger, clean=False): + """Merge folder 'merger' into 'base' without deleting existing""" + if not os.path.exists(base): + self.print_verbose("Base path does not exist:" + str(base)) + return -1 + elif not os.path.exists(merger): + self.print_verbose("Merger path does not exist") + return -1 + + # Path to be aware of and not overwrite/remove/etc. + staging_path = os.path.join(self._updater_path, "update_staging") + + # If clean install is enabled, clear existing files ahead of time + # note: will not delete the update.json, update folder, staging, or + # staging but will delete all other folders/files in addon directory. + error = None + if clean: + try: + # Implement clearing of all folders/files, except the updater + # folder and updater json. + # Careful, this deletes entire subdirectories recursively... + # Make sure that base is not a high level shared folder, but + # is dedicated just to the addon itself. + self.print_verbose( + "clean=True, clearing addon folder to fresh install state") + + # Remove root files and folders (except update folder). + files = [f for f in os.listdir(base) + if os.path.isfile(os.path.join(base, f))] + folders = [f for f in os.listdir(base) + if os.path.isdir(os.path.join(base, f))] + + for f in files: + os.remove(os.path.join(base, f)) + self.print_verbose( + "Clean removing file {}".format(os.path.join(base, f))) + for f in folders: + if os.path.join(base, f) is self._updater_path: + continue + shutil.rmtree(os.path.join(base, f)) + self.print_verbose( + "Clean removing folder and contents {}".format( + os.path.join(base, f))) + + except Exception as err: + error = "failed to create clean existing addon folder" + print(error, str(err)) + self.print_trace() + + # Walk through the base addon folder for rules on pre-removing + # but avoid removing/altering backup and updater file. + for path, dirs, files in os.walk(base): + # Prune ie skip updater folder. + dirs[:] = [d for d in dirs + if os.path.join(path, d) not in [self._updater_path]] + for file in files: + for pattern in self.remove_pre_update_patterns: + if fnmatch.filter([file], pattern): + try: + fl = os.path.join(path, file) + os.remove(fl) + self.print_verbose("Pre-removed file " + file) + except OSError: + print("Failed to pre-remove " + file) + self.print_trace() + + # Walk through the temp addon sub folder for replacements + # this implements the overwrite rules, which apply after + # the above pre-removal rules. This also performs the + # actual file copying/replacements. + for path, dirs, files in os.walk(merger): + # Verify structure works to prune updater sub folder overwriting. + dirs[:] = [d for d in dirs + if os.path.join(path, d) not in [self._updater_path]] + rel_path = os.path.relpath(path, merger) + dest_path = os.path.join(base, rel_path) + if not os.path.exists(dest_path): + os.makedirs(dest_path) + for file in files: + # Bring in additional logic around copying/replacing. + # Blender default: overwrite .py's, don't overwrite the rest. + dest_file = os.path.join(dest_path, file) + srcFile = os.path.join(path, file) + + # Decide to replace if file already exists, and copy new over. + if os.path.isfile(dest_file): + # Otherwise, check each file for overwrite pattern match. + replaced = False + for pattern in self._overwrite_patterns: + if fnmatch.filter([file], pattern): + replaced = True + break + if replaced: + os.remove(dest_file) + os.rename(srcFile, dest_file) + self.print_verbose( + "Overwrote file " + os.path.basename(dest_file)) + else: + self.print_verbose( + "Pattern not matched to {}, not overwritten".format( + os.path.basename(dest_file))) + else: + # File did not previously exist, simply move it over. + os.rename(srcFile, dest_file) + self.print_verbose( + "New file " + os.path.basename(dest_file)) + + # now remove the temp staging folder and downloaded zip + try: + shutil.rmtree(staging_path) + except: + error = ("Error: Failed to remove existing staging directory, " + "consider manually removing ") + staging_path + self.print_verbose(error) + self.print_trace() + + def reload_addon(self): + # if post_update false, skip this function + # else, unload/reload addon & trigger popup + if not self._auto_reload_post_update: + print("Restart blender to reload addon and complete update") + return + + self.print_verbose("Reloading addon...") + addon_utils.modules(refresh=True) + bpy.utils.refresh_script_paths() + + # not allowed in restricted context, such as register module + # toggle to refresh + if "addon_disable" in dir(bpy.ops.wm): # 2.7 + bpy.ops.wm.addon_disable(module=self._addon_package) + bpy.ops.wm.addon_refresh() + bpy.ops.wm.addon_enable(module=self._addon_package) + print("2.7 reload complete") + else: # 2.8 + bpy.ops.preferences.addon_disable(module=self._addon_package) + bpy.ops.preferences.addon_refresh() + bpy.ops.preferences.addon_enable(module=self._addon_package) + print("2.8 reload complete") + + # ------------------------------------------------------------------------- + # Other non-api functions and setups + # ------------------------------------------------------------------------- + def clear_state(self): + self._update_ready = None + self._update_link = None + self._update_version = None + self._source_zip = None + self._error = None + self._error_msg = None + + def url_retrieve(self, url_file, filepath): + """Custom urlretrieve implementation""" + chunk = 1024 * 8 + f = open(filepath, "wb") + while 1: + data = url_file.read(chunk) + if not data: + # print("done.") + break + f.write(data) + # print("Read %s bytes" % len(data)) + f.close() + + def version_tuple_from_text(self, text): + """Convert text into a tuple of numbers (int). + + Should go through string and remove all non-integers, and for any + given break split into a different section. + """ + if text is None: + return () + + segments = list() + tmp = '' + for char in str(text): + if not char.isdigit(): + if len(tmp) > 0: + segments.append(int(tmp)) + tmp = '' + else: + tmp += char + if len(tmp) > 0: + segments.append(int(tmp)) + + if len(segments) == 0: + self.print_verbose("No version strings found text: " + str(text)) + if not self._include_branches: + return () + else: + return (text) + return tuple(segments) + + def check_for_update_async(self, callback=None): + """Called for running check in a background thread""" + is_ready = ( + self._json is not None + and "update_ready" in self._json + and self._json["version_text"] != dict() + and self._json["update_ready"]) + + if is_ready: + self._update_ready = True + self._update_link = self._json["version_text"]["link"] + self._update_version = str(self._json["version_text"]["version"]) + # Cached update. + callback(True) + return + + # do the check + if not self._check_interval_enabled: + return + elif self._async_checking: + self.print_verbose("Skipping async check, already started") + # already running the bg thread + elif self._update_ready is None: + print("{} updater: Running background check for update".format( + self.addon)) + self.start_async_check_update(False, callback) + + def check_for_update_now(self, callback=None): + self._error = None + self._error_msg = None + self.print_verbose( + "Check update pressed, first getting current status") + if self._async_checking: + self.print_verbose("Skipping async check, already started") + return # already running the bg thread + elif self._update_ready is None: + self.start_async_check_update(True, callback) + else: + self._update_ready = None + self.start_async_check_update(True, callback) + + def check_for_update(self, now=False): + """Check for update not in a syncrhonous manner. + + This function is not async, will always return in sequential fashion + but should have a parent which calls it in another thread. + """ + self.print_verbose("Checking for update function") + + # clear the errors if any + self._error = None + self._error_msg = None + + # avoid running again in, just return past result if found + # but if force now check, then still do it + if self._update_ready is not None and not now: + return (self._update_ready, + self._update_version, + self._update_link) + + if self._current_version is None: + raise ValueError("current_version not yet defined") + + if self._repo is None: + raise ValueError("repo not yet defined") + + if self._user is None: + raise ValueError("username not yet defined") + + self.set_updater_json() # self._json + + if not now and not self.past_interval_timestamp(): + self.print_verbose( + "Aborting check for updated, check interval not reached") + return (False, None, None) + + # check if using tags or releases + # note that if called the first time, this will pull tags from online + if self._fake_install: + self.print_verbose( + "fake_install = True, setting fake version as ready") + self._update_ready = True + self._update_version = "(999,999,999)" + self._update_link = "http://127.0.0.1" + + return (self._update_ready, + self._update_version, + self._update_link) + + # Primary internet call, sets self._tags and self._tag_latest. + self.get_tags() + + self._json["last_check"] = str(datetime.now()) + self.save_updater_json() + + # Can be () or ('master') in addition to branches, and version tag. + new_version = self.version_tuple_from_text(self.tag_latest) + + if len(self._tags) == 0: + self._update_ready = False + self._update_version = None + self._update_link = None + return (False, None, None) + + if not self._include_branches: + link = self.select_link(self, self._tags[0]) + else: + n = len(self._include_branch_list) + if len(self._tags) == n: + # effectively means no tags found on repo + # so provide the first one as default + link = self.select_link(self, self._tags[0]) + else: + link = self.select_link(self, self._tags[n]) + + if new_version == (): + self._update_ready = False + self._update_version = None + self._update_link = None + return (False, None, None) + elif str(new_version).lower() in self._include_branch_list: + # Handle situation where master/whichever branch is included + # however, this code effectively is not triggered now + # as new_version will only be tag names, not branch names. + if not self._include_branch_auto_check: + # Don't offer update as ready, but set the link for the + # default branch for installing. + self._update_ready = False + self._update_version = new_version + self._update_link = link + self.save_updater_json() + return (True, new_version, link) + else: + # Bypass releases and look at timestamp of last update from a + # branch compared to now, see if commit values match or not. + raise ValueError("include_branch_autocheck: NOT YET DEVELOPED") + + else: + # Situation where branches not included. + if new_version > self._current_version: + + self._update_ready = True + self._update_version = new_version + self._update_link = link + self.save_updater_json() + return (True, new_version, link) + + # If no update, set ready to False from None to show it was checked. + self._update_ready = False + self._update_version = None + self._update_link = None + return (False, None, None) + + def set_tag(self, name): + """Assign the tag name and url to update to""" + tg = None + for tag in self._tags: + if name == tag["name"]: + tg = tag + break + if tg: + new_version = self.version_tuple_from_text(self.tag_latest) + self._update_version = new_version + self._update_link = self.select_link(self, tg) + elif self._include_branches and name in self._include_branch_list: + # scenario if reverting to a specific branch name instead of tag + tg = name + link = self.form_branch_url(tg) + self._update_version = name # this will break things + self._update_link = link + if not tg: + raise ValueError("Version tag not found: " + name) + + def run_update(self, force=False, revert_tag=None, clean=False, callback=None): + """Runs an install, update, or reversion of an addon from online source + + Arguments: + force: Install assigned link, even if self.update_ready is False + revert_tag: Version to install, if none uses detected update link + clean: not used, but in future could use to totally refresh addon + callback: used to run function on update completion + """ + self._json["update_ready"] = False + self._json["ignore"] = False # clear ignore flag + self._json["version_text"] = dict() + + if revert_tag is not None: + self.set_tag(revert_tag) + self._update_ready = True + + # clear the errors if any + self._error = None + self._error_msg = None + + self.print_verbose("Running update") + + if self._fake_install: + # Change to True, to trigger the reload/"update installed" handler. + self.print_verbose("fake_install=True") + self.print_verbose( + "Just reloading and running any handler triggers") + self._json["just_updated"] = True + self.save_updater_json() + if self._backup_current is True: + self.create_backup() + self.reload_addon() + self._update_ready = False + res = True # fake "success" zip download flag + + elif not force: + if not self._update_ready: + self.print_verbose("Update stopped, new version not ready") + if callback: + callback( + self._addon_package, + "Update stopped, new version not ready") + return "Update stopped, new version not ready" + elif self._update_link is None: + # this shouldn't happen if update is ready + self.print_verbose("Update stopped, update link unavailable") + if callback: + callback(self._addon_package, + "Update stopped, update link unavailable") + return "Update stopped, update link unavailable" + + if revert_tag is None: + self.print_verbose("Staging update") + else: + self.print_verbose("Staging install") + + res = self.stage_repository(self._update_link) + if not res: + print("Error in staging repository: " + str(res)) + if callback is not None: + callback(self._addon_package, self._error_msg) + return self._error_msg + res = self.unpack_staged_zip(clean) + if res < 0: + if callback: + callback(self._addon_package, self._error_msg) + return res + + else: + if self._update_link is None: + self.print_verbose("Update stopped, could not get link") + return "Update stopped, could not get link" + self.print_verbose("Forcing update") + + res = self.stage_repository(self._update_link) + if not res: + print("Error in staging repository: " + str(res)) + if callback: + callback(self._addon_package, self._error_msg) + return self._error_msg + res = self.unpack_staged_zip(clean) + if res < 0: + return res + # would need to compare against other versions held in tags + + # run the front-end's callback if provided + if callback: + callback(self._addon_package) + + # return something meaningful, 0 means it worked + return 0 + + def past_interval_timestamp(self): + if not self._check_interval_enabled: + return True # ie this exact feature is disabled + + if "last_check" not in self._json or self._json["last_check"] == "": + return True + + now = datetime.now() + last_check = datetime.strptime( + self._json["last_check"], "%Y-%m-%d %H:%M:%S.%f") + offset = timedelta( + days=self._check_interval_days + 30 * self._check_interval_months, + hours=self._check_interval_hours, + minutes=self._check_interval_minutes) + + delta = (now - offset) - last_check + if delta.total_seconds() > 0: + self.print_verbose("Time to check for updates!") + return True + + self.print_verbose("Determined it's not yet time to check for updates") + return False + + def get_json_path(self): + """Returns the full path to the JSON state file used by this updater. + + Will also rename old file paths to addon-specific path if found. + """ + json_path = os.path.join( + self._updater_path, + "{}_updater_status.json".format(self._addon_package)) + old_json_path = os.path.join(self._updater_path, "updater_status.json") + + # Rename old file if it exists. + try: + os.rename(old_json_path, json_path) + except FileNotFoundError: + pass + except Exception as err: + print("Other OS error occurred while trying to rename old JSON") + print(err) + self.print_trace() + return json_path + + def set_updater_json(self): + """Load or initialize JSON dictionary data for updater state""" + if self._updater_path is None: + raise ValueError("updater_path is not defined") + elif not os.path.isdir(self._updater_path): + os.makedirs(self._updater_path) + + jpath = self.get_json_path() + if os.path.isfile(jpath): + with open(jpath) as data_file: + self._json = json.load(data_file) + self.print_verbose("Read in JSON settings from file") + else: + self._json = { + "last_check": "", + "backup_date": "", + "update_ready": False, + "ignore": False, + "just_restored": False, + "just_updated": False, + "version_text": dict() + } + self.save_updater_json() + + def save_updater_json(self): + """Trigger save of current json structure into file within addon""" + if self._update_ready: + if isinstance(self._update_version, tuple): + self._json["update_ready"] = True + self._json["version_text"]["link"] = self._update_link + self._json["version_text"]["version"] = self._update_version + else: + self._json["update_ready"] = False + self._json["version_text"] = dict() + else: + self._json["update_ready"] = False + self._json["version_text"] = dict() + + jpath = self.get_json_path() + if not os.path.isdir(os.path.dirname(jpath)): + print("State error: Directory does not exist, cannot save json: ", + os.path.basename(jpath)) + return + try: + with open(jpath, 'w') as outf: + data_out = json.dumps(self._json, indent=4) + outf.write(data_out) + except: + print("Failed to open/save data to json: ", jpath) + self.print_trace() + self.print_verbose("Wrote out updater JSON settings with content:") + self.print_verbose(str(self._json)) + + def json_reset_postupdate(self): + self._json["just_updated"] = False + self._json["update_ready"] = False + self._json["version_text"] = dict() + self.save_updater_json() + + def json_reset_restore(self): + self._json["just_restored"] = False + self._json["update_ready"] = False + self._json["version_text"] = dict() + self.save_updater_json() + self._update_ready = None # Reset so you could check update again. + + def ignore_update(self): + self._json["ignore"] = True + self.save_updater_json() + + # ------------------------------------------------------------------------- + # ASYNC related methods + # ------------------------------------------------------------------------- + def start_async_check_update(self, now=False, callback=None): + """Start a background thread which will check for updates""" + if self._async_checking: + return + self.print_verbose("Starting background checking thread") + check_thread = threading.Thread(target=self.async_check_update, + args=(now, callback,)) + check_thread.daemon = True + self._check_thread = check_thread + check_thread.start() + + def async_check_update(self, now, callback=None): + """Perform update check, run as target of background thread""" + self._async_checking = True + self.print_verbose("Checking for update now in background") + + try: + self.check_for_update(now=now) + except Exception as exception: + print("Checking for update error:") + print(exception) + self.print_trace() + if not self._error: + self._update_ready = False + self._update_version = None + self._update_link = None + self._error = "Error occurred" + self._error_msg = "Encountered an error while checking for updates" + + self._async_checking = False + self._check_thread = None + + if callback: + self.print_verbose("Finished check update, doing callback") + callback(self._update_ready) + self.print_verbose("BG thread: Finished check update, no callback") + + def stop_async_check_update(self): + """Method to give impression of stopping check for update. + + Currently does nothing but allows user to retry/stop blocking UI from + hitting a refresh button. This does not actually stop the thread, as it + will complete after the connection timeout regardless. If the thread + does complete with a successful response, this will be still displayed + on next UI refresh (ie no update, or update available). + """ + if self._check_thread is not None: + self.print_verbose("Thread will end in normal course.") + # however, "There is no direct kill method on a thread object." + # better to let it run its course + # self._check_thread.stop() + self._async_checking = False + self._error = None + self._error_msg = None + + +# ----------------------------------------------------------------------------- +# Updater Engines +# ----------------------------------------------------------------------------- + + +class BitbucketEngine: + """Integration to Bitbucket API for git-formatted repositories""" + + def __init__(self): + self.api_url = 'https://api.bitbucket.org' + self.token = None + self.name = "bitbucket" + + def form_repo_url(self, updater): + return "{}/2.0/repositories/{}/{}".format( + self.api_url, updater.user, updater.repo) + + def form_tags_url(self, updater): + return self.form_repo_url(updater) + "/refs/tags?sort=-name" + + def form_branch_url(self, branch, updater): + return self.get_zip_url(branch, updater) + + def get_zip_url(self, name, updater): + return "https://bitbucket.org/{user}/{repo}/get/{name}.zip".format( + user=updater.user, + repo=updater.repo, + name=name) + + def parse_tags(self, response, updater): + if response is None: + return list() + return [ + { + "name": tag["name"], + "zipball_url": self.get_zip_url(tag["name"], updater) + } for tag in response["values"]] + + +class GithubEngine: + """Integration to Github API""" + + def __init__(self): + self.api_url = 'https://api.github.com' + self.token = None + self.name = "github" + + def form_repo_url(self, updater): + return "{}/repos/{}/{}".format( + self.api_url, updater.user, updater.repo) + + def form_tags_url(self, updater): + if updater.use_releases: + return "{}/releases".format(self.form_repo_url(updater)) + else: + return "{}/tags".format(self.form_repo_url(updater)) + + def form_branch_list_url(self, updater): + return "{}/branches".format(self.form_repo_url(updater)) + + def form_branch_url(self, branch, updater): + return "{}/zipball/{}".format(self.form_repo_url(updater), branch) + + def parse_tags(self, response, updater): + if response is None: + return list() + return response + + +class GitlabEngine: + """Integration to GitLab API""" + + def __init__(self): + self.api_url = 'https://gitlab.com' + self.token = None + self.name = "gitlab" + + def form_repo_url(self, updater): + return "{}/api/v4/projects/{}".format(self.api_url, updater.repo) + + def form_tags_url(self, updater): + return "{}/repository/tags".format(self.form_repo_url(updater)) + + def form_branch_list_url(self, updater): + # does not validate branch name. + return "{}/repository/branches".format( + self.form_repo_url(updater)) + + def form_branch_url(self, branch, updater): + # Could clash with tag names and if it does, it will download TAG zip + # instead of branch zip to get direct path, would need. + return "{}/repository/archive.zip?sha={}".format( + self.form_repo_url(updater), branch) + + def get_zip_url(self, sha, updater): + return "{base}/repository/archive.zip?sha={sha}".format( + base=self.form_repo_url(updater), + sha=sha) + + # def get_commit_zip(self, id, updater): + # return self.form_repo_url(updater)+"/repository/archive.zip?sha:"+id + + def parse_tags(self, response, updater): + if response is None: + return list() + return [ + { + "name": tag["name"], + "zipball_url": self.get_zip_url(tag["commit"]["id"], updater) + } for tag in response] + + +# ----------------------------------------------------------------------------- +# The module-shared class instance, +# should be what's imported to other files +# ----------------------------------------------------------------------------- + +Updater = SingletonUpdater() diff --git a/addon_updater_ops.py b/addon_updater_ops.py new file mode 100644 index 000000000..381b02dcc --- /dev/null +++ b/addon_updater_ops.py @@ -0,0 +1,1532 @@ +# ##### BEGIN GPL LICENSE BLOCK ##### +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +# +# ##### END GPL LICENSE BLOCK ##### + +"""Blender UI integrations for the addon updater. + +Implements draw calls, popups, and operators that use the addon_updater. +""" + +import os +import traceback + +import bpy +from bpy.app.handlers import persistent + +# Safely import the updater. +# Prevents popups for users with invalid python installs e.g. missing libraries +# and will replace with a fake class instead if it fails (so UI draws work). +try: + from .addon_updater import Updater as updater +except Exception as e: + print("ERROR INITIALIZING UPDATER") + print(str(e)) + traceback.print_exc() + + class SingletonUpdaterNone(object): + """Fake, bare minimum fields and functions for the updater object.""" + + def __init__(self): + self.invalid_updater = True # Used to distinguish bad install. + + self.addon = None + self.verbose = False + self.use_print_traces = True + self.error = None + self.error_msg = None + self.async_checking = None + + def clear_state(self): + self.addon = None + self.verbose = False + self.invalid_updater = True + self.error = None + self.error_msg = None + self.async_checking = None + + def run_update(self, force, callback, clean): + pass + + def check_for_update(self, now): + pass + + updater = SingletonUpdaterNone() + updater.error = "Error initializing updater module" + updater.error_msg = str(e) + +# Must declare this before classes are loaded, otherwise the bl_idname's will +# not match and have errors. Must be all lowercase and no spaces! Should also +# be unique among any other addons that could exist (using this updater code), +# to avoid clashes in operator registration. +updater.addon = "fast64" + + +# ----------------------------------------------------------------------------- +# Blender version utils +# ----------------------------------------------------------------------------- +def make_annotations(cls): + """Add annotation attribute to fields to avoid Blender 2.8+ warnings""" + if not hasattr(bpy.app, "version") or bpy.app.version < (2, 80): + return cls + if bpy.app.version < (2, 93, 0): + bl_props = {k: v for k, v in cls.__dict__.items() + if isinstance(v, tuple)} + else: + bl_props = {k: v for k, v in cls.__dict__.items() + if isinstance(v, bpy.props._PropertyDeferred)} + if bl_props: + if '__annotations__' not in cls.__dict__: + setattr(cls, '__annotations__', {}) + annotations = cls.__dict__['__annotations__'] + for k, v in bl_props.items(): + annotations[k] = v + delattr(cls, k) + return cls + + +def layout_split(layout, factor=0.0, align=False): + """Intermediate method for pre and post blender 2.8 split UI function""" + if not hasattr(bpy.app, "version") or bpy.app.version < (2, 80): + return layout.split(percentage=factor, align=align) + return layout.split(factor=factor, align=align) + + +def get_user_preferences(context=None): + """Intermediate method for pre and post blender 2.8 grabbing preferences""" + if not context: + context = bpy.context + prefs = None + if hasattr(context, "user_preferences"): + prefs = context.user_preferences.addons.get(__package__, None) + elif hasattr(context, "preferences"): + prefs = context.preferences.addons.get(__package__, None) + if prefs: + return prefs.preferences + # To make the addon stable and non-exception prone, return None + # raise Exception("Could not fetch user preferences") + return None + + +# ----------------------------------------------------------------------------- +# Updater operators +# ----------------------------------------------------------------------------- + + +# Simple popup to prompt use to check for update & offer install if available. +class AddonUpdaterInstallPopup(bpy.types.Operator): + """Check and install update if available""" + bl_label = "Update {x} addon".format(x=updater.addon) + bl_idname = updater.addon + ".updater_install_popup" + bl_description = "Popup to check and display current updates available" + bl_options = {'REGISTER', 'INTERNAL'} + + # if true, run clean install - ie remove all files before adding new + # equivalent to deleting the addon and reinstalling, except the + # updater folder/backup folder remains + clean_install = bpy.props.BoolProperty( + name="Clean install", + description=("If enabled, completely clear the addon's folder before " + "installing new update, creating a fresh install"), + default=False, + options={'HIDDEN'} + ) + + ignore_enum = bpy.props.EnumProperty( + name="Process update", + description="Decide to install, ignore, or defer new addon update", + items=[ + ("install", "Update Now", "Install update now"), + ("ignore", "Ignore", "Ignore this update to prevent future popups"), + ("defer", "Defer", "Defer choice till next blender session") + ], + options={'HIDDEN'} + ) + + def check(self, context): + return True + + def invoke(self, context, event): + return context.window_manager.invoke_props_dialog(self) + + def draw(self, context): + layout = self.layout + if updater.invalid_updater: + layout.label(text="Updater module error") + return + elif updater.update_ready: + col = layout.column() + col.scale_y = 0.7 + col.label(text="Update {} ready!".format(updater.update_version), + icon="LOOP_FORWARDS") + col.label(text="Choose 'Update Now' & press OK to install, ", + icon="BLANK1") + col.label(text="or click outside window to defer", icon="BLANK1") + row = col.row() + row.prop(self, "ignore_enum", expand=True) + col.split() + elif not updater.update_ready: + col = layout.column() + col.scale_y = 0.7 + col.label(text="No updates available") + col.label(text="Press okay to dismiss dialog") + # add option to force install + else: + # Case: updater.update_ready = None + # we have not yet checked for the update. + layout.label(text="Check for update now?") + + # Potentially in future, UI to 'check to select/revert to old version'. + + def execute(self, context): + # In case of error importing updater. + if updater.invalid_updater: + return {'CANCELLED'} + + if updater.manual_only: + bpy.ops.wm.url_open(url=updater.website) + elif updater.update_ready: + + # Action based on enum selection. + if self.ignore_enum == 'defer': + return {'FINISHED'} + elif self.ignore_enum == 'ignore': + updater.ignore_update() + return {'FINISHED'} + + res = updater.run_update(force=False, + callback=post_update_callback, + clean=self.clean_install) + + # Should return 0, if not something happened. + if updater.verbose: + if res == 0: + print("Updater returned successful") + else: + print("Updater returned {}, error occurred".format(res)) + elif updater.update_ready is None: + _ = updater.check_for_update(now=True) + + # Re-launch this dialog. + atr = AddonUpdaterInstallPopup.bl_idname.split(".") + getattr(getattr(bpy.ops, atr[0]), atr[1])('INVOKE_DEFAULT') + else: + updater.print_verbose("Doing nothing, not ready for update") + return {'FINISHED'} + + +# User preference check-now operator +class AddonUpdaterCheckNow(bpy.types.Operator): + bl_label = "Check now for " + updater.addon + " update" + bl_idname = updater.addon + ".updater_check_now" + bl_description = "Check now for an update to the {} addon".format( + updater.addon) + bl_options = {'REGISTER', 'INTERNAL'} + + def execute(self, context): + if updater.invalid_updater: + return {'CANCELLED'} + + if updater.async_checking and updater.error is None: + # Check already happened. + # Used here to just avoid constant applying settings below. + # Ignoring if error, to prevent being stuck on the error screen. + return {'CANCELLED'} + + # apply the UI settings + settings = get_user_preferences(context) + if not settings: + updater.print_verbose( + "Could not get {} preferences, update check skipped".format( + __package__)) + return {'CANCELLED'} + + updater.set_check_interval( + enabled=settings.auto_check_update, + months=settings.updater_interval_months, + days=settings.updater_interval_days, + hours=settings.updater_interval_hours, + minutes=settings.updater_interval_minutes) + + # Input is an optional callback function. This function should take a + # bool input. If true: update ready, if false: no update ready. + updater.check_for_update_now(ui_refresh) + + return {'FINISHED'} + + +class AddonUpdaterUpdateNow(bpy.types.Operator): + bl_label = "Update " + updater.addon + " addon now" + bl_idname = updater.addon + ".updater_update_now" + bl_description = "Update to the latest version of the {x} addon".format( + x=updater.addon) + bl_options = {'REGISTER', 'INTERNAL'} + + # If true, run clean install - ie remove all files before adding new + # equivalent to deleting the addon and reinstalling, except the updater + # folder/backup folder remains. + clean_install = bpy.props.BoolProperty( + name="Clean install", + description=("If enabled, completely clear the addon's folder before " + "installing new update, creating a fresh install"), + default=False, + options={'HIDDEN'} + ) + + def execute(self, context): + + # in case of error importing updater + if updater.invalid_updater: + return {'CANCELLED'} + + if updater.manual_only: + bpy.ops.wm.url_open(url=updater.website) + if updater.update_ready: + # if it fails, offer to open the website instead + try: + res = updater.run_update(force=False, + callback=post_update_callback, + clean=self.clean_install) + + # Should return 0, if not something happened. + if updater.verbose: + if res == 0: + print("Updater returned successful") + else: + print("Updater error response: {}".format(res)) + except Exception as expt: + updater._error = "Error trying to run update" + updater._error_msg = str(expt) + updater.print_trace() + atr = AddonUpdaterInstallManually.bl_idname.split(".") + getattr(getattr(bpy.ops, atr[0]), atr[1])('INVOKE_DEFAULT') + elif updater.update_ready is None: + (update_ready, version, link) = updater.check_for_update(now=True) + # Re-launch this dialog. + atr = AddonUpdaterInstallPopup.bl_idname.split(".") + getattr(getattr(bpy.ops, atr[0]), atr[1])('INVOKE_DEFAULT') + + elif not updater.update_ready: + self.report({'INFO'}, "Nothing to update") + return {'CANCELLED'} + else: + self.report( + {'ERROR'}, "Encountered a problem while trying to update") + return {'CANCELLED'} + + return {'FINISHED'} + + +class AddonUpdaterUpdateTarget(bpy.types.Operator): + bl_label = updater.addon + " version target" + bl_idname = updater.addon + ".updater_update_target" + bl_description = "Install a targeted version of the {x} addon".format( + x=updater.addon) + bl_options = {'REGISTER', 'INTERNAL'} + + def target_version(self, context): + # In case of error importing updater. + if updater.invalid_updater: + ret = [] + + ret = [] + i = 0 + for tag in updater.tags: + ret.append((tag, tag, "Select to install " + tag)) + i += 1 + return ret + + target = bpy.props.EnumProperty( + name="Target version to install", + description="Select the version to install", + items=target_version + ) + + # If true, run clean install - ie remove all files before adding new + # equivalent to deleting the addon and reinstalling, except the + # updater folder/backup folder remains. + clean_install = bpy.props.BoolProperty( + name="Clean install", + description=("If enabled, completely clear the addon's folder before " + "installing new update, creating a fresh install"), + default=False, + options={'HIDDEN'} + ) + + @classmethod + def poll(cls, context): + if updater.invalid_updater: + return False + return updater.update_ready is not None and len(updater.tags) > 0 + + def invoke(self, context, event): + return context.window_manager.invoke_props_dialog(self) + + def draw(self, context): + layout = self.layout + if updater.invalid_updater: + layout.label(text="Updater error") + return + split = layout_split(layout, factor=0.5) + sub_col = split.column() + sub_col.label(text="Select install version") + sub_col = split.column() + sub_col.prop(self, "target", text="") + + def execute(self, context): + # In case of error importing updater. + if updater.invalid_updater: + return {'CANCELLED'} + + res = updater.run_update( + force=False, + revert_tag=self.target, + callback=post_update_callback, + clean=self.clean_install) + + # Should return 0, if not something happened. + if res == 0: + updater.print_verbose("Updater returned successful") + else: + updater.print_verbose( + "Updater returned {}, , error occurred".format(res)) + return {'CANCELLED'} + + return {'FINISHED'} + + +class AddonUpdaterInstallManually(bpy.types.Operator): + """As a fallback, direct the user to download the addon manually""" + bl_label = "Install update manually" + bl_idname = updater.addon + ".updater_install_manually" + bl_description = "Proceed to manually install update" + bl_options = {'REGISTER', 'INTERNAL'} + + error = bpy.props.StringProperty( + name="Error Occurred", + default="", + options={'HIDDEN'} + ) + + def invoke(self, context, event): + return context.window_manager.invoke_popup(self) + + def draw(self, context): + layout = self.layout + + if updater.invalid_updater: + layout.label(text="Updater error") + return + + # Display error if a prior autoamted install failed. + if self.error != "": + col = layout.column() + col.scale_y = 0.7 + col.label(text="There was an issue trying to auto-install", + icon="ERROR") + col.label(text="Press the download button below and install", + icon="BLANK1") + col.label(text="the zip file like a normal addon.", icon="BLANK1") + else: + col = layout.column() + col.scale_y = 0.7 + col.label(text="Install the addon manually") + col.label(text="Press the download button below and install") + col.label(text="the zip file like a normal addon.") + + # If check hasn't happened, i.e. accidentally called this menu, + # allow to check here. + + row = layout.row() + + if updater.update_link is not None: + row.operator( + "wm.url_open", + text="Direct download").url = updater.update_link + else: + row.operator( + "wm.url_open", + text="(failed to retrieve direct download)") + row.enabled = False + + if updater.website is not None: + row = layout.row() + ops = row.operator("wm.url_open", text="Open website") + ops.url = updater.website + else: + row = layout.row() + row.label(text="See source website to download the update") + + def execute(self, context): + return {'FINISHED'} + + +class AddonUpdaterUpdatedSuccessful(bpy.types.Operator): + """Addon in place, popup telling user it completed or what went wrong""" + bl_label = "Installation Report" + bl_idname = updater.addon + ".updater_update_successful" + bl_description = "Update installation response" + bl_options = {'REGISTER', 'INTERNAL', 'UNDO'} + + error = bpy.props.StringProperty( + name="Error Occurred", + default="", + options={'HIDDEN'} + ) + + def invoke(self, context, event): + return context.window_manager.invoke_props_popup(self, event) + + def draw(self, context): + layout = self.layout + + if updater.invalid_updater: + layout.label(text="Updater error") + return + + saved = updater.json + if self.error != "": + col = layout.column() + col.scale_y = 0.7 + col.label(text="Error occurred, did not install", icon="ERROR") + if updater.error_msg: + msg = updater.error_msg + else: + msg = self.error + col.label(text=str(msg), icon="BLANK1") + rw = col.row() + rw.scale_y = 2 + rw.operator( + "wm.url_open", + text="Click for manual download.", + icon="BLANK1").url = updater.website + elif not updater.auto_reload_post_update: + # Tell user to restart blender after an update/restore! + if "just_restored" in saved and saved["just_restored"]: + col = layout.column() + col.label(text="Addon restored", icon="RECOVER_LAST") + alert_row = col.row() + alert_row.alert = True + alert_row.operator( + "wm.quit_blender", + text="Restart blender to reload", + icon="BLANK1") + updater.json_reset_restore() + else: + col = layout.column() + col.label( + text="Addon successfully installed", icon="FILE_TICK") + alert_row = col.row() + alert_row.alert = True + alert_row.operator( + "wm.quit_blender", + text="Restart blender to reload", + icon="BLANK1") + + else: + # reload addon, but still recommend they restart blender + if "just_restored" in saved and saved["just_restored"]: + col = layout.column() + col.scale_y = 0.7 + col.label(text="Addon restored", icon="RECOVER_LAST") + col.label( + text="Consider restarting blender to fully reload.", + icon="BLANK1") + updater.json_reset_restore() + else: + col = layout.column() + col.scale_y = 0.7 + col.label( + text="Addon successfully installed", icon="FILE_TICK") + col.label( + text="Consider restarting blender to fully reload.", + icon="BLANK1") + + def execute(self, context): + return {'FINISHED'} + + +class AddonUpdaterRestoreBackup(bpy.types.Operator): + """Restore addon from backup""" + bl_label = "Restore backup" + bl_idname = updater.addon + ".updater_restore_backup" + bl_description = "Restore addon from backup" + bl_options = {'REGISTER', 'INTERNAL'} + + @classmethod + def poll(cls, context): + try: + return os.path.isdir(os.path.join(updater.stage_path, "backup")) + except: + return False + + def execute(self, context): + # in case of error importing updater + if updater.invalid_updater: + return {'CANCELLED'} + updater.restore_backup() + return {'FINISHED'} + + +class AddonUpdaterIgnore(bpy.types.Operator): + """Ignore update to prevent future popups""" + bl_label = "Ignore update" + bl_idname = updater.addon + ".updater_ignore" + bl_description = "Ignore update to prevent future popups" + bl_options = {'REGISTER', 'INTERNAL'} + + @classmethod + def poll(cls, context): + if updater.invalid_updater: + return False + elif updater.update_ready: + return True + else: + return False + + def execute(self, context): + # in case of error importing updater + if updater.invalid_updater: + return {'CANCELLED'} + updater.ignore_update() + self.report({"INFO"}, "Open addon preferences for updater options") + return {'FINISHED'} + + +class AddonUpdaterEndBackground(bpy.types.Operator): + """Stop checking for update in the background""" + bl_label = "End background check" + bl_idname = updater.addon + ".end_background_check" + bl_description = "Stop checking for update in the background" + bl_options = {'REGISTER', 'INTERNAL'} + + def execute(self, context): + # in case of error importing updater + if updater.invalid_updater: + return {'CANCELLED'} + updater.stop_async_check_update() + return {'FINISHED'} + + +# ----------------------------------------------------------------------------- +# Handler related, to create popups +# ----------------------------------------------------------------------------- + + +# global vars used to prevent duplicate popup handlers +ran_auto_check_install_popup = False +ran_update_success_popup = False + +# global var for preventing successive calls +ran_background_check = False + + +@persistent +def updater_run_success_popup_handler(scene): + global ran_update_success_popup + ran_update_success_popup = True + + # in case of error importing updater + if updater.invalid_updater: + return + + try: + if "scene_update_post" in dir(bpy.app.handlers): + bpy.app.handlers.scene_update_post.remove( + updater_run_success_popup_handler) + else: + bpy.app.handlers.depsgraph_update_post.remove( + updater_run_success_popup_handler) + except: + pass + + atr = AddonUpdaterUpdatedSuccessful.bl_idname.split(".") + getattr(getattr(bpy.ops, atr[0]), atr[1])('INVOKE_DEFAULT') + + +@persistent +def updater_run_install_popup_handler(scene): + global ran_auto_check_install_popup + ran_auto_check_install_popup = True + updater.print_verbose("Running the install popup handler.") + + # in case of error importing updater + if updater.invalid_updater: + return + + try: + if "scene_update_post" in dir(bpy.app.handlers): + bpy.app.handlers.scene_update_post.remove( + updater_run_install_popup_handler) + else: + bpy.app.handlers.depsgraph_update_post.remove( + updater_run_install_popup_handler) + except: + pass + + if "ignore" in updater.json and updater.json["ignore"]: + return # Don't do popup if ignore pressed. + elif "version_text" in updater.json and updater.json["version_text"].get("version"): + version = updater.json["version_text"]["version"] + ver_tuple = updater.version_tuple_from_text(version) + + if ver_tuple < updater.current_version: + # User probably manually installed to get the up to date addon + # in here. Clear out the update flag using this function. + updater.print_verbose( + "{} updater: appears user updated, clearing flag".format( + updater.addon)) + updater.json_reset_restore() + return + atr = AddonUpdaterInstallPopup.bl_idname.split(".") + getattr(getattr(bpy.ops, atr[0]), atr[1])('INVOKE_DEFAULT') + + +def background_update_callback(update_ready): + """Passed into the updater, background thread updater""" + global ran_auto_check_install_popup + updater.print_verbose("Running background update callback") + + # In case of error importing updater. + if updater.invalid_updater: + return + if not updater.show_popups: + return + if not update_ready: + return + + # See if we need add to the update handler to trigger the popup. + handlers = [] + if "scene_update_post" in dir(bpy.app.handlers): # 2.7x + handlers = bpy.app.handlers.scene_update_post + else: # 2.8+ + handlers = bpy.app.handlers.depsgraph_update_post + in_handles = updater_run_install_popup_handler in handlers + + if in_handles or ran_auto_check_install_popup: + return + + if "scene_update_post" in dir(bpy.app.handlers): # 2.7x + bpy.app.handlers.scene_update_post.append( + updater_run_install_popup_handler) + else: # 2.8+ + bpy.app.handlers.depsgraph_update_post.append( + updater_run_install_popup_handler) + ran_auto_check_install_popup = True + updater.print_verbose("Attempted popup prompt") + + +def post_update_callback(module_name, res=None): + """Callback for once the run_update function has completed. + + Only makes sense to use this if "auto_reload_post_update" == False, + i.e. don't auto-restart the addon. + + Arguments: + module_name: returns the module name from updater, but unused here. + res: If an error occurred, this is the detail string. + """ + + # In case of error importing updater. + if updater.invalid_updater: + return + + if res is None: + # This is the same code as in conditional at the end of the register + # function, ie if "auto_reload_post_update" == True, skip code. + updater.print_verbose( + "{} updater: Running post update callback".format(updater.addon)) + + atr = AddonUpdaterUpdatedSuccessful.bl_idname.split(".") + getattr(getattr(bpy.ops, atr[0]), atr[1])('INVOKE_DEFAULT') + global ran_update_success_popup + ran_update_success_popup = True + else: + # Some kind of error occurred and it was unable to install, offer + # manual download instead. + atr = AddonUpdaterUpdatedSuccessful.bl_idname.split(".") + getattr(getattr(bpy.ops, atr[0]), atr[1])('INVOKE_DEFAULT', error=res) + return + + +def ui_refresh(update_status): + """Redraw the ui once an async thread has completed""" + for windowManager in bpy.data.window_managers: + for window in windowManager.windows: + for area in window.screen.areas: + area.tag_redraw() + + +def check_for_update_background(): + """Function for asynchronous background check. + + *Could* be called on register, but would be bad practice as the bare + minimum code should run at the moment of registration (addon ticked). + """ + if updater.invalid_updater: + return + global ran_background_check + if ran_background_check: + # Global var ensures check only happens once. + return + elif updater.update_ready is not None or updater.async_checking: + # Check already happened. + # Used here to just avoid constant applying settings below. + return + + # Apply the UI settings. + settings = get_user_preferences(bpy.context) + if not settings: + return + updater.set_check_interval(enabled=settings.auto_check_update, + months=settings.updater_interval_months, + days=settings.updater_interval_days, + hours=settings.updater_interval_hours, + minutes=settings.updater_interval_minutes) + + # Input is an optional callback function. This function should take a bool + # input, if true: update ready, if false: no update ready. + updater.check_for_update_async(background_update_callback) + ran_background_check = True + + +def check_for_update_nonthreaded(self, context): + """Can be placed in front of other operators to launch when pressed""" + if updater.invalid_updater: + return + + # Only check if it's ready, ie after the time interval specified should + # be the async wrapper call here. + settings = get_user_preferences(bpy.context) + if not settings: + if updater.verbose: + print("Could not get {} preferences, update check skipped".format( + __package__)) + return + updater.set_check_interval(enabled=settings.auto_check_update, + months=settings.updater_interval_months, + days=settings.updater_interval_days, + hours=settings.updater_interval_hours, + minutes=settings.updater_interval_minutes) + + (update_ready, version, link) = updater.check_for_update(now=False) + if update_ready: + atr = AddonUpdaterInstallPopup.bl_idname.split(".") + getattr(getattr(bpy.ops, atr[0]), atr[1])('INVOKE_DEFAULT') + else: + updater.print_verbose("No update ready") + self.report({'INFO'}, "No update ready") + + +def show_reload_popup(): + """For use in register only, to show popup after re-enabling the addon. + + Must be enabled by developer. + """ + if updater.invalid_updater: + return + saved_state = updater.json + global ran_update_success_popup + + has_state = saved_state is not None + just_updated = "just_updated" in saved_state + updated_info = saved_state["just_updated"] + + if not (has_state and just_updated and updated_info): + return + + updater.json_reset_postupdate() # So this only runs once. + + # No handlers in this case. + if not updater.auto_reload_post_update: + return + + # See if we need add to the update handler to trigger the popup. + handlers = [] + if "scene_update_post" in dir(bpy.app.handlers): # 2.7x + handlers = bpy.app.handlers.scene_update_post + else: # 2.8+ + handlers = bpy.app.handlers.depsgraph_update_post + in_handles = updater_run_success_popup_handler in handlers + + if in_handles or ran_update_success_popup: + return + + if "scene_update_post" in dir(bpy.app.handlers): # 2.7x + bpy.app.handlers.scene_update_post.append( + updater_run_success_popup_handler) + else: # 2.8+ + bpy.app.handlers.depsgraph_update_post.append( + updater_run_success_popup_handler) + ran_update_success_popup = True + + +# ----------------------------------------------------------------------------- +# Example UI integrations +# ----------------------------------------------------------------------------- +def update_notice_box_ui(self, context): + """Update notice draw, to add to the end or beginning of a panel. + + After a check for update has occurred, this function will draw a box + saying an update is ready, and give a button for: update now, open website, + or ignore popup. Ideal to be placed at the end / beginning of a panel. + """ + + if updater.invalid_updater: + return + + saved_state = updater.json + if not updater.auto_reload_post_update: + if "just_updated" in saved_state and saved_state["just_updated"]: + layout = self.layout + box = layout.box() + col = box.column() + alert_row = col.row() + alert_row.alert = True + alert_row.operator( + "wm.quit_blender", + text="Restart blender", + icon="ERROR") + col.label(text="to complete update") + return + + # If user pressed ignore, don't draw the box. + if "ignore" in updater.json and updater.json["ignore"]: + return + if not updater.update_ready: + return + + layout = self.layout + box = layout.box() + col = box.column(align=True) + col.alert = True + col.label(text="Update ready!", icon="ERROR") + col.alert = False + col.separator() + row = col.row(align=True) + split = row.split(align=True) + colL = split.column(align=True) + colL.scale_y = 1.5 + colL.operator(AddonUpdaterIgnore.bl_idname, icon="X", text="Ignore") + colR = split.column(align=True) + colR.scale_y = 1.5 + if not updater.manual_only: + colR.operator(AddonUpdaterUpdateNow.bl_idname, + text="Update", icon="LOOP_FORWARDS") + col.operator("wm.url_open", text="Open website").url = updater.website + # ops = col.operator("wm.url_open",text="Direct download") + # ops.url=updater.update_link + col.operator(AddonUpdaterInstallManually.bl_idname, + text="Install manually") + else: + # ops = col.operator("wm.url_open", text="Direct download") + # ops.url=updater.update_link + col.operator("wm.url_open", text="Get it now").url = updater.website + + +def update_settings_ui(self, context, element=None): + """Preferences - for drawing with full width inside user preferences + + A function that can be run inside user preferences panel for prefs UI. + Place inside UI draw using: + addon_updater_ops.update_settings_ui(self, context) + or by: + addon_updater_ops.update_settings_ui(context) + """ + + # Element is a UI element, such as layout, a row, column, or box. + if element is None: + element = self.layout + box = element.box() + + # In case of error importing updater. + if updater.invalid_updater: + box.label(text="Error initializing updater code:") + box.label(text=updater.error_msg) + return + settings = get_user_preferences(context) + if not settings: + box.label(text="Error getting updater preferences", icon='ERROR') + return + + # auto-update settings + box.label(text="Updater Settings") + row = box.row() + + # special case to tell user to restart blender, if set that way + if not updater.auto_reload_post_update: + saved_state = updater.json + if "just_updated" in saved_state and saved_state["just_updated"]: + row.alert = True + row.operator("wm.quit_blender", + text="Restart blender to complete update", + icon="ERROR") + return + + split = layout_split(row, factor=0.4) + sub_col = split.column() + sub_col.prop(settings, "auto_check_update") + sub_col = split.column() + + if not settings.auto_check_update: + sub_col.enabled = False + sub_row = sub_col.row() + sub_row.label(text="Interval between checks") + sub_row = sub_col.row(align=True) + check_col = sub_row.column(align=True) + check_col.prop(settings, "updater_interval_months") + check_col = sub_row.column(align=True) + check_col.prop(settings, "updater_interval_days") + check_col = sub_row.column(align=True) + + # Consider un-commenting for local dev (e.g. to set shorter intervals) + # check_col.prop(settings,"updater_interval_hours") + # check_col = sub_row.column(align=True) + # check_col.prop(settings,"updater_interval_minutes") + + # Checking / managing updates. + row = box.row() + col = row.column() + if updater.error is not None: + sub_col = col.row(align=True) + sub_col.scale_y = 1 + split = sub_col.split(align=True) + split.scale_y = 2 + if "ssl" in updater.error_msg.lower(): + split.enabled = True + split.operator(AddonUpdaterInstallManually.bl_idname, + text=updater.error) + else: + split.enabled = False + split.operator(AddonUpdaterCheckNow.bl_idname, + text=updater.error) + split = sub_col.split(align=True) + split.scale_y = 2 + split.operator(AddonUpdaterCheckNow.bl_idname, + text="", icon="FILE_REFRESH") + + elif updater.update_ready is None and not updater.async_checking: + col.scale_y = 2 + col.operator(AddonUpdaterCheckNow.bl_idname) + elif updater.update_ready is None: # async is running + sub_col = col.row(align=True) + sub_col.scale_y = 1 + split = sub_col.split(align=True) + split.enabled = False + split.scale_y = 2 + split.operator(AddonUpdaterCheckNow.bl_idname, text="Checking...") + split = sub_col.split(align=True) + split.scale_y = 2 + split.operator(AddonUpdaterEndBackground.bl_idname, text="", icon="X") + + elif updater.include_branches and \ + len(updater.tags) == len(updater.include_branch_list) and not \ + updater.manual_only: + # No releases found, but still show the appropriate branch. + sub_col = col.row(align=True) + sub_col.scale_y = 1 + split = sub_col.split(align=True) + split.scale_y = 2 + update_now_txt = "Update directly to {}".format( + updater.include_branch_list[0]) + split.operator(AddonUpdaterUpdateNow.bl_idname, text=update_now_txt) + split = sub_col.split(align=True) + split.scale_y = 2 + split.operator(AddonUpdaterCheckNow.bl_idname, + text="", icon="FILE_REFRESH") + + elif updater.update_ready and not updater.manual_only: + sub_col = col.row(align=True) + sub_col.scale_y = 1 + split = sub_col.split(align=True) + split.scale_y = 2 + split.operator(AddonUpdaterUpdateNow.bl_idname, + text="Update now to " + str(updater.update_version)) + split = sub_col.split(align=True) + split.scale_y = 2 + split.operator(AddonUpdaterCheckNow.bl_idname, + text="", icon="FILE_REFRESH") + + elif updater.update_ready and updater.manual_only: + col.scale_y = 2 + dl_now_txt = "Download " + str(updater.update_version) + col.operator("wm.url_open", + text=dl_now_txt).url = updater.website + else: # i.e. that updater.update_ready == False. + sub_col = col.row(align=True) + sub_col.scale_y = 1 + split = sub_col.split(align=True) + split.enabled = False + split.scale_y = 2 + split.operator(AddonUpdaterCheckNow.bl_idname, + text="Addon is up to date") + split = sub_col.split(align=True) + split.scale_y = 2 + split.operator(AddonUpdaterCheckNow.bl_idname, + text="", icon="FILE_REFRESH") + + if not updater.manual_only: + col = row.column(align=True) + if updater.include_branches and len(updater.include_branch_list) > 0: + branch = updater.include_branch_list[0] + col.operator(AddonUpdaterUpdateTarget.bl_idname, + text="Install {} / old version".format(branch)) + else: + col.operator(AddonUpdaterUpdateTarget.bl_idname, + text="(Re)install addon version") + last_date = "none found" + backup_path = os.path.join(updater.stage_path, "backup") + if "backup_date" in updater.json and os.path.isdir(backup_path): + if updater.json["backup_date"] == "": + last_date = "Date not found" + else: + last_date = updater.json["backup_date"] + backup_text = "Restore addon backup ({})".format(last_date) + col.operator(AddonUpdaterRestoreBackup.bl_idname, text=backup_text) + + row = box.row() + row.scale_y = 0.7 + last_check = updater.json["last_check"] + if updater.error is not None and updater.error_msg is not None: + row.label(text=updater.error_msg) + elif last_check: + last_check = last_check[0: last_check.index(".")] + row.label(text="Last update check: " + last_check) + else: + row.label(text="Last update check: Never") + + +def update_settings_ui_condensed(self, context, element=None): + """Preferences - Condensed drawing within preferences. + + Alternate draw for user preferences or other places, does not draw a box. + """ + + # Element is a UI element, such as layout, a row, column, or box. + if element is None: + element = self.layout + row = element.row() + + # In case of error importing updater. + if updater.invalid_updater: + row.label(text="Error initializing updater code:") + row.label(text=updater.error_msg) + return + settings = get_user_preferences(context) + if not settings: + row.label(text="Error getting updater preferences", icon='ERROR') + return + + # Special case to tell user to restart blender, if set that way. + if not updater.auto_reload_post_update: + saved_state = updater.json + if "just_updated" in saved_state and saved_state["just_updated"]: + row.alert = True # mark red + row.operator( + "wm.quit_blender", + text="Restart blender to complete update", + icon="ERROR") + return + + col = row.column() + if updater.error is not None: + sub_col = col.row(align=True) + sub_col.scale_y = 1 + split = sub_col.split(align=True) + split.scale_y = 2 + if "ssl" in updater.error_msg.lower(): + split.enabled = True + split.operator(AddonUpdaterInstallManually.bl_idname, + text=updater.error) + else: + split.enabled = False + split.operator(AddonUpdaterCheckNow.bl_idname, + text=updater.error) + split = sub_col.split(align=True) + split.scale_y = 2 + split.operator(AddonUpdaterCheckNow.bl_idname, + text="", icon="FILE_REFRESH") + + elif updater.update_ready is None and not updater.async_checking: + col.scale_y = 2 + col.operator(AddonUpdaterCheckNow.bl_idname) + elif updater.update_ready is None: # Async is running. + sub_col = col.row(align=True) + sub_col.scale_y = 1 + split = sub_col.split(align=True) + split.enabled = False + split.scale_y = 2 + split.operator(AddonUpdaterCheckNow.bl_idname, text="Checking...") + split = sub_col.split(align=True) + split.scale_y = 2 + split.operator(AddonUpdaterEndBackground.bl_idname, text="", icon="X") + + elif updater.include_branches and \ + len(updater.tags) == len(updater.include_branch_list) and not \ + updater.manual_only: + # No releases found, but still show the appropriate branch. + sub_col = col.row(align=True) + sub_col.scale_y = 1 + split = sub_col.split(align=True) + split.scale_y = 2 + now_txt = "Update directly to " + str(updater.include_branch_list[0]) + split.operator(AddonUpdaterUpdateNow.bl_idname, text=now_txt) + split = sub_col.split(align=True) + split.scale_y = 2 + split.operator(AddonUpdaterCheckNow.bl_idname, + text="", icon="FILE_REFRESH") + + elif updater.update_ready and not updater.manual_only: + sub_col = col.row(align=True) + sub_col.scale_y = 1 + split = sub_col.split(align=True) + split.scale_y = 2 + split.operator(AddonUpdaterUpdateNow.bl_idname, + text="Update now to " + str(updater.update_version)) + split = sub_col.split(align=True) + split.scale_y = 2 + split.operator(AddonUpdaterCheckNow.bl_idname, + text="", icon="FILE_REFRESH") + + elif updater.update_ready and updater.manual_only: + col.scale_y = 2 + dl_txt = "Download " + str(updater.update_version) + col.operator("wm.url_open", text=dl_txt).url = updater.website + else: # i.e. that updater.update_ready == False. + sub_col = col.row(align=True) + sub_col.scale_y = 1 + split = sub_col.split(align=True) + split.enabled = False + split.scale_y = 2 + split.operator(AddonUpdaterCheckNow.bl_idname, + text="Addon is up to date") + split = sub_col.split(align=True) + split.scale_y = 2 + split.operator(AddonUpdaterCheckNow.bl_idname, + text="", icon="FILE_REFRESH") + + row = element.row() + row.prop(settings, "auto_check_update") + + row = element.row() + row.scale_y = 0.7 + last_check = updater.json["last_check"] + if updater.error is not None and updater.error_msg is not None: + row.label(text=updater.error_msg) + elif last_check != "" and last_check is not None: + last_check = last_check[0: last_check.index(".")] + row.label(text="Last check: " + last_check) + else: + row.label(text="Last check: Never") + + +def skip_tag_function(self, tag): + """A global function for tag skipping. + + A way to filter which tags are displayed, e.g. to limit downgrading too + long ago. + + Args: + self: The instance of the singleton addon update. + tag: the text content of a tag from the repo, e.g. "v1.2.3". + + Returns: + bool: True to skip this tag name (ie don't allow for downloading this + version), or False if the tag is allowed. + """ + + # In case of error importing updater. + if self.invalid_updater: + return False + + # ---- write any custom code here, return true to disallow version ---- # + # + # # Filter out e.g. if 'beta' is in name of release + # if 'beta' in tag.lower(): + # return True + # ---- write any custom code above, return true to disallow version --- # + + if self.include_branches: + for branch in self.include_branch_list: + if tag["name"].lower() == branch: + return False + + # Function converting string to tuple, ignoring e.g. leading 'v'. + # Be aware that this strips out other text that you might otherwise + # want to be kept and accounted for when checking tags (e.g. v1.1a vs 1.1b) + tupled = self.version_tuple_from_text(tag["name"]) + if not isinstance(tupled, tuple): + return True + + # Select the min tag version - change tuple accordingly. + if self.version_min_update is not None: + if tupled < self.version_min_update: + return True # Skip if current version below this. + + # Select the max tag version. + if self.version_max_update is not None: + if tupled >= self.version_max_update: + return True # Skip if current version at or above this. + + # In all other cases, allow showing the tag for updating/reverting. + # To simply and always show all tags, this return False could be moved + # to the start of the function definition so all tags are allowed. + return False + + +def select_link_function(self, tag): + """Only customize if trying to leverage "attachments" in *GitHub* releases. + + A way to select from one or multiple attached downloadable files from the + server, instead of downloading the default release/tag source code. + """ + + # -- Default, universal case (and is the only option for GitLab/Bitbucket) + link = tag["zipball_url"] + + # -- Example: select the first (or only) asset instead source code -- + # if "assets" in tag and "browser_download_url" in tag["assets"][0]: + # link = tag["assets"][0]["browser_download_url"] + + # -- Example: select asset based on OS, where multiple builds exist -- + # # not tested/no error checking, modify to fit your own needs! + # # assume each release has three attached builds: + # # release_windows.zip, release_OSX.zip, release_linux.zip + # # This also would logically not be used with "branches" enabled + # if platform.system() == "Darwin": # ie OSX + # link = [asset for asset in tag["assets"] if 'OSX' in asset][0] + # elif platform.system() == "Windows": + # link = [asset for asset in tag["assets"] if 'windows' in asset][0] + # elif platform.system() == "Linux": + # link = [asset for asset in tag["assets"] if 'linux' in asset][0] + + return link + +class AddonUpdaterPreferences: + bl_idname = __package__ + + auto_check_update: bpy.props.BoolProperty( + name="Auto-check for Update", + description="If enabled, auto-check for updates using an interval", + default=False) + + updater_interval_months: bpy.props.IntProperty( + name='Months', + description="Number of months between checking for updates", + default=0, + min=0) + + updater_interval_days: bpy.props.IntProperty( + name='Days', + description="Number of days between checking for updates", + default=7, + min=0, + max=31) + + updater_interval_hours: bpy.props.IntProperty( + name='Hours', + description="Number of hours between checking for updates", + default=0, + min=0, + max=23) + + updater_interval_minutes: bpy.props.IntProperty( + name='Minutes', + description="Number of minutes between checking for updates", + default=0, + min=0, + max=59) + +# ----------------------------------------------------------------------------- +# Register, should be run in the register module itself +# ----------------------------------------------------------------------------- +classes = ( + AddonUpdaterInstallPopup, + AddonUpdaterCheckNow, + AddonUpdaterUpdateNow, + AddonUpdaterUpdateTarget, + AddonUpdaterInstallManually, + AddonUpdaterUpdatedSuccessful, + AddonUpdaterRestoreBackup, + AddonUpdaterIgnore, + AddonUpdaterEndBackground +) + + +def register(bl_info): + """Registering the operators in this module""" + # Safer failure in case of issue loading module. + if updater.error: + print("Exiting updater registration, " + updater.error) + return + updater.clear_state() # Clear internal vars, avoids reloading oddities. + + # https://github.com/Fast-64/fast64 + updater.engine = "Github" + updater.user = "Fast-64" + updater.repo = "fast64" + + # updater.addon = # define at top of module, MUST be done first + + # Website for manual addon download, optional but recommended to set. + updater.website = "https://github.com/Fast-64/fast64" + + # Used to check/compare versions. + updater.current_version = bl_info["version"] + + # Optional, consider turning off for production or allow as an option + # This will print out additional debugging info to the console + updater.verbose = True # make False for production default + + # Optional, customize where the addon updater processing subfolder is, + # essentially a staging folder used by the updater on its own + # Needs to be within the same folder as the addon itself + # Need to supply a full, absolute path to folder + # updater.updater_path = # set path of updater folder, by default: + # /addons/{__package__}/{__package__}_updater + + # Auto create a backup of the addon when installing other versions. + updater.backup_current = True + + # Ignore patterns for when creating backup of current during update. + updater.backup_ignore_patterns = [".git", ".gitignore", "__pycache__", "*.blend", "README.md", "images"] + + # Patterns for files to actively overwrite if found in new update file and + # are also found in the currently installed addon. Note that by default + # (ie if set to []), updates are installed in the same way as blender: + # .py files are replaced, but other file types (e.g. json, txt, blend) + # will NOT be overwritten if already present in current install. Thus + # if you want to automatically update resources/non py files, add them as a + # part of the pattern list below so they will always be overwritten by an + # update. If a pattern file is not found in new update, no action is taken + # NOTE: This does NOT delete anything proactively, rather only defines what + # is allowed to be overwritten during an update execution. + updater.overwrite_patterns = ["*.png", "*.jpg", "*.gif", "*.blend", "*.xml", "README.md", "LICENSE.txt", "pyproject.toml"] + + # Patterns for files to actively remove prior to running update. + # Useful if wanting to remove old code due to changes in filenames + # that otherwise would accumulate. Note: this runs after taking + # a backup (if enabled) but before placing in new update. If the same + # file name removed exists in the update, then it acts as if pattern + # is placed in the overwrite_patterns property. Note this is effectively + # ignored if clean=True in the run_update method. + updater.remove_pre_update_patterns = ["*.py", "*.pyc"] + # Note setting ["*"] here is equivalent to always running updates with + # clean = True in the run_update method, ie the equivalent of a fresh, + # new install. This would also delete any resources or user-made/modified + # files setting ["__pycache__"] ensures the pycache folder always removed. + # The configuration of ["*.py", "*.pyc"] is a safe option as this + # will ensure no old python files/caches remain in event different addon + # versions have different filenames or structures. + + # Allow branches like 'master' as an option to update to, regardless + # of release or version. + # Default behavior: releases will still be used for auto check (popup), + # but the user has the option from user preferences to directly + # update to the master branch or any other branches specified using + # the "install {branch}/older version" operator. + updater.include_branches = True + + # (GitHub only) This options allows using "releases" instead of "tags", + # which enables pulling down release logs/notes, as well as installs update + # from release-attached zips (instead of the auto-packaged code generated + # with a release/tag). Setting has no impact on BitBucket or GitLab repos. + updater.use_releases = False + # Note: Releases always have a tag, but a tag may not always be a release. + # Therefore, setting True above will filter out any non-annotated tags. + # Note 2: Using this option will also display (and filter by) the release + # name instead of the tag name, bear this in mind given the + # skip_tag_function filtering above. + + # Populate if using "include_branches" option above. + # Note: updater.include_branch_list defaults to ['master'] branch if set to + # none. Example targeting another multiple branches allowed to pull from: + # updater.include_branch_list = ['master', 'dev'] + updater.include_branch_list = ["main"] + + # Only allow manual install, thus prompting the user to open + # the addon's web page to download, specifically: updater.website + # Useful if only wanting to get notification of updates but not + # directly install. + updater.manual_only = False + + # Used for development only, "pretend" to install an update to test + # reloading conditions. + updater.fake_install = False # Set to true to test callback/reloading. + + # Show popups, ie if auto-check for update is enabled or a previous + # check for update in user preferences found a new version, show a popup + # (at most once per blender session, and it provides an option to ignore + # for future sessions); default behavior is set to True. + updater.show_popups = True + # note: if set to false, there will still be an "update ready" box drawn + # using the `update_notice_box_ui` panel function. + + # Override with a custom function on what tags + # to skip showing for updater; see code for function above. + # Set the min and max versions allowed to install. + # Optional, default None + # min install (>=) will install this and higher + updater.version_min_update = None + + # Max install (<) will install strictly anything lower than this version + # number, useful to limit the max version a given user can install (e.g. + # if support for a future version of blender is going away, and you don't + # want users to be prompted to install a non-functioning addon) + # updater.version_max_update = (9,9,9) + updater.version_max_update = None # None or default for no max. + + # Function defined above, customize as appropriate per repository + updater.skip_tag = skip_tag_function # min and max used in this function + + # Function defined above, optionally customize as needed per repository. + updater.select_link = select_link_function + + # Recommended false to encourage blender restarts on update completion + # Setting this option to True is NOT as stable as false (could cause + # blender crashes). + updater.auto_reload_post_update = False + + # The register line items for all operators/panels. + # If using bpy.utils.register_module(__name__) to register elsewhere + # in the addon, delete these lines (also from unregister). + for cls in classes: + # Apply annotations to remove Blender 2.8+ warnings, no effect on 2.7 + make_annotations(cls) + # Comment out this line if using bpy.utils.register_module(__name__) + bpy.utils.register_class(cls) + + # Special situation: we just updated the addon, show a popup to tell the + # user it worked. Could enclosed in try/catch in case other issues arise. + show_reload_popup() + + +def unregister(): + for cls in reversed(classes): + # Comment out this line if using bpy.utils.unregister_module(__name__). + bpy.utils.unregister_class(cls) + + # Clear global vars since they may persist if not restarting blender. + updater.clear_state() # Clear internal vars, avoids reloading oddities. + + global ran_auto_check_install_popup + ran_auto_check_install_popup = False + + global ran_update_success_popup + ran_update_success_popup = False + + global ran_background_check + ran_background_check = False diff --git a/images/updater_after_check.png b/images/updater_after_check.png new file mode 100644 index 0000000000000000000000000000000000000000..f7cccbd85caa1f4a6aadd0c5e4dac556c393e595 GIT binary patch literal 88170 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 z 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 z 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 Gh5rM~>uc=* literal 0 HcmV?d00001 diff --git a/images/updater_initially.png b/images/updater_initially.png new file mode 100644 index 0000000000000000000000000000000000000000..efdac124844242de1a7f41f9533d7f3d08442720 GIT binary patch literal 81896 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𝔣|?w2V)e4>PgGS^ZLMrLOA&GnS{1Pqv1 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

I$@x~Vc& zc%1LmcJlLuI-!`TOxrJAf`RXa9rsMzNUm-x?JA+--GD#ng*pICCLDxhk7>BMxhWf9 z4uC2gUu$LR0jDB{*&$2%QrnbVgc)S>BH(via~N0LT*A7+t2kQKh6f4Dz9QwgPw+d2 zz`=gc>grWhr@=%R!Z1OD*V_R`^~11%pqT=1$X&ot!27Un9u)K)po1m|9Z4F1%x%hW z*!M6*x(tqd2CN+OF3JG~X$kpa8@&S)C14edS=Tqf?LH6aE9DIsPpS|^FR^Ug#`7UJ zvJ{{o;2n>*-%M#obXLv5()d3H^EDn+{3jde%VEfZ6hnp1pwH%jH-+Fb1#AKA22jEk zn0kJGhH!UixlwljJ%Hrg*tob=KWI|{FJ+a0P-_P`=MNIh{~Iow%T#~u1^XZ1WH8Mh z27aNZp~=b4*6=$J2l^#|hlhtxwAvZ+NYzHU_VyvbDLUn+HFJ5l?EjeaQM$G((=Sc(1`dRt~-AXt|tH9v?i)Ng!j12Ov&{It>9H@4=7452)!+fiT#}kR>1> z2(*Q_<$3rIDY(+}3LYqtm*FBdDZ#qv{)3R9^tYOQv`LGn^e<61u5aPcf`xklPUzH3PS<{SV77 z2mu3PNiXQY8i7deG`21GSn^JC}X2y+C+xhZ=+?=L!S<}gWH^qDjH2CQY)#0$w} zKlt{>n_z~gv%wIPoGhT=c)C$t2pJV)WBpexE#sPUmW9=xfnQS^Myp$^O{#ThuY`Xh z+#rdvNAyJ#yhtWyW_?FN;T6sc7hY6VX+4jtuXKV4Q^xGa6%|ep3=OXbj;ae0KU)Rm zi~*py4J#VZLMH}P`|U$7@}s@w43;5K>{0^IQe0==C@e?uFI4!3&hFABT5imU)YsSd zNg$WLEFn85XT}<;GOUAZkRefVH|YaA%CntwP)Ba?!|0Tfc&nZC;no?#q8I z+3c7Y=!O{Oiu|S~i2;`%rL;;qxJ(P6Qr6-E09ZsuhW18+HhJ$*dC_Kv7Q`by%d{!x zZrJ~54nXO?ZYURRXY2(gg=$XKB!0)4ET@ms;^O2a!mb zmVD}EQ9Mz5VD*pQV$;pUfAj&!rU>SgBg`cm zclY+yaki}oAvBJEVf)0_PMJ;@=$qAV&xPcw)mJT1avsxVfI;jov)@!oOCVGoos4pE#TXdf;~*e{dRvk2xr>zLt*@HlC^VL&j(W2m2V(W}xr|gE14fQwr6g1lYM#1I9vBUB_}eJ3IfEHlh!3 z#u-QoYX1S90-UL&3m`@Q2`75XSx%fuDxBlvQ&Yp`kle!vSFT7yp@14o;|@-0T7W#4 z8|>uQ?8ZF(Aow~stE9Z3sJLkL(m2TS{{jsRRx6YuLftWHN|_D#Fm=Tm>4c|4t8lCcLGml&YnM9g;ftRA^F>Wr;Pu%yyAaLta&ndd z?Fp1BtkL2MF7(LeJGI4hxcvct8Fnw6ALk)WD{j~y6gQ?UfU$T0d`E9QBhp!pkFj~; z(kk84Wdhsdn0#a+4tbL%JTxlG4>!}v$SjbsOEKAXV5PT)YZJVe73?dJ^9}3Y;I$?4 zHlMrfk4eAsLYJuW)<=ZQ(ecf8d~*2uaS{S5FbHT9`B_p7p(cYl{n3Av8a|SUR0#4k z%ROeF5^M(qu%(K*tF^*9F+JVQVdTMLU_1uKGDJ$Efg@p}raq{}`{DfZlUTc-)+q4% z_1Z*UF=>Cm+lNu`aQG3)&*4W?$f|{;!fbAgA+8)DCT@TD3k30t3kze^Fsv&NK-Ck} z%i({Hb)ECj)5BC=*sudS85fW#w%)IsB|e>mo`zh1@>#IV1LLwM<`x!I=4t}opjao| z{SJbivWO$tTl&kO)hPA3vB_+A6H!ww^sSvho+1i#ucGI1xD=%b2K$$Tl=8&<8B}u7Yh)k7fwj z<0K*^q@J7jR_$sTPE$&mWXG*VfLYqW+zVWz3s&$@bO~ooCfrmuBlGYA-MPkOI~*-$ zj71D60pPH>AJx>gOd@^QzHBYD2xNP}f_y2;+5f2n=p?fq*&|0o!_s3|9ugh|7u1WY_8uweuKB0Xr0vHh8+zE3CO((c_1Idk>I*3yAUxt+js2#gEX;s22nYEf^!%4W&fw9zP81i%=fJQ(Xteduysq({ zA&sPi2El<*M^=osF`O{e9H|aNuTt?rRE$;NnQKiFyeWq#Xmmc{nh-sFb&$!nybX^W zpOmo|f4N+fAmkXH*Z;@an?Pf^x9!6XBAJKGl6kC%%u%LPgc2g*rZQECq70QGV;L%B zmMBwXswgs#8KQ0(Gge4cBH=r(_I}>?{jYa@>;J9qS$jQeuU+ZBuj}_ahvPWT<5cxq z<%y3@NRX^tYm^^C7(*;it0E6~3ZpV3%#M0=e0^6T+GM<>wJ*2=dO^%t0KYk;tGn-p z;k^=dVZ42K#W4@qJ~sCES3Vs0IUj1c^s;2wwEy0((|4IZwC#n5J3S;yozyt=k~?;c zU#tyg`VpPr^GQl&qvoM3Tf)=gor*j0?i+k0zwYT3+$3c26qmysGEXXB&i1F}8I{K+Cho>Ix$oj#YBA?`6_rhb} z#&Oo(h=8qBLb2{gB78mxs5CtCf>G+zgtGcHbsaSsH^GcD@z~|V``?V{j>98(&=kU> zpZ|I4i`RD~8r0bBmv`$e?VUDaxR${2T;h^Y*uG2CXBelBHQhQnd~6=nXVr$p5r?LM z;esd94OQ2DCanuEu_`Pa#X<>C0?y(<(I|47cV(wr~oy;bQ|luK?^HB&c++ z6clRz{PBOe_5XZu_z&aPjo{XE$cI>u{cmXmsO4x1aYz2CowdJZ5NIJ*tmLdF{A#{Q zhtOb6OB4G)e@7f?s{eVBRaU#8&Xbv_D`s!0k_DK*|52ur6$*d-kq6$A_@Mx?(l;j? zIrm(6uk14@_%pKYP2OkCBf+IyL&co` zJ~8r&-^zQx8JXi&1rAU3|4UW)Z%KM%k~LxAeBQyB|5T3IWH~RH$Nz1+9K-&9{*sqw zAylbQF%Bwv>7zjaFxi*|(`#JRGq|5Hmre0mh_|`YkS2NUxqg`oJ8cf{A_XNStcRa{ z+I!g>Pm%S)C~$|1A3nY+y8R>B#!2DWba(ngizgX&$>H&C9lYh4l*y|3p|iqve6hMD&%-mDn^*$VYT`5i8kSc2)AgJxBIo3A}2E zSXk*-SzPQ6s3hp8e*YZt4l5#NSuLi!HD%u?FE8}1Rd{AeTsoB2cKl$cIMr9xm8N@| zWr{8h`H!!Q!Xyp`zjU0tGqSUr%@g^H7A%GxXHG>&75*dMJ@A4v^Kv{GHe5|_L_b1& zu{8g%=JHK5xH`^bkIh#NpaR z@b19mT&ATj(#}?XOuPKNOu>u$odDzqXn}`9$Qlq8vDMZ0&^(t`~Y3T}TWJLT(d-k0t;d&{Q7r8wVdl>aV6X7YsssNDU zog<9KQI(aI-39#n@~)M-f9iN0PpY{t(m_2>Vh+TXt*gUT>*;A3e*L`(L&Jh~Y$^|3 zetrcUTlZw+$i#%R`oeUb!Gq}UIWxz?p8gtK98GyO_-t)tUSG61+jptRYL)UdoAQ}3 z&GHhG;B0f!`_(@^3Mvd%R)tHRCwg{mi(RW|==NXi_nJT5+hTRtt)Ms1vZL6Q# ztr(K7KAP;lk+M2}IV)eyqM$S`PV|ZDjDl^Yg#6!Uw@(>@ZaV(?I(Dn#bA9*TLO=54 zoG^xNC=lx@6&PgSVOcuEQlPrA<`dP85AFt`ij`Y1Q+s{phLwnRVml>7grT zOT)b_d_S$`mr`4?=-Z^?xAwb*BEboE-{l!Uo$!-Paze89x+WdNcRy8|t(ejc>J1t? zccAs_HUj|TMnGJTLIDy`QBb%PpbEgy&R=Tu+|Vmtk3e#BV*A?EnlulYkkVM0wz=|F|mDVGtG9~nM1lf2b~ zk`Bjz8BGbsT)xa(SeiS3*69)tpW?ZjnpZ2k2WS*dC04HX|M_{gVMpGZJ_V($zQ&41 z>hf~oG0RHR(wxN)w|{3nAj{9Hu&BBpuU-7ZCwgAlZ>4EshNY8>j{;OaL(B zsxew1j%w$pX*BlXz(Cxxm7N`&6b4vx0bHk((af_lG0h>+fQ1Rw*VOkv!5vJ`qH7aY!ybEV!Sr>iGkNeg9?5#Akx3$a{eJVWQ!0P| z9*M{@{dzoF;?&A~+1lLAM;UFlv8;Z}DQlccSC0S4Sn(8ivrYBt-IqT$&>&X1kx;ve9^Th3(=Gz2?%*PinlAE9Y`Qjpe;@r7?8&TFTOBaLz6@_;C5_ z@1mJN_HxnOup_N+22C^upS)U~c>O)4p&ezuNV^Cn<(0;NcLybk%hysw0cPtwM^ukk zxH?#&v^xidqsP$|{j5ObG5)$S-aY^&ttqcGtX;R3|KnJYY4J)|yAZqZA`1Yl0?%bJ z*zyAC1z=~bh4}p)J2Od6PW%6GbM1ujC<{cft+N*$K4X_{NA9~_Gy{Kgp|`)mVBv{Z zzok@t&pDib9op7l;;fdOY`VCt{>S0Xm+D=a(|;xsE;PIu60ZzqOn5pw2tZXTkTV;mEY=5FI#r0fBSoWD8;g1=M5$PA{xTP z=CT;%FEkW9HcVoSEG!5=4DJafWN5sX(fU5-pbv(v?^ocukW;hPmEsbj&_0j*7q3y$ zX@goGt>viMU}3MMd~pl(6DZN9*B)J1(Rd4H08cECgw_Pj9whIn9{~Jej$G%ut13*~ z0Q2b_IPkU$no#VtqN1eiO6T$!(|$l?xx=u0$EiA5@Uh?2%8y0f&UN3~!~OoI(HlnC z`IIhx@5;+kKhp2H@L`nuSIcN7-*mir@yo@pWkaiz_jwy$&|BGFuqq$*v>%zkovW!o zzwA0P@%4dxV#SZ)uQAz+@jYrzzXpil|0Su|93Nh+lvkUb>J3@;;!GV`oJv4+dOE4% zV{GN`nLml?jbnS?mGq4Dj_s`riu;7F`}Aqy59tWoiN0s}ckN=JyGj3_{^GA55=Mah zr7rvGZLm~f3C-MMYg^m7&h$;8=YV!Vmb-rmx}Wu~I*en(2=>g(%wrx&oLYz4@xR8# z?YoqN96OFaHq*RzhMrqK+?@Zt9x-pyMHm3$?v2rqxWYbZ1?dYQ6v?&}q zirULN5Gbr?*FspC)yZc|axTM9gXflvSbjxUH_XIEznX0KTg@KoK4&E~xmSF7p26?; zm-m&+qrFq@=l6G<}B1`3xPEZF_d(yn5);7 zk&iSI)QP64OS{#Em5*9uzb>Z~b4t#l%XSa@%^f?xgcPUyVf8hi_uBH%*^ujptX`-5IpQheBkO`5(;ImZUJ4-7pb!ejnv! zc_5dL=h?|b+f1J6dy%G=*Q2~%YZj4oo=hu<|7xf)VPv`5YPVw29oCc+O4l2(bN{|n zQQ8=7o9&7n28}dT`(F)=UNd;AyK`sAZ9Debo7?SVc%`H3>i2IMVKty`yiVrcaL>f# zeQ3UP+QXxM^sTU(7QXNB_UL;x5~05K4#9iw&hW|jmNDaP-p6!QEE_Lc=2$3B?N>F& zy}!lfTxFBV5025Ne&P9$=fC{}*1e~0F2B`U#}akGOq@yPtg@-8^+}ISV)@F$jjC#$ zm*$=5?pMS@J8{z5NNUgKFfJcQch3thSr5N1qN)}fteFaJYYR{dOFC-5_P#T*H}9=e ziU4z9jzliSLiTjoz9&FUcZbdy>cfW zYWgOr0r;|oU`gf>kImmsGG`CapA}Oag>l}1P5oxgL$$J@bjt3ZuG#1KzRi3wv(exf zL*Q+5|C4C;F0S05BRc%!&L#f6M%V_?_zi`JJetzZY32id`7dD{PCC0qR|Cc=kvYKa6P_Q^j5pTdh~5Tsp9Q%g57D z&E>!TSQ^RcZDt$F2S8G4%hR$oc2u!|v=tzeWLNWOPUp+n68P&c|4|kc6;I>U zJv$4Jk(8i&5{^k>x5Hce`};9<$+<0b{yN0^4rTd60gHcd1< zbLmf+b8odsRCF|nMSn|4``3aycxJ>7fy2=`rwUA+!E8de%<5ALhFJ#s6)XU7hyeh zZ>}{FBMJ+U`vEaI-A@{G2bBZ>A#*qZ93H?<1CZE(ZkHYcZ}jH6;xHtqH?XxO zxbBsr>oL}p|9TR8BuWj`mNK3_TZD#9DpxlW?-{aFWbLQb*gX6nQ7gwUNPUqE+nSq6 z{DUB_Ah;`c|18jpF3%f$B7uJMD0Zls>*{U}{BU*_CX@Q&&kDUNyqCIQY<%?X@7Jda z&-Fhu%HRM-n0PNV$>-LNL$`X{b1Nkt&LI2^Sxc0H-#cPUBHai2-nTG*xFmfJo$+gyHt~A~PP(KZ?l6_y|}wdhimlb_W{0-NRVB)68># zP-CIgquZuxCh-j&n)Ie%gHHM|76t7&POJnA3Iwic_<%G@s8b1E;|wwD+4uzihc$SP z(Dvkh;F#MVUzjU+=)MKO!OwuCPm~L*v?x#!Lr)ms(UkAR`FWSA&%HbiZPZioz~2R* zpkv2j|M1AkhX75>X!*~iJ$>qii-M`U;<|}gX7Wt9Q|JhbR-p{1SETh3;PYWJ@!)|; znjUlE#lY&(;v}bnNUtALK+|w4Q<425-}hMyyCnT z#$bjIhG$6$$i9}9m33WL3re-UBMb+NKI{RPj^)-mQBTuCnOE5CC8qfgW*u(xkr^@N zdZ$D9G06@c5Z>zi&xvMg4m)bJHD<8#=Hb1=s+`}gF-liEzXGo6$cap*Q&kUC+ehqo zKP|e$aud$(%l6n;h0&jdUR(*%u`MUA8ImJjyrcS2DKlVo5u2YnZA8pkt!hVy(SXzk zzVCl|)ihrs^a5iYHq69;7EABzI7Rpjb3%m+EJ~V%v8}e>u5_nGX>LYFz)h5?q52un zF1Xv!ao)}6mrDz4JedN;;Jzq2z@_%viLV!H?A5BQtG2w5^yTo&+dB6j>aU>RT9SOS&YQx;K7@2I4xx*~e& zyFs@N>tL?CK{{H4X_JXtZ&K7+8F>elu_jbl%9c857a}*#=_e4BOC|~Rda^xC=wzB* z_c_}%G;XVM<6&pNS-E}4wpm3U6Cca=2=8bJUe-+KnV0N7{5U^;oSk*wttpzTb*0!W z<+$|>!Pz73v#ac|EVhs0F^JzijxZYZHpdkGCTlsK_xDNii%T=1_eNNf++j&U!FKFP zb~YZF5kMdE5-mOb#5Lg!b@$@q9S+H{LI<$%NK-HgR^HMK&UTYbIkDqqRFUUF#ljzR z-*s&rouea2L|)sY=^0 z&eZd8A(N@RgLYxie_7W;qKbnHTu3l<1`!7lF|)q8y?yd?{9#oVKJ@;%x#11t$T9p` z#B5lF=j;2o^ggl}-5?dc`6|sdrP#@Hrs1_z;7gdu0)}jEK4flb*?Fb^!e6di$1ERm`;NLkLQ-MB_2ux8jd4Jz+m^=4 z_BIHOyJ(iUI&po(7G;MT99r_A4bpu?aAoT^a(xu$qOlANe2dgXL8Au!6LUNM<}mIY z)vi$6-2$t*MdiU0(kkGBSkpf?t&h!?G&fK*b_UuQonj2Cupc=jcP*02B{b?V&!{|z zTET?$#VrBm_V)H5W0yurVnTL2Q|s7_W4-tEV&ah^{?D^bS>DjZ1pTvPvug}nh|krN zs?VN0$>X)&Rm3V%~L|_erM}n65_p7#5%^sM(xyOsg92;jXi1e^KMc0Z}#Q4 zCGYJ+QKm*wBGlDv&S8T%C^r<(KVT-ucxhfivEw+0QkDLnxv_3<&Y+E1>8;PSb~c@# z*?5xKNG$n=k1MgyK<3|1V{(A;czUtp0p6nJb!S5(`eZN(hD5>rrS%pPCbki7R1ow} zms4dtj=h`m97;nXPomOH>ckK6f(Kf>L-~k2cohH(F?fR@@d~L3cU)4+rRp=@0TmsW zogz`A|I~jeUh2yh&NA)~?q${itcIOkhRkSE2OehzH#420^?5FKRM~eZ_d!Aww$yN8 zb?+tExS%RwWn}EULir4NV6Llk&g?=%=F9}9k(5MOQ=mji!1X~Gfd2TuCXAs5lRW)*jPK_rhO^#XYk&KM0I6XtS@+H( zV|pd>1imU%Y5(VtZYVDkzQ7H8&8EAtvBZ-0LN64YwTa%#MBc_f0w2IZYDI!Rz|gOY z#FZls_R`XJ0g5$$_f?p%tF8PvHsO7k=z#{Vd-V0D1kYpD3}IOD2y>Q@3Bta<3RzXK z5rV*=6=>q-FVhtAL4XGYDDl*Dx6^PFhr~1BOXq_I)TU8afPtt(u?4G)Kj&)fR~UZK zG5^Qv2H!+09!rn!`~TO#E%@D|4AUU_HS?RS_Uj!!T<)`c2?(vBGZ63wT`^X|dIn*O zP_>{&grpIE^|gtstNUv*ZiUi)eDg^zC>t+1-TP6ni4!u-^lkdNP?ALu-7$ASk{0QG*NT7dSPELMsmiJ{!>-CBiS-^w^yZ`V}qyV$bbH5kdQ>d`*% zea8vfO3j$eVx)yU8@3CdRlah-86s4X+#P#|S%KEx0M+cxV$F z2o*&|Awkp3#K&yRzwm)L#tdv;D3afxMiBQ8D;@HG@HLdqGkf?u_K>n_FMYG7`tj@6f&8>PQswE# zppRJiIuN#-rS1|Y+L0sTLTAw7J%9cjW)f#HBcKNB}7M-K2;!d0R~W6S+{(|L!F1-@h@{digJzPsM71mEBmrrOXr` zXkWv}D-xQAGkOx(O{P$W8Oq5nx)3&QZf*{a#)lj`froRd?j!g zJrDiUt&eaq5bjKjW_wT7$gn+^$O@KUDrLPJls(Gg)$nkTjnRdq6@Of^(q~@q+%!P$EWQ#jN1_N6Y zXy0D?od6}eSThy1O6qg&7xf1Sn{HJpDZN#W1e>FSK3ITkca6)|$a+EM5E zHgPxoHMXzITD)8PCht|wI)|J5eHex|3U&r^mkx-6B@v$$_Aqs>H~eS!E;k`3CsZEz z%l^MEnE9W7H*k+-zhA4W|SC82r zGY)4kDyLCx2)J*^eCX2+U8;wNjysA;9M@)IHO$bZ{rua!@2Dpmp+9 z#l(lJGiUcY&6K!x$@h}Z>0pu9-*3c z=Hf$*&HP%DI`tv~xm}P#z;| z@|?$1AIeOS)oakjAJlEaOfx2vE@G|KA%u#p9GWZ$>Z^Umt2Wx&+U^dBQy8(G|2emY zEon3a;m+yv;2q&-ZXH+>y$@z$;7r8-{Q2GvqLSFry(Ov>o6H?ggfnUciya`oomNC1 z1WcRtot=rfBGec`Rm65qAPBkn`Spd7dHApR_=HXzoZJAu@JVRZg>D099VRx-cwbYo`1cD?e%rc|hplWIRg@$wXIJ0qAOQePTl`EedP zf$Il31b(=J#7Chc0p&}#*jNP_KF`m6+m3AJ58$_DVG?qyzXU(J?(S}ACu8s4?dk4@ zh0FJqUqk9(23NJ#E!0nfCYWqXc>kt>iqG3+qLuSU4&Ip|4T5KojV( zCV!WGp-o|kaifsd{KT82utZ3ai?AtCxB0P#&=vN$faD+8A1Z5`8eFKUm7W$p2mxz- zkjgp!0LIRUaDA=FM$SH@F--k7yh$u;+ zc9)j7n?k1jWZn@6u~qcUg=1begx}BMfG7g$!VG^#U#+OHa3@9cX$pOUZiOYq%6!W% zdp>zY_K=zNb3z$EksqGDWz*QqG|))aq6kSW#IDp&FMkczbaiAhs4cE5TKZPQFqefX zag@tx`_UcNMxwAOYo-ziGzXc+@*HqYctnJuj9tEg#G15nkOOuATf-9qZxo`MZ7`yt1}6HJ@nb0L~QAZxl|8He{EzjfEh=V;OH8FZqBs zJ74}Q9NX zxsncarv!6xe;p6?-o7_k-A2{hcXeqJ=_PaP$t}Ns&9)n7^e^AqVI1yb`K#>lAI$fT zbM#?4|I0o6p9Wv59NTFhy?!Gl)_0Fy3NY%ziGYp((+p9=5Knlo{CvM~`2i6@ zE^=TQEHRr20M8x3%b!2qhs>%V)cu3)Z}cbhRxn4`*wSMA*!J~B?VtWSfYPv^!i05) zf515KK+bqiqtDTXPJu z&27Zq$6EP@6!z{)NxQpe&mOJa-YUC7?39-zns3HwGtdqXd^4uiK}hcLKY*!Xo1*w z(S6a*3NkWfe@n&16NY&NtIB+L%ZwHm=w3DB4FbjQAN=>6OgJVW7sZzJ9X~oE>>KR@Cn({ zC$D~Qp~8;CE_5w;xS!XKb@FQl5oU}yLeOPhs9gS94gnXI61k&$`_$R4zSdfgVjuSS zMOc+Q5+$uSRn)GA=@2q{1$f#ewI7+1Z)LJBi=Imng zLP^=Uk2VDd5uyW?^q|6XAK`Ql1qbK1U&;`^CbU3vZmiIc?`}*3SvM{|{-DwU znNkGu5BZN6cFQ9Pr606EZ(DN}cH%40tm2&7I)kVd)CtF^gOZK2tq09Cqzt<1{foZJ%u?OuL#k+HD{sv+0HtTdH=a9?k%<7&Omw&u?aq_bZ3ztB$s zn$_7OO(5t2>zYqHN9?N?K|v!&-FD8|j41_{W0+xR0`C!(4YhTx6X0Jo7`vpTDlh#^}Qh>G7oWxkY9-YtpNx)C#kjCI%tncN5@vRafp%#Y;yBvQx?qhy_zRqW{GF7}i zYyYoII{ZodJCR#ekwcE0s%I1V&vzEFRq(WgL&;nyDt5!%#9o7IB!+{2 zFOYlZQ`m>4Uimh>{`f>|yk-N4ZZY_d<((xgH~OBQ4hzp)Z6xD41dF68h0_T` zpv|{o>^XgA4+oSDP(@Cv$rPVSzUi?Ng2zg!R3M}V?t zzF$L@-cfbc&F$2xqq?=jijSX9h+AP8Z9Kn??P8=js|=eSZB(rV^}(vAaM(PD7y~a! zy9X~`{01_;nQbnOdBXvv0Ile^^KqMxoz1Zrr^&TVW^Y%^M=nGaQsZ3dYamta zm3iQ%^7Gm-#DQ?9<1s3C8*fGpV<@BS@9ednPT&5S50m_VUWs=7yUmn~tL}F$7Nod! z#jO5r=rU*d_ZK~1Mw}~{%}T^17mAo(Uv-bIc@&%pM1m2j7_1jDSNiuiMiz!_7WjLw z?&H^kxBuV&Gc&*K)Q6HB-mSQcADD9q(BfjwfS>Jwsnl2XB3g#``^ivp5U&NL5DJg4 zn#8T4d;O)JtKrb(J5}}jt>pe#35~_qwbm2QPcYLev}iEeJ6pmqEiK_ak+UrV?(Y1S zAWwW8Jz52Ajo~vVHgAZC&=^$j4@V8g|3M(vJ@@kY@vDJEJt(3ef9OYzA^wtc$*Gd5 z7QC9Jeo)X{pQdD8c8SQ`W&<4%~dlNfn;x7@zH~+u<=NoLYr5pIpPpYqB zp*rtwyI{W%`P^at3!y)+!Dm6QMF`l4n~SkF_E&v2|N|S4P5ifmfVKr~oe(6>$l=P+dz& zp`znwZIH{KocIO@*q0YpwPN0?)-SwKnLP<_8|u;LG;TG*tN1B{KEEs_skO^Z4aWga zwMyzW^3q)UTntwt`QWl>%Ka=uKEDP~hpKpd`2por*9@X1<#ji9CVbJA%St5}szt}p z-AO#>C*nJtodGsp1z{IJ&7x{qa}Ok;%QK`pZ`g*Ky+@pfR;m6r-x`9xjBUMH5DG~N zD3P)rJ}jKDM6xAbJ&ZhidMejeRZ1Hq8o$D&6@ZGaIT?~V6k}$krnzRs^a_a94xlV- zJr@wV7p70pV`JqSZv3;P5`p`P6EdZKtKU;N`p`J;z5M!m+!2mGdeH?oftl0#)#~ER*ElaWNt&1 zUCoO}Z{$wlvqFY|gpOe_zL>X8w-(XS&VT*rC3GC{$eY8PURIY?$?I;5%Qgu^Rhzc9 z%A0E1FXH9p!IT9!kk+VGd`uf7e_D*VIyj9rvEPvSqCWEjG zF-YXg%_64sJsjK`{-Gb0E9CVs-;7GCf?rx@bApU5Wgj-rYn?{w4{x@07VCzD7+T1K z-+%)ggh(L8+EOnY={GvS{Epv`&I8Zh!vW-7?g>pH6L+9+I5B1yhy2!7fIyx>u0t{3 zP9_frQW$)BmzVI1+u8kYdzCSs=E4P6s0140{iq&!V#oUVh|7asH`%-_KkfvbuDnYk z(HJzc?qMoj6#y66vReI46^}Z0iXvF)k*pXQMDCS#$JZN)cX^{)hR`Ng3A`G^d{yWA76)M-dDw zfnb~cB!5fCsB@UfvfH-Xt`X-VG_q5GEx3son>_sBHwYN=_H8+~mS;I@w&&%fJJ^tL zsvATO8um-k?2qB##={&zMssFddS`I~r83RNuSvK^ z$I`hSZEOXDBoycN;rG&Hij1h+)59MLKv?~f1N~ajgzm@%XS5s@SEUd8Eq=TS)F(XT z>>yj5Bk-0VwN6ZmV?*oJ5EJ0eT*uit0!Z}{{d9Ciaq*qj;ypIi6jn2S-Z;Xj*2Q=2 zI&1xT9}0!Mn^libFa!erVK#3iBWzs(^dTQviV~cSjqT{IP_*KsM~Prdym>w}33fet z1_ozkY+u5Le47kjsvrlyX18HJ-o<@eIu7Y;+OZtV36z)G$mC~k<6E3KTDD2vE7=V^ z#$ZwRG;eAiqF<-XCGD8E&h*b71OiF=ZNC+6{B}0D9;xD}e!hK zcbTm%b!T9Ok+nGv;9i!iu!U(?p4`<&{sBEk=H} z-_3=bp@Omdb|g|KkLU2{nf(JK5(#kBRpd(oa#6ZSnIpIlWx`aNa74s7)J;2NWm&c^ zBkx3(VmP;U3Jnmd+)Fwv+9Z6K6|(7>lJYlWNf7TG0rL@piKeKJnMOu2(*G>{!hm!PXk% z@Ci04vtf_=luK%#HgX!)pbALw{Z0LN%l*)GPqe?xf3CD>Ay=>|HHQdZN@O~gwEXFG z4WBRee8ZD|FN+Gv{zfS4;PZ>bPW4>ifLfAib>TDUtk7q|h_&H`nIKaxT2a4W1D6#~ z=;+iV0GOGZ?IK_nc=(&>-{X{EZaRt?hCEDo9+L|v9E1U~{tSUoGrmRI;p(&a%LHJ1?3Y8Yi~z~hmo ziZjwx>hixY9R^IZIzxlhSe5uOZxvh{_jONo7_aU~ zH?hCBc7C9~K2g*fSpZ_=%6ErZ{8oOlixSSTJLz~+`Gf9sVhD0K4VvoCLz`c0c+n$6 zp>ORR%;iM6qxZt?_~JrEqiPL;uvtE6@9V2J5@^g6ewC?d5=8>Q%cT4F9qAi(>s(B( zGSbyXumS60uWtHK;Gm-2+Td~YkAv1XrRABy`NV2=r*mtWyLFDq-7d6|i0cLTM#TKg z(G@?SXt-RFqV(~FAC-Zpt9`( z4?iK#?IaP;hZIx%sq(P)vd^CIwn}YBm?yK_j#3o1L$(ITzsP{or%&VlChb1GMPb9} zKK={(-Xsq#$^{b~DjMd06I>OUQM{_KwPqdQ-02qiOX3G6q(%4525Y5ZXFOp^!}bOs z&9S{<6dQEyh3yJF`|8%n!s^0fqWsYZC{q(lntdNRj(bPP2bd6H#nyS@CF`JnxjXDK z@Z#-RwhP=zDCC#B@bae#1TWOq{?_zq;sHRGc7R0iEevn}QomC%SI;dp zH_}@o-S@Bp5X_H=a}uvs7W%xO@_yQ<<#xxImL{TW@4TUg?_7$)l zB$cnKuh_ARYuP<_wU54t@_@$x>Wm{PYI}u+ z>%JESjR?!>dVqTXHImT7`86(h9litQo9j=v^If|$EO~}stOZd8bNJTd3n9&BJF-0k zGqt)ml)luEEc29jdieR>0;irGaT?NZpT2YY$j6W|e}y@&dAH%I9PPeMrBoBetQ9guR)mW%9?~VUyecDa zDkO05B3HtJ9mlUM&y6NV3E*+c z9$#whJ(m&+_)%c%w>a54L+KdvdAa83tZ4E_*^UEmCs;i?1nNz~F8f%WT=|}|CTANa zvHJ6gUz+`bps}^e7OMR~dk&luwPiVX?VYu=84cNh+R{kw_4CR}eUZ+g@2-Y$;(>i!7~N$!x=O>~0`;>`|3M&U0Vc zK92`=uNdFWzD=u{+);u{U1mu05yNK*As;h!Hxq>>lBUK7H)Rv`NO{NSzlmObO7Lj? z!mQs~ADaXJ9~;s$apnzpgob>!52!^+bl1)EU-1!AN8rYgi1yu9MH5|Fe~UNl!;2Li zqjn)$tYv6|npp9GsqqCIOJgT9GF(?&ResheFTJMX1E>CzzLQI9=Y)^?6&agcq$Z@y!qyC_ZLq5Y!7FcT~O6Kw9>fwf*tn_`^_bbU4Yi$69eyKEJa!8^* z{_t_okCLFYZJ6-K3Xd-wX7q%WQBt;`i1(o1nooWm=&H}rlJjlF)GQ*j9MV-YYrJi5 zdvrQFSf~%h2r;G8_HirL_A=!&~tBRCG;IS=F z*q|>ExE_ed+Z-|@=vkD(a>8giCp(*nFf~_TXpYXk4_GGrzA&3KEwQ+t_Ax=eL5hy~ zupU>M;)T@i&Cp487nsG_XrHzu!$X=UwNABPn^W%hQf3VRd8B1{;z! z`m`&*zVh<%-L7|S0{nl(Mnj_-O;}sNv%2XE_KJ5>Qre5hUdX!N@$3mXd&wwis#@cTPo)lIP}pyv8+%!!1fT~#l{XwycNr_8BOXq9@U)uA|DJxLBGcs) z&)pt2vCRSYPTPoChAOTTw42ZT-Nbf(kJDzI6POKyeOIhmG73x(erD_k7!zsM4k?DHoo~HqD?};BAn7P-8ON9{63Dh!k18C zI(-6;x+g3-{V=lpcbhG8BBI3+Vbu#c$*`U)hN@ zE-83Fn_fv7#ljdab?0bRlUs{nAoq2a$HxnA(Nl=bg-0B-9o+4nNK+IWN|yND5_FtB zok@DidunjapSesqD77gZ>}IS*EO%T&z&RHxt-kR+yGt*;S~>%VBPnBml0MkV-tKC$ z=iVa}Pla0XufBN!eN1i)__z*ZSX@ zzNuR-4g**i%P4pk8N{`IN;4rq7JbIKfOUd46vKd$?6wK4r`@iW6d(VYj+G_ovtzmU z(H!ub#y0-!)Q7H3Rm+#;reP|2V%_6M=VSd}7>9&~jdIB}PP-*g?2%9YC}fwA$k7C6 zr8tS}KGyQTFW>bv=cm2PpBzeNxFGJnT|^{Evc;IzW9N^oTNiWpXqh?Z9jumuYkH~L zI?hi@qPuC8bXxVj|8j>`@y%5pGzx@lUtz&?SR?l z*@5zgNn~HIQ{V27(7)e!17$iUIb;Z4U&wrKUN6~9{bVSEx*b2f4!qFEdUZcdBuHFH zL{u}q_Srg18D;MB9-&iBdK`Aj`bh3UR#<}F{6cKaNTl_KO41p^1K{?yKR21|Ir8p) z0f*zE#=`UdCrKo)tc3*ATMosXA=JjVP8_u*aZ-ra2?bZ`1&>RL-byCpzpyz$Z zsphr8dLxAkFFff0LTGB&e@C475z4W~Um}~gX9Gg{!tV|d8`ZtGw${(@BXzL4y`!Zm z+I-b|V@>@w=TyDR*x1ny-EGI?HqwfWgQ)#P^JF~_Mu$~o(Di3}Ss?V@{MgEmJ)juIvxF)Z_E}D>-*qWg|x|#mUPF1Q;jy`WXxdooI7dN(P zSiTvUNMmw$RysjLKYcC9+M2nZ&NFcIuD`L|fpsbUl@qT(ZcnheYz?sAzTb4;&Xb*F3JC8UT1ljd5^U1$CQ#+g#y_D3_1CulHZX&jMpu-5O_9MY&KTG?o^gn`*z1F>#_* zNX}MsHZFhR+Qi;fNW5At4(m3dIx&ke3mD!()Vn#4A2+qM6mb-!yhvA3?LBu;kh?yp zq#%>I)lQ^}?**3xHO-E30Ci`pkA0$FPE}7X+%)3|=a#S(KZ8H~Ye1VgsAd^UzL~#h z?maQpA2gT^?<5lKPn7fN{Id-%KmMR9N{vB276xd97`FN^4)P9gVzR9xaoi>>*LD<#C4V zqJNn7R`UZN8ta8@V*g%DKDGWW&)=QgeoCm3rI?{r;YkkL5ZtN+yjJSFHt&0{XvKB| z&gpL?KRxd-n7H_#S8neyb6IomBW|-O->1CA8!z41A5##ShJ5s9{N(g2LD8F@o6^}N zjfM>{IV`%v*13N{HJ3@m`SbYflktfWy^2RN174X$JIy(m>vuQFCS_IOHHS=!*!;xO zBe4U|b7l;hKM4~9@Bafc$87Y?A z5A6}MTlEH4Pki^(0i+k!q+_1^0Rm!BB$Z}=Hjgq+QE|(aVK9bB#EMa&=B>x)skp$0 zx0tDXzP9PDrgg3vx9(O%W?KiF=NcbSNv%AL_(HsDiNkk%8rZtYpOh|3imE{~sS|Sg z?$vutqdFpKC97jiEaxR()NaDLzPIw5b+Wq87(xt(%@H-N&&nSkvD~@-CF#dA1FH(p z{X0J7?a8<<*fGIg`J02=_D!SgHG4J}chub{?_*~i=~_+*qwMNx&kjwbqUR$OG2bTi zSZGCJ!^5gy)*J0?1EChT(SxH8K$Vy6XSlz;zav@abdW?6IJaqLqyAM(VI|JS`YA?E zl=+HGT%?4@hvn%v?PVV}^m!9Czt6TvO`8AlVaXo>Z>V@Jj@+AL=((;O-9bl+EQP~I zvJvg>nWM3Vr+Z1~i_WburSGS(Tz}4$R-1)`yQ~A1^V*;92HSd(K^LLv%hFHK;SXyA z-9*IU5&+W&KN(Y7p`rXMEsgF8J-wyV?B zKpdwVybh!O*9_jdZTO;F{oLhfzxa>W%gZLI4&ij10@r3zE%SO<{KV4KrFsC;c>P(F zi7@xgb_srAH(HOW%H61i-EVtVop>(EDR7F6+p(lgvTeZ%U z`M3N${Hd>L8g|l#Fn7&2j=!*W^L9JDo2r#OJtadUD<%b#XxE7HVMjcc;wR0Yj&`U; z_D?x#Yj1jCKz;iPSM`}j+E1gPdJk6L4K(!na`Dz6GCl`_B68%1?Z$yVm01GtyAk2mMX|`CYS!K<;%7(f0JZRyUAvs ze6s_ut!=#M+5bSFCroktg9MN2dZ^{?xYeb+HzPnsD1?1hJ!AUlDJP1PWgi4+#U~p- z_ffjM1J^>;_fseH-9Fd4cm}Nx`wFM52CRRGEv2k2@lp2cbagR@FBN{Yq%Xa0J#S%| z8lb!3*_{d{!&uKPFP%(t803s{a^Cf?Evc_HC|B*|o<3@?-<_0YqEznv^xULD}9MVCzDX-v<*9$c)LzR5_JaXOri@hRXUsn7+_mhf%b+gw+D*dB-uLxU{yPClOpUp~IV?J+uVUqe=Yo_u%^kr`(Y3(&CmOOBj5C`|xSvK-v)q~U{YS;BIj zjq}?nOO@;-AMNdUz3sJ0lx9hFRoLS|zwpx!YSqbp@72lX)KUz3)uMfa`8I(8z4?BW zVHp&TJ@XB_&9;8&%GZ8+9t%yqF&krYJ|*L+x$)eVyqy09;F7Z~>=MSt_k6S5)VFT! z*uv21@~_u#nD@|yW%SQ1=Sw}#9cc-hbJW>n@@q>-;lyG_t%_ry$=9BT{UdosPH#$I zJ~+kvNYEh9EwzKDfMd;)VeQ2rbx`&vKAvn8t&4Wtigq%FQ{8|Zcbsv4t|q-Bky@1S z!cIRkbd}%c5g8~8hF0$0xf2l2WZ;F46zs@|2aXL?Ek+va%!3L)TEM7`V-PWYb5Tm- z(O9}{Yv&a2`H(Do4hz&4+|$uKw%Dim)I=-8fzmeY`wGqIk=id*$D+(t4J<=N>MS;X zxfb_3z>9+JynXaOF4LDLd5C9Mf#48JMe;}r_HU$@sXv|#X1;$hRimWG*vEeUkFm4i zKYNCMF6gSzZda1D&V_9BG-L%`L16yuy)zUpw# zMlQ^tpMG4U`_k-SL|;@!YU({ouBW1hCS>GvhpgAo2XaN64LsVjEb-8v115@4Cil^^!%L+VD2ovp2{kbD95Cg!`^ zs>v=-2nn3-^1v6UJs?uHb%wwe`;<0#HA>qxMgrBMk9vCp*ptPnQ%9mv6QJ;XCo8|Z zJwc&ew)FmeE>4T0PTG3PiZ_J0Yw4GbQ429NrY8cZMrddszcMCdaKw$E77V)A8Z+IH z1aINemVe14ed;Jef1W=*ONnWICKZYKCVn9)etu$Oy7!0|1=&D@`oaIx-j{e&{jd9z zA!MGyM&=>&w8@w;l2AgVu+281h$8bmlp$m$iI91S$`~qS$P{IsBZOr9J)io1zvrBL z?^^c{_}#PCS?jFRZnyVmzlY~}J+I+BT)!6I`V!w|O6d^S+hDnBGBcNc4yPRF(ST)d zPWomXRd90G1Nd)h0=x?(3x@5KlKy45CP)&szOso4(;MqL5Ms;#bwD0!CdkOZIZwFP z*hcgtK&O=N+^gX#rIW>v5>*7F-AG2((xOg(%W1)|>H5v&tA?I8buzvz zX;_&4KPDni2Y+4{u4HwXo#L`6ruai!BQhBtcJN0SzubVUa&yB}>E)%~kl#Q#WptK1 zBMRb6hHvJ2DOJ%r5&!*n(#yiDK{XIY*b8o=b7!Pu!cK#pf3aFEq3OW+Xz0sX1TwX- z1gt-w7f4!=DvJy;_9FQ3Ft-clOg(gYsKUf2PV?3_NUjeTH7XpfBshO)v*>+wNv8gCYnZt6W2ji z(G>xo>n^<526<7mPFNQ5DJaGSSKoc%oAPlPs`WXQ;PPQ@aT}!#3<97$1JCDWx>@X6 zlOO06ApGDs`Tanm{^9G__l#b7-`;g;SK}(%E2LjF#+xLb$RH>|=8%P`V?OOXOb>)q z{u*oGrLAwDyAph0WLXk=dVHStEV?{9(7Ts&Bn-gKmd9PH1NBCH(cAoVd*jeJpZxUy$KH# zKn>H*@pqX-wtLRSL{Z_t&L-7mdw3W(>iNaS2-)5CUbv6Qfl{KIEXuB+z@m);Sk=qx z7gU|G)i9@y%XE_Wo8jUjzM`o~$ZQR?h#4eH7En~5FX1E%PoZBCSA^czhH4g)_8yZK z`3Q{YHH)F^ccYYi%_ib?)mn_e2B{lx_};8Ib`d#5E^IC2^03!U%QM9;o7 zehwuu8crmjaa!027#1;zS>hLpKgTtwJas4W(Ia-NqFHbZ0e!v79A!DwJMr=L$q@`V zUZSvcs6_<%`NK&eBB2sEMBvvSt#L&C(eXHE6t%UDO?g0$oM4|Z`QQiYRSqVVcm`w~ zw@BP0osoF$Dt1&B4UiI?+HNbrQ)ry!WRsG5^y^_-8dl5mtDDYaCFY3Fj-U0gl?t%l zI@xZW8TOze^N(1)x<-OhhJ1c!@S<-4w;`LuL(A)d6g z^4qh=45)gjK|!EFOWh`12#?gvMaq)zL1g4I2&JGv)RP^&KNIM=_nC)>hY*8@ekB@H z{uNrkH0B_ofjRl-W0-U-1gYt{V7>c-T(4M0AM~_ zDk`+c)Op`LR29@dr57tmD)_ep}MyUynUno_hTleYi&lez?L?zLS{+_`DvMJTz zG8xeQa(ZKL$wdqanrz5U7F>)1h&49u-V;v zKK;(vbYp0gj-$Y3rAB8K(i&eT*skfht{ z4Eq6u4oE&2u4b}P_fq$By-SyxQ=D$Fxh@lg0LeT-^gJPG%a1*vDqrH|;-c)CYZ}&j z4C5I{e81P$7SL5HxhkvCJPcG#pyPKjCj-qU=|OmGT3VE4pA&No`K^_?kC`9&LF)(y zmY71v*|!U?@+QH`zS&sp)fm-_{7DxUYithpf1XIwhIa$&Y_I@%)dQ)L4*+~5YVKqVv$m*F=t$8uTW@&1smZWP_PtfC5+iNV!c7Yh)% zChX&rwKv;COuKbkTQZwQ+WqOlZ#>e~u=qJFWbo~Q7OH$-m}6UmxUH@K(V4UCm%5)a zL%hI?ckY#nYAaGs%%tQZO0_q!*rG3N(Sf~*W#NfI|I@JrHLOY*>5mIFvx!boWc`+@ zPmE9ApC9(W#7)y) ziSFr9K4B(|2cXu@OF1JpY64voa1Jc4{~+NTJlS^n-$^s3?FY_6VeW=_)cKs6Q@sv$r|}FMo!Dl+y`H zp8|k)uIuajbF5)`EfR`Wi@J)^?F3X?*^=p8ccW=U>W!VB`40~~qquhL1py%_>Q!ue zT*+PE89$JDFO?H7pExqN7-6e-vY~YgU=!_+;kl(iGD8kx+nsL^`aLGHlZ90b zsFFK~${KoUK+1Q(9#Qx*euHahDs3OQ`-k!zf;1Ek?k@lV*r~#_6zEk-kiSXefq^M1 zq8Y8Ur$N2otNV{7iYFa;&rO;cKXTp^7DbKCaJ}LQQTvrpsYXJJWL!s4%1(Xr)F+0K zI38C!gx-J-(_6*d803GMV~=LmnQ~eU*qF?@R$jJ-EQ+XFaE>E)&I`rBqgV>T=;h|% zEG3WPMT&DPycr04n{p^Yanw4;1v*~Afb9dy;LV^Xzb~A?wlLR4ryw)?C+3x=!DZPZ zO8aZ7?(R~9x*FF%c$!VSi>jEYng}|<^GQRMgoAdqtGnByeP2^o_XuV^zXUi14TGcUR-mwCKcA4s)GA$o+p^$i}B}(n+pK6pa~POQbjb;=uAptA{r8;5dVX)CACXL`uBBE5z)zH1p*GV#c$z=0qy0-WHC-|ZUSA)L=bD0 z`;T7$g%l8p;im$CWddM!F&`5BL#SNtDxPBx1>vO?Fya5A!ZXkT5uSdBYy@s@pju1A zNYn8t!a+O;ckW+>QYYM1y#z{TIj|&#Rs|x1Ck}=sOA8IjJ9nUqfY=lUxmJW#84vZv z9l^TaWoNTk_3pH3?2W1I)MH6yTDRU@5Axle1j$IjfR>~)fJZP_wF#f;H7RsIL0BWg zq3bAyrd>kj+VHRunmvT)Nc=@bhw{wuA1*qjJVdI%q&k}UOy6@FsCa;Xp<4S1rn8Di z`?ox_JomPpa=V)4p&QiPgU;Hu<8%4=Y0T&`(mED9EI!>bu`YqiZm&6|?}q_yxtEeQrwA<=43wtRl@qfUDJlnhb#QP1IW=%`9333WD=MHEMhKKZ;d)HXZVNo& z#zL7*KutL=0M(|oe+yKO&QL>E-S2A1&nGggU&VmCj-fFG+rX7Pinf!^FZ=TP-W`}j zb3LQG8xXA@%X6&$y_fz)`4<}AP)~xT@Qatg++a-o{kcnB(7Uz{Q|`}xMU&Z48T~l= zRba=DRQZ)87}da1jvyOgjslXelB-t(3rkNCYAPTfYy#*xet%C0GQQqMLJS5ugQz(m z#Y#u}5-8(dpxc3JJ(w2&w6q95roL*xhoRF3D>nLNu%v5{!sq)0ld*7HqWm4O&Kfy7 z2Q8dWC1fQ{PX#cd4j4hsrNed|Fl0`lzjbs9#GkKxiuT+9VFHzEH!v=Hr5RJ3S|_ef zq;fX7!VChb1igXWE+4tFE|e2ZFNW^DJMr~sB9H=Mnf#Pl>lJS!+-A7~MyxAkL76hH z$8J8E0sRJFFM_9CNJgAe2(zt?nXdd%*tG&W4O(KhOMI~e6M&>(N0u-^lZ2lTlzgRz zIFTyZl>DS3Qc_z$l!4{QdBzuLWH5I7b)Q>JC5EyfINAW-QqS9pCw5(JOF8H zurVr{!i_V-8*VSgy}|r|Mo-@t{FFMTjmIn1*~P2#gZI+wGwwAEp2YT8wry`D4Y}RY z=SU+|H35YKpgR2RFLosB#Z6UuOHV}|zp@Kz6Cj0zjzasW7nhj{LJogVjemR4p7=jEy}fn+ZM+o5MLfOi_n~Xr*M~?@efdu&wL65`W&dx zBKFE~1Gpy6RRA^ef+?-@*H?@Mb)M@Sp`xcF@!c%3aNwfgjwK`vJ4vmM1G)gf_`Aph#r4*Myz^x;g2gmY}~J zn$22t=akQ8tm(eDWM~=tB_MF*Q}q2<=;hoe7RWJla9Dy`fv*9+42TeclOto*ra@=5 z0G~MvUjmaVzhn4^8{E;tehKzl&8t^q<1NE&i2%izUB3JSMA*+knUs+Rh57Dk{rCMN zisQE@fM$$8VN5t`kbCBN5B|X70IWRdHx|zJys&f&`wT7XnV=h%H$m)57Qv5^_)E|Q z^vaf;uxxIturJW0!PMwB*_TDQRbV0ash)+dvQX|^SEI~%EjYvZ*59Zv!wx&(l7u0! zAD}XTPoL9LO=t6~(f!+E z^{7Bj!#F2Bv3-N8vedbVr1rpk-{~xiv6;(W36TkrA-VI7oxib=;AkB+)E^-q6*Sxk zHUTU;Cg^Y_1^)N{yARto2w+J}Um9hOtIKiMQ!nM7vsS{v6Hm#3t$j46vo(&qX>+R` z;CtcWh<_7U`|O=G45B0pmCFY`1aw=gZ=TbP#dH8oQ;0!wE|Z>Ctrq8bnmAKmr)M zyt+!F472&Il@v-HB54E2nHnS8jv!)6-Mgetq?F9iss0zga|wf$oJ?e5SG(M(FuVGK zvb1tooHNMoH2m|y|6WPu{DQl+cOSmb3HTAGsyLaVguaH3+B<-P@vW$htu5rz^rL~1 zwGtB?o%Bli%(B;;?6{wc{k+oB(h?H!WJa`%Om{q-@SrEPfMxi~qtXkbdIBafXz1ue z9B|)=TecE~7`KeD2){6 ze;lg0>d&cchim|&pa&C_R>yOx(r7gYxMZM^0tdx9?6tFMN2 zQ3=DVzl4^^F`)GOQ8z6+W78&J-~xQL)~V1)=t8Z4u{bkB`#0k8`|XEBO6-1bnf*#k}-=nmeY-DWi9o|y2)9D&p0?gLS+R~4Kx zb`;CC*GuGps@4o}o99Z{X^g5ea_xc&?lf{$Xq+P+H}2 zP)NVRy?0gyI!y)eRak=91-~VOqS4_Z^-c=LoI&uDu@8%oR90oqA*RI-;CWVeF!r!J z6u!po)cB_qX;rppY|jxGFhwzl9rI0D4s_o~bCYB;6|9L=<`_})F?uhq zy`)|)r#1$JtBE=1x$yt+g4KSs{9gZ++!#!1l`klZU~fX6dD>?L`iO^Pa`qN`qY(~{Qm2-h zvcZQWnh92gH%G**te3A{>+FR&R7Io$4l0Zsm+1KWfRay6*g+2CNC;Q3>jIuK(5_`dF2&ZU|%)2BhgZ9K^+$x07is@WykP^8>KI9*8P%wROj=WGPf~ z`Q95W;Y^FHZ~Bd$lKk!x{^CM+QT$A(uUBd8o1%X_M02r60-bRh1UTTwb(TPnOwHd- z5T6A!V(p~Eb6NvG=wJhZn3rg&4V~zxIVo-24eCE)jcPu2Tb4G%LiOFVs&Lp~OSNq} z0p23cE|BwrGY9Y9#WO6ognqrz{?O53Txmz;HvQsys36GVAMm3b5Jw$%S5 zZ;)2U%bh!Hb`(e3MK>-d3w?j}Bc{IH8xDQ3H`jP6gt>0zLwF8QI;;IZ)c44)ZI*ab#P>bxaT6>3m+G z^Wn_Uw+v$#y??N)pOirgeoVO(Z4z>FqYW*F(k?+=!>`Ekw;!?}j8@#&u@?e68bEfx zLFxPP#yZqufRQ@GZ?NDCgbP@cAW&Y&QJv152RstS*z9;l-7MsO1*K4%MMRMFE6*Lk z?tlaW16?`V$^UUXC}2K({3uP_f+OFa!v)Em;q3Q8rVIs9*okxN6y%f4#xV33;Nv2G z?r)SWB43+tt+gbIE>VAu!4gFe`9rAT7{QrBxtGLxJsAzyw&TGtcmjmBHc4QE5tV)e zHmXg^DN4xr?o_jjMomKo8lKoOKN$Jq2C7l+=_xPv|ojA1gUh zPL7AF(nuCPf@e{xXnT;-XA&i(pl|>^4wNNL|YhBfUVH%ASo7 zlAs(&Ikn1v=T2}|7YcRgFIx7VjYKBiiz1R%R=n+JO|%+yBd=l8T{SZg00&=o{uHp& zvBY9OrSISTLNHQ(bBGJN_q?@ zPCs~f;8*lam3;^29ar@c8Bo>3^;)~6Cawg=cK1N)1*SN+$UHra37;6UDmH++7^tj- zc++2>keq|IutV?}M_ot-=m~!Sd0q80%+s{!0w9>AeJqC~7LJLE&aog+gg*NMmKro{ z@s6jH8AM9%*uel8x1ztR-$-w2ZbQJXx#m3)dkW#7N9DwTN-is-+(DgPFZA`age)R( zlq!K7=4@k5N^(n4hN-epIO(%k1SNy0TIyP89yqaH1A6I{nb^m@(-Pn_bDy9~_5vx>Ij>?WG^T<)XvyM>?ZIwe zUDOIJzo^>pk;O?zpU=Z)0(!DMW?Jv+Rmd^^-R@hh7M8q0>^zd1o~}*KHVt|eu{nHF z07}Y9)^QHh$&7l$treK$lYA8`f5`Zfw=4lz12s3pC{+EL{hbe>%~b%t5%9sR@`Oxg zswWk5iJgrc^@GA;;x!b5zKPwz|G?_jDE^Uf-Vxo#P8$@LoXnu;H9_fTN_ke4n@1Ll z(e{oDRkg$a>PL6=Ocftja+*2nFh@1qH*zLdxIRC1C9cWs(8=vce(;vZ>*|GlFq$zY zIq>CLvfx#r+t`b9ukKxoGxqahKwY~H90%Y0i(WujUPO%=cD(GlwJblNrD;_B0~;UI z&lM79!uc&deF)d%;GQN9L z(lBKz!|b45^9JayFa_N?>SpxnDF6yuG+gk-h>8))2ECh6WCSyI4i2Z?_4iUzQos)j zvbkCo+{0Ulwj%)h*z0fxkUtCuvtoFjbG*o906=V1%i|o{E z{L;ENl*5112Tg5E*wI86jIQ5;&uCu{k*(%^i3tg!HD=dZ?BlpB#GS`voQ+pY!)N~vIHDdU36d83*eX3ms#L6#@$4j zlTWf(|Ef_jJcnnL74(Gf*z+b~rdGl#A|5|8w4X_WseAq-X1;-v-iDcc)M-vmgy|E;M8 zmEu~WkymLY5NJVWxCV=ngJE4|$deD_4|fG(T%?bv(ZDC|QVlqn12vq^yAKO`;3fua`VA zFJWWQq=vWCT5p6_4F9-9bwAFf@ga29`vXQdfGl+4ltaD@`h~2;ST`gAY;>o@L2V35 z-$3QLva{VVB=8&=9Ef9b*wSnToePRqLcLgMApW-Gi2u8WS*t^t9;|!4)gHS~ zv_#Wy$CS?e0QW*Zd1~3r#5SHwDC(Za3pa*eUnbi;CZuxc7*VUiIlacuDKw5?XJ?eL zo60wNm4d&v4^X&GeX?9(HQ9RIx_X@vl@fgCGL@0GrlzL0_H?!vfKaeh!8Pgl>}g?P z9y*T&M$|W6Q4=JM5_!(xy3?*Kx&UvK>1u0}_Xa@`n0q`n z8;job24PI62anJX7vPg0`Z`T7eL^{Nh=f0q6xN+Sd#?7uL;dczZ{nRFQb^UwZciTw z#iqlNjbXGpUmMA2wI|yZ4;iLB@OPJibS!UNOJc}Cj_zpeZ)wZ4jg;FS$M@KhQfV7R zuX%NAkG-+`0?S0T7xqf~6GqPqqZF$4eq^lPumLv#BXu$4w+B}$^mMMgoH>L`)w62=9g1A5T|=RiTg_v$sN zup#629{}9N)AYw7)(#4{>%353IQdej*|1V2h!~eP9wvtUtb<}hyh)~Ylqs+?`XiCV z6HmdOAnP6APQhqDm?y)tZmOPC3!#l#cuDwN!bZP&`H9>41xtN1?ba6mvBrxtavPIlte&vxnR7r-u; zXekqZ4}ebtNW`@*+eD%Ngu^527}rm$V7J?o$aMw6vSPzwZj{8S*K8BuurhXHdo*o~ z2OqMuqn!2wvCQQ+epc4w*#+;-!W181+8=O0FG{ReQQu`jtZR0zy}m2;%zWH!;CZ)G zq@$%x8q@QjHrJ1zk>ww`mmZP(_7~qeJo3vERS`jB#kFjA0Xk94;ML3+n5AKv8EJN8 zXww*XU_@EkHW*rPw%H?j7+=)(7DUV4!3(CYH5pD523}5f+a@%HfSk^YZjhvT(f9r` zIhbd5bbn+RaQ)iy1xHl?NPhH3L`BzJ+Uyt~rW9cxKP25mrrj*&26RU zT`eq9n9J8pQD9`A!lGrKH!AUys_b{&P_zuL5ZBX8wfDP)oWHrqRq3`c~x*~){P zrDcGm#^jL8;Ll#b@|=!s9li4rn_AXOS&>AxH#Oo-Q2UmsG*f=Jrnz#yTSc+sBl~lg zJ6Sr|9+ErExMS7}OzH35zn>zX`l@{PrK6xk4IwXNKgmYLJGQFl;#E=S=xqnw1~2Pn z919z)|G*x^v)>G#r}ea$CT`?^lI`(P{8}SB$IJCt(X>a^`OU&&Vd?MapX>s{*p_Ap z&OIOP%az}P-6uX1>dYc))%tagIxDR_bH{}mDxG?gD3mTSexxWhwJy%H7E=xi#;Ha2 z$BtW>u204q3cnG)uFbHh0r&{85ttBpmTu_fakH8lHb)9_SMLuKew4`w|F$s!O~pL! zdGKOXLYBLjXRF>tb=D`hLu@$`8)+U7L|TWKwFT%-@aZI%xqd3YYG(4xtfY0ER{cr% zMGR*9^Mg6K%Q~wCdF4yYt93DB(Fla6%cye(j3?(t0TqR^hZz-j^DvLGlrc~pCAo;(6zSA~=p zP&4X;)VFEJSh-vRQ;0=qAvD2acC9f8cz6}8fG9t%8~b7)CbwSF?bD8a7BaGPG(xGW ze2b5~?WIi@6IYbzMP?Y_b!n~RSfr|?w7p2ClWY%C{=y*k9_B%vrp&+2ut=cy*2|7_ zhLpK_Y(6%7K77YtUSI)@XGuZw9Ae)Wz~~OrDk|0I&nTzNSruFyC(5evKX~?H=t{NI zu%p=+6r?80#nBB?=<$Y1wjeu8lVD)Z;$`S$+%LmTFlNuhH$Ee9{G*zAboSVI+OZ#= zlx-Z%$tAWG{~$X%I3`(p2=qPgUE{Dm}^8%q1J$H8(FYuB6bidFyG3 zXp&`_txCBzjxb`A7tJD<_?C63$xW0LtW2lDO9!eetuwd!l<2g&VTVA62;D^?kfauM zo~$N6&?|;uj1(-sDOwR2RAu1kVxu@0$_3@$6iodfJtv>yKv3kE$wd5X9F-dq);D3OhJyFN^}bOtJF7L%v}g2a~MqV^Gi)<>!~GvMQS@s||Cf{xl-m0l#HwQMws` zWWK|aMMRwgb|=j+)6m+(h_#TLKEv%P3|&!@>_h3~MOz2<)g^sLErs23aX#wj*ypv; zKa`@P8FE8a@^JgY)!fPx(l(&3n4QUmC8@((e9xeX_DmOCJ}W<6d)lFVe^>$IiN|S- zX<0r6Ho>1}FDPL4Kwwc!EIbRXB&B#;`-_-#p4r^D!`L3af&t&Qk>%6xh)=w##SRbH zJM9;jEk4UpkvubIxJr2M?Xm?nr;9SZjZm;pa1&Q4O0@CWNX8ypHEP5 z=9q;65CGbgC{OHwXA;1ub#}cR*CGyY5gnc7b_^%5wSE7VuGKSuX9gGSk$hh*RjSaL zqyb0AD}0KkIz&c}hQy|S6xKhJKu0O<;5Hbf5(X29DaVQx)*14h~5xHoED z*aPu8PwnY10X zW_1G5=gq%kD7(jPzY3e5 zP|`(F9N32R-0BYY@b?2ci`!IG+|gCN?)`lzn6$bFEHu|YKzqM7mOI)p1{8oEH8)le z8|N|FP61K#yu6cGa!{}2Gs_%EW>pd-cU>73hO!5Pp#Pl%({Gbx2$q=%SC>^( zRD{}EMC4=j)jcY{OS=jyLuTy_8 zC-b_bqLpvRXTk6**C+w!%%YIqQ}D6n;-%0-BtueksB3PdYIg0ve!a8jj8pr) zkIDsjng|PJ1ZsTnf}D(#kAz1(qkLce3iUnnL234|$}Y^Q)I9PhMJe^op$4PFDj5f7 zWfhNtX5mbaPp3Ev7Fb9wbbv*PpVHv~aUPxA4g8L*ht7Hn>E*L!?AA%<#{?f;`APAE z*G{?vQ_z8-3&+iU|Ar~oOs=)mR4M$Kddb6!CZ8J*FRy|Q?zC6H^|3*XNCuS6H;bAE zxiyofY4SU^3fa!p=HvzTmrYK6 zc~o=m>wAtn0m%43?PZzQ@a~GolK1NPPsR|QPJKw zz+hkS?b_YPOe;6#$bpbO#YT>k69Xg|nZFA6n z!B8u|{uPy|3(LLIHj21Q>_Z`g-zl?cT=~p#3w$NO{bBYQbcA z-^=<(&wiUmBrs%vMSBUR+#_?hpt%NPXX!$7|JF&U@gDR6izP19Pv|i}KR;qH^)RAn zjFx=kK;%n)SS4KWXhp>g72*8Fte=4riIZUDwZ~LdTbsO<9G9iD6WA4>XmDFfT6#!{ z4YJoEBg_EY*()=^bD>|v!0U_I6y-XCbDl3&T*Im4x^S`YQo3g(@qje?+pD~b>F*!H zv{Jk}v2`pqDIVyy1MkE~x?EzUAF3kO`fazzT{ z3iL*nNMA{=7fEKhyLYIB!Is8s%sd8xt(bhU@q;cxAO?xS%yI_%g5q?J4vZpUoM-!* z*WB;>Q9e~AF-2XIgAPu*GA+@%YbZYyO38b8+Q5p7 zQ6u;GnJlBtw9|(|yLHnOmc5c@9K>|0=|qoFx2FcZs#VQsKhHjAw>98pKN-8^|BKOO z_tes-fNIocbFc1FA59+F=o?{4u`UN}cU4hm0x?KQiEvoM4~ver4rf7Qje&jyP?6WC z;doq46>o^RS}yc4YJU$u+&keaKK5iYd7K(H;uGj#n6Q205Uxrw*RPTKYMzRn;Yv;h zKEmCO%Q08d()a?Tl;1&5Zy%e1FLaJ=X`wHQQG)N8c9f`1o8H6mt%*lv?9B8uG&C() z+0SdWd*1Zg3LgJa>Ivd6G+FH9b`dis@S>Fp9q%!{=ltVc6zdibw7jLn zyDjWPN~eM>BCL{uQ?$~jm7za~|KX)nQ#f0|(XWrbg0}e^dS*HHq;2=jgRA?P#a{d} zYSYMePn`j%2ch{kxo?ua&T`*i7^I91(}dDM$61s$gvE@>(rvsy8AU+dZt}1u9$A(koPx!76dQZ7N0nGiZ5F|=JW7p z@uA8}KL9n@{`et<&4u23t{&wC_TpfH&UWSlM1K&tHO7s6{CSg>lT2nz^ORsAj0_Dd z9zCrQY!oa5V9i>}T0xkfziHAqP>e1^^pkb*(=@{!EB8|fV=F5}aMX%T(2izgWQ4hD z71tt}q{>bfCV78GZwVF3X864+SuLP-*@O`aec*&n@AA=UUT`=ea)?39V{X~~v)U5O##h|}(-XmH`QwSgW+}*aN(P^7T7crd6;bf`DT{ee8QS(zolFaGb4oucSZr+?9Xsl2noNoOJ@ ziv5H)%WQUC!qF1NG0hL*S)7LfD*YYwc=MRO|~&y*|9@cP_FlLx@+KnM^D+4twQ>^3^0nZNY;?0~DjA6G`1 zYmD-bALNuvpOzMoCE&iRO5FTD%k}->`F^0y6tn#O<>5eGUfP>yHzvQzrsHa?2N1Iy zfJyZF^kxh5cp?_RxZyl-4~FZ`~;wv?BV9 zpEF(jzS^_mAq-ZjFW3Ym37KlJk1TkBoGthpSeB-29PJ$Pzt@}f9p!$%ELsgyPza?e z{qUpzO}G^?#eno@;0K~HZ>JNGIkhJRSvDIC_0vQ~>=HWF5)%_YKhCkXT8k<+jD!`H zMo>>!+<*N0xu>}#^0A;45PWvX>%8uMgVuaBDq2xb!QfEu8U6DwjVEl|G;V?81XmQp zhr!AoZXmP_AmeqLXQ|IhvRb=ljn=-ET5EuPxQlL8SeZW~s`PBRHz-8P3@+Q9;9b(Y za>csA?@>z1`!+ZuU5QAjs-T@qEoWma8U)Z~hEatW)`2UN1VzHz`*+@(7GDj=OKsGK ztOsXOCP~PE;G|o9i~hxLTXv3!FKBAY5aCb8%?Xde%cv^HD=bB5VLo^$MS{uOJR_DbIr65Ql&)-H5r%PHyQc>}<7L_@&F= zH4-RQ>&*`;Gl?p?Ye$_w~;XO+6j;1ni+&$b2-N_(%`nw zhCNMzOF9%A+6%Mu`A6ZBo2|>Y^o!CID^QY3T19D2N0)z`I<9@CFtbXSxgORFG7tzV zJ|C~D3N`HWKYUPR1YBSPF~G*=>@)pzuXjiI1cXNuD!j`LahHW>c}NV8F;~?IzBVYE z9a-9VhvrphxI*MPl3a4e_eWN1199Z-c5h?fZ+s|oF>@W4Fj7N^Uv|4R@JzePqbZX8 zQBoo`dGJ!|z(#i@*?XaIYn~9N(XH>rbTB6c^&@L=mC0s%+y&tII>qeH*HGWA$>!~@ z9`ZVELU%%f=*dITQL@gP_!&$=4mF0a$ape=&fW#YQjwLS|FT8le6j(9#p>OFQ3^w9 z+LN1iEGDK@&V|T2%mQt0^8B*db=_;TM=w~7r}W#|eI0@=c(+Tw=LmWbjg=h{zGY|l zKukAbq1CuDglCj}|H?JHvo1Z&vZbD-X7T9mSX}{oH=vJIP5<%!0~~O0SWN;mF0nrG z*65nP-Q8aSmvq@mNyyc=?AB%wuUoDB)G?Bh@!zrApb!b$Xh{6RrmC74xF7k$`qE@)wf?{ zIfIB$&iP=53V}c)HIB|N>6`!1>0Ux@4^9mO;Ge zbBZ<|?bFYrmh3{~D&VS0@byltc(w1*-njE4`eurM#AaKPXh_+jklj11Vr5sG4g)tO z#pe%RFd`q};O5z2%IJ{PFjM{oY-cF;PnRWqP}xm`X8wRSuDR zrS$(6jG_boX9}ZoB%`Uaa?``35b8Tc1&lH-6FKUU04hMP?+KO3~s{|m;ypsIUxxudJg{V6VzYUMgs zZmlhO1o>I;l*IZWXM1;Un% zy87Fp8@@iE41ohO(jO?X(99!tPEdXW*Zm1IRpk!B3HqKMs4jtlH3GrfBZ=^hX8oL4&JUHgF^i{*x-QVAbshoafGI-tr zXYZ367&&J^C=Ec-5GOIHM*A0~R9Ty86!Z)d;^J;MEY2e&QN&|-(cz%$1CcU{2{xqzgjlI8#?= z`8EOwFe@V!p=sjizsa%SVhjT|7(%^XU)_LICkLNm?`Gs$(hzyZ)w|GcCbsm22`HeKn54ep+eMkf#fr^QN;~4eSB2ua2Y; z`h%zgU;)1H?N3VuNN)lu16~I$I^Xz3)arkfl<=`r0kA=C)HwcWmKkc99 zx(Rbs^|?2&3*b2VI@LA&=5W_hH++pXfoKb4T8xH4q*N`o$P^iYX?-`|@zURb(5s)c zWEj{}m_RegRz&#qqsRw>=$`vUF>^8mdl4}>r~5X6w6G$Fj_Vi(iM#Bsi(GLO=zzt8 zA#@P0<`g4hZhKYLxj|o2k{H8^LXCnWXU)-MsQe9ZA0LYWRexJwTw91+_BkRl1f>o3 zS0$pPe-s<53`4r!8hPl zp1WlL;VklCEdkpV?By9lX4WBM1b*8C7;XUH;#@Ceik4-<6eaSRubZ3r^GY~t0G&Dj zTy=Z?7!jod0SrQ#9=g;*bNNRtkfsV^EU-|8AfO^yI2T)o_difo!M4se%qWX}{HX8# zxs{v!)V@F}fW_2vC5Tkw$q$1j#7n&mE$a!LA&~XDKSg!bv12N61+n4<6KH=35%IUOu6llcuSya!Qb*3pzf1z&k~r)k)d5p@C++ zhs%fB($aRyhk2R_|94%|DBLD*|Fvf{gA z0e#4Bj6ae#;uX2sA5`#)AWH`HJe*1^;)PT{k?WSH;J#UChGUggDMhDW=u)LW5^a1=bji9^P8i zQ;MV16(SkQqB~J)wkC2M8)Y{3!K3($V|qtjze&`}rCU?mf>Vs|RInEZsg#}&*`?hK>L-Ibz7JfeFPh_&swRL<9O0l2Q+`Xl=5D0BF?04+xAL zdoequmE%?a8E*nM8XQber8x2d3{mvvmDLluBHIwTZ4x6UJysrJ`zL+qI!jcZb#%1Z zD-xotVh}V`I}XK=cASG6m0wNJ4~GK=fY)F#mg}t^(OftN#YE7($9#yN=pw{`#iznj zxS9cep^mUq!`N27zVWFC+!bd5Y{CM>K{yF?V@FDhYJBNw$#E_3bTk*pYOox!LE11SZ#R4;8BvhkQ>>93?%CR1vO@d7GRF$Nu z77G32q!>tq;UV#kbAZqvAgJ=#gEMBJ>O=oLP*)(L~A*3M0cg$sB~9^31Oj=)6c z=R$Ab(l^8pSWMfI z&n^zmTZ|bLx>Bk+^URj1X)lf|%40ZffI|)wMxIn#Y`%ke{SEJR0xgg~xNj|8A!L;K z2@|u2?4QC@)m|8vH7`Fq8lX}Mt9}nNPduMtU6fg@r-J>+_hIm{+=Ge|UMvVx0w`69 za0jk#Vg5^k1`@g8*$78X4@*qlZV8cOH3R^D9Da3LQW``rFa?BSs7DV(Jg+?KEI^*V z9cupko=$ww5Z!w!WvdS$e^><6M!}Q=yorMu+6GfZzt!_yR`oc8Flv^zmxn||E%f!_ z>a)z}ib4YMKw#%!R<0WK>m20ZRfb)3b%5QGys-BHk5K4SIORKc;MNl34s#{>vATI= zPa$?&M?a_`hj(&I6y0lM2M`aqQ4;#mn6u-9(xpt>ofiK`7UgV2boA?6^A`aic2IGr z%}z|fiQRsh!jdCvGRHUy2de_c^p&R=eFqu*_!U6!ys<(773dKROcRolASyx1&UZhR zu)8b|Nqr0zrI;$F%gP4)h&nzg$(FkZih$;Yj{!!$l4nmxkx{AX;?W#qIq@jy>!tg! zDS*_jZx@PfIrVYaE_M#UaxL&EbC9T(y%_Z2Hgp0YfE9~EGGS&Df+Bw2*ISPE1KWB$ zK}zWFy(OQOf$LP->2SqwA|6noI`{?+Kh-|D$8Y8B?G0MX#pHu@9%2vyUV&UGF{p(P zp*UB|aTPA1cx3?x5Zt}b(o6s|IM)Ft3!TG|wIL2JwC@)g3czVFmd;=iP7dIfwYl}k zbdnxl0ydkuZ+>u?rw+#G8_*CB08799NYgx_udi>o^srR9GlUE!7?M{IeAN5#EC#AS z#z2~6L^_}5md};OX)6YIUT(Am2kO|JnGULpO+y5s4P|A(u>HOYDXdUMe9F1Y!mBb4 zZxhmS2${Q@qjKM0saoWFUP1~{eWDXEW0gDwxiWHhRyU81AGvT!I>K24qMbT;lCXV7 zUKA9t+nzuF9`QkkS{nB44^VY#7~uJ2X9CCl7chJCW8`0cQly#`6uws5m<{J675GLM zfH7Y(Ff1WggNI!xM+6`5&Zj%$KIh~w1@xrJd-c7tLR|6=_F5LRM6UOz9h(oEhrl%A zlWMr9djSD|Z$Y;w2>(-T5N>u0=m!xE zG$OnLf#*%U=xB@fzE|{cuWAbzH0>`~vG6v}!$a?Qr`MnO2tT^S{W?SmaD$&dNXy=z zs55;UycV0D-qmVOcc+4j0j6kK8IVnsb@HhFIEQsc}_`4ZE@>8_Hyj$7pjVac~I83-u^ZmD}RjKH|q^mgSfF_KB^ zuSR-yv)*+%M!c(!N~tQ%zU!HHo2;K@&%CYu0d~f6IwDP{tLfexguDE(KprKkFbhbvNl_bNm=#BxjH2%6yJwul_>*R zpkwPM)fO_JS}*|%_f+QJF0oWn)uLr30f#UMN%@lvsc98WMomMr7nXnAsBjNNxyX+y zg&J+}UU=pXPy&Z?D;P)-B2f_mOs4gIz6=+T;7aY%KJcbmZidf?&twX03OJ(wj!*>a zl_dZ@;LIGGng=?e2{n|)ki&?+x+R6AR-iAy>!$%{fWPt|FF;Zw$i*JaI>EmS`Hzn9 zMk+(biw-_bgmC1CFfQ|gHYN0T1hZ+tKrz(${&j@R;7LS}WNRQJI5NaGoA@9W z$!H8Qw}|fBWJ8zf+?Z z2cxZ}rKPF4GajNUv{Wa^k>c{#p{RcY1ETdMsFp8WxUh%(Xnc6S5Q2_%3ihb-0V_aDT=AE>CPfccR`NgG^@s;o)+YR8=uksxIb`6X-Y(O$#R za;1QL$Fz9FLgQcO^tqNO(14qLrG!Mi{Qvf+$sNNvWdGY;&?|~T?B{@^>+3)S zJ<8glF0pvEUCX~dr_g=_-Aezn2im7|aQ=QbvcniB0Ah@ongObReRLxrO6c?74-($- z1P!BU<)qDH${04rK+)npl0OX$;!>;ChN`o|+8 zpp^LYMo%o-=phpjP~3UTt!WS$fhSbi(tr7|7p(s65$!Ui{=E5I3RnTadD(%Rxh|K3 zd;O;x`_kRDr z_Q8L)4{{|-GS^&djyc9N$GBItx~d!|8Y$YVSFbP?_1#~+dgt-a=k=NmmCvhJFQp37 z652i{u)MdqpFb}~66HyG$5)F;LswTJM}S>`w|A>W2uqX&P2qd$Pa^99 z*DK+XhZ9-tT;4X%Q;8ER?vu4(_Zs7Jok+_9HeTv597z=FunHSQ>)jju*v*W8w&1%o zuJ+Zn7afKI(f>U|x><5G;XkM16dQc7mizBnEXj>D|7{^%9*X<#pS6{~!Tvo?{r!`s z*T2Vc=HD?0{d+vhL4h(YZ}Zmle=aUO`Wb4^>)lnu{saW@?%IMs#cp|r|MzN}3}V*h zZIB3_r@?%~JJHULRgne22AvMz?D1CWe_GIU@Z`U~+g!J0i7`zN&TQ1O?ZXgixO4aN zxzGh}_W$+TZ(@N}{vyknuOtGiSN+WYw{f1Z%@-iq%U6nKEPvYPssoPmCeNb|zQ6`Q z(Olx*)Z73huf~!HkJe_^=l38wF%SChhKkmlXn1YL+w^q<{M76k2O67t#|XE$}rh1abCVbrI)XMXk6Qk0RJ78kwTbN)sJn9 zRvd}wyY;nh*bl#6)yh*V%knO9D8nz#7K_8qQ_F{n3wz$8AzakI^belD@Q%j4KE+_c z79W9~B|CvN504F>&@_4DNC`LvGr_$)v8WegjHsW9@c9B;O&S{gCw-+HeadeKW`5gS z`}r8gGN{}#$oxCt+F0~#^c?hD^gPkp--@@=9Hu6x(3h7`w|JYnd)CIW?rkjnTt*#u z{ZN(WE#@k1J%upqk*XXmF?H5P4_Z#FrDA$oa|Bm_0fYe#&4g_94H+zWz0K}&Sx20O z%%l?LocCE8UdKN_Ec^aw$ z&FiqH6w%b|Hw_lJF^*gFKEK0OW;U@bp3=NqwYPq_|6P2`DV%Q~qxg@9Kz-!;ot20C zIkuu-OFsr{yB5Z*?}$mH+B{3PX3gi>wYW5&W9jKYV0ctUQM2K&49O5vZP;CZ87!N) zUoM->1$g(IHarQ}KuDRzAP2mT=F5B(U+>6-r<0$hgrFsSM`(YKRe%FtV zNh-i%OWOpN{Z+z*(cBME?mDgT_s_kkFU$SEl&TX7RB=j7@|IfcT$S4^jn^IKYn+)D zA85Sz2F6t{gF+D2n>d!!=|vPsaPYEgh9~tqy3j)3;RaID3HoVDCf6k7y{~`qn;PT1 zR-zc}HBTRSqR&z>&`D-eX&Y0|ZcFFE41GW>ofz4^`5Aq!r+j9vVC*Rn_8&)CT!v@d zL1;XqGi_A|!)I$)Lzjh4%yt+#^xY-*_}*|MG@S+WHub@mq)T2>1) zYJRtS!n}o+-DjT{+CS46UheW6aypl(n6B{K2xT}Qk2h|NqhaU?Oqe9xa@Hb(VK8Mh zi_rwOUy5oZ{ZTj~@ikVc2DFNJPBQHy=^mh=^Ndf94NZD1up9%g{oMb!&I*H%$I}Wc z16s-3-(W_oJFbU|E?ogVg*iu87i-sXK!+(c!)aPJ#>UOJV8?5wff~=V6R*vDGU!)1 zC)*5)hIoqhi+i1$M2+hkI`15od|S40W16zVG@B~*7`!3c!Q%%EDSP=1P;=(HrnJTg z4TJymCOTy@parC6m3}x;-xdGK_20*IkbJ-%GOFq0_FK>aihQ99_Oq>Z_IvV5divc~ zK(J_UmrBO!tTti51<~VwrpW;f5$XiaeO<8Zvt0l#__b_b%>oAz{2-fRz0K={&Gln1 z#P85~h^)(pBfz+zxu4q)Uj5T^%&9SxC_h(!*3E1lms}4Np`5L&FR&{r+4tAb^J%2C zpENaM(qVGlSO7g?ZKp;vF)Sv zaV#73o9?s;ihhcVC4AtIqlucVuHcKG(doX?dZ>wOk7aoPrsc)s{M3PWs)0-Z;?h#? z4V|JPVCI^2j$dU~cLtBo6?~Rnq5tt%Q4SK(xv5ZX&jivLk<#L=w*Ju7 zn8N?4gy(>T;#+G52G*A1yHwZ@S~lqKVybGX)!u6BJON&31>>BqZ|wnGtu?EsyJin% z)7d&kouHNEe`BoVb|jXJ=a>Q%72h!L*G2WOF4P69X>CB8T{_G6&r^TrfY#uHR&YD! zQo38+egNOT&-zl}*Z zOaHF|r*eJ+vK#x5*vSE62$P40hnIwxcmJ`w&*2;as=vqoM-_ef|5io+dtWrG1{$V_ zZm7I1A322xnf1)v|Bg5OiX|F4LD9IKtJE6G=C-%EI$TU#A4%wac@}zR5~?7YOa7#k z{__O>Y=-%o9p)R6FiFE&dblf&2#Z}9fKQaOyJ0I|^PphcVSu9YIW-GXcxOv ztzyr&0|yH=0F@lx`1J{8)=||xdH`P&Z?|{z{e;laNzC{0+r=qx?Z9M$Y4ic2Z|CFr z*ifDH=b>ev;m@M3pX3@(N8XG0o^PKDWeCPJrp|Kml7@z(6B)ER zta#i%6G%_*H}$z{dW7K=hn(?Jy6OAATRP4xrh&>v^@n#rn*odP zM(!~M7=)OOE$5`7zGGNtHX5xJiZ>s3yFbE1l(e-t*%ZA?%Wtn%z#=Q?D+P1qh;?`n zy`$cmDu~y4O_&%|ZonFDoc=R*G`J&M=_w*Nje@%}0+Vd8F03M(T`=jeLY$YK6H=%@ zQW1(H88sTr+tb#@5Bf^7bZlguBO6Z&Whl>m*Zc1C*DqHG(6SsS2RRB)?cph|DdE{k z{w)ll{cowT(*f+(wQj#5;PXJoVJ$$8D!}7WQJcGc!TGnnqhuOg^JXAi+G-m*EY~D@U7TQ#0dA>vIid*c{{b60p0G1GhwG-B;Y*O;x z{!gz1wY6Lnsbo#&hX{Lp?Wv9ypp{H~%I6mgz+!O^uu0Z%+2ROGr*0tx;@RyY;uufZ zGC4W{ELDwn9NCm{eR#1s>%ZeQD^2I{i=SNzHG=8r3Y*4|&Nr|E$qX(AJ=52!Sm_JE zp*tKXnw1!DynOp$*A7)Rgx8gOmkr-hBah4&L+$R&*}Ok9Ddh=yV}S)yX;m7lYCA?v z{Lf@^*v%!Q#B4U<@$7O|ZTV`^)VZp_TZzLlF0DG-re!0=PK{!h^s@$qL^~?l4pu{Bl_-CLw768I-YE< zrEUg-06XsdeA2cmHoH{AZ1a5SwRZkhwOB5)%xl~U0C`@%Y`OCDZahM|X`+4-T3!#F zYAv9hVE&A(YbQPSGh>T(*^BHtiovrP);a>N);T&q3~~?eVo4Ll4F21X&ejyqw+4Y* zA>p%A;|MLU$KG$3c=I~yl8N?o)KRD`84&-P+Qoq6*uJg>YLmk*DdM!!=Jxp;+UuoT zM=>sOgKYz>Q@`OP>g!Rax}PW7%$G`j$L-};C+q8?ciX9)&3GfDa(*XJ?C#SB z7L&9NcfCfRB4fW7zw6%@`$v5tzTg4*m;Sfz!0CS9vreA3=cVS%Pm5sG)aRzvg!btc zf$iRwU$1o`^WI%%fLh25;l$JtnOeAFlQOfxZEMX!$yZOn`p0xck1kgw9`dlrSv9fM z1hHoyq2snKSo>~1xKgWpsbPqc>^RS*A624_aRMZ@^eO>z{JTi%Hr^~m>}J)wK;-4| z!WTL~e~wPpG{UDWXf8rVkH=J9AL0pva2VOrw7sJZ;R@kK3x1jOa;fJupHhh>WP#Oo z9*;Vd2!&$2JgmR;kE4Jk=qc`gUR)p6^|sI?@b@PO{3Y(ZS@Ro!VJO=3j$(P~nD|sw<*ZvfAm#`cO+AN5oLC|Fa4a`^PGV_7TBui0s#-3rRLK;cU3>P) zo&Rn)b+F)U*X_sMdc?P9b9m!q3(THxFr|I6j*SICi{D;24rk}pNaX!mph+hZ!Z4V; z{|QsQwd|P4>K#V90XiGjEzW=Oa!WsTmkN3PQKYj_g%jliV%{pl83sv@=Q>Vka;_IJ+_v@Dy*1heZP#R9u|I`mT` zu7K^VHI4(I)f)Q}!G&61DZ@`?>Wkk$lQWUkI2ti`Ej26I+?)nJnE-17V!!Z$&Z{9$ z=LN4BzhzNm@;RH}kTc-Lkz3~b{>>_teCv`(@>ce8xdjM-NBoDG zk~7X;CTg)5Y_ZPN?qZKh*U0r3J89=2DIiR%^!f2Zjf~&LOpkLw!6uIO1_qsdzCUEk z;Q=gYzD9Z&=ibQYO=BlE-tjI%6_^jOiEQjQ!P~A*6no}>wEo+7kpz8p9*yfVB{e$q zr!Q3MP8{cNUbp`rqMcAbrkW`%sIX=w2tb-m{m`MiwPy3LS zGQKsOM7c!;s4`f##9Ws+ulKYp7y!a~U+u(o89BA@^lJ*I860rj1U}#GvTJ?alWS5@ zVCMQ6?iC}v+sQ}1&;WOu;ci<%*&c?dEDE$f_yi*@`_ri5r7kP4%xI+lm4@^jPfeI3 zPBUr5Dm{%t!=0f;w&B|BD*xyxOIOaITUMn;Ar@=lo39XH={tDdVP(N2@T4k}eRb4E zxqwtF>Nx@RGrA=vq~LnDiA1Tcd@9pAa3U8-_A@P0lqo$9>&Cb!+}Hv(Y6kSs5kSEsbEAOqE&lgBu$3>yQf(hLihIcHms)pVr2azSnh+iEA z{<>y+G=mUXU2`tWdXYV><6FF}{=k!>aZaSQ!>#Y1YXHOsAp^{@1p;?8xVcW_4pduj z2{yRZv!_MFyE~P|#pm(u!ovD+s!|JhUZ4duP=>4pcJ^@WAX8U<>#o)Hi>7D_ST8gy zy4CjHtJ>?r71vV@`!OsMhSwWe_-mMR|K=BwDPmukK2;bd|M@VD6xHp1c>z)p9yO8} z@ieAAC0?=mn=+Lg!di_W9J4(zu7}r(s~kK&UG-~zL}Dh49pQ(mPf6JzjYt*xzprj&j@?C>Ov6TM#2Z5%<=H_H!#N+h zVQF3AWDcl4xC>YYwn71Q-Gsf06QGA9TU`_19ZfF(+tVbQZ>aV3ERLnfb3x`CyAkRi3 z3Eb(SS7{}xq<@;7xFREfp3FYCcmcDQBMSlmB||FpV$ZqeQ$2U3s~6)#*H^7u16O!; z{th&<@tAK|`_GH-z(+rh7V0BSZ{dRSNZ)V2yW#rBMF9kum{9*VaLR~Ln@yj8{W#zm zz4Php=4c+f2TW)3&_CIIjJj;`L@+_9qim}Y_3^I~f{n)kpTW{KN2f-ed8%Hy=G66) zzh~!RG_Kd7lrx0O8Du?V;#22&0_jJ(bR?X~7S0m!OUMK5lw8jpnnDB?g`FmHc$)^V z(!;DH)q2mujs0h5Tb9s{YV5n;a`1r_HzI_M9nmcm1t7Geb@|9vX)Is64JdH!_ zW{#g@OFpI4HqOma9B?(Si%d;=b9psSf;bt9B}l)8jn<>cP9wVK_i%*)zFALfUa#vR9VH84*_cD5^gopl+Rb%O$p+N6 z(>gH)suyUes|%7CiF24k8Q!1BE+g0k6~m2C7dCCq!0apNFjtY}JU1W9+Cfh~%l;MU~d4m`Sns(({#Ce9Wd5pJR8g2Hc8dWq|$4 zQmaVu{hm*Q6E!BGv>ZaW?Y|8O=UZD?av*?{0BcOr)}}HR!9kce#<5~L|1Z-1Om-u3 z_us|($ww_aOJ0N2ImEwVjZ2i?_idS&-hx3f#4k>o`&!XCHz4(xfkNGszK^02Oc|XE}O{)4buel zJCz>ghfXJT;+O-rhEJ~6pNRNAp{Z7@B<^%i!P3ME+#Xh~>1l4swVM zs%6`-WG}=sNV^X_uz%1KD*NF|FOdgXk5DoE1#6Cd0>UTiRVgM}n`Sja7SZF1M;_&M z|FS70CDS4yCmX{)(xOij|9~;zBbYI+i6*VlF*<$+g*R^WJnk8v?@~YRvT-~b^cB}I z?xx{ZMGPbEPpVwpxP{(iKPR7T+Fk6c@W9*H#-Guj*Vc(X?C{)A3UMBK4O2&cBX72e zi0#%HkJCn4%TJ2jW;y#fC5+8Lg;H!Hs#iwLLUs8z4VR6oi|tO8Wa}emf|bpz@D9QY z8qd@i9{vzKYe2^%JjOTYou+hsP@kJ5fr7+3T<&r7+Kt03(O*X4rZjvU#huD~eACK7 zE9EN*8yhiJ`6=(f7?~HN#jB4Q_r}!7_@^_KWy6))m1Pip=h45+AUaiOXMu7RSe8Ug zUuYPG;5uOSz1J`?=SNpk!htB{-Df~dM)-F{ae$n&g6Ousz!7?<53S{XmD%yYSci)Yp1C+w8%2I+_tcE>t z0KIV31-;Ew?i%mjpgdw8{>t8il)P;Km6*?_QwKm7@n*UuR!bEJL&BA+K_zA8WmtG) zPKHfw{M*!vSEPi$9B~IXOC>d&oKkkREUNLIm=ku~j`Sjzh(>T_sN{K(!fds1&3iGr8WP0jLt=&9t z6G(4g;ra+&0r@>IBKC^Fb}*Az^dIC9+>qM3NIFL%$33F`7Z)|*y~q-fuC6>0Zv_oq zeKnoNhW%=XC;w{f6PudImG-04&JPSV3(Az;ZGxT9Y5xQaRc0!uF8^0x?O}N;&~1^( z^X=9Ky-guZo%K5-%FcN9N3LjJ!>oGzuchv`d7kNc0oPFTA9(`=!&J`L!vOe4X$b+} zWXZQ~D{VQYrPXSrI0JkAAbC8|E+<9Lrr18Mx@)5xyAU6ZpcwX1wNAEtxKch^t3ue; zfmu+7D6i3WmH@OtM{v6t%ZBAt5k)To>7!a8{%3WoRBoPS6RSF)sjt6&4_`}%@#HFR zxW2)X!%flH@AnRth?0zuLi{_)*1|UUY+(pbjVQb6x4d?kDNMkm{5>lhM@|MPRFwU~ z^{$F9mG*_83gOoR*bli14`#G{*v5@B+c zTYGYM#1DlqW$Kpu>3VP2NK9@d+ZNbx-B4~7i@yZbBEF$n07t3LU9n4vnmMf?Rls^5k3x9gwNehM(B8Ut%$gdjDQL= zLc-#iGKk%7(^~j*Roz_ghgvL6+Yn$S2`LSU@7tM#)(jdT%2cH+AFdzOU8_t-|N|o=)pC zSWC67JV5y^tA+0swG^##FPXo)e;fz?4X8@pQLtl<%;~LwnD{)nF9()i)d0CdTO&YNa|3qq(6O>c8|E16yVVM!8m1IvQ(Bz&#x;Ou{@qAUl-eU&Oo(OwcQX6|<;AbB&neH$ zcyJ_z$C_4FT!$!J4J*w7(lSRA7KF&{nH`hjNLTqH0&A48?whp@%i8JdS5n<7NWkbE z50FnzO6|DzCq`+gs~tODdFODF-LImvZOV9tEQw88RcOf{pAyONpK1jLa%X)M&!;&& zEmovCRd#Xyr0MLgk;bx)E^4`_2vV8QFt+ckJX@zRdd3xoQ?$x#EnBQzQ|X7l$DM?L zc%4Uc=3WEQWRceDL%D%<6UO9B56p%!^Rd=~jbQ)~7h2-0FAu3Du=2A&h$kJ;hA+Q9 zdDV4raAUi^zK*7?()xmswIPS<%Ydq|8G7ecT+LC07H?~-=re5`Ob8N>s3Ao^lCf?( zkF~$vrC{879A@q{v`@CYY72CDaBRqqC%y{M8}-ss)-c8g2)%g!O~3A)Q%Yf``04$!;-@A~B_2seGZY2eMFrqIYE z^T=|FU;b2DLHRnlWjyHuczFsseJlXr0vOft(+34kQ~{|1??Rt=015Gr_qtW<_1~x} zqLWNm)qiJ9vo(wc5#Yp$7r>K*Ui+mP5l{Fi^p~bEA?pi{F_YVeyWN6FTm!Q!geNHc zCzTDT{^jKH&incG69Y{T`SU;=uF`J-P`b5Ydv#8ogUd|XNuWy-5l&RVkFOlV9MYfkuu=}&xsTbdR_|!u z_y=K%t@~e0sOvGHRNGrw{%u|~A>-B4P`C?W_H%U^0&A&>%)=L!O@;Kva2dU!jY;Zs zqJ2iEbxSYT61tc*9yv!5kvF!#vJj{2d)$d0%+_?hyg% zw#m&-(DCQ&?jO%4#8q@0e!0voW^2p<@(b^ceqRn$^Nwa9RG3*QyVuN|f3!^^^{=^C zN&2q?_mwFm6@#CaM*MMsPr`?sm(`_5QofR3QU={E?`A3_SOBXb9=Xn7i@SbhEh(ir$yW=D`Uez0kplkVXN(K^SEH?S_x* z^+4g=WVWDalPSGCJ$ZYZ{Ytg5&kJ;R(2xm>oW2&owaXmEV16M*$$25=pK->e^Y`yF z50vmxM5yi8REob7*`e>j&(X=BX1z|`vKzxkvNAQ2?QOU9S4XRfJ&i+aE49{GE?};S@JAg2RzY5oGnK)oa;Fy6AWfx{y zdh$!uH-wDJxO{zw#A|;UM;f(YcSQ>F!Ljx(p5k6D{TrC7<@deRlFwT5g z-bAobigNv@c>T$NcWg5($sSH)2%E5-ut)0NHrj#`-zd%)ij3sqozV0Cfa6c;*vIBn z1Bzs@)EfvqH5=qt1R5H}?rooP?*BwS8Z$%#<#C-LV(wN-uS2=sCM%D9T7P*mtw8o( z^R=3%XoZ4~%$4aj}j4gJ}5#i`tJw}FE3BXwbovQXTj;5z7rx^|o3Cd#?-{Pngz zr`V~Ge$J*f(#!CT)eff6%797FduMRXy5)VYdIOixew1oMs@+Gu?+ktz1cMvlsS;%x z8Udu~3<70qeO%G~lXJ|o9#*_0%0Bol9vgl#M8%9jKOhzGus03zHPovMSIPf8MmTS8 zp<-|j%(&(VFSplwH(%)L4p?f`f^bhh$M5lsDhyYvCo*+nOic&pq4Du*QjI> zXz5j(^EcPHDrd4ZERG!TFrq0ccNeQ(@2-1R>pT_z$@h6LULq~?RBfL$NY6d7d{b}m zZ7X-FrQT~xZ>b4$U#sqQ&Qp#7xMdY+azw~$?WHUZoDocSrU;dkSW2$T&5vk&Oc;ywmh}&*4mQ z9^Ld;bbpwuRm#{yCJaE8bn2n1Bl`X;Rojlqcg}$)>6fl9T-r0Hj|bcoZHuR>v$BJ1 zvr>J9g|;C-HxFyN_?NhrDCy+uMN@F!zl-pTiz(D_+eFN%<5$eyD&d1#rPhmPs$`Hq z#r5~eHMT%3V(S-Dv(i!VXv0!hi$R*Vc1apW{xK=z10r5oSLWYabn8saBcf$vvZz;J za7DRcCr0YNId}$AUMxi`xT?8j`%asN?##@Y4780n&rM`I${HTO^C3*9kvy`$OLVR8N8 z`_uVQZsxl=-nJ3CZ6I%efweg4be#e8{*P7t0x$&uXT@Ylw+38Zt{Y}@EX z)k_oBozV4skVdE}aen9eao}daOWv_y!TUnGFnZ+5@)#_tS!wZguVvss%=>Lk zq%Pk;q|Q5(U3i+2Y9?HYF-iAAfjj<|>=VaP+qLk8@Q#3M;{68g*Mew}S(_Sv^wbKQ za&h3u@eYD+Pm~&MS(7Q7*cgQVBRxi(VA0hXS?KR!9#Wb`h?M0vWpaXQkz1nl^?vhS znh2`u>mAUXTEX>&y%5H6gHmw$2DLCLFR868yGtU)JB&}!>+}G-nj}X5N80>ihm=-p zN2w`UUV`~3e^yJpPhr?8li3azyFU@)aBX7TYl@cZ3r&8NS{#4 ztN$>1b(Q=9R@lz*D{6z!$tQn&%C7BCbg}_+WRhc0X(f@1M(Q@(>@HU1ur_pVSYTdd8aMVy#Se z!&F7zv)69;W*DJ)njUDeMu&XbB++?9?pmact~rwlVq@Ep745&zh}d!gc(O+J7q*Wd zO5uPgBTks!_34M)8C~0|ICE_3jM>>!DHIJKb-v1yan@bUUTU^6NEp4xc|+VpUytl1 zob=c{lTffJbfd`CUS^Rt*UG-nYZVca#238N_WH4S+qkBy4J1}6*06>qRG82^R}pQ0 zQZgKE>{11KUrAhbe$iOEXR(%>(>t&E7dVa@EiDvfWc)92yz{>UHUAH%GjbR7hWb0Y zV4-+ae~^|JyX4$Q{Rb0q&M;~z?BB$aL%UXgb4UiHkd z(UJLTvGY}TvSZSYBnM{)B@a3Db*YBOEAO@;DmYwKT;1ddoq^LUoXa*jK-j#lX)`=Q zG{n1PN3#sCt-wk%Od2Qn)>l}&FK5iuq7GuNnVII^|y86~%ORcll!;@YlwF%)lg^H_#`7tc9N0-j61fl*S zr14GVY;K0}J#yEdxGgh^Oi&Fu3IgwBk$->)VC(9_^@{tHOGhP6_&=RRBS&mSz!v`P z)cfQGFWNu1#uXtjRh`DZNJU~b&+8bnRGLM-gd$-!@+|0;Xot`^&D>$Hn8KF|a3sSC zJNdtg)SHv#wAulM zufG8ZNEj%7L5(Ee-i3GxtQN9A4D+tI4BURc`v)j`6RE);*2>oVID^IiC#V$Z?H(Lp zLLXJs{}G5N`Pg^M9EQH}oQtO(CCB^m9`{O&M7TWopY>vmX)j1Y4wdVlo3Iuq$3cTH zhPcUuyd3oeL!i#RPyHjDwz;mdI$+__kSVshvguo&2?+jJ7wUauIGOA8e*Avn>SwFdEBuf-S!WL!P@)i_5e4%O|>w2Os-?P ze4k=?^_m&9OQjy7D!BjgpIY;l_h_P^3i2^e*KAYr+1TZHo{;XLpiHybKj;vZNPJKh zCW@XTHw#nXZWOJ$!g3bxZ@UP7~H%dmhX& zphQC~y0Z#$VSS96(CkPu#nQ%wCQb-mAmxvo9i1jl%P zZ_l*CM-b&((rq zq-rN{x#b_?gY|O)F{VmJevLtM<3B~oZwwn7&v3X7?Tr_HZC1e6pO}j&F|idIXWw3I z(c2#_@VYt9}zF%&0#%D8t2H|P|bBYou1{)%<;ND9I* zrkO|&i9c@+-q_0vJi)+Il53}A)T+p!C`qJJk%lArx1Kf!bCqXRm-S&sInF%|@Jbjx zh>l0Z?;7K2+%i#wus4-_vwgoTXNl0z5qF8Khu|m1J5P8L$QuJl+Rqrm1WfBC0*k%e zO$9neQh1?E+3(ur@DOW&3q@?i-D{c`8r8&}xQDsK*X2y3{av@>`H=2tDahHs0`szF zK;4hyuv?Q5?TCK3b)Tq1!12{MJQRq$q=<;3d`1X)$mK_lU1x*lNWovcCIxoG5~2iU z>14a5D`e@{;pMsvl3xQ@{nSdOc0oAgS)PRnw34ekB=K`}1^yNkLS9YiY+da1iO1M6 z=%Z+^|706x8H3v-)a5E{@l$4lPX}zR;L{S236XQ<-w4AC;XH#^ro%3UuI98t-%GUZ z&!qbEUyO4}Sw3t;Qbp|22f}C+!nn25~4N5Da)8KB$gLhuUg=VKYUa`Ds65$iP z%gjwcdYy6nhVwsrC5c$iAAYRClMzK?MH3|xJKQV*hqZq>-2W;+oCLm*jZXfP{7(=s zPZWaZ=%v<2#R;vycQJTdM@k0ty(NOk5E zOL@G*f1b8&UH5givHJv%xkoOZztR3H7){bTJfTd@dOM^bN^TzW2Q}`v;q0mpnF>Qv z)Khddjvd7L;RRkL3@6FNrI8IwmgGH0$g>s{;}TIr8WV!t1e3wQ<8h~utz=e_tY3Ym z_!P1Q@G>lgA3U2p;4b)R_vM_-kNeL!dr{IY2A->ImN_AIX?TR#=gj=b;{+1=G|BX* z4Wxl;LMM%$?@V2E)^VJ2f=So(S!o2d;q>^K3UYQzNC+GlE!v0}PS%~+kpbaNcTjP% ziADz<1bCJR!8|DDd2b0&hxvqlW2fc4WMBUKndAN7AH4HFaN9A1Q!zez&%D5;rnbal z+P+czG}9%I>%GSExaVY1o@KRwZN+vbA&(_|izaT~ZjqZ6ck|IJxIe?ZAyx^vnBbGz zjaT0ob6G*5R!onh?N1Yj&4z8^-G9vl1L6LHax zvzCWyq3aWlnrYB>v0Sty@S;iy{Sqfe!wg~Oq`FFbep4FtnhMLteCk7a@3fBYVvC|x z#Cd|7RJ*xX|Gp_YR;1|^N=QDW^Ltpctxed?2UTIU^!#r`H&C-XxJHX?iI}AL#0`}| zpqIJLfV2p#3}J!F(NcxC*-ptqEzoMaikN%ON13QWw_2-zp6u%w=*TDgI2AE=!t^C( z6r&`A1t+3BwKrU4A`crUe`pSYIsEPON!)D??CDaV=JnB9ANI*0ep%zHbHATIb`E0m z7R+L;dd#Y9WC9LYJX5{mOIycBIpqf!Lk*qUKV4F3^jbM2P@iN?n|meRyTOagi25J0 zR;_4t;Y`bW{(6D<$%2qckubDlb0dE9(08-#aeD3(u@AB$>21?`>=xtqsw1P>OY>b=LZpAWNf#j z11$^O58|VTbO_EBwR!1)P$N{6sL$2xdc;KzQ(Y ze(w23aO^9#!XLdq!V|%}2WPXV`shBF6U$5r5logqj$KgU$&`k<6prLW**Q;gw5j7IndJ`j77j^3OFr+=6){vM81? zRF9<#zvY!sN%Tm(w!9+&ehgGX2Oq+AtWIc^mXhj-h2QiKvj3iFG)H3MUkUd~qMdG0 znZx+~n%-~t-T3kCIS*Dr(fHrcz%TP|KhgOHqt`AT>>hG^q<73dzLFRbLm5iRfeWS& zC>kf-Hzqi9KJa<;Nm9@JTaM>ZTlt3)dFsc8j37Vd(ni?pq9nAhqiVb;CCnU}D%Mt^ z6o-8zzGhrs8B6F9>6gb5r7`oAoAN(NLS_DxscN*^$rEGlYLf>Zzh~#viU~wHVa6_| z6hO)K(3`{LEhuJgn+abhKA;WRJMKK8+>ABNWtLr44ik*y9C(F%mC(%wD{u{c7xZ2& zv+~gcJ_7EWaT}s1szw^x>i6|iA~5$3oc(@H!CEbeFUfz$Q#Qm(wCIVu(8+ccY>@*| z9wvoOFk*0f^%LNn3U_|BU2w`uwtMai$~ zyP^6zR4D-xUdPNOdkvS5jKTz!d+eF97}7aE*GOzG^lK#jeipt4vWBu?5Z7M?T~{^z zMw+cHJ}s1=PIqfeZv|Y^&6zKmA{sBTIdgq>1`uNOH2wQ0v3we`A9HC+LtVxYSk0XsEsrRK{{#D5|3Z^LIgk4xC-G)4SLUYONE+yclQeK<2 zR_ku0k&qXSi*t03ZAy+(dcubrT7mUfj5!pZRW<@c_dSKLYTdg;ws2P zM2%4KQ8$FNrwX$Kk#wr}NpRUZ-{*Yr?m@glO}Ly=eTo?IPZI?xqbvfhc-BT?a50`` zeenGt7lxm2Mb%F_v^*Lm2n1irM4fNdWrjS*On^2=B1#+d##Qkq*XIJuqn}>naR;F$ zEYVo@D=`W+FjI4=S9?F2Yza@$ZGm`Jd@ElcDeZ^!X>7L?bGxK~RZuwl2*M-Hs*m?( z2BUKCkm<{W5H&q}iB#v1>0?C#kYFdRl&y;nmgv1u((lt0}3aw zn6#%QB8uaSRKCSa5L$>~mFzo`m?^LY3iO@BEePw#pjN%rt{{jvu4f;vTd_uGX%dCs zAz5}g7mL^?(mbKc8CphueRU~NY$LI*&^dvK3>Lr|8%<^jqM04bF`!5Y=xKXtBZI$M zU``lTY7Ui@u$@buMiBI)TD2~C4Or9g((BnQsj1$VX8)6h4da@LrCJNNjI^e$mJm6t z2B*6w&h&TqGLlGQMURLe@~LJ@iWkk$U8H)}czkO!-wur*A4hpQA7hh9y4cs#2r%nK z--(dr$D2mW!Xot#yJ+lx_iB_*QtVc_%z02M2nkkb^eTkaI?G#9qMW9m!ZXP2$eJ=7 zF*rXW+z;|gEZ@AKcbxbv2bTy@5&5N34nn8mGWP0CZ-Wv!%GlQE@Q00yxcVrjlQ5z8 zSd?ljxZaTuap!;dTz@!&%Fpo{QD^(Gu5ptX5HP%OoYk1*)AM`Sq5w-=k2XnRwyges z&-{>I6lZk8Hla}kOag7x%&^i?sZ(KEY?N4^nHCOk@Ts`baPN0SdzqYkthM#o2=1tK zg+Bt;Z-u_)pqp)r*#8t+LDi^WzX<+t0@N3*;9>@=y#-=`eT+2qG%{`_!j=$L7!~2vE=`Xewkvz0o`@HSb;bh4=Lzru&af3 z{CyAwWHDUnq^*PNW$8j(Cgdr;l7*^|2ZWhEyHV7TrP&kZHVkkfx(mKP-pc6oeA$oM zBiBG&3FI@HwKqp8V6Uj+<`0wMUpw1Kq*9b5rgToEGQ;LuQNuU;2Yu;x5EKJr&i1Ln zW~pa+%_47T#`hjN3=^@R&*Ij@wtxg1u51k=Z&o%VE@kM4;+c5bXpSkJ8rj<;&vqfU z5joTP3#(i~10pb8IpIJB^k>?Bk(uO6YSV^Yue%)Pm+*=NcJ#?OuA@1QA@Wo{8RV{- zoBLm;OMI$HR0(VpzKn5sL3|9#${jkq;#L+5M=$btrU~()&@FP{-nt zol^C~Z77*{#w0x55*PBcCuBwxC~Ok#RN}fr;#7Q60HesYdn|Tp%V1DGHh<)EIYpzR zYDmK=MGySW^bI+}TRA-=AC&KvpZ=V)`_IcEx_Y3vu6{TFrEq`A?&1XBr}HoJBEO^$ zsZSRR?%d~9G&DYDycxxnO-`MNbD_cu2h`z^fB3=C>0g<95`DTMsp?=Bla7`$8n7wS zKe7JK;k!;<%{iaXu~Q-uj5R#81zT`G~b0u*ES4s)8DA8*AJO4_;Maa<0uRrA4=n`UgY+Mh1N%j z9OGiAeXLEri~bPSTU}*)pMm?%#=}RoOGLEzJ}FT|NSvhDD4kG{15tOh38%7<<-)6; zF)`_#^EKP_F}enxgpN56>JvtQCT#^53~1A=h=0$ygt$#e{hezL4~u%VWwPFuu5J{o z(7zs(stT2>GA90JaqmIvBK9Q_ASiMC8gv>rI(Z^}6DH-;ll$5wu`!f0wA1SUF!t6_ zQATasHznQOAvG!j0@4ivN+Sv=DXp|44MT^NG$S%}DIx+&*U+6xH%Lh5(BB^K`(4lX z{_(Bv`NyR=x~`dP&%X9~oWJ8Z{g>vFIjiDKcHWFtdM5~2rg%jvfZGhv_hl=vA!T{e&!ZWQ2jQuXHwrVSjqzqM+O=jUx zJ`t3ERM_s|ZI4S3QuJQ%Ll3J3n^nI}$W-9KZBLGzP)H-?`4?+SV#Qi@4p zAT|QRyk1Ry?W6DE$kJc?j{kN zgh4NiQty8O+O4wv-)MmHTmCnmLbpL-a`>|FKZex*MScZTKCmc$s%KC-(`(-~28?{l{ynYf4Q+vzoWJzHYCZ+pRL(ed{ipu;hQd%$EuSigP`;z#B{A zd{N7TR zo&}m@uP-Y6TgC|xT~B5`%%rZ4MuTlmfdoAb#FI2ViMu!vr)cBb+|8G7jpb869&$YY zb++HhrgW<}>^~k?nWU(u>+^g5&(3rTfyyEWp*aBa1b7_rxYy9? zED+xs7v$R13S$$-vz5a4q&_!;N27?-%!KHKIW|}WM$c`4*7#gspV}jXd2XthqIRBvH7|%yhRf5>i1k&QSB;^G^qal{dM`L8>fjh z+V%x5@9!3{p_boVpEkLJd-x)bRc1+By}941Zku-LDD&o$*WUm*V>PWqX`bU>VfkTQ z5nYV}kEz4KO1CT1&4;f`dM|oRCM}>opwPDnNvBw~>+H7SN-1psI%Lb-=9h1*Nw+ia zY>X8rI#%?H{_JG+3AuCMCR`_E>c<;fCa3B}y?lJ`*Q1(ZBq#f9!DeWqXMd)g97G>T zc4VjS^L`%FKxsr4S&8u9E3MAit{l~}a3^T;dlEzO*dq=$F$o%$UxC`mv5Zgmv`bhw z=XFcD7Gt1QN3XTL{GCC4t>ULZV6CcoyM|i_r}o;!i=o^hbUZ>BS#I9v@*#`6u+8+d z0hsx?(4Ws=NX zKO1&&5reMlq>I?=sde@|Q3qf1WbL(qjO_$6W6uq*GsGWOV>`h}(_UE&53 z>2AQ933}xUE@2u-oP{xPo+W6htg2lY{Zd}N%{iq*Gfj}AdLHPg z!AM183Vc-52vR6R;_V;9o9nCA0?5oYI9mP$&aLp`hsYOY<_df1Z*1Iv)2i1cE*hA* zQqZ1Zg=|JSf8Xapkq`~?J@{Eym_w*{54JU@0R)Ct$94E>w zvSlAgfu5Bd&ME%pPM887qav<~=OBZyO^Az{`i`zM9vLe$uCzZW!1IF|>&(!WEpuFp z(#nx17B+;K4ceKqqV8K0=HvU-%co#3qC0r+(Y`l5O_1_MZ~VI|!y;?2SQ1=QbTUtI zN%LY7_|-pzp%}PleX^hq-`i;|L0~o2J)`9wHOJJf#`~YZ=)Fns^4Yq2&Jb+KV5DjYZ$xfb zOi1AXl#usF&1{3ZKPZRZp?Ny>Ej1I)f|E@qcPUs8=^-I627RdMIUsT7XNU=Ol#3A) z_5dH5#pyh(3A9>#+<`v?FFTmj3pD8zhS*){ALJ=n=TQV=SM?obrLohG>@N%ad4I38 z42Yi-pr=HOcyJJL@wIABGNe5rN^H)vmA`g9M^L?T^Ya(}ciOndzWePbK#iOP7F?#^ z#hldjK<7CDH#&U4G~!?(QCs#qT-dhb+w~&Y0(+8sr4-09k1(|LyKiYVHuJRPcvF&7)>9U^J~}$~-x#`{(30W$ zl|?P}k4UI&(4(?PZ~M+MtP+Hht%40KMC}LfN7bnqC+tMY|U zY$bppI%{F5J6FRzZ6iAus>3%SAdk#ieX!J3B&s?Z&kj+C7D4->0}|LTA7N$(ciw+O zmT^BQ_z=xHdS>BUtbwNvJ{G|^muL{-M~DQVy^WwpM=Z*} zLUa!mF%+mm*$J&#ABCLjKA)iTIOygL2L+c8nw-ZE_x3m%R_)AO!F`7(XETUkQ90eG zT14~*^Sx{U-_BN_Eb_9Fq>CNg;Pg~8e~F1)Eg?>%pAB`|oh%ODKXBVE)N&kIFiR!x z4#Iu4jY^x?LP!mHku9Iq_8=|(wR{jJ_11C|Q_3J#_~(UPOgv_C8#NuM4*6cx1r3EW zuCY$3-SS9(Id>!8lL>IcEdN=EvxxmOfHyMx{w*80Ai8Brzhdz`0+WT>aY}t^&`vtS z_RI6H$SrnU?jn!fxfU5hvc1%nT+o<(E-V4gBv?n5-7XALgjDpzMXMEL-BIP(5bVC8 zGU*^vf6%}o?3FN_LsF82lhRlR=_)3X(Iw~zi9d+4wyG|qQZanRfJ=aMAR{F2wbb!P z_4_4JvS%|aa`6!_lJg>{XbECRkiy9J#$5`m5Mt0$RecaBIK#%#gWV(6gNH0@<->m3 zu!`A(>vLx!6?xDLvJ^z{DDeSQ1Ywzq`g~UIF6SbXbv0KP03h7tkHj)9@8eqhCmo9W$33E*iEzn zznLEfPXl16ur#L=1b=H;3bX*Wfv280{Z3?f(;M04n9MxRZI+7ZVWD`nBN^Ur5&r4I7$&(-NyUNgRb)?;brqV|S*MV);2(TJpVv zQDMX4c{pkOz_0AqJgPqe$YJp8VExyGQ=zBeDjVdZK;m35t*@A{n|~w24GbEXlrmCb zCYaus_-?tr4v2ZfKA}ZC^SC#NL*hN&O~l1!^P@)j0IQl0ttIm1`HuM(z${5*%@7*S zKwv{m{*ysp-Z0-Oi3XRbsL*LIGb~23q|I{n7p~ynEhSio2q<_< z?akoFuYMD9C#*U`j4FrujFcH}8-oY;L$Vb=TtlPSxS5#ff%mxQ_i))Z3JrN;vYiWd z7s&-vBI@dO5G$IK981t0PSw~-6OY-4(1fk!$k=O4fp#I*lLeQLk-VhK4IzQgzi00+@FaT|yq=^{L&rC}R$_=JglH8l2pUVrvul*u|=SE#&sN zGghTX3SV~)Wh$8RaKEnJ+&e888`6oNMV}&!w!|oO3y|$i|5Z=2I%O6eRsG8}-gl`t zXfIXdeEq3OdJRrA9BGl0hkEEPzI0u^97{yVqA0r^s&ug^e2>1A0Q;0T1FA=_X3@kd z%*A&Yl`!au-Q*e`L`lNSFnnt69xI~<73||5);iadC8KJOhRclHx)pj^=*Z<1xsNgR zEQtf@x*Gdtemr<7L@)B7)og3nzao6Zwj7igW771^`MawD51z9Ldg7NjWoc{R`cVc4 zuWFtnDx-%U9F!}6Vqlasl>|V;Z>e`G?2|fCE-fE#)CC$u99FC+iC6^R6C;UECUIiq zpg;LiE&QZ<{r5U8tf(;K;vGa)M(sH<*s05Af_2rk=x_6#;C~;;cp8Qu?pb4w6%w}> z`7)*2*mE&-v5I_^U^T7b6?1Qz)0tkWj=+RL%NFi2ZcCE&=LJ<@h2?q@dGFJI#l zyAOwtWJ-3ib`3)0j>H7&_Y_BVx6K7c+0E>W{wGZc&iZ@yt+)2ip~>%g!K>m>Bs2$F z*?fSH$i*1mKX98_7RacqQ!-R=$+lF~^kLD*uiEBwbb~D4Ek$|`VrtGy z4!)GPsBZO{+(ce}X{D|eF<6a?8kUN(YpWj)Ib!j-zUBnkpH&Vj{P;=v$^6UYTXgch zN;-M5pwmmT|0N+mZH$JIN?<%P3nyP{^JC>grO-%h3)bebb*c$%N>({pL~V-WUzj&|I=J?G059p@v& z*&aZ0M$7#X56W8I!nT#|`F%XXt?R8UhBvyq)cP=3sxlKI-p0Zmz3PxeU=s%RhiRG0 zbVxVEr82PEnt`iuog6m!l6@ZjEN8pna6l@UEiV$i(PCnU6Z^YXlaz}J;SJGMU&dXw z_fW0~q)d*cD%XHUT~K{S?E3Y*M)by8MUWnp#i=~Wt_Ll;){}M9#M{W=IW6mzVR!ZX z^O5z`E7oL(qwGUkX@E)V2e4rzmhx!{z+5S!41nptwJadL*+ zO_AMgXc#oDUL(h45i4wd?VCpqz5n5ils-(W^Y1BY`!rx61)GRmNZbV@@b{IQ)WVK5 z9~rMveSod5m~NBuFYLg%Lm?{tMu)6uc6wSu{0tHNK6xDvVTKUT-y;QYlku>?$*l2cmMCYu$5C~ujV^M2>cuysFJm}^<5A6a;l6A;>91M_XC zMMa*L(xmhV)%{bKo;$)XU@)sb{}D(c!FTVY2c04)B!kn7v3NEt40oFTo3Q%Cb4y z1P@;%Q-^(KbOx`wJzq8ke>z5g)Nj?3vz~h$rw#^)LPE# z_`miJlHM=I)Wp4OU6(srtp1w}t89^#TNv7v;6VLfnd{yECLFeiee>5BTM{Nw;sOAv zEy@SK`0@JIQ--n{=Zts1zdtiD`Sm^uq`_7cmh9XMwqxC!KE&ub^y_K;M#>^N0U{C{ zrk(1({`zJn=U?TWxGO}{e^Z3ngUKu6zA@4c*hT6smA^J#zs%;|07avM#=v-(R>0Jl ze>Z&)8g*`Bx=%AnbzdO#O`n;I>BBmf_#K86S*2m?!!0f@}WLNM7>Zk+6EfPBPd z06Pad(}`XDnMj*GVD^53m@gZLF3-lRlj&&y*wu|W@$V1?wn;DS0>tYT+FZX5@sxF# z5d1se1cT2P0$}sIrE1;z=9jPFfc_hVUp%?Pc2{pbw|s zjhon_u}nu$96z2-$-h1@1?X1ISM(9m3levFf3Q4VZEV+JxwoRNo+dx|===}AzX02KGQ>}ZHSBH=B#^lI`+=vjfKfzN zfP>Tz{f&SdYsX9=Nv#ec<^U~_?U*044OHPvdjeDgxIv-S*TA0`Ie*^_Bm?VW0yPjK z!kp=UZg1yVG{O7HB`AhjVgxv|x8H*>O{!uQHc=t&1K!AZv|Ar7A!-&3M*8 zG}5aK{8gxyLt%z{IVhH=X!(ul8BK6%%Nw?KNSP1p7E*G-U0ZJ7fiA|LGl z6ZJbkDwz|W_pCeWWP?qBT%Hs!ZCn=}oHMKF@mb@R-SSFpAV5~V9gygh1>9Md??@>t z08O(SxObTkA{BBUC-Njqmcolhp$n$1QkqN*O&WtUHE+LK_onRMnyYoMUM*~3nIQn-jlJX+NlNeJgjavt0!tzMPjbkvX=OcxUn2?ONsW5a@q8Mod^ zv?TWE(W938FnixiiC!$vIq=0xmwfkH?F$;p6)D&$0CLU=pm`^n1F>5h045ynxs1DN zvA59jyVOJqO^c?AcJXy1Z@`!RR^WG#=F{R#EEuYZEdv;5y?0u0wLa|9&KM?JG-GIg zFrqFHdcmOyX0F_)~6}v010znE9@L#V*~*@<{q= zGTBJ))gaGJB&S6@E;`AmM=05`HopgZkhAkJ(+8*@#-7fN*`dH0aL1?bKv$(BmgNmP zWi5tPMslp*;jgoZ23{4uMjqKBxq;*f8Uk&b|4Z(LC~-;*L-==(WTG4@hgB9&>CAj7 zLc#&m=TI!S!tJFgTLMD4Kn7lb&WTKElGLUc=j3u{oY^0i9Dh)=uQ4oNpoO&?s%fGT zsxyws3yN>bhFWP`EIm(Z4-_-hXlyEp4;vH?sN}ld_K(3YK^$8DMbk*bwh>X@!x77)B*L4K! z(uzt%`0&X^#NT}V@w|viWP#4uMFDcd2D@}!KVr~)J(Bm>jy~;qA*MIjs2qXeDtozI zE^E1QB|%-$@&br@p(^Ap*iCkyz*n}6y^S+%Sa4*2ltM?q%O7Omg{gP|1uT1Dk&cBM zn+0kI(Sizz?4UM)vBlN{fI{JGBF~M{-dT=;og2V1GN<5DI4?!q0792=#|Wm`xwM<0 zEls8dV>F)&6_;GWX2D{KuadcZL;#TUXUId)N9h5a`5t@8aQs0!w`--dw6?~y{x0h+ zj|$sC(hbdUdC9>~62c+rcN}xQqDGeX-A9t|Nt#KDq{w)lAIi36mcvVZhf)ru(l1ZN z6HM{3H+u97pqzbBuMeneQkIf6nK18&CTQvKMc+w09=@|~lhChuNVQV6c`*SNRS$EM z?%m6pCgqO=Wl`2wW4ORe+OyFl3`Jo#rNUvz3fGJ;e`ZK8Mh#@4gG>*Mq2Ym(=^4T zImee1XJ~nOh-5Ff&lPvSSFpc#Og?jNXv}Y*%*aBB{@1d)Zo`XT?s6 zAlf`!))c5K>Tj7kum(CHM7yC(Cy&^mov^aE|0?&+hMIk{4Ac!ASE~@RnMh2;?(HD2tol9 z!iNXwW%IHpr1emL^?mF*Xo8Skq^{eM0is{InGU(m}) zR{mVL^+Sn<^^+8DUM{ES(`%_i&XNx!c=A#t%)p%l*6 z&*p#e?$s4{pWP()<*diNOvy2tqzjh9AxY^v^EpU8l6TR1R@ESFk&rKk^^{s0+oP43 z(n}L|38J}h6f)rWJv4%n8j?*wEAMTSi+5Ox@}X|F^J(!B{`_h4D#!ZQ<73iFN8>fZ z{T_YOkr^+q#7> zTmv?4Z=IB40fbgw{5aE&YfSm-Zf41VDWLT2=i#C~SK7ZyRlPvBDQGF^h8ee+ZxaMw z(2w+Y7x=2SE+cyJ(~L*rL~M25W8zvt52Ct>l9+IRscBQQUE12etaUGx?uv4k=T!)b z*MS=9R%^G*S1)=<)+go8rh5*Aplh5g9OojZ8Lu^_P+ zTf z8yvlFX7r3NPZKZNm^i|??Y4aO%5-1QH*m+AjvKLd)KNAPMT$hATGal67AD)Kx2!^h zEgPB;XO^UqTqs0%-)-yNKiX^3^`x6irSjI%P$Qd59pB0Eu zNB9qi5z&uTE80hX_`J_*6u;kYOhcO!qE{Xq#9_6L+(I6Cs6Cf8^p>CO<&Kr^RGt@p zQ7|K44&~%SYNX=r$Wo|;>LLWA^+wpd;Gh#dkCY+K5K|<~Eo-|+BhBd_qRJ>~oJ&q_ zaCsoE2lK+KTHaCntN(6#p4;fWf?AM~f1kr-!T<_H^r_WUGgceUF1iuo8+v{7wy9qH zV~myz-}fo$%H@#)i=K_Iq@5`|^%~4>Z_EXjf4bKO|M|egD-dc?%YtLSq+ygdBY4hs zKewKD!JyVV{DAK31uC<+K2M!)hDY54v6_%_jTk-&VMv1R#yg&=)2L33LazV`oyxDf zCuc;D$}Ej}--x|{hs^;Ys>G|dWFy~gT?m*yJ$jFnfgwKkbMbGCj7{f3x4o&U-`Hf^ zHx*AqZVxw#m^3Q)dI&KDdUTI<@)ocyV(z}(`re7l9Vw%;!mt|&+MGI@Md9`7b^A@L zk2jxxCDsX)si3+=$4Ed(4Bv)#@Z2q^8bZ;tSg!O7GrH>@HqZAzelFW3tikUZeI8ZUCPc$+ zRBM5XxiUV$h`{D-;i+tDW9g{`Zhm39teo4j=c3Qzj@Q{7iH7>b-A7bpD@tgq=CSyUs8B5q2yGk>rs8E zU9FP+$jINj?jy(Q-E*9&;;%-2X!mJ(UL+K=Vx9CJJ1gzLYm~9-SAL(VcB3V^!uK{2m)a- z5k`?cK8Y5=XM-XYgA+rBx3kzhW?Zx5<sMJP0yMsXRs%+%@2XHOtK)pd*hh!eV@)ue0qQfwf>5D=+^D8n9?*^pBcQ6y2C=b zZL3s!kf2`c)ySLRNhViO?4di7oa(R?klakF`?U$cda=en% z&$Fwu$7&8j78#9L;2D8rHYCNtm+h?Titzp0e!Yn>x2zy`*T;fM)TUvR^p(A!|HR{< z^XiKIBSOwYti)M)V!6brAW}C)P0c@-E4y7!UJY_r?8QCK>fQQ7EyJh*o_Q-chw>vu z%Wem*r$}gRG&zSkC_}zj{0WOES20O5EzorhjD~A6-euHNv4O0Kl;hiv@%D%XF}(4g zg+6)cUEmfC;1(j!)7%d_;UNhcXS|KN8Qnar=0Wpf?0$UZ&Q>}@h z&m&`OZ;xprttWMUVi_2*6OZ7w?zW*^HEjdgRd_q4%8$ZGgGFouLZSP)kqq&#uHJcd zW_Tt&bo3e^cvIX%6Ly-*cU!uwK2V0Q9!=TQMc;Jy;9aMP#uoSJ^F%PMHdK1a`{sll zbiT&8Y<5nPeompY=F32s_oXSiBOw-eridRzAzygR#rY8LoE4P@-=NY9Yz&$KJ`6IPpg7&Nue~oo*a|1imFFJ zzM&q~DfqMV?Wh0ZMA!t>LEni^Lwj${SU=rm-YUE&FbO1rouqN7J)C5+KK$a@NAZzH zn}f_+gr>~<1bUTHM{4UxRN1p2|DZQ3T2{|(cs$kl(`)*U$tx6~6z!1r$1!>HKB zI$Rm=_FxiAWXB>Fm+TW#h9%B1r&LY-(tV4e+YRzwVR{pL!Pa=6wwkBp32A~@ua{)g zHE15<^}Kkb=v7dmN&&hlKDdy~t(Yui-CjRlby|BHsk_87LUR2_a&5Tw~zcAZT z-!ATJJeN)5$nxud7~6L58T?=`p&?bSmxqip@|-2q^RTp@4$oJo$xwArbx+4V;@-~4 zFSC(=Q)rHtDqD!u@2?ejfwF`1L@)xmXR|8oZhF78watiwIIw+>0wfH%A z1d;BH=HKDE=N#!-i|xwcFgI^)T3XRfr$)v_pZx0?t4} z4A<(&so8hqq7|0xWPYn*7}QbB6g`r)HN>6(;S%|H?`eXxYOr<8LrzgHS_V~QnKWrj zuo*QtKl*6WV>ty5W+AjSuEsHTIGXMLzTz^Jl8$c z(EdVL<%&!f-cqO8Tq^1?{Xn@e0x2))ZMsxg__W-Emo@MEvTGYSMhc`>YT^#=V@q}S z&@3*J4SIPXSFX-9>7lPDlj4k*)_2?ekeJ%{wl17KS{v+Y7jaLGdH-MreF(?iILNeZ zi+72TdxvWsAQU4rV}VbEfA86qX4`1Ikr9%kzk#`?CAP_|yte-ky0QD=x$&~xwXXX{ z6~TOFyh_{TVG`AZxJjf?|CMsiF;=}pUX*}+nBU;bx#7dx$yat0DD~>@xj>&4s`2WU z`x}I))z!4qeWBI80iX%-I@a8DkC0q6zpIp9V!QVCWW^oao8MmGd9hojJ~L~^YvR=s z2X*C=_V=l!!aa>tk`x=RTw^%#+Sw)8aV|e?mi4dBY!gcrPawV2Ow~fc@0zIj#1$$@ zg18Km9qu=|5ih9+#gOJFSaLJSTbU`nCOn?T^i%2*M6#fI$n#8)`UNK;QRE^H(KgI7oMd6RjpiX;Po_b&#*m#2wsq7&1~EdHtv-ImdCYV2 z*0o!lTc5sIa)wWJ=U%!BW?=OB!nN!CET!$t!FX$Pwa*gOF%`_Pqm>=&U3e|4|zAKcS>waQ2c`s|F zT|7unXIVOyF?PObdU}2#RkJ9&vyT_p z(t0RJPh-my)!^Ufwjei{u((3R%Blm}4GhQ`|h;X`wPBY>i%D*h9sHiK*j;M*(vg_EavXI?0+C;#MW|QJ8I*W zaYwTzm0oU7y!LTrB8vIO?ausVOsz+v=6PVaw&4nsr)PCc0=)sEZvQU?QjJO{@wzI4 ze84YpRLO14s>vb2iZ662(|!ML&_V5$BljCtuax_CEhX4iAqZtFd*;6-XHlL{-3b@zA`ITP5=RGKAz3F#;Zy$(x$LZ3k6coXB zXqQg{ZT;snA6-GKb`Z96c05zJn!=^F&USr2+$Gg2UmLF6gSKI0&|wSoDZhO}*89e& zKnZ)xzxqlU#xW_wJ6T~oD#{?;`Sqe@-mb|*g+`AVCMG1IPkcrVBG0Ok3q++H}>0%bO{9A>*?AXJ?h!vaI_nK39f!(tyi}NO=5+RM$;wME8ODAp$v?bk4PC7 z)Fef7zyFNWj3^1T(#DGH?P6le8%hCPu1P_bPM#Mk_I70xU&=sl;}$obCj8w;RC}!g z^=-Z-dhRLhOeEKOWW@%z zWhyQ5QVTPPw0?b$x$~b(s2^p6kt6pCd48RK)VF=KsyFxUIiI=$L`wE`kYWNo10xgL zqZ|xD&eljGW}yI~)>Jbi|BlW$a+U8N6plv%Gv&7zEw8#eHlS7)7zMt2*`g& zZGL90xhv(xFd$#tTrJ4(keMb@FSvy?h$|iU<}mXnBv)1C*BoU?g}1CreZ4N}hSM(DqmG5BduP%Jwj3()`b|NnH*|5rzv zYi$=a3{8eS{xe1NGi{B(ZQ+RA-Mh-x&8m;i5L7%=tNB|lZIXK&fS<>GHT!P-2cTfl zW0a8lyAN;8C0p*ita4%*vFJ&<^V4ql_C0=n(!uUr&>0SypXrR1J8bgBj=qrA#<`J@ z%@h)LS!ia2cYq63mMwN;qoK(u?@}4QBT$rt?(Jr{_1xK)qQS;GM~7-9G12{w?ES!@ zi8*dK)eEW~+A7b@8(yd!V_-xf5 z4pab-0IoHy6iCeY1p3`ZEt=FLZs^80@IuJ>a@Ft@d`I64JK%Q7!P+wl0&~B3Gbp-v z8@!Lp!C;>7`94ANIKXQDW(CQcdvyiPb&WtyMdyG_0{oe^kHurg0_2S7sId*^0`7dw zefFIJm}xM(6+)#|7SE|V6^O@b2bz?=p4Xt&X0$uk@D&VYa?MniFIKp74q5|SAmyM8 zM9mj;Nb3g|$pNN5Ir27y|Fyf44BOEg&^oQLr@=qW9=}_+vHL{c?O6`%%Q&uVW zl5H^7N7Vbs?gI2ml~`SGfCft3OJduXW?|-kmhT4?$)8}>9DJ2OD9R;-7^{|;pbgRZml zt&D$5tWja7%l%gy=zH1Qs7CaJ5k{5y00kXy@dT_RqH(Z9oX8UbS9L&G$KweBG><+B z97c}7aH7C43Fxg>Sqd9!aNon(>xF$@bgk5{- zXn7iJp+9MbjUyu_ZB^=GH2V(WLUaTKd4f2RkjfjtD}M#3wEM4T2DjRi_CP3t8QSBr zhgS#Cfwwy5H61|0WK|$QPs~$xLa*Wk1wk8uZqP4aNeV+N7kuy+Xh%RFG1f6hIP4S)Wp*Re`KsUo2osj3*(U@>^wF^Vfx0*l`_GpidW6f$xi&+RXMgPH@J+Mwe0E;aC zP<4AA5z``bU9|*QVq3taUyh!8fT{rlV{TdFb1zKVX7-=6hxY^>H3Pp(>kjw^mbFDs zegvPlRNsgFKG!;WgAZw6f!*b)XKeXs&0E`-_W8*vwU%)MAdROn8mrBDgxoq_q!C2k zY@sWxivYD&U`^mcMIF=v1qDwGqSkl)T|f57S~SDxVUiI7P3YYAK~oRiU=i>{PoW3g z^g#sE1D2Zko}f)c#81E+pJ4XwL5fDWg#x*)O28F2_+Sc5{LfY`?$DgiX|Am-?rQTOq>3|7 ztcNt5OYrZqI++onm<2MV(v=$A!L}wq^eA%&$@dA}2{E+MHV#zSm)}^J%6z-6%2~H4 zD@=vo=BW@Bs+Pp_6$4vKomW17~kSN_2f2nzna;L5Zc8NWcg>g1K6-wIM;SW}O z8FU*R>)sh!ffw%a7>L5;;SGs&JIb*I^o4jmEADWvb4sI%sV#+;My)I8hM=g?tDG?h! z>2wp{dW(-$Ar3L&lWBupm&5Ru|6{y!<8*G|MUr7X%31UmBL8fd8!O*(5R1+Ti_YVr zk|&=Vk)g}cv4GQCe`;WJDxw2eV(B(;ll;zmoXEcJ1k%JT7^cv|i_J4}mgp;PJ}ISj zYuYew9cKB3W6UPF#DWXfrOQMdGC?Gz&Z4u0ZKja$0?d~)?8vn8Y_Ps#__@{uLT+%< z^+5%~%}2Eil}dU<>gUo<+8%BlocFL7Um|cPFHx%;3}<@C%r9RX&kspPtA^sWjQNpA z$a%YuuKnSU;O{KGIG%8O1uQDd5W9NGk9E|vs zyTejV+zHf`C;FHlq6dQL-3s;j1P##%D{oc1tB8Nf@X-3Ow5}Bf+rfHI9!hErBHWqz z!1gAF^A-d`O#$N+>$P5~QCLSH_RO*%R_qfMh9!(3uq$&rxU7k>bsUX0fgL1ePlkTy zkO`Cd7Cw2sgg!=}lUan~V}2F!5oRrcgVYMAG@?Z*gTr% zRKOTHofbZnEjep z0MnMs_C~~f$YO;8`i*Ob?@n1uHA@21Zw8?>U1fi$Vm( zmhk5&9~@?zQ1ZLR6BG}L4l;z2N$`&+7qH$4d8)uY0^vQS62_r{J}1x}jpyEu3e>iVu+Q#;VC<%zL}!I&QhpAuy$8 zPSM&al`P6a4@!8qqcI#Byg z7TWb^7Cml=x%0ggHT~A!DR>x?R)|6F@L4Xu4)Tu~`x3 z&R#sKGsAh1_sBxcF+&wb9*To>7HXM#d@P+<=Kvv-`;3)*hIq&w19t5QMRw;NQgjNY z#Zv(`$+oQMdT@?i)Q2RIXtBI1W^4inF^bp;FrG*OlkI-HV0olTbe!9(RBMg^y|xI5 zkC!0xX%8Qz#r`QU3=@u;hJ=={be_GoDg2`-@t>;XS8Dwosc2)NzsMFW-!rDx)Lx@+ z0|z9C3MZD;Tlry4TOJXyp0zp4Su0%pbgpUn`>P!E^6~q+`qWHhMET(i8Fq$XS%dl| zV)K!yt-B77uV_07A;E=HTEn6bXK8g-mrJv}P+9up2a8@glp*D<`!x_zU#{Uys&GK6 zhRpw;fBe`~%My57l(5qtFX~{NER`iiuUhxj3f2X`YDKW7WM(J1++|`@VFvMuDArry zgnJJf!9#%GcP%JR;2;{#u=E`q$immE*+lGgbY7!fm1RjJs}ZB)Wu3aenWLLcIhKO- z+QTpQ$eLzjii}()ZdrHRVvfddH}X^O=ofyEd>_bQy4e&R9j(E^Xci_A0+G4(mXRs> zBQ}+;d2nk$wdBW7YVQ3mI#Py$|un4iTotp!Z>Z=ckv&yO# zj6(8}HNh7brzIfb%sS0xh>DqLU5}F^3v z+Nlk)CpRs;{-tTAJow&r-!(JtKg%e``vcu$Hf!8qWFRHwLkJHqfv4NgvT73oTh4j?>q#=l%&9rnu>;s{_# zCDfio#W{Y5FJs_OVyPocY1`kKtB-s`uFx6*x(Z^hZc`lvy!)EV6rU4_>)0MNqU|{J zzdA?PtxEG%|1H{6YJpY|7sDbY+T{`HdIk=7ifpY5#v*edU6_7{x64k)(pGP9-Q#p%_d&$ z={3T&gTWn?voAr3ro`$GT)qm=)if@Q*`-tPcv7OQHvYIv{75q@w6f0Q^K%fHr|ji+ z)8=QtQKo5!YS=fK?#zQ)w^ly%OVRGuLMNz185#Ql4h7q&qP5$i-v<$vW?LZpl4Q_s z2)%fzBS4jm+0aTYZCcV%asD_JJiF?-m9J(_-RU3BJ69f|^wahJ|ms<4*$EE^u+} zF=P6pXLE!7Xd0dG5aN9v_x$UNNi@tVTXqeALA>^5@X#iyV2pIF0n-STU{o<;ihmJ4 zI}9_!9>a0BFJZvs%;6BClN5@MqwJ$3S3Nn86QX07{1Pt7QUn*8pUWVm63`!qrxI~r5 zZ_ci-Jw1!5YlHeNhSCK|UGkKonP8nQ5NrIEeFb|XbRiBa0NHwQf=(<(`x6#aMYbzw z_E^r9QyT*zK56ka2TjfY6voI#FYxDt4fQeC!nmLK3VE9aPSw-m-OfwJfU@e*`xpxhIt7I$B z+1}NQcJ4FY2Jy-Gx)aP`#JNRsA7GnpGbG;;1_@Wt9TD+&3DI}-;W|n^=>lF5hI3*u zKG#}c-4AZ|0H}3HW8fq{&SN(5I`C`@(uq_IY^t`f!L-QqUzvG3NFvPA$F;!Qo9vQG zPq(CSqbS~n)~Co$3CQHWhZ_NHBB-fv3?u0OVeGBLqWZ$NQIYQM7J>QMyy5OF_Cp zT2e`Am5>H$5HJvj1}Pc3C8WD!XeDHTvo`+T?|ZLvoj=ZhT#C-#d)8j-dG6OxfooRl2Qm?wp$d+gNodF$ZC%NVAVVya2FCya4Vy zY+BNH8}Tg;qD2ef0<|0H@$XJuV7D0r-ti3XQ`6qCX&Fg&M6qeW2)lmvjge4YTyhm> zT9R|9;p}P54-N|>;WgMck^Y)$e#5t@({OKpGwH}RzO5?qI8(q+kydV!^@6{4Ata~~ z-@)MNyU?y0>(zuq#dMBLr=KcH*J7cp!w4>CezTdjr9ivzm0b+K z>ZH9r>Dp$JTWi-a1aZ(oWp_An1sXaw5rMO)5LI-M(6hMxzAour4-&Uc^r>oRdRs3N zfx5VNbW&MwNqzpl-KasYJH8By_X}JG^H-sS0V&iEmLG=n0p`+&0{FouwizV0hL-)&Ae=0vNh0KK1z{UL z8ZFH!n@fWX)=8~Z-DBaso24HVM{dgKG#Y)D^k^m@Np6;%?=PWy(~8TPNwV}PN8@F# zZ*G^sGI_rl>TL&gecjS(3n6$|w&%t#)c^2(&^O%QPfS*&cr-ZfB!|`q`5Wo6L}Li* z9D)}ulFL)suff9O<9?G!EZ1{!sZxhv?UaVlg2lYN!wx-g@>?8%_ZHJ8*hZH?j}aug zAA_wG%i zKcu3@nt@Zth+GT;xQtOl!zv{_9WBgjx1J=19&uEAlzK`ceDU=2dRuFb(49qj;e&Ot zLCMS7xTc(ww>;YeYbI&hXuGfQPx}UL`-vcA9UiWUY;IldkB=lv+6u?CzP_=T{d@5} z+s8@#)}}j4kfjU;`&;RpRTr27iTe2=i{W=tv&)cTbjA7hz2szQy<~qWPs9h)jgRK` zqYnE5D2=d)O!fCD8^y>~Cz_(u^szv2gv+-operi0m|ZWBo3kIa3qo?E_oH%8fNSy; zIPR#!OfdGr8j?Xe{NTf;_&Fz`{VH*O6GQ7Un<j=>c^fRr4%wP+2MuA5WwAd0R%~ z2ZDyO==bc}eN6((OXtdEy?xjh)ENs>{(req%VI+Olaea9`|Bw7%il2*udMgtq;_qN z`22M{E}qjEsQqzaGUaF{Uv6Vz?;*Kp#6L9_N^EVp0n>opg~_1WO~J9&x&$%_QwtM(?ehZCNo{`h)m5eZS^Ao`>iQcfm-WqU~TgjL6D_Gg*$ z9Ui+C{1I^9fx`l|LG2q5ud7hV*vPp`KW)|*;4=s>Zj!W$0P5jLN9>xgtgYGd0|`MB z_s%^0%QB79%@L6)`vMZ|$G-c#j6_7{5mBq|IG2*k(iTN;T$>*Hry8@CW`5|rD>Xd& z5Zrq>fQ`6u=y=s`4V|M35hKCn594D(GT*i8i5HI%FiT6`Ynrf%;q4TDY`x40w1~fd zHVHi%w9v%a12c>UDaf<=NOVV1p0`+!b>aCI9X1i1HGAG^Ykh@#Pl#+fuz4?+$6cJp zWm9FMc5u_2;9VJQR=}4MDsyIBA-e7*L@vE=!PRYyTSKAp}H<| zsXUU5PO0_A;HAc#I}X}jPYEfurmrcyBxdymi~@Bm37Ea_Y37YvWKM+smTD|{sFnN3 z)%9W`EXMHLIp}OZKku$z!_VsAcy>FpLs=z}@Lu4gEPB?~J>jAj2U&x?-VFw1tNyz&%mojlMFn?a7+opcG(!#EYo~5SfgB6aO7LjsXIYxzs3wSoq}f>D zBv`KO()ncS5uGs%vsK<3kqZZo8a#S4l{w^2c`eM$gP zdH`YIjbdZ=xA+MDgS9ZerIhpk@d7p=Duvqzu8 zD+y&@OB|z2E-vain3p!j)8{Z((F;Q-ZzbK%wrVg__ZQhEWpV+By_DvY!zjPnR^rll ziT%V{<>h4(S4fnM7RQhMIM-ik_Cu(f)Yns0;~7^?&LzZoXzHD~CrkC_<>8|BR}I*g zZVL+EpQrEm#b1tM9CxyIv)$E~Tg-ML z^=1?TD=+pq^AcO`-32eI{b$NZwI4n4>ww^zi#eJ7@u2zu4CAn#L76Mb5*#5D(xdhQkrG3$MBx1GiBj5CYi-DiF8C^FG*eLk}s+DudW3O-wEwjAMzv_9v{ zgk$YepGfv!G=(xVX>d2ch(OzoU)$x_vKv*WK$`om4b~l>-g?XFkxD?!Pv>&CSyxK) zm~V0^aEYlVNi{ZmK##9N4&ca!T0=b=hIy~h=`iEzpsSbfP}wp`^JeAOrO#1imd$Bb zp*tht5~2=U40$2^0sqdpuR;;L;sw!Uhs-0sy@UrvZmQ(phMVwr4aj`@1Uq@ipFB~U zSQ$*{wB9c}9R84{FwrOdx8_BraVwu=U9^r{4-x<3$dgh=TXb*3_0HaX!4KA$WeuOA z1(a5`ekC!+GeVQ+@aQ`dT2EU<$fI-7@5b;KaBCh??)Bt;ZoohIfCQyG8;q9dBwlJ_ z;|eq+7pg9+jT7g+JUR{s@c65O=l-P@sdjZdFq_D*g%y$}n!a)KN$V8nSGTkwZ6;hJ zv0u%m`=d39h(_x|)&zwL$Et*ywkSy8$p*a~SlZe)oMyEGeP%0ZTe(T2p6?7_O@34i zN3T_p=1erw=I+TiNP04{YRKoI?|mrlB`5Eu#%gA_`lYeX$?4VsI3}Citj+GZ_u?-_ zEOm&jp*V()7>lmEX=#fE!q9hIO2sc_r7gR3Wned2ivpu_)~Ev3ib~K=Rw=!0QhNV) z*o50sSkR;ty{~pG{))X=Y@gMdHIQB|vJa7n*=1`JX)MzSJEi?WP6|aw55B*D2gbti zrB~ahuW28R5BWTr(Oc|1BPJkoMF5Bb_vJXHwf+FG4XYV9wBI;$U0pOx(?6}M#Wjf^ zrE+H_i5z8BnR7IPnlDZ74Gl7Fp0Z5>fd%A%A zh?4n5AIIf2d?6pz!|v+mZGaWAFld?u3PkbDCj;Xaf-ow7)-+1|_Ha66nf)Ox$Az8EFOgpb=Eq2Q<=f>ANX-k+j$?Pr?D_Hh9t9zRKMH`BDL|>Ha zJ!S2K3!%Q!Tw`qd4_7 zz3Lde^NC|R-?B(gAFvm51%0w1U9;XnXDQ4nZ5Em{0H`Mwcs9cDc|;T*PC^6zcM3$f zc-ZFwTHaa@7=WFG=$S2tEbc>ZS=mv(AQMt~G{B8yOd_;(dHmFY{T$Rt$k&|NI6|Te zk78Qyy997x$sFWVMT7x&(kqx$AJxJ5a;hroKUj%U#T0bs6|t=$cagf?6?r zIa3=0d8*-RuH*CUfJYXW3@05)v z1}jE1B-)*mU|dK>dDf-6!JZpE_$np3Pwtw)Lh3+mH5KoF# zMK|6<*^lsod;kJ(VLA zNDLA>(9j{|Q_FWh&JNisXQ;phrrk$K(6Chj>9Zt5#19TnTfg#{#D6GU{u0;8$b@Je zUU*14B?xC?z-AAoCD+h09}Cx|(Beolv^d7_aiUYvmRmGuCTxB+|JqwDH@KMr=Z6Ps zg=sO@fRuVykUlgd#0*&`*CL0zED}k#z~4h?k-u*q=T^HWc6r3d~K`s-&Ar7pwR0y%a=_NcyN%=;|hmvgXwVNT?-|CJw{&#DKFt7o% zFo)(ZKa!=OxS51Wfe8RiL$nz;;zXp+XlZ??CN^e-A52IaocLj)7AP?+8F;J5QW6c( zVBKDzukVB^Rk8I+Sd@HS0Yi!kt%Y#BlpAo0v_!=|P-6X{FTM1GpyIrH?~r5u^4jg< zgEF$*r@g4M_PqR*HEiU|lW%ZlBv5ch&vz4Hs1x-WK;8#J4~2>pa^&S9zxSe%M_221hF>v;j`J5vfwIgUXS z^X4;Q7K+26Nl*Cg!;b~A#MX52_YZ#O=fN~Vwo|!=+RmZvP;BCA@13bh zP?Rvt;V)92@T{)T90P=5@+m;;Kp(66ahsv`)%n&9>;$Lpn?y z<(Xq~7*6RbpH@?WHgyx)w>zgHbO=~gXl+kbeSsV#SVU@!91HUc>l;G_sVT{NyY-%%mH=EbeDD_H=iKc+f^DM4$xOhOl#FYHwlVT<`T9h8 z5Ad*jS>HJ@*bUX{9YR823`uT4C4(G28igEX{f~K8g@`b}Ov#WR1Fs`+a&cC7sn~77 zX<^Kb%vZ}RSqLnM5iSP_P*Syv%T2}}N#Y1;i=|_DD^Ug5?u22cILFALS`gWUxUAU1 z!|Q^gZYY?Na`YUUd$_+~v&GNN ze#!--`POjw20D&eFNO=HHZys$h=BLVyK0eHPhBn3GY)D8P3Z!IwfAOWUVsh4`3EE| zJ}(EKF%1?UWK5#jRRH-<0Jjy&rO1ct+3U5-eijW9?n@F@Fw@hRo0$Va;494k9G_UO zpwa~^B+;kEQ17{mFi{!?)+lcIzX0ouDn(hawY8ihXV%@~Zn{?YhRlK2vg*Dsu`H?O z3sSb@w1ef&$n={jPa)Ekax@Jo%De*&Ga{W}DP*6h?*<8<%R%a@;ka2)fL6q3`ab{M z8!Y=CS{R#an`u0NkA*2*W$@Te$k{ulrr zxg@CDGTPQ|n!YPO+$TuJC8@M-%d?quyKDzwf$>6X0!AM;4_s4{t~U_<_{=266uF-V zxZ25i1Z*=l6=M|*vLvhKH7~JcXet`iu*{dT~Wgwu(_5>eHHaX@2XBJ!4-ZeMty;i&`sWHEg_QM2EK?C*G_=h zX9+@K4p@}=@R~L`19gfYul!!0ywDU*F8B#|iusO@vPsIZn|Srn@6s~z-gA*(xVF3# zBhSIg#8w)a7u1~!EhgVQ2GqmIN_H7gq#v6D+b^Pe;Gv};z3j?&7H$SuL~5JsQ2bLO zrzX*0I{Rysrl(7fvK1?cf`Nc-zB}xvwRL?G{uK?WCI)N5g&;HvffBWwfH?`hh>NiScSj%* zhN_0G0*%etNH7{Y5|GCTcLCIjO)u(}8vrJtastp;C^UbmHnG3(5Wsr6I^Xp0Ey+wNN*Slh3$lOq(a!^sp;57e2OL_j{X(K55 zj)C}i>LF(qMGw{)WN=-q=0}wDK#eoWE+x8*AYO8nu0445RioGl`b@+~saR6B1(@XmOA5I<7NWic%P4Ye zN_a`s1&x!xN}9FDDc}atW9Vrh4{2`-SCR)QZ%w*}_=T-1hKKo0sH8OkC87d@L3voS zlWgz>x%dq5)?D@8EtH>{J^OyHaX@;{ebRb6#D39G@YzG*uK1@H}9UBR)Y~KY| zLexn`z~!0s!yZ_-*L9E(>_b55S@MA9Qs|O=;4s!vbSTb5Z|GgD^rf&v53pZPKv?H7 zkj8~lHTW+|Ctv;g$^&hewEv3BQozV z=-I@t_qH6m{SJ8yr;ez}y|!!VFTV$9nw6?1noXW=9;{5M3-7k%yy`^roBYcU)`cDw zXsls&J)eZQ29vt-eR=iI(1mw0}UcC#Vpc0)^9 z^-sF6avtzIVDKs;#wEdH;yB`$I>8^{C#PqUmi&PSssI52LtUeX$j_6`URg!YJ#BF) zQ0U(uYwi}8ZN8oQuXW@Oj?Jd}_w)aoa{lqgX|?9;cdz9qy*ghW^8!elB zkkiO$1T37s*4By!K6%$c(^RMU-ox0J13q73CPXH!maUG zTeXqHXk5p)OFmbuBOa`Hq!e+W^BDk~ppw(9AX!p5t~yW#URycU z+e8XP63|*g^y;K6(GLnBj?Wpe$*w8n(EA2h-aQ|q8Ni$A4aQj0fT8RNrmMxyz)I+V zv%C9O6ZE7GRZNo^!`|xGQ%=s>xja+Z8=ZcW`auTGv3p6Wx_fH2WE_vz$~(1f?^2;? zU7q3=FbpdPbMEe!C%ewTwdM`5@)Exbsy@gF1_|~;evx(zn{_Dm?xs|;(!=+;6aHX} z^@g_1?QneRA~ohiOMv?lJz6GJVXy$UxrtB};tjlWo_5AEE>~Z&J~@XTdzZ|azIO^w zdCXt0a^_CWYP2ujl@V3z?lmhG3|RW4vWSgm2TK#pO4at4#zvJl>eF-ZwKw2;cs90R zxd3+f!s#s8(@J|%TQgIDXS>Y;dmI5FH(-W80R~skfD6^4^vyF+zdHd^WJT53)81I= zzxLB0TcFkHCp4=>vgx@35W=F4!QyytUIws~ME(?mq*6H?8Q}Qh3?3-4Y6;mzM?Z*J zv5I7P9>oia=0!2{8ubj})uL#9D!{fYgCJ$$=PO-q{iG|O=DL$pK}FnuO?vC2>QpEZ%wz%3E8^{f0kF+B>r)Je3znVB)jG;-!l)|dA0`I5&L{qjl zMoqdE6OBs(p}KeRlQv)6Y9Fgt5t6Xq&h{RSy)*rIyRznQmErDV2Hn`p>K4b!ie&No zmC{o0r!1zwTAw@5wSKSqME+LybykY{_5@!j7~mXX}7;%SUd$Cpim7gB!{yKrP+crtmi#=r^B9OtO3$tU-hiF5j11m z0gXi^m>RWB)wsF>%e1B#S|JV?474dYfv&ZS5o5)gIfaXv;91Bm{sj?Ci2J=IT46JL zp~TV?P%iueafo=J5PA4H2oe|saRk*1KKkK4?EJnWY8+ic!yd?qvd7;{8~1n90Asl0 zv4KT+5Ep;l6g5~nikICPAdRHlG$&TrYRvfj@3{=J(5I;~2D{Yyt<@tHU(<%Rh|ChiuPeR z*D7;LnAb~JPm0ev|MqD%Y@BNMUR+f8YO|asK&R_FAYm`%IGvx@c+%~&_##fD|Eru7 z*rC94WV0_of<)&@0GAZH5gQz~ZOGtZzv%2NrxFi5ux3RfFvC{EdTO5;*s<~ zrr5}P5m%;R_D7}1*No_(!y+WlYc2@|Y|onUIeKR=df^HmnGAEO@0C@hUum^txJXo~ zrb=5Mml-h!j_d|L50g3{d*Xe3KhEe2m3qjM&Yd;s*`uH`>-e3zvuEDpeuJGFCw-vDPtzrmm;=zdAb` z3737@^KY30k};{PT@mktul&=$X)CN2+gnNUlUPnQGDU}!KR@tDvZZuC3JeRo4h8phG5CZHNBA7Y8PdiQfEEiu>g!GW2#aZ>9{i zw+D{bkxzvKmquCqs~m<{c8;jjw~ekSjSQM8-&huX@^aSYp9u09HE^8xkW5*%Wr_cc zdUC_PdGe4kBO*Y0zx#=d!R+6duMgiI3yutRXuh}Yr%P8yEo+`zZJBu=97s$K7?oIk zDH$DkU+v`jhwff1E?>(h5}TV!%V4lqCKrl@86Fmj+Yv)gee84Ef*C`1zZ@J{k&U7- z7|$#D7P-Y6DGh>t!Dcg7IRl{QcZ8(DS&#y!w6#Gro9{VxO6{;OYk(wNLhBx^JFN&6m;Fx*9ZV^sKkP zO*M#o9OINhm|C-geNxFgZZa@c^N|_JZ=lD3{N+ef!R#U8+G6QAlUvGb+BTOlaTKmv z5?D|qs7s-ymWdxSn?G^EHW<`3cj+7bwc@Et{b6m)PDrb8d47?gI!>HY75ZZ3Eda22 zV`5rDnBcj!XkpAYFet<>3~iKPFp7o%O2kk*Pmo6;x(tA?FvEc|!nqNQrwxiVvJj?> zIZ6xs#SM!h6%TfagVF`Tra7!rzw3Gzt|{ey@{4i!m8Tr->OzD)-PiISZV+oT&zt!8 zzYVSZ9d&nMHE*??BcI*3hNHU1t4)#PMZ5WqKA+=>x6B4vY4B0k!W7{bQ)Z7FK1_V~ zdFEWTol=tX&8Rrm>)HG*2JHRw93fq4GqQ?=7IDpjW3i3CWj?GWF_xg`Yi7z{iopQt6g&_2pO=Gl`BqHY;;9Xo_(2=%3}Ejv5Ta z4e6ug+;Pf@j;#v_3b}7TJWR!#Y1g?kH66%wRUfebhuQlw-pF7%;*XQE8mZ$@WnSZD zi+%lZlSs+KUKb0)%#YHjzf*N`hUP_VILU;^gZ@0-+`)P!p#nef_--ujI&Omeb1hbK=r9T zi0Hh6zrysmjb+f<5~LRPm`$Gfjg1;aHg{cSpV_I=I#B9*8}R9rt6{a6&mkRz?K*Bd z{;V}rdj%^O8{vFfPetf#;m(+GJU-**D>wU+@T`a-;nk4$<+<;!m{gS2nCt+Vj3MIBMM(8F6@2~JF4 z*eLhr+D;*)gbQ=16w154w9PHce*Bvh)9&1?z7k661@YV+ygkYQ&C9=jmg6IYWFx#r z=ciEH8da{n*+W#p4)<-5{G!`zp{16eYtEA?BI1eiqQ8ebKWix9`dCdM>Jz)yRw|6L z>Y34O+VqsyR=Dn{j?_0@k%QLYc0rq>HW}NO&&Es1E5>1cJ#K`mRJ?HUGSNDtrFv1@ z+8XO2MB2HSU>1yHp*@Tm@ogUNfHeGd@h<;?h7GsGYLB`jy?VuCA}MzgtW(s z-YcMyKF?-MqE`#$;Jqx|xDkmi@CEVE9w!oZD<-3+hC^@!{?W^=(<6yAEX;H8O1&>I zw8Mg<$l)!KpwEt_cSfXul<6OO-fiKwD))!RuXS<0D4j1!b?;1~pB$nEX6I19M3Ud| z|LvFk{E7DxCjmr!gKmN~F|oXL)8WVtMb}K0|EzrB+q}Ht!10gk))+_oe)pz?guh(C z0E&Igrj=Z@nkVo{)Mv#qb>EZb$Hl&Zrvnw#!_mEL25)C80X?F16Qtaqi zMmGfNQIM=rjemA^_S>^0eCnAv%=Q_p?2*vbw|V5?H>UeW_r~e&*}v0gN8^(Cg`Sl8 z-D~?P5a23YL#z34b4wc#ELQEdh)BZIoJ(d*0{|Sa0i5OQ7`tNLE4Wc}V89mue5L*B z_6{@a(fHL#nFV}++xM<-UyByxRXqwXmQP}2xe1e$*P|ryHLOnQAFcw*_RrEQ>Y%;+ zYS9{TAh9XO)sf3G^pnrDLA286*%7qnP^|=mZLi6lyA#+CB(Ah90ElrP#OUcW9~MDe z@GqkR%QZl?3FWqZReDRMnp&T?qLw2)8;CkkffD7NftGpkUqjsrl+t>9J+Vy{U}Pu= z1+7Uy9V4*29s8tP{4=V2WhhnZxhqsfcthjPl2kcJLX&^^4yYqBwcoRQ=35#7Zl)8E zvk+H^rJE}{0G1FTUK~ljzj^n^ns}70@MCm5`KZI(|C=MGgA?BcvaObyhZQ>e=tiss z2>oW`}1KUCS0cpEi%Y{>Fa9JM_J0n4d>;QZ`;~=@U@SLxe z5fBHIeEir2M^}X13|MFa{byCoo7M z+6A~ELry%)TsLaPM5jH}kT}I(a9W#^f@LYq$u`ojLF5cAb7ydqA1qYD3Spopdf63} zlndZ+;R#m4F$1fZ{d%C07Y0#ikVd_hN`8gtj~(y;Ao%0i7DbxJ3(o%e5|8zP7D$F` zvBv=SiIu}b3bl#@U8?}it8zuZ_8*wu_V`bX-IdNkh)>8BP($E2r`NcSI=a@wRi;6d zVe?OppI8f=J4@VON-O~`(K{?0BAg~%3B>Hz`26{&B|XY1WmY^|;K!gHo@d1*>FZ`7 zUDZxyGy%L1LT zLo9(5m*wJr2Ht>{;-)`j^X@Jjw2?cn0O2a+ty8 zM_@2N1+k2W$w=P7mlq)UMvNIQYY*OzMulyE3LTb-eFll|gpm)xhOk)If$b~7n|25t z#`1uVGzSGi{Qi*PBTy-aS5urZI^#0OFP`c+r!Cedb`K;4j}pS!UitO4Q-n55$pRn8SmzrCJ4{ zc9l@=s2Y4BVYRDwQOkN8n3Hc?&@= zl)y;w8sN#&k_FCIR4KwyHbs3mOoA@{977=UYJ_m?arERGu;3jA>-c^>X!u)8?uFhZ z7-#^&etB8T_Aj0&SA**V^l!a+-(|x3eFT218eu3Cfv*~f2kcuRlkU*8v^J00A8voW z4rU0&dc6}gEoovNw)T27XUXxO@UU2Cn`rU)JpUj~5wIWM%> z!UR3A5b=I|0=M}a7f z*M1u2Rv$!34--Q1!$=B4y%TAvQf72CX=TlExq5JW108w|gzJG28WS^&y$&YdS6L0@ z@{(5|SkM_1(gf%f4EGSZ7+#5fr!71p&UBARFSVK-h#ewnk$JPLwJ$E0_`T-rJRR!i z!6vj%zZyk*3oFDv5%>peC%G@d6OGU5S=(gb(J^wr6vf!aZJfk{^pfIEf6~AMb9#6b z^Ua{HlKl=A%twEt)M}=Du2B7rlnZ`UpF;xbMAA zjr})!J1wRGAjE^45n)D5rT{9Y|$2Xd_t+ng{#LROJJ{R$W*qPVs1ptyQ z#v=Yk_aUUFB&RG863fv-NQmpSL$`Qq9yldmnA!I-1D5#0Af$0#YQMq1n|6^GVExee zyXera?a`0|tK#zwvv?~lm;4nVsk7Ix?3|o(-g1n0w(-b| zd~<=27hw0p4%G=0_>n;PL_Fav9my1!XJB(EL`S?JazaY*IV3-kh;A5m@AHROcf@(@ ztR4~yoO^+>Q5cr+o48Bph;YV7;HwVW?-@Mqy`-6vu}yUNqQwHq8q8^aSm4s`q}C{* z)SXiEPa1ez`A-rRNc^#Y`@>^~$MUs(7p zWn}$)H_4*sd7h9>Pm;j)k2M2jYP(k*AhxN?mwWg_6lJR?@Mb!1WK{r7SuEXVQBOd8 z2#B5dN~oKG%nS+XIeLW*idqCe?n)Zj1q=?2 zkLbf~cAgV8ZRK=x^ev8H&}+2z^JZiyy@4)I7>s^YCR$-yQ6dIW0n|U(?Tf&16Q7w@ z3UK9G@6JOEkWA_B1gfbDMH!Y!sVUwmVblk8tDiTo0AaY>0t*1`V#gnk+QMJmJ^q`! zK_YW$`z8?-N8JvCM7q`DFCOS&8vugTuoDb~T=QfUwA#?ZGAtX>i_n$M@^x3~{5%^b z@(Qe1NF_W=0>Kp7trdJxRAQ3B=e3>cqngKDHh7V~#fOROI9Nlz<}Vm>AOW&@hZpv@S*7Y4DWXh4d8Bez}_1>O(LI!wMDf<=FIzN zV0>}p819sG9BD{CMPK@9uyTIF&ilQ0&ot*2d*ILP#q4#I4LnLb7UXp^;o%&ZXj#)o?C+;iNuaoaTE4UNAC zLw=rpGz;%z6W2YPP=DeT#7zUO@^{Y&hx`Jw?D^Akc3tl=8Iu#2p6z4>vbIVT>39dT zJ2FTI2PY8X=w&WYWUZ3QClR?C*@xO|=HuNQ{OCHPV%S227f~ZK$8?bTav-3z(FDP} zL+8?Xan!=OC9w-{m2$m;(^nBsv@D1W!q-2%(amR;kDB?IgpLR8z(m9f*c;6S;~Gm+ z;!fh$1ShZTjD?AcV-!}%fCX2Psv8%QYglyF`fgW+K45#L- zoE3}8IND;qM*5~Z`Y%qOFa-iTshkF0tD_-W3`|zM7-0Iv!A%`T9Glqh9YnfA-JxP@ zIJea60QF1pW)swXCnf%x?nxmA9T6d|@n1pJt4Tt3NXS+KC{#pd#-&mFVI=zaQ<(F< znS_-V_uwUz9s5RaAZn+!;6ADEF(SG1`58bt?X99iZV8YK`G=ObM(YAqH^Nn&6`wU9 zlxlos6olRYW_~Kls;do|5ruRD z)`oQ=hdSPycp1A;=J|>RvGvI#N}Hr2fa8XF3T<>j{RM3)(7dz}?bA~7f ztW)4Hbq4vsP{4I07eCS=Lgj;ek4ArZ3;7f=qW}xkJ5qJ+ZV+y!e53qO9_sB4QkNr1 ze?i9YIN>-9V9xld5jY-MP_02}rac1=#aUF@1-}?Q`UG2cfG-KnOe3HuEEWWwhMu#< zir#|V2RzTmTK**FKta1%*!iev7$+RGRnT{-{Rh^yhs=fFsNl1AS8kzl_$zPQX((>7a+CE~y>R;Qk1czJC5GR4 zEA^KV<##v6LQn|VnhFFbEcrQ36q5%G1W-`hx+k=}wcKxIC9UKzvqqoS;L`l)58L|J zsG}@|BOksq=D5$T$M!%^jcjwK?&$8Igg25V_N`4@=CYZ#f4*WW>+0uKTN(VB_{@0xLWOck0Uv<&Tj9Lao`EASo&G;(p(pTio8hTkJ7tpIo6(QJ}{M z`B38^OTP(OPxKnIzwDMb7|70`Gq zKss}H?6dxzX<#1z)$e52;@Ngd#lY~%J;g_dpO80Hg}Ii8q-?Jr;4L35mv?&}=|iu8 zCj&BEmQ`+2Hf==&Ycb9-iLtb-6DE2h_Vh2Ps4K4>qRf`1JN4M!Su$(o8{7&r(y%b6 z>n*M_2dv!|ezFiZveZW0#T6qU1Atz@WL3z>f<*QpYS(1{zIR~U`iz1*sM&N8eS@Ib zCaV;YnS3*u_c5Rdo?i?{d(Y(J8!Jb<#N-nGKv_DOvB$D{wJKANEh*FOP&zQ1g#e3Se@k3KOB$0kyj(mzRRJVr&H z0#8rc_Me}g;#p{>K6^4_QIUU8Z0t6rK5hR7bf5Aok;7ev!~fV4|9`j~w}3?T-!<}f zpB3bT8l&gDAV2f=={0N$T|BGei;;#G9!BNX4^iAw{(AT9Z0rCs5@&|1?R5r7iLI%= zg6aSBGSUDr&7L;nW0`fqMiS?rtzY=eKifg!4I3x6VlMzBu4?dNPXp%w`X+q{W5Qv5 zbPbREz-far??J@OJ1GEKEdHO+v(sD`hyRztKSsLe4)jk+Op)wl{%{I)b_9qa<>oCnr-7ax(bo$_YW+_pRV5H95177K zrJRNmv+{6_0r7ia?7NpEpjPgMWC6dup$HqMtL`wuAy)78bf9}r^8HC0FbE$US zC@e%Lc&#IapCgfdmQOjIxYSv549mJ9s4-rFN zf8Wkm`GY1I0j$YYg@P1XbB(;Ms1`+We>#(z*$wq(Bc;IhzNn_|!YjiA6)i z3NPYQ1p1gS_any+TAV;+p!&gG%R;mzjXX;kZkLfs4M6bO1tezI0*Ns`lcV?JPK%DM zSZ{u1%>6EUo!k$-*I{z`$S^pW;3K*2x=yLxA*sJZak~&1xriny*tIfjY3aMNc1(!D z^wJbv3K+7Mo)5(Zj#8vN?OhTbkiqN}r%`*aEE7#i)dOZELdu;VcFYthITZxysB2Jf zJ%B;SW~}H^lnZe3*fzcTJ6^Ntmc+K$uHa7Q3Vpo@V*>%3NLj_GI~FA@ZSWl863z*r z_MJv-lJ%@5hR4d31dhVgVuD4F=gCzfZdt4-G@j3$G>tc&&+fUbN$tJRoNnLwVs^1* zGxzl&%I`!V;~rM)Z_>-SAe5D#rjxv^*rpKQE*)-_hb~=h|=nt9NP~T;2)G zBu8F9fXQ+eoiGPZP)A)%|4uTR-Fn>Xbj8jvyMQIKVY(keeGkn+DLyv*=Xld`mC?+d zkbNpkvy<=RCZ!X7b|_YgU!*@one}e{7!V$wKkX3t4j|F`oor=6OQd(l@8sagzn#X2 z-+40=Uj4hz<6e#yO#NlOoTXm1GoG2_q9?Z}E)gr2e&9dX2wGv`45&unNj9G6BdzQ;fJ?1y+g`7eu&ArNiP%2 zHCigSe5G*yGw65JA<|UlY;T@52tBjviK}-0K=%x)4$bg%FrCT3`fKs#J8@5pmkN|k zeKJu!;G4 zB85!IiVNy3?>#`B4Fl`YD%zA6o@UF?CPY1Ry^6e=g@#*CSD}UKB5r@9;f}b@nZ^ZUH=E5MT?}9$ zSK$U)94wgec`IgMY-@A8TKHB<(0crHEB&QWfq1|umaa zn=tCjXq@ZP>>WMF4vv&}@dcGjzXt9J^TmeBbQ~714wIrX7iJj!^uiWn)3(XpR1%R( z*lh_>hzr;&k5bLG#=e=BJr53#JX~c^0QzM}b29b3c6Q!-o?2hYbq^K$=lmj z_toqizID5ung@Ap+EHy5Z!);VNw9rhBoZ4Pk_~4cCKXp=j$8auHqko4*%`p*vI*D8 zjin9?+>1SVHC)0b=UYS((X@1Tp!w7;1Kix4^O+5&Q}{^}j#&ofz6_s>3o3orHXv?) z$+|O!d39ABI>0UXc+$$z<>R#(*;pu;ZfY{`UJf1{#053PAPh*HzZl{to!zJN=;11^ z9HQ&NvTAB}1Ae=shcXT12{55c#AP0Fz{hi>oy_#*`oZ_{#!@c2RcUVCgZIy@FrpGx zT#uFWVX~AmHbs}fKjZxGc=O!YZ9^?y&6l}ng*=U0`rn={s&A7P|G^DCVS3Dub6J@A zn=-~SvwmAgbgL`p#M~fF`;v>K6=hXzfwhCxnp!T@*Izc%zW7og)6a^V7}|7kJQmBz z1|<~?Slj%U$aCyvwC*8CBPDFwaNd$8*hwFyJF9RYVulz(V!51(BDIBK1R{-_>eCH@ zcv1VgU1?-?@kfI}mq%mtJf=O5cBsO&9m@Fg2DCNr>B^^gwhzt|2c5RA9`q(Q|IFa# zl-XBMI;-AzKa^n-*t#TtVelyFrT|yPpSZd(uo1NNr5WE*phs3+PJM|FUU`(+dt zJ0LhL4|5k5xy|mSQ*jomOD54BsG6aaJsDK_ld$=aFBj&F#nZH*_a@$xg^$w1O3=cc2ntynN?k9tm{(71GD%1J!yyq2W*VyD}N+tYV zI>J51(YPRHYU1l=(@CSN#~s-HqH^sd7w?LUs^+isf`SRUQS(u6NSP%XwcXT0$*Dzp z@CqG_pB`H4-ozt4p-Vs_0KiW;9IkA8C_&Kum6 zd+Q)qjvlYo%|wX3nNo)e?92O6Fhml_4F)-xw*b0LiBr_-1_ zfHS)r2)uV{cAV5j=u=Zpow!+Y_+NCZeot*g+Ndv*%82y*QjtE47k=sa0}a~~3|N9P zQr4SqRZsC2em>MCsQ5RxW#y5?Kg`LRYL5=FNNS^_reQ2|uF$5zzf`w6k|BB%O-l9% z9WzRzur&fJiE(@;8UxpAG~zickCHsiW>S{py0W<`IGZa?hBPD(+NcI=D>J9DQss3W zgJF`C&5pZ8ZFQWw(;o)aY1U&)3%?R1DTSwM7%-%DY|y^s6B1;;n*29jzBAx-RZ+2q zRloCR=}wN<=-n>|G^}~BJ`APS4SWTMk6fmO!6bhfdzo>PQ0`v{Z#-Ir1yNQ56Z~Q; zyr&ncor7x3zjLvxYGsbg;&?U53x*S7kG@k8%Ooq)J|b<8$qDpziH$xze_{8T0r9!B zIZ2Xy(1imAPh5DRyMKKoAP};`Ii6#qv_?Bk0&Efh?Rou1$s1gxaoZHjBovI#(J|s_{kJOr zu-#d^zB+jv-G@n8{}vBIkIV*GP(c4qAX)Lh=f|qXu3PoT6DP5pyE?ntFyh{k$K>^| zT(zYP2hQyI+$}KJze0uy@Pe#Gm8XFCZF`d1j4EvWk$8C~a{UT;wd`36Pg*DL0#{rn zuAr}DGL(cCI?>2eY;qy;JD-s>LuHI$5R=o?$8r7X(U!m!X=?zq6?truU;bz+DWnl5 z!o-hWfxTAz-&U*BYk&uwR&#$q8`P7y)-f8_1w#*K z&-D*r)8>Bt@1c>%r#%8C-oN`UN&x@Qzn?$d{=dI!C}7hWN0Bb=SW>231MHSBA_M+C zJ=Q)E{CuRb=aAAYI@5me?jqRfY^rA(hhkht8&}x*9Xd%6%?6;Ei}bz$ho;aeCjBu+ z^MA)?L8-l?-}I*{mMBQ_^4rzlZ!T|ntL^>PD>C>|4_|<(@?NRm?6z&j9&}+mc5+Es z0CsAw2Sd4x;pJjkD8%+VaK*Zut)Kf-y1Q+5_0ogb!YlIKB{(3O{E$}6^?hq*BooX~ zwY?X3QoqjAfbVlsKi^n?5aZg=XL}E|m0SDkt4md%?d1fRf7V0g+bl4t9&TKs{I+r3 z96*J0J^kE%M6Z9etwEFWqX)HLom*WWQ-#N+ML|Mv1%5zC+CTkdmEAzA8? zwS6yqi$kRDVGU?3YW^R>-YP80FX|h%X#qh}N>ExlBn1?d5Qau_P|BgZQBp~f1}T97 zq`N@}2}$W35RitU8Jc(B{-5XiuJ_=(-V;55VeZ^}tzRvK{~RFkCv3`pJ?!NXafRlF zuRrFw`n;qZEbrL5exFy~ix1JE8pJyR^!phYP`|m=0DkS+JA49vv0U5y<(UMj4Qk(q zZC+ZpP+@Mo7?~sNBZJMiI{Lnn49_ng_j|l_1Iwl>7F3fB&?Q7~+PXDhKs)2%1|-WO zSO>!HFtP z$4m<>AfYx#fie#Hn?$YHr3g_)ze)B|H1qVJ#1D8IrodBqK3BeN5~x805ucr>~6KKbd%0WfTe6a?X~kAg3{%SaP%YsGxVqD zDY%XQHE^Ib-$EN=91|!mbXrcd+yD|P9P|;jAO)pWx;Ae4Y)ze?Elb;B8IS=jpzB0~ zkg=MLw-PZNv}?{IBT{SPa6hWG=_ZUz2?m7XZTcRyGE}b`wt-_l$0Uz6nq$kNdaX9OZHn$sjddzfhw^cU%)(LE{-~+U8PSa`jZ_^vOC1h zZ@d9P0b9`GjbxiXTN1I`T9v1@8MXnC+-B2mvttZS=p`K}qYoqT7NqL5(u#c#3Th-g zwi?5BuMKUd?Ps&P*!isMPo1vNEx7_eU(Hz^kGU?*CHR^PX5$%)t%B2yj`&rl+xlxfMIf?>*=X8SY6xzifXn_0@DVH3xrz^r(r%c znB78?23iJrrH_zNp9>ytj!V2QKvUWVTuZ72kH=VGrby!)kxCMicPHaqu(;V`O#0ay zEL6IQ13-DIlXxy-TZZbs0m%w3)!BNl%TOTdPBj}>2{@Go@Tw!ww4nRZ=Doo+v^Wml z0=xBMu=xuz1;5(^4|DM;IF%V6(AKXupNy1L3)*>f>sQw**Ezk}zvFj0HH(=!?sF4< z7Ge^c?*`Y(d^vM*ShJOOSeferb@vIJTP0wzNPa@>4^=1o$W9GSC?G)C5#KkW)blbh z$6aEcG|DoSXc~O3MW`*zAEx;J1Y@}WNbSg3)?krCXLV*bzQ&o>y7b4cgd}J^Y`4nY zrcb97yvda`dcr?>ibPb3#m@_H5N)=ZG+*rJN(;3)=o+y<6BFhzhByaWAtde#)er(R zLh_zmiADCJd$A)L=_kY0?VtSfeLQ;+MnmLZ00#cG>2f6a-&SB%X3};0rPylrXn}R* z8!!Q(Dg3J(JCi$!C9bTz?tc3n)9_nACh0XMjx6@4eb@D8-!6|hDSs+!rJYlnUjE|r zlI$g}`UbB2SwhBr!&OL=iv~qu&u9fATY<-oT|hqaXWPrI9aX=Rp@(XtCt197YOx9U zYvxTj(;oqwWhX?fmL7qZY_{poO&&{T2Kf&s z8r$JB-uqb$o6TU&t*kt`2Q)J(czm)sdr!W|yX1tytSrfV!OsmJ8iTu*+W_8Eughqi zP}Mlq#r4bcmdmlOHL~=hr!@c+uMxF_%EIba%cv^#EszAN{{?Cwr#?gR^>C2O*HWX>|5qw#f#DD({S>-+>t=9d{Ct@g69<1%x zhp2LvB9f()Z*Bp3G0%>VF>WnW8wI|!nVRWE&jc0+aoHCQ&xM3A05mnH*U`4bZJD4lF#RSp*qfVr()-m zMUanb3U-a>2~O+4jvf0WeZ*I_le_Y}z9DZqTEqtN^FLG3QzH-3(U#AyZD0*0fBjR} z=x;zeN7lcMla6A4UF8Z>Ug>bOr|{YT)HIY}|ogf@$6`<3S)+m1hM}rkVjhO))cZo^JOd z+EFWr`F{xG}$cxWj6DeN8Fo!HxiN&)=$BYc~)VPj?@ zTq-M-dA!PtI=&e;YYB0P9nn`jM_@;&sFJh;OT?733_hgEgzkIs231|A+WuX7e`==i z@B6<)q$&Z!wwZk2G&BizFL?WhuE^^ep|C&|1al&(fjI$ODS6lQqN#DEuKM^pBXU~T zp8N6!FT!*GIa#P|qFteC1)Cp<>+}iXNmgSD$6FRzIyb|E;nUZOY+f4jU{Y#_a8A!k z9&G5`ztlgba@jhDc(u7HJb6%Vny=HzG8dOMi6#P@7)Ws{uz1ab!Y zb@+O0Kfy6B#wdhES890<-Di5a{K|?HBG^V}-u0i!85{-w?jsR}vM1|z%@S+lIVMes zHCWVJ|HueDE~GC=AD%^y9^r(n+Io5gF+1z(z@K(Z(ssZ!v_s*pam13c|8canxj}2b%go=OUozQUpvC(1Gmk7o5>Q+G! z@kXnHM4G$&+-{{dP`iSfH~+uzqeM@6(L_A|yK~=TX_(n=+>-T2C=xJz{4}qtVS;Ns zji(!UA4M_ODn^U?%+4DqmL+{gz)FM}WMr(Pn2DD5XTBPhx}WpnH{9YI;at$QH{7@1 ze`H9Z7)N3&($B3^n%mK+H^5p{tWEh4K9NGM`?hUKAmTAh@=J8oo(l?l4qQf7prmiY;5tBxS`}}2Q zuv#~_?veRnzlC&C=VyB^uWP-qkuEAPmGi4*K&_!@;%c84%a`5KiloY-bG`?ftf*2_ z9kZ{@0siexqvNX*yj?7h#Pm5v?H5Sf39oLQ0&UKsc}GiafsU9mPS~>vSWCtXKQblX4w%p7D|D8r zT;j{+R%=Gv^CJ7MUWUvSHy2>nJlR)gbao0l*6f-n2T5ACHv&ug{5>hrVZ5mFA!?JK zt>X8MJPK=%muqHzNSzIzTHMIN^frklr0)uF5qWT8;l~`}V`mNWsXEO+nN(ayg!fw! zI&AUe_Z7dE|7JoN8U4-g(t8D+x32Dz(uCe8I6ms8+`IdXZmyfS9gABI04Zcy9$fI#^a>CNdRZ*WSqv~D=x zKGMsDy<9DGd-HS1Z}w!kX-Ac>AVMk-&NE#rXx^nWaj=IXTvAFbCmR)f%&c=!@VfpF zL_KKR3M%VS}RZ62Cy$Gm=RqBVEn&lXZy&SV#xq9SPNk2@8rN%^~ac>IpL z4@($^tedcL7hRo7&_a3<^Gq_rrup}f{*dARx5zcgG@gCeF$c43N^QC@y$R}I?7Kgk zi^b8OdEH`Ps~|Yd+V}Qma;>2vQmg-KTD!0@i3D!;`6?R$9#e>(-f9ppd(QUQa7n2t zo1EFI;TA*I3Un$%&$5vu@mB(!f_c-dwDtmav!9GwzKrbzKZ2ihjzI|u;4kvV^(amZ z>{+$GBZ=pyI4$U=X8H$eB-)ziZ0PoE_AfGVnGMgqx`bvC1(F~W^w`BO5Sa>R*)cD> za8-33^D5Sg4SWBm(N&hNnDngQ=E1*2G71KlYVz9j7VA@FO)c6DT3Ls|*H{02=g3Db zfZ9l1faE4Tc>a?*zGQ(Z($xQHkU0~yiUBcFPx2p50ADPBb*3r!-@%eBDgM8J1kja3 z$NB$@IrOYbi~Bx20o6kj)bl1x1ePA@0Vj3?&}y{kL+t2;viwEGf3Sz6o|*LB^Qqa3 zQA4N`2dedvqKZDTZfiN+voB!i2pS*?Glmzt30q)bSAbcyK*gu7NM0Z=vlZ{7;5m`L z*okuf56NBAebDtXV#OMW#=5O#bv@4jC$|OY*QSpO?i7j>bF z7iu#IZa@w58F%#+*2my!$veyHcICCM?S50bI!rf6DReY6r-7js_R|P+J=`Qj7QmrGtLw>&CN^02VVe-{Xm0 zy$(`+cQ8RS%eSotsEa4+(*e z$QJaawy7)?W@Xb0-lbp7_#%VC#RGZ2fQL?*{YE6htsjH%itb`r-Fnbu`&p%sE2Fag^P}SEW^eIv zuYm+LL)Qa4WsAXvny=&Vz9puB#Cd3%oy$K=6{Py*FK$BpyVG7Yl%g`V1NhRnuDo#| zrGIp-*rONW`VT+>!`Jc_cjQItVQye1h47_F-7l4T9O63d1G^Zvf#Ss@c@(_z?^i<}(HxUN5ghCfgY z*Dj*Ef+&r~!Ij3Yy#!iyOo;T^oSA&+UsxIhnF^hTA|Uj@0oHf{`Xpl{p|buI$XSX{ z=m)mUY0RdD^r@c4oA7-IBU%54GL>t}?|ST|%zFP7xTjMLHy;j~%v%P-{Ve-m*fm*& zu1$jTY0_R=%i3B35Z2gQyqi*PfY{>Wf`I0Ha6qr!Mhc9of~u%$Zp?+oFlbOlbms8@ z(aqBC$t`%(7655c`RRkv=G@zHcFf|tIp~!!6#$M;vskIE@vTW>V>4b z_qQ*NPP+x%PC}SJ;-w1o~Bg}P4>U& zHsvi@nAgUUxISdmrh%WwD|9W_`ozW=w}5Q&Gt6{Sp-H@ukDT3npF?H*A{->vc%%IP4x3TTkGSxUZCwZ{X%z_QZCbh7>C~71PjQajELRR z{~HylZj=DHt4)^)I%_w&AA&=;FQI=^cJpc=Aa2J`Le76hd6C9E%3`&NY1(g9$@s0= z1=OJ)%#dwI{3N|#Z=a@uhY!N?M&!D_)jyp>66O`m|5Zh2WKfKL*|FFs zO=}QsV@-u%Gw$XW>D+#kM4@LOk7Xdx7C%%F+~fv+_b7RB7sgV7Z%js6lF*3H1`37; zA=Xdy{zw%|m^+s2(i{@9QMY2!O|u0$eY(aV7-%u|Hc4(d6~&mcM=HDRW|Rs(n^@PY z5Ta+HU!4HQUcGF^VpM-VkWGTxfB=7-V?0%N*%X`>Fmc5VqBo}$;=T(N4kVGoRo3&` zMFO`={7eo8m|y(HW{z^|GJ{yjEtRH#)|qFL(If10Y>h?=vMEOGAnK;^nD4-!Q4V+L z)aryV=v`*18VT3YWtUF#;8|FfD|^8a9>HQeNg?i)!DxD!6@bYY3m^;XRCnGQn}_P# zK_gYBW8V{d|GBPm)#L=L?Mf2QD6mE!XHoT7{%K%>t#q%cChZtj$F~`%J|0CWc?Qx; z4&9LTU^?myn{m)s0DezCmn8^)(IAg-guVHzFka7dG5#_AJkN1NI9DZ=HtoS{!JJDj zycVHvYA!`-H@#BdpB<<1$v>93-k&?8!OVr)=^!a=y1t01BMmp)Q+Ust{2D)NKtC&W zcbI{QCd7+G6@C5L&xTEJOg6E&TTmn5?*hqIpIDE4nE(~rZ zjFnpaLC?)7JodQNWvfYhf9t%QB!O8#!^k3Zs)?3;uug{5)Gl^n1q84TZ8w&ne#zm& zFY+i0|D zKZnN#q2&G4$6aC0=NoasUcD<(sqM5;T;El1}<+P-Fk>T@^$GE&yu2F-9)k;&^tB_;Z z5gOLqRdUHS@z|4MF*hx!{`-u83x;mDr^qhz&xbJSEeGkB>jk)2azZ#;2|42qs!~ZY zC_hS!%-K=XATA0 z?QBJ6UV!$K6vWVYwgR>C?oZ_VIgU+}DNBqO9$b4Mx> zYr_!&yC%!E2ayYP)Gj-jLLrSUF9Yc2vbO2VU#snnM$jDF2c#gbg|Q3Aaw6o@j()OM zuhItI91`o2=8)Q7;K_!e$lBVgf13eOnp@=n$7(Nmjh9Hd^;!b`aB~Z+$2n?5n6TT8 zp=oY1MP}S#U0|hTkS3ne24S3%el%2%f}Vu`^Ln=sQU9f zGp7mq{ZSjw)h_=jy2uo^qDkMw4<@7SH_o@|v_#m51Fg5J?dTsIf@0Y9bhNxgOwGmg z;oDfGz0F^<&u52QWu>>DiEC(}|2~t<&bG4qQb9}EqQY3IQ^8&0py^3|;c(!~`v@N1 z9NxXI>=34*t1)Z~;r_P`F1``|QjATD^8U-Ll5}77BTpc&2*uxSB;Tm0y4wDX<;wn= znh6^j4ZdVcj`eqiFX~zFL-mx%%uL?Pac^w~ccQ>sB@}3y2mF2$RaSyGxR!$ha}aYS z!T#l0SdBAR@jL0O3}+gV-n`>h_VfpN3OO)5B?_0C>ZEGlHnFH?KFKh3;ynOWk7TVe zE6uS!@#?2q7ga{@&fNLh=q1%R6TOx*V#OF9N#x)j)wJNrfj1*H9tFt1WRq6I+z|Fx z3x8Bk;gw%UyKy^K3K{<(UW0Y)f=vSX8&Yon8i?Sw(usg#dYn z^5SH_PNFnm+PekTS{MSIX>E>1%PiQg$ji!)2=#a7MQp{}#luo*__ojYnhI7`=)n;~Ls#3*+hZ~a9l<6em@)oZYC65T% z$H$l$qRRKE?v%5rfR?0PMR*ds?O3cd;@dZY(Y-;d^;AvauHOQ%;Akc2?b$UOve#2X z6etgIaWz+2YA-A;j{MOpU2ZLbZQr3C8F;7rJ(u<4{e7@Gm-I%kW~};Tvz+fHv{(}` z3LSd73z4H>X;OfOab-C99rCJV5#m&rRB6bWS1mtqt5YmR*m=K3bP91$Fjsg@P0fsY zh6?cmy##Jcpyw75T<^S?xXj7_(T_<5osvxK0Lq2-#?kYsZ+iERAf8ET`0SXE{ryBe zi7W~td{GiW#%4!*gT%7Kd2bOq; zB%T+HX7!NQWJ#>>dbA6q4UFE7|0;re8HdU9$`-X}h~JXxdh&SE`VU`}hcb3m)vrD& zSLz_Y2+h~^FwK7u>C_=vtJBm#G4PT)Ztn~3Q!%G(JF%2rg0%Aui<(koDNJnr zxGo*uZ?9RWzJmIzDamO-j4IynX^bP(&^c@?D30gaV=xc0V^QZM0K0M?BQonf z>`7x2bAqU;O>X}+n|D+oXZ~nWXv23=##{cib8@I^Zt!hb>Xla1JHwz<_L7*NMc(1f ztJ8UYrmJUp6RapIJftpBw<<22e{|e)w)N4(@lg#|!@Vd#W_&(w3cd}c8ih(i=_`d9xH0;OtLm#6$vQeo~J1j@vSAX1l zdd|X2_%-eHdlB0Vt*qP#eCwl;+Sb(usp%0Pmy{HzuIrZ;={~Mrz+)A(@Y4N}_*~;y z?1L>*rr-vwnrDDL8BV4$mDNh+JJGtZgi?*;;-l;bg|G+ARWmj=YV4Y4s&{Jk)^;eW zZ}5HykYs*oi;Af4xI=S#OrJf;ZpFVw?H5S%JR~}pZU8rT@|onCn7KrESJ?h^)&Qph zmgmCLcltOc_^9Buf;-AN2qdjQot>62TrdqWLbqt#-)PJ;PE^p}nihl*U_9cPYf0NH ztzWA9CVl4g`X|gv%#%k#-=k0r)?dB*v-ndKK96B&S?R8TEW#-ml*_i6YT}R{%Ofi= zqYZV_kQhiLr$T-I-l6f~TR>NB_%z;q7aT(OKAth}N3eVrjkZFBqL9JHy|5Pqd|Za! z&yhq7N?SoE8)&LP{if?KFUxXS@-AnXZ0{1gxgKPiEx%HDdN8VO(3&TTE9~hK=iyUJ z$I1PnWh1blbjBFI7$bh#)y?9t*BxnmSRD34a87iM{&=%PlF&grd451G#g@}xv1m7g z=nk=X*6Xvw^XD3`$f>&w&^WEVRlIk3%F&wR3?Nd76Wvl_(EZ)?lMH!3RB?=SZ}$Iu;;S zvhGWLd$KNVUr%#7z=7g!@jQF`2p(L%ZNjZUA|7rmY9aCsW6#jo(WPOSb#}1O&ay-7 zWKnx?ZklMA9$KQ@QfMApfa;4KwWE?}=82at?74hHyp$|S!J5idXwqgb(FDRlngbD5#Qw2)gj|j&|&Q|5@8|-b2f%6?|Z0yq9#o?q6jO$eo!oZ*G4$+ za`2x7E%716!L6HtJfZk9pEGpB(%J8B;99y~-Ca->G2OiFHb;d)>1Qhp3@li^r4h%F zQ;Bqu=(0c9C?s&);8Z9MDmeSlu)C7Xp3`2oQ5#aqpLZfo8RJRwj|@n@8564r&&=i} z#|_2vnoRUrwP{#4rY0xL;?Aopy73r(0#{<6d-?cVnujl6BGPHcae1k6{+;Of!A*JJ z2{XkP|6%V+DL1z$9xa-wdAKif8c#GGweetprXanFG_m=PdN{r~nG+EdSqX6ZM0)LC z_o$fJt1jAcl_Pro2j@q5mod_k2bPZODTDt=;^~Ei#MYNkrcYVRUHX~0w7IOxqLX@C z<;(KiUK7B}$N*QstHbu#4A2m5&o{McQKmVubc%IVr>(lf4P}r*eCT<^$_m%VuK+1` zk~__(D^mGM@wsvs!q@|cKS0{OyB21Z`Tx-ecmuRaq(HHl$e=Bsl1w4~-%$ao#52I3 z1Q}$l27bg10-oWg@B?r4rsM9fZ@Ub+TH#7lY0;>I?g510Q3%q^$Y$K`y79>?X1 z!R3aIs?D2IJT?N73bWsv%z<=yQO}toZ`OsQ44VtVtbE`^*Hc zLt6YQJy+R!Ajlg5CL6ysUm*ICpU`_@u;n?n4q?RF7qOqyFVB|IAn&8G$E7XF&MbFr zRTyXydXVd27%K|%#i?%<2==4}$&kbcD}6v1oR{rBe?N8QF3gEk;+Rwa*XL%kBDhzN`5S0195u9-oDYVGi8aoGnc zO1wqO!%!9W?zhPG6aKQb>C>fuqyA8fz zbs4McbE$^}P}JxoS&6-WdMH+@osSrxp>Y=|u2K+F(5_T@rT3rGRGU=Zj*6MnQ@92s ztv(dwpR%bjq`f;D@M7gp33)sOlQ%%5g(0NolWO|#N9NNE(95Ny(@y`ng?0f-DC9IQ zBJjhL-g5|GtN~)5O8fc0&A{7MEs8gD7Q4+sc)4i)^nMSK*|#&?Q2A%dxyUD9Tt@ZK zamCI#hxaI$ciZw_Yf+9UNuGjZ7I}q+ElQ}_+QGYf0pMX|3i0VaVX=1y)9@92oES>B05fgd&6o?*A z$#_9}-+g++Tm-QbTQ2vc5eWGw$=Tqx4q^I&nQgJ`s8A!lIi-*D3Zihxrex0AH+lPT zNuZEpeY6LusZoz^NLNsQ7sxaGAhb@bUv+J2{)Z=>O~^8A{fkQ}k_^(rdV#;^O=b*sYMiy750!c&4 zrXs|bd(p`pW$iR`P_OZ(CxZ2z$+(yrGl~bmBcP_djG89O% zuaI7&L!dKPS>y?DyUtc&B{RCd%27_Y{qe7A0rv;{HA}y287c?SJ8x`EOMwQnI$!>b z>w%0#nHtImZ}WV&U|Fqe*}JryoE6J->0-AQQg0f#1XOiCHDDDHk=B}JTh*!S(u$Az zO9gv_qo@Kd?#~MT9JSo=`o*LkRjdVxYhdv4ustxTMNy+PTnxP=T(b%hgFNZ;6y`WV+Ik7Q zdTgpg1PL6-ANN$(xp&bJFAOJx*R z&bI(F!|wja35Q)l1w_*^i&B*6<7qwk|WU|j3c`}_o!Qovg zxyyI2Trnki@l-}La$xTzZWS%r&2Dp?IHSaH4mX4Wv?jUUUVQ#Ru*rVBLT@9FK=?sM zhT8ma2c&Pa;k2RU$#cp(ksUyG(mu#j5oPnNy2S$SU*?7jO3ktgcJ6BRzqjv3tm94) zk9X!NXpN_DNF%2ULl~bV&&crx`puH^9(?U*VRNc6?}*fWpc@(RPHyME<*P*Hj3So@ zfoX9^0N!oU%LxBxAH9&hp7Tj}ba8Dbs%+Zl=BcDKDARlh29Nnbhj_ zp`2GUj@THdYOSYtU9*60o6|wzTTP%CC%&r_q~$=QQJ!dZ_Dt{jfFiS z-}on62SaN(cgWEJaa;pnmANGqXz56L08K*3Rv0M1t}da_5aR=+ zdN$XZc8z+*aTgxB)hVSI$^XjyH2&lXT_Jm%aDVNpirwT{owQ3%NgmsEmqf>>$J*(N z9y$yfvlNtR`O7bN1n=iYBtP{vQZ6hzXbv$f-`la%bA3!7#&~dFjg=R>3aKbCH7hK&bsvF!rqRcF1~A|}?rB1|RNYZz zlj-G~*%jloO*!F4Y)y(WCO`hNSY|7nua5Eh;KEn4awoCY&7}l!TQO~Q%|cbe?^Eq= z2L&)7BsmOcHD`H)--WMT4Y5n0cf6ME&e3?(#xBuv5HV+`ONFo5)}5ALo87C@KxrPb zTeuaDlF?ShuE{Kj|-xZH_iNwLgoe- zo6gOw>Nyxw55djoEI^hZc@qojIpn#sJpckxV`EVZGPsulyms^Z{kwsZ zXH9nV4lLs4_2Ye0B>_;kILl>lGL=e)Wi;ajipv_|QJtmm{b(9}Op>TX^~NB97sVjr zI&TqZam0NSp-W|@-Po)$xS*Z&l2l?j*ipMWjcx)Z0J|t&uj3K^t0I}PLE9T`eDJ-j z53Mso?2D!q#|S-$XmDcwY<`y5w{$TfaF*N5{b;Rj*vTlgA1>oqIRDDoyx%vjisKlv z9ak3yFqKWs99I8lSO6kd)zeH(tEg(GX<#Xs^!O3M;1t)L*6s%IyezNn0EX%LU6Lc( zU`mArOxy0DC|3Ht!}DBE8hLgGBVEN|Ir`mCnE0ATvj(i`u;d}1jf$>AA~D`-L_L%U zF?5~DpGjHlcGk2~=XUCj3in)A;9p+@pZD2z9mYXCna-M2vt5o0HOfJFP6~Qs0w%Y* z{mSM%1kNP{)}FI-2A!Jpr}{02d$COYGX&=fT{_*jh?{1){Sd4du>PP`>Gd3xf1_Td zhxo5?-`^)xU6C_aUNwdi5R8&fg5>+5CDUYaWe27e+Uo3k+s5u5%+793 zX-eBttUS(TgsRnr?Ou)we%*=HqDRV3Ns;v;baTchg9($bzNqKnA`J3|r=ggj+j;auWyU93Z5iYv*ltiHr0l&_pceQ25O#l|e<(nsFOc#Qk}hMY z``zXBZyeNiNEQbzn+LYB^<=NVVPmFHs0)FdC!0Agj~aU^*<9$S^SokhgK7{TDQD_P z?-NX9Z4};n3kL>i<zpN$BaRaTJ| z!fq3w7}ls(4LP)hu|v3_R<6SABsDHis(rp_R%C~}!xrEBKkyyfU6{Ey5mm1+hYs0} ztyx3clS}dV0oTq;Z`KXrwl{&mNwpMwSTU*2zbDHfPEdW|jJF|0NSHap2IwB2bzyY( zhbS0DLj}y1jTyQ!4ZvA(tkUYVFxq-_T5Pin83JAUJ^GxIP32@BuVe(&>om^a?XD?9 zKH;7JDya7M`^&AXm&oXeDWj_z9RHO6n>{}N=&v31SNQk?muLN#f(_6a_R?WG7(c2G+O&NV)5)wQI^ z)-X}LG>7W6+wg<$HP24VJ~6D2EaBI+)o>mNaA|k;JlMjTZAtA_9qfZ{+o%{s%vD6h zA6bzz&9L?QU1I%e=q7+)Fv=NXof{xy|7P;F)?VcGoQ-#m+nowh<>DZeZYnR_g-7a< zye-!fb__nHmvV74>&cCm{$@>oq@LreOZbi+L*zJ=`Ig+2I(P^yHxG}RK~G?*7`^?B zU3}NVhG>ooOE!Oupmm>jaj1lO}t(fFI2KlCC5`XZwIMNkoFZ@%fBzQC>u&nNO-3h{paBs zH>mNKT9BV6xc)%8QL|Wzi-_#;nF)q4#J41uXTqWxft?FpGka;>%I~v&t35BITvO$a zxr8h*Hm{Paq{*pvDsq+URF4H|gx2WU?FIEx9=Io>x{2qeCcgr@S)!}&+W*-1;5+4c zAoe9lS&bvyn~IMwF05R3CE;-w{>=dKtI?(XXreki|15-UVDGC04I0MF!9V>k5%XDJ z)EIHg1~*!zZwAPkdRh1(?lvRSKPISa4b49J=*TnwEQg!WZ}3yG{a_&}^EE-Yxej!e zlgA_wn59TFYevq~^(ZA8|Bu#?%Lvk*It8E)J$K^z#oi{3xU=Ejz$Rr74*w>@R^XkF#J9j3?q}VwF&qD*GWu>v@3UxB~pZ%Ix5dF{O+ZxrAyh0ke|WoP;bENi_JxA zXiW5frpUH#?}!bqqu*EOntFKK|G(c$Vn0tBOkwx_4^x33zDWbq>Y*?De_IUS{D5!~ zzVbxZ*A+QmH`^;l+;QQ2f5r%_2hyFV&SeIXK_up;pIyyimq1(D)@KTHU7J;e#*>Q! z-?jtPsi8-TU8~G=2(DlK3p5TIh|@D1Tj6XK0w!e?%Vy8#2~V*=-g`~yf&K-+=0l1v ziyL-pa{v-cP3HbcKaOCwd4&sCUz+Ue3DS##tefsXv==)gE1~Sr%at;4BCx{n=v3MM zb$~leUzkYYSq;hJR+t%x$5>f26<$G>dAxY&0R!5|36Mskll=RRY~pQgWcl^gRA5W) zE^dzz<__egl&=yYG=bl>KHFhk>{gU{ftk6umf_bq1-ZZy`gb3ox55@lOHG zF2Ho$b4E#5dxNb?S|Gru24s)ALB>se#2-PLkVCW?*T&;WmpG9Q#- zrQz(I$KJyf*hVblDwT1s@35()l5UxkAx75SVhR7ptYp9T$95KMeR=n5@(Om=e!oY`5MIav7Pv)5@!vP>qr}$^~d^L&YUiy z2xkzBMaJ6aXWGfnf@t@39Gr5uzqn4Wq9rj7QIOKoD6OP){vYO|^)9MuMrDY_XXVdp z8d=>}B-$>zB;HCNMAY@SoKn4Jska)|@0crPJkmh%w#;)f)t#v-E_TBt1`EBru8Vi9 zStqe<;)f++yr@tgynd_Za7!(peW=+LetsPHsHIOKhf@ms+pVOWZ91kgYj>OmmJ2*ZF(M=ga<>IS*7%P9S7~lp#k~4dCU*% zcpS<)pkC~7HVI+4{)#*Gf3H*^u?gsAnTbwhIUvr&!~|MGLA}Ladgk z#aI-v(C4;{^h1+6z8DD|bL1(98`~a8e=3UD=v-L4W@euWqF_2&w{&RQ1Ayg*t^s1Md3WIoXLSu#EXCYY4zTJ3qhTE&$u^MI82psL;BD3(HeM#H4)P=W%x5!MN9Q z#2u1I#0gpOG3&;z{^rvbjW@-+FQijV6VV1k^b})^cei*symR>6B_kbtyH)D@l(d~$ zu#b79U5t>EYqDpHlnZH`C&x*>K1q|_AQk&u;W(tOg0U+S-x=UiE#gppa-CShzRqK` zB5efBEVcb-c0Rn~Her^45d&D@c!*Rud`EiuasMg?gr`*FOOOpV92D814gclFSblW+ z=YIwbbDx+r=&LDj)eI3bDYL!-_5_*u?@CW@d1Uci5ohffj?JxezSSQT7wu|1k?-|L z5knI@XF%NbX5s9%+$&V9DXO;kwBV?=!L7e5dX-Z==!oO8H4P!%vamae9Sa#GUrI<4 z3V3WX^A+C_NNHVFebzJ@awRvddK-a>Zv_&SID_)wa*QJcr|7GDzPVi6C8Ve1p8wnq zc>&SDPHBhVorkY!k8R1A+?2hkm9KTyrK+{`?f1Vepd$0e9~qCYf5{d6w=%qD`v~LX zWEQQOhaNo+qt1DZo3)f^{hu>4h{z z`oy%3E)~Voi5(Lec0QE_VE^+HApZi50Y6^B%bM3&#O^WbVuVpWF%Nb-b?(f2~An9(~&O025jDJc_D8NTIEsc~811T39#DTfHH)Hor}d6jXr4RFT{@2_W}uVe3PJvTP+d6tzf zj1BE~Qop_MrqQ9ls^1z@@JF~$vM2H;%oRWG=d8;4YOEdzm7W@|0@*L{q$t0+_v-Kd z$$;?BfYY@S3ags3{Dd!vzf&Me;Q)K8$#^&7vkOSBDm7#PF^p(Pv-D5(97^tn|Jj+% z7#KZ_>w!4{ajeAVS5w=@T@NZ@9d2J{1z>)aadK(~(6=k(2x#~RoP(!#O6nm*KbU@Z z>#pgqft6I+(aMpq*sFU7`_z0Bk?tXsiTeT*<(X^v6GC^4L_XeG?kwu6pDr3OF^JJP zxoB(c6(E1>JVS4b0^mQUJwqQK0vDgGGuo<)6QZ--Yqa zF;?0tMz31d0On!x)^%wRZk0R*IbZ)F^Rzq1fUTIEZvbgt6N6tnKb(RV!UhYZ?RBS< zW6jl#U-L77jlUon4MiF(^&k4hR;dV2WJ9g=m=9PCwr)$GZDW8c-OCMxI~y$J;4u+~ zyb~(4NTQpwE_S~Rr=fwBc`N8I`bPYat!=AshWqqu5JT~dr@hd+xi{W*Ura6jB%Tu3EPhLVqr$*v-hlS7vX3)V}hjjrVlw2jgBbOMb9N7V6== z`MGE=(xB(o$rK{^;MpSYBy%K`apeWr(+Omn)t?FRZ_1JKk%?=o<+q=^XFcx8&rO@; zn1(zlzK4~7+NnBAy2kp*7l+eEmxgMNfD>nHHwKvAF(8m&YS)dS&kiWVE8U!t#B*$w z>@$9;cg|}=e)!lseLl`e$H9J!kv|pG@HG$Ui-#B%G=Svy4w*JOBo(8-;5le|f$V+f z%8reYDw~Z;FQ*rF!XNxT3&u8;BMtg2Ja~j8DDlIwAJhfDam7+%cNxq>9BC~=VTUVI z2j_&zrioL$Ll&`9%C0fBL;`KR;>wdVw}aO^M0)nA&1Q4AEPl_5Ho%bmylzOy9m=j@ zIaIYrfbJ`X5|I`%smo6R*gu=<*u}ny^8zx7@a*ws!jXcdA{#GvGT$V|AA&8mSjCDK zx$)i`?kvyW=qfI81rL1YQW{mzWG$QCI? zm2tM^=D`?2h@0^$0Gkqoo+)gxwka4e1rEesS(3b`d8JYMK{iYqL=2`lgNy*5lv}46 zIFflP4iB97G~BlUo)=OXAzPR#*EA)}PzSZe!qjyDxfgeIx|0$y4RQ#KE^Md5|AKF} zpuI_9yMhu{-dmh7 z>`NKlYf>ktZ?8MTy>{ap!eD{M20xitFf*5=uVbjO@#bAy^j>xgxtwBSZgpJ#b$l4F)a2b{zuqr+8|LL5nsH8NkR>E z91+%mQMGU3f+I^T#SzzNM;On5{!JROlT3vc~k;m$3Y>L9_6Tman02!TB_zFwOuVzWRW@Uev&>GCU;^wfL zJ#d&L)%iT^l-lCUz&}{WEW=0Oj_SlfGrOwmJinCgIs>oe^bzqqitTx zc(~<m9L0N_EYCXggO@3=ZVp}KHub6nGMAwtn;CLHQFzg?(!B4qNaXS#UJ6CCxyXKR zIG^bEbv<5UkvBa}i8%wzRAbK)i!cvgYHo{6s30PM9DmG2oH@?pEW0rIoO1Cu83}ksj5ts*7x!KiGerfjj5TM!f1FKYs~m`tdcS7r=WmOgIHFVr|m|;$vxe zK_P?ch={+Jka}GIjNGy-!Y;#ZsMPy;Zhv;FEvCj!BIcWjGH8}*5!Ovx@PrNTGkp-7 z)6p^8FKU76sFfm@GLrv4?VaUYlwI5QF9RtNkOpBy6o(!{P*OxdO1h*RX=#uyg#nZr zQ94Cn=#XxtaX`8|q`Q0OUE_7X_x8Mh!29j-1Do40%$&K_I*()Df4jlAh~e0`Mc!^+ zoQeBsjf-2Ap!85yME{P&+xOa)(BOv8ft3On@e}ct{$2Q?L;BMv$GituvMVzdUnNE| zSiVpYZu+GBYHwjd^C${i^bS_m=X9`P=J!*WaP57y;KwtWpLEZa%cs|euCPFbnV<~A zJwqQqxdy+^KmL0nJzZ0FL(K)?!$?0d$aZSP)vId&rgS#^1g_`ttn7Hu^Q4KUz9{Tg z0{Zz~){fiv2#dz)(>RB}SzoM&2x1Hu6Z@ zyPJ&TmQLZy*;_1-(--S^QuX7K*XzYx2U_$Qluk$6Z`BRj`m?$PH;l76yhVPCF)~O! z`6Lw=nE;c)&r=^%eg2}H4)G{(t)P~}96qQjANVLTQp}V^++Ew1j-hiKMuPZC%l1)Bo=)LkMb`|5R6Ez6<^owc}tXA{m-u35n2yFsuFDQK{~PXOT%#C zwJa@G6~nIA?wXggHo2BkvJR{%;+V5$Y?LTrE7?#mAe_kdx5U%udO;0b@u)yY6X=6cT!&4lJ zC0!UzI?{`cV2t~6<(aI+!iKjF;a&0T&ReN_+L-fTgcWH`Pu2-BmDGj!PfFIg45?l6 z@EUufkOSjswV6lJ2BO28d7dA5E*HgdYfC z=D(AH`wN5QXJfA zW!R*fZaZ>_SvHncp8Gw3Yfm)U%P#7QmHS*3#ONK~?B$%h!(lx5yq7n*tIb9VpQ>|*M?T~7; zb-DLOLI;CtlIy9XlF3VdNJ5llhgXA+Db{G~k2E*EXK4B+IQd+|@DifeDJ!OMs-vq> zrQ|2t*3#1T`{}vLjQGr_p~e##?)$|3uil2z34K%LUNcq|(q6uZt|9dcOmXP;E>eY1 z`9k0X_vUx6?7~eD+433BcAE`e`JY}9nY*JY>cjC8e(obh(7anu4$YU#y202zrt39R z@v!S?=6r36ZLZh3$`fD7^6G~nf(~4nrTodKz92O%0_)J7sAww|s*M{$FL?9AngmY5 z*S+bZf-qu0cxophroLZ~IV==%MKiJ#KG4}S+I^yR=dKBZH?LZ1=8T50MP>_}KAHT= zz!a1q^e88#AsFc=t;&CP-^Rg$fz1=~ZqYJQ){R9GWk|jjmPn4qCx7^$Z%|-Plw#c& z`gBrXK~FE2F<)>f3(xfF*v~9VEIK+Vf>u6M^`6K8okK*XAH=4tlI>+vlxq3-c5ux$ zH_5Rit3)2pW=umLoqgfsKQm?a=s{K8qx~ z2>zh%{J7TGElj*FTx)*awr&zdM~=qfy~+!oH+M`GyuEHVcQ8)@wQ{-*=OQR{JI%}+ zT)KZw^^ZDLIrD&*M3SWQ8aG^^a$MM@8NrHk(RoNHqP(0Jn9lJrl z9m5?CBzi)i6xW%sp^taIkADAi21z>nStAI!e07!98NCyi_!Sx_5pRpzFe{zJD68B#LzB$u-Wd{6CgTzczAnT<9LdLWg&IqP z`sF}TAS0e`cNvk!W{a>rjbVk4W`!^|KtJ_=?^RI?Eu~fZ`^3JNXHD1iq;ax3r@BIX zYalD=@dlH2n((~feBFA57+ZmP@RlbdNIg6jI9?q?FBXF3}u{(e!!%y|g)K$uc5ivYzRQQ|gwk&xE> z?V{l}N};BVLwbaEPsprAi{u@|OWW(hyQ=z?HA~$}ZZ1up)KtlLU${|a7RkUwrP3sm zPqRqWo@UcW;iC|5K1#*+_a*c+oD5MNfrPUD49g2E?H~2uj7GwTyU7Xwyzp2E$kQY7 zp7AjcHF-6a;O+M3vKem4RimQl2pxU*6eBds_vGfBc>0Ud61+G#(hSPus8M@!P^{;6 zoom89i$9H*d+J+@F+X(wc_2x@_X=}|@Tff2jHjnRLqpXo-=CN7T?@Hv>4{>Hlk#2$ zrt%^BgXb5BNLk#HMP0e09#^#-Bo9ER2nW$5l z4~%Lc5m5YfM=@<{jFm)&&+5*VLUmN|s2m8+7q~Iv3w!@q250&jLbxrfwF(7>+acHl)W!ih(k)~yweYdN zLeEFMj6B3ywXE!6r)tt4Zcg={pAnu@5D^FML}$>}^KQ{LZC6g&>#Reo-?=!NYU$}d zS4F3JX}A+8)u812XF};!>IPgJ@a-A zA9j*KF>TSUW^M-=!ZO*}t7U#)?NZG&;c*px}g%-d^mL{hV+C+nay! zi%l}6<}o6_@`RjJWVhJge%{4k%brtxjzhv*T_aKRhBpv}*S=e0L5I&(>~$2{FSbFj z883Dwj*Wa;mE!(r-U9AMZ0XDydkC5Bz&j}jDB%-)VX zfwwS=p9=c57NGOz^90TuNY#QviXkq_Wc6!{_vQO?zWdHNZ*MFSFY@PvQZs1M$nbtW z4=&PJUKIV+TVy2t7)dY8op0o5pc% z`|5(b+wz(>XgRzH4*wZ-nYR@3Us$K_1d4Uk_bd&JZl! zxft3XBiLH&hGCOSgolD=Zm%J-?K4Dgo?g}x4_o#xqHdgj*_f4!mZ?r*h;k8Pe@ z!<=uK&K#@H=_7*+A%Q855E?VGt&1qSrH1WWJ}MY9M^~{`vB5*=*;eyKNRUBX<3X=- zZqxpN1kZ_7)#2*IP?d3IC3E{4;oUqJX=Sg|=`knLy zTt0!sByWu0!%joz&Nx}8LM`M53%jj)PrCFGOnxD;_>IO`wT90xj*I4Zyte(k?A!)$ zHiM?<+Ide+_!7k_9qN62xOJqS$XJkm21&x73HLUwnjTw|_TSZ(dNyXDjPhtu*I8Ri zMJy5SFlYR8#eH}fF}5HzC(3Wb8TsIxsM8i!U+naI`bmus6SN?0@23y#<;6$kJ5=TpVh8)0?ymBKH@|Sl#?qmLe?TG{g&yh-a~UhG`jo$&e<=dOMJF!h zg81IyNcBe7ai~zcxefZ&sfeB$PzKE3k0GD7jhdfDesAuUk@TTs7ULVR0o0PM{S>TM zh;coy-}6FRlPFu2r!Pv>5edjoy7Fzr3yV9?K+j0$!lIB+$CSXyd#+;K$=Cbr+TvZ{GH&UdZ=wd3jW1h+FGpm0{T0|JOC1Eh1#+AHSHyx$z03o)-5h4r^T8& z88p?Y(iXeb5$}yC54g`H-}^HbdDEo#dqJxwpvm$eX9!@&K3*9ezdUDrvSH?jil(T` z))r2xg$G)80O!TYNT7}2sykL>6Qg|qJHiu#GoC(}< z1+}&pOa_4g87i~rP1$^*;M#v4cfW3Ii7;*NQHP>w<-ME466`NeX*Goq*=I^u=8z5r ziHx~j?X9Yhmyy1FpVLmph8$o%BbSfmUG^|x9L-el(T;8}UaYa|-+to$&AD7e%Niq3 zV~9Z*QRFJIbpe~$1C=P)lNYTcGzT!ZDRY$QO)0NM@fGt(7`UTi*?RZ`Qa-_Vf9109 z4_t;Sq(FMwoi-&Bf*X47kEEf=7WR094?De5Hh++y(8j1PYl7Q%ps z@KduNshZ%q=5pznU-|ZWJAqo2$kE6@l3vL@=y5vR`u|Y0rIn0&IhcPS_(wd_tD@%G z4mQ!>u1mHTbF^qXq@{F2+ZN%J-VF$^_Gexhy{TJxd!nB_B{qd2uB7~`?)gp*M++RT zW;;Fv$NnytP8~uYUe!j;G%h#$z!KMso$hpLH-=rlK5@vi(A7E_8z$Mw6jkJ%08Q{1 zWWlKS?*smI%NBTyNdlRMcahb^EPV`I<6`*e1o<*x2AEX1`H9=aRLT{T{OuLOb{{a} z98EGdvj z?*3S{vLh)!GX~AC?k5WFzUqRas7&#_-^xaF*(V%|SaIT!=DpVKyHS~N+h(1<;=G+b z7VD|@%IYf)#GNTz>rub{GLDhlde419chxG5Q|29@0~?jWCUFY3^0rJDgXSWy;#|J+ zz7JlS7cvgkL@JA2g<)5%&3WAfdz@^IIOVGv6U7 zP(SHII>CHy?juz(Fxr_cSjJ>lW?Da8`gIpL42^wV-8^6D)J4gZRzO_y!{$fp((fsh z{3GuT0KT>gCNX}?0DUxm)u)Q#w}WjC%9F!15aRF=`MnishqU_)+q)}z?6{wFJ37gC zdo+CfrFB0|yO*($;K1J5z;2N|kUrtAX&t(oM2OcT6%bdkZV1}87ee6cT>;#b;{Hcz z7pdD?%ibb4lY54|%a389aQN9sbN9Imt+SW~vff}Oe*^q~$(-`h8`aP~3EGECucG~Z zWCE_>h1+ivpaYbmPlVzZ;%`6W{noM5ZZJ(N{~7X8?Rv{XJa+9qIkIR2k-viuAV� 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

    AW#I@si=VcHwFpC#;7RT`9 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

    6WVTvRMQcW+tGd)we9IeYO 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 literal 0 HcmV?d00001