diff --git a/.coveralls.yml b/.coveralls.yml index 91a8273c..77b56740 100644 --- a/.coveralls.yml +++ b/.coveralls.yml @@ -1,2 +1 @@ -service_name: travis-pro -repo_token: 1OI4obkPMbvZy6i3ADYYPgxFulDJGOIU7 +repo_token: 1OI4obkPMbvZy6i3ADYYPgxFulDJGOIU7 \ No newline at end of file diff --git a/.project b/.project deleted file mode 100644 index 8f8a283e..00000000 --- a/.project +++ /dev/null @@ -1,17 +0,0 @@ - - - DragonPy - - - - - - org.python.pydev.PyDevBuilder - - - - - - org.python.pydev.pythonNature - - diff --git a/.pydevproject b/.pydevproject deleted file mode 100644 index f7587e92..00000000 --- a/.pydevproject +++ /dev/null @@ -1,8 +0,0 @@ - - -Default -python 3.0 - -/DragonPy - - diff --git a/.travis.yml b/.travis.yml index 9a8087b0..ffeacd9f 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,18 +1,28 @@ +# Config file for automatic testing at travis-ci.org + language: python + python: - - "2.7" - - "3.4" - - "pypy" + - "2.7" + - "3.4" + - "pypy" + install: - - pip install dragonlib -# - pip install coveralls + - "pip install ." + - "pip install coveralls" + - ./download_ROMs.sh + script: - # "python setup.py test" will not run the tests from dragonlib - - python -m unittest discover -# coverage run --source=dragonpy setup.py test -#after_success: -# coveralls + # - python -m unittest discover + - coverage run --source=dragonpy ./setup.py test + +after_success: + coveralls + branches: - only: - - master - - stable + only: + - master + - stable + +notifications: + irc: "irc.freenode.org#pylucid" diff --git a/DragonPy_CLI.py b/DragonPy_CLI.py index 676759e0..5eeea6f1 100755 --- a/DragonPy_CLI.py +++ b/DragonPy_CLI.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python # coding: utf-8 """ @@ -6,15 +6,26 @@ ~~~~~~~~~~~~~~ :created: 2013 by Jens Diemer - www.jensdiemer.de - :copyleft: 2013-2014 by the DragonPy team, see AUTHORS for more details. + :copyleft: 2013-2015 by the DragonPy team, see AUTHORS for more details. :license: GNU GPL v3 or above, see LICENSE for more details. """ from __future__ import absolute_import, division, print_function - -from dragonpy.DragonPy_CLI import get_cli +import sys if __name__ == "__main__": - cli = get_cli() - cli.run() + if not hasattr(sys, 'real_prefix'): + print() + print("="*79) + print("ERROR: virtual environment is not activated ?!?") + print("\ne.g.:") + print("\t~ $ cd ~/DragonPy_env/") + print("\t~/DragonPy_env $ source bin/activate") + print("\t~/DragonPy_env $ cd src/dragonpy") + print("\t~/DragonPy_env/src/dragonpy $ %s" % " ".join(sys.argv)) + print("-"*79) + print() + + from dragonpy.core.cli import cli + cli() diff --git a/README.creole b/README.creole index fb142989..3ce9f28c 100644 --- a/README.creole +++ b/README.creole @@ -2,6 +2,13 @@ DragonPy is a Open source (GPL v3 or later) emulator for the 30 years old homecomputer {{{Dragon 32}}} and {{{Tandy TRS-80 Color Computer}}} (CoCo)... +The [[https://github.com/6809/MC6809|MC6809]] project is used to emulate the 6809 CPU. + +| {{https://travis-ci.org/jedie/DragonPy.svg|Build Status on travis-ci.org}} | [[https://travis-ci.org/jedie/DragonPy/|travis-ci.org/jedie/DragonPy]] | +| {{https://coveralls.io/repos/jedie/DragonPy/badge.svg|Coverage Status on coveralls.io}} | [[https://coveralls.io/r/jedie/DragonPy|coveralls.io/r/jedie/DragonPy]] | +| {{https://requires.io/github/jedie/DragonPy/requirements.svg?branch=django-cms|Requirements Status on requires.io}} | [[https://requires.io/github/jedie/DragonPy/requirements/|requires.io/github/jedie/DragonPy/requirements/]] | + + Dragon 32 and 64 ROMs in Text mode: {{http://www.jensdiemer.de/static/jensdiemer.de/screenshots/20140805_DragonPy_Dragon64_01.png|screenshot Dragon 64}} @@ -43,7 +50,7 @@ The Hardware are //only// the 6809 CPU, a 6522 Versatile Interface Adapter and t Current state is completely not usable. The 6522 is only a dummy implementation. It makes only sense to display some trace lines, e.g.: {{{ -...path/to/DragonPy$ python2 DragonPy_CLI.py --verbosity 5 --machine=Vectrex run --trace --max_ops 1 +(DragonPy_env)~/DragonPy_env$ bin/python src/dragonpy/DragonPy_CLI.py --verbosity 5 --machine=Vectrex run --trace --max_ops 1 }}} @@ -60,7 +67,7 @@ The "renumbering" tool can be found in the editor window under "tools" You can also run the BASIC Editor without the Emulator: {{{ -...path/to/DragonPy$ python2 DragonPy_CLI.py editor +(DragonPy_env)~/DragonPy_env$ bin/python src/dragonpy/DragonPy_CLI.py editor }}} A rudimentary BASIC source code highlighting is available and looks like this: @@ -69,27 +76,56 @@ A rudimentary BASIC source code highlighting is available and looks like this: Special feature: The Line number that are used in GOTO, SOGUB etc. are extra marked on the left side. -Currently the code are only differate into: -* DATA -* Strings -* Comments -* Code -TODO: parse the code, to coloring it differently. +== installation -=== ROMs +=== Linux -The Dragon ROMs can be downloaded here: -* http://archive.worldofdragon.org/archive/index.php?dir=Roms/Dragon/ +The is a virtualenv bootstrap file, created with [[https://github.com/jedie/bootstrap_env|bootstrap_env]], for easy installation. -There is a simple shell script to automatic download and extract the Dragon ROMs: +Get the bootstrap file: +{{{ +/home/FooBar$ wget https://raw.githubusercontent.com/jedie/DragonPy/master/boot_dragonpy.py +}}} + + +There are tree types of installation: +|=option |= desciption +| **pypi** | use [[http://www.python.org/pypi/|Python Package Index]] (for all normal user!) +| **git_readonly** | use {{{git}}} to get the sourcecode (for developer without write access) +| **dev** | use {{{git}}} with write access + +e.g.: {{{ -...path/to/DragonPy$ ./download_ROMs.sh +/home/FooBar$ python3 boot_dragonpy.py ~/DragonPy_env --install_type git_readonly }}} +This creates a virtualenv in **{{{~/DragonPy_env}}}** and used {{{git}}} to checkout the needed repositories. + +In this case (using --install_type=**git_readonly**) the git repository are in: **.../DragonPy_env/src/** +So you can easy update them e.g.: +{{{ +/home/FooBar$ cd ~/DragonPy_env/src/dragonpy +/home/FooBar/DragonPy_env/src/dragonpy$ git pull +}}} + +=== Windows -=== Quick start: +There are several ways to install the project under windows. -**TODO:** External {{{dragonlib}}} dependency is needed: https://github.com/6809/dragonlib +The following is hopeful the easiest one: + +* Install Python 3, e.g.: https://www.python.org/downloads/ +* Download the {{{DWLOAD Server}}} git snapshot from Github: [[https://github.com/jedie/DragonPy/archive/master.zip|master.zip]] +* Extract the Archive somewhere +* Maybe, adjust paths in {{{boot_dwload_server.cmd}}} +* Run {{{boot_dwload_server.cmd}}} + +The default {{{boot_dwload_server.cmd}}} will install via {{{Python Package Index}}} (PyPi) into {{{%APPDATA%\DragonPy_env}}} + +There exist a batch file for easy startup the server under Windows: +* [[https://github.com/jedie/DragonPy/blob/master/scripts/start_dwload_server.cmd|/scripts/start_dwload_server.cmd]] + +Copy it into {{{%APPDATA%\DragonPy_env\start_dwload_server.cmd}}} and edit it for your needs. {{{ # clone the repro: @@ -106,51 +142,79 @@ There is a simple shell script to automatic download and extract the Dragon ROMs ~/DragonPy$ python2 DragonPy_CLI.py --machine=Dragon32 run }}} -== example + +== ROMs + +The Dragon ROMs can be downloaded here: +* http://archive.worldofdragon.org/archive/index.php?dir=Roms/Dragon/ + +There is a simple shell script to automatic download and extract the Dragon ROMs: +{{{ +/home/FooBar/DragonPy_env$ cd src/dragonpy/ +/home/FooBar/DragonPy_env/src/dragonpy$ ./download_ROMs.sh +}}} +To verify existing ROMs, just call the script again: +{{{ +/home/FooBar/DragonPy_env$ cd src/dragonpy/ +/home/FooBar/DragonPy_env/src/dragonpy$ ./download_ROMs.sh ++ cd dragonpy/Dragon32/ ++ source download_Dragon32_rom.sh +++ '[' '!' -f d32.rom ']' +++ set -x +++ sha1sum -c d32.rom.sha1 +d32.rom: OK +======================================================================== +... +d64_ic17.rom: OK +d64_ic18.rom: OK +bas13.rom: OK +extbas11.rom: OK +EXT_BASIC_NO_USING.bin: OK +ExBasROM.bin: OK +}}} + + +== cli example start Dragon 32: {{{ -...path/to/DragonPy$ python2 DragonPy_CLI.py --machine=Dragon32 run +/home/FooBar$ cd DragonPy_env +/home/FooBar/DragonPy_env$ source bin/activate +(DragonPy_env)~/DragonPy_env$ DragonPy --machine=Dragon32 run }}} start Dragon 64: {{{ -...path/to/DragonPy$ python2 DragonPy_CLI.py --machine=Dragon64 run +(DragonPy_env)~/DragonPy_env$ DragonPy --machine=Dragon64 run }}} start CoCo with Extended Color Basic v1.1: {{{ -...path/to/DragonPy$ python2 DragonPy_CLI.py --machine=CoCo2b run +(DragonPy_env)~/DragonPy_env$ DragonPy --machine=CoCo2b run }}} start Multicomp 6809: {{{ -...path/to/DragonPy$ python2 DragonPy_CLI.py --machine=Multicomp6809 run +(DragonPy_env)~/DragonPy_env$ DragonPy --machine=Multicomp6809 run }}} start Lennart's 6809 single board computer: {{{ -...path/to/DragonPy$ python2 DragonPy_CLI.py --machine=sbc09 run +(DragonPy_env)~/DragonPy_env$ DragonPy --machine=sbc09 run }}} == unittests == -[[https://travis-ci.org/jedie/DragonPy|Travis CI Status]]: {{https://secure.travis-ci.org/jedie/DragonPy.svg?branch=master|DragonPy build status on travis-ci.org}} -* https://travis-ci.org/jedie/DragonPy - === run unittests === You can run tests with PyPy, Python 2 and Python 3: {{{ -...path/to/DragonPy$ python -m unittest discover +(DragonPy_env)~/DragonPy_env/src/dragonpy$ python -m unittest discover }}} - -All variants: +or: {{{ -...path/to/DragonPy$ python2 -m unittest discover -...path/to/DragonPy$ python3 -m unittest discover -...path/to/DragonPy$ pypy -m unittest discover +(DragonPy_env)~/DragonPy_env/src/dragonpy$ ./setup.py test }}} @@ -162,10 +226,10 @@ install [[https://pypi.python.org/pypi/coverage|coverage]] for python 2: }}} {{{ -...path/to/DragonPy$ coverage2 run --source=dragonpy setup.py test -...path/to/DragonPy$ coverage2 coverage2 html +...path/to/env/src/dragonpy$ coverage2 run --source=dragonpy setup.py test +...path/to/env/src/dragonpy$ coverage2 coverage2 html # e.g.: -...path/to/DragonPy$ firefox htmlcov/index.html +...path/to/env/src/dragonpy$ firefox htmlcov/index.html }}} @@ -257,27 +321,10 @@ e.g. The Dragon 32 6809 machine with a 14.31818 MHz crystal runs with: 0,895MHz (14,31818Mhz/16=0,895MHz) in other words: 895.000 CPU-cycles/sec. -There is a simple benchmark. Run e.g.: -{{{ -...path/to/DragonPy$ python2 DragonPy_CLI.py benchmark -...path/to/DragonPy$ python3 DragonPy_CLI.py benchmark -...path/to/DragonPy$ pypy DragonPy_CLI.py benchmark -...path/to/DragonPy$ pypy3 DragonPy_CLI.py benchmark --loops 10 -}}} - - == TODO: -# Use bottle for http control server part # implement more Dragon 32 periphery -unimplemented OPs: - - * RESET - * SWI / SWI2 / SWI3 - * SYNC - - missing 6809 unittests after coverage run: * MUL @@ -395,6 +442,7 @@ Six is a Python 2 and 3 compatibility library. == History +* 26.05.2015 - v0.4.0 - The MC6809 code is out sourced to: https://github.com/6809/MC6809 * 15.12.2014 - v0.3.2 - Use [[http://pygments.org/|Pygments]] syntax highlighter in BASIC editor * 08.10.2014 - Release as v0.3.1 * 30.09.2014 - Enhance the BASIC editor diff --git a/boot_dragonpy.py b/boot_dragonpy.py new file mode 100755 index 00000000..4526e337 --- /dev/null +++ b/boot_dragonpy.py @@ -0,0 +1,20399 @@ +#!/usr/bin/env python + +""" + WARNING: This file is generated with: bootstrap_env v0.4.5 + https://pypi.python.org/pypi/bootstrap_env/ + script file: 'create_bootstrap.py' + used '.../lib/python3.4/site-packages/virtualenv.py' v12.1.1 + Python v3.4.0 (default, Apr 11 2014, 13:05:11) [GCC 4.8.2] +""" + +__version__ = "12.1.1" +virtualenv_version = __version__ # legacy + +import base64 +import sys +import os +import codecs +import optparse +import re +import shutil +import logging +import tempfile +import zlib +import errno +import glob +import distutils.sysconfig +from distutils.util import strtobool +import struct +import subprocess +import tarfile + +if sys.version_info < (2, 6): + print('ERROR: %s' % sys.exc_info()[1]) + print('ERROR: this script requires Python 2.6 or greater.') + sys.exit(101) + +try: + basestring +except NameError: + basestring = str + +try: + import ConfigParser +except ImportError: + import configparser as ConfigParser + +join = os.path.join +py_version = 'python%s.%s' % (sys.version_info[0], sys.version_info[1]) + +is_jython = sys.platform.startswith('java') +is_pypy = hasattr(sys, 'pypy_version_info') +is_win = (sys.platform == 'win32') +is_cygwin = (sys.platform == 'cygwin') +is_darwin = (sys.platform == 'darwin') +abiflags = getattr(sys, 'abiflags', '') + +user_dir = os.path.expanduser('~') +if is_win: + default_storage_dir = os.path.join(user_dir, 'virtualenv') +else: + default_storage_dir = os.path.join(user_dir, '.virtualenv') +default_config_file = os.path.join(default_storage_dir, 'virtualenv.ini') + +if is_pypy: + expected_exe = 'pypy' +elif is_jython: + expected_exe = 'jython' +else: + expected_exe = 'python' + +# Return a mapping of version -> Python executable +# Only provided for Windows, where the information in the registry is used +if not is_win: + def get_installed_pythons(): + return {} +else: + try: + import winreg + except ImportError: + import _winreg as winreg + + def get_installed_pythons(): + try: + python_core = winreg.CreateKey(winreg.HKEY_LOCAL_MACHINE, + "Software\\Python\\PythonCore") + except WindowsError: + # No registered Python installations + return {} + i = 0 + versions = [] + while True: + try: + versions.append(winreg.EnumKey(python_core, i)) + i = i + 1 + except WindowsError: + break + exes = dict() + for ver in versions: + try: + path = winreg.QueryValue(python_core, "%s\\InstallPath" % ver) + except WindowsError: + continue + exes[ver] = join(path, "python.exe") + + winreg.CloseKey(python_core) + + # Add the major versions + # Sort the keys, then repeatedly update the major version entry + # Last executable (i.e., highest version) wins with this approach + for ver in sorted(exes): + exes[ver[0]] = exes[ver] + + return exes + +REQUIRED_MODULES = ['os', 'posix', 'posixpath', 'nt', 'ntpath', 'genericpath', + 'fnmatch', 'locale', 'encodings', 'codecs', + 'stat', 'UserDict', 'readline', 'copy_reg', 'types', + 're', 'sre', 'sre_parse', 'sre_constants', 'sre_compile', + 'zlib'] + +REQUIRED_FILES = ['lib-dynload', 'config'] + +majver, minver = sys.version_info[:2] +if majver == 2: + if minver >= 6: + REQUIRED_MODULES.extend(['warnings', 'linecache', '_abcoll', 'abc']) + if minver >= 7: + REQUIRED_MODULES.extend(['_weakrefset']) +elif majver == 3: + # Some extra modules are needed for Python 3, but different ones + # for different versions. + REQUIRED_MODULES.extend(['_abcoll', 'warnings', 'linecache', 'abc', 'io', + '_weakrefset', 'copyreg', 'tempfile', 'random', + '__future__', 'collections', 'keyword', 'tarfile', + 'shutil', 'struct', 'copy', 'tokenize', 'token', + 'functools', 'heapq', 'bisect', 'weakref', + 'reprlib']) + if minver >= 2: + REQUIRED_FILES[-1] = 'config-%s' % majver + if minver >= 3: + import sysconfig + platdir = sysconfig.get_config_var('PLATDIR') + REQUIRED_FILES.append(platdir) + # The whole list of 3.3 modules is reproduced below - the current + # uncommented ones are required for 3.3 as of now, but more may be + # added as 3.3 development continues. + REQUIRED_MODULES.extend([ + #"aifc", + #"antigravity", + #"argparse", + #"ast", + #"asynchat", + #"asyncore", + "base64", + #"bdb", + #"binhex", + #"bisect", + #"calendar", + #"cgi", + #"cgitb", + #"chunk", + #"cmd", + #"codeop", + #"code", + #"colorsys", + #"_compat_pickle", + #"compileall", + #"concurrent", + #"configparser", + #"contextlib", + #"cProfile", + #"crypt", + #"csv", + #"ctypes", + #"curses", + #"datetime", + #"dbm", + #"decimal", + #"difflib", + #"dis", + #"doctest", + #"dummy_threading", + "_dummy_thread", + #"email", + #"filecmp", + #"fileinput", + #"formatter", + #"fractions", + #"ftplib", + #"functools", + #"getopt", + #"getpass", + #"gettext", + #"glob", + #"gzip", + "hashlib", + #"heapq", + "hmac", + #"html", + #"http", + #"idlelib", + #"imaplib", + #"imghdr", + "imp", + "importlib", + #"inspect", + #"json", + #"lib2to3", + #"logging", + #"macpath", + #"macurl2path", + #"mailbox", + #"mailcap", + #"_markupbase", + #"mimetypes", + #"modulefinder", + #"multiprocessing", + #"netrc", + #"nntplib", + #"nturl2path", + #"numbers", + #"opcode", + #"optparse", + #"os2emxpath", + #"pdb", + #"pickle", + #"pickletools", + #"pipes", + #"pkgutil", + #"platform", + #"plat-linux2", + #"plistlib", + #"poplib", + #"pprint", + #"profile", + #"pstats", + #"pty", + #"pyclbr", + #"py_compile", + #"pydoc_data", + #"pydoc", + #"_pyio", + #"queue", + #"quopri", + #"reprlib", + "rlcompleter", + #"runpy", + #"sched", + #"shelve", + #"shlex", + #"smtpd", + #"smtplib", + #"sndhdr", + #"socket", + #"socketserver", + #"sqlite3", + #"ssl", + #"stringprep", + #"string", + #"_strptime", + #"subprocess", + #"sunau", + #"symbol", + #"symtable", + #"sysconfig", + #"tabnanny", + #"telnetlib", + #"test", + #"textwrap", + #"this", + #"_threading_local", + #"threading", + #"timeit", + #"tkinter", + #"tokenize", + #"token", + #"traceback", + #"trace", + #"tty", + #"turtledemo", + #"turtle", + #"unittest", + #"urllib", + #"uuid", + #"uu", + #"wave", + #"weakref", + #"webbrowser", + #"wsgiref", + #"xdrlib", + #"xml", + #"xmlrpc", + #"zipfile", + ]) + if minver >= 4: + REQUIRED_MODULES.extend([ + 'operator', + '_collections_abc', + '_bootlocale', + ]) + +if is_pypy: + # these are needed to correctly display the exceptions that may happen + # during the bootstrap + REQUIRED_MODULES.extend(['traceback', 'linecache']) + +class Logger(object): + + """ + Logging object for use in command-line script. Allows ranges of + levels, to avoid some redundancy of displayed information. + """ + + DEBUG = logging.DEBUG + INFO = logging.INFO + NOTIFY = (logging.INFO+logging.WARN)/2 + WARN = WARNING = logging.WARN + ERROR = logging.ERROR + FATAL = logging.FATAL + + LEVELS = [DEBUG, INFO, NOTIFY, WARN, ERROR, FATAL] + + def __init__(self, consumers): + self.consumers = consumers + self.indent = 0 + self.in_progress = None + self.in_progress_hanging = False + + def debug(self, msg, *args, **kw): + self.log(self.DEBUG, msg, *args, **kw) + def info(self, msg, *args, **kw): + self.log(self.INFO, msg, *args, **kw) + def notify(self, msg, *args, **kw): + self.log(self.NOTIFY, msg, *args, **kw) + def warn(self, msg, *args, **kw): + self.log(self.WARN, msg, *args, **kw) + def error(self, msg, *args, **kw): + self.log(self.ERROR, msg, *args, **kw) + def fatal(self, msg, *args, **kw): + self.log(self.FATAL, msg, *args, **kw) + def log(self, level, msg, *args, **kw): + if args: + if kw: + raise TypeError( + "You may give positional or keyword arguments, not both") + args = args or kw + rendered = None + for consumer_level, consumer in self.consumers: + if self.level_matches(level, consumer_level): + if (self.in_progress_hanging + and consumer in (sys.stdout, sys.stderr)): + self.in_progress_hanging = False + sys.stdout.write('\n') + sys.stdout.flush() + if rendered is None: + if args: + rendered = msg % args + else: + rendered = msg + rendered = ' '*self.indent + rendered + if hasattr(consumer, 'write'): + consumer.write(rendered+'\n') + else: + consumer(rendered) + + def start_progress(self, msg): + assert not self.in_progress, ( + "Tried to start_progress(%r) while in_progress %r" + % (msg, self.in_progress)) + if self.level_matches(self.NOTIFY, self._stdout_level()): + sys.stdout.write(msg) + sys.stdout.flush() + self.in_progress_hanging = True + else: + self.in_progress_hanging = False + self.in_progress = msg + + def end_progress(self, msg='done.'): + assert self.in_progress, ( + "Tried to end_progress without start_progress") + if self.stdout_level_matches(self.NOTIFY): + if not self.in_progress_hanging: + # Some message has been printed out since start_progress + sys.stdout.write('...' + self.in_progress + msg + '\n') + sys.stdout.flush() + else: + sys.stdout.write(msg + '\n') + sys.stdout.flush() + self.in_progress = None + self.in_progress_hanging = False + + def show_progress(self): + """If we are in a progress scope, and no log messages have been + shown, write out another '.'""" + if self.in_progress_hanging: + sys.stdout.write('.') + sys.stdout.flush() + + def stdout_level_matches(self, level): + """Returns true if a message at this level will go to stdout""" + return self.level_matches(level, self._stdout_level()) + + def _stdout_level(self): + """Returns the level that stdout runs at""" + for level, consumer in self.consumers: + if consumer is sys.stdout: + return level + return self.FATAL + + def level_matches(self, level, consumer_level): + """ + >>> l = Logger([]) + >>> l.level_matches(3, 4) + False + >>> l.level_matches(3, 2) + True + >>> l.level_matches(slice(None, 3), 3) + False + >>> l.level_matches(slice(None, 3), 2) + True + >>> l.level_matches(slice(1, 3), 1) + True + >>> l.level_matches(slice(2, 3), 1) + False + """ + if isinstance(level, slice): + start, stop = level.start, level.stop + if start is not None and start > consumer_level: + return False + if stop is not None and stop <= consumer_level: + return False + return True + else: + return level >= consumer_level + + #@classmethod + def level_for_integer(cls, level): + levels = cls.LEVELS + if level < 0: + return levels[0] + if level >= len(levels): + return levels[-1] + return levels[level] + + level_for_integer = classmethod(level_for_integer) + +# create a silent logger just to prevent this from being undefined +# will be overridden with requested verbosity main() is called. +logger = Logger([(Logger.LEVELS[-1], sys.stdout)]) + +def mkdir(path): + if not os.path.exists(path): + logger.info('Creating %s', path) + os.makedirs(path) + else: + logger.info('Directory %s already exists', path) + +def copyfileordir(src, dest, symlink=True): + if os.path.isdir(src): + shutil.copytree(src, dest, symlink) + else: + shutil.copy2(src, dest) + +def copyfile(src, dest, symlink=True): + if not os.path.exists(src): + # Some bad symlink in the src + logger.warn('Cannot find file %s (bad symlink)', src) + return + if os.path.exists(dest): + logger.debug('File %s already exists', dest) + return + if not os.path.exists(os.path.dirname(dest)): + logger.info('Creating parent directories for %s', os.path.dirname(dest)) + os.makedirs(os.path.dirname(dest)) + if not os.path.islink(src): + srcpath = os.path.abspath(src) + else: + srcpath = os.readlink(src) + if symlink and hasattr(os, 'symlink') and not is_win: + logger.info('Symlinking %s', dest) + try: + os.symlink(srcpath, dest) + except (OSError, NotImplementedError): + logger.info('Symlinking failed, copying to %s', dest) + copyfileordir(src, dest, symlink) + else: + logger.info('Copying to %s', dest) + copyfileordir(src, dest, symlink) + +def writefile(dest, content, overwrite=True): + if not os.path.exists(dest): + logger.info('Writing %s', dest) + f = open(dest, 'wb') + f.write(content.encode('utf-8')) + f.close() + return + else: + f = open(dest, 'rb') + c = f.read() + f.close() + if c != content.encode("utf-8"): + if not overwrite: + logger.notify('File %s exists with different content; not overwriting', dest) + return + logger.notify('Overwriting %s with new content', dest) + f = open(dest, 'wb') + f.write(content.encode('utf-8')) + f.close() + else: + logger.info('Content %s already in place', dest) + +def rmtree(dir): + if os.path.exists(dir): + logger.notify('Deleting tree %s', dir) + shutil.rmtree(dir) + else: + logger.info('Do not need to delete %s; already gone', dir) + +def make_exe(fn): + if hasattr(os, 'chmod'): + oldmode = os.stat(fn).st_mode & 0xFFF # 0o7777 + newmode = (oldmode | 0x16D) & 0xFFF # 0o555, 0o7777 + os.chmod(fn, newmode) + logger.info('Changed mode of %s to %s', fn, oct(newmode)) + +def _find_file(filename, dirs): + for dir in reversed(dirs): + files = glob.glob(os.path.join(dir, filename)) + if files and os.path.isfile(files[0]): + return True, files[0] + return False, filename + +def file_search_dirs(): + here = os.path.dirname(os.path.abspath(__file__)) + dirs = ['.', here, + join(here, 'virtualenv_support')] + if os.path.splitext(os.path.dirname(__file__))[0] != 'virtualenv': + # Probably some boot script; just in case virtualenv is installed... + try: + import virtualenv + except ImportError: + pass + else: + dirs.append(os.path.join(os.path.dirname(virtualenv.__file__), 'virtualenv_support')) + return [d for d in dirs if os.path.isdir(d)] + + +class UpdatingDefaultsHelpFormatter(optparse.IndentedHelpFormatter): + """ + Custom help formatter for use in ConfigOptionParser that updates + the defaults before expanding them, allowing them to show up correctly + in the help listing + """ + def expand_default(self, option): + if self.parser is not None: + self.parser.update_defaults(self.parser.defaults) + return optparse.IndentedHelpFormatter.expand_default(self, option) + + +class ConfigOptionParser(optparse.OptionParser): + """ + Custom option parser which updates its defaults by checking the + configuration files and environmental variables + """ + def __init__(self, *args, **kwargs): + self.config = ConfigParser.RawConfigParser() + self.files = self.get_config_files() + self.config.read(self.files) + optparse.OptionParser.__init__(self, *args, **kwargs) + + def get_config_files(self): + config_file = os.environ.get('VIRTUALENV_CONFIG_FILE', False) + if config_file and os.path.exists(config_file): + return [config_file] + return [default_config_file] + + def update_defaults(self, defaults): + """ + Updates the given defaults with values from the config files and + the environ. Does a little special handling for certain types of + options (lists). + """ + # Then go and look for the other sources of configuration: + config = {} + # 1. config files + config.update(dict(self.get_config_section('virtualenv'))) + # 2. environmental variables + config.update(dict(self.get_environ_vars())) + # Then set the options with those values + for key, val in config.items(): + key = key.replace('_', '-') + if not key.startswith('--'): + key = '--%s' % key # only prefer long opts + option = self.get_option(key) + if option is not None: + # ignore empty values + if not val: + continue + # handle multiline configs + if option.action == 'append': + val = val.split() + else: + option.nargs = 1 + if option.action == 'store_false': + val = not strtobool(val) + elif option.action in ('store_true', 'count'): + val = strtobool(val) + try: + val = option.convert_value(key, val) + except optparse.OptionValueError: + e = sys.exc_info()[1] + print("An error occurred during configuration: %s" % e) + sys.exit(3) + defaults[option.dest] = val + return defaults + + def get_config_section(self, name): + """ + Get a section of a configuration + """ + if self.config.has_section(name): + return self.config.items(name) + return [] + + def get_environ_vars(self, prefix='VIRTUALENV_'): + """ + Returns a generator with all environmental vars with prefix VIRTUALENV + """ + for key, val in os.environ.items(): + if key.startswith(prefix): + yield (key.replace(prefix, '').lower(), val) + + def get_default_values(self): + """ + Overridding to make updating the defaults after instantiation of + the option parser possible, update_defaults() does the dirty work. + """ + if not self.process_default_values: + # Old, pre-Optik 1.5 behaviour. + return optparse.Values(self.defaults) + + defaults = self.update_defaults(self.defaults.copy()) # ours + for option in self._get_all_options(): + default = defaults.get(option.dest) + if isinstance(default, basestring): + opt_str = option.get_opt_string() + defaults[option.dest] = option.check_value(opt_str, default) + return optparse.Values(defaults) + + +def main(): + parser = ConfigOptionParser( + version=virtualenv_version, + usage="%prog [OPTIONS] DEST_DIR", + formatter=UpdatingDefaultsHelpFormatter()) + + parser.add_option( + '-v', '--verbose', + action='count', + dest='verbose', + default=0, + help="Increase verbosity.") + + parser.add_option( + '-q', '--quiet', + action='count', + dest='quiet', + default=0, + help='Decrease verbosity.') + + parser.add_option( + '-p', '--python', + dest='python', + metavar='PYTHON_EXE', + help='The Python interpreter to use, e.g., --python=python2.5 will use the python2.5 ' + 'interpreter to create the new environment. The default is the interpreter that ' + 'virtualenv was installed with (%s)' % sys.executable) + + parser.add_option( + '--clear', + dest='clear', + action='store_true', + help="Clear out the non-root install and start from scratch.") + + parser.set_defaults(system_site_packages=False) + parser.add_option( + '--no-site-packages', + dest='system_site_packages', + action='store_false', + help="DEPRECATED. Retained only for backward compatibility. " + "Not having access to global site-packages is now the default behavior.") + + parser.add_option( + '--system-site-packages', + dest='system_site_packages', + action='store_true', + help="Give the virtual environment access to the global site-packages.") + + parser.add_option( + '--always-copy', + dest='symlink', + action='store_false', + default=True, + help="Always copy files rather than symlinking.") + + parser.add_option( + '--unzip-setuptools', + dest='unzip_setuptools', + action='store_true', + help="Unzip Setuptools when installing it.") + + parser.add_option( + '--relocatable', + dest='relocatable', + action='store_true', + help='Make an EXISTING virtualenv environment relocatable. ' + 'This fixes up scripts and makes all .pth files relative.') + + parser.add_option( + '--no-setuptools', + dest='no_setuptools', + action='store_true', + help='Do not install setuptools (or pip) in the new virtualenv.') + + parser.add_option( + '--no-pip', + dest='no_pip', + action='store_true', + help='Do not install pip in the new virtualenv.') + + default_search_dirs = file_search_dirs() + parser.add_option( + '--extra-search-dir', + dest="search_dirs", + action="append", + metavar='DIR', + default=default_search_dirs, + help="Directory to look for setuptools/pip distributions in. " + "This option can be used multiple times.") + + parser.add_option( + '--never-download', + dest="never_download", + action="store_true", + default=True, + help="DEPRECATED. Retained only for backward compatibility. This option has no effect. " + "Virtualenv never downloads pip or setuptools.") + + parser.add_option( + '--prompt', + dest='prompt', + help='Provides an alternative prompt prefix for this environment.') + + parser.add_option( + '--setuptools', + dest='setuptools', + action='store_true', + help="DEPRECATED. Retained only for backward compatibility. This option has no effect.") + + parser.add_option( + '--distribute', + dest='distribute', + action='store_true', + help="DEPRECATED. Retained only for backward compatibility. This option has no effect.") + + if 'extend_parser' in globals(): + extend_parser(parser) + + options, args = parser.parse_args() + + global logger + + if 'adjust_options' in globals(): + adjust_options(options, args) + + verbosity = options.verbose - options.quiet + logger = Logger([(Logger.level_for_integer(2 - verbosity), sys.stdout)]) + + if options.python and not os.environ.get('VIRTUALENV_INTERPRETER_RUNNING'): + env = os.environ.copy() + interpreter = resolve_interpreter(options.python) + if interpreter == sys.executable: + logger.warn('Already using interpreter %s' % interpreter) + else: + logger.notify('Running virtualenv with interpreter %s' % interpreter) + env['VIRTUALENV_INTERPRETER_RUNNING'] = 'true' + file = __file__ + if file.endswith('.pyc'): + file = file[:-1] + popen = subprocess.Popen([interpreter, file] + sys.argv[1:], env=env) + raise SystemExit(popen.wait()) + + if not args: + print('You must provide a DEST_DIR') + parser.print_help() + sys.exit(2) + if len(args) > 1: + print('There must be only one argument: DEST_DIR (you gave %s)' % ( + ' '.join(args))) + parser.print_help() + sys.exit(2) + + home_dir = args[0] + + if os.environ.get('WORKING_ENV'): + logger.fatal('ERROR: you cannot run virtualenv while in a workingenv') + logger.fatal('Please deactivate your workingenv, then re-run this script') + sys.exit(3) + + if 'PYTHONHOME' in os.environ: + logger.warn('PYTHONHOME is set. You *must* activate the virtualenv before using it') + del os.environ['PYTHONHOME'] + + if options.relocatable: + make_environment_relocatable(home_dir) + return + + if not options.never_download: + logger.warn('The --never-download option is for backward compatibility only.') + logger.warn('Setting it to false is no longer supported, and will be ignored.') + + create_environment(home_dir, + site_packages=options.system_site_packages, + clear=options.clear, + unzip_setuptools=options.unzip_setuptools, + prompt=options.prompt, + search_dirs=options.search_dirs, + never_download=True, + no_setuptools=options.no_setuptools, + no_pip=options.no_pip, + symlink=options.symlink) + if 'after_install' in globals(): + after_install(options, home_dir) + +def call_subprocess(cmd, show_stdout=True, + filter_stdout=None, cwd=None, + raise_on_returncode=True, extra_env=None, + remove_from_env=None): + cmd_parts = [] + for part in cmd: + if len(part) > 45: + part = part[:20]+"..."+part[-20:] + if ' ' in part or '\n' in part or '"' in part or "'" in part: + part = '"%s"' % part.replace('"', '\\"') + if hasattr(part, 'decode'): + try: + part = part.decode(sys.getdefaultencoding()) + except UnicodeDecodeError: + part = part.decode(sys.getfilesystemencoding()) + cmd_parts.append(part) + cmd_desc = ' '.join(cmd_parts) + if show_stdout: + stdout = None + else: + stdout = subprocess.PIPE + logger.debug("Running command %s" % cmd_desc) + if extra_env or remove_from_env: + env = os.environ.copy() + if extra_env: + env.update(extra_env) + if remove_from_env: + for varname in remove_from_env: + env.pop(varname, None) + else: + env = None + try: + proc = subprocess.Popen( + cmd, stderr=subprocess.STDOUT, stdin=None, stdout=stdout, + cwd=cwd, env=env) + except Exception: + e = sys.exc_info()[1] + logger.fatal( + "Error %s while executing command %s" % (e, cmd_desc)) + raise + all_output = [] + if stdout is not None: + stdout = proc.stdout + encoding = sys.getdefaultencoding() + fs_encoding = sys.getfilesystemencoding() + while 1: + line = stdout.readline() + try: + line = line.decode(encoding) + except UnicodeDecodeError: + line = line.decode(fs_encoding) + if not line: + break + line = line.rstrip() + all_output.append(line) + if filter_stdout: + level = filter_stdout(line) + if isinstance(level, tuple): + level, line = level + logger.log(level, line) + if not logger.stdout_level_matches(level): + logger.show_progress() + else: + logger.info(line) + else: + proc.communicate() + proc.wait() + if proc.returncode: + if raise_on_returncode: + if all_output: + logger.notify('Complete output from command %s:' % cmd_desc) + logger.notify('\n'.join(all_output) + '\n----------------------------------------') + raise OSError( + "Command %s failed with error code %s" + % (cmd_desc, proc.returncode)) + else: + logger.warn( + "Command %s had error code %s" + % (cmd_desc, proc.returncode)) + +def filter_install_output(line): + if line.strip().startswith('running'): + return Logger.INFO + return Logger.DEBUG + +def find_wheels(projects, search_dirs): + """Find wheels from which we can import PROJECTS. + + Scan through SEARCH_DIRS for a wheel for each PROJECT in turn. Return + a list of the first wheel found for each PROJECT + """ + + wheels = [] + + # Look through SEARCH_DIRS for the first suitable wheel. Don't bother + # about version checking here, as this is simply to get something we can + # then use to install the correct version. + for project in projects: + for dirname in search_dirs: + # This relies on only having "universal" wheels available. + # The pattern could be tightened to require -py2.py3-none-any.whl. + files = glob.glob(os.path.join(dirname, project + '-*.whl')) + if files: + wheels.append(os.path.abspath(files[0])) + break + else: + # We're out of luck, so quit with a suitable error + logger.fatal('Cannot find a wheel for %s' % (project,)) + + return wheels + +def install_wheel(project_names, py_executable, search_dirs=None): + if search_dirs is None: + search_dirs = file_search_dirs() + + wheels = find_wheels(['setuptools', 'pip'], search_dirs) + pythonpath = os.pathsep.join(wheels) + findlinks = ' '.join(search_dirs) + + cmd = [ + py_executable, '-c', + 'import sys, pip; sys.exit(pip.main(["install", "--ignore-installed"] + sys.argv[1:]))', + ] + project_names + logger.start_progress('Installing %s...' % (', '.join(project_names))) + logger.indent += 2 + try: + call_subprocess(cmd, show_stdout=False, + extra_env = { + 'PYTHONPATH': pythonpath, + 'PIP_FIND_LINKS': findlinks, + 'PIP_USE_WHEEL': '1', + 'PIP_PRE': '1', + 'PIP_NO_INDEX': '1' + } + ) + finally: + logger.indent -= 2 + logger.end_progress() + +def create_environment(home_dir, site_packages=False, clear=False, + unzip_setuptools=False, + prompt=None, search_dirs=None, never_download=False, + no_setuptools=False, no_pip=False, symlink=True): + """ + Creates a new environment in ``home_dir``. + + If ``site_packages`` is true, then the global ``site-packages/`` + directory will be on the path. + + If ``clear`` is true (default False) then the environment will + first be cleared. + """ + home_dir, lib_dir, inc_dir, bin_dir = path_locations(home_dir) + + py_executable = os.path.abspath(install_python( + home_dir, lib_dir, inc_dir, bin_dir, + site_packages=site_packages, clear=clear, symlink=symlink)) + + install_distutils(home_dir) + + if not no_setuptools: + to_install = ['setuptools'] + if not no_pip: + to_install.append('pip') + install_wheel(to_install, py_executable, search_dirs) + + install_activate(home_dir, bin_dir, prompt) + +def is_executable_file(fpath): + return os.path.isfile(fpath) and os.access(fpath, os.X_OK) + +def path_locations(home_dir): + """Return the path locations for the environment (where libraries are, + where scripts go, etc)""" + # XXX: We'd use distutils.sysconfig.get_python_inc/lib but its + # prefix arg is broken: http://bugs.python.org/issue3386 + if is_win: + # Windows has lots of problems with executables with spaces in + # the name; this function will remove them (using the ~1 + # format): + mkdir(home_dir) + if ' ' in home_dir: + import ctypes + GetShortPathName = ctypes.windll.kernel32.GetShortPathNameW + size = max(len(home_dir)+1, 256) + buf = ctypes.create_unicode_buffer(size) + try: + u = unicode + except NameError: + u = str + ret = GetShortPathName(u(home_dir), buf, size) + if not ret: + print('Error: the path "%s" has a space in it' % home_dir) + print('We could not determine the short pathname for it.') + print('Exiting.') + sys.exit(3) + home_dir = str(buf.value) + lib_dir = join(home_dir, 'Lib') + inc_dir = join(home_dir, 'Include') + bin_dir = join(home_dir, 'Scripts') + if is_jython: + lib_dir = join(home_dir, 'Lib') + inc_dir = join(home_dir, 'Include') + bin_dir = join(home_dir, 'bin') + elif is_pypy: + lib_dir = home_dir + inc_dir = join(home_dir, 'include') + bin_dir = join(home_dir, 'bin') + elif not is_win: + lib_dir = join(home_dir, 'lib', py_version) + multiarch_exec = '/usr/bin/multiarch-platform' + if is_executable_file(multiarch_exec): + # In Mageia (2) and Mandriva distros the include dir must be like: + # virtualenv/include/multiarch-x86_64-linux/python2.7 + # instead of being virtualenv/include/python2.7 + p = subprocess.Popen(multiarch_exec, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + stdout, stderr = p.communicate() + # stdout.strip is needed to remove newline character + inc_dir = join(home_dir, 'include', stdout.strip(), py_version + abiflags) + else: + inc_dir = join(home_dir, 'include', py_version + abiflags) + bin_dir = join(home_dir, 'bin') + return home_dir, lib_dir, inc_dir, bin_dir + + +def change_prefix(filename, dst_prefix): + prefixes = [sys.prefix] + + if is_darwin: + prefixes.extend(( + os.path.join("/Library/Python", sys.version[:3], "site-packages"), + os.path.join(sys.prefix, "Extras", "lib", "python"), + os.path.join("~", "Library", "Python", sys.version[:3], "site-packages"), + # Python 2.6 no-frameworks + os.path.join("~", ".local", "lib","python", sys.version[:3], "site-packages"), + # System Python 2.7 on OSX Mountain Lion + os.path.join("~", "Library", "Python", sys.version[:3], "lib", "python", "site-packages"))) + + if hasattr(sys, 'real_prefix'): + prefixes.append(sys.real_prefix) + if hasattr(sys, 'base_prefix'): + prefixes.append(sys.base_prefix) + prefixes = list(map(os.path.expanduser, prefixes)) + prefixes = list(map(os.path.abspath, prefixes)) + # Check longer prefixes first so we don't split in the middle of a filename + prefixes = sorted(prefixes, key=len, reverse=True) + filename = os.path.abspath(filename) + for src_prefix in prefixes: + if filename.startswith(src_prefix): + _, relpath = filename.split(src_prefix, 1) + if src_prefix != os.sep: # sys.prefix == "/" + assert relpath[0] == os.sep + relpath = relpath[1:] + return join(dst_prefix, relpath) + assert False, "Filename %s does not start with any of these prefixes: %s" % \ + (filename, prefixes) + +def copy_required_modules(dst_prefix, symlink): + import imp + # If we are running under -p, we need to remove the current + # directory from sys.path temporarily here, so that we + # definitely get the modules from the site directory of + # the interpreter we are running under, not the one + # virtualenv.py is installed under (which might lead to py2/py3 + # incompatibility issues) + _prev_sys_path = sys.path + if os.environ.get('VIRTUALENV_INTERPRETER_RUNNING'): + sys.path = sys.path[1:] + try: + for modname in REQUIRED_MODULES: + if modname in sys.builtin_module_names: + logger.info("Ignoring built-in bootstrap module: %s" % modname) + continue + try: + f, filename, _ = imp.find_module(modname) + except ImportError: + logger.info("Cannot import bootstrap module: %s" % modname) + else: + if f is not None: + f.close() + # special-case custom readline.so on OS X, but not for pypy: + if modname == 'readline' and sys.platform == 'darwin' and not ( + is_pypy or filename.endswith(join('lib-dynload', 'readline.so'))): + dst_filename = join(dst_prefix, 'lib', 'python%s' % sys.version[:3], 'readline.so') + elif modname == 'readline' and sys.platform == 'win32': + # special-case for Windows, where readline is not a + # standard module, though it may have been installed in + # site-packages by a third-party package + pass + else: + dst_filename = change_prefix(filename, dst_prefix) + copyfile(filename, dst_filename, symlink) + if filename.endswith('.pyc'): + pyfile = filename[:-1] + if os.path.exists(pyfile): + copyfile(pyfile, dst_filename[:-1], symlink) + finally: + sys.path = _prev_sys_path + + +def subst_path(prefix_path, prefix, home_dir): + prefix_path = os.path.normpath(prefix_path) + prefix = os.path.normpath(prefix) + home_dir = os.path.normpath(home_dir) + if not prefix_path.startswith(prefix): + logger.warn('Path not in prefix %r %r', prefix_path, prefix) + return + return prefix_path.replace(prefix, home_dir, 1) + + +def install_python(home_dir, lib_dir, inc_dir, bin_dir, site_packages, clear, symlink=True): + """Install just the base environment, no distutils patches etc""" + if sys.executable.startswith(bin_dir): + print('Please use the *system* python to run this script') + return + + if clear: + rmtree(lib_dir) + ## FIXME: why not delete it? + ## Maybe it should delete everything with #!/path/to/venv/python in it + logger.notify('Not deleting %s', bin_dir) + + if hasattr(sys, 'real_prefix'): + logger.notify('Using real prefix %r' % sys.real_prefix) + prefix = sys.real_prefix + elif hasattr(sys, 'base_prefix'): + logger.notify('Using base prefix %r' % sys.base_prefix) + prefix = sys.base_prefix + else: + prefix = sys.prefix + mkdir(lib_dir) + fix_lib64(lib_dir, symlink) + stdlib_dirs = [os.path.dirname(os.__file__)] + if is_win: + stdlib_dirs.append(join(os.path.dirname(stdlib_dirs[0]), 'DLLs')) + elif is_darwin: + stdlib_dirs.append(join(stdlib_dirs[0], 'site-packages')) + if hasattr(os, 'symlink'): + logger.info('Symlinking Python bootstrap modules') + else: + logger.info('Copying Python bootstrap modules') + logger.indent += 2 + try: + # copy required files... + for stdlib_dir in stdlib_dirs: + if not os.path.isdir(stdlib_dir): + continue + for fn in os.listdir(stdlib_dir): + bn = os.path.splitext(fn)[0] + if fn != 'site-packages' and bn in REQUIRED_FILES: + copyfile(join(stdlib_dir, fn), join(lib_dir, fn), symlink) + # ...and modules + copy_required_modules(home_dir, symlink) + finally: + logger.indent -= 2 + mkdir(join(lib_dir, 'site-packages')) + import site + site_filename = site.__file__ + if site_filename.endswith('.pyc'): + site_filename = site_filename[:-1] + elif site_filename.endswith('$py.class'): + site_filename = site_filename.replace('$py.class', '.py') + site_filename_dst = change_prefix(site_filename, home_dir) + site_dir = os.path.dirname(site_filename_dst) + writefile(site_filename_dst, SITE_PY) + writefile(join(site_dir, 'orig-prefix.txt'), prefix) + site_packages_filename = join(site_dir, 'no-global-site-packages.txt') + if not site_packages: + writefile(site_packages_filename, '') + + if is_pypy or is_win: + stdinc_dir = join(prefix, 'include') + else: + stdinc_dir = join(prefix, 'include', py_version + abiflags) + if os.path.exists(stdinc_dir): + copyfile(stdinc_dir, inc_dir, symlink) + else: + logger.debug('No include dir %s' % stdinc_dir) + + platinc_dir = distutils.sysconfig.get_python_inc(plat_specific=1) + if platinc_dir != stdinc_dir: + platinc_dest = distutils.sysconfig.get_python_inc( + plat_specific=1, prefix=home_dir) + if platinc_dir == platinc_dest: + # Do platinc_dest manually due to a CPython bug; + # not http://bugs.python.org/issue3386 but a close cousin + platinc_dest = subst_path(platinc_dir, prefix, home_dir) + if platinc_dest: + # PyPy's stdinc_dir and prefix are relative to the original binary + # (traversing virtualenvs), whereas the platinc_dir is relative to + # the inner virtualenv and ignores the prefix argument. + # This seems more evolved than designed. + copyfile(platinc_dir, platinc_dest, symlink) + + # pypy never uses exec_prefix, just ignore it + if sys.exec_prefix != prefix and not is_pypy: + if is_win: + exec_dir = join(sys.exec_prefix, 'lib') + elif is_jython: + exec_dir = join(sys.exec_prefix, 'Lib') + else: + exec_dir = join(sys.exec_prefix, 'lib', py_version) + for fn in os.listdir(exec_dir): + copyfile(join(exec_dir, fn), join(lib_dir, fn), symlink) + + if is_jython: + # Jython has either jython-dev.jar and javalib/ dir, or just + # jython.jar + for name in 'jython-dev.jar', 'javalib', 'jython.jar': + src = join(prefix, name) + if os.path.exists(src): + copyfile(src, join(home_dir, name), symlink) + # XXX: registry should always exist after Jython 2.5rc1 + src = join(prefix, 'registry') + if os.path.exists(src): + copyfile(src, join(home_dir, 'registry'), symlink=False) + copyfile(join(prefix, 'cachedir'), join(home_dir, 'cachedir'), + symlink=False) + + mkdir(bin_dir) + py_executable = join(bin_dir, os.path.basename(sys.executable)) + if 'Python.framework' in prefix: + # OS X framework builds cause validation to break + # https://github.com/pypa/virtualenv/issues/322 + if os.environ.get('__PYVENV_LAUNCHER__'): + del os.environ["__PYVENV_LAUNCHER__"] + if re.search(r'/Python(?:-32|-64)*$', py_executable): + # The name of the python executable is not quite what + # we want, rename it. + py_executable = os.path.join( + os.path.dirname(py_executable), 'python') + + logger.notify('New %s executable in %s', expected_exe, py_executable) + pcbuild_dir = os.path.dirname(sys.executable) + pyd_pth = os.path.join(lib_dir, 'site-packages', 'virtualenv_builddir_pyd.pth') + if is_win and os.path.exists(os.path.join(pcbuild_dir, 'build.bat')): + logger.notify('Detected python running from build directory %s', pcbuild_dir) + logger.notify('Writing .pth file linking to build directory for *.pyd files') + writefile(pyd_pth, pcbuild_dir) + else: + pcbuild_dir = None + if os.path.exists(pyd_pth): + logger.info('Deleting %s (not Windows env or not build directory python)' % pyd_pth) + os.unlink(pyd_pth) + + if sys.executable != py_executable: + ## FIXME: could I just hard link? + executable = sys.executable + shutil.copyfile(executable, py_executable) + make_exe(py_executable) + if is_win or is_cygwin: + pythonw = os.path.join(os.path.dirname(sys.executable), 'pythonw.exe') + if os.path.exists(pythonw): + logger.info('Also created pythonw.exe') + shutil.copyfile(pythonw, os.path.join(os.path.dirname(py_executable), 'pythonw.exe')) + python_d = os.path.join(os.path.dirname(sys.executable), 'python_d.exe') + python_d_dest = os.path.join(os.path.dirname(py_executable), 'python_d.exe') + if os.path.exists(python_d): + logger.info('Also created python_d.exe') + shutil.copyfile(python_d, python_d_dest) + elif os.path.exists(python_d_dest): + logger.info('Removed python_d.exe as it is no longer at the source') + os.unlink(python_d_dest) + # we need to copy the DLL to enforce that windows will load the correct one. + # may not exist if we are cygwin. + py_executable_dll = 'python%s%s.dll' % ( + sys.version_info[0], sys.version_info[1]) + py_executable_dll_d = 'python%s%s_d.dll' % ( + sys.version_info[0], sys.version_info[1]) + pythondll = os.path.join(os.path.dirname(sys.executable), py_executable_dll) + pythondll_d = os.path.join(os.path.dirname(sys.executable), py_executable_dll_d) + pythondll_d_dest = os.path.join(os.path.dirname(py_executable), py_executable_dll_d) + if os.path.exists(pythondll): + logger.info('Also created %s' % py_executable_dll) + shutil.copyfile(pythondll, os.path.join(os.path.dirname(py_executable), py_executable_dll)) + if os.path.exists(pythondll_d): + logger.info('Also created %s' % py_executable_dll_d) + shutil.copyfile(pythondll_d, pythondll_d_dest) + elif os.path.exists(pythondll_d_dest): + logger.info('Removed %s as the source does not exist' % pythondll_d_dest) + os.unlink(pythondll_d_dest) + if is_pypy: + # make a symlink python --> pypy-c + python_executable = os.path.join(os.path.dirname(py_executable), 'python') + if sys.platform in ('win32', 'cygwin'): + python_executable += '.exe' + logger.info('Also created executable %s' % python_executable) + copyfile(py_executable, python_executable, symlink) + + if is_win: + for name in ['libexpat.dll', 'libpypy.dll', 'libpypy-c.dll', + 'libeay32.dll', 'ssleay32.dll', 'sqlite3.dll', + 'tcl85.dll', 'tk85.dll']: + src = join(prefix, name) + if os.path.exists(src): + copyfile(src, join(bin_dir, name), symlink) + + for d in sys.path: + if d.endswith('lib_pypy'): + break + else: + logger.fatal('Could not find lib_pypy in sys.path') + raise SystemExit(3) + logger.info('Copying lib_pypy') + copyfile(d, os.path.join(home_dir, 'lib_pypy'), symlink) + + if os.path.splitext(os.path.basename(py_executable))[0] != expected_exe: + secondary_exe = os.path.join(os.path.dirname(py_executable), + expected_exe) + py_executable_ext = os.path.splitext(py_executable)[1] + if py_executable_ext.lower() == '.exe': + # python2.4 gives an extension of '.4' :P + secondary_exe += py_executable_ext + if os.path.exists(secondary_exe): + logger.warn('Not overwriting existing %s script %s (you must use %s)' + % (expected_exe, secondary_exe, py_executable)) + else: + logger.notify('Also creating executable in %s' % secondary_exe) + shutil.copyfile(sys.executable, secondary_exe) + make_exe(secondary_exe) + + if '.framework' in prefix: + if 'Python.framework' in prefix: + logger.debug('MacOSX Python framework detected') + # Make sure we use the embedded interpreter inside + # the framework, even if sys.executable points to + # the stub executable in ${sys.prefix}/bin + # See http://groups.google.com/group/python-virtualenv/ + # browse_thread/thread/17cab2f85da75951 + original_python = os.path.join( + prefix, 'Resources/Python.app/Contents/MacOS/Python') + if 'EPD' in prefix: + logger.debug('EPD framework detected') + original_python = os.path.join(prefix, 'bin/python') + shutil.copy(original_python, py_executable) + + # Copy the framework's dylib into the virtual + # environment + virtual_lib = os.path.join(home_dir, '.Python') + + if os.path.exists(virtual_lib): + os.unlink(virtual_lib) + copyfile( + os.path.join(prefix, 'Python'), + virtual_lib, + symlink) + + # And then change the install_name of the copied python executable + try: + mach_o_change(py_executable, + os.path.join(prefix, 'Python'), + '@executable_path/../.Python') + except: + e = sys.exc_info()[1] + logger.warn("Could not call mach_o_change: %s. " + "Trying to call install_name_tool instead." % e) + try: + call_subprocess( + ["install_name_tool", "-change", + os.path.join(prefix, 'Python'), + '@executable_path/../.Python', + py_executable]) + except: + logger.fatal("Could not call install_name_tool -- you must " + "have Apple's development tools installed") + raise + + if not is_win: + # Ensure that 'python', 'pythonX' and 'pythonX.Y' all exist + py_exe_version_major = 'python%s' % sys.version_info[0] + py_exe_version_major_minor = 'python%s.%s' % ( + sys.version_info[0], sys.version_info[1]) + py_exe_no_version = 'python' + required_symlinks = [ py_exe_no_version, py_exe_version_major, + py_exe_version_major_minor ] + + py_executable_base = os.path.basename(py_executable) + + if py_executable_base in required_symlinks: + # Don't try to symlink to yourself. + required_symlinks.remove(py_executable_base) + + for pth in required_symlinks: + full_pth = join(bin_dir, pth) + if os.path.exists(full_pth): + os.unlink(full_pth) + if symlink: + os.symlink(py_executable_base, full_pth) + else: + copyfile(py_executable, full_pth, symlink) + + if is_win and ' ' in py_executable: + # There's a bug with subprocess on Windows when using a first + # argument that has a space in it. Instead we have to quote + # the value: + py_executable = '"%s"' % py_executable + # NOTE: keep this check as one line, cmd.exe doesn't cope with line breaks + cmd = [py_executable, '-c', 'import sys;out=sys.stdout;' + 'getattr(out, "buffer", out).write(sys.prefix.encode("utf-8"))'] + logger.info('Testing executable with %s %s "%s"' % tuple(cmd)) + try: + proc = subprocess.Popen(cmd, + stdout=subprocess.PIPE) + proc_stdout, proc_stderr = proc.communicate() + except OSError: + e = sys.exc_info()[1] + if e.errno == errno.EACCES: + logger.fatal('ERROR: The executable %s could not be run: %s' % (py_executable, e)) + sys.exit(100) + else: + raise e + + proc_stdout = proc_stdout.strip().decode("utf-8") + proc_stdout = os.path.normcase(os.path.abspath(proc_stdout)) + norm_home_dir = os.path.normcase(os.path.abspath(home_dir)) + if hasattr(norm_home_dir, 'decode'): + norm_home_dir = norm_home_dir.decode(sys.getfilesystemencoding()) + if proc_stdout != norm_home_dir: + logger.fatal( + 'ERROR: The executable %s is not functioning' % py_executable) + logger.fatal( + 'ERROR: It thinks sys.prefix is %r (should be %r)' + % (proc_stdout, norm_home_dir)) + logger.fatal( + 'ERROR: virtualenv is not compatible with this system or executable') + if is_win: + logger.fatal( + 'Note: some Windows users have reported this error when they ' + 'installed Python for "Only this user" or have multiple ' + 'versions of Python installed. Copying the appropriate ' + 'PythonXX.dll to the virtualenv Scripts/ directory may fix ' + 'this problem.') + sys.exit(100) + else: + logger.info('Got sys.prefix result: %r' % proc_stdout) + + pydistutils = os.path.expanduser('~/.pydistutils.cfg') + if os.path.exists(pydistutils): + logger.notify('Please make sure you remove any previous custom paths from ' + 'your %s file.' % pydistutils) + ## FIXME: really this should be calculated earlier + + fix_local_scheme(home_dir, symlink) + + if site_packages: + if os.path.exists(site_packages_filename): + logger.info('Deleting %s' % site_packages_filename) + os.unlink(site_packages_filename) + + return py_executable + + +def install_activate(home_dir, bin_dir, prompt=None): + home_dir = os.path.abspath(home_dir) + if is_win or is_jython and os._name == 'nt': + files = { + 'activate.bat': ACTIVATE_BAT, + 'deactivate.bat': DEACTIVATE_BAT, + 'activate.ps1': ACTIVATE_PS, + } + + # MSYS needs paths of the form /c/path/to/file + drive, tail = os.path.splitdrive(home_dir.replace(os.sep, '/')) + home_dir_msys = (drive and "/%s%s" or "%s%s") % (drive[:1], tail) + + # Run-time conditional enables (basic) Cygwin compatibility + home_dir_sh = ("""$(if [ "$OSTYPE" "==" "cygwin" ]; then cygpath -u '%s'; else echo '%s'; fi;)""" % + (home_dir, home_dir_msys)) + files['activate'] = ACTIVATE_SH.replace('__VIRTUAL_ENV__', home_dir_sh) + + else: + files = {'activate': ACTIVATE_SH} + + # suppling activate.fish in addition to, not instead of, the + # bash script support. + files['activate.fish'] = ACTIVATE_FISH + + # same for csh/tcsh support... + files['activate.csh'] = ACTIVATE_CSH + + files['activate_this.py'] = ACTIVATE_THIS + if hasattr(home_dir, 'decode'): + home_dir = home_dir.decode(sys.getfilesystemencoding()) + vname = os.path.basename(home_dir) + for name, content in files.items(): + content = content.replace('__VIRTUAL_PROMPT__', prompt or '') + content = content.replace('__VIRTUAL_WINPROMPT__', prompt or '(%s)' % vname) + content = content.replace('__VIRTUAL_ENV__', home_dir) + content = content.replace('__VIRTUAL_NAME__', vname) + content = content.replace('__BIN_NAME__', os.path.basename(bin_dir)) + writefile(os.path.join(bin_dir, name), content) + +def install_distutils(home_dir): + distutils_path = change_prefix(distutils.__path__[0], home_dir) + mkdir(distutils_path) + ## FIXME: maybe this prefix setting should only be put in place if + ## there's a local distutils.cfg with a prefix setting? + home_dir = os.path.abspath(home_dir) + ## FIXME: this is breaking things, removing for now: + #distutils_cfg = DISTUTILS_CFG + "\n[install]\nprefix=%s\n" % home_dir + writefile(os.path.join(distutils_path, '__init__.py'), DISTUTILS_INIT) + writefile(os.path.join(distutils_path, 'distutils.cfg'), DISTUTILS_CFG, overwrite=False) + +def fix_local_scheme(home_dir, symlink=True): + """ + Platforms that use the "posix_local" install scheme (like Ubuntu with + Python 2.7) need to be given an additional "local" location, sigh. + """ + try: + import sysconfig + except ImportError: + pass + else: + if sysconfig._get_default_scheme() == 'posix_local': + local_path = os.path.join(home_dir, 'local') + if not os.path.exists(local_path): + os.mkdir(local_path) + for subdir_name in os.listdir(home_dir): + if subdir_name == 'local': + continue + copyfile(os.path.abspath(os.path.join(home_dir, subdir_name)), \ + os.path.join(local_path, subdir_name), symlink) + +def fix_lib64(lib_dir, symlink=True): + """ + Some platforms (particularly Gentoo on x64) put things in lib64/pythonX.Y + instead of lib/pythonX.Y. If this is such a platform we'll just create a + symlink so lib64 points to lib + """ + if [p for p in distutils.sysconfig.get_config_vars().values() + if isinstance(p, basestring) and 'lib64' in p]: + # PyPy's library path scheme is not affected by this. + # Return early or we will die on the following assert. + if is_pypy: + logger.debug('PyPy detected, skipping lib64 symlinking') + return + + logger.debug('This system uses lib64; symlinking lib64 to lib') + + assert os.path.basename(lib_dir) == 'python%s' % sys.version[:3], ( + "Unexpected python lib dir: %r" % lib_dir) + lib_parent = os.path.dirname(lib_dir) + top_level = os.path.dirname(lib_parent) + lib_dir = os.path.join(top_level, 'lib') + lib64_link = os.path.join(top_level, 'lib64') + assert os.path.basename(lib_parent) == 'lib', ( + "Unexpected parent dir: %r" % lib_parent) + if os.path.lexists(lib64_link): + return + if symlink: + os.symlink('lib', lib64_link) + else: + copyfile('lib', lib64_link) + +def resolve_interpreter(exe): + """ + If the executable given isn't an absolute path, search $PATH for the interpreter + """ + # If the "executable" is a version number, get the installed executable for + # that version + python_versions = get_installed_pythons() + if exe in python_versions: + exe = python_versions[exe] + + if os.path.abspath(exe) != exe: + paths = os.environ.get('PATH', '').split(os.pathsep) + for path in paths: + if os.path.exists(os.path.join(path, exe)): + exe = os.path.join(path, exe) + break + if not os.path.exists(exe): + logger.fatal('The executable %s (from --python=%s) does not exist' % (exe, exe)) + raise SystemExit(3) + if not is_executable(exe): + logger.fatal('The executable %s (from --python=%s) is not executable' % (exe, exe)) + raise SystemExit(3) + return exe + +def is_executable(exe): + """Checks a file is executable""" + return os.access(exe, os.X_OK) + +############################################################ +## Relocating the environment: + +def make_environment_relocatable(home_dir): + """ + Makes the already-existing environment use relative paths, and takes out + the #!-based environment selection in scripts. + """ + home_dir, lib_dir, inc_dir, bin_dir = path_locations(home_dir) + activate_this = os.path.join(bin_dir, 'activate_this.py') + if not os.path.exists(activate_this): + logger.fatal( + 'The environment doesn\'t have a file %s -- please re-run virtualenv ' + 'on this environment to update it' % activate_this) + fixup_scripts(home_dir, bin_dir) + fixup_pth_and_egg_link(home_dir) + ## FIXME: need to fix up distutils.cfg + +OK_ABS_SCRIPTS = ['python', 'python%s' % sys.version[:3], + 'activate', 'activate.bat', 'activate_this.py', + 'activate.fish', 'activate.csh'] + +def fixup_scripts(home_dir, bin_dir): + if is_win: + new_shebang_args = ( + '%s /c' % os.path.normcase(os.environ.get('COMSPEC', 'cmd.exe')), + '', '.exe') + else: + new_shebang_args = ('/usr/bin/env', sys.version[:3], '') + + # This is what we expect at the top of scripts: + shebang = '#!%s' % os.path.normcase(os.path.join( + os.path.abspath(bin_dir), 'python%s' % new_shebang_args[2])) + # This is what we'll put: + new_shebang = '#!%s python%s%s' % new_shebang_args + + for filename in os.listdir(bin_dir): + filename = os.path.join(bin_dir, filename) + if not os.path.isfile(filename): + # ignore subdirs, e.g. .svn ones. + continue + f = open(filename, 'rb') + try: + try: + lines = f.read().decode('utf-8').splitlines() + except UnicodeDecodeError: + # This is probably a binary program instead + # of a script, so just ignore it. + continue + finally: + f.close() + if not lines: + logger.warn('Script %s is an empty file' % filename) + continue + + old_shebang = lines[0].strip() + old_shebang = old_shebang[0:2] + os.path.normcase(old_shebang[2:]) + + if not old_shebang.startswith(shebang): + if os.path.basename(filename) in OK_ABS_SCRIPTS: + logger.debug('Cannot make script %s relative' % filename) + elif lines[0].strip() == new_shebang: + logger.info('Script %s has already been made relative' % filename) + else: + logger.warn('Script %s cannot be made relative (it\'s not a normal script that starts with %s)' + % (filename, shebang)) + continue + logger.notify('Making script %s relative' % filename) + script = relative_script([new_shebang] + lines[1:]) + f = open(filename, 'wb') + f.write('\n'.join(script).encode('utf-8')) + f.close() + +def relative_script(lines): + "Return a script that'll work in a relocatable environment." + activate = "import os; activate_this=os.path.join(os.path.dirname(os.path.realpath(__file__)), 'activate_this.py'); exec(compile(open(activate_this).read(), activate_this, 'exec'), dict(__file__=activate_this)); del os, activate_this" + # Find the last future statement in the script. If we insert the activation + # line before a future statement, Python will raise a SyntaxError. + activate_at = None + for idx, line in reversed(list(enumerate(lines))): + if line.split()[:3] == ['from', '__future__', 'import']: + activate_at = idx + 1 + break + if activate_at is None: + # Activate after the shebang. + activate_at = 1 + return lines[:activate_at] + ['', activate, ''] + lines[activate_at:] + +def fixup_pth_and_egg_link(home_dir, sys_path=None): + """Makes .pth and .egg-link files use relative paths""" + home_dir = os.path.normcase(os.path.abspath(home_dir)) + if sys_path is None: + sys_path = sys.path + for path in sys_path: + if not path: + path = '.' + if not os.path.isdir(path): + continue + path = os.path.normcase(os.path.abspath(path)) + if not path.startswith(home_dir): + logger.debug('Skipping system (non-environment) directory %s' % path) + continue + for filename in os.listdir(path): + filename = os.path.join(path, filename) + if filename.endswith('.pth'): + if not os.access(filename, os.W_OK): + logger.warn('Cannot write .pth file %s, skipping' % filename) + else: + fixup_pth_file(filename) + if filename.endswith('.egg-link'): + if not os.access(filename, os.W_OK): + logger.warn('Cannot write .egg-link file %s, skipping' % filename) + else: + fixup_egg_link(filename) + +def fixup_pth_file(filename): + lines = [] + prev_lines = [] + f = open(filename) + prev_lines = f.readlines() + f.close() + for line in prev_lines: + line = line.strip() + if (not line or line.startswith('#') or line.startswith('import ') + or os.path.abspath(line) != line): + lines.append(line) + else: + new_value = make_relative_path(filename, line) + if line != new_value: + logger.debug('Rewriting path %s as %s (in %s)' % (line, new_value, filename)) + lines.append(new_value) + if lines == prev_lines: + logger.info('No changes to .pth file %s' % filename) + return + logger.notify('Making paths in .pth file %s relative' % filename) + f = open(filename, 'w') + f.write('\n'.join(lines) + '\n') + f.close() + +def fixup_egg_link(filename): + f = open(filename) + link = f.readline().strip() + f.close() + if os.path.abspath(link) != link: + logger.debug('Link in %s already relative' % filename) + return + new_link = make_relative_path(filename, link) + logger.notify('Rewriting link %s in %s as %s' % (link, filename, new_link)) + f = open(filename, 'w') + f.write(new_link) + f.close() + +def make_relative_path(source, dest, dest_is_directory=True): + """ + Make a filename relative, where the filename is dest, and it is + being referred to from the filename source. + + >>> make_relative_path('/usr/share/something/a-file.pth', + ... '/usr/share/another-place/src/Directory') + '../another-place/src/Directory' + >>> make_relative_path('/usr/share/something/a-file.pth', + ... '/home/user/src/Directory') + '../../../home/user/src/Directory' + >>> make_relative_path('/usr/share/a-file.pth', '/usr/share/') + './' + """ + source = os.path.dirname(source) + if not dest_is_directory: + dest_filename = os.path.basename(dest) + dest = os.path.dirname(dest) + dest = os.path.normpath(os.path.abspath(dest)) + source = os.path.normpath(os.path.abspath(source)) + dest_parts = dest.strip(os.path.sep).split(os.path.sep) + source_parts = source.strip(os.path.sep).split(os.path.sep) + while dest_parts and source_parts and dest_parts[0] == source_parts[0]: + dest_parts.pop(0) + source_parts.pop(0) + full_parts = ['..']*len(source_parts) + dest_parts + if not dest_is_directory: + full_parts.append(dest_filename) + if not full_parts: + # Special case for the current directory (otherwise it'd be '') + return './' + return os.path.sep.join(full_parts) + + + +############################################################ +## Bootstrap script creation: + +def create_bootstrap_script(extra_text, python_version=''): + """ + Creates a bootstrap script, which is like this script but with + extend_parser, adjust_options, and after_install hooks. + + This returns a string that (written to disk of course) can be used + as a bootstrap script with your own customizations. The script + will be the standard virtualenv.py script, with your extra text + added (your extra text should be Python code). + + If you include these functions, they will be called: + + ``extend_parser(optparse_parser)``: + You can add or remove options from the parser here. + + ``adjust_options(options, args)``: + You can change options here, or change the args (if you accept + different kinds of arguments, be sure you modify ``args`` so it is + only ``[DEST_DIR]``). + + ``after_install(options, home_dir)``: + + After everything is installed, this function is called. This + is probably the function you are most likely to use. An + example would be:: + + def after_install(options, home_dir): + subprocess.call([join(home_dir, 'bin', 'easy_install'), + 'MyPackage']) + subprocess.call([join(home_dir, 'bin', 'my-package-script'), + 'setup', home_dir]) + + This example immediately installs a package, and runs a setup + script from that package. + + If you provide something like ``python_version='2.5'`` then the + script will start with ``#!/usr/bin/env python2.5`` instead of + ``#!/usr/bin/env python``. You can use this when the script must + be run with a particular Python version. + """ + filename = __file__ + if filename.endswith('.pyc'): + filename = filename[:-1] + f = codecs.open(filename, 'r', encoding='utf-8') + content = f.read() + f.close() + py_exe = 'python%s' % python_version + content = (('#!/usr/bin/env %s\n' % py_exe) + + '## WARNING: This file is generated\n' + + content) + return content.replace('##EXT' 'END##', extra_text) + +############################################################################### +## 'prefix code' START +# requirements from normal_installation.txt +NORMAL_INSTALLATION = ['click', 'dragonlib', 'MC6809', 'DragonPy'] + +# requirements from git_readonly_installation.txt +GIT_READONLY_INSTALLATION = ['click', + 'docutils', + 'virtualenv', + '--editable=git+https://github.com/6809/dragonlib.git#egg=dragonlib', + '--editable=git+https://github.com/6809/MC6809.git#egg=MC6809', + '--editable=git+https://github.com/jedie/bootstrap_env.git#egg=bootstrap_env', + '--editable=git+https://github.com:jedie/DragonPy.git#egg=DragonPy'] + +# requirements from developer_installation.txt +DEVELOPER_INSTALLATION = ['click', + 'docutils', + 'wheel', + 'virtualenv', + '--editable=git+git@github.com:6809/dragonlib.git#egg=dragonlib', + '--editable=git+git@github.com:6809/MC6809.git#egg=MC6809', + '--editable=git+git@github.com:jedie/bootstrap_env.git#egg=bootstrap_env', + '--editable=git+git@github.com:jedie/DragonPy.git#egg=DragonPy'] +############################################################################### +## '.../src/dragonpy/bootstrap/source_prefix_code.py' START +# For choosing the installation type: +INST_PYPI="pypi" +INST_GIT="git_readonly" +INST_DEV="dev" + +INST_TYPES=(INST_PYPI, INST_GIT, INST_DEV) +## '.../src/dragonpy/bootstrap/source_prefix_code.py' END +############################################################################### +## 'prefix code' END +############################################################################### +############################################################################### +## '.../src/bootstrap-env/bootstrap_env/bootstrap_install_pip.py' START +INSTALL_PIP_OPTION="--install-pip" + + +class EnvSubprocess(object): + """ + Use to install pip and useful also to install other packages in after_install. + """ + def __init__(self, home_dir): + self.abs_home_dir = os.path.abspath(home_dir) + + if sys.platform in ['win32','cygwin','win64']: + self.bin_dir = os.path.join(self.abs_home_dir, "Scripts") + else: + self.bin_dir = os.path.join(self.abs_home_dir, "bin") + + self.python_cmd = os.path.join(self.bin_dir, "python") + self.pip_cmd = os.path.join(self.bin_dir, "pip") + + self.subprocess_defaults = { + "cwd": self.bin_dir, + "env": { + "VIRTUAL_ENV": self.abs_home_dir, + "PATH": self.bin_dir + os.pathsep + os.environ["PATH"], + } + } + try: + # Work-a-round for http://bugs.python.org/issue20614 : + # Python3 will crash under windows without SYSTEMROOT + self.subprocess_defaults["env"]["SYSTEMROOT"] = os.environ['SYSTEMROOT'] + except KeyError: + pass + + def _subprocess(self, cmd): + print("call %r" % " ".join(cmd)) + subprocess.call(cmd, **self.subprocess_defaults) + + def call_env_python(self, cmd): + self._subprocess([self.python_cmd] + cmd) + + def call_env_pip(self, cmd): + self._subprocess([self.pip_cmd] + cmd) + + +def _install_pip(options, home_dir): + print("Install pip...") + bootstrap_file = os.path.abspath(sys.argv[0]) + assert os.path.isfile(bootstrap_file), "Path to self not found?!?! (%r not exists?!?!)" % bootstrap_file + + env_subprocess = EnvSubprocess(home_dir) + env_subprocess.call_env_python([bootstrap_file, "--install-pip", env_subprocess.abs_home_dir]) + + +def extend_parser(parser): + parser.add_option( + INSTALL_PIP_OPTION, + dest='install_pip', + help="Only for internal usage!" + ) + if INSTALL_PIP_OPTION in sys.argv: + return # Skip the additional code, if pip should be installed + + + ############################################################################### + ## '.../src/dragonpy/bootstrap/source_extend_parser.py' START + parser.add_option("--install_type", dest="install_type", choices=INST_TYPES, + help="Install type: %s (See README!)" % ", ".join(INST_TYPES) + ) + ## '.../src/dragonpy/bootstrap/source_extend_parser.py' END + ############################################################################### + + +def adjust_options(options, args): + # Importand, otherwise it failed with 'ImportError: No module named pip' + # because the wheel files are not there + options.no_setuptools=True + + if options.install_pip: + print("install pip from self contained 'get_pip.py'") + sys.argv = [sys.argv[0]] + get_pip() # renamed main() from 'get_pip.py', it exists in the generated bootstrap file! + print("pip is installed.") + sys.exit(0) + + + ############################################################################### + ## '.../src/dragonpy/bootstrap/source_adjust_options.py' START + if options.install_type == None: + sys.stderr.write("\n\nERROR:\nYou must add --install_type option (See README) !\n") + sys.stderr.write("Available types: %s\n\n" % ", ".join(INST_TYPES)) + sys.exit(-1) + + sys.stdout.write("\nInstall type: %r\n" % options.install_type) + ## '.../src/dragonpy/bootstrap/source_adjust_options.py' END + ############################################################################### + + +def after_install(options, home_dir): + _install_pip(options, home_dir) +## '.../src/bootstrap-env/bootstrap_env/bootstrap_install_pip.py' END +############################################################################### + ############################################################################### + ## '.../src/dragonpy/bootstrap/source_after_install.py' START + """ + called after virtualenv was created and pip/setuptools installed. + Now we installed requirement libs/packages. + """ + if options.install_type==INST_PYPI: + requirements=NORMAL_INSTALLATION + elif options.install_type==INST_GIT: + requirements=GIT_READONLY_INSTALLATION + elif options.install_type==INST_DEV: + requirements=DEVELOPER_INSTALLATION + else: + # Should never happen + raise RuntimeError("Install type %r unknown?!?" % options.install_type) + + env_subprocess = EnvSubprocess(home_dir) # from bootstrap_env.bootstrap_install_pip + + logfile = os.path.join(env_subprocess.abs_home_dir, "install.log") + + for requirement in requirements: + sys.stdout.write("\n\nInstall %r:\n" % requirement) + env_subprocess.call_env_pip(["install", "--log=%s" % logfile, requirement]) + sys.stdout.write("\n") + ## '.../src/dragonpy/bootstrap/source_after_install.py' END + ############################################################################### + + + + +############################################################################### +## 'get_pip.py' START +#!/usr/bin/env python +# +# Hi There! +# You may be wondering what this giant blob of binary data here is, you might +# even be worried that we're up to something nefarious (good for you for being +# paranoid!). This is a base85 encoding of a zip file, this zip file contains +# an entire copy of pip. +# +# Pip is a thing that installs packages, pip itself is a package that someone +# might want to install, especially if they're looking to run this get-pip.py +# script. Pip has a lot of code to deal with the security of installing +# packages, various edge cases on various platforms, and other such sort of +# "tribal knowledge" that has been encoded in its code base. Because of this +# we basically include an entire copy of pip inside this blob. We do this +# because the alternatives are attempt to implement a "minipip" that probably +# doesn't do things correctly and has weird edge cases, or compress pip itself +# down into a single file. +# +# If you're wondering how this is created, it is using an invoke task located +# in tasks/generate.py called "installer". It can be invoked by using +# ``invoke generate.installer``. + +import os.path +import pkgutil +import shutil +import sys +import struct +import tempfile + +# Useful for very coarse version differentiation. +PY2 = sys.version_info[0] == 2 +PY3 = sys.version_info[0] == 3 + +if PY3: + iterbytes = iter +else: + def iterbytes(buf): + return (ord(byte) for byte in buf) + +try: + from base64 import b85decode +except ImportError: + _b85alphabet = (b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" + b"abcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~") + + def b85decode(b): + _b85dec = [None] * 256 + for i, c in enumerate(iterbytes(_b85alphabet)): + _b85dec[c] = i + + padding = (-len(b)) % 5 + b = b + b'~' * padding + out = [] + packI = struct.Struct('!I').pack + for i in range(0, len(b), 5): + chunk = b[i:i + 5] + acc = 0 + try: + for c in iterbytes(chunk): + acc = acc * 85 + _b85dec[c] + except TypeError: + for j, c in enumerate(iterbytes(chunk)): + if _b85dec[c] is None: + raise ValueError( + 'bad base85 character at position %d' % (i + j) + ) + raise + try: + out.append(packI(acc)) + except struct.error: + raise ValueError('base85 overflow in hunk starting at byte %d' + % i) + + result = b''.join(out) + if padding: + result = result[:-padding] + return result + + +def bootstrap(tmpdir=None): + # Import pip so we can use it to install pip and maybe setuptools too + import pip + from pip.commands.install import InstallCommand + + # Wrapper to provide default certificate with the lowest priority + class CertInstallCommand(InstallCommand): + def parse_args(self, args): + # If cert isn't specified in config or environment, we provide our + # own certificate through defaults. + # This allows user to specify custom cert anywhere one likes: + # config, environment variable or argv. + if not self.parser.get_default_values().cert: + self.parser.defaults["cert"] = cert_path # calculated below + return super(CertInstallCommand, self).parse_args(args) + + pip.commands_dict["install"] = CertInstallCommand + + # We always want to install pip + packages = ["pip"] + + # Check if the user has requested us not to install setuptools + if "--no-setuptools" in sys.argv or os.environ.get("PIP_NO_SETUPTOOLS"): + args = [x for x in sys.argv[1:] if x != "--no-setuptools"] + else: + args = sys.argv[1:] + + # We want to see if setuptools is available before attempting to + # install it + try: + import setuptools # noqa + except ImportError: + packages += ["setuptools"] + + # Check if the user has requested us not to install wheel + if "--no-wheel" in args or os.environ.get("PIP_NO_WHEEL"): + args = [x for x in args if x != "--no-wheel"] + else: + # We want to see if wheel is available before attempting to install it. + try: + import wheel # noqa + except ImportError: + args += ["wheel"] + + delete_tmpdir = False + try: + # Create a temporary directory to act as a working directory if we were + # not given one. + if tmpdir is None: + tmpdir = tempfile.mkdtemp() + delete_tmpdir = True + + # We need to extract the SSL certificates from requests so that they + # can be passed to --cert + cert_path = os.path.join(tmpdir, "cacert.pem") + with open(cert_path, "wb") as cert: + cert.write(pkgutil.get_data("pip._vendor.requests", "cacert.pem")) + + # Execute the included pip and use it to install the latest pip and + # setuptools from PyPI + sys.exit(pip.main(["install", "--upgrade"] + packages + args)) + finally: + # Remove our temporary directory + if delete_tmpdir and tmpdir: + shutil.rmtree(tmpdir, ignore_errors=True) + + +def get_pip(): + tmpdir = None + try: + # Create a temporary working directory + tmpdir = tempfile.mkdtemp() + + # Unpack the zipfile into the temporary directory + pip_zip = os.path.join(tmpdir, "pip.zip") + with open(pip_zip, "wb") as fp: + fp.write(b85decode(DATA.replace(b"\n", b""))) + + # Add the zipfile to sys.path so that we can import it + sys.path.insert(0, pip_zip) + + # Run the bootstrap + bootstrap(tmpdir=tmpdir) + finally: + # Clean up our temporary working directory + if tmpdir: + shutil.rmtree(tmpdir, ignore_errors=True) + + +DATA = b""" +P)h>@6aWAK2mtS)wno;)icgje006Ei000jF003}la4%n9X>MtBUtcb8d7WBuZ`-yK|KFd2brwikWo_B +;u!rn<*pQ}JfvyeG_Vod&A;=bObCD&Dl#;mHzWcj7k|JfvSvC!;CGmK7Jl_3ycgo4LuUaL)T8i>3Uf! +{K-)yULvX<43rRlnDTFKLtiCtaEhGk1t6>Y;){XChN_eHhYh;m~eE7jfAO`S=_?el#mOCVI;OttT5C7 +)=ywWt&Ru;O(is#00muS(TqMUmmlODQWEvx{oC%gWq5U5T3R9Fw*YMK^!Ln^b5XJWq3>8Yz}7iHK>im +euCS+?>~vuSm3`xLY~iqKVm#%T+5yR>VxT%R4R=kjHG9ea7%&OvOsdBN9NTQurtUeqruxyzb{dn;XOOY|12T6iY~H_KCECyGp_mh|{!`wT`}HI6L3<7HmSMDpK +St{Rop+3GgiaFw*OD8%yHkxdIH3@+F@4yNJPdge#%1o0%AOeQBRQ%Y>g9WNWUt|VI**)9J!Ybv(nY@5 +~f9*N#>g<@;*z!l3_4crO=YisuGe#=WE4S2FUk%8apXYkt@aA)_NW#C*VOq8O5{SgW&n=Qv>v0at71& +`U(F0?blF0b@zrVNBjT!IpJ$Ox>%Kr;@T1iRXxviFs|W#B?Jm&G0=0sjo#TQn`XO=7*A4Bl~`xLYRvniMxBNaSuZbLQ!*LY3u!Za_MBV(C;pV+8Q)}jEnw2$Ew_O+6H8Z(F;zNzGXKJE(W2svM~tZgdrzPjKI52JH +(p6PUI;+$5hjl&ET-lEf>rn?L*V}?y&g>Ht5h#S5Tjlu}++`dPZOo;BX%$5ab%RN(7D_6MWs^qL%lPF +KR+VY}cY9&PtY(t3ZEdzx +gxNc>BxM>&y3-0XZP9TqOYDLRO`=8(tE8M3(fp0td~}$sFBHfK1YlZ?9jx3l@p03(#?apptr%_ra8NT;Gpe>Uj$jiH;T0$+=Y=A +b%+D +bP9#hMm;|(g*i-zR1>mQ3;Bx}M1K;T}9B0brb2Htsr&aC2D;~gS&Z47Y0c$a +tN%lw^rM3HVnK*5aOZ~P{K*RoOfqS=PQEQtErI^mr|*sEBf`3;kzy6-G+FH{s&w!U^Gj|gd@X;l{c`F +q*&0}afga7uE^_rAKtDx%fcF&oq-gdik`ta^(|@Hi^-&@$-je}ZxWxFnr~xa)cYy6G`n;}$I8M90Hy0 +J42cuHD3;TE49wA;YVdh%HDQ4aR-v8i^y^Fh5PXIdGMQw}Tc4p2Nn6@PKDt3co3CUAYOP7)g>clN&Wu +#I6ZQ`jMaLAWby;6g@qK#g6aOnnYj_v1juxEl%EjxVpN&eD^N>`SSJEV&a97K1x~DLdqcdov2y`5k$e +Y7QDj&eGq4N8RT|&U>!y?&c(G73_ci)59UDxs71?q=((B0>czl(XuXG+-9{l`fEf!!EKSp>18&+h8;XI19tvO-r(V7&{)XhR9Mm07?waf}%B5DOAw(hpG{yfNuh9zQdRIXEdeH|`vsONpTZ41gji!<_ +Nlydpv8upP5mBX%6Jnfbqhm<2Y4huhfVzX|tILQd@)_Ftai2)qfD!s>wm?ekl58K +j_1VK;6U%=!wahTPG%Q-4mvRU71IlT=3EjM>u%qr2^JOhf>D%qkfh1Ap}?*Jqpf&j`#0uwBKfYm1<}lrnp@c{LY4M8lD(EE$o<)jo?TU=h!E)V%G+?6m?G=W3zU2JGi~029`0QY2 +#I`WG`F~pMA8SA&^QRKHXqy+LyQh?{)Ix5|X})pWeTE`{tdK-L*c!?*R97i4#t9of=K!G0xov>+GhLT +0xJpV{6*r3X7y>3rF#0%XAA@nZwU1XkgDuNj04f!hUOYGSasjID$n&ca-^kF8jF!`_k}g0CrqTgJILl +>+84I=WrNLAs~QufOn4eQM|LQfMY#?E^b5XPxAvWwo5ZfoQ(lf(39JBB=m9O3%uqpE)& +iA;4Be27vWaR-bu!txHJ!{t;HoU-_y5e>a=E#%~#LWT$DUc(IO|-XN$tW5#pQpmWEhKFn70F!B%@CnN +@3JHYJ*fCapVfBUa3Qy8rN-d8l68-aJ8V>yb7o8CT%sggt +x4o~TCfWNT5FWUA*~Lt4*ub?(p&^cq}`lKvf;*f3QZ=@Po{jRLZ8{PP7!b!kwixs?9WGvuO}7(*s-Go +8=Dec<2ubP=;pgM|f`4=@AMn=_hA2^+El_k~H{cbc5a?{$A1Z!tq0^3uv^TbMLeL*11Y*+9er)`bBK2SZ=M4?u3-_$LG;@W9-o +4qJAxPkVE6}%u_qTE4|rr*Xu;+P*iNnYy))-jokL +_E<>#kOk1LOtA1C7r(LC=kGAv=D`)+6BERWm7u?l`aRevJBxVZcarjKM5jy1w=aH@VhRVRG2nVSaNQC +)ohKOSVD@$o?fBoL)DqVbP~c)7PWt1pz!-D+83TAe7W{EDhE$zy@j?2@P+p(fW8uD-)G!(RQ;Jo +xa*Q)S2yfc3lX+tL7NbPX@O5j4F#4!HT9nzQTr*?ebLnXr9oHuQDp|X_x}MtB6LPlNBO;hh9ZachS)9m2Y!fHTg19=I-g)>-5)UZy*_y +g#11e(nC2o%NFCruN3-zSHly^kvv&4T)DAYEvR0g_9P5B)m%Bk#ZkBv#&T8)v!gq=!%TaNnmBwC!^Py +mm5=^JNe<-@X_TBwIZv^)H;@Wb1=4di?Plpn;|NU2C%)Ny8rJE~ +SiK$#S29>XbnQuoOn|gWaxXKSuO9KQH000080Pmr;MpT|QaPA8L03|5^01^NI0B~t=FJfVHWn*t`ZDD +R?E^v9x8f%Z+HuC%a3PQ!gQs5{}4+k6;FnY=ECN-Mci+wabPechs<(d(5lRspod(jDk)fbXizeKUlu&c9L80?zhP1Wkp_l6q-@`!8@^65E88i +Vmr^A~p;x{Xf{Q7+gH^kOC*+ZzC1%mD1UuxslCP`0$S!iBhogp}l<)S5BJJa#S)QtMUas>^1Gxe%&|( +)3+CVJzey;Qku)EKI(QOy}MleOc%>r`eu2zxGIFAU(Y@fCDJgMtMgAW~L5|xFc$~4lU`CT1>NVT(1Iy+m=*K_a8`bTi*>h+_lz|Lj +U_g=v0W2`nwrDY6224Pp^3in5z;;efCyF^7Nb%Lmh2>qhXH#~XD?oW*~0;6u$^E^+G9+J0Qf +-MjIF`P^J43YIVY8I`4Tz!7fsfI|3St(u}8+b^x8s0Lnc!5T8%#M +@_<-{%pYN!)MQGDMt<3H%?h3ky~CB8G-E)>uHJNL~V0v-^m7o$i7B}K|MgNX5k5#74Hs5hYXpC@OsKPtc4+a(;N|o6(P()MI +AyJ5LMHR+FIv +(k>3pI3wWfA3z0$xW}pEFvAwB7jp1tbo;DLrk~PjF!?y#XP@^A1`%Zkc{uWT51U9zz!l44y=H+g7>ek7xTs2;7 +KCiJwimMrEL>@o#pUa}w?5`5Sa5eUE;St4Pp&J0Cw9><7e=@?s{uyet=2H7;SP)%a^pw_qfnqwzJI{no;~b~JcSHhi$;# +3Y6l&BI1M$N&cEbG^5m+~SBrM5efyYT!R12=%*G{KpD_L(k*6+^hSlht7hFL8lilc=#{`;DbuxufV6% +6xRQmAk$FZ}l&EP{{>qn8Cf*{jYx1JQNFE7flpYVuTIkDC5@2?Zx%RgQU7*x?ceZl^XEB*T2zh=nUHC +MWf1TVy%5CA9wLo@PH2cU&CC=p%lNqDSQbNt=mvBq@(Bc90d5Irg@!#gM9m5=4tb*cQ`BK)>HI0FxZjXUH$B($y`z5^xMFkzkn=x6in +V+L#3NBg}Bj>Gw0-Z`i=hQdVik! +s;c0epw)q<6%Ns&0GA?SA5*j2+# +kELwg{_7`)KTp>^Iv|tJR_jF&N0-DZriT_l|ogpggfZk?QOvo=DK5*=?o^9`nIo3nd@SejAhzM9(P=@ +u4Odvp;-h-lxn~vTnDAiiMfs(z9dBX!hEOR?^qV()*%3OI<*!mW2Gs%lX-tiux`aKU!`^V+-sEDtLpk%)w}(6H>^%a&kXWE(RA~4#~{@(0aEu@`M$z%;o +p^mOIBg$-FPtXz6V3zSYN31vwm}GGIR7;tf2bt#q%=w<%fIzDG_p;6nM!6wE>h1y4ea|i9;sfu?3V>J +V*iaT>XJSsd3Lb;%#kAUwwIF{W#SBz97bgjv{ZvQ47dTO-0vSE4%RH2I!7wBZZ15qM7&nMDE~ek+=Uk +3(InavHgD~3`c)lAcGT`xz(nJw7CfL#)gspBAG(sh_Zq7hGL7P^)Z5h5XALPe9`+~p|qv%om2mVm0?M +`1%`KNjB;je({V7Xjn>-Y%-Q7Eh-x4w7?KHgeg=|<$JGp;+m!((F8VeF+fF?l#=+j&9scZ{`tR;z2mJ +TBoBcS-C@{3=PqM$soy6O#aPlu+kzEC8^(H@nPf}3jC-8>-4Bsh%m+EKv_BS~VO@Eq%yW|MP$`NU@1k +kV=C-wAW6f~QW48D&h(^s0001RX>c!MVRL1 +0VRCb2axQRromy>g<2Dlho?k&YSV-D)blolPOK>T!w{I8V&|MVWe#zzpTB2=UBvBwKJMQ8BduR9}k&> +LGH5OS*8V+ZM^YYBdtJUhCR52nt%|%N(DixDNG2M5o)#_p^MMH{W+v{Gkq9DBKgw%v?l&E{n3VVHV;q +I%G@?U|WVK!V3Pvme6-PWxdZiHzkWF4H@6XfE-lYafVI#Wn_g+MVT9Iv*RqNnx!w=laXUl0!z1o51jLN3|_$-tZL?nnK&H$+ +|-h438IXi>i^hg1RSEuGVXA7)G3&?YZrHjqwvK~6&=m60FFn*~0+g_Nq(H{KtzCA~C#V5&fKLe#`eyz +y^5t-oRO3*Lcv*O04^ki@dHipT0g7_uWr3!RlMPvN?L-ID*@+T?MGU-Mwd9 ++SgjeFn0m^j@b4cAWQ(^3sAOKMzVJXvfG^g#r8&e5163GJ()E!=F!US4QUouGr}G_2nS5;@U&S2goWz +kFY$n&SRa84oS&4e)b+`*LR;(|v_?z>Dsj$EI~ +hmZ=aHOI6Zp=p@qlJB)seNv;Kz=!=uxk6n*EI^Xl=b1_Nw)Yt}-pB9{3lTutCaDcN!87KiR54-1^x!> +1QoRq@`-z +)!dTup!_uxsxumiZpQ@s(?K2uE+4jNaDz3uIDt%C~y~zz>SB@=DGvr=sUCMOy}-2i}rZbaoqEA@8g+p +2;ni7Po&(l^1;QeVPkvvUYa=pF|E8Qe6BIa&Jk)Nz)em!@N9@)u0(BGha2*dLX!Ox?Xj_;-52N1(&>nM2g(e;?j{}{Ah48Dyx7|c;IA9)jmWUfkN0xL2z0B!~;qboDseI{L{zVPsPXEe}7132McEva +WE_@c4z@|EW(4ZeZ9nViZ;XH7&$Tv7HNAjQ?RQeuUH&LW4dszgmy`1BeN{r0&?C}kDA8;*+LQtwZOs` +`SuLehk9ZlgQ6YPd&ov0gi3?Q3n1Uf@=x0E{j?srSZYuR6)?AYZc3MMCu7gdrJS`?NH)68f?0{-mJ$6ZtCF}IG@cfF@A +EX4#Llx4*8-Sxj`?>lNdM-mF%CZOSUy-Ue^To&oaE7vijuW`Vmc;`Clj`*QpoA@f_w|5dV(|CXAsvh~ +i+BgTW2%+WSrPMc0%?NaHb`f*AUyO{g}fK|6cV@A;AN^~B@QDXqN^HpLmXH_^`_Y1;42yco?-nq?_5$ +$`znhdCMFvYaVJb}u7!9oyl`(56-0?%mWJQNfRj=Pp8vo92W;Quk!BHMRnU-O7=o~Ava7|0)=(k`;4y +Jshg<9!EJT!9hCNZue`5tWlWVR5+~GD%-Tzs3CbTZe+x#5T`~y`lmiS2l{re`Iz^7T3O%FyfTk8E8I> +3XigLS0Hus)K|vQ7vn@{O9NEfI}#P!4+sLvfyHEb-Yc*GkKGt?A2~4ob~Lw29^5>70YJ8+7D7TUzMy1 +`Rw1nhnVc$l?s&JJ_o&;w-!@Mc?YBxgmbgL^tD`&ooLtXE(*^v(28#Q*7a{o3+e&j#PIRlSfH4PN$hU +(gW%WOYUd9mQhcj-g6tE(zEqGS=|Ni0`9F=(*og1$2_^<<=%+v;jsvNS +2oyRl>zT^JBZ2n~qT3bjv@tE(l)wM^mRD}}RCyo9(j?;#LTfFb-Vxj6DhJ?>!5nX?>;78|!Qf#QiylJ +qd~@Od4F9&xn@?dtnfm!S4k4eS@PfB3dFN@<36s)lcqy!cUioeyfPA7WwMv6h*4h}HpdW;3e;F8f;eM +$GR30=1@Y5%h$MIT*|^|FuD`7?tJT__HZF& +2Tvuy6sw>2f4**C027MAV${g@azT{y8*!*?0O)!}qmJ9}P8Fq27>#x9NyA#xP6REw7tFb&M33O!C89>{rt>?~1^BnRfaR5j4o*%+Y6jrHU6U2Qc)~US8D0DiP)h>@6aWAK2mtS)wnp4C2lLwx0 +02)o000pH003}la4%zRWN&bEX>V?GE^v9x8~tw^xAk}Z6~qO@NriN7Hx$E+dYEgwNw73AVy7#X1_$ay +Nt{o2*W;ZXZP@?5_d(u~Cs}fm4rqYZ68ZS}zWE;c6h+adA?1=8(3B=Y05&(l`d8=FPj +e0gKpMBX87eSmQ|&SMJzH|z<+hU6@ax-qq%Axlqy6eYokmeDqZpC*oc)XR4wxkVe_CfAi8K&T_6Ed;? +JzhHeVERGpeLP@)>g?ZcCs_WUx}3MimW!=eb86d|8%xUOoWXAc=)CdQ~K&Q3P^a*5yW|>9TFwTBWJbo +2slEA?K#d+eW4QeZ+9fw#b^Y%#8yB20&gp&%%bpkehr%1UyHrOvTN+>+82yH#g~vt5?@kJ2$eB53(*m +s>W^uqDgeIP#+zp@kqeG>+SW+sraF+H?p}Xi>5B~saS5BG;8v74HC*#x&c09o~n;o-Y!%>U6kou7qZ? +?36(e88kIh*mC7gm=6RV(7M>;G;ynHS-RsL&SLyZn?Te{+cXRbNy*R&kag|=ad^;7U&eEy|^ZGa%jlj +&rM&7BEHIR~Bj#n%Pl2AQ4B{EO}`1h>>=@+16UuL45|4U^J0nlP0W-|erZ#Q804e5NLvxdztF62hVWG +AuJd@SzN*3f$1mDU%%o~~&$pu{IxocZL88OM}qdC&WOn6Nm@+O7nnbpVcv56tTjdmp3YmH +FH(*kj;^VNv0u+#mxb!B;8GhohhRm>4N_mJdS*ZnRZ?vsj(GkIaZkVu_%AL#1+~bHn>-a5{8($O-9Dz +2qOBGfFZ^`@QM}q)K(kXPOw(3XuEF+zW7*~nf(%q^lE9kuGTZ>;Ff#6GA(-xT!MvelSE@lv8yAy)ku? +yQl1)>O0~}LPOlc3cC0vVm-$$$z3l&X8#QO0^oc`R<2giggw&RTiA7)~vjCL~lGHbGi+nJIBanUfr59 +4ka|HW)5cmknGfIW(G>8xhaDpVRAU2bAFBd%vozHx}`1OQkH9RvuK@{vAnWlupv8h|tEg=s$`$6VLc|`Tvir%&bo$;FDy2CCIJ9yNpC~MTBD(-b%78^L +V#l5UGMgh)dT6Es1#|LJz)T_3pgDK&O$#ev)*Xq|+1ATxA4?jS8i2r8-DJzS7iu_B2_OuxZ(2kHN*qaR_1^m}8EiqrECw<8j#K +I(>i1r(#2!$kbbL=a>^f7UapS#DL`OYrVq2F&XxNH=OIse{@Z`wz_|dvbQV>zSw|in +(KQU9QlxN}#MwG}BCH3mV!9xIgp)4QO-eD(9QLPw)Vcwu#kh++*(DBz0!On^8D?YWPsox3nemc9&U>i +%t-J`19$kPI4s&%0b_R8Txufik7C73Aaz@_+f*sc1ipr`kKW+~j>5O0kD*TaVTPY-<9_$?ZZW7&8D$~ +m?*aYtg@fvl7$G3QoLHHD_t%t?mKG1vuBlkE6WkC{A^lfUb4w?vsNrDq*m;D +GFJX;pC^()BAmhL>wz;)U^_i(YyL#qMU`T!ON(Jv<@>r!XR8|D +FX_C7Xf{2KrFfd8AvAAHoz^m}h?a6i;fbdIt^1N;1?HA|jmj^!Snp?vew#j%+@=q6iF#aK@;+k^~d{4 +miK{+&-CorlsA9e$Ll`k1>TNMHlrz+(y@T$zM10jUq7aCb82bm!G5ad9r@E#B!6l^GPC1yoK?pp_u^k +lbT9LOE8CPo?+f=9OT~0x|2Q&VYDG28Ds70xEh;TPTu9UGT-B3W9M}>w9GPPHibk!+8%A9!J+#KMJlU +NfdN5mbP_%SP+_nGeOS)n!i@tO7k~QG#$oa=zjP1)j&3Q2bUPVsd9x2{0RNMgnSBC;Hh-IZPs9`*I;I +HrNm3R%-f089HXuCH?>SVLXNmUc{MEXx!dvU0HN9Ea6Nkm9dw^JGs{=F3G!@^>B@3Tn<~C>F{D8*5=BBeg6=9BEVvy>V4OqQtxMD2>Y!Y +h3B1yCtBzEhEEK%_8gT9l#mD!#7e$8{&vVDR;ddsy@%7m5*mSCg{ct43iQ|g5&@+VIQM-@IJVooBhF` +q7xqW^9zzlq))Ywf$)YFGMN5C3mNT_{!Q{NUYbC4V$y{| +WvC+C@&S5;2fJ+6FXJOQVC6B~pB)0P3Q|Wy&-H{GGYwF6zXPASi5Khq!t-d3Q3rR_xMnBG@bP_dnt^B +iFwclzvLOq4T}EbC8V%Urn39CVd!C7JF*e#KRsT|X1A9|jgS}Pm@@IQ7aa1IVMdILh^JaI$@x{Wx1n6 +W>;x+ChLRW71#*OKX+n8QRplD4%AoKvr4F}=V6>t(Q@KUs_2tJyyc)R4w;&n-w6hB?u2uispo$H%AJC +be#1dGd*ZJjCq^9)k4;df5W!po96O9?V8tok7*!oGvR&&)5oe9yhc;thH)E6XS5hfV1WDE2S2Fc^A|I +~Xye@9<5AWb@Y(*f-j{5Ytb79CV@B@L~vJHP*YpgIykTH2V4HpHI$B>(~crnURtM6@it{}k^A+YUjNnE +4A;6*<~m7plQoo%B}|9;Lu1e}_to(ft$=(M35G8D{Nw+YWDd-uX62Rn=UkZN~x8zghGt;Z +6PCIPpl^$DiY**Tm7>voj`0IytEb%>ss98i6e@b4d8S4ABjp?byJS@A4q`sP`nGLC4q_&Xnfka6#ToeD|fi8#+PRY4F}8fI&83VfdKyJuL~E+ITS +2joq~X@QM3xC|eBw)|M4nkgQCC3Zd5JNP#Ktq*s~P%l|lZZ=SoxsFBbg-pcjlG-An95v-e?cnMvRxDP +VT4#5BW|f-?Z$MEv8@YwhqH`R#M+%3n-8+yz`GHTA_>`88?!Lo!oTG+^z`v>K1-|jy8z1Kszgy!QkoW +&LzH4V)2!a{V5Sw)eAQEhE-uj)d`z&r?VMA=Y7MFo66=rfrDk*})Tren|y48b{XwXI)KW# +IP#L?;%qk$75vhlv=sENVOJgZK5N}R%(m#p~y?QI8F^dn_6I|DSSB%@I3lV^H`Syq +;|*N>W55LYlyCAC#|VZs5U+Eu|e4SC7LAS9U$vM`VgVtkxQNb9i)%S0~#_w?-J +XxrL(!ETNdfC+8-|jsQOn1tP!UyqguHKE%)01nk7pOTWOEzIp{bI)EuJuLM_|c)f3AhRR=1j{7NldxO +HY=RZkpaq|KE)(#l7X7QwzSRPa`9W&O+P#{~*|G^drWQroH&gIArHIvV&)YLs`kJ2y(fN6VUw+ZHyZUwea!h7GU +0O`^im9TvG9e|zu9}&$H9Z!aNK`A3osvE#&0uw77QmId$#BW_&-of0|XQR000O8@1eFv0<+G<(;@%>z +LMO4Vi8%9MW}9O&o +sWnsR`byk!~*A}HRk5-vlmBp3$xs>fDQ}*pIs;e++C|;0&F@B^7a}qTBCM +y-dT_Dvq#U@E_WR=%VqKdm@UEfHRbWI5)FavI~MoEz=!H-k={qXLM{Cg)=>j2PC?1BIk2OXY3QCG@9I +IC2fl|VyyNHdy=Z()_bE7Uq`=c~T!y3S>3yS?7NKI`AnBAZvS+LT2r@7kGY)@>u@OyK%tZK{f2;YVIT +gKP^^ZC5iQ-^k}Gn_qXEG%o<3OkGpsRNfV;RWs358+e`K67B>rhe@TXyV^AMTq@}F^v$zx&whBGKL6? +M^OxsmuU?){g9#)E5ZDCR!^~yAl5;(HeOt*U?4jAzG%u=LR&5GT!-id9+I$Uw$~wzmH}$ds%)ZKCis8 +faO;LHnmGwOH*6p?d8mF)%68>3d&9!WZAbppcxor$z2Rs$95Ksu1Y{+@$b&}=Trj?C_`BkRmQ+@_4^Y +-m){bL`9u3ee#PvJX);J)y!nB${8y?q9JBh?1TF|t=|2h}#+9L1LH^b7_BhL@Ep+TuojUCi4({gKJCW +#5~3*yqC@^9=c#A)x7EgYJzb;{}xLIWbQ`NgRfeF8$XK|WV*&5W_6q@C7Avy)y3D&-9<0*^y$z( +$RzLCIDmB<8e7w-H4~2~H$Za~ ++{MY~m$oMeF!?*-d=$YZ$t3xuE~?lY>jHQ-zMG;t7I&bmhJ*K*ejI84BV5%-;#rLyS}Fbt(p3Eumiw% +!s{yzDFX3f&0Ii&91-rXx)oszP;t9yQ?rt)5*d9!o1{XUAB@}~90|nu)R++7@@=V;Fh`Wm?m%gF%Yq5 +#-WF1)nUyFQlIqMOnVN)8bxaxQVJ3DwfwO>KA&HpiM0D_B*kH*y;skLixpd2>wcLr04;LeHs_{HtQ4T +4UzjQoZ=@z?toD9@VPqMA%aR^>h7>rCT)aeNtyEN75jdcQgsKLz4@3|22Qdt}J)jHmuEiIOcSq^v93c +*0Ep{QD2np4EpShQPH*`v~Z|hd+P?GaLbCw<@Z^2p5z2rt^W=mJFm}g*tgp&8<$nyukTget0~1u1S0O +LA*zg@xvrx_agQNKE?m_%!Vyb@qbC)tv4#Bw?awqx3acw)M-4K;kunnrtlanrSw{E)hT*?nq|>6n3v$ +Litm72#n&~sx0SV9V`I<4{8`)G(QRdLY^)S(mq%Scv#vghy@bgIgRkmcxRI&wIQ{V=vJ8&|qEjaa8GS30typibZ6yWdLp1 +S?19y8(JNka}{Jo$GZ@RRAq(UVJeuyZ{aAR+1neKlTfTiZ7-4r4>>X^c!0jX<0z<8*QIsXD62)5xz&i97a>X9{zj*sSF%2DOTByBxTyJ3Z-XnA)pe(WurRJG@0@Axqk}%opH3_gzmj0=o?yDpf)q{$tTyhS+i7A*A +V&<=2MlhoibR9>lZ~Pl9F8lT(`mA7{k2sxbly6a`#ZR`#x!s)Zsm&cI-aGQ%VlDBLSeVQ!%~eH~zk5+eg~ +aeEK<+qb8pkN*|brUO~}y#aKn!0Hf(BG{2VzIH3?XltVXjVG_o?i3Rb-+p)Q#1RP(F9-t;4cj=<$H{_ +VcYCwAf0Ls%U#SiT&>;&#Qd=oBgSsh}=)GZsO3u*&M%+PN*0-YW8l0lX$&T)6WT&AhnnNWMXY;{A>p} +g8O?GSSBn+fj?|=t*n&)QN-IR57perSQhg?E@7?8ihC>9MG;Yjc-#hx&nnWd&2n2S}8($0}6gKh~(R$ +!oQl5IBJTy2I@%e3xA*HFo@1k)Vt`R!mzpyuOOLoKG==yCJo_|j{S&`t=N>FL9Ba5fDR4e*2jj>!zul +GS-Q_g>Lklk!Ck7Th=II#3upu~pZeB=TDu4;O8QVJMlcPZ?%gtR={C{R<4`VzJdf=CaYx{po@5yDOxk +SDw|_uC(lNqJ6O*HV|=|TTDncp87k&mG!6Mv*Tm`HJfb?uZ1mL@6Yxd5C^c_m +8>RM6vozQD$`%Q4UL7+foGU567`$t=f+{pncXJAOal^T{(t;pi=l1+J@$(J;|sTfdOivRy%YJ5@^b3_ +HBYRD1NDrWmw0#Pgee2&_0~EozV`mImOhHCK~x|DnJtYbA~JLUBwFMhquc{7@U(T;48F%I?wgY$0t_K +DOV2`0!Ifp?R=3(P_X2;&xSlH3;^m0tiNP${Sh18_D)b3$hgapuA{6(t_|5>ugKl&`7yLa|)AK1)4mt +>X`dM^QR9m?{YamK^Z-2|EX>Rg2tN@8=KR_!U%hNiWf6uI2qunj?9IOO`LuX$UeZBXh5Q_VPe?V4lE! +IX4i6Ywe78>dDk?k(dC_-cjOmiAY7a+L;-}Vr6Sr;O3(p?Mru)(oVX)kpjQw~k5&ijrNoAd0<~bJaVL +-jE^*-Ta0L%GMAAbJA6FKGyimAC4lL}&L_mdK)=RJgfv`xRen@SYhKWa7&%{n*>PsQcY$O_3JluJ2y@ +iPmRfK$0fGi!5C!FhK2#qG9mxt3G+RNhEtw88rNg#zLL7s@$Y>|z?au!N9>q03?aw0&QH-`i=2SH+i5 +kUS@kdvpn98~bO?r=M?^Ma2eC62xoi!xg#lcALI3GKfh@h@BA?VfzFBVH0u)n@uMIZoy69tXq~8wB_Y +H!_9>?%Tt}p1^N;T}3T>{#lR8jQO!&7qzOpGAD5YOMFysJgy7y84VGzKgcIPC?5ho9b +Lr;DxGy<%>lC$@IC+6pkw^-V9zV)-Yz#)xYSXtN&m0-HXmO9RHH*uBZ0@OCKz~wkXje2R$mC>Y3R2?z +(>HzNPHYX-+}6e1^`MarD^7bLfRF66y$8qZbf8d;aEa`tsGw=TXooOR=4@T1X@Ky4ajcQpvHciqQ`Ya +@yq_=&uJGqQFHBIG_N4UnQG*gAq`A3Lf@x&o0c_enWaT(Q)&h#WiKqRjt|(w*M0PUbvBeX6Jt9A7vHm +$S;}%6rp>Hbs)P!Ivm<%AMJu7dPmfr(q(Q1%8n5*288>7E5mf`w=ttBM&BQe0^q0P87$wtZzMRcG>k5 +LO5VVdYy~CaaJ#WrL#8fA(>jGi&tVJIYw-UZU@Le_sR@dL>!nRbIKUe!4z`y`6t#7mm7?m_S8N`d?qn +urXwU*lx-x6*W`(UCz(VoqZ%l%Es$tDSJMXFZzbc?~!fztdcEHL`xB_EI)pk$2r>7hH|c$^vO9jolwa{<24js+@pll`a*Rad@i>3~ +BbgO&&Xr^0lMyfMOpn7Ho+kQT+AxA34s>0KDFC&{UcK`F8{sB;|pp9JXC51`E1Pyn)Fm2Zkgjc&T#{j +9UQRPW4whq?_Mi((L=8({2e+Y!hfv%CWNXSB52(fD?X9-f=^#u&Lc>%$WcBv30{QLK#w(2JCHyOGm=X +Ce<3EhmWJC)P5aJbo;`fAa!dV&y=)mAJOl~^5!9{PbQ4+uwTUIsgA1qQQY2X5b;hbf! +1_T>3Q}z>%bPY*>cw*3_T&4?oy0baA4l(hQ;$&P=tPQ6QibIWp(+vPz5MrP15(>BmXfjtvW>L`$)Wo2 +b0h(Lk#ab|HTy>XAxh7f8`1iEM-n2+X6<8=ENwI)@?~gw`wv{f}XS$O@Xntt~we_`@?W)eTwYbm4cuJ +Za+%=xH(8WR4%B!jJHLxtSZROSy>Gmdnt$%tX|GH2cJYnFci^HUs<6#U&!t8=oYmh**i(l=aUHa +dlMfT~%O)A~Dfra@`2Sq0iQ21+XrL?#XfTrSN1h|EZv88!Yn^qb723Ew_|F1j=<-26-YPJzms@-1IWi +`4A8fsRBX1mLLv*1+d&ZrtFYLms&YtXKIV-4Sb#~o4VV?Po@d59d1fj`^2U#Rp6E~BBj``*uZ?jPygD +j?u(H4(KPTSnP7thFhlhfy@ThOQ~ +;h-X9f6Z#DCj|xL;aP{k^MOIgST|bk-T>w-YURX|O1<9(EHC$ib;dY_i9ocqG0#`{}#qC!oracx0~!I +u$=UDXO;*#Xar5aN8urhG<-;Y-h(olo|P=xJzFD?em?PX_H6gdY=T7f?m_%BzAXpiyFL;4~5hz1BdfK +vtr@HG{W&zEP(H_+|+C9LvydjGqMlbh0!yLW>I1SFfanE-;gH)a~g-34vztRPiFpR^71V6d4dNAz2u^ +7AxwR}0a$Sp{a1_<<2O>izaji7ZZ&9fHa!^GD`EG?pTrm0(XW@&pMSI6SPk(ZnwWC9R=pT?(1Q7k%T1 +*>n0znm`Wl2uagE9agp8vGa8Fg_JW^9Ho`O^5gNXRRid<|LNRH!6Px2al%RK<}1xrql97GEIVh-{w;5 +n93-po}(XYHtyG6!g!q5)(VKS>H2?ndG%(q2zeRSxe?uW6=~O#W7P6vd;eHkt@SN +8=Ek?Aq#Q(7Z^y!)A)5Q++W*YRXM!gvksaq$9;%OvJw5Be(bxR_f(5-5)$yEP|mYYNboph{?@5hBYj< +h883?$ZR06t}CS$zJzpYCO$J+aa~WUC7rjdB-eO(oFiK-S$C}u4M +%krV`r#COikF*c+8_0=<~@wgqVJ@_eWVjA-RfYNWmlBY9X=S#<3G+)d@3K{BrW+xoVg?@j!C)P$cDxC +$!wR?we-=V(GywD5!WkQ1?x>@@T1T*RceL$9>gBJ8QAppi^u=|EbRtMXhjwKJaz21ZVQM(xbHxtI>)U +(337(78P1v>!EMDT#})Ok)Fr(x@a!CMp7NVq*9ctrGq%!n{alpp%1;|9@*km@?=MUfd+%Nbww__J^aO +-7V1QOfDkuf0BL=%TBeU)6OP@0pt;;LQQW5hw;Dv*2Sg&Croc0Px6soa^Jk^lK&@xOfc4eVOFNQtApE +EUeWh?vqO1GCA-89d?|$O?ztUQi6F?U|_inya+rRF1VkdA#}yQJ}N5?a}gh^DFr|&Bb09;a=lKDNSMrW=0UzoQr#%uMMZ} +PBY8T;rN)3s`l-P-(L!<}N$2Yvb%5p@G1|L!>;HjBIHXg^33DgQ5AC|0K^2CSuU5@r_PH$RbFFU)oX8 +c1|c2Xx2tw%f^EYN7d%;ft@2kQd%4CX%>@E@E8w(64w$z!=d?q1--8K?6+=1^^4To)0SQ{v%(vFb3s~EIR=@*f(ISfV3clG$Vr1U%?u<9 +9z`ghUtk_L<%n#LAB^#bEw?rLgPv2lmA6zqH3nJjk7YTB?Ru{J$nvZQbKIcoeh$QsHc`EKQnD*8scsX +d2)1$T7K~m*n$$7?lV2@h0_W0UJ+zBAy%{A5V9Kuyz_jz+LG=c~C#sg& +)W8z`kM=nJp;&+l>vYO-dqz_BLtM>7E_&NSuQTD)10Rrq6tsM6K5jU$9Urs=oM^3)F{9PmEy4AHT;S;?7g?U8-(!lvpI5L#7)@pwqGO>uK;+~VQ>GPb1A3}r?F`EKMX~I_l^QB7?tdiCG3v&B6r&HMEap +xfGT)Fw##FWgjIh)yOfrcRuL!S{=*(M4S?QkS2;p$A7FCUq>rJ~I(B&VW$?m~R+{{~N>37Xy4+u;x+g +=%E^1~^dh~=-vW+x0@_y^9D^4fZ$_Lw2oZ{X-7aeXrgq1R^DCfh<(ij<`R)g9lv2ZTu_=#2~GE;A5X_ +*8M3$Eg#&yUrOqUx5vJ?6-dLGqix +iS#pSKVA^7&Wcait(}oG$bnTeYQExuwh`OaTwR82ti9NYPQ^OczQr#1>8|RHozxz=G;N5=I=ee{hY3bW(9!7mc90Trry +0zOC-gh;)c3f>&fvSvP7i_aDK)DX%*Vh-{Q+nnIPG$I)h*-5ZAg|4r!XVq!P`ikHRwhhyxx!`-*YDDA +1{dKdsAA-4Qq|>^E~n6x_=2>f9JM%u)}v>T=q+s1*NK8tEW3wE +Q!#_t>6*rTD`Gr==hfKi3bfPkGQ}X;^VXOfhx#m(N<>^tv3v+-6W>k?oK<`^rRy0*Bo6&$bgp(BK?r( +A1?G-!@qbs5pZxBTJQdI^%q?i*iVHxH!Qm0ww(Gd?vw>B1=qsZnj&#<7$% +oUH7(0NsK`{{r#l^OT05Zl_OxunB?jreYfq}(eYMnfyTw7|8y@wMq8*U>p(xCx +f$wNM&^-H2W?Ojnh5=tqKLS?_9TiJsN~*T&4HA2Z)hryepL)Qm%GAV}g|}d>n{vX0HnE_6#qcDg;Tz$(b`Cr618qN2Otf +VpEQ70L*W)G2uwZ!|QaoHZHhAV+C&3p0qjG-|uX=PJ1RVW%)8`nbyN1+AR&kNw%wZWl-trkr$NmddyPC3TXoS=?ThoI26 ++(TeN;j_L>%fn(16lk|q;UgF)Nyp=qeHK^VJLHZ0;pL@eA?FY<8h}WVwE=N1r9H0$)L3;_STzdd*kq4^UXQ`_2l_w$?8%@0XvN08 +s%fB>^k6+SRgy{uOaI| +PjrJ#mByJi*9qrs%br+9z<(Gfm4LjBus)Jr$`#(MlsSJ9<7W&t$M@NIrN0;erO>P%eO|7i*LirwI^T* +N&}AY*RxQ%7=8oLIFv-Vf%c)vd5+EXXqKB}G5c-Qg*CjHg09?gU*j9nPFhP?|e|Jk)i$G;Mn1NVtLU4 +;uJVRQu*QVYYkSL+n4%Up;t>2V#*IWACpZB=&hPR9~~@3o_*$x5Ww&+wPt4?+F(-MTSlL6G}`sH^*WB +48ZVgJTC2BN)dDG%+ayPtd)3jYLJiFfqoLebz!(i<8d^q#NBy~rNt;XqnFxRatDg8$P8QRaELttvFmI +ao@JYv!|V29yY#Bgw{)|?Rjq~;FzClFS_4@9MSJ1>0QX)M+&Z^Z3<@Ipd)3}Y?v-iLiHPVzHdvtOgYP +=@5m=8t31~xo7L9JL_NG4w$L;=Tluq@(_Fll@HFE}&v2!PGJ3>>_AF$Tn0#JNhpuZ#70FRwfZU=Qz_A +UuLQM&t{zP(kH_?cjTeY*Wn>Ga`Jr&LGFrC^N2qUKxy$O)@GQB5M2?}I-qS{R~0N6t+%=IdRj4jqTxT +2*J-fg?BYhiB*X%OM-u3+@OrtRLk+O@yiC(4ZynQQ8SO$kLU+S~Gaj0@DW7RgK=3AeRCSuK<^$z5Vfh +U}MkvIF1e-1ULtMgPG!aXFCkxNB7T|F^vR%M2CB2&Uffx9e96yxY$(%j-Pw#>5V!i)Gb8H2<#{dcYr= +9pks$X6Ve^RbqDu_qVdxUX6JSn=g3(YkoLFapuEsx>OJ*Vb!_;sN;X_gr~GxtAG#VIJa~A7)NV182IW +mfx2Pk}*%*39k$4*i(~t}&>DpaCQ*TaKJ&N4xW<4D;ax~DRQ4iOroh^rZI!8I`l%N!JX>PmqYvKl1GB +Xf;N}I!Y1c_43ef5y74{+m%;k)?H*S!dK)`(bW_I1gEFJC8z||EnUT1W*2A*DBiyTAR9GVnC0fXWANmzE;d5OxyG1$SyD&^`UF +70)a61;EWyRJ0j=0=-CX<9z}T|yCxM*9Kd@sKbMhh3E4{rtegb3sq&2>KxK(=3xt@Eh(LL7Z&VwUtcH +-9{mh0B*lLoOh``7>j9Xd*3lITW7+23fYz$V8c1Z`G)Yr<&twaEOvh_`jrczHC+bsAOw8G|dBApBU`K +c;2y%$*+l&~@5HPEEi7h*O|WK~wz8J!|yA=F38R9}GVp>D*J)>d<%Z>gL_Mks@+?@D%U+2J6mc9WU|ZLGke +Y6fZt+gAx0>Dl~ciaB8m(2vISCB0CNHcQM>6A0CPT*~Y;+VG2PRGi_$OP5XcuovyN7vFJ#jt#a$goT& +Z7jvXDaFtMl0N0Rma`OW*XL)H}4H)?w>8Xf;>^4$Nxne_X2z-&k)#YGr6m6n%3%&FenX_l)L2~#R|0usyX-fT+ +Vm#BC%fqZ4Ktkh8AOeU%N|mE*zYCMOYY&!A;kMC!|)Tmwmftc@(`cx6jxcU)4{`AYY0RmZC5;GHBwyW +QO>KMF`r?Lc3=LmW0B0qJwX{f8;z}(5dZ)HaA|NaWq4y +{aCB*JZgVbhd8L$1bJH*ohVT9rJHE6Wk{`g0&=xqrWI6*JGaG9i?;uNNR|@3cBl&|U(1y<7o8^6JF*LBs3?_sxVV~9e#9dJK*34nX`HU`>F?^RVb7FA)(!@Y=?+u +!t8uPaDTVr@_f1|EQxZ`oi`esCJlTFmDYVqu*L@5qs$Jp;f*VRry7#3l5zoSWCY4}1(;N2T5gyuAxlX;@crF-ZIdanWEunK-AJb2>=ynicMebvaqMR4uoXJ8kGh +F$%^k~&t!^}TX;vpA*II5u9^F2p(uxT+!ON+1dym?EWbH9D-L*w2w|km>my~cs8%e=ZRhnkP=%d!MXNM@x{!jYO&> +6-WE+Z-3`A1AqVs%JwGjQ|?_VlfVEN3#R|Wq$!iv``71_Brg`~qpAmk!O^l +RH_2?a+%>yO&1Oly*_Kt4WLI^$-Zg3_e;*y`_v`ZdIxnuxpY!WnAk544TFslhENTOy$Tn)x?6zxVO6Q +HLnzCHi=0&}?KTG?ovgJ4VMm77bvY)nPoqybB&C0yE$*O|7Qy)n$w)r-leNe@stWqkOZpsg;PIuLMon +M)5ZL_LYNmeKFdd7d>y?Uj7*{Qm50O&VP7v|-LI%#U;+ibC@R9&|PXkOM9PotxRp7UZkN#@ynr53YoR +c;AW`$fx)a`EHq*FU^@`}|wy +?KtR3x=`Cn%`;4&>D3#B(J#)6*ZKDMKMR_}YML1AK#8h~W=3z@g6iX3Z9TG(;eMOfO_g8m@aa|AyeN0 +YVv_uk@c5IeYI^x}U8!ubKQHPgBhsRe=fwva@Z#r{QtKD_S}{f#*pEfM+XA?fuahHZgp2Z~SeMztwEx +}Hi`mlYBuYyhz2KyED7HB{WXzfUGA#60{Hx6m$IyyR<&1mX~r<^74hA%*`&9ky-s&YM?B*W#Vna!K^Y?T#@wVG{+0cAkme7##J6nM>@ +R4+hQ)$o$wJxJbW?^Tg-cb={2Up1_gHIY(ME|Xf#iG?L)mD9-TWOSj_DPgGDo<4qjl{e{n|M>WqYJc& +6o{f(#okC8<05m;c$2*qKjMB +mLj8U)nUngOi_rf!TYtr;j7I>513U#D_F?hgcD((?fKIQ7PK}ie&JIIIjNsljN_*@}Cp>&-m*> +x@3|bStubw4)$tdt9kufW%a7JfA~1ENbu^d+lecim8!axr5(A2LuRCBr3u?a(pcbE{vtIWPO*eyFSE4P*vY71{c1G@j^JyMh=;zRcAEFZ(KDgSC}kWb0Z@oG&ERk?c=sQMLZqh0|2K +8qx>$t@;d`4D)^x9_ks%g$hF5d@p0^1wsvg$LZ?A7>O8pv*(u%5fR#+5xxnRnNI*|OGT$d#n~nRbecR +(JTW2>ilHr^H^(&ju@)^ySMd5t?bp!D?1jiFA)Y4Lgp$z +joUmEOyV$siFJ!LtGTyIIuVXSdpj6pbKZH`!V#tja +#%oNdCCX*9(Vw)8u?fBeZ}MT3l5_sL7jE@(-eI($cbha-|#?8SmWd1j38xp7{rbX~{^a+NfkfU7j~(w +NI0alIU-5l^GYw4*(muB?Qth^)YAhc1Oqp?ydf_Fak>IR5c8OUFep5WVAexfVF@4g+g{Cc=M +)JK|LWU|BA$XLcSDhR-|pOGMd#)v__gzTDdGGFKC@_)T+D*gjV@z+o@GE3j6GHA1V~Qpn3Gz(TIUe1e +Uj|zAcj*C489#*KDbnu!X;8S8Fv+3=bz_10z-oUOn|UevkakLU-G@5sZp4Q&<7=^2>W&`gxVpj)@vIB +b18@_tZNm{wpdKI%~EgboW5t+FeWc&LfyxyV_O{#bfF9Q?vYd%4va{ZaeMr+q$%$%F(ZyukK5~`Ar7JmWNIqxgkzYd~uVvW-vx4?^=-WcDze`_xA1U3%_xh)|t_ijrMCE(MZvGQAWL +wXaS!vXCqH`0B`YMC=wQE1-Aga#e6|qfZ|#-nEaY(gK$Os)nZVuZkkFnqwR!;X3cTt!c3`Y5BZhDQKln`V<30^i!}&Bo|uZx=};IBg+g>65cCoC<|9at!)(gmkaQmr+C53j +dz*1FE41)fcwP+lT;)>KYjBGGez^iU1ua!Qo}SyT8VIA5pr@u88t;fT7f}pWZE`)+F5Z%Ua%JQbiN{H +Fbek8Nw_6PHgz__fFxY|H;ml;qhD;0dTBi;qEt}6wK1$mY+!3tsu@#Ps5Q@En{UCfX-{3|*E_5s7O0G +wM6)|B=tiVk3yARc_~POv7}t#=$`^sZUMHJ!v0Fn}PhQjJA!0a?eE^nSTWP#d7eRQgNcMQ&YJ}Nh(V< +hV9fouBfd2R5{J+0{eoDQj?$xVuw_bqWNH)D*msiXTA)V4!7P_Sb(b0PEK_L;0HXb5&jWNjVHMAXILn +}6d(t4}r;10mB@?dn<-G^+wQ?brspPgWF=aJ;GwG=)hX{smkncOivLF> +D!i}yyPBhu-N}rSuNtAadI%52AL6OxQda~pc3B)izSJ8#uCld(m_}Ijk!wvQa-&zW!)5ejTWA3E%W>* +Z39g{7h6heX{gHzUKYJTM)uc)cFrvgZAJ=~XzIS!ZGT^gC(o>~ydZjEQ*%8?MsPonf>e(gO9QYKk_PZ +wOgk1zM)Z_dpe>MQos1a51Qo{7X8F6X3u%SGm-4r}hKUkinfu}QHT9_wl@i*EbQ&Lg<4oOdt-uwdiq# +?f6L3R-KXW}lQYci!tQRu9-hou{dqky)+0vFgZ#1gkJ-Gx|9Kt>K7>=1?mos9xMoXgKep8T^x>XoyUL +8-7#2E6Toy^lCzxy>4%9?RNgAH`QP9LZ|8k`Ag=wD9*#i!HZ_$b7X-wNDQEtu|z!V2*XM0XhexbRaPQ +GO-k+3OBbcfnvHuW7Z!sKY7SE~|JEr)dM0wt{s_cfGYRg|w${Fo#qX^m|Kp%+pe~Y4Xn{2?XNJ1juo` +RgyoJhv&yU2Z_~!YVin&hk72Y#XHb`rw5^xSvU@tbB*A}axI+lz1r(-cOEfmyA0~Zt`O_sPTLW$Rl&w +1k-q>9mbO+Rqwyl3IVj$!)yA +QQ&EKmVt;b>zM_5z~g{A3$kRmSPk5jRj-_?i~L%H3nC+!P +t+l%0`_gtj4k+Smy$oCO~bj@B=atNtF4#W&1BfV^ore^CPc;nl0w7tYF>WHG+smz9g)(4HMdw2w?#Tm +OU9`840--OE)atu)A4|wCFid$-adW#^7*&3pPs)# +?1sNcXxk&m$Mzks$Sx#WoHL#_zxD%GNyYvg3$E}*FphUPler#6+F0sZo&6IOedAJyT8ttrLi!Pga>O- +THat<*{d)oe&g<;FL|JRds7K&P-9YL)7OT(<$(qBr18;X&bo)e?n6~s|64 +8%u7$7}qoLXzHmM3Cl7^whaC?V#=KHh#$p%4n_5-d2td}8m>3Iz6F4I;(7JC9cl%A7f&mH3tslm +Ny~=oEn^jfru2-nwz*=S1VqPxPq9+b$0=m0Vr0Zoho99R^&oLrWsmsFIg&w#zh_VoTdak#`xXV+IEWK +%CvuF@q^eAR^9f!R5*-DY_OslI_dOnqnMiT$FszcT)u%LN-apv~}@33k+FR9?*%ZSkiPK~_SDPOp6s( +rWUgXCwGz|M%?E=s}FLSYt?1@OZ=H!<=`S>va8XCk0znQ}#O<&p{uHLtX`nv?Wn+Np(jO1P0sU}c(bX +ZmM+ztF=!zKnh)MD`n~+#m@9g`?_HD0-|6j+3(Lt#2zC@9#YfN^C#308&BmXs~ORzaMmKbl()Jxhbpn +A*%H2_?Ufy>BpFZm#|8Rp8m0gHSae>i9Jkyf^^Nk^Bz)lEVoxBJ8PNcCK@GBSj{Vq8X7?vfhE@Dxhzx +=yMvB-<|56&NF4z#OJy?(x7z`b)I%9Tuj|p1t0uysBc6@EEm95_ZiVm +KaEC(GGrra&Vx(j=hkku$_G^_O_g6-&#V`+W +-%q+J!O`0P=TFmfNg#R?9n{AcDtzf7IWnMsxaYnM3lk%B9`BvC15e@r`RTW@{_U>vLYTIY-bNaxgrK{Sxd*c0tBQ;M<6~miK}90w`O8@dvSrXfz*cw +^;&Tc#3RV@GmJK;705Zp!@vqO`)GlaF0_g`;${O=F>kl9r0deeaa6X@fps@fp7!OAqj74eF7wc|J>YH +_w4v|f_2V#`{Y|#lQ9Z-yRF8McqkLEoL#uZv>D}#P*M8%8C0P_k(0l96a%|jQNHPZx_&UrRh9?W7HEb +_&s(=w3_{rLiFk7+KW`-=npJKHJM(s+R-3*#U%yAp`)ta$6C`sgRfk9J6y5{}Pu1 +h?F7qpUuy~Bc=Jgj8@VY?N)!8_W(YJGrjx4o{iMV}{pu!lM=lY+fe%t>yrq>lI!mdCSCBk2M5xaPI>_ +^&AUceagr#5f7&Hx{Ox+{Hf{nKhod?(&dXp>7z86Z?wA(+Srx^`BCMPBYl +9vQ+~_-)3&l35gBWIB@3d(U4E}}#8^zbmaZ)UBIst`Va5ne3l^9$$5fwx{1O{N(rA9@ai2s@F2m& +EKF_hQE +=pef(iJCYc@ECNkutqYgh81&JsK^1ix7}t%amAHq4-6qgu`e>-_rzJfkscVog_c>lf9aU0?s-UG&1uV +a8_@Y-Q^JBxp#rlu7g7WyebY&j}OJ;7y+u!5^rtrUIdd9vZ6K2g}T~ZkA@FheRd@N5>aWnYnE%3OWNU +2hw%-ForT^^jRW58M}b)VnMUnZ3pEJ0pI<_=b36+zNRr6QB1e3N-gUh*#VNvDW#{#}WJFW9XPc}6k(s +l;`pqa3UOx$1b&rKI_ReSzz>lan9M(2xkX){6nPR(j7)}@NDL$EZxQHBJSxfXPtOerH_78M;ARG!GPM +5<2bRGt9P6GChwqmSq>+Ol111BQS7J(F8`$X0&A9RW5X_2k>e`$|k$O&;Y!bF8%X-BSRZL`f15c2|i! +!R*%J(joV%yG+l?-Ojr%*gI8XxQ#OsUpsE;+y28J8|Y0F`q~u4xqj>nqenilLe_$o{4U0qChbnyo;jM +9Hz2(joyA(HJW +p3t``u7bfEj?jD$L&&Bak1X^3#5xT8%+UuIVb=HT<#i$>-$)hN1eH3t{M;?Sj6y*5E8L$({thE?=Gck +&=uf@Er_EwFiF-FfbGd>AKi5$eprl1Al3bBUq_S2vH1@~dHuVuzTjBd`uOnV!nN +U#tKrWQ1D&uNzYUg(mhJ@D#SBy +Ze;I_$+R@X*dLFi}OEz99IH46M8Ama@e78yizIM;Q^e9<(CzQLyDu0HdMmyg((ou*N%OYx$PR5@+W; +}5scy|)v#y*N{j*voiC@}&wD(%imAb~y?5y+mgJKID`!;7rPE(e<|8YKj~Mdiafg3aNGbr;*09_&FjI +3V%GH=sylq4%9OOE?j7GYz6jf*NWV%RvXI`>=x5oYoVci>Bm2miw_G1ZyK>^8@1r}O-+5OXZL_ +usVnY#5)ytXg$kSVP)ys7vI6XeSj7B&P3S#erLxxqMibINwJD;$5#$=h~>*V-e_K+WIXBt80$Z?`1IQ +TX;-$PWN7p1+tSMn3lEVeoGZlQ7ygQKv1>TnE44Un+EvgwTGK>fHiu$PDF6B^r+jSS55dzl$=pB_%rj +Tj1h82UV|Q&=no*7Gp2(GGoQzc|krmU=_dJ4ZA~Fwl|@y0URvO5A?`jH#!uT@*w#syWS!H5y=USISS5^H&0)mr)f&NNM0@ +EoD>Z`4QlJ7-d7p-cT+C%B|Dy+tPR{Pw?E0FGcW!n9)b~xz6c^O4hx1u(i2$-R4`6R(8E<$%jB^cx+l +IPILM6X2;=DpGSqY +uT;7%x1%Q=N^>2D=;MKiW%nhDri89h#CeD(zTVryK`;83yw?No%O3Q=HU0OU^-1c1&b=`X!rFA}BR4u +qM|MRrMD^{NEl#3oo%#+#_a++ZglC)Q_9c#IK!UgSm4KKZN_>o{3s-8MK^w5G9Y}$~nHdm2LlU~qq}8 +V-aOViacU3*{#3vOGW`x+CDc&bcg#<|DjdsHvnu5ZNgb5mBpUaMCLW +?=k6u~?IB-9x{=Oi9VIMqwW{WI?~tZp*F+17fCW)=8Lr8w0-@(xtP>2^PQcYN~O%Ri;xyn8bJ_seg_| +1#_xjy;rx$7Srsp`+Gq3LSB-B2xprWJtkZOx3mZfFn?RlGqmx@5iCniRRsEop16YV@-3hW7)n@@y&%m +)o5jgAMDbfxNiOEp5n5<{=AYc&Bs`N%ia5OLGd!9Ud@(OcFp-lqf?E3`}5c-(VNOc4?A963m679kGLg +gsyohPXTq%~*-f~N46prJI^A$Mrk_}Dtq*p?i-sw3op?wBA@oDPm!|EY!NrFTBILV+0Af%xmVb1LO9u +hawX)hfN!+1|AV21zK#&V9WeJ3b^?&H7BDbYLb_k$5q~;7DibHo4omsTUKyLNIx{J&t382|?uUv4Gfw +s!H=l{EX9pFn|EK3#)gOYy1kBu$!vHcWr9chRYw~DzGWE4>(kT^H8IyIq&R3exi%AqH07sEb*KWquz( +c}}mapcZDh;O&jtzDZN!iHQ)nAfQ`7*a3p+TnpDdmgkz&&SS8%$oSg8Yp1)R*%mzh*zbgnTCI2i&OB8 +$y*>p(EY$jab)Gr!`Wo>vi^AdWMDWytC{XNhUs7OZ6qnxVOlV7aajId)NmMc(Szl9{5&H(ka%VhJo*H +1EP2TRvAcJyxxg`bL^PzxsC!1PM?dNdmy{eKUa(~H#n}Okf=R(fHXc$X?ns1q^k8qQ5()41-5qQf7-2 +2IE_xR_JdA@oCVlyY{)+^ScFd8swKDm8khy{L2i$M&ocJijcsBcFmC2#wErQ32#&~YA-~CaN#s4hnkY +I+0z+*Gpu2{pLrA7Ya=e$^yH+<~;`)uyPNlgbLppb0OWXH@Br1H2{=0-18(yq8$BvO{yqBeQ+B7l(EC +{2DSI7_LC7PrYkB!x<$p_v0j%ZUB|fytL|GD0!m*?ko2%0gx9y3MDQ7c0rVLnwWJ)`2{G_vK7@`gLgY3=A +W{QLm}?glod@SLC@SGYKp-S`Dr=WTyXsZr`7Su!kA8Qm^3BbGYEq+)^hOfGd8BbUkv<25%na`HCXf8f$L%(QA#RKsB_eH1hjQXL1;|0)5b0c +-$mkx)DBIHSwN9|CHT7GISBt5K_!`#k-j7{2G0w0<(D7ug;kh+o$^(aqnilb@Ql5{zoVG1fQCxft$LV +Po+)1fmsQFB@hX;aG-&37qIafDD_1HZleEPB4qU*_=aywFhrx2w^b{got@A%d +wW}=c1Zhz)y&qf)S2f87`@A;e|a+f_gQ-RXgqEI`r^@)UJPNBOwSEd7z_rlcXHE)ohk{F*fkRRA;~HA +)nxiwGSl`cC;ZjvE1@N_44gbquTxsc<@6*ycB?tVk($OC@8{;{6hi9~*SR!hDxB51m5LhH*@gK4Bxlb +xXPQM(;&^ZRc$Hu8%3UpyAGPUd%X8NGdnNsxp6K%)?S)t+;UDkeJVX)tD|H8h>5x%qCTbC3&ooc;*;K +hC81a2sz9tUT-kyj58gAjvs9_W4l`I%7Vg-D{Un^~Bu#DNBDuGHPeYVS{V@9{;U5@9plhqZtmP9i%({ +Y#6Jn6t}i@s}rN*;&Na5@~H3J=raCq681zaw$m+;a$I53r96q#n<{XLL&DoP}Cj?oDh9=%rG8LCI)1L ++ILcXn=d7puW?HF}K0FS0u<)n0TFnI!hK=Eyo#=o)ZUqnc-WUS^L(bWH24r>BARC$u)JmEX7B}JH!UI +g#~54b=-?N(br2FzSOx{@(r$nsKu{Ws6=8)GORg$MwLGN_~zxI3m)OdRLFzI!DTCzEeK!w{zG%PH%I~ +(BtEsq7hHKnd&5GG28gz!V={2uM#FCTqbb|zue+f-V~`^6hPvAD(hG-Nrn-aZll<~O+Z?v$F6=a7fN%l%@|)?%nf +c*==4?5{niWXtx%LHzw_pZ07~8uO{MTk~&N>sypN*^k%utU@dBjMKK-@`D>g?6y2d=z-pw- +y>m>g*x1xWT+uP57n%5Unw=IUOfpTjSt%$aO&YRrz(4+gBeY(t2ii}i$A#x*C-`D=&3- +jD9&dEG&EPze~VFS)c#&x%ip7Zma)^9bX;_)`HgQfeCjwjS&xd-0j`7hNp&gdjuHrN13N`uRY<+~J9L +;{B7?NO(XA7iy?M#EWDIf1sm4L1*tC6CO46npn1k*i%~yPPDy>{PWU30sE~jEQRh)EQsgHXqA(H)`*7 +<7<9~y*7XU;vC(AzEuxxoZzd(u;QARn4SIsA2{|CNE+#03uZ8?5HOsqu!qn|y@>hPmN>*rORpPNp~uG +h(BU9?2Vr6Cy8Ee{DZfp^Ic(=VqTu_KB=lg?CffUuC)lYQi4}}e7vW~x-cbm3ySpmUna)cipZ+yE>cL +aakv2F@29~w-xDp1>G9r|zzVQ|{HrdB1Er_#!eexty=kEv42hng+mL4G2&v4t>t{!z)6tW%LE!*rZNp +@9!P<#naf^^cg$qJ2$;xwh0>xi)q!jVlJjGeF+O_*=FX4q-+oxMXavu@_B1IrDfFZr5mkXiDhHT{X7B +TK$}{`6aO^CTxBMH-@f-Yz+2Ao-j>IOnpO_tq(ay2mKEH?s^g4wy`*A~rhUL+Vsp)1`&xZV%dOlscWVY~6ZtcmK^ +*GE#moM_ONb=0B_bC&ybqigU581?og^?BT-*Ch=c;P*CC3e)_BxCQcBJFGj6r(g&CAIo0f#x$%dR!U@ +yI%&qgD_=;0G_Syi?o9y6vtaiq~;1l)s#LT*7flD6khNZvY<|6Ws??kxcDzp+OkDdT2Bq9l=!t{Mb~I +9(f8~K4gr)IsqjgQ)KPf-!i;Q#iCMSAPq(Y714*o!**Kg)Bg6+5Lfzwjq}yM-IIj+EFdT3Hi_i1Cz-w +Io1lDFBmawCf8WF?W;k@67M^?qrY9H`r(UH*RH}mLTFL`6-E)XJiy5vKr4j7yjAz +^2c#cAQ4B;R3#7txUM#gGnFF6T3l8&U}c!A8`@-0uPu5IX?u86A?&>lPm2#yd@+k3EuT}IV9T +ZOH=G+@+cVv1($%+T;xWb!bWXGbCTIyW-YtYHw*;bpgRTbQk8h(2FW}<@=I>8O +c_2W#?krYBLo4O3<}GwJunAI3}9?YIRp3&SB=2@xp1yqd +KN4s0FTZ&-d3^dGXW#s1`rzU0Pk;K`^wNY}w9CL5r!?hXok0}*J#ofbY#o_p$?%_RS1B%5O5TcbX2Mj +N4C#OM3W4>zEs=+X*60w0iQFzj>xbjWZ>rqfYW48sNivetnb`PCVs}&AyyE5#cnCRH?x2CAGMj_^#%b +(2QMnaV<0-9oSN>$Kv(42a(@_k`@ZrOUCm)9le=+jC-eY3|)b4DaAnVF*l@Q-C%`@0WSZkNGoCPy7?pCv!OdPXRd;|etm+jBOfJVV?&9YQ-YgPDZ&?;`m%m96iFV-ZDd`(44qKfIJ6v9BeDcfEA0s$VRPFd_S6 +WEIf4>k=gb5|Ghg&{X5IV>o%usgUw#e5{GkUi*S`j0zV7M +EuYs7adl0kA>Q(PD#K&;;c9l2drVfG3Lfa0#nDrWT+Gb3Bb7ey}`A{eC5W5Jtt+2M=SRwb2`DZZ2wv$ +M3=4i;aw8~_rfR(L1K&hFL-%oRf-`*$GMUhyida!&8K5WQG7px5Vp9Fi{3zqY`-vy{f=WQ*WTsoZJp7 +HJp0y3W?)2@a4VD5YA@<1aT#%m9oA3z1tNa>6G?1A?X=%*Pnd+8}GzAL0ck2_trr)^v!}z*~@%UF~?4Btg5=eP$M#$_d99dg)I3i*1_;2*j$;t2VpWptT +|8w%yzv4e%9iRMdv-oO!hT!TYQms51i@&@V8T(K}o1*^r2F(f&3ma$t-1&1YJFuxCcZ*=#Hu6G?T>w@0?|8shbqL~I=LE)lZY8NM +*ee>^8*E7f~KK5cL2C~zQx!)qsnI!A&rlAg>{`hDmXdFu?^T<6u^87vXme3#>wn{5AOiy1zAbF~Yva8 +4wZ5Jry^INqJtNU5olrD4t_jnJ-Gm=gi&rUUHh>vMali}x|=4RCFPX9uw7l#LJCT|sQ(oJmSf;+M}S +dN~*iGi=23b(U{95@y%PdK%U?DOl`;T{I>^E4W~Bhq2L5-a1z@-=>!_Pu0gCqXXeEl(MMvg&+n!?%KH +ft}E}m$Yayy5(>Pjg;)oEDU<= +%~7eUM#|&`T8u`m#g`^4QYFVzaf*-gnNNgfo*MxmmKxuc7N6b<(Dri<_x7%#knnh>DH@)CY?e +&5qP*99DF`4LO;VNdkaSJ^h>HX57|<+17&u=V)%AG{VopY43D3(6&=GJvusHa(XHltzi}>JnnTyMR3P +jHSDw#j{Dc)DdFaH_;)U$59x|*NAHjHvAf#rK%}$Oa?d*!rnpVT?91(?;uOPPBJFEYhuS=%X|jzWxIW +{cy_CZjE1iCv^GoM^7Xpac9QtFeTOWix!g*ooz(i+zAxw=(Ge|PkA$WEtS^|)kiQWrz1!PW7kNF;s)dAS3cDbxg&>l&R383(PnU=5?-Nk6z4;o%-+2EuAtFn?Mm>y>}+ +H+QcUGxU>g2gR4bxnVmpRoh2S-X0%-&3Or35yovS$v>c=#oMlE9oI}l@*s%zt`}W8jA+5^4Ae;bBT$B +#y$bvPqq-W*unzvoh9i4Q$If>yQ()zAeT5gDUpxZ&=9}+=U^DP2Sf2Px-oD$5b<} +M7ytke0001RX>c!WZ)0I}X>V?GE^v9hSZ#0PxDo#DU%`4mNJecLhXVZ&ASkjM?`?2-S*)|zEz&?MOSH +|4Eb2%qj(fQK?R{oMy*bHVTNL#dOXSRO=Hbl4p~mC!rA`y4bYaDQD~%L;DRQkJ#9AAX>SC=nb}Ce1U6 +SX*x@x_i3hC1EcsyDgy%TY~u3Tkg91FE8wQ(X@S)Er-#`XJXG#~3Oap^3R}T`3SSlc +}ax9)50H{m1GJC~VV{81 +La2Trwt8=Znk5?ION9`}7kuuNKSY*^dk81wrtS(Jg_nR@giImwA%POfX5W4n#(@xyUjm1ws%|RVD?6C +y=h(s3#hYMmI(3bD&Jphh)P>ZI!0d+I5u!c+ZengvGqI6#0T&Li(=cD3dvoClg^+VJkg3sd)jX5&eH +51%`s)sTD=7=y9YnkP2Rz_E}{_Z=L>Byialqb^~?>!~u30*n +^F2ViV^~2)aW&D7ri@ja;jzVA2I+x^;O>=Fo&jREvr~ol+an*%_}AE4`iZv?uwB%~5ZFJ@&YCk;H|LH +@RLV`5$0{vIhdtU=}R2=W%X7ni8?YQiBckY~A>N8)C&T6)Z5I89Bp$_F7jZnPQ?SK=hmUi)zW}!KJ5B|YX7^uDJch5auPoQ+aQ)Z +zl6NkSkq|M_BS+WmncuG(X1QL|kp-G*BcE^ibP&AmM;#n&hm+P3uHmOtqL;c^E-39gOK-#lTtWQ~_F=Eh10{V+m +_!^nI&i*Y9&jO9jHl+T^9mT?q;+9C!dY+&!*wKl(x7XEH!`ibtcc>d5u-k?piZyYKyXDW*oA1^+M3Xj +%^M@Gk`$4Muj0?WitRI$#}esON`phuNZe)~xuL0%w&+Vi18{&EATcKZ=T6VdgWKw2zEZ_JihO5wf^;Q +GVoN?%vWmMkw<`%C>w8=HOj7o+L&x)AM=$PCTkq{8hsEi^9a#||1=19;JI)T~HZn*Dx)yaoib0K!M$8 +4xD^_c7Rg?>H9aEgE6>5ZA7-q*)wi0o(v%I)n)Kf#cl20Xwfy*oS9hr1oj=%}#zgr8-)Tq)~pN6DB=8 +jcbx1MRd5vxk&nXVkMh7|!!1O)jPbWM6sO}PGB!xgmYM?GKdVvoK44WDU=$w1+ce6BTErA9ucGm$B-? +vrqlRY5I~%T1CVVvD-MejOp+S+02z$(5m`160^B1eWRT>C=-rxKFqWvxuTU@?&ba$|h&+RGq5~tioPQ@0qeo7a-si5x>_2b|)YJUoN;> +wlPsxNn$N&kaY^Yx4!7+yDqpRVYs=|j%(Y}BfvJ7%3lwLVb$^|w*8e~mBQ4&ZKUl9;1R%!WYzb!?dz` +F(sM?#8njnm&qtmaaGB``>)8-qi6cW@@p)P(VNiC!z)QNG7Vv4DN+T)_hrHFwqY)>fgWi$=;y$L#}i4-$$to_iF&LE~aHtD8+~FxiN2;cG#pn73B +f8Tt+CfG9Kl+Wu>5RvA)Ut0KwOKV_^-9uFI5un>d~^tCC-1XUPpCCwhEIenMnFC63=-A+2s{H;Vqo<5 +sM>H$B;-k#P@^Bg_-IZANM@gL98lb?IVVG8g;(l>(s_tRcm$$sBK1QgNU@f4WW!x9H*xiCHHQn&d+OZ +`RDcTw5(Tg<+QOCCTPfGU-lq^}v8zDkvqku*zWMNEe0Bd?ky%v9<^FMc{$ecEUahbNu0f7IUhFbK9Xf +shUEUp+@yx;qvJ;{Ytpt4sz*!$fq)V|9N<$dWanVX<99yDr>6wiWgk($a}g~>1Z?xHnJ*7mTel{NS +0-UmvtpIp(|Atjb@qs9t7>WWbR4rlzY6VQgE?VL7?Ss9uWBK59O8E@NK{za#m|{Y1Us$S;;veV^T}HE +h!OIUfnTiu8zsoPTy35{6x;u=f1QxSGv)>P-!QZP~|BZoWtKikX7m-qcXqAfB~`qBhnn$;023h7^TnR +Ec$!B{|yUa90b9dZOE4CjILG^c_^aT8V9_+Wx$spxW(=`u)ao+1uL1*z%rm0v}A^1W59;oP(`(t5ui; +-Snujx1{NzgnsKqI!d5nZ>K)1gpkZByW|b8n0dA&sLG`ARWvVolTA_!d@Rr`ueu$vb=Ja& +tBS`|CCpSSzcl3+JH!tg5^H{|Ppqn3b~a!;6dT;yiR1#^l3?4}heEfZRtCS+kmnH52*HN7|3Hv=1ef48G(n3RBdUh2F}fUGZ#CO +^wmZ)=_J!TKrK7mOye~>@I$#;ErJgk^(T03f$}N6Aj5t00Ut(zi}iJRkNILI7X^4LOwb@AJf1r%xfxX +=`N_bFI-E=@NO%?HGRW~q4jz+n~f4Onw^c7Nf$4mAMvN;J)Ywd1UV@8yeP;DDwR@AiGVAI-uUa~FPEt +^)BN3=wjkHbp!L(AEf`WZAREMO`5hCs>Pd#?YLtvHYsofDg7=t9M`sD)%D~*mdADP9xz&>1f)uqmxEKBGbELh6JfgdrZah)JuBE}&Tod#5F}tHO3g5i}_d#Hr0@4=!H>TiYt!Ad`UxMEm8Bb52pLdd76 +G`zQ8htwbJW4UTsE$~ikhhJ{ykvjbQ}F;0`Y>?LwTsvX%~P*f=CyIe#4ng=@%8EabctqTc_Yu<%^KRJ +P1k9BJ((_-9Y-@HNiiM8evg7bf%B?rHXHtcZiUs<<~Xh}6?w`LuUUpr>LE=*NqFFIqc^4Nb>!W#7_rE +l#Ski<8&me6F)WlVESSxa5zz&LIpu;!0EuDT(I_h279Wo)_|^u_zS8wOoV!Q5_gH`$}z~1*Ctw9 +=!4`^ud!QWpAm4@+1I_;8?opF>bY;vY-NHpQfL)6P}%@(A7dOWRHYn7l*^(Gi_$yV!(#T_5`SPhh4?L +L-9_}h~sDX`kj$z#|bnb$f>xGwLe(8&)60hNM+5;Y_%4lZgV~Q`Mbx=?dRK2{NYKjWxr}93VlZ=pJ*1E$BPQ7gW_g0<+o1)R$=N#vI3B6rL#XJ+g=mI_cUylzr%lpd~ +TFTrsy6{SJM0#RZj|!JxLTz;LYOjbdgNY6lT8&ui;L&GoL;?CG>>ZJX$89zz2*#(!^?6S8XXW%1vJ!z +5W}{Ou1WIFDx`)97zpt#wo@BFit;!=9>|c2T^RQ|6vwu7df1QPjd%+KX3y0~B*VEkmz7czhcj&oy +m#O&RKxQYJ!MXM=>%DAP9Q+4RO9KQH000080Pmr;M%%1+_I&^V0Gt2-022TJ0B~t=FLQKZbaiuIV{c? +-b1rasJ&QpK!Y~j;_j8IIL0h*jY7;S7XC%qQ<)F}lV2Q-!{uadU-hZDrc!hXk}$=E^v9hJ!^N{#RK9}WEXJh^H&o3d)u +vaD2A)J>A-S+P<{k*ax{eikx>%H{=00A0GP& +U~nitlximQ_?|52npkQ^8P|Z!CGBo$HX6+afQM)U@6t&28M2F(5HhZGo$S-(3g&u+W<(D~sB6xh(FJJ +WKzI%lHZ=StM&cQ{NXgGl1qd4nkfok`910s~aR@9oLInjh)|KzKy@R`1a!cMg029cYnTk7r(mv_TsxQ +Utd@-7Gb^l?8R@I1c+%zAYi6J@I=990o)MR?R-;}3tiVUr2#)+rZlT&YMtEam}Xw-9B{h_6c)(_xh;+ +BCN0}$Mo_ACQ)wOcMv8<@%!pZ$>Y|C^>2P6iuE1bXy{NKHW0Aa~pRWOrYS72d^lkmc?D2S6)ob(z(@=89VrmS7HL=x`@PquizhVfK5*0}0BKB +A5(2g>mh{risbNkDQ`K<^UN29UglFG9 +)GFj`g+uOSR!gs=1>X={yCht>)F_uA*mq}Zvl(5l9bI#XM%Kw{iysrE-BKrkY+H9%U!Kr>Qp@T0(;SG +PIv!EMrbIBxM>UY2*b{_RHO5`wtRnp*JtE9{dZ-{HQ{s5x#?Prxr2&N7P1h+TJ}uI>TB943^_bFJ=mR +fAw9I7Pdj!%tX*lJS74q-8NBxzHqQ;KoLKAh%g_YetjyK%1guCT@%DAFYnmMYM`kbYhhBI$PZ~j73`h +1R@nTlG)KXoM!dkIJHmU5`!wXKaEbKD8dFXEx;0+aR*sT+0VEd(-Z`E3dB<|Wl+qt5P*FRyd=9`gFF- +hDHfKf)nV7cW1VK8kA%|W;=pY*-lxDTfccKLyx$F3ihJNUBS464XwKW)Y(WIAfwXyUs7#y|S#G8;N4V +(Qq#(hu(uJ-_iWO)H;3H&Lm;ua1pxo)*%&n*C`D0r*0~ycH{P3&1nIrhS5qms +PS_gYF{gZ?!-Zw!yuU%t04I)3O$61*m}LtU!~Ut83b3fOL$^1Px;Y?}pmKqEHJovS{}!AP#Vt`VJWdh +qSN#H%<=O!J=fd0X_&O=acBiGAn}XF5sDibQ6XaQKaX&njA?d3obP4a6$GKQ5s$n{b^s+x5qT2-%?<^~2DUPaew0!G>NlUyfXf?(oxmeBlPY)%`vwMYHt;TBY0}mLE(fc +HVd^kae=4`Y=M^nlnk|>GR|~KTWU0`e0k}CUHuoMGQ^4UA5%mR_o(e@FFDFtA`2E}%!V%9r5b8y2kOp +BG-Rg%lTj{z9!VxYm;DsQ^(hp}}m$2mUa#P_RB`ze70G^Q`Xvz&t^B!zP;XAMImc;eeh@7e|kWknQjJ +i%sfJFnny5cEW?&P^$pS`%5$vm%LoPFkge0KJ^`|a#vYK&v6gX@RlggIKqWNeCe-8T_FOs4xGBEpD(wukA=ZHKkd=qp?0;W9Zy?{jq6AyXE*?Y@1P_xO +!sHuZKfxE+o2JZ=bw-cHG8ztC%Kl)^qo`2LXVg*?393VFHad1Q&xG4vX1RVl|$nDvMQ*W*=stQe>T6u +H?WOYPNvN}I!Z#la7?#;z_?_HZQgy~t5)!I-$%~DWfwDWEZIX&!<3LdTwcxN_tMgWF9jKK8?Z7Z43m? +PQ+h0Bx`t@dY&D?&gc>#zo4x7(5Wifj@x5Uo4~PTYZ-D^8MXaeJbh#o?hGNsRUiI>W}qU@;hGK{)eB6 +NcSwYM>lseKS%GfQ6e;sxU`5`GPz#^V(mZ-dsPw34M9wSpQpOKrcQ(-vQO80>eY6=kKf5+Vho0IZ7?S +F3wlw`IHsk6f_?Q&$~MNNuNJgzyG~@aq6slG3*2E3>>bD6^uY+C+x}Qv#P1k+Wn9h94qA9O+zwH#(5_nrr&(w4}=s4{tPh3-n7SLvnj@c)l6uFtfG +JA+Q_`>|_@g6u*U?UyaaOrKgUZj)jK4u;{#BlW`%Kd5&XU%z?x +4O&W;H_faXiSmJf$ulF0%@QO$BN{eos7wPl7JfiEyzUBJkkA#=y~n`P5K +k+7pW&;a??rtvfIEgBHb$ECIh3ZIghLYD`Fc3g!<^625{HLeF7;2VuB(7KjUSyaE1<6&zTbdSd`jl6s +M4lP-{oca28{j{*atZVwPuKy1OZ*MY??+}{R=cCRbPIlzygnrWASVFK8J5iX(YpaKs1@8IRz-{Ul4KY +d}oe-S-<83xDr6CZy_@pt$#94t)#^MOK-$2i)r0r(6@`^&|AGvXMv=fdMfdg +E3nGEo1%ARA9gvQ`l;Fbf&?_Y4cRAN)Bbn5K#vtg%p=%o{|TGzhI?kQwEb`z<3f*tYJoeD~{ky86z-`f3r*F}!Dq9eYhzGF4`MHl@&qA>b)X}a6pBW(weD&8qU0i%S4T-mU#`t1uYDQ>%{ma$7xM?)rKQwvoZ`v0{$(s)IYB49tH5UXdd`KnFjt(roldkMaq1!Kt +hYfqx2De;H4amFhS{4lo1sP?9+8`-)<*L<9c-PGsRzCyj* +sn{V_#gX8L=#X1BWeJW<4>59}rBhla0bC3k++#DIAId>H?I*vHr`*KSc$rO#&ePRC#18QJmwcxBb=*Q +IQ{>?P#WTEu-9EM+VU`FlC0ln3VX8Nt)V0Jkl-laz58?$y4&mK`LS#dWP;SNLm*3%vJQmBcDrjAn+mX +AK<061g~-LOtWHSLO)?OE(?%-q`P4uDsYMy7paON{h9@^U8@nA(F9 +9#|$%e%jFtl4T=jpfmtahR!!XBHREHp +X`wMWGMcnH?mS6x^%Eauj%!RRHg)%fvSIW%5V@{Y-)!sc6mJ_5=@z=0P{ixw)4OudFH!3mm?nex!|7+ +sjJ4M1WqJEqZ?3}Mk$cn$>PQ#t_V?TmmDWF?2Lg6SiE|+wiO)LWwbQ?ZU`N{$1ujVMf~EGJLvF*V8Yw`JKD=|nw6O>G +>$KWa%Q(MxbmQx5Ve4)U>!zlq0`j2RN_K2XtqXfSFX8gaP%Xbk}9$1(-9XOn|P!7y!|NBGWkB&d2oy@sU4C=!{8d;1{7%*OFJI_y0MMiF)(7YQ^2+UoGa +n%oXY+H!y!x@F!&GQ;{$(ZgW>p?k8i=U71o?%S!OBMPq=_XJOnC3HD*2q6I6S?Ndi5lP +D{t<`PQZ0fUyzidJw0{UL^315ijN69qgun&OBCIy`=rVeJn$eE5~ +Suf)tS#vl6+m-6wyK(8;jEA=4HAgL#!UdeV#S*c5$bhsH|3uzFcJBDV%)zn-gyW78{P_1ygXW!mxjw1 +LC~}!Jk?@DIs;6)mjN~w)%B#XG8{P;^id|&556j_zNF#z?SuXm-JWJdIM5y$0@!X&14Vifvv%0(b)4O +)DQ_~e@nx93!1dtnmkSV4mR;Q8Y0=^rV*lC6FY5N`iPdE>syjwCZos<;Xg7}s0ISG0Tw}~ +!gOdJdXERQKdTp*JXRN%y(FTS6&^@)7@ck5WzHP(0T|z?%+DxJeMrwN9@Um8~y=(DrZ#zf*IbkAQ?~% +Xgy*Zs@#PLWSe{!riBjHT7&GPuS_+;e%*UsGHdK&QLLwf_~Y2ZyYgmxL;Y~hs%ap)_XDWQ?Y};tUJqaX8iN(^pVud}K=cDp@o9h*3u_GYdb#FT8@}L=@KChOfhkhTQV>|~n8mt*FjKnBpxA$+NtGr +ILXsb9?}!7f9f6jpPiz9=C;l}E!I2Uve4Hp>2t5C7RTe8ciM9l*&}=3t#C|EuRr1flMqlWz@5%uLl$7 +`t)Fd#~+yJZF#jUs8J_ekt&b~fro?8l5!Q26{*9Q8F=oAJwle|x|+?UChh2R2efk@ABn)xuayNH6mnprMEAdEU2!(1}*w +iWUSZ2)93aBvJ;sF;H(W^>$U6~;7laX%Aapz%$*7{av3n#&~Ws+?h529qGl%__k#AgoPiX=d&=2bw7r +=Ck91?4i3{2jSTwR#qZ31NMX7lpvASvW08T?%A1}4aZ<@t#Rqee(B(bsF^jb2V7&MOsSHTZdUQ_0NgC +Ms5c2q3L(?sJw8VaW}Q?E$*wip*V4MN2-EuFwJf;+rvCo-i|?+!e|LemP~W_LfBELStH1vpy28?w1zu ++nU}WYXQ}JCNzUCtlEPiCRxAXKG)e9P$Sq_FgPx40EN)rY0?hW1z1N?u8{zeM}RNWbO{TLq_ap622x> +;og-8Jx~PhhuvZL5&H<^WE&I7Z8Z2)tR7H$4zS__0yeg+aKR65=>dJdxp?*E_uszvr +tsb~$L1REn_%Xce{6`eGgCAZ_NVHNIYw@|Vv=pdw%|k<^ckZ~xe2E526Qx?$Wco?b+(N=N%xb%Ho%`Fg2{pj|Nq7TFp8QO`WsorZRaz%Xd=n1Kx+{6DE^Kj_CHI2jKQi-Qr&W?&+P>Q`VXxkZ@lMeZp +&0#EBHSc`#|AAEiG{AT8%9R6aQA2Zgcd&YXiIHoCZn9j9$Tzq@Z$xmE_K~%~xhsFiEW&v~O2Np2P#Uv +zFh=1@Q4L(F4((omlcz2=mc5QD4*-Pruxq*6pCuuJpv+m(fze%4_N4o!SajXwoSa)Q!|Ck>-yY(PvjE +w%j&mx^!kMc?f4Q84S5kAU6K7io(L&~hgjAS8=a8z&LgREskvd$#1*r1I3_dpm7UPj=wd3%U3a&N(Q@({p``)8f5gG?*T8>NU +CbdC5&V29}{4$4_IP5DRQzz&bqt8$A=!9YhYIFws<$DL(^l9M0LQ^4@r?~}N#jqFYE|Q9pu4RX-m0-KfS++_re!V|EQ>uoWtpj+=sg5BBmh38^ +sere1M}HsI!_6VY-NhKG14$!aDd)?^X80A=T#~9sQEthT;t8;+7D4s2-h(|hl!6Z58;sw=pjWyfnun?Z>0ER90?8GPV*o`rX=8%gy@oPgM(7nl!Aqs&`exOl%@b3ZhnK +A@oJ@0~Gn&z{iNnNnUn#KSICOVfj3{y}Gst;nH8XicoUj~CO5?!SV?EbG9~1W +$AFIlbDe0sy}5b86~pRAu1Ce*)eHQX2*tVA`+C};==3J)-z;*ynifr-b+Q4e-ptGk;hkw@+1rzBew7- +&xji^+@UIrZHeKAsnEeb4KhFT}E)Wni<(;`(#=uMHHQrn=s~Q7=m}XtmT@M$GMHay*A_L8PJR}VA7F; +^Hw^r#Tous+ALDFM83~x*^2)9mt#4|XJc~b-?xy4dXRQxJI_LKE#H^gR3>*Ixm=sb +&xxs9p&@7dFOd&^jwh>t@Jk1n_zELIBEyq|F&XcyUZC2NR<#OHB1!4dxWQ#<|SYYaD^sk?z#f|7|%hM +c1>rAP^9UiU25ECXP$SNX4Cs*QQ?^?u<(#9b6L(+pMyCp@vy(xvOF(=J<$^=#SGi%`pjuqV!a1$2C<{ +u#hiiNo~TX-OK{(G8i8c%)Bquu$US=|Jf)_>;57hDph5Rtpdjn2%wO~Y3V&(NoQ+#fu?i}+c8Wr9F7@Je;WH; +B8YT3E0BBxMvp#}rQ2%bB-yIX_Xx^9gRUfcC=?SAsoBYMCWdg(~XynIQIHal!@J16tZ{lL>o`eosKz_ +Nb-@^1Qubk*0BuI9?`6QLjeGg5DF73#U(Uc0H6<=sZ3d6=bRhfp}Pb+E +PlR;V+(mu_n!Yqn{N!?p}Q_}fkMp669aZW5pF8;V~<}>s9OS@51Ug1dFin3UOINE=`lJ<$DXb~l3G;2 +o-M$b#1pyJIys)Gv?WQ*SQl99Z6)a}UjN`Ri7C&2bK09z-(c{uhIa>%CIH0JCJA#0gI)s^XF+tk!xk9 +t2rmwF!_Bg1KzP&b=n?5l@miW>g~E3(xvjOifCspA(p>Gb$5@e6{K^iC1P?Q{o2j3;tjPm=jUBQK9PF +KKM3cuyKe>K5v3@uRxAd^A4DW43tba$y-+`WCjR|`-*E4wLMa_+K +&l@32sVbQ9(XDmy(RXb?pdWC&H+*mP3O4MS?^tQ4zL`JJoNb>|`-2Pa`uqhaOd)%X|k~cD@~dyeKDPE +2C10I=Z@zS%T%_uCso^2ChnN)TMxfh(zXcNz{yf2McDCgI0%8rV8=gS$(muxBG+9Vc|p`=$atw{<| +-RC&kwX?Wm^!GuHgX)D(>2E0�>P^pXNkmo;92jx!M)1Md6IWpbplj;LCPP1%#Y5Kz62^#$>78<-Ir +2ROe&1^;6!pqoeR>&`%2AmJ9O!T8QR?k+{LYp04%gyotczX^a +2T;l}9na)wsNJ!OU%3&fWRxH{QjjK2OPNnU2gmvJ7rXo~i4pH#FJCsp +);AK6HrkY(!M<7YDuK_JPA-rWV`uoM>sIj57>sZKb$@+_oR%R$K1}KVw`k6rxC5FnvYx&i!qNj}q7$O +5%O^1lgTn2%{%$QyQ3Kr2%}+J*@T4f5G4kFR*cy1mQ}rShKA-?P_XpXr;S_xzI&N>|<~j;K4w)6s&(_ +;?!YZkOHPKh_JZUX +;Y&?U*+k()C?UYdn-tRi1Y7}+gb*8y+_v>!50^&!9wFrHn6OqS;b!WW>(22N5f$Co*!%q+V-r{R_Z1+Z;^0)qnt8?((1DYts7w~??-ui5=(yCsqxL6%UyI^lHG(Ik(y +1&+^+PgeQ>YGy6cz{Kzt$9Wz!A+e0SS}IS$qs^YLwN4SHU^%kgnUt|Z9f=I@704#VON3~+G&rjp7KP4-D +4|Fd^Zj6gPJDgabBWt39vrO{}eXm_0oKU`2b^>m=qd3&ig{iUP0@R)~M1@7K~P!S&6|*J1b>8Tl6qBInGgVX5%G4KT9;Yn%bRiW +P^Pq;a`9z@}%W3_7@|zHQudWe*{dEj<9^*mTyV!?$CtA4P8bP(|M}dxvoi?ZGTeTafMxDvQPZ(lL?tO +PV9PT0(AK)SEk~-6xEAy$PVkItu0epw@j*>aNLk_EUz6Lq +RQ%-l03h>69I^&f35l*GmA@aee|#}`oT9e+yH^^t6Am~i@9@+2Z}$KButVaSAkjI|mt<;#2~P#`KR*5 +h=k5px+LcN<08!RSb*HPzevxYvhP^*mV?7cVl}6v>pd|*zG!~e&>libvJ=O+~TuV^}HUL}^hGdn1Y&u +rv?C!28x5Z%;?y-E^v9RS51%GHW0n*R}fk()@~f#dI^w2nrzSjMGisH9D;>FOJj +>MC8{K~j{kk%kdiD}3X%ZT!6wDwaOUyNhtf1nTGeLxGc~2LLOF53U!1AtC`xKErlwHjggFQZ3vWbg2{ +K+ZL?w&G*GZHXrV-B6CrSVQsLg&D8<(}xSHsj@ +T#_Vr;*SepImk}?ozTXd;E{l@PL#@0;f=in5T)36O;NF<*}2l<5WGKE3h&M&&Pr=2lV$M0R|KDqs%aQ +AY{6mSaJ+>w0N_2;yU4^A|f0CFb&#`)03Mwo_J#C2_uDb2ZwcnC``ONFu8cd*h4txhD~(O$_W0Q{ +bC6A~sGs5&cGv7Q23J+Xnx3g{A_D0^|K{Bt +(;6k~uRHy(;y#Ji_$!Cg$QpoJVWu%kHMHm`|OEXahra=hKfPX!knU&e>GKSE*>RJzj>-rbo^YjC&3zUc+ +#w+3Hbocf$Kk80=W)J$>D4T*rg|ZI#3)$iBxClz*WKPkjnVh!ABb2*Q6^#|l71Mc9DIaQ~ghNFas=pv ++!KfX#d#%7X$|iZ5i;8F4TxeSu7V2H)cLr?DRe4|>M@gEV8PF9$0DH)PaUG*N{Cf!rZ>(6cY_ +z3dN=iMyV&)#c$4=n5DHUBehYyf`qwL@nTjEebE#hXeJ4KAOD@QWdoIk%hhB~OHA5t%*fTSvmMHV+lr +*g~{b%1=xi}Zj+?vgn+K-HZf#gQ=4hh*1EJNCe1)6%yK2p!8Ztd*UJ&dD1)dEgS&her)#fd*%c +pNVSml!6eV-6wQ7V1-YVa+k_ifSzV+aVQ%HMnLk{YE4-h&+K${{c`-0|XQR000O8@1eFvChl_;F*X1I +nHd297ytkOaA|NaUv_0~WN&gWX>eg=WO8M5b1ras?R{%^+eWhBcm0ZvbUh?(iXthRmU%7DY8-o_b24^ +r;>qk;uZIUDK?!3L;1Hl5v$Ol#x2pPqeuAJRJ8^E16IlYftE;Q4tE;Q4st?$!Y<0U%E-nk!?{=TDKWE +v+B4+35w6k}>*!RgaPV;!iij4j6(;K!)XYravP%ACg$z)SxYj$?Aj^kyV7M;Dl{r&wjHjnb6%@zpsIw +sKPKU@ut;Kz_HqcmA<7EzI8DHNHkqxCIIQuf1bahat6;r(TjmmhMr5v@}njf?AS{VC^o?d{Fi*^-UN^G&f?$Kx?emaA-CK%bInHjBrLq=?tiBH!B^kFVl&4j4kA +Q`YEpx}9f@y}dnAAuraOX#sy903DVq=*uL5%C~I3NvGJcd~ZCZ591^)#>MR_&H+vn{%E)MiuLVikHHf +x!xmY3(b|h|rtzv^Z=+@WdcDrpyw)npa~B4n1hqv^0yWLD@RQyGxET60xh(*JZ}|IU&L)lj-EDm6eq^ +VotUF@tK#UMOW_b+sFOq3)KqUaI?B~c2j*(y6ED6c*ts +T-5zqM=Hxi6^@1Z|cmI=nVoksUrX;d6MQuluqO3d7JC9sXc)j;NwE;HyWUwb +VmUG_U;;cFrx(Sg+fx@QStEd0HCcc)c}w_uQ1&0*bGYmU>oTB|`0M2<>$As?*>T^b)jCS@Sj^;3j04) +-hbr*}h_`H0uxt)R(ufTo4NJK-pNT_;`cTy&X=nNEer9CCQP%1a^*70BbY~A&cU!2V@{WbV3z}|N)xdB#@Y$$`GY+HhS}RY|KaDs_pjgn`TchQ<+zW357pnm +B!I$n0aJ&a@g?x*XtCjfs#*Rj5TQky-ZFX(ynt&dEwjaCELYJEEt&%C+qhUp`KSAUO*sew773QD#-gp +J__qZ0KKcZhq_D0dk0$BG5ikX<^n!EYTQ>PeJSCP#_|t5?#y?S(z><$}&ej*2j1+B**qHz+<{QqPHi3 +Y~Wak-soxrO#*D$iRHVI8t15}z@Hi0R*S*;dHJo`@x64V$JU%<4$rjH*V_t|x_SZHu2h;y1Jpi*%vO@ +ux(xy6Mg+AIpuj~}VaT360eDk%mV`+-QQKZ!1~E>1|TYB_Erls?$)$D%WjNxJ}Ck{st)%n1-NA^`q7) +UX$I_T+%kziNHeM2v>08fGpy_`2G3Shnr5o3?I}22|DB@bk2WqPkqg1nf4~oLaU3bf=*q#T$>-Y?cA@ +q#*60)hdqGf&rpba-6|u9o8@be4EVJZMGr&P!L8!g=?aErxa?|Z!ttUj%F}TED%sfXpDkm{@7rTm?GL +<*&D4JJ7W$o{W@IPkQ4?&VJ~Tm({x&#zF%+RUtTf@?6yh=Z=Cw5My_#&|&Y^5{R +G&F8%B>%VDpP6gli7Bp%yj$6G&Fd}bN)d0V~5v=ZdpVOk;Et>;lGw0`-y^i{30=aPPM473+tY(nuSKs +nZ1cu&;4`eTU@X=^~PS)5N{w@QPn)B;>3R-k|;)6F6(X)RbCSez8K+XiUUlPFK7(PD86RY0u;jhCBjf +D0xWsKnSA0k<4^U>hlE1Rgb~__@QOpLcS9uJ-ORt<@y0JF%|@eCM2vaq||>+{yi8yn+`oO=wvgw%2UH +cnzU3fU+P(H0*3H4*AZz1(?B<*)qjbISqljqA|rMvWMDq56m-UV+lv%DNrPI>*HB91<&~ulno^?DDee +gdqwlQ$THaFtzqLV$H$aKo_&T$Z%^5n&+1jJVLHly{`jMS;{u%5mwiw=(EqcQ*$rrwSH1p-~^-Npj4SbS6y#!i=IcfRY$*p +cE`idHl~!jAkL=DWK}XnZZn6&IHi_6&FcfSe3*=9^}L`R%})a(jz$U>K6F3w?>KlX+SsX2z0pV0aJcG>q0A|VLcc#@J=0t$;3q5f)->1QGg-&cCw)kogk75 +|w@TyI2ILAI6@jib8~-a_XJ{nLo9SjbLER4jC`aiPmgkI0-;v^2hpYb?rw%`PLU;@{H1F8)>LZjJLKt ++^H-t3;-S8$^ZkAd@)CQg!Are*Mr9N&_0p>NV;lz2yA<=n>EnyIBIjlIUoVhiM2`GY?Xnajt><{*E3V +7T;c)-pU3xV>SD-bb^_BC2Vu{UiNU&X0VJ>gvh|1Yz3ELoE`wP)kW$2;FFm(e=;S8UBkoi)^0|0D~;? +2@9GTcIx!L}ANZ5yX6b6QRwx?D0#W0#4Ru2pQe9)aX6$ce)+;ztL(d5S>nkRX$!2y<-5`q*6J#;7)F{(wZgcSOVM}q7C7*Et(k3$OMYTgYMWnfp@dP +BA4XBlyjJSJ!!aQ2WOq>~)Ff`@U2Umke$|%6PphNC8-_5GFy;zCXB<%!}asW6u+FcA?QPsqcP0g4oCi +VDFQ67syY+;YhjfhrZ5jo{sjtx`|OS56oaJfM)0ks2nNDX +4+uwhc;XA7^2QZ2h<^&4Pi~NVF@|aWn+j5SfjP)@2hpf2`jxm@3}_0@YNc+wT5Ob_ry-eeUpAlvum;n +38)Ik6)pJylQ%ksrFRSp{yez>U9r?`a1T-z650onM0}763%%z@VP(A+r>dx?1&DT+N!qN?MHG~_#8nr +Y+T$McH5Gn`8Zw|!;Td1ATnvCkNuz?zeSY+4hBkA_Dv~^h99?Y%;pci#)fC9QiBs0Y!}nCF2|7CnjCw +e*sPUbB|NZ#g+t)vZbT|dOr2m+#G2?Mb9ZjoSETUDe7SQ!g6c!j%kG!CaQ|M6HqCdJh-s>L&F?c$OGkAuoKY1WEu?OWJ;>bmzhTCby9`0(M +QdX1ayB`F!F>`ercu%tL@=P-^On!fci=Nc;eu$(CPu8)$AlLY7#QuRA%7))nPS<-aSArY^>b;JTGhZP ++~RBO&hX9?%5Az@9{Su~r<+F0R*4$b-8a(k*%6UW6xT@e)bsi@4C4dk0uyat?`E%qGCO+l +->shr`}Sc4`pV2X9wA?Je;`45B-~0FWxL%Xv~xB!b=zU+LJ$<+f*bdxZ5XQOdA+SgN$M>GBDVsy$0kf +5Im$exa%@7oDeupbSegbAPe*P&91%aW^WGMCCpu0L!vQm-`gd;>96QIX27W2F18k>mfmh$fiNJIx)fPZnycE*|lk6MhQzsu*&dOT}Zaw4ZuTO!m +lMFhN+6F6CwpGbfqx=O{BT9~2te(k+CjN)FBbabi^Wx_tOVIbD>q|@0Jz+|{C6qo+W$S5(g=!ma%Hj< +MMoyM{GSv=dUwAqRu;#o6?6$@SnU}ElS-|$UKKr7t_(Ke5@%HA6rRy6W^%<0Gg$>^h|`qEw|??BP`rp +c?qp2rZWc_+Rpuv2x6g3@tFSSmquHmfye(NnWUzyZ76W}o8QQxY{o#CFCPu!Ks%HHOb1pL2~t!)`QnQy0%iFoDWb`OpUNN(sEtklZXBnj4-XETZKpgdwJT-`e#Kr0kf4`d2LCA!*SWOaq_YU! +W9g86mdxid?Uwi%Jj^dVHbbr~^@xzQ6ScOAm68L%Q)t{qEV;)A^dAE|I%EYGw&6U3xd2*7jD9-T@fF( +ixo<5xnxO;6b&_8av?61d(G@V_N@|Y8hxS +ZP5+`+xz+~w2;C+A%WO_VS_u9e^J_y&LS2N%q~gK +BbY6>alx9GMX?$k9ZfbDd1u9=hqCp>QIhAIxYz9t`kXvu2X-!)9R;juzvi{O|(F +P4PQH=C0<5Xo_HzXZ?hq7bZ5aglEF*VEJo#uz(R2QTkY^~`njT5i8YwA@XR%8maj-Uz62OoD1L +bnOE^bw)VQpMwGg6KgbFIJS3Qxx?S$aW-x7JCCW|M~{CK4`r9VzJ@?i8(!^GjHG$l9E&#=KIq6+#iEC +g}`YkW@hLj-~F(L2ZR_5-r#WE%OTua(vY9c60L4O*4f|zKW;GJc+rH84)hhw)>A}tO?&*@}#TuH9=~TgV7_Uxb2(F9B^Ji$k55s-iHVfRuL@|)x +}R56o&Z_Wat6lLIq8!6G+Z{2B>w65+nIyy~U-Ymz8yLNGaQKwg5zQU2?KYzUacpk{S#$f*k=7ZgG|$jVmc{{8)M{uRS<(RNG +G9(;_IK8_-n@KSg3}4lUvk3pK@f!Jf3z8r^7OdxT?$OPQ=B@|X$I1F32KCloU0-?Z^osy?q#W$M}Q;l +0wtg`_ATG2lIPTMzy82fkE&VDd8wrMJYn$ma1F5(o_!D)FcA-YFrpYW1H6JD3O;rN0EE3~ +wsSzsB%{%@9}b!>WxwhRJ7sUs%07(7flEnJT?rDSqlI!Tjqd*Rhf$a5wf1xUMK^nFcIuZyi^ClC73{x +y~IUP80{XAPt!&aT-&j+tJ*Vk_*}fu%pFgoD;^s-%23?1#K1_0>tMBG;>OE4AH-9I$Sb-Kp65!g!ged +}E{H8xGBDsg~8avDIpJ|HVDEY#}9-@qP)_%Z#Qu`kAi7$Qp +6K?xMF4|0rbwswn4wna9#}g2iam4L`Xs4vGFtV}>2uE6N(%(!EKh8SvvWj;CqvK?)xWisqY{{itjufw +Gc^5l$4Nd6EuMN#Z51JV05fntgsLe;~7BQm<6@E*BSI6VFyOTA^P=vwTH7ge|6D;g_FN1LLWAie;X`1 +zQ0Jc%q52$GfBCfz&tEIHw*IO-3zu3>QYHHb&1OoL}O5WRP1UpC2IR4N7{k8Ck=CMc6tpiE1vGVEn7` +U8!Y&n0%A)!Q6%0~d@(I%(EAF9Q-lrnnU^6#Q#SD#`eDF7Ic<(jD3#Mh;{DAk-e@xgpR(n-frZuC*ZN +3sm%H}dwsl>Q}Dt+eY8q{^cdztOcGel94Re8PI|5~d}JxN9UIZ8?)@(3>}=qC*6-$KaRimDVHj61`im +Kz=~SmTEGkU#M@ma-j2=Wnbgx?qblOKnXW=%6^Uq$NWIS_^2--CIPets$2k4p8CeZPN#Va`i21ZaM&3 +QwEi2Yn(i6q9WZ|Y4NmWZ!s90itZ{ +5cIzbyfYK~{uMO1L-a!Rglj#mB+RC@JB`H+dP-p~qYDuwLsHt?b)STwsz2aLHYp(W%XRg +!IBp_#6;JU7yWl_quBS$$#FTrZP!mRuz>^s}L~VwQ~$AD?dnbT^wOl$cUNBO2V##lfZUwy9*F!>EdKW +I&HvY-VwIY5Or=!uqFYaiNpLh-VvFGm5&?i~(=ZfyfEI!w2j4$PrlO;M1K*PZ}+!ct23QMX&-TAkNg6`vU?o{hj%b7GFfK=s4fzlDi5l+>}jiQ5f2s4VVWZz)Leon2FQze>BlEplTH6-;N_`*C*s?(hxP?8P6OK$Z%2$2c59 +h1IQ29a?F+otL;f +d0}w~hQov6r5@0sFZFp9&Z@riz@5COYy$j{v#jvcVQD=A9T$DFu#~(JYO5AkeI +GNp;Y#;;*%`2Qa=ZuM&28tOw9ZAk5~gAg)=bQPm@!_Z=vleDeXPzDEWg%9cfxsyr&g+ZA*8e?PsCuy= +dytQ|b6zs>LcgD6Hha;w2fBbAz|>k;jNx%2(kjhQPz#W`egt(Ed`3;4xBQYC94;N26y$7Uvz&7`k5MJ +YERODJW%bXTTQ^F156~P&7h2T*`yI_{npJ$n&( +{R%?BS04g=;8dWt*}p@V5QWp~P{v(*bm}uMZ>?t3DM#t$ZatF20QD*c@h&81p{x +npd!|+NZ8o&+hD=$lGdi-h3RMj#_y;`UG0k%s^2tSWq^XsEG}e~ScyxN7gUN$!+Y~m57uhu}QtnxB&B +I9VDa~PTE4Y_Cfa}>^s(mWBrGvgR&>cEN)nC@AUe*>bx|R!;5oYT#z4Fh8v`Av~w+u6OrM;H&o|d=-e +Wfr6O7OHiLnzlrO=nfU^zV&W=7d7HWWf18Ah2J?G|TvN3~E+@C{n5O4~>Pgt6lv87}e}k2Cj}x3zF~Vg8PCakCQ%S>?5s$y~zcKd35A%V>& +xd)!w^u+g~TDS_7`NeD6pbE_>h(MYrA&>84IFi~H&Sz9)YiXZ?Yl^Y2VEma0wBN)IEL_EV6ruRxxyyT +F(-*xo#UnJD<@`D)Iac79WcCyN;1fs6O>|6JABiDO1U^*U{#hdzTr1W-ockh0zU=oqeL=6}&Sah8Nb +{~VK)h7!s7a)S%g8Yiwa)t?@a#(CW;kCH(uFeRAlxPKwb)NaeUsYtlDSh8OvfMO!8O)2k;2x5i#a`GL +g*?A>6PCv3lC?2BI9^-&m&<{mjP&ZX09zAo)-0-r+-lG&d#d;J(0@ea$I}Uvbx|~9pQx53#!J@K5G!% +;MhvkhR^yHtQ+P_}cnM}QE01}Lb<=?DkB14}nT3z96OZsB6%d}(7zy}PWSo>{O0Vi?V4`f8rx^C;XRZo4#B=@Kue}-xsgAdVgl=?MJ3$~RO%_SSl3hZW97EU_ +ipPAuzAaSv1nCWxI$ThRFpCMT!B$zezd{Y +crsbioH9ADEX4##WUz1Bj!2P3Hn~C00QZV1_CZ{n6UemJ`heE +4Ch0j{em0=4xs}rG$i!90c*2!^H_>nE#EqvjgJ-UuZpm!}diz2~Q(_;#Gk9UL!+n#b7MPZu9>#LY6P^ +vyggKZC9pJdqr1Vo$k3lHo_1L#dg@KYSKAK$!U{o`lHbfq&QF^gdVT!f;T4AX~2sE$qo@0p@sX))?m( +N_|yK6%N+bxjc|uiw8>)V@D$aiK&9<5XTyV~JHUs&wO)bWfo$rn?eWf!vL*vRV~c7fJeQ42pZSxFg>p +fI|Xsf5Ixjm>dt8bI^a@yCcoYj_pXbvSJn8R_o*{D&k6_m6l6xRY9PIAe*RfhkQOL@p{jX??^m}-ENc +!djb`FFO1w~$T#L&MW<`rDawd$+!4q)ZmkZvob#Q6Oo>83)C +s?l6x_~{a=>2ya|4rVAri6np8_M6|KrZ%xUa4w>ovq0U#3nvWz9Z&{1{sOdGP(~w|{>B9o?+LOMUzL) +%jn}z8`;k{^#@eSa!b7{)H)Oi)N$S>mLuE4xgPomnWD9JgA*4K6vj|K`!UQ51jV_cZqq2A0q%Q=9`5& +ClH8n>lBt73mAH}t(T8`v=kTuAhj(2wysTDeygE^21M7=nR;5cxB(bzcs&W$ +gz0Ctz0-c;;8W2id1%C%}h4G!fx;R=SQz|e1+#yvMZ)aqsK?2bH!#08NUN0;Xzqu*He4BhH_0EWAZzn ++fcIHTM8BL=zM?!gATSad?TPvrzX5&nTAn^SY>^tM-s<_op>J@JaYKUt(J7$Ct1{&~^E!>h0>b1ZBTI +LxV$aYk+Au;+TB2IwneA$cP7l`5cR+TRP +mOZ4fk`LVuiusS#%wKk`+O)9$8rfVlY-DcS*EjutyG)9h?#Cb-)n$Y^eL!}$aRr-_CtFhm9pSQH@Y_H +C6|FI$d9j(#J2r}(SIzaNgK47y1r+?gfyYPW^Q1d&C1qyG1+I7YRkziB=Q$zEX7v8XJUx0WO|q1G6Hu +OJ=}dN-yYO+bq)5VIBgw&m%q#-P@(ZoS&7bH7$*qtmph*wSwX;H9k`Qw2B|G-g;j93VFfhm3usj?gt6wn>6_Bm*c-E*5WDc&KLR+ByYB(PopDynuS!W2PUN$P9?J>Y~dxG!-n1l4+vn-BCBQ%e0^asU#SBtaIQ@!!BK(jB)=tUMKTg<; +1KXD-n#!L6)9s+Ul)toe-x8XumXu%Ia+Dq;%b7uPYi+e%raBruuLVFbMVeR22%VmMZgyrC55e4pMoOT +z@_dEKbZDKHC!+4(n{m{I&7%=Ci=ZQ5SvD8*j1=hTmkkW9Db9kyL=RJxnHd0fd(WCWr!Er8T>0vs>(1 +3~C)E32Rz>s1sv`Cs$pP>bLM4mi&M(VT0_s53jOy@xi#}&KW1k@O+_EZh2?iihMw#;T>zagF&q +?koEo?tZNlpS_8Kuc;vp}P_GSrpUhgiEDqtfK$WiodTNRJ&g2}tY-384SLxeO(!tiX5pU)!E)N}@fIrt-!#G>FUZ{El6LW3}Q+J9ZP^q+XyVkb;?r0M8ljAJUH?-kgZ3^ +SgG<0WCQyVXT69Eop;GYJG?`o%f6Q0XN`P_C;&~dU#M=vX356NzN>P>yF%4waJzdGh;2`ijjg@(m<$^ +;^6lBCi4)*IDWo`U-F>|6~vA7^6?K4mHU!oC20C8NGKfb9lg_yG(|KY-xYk=KxsHTM1J{Xw@w{~hT8b +J~K4N{0>P>psKoJ@1_as3lq-_qxtK@{&w?eiv2znR}i6Ggx7URHN7TReA1Kd5%?1c%7j;8cjJI8kU)R +m9p%0z7K_PjAYY67RSByk)pO`@fK*VL3I}O5eBS9l9Ry{hB9{%w*v_5HOn3 +S|LhiKc-XY^tLz|>BwlTtkM6Q!QKeLGoC=-*AakRv*RVBF5z{dy6UG=lb#Zs7%(4!eTe +|e2`%zD{6YftL>gsj34RlO~RQLj|j6h|pd}^h9rjN=RWfhk1bynHsrh>`~Evj6P4J^DjmsRDYR_W)&r +KjddITdv_r_@(Q^=xgusCVtCQ73E*^Q7!`!rE5K&5JmJ!T*n;W6zhl%aK(0PO1GzVd_-{4j#s3vm*ibIi*UzNPak2U=Dn_vtu>f +0?lYEui`nB@_L#d0SPpMx{!+PDrf7T|9(zQ6!-!qiQr!?WxDA>z-bmQ>2C6dgx!OAa-H~Nx(sL=F%&Q +_oEB`9coUV^;-3ixEADlmwRQo(>hVLzDA3PoL{V>wf7HgV}Try3=beY?bpprc$5&3bA(?-Kcoy*g6Bg +*cHmN-giZEA|bg{*M57;ZBG)N)X?834D6B|P<3oWsybmgTAX27f|y|*c)N=rfo+&V2dCk3@g$nBo8L{tY* +-v3a6efWa}|Is$`n@ON5K59ho2FgLnBR=?0$}U5hu0d$aye)X1VEFNn^Dz4|GXbYIp5OctG4S#qJxy?&E7Fl_+$F&!EO(7`_9 +A7>nGJ&w(d%K5ndjjoY5HhOXOggg=k=x|UNq75-5hUwSZrYsbxz}Nyn*zw^(!^Y2QSlHm^MRo;Ed0<6Go% +lTe-X5ejNE3PxG97XU1|}aX7b&8N@Ocxazb2@{R)lwTwryk4JKh3beRk=Cw*&%a=RF{iAN$^LCmU08JgO1eGo_1m*yHDas7$CbTu1~v>OEYiY4%_nXg(rj +}!@QWh5*>_#0zK?78%9d;dyS)O5gLbSux!*p +(?wC2ja;8{GS3(uW#Oxs{@}TkkbUF7`pyfXPKudF{F0+G5qBOJXhz}zpH<*3npN~;7d{N#!zd|g5A&% +sc$q=4htB1?%CMD}>0bEtz*ZpjFdRrdyh9-M@IeBpy%EtvCnEa0*Z=eV>-XbV@BaGsJ(N6AZ@0uqpZ) +38x3AwslPPTZ8utlJ9$H^Kp~*uhGqlU5NI!ldiQ^M{Xv-K}xbh+t+9=pKA-_2tVPjkQ>FOzgE8#%VMNZ}IxLMs-EBIHdynhA_!8IfED? +UpbU8`UCHc|9BN?YZe?aLJG6Q1Bh*#VuaXvVpzSO8H^&#!g +&JgTVph8aO);s8!Q48C$Q+nacYhY8!S8a%Ezaei3=&?tz*Sb%d(#F6=PSieF%)8UD%*s +q7N`pVtkoMC%;tPPs&+{E@D~T3RB!9yNZt{@jMe(n;3nRz!q68V05d%QF%aMz^XY6@|K`EMe;=igBJ2 +s1kLla0Xi<3;yuy1$;2I3Y#}X9wZ=Uqpo6C-n`yWnvR;_ux*m>Gtsb5-_iic~AO!{d94NTydm*u4ap& +o7N^Xkyh1WO?#AlwUeEC!`RhbL~$^Q2dTjQA%l!MoLh(b3@*}gVvro!~a%)@zs$CFakZL`Uyka=4`L&L-^EpdX0)87KdlU+oXyOa~Z==Qr}2zZ_cS8+w+ +xOzE#9Ln2h*B^5Nko_ybOES{F)A39Sp=O1aRj$fR@t3*2>^XZ_)>fW*=2_@LK6(eqPST)Yx +n3bTDnJ(4}~#h-HkFJ6F19)`aDTiIUqDJQk5mJcHikUcg@QHA88q$Z|S`vQo{3)ZP-Db&7L!YP3qw~+ +8ZDpF2~Z4xgR$h%f)FDYAifXq_@jeDk^;wNrS>L~y&aYBvJ8f(l&h1Do+q^M&T3GljW?#r8- +0JlBvU64%LA>uk0W>?x@Vd?1a@+RYQTDYk|{BR4~bmijU(?i8&T#brSXW$S>E8PBrKWD%2*W=zgu!28 +-&cTO2@I4{@fE%mFa(#nb3PRWmEsu`C@@ku00db5T3ntT%2rg<<&)I+9{p9-O|MF#7l^(S}FRzsw5cj +X>z5bKv-(ua_HuSGh_Ip<)>(Cso>`;iR{wDqQ5RoPkRooN;Jo@ZAvOch~)=X5FW?aoVkKkAf1p>fKZf +gU~acE1iKEngqHafXkHE3Le)alS4QvZvaD<~w7R@&jhUheqS0PxgH9cX#A#@FVlU@$^TN$UF8*O~r1w +GaLu@M7}78UMz~n`#L%Ge3u!C#Cq1wg{!ODiOQEst7odaIs*RNuRUOE+#9I*RZfzN3z>}yh@cW<(-ne +g@cIRQkcj&jil}n#x{-T5BM4;AQ~jmo^0P%PZ5Sso;=)6^1V}$I1iFbFAB{)d<3644SeqxE%lPq+(6J +~_<;~~@7;o^AG_5je72o}J+w8cHxm7;ydBBOZEVfD}C$G)KjZwo?MDCV98^-4K&5C=^@+*N-d7VZb1* +PJI`c8}+6E0y4Y*s3rJ^6gqZiu#3gOw+Hi`NN6Gya8|P)^ph8_}bX-L)-PPiK8OHG=MN_Sta_ZdMuAY +zD62-75Mwb*E^XR{pGMS}3sMX>NyVyK!)KU9-ZkJ6qaN9)}Cxo%>`<8}6JfO`Ad9@TXEZeunU;hYZ6| +WYlheZ-l}jRN+DY>7e^;I2`m~vFbm4-amOdeBM2NelmFev^RWue9|929d_;G#X2z?stFOX;m0o+u;DL +$mw1g}w8l0;dWZaL!{76--7jKeOa3*q)97`6Pr&w@NWeC{Ljty6S%#_4aoJrU-;~tknvMCq+Z~On@&N +6UY-;_RzTU1(Nk@vEK}Sx*wn^Ncq-{m4y-}f06`nbO2K0VdAJ7R^c}-^=44l@zj;kHo;UP;s7ywa-l}wZTGC~MtA3ML90oFMX(A{-L8|paDck(XwSt7o6 +Ig!lLns8`5bAA4z9_=XRu)lE@)aigQQn9%T*7#g$;mBGLU!`(c`48T3KCDdq7WA8B9N_89MEw1Aj&pr +^3M&Lo2Ob*BQ1WQOs*#ywr)^-s3AXo+T&N>4Fdy@MA|a&(`^Iq!1%fofmU2*DYIgRXf>5fLx@xsfZtL +|$hy~8mI|tJn)y0%I_^k@EtgH|Wax#HH(d?JOLVvQF~N`Gg6T_|k1-vV=bWj+qutQI85$YZjb0c4iN+>Qanjn-n58A&YUcr|4)elUdUv;l=|DxiV&TlMJwd?@IT6 +}zZ&)g1#PP||=o9JI{Aa1}MZ?*H?TU~mZYyKLdGcPbeQ4Jv$6jHsG>6q^G4u>8 +dVfR-UTLxoyQ+cf_4?(=_3t!u40tEqmOXKFj1<!61<*W4TqTQioYpKlhI@AwxaSL(O!vv{Y(!Bakfw6Kh*K1i}G@ +5Tu^BRCZ52bo7%g^B%ZT-;=q=1FKTiHP#BnhlUZ`UNS62-6+ggj*V3{DUwBQYL*V9i=|_5&{D)H@0!3 +)99A80*AIuc|)N<~8)Ax~dc0T_d=^SS?_}v{{_yo3%JmxE7hj=-`0U&?Y?9vXgKEl#4cVWg^cZgc}6gaa_9|I!nu +}o(>>{vc-Y*?w&F_l!wV{8UXIkYkD13CN{;-wKJQ_-?zE$80B_IZ2F64=u|6Jg$K<2Qmt9~uRq7&7j+ +)`x(M+#~kDu>t5@PCfi$^5o-hY*#HN;H7W30|d|ukB{6nDVNGs!?&rqgMe+- +T<1QY-O00;o@p|(a~9tVwP0RR960{{RR0001RX>c!Jc4cm4Z*nhkWi57PZe(wAE^v8uQo(M*Fbuu +-D?D~cI?+n(h{R{?gisW~Egm7Ql7K+k$InUAQfVxQ)N$T(o}WvXzHYp+nd(weEE|)q3yaSB~c+Ijb)ym1@YKQe{~bM{MBgb&IlG7r?7`WP@CM#oQVkRyVZA&ei<`wg-dS{t +SuTqD**JSL2<6T;*yBG*)Xm2aN@?QIsJcSc8l*^L<=d)=ce6BOfDxNH4}n-ER>nET1ioIqjs0z5 +GPE6yo0AZkO$3yZ4E+nVhOejoa*)A%v~oWKXkQ*>{-4LCAbP3B1QuTMUxTS3+bZH!<_6?o6| +%Ee4JHr#{Qm6Kbe8*Et|aUC})K5A^+ifq$~S-1amTCh<{#aJoWY(OX#^(Z9<}}CIA2z000 +1RX>c!Jc4cm4Z*nhkWpr|RX>MmOaCyC2|8L{A7609T1>yWKIpJf-zpuzG-H{)PEMa1DbOis%k +343%WC^Kq7$j=V$VEwG_*2i!$uCSuUgYE~T#x_>ruEcx_7{ZM6&2Y4ZeA!-Nd_2Pl9XqRu&0=nitwDo +#iqq8YM)GUu%qFr6`b7SWv=KY7-KwYN6LkmFFiX+wC@_TG+4<4=0%+lP5o3y}i7?yL=4 +-*9(5mGbSYw?B5j^pzLZ#XbA$vbOmB&bV~|B=!0M|rwSB!E4bqM!<@(>Ra+_;!X#WO!B>@X?A3?|TH6 +F*F`AR<#T~i2o07j>++E$x5#;^V{SP-k-;?(jx3?G9_g9y9bi|b#>->u1m|1yVHi$+y7*`G{^IJMEXnEOn>XKlb^7PCH-MY46#T5jE;vr8c#v~)e4Kp +V&dw(UKGW$`|9!{eLQn<5r&S)K=AbggP?d`2ic`g;Ho`4Jq1lSnCl)Kc_`8w{x*-PtoRo#+h(I#}1J# +D*N|KUFX@Y4V0!nsHKC|7n5Q%s7m<){~V8*J{#$6SVSKn#X(XaK_U`D7Uk2K>67%*4#NiX9m$ygp}4Q +6BsHq>iknq`<0X5z!*V{JD4pkcRymXX8=WI+mZ?W9%;0w6>R33JX&v$SMMlm^F*TUxK!ACS5dd8>0U3 +sI;bg$33+mvgYKDqsk`0yoe`)8&=u4>zX%J@+LLDCyIgL&zaTM{Kt0)R2%hLHkP$E@P +F0YFmHh?YV%6#>cMUa&dRf=s&73I}t#l%7Kgk^L$MuiNcls~a#FNLW`(T3-ipzSDq+PfHvjbNBn^_w=gXM6)TMi +L?;t&aE_IK{{mr`@LKA2b*3hEscEn^7SuyC)cp;=k?M!rnH6=!ZG#@^;(z;V$Y+y(_K(2{o`EURG}zl^WW=w_8rQfmqAf)?l +;8o6DN2EE~#J{zQXwCOaP*?i?5Ru2r02TGV;K?BSVh6aX`H#D4ycD&tObZFGNS$&Y{wHHpzxRuv$?+( +}Tqh1xsjIq*np{EKrzuZGuv59f=?Q(1v4x8%+{L}}{5rH(yzCPcpt5)K +FrYYV*5q)iiPkO0WY0bc=>pspNh0W2S)iWrhi%ukK`+GsF8+i +;kp_`(DJqhn{(fli>wv0g$qw(5E=@YSk%<3ezH_n$A*`SZf-0unSs;t)tcyuw7ddKIvN#nuUZ|*<9%{ +sk@d-Tg`-+r&nkayhhGSfANNhj^T8V@@`=uohH)2?QY^)YBPdl*apbB=1RW$ltZdP03gf-!=wSvn@cS +P6SgPG>WBd(nLVN*3;J(8{wIIN#a^(2axE=7qcnxWN7lTI4aPy~Z19?v4@HV}Nh>9AQT+Grr(u4Q%h< +wQUWFWvqIsz5wf1IxWwErT3z;R?2lzWr@48Ids}faT;_md@ZeO+Hg%}*9-IwpcnsVIofeGy=eGIvxGhFpRncKdYAqeI7w;st3{(0^a)WB6iTV-F?N5nAuFdc}zj({RxX`Cg5Ag+-=$dDi4 +<`|b=EG~LKW-pmu0$Fzj%soxn>T@x`#D1meUFZbRs&1q`VLt=(g&V)rHqOt2Arz_X)XmL{1 +o9o9L@H=ug*m|5e0sCGZChNhNR&A=nd(D_j${3bggxeF|t*7g^|FOQ%si&}){iRMUcvFc=QP +H!uQUNf~N^s3UN-kt)-`_g&#hkh|Z%x6^+{uBzPmj|8uKP*1Zt!RKA#CbeB(2{f~KNCb&cnVgEIy^1k +KEnt#>a=!+JSV>`exDPq?fJj*-%fv@hAC!Vy)*V>emV_56+92xpRCl>ky-_=YO`l3*B9d#Tnyh2Nzrk +dx$pFi*DiZW*%l`|w4CyUDF7&H81m+qVs#uo@J9^9sytjX5G@*ZB3g2LPG6~Zk2aoE9v?TB>ooZQru* +pH%V9qGFHlPZ1QY-O00;o@p|(b1X@*YW8~^~|a{vGm0001RX>c!Jc4cm4Z*nhlX?QMhd96MDbK5quzw +58SQ>SCjo$g|Nlw$gT!urDki?oIS%S2!ySe}U?JfWk{FE%mlZgmmcd=OPE*2oU9 +1e#cvmgwzfD5*YQ}&p`b+l$)>~ofF+>E7pBv>4=+g-MSpHt>WK6^794hMs8*m<1n(qO&GnB|Sw>8sbT +zJvdMVDEVJhr0~`i)TC)aWwb_pl^A)4TK1QOd!~Xr+m3%>(q@h?vL3j<($PU=55?`&BrW@p{pHB2%p8 +v%nc%B%?0L?9gqXqYy*TuyviQkloMyJ5V04yK#}>emv4ELxf%Aj3PKp8m2Eg1E)>RaMBVt@4S^o8i>< +nmJq9r193;R+mIfYD83T|P=05VFo5Nrms6G&##36tj5Y7dR1GycuZR`gt{N*&bBwvPs*o>JUAn|3ML8 +ZV-k4K0FWBE^*55YrZ4QSvD(TGb92@3m3P_UU2mB5tEPAz`VY>W0$k5*&UF*yP+->vDtKi3dDv!J@jzgg<0`N4IiWrp9&Eiy-#ja?|b_o} +Qf#bM27;y@{ov~rVX|bP{s_N&2yq_JX>%R>F?E%_BMcAt*mMV%qXyS`6yW;R!a0sdcDy2nlhDmzvbHvOpEMKb(yiei?t?oVN&fNg8}>hP?Q_FN +cPG%R3-;y|NN2(>ph`)=7%b~G`{^h4=Jkku$6iYgOQA@jv+M-?Wem=88FKW#8y8$F$}e77Bm(vyXS#g +5a|B*G*{JN2q{Du*VshXH$N1;-6H6f0~8sgUKvuO=@2iUX^B9&#&kx4fi2lRihbjg{1KfyLEL)-rbmE{7^$PBWmK6`eYoxFhKfj +Hx4|BMRa(Hhuwqq*geW?mu@ITzF}z9)nUZAe73KVvL!=F8*Pqjdd_Y{4w#?yhH=KV2p`@36WABW@u+f +!hvEOK5%PfkOui?#L~FzXRHuMXcf^zd=K{JI0Cz}yR{Mn5{Nk9pNpo*@^uLD6+}|75-|564t#;ZtCBQ +=ts#O0=T)PU@@@Q30Qo4gAc1AWu9;J)IR_1pe#tS$&@hfkrsBF5>qr3G5E@OT6hSe6R}g3US5lqIx!f +~}Fef2I(h+|=yN;vEoaV3?S_VnTi3pSw+xTOTog08K3}c{Lk7 +{mA39e>)n#!oAwm5r*u&`iIQn)>e`{0H-wktxGqpg`JHT1jeWh_xgb*`zlYOQLvkaNwnyx_*Cri +hd;NBaP;J!Z>~xU_AU)=8Ak7CswJ?HzO>fYGsk>?pLz7mp2RoUzQSTp60nsJZI=_2eS>b;=otcJIR-p +aR*06J1`l7<8EP|&i0K0XwjSN9}S`8I-gfU@TfP+;j+o)X^#v-xafr;SBMjH~e&4-{Dx9ckEu;tijC6 +?U+Qphoo!gcv}di&tX4>!8QWO?$MW +H)vzk4`#ayYgmbAIz$RbX7&Ti%G6<>b5X^(RL~+Kj6K(3INR3bhQJy~%I=l2>Z;b}w!oZMB>sXEb!ZQ +b1iCLusRRMz`{BlIboChL^@O01P78!*Rh1NEuk}Uk+7J@Z>IRQFS%0&cI+HBicm6_DUQn8#sIEm}syX +&4A(2fTG=8{I1=Aib0JhMb_Ur#mdP!vh!FY)gafN`$QO~C+&7XOY;^}^13Km6DtP|WfneE{Y +^_)KdMh=U?PFkHX&92o;U>T{2I8Qwl!qaGwoIqFPilS~XaEb-+tbGO5k*%@Nl0wfiz7=NhT`sa%N0yC +i7g#6-q=4%$JKcBSDw5GBh7 +#{^sF9MHd*1Y!OFywS}*U2h^UqU#kQT6qKsFFX8T$T<%fBK5^{m)>J_9+1T=_cXeX)~AO?=jCBq*(;o +C2@6*QDMX!s>z6k_2Ot1tP{LjLN4W;%D1xIj*#q9u4JC<9K3FW^Osv^9pwnOhHLzV9~-OMz#Tu|Zg)< +$NjVq@0@un_fHo4FEK6W9iSGmchnq?Uu@DAJEMT);Ht(Szq%iQZhAcWzx1obKm@mZV)=#09My+4!Q!J5DBWcuVz=%t7bKV+a>rOx=|c;kc +L>Hi+TlVPX~A#s!I5-QbPm@Xb&O0Q&uJPu2MsU2&jz^!hX2ByIt_~K~7t^dA1UFbxYGGr-xsQ^wOx~|!1WR&y(qbpdeY>t0@p_ +{3n=2alRp|AYkRS>djeNK8VibjSg?B0<10c=WTmKSl$E_R9Ql%lx+rEh>Qx}%AdFLQ6UWL+XZPn=bFO +O|XP5?G24;U3+bup3RL;mb)#y3u>%ze7mHvHIMYH=CDd{SXlrp|At`vc|V-3=%TP_4_x|Xrho-0{?7g +w~&fa)JsUAwdUs(yFNZm+)QX$XEyF4sU>Z%^smj!tdu8ic}-Yj__?j(h4}k{Uvjl;v)ceZ+d(dbmvEW +t^44O0B3EGi%#uJ#E7@@r-aUY4BM=$9)kB;uUIGHJ2?%`-o66WIhxOsGBrwZ}dZd +2Ix;)(9_QAxV6gGhHr;%0>|KNmBvtXc<;Re(=J3)-s1>)A?$1R|b=v3E2&K)BnZya%D1@_s&ciVtT64 +|^@DwvhJv>FTQ5yN0x^v*kM2i`l+1_VP98SpD{_a(lwUQ8NTpfoOXSY1V4_?p<&xJp5V}hW-YoOx!#j&{Ou=fB%y^G_;M&G$=HTr@|yV|yo_As?2+@sW%FniUuov-JrtE8abJcvz$Ztq!7XjYk?{Xk}NTB<<;42qmeR3Zk+{h1)oCu^f=RUFXQa +bWR#cdjUT!oN6G{KZQM;Bo4U@L$INx$ABC3u%0e=vlp&ijn;0%RCi8r5sB9;iwe| +puCW~QJx%w4Z&-D^?k-Px{sv9jX5IW;$1$6bI^^h4t +?uk;XsuuDIBMDC4Rr+^>F%Z-7_b-Tm71M3ioPYbtbyW?bE}ySO1g(o~PW+ICC3{Mvt0{#PxK#7B2X9i +7%+&bLjdp@e=Cb$Bhw)7%$&SLO~l3X15&;s#o1HxH=F|pTZ!XTEq^-ESEfqE6x329u?xWzU=0jn`_>kICL}R=vz|K0o`dplWBo8urp#o6_gec$CsSY97(q-ESpb0O#24I%kMo<*GhES>K7=u~H6}!*}*MGoAB^-Pl8 +WYOUo2F0MKu!NO%$_m-(rl_2R**HFL6F%<#u^Rq2Z+|OOddQp4BaKYBdRZZ`qv=%zGt&zH`-Y^>39b0 +3^6je$7QL|a(YAYUcSv4QMwhP1MS;1mT$h8da7R$%A;kRN4}%eW>~7C$$)B*lkL&c=15%i9@Lpi@^VE +*TnZ)ZtegQEd>OiSG#j?k%hHLru%yz4w92#2YY9vLmG9K6bwUOKdMvg49GVAGjh4hMMxT~`WgKDknlt +EBmm&j7o0N=Y0bJ`ZJd?@5R4c%Min^OTgzD+;`VZ3IRQrwU2;=YQql$k?qHqP$vFEz#nl~rtGB7poRm|5L<@^v>Ze?ylgiyi0f_yY6keK(>Zuj +3cwdki~;(h$w^;2K_%q#CP_m)YoZF6XG~TBf;ffm({lhDwYgpmS+TG~P$si5(HO|#`7-mPo9=9U^3bF +sS=vKMjcp$-;?#7)eKaj#PbZdvOtA}hXnLrnC7LQDZ22&jHN@w1qVHa-T^Azctq4 +?sdE7R**2Di)p|ZABlHtAn!hSkqugy)s3Uh*;VwO59XkR@kgPmms<57EVwj#6C5*NPHC$@5hOwi@ZET +6^O%Q9Vh?U`(y#_s625Ti5tUU#M6BSiNEflZRlf047pNN172QUaKAplwf; +I*t&2@_)~=~pcgBDQsjn%*I%ZczmpJ7dnBG&_d~Ae;V~yCKHU^}3-6I;Xd_=X}kdN?4<^3S0w|09CKs +u4n@}f1l#?-c4nEg6TywH}c&ujyPMo-o1eMYtyfQDutjW?35>=>v1bR`NuzCUyeU;fv?Id7>5hbP4q! +Rp|kR0P}2ilMI%siY%NSmGBt@j$Qy$%*wnh*|P2AMj~L=jS|PomPRV35^PX&PBd~$9;<-R +FrpWZ$_nO$v8M{v3>s5F$}=u=Z)1|=^3>KgQ)C1yO|e}9t5hX3f~6AAFR5%9$wA1J6ooShZm;yVqXLC +p5xd>VuvB|V2g-Fac#uZT<;hvNhjc+!F>0K-anAyA;4hOBrh6L_Op8}pvPN(a;~)i-lUivWC}M5V$J< +lN#cRD8v(wSrmi~~OgJ+kPqKDUx4Bg)9pr)*A3d7X0T3McnmdKJ(5^XD^e|r(12Xt(jzyTB+Ml?uZ70 +G&C20=i$L{o-SqEISw!~SJ`!$nmr4l|lZ{P8=H?Lsaw$|Da99Ev1l-%}E@Q~QUCC9V=+RT8$7IH6o8c +q0;}FESru$BGLA@K#-yp0*OeVjg~O`EKUc0$5DT2QJHafeV4gMrP%fM860kvmZ;66@YKpOeQTt<}phU +?g=Pf$286IitB(#=4J~ryUvtlaI^yJL1H5mT7#Je>xy(c^eVA6FWOz#Jg5Gn8!E!k9b{uDYYT;GFtgH +lz3B@J+C%v%fMJ)2@keiV4A#erLX`mkFy^^vdUPW^p9|F4)O$>TQ#1-**Ey(Z3=cg3PfUR|w8)qS04- +;sDS#S3cWGWtc}NbYrj$fdRFbUfKWXuJPO5H+Ag9}0WS9vMS;Y?mxGHn_(8&K4`L&UAdPll3as)hZs-emI;|2s9_T`l;Ng}CMN0|t4|Ua&GjK@QDky6z)V#xvKpuu&WEaijZtU3^Am*;Z&b&QTsF_tf_wP-Yc8JPvU?Z +LRhWxSeXYehfG7W0f=YgxTN6V-k{T}Ps~#T--kAU`^Y~E3k7IdvT3R43mvkpirHUW5hl;OC*?m7M_E*6=;{I8=UH>$n+}=*-&SbHe{c?>T4q4Q1;^&EvpS)>7`gnUWxtlHwx$90b2XX!8(y +DS!(81bRcQ*q3Dmv`16gWLuqORLc;2J4C6-!1GN!>RYlDk;imtopkx|wF-70fn8K`l?sV7T8ZOj)S2%E!2wOF}oIgTA*EC@t}EcNX~EMePCKx^?fd7fKDKXchFyc+t0q`~kK>_<7P8G)jaZaj%7C|2xY9Vk}e4zXNOc!6OriI6t)IBgnPaI;QNu +%T$on(PAY6^h>PP7b8>VZ@P?h%&cl&@Mq4TX_&DupW_K^iMjlMZ3AAY9QVZT?b43uWkG5#?SKNr +JaPsG#Szw+UAyEiik-|8H+1r=aPZRt+(Z1vrLom4cJNDbuI@bIos#?^;iFquj9K9N08i;O(tgEdAzW`R+k{+ +gXi8jMfXC72#KPjr=f{+Ni612(`Rwu+>bs5zyM8^NGlt10jk6r)B@s> +>@DVCvLc!v6GdL$^RGh6(EpFt38c?DyVt1R6-Lm5FYz#zD2Y_S2EvnNgJWAdK>QD<46p8MR$#PF{ +Z_sKTQ!lXc*Ghunc0*$W#2PBi^vqk|I}Id{oW!ipm4h6V;Z69~CYG&uoWn>79p-L#X1pTltBA(li?1+ +X}0b`#Gqt;N_kcL5&H=uLlMZ=CmGTY^3im7oTAuZ&H&X!#7>*L8U{Rl-Re5M}Yh`k5X<{#5UukY>bYEXCaCwbTJ8r`;4Bc} +I0v+rCfeuh0V}~xCx(kX;w?ZXRplByS(Ysf+6~PHQl#@t3z7K`3&pXIveIynzNtSkC@(^uQdcx2XEA0 +(`Av=3g>nq(>dK}E?L}QpNQ}7t%03G>g9Uj02L5_^F!%K%z;C0!0VJ0rh12kE-$x!%kbTTfr`}J!sHa +6kXWud>s?!YJ`2l)P}3&lvgn%+R?&vmGW&~EsSZxpg|nvmJ{xU`$Sxt^dwALR@ +6aWAK2mtS)wni=!+@!_@004^*001EX003}la4%nWWo~3|axY(PVRCC_a%^d0FKuCRYh`kCE^v9RS8Z? +GHW2=2WWGiRLP?lGd}y*m6T=}SW^1yrk +qcR=t8cHT@aW_7>$GpFTGe&WTu(eRO)YGaq8X>4OeWcqqfl76ucXk_%vMS-gMRz!-GrBH=VSjB;8!l2TegRvSbJcU}^afpwy@8c;b4e>_E7e_IbJBsq0VU}{Vd=;0 +xVyoKby^^CwT&QIuYEDbh!Xv(pB6O{^1!io!RHj{Zi3;zSymq`wCvUEi!kZH3H(1B@Z8qR8s)u{% +no)v~h&t@W|9NBq9vjfGPuGuK*aZ$ebN0?%ObH(Rrb-=XIKesk8~D0>OF%+PsYsmfK&r*N~fK-m6T)} +dO-f|gll7n3<2XOixm(}USuX$cb_#>DOMn%bh1V8UQdq63trniiIqV6aEAgVsz7c2jc`H)kt{q)Bi8ipcrG3*p!T*@@BU0^8LRHKtHcAN_VQ>2pK0Z>v^FsoLogV|D`8oA}KOq4ns1a6!Z0)r+Nf7M=Rx=bmSI9D$*;~$Qz>i!GGW9u%&=Y|NX&d>$*u=pnyW?Avq-obUaTb#V3hv +`cgle4pnkMq|k?E?4(d5vl81$y~esrsVv>l2Ipj13aD&IxpGb*5P9SC>|MRzCpJ1l4fu +DsKj!o(5MZGU#1&YTmmrNOE6Mp8w-@f3@xJ+%HaL_%-eCxe798-EWY^oz@O6Ph}c)>0S$i-RE;Hu_(P +XV_E0YtTgZCSIK&d&_JXMiNsvjYJ>exil&1>0IHinkc?1SA|gp<>Pr{SxX-%8sc^YP+xPCSNMa1O^MR +Nj8+`thhlc);BL~(-o@9ud=~v~Eli-OvTvn($S5<`+pTbj!|BBOecNuutkH9*6l-<3==N;O=Yt?`i1;Tugd&xIB*+Hnc2u>#MBAL+S=FYQb^@?Yr^d2*^mxgs=??=x@gpk*&@Eq4V> +CWYDSG;|A?n{&SpKusU(~pnG35DG$-Rpc7bBrhUUdeEf9Cl)94v&~CR~VD-m0I*!yNZJ-}Z($dKx76_F|%b_evR!L`{FHqT~3zypl +;ToEcqY-~<2XeIj~ +^kalfXgp^S*k&vR|~&7n+UV{?QlYGk=Pt4I&+@1GPZ1m-T7iir4Crn&o+^3imIL|K_%bxa;;%e$b~wb +h<|A{s&4%eD}+w2c6TFJ{d&%A5cpJ1QY-O00;o@p|(bx`l#=&0000k0RR9b0001RX>c!Jc4cm4Z*nhV +VPj}zV{dMBa&K%eUtei%X>?y-E^v8mk3kNCFc3xeJ;kIOc8xAvnrMg%6Fmc&)Bzfx(@cxR+gk(@7i|A +~fAU9bU7~HNWS@k4a6@28aQBI%MoUJiCw2rb0b%?=;!UZA2e5P3uHDI{md6A=`vyD?6hpocjnZ1Hs=_ +g2sVX=_aT90ZffCsl8PR~QUkGJ#aqNX{XIPpUze!?_7U5uyM{_Ea`VBCXUc!Jc4cm4Z*nhVVPj}zV{dMBa&K%eV +Ps)&bY*fbaCx0qQETKj5PsiZAug2lhQ%aYp91^P=5p6UDF@x-9!fD6iWf>reh!=a!eMwpvL +Ex;J{{VP8Nl>c~~*LME%O8sJI +pNb8!ZHQk7vlX252DuD^cUueWUd>FKwp{nPrd&C0n{aAZXxYGI2aGa!#!=HlM{u4>pilhNf~7GU|a+3 +j_kGzp0)T<}X!2DHF%{{_8dae`J0V@0`SaLe_x*|OW)mrIud2i#)nvP8V`IH_h2M1I%J>y9Y?#qta*OuBw?;h>qGhGGPM%{DY}QVb;#g7ltFIzw=P0QMGZ77hp9 +&MNrGsw+X2=d +$R0)A@^nrM*)X-V?i{>6oA~h|4u$4aA-#eM0e&^Ei>8xiqjq{GSQVF~6hE;mXeZ1$*=$2WkMVp+|w+` +4Hv)Bn-OW|y89a`o%ncYW09>0?k+Wa%Mqsft=9b8So)?b6VZX7O5>X`}ydI+dg_&^cV*LIgW@P5~e(U +kL#l&!~JGy2>o>@&gLRYbA6c{qmWx0>h6_IJjsN2k;U4^*@R^b_sEVn0@3OsyXF}Z`U(3=CW`@6dzu+eDPEYwwl1m2xzSe6<}M}L~;93k*=g +OlgHv_S^6yR3pzRaizWEb_c-DsTC?Rmr~25=Dy$Gb!Fwyi@^s;a3wKrXTO_1HxFoAeRJuKW9PmluVpx +{gcgPsT8wr*kd@OsN)Q6#;fTpo=>(HTX&u$Kn{QaKyr1BSM_~&YAKGBNiWUysXl{w?s{W3>@cMP9Qem +G41FPZIdIm0Dfk{m2SKP)0xJsTasodt8H)@%V-GXF0b)f=dxq)_N)|^tUlU&?OMPYVOV1+DbakRg>GrWuvV(X)=pE)Wtmx*)xNid=1|nd4;VB2fyGn+T9oNIv)M`Xy~w3lNb?zHJ}<)K}*Mt9Tg%Uoh-wTcSgHXs +&1l-zZZwN{rl((@4aI84*vmAO9KQH000080Pmr;MiQ#V@GJoU02TuP03iSX0B~t=FJE?LZe(wAFJob2 +Xk}w>Zgg^QY%gPBV`ybAaCx0ky>5dr5Z?V1Cnh4LJV2xj{aGSKQHSoxwU6M&*vLLwMN!_pXGjAq6|Dy +l+VQ&9i<1Hs;_lMq5#86!N&h|ftSAAGDfLI59DgCkNN(N=3X;h6_;J3*R=aPYMI@rpWMjk +q|)t>IJJ4*vkxXp!(=%F6mUASa-fbKdj5a79Djd-7@IvNX<6S>Dw9kJRe+;N3Js8W)y}gl*p^o0yHXB +*~*Y9{6T2*9Fxgb-|4sMOy4z>IC>FU&7Yu^A|?%kJSfdQ+ukjy?*_7v>&X-==^o +@eNQ*0|XQR000O8@1eFv!o5Cvk^lezHvs?uA^-pYaA|NaUv_0~WN&gWV_{=xWn*t{baHQOFJo_QaA9; +VaCwzZy$*sv4Bq<`_XM}Nxtr)l3_HQ2n94zGdk}ql5sw%X9qiP6|4Hv#aPzgwy&E+~I(ezp&`~d}>4{ +yK2EbcDN$#+qJ5|@6aWAK2mtS)wnoc97a~Fo004|9001Tc003}la4%nWWo~3|a +xY_HV`yb#Z*FvQZ)`7PZ*FvQZ)|L3axQRr)fsDV8@chjeg!Mzpj9KSUx9lypi6U30vO0$4oR-}!F2>` +my#IoLq~G`xT62PGsDMnSCZp2?S~3Tyvv;#4(C0?;cz(kxE5?}%%+fw6UK{Gt)y9(nr&)jM9!AAVvQE +;4px~Gzc)e~oeqY8DNBTbMgNrXLR2|d{@ut@43?@cnJBp|(#FU_Gxu@Bl@>WSVs8EzSg4KMr1M)KQL8 +j;rHyJb(BR%H~Y_qCO+Bpo0eLk0!H1m0)MX{ +V%=-JP8CEW8|7{1c8kE(%{U>1r%94q)kY-dt4i-}^U`Ws2D6r +kU{Jzk@Vs#ax^6?(#2%W`7)89rG%N2B`n{ach{rUdvJn4IQI!EVF@c{TzNqh5Od4YR@@s0=j2EG4I>m +R`#)Sr(TNU|!#6Vq;`oCBt`B@xb^(*F|IS0GHq@3V1Jy`cC92o)~uiP7m34bo$mK+6!~_E~z8o*<16CTC}7X+U;e~KfifMslio8nJU=`f!rx +Y0&*Gg1(e@M+S}KoNt#t@6-Cbtu2*H;$Sa+-1Hk4W-nT;RLz1M>0Lg}s(glCGit)VlA>#^LWXI@M4gm}E2=jkhu8D62VF6!xw<-|=Uf4P?`+d(7l=lZ?H)kvQ*> +8KmNN7|wY`_FU)6Me#d=hvDkyIgXMGQsLnau+aBk5Zz*w~P@&4&)KFUCS)^g&UTQp8)%wqb)$pwDAY}LXdBY +1WcKbo_eM)&DS7I=545sirj$Fh8?s9vN;vGMZ#Z_HR5gHv@8%TMr`&RYbCv(jFB~~&60D+lNZD@?$?IxlV(Srr11uV>HS0#T4uS4YmLC$w;xMxUjqss#RTBC +V=!Bqz84?qGQHUV}?ON&oBA_g&AbF$_9_0G-=#^1NrXdTPx`vb}g;}PxS{<%USsbcm_Lq~>;{$DrgXv +lNJUwZ#W04mUvsA{xC?Kc7!IZFiMjN5*#ug8-xPjuZ?LtVc5gE#b)=C$RCO|I)I98(@h+&Bo!IsBqtV +9%HimupbbQ93XPIV$!t4&XTwyWDqh-C2op22ujP}m6j%Mq>a%XtUvH#{8zA_ms$lh%Wxh=@Y0#4Q-WL +SRRn_sC#OaNP+2Z6MQ>V|XGU;c@(3vN` +7O@^Tcc8->Nt93ml*hM1TfO^AglZPy6`AK$%tcg{Y79|?2@kSP?3O-Y46h@Bf}g1RXT*j-VeFnPx +{@CR}zVld^SwS;-C$`9Bq^^ys7vQ8&IN#PX2fcu?Rz_Nn0GoicV}}sVL$= +5SE*d~9FbLh?@!>DU6KT>;K%GCH-F9WQ985r!vJy5-S3*Zssb85Faw$-uK>cV(24vu${MX +xa4oBsR>(B9p1ln7I)p?`rwZrnBMolHWsOtwjkdokTOV}VEwaovGIBTt9Iuna~d?l%%AL_OX`K`v)M? +ysOd_H2*odjh?x6li-)Fgi3ioF8mEvjv*FL-$?Jkr+E~*{(BpNzOT0M0t<7*gT8fGt?Gjz=0ksWGRie +0f_pKR6N~7K`z-ofh%?iO4)Ba&$J*q3XeCfZu%Ew^hEh)8vQT5fr2GL&C0%L^PdG?iu$8lEV_&)6~lD9B5FDdnO>B}01@%KUhg +f|14ct8Q#fMs!D=ID|70CJ5J1bma@2rcpHvuRU2>IrMr0I~e$)VI8<5+~L+HbgiL}`k`0s(U{$h2dyL +e%6Gh-(r_TRRUaeCZP2GE^$E)Dkop#*_rG4%;QO_3U7Lm8Y=UvE6ui=?!uT2&KJRj=qnc~_Mp%zk4H_xY0yEQ#I3&ZT^>2XUn9vrUG8WdWJ9R=xTv#GTm*MphlJ)0%#D)~*EQlha +gIvKjt=S +X&e6s`6qTu3y0?6h;CJU*l@>Wx01KI+j~G?4{Q7p#uN_cnAOhCjbBdaA|NaUv_0~WN&gWV_{=xWn*t{baHQOFJ@_M +Wp{F6aByXEE^v9BR>5xLHW0o0D+b9SHjv6ij{$N>w_Tu@roa~1Ls1A6HL|#-NP(nc`|taPvL#vDOY4K +}Si?7O-n<#63BDua$#lIBiGIE$j=#NcHXChKjPyxaTPc0~Y%G5bs_!{$ef5oX+P!QDuZM?+{Q0FrB%Q +_(Qo#?dCPht8V>q2!qgy%|L?ve84-S{q8h4<;swU%-CzYY9p=mfglLEr2Wk;!1i5f5<6G>Yi8S!bv;x +p?ZF;eL(Rs5b>oZ$?ny-Vy;B;SlUBYLsPPv3x`QVOO5Mg(o9KKQdi0?+{lp$rc8B0MvLv6}1gKif=5g +c>5wcidGR;>bWz?T5-$#LzIyyRg~mQa9RZ=K%m){oJ$S0Jo^p5%R-$^iwX5ZJNoLxIht!ls&0SL_{hGWk7mSbE1$nD$8si>0lqshf2Hz0k^+?{2M^lpCV +cBkAg7tIex+bT|02b3CiRo$}M2tZh^ms;KOKD*s}H<-BW@yO$5X2k(j)In*+*gFmVeM;~ME5qt^je4m +pn~9K{RQnh=$_X%$%#g=IOjRISRHD+UvhXAW9~OXY1!eSF#PYp-L`V-CG5d^qfX+QXATcbfNnhCyRQU +t-aw&OWN-yC1SMO=IBb2{Sw9%HqBW+o$qhHi&S2ntc~I4Z+^QB)2`;CE{RTckJz7U=XSTqJc$TdF={e!d5EOOtj;q=Lo2Lm^3XJ#j7*bERd!##gH~WDU$!t>sE-%98?ey3IF +4YR$WMRd>5;P>Ffe$B%(&33*T=X*yJa6o`MOWRvGq3J2#Tih6W-F@@ruls=L!tNjss;`v&FWPNM9H9g +;SCfcePh2;~2-Z7j1ckBpdF!3ngT=n6cV`Q{!KR^dtd-?tGB@{!-i_eScHrky{&5{IdB6P)h>@6aWAK +2mtS)wnm#BRh+N|007kw001Tc003}la4%nWWo~3|axY_HV`yb#Z*FvQZ)`7UWp#3Cb98BAb1rasl~-G +j+Bg(`=T~^C5P^jR2By`b<)OQ6cPe$--Ih_csz#AX9B{{pv$it~t@_{h*s&eL+&VmjT+YqkxqLRwOD+ +^jFe62ZMTgeUisq!#$pp_4$uVVNr6`lge$BYZu}ZNbBUEA`$6a6!q4q_b=+5EqdpR-Y4|e`KsILbW)Nba#K=4Vw@==0%KrgtS;a4f(#ZN1V8-@#>^iV- +f39yT`({bf~ZOqwZyN;#$oI`;aKr_OK_^aC~MbhHOmhiZlPA$?AVMGm_J}9e)c2sQK`IHQo>5h}PkvH}9&8u84?`6Tb=6RC(=2oo09Y1=s-xq{qafg~omUzV~e|`ina){umr +X<1G2E|4@)uc>kwPO3<1B79>Yu6KW47qos{*R)KF4w(LEns9p6geP%6+ee1 +GsaHGX7pxQ9nq3cN?I2QlX*RT7RgO-|G*Rnm?Jv{`lT)CVMMn@HV=g$yfDv>)P&1v(U%OVmO4kI~;ErR9R5ng-HO%)Gv_2n;hqBQwgrhVpd=eV5A5UOe +m6uFsvSy8!mEyqk6j&aJ$j(-ceouzTGfGZ3TZPszzcsJi%Dyq#JAm5P!8}CjqcK|ur700A*aspZl9XH%#^G(4^KXZ1&p=&x>In(245$#jI~`rUkT +3YY0bU*Pd{GBw(lKhwB(j(`0j^s~x+ZxI3Y!|a$sTU!IC*Y3>&Z6LJt{z>{vGfIEPjfuNP(lM23wg(a +asrU_FIh!tYX#YOb&6V5cI+l3Uv}MZUv%}%>DLCfLW^`)bvGd&`T(8p(@3OTwGR~n&^*%_irESiBcyt +MHlCq3pq7NDuNhJhqI%B-iYs~RYFc}%~v2oo9I@&P-jc=jRimTDeAluu5NEtJl)kjP3C8tGwB193=eF +2ArA(}m(OxnA{J52n(JdFF%)i*?E50JM_-eS4~ax<_=B{Bn@JN?#2;&79jw~p-w53<)mA6q{@6aWAK2mtS)wnhvlf|bVy001o*001Qb003}la4%nWWo~3|axY_HV`yb#Z*FvQZ)`7fWpZg@Y-xIB +E^v9BSZ#0IHWL2sUoj`+uv(u^mzScr8rTnQn%?DrCdI{QKN!ZEl15&}T2U3L^=*s%_s)>iih8k~>mrE +tLOz@s&OGx_a^I-dKqfSP{neRtcT)9NpR}s`>)$Gwot>4f+Cw9obbG+MP;J`cuN`WmQ*GKVH(iSw{ER +n*`mWYkYiZ;Gzn8i30BNrFjWGSde_vhw^k3ACqQMEF=l2z!ot+g}!Z!Q*t1Z^KDsY<}4eB^sU!DQ|TB +OBlZ+c3@+$egV7HF>`p>rvt^#T+b8|yL9d?lTF$fz^rKcn>s$gT05P2Q61gyc|M=OZLl_*A4H`w0Oa2}y#H|Z_7cAN=C7bB+raDypZ*mD06aZ~cdI? +9x;jFI;vnlgkY=*a!Hd(~5&h9DDAZoy}5P4p+Nn%W +sz!1ifRlT()^9jdn|MJRv(SqR^6tgUid>-4xnh``rUOz1H0xi-cb+f{^81MFfP5B;b~TZb7tnG|gdLi +0VNc^#wGP}hnS5F(y|an(171Z +v!i}`bUArr-!cTfS)ez@PUaJQdC{DL%WgJ+fAN&!?$^nT_6|foOOq*=;68x^$81{EsWiCP@qFTvrP>J +7v7sjv_hez{fv}~j!?FI+!eC+uZO2YM3OR&EEZfvl)W$aPlZByU4hpA?-;Aez9&SGmnQ;zpXr^t9pt= +?gqCJ9-=_q}!BYqX#a2kCM3Di9g_oV0JF`d#diABKG)8W@EMq1sZx~ZgzSIKI;o4oyQC@(gKyPQSIkK +FhR8_i}RKSJNG-PjvzoNYm;^twY6yX(ZZigg&mw|1v({C*DN$Gk_K$h81GQu$NkMPemi(*^UDGd)49FwpHy6h5&3Xyof?aeiZlEYa-zYhZ#2FR2 +3x6S*K8s?H#oJQM2q3P_ohrpc>^Q9$2|9An_fV`)MBqDh3q$Gz>XGUthkyfxmeBqOs-PcXr@!k!NdMO;8@k#Wuffq-0*8 +!nG2ljs;VYnpE?r2yuDO;hIv%LUeXzZQ^q^Ry!U8fahVez5vL4-Y+CVFt`$MeM^W@M6;*khwMtUFyf3 +_Ze(I-!plEx#wju(2eL@M(lHd+PX}Cm4F%9Na!(@rJJp@)4E7xKUTzc#`dA~)m|Y7G2j!NEWQ0BeJ*kQ2cDgs9W}_J2lOPmLeVidCN{u2 +5pe|&^&5m-`&Qxl4sAhd?pPGK35x4S6L%(Tk$|;?yR^T)b>rC0Ax=5G1Xt}4yH6bJ37kDT!cRw{ni^iE@a^fExi;qW0bkIdHFcV*V!6}R4vW>!1Wxq +RU-K-8yINWy +1|EMsH3Y+k3O!~RW6Kg$t+I%(+|Nm)oy!IEIH@~oq{s2%*0|XQR000O8@1eFvi+jaFyZ`_I@&Nzmoa`m! +9c$30C(aCNPV4rqrXBNpi!Oq0p6Lk;L$iTIsj?O*k;Y;a$AhyMH+y01@h|mVjC0sv*U9~ysIOy%Nxrm +$FN&9i*u-HiFt4RKq6_0#j%2xDyi~1oAipmi+-xO9KQH000080Pmr;MxGs3{L26U0C52T04o3 +h0B~t=FJE?LZe(wAFJob2Xk}w>Zgg^QY%gPBV`yb_FJE72ZfSI1UoLQYeULG40x=AQ_xy^tU0L`6NS! +Jwu@nihbgH7nC#>Ejk>jKA@0;W}1Phs*&(BZK?j?>;y6B(S1Rhfqg(puzjZwL749e@PYTffdKhC-nEy +B-2J}NMDag-Fh#l04)Fj0B~t=FJE?LZe(wAFJob2Xk}w>Zgg^QY%gPBV`yb_FJ@_MWnW` +qV`ybAaCx0qZExE)5dQ98!MPtQXND4VTL%~jup~`@0%;7S*|MT21X?;pj3rVa={O$x<9A0=5@jdbFnz +Ho-uv_1krqv>v}F}HRV`K%;g`xxCZ$#lYek!8Paq4W(^}>0Qq;hL&^4~FaQ(Vu+N=wq_w_!}$6ncMr) +kdfsuwxu1}^ABzpJFxs;)tIB5wPl|2&yY3Mg4-Am3=nR0}fOYGENE*OE6dXJw-bm@Os@pEv9tn3DC5Z +Mn3}D(0l=#a6;F(wZ})7+GS%G9iP6QzA>wPFeE@!%nec=`y>&UEW-OnFI&!)5Y!O*&X}t7ngrtT(hmH +YgTemGf|>1aIP4yHSl7`;8_@Joae3g6|8wZ7tN7`?U7S6>5z{eJpNUR~B76qCxb5>ZiGW_C?2cTacdvLn|9EqD`{i|ie!uf}4yDo#1(%ZA=s>&(w*qQF+Ho1kLFICxI3$G$rVuRc0knEIct@ui8 +uc{v!OZQ!a}KR#$;aiT)=JOW^0Rx10)NBqI(9Z2V;!t6f{v^mOLH#SBT1OGXc@0?j{>KZFxcK65v?!t +I9*~I(G^MePhAsJ7)#HCG0k%fLdil{p(G;GqIK#4y9IPZ#``ijDmgfjZO${=;xbqQDuMU40<rIAV02T!0+uXt@JX*5F#pPs0b_a`Uw-dq2mZYS_73J`rV{FV_er#FhQr +Ps`by%~fhRv>JM-X!K2GN{H|i%}RZarOtVH{e<)nO<;7qQsSv^*xJLJpi>ULiAcdV^5Lp>HhH< +85jqB81TrFT%wpH5GsN?&st=4WhGITETN69>CZn;NTcq%0NyxE91twS>9bPa3*4Hz5A}~3G=+-^1&Ss)b4m{?9d +#xBh3W7KBSQy|9l2mu*%xjERK&KgsnC!yyY~LwNxW3|F&|)G*%ZX} +PwphB&elFaLG%%eNW(k$v^cZ!b)dmfI?QRKk}bjau}`8H{R$EDp6=!!9Znh0#Su^`zaHr&O=blfUmId +&Q1IA{q}I-D08K!IJpl_*Spp&Zz2T^`drJrF2xq2%9+SIeVi1{kPyF^gi)5-nINO1Vf92i(4-^n$h%N +!g$vKR4_@GJTAzc&wf7Yj-g=x;iUFxcc*J#r@eOaZm3v?69#XP{&I^a0MG4)*RFX-GS21;7i_ZT@|lk +Zz>B!hgP?d#U;6rSM!g5;z=rOg{P +eBaoYU-_B!?1xG7O6@MlMVZwdOID?fDR-7hAD`R)Cy@&Af4jEiFP33try!W_!+H&9Ch1QY-O00;o@p| +(cTh{jZ=0RRBa0{{Rn0001RX>c!Jc4cm4Z*nhVVPj}zV{dMBa&K%eV_{=xWpgibWn^h{Ut?ioXk{*Nd +394wZ`&{oz57>ixztWmFYAUJ3iPzgPQ@@_XF;*(TCFSv64N&Sex#%LV_S5vX!5B!K0%PB7vcVTcD*&Sj$@Vyg^LtSg23w#&+Np$1@FtaHs)qvjtX8X^C+dQS`+5gW=ntCo-a1Ps4h<0 +7LZ_1^icH(U%|huW>&S`71$rP;FOyZp0O=DvO0c(03^_Ig*p?8h*VzrX0yO%RU=8=*`0;hO-B!gcOW6 +x*pswM|cD>$J@cC?T$Bok|!7ns6eb-HgW!S%9LtN~jAp=p$dP_=`30=G4*1ezgBFV%3O3mvG6+Lfp^Ax*K<-_Tjy(u +BX6{bCTtE%{tYXd~DR9W72=eH0fs0azu?o9S7o!!<+a6-2o%CA)X=DKZAA-s6$DRzMtBUtcb8c}M5r%m{MsdZ9}bVawje#(G#=i4J?1W)q`fQ7*xZb7yY>!O;nQz!U-^>^ +6C^FAJ#2p;onU3z|GdvW^Cq+Kwf{i==SIPs%&Lvh{&}+KOekUD(q#g);VTDEUnS%by$hLEcP%llg!Se +0(9Ls_Kpsh<#PT43bP6Z4#xPP)h>@6aWAK2mtS)wnmqug6%W|00009000~S003}la4%nWWo~3|axY_V +Y;SU5ZDB8AZgXiaaCxV&ZZpje7sj{=DS-}<$#!--9@QK`t&tf?Y{J{GBs&; +~QD<|pz5q*~{-dMgU(y9c`R>5!dL!X3XGCrYgImI7h6m_+ey;Vqm1kYLPk?$0^1-EVLXcB$vl +P?&9LLRuInr|RKPZ0?lXinGUP;}fN(M&LAoKFq!Kx#`BHVt9Cn;CN!eQUWH~ooif<_+ndmrk#B10{xx +2o+MAmttzvvE^lyq{wzSONt9XCOdk{u>Gs7b+z)MR~d|Mq&lzg%ZJk6v2eU1t!FiQ1yk?tR%_FY2(>gOXr$NE%zymERF+yDI7uj@GD(^OvsJrTb&2(}$~iEy +MW76pw1|Gn^+Q*{a%qNjgj8QeJW;u6x{3R0pnm=#*&fyE)+mWA(-mzaZk-Jl<)9)rJ*NGt5++=$RbT0 +zi=3Y?_2KJFpuT^S*;xgdE?*;T9EHQ_ojr!L;ak*Er5=RQm$yiVmGtX$UMipaej5(Immi +G$k4D*iHqF~c;XU;g5=qrwYntD>@w9W**sjqUuKtyQOWS5hcp_4c$eL=$VZUqh?Y8u7O;>nU=|N+hEu>d;AR%blRD@c@GTyXr;jzzE9ZEKUxf+`xDRjQ$s#-j9}I}Tg +_Bo`j|M#6juvqpT$Sn0<3$~OatyhE#Rk>MM>xWYP@Wy&39}5uez(iH#AO?P?4{YKJGDb0UxD19Dj#7> +!j~NrWIVdLU6@)W@t-FAC$9pkRzK<{*phq#QTKv03QR+=gBp#r*AmEvOsOs$T +SU)2mSAn7lg0Ro!=0-FH>n*jow0Ro!=0-FH>n*jow0fPV60KR8)fbZEX;CnU?_@2!KzGriR@7ZkNdo~ +~VUfl?DdB|Rlf|(v&1~5It(fzTSMdFj`>^>ZqJ>9DCNjTOQv*$SaXi;y~y?Q)wpyg=WokP>xa!e}cwC +HX*#ohJ7i;Jw~{0mS^0|XQR000O8@1eFv{&Bc0;|Tx&E+hZ|BLDyZaA|NaUv_0~WN&gWV{dG4a$#*@F +JW$TX>@OQX>KzzE^v9RT5WIJI1>JzU%}gakepMDynHwyJ)>|OZ<}qJ0!fNoFAW4mrekeoQcF@zeS7=g +Z-%5Kijo!I-We#Omzjq%!)Jy=s{3Tdi;c*hSBm_?S)x`6BkvQTa=IZWN5`jQa(;V3P7h~!Qc6nlETv4 ++h)7Dw)#Yq{eLE-1ET`kWY+Z1nh@jP#+{o&Z%e}p&;A=8Yn9PWMI)&?>xd1f0I#1GX=IT~$a(Jl!Shb +goDJs^L=6%NQ;5NdG8PB=USDwP@NhJ<9i#*@k+pAzECM6GBwa1}xm=5eip){W +!1lA2WVzJN6w0y=42*mJynrV0nI9Y*6E7cEn)RM;NYN;hz3A`FnCKa>OH+cP$@TB@cN=F=U&$86{)*5 +$g$=^7%6#Hr`KB7&a%2qOp(3;rTu{xZlHh+$Tc>Gka;Nmq#g@=-$wNq;LT&_EhKVcgN6Nb?`^4ai!QO +4-Q-s;Z5Jw0@up<5;XfZokdTHZKwu?!PHwH;hx;oB`yDmpR +aa5^VyQ3B_09RDv@}nInsqSPpd35=%*MgxUibqrP@WNx^a`Pe>k9zO*G6MyNZMLe{@Fvh{i5Rn$7FC^ +TwD;w*kKv<4L}$C!I$G9dv|fh$DUWsa54m2Om#*}>iX=3@Y~MHtGyXM(f-xH*~QGYaiz3esI&eb^0xdavt_+v^+wHjMJk7~_O +_R95ik);50|UUlacK%7vYLf)ieO>l9MptfCY=b1I)_tr!F)lK&JW_~-ri>FstXC$;3V{J_gBS&Nu4d|ZVT)umM +=O{|kw^yCG6&S?0xcoQ(aQ*4#1<>t_?4Tbl=^~=hxe +{_3I)1FY~LbPxspa%==;QKhKAp|2!Yk{y2R%zrLGp2e1M|7_%?afe_%^A?^G3mv;jWKm@-GPaY&dM}0 +`+3Q4U=5zqhe3T+}?bzemTk_=+O`yG)qVFt0Z#Exi&J%eyYWJf$?(xuu3wux?V;MF^*go60~oAL*85g%>Nvl(Hfil{ZSnwyY +m>(CYLf>rP@A;2Uz@rS+*X_HdzD^XLhugiKbND!3!p;+-AVM!r+A);~aDy^DSJMzQiVT!|dFy^O%;y!ocGq+@x)o2rE8azmA)gP3%(09J)d2?iiFYf7iaUr-=g7%PaVj7(KM0V0Xp +zTgxWlVU0`Vl!eFi75d-r|WD+Nvj`B9Szfsh~A0!7cn2_nI-CAwCQak!Otlj{{(>(Qo#v)urGv(_ick +N%AClUMkva0(MPCC9YJgEq}@olPg;c5j0N}v?nb?SY32{((IEdD3wJ-&f)KZzp#kR;0m}8a|%gw0XNt +=x3qplWCM`D2UD;E5}X{eQAC1sd#7(^cmrrhc!Tzahx+c12kXmYZ>(&blEts3R3Q#D6r=7chz(6|C%2 +`qF`qsE4}Fd8uJlTNrd1xH!s}b?03LfPdwYSd!K;qOuiP#N@H4EXBTgdTg8upZ>a|tJT`qol^HVpw_h +ErN#1G!=85+|}!K$YRg#g1|ikeRpoMD6N$n@bHH#oKSg0leH{IbyhX9Yjg^l6@W7HqA$$Y&joqmwPGh +ns^MtEvLWPM2lZ5}d5P{{T=+0|XQR000O8@1eFv?qbWv3IYHCJq7>(A^-pYaA|NaUv_0~WN&gWV{dG4 +a$#*@FKKRRbZKF1X>(;RaCwbXO>f&U488kT5ZIwMkQ!Ta8{os1W!Q$HmloS$9RjtcV*!d}Q1Y_;`%&_ +j>~u{H1hM$>_((qM4QxzvBDt>}d^1|OT4?wp$SFL*&D(eD96sKCg7x)AiPj=0`Gnfy3M?Xg|GL@U-ff +|h3iCuB8bc0*!@trECwsC$!G|O{l4 +u$%pUsMV=ZPK5U1>D3=d(~2nL&va5L$FQp;Vf^Pk^6@WExS-@+h*;m0G$~w9W)q5nxyFWb_{-SKM+j9 +-JfD^zWWxaZfFBsZdK+pp6T55W3{wDg8A9j!-?y@1CK5NJw7K520Gz5*bRb0(hX{(<+w!A2M3D6JxzX09rqUiBcTrgS)Oetxc=Soj<109TNHuMaP~wHW)$-p=(L^Av}eDP)h>@6aWAK2mtS)wnnq5o^LM&0003L0012T0 +03}la4%nWWo~3|axY_VY;SU5ZDB8WX>KzzE^v9xS8Z>jMiBn)U$IJbHCzeG%eScc;5bg>%4bK$r{r`x +Aq+#H#jLfv#PL=A@112aEH;p{PL+xxE6hCe%FOKSDH+oBmc=iTAb-%*6Oosa2akyaw&e2s;>sqs&Kb{+X?joU^xhl1WAJ0YAi#E*-vqLH<_4i>QGpjgEt@6f*1oKSiH;xj2 +NTLBI6vFznIr`dsCW1PH{jCY07B=3wRTy281NuY8iOsqkFB;kZ`ze^JTeZ5L(0$Eb~RiFtfhvM;8k`J9}b@SIHIRI2r9 +YDYFwON1N7kObUCvtLW1e2kM|Tw +9?tC;{H2Cnzdy7}uN=dc&`>p&hfRMN@ro?p(4oRq`NfxBG%H7{VI3jrPuoFSG0= +A_67qAqPt4mvF9}3tWdr^(2S94iNce3PES$t~{X22y*Z@`Da^lmb$Tq}lw<1>KtHVZ>w<20nrj<$f`Q +}#{}%B8BfiwR=1PX=>8r$N{!vEccF{gw4O~ +0GTe)#?Q`o4Mk7#$^6@Gp#vDNP4^JR>Pjt$T(u{`sA;4<8fd0*dOlx0ips)jUXR{Dy?NK&g%TPAH4r$ +sy@@+0FcY_$z?W9O*S-Q-SvKd(N>VDKIDN58u{bOR>@VcE8*)x4t4Pl|sc9Y63=eXrNr-}Kk>dTe43gwgz8FN#o7hnl(AREOKIOtv9ohQ;CJZJ;-2P +;P>=k_3A^UD=-O_$W>iwcFsR^VnBEnT(cuX8SwNL{h)M;cpC!$Dp^dHou%9JK^s;?%>-lif5wJC=#&0ostW-Bi{5KOC+a(|+}m3 +_3nm>#%MASp9y#OAm<(hLulw{Z5JVY=caBX+tKZEKq%9kzah74E|Jn5)*A4RUBS@yQ-EPLvsGd^|5Qg +j)XSWMj7xA6-d)bD|a13$Y1T-HXNDxPE-JU{{m1;0|XQR000O8@1eFvl(HuwD+K@mWEKDb9{>OVaA|N +aUv_0~WN&gWV{dG4a$#*@FL!BfbY*gFE^vA6S6h$TI23;8R~!jx2U;eAnQpgQiAoGZr_-In3K+HX6ot +e9Sf0bd3L-Up0hw1tay=hB0#$u(S__i +>OW2yh%ClAsnO2*KTLe=wX3U>;-S)#i+@z=L?Tri{ZTCYKkrTCEOhUWg$j-m(_rAW7g;O!^d4)}XU5D +CEuGYao7CcfI}};=c=RBi|1|$sHx%j0c0Ek}s6pf9MVM`lXV`gKN<8DaP-JqYBUSNuM0*~66uu2w>R&n6+7REoilw7Pi*$ +DM3rvFqx<2t+5ET}8bOM=@TE@GyFt89NkTE2gbX +2amComg-I6(NXobo2dUQW+dYc~SES{wtC9cT?aX%1iNyG8btaj|rDMP}$o|M8KJ(+T@CxtzFi9FI=QA +tHD7EWwdF&N@0BUTjf(sBhapz}JPDcN-MZNawyr)a0nCQY>nzX(ve%O<;qUVr-*UNtMUvfMH&jSRw`! +QOW$%~*hH79lgFg2vc{Oo=cZA;!8xN_JvD?m(qhsFBl9+TD_N?p>C`IF>`@vnAL^0K5Axz>p-h`!3yYjDofxJfI|y=+Nomggzzm*orFgJ5lJY;>Lm1%Nupq_qUXe29;x7MR<@1jo?X +Mc`v&82u3;wgJ76j9XpYCNYmGF*VStR=U~xF&B;5>_wY?$`Z={G<$Pnb+|&Idb0>PMs +$-vNGXeA@y0<31fsdy=d&O|QOnvQjPB&;+6VNw7MEuN9lhJziQfARFS8emGymYuo9iT7E}=y^EmtfPj +{#0z%u4LkZ_idhCa_o5jJju-gER}# +!l@~I5PeA#Zp!}Hg6*MdKTi$^Yii)1E9-bsDOC9l{U=CIUA!88?Jc<880# +h#>`Jv=_zt`L$Dd)OO=-RzjHvG6h1Q)`p0jgI%+Xo^+3SIF@ReCZC6#44*C>-v&b&5ba^;H|lE +v3SpSLIR_N9RBs8UX##XnfreebsIr6GOE}ge{*JKig-Xw*`oKjPY(y3Hy8rGaQhwNr{}^i46wnqm-{x +-p@dk)6*H8wMsFxtnlqlAao;dS$_9MFIc-9{>OVaA|NaUv_0~WN +&gWWNCABY-wUIUtei%X>?y-E^v8;QNd2bFbuutD=h7>7SU=<98jfQ7(+~|I+KtJeiJbvs)c=Y<85Aur6<*yd0A$4gIVT}q)->dWr*v6d|&+nP)h>@6aWAK2 +mtS)wnn^wcHl!Q003Q{0012T003}la4%nWWo~3|axY|Qb98KJVlQKFZE#_9E^vA6eOr6mII`e-eg%#^ +IiehyiJh6gct^dHcARPNq~n~}>Fzy_M@@^A%{E1f7X6YgLumFgoh5md#G) +=leUpgStNNzM#aS`0@1rsiFN!9QqdJA(;6qZ12*%6nGQDc*0=`|BNwP@t8eyF!iFkQ(bo}b{%D*tz%{=GY~evpUUTzR*T~smvxvMLtijUq@wyWUi3T@O??&+hN1$RW!S$4vH2 +xO`T?Ki>Az|lX|YckMUEJx1WD0(wsh2%Pg(sWBP0X%hD?aDuAzL0u)N_0K~6NQPYg4^a%ju>O+|wETj +4+j}{4&()XuY96<9iPQM00IxmW|8yM@jEQ@k12puHm=mEirlR1wYRHH);86+XCfSh%d&)~^eam#2z>; +^toVUpvcU`Xp_IMOX(VojOL$pH8VCUck$2QFa_G-ci-zcwH|H1}ee0Ab(0c_}CH-TC=z{@6<5IR8BcKvNjWk}a8uX7j4Sh}_lvAt&YU0r +qe&VPi(m0WOR?|HzkeyETefU}vBz0tAP8x_0%r3HDWiK>-pi&22I|i(HLoK6w7Km +(%BrO8Kwnt`rVSvtEQ@Ox{8f=BS`JAz@nLXNRJ9>%gTbJEHpG7~4wuNq`0_8<6u!a8m&1|R+xte?4Tf +VeG~0v#Oas2oimNDVF)|lGi)LC8p0@0_D%AYdoLiZMvtqFX?G+6F9)!E2zu-TA7|Ml!e~YM|-9S^_Eu +>#~{w6Z?^PyT&^ewzDi)I<@kHtY}%^|vDflwYiNPzH${!WW+G&g+hs%-et2j?7`oSgnxM$4rZk*>n_Y +3Pnd?$^MuCPGUK2OHF|78t2l*Q`+bGj(l8e_MLfMXO{@Wg^B3%Tn&9KHEZSK!9fn-n|0c6nHv#3s(w8{HfvaH1kHK(5#&@2Nf>NF32h_Z%18af +-*?}OIIn8ta9qfJ@C#W|}dMqm-WpWcIr%%U=`Ci}ML{~kMlZW7UK1_F$qz_)($;z)e4fAA+*nIMViPJ +a>pF?`ypRuqE6$B&6*VVczQuqdw|Bh4R|^BH#Ckv;dgr!k~4i5j)x#igl>^P(1UZd(JXcVDztj=PuCK +h8taAHgs*{G%+H*NXyGLYXY0l%jzN_W`$iEI;iZUbX-=k)WaK4o0TQ0rc+BvKVdCZ*2P7i0_D#ssi_7 +XaCEuzj|^gqPrrEfn#|JQxOFi<)plWm_}T!0L^(*A^jJHWA=6+)`@ZfR!5I3&=}0i=$fJ#A)bk<`xPM%vv>x=J!pK+BS)2m7E<@1a!lXOX +BG6WHa^?RSzH^K0IzPAV7DVRCUv+iSeLK|85G<16WCN?^-?tw2!A0L6l$>J)BV}O8D00{sFKHHN#bz! +|#59Zh`g@MbQmUEP){{Rqif%=aYQ$M-EoldG*v`hj;;*m-EDsky|ilTL&qF0Dwp;@16mP@a9ERyg#6! +-V{yPq;TcoWMkg7~-`zT3qx1LXmfD`vMz9bP9j=-Cnh1f!8=G?IN+4ZI5`2p81BSNmU +4B2BHXc5+RI(gFOK7a3~Qcnpp!ctNj`iLhWQ`54tS_#)sTF^=XSE!ABUgKLJ2PYh;K%%e1GfXd=Dhvf +{wDi8-mc;4i+)*YHxI4XKUp-Dg2cpwEFyFuozbpZ|GFHCDTcK9Z8uw1Ao2Nt}}-vDiNMSMV@_z +m-!5E7DN5J^f3eiM|V<2UEi)7R%Gr>~y9L_qYzo8$j@d-CS^`Jfd+=|(zUSp{lkLeoKE2!@~`e*vBOE +URBZV-V=T&=ttC+hjEscSsgoUeMhM?&sKo3=LR$$JEFMjz>$tyn=4=gSgpwq-LcSGXWd9>{YE?MTcr% +&KRYv$g>sb>I8TaqZ%j63UZsG5Q+HJ8PY_61}aw$AS8uFIqNyn4IV2u$f7ipxI1SLt(z-9X?DaP)KP)%ktT +2EOYpws#hYc(tU{6_qAB#aiD>taMJm}dA3WD<_1HF2mkezArc!0Lk4%MxlkTVK^uy3^lX9KMvrbECTN +HzxQs$EbJ4z}^tpPz|qOw7QVnyC)7Zb@}4nygL%0balrnFSenDWmKKN-_TwJf3C?FqmDiz?BGvE?8p%0hTKyb@gtrDCYUY2;4i@Om=sm`VtV>F@qYw +-`UyUbDGfKltg21JzovIUqllycoC@wgCjTN5ub-WNr#(#RI-wpzSWdu%iBNEMDz$5PO>hwyIt#Rq2*A +cDVu%E)0#m1h2hqa9?5p92{ESe3#(74-N*bXvzfk;)NZGB}Ypvj`h6OsI!2O=Pv@CMc{{zHpFe1!mV1 +z*|3JCJc6hecXJpiB%C}QMY5|sv?IHG~4DLgyk2+bEehLNNO&P$CEk;f#155g3z2Bsv5W@cpjERIu-G +?YQuCRF?g{&sO+8K6`XOy6O4i^c_dFft50v=;zBn$n|Sp0j+6yrF#nkccG7 +`?RVnXgwl1(gU>py#@r^;#3rvv;uq)iWQEWfV3yWQb|}Og^~HBX+Wu`vB-+z7K7$yDIWm|%LoO}iu5C +lPv*#Uw%R232C+hLP*TjE%(5m+f5sy +0FoXrWn)IIiEvICmW%jQ3Y7qXH7{-=xzIXZKQ-% +e6K04DMI{%3lrg8PV20|)5jhG-ZOLu;=!*ic#Hwh3Wau +g~Eijy}M3&wrTGEg{2`~tncG6){%@R;G^LhGS<^q5@vj%h7K<=s#zhKBgwxJ*u0=8r?bx3OyqYYt`1Y +_6=1l0~zd)HD9v%-fHtpf2EOfd(vnjC)O>Qr4Y4ukQ!l*eDgD2@Z!vTJJ)B_J%3BIQL<`J*24*<0i&P +5_W&)!lE$I?7sZ5&5;X`jZ+mH={vIWk1*v|Cugd5Z09}xl2<{PSOA=z`tGR5?`vmZ`O5>t>u-Mz>_!IpJl;9 +hYHj10V>|t$p|TmIoF~Eb`#Jce)9bw%CV)RrwP!wTW?2E^?W$_4>H(G^X)nQX0XqK0j0{^$TL7eiF@T +G%VLlG!OtN`t_Afd?g$nM$D>N{|>W#{f&9-=kYx?@=V8|iKmK(}xmqf}po4cvK-{%YNaF-Bs=+PnNFf +rcHp_~^;Uv4i}0{|8 +e>@-NGIUqFxu`mk^*M5a24e6NIhsd)Ru*Ejn1d=p|7k`!)k|_fhR;;wG;hOjf5EwIgVI6(yYib-XGIB +lOqL7%Y}lDnGl0Qk^)ApBRn7L{&xPM;zCC@Y3iGN#9J2X5r0!Nc~*0IubxiNY^D+>%Hf1q4PGnR*Hu- +cB=R$<9MDdh9YB^ASF_5HC47t{qO&nXS)bL+d)r^Kn}HfBP;KyD(y*nVns9&^Ik`@|TvRmxo3a9r)Gv +^#k)0y+LeV8?>mjK+RD&wxc5<6jeOPX+_DIO1XY?_%fz@#26+Em4;^Ep9FXGvf2n;19i>D)#kSrdbLd +Y#iumv%#q!Cs|tDCVBb~?Iy)Z4MR>9=AW#%aOyLyNxnV(e){(O#aEmRX_lsPES2*BPts&sC +iX7tfDyPjoLs)Ec7uz(clY7tqtU<+g()oXDSFybM$-$5GQCFBZG&~PNWlmJ1)b(-ebn^Ja2DDrv{Tv! +!XPEODw>*i7t;~~l>LKtE8hrCU|dvS5`~My{ew##{Hd+(!4#wCy@8dqppFwUpaSp#@)>?H?GrzNUS7G +A{alDJxnO_^qI_>32TiMD@2ju=^mY49J*2{lcP40Od<|#M2DIlu0t|alGzNE#hayO$T(h`?v4$Vp`O~ +7PZ!OCQYiQ7Oy`%z6QQc_8Qtp5aNIT({To +SQFsLa+?whY#?+`mU~YQzIciRpF@92wjvmwfa+DM@#>c97>>qiMaP1GM&fJ*{^)xyC?LY(J`7bAFmP) +c5-`TQxxvS~C`-ARr%I63q_i#20P7VVMIqTr?WqGa+P7+PEm~=D>hp=mK%9Z797iS|2bg0Sm;K5+&fl3tfdvKwB@)>Y*k$QS-AxGs +JXSl+&s%mVu*&Iy1ySxmwf=ouE<9>QlsD8l-eeH@EuW6!>3c*7{}vTO9H`|7NH5Zgs%d@X=x!vZ^Hvh&u2px>!5(b*;UlH%KKxtxaTsz +nRRE918d5g}$J)Tq1=zvK%&Q#uq;-8l6d2I)fk8lT22%Fzl|*a75Q*Ex)Nz+2Fx<-DES}`pAydhb3lv +;0Ltj#x9!|3$;O-!^iT&RZqwEwLh&ajxXww9@RW9{Np8kpphWn3kABO~hqcTxH2Zo*Eu{`}MPC4 +Mc-I4BF+8KaJi){|-uOv_~*BnQ))`tA$NJcAGYkptwN~FUNHR1K8Bl+UJ=SG}(UAA==z*1Kuv|9^@I;=VL#X*cc=EQ860 +sh!@^YRA9}yr{20A4%4qwr@8O+`r!c{Uk{#+#UG{EH90 +p261B&)Ai!0>yPGg3Ub>BgyDtNI6Q%k0(eg9W4;@(F^9Cb8Tk17vSvcy5)py3p@-mqXr6jJFTcxj8D1xwtv(gRg{V}<~CzW+Rzq5(7WM@U8u^xMPuVur>2=- +{TrZYKNp7Z5AXGrS}+wWSc`%@GjAtQJ6LJ84x)h=M7DV5p&vON;!qiy#}hk>a6ccgW0|7Ee#oOL7zrw +nyGmveJ}%JLC~ELbqa|4Ps!6I2ILTZH6&FR^WO$Xv1ldPBx)ud!PggY>c5!bZ#l>s`7;3Q=24_Ck0^u +fWp+q^@6+T3_0hrZtI0m=SZ5`*fEk_eQz`6LNGpOGbNw3NB@6z*?7_)#1!jh|Qy#vrynQE +}N??ol$0IW@KG-!6IPG1IL2TQqn0E7^2$6gIb)0AfRn|Cr_`!9I$~U$0(I7t0Xu+q~+-nP^Q@m8esKo +#0p0ya@rvHBwL(2ju7xC@T{|o1Z-@Ath_V<8ZuT9h=Xk6|L&#%+DTyrBoXHey_@HBc%^r%ud +UGcQV^627~|4s7KB$D=C@{sR&t{|L6S5@ +_N^w+%PC&8RoC9h(}%utJ1GXNlqcNIg$Pd11`F!7i_on*hA-LNZ`U02K7>!4)1rJ?YIt4BnjYH8eni! +w5HJL1<6VVsl0|Wsm|L+CsrdznL0THTf`udASjeG|q!uRK4gfBc!_IY^Sk{_UD0)-#+f(aRfvl?5P%9 +jEiDQb5SCL90?Lv!PizFu9Qix1Qn7VYD%dWD@SWWu#X%!f_{=b*68Mw6G{K)VKpQ!nc(e=HPkqWJ3%+ +E()OM0AYQq}~!Qv#GOmik7qXm*oK@z*I=I(%vYX$Jsajc|j`-Boivm1o-$*T+MrvE-9G?Kz2IxLnzH^ +4LK9n+#5y2`M1_Y1$9TQEYTT0kh(>mX_VUhqhVKDG8;MERST9Ez+H*B?O*H{2aaaEeXD}BR+iipss1c +ot_Z5555@3xwB&N7~HdTnN*Me^yL>{eEsyX2+FTV4|c@2s<0G%0b}4`BohndyO#|GscP@%ApGMP{`nL +B^9BC%C9T%wYPrIjR$sH%&yC?B7%)0ZQ#EPL`Y_FBMY+U$2A=!?%S(IO5w(&ba@doZt#7#Ugh{2-fs~ +Wg-!`UW2~^xH7OUxY0DG{RMpwu{)f<+4^+TH6kNJ`a`S}FYFMZsImT}D&Q{UtWx-4cs=Xo1aGn0}9UL +#ZD;XqtKRLYM1TY=mW&v57NCc$(>%uW!+*reLQ^W#9qz0AnzA%pzNjEBc6wi;XE2`4(Bl?$@H!G&FMP +9G4udlBC4Yj*fHz1}+&Dy3Yfcw+_Swt@0ycU@8y@$)jdZnCIslMi@)@o~VvPV@02U>)Anh{bpfT@<8modJbdEa0cuxi(EDxnVpy+- +0pLD!M7J(z-+p*Qc=LEe+&Kbg!2nw4D;)p+5Z>)qF$8ev9~6Tw|?oJQNRGxLcHJNVzVH!cGQlQLW{4$ +9-1*@8Z&JMt?i4gyyQ8-FX{<*2bb4$Dfzfs4zNHEZ3 +`&PI||X2$iYejE`d|Cl!iF$n1#Q@xcwtIQF3B$oN#CsX*BMU|2ia5KG+FZM6n7A-hnwTc}tGRm8?d~{ ++xlWpC|bc>Kva$Y`BoYxJ#oNvJ>wqsBVtY2NajDJpNOsl!&X!Kh$yf#$W8hSa@4kL +o&03YI8cLCjS<9@;F)D%+UOcT-tythOxZj;c6uQurnnjDXx~gV3j#8X5D)JbBMNu^6Xfr=GsdaoxY$2 +!CZ^(0#Vgp)!NybIBY^s21_a$%3qxUp)AyBy-=EIbcl2XZlseAhznRkQLrZL+vgOy3#KPpvU`{?hH#b +=T#D~o2Ai4&Q$&Kn`Zmu_nz&O%WXqjn5K+P#ojk$9Pqk1nN2}w8~thazoF?Cq5fP7zfOI##G-_-!|PT +Ew|KH4yEyF5Z3|8KndVMM=H}xqt#xPPhE$tD>;C-Jm{juw%f`CS8W371l8`IGEoj@(xXo7xu#RMTEeYmnSbym5ViJ8-hL`AcGm~7uHj{rg^jT#g$)PE9RtXY{N*?Mx=4U7X>Cua>#P&ZK-e(WOGKb$=;s5sA%t|N3qc}T0tttqSz7^KoNWM^|bfx +S-Dbi^$erbnmLf#r0gB)qTNxIHw`L<>8Nf}z*z3ZMm*i +X0=YHYVS!;k){HI5-ZyqXS7_S(o;X`xCXO^1Nq@Xcp>WW!@@^uqKC-qH +iWOJ?*y4?I@8rs9~)(hJ8>oXp_?-C9D)EOn}POcwx|dvbbm$A{?U-=gk1Mp}2E-B8j*t!-8xF1!|+Y_ +|sJDOtH=dB8`{r;sbJ1x-MKO%9f}?mx-ZEtGij2aky1{b7~4`+3-+D51Sj>)3?)DcO#LEwUYwts{9am +dbe?U=@YDXHNKw|1Ct?)K2g)=8B~eCP@N~&)CV6(1~ukst%rh7NT5g)MjTy@I;Ml4@DIz6B@`h?mOap +EaSyD)s(uZ>^_0tu*A4(7E9h1;1kCKDqORVGI1^2LBPr}Qw>-K4PYRU0(|CO|)9I&C +^k8TaigqwM`Z!_bvp%CVz-jG3kr3eUSr;1pl2IhWxcSDm_J}fD6t +Bz^oEygfhi!Ap{o+43tb$QsWrhaqVkqxg6}sC*6-%3`YhG2FJuUAFUIjD>Fm3)iV@lay~su9urggfSu +Km44qx!Tud8!q$)(<21$@lYvM9o|8qI6l%*}Oq%6FqiGu#f}4zjH0*4*keQ4XyCsa=rm46V-Nq(;673 +B56z>GOWQ6>(Kk%ip&wzC*Seom%d~?^wcjJB}eNgaEBT*lau|#E@H+S#-UK&2+Zw{W|(ptrRuGZ6|LP +rH#eZET`|AyY8ctFH29FNtzc6;-USuo7Bc58B_Pb!?f?jLppCe0O_Xd&pW6ZJ3MG&J+%5=D2PbS{mqG +$wL!Ky>_gCUWRmUjBVFY;?yZT(t`E!goq2&sWokp}JwkyivuEyIA&Hw=(vy>u_g~RIyGU~`<)HhKLDM +YL*=>epxi;s>ot}t`i`Fx~w0&vEAcHNYJL1S1l+vx2)pmY|oSIqt`5r5y;j*IU%v49pbgN#eau_of0s +E;SzPhtlCH3{&vd$3`g+v1iV?=esSAnY1#-4D_Q^5FJ>O=Vimrq*^ho{fmV$QP*Xv?Y+YxcVPoxD-QM +OO4~SPL2&Nf|39zc%0)<8HkOc)P&7X__$EVA=4*B$k_cgom|>nx1Ff^gB69)pqXd`&Fx0vc_IlK{ji5 +)Fu<$0X`}g%cx8%%)S&r1om4`pVO-us9K=H3u0^cc$>^$+r9NRu`bY8Kya5=g4yg8be&^kq4i&aoXHF +SMw1DCWK!@JjiJ8KUuU0I{@^7s?^ksQ>ry^X)>2;G^C?xh9(t?n7}aawxfQw`CpC(LzU*Yg@JLW!j%I +-AD)n5gvHv`|~ymA2Wr9^$8m=;pSdk+FGDKYuap&TpM4-qCzuVHu9Vwexce>R3FgkG-F +8h5~?y$qicZ1dqA=k2Yfs75!ES4qN!_Z=+@~-zVw#mu|4u9Zi*~cyW`QU27B2~zikgwqru2ZZ$8TN<=f +%B$5B}%tKQBvw`~Dk@IWHfL4j(_pANj1-H{tH+59X=HA5Y&r?*)eUQop-@G=l$)J>ci3{lmWt{e4beJ +wN`bzt@G)>)oX@+{s^0)(jXwvgSiVI#s5GF0KDyXTQLF488ec9*OQw>y+vq%jOvuoU$13Kvv81aC!?nZ7Yj`X9?yh0zR4!0nZ^G +{pN7MFXi?b%`?m^CIN`~R3NO54&ql*gazKG7~)H|vAwt1+KaaoR_c-_xn)eR_V#w#ve;JrZ8 +O`?!bROqhHb2e>kbj>He*p=34Zs5dPz<&!o$IxrdWPzrofKq(kdms;vuHJD&B&FYp^EVWYTsFSz20)gd%l&b!z0}LJ5Co`kOpDgVtjI!F@XdW7wL*O-M+}Ab +xu^h$4X9MLcQ0k37LjRkWKI)1b^MJ*|1GQC*OtG{DP3r!5g(QVV6VrO@t4L(yz#$_1s>84Mjo+>ZNCX +x@~vYag-|qfZin**O08$`cI%9gTTAKgE=N}dY_7D_f5V5EY?oUh>b318$WF3?@NX}gr;`;vT^zeR{ +#$5W>$~*a)D8&k64veiX~H0UHBAP>y3ZQtUft{hXz}MBv|QAbhp(ege$sE0lmzIe0gvY`0r6a}rGx=ULGOrP7x +#h=QMsAKC~uJWP~a`Ldw7v!hBdnLh~8e^ab9PPD@MW?9}WYz_FXO@{kp)JN7iPFiOLh7*)ULpSI$7;( +8pHwo_qAYdH25Ewztnj@_RPrPD^lsm2c8Ry;aAJFep{k4|d7H?dY;6MK}xmukgfcA#oNx2UF=ya=I>@ +TJ{%)<6k8Oiw7Q?5WJ$|%WFr~loZi=6Z^JKv$S5dSB%Ry$f&{rwxd`fKxVWfAztOPL5J6UTF(;v{|it +{0|XQR000O8@1eFvu6!NAWG(;zFTel*9{>OVaA|NaUv_0~WN&gWWNCABY-wUIWMOn+VqtS-E^vA6eQR +^$$dTZ8{R+4h9ROvDJ@0jBPrjAAHQtV$eq5`^o(oL}1(HPxBM{&Kpd{M2|NZh&?<#;)caP5-w+MS$1g +f&Cva+%=vof;|ljEb~WL__d>iQ(vbj#yE;G2WPgTv%`z1}v(^-Y&#&qv8uUwrx1G5qJ7S_WtFN8>bc=`PN^~L$5d+3t9S|rckyng@g<)40h|K{BVzJziIPo6w^d;T{0 +`d_|Fiq*OlD^Ya}1il;`ESq|jOsC6Dw`s(5ie>7iOEy&j9TwBF=tPs3?ZJWkFw0x<-8bqNmYKKaSJjD +!t}JHi%}w6kSU=19`Wld+e%89?x^9byb>7{m7wuMm`&+T*zhq}8s*f*<7TY?1n2R+IXq+^ntvAhFw6f +&9UI9>5{-SH3@t1Gp$2-xqP)mKi7TvU+-vEBb$&XdLS>s!=_zRahZ<@N16<4CmVIFc-^OgKPPF|hAKY +MZZ{%rdF%OB2PpS?PlH8x#Qs?ymyZ(1>J#IKv8q1hNG^BfvpOxI1l7EQMuCtRk=S7HkDI+a}=A0*+^h +4+y&*C-)6ZnECnq;xF&uyJ+aozv9PcbZ~Gmo#tf;vwfOerijL-m~9Y+={QOM1T*}yYC9+)7Vby8 +{j{e{lAd2*zpR$^KvnzGTbT9q1M~@rLp0DONhK4Qkss(?Hf2;yq3h>Ay?yiU{e{Lbluy^&1pqvjqn`Z +ILW2j--@JNt_WDJ%B+$hQ@T!U)ym)!>p2}T7p)7s*`r`fB4?mp0OCwVX1AKS>{LQ-;DgE`oemuW;fBq +u%=LSAqy!r9n^YaTR=XV-vUi|ynJE%6|#$Uev{>}9Kr}x;$33agm3_{Ni=4IZt$@Do=NLJ5&5%X?zLT +%yl#edI|mKHWsQL@U{YrtND7;A|u7=Q^bu{P=IWMR!f>wsH`CGdlyD!S=3Yel(~&Dmw}c?l(oyewJ)j +U)vULp2u@dpNVZY;F2D+Xv7S!=E%~((O&lZa$ccv7 +3t%qZJdjfnVUs1^u+G6}V&|G|M#gfW0@~awnYGp=s;?TZ+eW`1FfPvwUupFTaunl9)H)WSmm0JNU@bb +fG0;DXe1-%^Uwct}wd{w*?YuF8dyTTg4=}hXSOY}^#$iIL$dA+PE-p!5cPdD8D1V^s(JbvsC +*1C=j8^rO>upFN;BC(NHydcTyD3_O +j{Bl4VJE0>iFF_wYha8`C9x21Sw8MO!+7om0E2%)o&t7-A`DHsl#6;PUJU~0)}?XDgVac)3@ZFERRhN +kLJ1sqPYFN`6tI3BcmT^LSxKBH(i@hC;F}SSvQ#cr+`0(axFGPm1JCESa`GZATTt +34lyP#Gmm7N}#rsdC7@Ge{307Iy(Q%~Nk+*g5*PR+{}Vr(me@9l^|>{%+xETZnQob* +Ox(bN?HQ+fo3mrf0CICICL8H@%#~26LGFRV0-FgaW64-py}ujogd$PC%yxOl}RdqDAl|FHtlFPCgU!9 +QXjNI13gP{-LNg54egtv1*e{Os*&V;f0tLdG+ka*{13?FtZK(>e>+^7=#N@hHOaNRasQGu*z==5HLU_ +ft6lk$z)lS0(lBejHvF4rmj%po>S9K3ldiKcqja73YDi=KBLXUsRZbf^`cC +LC>K;HK#FiaU^`rq8p+Z$fQx*&Nub~K$E0Yd2q`Z>u-LZ|+#~@Lr1fOYL=Vhuiv+o6tjEXObot76@u*TwFDGluefDU%M%bG+WP`##Fn&2@kW$xH&skrDW;QO>Z0PIM3jPXboj8g;bFsRAz +n{nhO5W>=^$iqB+$H4P%~T)AT6CTvEHYm~F1JlnfWi(-t%#p +6GZbocak0yhDYE_W>Kar&*qoNGL0e^_Wl9ANvmr*~2L@(V&Vb0}8{9H9}xniaeEdw?{M`JOm~k_0Z^V +joeypE*^3jIrg5_?wWzK?o;03BJr}K?$%I>qr2IYWy2fEiizadZCFGdxfhKy4Rq}na#^~OePYLF4?%&L%XOR9b +v&EqK6|{`Y0h)Mu4o>5JVz+^j@X%x&}#CZIupR)!LRek5W +o4HOi7A^YEwJvcT#iG#r*Dm*ciNpi8y(eT{c6?i}pM&Wi*qiGf=29~g#MjUL%Ug|9u)7KANf-70|fRXuyfNwXhWhU5y!U>3&-ki +FqsQlW$oESX(8i}}MS`F&!GduHE44RCMO>1|Wr6$`SXCUg=41K~{wO%rX;UM9zG#!4*d;dmm +B=eI=VORV9{uKxkVeOtqX;<6PaIEndSxeIiu8JPo{y|f4PQ^T~T^o_jBCYpmq+4#Pxhzv|6}408WzoQ +>Ky?IW!!jD#6RSE|)s5iI%HD}+oXBOx!y34RSSTao4O!n?1>@=p)n(Yu;1#!rX2pQuhlzYVNYMeN0Wq +rCDE{OqPf3%Ha<8(!7q)5VH(wRXN`EW1$tiatPC>fwfmL2TGtdifKXGm0co7}m(u#LWcgZhGoc+V)7a +yD|14>z>Oh{$4|25)RzG1vXiM@l;kvy}9K7fFPB0NdZeA0$L2`KdI?fKi|ufO>g_{Lsx=b#{E(+4y#zagu +m!*V2B(f$lE+hW&jL((_!Y;*razRuF8ZIV50M``jj$y{B@)gPq{`WKu`a+HXyvK$YJeUFVSEh->^Lay +1`nzpCS82%4U?`cK}I_Ow)9c~&*fF3JVD@5|giCWyDR?$jK^e9k`41Q(k*UI{3CZPv6{vb3s0g?Rzg&m0ezp9^2^K}4I_71eu2h>HXlZR{c=7E?4_ +7NV8dLpFF_qh%W#8rq^H_DFGMHmyJ=5+tq&JjQOiV!kQ!MgtG{wEn_}(CQb?NGtMYexnZ?@buZQ%)Au +#3UeIITaxMrX}`qjnKH?sqD05o*dEU)8pR=`>ya=0=po@*Nw@@%!8Dhu(1#ckU|ELuzd=<&n +D3%q7MY%ClN*35)sQk@mN#Z*{}z&y+ao^bN01Vouxl!n*t>9t^gLk5a^vEs`*y??bzeG5ac|BmPxYVV +mr50eNT=yGr`1~Gr(g6m{#f3+w +3^Mj@)Uz?~o=KiH;dYs)A_^_9$MwdV`MRIaS&WJvNPPx`hfu0ED#Ih$cC?xdMSRc#mdkc7XVgNs(@n@>DPo!4YGwyY1$(DM;wbr2t7QKV_!i}ndCKBbXNsV}VPDx$>>}1&n@+E!toV+ZzbtOE)t7+ +bKjpOb0E3GN0fnPFbU{;Ng;ybtOBxsXBj}zuBrxus_nDcgZ=C2sdsF$poO{Mw~ke1`y7IZkZtERmT;D +|rA1*dL*6D+!XWE*bf{zgEi=sva$r*3}}3vu_cE!b6U2S!#|Tf4NO?mn-Ee2WXrbz7Byl5DvtL2fGB5 +owniY9M;RH=!UV{&;V$852{{*>%~QMb11 +9ZBK$EJCkAPGTEkccbuN`f02mHi{9shP_3cO}#CUUYZ(#QOh!Dxuz_1XVc9Z0Mc;P6Yk@}K1_c4=_k3 +J9H~~FziI+U=JTDI>P%2Y{dl#JHF +Mt7eQ=bIPf4TOAbn$hyh=)Jh0ZCw4xiW10QW8V>e2FIZUhOel@VAK$*dml4h1*JnP*< +Y(l{R$RZTM}AP1|%o}uco*0z!}!C +*k^5$ye9=8I1Wq+e6;l<_fai*hdIW0p}U3bUz$04U@1m|60Dh;h?Ht=71qFaZx@I<=tagTR#qu`<Ko*-$P#i29M(=Z_FDX%hjHp +N|s8gW`G^iXQB!eh)b1`p}{O`Q9N2H8$y&;}i#Gg=gf=>S=!FU!sW4v+cI8#<36@e^WUD$WnH(p_%&F +R)Ii_chwN}&utbf)@P3(#4$!vG|;T{Z*p{PpkBj>5<&q$5`y97(HuhEWKG?r9&@!Xu-^Jlk9)&3A|q$ +J@;g^x`>`rykOH4~4b2Ai5Ny%Y$}dz6yOJtZ}KsS+;A4KGm3e0F%TW&{U)mfOQp;{m{OF4wyhO3JD2$ +IvN!Ryo6z=2C=7iAxL-Ui6%a6XmssIy|G^8KrO$*=-p!&y*kGUlQNV35FP&+t;si%lhjMLYI9{48l5v +2DwUVlbp!hmdYUdx@6>TgcphU+phR12rlzhfe7`>~I@@-ZeL_Ovu`nE#WYGnIIiQn(0Jm}}E}?-%<_h +Q)c`bjONpk*>BP{Z4f37Zt#qXw2KVikU! +k)pyD%ws26SniQ1PPUPyOo)jUyDosn+QZ?>)5``rxTROyyc(y0$=PiB(at<~9==#pC4Fi*I+p~log}ddyQj$R;EELwpt#J74g+w9!c5sgg-`Pstny?50T{$Xcq`BUgaITQihx_zC0fym +4%5@r*SlSv+mne5GQ$Hpy`>RP@S5MZu3Q)sAVXJiqLI3ybtqnGFv=LG)|vb=>Vf&RJ=K!F*Kuv}=l2= +$MQKX64D7lX=M0&k6+T~z>Fm32M1`3{GA=QiG)TVc{?wPh{x~K_GwER0{3+++cDBjT(a +q9^`4l+q1hJs93dA!>e(^PKB#TQYylxy`W&$a5&tDC{JdoJ2Cl;N7VJ7CBeO6s#TAMgC>M0<@Qs%_2n +pyWHAaRAtFR@`Pqr6;@Ji<nzVJcS%_fCcz0Gc`cg! +F;V{zFJ5p*tl?quUf_^(Ai-mrWSJ&F?ybJjWWb*&2s2ephvB9}P{_Z<_=1sp%TpnYG!-oYPiK5~svy|yGJ!#n0AfZN-FC(z8(_Q~#}N$ +bdLjxG{IW&$PLtE?MFpXLbmn2r_NbItbH$ +}P*Nl;p*q&p~txq0u_48{VVXR~Yoxj8*A^a�rAIGTA07CxAn6t`q$M#+FD9TUmC7DXqWa#kI7z5ST +NwqRABG~~|;>n&i^gU!Mhh%z5$eltO9{E%p1qqxlD@((o2qo1+6s4xR`e{;g0+NY}YqSV@@4ES{rG3` +<9@fXHZ|ZyUWg8wPKC7Z7wG?LSwMqb0P~E(`7Fj8(41kTs$=9RM7Y!e#T*@=iZjjd^L7q|%ey^ZMD;` +RJXf?c|g#l)sN2og~iO%RkHFVV3vviDLS`qQk^=qo;C>qT{CG+(-1m$Ee58<=es7F1f$W{fsy4mA2_m +NJCdmJEe-V%0UN7~RnoqPK|EDCa#Ln)-zEsu3FvRuJ*ygYNN7UIP+yPZ?5a}2Y$1K=DdEJ5yUAbfA~G +6W{umHdk1E^oz_2S@%>1Kh^VGq!`-_*vc@d9&#;ddq#$|4*jy(?v|(L3c)ZH`zr6PNqkxg2`V!^g!t!<)RB_m1izW8JaMpEte~NEPeD!`6lV +uqsXKeo*|$8sAU-?4aCR*Sr8Eb--X=_@SonNG~r8+Qk<#MXj*#C`K}wkazEJ}(eV1s`|}evte?Go$$l +I+xXWr`i;}xqOWb1nus7BvS{i$TA&ed58oE*G4ry3kfT(tBvHES2%$WgUQ%2YsEAxtKdxtJaGIA#x=d +{cma0cU2hXkepI>{o7=fEMsZs}6x`1}V7n9@wrD}9liCb2xm#R9#S(q^?sb$pQ7sd+j*^(M1-YE)Q?Y +0)5(i~|25w#Fn7p)%bj%^9e4XMAojmz3Y6-b4}mWl@Q6vu)jA{SZX7vpmzZhZL^Q8*7}Nyvv~(@qHwQB9>c$QE5YKvz<1ZYA~}UZ8EK +oIRvT>s?1Skivis@>{%&{4Rey5RYrvr547yAeQ0#9f@xLor~oGm$I*$(!mYGrtHTP+daF)5*s=<5?s- +qNnMI$IuCk0fg1$nHosx|X$M;grNKM#~wNrz~cN3Tl*di#W6o2T2uGI~<4^l%@c`D=ETBsdMUo|X}rE +|1|BkDQ1l!53*x-n7s;w`ZPCn7+xHqJtw+3+YwC%p~>;guzprY0KlZWKL0H7k0FtmvfXT5so=MFjq>d +vj|YCX1SruWdS3IdQS`LexfzLnbzmYf095N=!`+3}y~LL^29GxFs=!IY-*e +q$INL=htp;6^YQ<^m0u)Nj3_blX+2X5=HVOlxHD94;-4tA0N1+|DO5slyBGu^pU}smP$APCbS9vQ{QJ +6vt?{(t=p+efh)wkc-2TQ)FI+rbLi4uD*>KjYJj~~{h?T2Vv*@(;N%D-Hfb|LW|-pmQY85l2c0JQ91$w>0iZ`T=thewmCo22Tt*N?#quX1o +Q%8;CUxs@PeQ=*PlP-gs~}rSj-UbYvQ^2w@;P~b(#!bnWzgc~?M=}YW&im9WoR~BKq#y&$;oClkwD=))B>Fjfa>z;O)7N&A10nH(cZX;2~t~Wdz$nSV +7>oxQCjEYvsSkkivFVZrN&X7m1PLiIcNHn`j;^R0^aAD~a4?xDrmw{)z=}X_3RcOYcWGEz6PaH{)r}~HS_ix(v0a(w3?>0B2o$u#2kN?cMzp5s2fnJ)^$bPUnjH*Z +7Z~usu0XdFx&h@F +)ltCN^@akZMw8@a<-o#-548zeC`jmv2I}-Zg|pBus_b{JI^}EyWP+*djx#(ecq(FC=IRa(92|smnjsn +w71d#=c#b%q3sfV=($-UoyS(b0vyH-zyvP?O@g?8L;&{}$r*Z7)v%jrbl6Y)8()+7@6O6TvJyvf)8b$ +0yd<)Zrn2uExc~6S&1bp?>X-Zd5^)e$Q1(XgH!(o0&Z!?$ake5lp`9|q`2#n}M=@w-3aJX-5^N~r*EG +iqyU1nbz;@=m-_XRvc?P8FZ0Oy0gNWgp>FuzB+n6{hjZ7=aTnnSQMqRt~vLz+={Z{IwhYqPmIgJ0D1j +dsR$xX}rw&po;FM;CgQE9Kw5#e>9AdALpX1mF&!OjotG+wcw&^AnJdw&m#NY}2moz|O`)E)JOL@%8@5 +g*adhu~+0rSwqxnvt)5xR=5aYdNRFlC8^w?tX;|4t7wDr(^r|J?3QTS7g|Gu373mVlhjSMuFxk`dT-H +^^Bu2n0CcgAw4;FxlUd7ooMgTl?}FDwWh+%{>EJs!-Tj`NZpo^0mi}DH%(2vmP?E90hgmk=a{#mGt>G +!nLWbX)E5>5!p!yS|5e!b!X*MII`jdX^xc#J08+MCgm)Trpa-aBfx7!ahq7?3M#_Sv1kL10EoDC34$B +qO8hsiS^)jw%kY=b8`L9tbWw{Itr}$1>IbCH4Ew#Mkr4X<#QyO!Z^ +OGl_*L*~I1XS0@2)_v@4Tu2z#@|H}`1XKIYjRqC=NJhDRyA)YrAWo^=9vVUfrW2LsR@3X0hf2Fl497> +G<+NPM)HY%k#-n +rOrX7>GayG~7AZPOn0{#H(7uJk+)_c>r?W`X=cGV;2SK^mxPmWqW?oYX(kx@n(5m@$W-`GDA!cm{*(C +8=iC{UlVR?}C!(X^<61siLqg8t03SZ@O-M^6VLCEHG@k7I{)P*Uvyk77bd{pP?L#!7Sw==NO!*=xhR_ +ejwhw&njprk`jEMkfGhtLMEEl-Ir;7sGuPNr|#^0WYCaSgZM0Jtb(kIrRBCm_`M-PTlu}@raxmBJSAD +TOd|x2nz*`p`yYQk#!D4oI7&*Q!ww}EMN<({#sQj4x{Q&7oH%G3h%7_6 +TLtW&6UJxQ8*cI-&Y<6ZcaLT0tg(Wyb1{VY}+3E%>YFFnKL>5Gz`KXJUyd$8jLOr}(FI+2^nO#^%s4U +Cf#o9o;dC8j7%@N5l;2xD$=7s1~HMU*AI<;l3u9H{P81}hzp(;D_tbNSWe3g? +!ah1t+^?fsdnsz%+-rLbta7oLi$x5Y*D25V@~dZO!AF^2IIq+v7&_^*GI3HAYt*c>hQ{t}Rr1V+!7Q`;HC+Idb%)Aze}4gtl_k>VM^K>hPKWat!}grFOmcf7Nl`~n&w +1aXG1|T83sd>kwgQ?Il#OJR2*Eqq)rRw5+d=Lkyq9u3GGuSuc-_?H6jjq@%Y-PNnT>({Ld_CB2tvl8CglOFkOUj +s^Le%bR!tuw<|Vn#389|b&$;6>4~o2!{qyyKfO8!VYynA>R!xNCA|4tu~x?^$Vu|MyeLuZ2*6-L=nee +Cak>-zmuPxC3T2ox)Vd&(=F2y6^ACb%Cm_VSM$Ua*m0tJHFxZBNyKeg8wau9G`(EdzN_b^4_tsBWdP(?0eKFG9HRb>hT)AiM +%C!yyv!mT`L2hr=gHfDB~!u=b$nWBs!+@p^J^u!YnO#N6dUgqxdI{nE!7d)c^l{P~-m3!STE%ies7_k +2hJIPx@in0S57~f^jm1|2@hNRW_x}m4iN`_zdYM`}>Z1MD;lT(H_sd&lMdNnU>!=RLbZAI|8K~wPU(k +d>cbBN=LrG=59e=+9@o5DHmu_p@&N(I*$SZMHbbStV~~-Y+y9G5f3`GmOCKh%^USM!DGHI@3;i~N#ze +d@3PZ=Z`OK#%ua=+;0X(#zV^(4fQjjkUZccq?QeyI^bCq(xs%Psi=r> +5Rqvv@>aRJ!p#rUR#K03YDn4L0h;TYylT!dMB-e|fT +bj1NZ<6cTeWSi>35%rZSP>&kFc$i=kVlNkIS$ef}4r +les+mz2%skb@iT1|#5MOkr?={8S{dZ3@?gKW%y7_)fq?!0WY>U*GWt*H7*L6OV#HH+5IBwdG#u3OVs2 +e5GCp$~qQ2Jd&rQC*iC>8LPB{>|7vUw>SVc<>PNsFqFDZ4islcvK@cE`#b7YK3!j_{ZoG*UK=U8-#+Y +WFgQlnS-n%PNk`?L|fL3WqZS>`iQqTDW%&artC3eb0%WY2>P`U>(x +LQTu^ +Q2O#)wC5Gvo2#n^L14x&D1G_x0dqi~RXjA>1U%R|Vyg~N3}0q+?_yp_g9aDn8HFufmf)<()z-;^=A4S +)RLk440d-q%>aVV3MI53@!6*BpLk2W04AFseUPd+Uar%L05;*$;HS9588R?O(qJ4|8SY91|=2(|zy@( +r5re!80^4TP&vmHs${1&;o-G1dtTxT*E{KzhHqt;SyBFnc%JV;4h +^I}1Tn&uuI%v)A^Fno_y=9$6KRbYLXA>bV@{zYY^QQ8&~ +X=M703QG`fK!$Qn9*W^>6a6=v+{pgKyb2}Q)t!jk@I#A4JLuV&g$(q^7Aqt&h&_M}hXy;Q5`ZGMmAdn +TF2^x?<-au#N>6b2nylo2dcH+yRK?|m>!$wrS=`a}$@JIH9GySEWy76PSP^OnagqwToz`oqxYJi1$rz +GlI41DNPatRNSrmhUjBob(iI~90<+Pwr{rO6SaEBQU8FrbmTwE$HbGjbU#q$?yy0AB_b=`vtdUqz<=T +&2-|iHDBvM}=yaU!HsjFC@^BWL&|bgRY(~YDHJ@KU5S70=sCQn{i6`u5$p +Iy)EvgX*!1r-aXnfPf@CBtOnpbL?taTM|KvEpER`t_gAC-1eztc@iU0_KMogcmx4O&|9B+%4K +u$DUHmWq?AVC5nv^TJpj&SM4$!BJeJ}2{fy;UgJ+|13}oQL`|1*ngcyGJ +oXf^&IGi4`ubctyY{Y+JYs`9V}@*Slv^0wNGbw5sofP7Ts*+^CEWBeAJO;DTv)7`u_>c0WhZonBsf7w +1U2F~yc|jcWCa<0I*eu*F|B)4pq|i&8!vh$4C!Pi?xZ6r5 +EE^C(U@A>3A8o?`&ZuoeKDVh%+`!}9T$1i!I1axyLCiTZ{ +K6->F9=A^{iTYnal?} +;SZWN~uPA|0#Eh*ek(J(8Airl2vGl5Eh8?uaUKqS4NML!*LR`XS+Rk__AVigPx9~n^!-=x7Inu4$wT`a{ +1#GjZu>oGPJvEs*~x|NilYwR?<;FN5Xz(=iyP;me<(9|r8HFlLtgb@*}@ac8b*Ily)ME_<%u&Dh!mS+ +5>7zfc}cu^mg>IY)j7@bt`#;hQub=@m+p<++^L-0&?z!PnRbXLw` +ym%jG-jD%r}7EI{~WIwW!F|sBcr|9iEKY?U6PkNdd_+BT+Y>_&$}q?|RA`Rs&dwNuRLX)l>WKQTc6(p`(qbq2qOf(B5}9i(huG`t +MU7$w5le7-N7WVTQ9z`i{q}}p3=^p`RVhbV0!2>>ZY52_H;P)L$5w1I@=;x6x_qjoAut{eJ;aO9KQH00008 +0Pmr;M&bs}TnQBb0Ps-&02}}S0B~t=FJE?LZe(wAFJx(RbZlv2FKKRMWq2-ddF?#?bK5qSzx%JiC6^) +9%1oTzcJ{RAo5{NF)-!49vEAL<$z~*qge24y$pb*k+ME5~_q_*z1ixf8$=q~1^NoSl +Ag%90`#`Fh4Gy*m9pJ~?@Q@|;~1nAyCUayO8&I)x`MVM&V=HiBrp-B<2>QfN!?%u+>W; +hW(IWN?8lq8tXR>s2#JVYtyo@wI+Q#SE5TDUXKc3uy+kT7p$3Ji0(FlD(L&rK7!yc={{x&B%iHZxBj# +WWR$^UAvJl~K>&WdCTJkuNeA10-y3`AdoEUsj{HbaqYhi>==j9A$|hzs??8|nvt%^*Yuk+ +YD*F_>Dh3_Q}~C1a#^S7pOM)@TzTU_mT-9 +(HP?hc#+)ClQ_%5_rPM%B$&Sf5(gj9Or=Go&k>Ok12=v_UoIu}oecH`Awgu$*{fkp2}ncpVWq%p2_k* +pdu#p054WDL=w2ujo-F|DIY(nB6Ht)t7UYCvd&C(0iEGkbv@&SB6|$Tp2g52_NegBP3z%C?j4UK?6Jd~P{C{8LJXAE@yJ~B?JEXpd2HCJr00Bb7ILoOCm_ +~ncP{Hnn%7BHD?yI4>_1U+Pi_u9|}fY@+_w=o`O+jGR$6O{%{#IJ5f%84>RB#R9jlBh9zt_PskykDWl +B+;DMVZekPd*}#&4ObL7gn@e&jMz@Ut$WsOOGNV<(gQSA6i0NiAg|@Mb<=_ljUlhaOT`cTc=5W0)`!I +_Vt*|vwyhL~wa{1rlYH4=zFzoZ;>*F3uTTrohN8A>6tyjfASU%9gE#9~2t7pRocCe9#Mc@Qb+iUZk?xZRr>d&6dw +e9RW#+h>b9Qb#l)-UqNCZyAq)H!(wMj0ZQ!O&bxhyxJ}SVRY}#@z-dBsx1$IakTM6_}b}Xrhw#yR;q- +!fWu9~#RJTkd<>bd3f^GgwiSwyF=<6_L}?P#k2D}Pfho8KSLwY&>tDauMJf{QzkMIfFxKNcqz`+2kNe*H!aK`|%fF}TT#bsY1aCjqGS+N%2o9Ky4Mh#jlBoBlG+5!S-U +$&n_U0|lU0cX3y;Dj_HX2YwU$TFtESD+`{W5zGaQI!BUobyCC6)d1oS!o9z@bqWf!^qInP7pK;p~NL* +QYM}x)C}=-F{}%_jmS8=lU2vQE0hmHf>LD!61Ec{iPSMXq2pXhzC~Dv%u*w%qB8i5h?0_{>ip(r +R)qZIzJpgD~t;67ja>;IJ#cbjkaD#l36$&x0#S?wK66?H`+dwuCWUxTsB^9Tzk@Elt^1ge%r}*Gd#pK +4Q5Assz7^^*gl7u6XH6|?jLhNuee8yq~39*$Jd~58kK|SruEzQXE7G&-yv3E*9Z{070!2p1o6b=ie%8 +iV{Dmh1B00rY2s<}!j9>Am`-B_)7mIS?#9dVnflZb=U0pCDzKL~KLp{g!KmWmL;PUA?>m?CGUz>(Mhc +(5Qf4#c_A0Fx+J_3-22IwWOSj~E?0hGW9|?RmQzGz6jD6L5<7qehK?4?|-o;4t9fnty0j)mrk1xFGB +L_;jEyW1Vcw+#2b%bAAib(d$0tksGp%z+X?%U1yQULFZA +u8mO?<0Y))}r2EkZv3u$g4XpOT|3|NC^c{6L{9?<%MJQT(47S#p>DKfHticLin{AYkr`&rq6L8WX`hA+M_qxrRozd*_avAIU~Kw?_u=!GCiVH?PdKyH#4U+p +;C#(PLx$;x+%8%f5&f0>eMug2dUbbJBzi_EPne|r`|pTWCW`g +xCjeKdIFrv(qUQ%g}F{Ocb0BUwv8MIP-WBr##rV=~yP6&jisyI8blb!H4=3%AY_YaYwU+!)>TNC$KC3 +U}zZ&@LYtbsiO5-a?n(V#oj2*wGC+vX0qAhvT3=DQt|Fs>rZ;%}|d8FfFtrj;s*bQNY$mg{U*Kz+&9J +Sd+BY0bMtD`uMDA@NyjUv@7WiUIaCWzTLh^y)0W|p3H!I+>fBiQ6TvpQT@2(&jZNmb{KkS +~unZ6vo7l>vUxTqsX{-vw4Mm*#cEuH_`WA)^Nrz45*&u4z9k*wk2MX(aXt?*b4hWBmN`jCdXQh55Bti +Wo$C6`XdzxJVzld_CXA%uv2aMu~QT2832?+nfX4Q#=85HkY6JK)VL_Kj+6BFuSI^AD8HkKJ8sB!9(D@RzYxV9TH``-cQgY1QQZ +$GHuJu)>{OuAo`>ue*QznuO=YTib4IA%%B#g}Az|t>E;_yS9h`i4C$Jk*~{Gps;I{y7&QHA62hT4KNB +WgLWLwGsXMRyD>)-GJnQkqaSEAdytx80=YC>kXD`jN6^A#BInHPB=gsf(%;Qfu{J9#c9UoX55v0GB-- +#t)5Pb}CVu_9ulrri^QU^JQB{&qbkc0M5;S80K`?f?Q%DMcZ8|Av&zG{T&$?}#*@u_zwhLw7^snzbZ5 +rx8qvl69>-TAa$-n>GOZ}VqBT86hcpnC6$v{nmLlwDc!^6pkjzW;IwHe+BhkHLR9K=g#H6|Z5wr+`oH +nGj?NPP%zH|peojJq)>?V-%}<4A6`h$6Hn8}CE4;<6zK5g9 +7KmS9FxkWJ(Bk-LuxLp!9Bm$QWfM8OFeLFCQ)LL-ow15=Y#rmv4;|CMNje2IE0T`t)a6YKU*)#BiUc$`7q3g9iYzYm*pJE2Fnqu~cbk +0NwEVw)jGH{}JlSc->Zjw`Nvz1#aS{6&tgTmB@6>|LL*z|mckaOcKeP1)IzF`${%$1hJju`pq +eF*T+sEp~Z#WulT9&<+A2lSP}9-Y!buu?ML)MR9+~^0QO{jO~o=aj<5ds3}dVft#>+N~LiASem`Blnfkqe$-oB@rDQ?`hXlW +J&vNkLQkHzEJ?_f-Y-spL`RVzE#n%33q%JG9I+QEo_;~2_9CT?$EqKYzhEKaVTs}!V>1IXLNRj= +2n;Jl5EOPr{@jK|!5+RnZ{%QTwXp>PcSo6SeRhmxA}{J-b1M|#Mv(y?=&1vXqtZDd>kB*u4@9(QfoiA +fjQ+8Jx|buOncd_FpXt(ITgGu7v(AWGHs2&f@M~;eC#S91-N2_VwppLCK%Zldc9W1&E+%wSPjJgB{Qw +)rHsP5obps?s@u)?bW^E=MKoZ;D*rt==Sj`@)Rqf5x?p$*B>}^}PT;KYf*ie^A52*iPlOq87%^P6m>q +Yp%9q(gC;TH}IUIoF2fclg)AzeJyEdb1?Qd% +(bwr1b9_oFh^#w!>$B9oqhDrDH3*WoQxka%u|&WTE8b7IWdEdeQ@GU8kgEFC7O>f0d=Of3Ws?I@(62K +vDeZAfZyYpy?luTk8ok?fn%wfxk +wsGt0cx{=Z7C39O{5>-dT1TNepWGTOhx9(n<$YGqo1qq4jvv7KDta}%&|QOw?4&!>#of38c&T7=@=s7 +p0|XQR000O8@1eFvz6#x)(J%l2oW1}69{>OVaA|NaUv_0~WN&gWWNCABY-wUIY;R*>bZ>HVE^vA6eQS +5ywwCC3{|eSVxujB=N!-WnaqDE#G@a(IJ~Byqrgu56Oo^1tS|U}Fild(Nzt4UF1VE6I)1H~$wJuj1OB +As2+SqSw90kXBkAqp6=EdSP*fjIw&+yH`(ZNyhq+D;Sd~wwT(UVbda{s}}G5qs!@Q=Jmw!zEfmwX*Vv +2XKPR@7M%W~e_BvlrCU2cjrX>xc6AF?V)puM80^6922;oG9hvQ<_z2Zh< +^7Q+cPvhoo6C_0%Jo(}KS1+D@`Qxh}UcAJYQ10L$U#-ik2^PQQ>w|e!u7bP_eITc^SA4yxl%8x?4YT(rw0K%@~XM2vIOVpAbUH@)=lt?-aoCXva$-Mo7HMN(Zz$LHtI +^5-`MOM#}HGHaJg^IfUw7vIvSkxT|4QZfaI=A02G!F-LaZ_i=q<6xCsXOk3OOZ`>WBnU&*|4zQk&roxz +XL^>*uCjEpu3*?zv&GqjDW1%#ECqDUlO@axVE(4cCiOC@ue`&m*UP+_%=2Z&E3(KMg!l{0#snKyP%9W +b%n@z`FB~p~FeWgGlQ&sa(~w_g6?}ePm2bCdj^sBr4s5Z8kzngTLU-5rHcS7(rD%4g;>}f->EZt;ei; +XOJz)gQr_1c%0Cy0q>zUe0F+l&8-bEAc-DGrd@Xh0w-#mRW!9P&6$_R&H3Zn4m==IHqqqFEdIiBA?{` +3Ach#(x?~*kv#Ei($y|>X-GkUaILepP8{rd5b-@ckW`~It^KSAa2s%h4z_wKEUh{a{KfRF1uJUB?R +IZb7)O;K$U{)qP!`B=@#f*kOOUe8&joISnOnlTlqA +21r!xFK~T<#xSFLZf_)l14we8KOJFk$v)fo~^(&tvcv#&4JAJA#4qu)H)~wKPvt_29e1Akmxm!{r#;#4)$?Q5=z$^i7%wVh3fkP1@50!9c@^Qd5fy>;K)pd|m$X9@wOg9UdmY^ADXp@wZmZ(N5>Zh*XAXRc;1M9H7G?1wrZ*=6l=*SGDVk02Ly_fGJ{!fsGnoJ2+ +mdlCxB_~gRZ^9wqz(wey<|Frebqpd`LYhC*(}*0L2H6K+1At<-mXCyN_|+SX}Q<{y@4$X*feW4u+&?s +b5(AZX@C&0X2mo#tfeNR4vwaU8WWS1iOTDGlLbc)KKk_UpYk*zn&TdrWJnk$AKgER>TEg34fpFfn6Jk +uEC3~0)r+wVvL3bg11ucpttKp~gD5X%Wrd5n+>R7xtTxLgUoSIvvT6fLRF?se$!Ri$Vb*}Z!J>o>gG2 +f8#WR@g;71toJg)%pxpu5;7ugM?F`~A9i&d|)Ev|PIE~RB4B;lsYLt_N8JEW-e?6gCYbt6*Z94cINN= +Lac`G9jvBu^`PE5V6n(totgmLj-GygnKgI05OA?(P$jFpauL@Q +YTGQMKVm7uPR$FlUX+5H}2HoBV}W|WCSzhZzfyTSuYftSm--f)TIQMJai-87k&Lw$l#+8{($OQ4Lv|y +FkgJ+zWCqnixWi+X(NNEWX5u3lOGSlBeUcV_Q0@bzyFIz0AVD>hnzc*J)sQ`lWa+88gx8Af_*8q0Fzj@fCvM +^9<^MY@7qil2pS3ZK<;eHw^7G_)^%PM(Sl*UK5(H${O{s8Oj~Pm|<>VqPKk;x5!uvMG=TrQ1Npijqnp +Rg;)agw_azne4b}@A2b9o+W_-|_Mbm}ehghHS0JAQ{wjdS#CI<*!)3NeX4~-cvJY6!SfhF;#8Z1@KG$0ztJ++pZM6$eM>Pd~8?}3CjupFy;Y{0t7Xy +kxL0ZN;!7Y0>A+W@Fh5&W`&)!WoKHXz$rAhtUyb|s9 +p}AXX%sX7;qt>CrAkU_66FgNty+v33LHyJN>us`k<*-tt1XgY>Tmriy8Rb~~yTj$1^nq=$xljdr1 +6k-q_9S1OU_3@?Ed;2r_K0}H%flYQk42+~O9G?~EJH*Eo}yd<~)j8VU1YQSRjlne_?!URA9+#;JPabB +wmAfkzPiAEJAe~<0uzR5u`n`VS`NbxlwRX~a8CL$u40G3qGL24rYa+9-~pr9cN`AI~TVA1c(=2<%!Qu +L$nIq5|0D3$)B#u*xmhHK_gbsa=A8#dHk1lp_elBqDS71jTjkK!+kd5B20wLcI>TIxweZFfwTP@<`N% +&5R3S-_4glPzFTi4(i_PbM%RlX3JYAT=;{!gY)>V15;X6hp1LqLH;`foUgLp{xY&~F8bI+ +tb;kiJO8^ws5k|qNsRhYdgP_qC%12BPUo&w=yy(abT89DqJEvNmBW=C$->p1c9!rVhj$$lWiYS$b2$tFi7{yT-^2P;ldtumotMz?ZBaD62zFySYJA4vt9R( +1z-vglbdZlsn4*1AG6}57gdiQ5;J-8|TDZ>ZGIo1GtA!x~rX=U3%cwk{>_d4tFcF6**2b5JaO8D15-C +0wiU3D%Qa6p!R7X+8!1I8|;hyLG}>|%XTlg-?2apBi^S>B-LBd^t0caKq7wDwV{fereq+GKldo}-qIX +0jcD>W0T5`X|Ck=;ABdIZBv#4p^ju)1c&_SlxSD +K!P4BT+{w0AE9kG`kYlAJvdcivS9af$<)Rz|N-RK|0RXFbQI(r@9hpL)i$+czoZYcK$7Pi-a9&Y+L~p +y%KE1|$hab+5A6$?n`<`RUHY%T=LLnDIoE53eINKfV>e{DoKJ4~9V~=M9)Y>Z%FT@fA(W1JR!Cco(4t-hRe%N&{dSfd$^V&D +Y}~GhQsw>8$*>gjv|U&YM?Op)?NdLfP~>_w4*aDydSqSKvr~e-0W=pJdC9%8kM6r=O?EZqY-i5H%L%; +R>;77G0>0StzRVGMF*x}SVzD3b(2(RHjl!*c#|x1-q6$oY8*%z>M8a%BZbo5zqGS@Y}g|&QP7grnNO| +h?rYW*8m+_jG}awxr>{`BXXo4W3i?N7yN*J9wASlLbi#=C*{%hM(oO$nb>(jHUf@Is_T6Ve( +@Mv;YS24Mx`$7M#9YR1%%=Ch@YFoFkU{o;_(3K8il=rWI7W-J5&SC8}f4rv0cA)%q7wCVXy9o$xsdC7 +=U?!;n7JC^`;ng5)K>{WLMFFLKXD~CjKcs +qu(K4dIwbKLILiaNkc=ElQCvZnw%M4{x4N4(>bNQjj{^C0oBv +A12y=|voDL!TqwY4oZMF%&kRk2qad!miN=Tg{ax2u$Paoy-(&;gZ3;OQ{Z$l+|_6gOP2qkS8rw^~`!A +6mP&kPpHnU5f*G2!V+=TsT|pJmhM1cySKDdngv_dTA^%00`~_3*M>If3u|Y&aektzq1+LOG@Df=uuo} +jf4+G?G$EBG#bT8n%del&5t;Uq-A%kYJFvn+YKuII34<OaDzD{7h`y4?zn`o^t1k2LQn@UB +LU{SK}8-3Kx8q`?AAB-O{fYbE*8MGaQhO!Kz2l4$;h+A--RaeQnH)4SvuJZ6KfLi0=i{J$Re1Km+8ij +5*jM+FvJKE(X>YJCBWAr|iH~9Op6wofN!Pc7+T_QaFX&n5}8qaPG3Oxh`nTB0!n-TeXO76bXOVj6esh +w>o9Ko27_gr4Gj2YCM*;Th)Yh`E37p%r{3)WVVwC_Z8N5*H1npHiHIP!eD=KB_Sr~MuLcZv2M +Z4>rP=OA)asm|EPZBpOFQO{;wqxrSQW({UAi7hJ!m$E4Mn059@@*8iVdDyt_N5BBF@1nlZ0kQQM{xAC +BMM@{;N*JTLPVSrwbUwIFPYAt+pOZvY+1Kcp==Nn!nuwrd5t{D-x++orY9K!qPc2>&2!fSs*P(l1msO +y5bWj9lYRX@>KoasG-bd|gy3;Dpkr}fPugFH1$LU(I9abjRgQYPvb#IoLD$zgd*Dr~5)J~e9wl2KdIG +&AUH4kgTI|=cT{DQk!>$#Cf;|~B`J!sW7qx4ZFct|hd0-Y{snDuGMMlBH;6b-n3b|`K_rXQSC@`PN&W +4X&#~+s3SGHw +v$NGBiDpI*_>1RHR8X`0b)uSI8R0(|LQw}lefRA#RBI#eoKWWA8O7^@>{(Xag;`P{T~aX^w6ALN;RmZ +6w_S}273j>QwDK!bY3KkVaxXhR+7t9jQtjQl*RY)}>;66wudc9Vo#)|LR9a{mcqc@b8$Au4>xe`SaRM +ojCmKcp6SSH2Mo>}N$X*ZjSs>q)f$GuOOOA%qi9R-9|F-98AU&!7(}83v6q0Q*vHxh&t)dlM(;}0FQ` +o}eK<{Y$+HQYWppo{a>51aAqFbT_-mZnV-1{X9Ayg(<0Y`*FsjCik!UK^0N@U6KR?;UY&-9_mXs7lo1 +!GbF@$)&W{ulm&Eu-MF+Pvp4zT~sVQkQSn=R>Iu^h`}_RyyzJ$KD$T29lG5Bj1Kx +t5dFpnAAntk6^9$P%<%ub{NelCazm^a)&W+9S!uFro&Zk)9tbaCQ*1%#TICX>Jl_;-0$k<|+iS^>u8z ++kj|A)n=1B4Q@6GdCZek4RJ=lqPW}0XHFT*JMBaTV+*5ST#a-fA5{_D7heRR*7%rP3q?_q`mRR8G+KS +#;7liyK0q3yNWKz!(e{&dk_h&`5%F?&HY0*!-gKm1>`aV;Y8`dS9a%&7<{r|4^gP7P? +XrM$H&aRXWhd!v7)g427Lxu^=8@WEgzKk@sQo!SCH?DglXmI;Ti8lJi)cIY=kkg@LMlYn&RX*yF@t$V +E_1uF1T2V8m%(Zdp;kr=HSpw%y~8uTnBd9^)O?#e1#WN-P +{0(%dY!$|ZmG`irsW3N08v~FgoMHBuWT+;UyfxYAYP|Iz?%mT&woC=xH~$07s{IxcoV{#@SVK)2wpsVUB52i< +>+<&;pou;w&1|R=x7@jMoL?-;DrV2AOdLKUVYr@)hBMRJ~bghmtcsT+aq{~e_ryRpBTX>bP(Fk5&{*z +z}L_RV>svG;l-l}+B$rA@!`k?+JDBCGqUs_2Jx%9(kv0c`KF>S5sB6ExI0L7DwG8?dvOk5<>@xqtPuxc2I50|> +HcsWGd{vdh60aR-lPz*oiRh6=9R&PThph$n#eYOuv0^yGs8_D&oLzcEQ^85j@w>&Z5VAaL?Q}1!QqJ5 +5eQL8K*I~9+x+Fk{PGcf@r{pv|JW@2iTUNz@S-EOX{oJk5DBdLn5cojaPSF4T7QfFi5A +Q->7O@p>35OO-E6E +{QhShXqYHcJlYj;rNVD9*yOdp~@Ru>eHPkpJM(n+8RU8tGB6C`%TD;PX0PhbRD&sS$%3(A^|yG|K9lk +7D3|3CNq}26_fsx$X{*vK9D{>s9T6$23cpOjzF}RgQI^FvmN7T5v`|p+&VyErh(Ws;z)bOee8~xdEjY +bK;STxgtrZr70n%`GW$orqff(`xpN^{PQ((9W?2KbbBV5|DqJ6bk)MRarK!cc9BAq?YuIYs!}~6H1UgQp}Y>!5EbJj8{xfr`O#RH|in$6Xl0cPDf +8fAk#`KI(J4o>h#K(A?_KxnBv*wdBCqVKAYK00I>n7hq*|nYY*<<+GR52Ch_k2KgGOdl~i+hre@Rrd4 +e>fH@nBA##3=Fo8+IGa>Bad84DZnf8f8JV$&p@T$SwQ^MFCmIt9O1KoPJE1xeXuj5WqHTJ1NdDWH1SI +8K%PGJXNGdL5bU!N{!f@h7L4S45>qnG(Oq+0%5R&dMrc3#fo($bdvg%DAa9Ct4%Y1Y1E)_r~)L5PKj- +$df>~3me*FZC4FoKsf10A??6f34AawI0F%;JRy55#%L;3KBm5rs5e8Q(Crw;O8|mqk`&ZHLouDKd#9= +;P7aJA3Hg=uiw;?Hhu8;7^Ju0T&>2)X!vKrAP+o(YlDidWLz38$vb-hGamK|Xw3DyNq~Utvv_!NQYkbB^Ve$=MAI#_S8#G!`~;W@!Yrq7!FANIuuWxjSqY)7O +aGi7q2W8@Tw-mmq8k)m$~7A~K-9orc=OcBmIVn@Or!2{h7!!0ktHY+Ne8VZY>(ZjIq@iXDCKsJ0ZszWzTENhqR&o$z6Y=W`bJ)_kCofHSWjJ{aDp+ +1@-X2H!>-4iv-@X0p)5)hFze}nWX3TxJUvOI$-oW@iI(c`TtkO?E9=%&7v$B4B{OEQ1;pp|$w!jdYV= +!N*Z#$Ese1*w4+4>MrFgPc&Q;?4J5d@|2Jo17ub5wPEp$t~Gix4;E4AcXixL{{zRhELHO;b>B@`fCFI +zNGxo4}h~pvo4Yu4R>JMpAi)JSREKEMfNf4Q+DjoYa7(LXtU*4zxs>8=@KGtcH1wbXaGDCB3X{Q?MnJ +;bYSbrhaL2Oo@FM>u9YF3C+zDLg0#1?rqjd>eLUgq}Y5 +`(ahE5<56y)yDqUCn$LD8Z=IkguaU%Ok#m;?o4;YBGQm*!Ut8wKqZc7l|z$~vdd)>DEi|&Z3G=tN-iW +ydDB`6*jqzR7R82*lwi1(oD5-I*NLI>0%<1Rj)_dS7$J96ve9c(n8pD=g#tweqyb!$PJE>{mun$%k-6 +HRSEl7ajJ~`8i_ALTf*$(br~)E{i#BfvzB^(gM>0o|1h_q&Gw7vv=!*pD(w|CXuD$L^9x%@jI{ayM2G +58PTan%0Y7aY3gtS@)It^@s-_uTnZ79{k5&j5(rStA++2pM}=+t8(DmlH)WpUCRo(L>G4j5s7dN;n9U;dWSD|k_ag9-Jqs_D0RmSQU3__irm{HfHqNK3 +HO0}GzcUG=Nl@evGLWG$Ci_V;j14=qCQnQdnFlWf$pJJlqTI +44=_@^Wm4Ch6&gc83fJH$+7Ny7Hzi8pNb-O`0}+wjf9Q;!(*ZQjQm8GLDrf+)T0<)`L~AjlRU6}IH5< +GqQoYAscBB#&u3>)TCRP?Y1TU0UceU-g=g3*lCy{AdNeTH3FE{`Mt{g^HlIR=V)dx6c(e`Q=kfL +@u9sCZdZO365{)4ZZQgX&%)_8yOXG*_81I_7kcEBF=^yw@c(oXEx*7{^vIm}0ao);$;FW)wueY3_H1Z +s;5?tNla5i2sDC43*&Mv1+USF4M|Ob#e~R4Q?nWI@D!o?J)4`J{cFQ>{sZXT-?M8oLrG`_RsL~3?tW$ +GjRrDqL7?!PHMK{?_Ju^dqC12z}J~RN!Mo^lDYGSxzarl%Bg2MWc*+}Z37_~ZdztQ#mn|x0LUhS +ipsy0)=uqWLeT6wzC^Ji+XwbO?NzRa(&<9u>u@~`OQHK|Z=F6Tg%BPXLzpouGpzCRk-56*&*?|;1WV7C$R`?VA7YqFaD6Uyq+yn#;r;im9$t!F!?So0{7{JSj17{RVobAQSZ +dgbc2%Z_ZI@gX4n3v+qra67k{N}{QeL +Sdft(`iJ5*EM{;g=z;AC6*MNhjTj`=))O&k1hN@{gFrcZ7nEbgzM|_&K;P +KofEU-`Sg_i;@`WrEsRD+vrI{0g<%v*YvHZ^oLPA(Z6p}=x+dZN@*2Jy;&|&4?I3L;l^8s#g7lQ;hRg +LMVjuE5KX2W^2L{$O>q25eY$McNBAo`gPgQJ6VO-a`~ktuJ?0TbkdFW1LQ*zC)8Hu}NQ)iO9kSvvMEh +j;_j7|vwoIOUaoAG+s&IY!CFwmrg=Bmf1PxgvNLT(jf&hRF^!%cm5|16q}{ntFpvzu8nwkR +BME1_$<`B$;py}6u}i|pS2m^a`x^8OJhPE_Q8LVa}7?EMm@{>uUya1N1BU>ZTZ77+VIR19$FCRtub)@nOwM7C +VA%2GA2>6E=IHd4%sF*Vww&CCk}(fOi7>fyZb%P-o{phMi*Xo1?+zS%U*82!9S1o_+LP&Wbs)J!fCmvcx!*Xaqf+|ZKocnM>THWWESDP<(vmWRm;8PDZpH&15+#4r +IY8Sp4H7D}1tOa=ebq~WiaA3#he?#1%XbyGUEE}!E3&w)V0+{|rSX8N5%HazZge0p7zba*Hw?@HYuW~oE;#!V +!88*s!n=4tI_l{{*lHPf8#ujlLqfM-QEhid7Df??YI-~rL@kj{^tB(Y{n0?9VqrXJXXKFUDPy14@0C& +_pC9Ir^hoWC-1op@lMuIxzCfX_gZ+qTI5$pwzsO~(nQ-GlS$0Xz&{)1#&@$Qp?Mal*k#Wi9)#6~FP}8dJPlkA*}c-i#PL)5)+KM6o!W +(QL+}=BiPXi&&foZZ-}aFG(Z$N$ra(%v%qQXK0?C99W2X1emYG!;nW^svS2Ea6Ouws2{%NSL0J3$^?a +*JsCdjiz_CT`UxduTt;Z)G`dNadF3m`K6ypM;YLQ1yE7OF>VUIB*&L$uTlu+la_T%rb07}db=AQg2## +ZKo|+7W;60B44dP4QgVc13yz9ELNV+vRmn&TK)S3J_iDqV@o3(s(&^r}Yl7W>s4QZ=-1J&bz5|Sctdb +v^(bgZohv2e(ZOR_P18)cn;L`{jbyZk<zfrQhyam5`?Qn==USdTbYDKT!@fH^Xj^+@{jgnw9# +q=&A=J`rlGab|$&qF-GgA%A3rQna29NPT=H)DDAV2EJ}O2JNFH**G9n;f--D6ABfh#Oygrt2}(6$7{# +iNcEm2?4JoAM4S;U@eSUoryaQ|CSR><1t^y> +bi+~K*@<-PSB-qnvhs%Yh1y+7l^uU;smPVctT)qYk-__(j&Yr8+7xcH(&Y$*qeepv4|oH?-4fY|3|H4v`XIUMJKhXpk6N7+D!b+~PrqOW$fhA~!q__ +EmCF@Nu*eMtk>QE$9zaA~`4SUWn2&9+bvi +(hb{UQXGhO;H`2XiT9{Y(4-XJo8`p%XlJi~MXOkJlZGCh +`$-0d|SLxHkW!#iF=vE5&nA0?y2ZZsC4TqEW-ICC+7q(caK2df%YnAL8y;ld>dX1r%Bx!0JfLiNY&m2 +5XQzsTf=lY^GirHR586{YtYtygv=kvR{Dpm9aZrG&h*d|iCv*eXaJ5dBkd(Md2vEX8wv}#khVQSrgqL +LJ&ap~Gf{iqFR^<=swLU@k-tMcK+Y7T7DY29HLsQaoYR1PFshCe$@MK$2nO$TCDd*JY}?20GxqSnV6TOi+g4%6%f!BOZ4P9ZCLW2x=xKTw#t6(!&p9 +at7cBg@*Klv-7)AO8-kR8&bCxrh|ZjF8Nj3VeS5c_+hk;>ye&QYsq%xU@Bsl3f5!kWd#sin>Cw1)u4O +~*{c|`~y1YJVP;b_2N(1>1Zq*|)9?=;vdQ0=w^jKg*kzNtgrTMMb8d>m4w&j#YfpFd=)2Bk{mkOL|GR{u_wWsyc+Q+l +0Tt!#TC#4j3EU=FS@&6Rsf53>5izC4>$lkLrT)S+U{F_;tuatR#kLFFFx=oyL3RoW?InB9H)JSRT5vknqQpK4% +?w-IuJr1fbJOtS>jV2hHv`X#%#(UsZ1iSNzCe34;4H#NWLLMf;pWn7R)-Aop+uj;Jee6FAxutfC_@-4 +#pG$m1_j_kcw@t-`H3aog!Z7sCOYd519-tlpya08YX0sJ$L5Pc?sCvHH9 +C3WQ_M@#++A|!!tdFG~I+Ln6FP81zdb+4ct;0?7`I(A`7Z?UUIb1K| +31`neNk0tjMDN17*fspoFO6M(}kYx3S_~+!(oe+GMcs8&m8jI +Ocu9*O{~ZSJ1;~c@Wg5SOQn4J3x>jGTTll#fSK;Qzf|?gC1g=+l`h+ +r5(h3ecn*M-*(P1A>8SuAXj>6CWy-#&K%CukCc;OpyR8h^2*|Jd1)XhlwRv#q039!W+Pfb=8ydyAWx;d7ZMYir((x32ur`OKxYPqAGPbELlskE9?Ni!%GA$0xA%WzZF&~lA--w= +ALWCL>}t8-_lPhbq}b|0p=cf<$pZMB0FSL|4SGK*^uwc%hY?#7X;rqkoIS2SX-ec%Vhd7 +=28$H>Vg|Yxdp<*R;5Yxv|{~O<0~P<*(18gO8IUlef|x%wS|zfsU27WvnX@I1O56e|9`reIF!yp2uX1 +#^-KqQE$8`KD*D2i;sklqZ%C^GBa`=$@1b%6j?as8ilOmW7hlLm1&zYE#)P}nVQ(lq-LVF6O}2QLaaF +=6z?kG4;1KU56iIt)4Kuth)g-vGPAl_8@fk4>j+t0%d0JjA495}-D%y3D=21v6E!?qnU*`=hY2s5 +?rExyZJhrW5HD(k5z@a(`xT+%%oKbQcjQ$>_AFB!-l_EjNMrVBad>JjW +ai(gX?!POJ9-6~;dD(;1c9=)Dy(vBupYCP%3`6)?31+W`_gEM!&9(#K$bv(@LSHb@uY|Nj`yRX>N!G* +xM;hf(}%oA5uQk9dtx^_&OdSzPIJr>gh48SQeF@SscdITk~mSFq +&Vlhu0l10m<455+Ew@6aWAK2mtS)wnm`~BzQm% +0015}0018V003}la4%nWWo~3|axY|Qb98KJVlQoBZfRy^b963ndCeQ!a@#icU0;F3n<42+Oq0IsxN$O +G$JzBXwllW7?M&=dAQF;TQv^$pmNnCl-*XNC61>Q9;xDU!vqWd32mUVi`L^ +BjW!QP0$2V`*2k@Boc(h_k8%@TKcDhsO(G`~@$SdlKl&r%dbC&A)*o^EjMEiV#TDF!@+1(`z4ST8{wY +lHzi0T>`>5g5^zSj^dUnq)~io%%|obI=^F#Qv$wghAG>x8ILpal!$60r-G+s*-0Bz^xbT<-Fi4g0sgi +fdc#nN?HH|WU)cKG=+kJ;fNv}JO+^oY3DwuVu+d&@|nWFzWtraVnqYAP8PTjR3uu*eh>t0P+((V4*;w +I{2i`WB5yAQRn#KcXUK*2q@7Ws^aD-uj{cW@sAg#rv4aoCX1HcBavz`)f7?ubhjM`_qXfhb5<20B;)a +9Rr%x8APoI!`xByro)2eLHLq4EMs79ye=$MANOC|}DtBv(ydVFzy^zSi!d3$`Wzq~*FX|$C)&exCE^{ +PV3(&ciqz2wmiuEiD2`dsF?94ABg-i%jjSx&@Z)(;*7Yttx5Qq|KQutzO- +CBFf$&tu`bc$Hqw|;10L=r-K+wiY&m|%E~z5zK=pM+DBRQ!98$H2!n|N8D(rHz^A7W-*0PxsMo`G1ym +!A2p0uZlxm%Te{wufhh$vYRi)Z?44nfmC`4BD+#s!P^J@ykZyctnd%4z*Ne^P5YV%Jy41}cS%Q=W9NK +63})bLyU(oP77*PN+IRp7*g)s8jK(8AUJJD#d-aqL`_RgsyEO|I3%DOrFwZf&i9SmvS|!Gp#u?#LBK3 +D3A~96F^5V==21zGq+{EWqKJ@(@s4KjtiEPaJ>Rw-}HGB!Xi$b@WK(X;OC2#t$SVka(FrT30jXdvLJ# ++#6WlB2w>i{2S!0Ra%;O*l1^fb333oHxQ^G*~>RiTnn+{>2s`(tnLJA#2nGor}Y`oM$)nXexXA8^NxE +mIRCLvCpx5%I(%$d;x2xjmQ|jD14BHT-+)lxIcp_s3jx12n;SZU>qdK{RPbUTKRCp3N)RGQZ$U4uriQ +&#shyd$rrLqJJ``#Kj7C$f@nD?Bdg|X>4CjO1M^%Ygi2*rUGLc}8iSjUIhsi@Q+2|xOHMCEk%-|RkxI +(Pttr*&ER`s1wjf8eY4Nl-{42i~@tEH^c7~K)oR3H+le+B~()0IpDH4{Sz-jrB?$;rX#@w=mo%P`4+6 +vAt-AM)w5EX#cF`SVytpb}IzhO$^Zuc19xvMM5hzr$s@N_XH~aJR7UZ5-2tXj=LBH+^3;Lel-3iv?=m63zV*-wxO$~9JAH~6>2GOQs2841-paX)Wg66_*voAQgp;Ysi;F0aRn0OHF`p +w{WX2IFJaC%RVvM$zl~P89M^=n9DN{=FJ?UW-KtRFdB2Tf>f&u*hlX#ZnYtg;R3xs!+A#GX7JVD_Z1d +=Ete-=CeGsgN^L|nAdD-Fjy_$x-#+rprqS9y70FNvw$#7KsoU%E`ZKo(Ns;sL)EsDB&@hFOhq~53Uvu +5PAgPlugLnrpBDS<5bV#W7>B*_17o!pYqv|B@D0_Gua!;TpEWraC-Q(i>8!tAY6A?`4fK9*vYr@RzX% +;Va%DaW>Y_jbkaQ30t5jrStDl(rI2B_XIbS{p+KYoARG)8Q288?aJXU(bi>84O$58)9w^aJL +jfINm9jj(yDv$~+E-O>|g6eYY;MB5dZP!(6l3|<6|9;%8a$KABYPG!Unfmf<-)N +iGBCBrpPH3QD`ciG_=|oS)-A-{!WnZzEeLwn8_d(}FG!%C^*oR`T40$hJ*I!@0W?>liyvhKdKDw8=gr +4qpQ3n9HqIvvc@A`T;wh-e6lygYgKEsk9{zR65)L(xEV`{DGaRqpA9XyVSFYjmK{dU!6)|34|Q-L^B5 +M#k_zjBP_^;RaeEouv=+5!3@VG{CXY`0|hL`B-IdtDETFHW%RCTu!b4i)@$(nA^0cK?{DX(1NkZs?lg +LSVa>VNsMV6!Yr9{rFOy!@5(UmfmBAUL{{pT7dYjacO{KqUdgyhArtU+Jqokl8_yz_$!wxPi4vZ&XbG +u91Sf(lbp80$OgR^9iec`Az1xZI5W?AeOr=~cu|0kdk>BxC9I$BhWX~HzW3FOpU$PEF?_#+9 +LIs@GhX0eh-lPsTy*BBKw~zOrERb(;ehSXp|z7Xsw#)fNW=zvnYsGK=mry$XKEhWeKjmUDN*%6t87wD +Oaz%YdurXI-#putl#VBOEm*FFXruucti~?ZZ5oqBCh^@%f=s5nStUAzS%a!YG;Sb}-dV~~pA9@xkA|r +hUut$MFgZ98Qr5cPjINFZh;FOo2^K6cM#o~0nLBQVhUnc7HfJHLDGQ#dl-nL~Oa+qex#L@(dkEy~y7?A}t!^(^CT;D1S@$}w9cZih9*dN3fcR8$(nBmI>;)L!Z@al$`+5xcj~;vA! +r8vyaSn2yinPG=qHaTDs01&frBBZq`q8&@y+8b}!}1Y@*9~bj=Y*_oMgG@@taG}%dsxVFqLnuGz6Cn^ +dPbH#<%rT7UhU1$@rmqNFo$2AK_pi0E<`i=qk9>6R{2!qA^ZS)vU;e +_XM=5=uy2q>i{fd8SPsHG`6lpq1lN%?$viSgNL+#wr=T|9jnoN*OgTW~Mz}F6*H}|scMsXK*BOZl2H< +o7YV5WN^V2d>zLPtj)AH+o$xHh^qA^>qyP}1DCF^Ks(I4Zl%jdsD-w^0_|o~|UyJ|t~)5il9h7bA7&I +c~3`N8Icc4bJ9Pa&Is&W9>Zy#)G-?w3IN^Ke&Hr3xMY}Cz_Y7K!#8e&xOD31(@drt+thU#|k3A^spbV +AOI$qNkSHeZpP|fom;oLw93nkQ;PLS^g3^X^y%C9p&z(?+?!yb*@7Khx4sv#h9;KG^)s;8 +oFmP{yllQRte;)genODBBL$lSd(f^9BRk({Fn^S^*3;DhewY7}!AR7cz$I{t2BQ{U@qRR+9HT2$V8== +iiuiEX~3zFctO-GI`fB7I+hnw4O&Um+bz1mPJU1!7K;NB+lIYxU-8JhgSRF`4x=ONJRq5yIUtT1CKv~ +ie{s$X6p@3ke(pWpd%;6Fsk_!cHpf9Bz|cHLOlQ#elK|4>T<1QY-O00;o@p|(an5v~G_2LJ$y7ytks0001RX>c!Jc4 +cm4Z*nhWX>)XJX<{#JVRCC_a&sS}Lt8A_z662FShUSq7 +IjG~i8u7W?;JiPQlfK<;R;AhQRn?8Ps#bKbFvZ@Z#GNP>Gk=4aA$TpJ0|;AST$C!eTPKx_>pkSl8*xfBf&B6})#Oe(VHD=E +%v+H5+yVWeVf-hiCEA)l^3k#D~Jt^hi-8Q-@;0xzZgQYgPthkn`CR0FsDY_^tSPl}b;w^S4V)o5M9TW +z#43NMHPJ)2Fb4=qy;uhYEtSiC78LGszGENNYrCAlPb8E-U`tzB+umXk{lKT +$VN{=ei%Wp1V~JUH&YPsPY6;c7=1s2NHF?7X4Hs~%#y%6fJWa_O8;v@B_%Nu8>IeXO$!bcPpm4@A#7w +{2&>Y^6Oe<~!oLRGTuePeEQ9L+E<01jnaaqS!EpN}Z`R^&d2v5ro{|=_0|GCiOt>+3FP_qSr48- +JtBsHIiz?Xo^6XZE$^@eG}icLW-ihmauuNNjQO{zm00j5u^C$6`lWD`x+9R&HHP5@e{w&ps|NVXtv=X +Y-cWip}4hVIeDLKV0QP2_YdT_zz_Epzvl&*v#vFaVUfF%SF-Fs3?a=j+1 +Wh=hstXdFsf+ASlYaw>v`L4zI*INjNJ#AZvydudL1uPs<$OylJO7+*57)Xgut{A|e7K5q~isf3;4VuH +LE7ohp^btjWW+uWhAArr;tR3m6EnjUhd{?wHxk5=R1?0s(ExTu1)~o@!-o6#Ev{MbiPFe7;Mc?ToX#x#d)58trHqY1Jv5ft$BQpeN>5_g%0$nJrh +e~F;AJWSDzCoggODX?jHm0rEFbmtKQdtR|tlbZt+qvtEM5+IULgyx7yeYEWL1F);kCfNgfah +6k+**CLC5_4}QI{!$PK|j|K||4G*N7*wg+FNOKGVnYeg*eHcD7DiuIP0HOc7g@uYk*na9j%~;94`%#R6KgR?H6&V +WUikue<_h{Y1f!{gx|98N%XB`~vX +1rkch-G7!>XhX&3aLHx5~&k-=UD7b3}dGjT=}4&8+vWYVvK+I=v^qP99P5!lUe2Qu`R740y88 ++rnuE1Gl9~vkD2%U%ae&~dMZsNT|bQ46;3lRx7?$JF5QbA&9EOQIK@r)A2A&D@d@Am(}?2ePKMNkH`^(te-YPGEH(Pa>17+f(#h(IYa;*vs+9l$9{>OVaA|NaUv_0~WN&gWWNCABY-wUIZDn*}WMOn+E^vA6J^gpw +xQ)O2uVCZmNt2zK#%_9db?a-r$z#L2Ur{ixSfG9plATnS?Oj@P_Oe +=)S=#1RIfYIqoU>Pl&u2#`vuXRGWoenQ=WmWqj}O0mclze|1Rp}Xtw)a@9WIsyU+}V}&aAp*Er5T`+Z +4d1?6RuWSj%*NlV0(Ly`8;nrdwMltL3t)+lHk@!4_7BMG6n&o$1pt+nMg*e|E=&!tV4b;~$p1&S}76G +(`-yF6(N+lH_vLu4=?c$?5OIq|8)NVUiJ&HNgca*PY~?Ag=go7w +Tn;hUr6c(%2Lv*tD1SJR(D`&aZVPLeWR0NqDGhL*iX|Q&xAS8B!^zuzIJ9_@+#o^Ic&cnCIvzN2uIQ> +RQ6@bD4%>CUphaK9FKB53Z1`tSI9Ujf7!QprCwC1!&0r5Ecp=9FchrdUotz`GvPV(|__Ugq6w2L+ICX +yeJUPrJa@L%iE+ahgIxJBbF=Ke${s|D=rdu;WBH}g8DWezm_n&015b=F|ZKUE7pS%SF2KMqzPVr%o;g +ydQP!mE7F%Z9@=wvu1(Jo~xlA!$D`js7XKgO<;6KjpB!sox9OfJK#NlXu6j@b5PlO;zxgHvu4T>*_Yo +IH7SY1XH8w_4?rWYv3Frm<6P#R|k*oP#wHzjAy_3H(Qg}DI8Pqf3XneFV(?XHLvf6i#S0E8D7c1@_DP +;t0j`n%{uk<*YAY}<8+yQfU~zu3%zPKXRI430NUq`?({-~k6rruKtlAk$%5EF+x?IK=ehq=JV$`@+qC +6okvvEW)ok)55&eX>tL4PwL`8Y})WP9@)>Pt0gckkF +C=={N9{;J@2&y4!<|M1(2G3cY1sP3bLy()KL_XuKh#vWPcz26F-X2{_^Pji_xRMNAOz&zeOWxger5!F +PSnAc1ayAVEVCqB6Yp|QfrO-q_I4W_B0v609e%}vt~}Oc;WTh3G_1b=ZPd^?zJ1l(9n)v)oI@F +^{TZZg(B7kZ(2pMSSavDC4K>HHg8G&#C95~j4ydfDk}VeZ>8ps3M;AL*q^{(r%fUZtr#pPu)?I(H8S% +-1y?);bz8mPbNCwQVOk)ZJ&)}rRZi;_?^5a|*sEYz;uGwPO8WVh8ky`lsqdF^9#gPt7ENs7hzp|H#Ao +NQo!%XNee~wrBiLC-Rmn##LSXo`d1+yS<4)5hQVr=a64)#&5RMlGSM(>;h#$v-!N!7P#)1XTMXznZvW +CR~84!W7Ro|ob-f)gcN*fGy_p)l)G6iE4OclUTITPei_WXUK0wjEnAaZ9fkmrCf#1|g^E)~4j)0!`;T +d)BTz^HFDOOuwP?R@TNI|HK`9Z`<9`?;g-_K#+12Q=F5=TdT)C@J}(+l=@S&gzE!2qril!`d8dlq4*8 +8GGPID0X%{k>j;HdwMPy5*=Rb7e;#ZLw#yNbtIPShKM{v9}X!qQ^EU^>5;ovW&R^DhP9hKW%~nM&i6Ivk&l(N{!{NB9@|$<~Zb@GW$KiL#5jy5 +S|0imjAm7ps1-= +-8>@SmPW1J%qj|L|vNCD`J7|`c_pDj+Iqc85WMEr-47gj? +3l6z)`(bGAp;>r4Ubu7YHoKuVyOH1k^#mCjmCV!A<6RPWz~w(ti%9Kfg>baT0!ET(i>^?7FAOH}%<9% +@y;SDWo@Y-*+L4vmtwN@iYA?*IJPs>-P4;^1z-TEgAK +k2D{)tx7+ihBfY{IBPn<(+x22G_7+@&xb_xjunrX^Pvru@inAH;vWkq(!ZdNVGw +6wQf*y`0IWy!_8J(y*0qCqB&$vxlbH7iGUo3nJ%irxAM;sJ!wi^Jy!r!(7O;@Pdf=f>p&Ff64kI|;&3 +i)Gr`&Gg(y=(9dKwO-lo7T1q4+?sSr-+INPtlhQRV<@8ubd)$_iDNa*`Iy>$F@gc +nz8d^opjD1!sPp;-x2Ek>X`u&Ee>r10F&XV|bkiI#e`?ri>kAS&s8f@p=h{vA{G-=!G|Fw)rWqX4wUY +mEq37g!Mkt3pj077cq=7rZ>j2(hibPQ$=ivbR02coM|)~IeNN!$hC3s~l8$@orM&H(YKnF|h6m>NJ{}Fs +uTwNS8}k+$YG?DQpK22v&F1O5BgjMw%_?A+5Bcu~g1a-@JIkvT9Bfq-n@u=sFh3C_OUhcS=`9i+1;xa +YQ9~nYT$2H@vtU6AAXwaWiIey7DgxRQ%;RnIwMuksKp(T|{RHRzuXl&O!XFzyc#j5&J#c?da%agPqvGISIuEL?m%Xv=k5mUE?T$p`H0ejZOPSW9 +o9o^YU1kx2j8hM}7m)5tFWU5|0cE1>a*&iwW$7IP>kAbCgz&$JO +p&jg?Sjg?KJmR&$jURp^eiy{O{#lsd*B+4k7u=7-W2Zq&mb1W!G5b?R+F64o>D2uEld3ju8PZvy>&)N +C+~1fyEn&@x^OVMD}76>G>uZ@J$I*0|jEhGZgjZDyOpv5r$NW$Yk=2*qEHcFz=w5aZQ9gn(mwOjz2gVaH8ke1Rk +A(mK=wWX)yF{d6ox@K@bme^AofO6wo*a+8ZQh?@}U>HsQL88>d*LJLn&_I5`n>(MsfdFaS)_v^ZEQ}^ +wa3a|M%;j9coCmE?J-NrC+wvTJt7DktqI$1-Aq?x{paQwqK4J?t15uHA!rZF-8{q(V3H8x*9 +Y7e1g`DKZlnZLOoHve??yM;cY+X#5B_^E*Bg>2)1?q~8=B9Ga+N +zx`?clh8{gn@4`l;iY&1lA>yM2Xd`kNH +@7e2;06wZu3oV;Z7*}OV%+wZ%jvwR8gA{Vy_-^}r^{e|?`?^hxOE^NUjji +(+URw_X+tWcNwE)(ua(aWFwJSg^roX4n5;UDS8iPGb#MF1oqWQT8O6yL9l{{ +P;7jF*YHAEt5s3TFrG?7d~p#7oE)wh|eAp!fvzBxq0BnaZ(Vc~VUx6o=`kplAhCSN8iaZwmLUcRO9WM +})S5amjP*;vHfeS(NlYCOpp7vWEkI2JU=CIIR25Mr1}VoDESL>Tf1^ogUjYeX13Qo#?x5vQpyqdKt@d +dFz9Bd|w-Ded_>TM{&ED>?&%HO}#N4yUnjf`pYpin(3Ms)%ALVG^!EhrJ+ZBTWhuB{ayZTMilP|EZ}uKtXwrZ2eh(F3)nDA4zkiQm0q@ +`A@Yhvl+*Z)&o_t0{RiQ2nW=&0FzJE`f5xSj2H`GR(Cci2I;Yk{&)nkO4Ir!@681l0)FmC9=8jw#7rFBps8}vN^Lp%q1))ncqXgRkYyGx;J$a+WhG5g;PG`*W!qj#-SS<(QGaI2!pZ>-Vtp+yZn{O5WM+6k9H1DOa_`wDe +I|{|l>>8s53fka5UE)1C7_Vb=J|1LtM0vdGq(=FO}`ahAQT>R2W2eS2_xba?btXLxlRZ}F0HD!7N2_N +tqN!Ps)QdpeIMuy=KC6!Jln#9jBWT7Wlye10P&Fx}aS!we4+@>v9XNkJzN2Vy1EG$8@c>-bjj*zcmz+ +0&33rhX*3K^Bxi;kdUQ{zQ-KJ@&X(a~2*Ip)bPYQ6M_r{;`({BuDpxQPAS$;difRBG<3x*t}5}O=EID +A(1F0_zxWpvzMzIps?X;_0SZg67W9Wjwd3zJ#e)3P_siY<%Ck#ZyS>?OhK_PeJTct@$=9^*&+XuGzhw +Oosb7l%;{reSbbNbN*q%Gk9AiMaU4bDIaYeVJ#;rlpJ}(@2)3gpyoda25b?BgC5%7PtQt5fI?J}+%9CTMGz +b9eo0Z{%8Gp9fDTvyr5k(M8oYA^ra2z;rXlI`7oR5M_5AC;l7G=Qp-+Wyjti0IVVrgevo%ex}^=_s^T +<&KaZQh2wLeJ@_&o5msS&lIs3m7&n+bJ5H0suazdkj*g#f?*bX*PVtP{~2<_Zt;)1UiF^2FxDpP}*kS +efJ$}t}$9#>m=L+(ZmvM@><?nB1PH096zfm_ebF_zO=!yy#_bNNSyTSy +*l3@OlN@NsYVh8txkTj-v578E#t7qpfC~-3osTN+b2fX&jOMi-YB3FuR+F^Vr@ZYH|0V9n1=o88y^>y +{nC5F^MaekU5DM$+Wq2ydRa0N%mq9#wB^Q6z!NZx8U2akv$c9X|0*73PcQFpu!!1bQ0)&y0Qb^7?vqE +$O-aDf+;Gv~W;n=!c}z;rG|;$0kjcE>n8*U?6rQ{2^yH|n)c9e&{0pEb0K7YwYbc7KL68T@fhk1KOML +Q!HNMhM@+;2&n02K8XY)@s*9-_{juF##8GCdF99LpnZDi@k@p3Nn9Np}SHYJm{pCjRyh%~wbUDhJ&hZkW-{ +jbKT4EN(!Ify`Al2BhaLCH@{3H9kDKlzCveIx1go^H*NQ2Rws$&Pic&Cc{v!#X|P6KXAc?)IxTpTVLM +4Bp|OV&^15^`7U0d>!i0Z_=|U<^$JH#VkegdK0riw3YJ&RJtdO^0O$A~|%U$pmtw>&oD;ixW(4cM(e>Pz{bnKG*#&H? +;kge{`cRc@rzBBkYbZ0Q&oskj5#Hb@H!ibT3R_&uV<$RFAh!*C_(G!;58=WMaz3U`KDL}H1bL{dKp&q +@2TyZa`LO-RZbN=?Xsz05j2#@AOFwEnwipaB94FcG#?r~c|xPlkTcR8bb_>x0whf0`Y4G8O;wL-s}d!xa8Idh$zEVgZTR*Z%D36e`7rC+}XrJ~;lqXVmFWJLBD_&;IkH!mv9#Ro_Cq{c3hJJ3cslgJ +7ael;ULZ<7R{`Xcu-Bunvx1VB_zTuV>$%=o$j}qiO@h)(K?Q25=smWPY$IXi1~7eE(5qV;;SjeWwNyW +|h7Vl2!)5!X8sI~CWqv=rkTSX|ZFBB3sl(UPPoDxgI|3zn!>EJ{?xSm9!d+~exsK6Ozh(S|Y)6KM@^o|C +vOt1vIKi{IgY$TfonoO$eciPz>0dNI8QDf0heJp~CwRlDTK=D!BDwq)FJxSypV(L2 +!Q%Pc^-GC=x8RFp{*$2R@=AV;RG$Ro2D@MnyHOPx}-D$o$bjOo3#yu=4_Y%B09Zf4oeVS6$)D(rtDK+ +b#z}G%D%6tT4s8VH5N_USR#8jQi0r&O-kboLES(QMaye3#(kw6$isSZK+la_0#97-{E72Y$0P-mon1V +l!%;FGQG#6EGLQoOf!yg^RX8guYQ7?$)gvlg;PB28bZMbV|sX7&;aV+g>sX9gL+!ecEX=+V2YOSt=)_ +)t2jxI9w>PU>LzHE6bNhvWpR#I*{NUMz6XxbHsw{QxLFGVwj9(h092u^@v-WH6`riA4y;X=s%hVZn$> +(x7jP)s!H}h7AtsjsRU(e?$N1_lE&HH|(6Wls4AU!E!+~Y)lWXemQ|0~zzif7o(-~)2AZk=Bp-7E@hz +n3wWlc$pL^U3H%lB@%v272u(jSy%isc&U0t;0GaiY_8mU)RcBjzRkCA;DV05wb^V(Cw|DoE;Yx28b>91XLljZkw5H?KrZ7cEhqzYh}KDp7fo-l0f!Rd12x)>~YE*ap3? +jb2a4IyHp4h&I)#o^x5hDehKECiSaBrmkKbDm88O`=}Jk!kVeUJCLVLdBj@n#PD__D+TN8iaXPuPLZ` +mtRq42>-ydnU;8CBr6-YRt^_Y`P7QAZ1%y}?5MG`eb$OyXE*f5DL9iSt>Vhf-*^Biw?$FKw4m!<88 +=^r)30EASY@QvU@1C;H6wo-rf6CdP>=8jb<+Nu2Dw1!RW_1mknS4QOdufc#-`TF_E1&*k +dmzjwdL91xS2O(2KzfN`sTga{Cj3K#2scHLsvLqloika6Hv}CRS*0Ii)6F@Q8e^GaH+MWg)HtyKFO}b +l9)msSzEoGV%_E}p+P-&R41*(iPw=qz3#ofp9swg0H_Ly&=r +GNiciqc{U2nCZYd(CxJoeTuVXk0UJ32Se{KCH`A6$E#3Wz=>+jKV!6SpNr?cYb+!I3h(-lNNuWqqUvo +O*`T?mIT>?xhFu?EpO?|~bopVc|`$Lyz%y_(ks2YYtro#EjLIb`4L@D?YajdZNQybqB{ZO +!2@mH#zk5t{jjV1Lu@QRa5FYw5Sh``o|xo!OPHpk+0dOB@ATo1z=IAa2VFGf)q&jln4xq8b>-jaP#$T +TWa`6b*$(EAXv#MP^+uA>XW$PcCN6;6d6708&X}1b%%Pmc68Q>96KN2zL1vWY#juZY8;zr4ps+Z|^hg8P1J@WGq1v|i2_Sj%j96Kico>LgHVS$I7*GI&!`ihMTqU;fr +nQSZC@AGEfasaL^)Vri>nOj%8(NLc_9;;*lRWmx*nMD;7FhgcCGU +`!f??ld%Y4UiEoLRwXcss@fbrU`jAYG8FvISC#r{F@RwI;X+p}f?N~BR1;vU;@)0b^RnMVGK}yr(k_5 +ZyKL}NZNfNnHe+YLvgi6~QnL&TU#FP4pm+IL<}+C{?u8{8++b;~d%wFve?)88UtwsVzla=*ek9+5>g( +X_#ln>{?$FfK2E9yjY3Mp3*|A64q{%4{?Iw( +@*cV*~@31Vu5X56a}Nx|joUE%Fkpbc5zM=Mw22U|757f>Yr=95pkyaRZ!25+UGPeB78@6F~>}`0rm2m +44(Naqi(JIrNhacRUu6b=K+#u7ZX45-6SO`va>Q6y(m~G;=_|*1g>Ue6?2*32caW4X1>1Y~U?WTf2u4zbCbafriC!wPd(P_ +scgr8BT#0V%Vz{W0YpTkb1Pryxs%BGNu +pO$P=awuIG{(b6MrUFx383gdoy640G+v{O#{;2jWba>wbt3-q38y6ePS@zMnPOAc&k`sUEZ`QOKr9(Z +^kgDT?JQHf?F4(Vr7J8LtmC=?&rV)q76p_w1WcersI|DaY~jqtmC|VfEhxaZ@gDx8P7`cRs()#H%6l0 ++=*x6c(J~nZ7Wk$$`0{Ai=s|-2I}vWnWwRgqY%fuxijO5kexV?^ytLy1aq=NA2l0$F+3wz?p7c^%bW0 +bbn#o7YSm~XAa$ynbDz8p4bOhEziKA?eDsOnI9Z63)f2NLML@li`)bk?-RFS~|7!Nt!E=nme*0E@5Xw +&&us8NN;;Tg-36DKNCoA*M2IHTDf6D{x|hLTC%LIdL)_jrOkPRarSMEdY=4u)RnW!g6R5!kv +oK?BsvCcEfmctq8;PdZ&uz~jRtMgS_Zsv+bZ;0A!by8f|~dG98hfI*h+*GenZ#hK#6IZWpVu}PH}C7N +Bx(h`QBrWp+Txt=;$v0L=`Qw?f4+AjP0di{!oBBnBx{KURByBa;L4(213<{)GIUHzxml5rg%&7o4YHX +1+uiasu#^Aug+RuMtF-Lk-98|lOd$!zj`H*h?o2}-7A5;Tk(zV@(1!`*pc_t>khUiFUOI25UBciA +;vL<;JjEWsfZ@?{WiDiS`#W2lXFTgB-~{qLFis$#;;+5*6VDS*U3D6U<%HkW9C)7j6;3hHAmoRz0v`$p7vbLkE +2o;jN|f3Fbnps!n23e~VFy+}wmkw$j@p|rLm2?sYO#znD+>(tomI_~w3+8QvFjLw6}sT}cZZBr+;9}t +vhN$tVXP^=#{TYt_00v9Q8JJy%%cM7M)U3%|*@(+J +V9fTu+{P8xFo(rkK-IM4puBM#pAbJsAN{tY;2{yT?d3w|3Y}v0ju1UlF$@vDeP3%spRF}rnyhL>(ema +)GHeu`k$`XxHTvnn^tA**lrbF;$1~5{4Y>T0|XQR000O8@1eFv?_5JroeBT|z$E|xAOHXWaA|NaUv_0~W +N&gWWNCABY-wUIa%FRGb#h~6b1rasty*o5+qe<_?q9*iI9R@V)y=&Ch0#Tuq{(4{G&y9G0_|d<&=zGg +D@%e%W!E{}fA7qYlt@W->|Bi?D~U71;qaLk4K-yK-(RqGnaX0bWR1=){)$f~)5(;*D64%fH(Sl37jyQ +*<h7ri*~oAa#z*;rqMEYw`v>Q?OQs%uS9$EMONl&Vib&>UjLLz=W_M(aV;t|g +dIkij%3Z(TahMJT~?yj`vuzwozTN%#g$mFitBBnOZzO9^@6>?%gF>60cO2&tBHa2H9d=xq~JR+(0nqP +5F=2%DGR~iH)ZQua19&xuoVR>gh)k-bU9awy%VZz>b0ObBKm*6oFHE+GBCX?q)w7Zi9A~{)bI-BS`z% +pj2<(oXvS{9%>4m|3P8nY!4zPj*dToP=TfG?p&FqW;N^$-amkcuF*ODJ{d5@zqG*yU*t!@k6n`pZ5rw +vk<_nx7n$>nq7c@4T&s#yN0jo#Bnt=z_Hjmq-qA0MVGl5iz(mWT|1WvZuD9;X0o;+!jMjCTVAIOAim1Qjx8@b`Ikz=2Q`nY+0KcOVXi$sV0N`y?_Gh19TyqSP&^R4Cmt%tJl#2Xs4rFMvR`RLA6rM~Jk_%{- +K6eD2Bs%^w(=$tNd^v<}~M^}aqtG?X=E4>hDE0?BHxF~Ic@4%2Unu7t6Z?z!)i8XT( +N98EB>;WW^VP4Y5IZl8F7OI@Ejv(x%ve8^Kb$%5MHp}Hj>@U7+BF}nZb*sB54SrqO5m3&-XR}Xi2GYwP%e2?Xj$YJlAMe +!=A$f7~sU)k07sTl^-FgN|<%W3(!Rc8yyEL0a#%<#AQK7dIe>R=rHpf76VmOsz8Gsz)h|s6gT@WNOD9 +av7=_D~@Nitgy{^lWPua0#|bVLrp9;M8%gzc2)>8D2N&LIY+s5Q2m0{ko|Vw1)? +LFnzi7-zAh7v85(&_b!sraxaU>HPsi1;yhU%6fb?!W?Hx&cfC3P}6$?atVRODU=XoMdiD!RIVV40yP% +Kx#mkFM{Ua{PhlDe;9FindSt!1jG-$q@oM&$*^&Cl5cxDvHfrTnY@|S}DgZuMsG5g_F(?e+k1iM8#`< +w&tor(%I0w;&_=A0QHC4A+i1L%R+tx{_e$ZjJcpwv)Fh +SIvUG%75pMhBusic&j!hS4XDdXu&3>Zsxt&%i+R!Nfg*VICQkN<~zjmk%P1vH`S=vg}V+7s2`RbV8Z<@xMOKugza=SC?`ELUpnqc-TRvW|x7dEV@-ugApN6^Fz6| +G(Rj$}m_GboHk)`YeP9eqpx@T!AR58<#hCn!Hl&+ydh9r(DsqGP>hKQnl*+5l^41f>jhcH0FmMhBso` +zTgkjUA*pSMhu#M#0%nTJPHp3mB<7$kBFg}2%KrJwg`<{jX977cf#FB*i)3Nyzbp{=4G3a`KB)fFHxAHCq +UxvDZ!qZTYpmsF7M&g%sUDij$(ralyFPqVj%QU0oRIHj!G^3qk83%KxOZHt2|7K=QivXdvzjVaxV{#w +L`u;q*N7CjgMUZX39gi6O_8x)61r4i^hfRlguQ_;D2KIx!)d;z;({VI4o>(TxGJcK@;e5&Pw +8=);a9CK`JA!y+w|@+aK@F&h%$aeU76W@4o80cV#jLZG7N^A@g3cK5U$!1`e +0ZXI{pg4aUbT0esH<1LVI=Vig^m*+P)welPuWN`R(Q1oMD=zw=}uii4>b`4BRJAYZ10OC7Sc;*Bm#jZ +vGD$;ty>0Ih!|#;pfKhuf*;Hal2>5#FS&;I~%A&srdViXz|rOGUs`{mdk?1y9&W8XO_dNaPs?P(k|5= +bS7C{ei21tZgaUZMQBfz+W}d8V+H5pHHEo5?_KIu*IGV763Q?fBQmUIqiZ53+b-BMZO*F&-CJ~3Pzgg +tZ2DU`8O&-Xk6fu{b-@>1$2HK8jBOa^cWs;8@N|3R`jfx?Zl|;}*>3ls;HHiC4#m96n={K~YVG!nke- +=SF8_opBz9+E!=p3T_;&r8_GmK@(6+rZ_Z+LTV3o^Zm<+~mEu->_OJDk=FEh8;DI;mn*wc!Jc4cm4Z* +nhWX>)XJX<{#PV{&P5baO6nd9502Z`(NXyMG01Um&Tql|J^0Ua)R2+f4ui*)(X_?saqiIn6ddsww-Epa&HydUI|Nht3miL(WH|Ka@Vq +9|#4CIf=iUQI*90A;t@5acTTMDnRkM(#!x{sbhlTya>l#U6@qFb8X27>`o4ji6VEC>PgOnvjCD2q2Vi +U2D5_2l&U)7e$@+wuAA^yKmiCU~AV`1#%4CMB@80AWpsFT&?TQqemde!4oHycq)LKqzsVXLLH;Q89e? +cJOm71l`Qj9fA3om<~&x9f@R3H?f#(Si*Aw$}j=e9>ro4-o6-;O`NeM74oya*xLcAQOy>>4JLQacJR+ +|Knk7%qeae-d9r3GmXgD6zPx!2gGl9ccp%`X+!gS1%d%H5hlg(mfc?p2LNw;(PAO|#6e&xzb_(Dq$0a +%aqhwqur3lGng8Kq}5ptF-^GDM7N>Njx#NUV&D5i@G&Tc^kR#Z5jPn1MqBWLuMrX6iFgKAMQbWXfJ(O?;eD8Sh4sm$UFo?V1*A#F(N=razog%vS21i5~nFxHoPFSmW&IqE +|yWUWpWMQ00eXwbRR`DIGugGyo%0d=O@v}6VNG6l{vwt{JHm^(Ub6Lp)haXT|b}vBmDN%zb0ShxA1B3 +?r&Z&xP1R{c5xM5o&0ujc6@cBm2$MlLBTdFjV4oojG|2pb`W_-%3>P(9i!E&Zwm@@&`#4^>TmKziMF# +Wvm`jGtt^W4%qTJtK|KWTuqD74>Jf3R|NmA)6fu_qU=U|0K(VCngC0AQ7|lpL2B>seuu7yk +30fn9=YEWon$@R8#NI(YO4KxMB5Mv)m%O+Pr71`pB^^VRM3^KV*GqMZBO^Cuz!g^*vvVz>S8*AUzc3T +F(W7~6A#L9FyvCP +<+m6t(a-1K!RHvQ84ic)|6`&7AqplCI0?uv;WU<%XpRb^LV=DF^*4k98$&;?*Dq+omc}EA&{;vxi6q? +=DdL@ymc5Q@3LFjOb8rt>&k3CkKHmNC?ILDS{f>@8X_2ul(K4Pi$8ju(q4jX_>(@Ws`U095;m-Wro_)hh^|UGsv;Nc&N2oCd>eBXXUciNJl{ua^ +S*??dqE2@(tJhx(LX@0c0S=7F$9*7k#%tj_LYIwSc!v?x}8bn%Fcu(G4QkIBjysmw<;OzO))A^>6uMi +COy|vEi%xA40a1pn9dll*en@1;0kn^K{5pzo`AjTc!A6?k;8K*IJ#b~@jYjmuUGE)!)8K@LB=>Lp43? +$h)YJ=J5A>(7Q>CUX4CACGFL{4_F=P6$*o!UXg>ihNEfiiuXt}16dX)E+)8OfCL+z%XkM~(;Rp9@%}qJ|z{P74(0egB(rGq}3;KhlHNB@k#n0 +)W#%ZY6~6nOU7&2^UFzsfJO^IvBld$wHfQt#8>kK*&m$IID=^M}a3cN?16pvPz*(zgB1q0cQ0Y~Q$4I +bkWlb1v8-^P~x0J8%n*Q(@pOp+Jx$yU2 +P-5j<;m}>#3A!c^{xEwl_i)3*k^x24V}C#_*cm0GzrQ#liyTP>vdK~?Hvtq1mO*gYQj#i4WQRbNS<5v +PmdG>XYcRoHP{5$JPzp?BRD# +&1C1FGKS;7DyS3AbKWXeVg~B?IZjJG+I6p<%`pFf2WS{bu)B3_8_Mfz*r4l;jO?&1RTiR}QZY%O`UM1 +4R3|=~Z){EPGCdgoS$!ao=(-w5Q@$vyL&MB+7FhlX0|AoFxv#is;Pz5aJ +$9U(1B!BkWC7XIkZK^9DR6`m*6Wx_!VR?x%K)7YQDufRsI_0nKcoO7?WBOhF5cJrRws{Kme<)je+IVC +03P0xMf&RQBcoDhbL&EDKjs7gPBQK?G;-d%GxsS#pvp@dYNYq$UVs*n&zF<_1VtrT1=Z_rHj=^-;?dK +q_e;ykhE(XAt4|^@U6PrzB{ZkBh!QSH7t}#fCRfFKbGC)e=Kzu1YrHTT^0hluI$}aey}21#4^S`t2Hq +9yhYE^+D=OrHLcHj#ZsYl+FeRxAU9BY=k7l*rPilb8R2#cv{DCc$?jJmd>}cZ?E)3Oi&--0Oh8=;b=H +6~@IB;V&_(R-JL`-$W8MKaohW)n^RWZm8y6Jct*(HUZ!~8aq}b|PMa6w0#;4tB>tAaGwI{=VFs_6C+) +4DwL}mKwz-X=n35*YW5$R)!a2xXs(D& +F``@0c?p6$MiHshSv72I!Rh?@5hC**C#<~|P_xG7a4+QJv>cxTJGlheDkQd5v@)ZHuYk`$C#Fr0aQRw +U>`*WnA3Y4uvi9b+>$N_fy_c~ +2{@YI)OWmiN08ttrFZB^s-5&lv*T`e`szc$N#Yqch;geZ)Q0%X?2hbGIyHnE#znG;91$o02QJj9VMa|}L@XwCA#E>(=h?_FlQ`$d?&X3YJ!WEBLu6xh2FV?8=?cl^6Xq9kNG@J<%$sWy_+sP9Weje0B=zH0-B;me;z;nl4}qx(A%nxk+$ +ersV5fB!%5PxdZw^y*u0H&N&I`;G(J-8B>xq|@6*m;1V~2FmK~DA~FdOSAb-#nP!&EQ7>@IM*OMbF5v +*i|?f>-dblwmC|)nPy4{kzO`XCZ1M2132dj}>tL$d_|2h~$+3uEQo5MO`liBGHOF-4&TX*i{od2wS}NyBvzkX9pLe@kvkyHz6k7!5ylqdDrL!Ws{rk+JK +6g^J5=>}aJMxzy5{sj)_yoa>-uTbkQHz6LRc*#8X{P#}n1J*&z&*8VD+xFdN2nxBs2X5X$eqptd||Q! +(3yu)KgB607SRelRAz%BFbQQaF4zu}s!zwD#qbP<{0qis~c9x%ZWS#S=x<6%IO#P!oHiW91v +1)4l3(qoG0(u6SM+{)+%lXfd9*4OnCBC{|D5uJSX{DY$KGSB_34OKpp9<9{GU`s>r93Zkp*MyFV|%zd +x&Jm}0cYm6V7yw$0tA#ATwwOnbhhC9^lwcPs>mfnNm-duEEA6cWXyU(^1cY31be$I7fbtl<}?sYKPo1 +XW?-0SR{6>GKcK;vvj+ZNgP>aQC5XTibma=EMHw2_30hI=}>Euk4q<_#4UxQAG?uKQHpyNgK_0}+n(?qZzkPBaU0n+m3NbT+QPZQWfM^NfI3lRMJCs&{P6|jPS_0olIiqxj9<>NN +TYKp5d)zRv!`ebz-^9APb7+B)D$kS5dVQ_L2uPD)}D&!L_Bp4<62E!b~TfS*5*)6RuBtzc7A?dG>I8z +r;!lrBZpi$ym1j8>ElaxjqRF2jKxzmCfDi)H&_c>5Pfg?fjF<~Ef*v4K +{OkCSK2`02T)a4be)afr|xR$2NwJt=f6JBW@A=*-{9Wf~3b)%e`-P6v!a^I0a>&^sD0r8>^waP~2ES); +aRgI>Qx+l_WEOvWje`BOm^c!2LL0zMWHef-lNPDegf4{|M|J8=^pV0<&@6$0oY!kTq+>^*bbjL)_oGhaI>2*BaliNm8{{v7<0|XQR000O8@1eFvB1ne5o3sD`0A +>LI8vpxP{+6b1KiKrZxAMR7z{3xJTgv~ZjrmRT!}$+AoL_!#ZT`2uydZpPGOwTZYMF3FT(O5?a=5cpRk?!Zm(u(Cvh8u*>Wamn#Ki8t47V#EucGyxqQEesH0N8TeZ_Al=m$ +1P?>nz-j(e}kycnYdO!WzRu+t^@PPCH$NjRv +D3hBDe<#MmLA{P!4KVJF`B5-;yz&C3vw3)jP-btpfme;g#^S1%;R;xh+ZalnKeFbj +m-*4gn|L_0Fzt!YY%OxHdVQ*l3DQA0Ab;gutfs>sfr`4s)mQXM@r0ZTCbc7fA#YHdO%yG&a*+zoPd+D +-+qrV4^RoWdcdc=x}7N1Ga;d&e#sgBv+rY$KP*A*dE1-!?mhbm&)0+)Csxo<`(=c=I@7M3H}E=@m#Q6 +$YS$Vns`sx*=E0--P*Dqj!_wl|+3osAK|R=G6KO6wk~_8_@l7b3 +J^7Px~}WKB#$n~=(`g@!QmSiOLbmKjt%R&@k +F48eyzP(eL=u0Mjb)n|&%P){-p|I2JjFLWW=Mj(v-cA3MiuLpps0uXYkiD}mQBk6rGNT$d*3eHMWHt0 +d4QBx}(rs%Go)@2L_s)lgxaew(yIfe`?@KnJhP7JOCSpCb84@)6A-~4~yCjC=+L2U1 +L|oP5Sg40s2^(%lVRgCaBD%O9go@J!diYd|z-tw&*zv5F(l)n<_|0Lqyq8z;p8Wy&DQkIq2~;9|z!80 +I{_@Sm$1dwp>DO1D#>hJsv%09+uS|Dlf3Od|TkP#pO$@)pH6U8VayLftD?DGGy11Z0+7HtUdFfJuSNn +{K(%6IIgaa<=kxKxhQ#?E7yYP_F}5ldZZB5Nb7 +L%%HWLeI2Z$~9eAV8I_5{G;b&L)-jCvn2lIe2sU!Jj)>->8f$j_d#N8=j-b15jm~X8TdAIjW#W`#iWU +>b?1|eN>eM^QUdL=rpf^?O4bonHEtkx5f)p5p;=P0Dz|EBm7UJk2OwNYs#{z0Od;nUSBIhB=snOLCUB +RbdB6zs2aq_su0ktAyRcZBUPs=s_dSx+HqL)FQ?mH4rc0@%_G3+-Yf0n^WE?`8ma}a4Vz#>08Hg#6=e +9Ve$rVM@<^M)P&h~B@h?96WgVnNFn^JFR6T;5)K9_(UyfO;*ylE_K$hq6)R_k}ub099N({F1puJ?QYF +c9ys-$7oC+U?~A<54d{6mj~MH*!IVw^<#5GxC+fFo_c9?lBSF#MwF~;uvuTpd%6y9pmv++I0ZNPqNBnB%0~VM?fE+B^a_DgZdS8MrB_|alPr6tbxJ8GjVGD&Cxc +R}+#;va$G|93Q%D7GPhOA0Js!@>mx`Hfd+Nt2nbocjwlT9lkbKiWdZbotdzVmzmzk}Wj>y!Ed*XsHpVzNy$wHA=LHm3 +w~O9~!MaW-4zoJV!2W2yz{z();aWQ6{1VWui@2e-MXi8}o>R^=x;&9?nSn!;F><(Q{tP5#9sRE*9B1H +O!|H?4-xcq&jSkF!HpGCOTkMQU6X<-%1&E~6*;rV0Ocj8fUD%rS*qRkkn6mK#w#dHdd1%eHS%A`F+el +-|>_%e}_@^O7ofoJFu>jCJ8TJevHx!}__lV!yi)sf{XeEw#C9RCUxwH%X4c~M+sT}MlaIZL8SBiw$i! +@ZCCOHd83Vp4aVF+_+c}mnQXSiuCk{_u7O)^y|9is9{-*sBON4kUOCHZgml+(TmGQCnWo(tZ9hY&K$yWwdB1Rty+?laK3VsZ@JW;e&n{(8yKg(;4AUQwX1`M0H89cSt-GnWWwZ*_XCl*#a4MyweDHN9djRfG1R9nFBPHk|_ts>5H +%~S`HFFs)Jbj?0rqMT87s{-P@*+cM6Y%uOusBYYi>GjpJHYS~##5>a=vFBj2s(R6!>;Tvq~0G`o4C(r +$IpNw*;z?0)^dBeX+{aFFt=sBMSon^3&YS*R#5-fS#~3@YgFE9LAjC*r8ZB9= +V3^``Bm@}_%F0nUmFQM&)n(Ih63o$Hn5s&Nq4wMAgc<5!K3KiOF3=n%2Cr@$EA~jE~&)E~4TH#8bJFCB(_@VaKaV)#070tR?XEpYLDh`jB5+qwcvya^ +Lo6K+2)H7V32-5zhlMTPQB<2__3{IOvE6TYnGKWS4Nm3CgrO5|`r4*9QZBMAE!l5RWB+REB!J2}!ksf +XMX1L)beYtrO!uN6Km@R_6?8^PE>*uWQ_pilg$Plk%oqEPEE*xJDqXCpQk7kTuBDJW$VQ8C~@ddn1MV +cOcY?EooTm{DMlNat+rMbnMX<8;wI=r{;aKqlS53dn^5w71mySkVkQpSng0^$nx?_u{xli&hxwe;;T? +D~y11mtolYH+0w!0oe#DjG9q0;sLyE1NLEgD(#yLB~NU0<3F{CZlBC>CY@S=7cFXIsH7(523gcp6i;Y +SDm@5*glkMl4UAd9%C)54f~LG$9R>W0o2}B!;^u5A&wf&#L3cq8uy#F0Ydkb-a-2Mk4QpYbl5_2YQl@ +fDx1AZ3t;NpltuvJ&UCOBS)X+t%SaSj3&?tayza-68@z>4SgB2DFm@(iKl0QiTsmKLSOiS%__Tw}KSP ++4WP+=TMDu;m@IIcw8y$FJ2$ll!q{-?b;CVuZY;-%jKt`GQZw5*onZr;h8mYABOg?|F--rO7`&3(O30 +hGPIzsajK_jA&WLqM9xZD;K7Z%rfNL2&89S}KX)N2KtmmT?f1?cLjwNW|`hI(`Vbq0^#n`tp4s<1YHE +nz%&|Ga37We?hcVCD4<2N2BC{B>dtU@ +5unj29;5mrUfo|l0&+lV3(QA`94!gUP1M7!#_coz#jF8yXhC%Q~9Q4d2mVmVv7y;#nb7mY<{eY}o`CnY$XF(Dn880QQ6-W`m0bLlL!Zd +L4-+%e``3v*?&N3ngf!S))<)^K%%hu +=j07m15b#V5L8(^+GLu^ooJ$K$*oMZ>yyzTt?4HQiiT;7ek;=x66T`}j%2;r1VmRhDR&fAB89^st0b~CD`%X3EPvB`u|eg0mKD{kb$oQgG@)kfZDs&& +zYMpxS-sx!LdEb)Mn7XVro3YYP{x1t!Pl6%4S?koI4mHP*dnx#^*I!5FeQY)KLN%>?(_>+`@^4od8G> +M$HpL%2*>GR)}E+^~Ge%tw__H#{N6xT=PJmT!{{Qyu4oO$$fIzA^sq~7nrV_=!ZBnDo==6ZPhSy@o)` ++Hx&U_I7W7&adb4<$oYp}c3YQc%pq%&J`g)o%AC`Pih=Mnh!n&ZwMEmIjK5RoSv<(!?g2A)X=(OyyobkehL?3B4VekH7AR$cx%^k+?uMQjQY;jhYGC0PxA{CYw71>G;O-R +&%#XhL?e6BQGO=^Wj&T`WTh@}Y(rHxju&P@lwiiT`;f%ff!(h~z1ZQ_e2Y5a?Vl=Tv}SWfM%$VF-x66 +&V^Qq45u@Vz*}2Q)*?_f&W}2{$l-<*q=xx8DAhcF&nGw%xxPKho|cFjClurF2C%Ny&Rd%hkzH{ +bbl32u%-I&OCLeg+ySCWNpvKwtp9_Qj~MFDg+zUjuhww3d|m#pa4U +J{$kt+1uTGrL$Y9D(4J-}A>yWQ^Yg}Ih=1X_cdoeBCWGaH{ +dR(wvg;B%3H&k`PLKrWWZOlA_C$tJ)@i~nekUmfqo0sF5WDI#WamK(R$51&5`t15PhGq)eJ3C +Ttn)<67H!P(c&b2L45>7{H-{tOVsWtY(3Fg2GUr9ZQ05fB;MOCA1vn`83i8o!p*p?~^R_HTLbW_sN-P +As=lpxHHvFAI48GH*tvbhygUCaYkrKsM4fnk(IfH(dG6bbtS)Zng=H}=s(r7kpV_bty(#j54EDeZYR| +igDF5x!+6N-fv3jU1AM-e?Mteyt)a((qh}ulb%J)p9H_OeT4)uti8g(i2YQoLcX?f+y5i +=TloqFxhJ(x;l;p;>4PB9eQqUGD%65U13iRdtqZwpeYm#mfUv1Yc;*s_m7u|{@2bwmrIV~lkrzFORK5 +YW2wzfG1z1l(#phjJyLrKjR?(t6(-U5un4p5(c3zeHvw8A#CUM-N5v>Ec1K}LB3y*CrkE +&7@)l9T)IrW>%pW`TSBT~vs1d3ZEw^nw<1LQpZbgWZBwUnulE&Sf5W1)qmM#Aomzd-k#C3HGGyd5S&T ++4C4Y>BpL`2M6Ruw9}H%t#MPBRc2odI{1!WFlqrZ +-An6MaCo@y<0PE2t@)olLe=yn(L?iG@@+dnni5x{EPz*i@)Ub8g-xmX@|Jo*~p>D)H)We>?hiB_kpTj +e7MhwgVe9Dx=2*9b&z5y?BcLv0@9i5-Qc+IwP;*q1`5&wP=MWsiy4QRY=z}7Av34~8UlrJ?L1)DDTBb +-_di{JYdNSIy_Ty_UQhmdkW-aU-SjC2PWNe?h$9$-X1fW++G3fZ6@h2~55DAX+7p-@4ZQ&}nHKu8RFa +9uHk@Ivp3k#D~D?vZa(uMNIi*f+{mZ^1}XQg1GN`>%dYp09NBMn99sWAYpWi;shF)NVXP#`PiF;>cQX|?~VS1R{k-7Mw +$uWl2A-w+b*;oz%x6@u9}%M;7uk>J4^z13Shg1@!*mXYuL-kI>-W?p=UJk9@@X`wu+ERoeel65$h;}+ +W(!0im+1q8s^rZ~WVA;1PP@Gia|5(97J``cpRO?=B@;4r=)6$1zGy+#cD3YR+%AUA}9C|oY_)uS$>lj +-JlOcS;Rk@M=LStNvl7dn8PN1q=8J~fva)ds-leI6INMngOS5WUr@2BSnbh)+^bqhert68grq;*+@Rz +)-3REtRamJZs=jsH_x&{|ttP|7d<^5Lpq2B7^%4LOF_AcZQzrhbJ?>)n_j-Ie(7zVyEoJ|t@aXC2s7Caekz<$^_zQgQ-96G?7o +EEXIHvaHPSemCqzbyuzgR}uwz286^cK}Hb#Crp$v +{#cmM{uS;^Pqhv2EKk(*NtrXl4TPKBI9jRQ(z2apK8i=!u0-}Pl%ess3IN5a~1&(n;%hq$?#x3ywWN3 +zKf>9IRDiL<&6eAG4j?Gv+tcLhB|0r%3~j-?7W*WzHI5JH=$Fo0?g(%#ItU4{*c>Bq}G_&MU01 +xn|2Kc9^0t4LoQ}0*qk|(wPyFQ)V)xL-J)~IMJC>3AR6;g2~b?gf;vp_ql34v=W$F2`^Bt6sylN28og +ncBYsaHCwY*YKKG4%Y_{kal}yXvCQfLCa4dfZ$sYk7cY?9I+I<(o*kwI4sFTuO%R{raM<6G`wJNpo{n +nsn8Mn9gTm5Mm-~x2DH&nEG+>R2l*1@XK=E}bCJYO($8UcLsU@WuU3H6=3-)+CP^e|Rm?Vue0{KSwA= +L;QwF{r^VNZ-T*uWxB(wT7=V$xgd%conuWZsz0Ob~MTdSWPqh0?8GCNc|k(p2M%m&bc*eG3dYdaF@_a +u`(>XV6>P6l~x5PvpR;VdJ$FJ%k@FUrNZ?4?6Z~2voQ#=w{OyFlUqV`9S#00J*`? +fwnT~GjsC{QIpohrS`l>?ALG*E8Q7^_p2jkV?JVvVp*9^BhIDdqn)DSb_pJJN&**{zxu{4>Tw`uoNQT +7U5Vy|b9u~+a7_Ijb6y?%v6dFDw*N^o{V)qE$b37y-xClJD+k1UTF<5?#|Y7+Xn3|VAHVEz%m*2j@i9U}mfOpc3-YnZPx0Y7_3F&IgR4+oJ(Mg%cyo0%3?}6+aF?)UQeI_Yk=nb+s}+g;wP8muDGl^`?0C*v%^ZeP#>Y8EH-hHa*)d|%Xo=yG1j*#kpSr}NTMwlbBi%G9OGJ^E^at$k(NFG~yUks +Y)2>I;vi5@%0qt~L(xxN2$F=W%CMN+!;1Eep4>TxealL>HfJudFl{pxCU!NK3kh$6~gA1hd|AMoR=wa +lKWxLOZO*^%i-&t-bfRxHNPb^l7ujKD5nBe~1H|G5!1`7NX$1j+|#KW7wOmTW=vn#A$W7+};Dk!O>r` +N^-&PldGs314XmsjkF5B)FN#i;XDQ)h!6D}u-FKM&r_PMx;%yE$8&w1P8?=}s|wm|d!%_*>vROmr8=@ +Rn+7pfDZh6u(Xi`e00eK?DDy|7w))5|&w~_8vlPlplN6dMSt=#7tvzxOH%oghM;6zxc&34hg`3Ao2iQ_|EH?u`S!wYIWQz4~BM4!< +|_iixVJjr99Z!kWepq$zx^#JfR@HijugM*K;<2sJ)K)(E1x~MvCl!@uS{QKw&cd{vzGVo*q?Q%EJYAbG?g)C5;3u;C{7w(dzXCJ`D;#!D@ +SRl1$B-sO*YUwL%8)A7JAT}C+8Sf0}Nd{DaRNL*uY6ik4Da&7#GR@kyI~j}B#tnp%q#TUO$0#VMb$1G +qOA|T*?1RIm9?{$e6+43$pqzha69_l6Z}JpALxC(zHlGUJpRWu}-e&PvWkD^c!LQOpStI*-luK3+`C8m;b>)4KvS~%2e3jv0d3t9uej?rU90>|4s*g#|_`WJ_u`+y39zPmn3xH_nmEjof +vg#ua{(7SJ2Id8Y6lEi7M?%U#aej5y%EP9(NYplj+LVi4 +uM>zsAZN=nKh&?hH~!TL~bkHq%J6RIPL)>`Z9eFrxjiUR`6Gur|}MZc657_2x{| +(6m1C7=!O2KGFlr>!CuCT0S|UVK1e++pM^5f9Xu}vDj@PuE84%?ykzL|3(9P+7F9CZ_jPruvj;jb7{h +e=Lw&1vL_)@q3U7%aBQ83t8y(69Z!IZ7snFjWsMwMu261D=Kr%|ENeuoMZZgTFvn>hnE93W7LiTiI~u9B%m}jgT~554b$4XU=pT%q +BDsdL3;v|AtP5UwP7xrJ(w7NaS^G9!xa?;f)S-; +_k6Y?(szvwvvr-x7-3=q!>H9gvg`L4b>3r-NZ&45GaU-|l3n|8l#fUa#kunRWY<9>GzmfzT=ci+0KHc ++7yYsx*LldUSH=MRpaBG^A=mwXhE~H`(%D!a3F^|F0B3WP +1@=K{o<}XBVdP2}@us?|ldYkEiwHwr(PU%Dt3%l*oedFSSKM`jYG%U(=czMNyYI=SBce`b!6-#G4p8=du2D%<{mEB_q*o_ +>8Z!vC$RV}GaWJ4UMh@PDdW&uN8twm&;wubvY~9DA9nFWP|~+eX7X8Ufgi038jH5ws=(S^u2Zrxh^nnewWg8opK~;5Dtee;C03&;ux-%PEP+$;~Ov4uG +XVqOueb!1H#!?6)Nz|QNI(Fgy@v@FxD{yA6v%-ri6cp>UlsHeYA!W2BwFHL=3ymdX-OVxLw5S!EaT$I +uat?g!TQ^e^9y&?n$U#Mv4lRfPdVnhwe}PB64aJ=24OnTRzmELS%K%a>|G8M +VI4h7>bw*jdy@*_#nXRl+u4W5gezR4CR^_-`XoGW=>Q|=K8^-gACnC$T{ +VHpMnl9Wcqvjo(;D9kF9xD)CAYxX4RGodc6Y^mBXraVEi^)}7@@^R=;ubrVT7JGLghxN%?MQ*p&dqOT +?uw2Mtl<^fLu@Vi7|Pn7qrC`&nP=sHwHZqU2WSEqt0Z^c&8KmWyT~duOZ +6&;xZ=&a1=EJ*o9g|4Ezq6RmjFz%uXkO8E617OsScLS$RzCk(h>DGkodCSJ{BeDx+(e%PDR27A|un3M +?67thz6u7Ah0m{Z#GIyVQt3Yrp`VcOh?PsZwYd6SP3iQvfy3*CP??F@V +B19Eq{hJ!@il&pCad*AxLFX;DM;)BaM9--Xr4fwe94{6kdoKaT@<6N|x?fT1yp0O4=`_TdFLkGy#u4Rj_Ib*Y(7C-KwO(oTR=u{=#BJgjZK0K=A#hH3 +giqBw=;aLbg7*G#mo?{;#sHkU5XB&8Z5BhA2zg!3eGs)9K{Fe(*5fyo#!$Xz}l+Ijwd2PHcmI`IKV8< +CK0?4EkFi5cZv@eKWOQt;!6}gXKoQEs{S(%{h0RyVCD}GH}!+OW~{hJ<8R)x0-!--%nQX_7#G>6y@HpT+M%EGI{H)7OG0(2h +Yx2cd&doO`Z)1%$%&{h3@GYNqOcV8sw0ef{ArJxbLJ^AZvMW0?pO^>is-fZ6WZyPXG@R(8A3-qiU^>D +j%EF`hGEpGlPY46k@_dyzg#RwybEd|8Z*)`J=fyYUG0K_Hz((&i;YaK&ma|JG}inf^0v+a30EkWD+@k +_OrorGbO;c%FN3%5vkj>DWMfTEdCV(TTEj3eurnJ2xK{r$J$tlWVxWO6oAN@8FU41ZkGl72l4$&)qNq +$X;KH!0&a-{=#}sk;Avke$m`pHD6Q4vaJUsdkce~q%_1jfk+&FG&uUO<+GO_4s9S!pJS|tdnE_dWtfQ +dncnJTNg)fEz4DU26amLgXwR{0s8-2PU1}{VG-kyR|HhIyF2xjh|kJjLGIKJT30pX8CbEV~XxIkN51B +N?GXIbK9r?~_cBo3>Qs65|_m2rvK;mR`Ov(oC{UdG93%6fj7#VC)0eYmmK$LU)v`Z*S*Z?TR&+!kkZO +anG2ImqvY$3j)(F4cr8vuj*5>_Mp#aFvRI+LIA>E3bS@$Y#>9??r5pQ`m>`Y6+sawy~irviFzp1)d9L +^4N5HpS)0Mw|=ud8_Y}0=SiUPOF+ZkDdTyKN0nsEWi@i`W5PF(ZD#P^H$VmYghVbp(56;c?VVDmkN4s +xW-kgRSR6016blqNUf*i`(4fdweV!2izZ{i;Jy9lX*m+#~nMM>!80>m0^7YiGUsP8v>DDXSiu>!koO8} +K%-3xUlhq(H)ynea&Jueq;I+Xi_nhZ7@46~TS1+R-(L->0})VjPMoTJ-+ozq(r#i$AH!F8(1B6q%H3O +2e0SHuCu!vEje=Ze=(j8Rk4!;1i-xL9Ou_9z1vl4Fa5I!}&*;Qw_S~T3?iHXk6+d|LxS(zqNVT=_9aD +7-kEDp-XFKV^BdE57b^hK^)on3FXX>tz)c1$-hSYj1C`im-Z&m9Abp?+aWrYAwdz~PA+Nx4Pi%dW*lF +BQ3{v&z*<_V}pPL9?hq4GWD+Pz>NKEV+lb-y_KDK$aLcHqRv +|QBY!`9Yw%%YW=0z>srfI_!|~w8>zko1OLnnZ9Yhk0k)eBi3aq{$-^S#kTU=XKxeMtM>Ji9yd38 +Gv6_W3wVh{r%W;P@^^BzG3fEol)YlJvn4F+ds42OX$kvW@Z`gT4rD1yWvMRW}z{L-1GFQ|tDy1)bZRG25FibtBcmtaHZVb~FrZ +A!pwP+_l9;z@XZoX5wdEBa}=2QeT57d`BENwi@(^U|WRcc}Pl!Q|CIJ{cKm>V^-W4oC&s<`J~NKM6Is +_)2_6T3c(0-7zq_TQpTbXI%1&UW+>c6n=$O{H(D0KlbASx*ab?VrT80Kw67L?ru)FVMa}UBu$qN_a~wN{UA)F3jrST9IZKYwhmC0HShdn}BT82fk45R?V +Rn}SsT81fCdm0)?3ChKix|Mufbn9F)5(z3n}>TQEZzm^qgmKGI-avRx%F0G&l=mA!7uDi%hYynEXhLz!-Z4V``Rajx1_6MUMdd!~8ZYQ|Y$J3ww)i{} +h3q8+Y9eXyX5gD)kg8fg@IJ`EdmQI{(oJaeU{D6C`AxF9)vZ}a*-5X$Y)9)m+`A#v|#15E%l_v&VdZG +!vIMr;^!36*emVSX=9%RpCa8il^Ln731P1oa->912Wv&Qxt7uOh5KP{aY+oG?($Z^}SOaIsy_vPqIym +4%309Upbp_fc=y@(f1;VjH4XhR&(JMUvW5@JjwNjcu!k4MkWCbQYu`ovxZfgWQMs#rg};KnD=28KO+J +k~er{92!u!Myb(sH=mw%R*CM!YwsU3}_-s5(01 +7O|zZlbE$VzGy3~A9Cxq^Qabqp7Xo|(C-+N!gvHiLQ@!{>|5v3>+n!t(-hhWle;3zxbKa+Y~oGK-)1{! +b4n7VnT!s;zox70U5hR*zT1Cb3rV-^wxK^ +{rrT=S5n_`VSZG9Ssx^)p;pFFdT)7QQ#r6InTmu#Zr8v(|se}7nHb`OZ>$yNQ4}G{Saqn8DaX8Z3%@m +b!*U@cr@FozhBYDx>Qryf?WH?uIy{DiY?+|PB{E-sG!~vKBqYO9Q_%)7m0FH~d7P;vf2q>S~%^g1Tq4 +}V9yeFWL!eij_E?mkE%s>(2Yy$=wAHBzl(2{He-eUk)>!B-3Z$S010RtnczVOX;Kqvs3dn3@(29Vd9Z +{obqK}jC^uFJS2;dWoYo-^OjhJTa_@K%8tK8{UPF1&{20ax$48IPRmchu@Rui)AM4)s84JSdH{mvSKR +S&c#W8F9MH6TLCE#5x?;U~~psb{Lr&+lS3hsHsI5ppL(==`lP74=RjZ=LF_6&S?T0uJUd{@&30#)WX0 +DA?Guo^xChlz4#oy{02AOjQ2a$q3*_+<9+O;@}e#947K7ed~HF8gXh5g?r*RmGzp?@^R=T +_aMx+i2|N0d~Pl8gxDhxRaxzBURYWxc@p*BAH`C@JfUxCBn)%;)S!o6hLYp5hYBzvEdgg|IJNzYpp=z +eSuEh=Awf+;}dorp^4KNm}uuAZOI*IlniChs8whAsu-03Oh4yUT9o20~t9rrOn)0!L!NGP=&=sKX4kz +i-9iGkQD+{U8XoM@WstNJAP<8PcCB#i&z0EI9s2ARz`|{CGXdoIx6@Ua1@e#18cN&5~&>Qp4zUof9Z; +ITU60?sSK3t-JTKL7OG3w^tuvFlCcyAI3iKA%)_T}9jo#OV+bk^Z|&cP +nMPEQ+$SL%_CG|ni>F`fS8%Y+(4MS}|OuGdgW*9CR?rsCvZsIxQ($pvnId +a1X7J}N8Z3pZbz>-h^|KYMCHB36f6H|vs%`bLZq<^rquu+=N>fM7PSQJTg(Vrj1VHCR7jC-l{>>cwM7~xZl>vwQbfW_zwQ|Je; +;9fI!!BJkyGVP}~&XE@YA~1kZo{l{yPAV+qnExZQ?Y#d=lI(a1_bo}qV6uD2lENr3_I!`aO@Erj4!+m +SHte}hS%iFn_U)q5a}CeUr?SJE$Mr_YsBGeaof}AG?I;T-I3TCFDY_f +-&y(kM;coZ}=2D|H~w&Qh*4eadpekAAQ%Z3JmQTsz^%s6Toqj*6^kDc8BC5CVV1tUa=-(OrLHN*+(hG +x9-Dyl)-nWf+x$7#8rR9XhYiuCp3)q*_EMeot$M4t{s*CrP?3vxE@V1)kodOS%sr#ZnIiBUWpQlSOVF +ztzV#C{kRSS67}2aIQSf?$G9kj%vSA^q3C8a?sdPnacWqBE{9TPT;Td!M-(1`^wOTvbq=F}1#5t&ghp +eVVDlza(F}+Lp5T0jYR#lQe(vHfaX!Ix}`VaLt*7oxcUojX5nQ;8M-1RL4wey+zA_m^3`VR2@sQb(L1 +MrFia&hyhfUp_<2E$8NA67Xx_pg?OZ$ooo9U8@=1G88lxEAcH70LvmM2%M_X`eO;mHY}>6E+zUy?^-( +eSJ_1);tews%JF0|ROVUft9Bb^>F0Str1OI|~_aI565#_sZa1)S^DFn(*>5E#A!2qsop%6-Z+vzQR!fKa;6cSil$3 +b=)asA%P})f8J5m;uiwP3x(MMVtEdBAv}0AmFv7|DeB#X3lezp-HuC_UZFQfzhF5ddHG;Y(Ppz~X)`` +{Ijk5Z!&r$U;X$2 +-^c+!E5vMBM_Se&=s6xCi$%ET6Z}c;s}R|l{PLh204~2PeARu4z)H#s +vPo4z?&|woH8tKJJv1_>W9-R&LoF{5HmGyrvpfsP8Udi^+a{AO7G-!?vO^gQm8-)NZ~yDoTSE)ChSvS +YN;06kl*f2ZKEbxZk}`o_1Wq}`wqHOX1_5pVh9}v5;>sJjjkrWyRlpCH^0<%eAi_yDya}093btc((XV +vSSKeG)Xxd`cw`9{L#vLW~3POko)c{C>uc$DW>yFIn!qOBd+XY%p<7Kh7YO&&;2pE{mALzKRNzL&A6$3@UiESXC~5e-Z+MOByrizaVDFQs(yh41ARip)6F4QqZm~F~_qGDJz({4kyhE@vtFP%MS_KelF1`K4h> +}5Q`rG3pr&MYn7qfyr@fMQQxINs_R>=>9O>#C(F-o~~JW-wIYr*X-k8g9qP-s63!w{4LJ`N>bbMWdD_PX>)PCReG>hAfiLBw#Em=j`FPJ^rHGO1~NdWqrhfM&SWB|`emkS +u=T!fsAklCY(G#gNJ(`!T3v<4dEBB`L@^qdp%4fl`XhRkXTM!@bZXx~;_#qT|cajB;2zEF7zKfw9Lz$ +Yf0v>#3q0~3?bVvsUPb-%wjT~783yk_?250UzQ0@X#-dYr(ucZ9gJkrJiwO$KE+O}_{1_i`(P|5-d!B(Fo*bRmnJGv{_zQTMPJqm@zo56|Bx#Wr|oFl1o73k#3L +#OgI#hay?hKg>1)XN-z~KtlX-Ku<``j^f->;ZT5FPbq_s^TV(Y4`Ic4apB|>w{3cI!OgWW&zneKD3Tj +R4>%fJFHtnWWf@v;@*%6`zIcoIX;Ifm=!&ORXC!o+>IPai{DxB3!JmfOMmNp;ajU&OJ~c?r~%7$nRc@ +9R~JH<@JXvPZ}Is; +J|#SC4?i+JRGGv|%~aZXNcE-nejjHSfsNSGmD8FOXOtwIOZj_@vX(K*>I9?A+oUu{)209PWvqK) +6z%QluW?0m@$_6~Uxz0{G=f3&{?k2dx`#I73nmKdzVqj&X}de;rJt#x=c4j5ihG`#x%!j@TZRb(pteT +SjB_jZid+_)5F8?bkP;%3t!O*82aSp{_a2%Ir}W$G~0U>CdgFOk(cZ;&hEP13~c$M|+$N!)OzO{8DGInwNFZ(=!kr`U}SZ7sBt-F)^> +H6w?naMu?$3kLd^A*0*4Op*=s#cz%r;4~A5b=2&7wqYBffx8jiy{S|NSl`43b%C*TGW>=y&DWth@#fH +p#j>SooSWe;(BFLBn9B=8L-4YEI*S=l7KD5iARo!1bFsKtb*ezV(0=8cxQ30ks|qY=Uj@%d4;gpm2Eb +x(xr)0Wo3fM=Zy_p%r}PNsFutttdQ17UIoz8hrC +k066r66rT|_vjpfLhZ{<=%(`9+wGKWc!j-w2juN6}eyuX_@41JXN_wZOBy{c(7cO#-VO(bgYfL`GyVBEO63I +=>Foo0J>b0-E;*w6D^x8Iux&L%EcdhP&Nr%-RMOUH!WRhSX3}X|7Ta>t=g^fWbOPiQ2pf9-F0EBX9 +EDv1v_HosDR%={7`gv8{Ms +@9Flo&S2X#;-LvL-o08BUV(1{~#3y)TKrQHACXiPGOy8I!;eVL!?y9kL&tkVV +#;>Xbfw5ml;cpQ7xt=(o8Ch<)yHc7CcKa0YA*i^Q@%kX!G+n2rpbS;;qpkrbTuTvKtp1wvsMQSio+G; +?Klz7~rJRzP_{u7og|E~S&hZnIoJ=n+LNP;!%R6VABYwG^tv!-h^KsLhlg3E{<4_-QuiLwBS}8jjMc% +3{E{1`;`pD_$h +)drjm)3{{x6&qQjpC!&{om#OT_>b*~OdRJ+rnAAGa+5`PyCV!Y_zMBZqtBrgTq2p4x#{n +4D|JXpF|l8}xai}TdFZrWHZ5MKmf+ovAQ8un5^A-jZrX+u7Tsn3B_(yzZQy6n&nY{03A$HW>8^Fr?0H +{V7qc8T2Ek6=d>N0g9@1HP^x2<6{2ct`l$*HDWdF#S!#Ze3L|=sU(`^h2Kbca!U~mtZ^tHBjx0*`+N> +*DsadrW3kCoDJ3yxFZ)d{LI=3g>Pw&MQz*l%WuKWeYQD+L$psW3#CI&!*(ICMGBMB#Xtbp)&X@SbX>v-1 +c6p`tF-tgQ%*W!HIH!T2RX5qrm)W|sq>57il6BG*#C9$^qBGcy*0?3lUo;Ciy-&-;=?G{BGy>Xix;NM +*jbF|xPg=JW8q_6!fo*|4lvXnw1wdiN;xuVl@Vr!lKWqZPv+09XMk6!ZQlNQ8~w1vRLfuJ7o?X=G3FG-N{H!G8xk#8_5!%)_6MX`NPnb7_20bu +ZpPsxIQ^l;X+GRA^gKu53nIZFLNd=-S#)b3aYT9Vbp)UMYcE?|$SSuPC5w8XDDeIZJ8Mrz9WGC +8Ex7smIn@~js(jr=EB?Y%eGEb~(X)?&FVzoFctQt<-x$5`-;8-q&`BOW=R+LrBHB9e*CZYq@PwYz&5q +~UFN*=(>QXdaN_POMhww2_*x_(NUGz^EnBW7t7Pp@B2gt#8z~Jrd9$Gqw$#pyd?GZ*c_rV2G2X_P?9% +yODBO*zS?p3{dzOrLQS2;Z038-FN3&!GtC?6*1lY<*yPryjW%O4c%hm*rG22YRd-eJa~tHh4~5 +gcY!RrIk6G(Iy_*we4iL5~z6lwAJIri$|8017S|;V0y^o=*x!^BQfbD?`ikwa(1XXR>QiCnSj`*o$`c +)J1C{O=sw6(r=9%!wjWfsI);kfm+f7{>_6OS@Q#kVQ{;7O=u7KzU0iN42#s`qQ$pc1zxvJ5*j`CL=iHAF8W+v?){`DUCKCG_ +1xCb-XAbVbHMsR?ZK}>K=OHy|_(tzHG#%Id}nY*Z9fu(bt|}f7u4q;KIM)wMa$mxd5KUvX#kXZwiQMh +kO&oA0`0L@r&2S`fuA`8<{{nlEQxB25gf~=%`S96+OjpNzI*YYYLLipBhpR%!A@vpS=m5{-GosCrt7J +(3pd#QMJ#dKYI;-i2$nFbwgEIMpeCKP!GGqb{y_@GB)h&WS7z~&+nmBW6N6L*(9Jw%0PK4?-v7m@REe +P!R;lE&9<)M%Ir`u4=@ma6n2pmePOB^%KrfP8eE +L@a$3b*OOx@Ir}Dqx#d6rbK)V=x5HFv}AgtB4cK?-h9HN3)ECHe@j~3ytuecVruI_KG{t~w~;Ot1hOI +slx3A-r%)+dfOcaad*S$N!B4db=LeoWl;0&ea}3I%b82$&Vmv0wCHSD&*>BFl7!h&B~$5Ch0XcZ`Aw@ +y5lpzT{AKe~r%+3L#95OFw|kis#mIdg7;+#lSk8H|0XCwJtZ}NP^fX!U6e=T`)+voAKI5mYIZ*k<8)Z +1B)5Ckh#R&Ie0zdVQfDP`uLLwBW2?J;q^j0oc)<&3OI2?k8-DsdsnQp?4n-Yhfn7qS4bGVtf?$gGAGvW@_b3*vYf=dNntu6$fEPB +A!%gfLop0juH)8E=GwmGHDzTOTPVPc3E`;j?XgssCy^=oE%u2bbwEy0+CC|7bbPdU^uKH6110Mk$5e* +emm~S89zILrSjq#!`kaLYP?7>=AMIT`UeOEo3dR;}lyJ-gAprlo)~mA}P(Ich59 +s**H8${Eex~kQ(YwNa>pl+d*b`ojMeXv=8{NZhbt6Vgqi=A081A00R*)F@$utY{0BM>&WD(Fqg!tXG^ +0T}PNUupb%Zc0E??*e5JX=vQf!VvOyvbEiZk+#Enhi|ah$waIm}?BTYSk4#Y{rwY`XpBk+HAkWgLmLy +W`Rud>O5S+u}^b^u0q84O#LRO<_}J1+(UvGV +HEK>H*~m*T?*Bi`C4IP`830H3k2L`9+5ZpEX*^;7yK_mmMn}yhHI7t4AKd@<=8_JdjGF@|>?7uYF>lC +@%F*Nxa1o(eP)h}Lf0X4Gp|g~&QEKBLz=uk+Aqk>zIg6AE$^$&7nnwQu+ORCrKm0m@3T{tykD1BNqp$ +vYWISisF8OtQON=%pac4O(b_0fcQp6+WCSK`rG{g^W>!H`yPh&eTfAc$b4{M#8qUiIQC>X|uL43>v<8 +^Ws_!pq|N!a-PGqzS9Wo +SI_9>mr4`eWNM!`(R%d@I2HMJf$4EWXAHMMHJMc=|38VfRJ7uQ?FV1sdsr2V*bST$*f63*mz#UNf!iE +bKhYP1iDyBgt*%_=oEk@w!K$FID+;YPw8!||VRy5To7Z{Lj<_c;Yp-AB~;6$jwU`Ee!nt3Qotn45=m< +M%I5xN%oVM!P%@IvIC}Sn#k1>Bf0|c=wUW;0B04Mmq3qKCLZ-?{yG^%M1W>y7%u5z1RSZ|JcC<{IP?#{Jr`9|IOaF07O}={m;UptD=jAg|}Q4FN +GHjH4)84SOs$xML|SdKO)bRWo?50LI=H{A!1G_U*MzGieE%x$RqAi8(S7iyqWj<_Y!ng~36mvmhb}Ha(-S%nq_j(7`<$Eh1998BtlQw(#~W!sSS_?4xP +{245S0_$v>*J8Eu#5LJQVE*xcESykHt1s`@u|A`@uu1_Jj48o6vrs+(O=j`h!hq9mOV(2I>#Cc>G7yA +H1xEg2tBBAKb61Kls$6Uj0E|Mg76!e_H*)t3m{>s6W_#`FhnK3~8wTKpZoO&=wrD4!bV(2WK%0m8qq& +{3`ti(6Lr|P}P6%yQuOr8b$xXPF4TG?TY?`h0uTCFZ3TgQLq1?=q+(Yd9%6?o~;Jd`uxt<)_tIsO69g +|>ppl6HxOKLjIVXX)>WR+sJagl-7dSoyII`_#)i5NCKFfd(tUs)Jw@lP{Q!j8Q2W6>BIm1=ABfh-g?f +^!l^<-ne3kNp7heYVr&{JtMP;4NQRJ9-6FNb&2eo(;O0}1U1F|I((Xg~16))E;up`b|7eDI#4`M +{xSKG>;2%S4D~G#@Mwnhy}5dCdpo-83JV{|(It1;?TJprGV`gyw@u)lio#Yd#Rfp=drpQCwT|!Q6Vy2 +eDUaJ{S|3Xdl6#`k>&T?R>rJ1JPMEtNMV#Hd1|nru1K}`ao9ap{hQxt#6?Epx#qaeQ^K!YpFg6T7NCo +2V%&8>I1yER3AXu2vi?Tx}fy1P<;SLs6JSG*5)bCiE4i-wQthdODDq34RNnbrJPi+-#l9e?Vpd8^U2Dp)Ogu)#86935$8QG*_Bg-XonoR +#SMmChpePmvEs9rk)u2!>4y1Wrze~nGVQBrm;q3fE^__{IsF_>Wf8r(gKro*-o(b3T7mQ+`XyN-xFqI +oCn8TsDIqR|NA?Bph`EAxUAdV%0L-xa+aW?zTNCvt?JRc8$O$X0DX2!+7`r4b<}-)xPs$mF{@N(l8lh +}F^H23mdoRxuW7^aY1;IYnG;aGb%WbF^|8wM8a_W7q+)&mlO@AF?`M{Uarqj%Ysw;YM+rK^6(>^B*FI +6=5mmLC0s*)KL1FcNB+@(T&Cy>LoWy@xzGB_tAv0TNyii7z-6qQV|M-oZ6Hzl##te2hGl&MR6B`<1Xm +)@6_P%x$S~HFT|lT1P$tpQasW&j3629r=2{%Q*~8@XD$uujYj9jQeZIKV*W6A2&~sP_5O? +&u#}qqfLq1wzlEMEK;0G6nw^6{qNqPo%U0mDg5WRVrey5(Rvdkfp9Y?3CP#*=l1&?Ote@qc*78*+*!EAT0c%Vo^A@vr@tk+@M% +wt0JgtzUf-so1#m_xQf)-#ie(_wS>Ss0U-yK*9B`El;!2+V(V=cLFOH7^22W2pM}%@VoN#hvcP(xwE2 +FQt`4#4pu?)euKOW3?oY4W<}aXWkek%M4)_?FT7sA|rM{tWo`zFtqP1TnG)F?<8&o|mMzr-9-pN~S=E +D%sIkb^bewr+lpQg579Q;B1En`aim6+0g{fH=93!?C=Z@&gqu8(NH-u3O*Pi?<1qKZf5@hTh;80y}3w ++*?v?S8!csyaSZ@Rc>WSUV;vg+)v8;$mv=*l0yBw?^cIv*94HXi+~vmnuA3I{1f7C- +8el?&F8K{sHYZ}8czg)e;w>O*pDAKjqRme-4hD@7flw1XT?9gKqX??CPC5`pE!23#NY4AjJ=BZ;ut!PS`v9SlFE&aSfyv@<=~rP#NR`5#D4h{@l= +OwLr%A_zJwrMu?AcPOuuS7C6|d-&rSal*JzhtNSIkwVA>tJ)r&3?>`m|UW6|YLXsaZ@O2WhRt9IZmU +#GUWd4}7;&+{~*D@tUo;92G8$bs@v3?W`i6_>FxH2xvOmMhQ%xAve(5+mqKj2KcCroofqq%lp|I`PaU(yndQP^T54mLXDfE;6@mT$~>$k9dbXJ_aR*we-p)4fQgK +O6!*(#5=xG!~&M*pJL-}x(*6R{xVZZFlWY9+k(YxG;R{#m~`N~z1d=b+m$YU&uFp2uD3j>xcH=}uSam +WFse_o#~3r--U8yv2FQG2JKRgm^t>&-Uex{WkrowuL(5SVHX@`RH%JN#%pYS+E!S*mr6b(Lp^Mr$+6?ecu$*;y;N)8qitJZJMQ2?C41 +L)EjdQ{oP%)2Od;`dN@;@=b-WB*BS|4|=u<(@e<-92;SD(eD>RVx$dbSka%uz%-izo^T+? +ff?G|479aBU|ezdl$a;N^PdMz1-9D0QWDbea6VRfAIzQlf4wSj(&!cnL(yEinsNuahk&MnpNXGDBZ&G +9`^m7_A-(BVOQ!zm#(lPl*Yc_!(QfrP|w!GAcrBs1%zc9_!hdS@fBGI$dr(Io6M_Zwv&09%my-!@HG` +h;SW`iEs-seeU|LAWLJ@0MfL@H +TdoU-;vYQQI$RGi}B9*A?)^X}ILqq+8`0p|>l}QS^41-Yz +?Dr?)zKt8@03b93rf`A{mpBRkrBjG^3A7aUiYc^2oW4(`?OVEP?x0!p2~x%FSyH(ofn7%05ef#TQVao +laBz|A|eZ^g|!DLzRXAoGuem>#+e6u#eA@Rb$L!4A_|2g9{@I$2$S- +BO`m!vhI?2qn4qujt>p^=rO=+qb=${_WIrqAi`=F86OUU`yoYOD`j~UuXY@)UVyY2^gB~-;^}oBWpXE +r^#$U1TuwWa>*>+{#W&H$jrfk^l35@nY!)&iT>^07hL_D&kN1=Zwb$fIziyIR(jt+rsVl+^l$gRaJ~J +TNcT_mZ%W#}WOXCsPi6p_p=3sp2`3Z#!e7DTXZ?1{TNzDehZ80C3DzcbV~I!3>9QLCWivBlv!zk=$;U2!9Ggm=ir%r +=f0I?pdcE@ieIYcJ^^@>!CQ=Pw?uu2%>F#4BDJ!+2H%Qb2j+T6D&GLe`2igQ5hBTz3 +kBZxm3`u@Yvkx2+BwS`N`sD1gCNSoLX9*-j}0C6*ZocHo +2vmGa-I1po%eZS7p%6YeAuU*nxN7$7o#H74yn?;j6+&0elhE#i^FsDZI%``(&gw-Bkgcm@^1VgolS +Sk2C3lA{yIMDyw8Go77rKXUdddv*nGrDW1Y997vX{2Bt*(P2`dYUMB;EgGK?R3d%alK5;_R)pp$sDKj1vrwKwBbBXAo_{5EU4ePP2*C(v--SHzk`KxUkwU4kkTmA`Y(t379_( +zi;}v^j!D9Cwc^-HcAO|2*D8*`LQ1n`!>!Q9VD(KJDkmQ$eIeY}qdxHyve!B}xI2Pb$45zbtVd^qFGr +Ph+j^n#uC}1sI-r1C`-^qJ&c){1DJkB?=Ce~$G*SF>a%xp=x}dSO$us*fW?;_X&8y{f1EZv$9+s~<>j +Sl2b@bA0^IF;S#wh8K;;EzVNBC2Zht~1B;_lPfA2c8mLBQAl1ewSe}()4HKE-$3a+RqVI7ePI +UhhslhTq~rBRh&ml(;gQMj$+^UxKR6xn_MG8YHY27s>c=KMl9vd;+WV5S|dc7hQ?{uo})Cmty~%?67y +AC&LFg$>~dxsLU?P&)h8NVuSw%2`55yJV6o$Lg!D@r#3gRo6-3hoxBy(a+ju~X^vFx{#Z?8zDS64SfI +5cka$BmSO1*4jZ$1!j<(z}K7|^8i`67@tNxoUexkx~AH2~BF#sqtbjE2TY1LTaXJ*YMoe;gxq!?*NYe +!cb`sryz8AM44f5_j-X{F|f)^3hYOzzokvFEZ0n<~&ZMF$1KrWs7TP@{Q7reD@v6FCf{kLiW10-*%Di +a0QUpk#^hVp7p4_6?s&{t;l-)2NOGpt;qYMq?!)0ULg5S4vlpPMz;kWm&dAE~l)cMoKklkbJ5f)a5_ymfqpbx?%0uh +hwoONi_pxKz8c!3NyCmGWUEh9f`IYn`2|OLbNqrOYVhU&>5S{br<+$gXvmd{cZdT;4(EHZtAG_}C?*Z +F6vTtvIk+<-A3?1IXD)xiZMmt +3Brxx@>d7uGk4wbYUVnG9xm0k!BIBHQS5pB!^`3O2r|LVV>4F~`5x3ji_%s8_$s`2iIE`Wcy%=yu5 +dr&8v;s$LZO|1dSoR%R)-6;iExb)>}t2BU!yh<8DRq0)Vf=xjOZOF~T=} +Fy3jmZb?Q=k8q2Do!$QJkbN*e>o$s(nWgPU&bgTz&pd(U8y;ED0&q7vzgDXG8YtA6O>#Hh3)VK=Yc#f +%aN2eLo+yk@#N9PM?eC;0yJS +QigoRNUcZ3|yt7 +!#@N?~Lf@VrzXr|1+8@HDR$NAW991-WPBeL>GxrqkP(AoOdpZfUXM$rq6!1kYg8u_-e_>9YyxH%L1UI +s}$?r(VS>T~xghg<4Xe;d_WS%BR`LMTVED(`C;Yf*EtCSj*4O$ie9JKAuw4>#%bI}hr29IFoZ=&mg?* +IJW-OgH@weRa5oTyRe>)}ts?qT_t!k0|Epx>YxfJYge-yw-Vl=^3PTJh9y&Ijuy;uarz;NQO_QH~rqQ +q*bD4hOcutz2B4>NWXqdZX=g2PJjK*>9xh)9@U}UeXQ*%jiT;yK2A^l&O=DUVXGx)y$s-Z1;RRO1R$i +$>zwzjx|whodBXZzJroprJcUXOi4Xup2mm4k01*O!2mwHZ3_x8A0MsQqkj^Kzo{1snt!*e*eZd|gwuT +igZXLi?nH~}Fs8VXw`IGB>j#~F6Vt1}j{fVDwnQ|cRz?wj;ps6Y;a0a!w>LJfnrIKYI%Ud +l!cao7)(6CnMtv>^>FT&f<60=Ts<8gMSel0Oai0n+P@qKs@VN-*&~R6GVq-_t>-k6c$JiR}(36ho2qJ4^ICj*hDiA4w?~kR1a!bo~iS71` +qo9c)r8b|$kdLhEMWx(}t(Qe=9n@J@D`n%fUsVTrSCl#svYP0a*y-Y$*n|?H|3&h-nXx!^d9m@mwzrE +bcO&Y84oGn^;$B-HM^yi*jwt`Bk}pQLeY&fzwZ&z<;r>3;qf)LUrIs|lqnCykf33W(N}>AWj$Yi(%dI +2r%l!v%YpW2e|A55k?b`+39P&`FU@d4XOX=T3mFER-r2^ahnAIK+3}GA +&@R`8cL{JEnREPtn=D1ZsPur@Z&{EuqZWPI+-4ue)?bVcMbv-qWW<&6pWCbJiX$<45an(2Ff7Sw2&q& +Sg!J2RY2v)R~)}#t8eU4%{|OQ8$4TU$$H960`c?#E0$1=#&diU3ALtPS5C+YTn5oYdx)ty0r=_ndQ7m +x_Pnd9BGfm>Iqrb4YcycgpiM7VwcYfX)j=ic9eqS{q?HrVylfbM;r#dXMw8bi|zp*S$!g{y2xgruzR< +nk;&OfT4!@XvC$@`1mXgkh9^z^q->jf4tK82ZPu$EIqjtsQWM8YJxc+c&0iX26W3YvvNb%D`hwMU9if +K*mHpy2YuA)EKFX?Tdk%8^cGy%ur(CL(R($)tR?Ymesz +?pY)i!PMciHfpM*|||)40VT&q35#h)E6pW^ +i0WzSaS6WeNmV0?t5qo6MuHd$1<0}KWtPw?;{iL{(%T!)aVvR5Me!qbR5=Y0pJp!pcSvNP*LSip5QY7 +csr9XKUWmm|waKwJ5N9h^0!uE&jw3=9H|7E#YwM{K{4EY-r4YZRw3h2eiq{TV!Y^W|Pt!$mBKUd<^DF +>3*ChBv@C1<=3ehl~t#E%g_QTVwRKN-clF|muZ9fdy4AL8U>eUPk4x6x4>^hdxS_Mh~y3b<_)#Lvg<- +{lldzYucBdPBgWDN$0EEItA)O}|iZ+-mYP`2_4KGSz~+taX?#oPPll`aw0{+RG^6DmdfNES#&Lqjb8D +=YfEuQ&ZR!X@y7&5`6_6YDVRtzpAzJ>T{yLf2q=LoV^vHx{yOz+m7xI%QL8CuObm?BuM{lt-9b%Y++D +IG?X!zE@0Q^rWuX{!?4gB_2j0z1CCjHOnEY>ME?wYX{{Zk*<2jaf^H +ow=F$i%Z6v2HkirurjdpMH$>PYcHxAv~XG~KD6g;J>-8XO|-ZSqmB;3I5|O`ay!iu1%NOnRI*;# +KPR_)@19JnU8M(wl4_y|hOtyJGW__R#>d86RR>_S=}BIWuAiI9%mo)=i<7A1E)(&9{$6WDnby^_zc>6 +o~|5Vp6FlhhOJwjOdIBK#d4C|E-V$LKtS`>KeEiIM{MD5Ak +^5MkjS1|zV9;xh6w*?WQwgqhrleCe4Rg~MAdvIjtGJ_+_1uyCOew}?0SCI4)Ew=7z_G6ntKvN5Kx +SJ<>CE*GR;2acI}i(O1!zW^7iR;AJkLt^n#DylD0E$%Bll +FE6t$xlKas_!&K+=Q^N!{s#|gSr689ekg7t3 +!CupPLwjkGUl-y?HBr)wmmA)c;9cJr$w#-6v_3*D<9^d0jCb;p`x&7#s4cvu*~E&^ly|>xo#3|neW?4 +rW7PcoicF`70;mf=>R>TNrqk5yV~I5}A1=x+FUmd{V)EAK&k=&i1ZqgQ8b6AE=IAcBD(gM=Y)NCAA(q +Jq6UYGX5>6(E?R1&xB>Ey^?t$bf>9_a9=7ez}H7jQ2T@gnTqKm_aD@PIrOE+l5k%Thq2<1q^z*uTerz +xtuI&s2*JMm~tsyrry%(qO$afPx5M~xu*$gT*^uCSge)(*!hlM3mDZDJ^l!HSW4as+ISBkpj>x7O~+s +9Q8b$V*4%GJ5wG#g!8&b;oCL_DP#B+O8{bRS(N_mwdCKmJb +{7;3jL=3JI$3qtq*1HBLHC%$&Ilt*8h)U@55zAfHk3{zsZ1Y*%U#gnlF#6J~qdWFH?^Oo!?$pbO>(}k +Aly$f|Yq+{v5JGtAcQ7z5QPLRV{y5=TrQgw7b{Xg;uI?Yt%|2Egu@KsjD(lAqRh0TW?&5aA9*G_-IM} +AM^^hjbZzxv(EKxuxudDP6ws~7m=VklgYsraw;wmdCo0$3`d51hC%My5YnRwPw4~XqhanR`dEmls;Y~ +7{GM0KZ%e6iD_MAyVITGiD%B1J2;x?dH#558X&x?9^hvg+)=w4teq)6-#d?InWlAc&xSqFrM0q2j=qW +4}~afT_vA9y(4TjR#?Snh4thCVHNBXmbly^arMhM@Ve}6KUw9&33M&)NoftC~y;V_%^TY#i_*Yz)T`WQp&pHG889b%CR&i +dh6+0$2=qp9n3pLZCxC_$s7qL}A5~3Drz_?ImrjUtH)d!QG<3R62kirn(8!B3(Pe4`IKlFwBsi1O*3i +S`{qBn7`el&Laj*>ZMc{@WL4TCpJpCq_6&+JWrv{2A$5~R<_rIQBtutRY+U*0xH8*)BV>)7kW?g#88p +#V`YsiF_-@QuiQX{($Q1=UNAI25_1PQnm0b0&p{wqFH=a2(3}O6WC_?xB3`BfMkP22j!?Cl&VCJDSLPn_a7wxH+8k&5dY +{~$xdm8;qL~)5h}(t|!u +?q{bqb-O+dJ}+D5;_e6h4#*RE6nQI-jy-8DGwB=5hErUACyL8}>LmhHVW^o_fB7_i5?f_PJZEc|Hqvp&W9~ND6M!6;|!Qa`?rjX25GJD8;M&>&*P_lA^M#H+1=}%@PnMq{sC6h+ +xJ~D-5{zm2*GH;XFPv#_?I@nW5 +1EjUt)Cm<$h{p?{_g?6-Rw~bUhFa8+!^Sk~vUA=6l9`aGN8U{w$5zSStP9D#G_qv!$lWuh{I<3gGxK& +sMCJhmY1|GI`+{7RaJRV8e*08Lf5fj=;d!sMd@baAOu@x_guErH8Sl8B6KWQ3%$W>2zf2=&!X-flcG# +sr72rTGys+JMZ=#^gbPLxY4)MO*i{>?$Whe_gi`xdiLt=-=}ZC{ +hhyYK$x*(-9GDQ#YQf+Z?FIn8RxBzW#(CN`B#qTh)uh~3Tx5fx4prN&serD51{safMPEf(0(7Hdp=s! +hC)cY6;_O--MNxMAs;rlrZ&sLb?vmaHts7P2fhkEOFrW}&}9EJ2h%W0|%zYw|*i!IGJoo@rpLeOtz+O +`IGZExX{8MMq8=@Ak>UC!0efC%L;YHg$Ml(9rg6L(>fL85ya`^Wv?^>1l?f_$asy?qf#yLSr)^*^fYVyJgbP|mU_P|LzXQgBR!L +REb$8siG;wy^h^t-L9Yu%m_hFF1+{NG&=6V=hKm25b~GKHl(V<7HVBT8K9c@iJ_L{o>?It1UjYzJgG +bA|S#IZ8rTm>1h^fp@XTQ$TC=gqAUF&!42_F&#1k2*&d2V5qGO{eqpmswPgOYJ?od|PBqc9 +7J?2@fXnHFk^LBj)_4luUas=SjXu+|$Y#kxMxd0bN+Tyks3%*POtecxhx!J&+tO@VD8 +ME0e_@j+90G%z#lezBwU(Z?(2{1Q&Bfk(oX}lTb^GrvSFJ1!?I^((a^ul_(}uQ_r?-qvT*Csmo^b +=4G+z)5Z-PLGQ4K44-I1n$ssmhD{C^uh>gl(oPuzA-~cp?~l5@LyM6*POfo#f5`29t=s!LxA(ufy+7> +s-YPfuf!w@Y8qhr-$bDdCuCJFDjpzjh1q4uFU~W`yA&t)c`;CZ-&86|02KA^Y+>Bx9pIewqu^0{ONl8 +gMUF)S88A~!Ut{Tt(e}4>D{q=YKUF~=EUj%VlE&b&;@z*d!p4*@1I{)0`uXOwKxXwQ{uHnDC`2PnySJ +!FMf0_a`^?%p&3So@5U}daT?3bTWQZPc;Lapq +E(L7#cLi~yY6ofuYcsx$2M$y{E1CZ{{5+^H$Ssw>$Yc~+y49uFTV8hEB|=)wb$Qx^Q|2_-+t%a_jbMi +!S0gMJ$v_kxWDYc!9yP%{`iw4M~@vpaq`p8K0o!vmtUR!`kQad&wTfN#ScIJBvtSJ%{D{NqyH( +;-{Zl+D)=_bUdiC4-8=_6gFiL{Uo(x7Fzbv; +&#+|(H~CvmhM6hF`1zKx=}SY|^k~!6pxXz9Pn;-VqO1u50)*fpumGJXA3~WhrvjjIpyHrXp~9guqN1V +_L&4D#HhI$I>C^n#IGS>#Dk~K +5WPYNfHYE5V{}UvXU%wgVf*#&XNXszL1{J!-9*~`diEn&Q?V+6y6JsY5jGL0dAypaD|NbR=x

0f^!5H{2raT=6OjSi3grTx +@-9_igeSMP6Es+siDyI^eQjhu}>DQk8NRmig0)Ni44%9E5#c&xV%$d-rPDe~^F6{-gV}>_50~L;u5W{!989nWJCJ@ +!9C+M*mC?k!&~;x9cOgCKjij)s!_PH5%qqP+}<0fH+JGR%KPqy{s$WQAD`XOf3=(cm+?mSO?*TD +qmAMx&TF~6suE;>Ji8K%&8Ab6)N(#|WVY;|XKUI2=fy3<`9V(0@jrgBd4HehjI7^t4gKBg^Q#w)?A(h +j*VCYvn~%SM{L&lwmo$oR`A5s}zx{g4{;6-aTt0(#wG98mdmH*Urn8wJ%KmsB+1E5ZTlO1S-u{;1Tyx +CGW?Xh9B@5Nc8QXNF-pv4+=NZ=I^S^S{zfP{&S>rB>TcnM)xO3OUG0Ge_E71@~9cIhSq~Ti)eNh`5pK +KkMo*7N-LaIdxIiEtNSu$ym4wGd9Vb;u46AkyoRzDz8k%#VyG;)Wsn^4a-cnQWmMv79q!BEZB3RC4RBxD)$nt%9Yla*a_|Qv?Kvcf@$eInmAHOLO=*^w*l +AYy*(qd!Yy-c^XFSKqcSa7sKiWBhfyePcFrRb&_PIJNr+4%7Js3rXQ#V6&6HI4B*YC3i=wdrWjWbo#( +P`JB_=*KIYHDj&C-}(eM!ruNSu<%Lzx?fCM0AEyvnrG+$78&;!BY+AHcgy4!s{=qG+>#ty@ih=tkAkg +zPAiCM_R}@|Wp`v9sD3S&Al7I7Tz(REzbhg0ECVDG(eNX-u`qpRa49Q!O;R?&B3p@dWj-big8G7nW{A +>6`~N@SC?vP3!28+%;tQ{>i4)bx_uH<1vPM1beSFmrr{3=Flqf$rY~TcTXj_( +I83h~$PY6h#--Y_k^ui$TVf*39~g~1G +PS`mls$-=bL*eF$W)`?6v|$8!*H_Anqjj7Z~q3NV%bSSfzbpV^)yJ)l$J0#QKpRv9`)-i2-WmB`@he> +_mm6>b=eyCZA?B_hsA!Rt9Lpz^!NA+Vf)|b|NRH_H0ej9fix +Luqzpt3EwzBl{bgeg4Zq`;R=$3*Th_=7mH5y>S1P&;Rc&%~RG@jEeo%b%qaB>>U*T$TJnsbYVX{BRw;#`Se$87H?B% +0GaaTJzpBwoG(+py#4C%Cr*7+evz>uE998kf68k~VTylCe9*u11a=PnOTRVjYFMGd$n`jltni$X>3%h +`4c$Z8h|cm6f7qyNt~@@C(sZ}~tb23*e>Qw`{{O8{oKaX9YcnLH7+b^1#u)BLHpcYapNxXvm_|0nW`D +B5Z!ofNB3YqP$UzPaHH}mvKGR9zCe92|RCP1 +IY9z<4?vwrW+YQGCpKspi>FZ^Gvn54n;hktph1k5+?Q_vp30{AoCj;9||{^jG0Vo!FZG!MBF>vgC;PJi^b_<$BjGS+aaN0-WQA>yGflHRN4J-#Y +p@M{((U$r5}^M-Cr8EWSlE)6vg4UY98Rmn^T+ou$Zpzw*80h^`j#6BFy??;M0bd?YdPNSX3oC;O+8dm +X+h{W|i;Lt%2{^yTl=8WH~R;UoKHhZ>Rox5!`qru;c~9D$G%Zh)`u$i;8zs~Y|S{*`sB4%Z#7MjH6OG +Ie$&1*l7<^y%Ac*FoP~Hyu7gC?ukMbf;dJe6@Ct +4u*u#`SExL)H>>MWl2h)PJBCQ0hnw*vqse7*N7IbaDB;}WjcLZ@km0#ZL&lR#YchH=JvivxN1^p=(fQ +D!Lz&rZ#&!DazWeTLK;vuIu4OO0@B(}D%{K*&fA-mD?1vwIaM5`NmRVki4%vuNcNls6BbS8{H-~BMNz-qv +!>5sIeg3Rx27Y#ch(^N9M1n)Q}ZelRD3^UD|+Fb?R*YUQCzO#y9tzHnu)~AQECo+xfy}Xg^<=ja2c-~yLb3+E(|Il6R=#~Yn{|B56*u&Y7{hW>2$Jww$oQ? +W~v)LbW7Iu=eyT0UX%D0?lk(vG-XS06dY+gBMbI)>?mzT$iii+5}b?ew;k3GgVZrsQ=ZQ8`1e)?&)ZQ +C|czpuXfDtqg#w?tpIYu7GzV(+VL<*%H*RmItdAAZOV9z4iC{`g~d?AS4O^5jYO<(FTwufP79o%`VwJ +MkN5XU?1vbWvGZ$u6AxnSFnev#P2pR#Q_WXa$eQU>YBy7;8mDqgzXSBhgJeYU~}T0UP)YY&0LjX7MR( +8DGRU@OA7h{u(>UkE#7B^QHK`D1IQtA5HNmQv8_|e?G-u$~&@E6n_)Ne}&?gQ2gT*zrrnkUy5&}_;*u +$E5%#odno=fihqjYe?#%Vr}&i={~X1yc8fo_FY!$@rOcpd_gX7sudboF`13TT?WIO|yd&eMhA{ +s16vitSG5+&9#;aaqyxJ|kFU6;cN=6{XzmwvdDL$oDl}z!MQT$aD|4EAf4~kz(@sCsdAKc;-^ASZ&If +IyuwKUOsl^E|M)c;fw6T=NRFn%Y+pH1=aqxg?e{2dhkq+5K}fkm;Ksm=CeYgqs_+u`g8QGOMRWW3|uj +1S3Re98liFWSWTy4M+h?EvG)zIBUlp!mZn{zQsDm*Ov__-iQsR*L@y#s7ffmr;DmbKPl*{{zLZa>XA& +DcnUVBvT3xQVQEBg?*I58A_q5BWJ%2;q1Z`&Z-x2RWo~@!zEQdno=9ihr8oJKf^zloIGf@w-y|o)o_?#UDWN@1*!MDE=afznbDdOYwJ8{4d?&H+<&EkGo +S?*x1mqq2c0v;%)u=`1k77cf89tbnJx4$nfw9VPnRGhR+$;zhA#T{^Q5@R#OO%ByakUq?hpUIRUpK!1 +(b7#eaf1%rs#PC2tA~9Wyp`&Hx1H)2CNY#Xr()44n`f79K|N0oR}b0ReZ;sRwd`d4l?k>*{y&oI!)+6 +#RSjH1r;i_>}&H36Wza%;|n(XFu|%0R5E!edkd8F`bVf8QIs-=%;y@iyc@@#l;QHBXu_!8Bn`7bMWx@8+9t^7i)bHW4|%-z*+Vze|Gvb5IQ +M4>Oq~CrmJ#%smzd9n<#@xz-8a4;1M~2tuKPL=9CWo~5Xl;al*cc+$ +39Q~9QupxtgwuC@gC1Dy^| +Fto7jfTF!tt36MOaX73_`!#8Xf|7x6h~G2h8N!&0&zee_ZG#1l`jC!c(hZQi_@ZQZ(6@Ct9d@rK|B-+ +lL8!7F@P@*I1D_>EVISJ=02AN%B!PXupJ@!hxVyYIeZ6%`fC>2$KQXV0?Vemy66gWrGuon5|snXRkg> +^1s6cFC=u9o&-!x;to~qjtG=9u0KMXrOzD2D)ciNB$-o!arbB_yM+vpJ40wY4#fbfyVDDxA-(5M$wEu +g9h8R11SD*if^R&6Da;Hiob~BKS=SPr1-B>{DTy~ew_PXKIMP;l>b}#lrBmi(4|WkA+qW$Ru#MW^%*> +PFm9*nV(8MvuS?I{diZqca0}5{=U)B$^y$}Ua7Q2gt?lW%OV8f@`cc@9K0O8p3=Ux3dfnE4aQC)@J5q +oS?c3kdt!JP9gWI+3e~aQ^F!aA|uukXQpW@tlLx=WV{BFK&a66r@Z5uBy?_2fyF4|UIZtLDo*A@}880Q*|HSjJh>QR) +woY{F(W3_n6$V$h_ifXr4fQNS)B-UKL^RM|f$bM+iT_oPr;@Jsb%sZ|Vt54k8=iXVsaP6!-aB{h+>gK +f^2<*&_I&rxfBy3avcJ7>;leqZmsXrUefqVsvNDH8qX`%_YSdr_CqE?}h_O%(f2RCU*BF>@=-an%Z?a +KV9j-I3->g})#tf&2-n)MO`R5POJeu#`y_^5^(@&hnQ~ud!pJ9QDfBWsXoaWyg{)7XkarSFTk}3(;Gs +lk~|9fd^Y0lWOV}qDnPY|Eo%;c>xfCcs1Rxx;2w*q0yO?QM{xNu=mZEfuz4Bg=M!{3?8`v|qcp-AJ7J +MQQU_y{fm|Di*N_&e{s!wEkA_SgF?5wPREyu6%$_0?D68#t+kcphOB&0YBQ*I#Ri?k-W9(jR~P!GHVhxAUKV`sq +90fB*frl-EUsBRn6b_BM=QScABK7JlNVkeABH{|F4Q&T;KKke*0YB=H+CN7%lF=9kt&@l|)|M=sN`FroZ$EnUa@ywzPqx?}H2M-<;2CyGE +a6q(`Q>RXeci@0N0Q81-f;s|hJAUEZ@+IeEKH+@mLCyz%$az31=YvW(pL&S%7k=RU_v-2s)Kqx?37|~6}DH;Cc6P)|+lH0`f!cSucSNng^KaEEmrg5F9bdGXGU4X7Y +8!8@XTwS@2S +3&G>Y+o2_M-kgAMk@t8sh=F2VFPDL&XKO4m$ew@SFU(C8PKj+i3pxtUCn`c;YHKpQ+#w^)2TU38siI+ +}bm6P}=h#^hwmG_MtwhC*jcJZMkoyC$A~^d-dw&qJJ9WG0tCAA85ZA57fFqd%(Af1K_8AkC!}_z+YT8 +ia)z#G=GM0c#?3y6Hoo;Y{Fp%!7=SS83(mJ0|&J|qfZ)AM&-Vj^IL%fmA~N~YX1jBGM_XBKlS&5{;93 +40Y8K`r{baF0vs?NG)G&2AN}N8d7=E3`$PB(gu^z%VY5|+KkFRl_c{p&iSyVWzC;ugQK%z)$@B>S4o%^&%c6AMm4JgbkVj4&ZrIT;PVWR^`j!h +w&CX1DMJK?ZvV>-WZuJXD%n@YlSA=SwUwLL35M!yf5h9CWfO8+BAj_ixNPz~BE +;0A1fUBv}`Kl*#jYtV0Etisra=Yy3a_&bEdTPsHLSC@zImk5W(?fDVvlh!Q^<*OHr<%P*%+&({y=Ol! +4hwX0u&F4o24(>e0AceR_g?PygPr4@fSFP{`VH%$=@d&-XLt;2zkzf)y;6a}>(v8O$_F>cXk3Iuq82AX7?c2BW7himlgD+Bzd! +4k@PA*@*%#Z#(o|oG1;Jfk&2Wks%5Dx!P+B5p3&9*!FlbLt&4H;wj`ZObdC^eKj2!{sz)!Rw=%461AGkd5zytiHmtGS1Tn`>9E{H1~dxP)Ezk`<$4(|~TqCFE1=#$j;{517Rn=;4n +$1;rkVZvbz;joHuC?Gn@vk2V*qE8BS<1yZFHr@XNewF@1LPGii2EbQXSm?r`F&-`9a`|!{KU4ZR|8R8 +}-)$ek-&5N2>u&9NtAfK53J!lGI$EiK-%D=r=b?YUTK&yAiI`5(ZKx{rv6Kt1s1pMPHPUf^Ylii-H+#f +x1yw1h`Xb%F(`IZnKOrP+qR8kT+YhM;#RAbuU@@cwCk_G{ +#x`q;DwsP1#n|*Kwkx32>dAK19;G$k34JRb$`%&W6NS!dscajjY@l7OKss=@bB8SOHaJcG!_1V0|yRI +OiWBmNJwx}KPu|snP;BilP6CWirI^ci}|CEKFZgxUoYUn{2uTE2aE+6CsaHzhXD@gPeF$m3z5e@M>s$ +J9N@3!hqf-R=P?$`JOPV$4wLX9!XbjoS0!olk)eeByeDCpb8G{l<+O#X +1P`R@ySp&CP}G4&J+WZ+`2ow{qgG1uTFAZNuFF2h}vj1qL*wrj5S!<0t3xT?IxOpJg5cY{cAtA-{>=X5`WxC7=$~k5b6#HFNwm`m6DIKG%a@CK01kkE?AW +n<#*7)l9d!U4R0AB;c`xQ-;IBdVfD<-o2)Mb^7I-Rzr@rKG{{H^M-+c4UhcJiuSKtS2!hn{r-V8Uug* +9iJ%_iD!SXdZ08jXC=ph2P@;Ey{`&$4ln>SoseK3>;^X7_#EBCHZEfAURltw3Mw#OsaHAcd|A9MrQ_v51ZL|Zl0kjFEi$0iOze4Hc +`}z49sotO2w{M@sWSLLv>xCcry7ND3xx!$+2zaP&Iq??QRV>;A)i)=46EuJ^3T3RuQP&gEkD^S`|G)n +F>-?2hUJ+y9KmPF#5f5ce`a)Nyixjo2axySX&Zv_7a{s;X(wZ}F1Mtg$|SWw?+vqYzYmsq +%Pq3Bzwt&8yueGTYar9-p>v`f?p=md3uKG~fg!aLGM9icujo)f+}S%`kq>pEd~!S7D1?lkO9+kg#tfr +ii)9(?dYPJNabr`;dGrW(XSKZCvq59kMTA{f99yqBzTL}R +H3$b<0Yb7qo@G6S%0b6My>bzew*_!4F +udeF^%f@jG9gf3<{*y5_0M?@%{zLp`W6In){YBFGXTg90vqo$~ls`k5BtcVGWe=Ta@z3HW>PKlp}R4h +FOZd;k9ZqTfXspuK|L0YBOS(c{*?5Ox8-`}!yK6R!0i;DE6c{0sU&&;iCHjGZWB%sEl^s0Vd@7xjQ|^ +!ey((T~xbLdZ1;=f4_u0Y7NBB|2}8-rf5m_^ay{C}-dZS|>WXLOg;*b%k-Y%U=vT9vln4>A%<@5A1vR +ORnzWxiq-!Ub3W)wdPmGELl>{*qAEWrnkS?_Ec<*Vza-<)-+1rE#F+lF8M3q&rxhH+Zx68RP5G@tyk< +GiakcLa}=A)wgz^?b2|q1FFe@a(^@fJtOZ^X>wRPnlBsSqU&J>gDvj3zn|qL#AMw6{H0DpRSS(YB-w& +rgAKS38?F>A3C+0?{Nc-zr&KG~jdBkV3j16nSkSW~0m-E@5aQ@kE0+yCw0IuDsT#&C|O&n{npI+en=x^60>+OMldgaQM@$1*Gj{ywe +oiKmE_=tWTV-fml@Uq}j;D>iSv!r@?A!Iy|cVbN&@*S+nL&kQk{4ochIcOTq7gE&uJ?6Q{7ko6zM4j` +1Z*qSiFT49ES>6X(*_%~OEnPHt&NZS3k-z)ihsJvzP$n3^{`td~{5gA!SjSwWtO3sbC+Bm1mgT0=-^p +@cb^m}nJwiSNIpZj@KW#{pJus%w{578V+!*(L7^r{nz<>qg&wCpeiZw8-2V+fM%^&8TpJllxTHF7H3&phwfhA@C0V;a%p7)53pq|jp{Ii1L#=1K7z +H*Sn^hXZ+o&SB$$ybWurkS}0Oc*kQI*OVFl{0HZm1k31SvaAhl0`gAx{J~c&Ted7MCnqPxUG@qXux^5 +~z=QR5$eLbO~VkZ~#bXD5skd5w3Y$I*uy)<1Z%qN1YsO`A5wpehcMO6^g9U?YXM| +L;enjBmVDy|9cE%L*T~&hdQrT_YDFLlm+@D_~C*4_LckU+eB0J=tgTz_W$6qmoHzQ_TYmLE<`yz^w2} +1-$TEPu@C(}XaVH`T14LNGN)g@JIVj~-DlJ$8qs5Fs7qGXQvMiIu+D)sU6e8ASJW0=Yw3+;VQSr=EIY?WUi +y-MvUvf2#~v#70;u%(%(8L(^+z(ev*I-8&G0{W-g#$`(P&%-JXWk&kv@0s+_J#HK)ztX00e>ogAOpvp*88c^4eReGRtqAoQxbw1H@7V$_p*o`^=wdPb +kP*zm-Ym<_a_Cv;lHTvn(r*qT=TNcQRm#KXTUIj{(K$~5W +pu*nj~OT*Zoxa5W<0O)cykd5?_D)bzFtn={oWj`6EyCKX$u41?gc;9%DZG9LN^p;^Ksi8SMgL@t_RUH +QxWz-nECMod0@`0$F~NZX~4bO38y{Qpn=@WsIE*RLK~cyOp2ay;ILqaooHA%5QjXH|W0o1b^7{e!qb}c38Z4@y4Y~m +wpczbvY*|=T9qEthftza&vR9KpXL^SFd)zhim+nEnC(lJ3D*Znl)=&dHQ@9${B3>v&!{xJ#EL19XQW= +6WTZh`d5Z_h`BN9>srV`dL65{56Xe~I`i*tQw6^IcrEHQ#&EuP#%EKAWrNOFU+MUxNv#-toVx9FyeOZg!v=pub3-ft|CFM^bYh3*IF +?r$G)TfBi(n$c5!2zYmkFwmQ}QYxj5!tnEPSghj}N3yc1&>jH$5Sh+9}NhrxL9FLQ>wZB#B7Z&u9d;5 +-86Y{);96Z#`EaUeNqPP_?&gyiy +JOsrc?0H7VT>W$^uPRIZOWjs3=UkQcaCgkw +UVjq^!Z7xQfN-9<%3ch$u*);~8S01nSXw-3*MIegdn-#+T$_tiZ9o}i!rcef|pajhEeMC_j7erwe|xW +6#&9Duv6J>`eJ?R@6A>S4g(tY9LqbEIf4)oiPGMoU|EW6v-<_iqE(SZRErm +$^rBTvMDPP(y9hH{IKgkUhq4ZV;E2+wxO14s<98|6<-z$M?8?~$Yx|*s^R2Qo&)vaogdQkmRJ+EF?Jz +71jf!0fl)!x!R(vEA@^=EZeH}x)he?388sTb?FbZT@n3XFrsMWX}hMh25%yUNUx@t9KU0FXigiU6fSbM&UV~zj+n4QN-i +8w%%KP(JK8x?+|KtH;oX8U2ikF=P=UeA0(rxeY^agzMlOC63$pqQw!4~w0LczHeFk+t+FWgBq^^pO=HQj~Jy!Ez*{(0xo|_>e9#PAQ}Z6oJ`-QvuP$>LRZnXG@ov +zJLx`pn4YAk>3MpEUZX$IpQxYtuo-B!HBD2PUCi!gKl3$nm^spX!<=E}nj6f6X1=w>+G~AgeFa)kpEY +Gqvd*jri)QI;0-Mejv7M~1J;I)3PqPn*W8!OZQ+S+uPN4IoBRS7GuQ-F9D97szcSbq$oGfRRv&PxvY; +krw`<+wHS*OIgi98MUcnaa8y5uhfNKK^X5|_G5y`@NLpA@AfYB`|uHT14}6Vi%Eq$3$ZHjo)Gx?EaBe +{Z%kr<>X48S|2P!wj>+L5ttD)>)ga4?)K5p|=BA6dT4yvq@|Qo5!+QKIqXgc9vaX<*b3-+YYy<+ZlGI +oo#Qk<9RxNhZpm6{2Fg4f<#Lpi3E`XI +_)b1bGxhkvOUHA+`eEp<~o0#cj15F@q7;7%y;uo_!sdV!XX8`}|Yge@o^o!7^=ZtXUCqp6OI^kQovofwPlKIbQc +Kl7TDX?3y{S#nW@s7OdhM82S8t#P>W%dvy@lRNZ>>xED1DqhQJHnOn>fvkdIumg%wltXftbE5Pb+4Yr0_ +(U#W=W3RG!HWNm_k_Fn$?JPjQlYo3T?e2UM&)|#rGQNth;amA7{v!_&FNoLk4+4FFq6lG3CJQifD4m4H5WkwfJ^@)$W!J}385`YEfGJmm=R@>x +|@Iq+{j__|AKbFGc$Z@dM(s6m<$mApX0$b7PyEU*f#GOG!*SVuMxv~fOr$@XlopdBV{mG(*@@&I|L{A +YQETp%9@|JqV{P8p(XR`x1>YLGfwovdzDcd8$$k7!M_H$WmA!5S`Wt@Un(hm0mu!3q|ULh@JO{Fmek= +*ungC~ZRz(e~yUR>J)47IvsT)t+mo@QJ8@;Mi^WSS6K91nhjA{GOaIe<5eVxSFZ0)aB}XYE4bm#%q1R +JE!WS0m-N63-natao=@`H{*oK1LeWc=V&=uPLp$iGw@|;gsZO+}SgWi())A}J3SbfoWeF^U<+41spB1xGR>uyoCFp$uU|gPEY#+DF>>G9<$IYzIxw5 +Mz%}_Exbgj$`z|lOgkz&xHpYMEo94q%0^bmih$A)cATANmslCQ#r*6#_F +z7gM{_Sv;K@7FmOL-Z;!EbSo@ +DsH}9T6ZJh(OU8P`QO@C0YYAYk~?}v=^ZwObir*#ZVC~ynxrqB2A==DI(PA?cAI9RF$eyRjNu=sVY^a +s{FsozW`860|XQR000O8@1eFvZ|O>f$g}_e0CWKW8vpJHh!tn4ZlR8&wjh}0(yvw}5X;%qd_u$8u`efVu{Yg? +_>R;v&|AtB^N0^y|u5Q&0ymH`c*dGN^m&N+8BSsu~v@B90I{*TX}580Wy_uSXH_ny~1_ujxgD>*aAaT +fT~b&jj#*gp^V!~eSAFMY(ibngA+t(RAt{97-dx!@;@oC}Mee7N|5$DKtFJn_VnlJmiboW;Q>oIiQO> +Ah`+^YJI=Jv1&YEyZQzG5xPs{UoD)>V(+en-x1IIN+JJv1Y=J^xQn*X?pIQkVVhk69y9OlnGDK_cjB5 +m+}0Bo{hY +7N*bbAr$C(YiQqQ-c<+9nUL$1hGVghMhp0%dJW;6;mDx}Md9(9=c!jFZf|3?wis9+@JMR)^3U>&1LYW +@F^0_}^J$M+J8F6Hegl0xWd+sp+wX2P39H(q`*FsDk0Pw4-)lYhKT~z$8CEiG3LherW_YTAle5*?`jJ +HVT836Jss{1VOKUVTfEO6 +qf;U>J`7>I3fE}^TFr}z~p+ESr$=gQg_*m!iC63K)z19&x%TWZ|U6`M(KW~1_~FIZR!(t>>;ZeiWJu3 +41vrs{1GTv*$NH*4#*1>50&6ws#Xu4)v1%6qOwb9b3xStw$~0^rFCM@ +O>>}Jy1!C>~1RHsTNAyBj@Aj4TO0~KO%DOc&dz2nH)1 +w2+vO3JTAy-nj!${i<5La^_X%@^+4tX9bKV#OuzfJXbVt@!C{rHA)x#)7O0fY)reCQNl?K1kBr1C##T +a>>%L&8vZh%!<%d3K^y5mN8m%9>q?`Js9X0c&59fq0beke;mItJ#^B}&>(rwL}1WXs*DJ2n9&t;FmBY +D^8)=PsC9NRyx{xjSu8GM%T+$xY}`U=bWE;EJxju)=VS+2}q(esGX;EJ$EPe^g@`|3)JzmVa|5wx(;YsxPa#FHI!h +LtBP`HP+!HN8gT?z2CE^1wckMk-C;HW8w|ij4A9E}BMA5{0q$#JfZGkgTNt350nR&(Uul1Yz;)Qh`jG +2wY?BEq^Uo&M`_uh^RZ#?zv#=0Q0C@6<(0O?r{^oG-Glqkq2;G|72u*P^GUTIz9Vb4=p09_px=!K5o$ +Z<{Dl?%|l_qaE%QnIUpy^F)g3Zz$GmO{i@)oH4fi1=twxEJ4bz}==Tk|>9|8>YySz$!I0#VJqbnh{j9 +S3HnL5>6*6?17+SZ@MOX%O7$l(HOB{(EFzret~7sU7YKIlIw>_^{zh0{$ayBz1yz6K#;dYS+(w*`xs5O-y-L0Am=DD$+w-#0Au2ckU=ra +)l#e6`6*pXp;{qnoo;vH6bQ3pS{R=j28x#tyJ@z@)TSa2=UN`nw#6m6Ufq5yqql*TY=A}t|Xg9n0K2=H1eHnNGq4g +grAjZuKUoS^Fs=)t|v|8*g>sBG0n3VD*tBIO8qv*B@-z;E!oEb2l64i5DJ0xXbSY8!URgE;t)lSP8L!P*=eGm8jSDM&I4W68{vUH3yWP>QcWmQ9aWP +a3SvoSMWbE +d>nsF`w%~Z8B?Bjxe^XKy;LL{Gv?zGEK1Em`%R#)5ScUJ3qFyUm4SlwukK0Od-7050mv&cvDKr9*K3m +3He?RWyr0rw8+Q +l%7$S-EwA31){)?YTg5Fk0!S(pW|vH|L?@CH=W6Sl?U;5_*dI!=_k+Z +LB>ByL*XDDs8fP_@gUYVZ|wsxv^%TYDMy>E(IwrsLc1ZoqQW&hRFr^4Nqw)?!FI*5sOeYZ1smQaX<92 +PP0>P1D{|H;e#I!=+;SfA_wMN}YCz>INwF_q~D0RY>$fsgtBlsCUHrk8e4yhT%Z5IfSIp6iSv1H@d +Q9rMkl_vE*^)JqVlc3)4!|5>>Xm~5wZFd%&skBb@b+lf1q7$6M(j@do+{RQpCu#9NlrShUPX_#29bgA +SUly%FESu^}TrLTLAjqK4?~NK#G;BvZZ)DR3+Sj?+uHy`E@_dbziH}wK)NfS0nX`)`e+!U$`o}92L2$FntO>PzB5x`NHHxPPIulC8RDR|P?*(wg +J5=T{&{K&)xFR2b4P17yD1~I;GGaR(E;X{0HG|Iu2l7y_-^HQeN7W(jRfbk!oRIPQYh5CS +2vH=~F<^T?t?#{7OS1sB_95R9Dsr2+)O-_Zm`}>Txp8!pR6ST#0J|QZr$8FFgYFpbC^%9ECtHMyq><# +cI4Bi|ng*I8)VNeknDYOQzFL5F!i*Ri;!t__P)2TEbyYBJB1gDCrs&K8PWz#Y6bJW +dDIJ7(xk2}Je(QHPJav^QpVcM1U#ZRA=~K3<4@}2`w<6##;sCoA%Rc2(AOFvTol`SYNqRdeC3=A7HvXaXv0FWd_Nz07@`d*VI2^MXQc=HMT>2PesV`4$|a5b3nxjvN)nYFOmDmDHp +uR(#Wq2y^Fwbf5wqJx6GX2dw0Hq#q2JstW;aA%r<4Fv2r`Siy?8+(a3=RlFzPe8o@>5Sh2_SAR4x-TU%&mY>qeKvSfopx|N2<(+5OZ>uE-eO_wfbwmbPBHs4=nl} +)JHL%y%EIj05uZ{Ywe^sE)N99B2ozvRrawH_Dcr$^_3?nB!tD1epCj=o4nQ>@7fF>V-ygg|M3SE3S2l +sTP=s~(EVJJUdvY+%$LnxXO$8xsB@ITuvMm6Tys`&1_Y5=#uxaP`16^I#_8Af +02-TaXPwVhNyzy-5V^NxcTK%tSNRw&~C=(dG|(plzaa2F@f*hidYEBC$Q+=6-yEw++Py?QkLWk9BYwzu7zp|Lm!X)80|Wq|`UVq52JADZR&@w@rP4@ +sLci6Wj@8|!1G%^wE4DO%_KASfOe*e7pn4FPkphA3&|%O?Ind=RF)#^Q1=9ggjx^)mn)orb0C2w$n93 +4ouXQZPAe2|C??8#-<>%CbRZZROV5pmALL1*S_;|*~`HR|?TI3=dNQ{Eg?2Sw|sU^2!eafqr>{MoCc5 +bo(crYbu$aZ_UrxeAPWxLH=^YG{w>$ +c=XsTp~Gv1(tZ|eMS{9IK$_qv67yR`b3?2W^;C)K;^X|fqRg~KQ?&v#eSHGy)aL?3Vk(dxknjhTmhUL +Yv`NVboT79sGAqxxKme%(0qPbgo65CFkZX2l#Cs#hY)r~y=W(_iM*JDyu_J@A-DUJzoCq*lJ)Y6;WKY +bX-qVJvvpaCA!(h>1a?bP6aWXT0HiGqs^YM~z9!fM1)GF7WFPr4%RC7q}2_m}sqtiRy`VU&SUQX +rQ%`LfsIg!Ugp7LSvcVh9qHR;+OMIaq2M)GwCWE@7?taru7fTKTjINWkd?X|($5{*(N}NHRh- +e+P*5Dm7?$ZBf^vfwh%*5ri}Ip@zV*I6pzq%)7FmC>hs=Su;=^2BmWRuCk}Y>Xr0 +{6&wF43mT+HkZ8Y5St{UCjDEMRc%{`_C#f+hb_4Fx2!2+}E`TP&kVO&cjsGMxbh9n_hgY)~a}sZDLZD +yCFU0i9m;jf#POa+-neLQq^hQ~%ftIt)R7I}<3ddc!r;2PtcZVZ_U$(Teo;YEtWtfheU`{g~dLhTPN- +Z#Q63KU5z9SoO_YjUcq%s&|d1`p&+Bl-4BZ;=<7=DOs;Kfu +R_87?LN%+wQD_wF4sOmu*1m6xJ&FaJOyYk$QAzkn0nM{R=-bq3U4G*#GD2b$zwBTuM)C;SzCRuXa7{4$hM3L-c?z#z)!9JFy0sHj +$eL&3VZ03v7DuTF#|2Ax}*35!obNjh=DoqAy2yR6dLDK7~HxU81ef1Xnu#HM5RG@jKef#o3XMrFr@M!APO0F571clsT)8RRiV1qH9hpfX8Uk%pLT)uOe|6)APr*!+2c4ePuIcRn;Lq72=->NsM +cRT=HakDO2%J)C}RX^ +zG9yl##;dEACJ)-M{sG02x3hFbUz31*fpI?zEtG+mZf0=*J=4M<5IePBNSNP*5OC>@5=Yam(Qj^kuTLjSEu1i8C9*}ZMTH{%Mt)QInhG)7w_~R9no&NAD +*RKIqm~ey-9ZAF{zUq1d1J;wwqt^@W6Jq#7*T0Zwt!MyFFo6%Dby@Bz;6vL=aXw~KKCZ+T2Yw=FZ-k`Ko~qcfZxb1y5u*&FK}6m%igr3D|(3qEfX_c)1x->R>(?*Mn{jE0fn8Lb +D(iBkN9;*2l$jZT%o&DQ0msA#e(-%V;KNrw_!7elF?#cENhYXW;J|4BQAP^yCAQ=l+rbY{F*>l@0uvg +6mLMOQFG@|zYEZYEXZ^gEzk}UmKS!xmlwY(LPm;L=@|_`m2sgJ<2~~edGH%CyGh*9tz8b7L5#dZ%Y02*ir(PO8z|XCy&A!eXEy<%@J1D?9ST5*CB8BVZQDRE1Q +Lo0Lx-Q9Yq`D7>+k!BVB90WkI0+xAi&6r{Xwt?}uVEgbUTpSANdbOiVV5=-`VSs<3QG(W!MmkUDeR)}w19il +Qk$={73*eW8K+Rj#pXh#3c6>hO(5q1ZGa#j?kselEaY!H=>-*SE}GY&?>6Ez?ra^_IBE+ZNfeZAg1${ +~Z+X@Vd6Okesq(>`?L6*Rsv?tfX2D!vVHWi!Z957xn1!$rSIe_&M7;*fPX@etd3gw0;2@jiQg; +p?8h}&`9=kWvYtP~_p+;m$c8zz!qlRcyO5@Zh#aAXGf4zJsZ&c7HX +tZYN>NFhcZ?%!0ueYX7Ih#zQY&?dgN^+qUeJr7ojGK}Q|jOqM7R|MBr3bS!1SE@c0oClTUGWIn#!asu +e&{%iR(C!wVLB#+?ssb!;|CcKpaD=|5cJ619O4njjH~Q&XWEk$cWWKDr=Va(S~mAwCt@Ev|+8L6-UCU8lM +m7e8rn9De*5x<}3EqVZ~z2E(uAoCG=QpCJKc?ai&q2XZ3?-CfImDk_>62nlnppjFltE;LXGl{nk=7E! +KEP(Pa$n-Rh5l~pX>y;HgZW#R=!6;@Dk^;ez5j0N|p;NPhF+9-MePeT6)ZAfp8_8{8kF>uJo1G$$B#a +c@l=QQ(J2Z11u!y$syc@R1v>^MZ>F;0etXk=C>b--+#4NUhBjerc|XUGA8)0Mlrb={k{s+Vo9U~Kb`# +5O_rg8&pl#N1{z;R_V#UUfOmBrBt|5^wj00pgP;!0!Sn8-5>?(%^S-@MWUY+KZ((KNd_uE()KiS}70; +dvq~OBzSQ~pMaO;NkpqA-W1Fzeb#hCFkO`E6DTNp8$?gcrSR)}!@uRD<1u_5a87&z$-NSvKxjwc6DaF +od@kWbJU)TnCBYLp)NC5I9)9&!;#cZy)Eqk8b<*Wzwxe}Y5GB>ry9iNGYtMwQ`A`Dc;^P4{HpZjB0a^ +~Ny*fCgPzlns1cJmzUV-33r8D{>JPRVJtC3-QBa*m1x|Cv0M1!$}S%N_wq0>>M<0JR<5OOS?tr`!bVP ++(?6w^n%;&udxPGCu$k^sM>r0d`}TN(+!W2Hgxo5Po9vK(wt-pDGN$X-m*vuEK2aGMl8d6t3_qDRg$< +SfLWS@<&(f5bxN3upsl>~#R6UY!uX8iLZZu|%Sx;Ni)8p9WKOaR;-Nhtt*`XKS!!N879%Isq*t3MIj$ +s9c5VW{qd=Lkp3{qK_(09(*!)B9v)$$NIl9naq~J$PVZTO;86l?GKDfx(!bwWhR^dbBX%l+bqA*Ajaq +)WvkTSw-fZ%#@_=mcH&f0t&Hlj{QJJ&Fflz9zfmd}jOwY^C6RCf@kl#$hxKo$eBv_v$-goJEb5N7zmj +1h71VrNL`+aUg$Q~zgsvML(>&k*E6pav%)R~SC7?Y-f#?>uqwKNQhvu3S>Pnt9d#E2ZaIezD6c16^>W +8iZ(yonOiw<>alNTF2`+OJ_nHP|XMymynoooGSZU$=cz+Tioe98`Q#A9=(NZERo&%9mk8e4oKA{>*u1 +};vlOhb*itlA4RtCEb3-RS~9rK(2!wV-&bErzY4o>exOEJm!0_5sE%pu^gkA0Ed4EiV49SbPS>8*BG_ +RXGkOw-+XysXoHv=y43&#}H!iN2c3>kh+n$gcEw#$1lX|+}!;EWrq(JY)<%Vqh-fl~AWE>5^>B&+D&CAIj0LL#*#SyoW0{O)RhuT=wvB0senpEMA2e9BH3I^tv|j^zpZF7&)QDUE +m6l#G@^MKmo*CO?phOkA{pWH3aZ_yz?-Uv!M)Fc2%b)b232)W{X%F)tt7YQGYOgzPiPz~{#?N3ct$MhhdonjIrY1e_iu +VjkE_LQy6Py`=yabcJokwYZr_5`0)PXO_d^G5RJCP0>Q4Xro)4PCnF}s2oxqCRw;SDAtB`^!?aQ*LkB%}Mq$WprynU*NL9f-yg2dq*=vsg=wO_kP@KW>`oe#}%Ii#~jewyZ +(eu%_g=aJIO>w2#8r&k)T(J`X+Zx@psF;t~)_ETL_ISaowq1#jn20owHVKzyrrOEc?p$se!^%HY~bV+Hl6GI? +rMHymBOR6hl221D+eUneFNkH$P;709c^yIxY3lQ-KA>wh$T|*YzAiv0DrKKdre$-S +$%9%V4`o%Y09B;M+v%V<&Z50 +!=`B}a5;B?0A^ykhx&X?VMA)FH|y1ZA&Y&&gQhsoQVb_E90NTk +%k}_oaR)oNJrQjX6&O8%6#n5C5d^`eYyvx;plJ_`N`>?;OKhm&!Ws4tUH>4-7}B58B`lXRMiUQ(`SR1 +)LWN>eO8^KM^ubMQNKX3onD?h+$YE?bLxgi38TpLsLIDYsh6qOZfWkjBVSi!@x0rb%|e-3)B0M +jKjbv7l9@5^X?QYNf@7u630I;VV2P)f=8~)6C)fY+_`Y9mw2TRHT5uMcWWHS$~2S^5ts`?)u63Epv~> +fX5yO%w{cySkZh;Sch9B0uk>qJ6aj@GNtSC?lwu+@T&*%s|AyL`(jk8uFn#dgZ{o-u$eG4U~UHHbrdZ +sc|(FNKDo*kFn=1z-W^;Ih%5UB+lDojT=F*-DO3I?O-dEqXM#i5v$m~gZClUUww~H{U#b|n)9#Cu9J5 +fP_%%sLtML%;Ur$Wn<-MI#DX?^Vj5KcekDq`AaB)GOA^kUcGZ3cGx$ADI; +BP3a0b2Q+uQ{fKJ+4BY^@X3P7m#aY0cF|cRe2}A}9CD>WvtnY +TQ=CMW`91LS18-%jp6@Y;^TM+nDi56k}0Iw!}7ZWiwYc8Pm8v%WG`gO}8U&Tpx;~tS<##-nIT|JIMin +XAf5iD}^98+_FA8y$g>Z-jc_dX30l>RCDomHdDkxY6Ngg+qXalzT5qBu>=ZR%1vp9>CD|GWzak%Bp>8 +y~=Il+1G>%HkmIU=Wz8`jfcuIrJ{)7==y6!X`sx9tM;}k%*}I3|@qwjWp)7Th!4k3{AZFc`5tEY}6F? +K8y4~>)R;S1IHOEuf;tXSg!;3QC-N><-kr99iN#+rdR-<1N|iCPi>bj5fz@6*0C*C^#g>HpY1|UsN80 +Yi}@YJ)H_MG`Uto8oa;v%{n<`bWML)%M=OhA)xtPjne)8w%=5l;&iRfAvzQr4j5z*{93_8xJF*}<2-p +acU=rmeP)A@X(`|8KRZen0ZG;T5)$MXA;=)AwBFgBra3MG9?Os#zIhFL9Z0A&xeP^Ecopa82d?nK_tf +beJazQ02?EFf4O%-exO?96iI;tL!LO}da^eY4X?w!)LVi=~}7WKEl0Rj*?!UrFt$uu+p_ZdX2zutiw* +LIkVr-<^^kege)zp)ynl3HUj&#jO`%IuYS($z+a|22MU*=xz6e5eBjpNK-Xf5q`DXsUWA`5U$}fbKzY +QVWxj<9y=v(YL?Cam^s2>Z7N=!uAvCqYLp3=d+Ub;7(MBbtz4EV7#0*9RhS(vL806Z~u`ol~0jNwl(q +^QqwXtDAo(ZalqG?VUzH!t_+P11$AYe_yFLXCIYVPC9YF5NS2csG3E?vbsdz(T687Fhu2e+%k^M7(7o +U7z)WO@1ww{u2ja7mrTFd=j*HvD8DD4J@voPFUZ?$R2QK95jvv3w#Wog*5z({`?S|^;^jM&jtEAnAWh +vWr$2fv*g3wDr-uo8)+8x(pm^{s3uK;4Uhb6_bK>Mhr}|UYSy-SgBHGoh=D04Rd68{mG +Hu_!1;v+#W6!F-zKxcrMfUYF`OHR`o^* +XT9;~OQ??&CU2uW4GFV|(GG?rvm4{Y>_qkKR_qE&_{hLmH_l~Q#JW++Mn9&LxIxc7sTr7&G!!x_+J`jiqyr-sbW%UZ$D +qBq&?hX^z)Qel*46ct!`3Nk+nH)S=HOmv>g*VyXg!GNPYWF&N0)7Mcv8~+VtjAwyPVPKv0R?ZxYH*#`8AfOqkllTsFQ4j)jc*3zj~Ycvq^?ViIwqGyiZncPsN8W^unkMxt1fD@J4PiX@fAdf +`x`D6umxhOUz7Hp5Jh2QG^WAS_KPLi|MVP$}(;Bp_yd%yEM=1n#B~1>4t)lTcr&JS;n<+R4u3AT!^Qb496Hu_KV@Wl6z%b5`-c(H4YAF%y5s9#US!WJ8G>4oG^|5g@@oE3?&kBnozlXuilIqYk$X&MD`Ky`POUuGbhp(s@*if(*|yZ%B%#LnjE`m)QEap@7SfSEs +mG4`8ultlpJxKTt%|4?l@%xT5#FwynRwo)*AGPYtkKyRuYY-Rnh3z>G;9kzevM((YK^!R!qWjd=3rb_E`dzC0UlcV#Tp<_YWWhoZv-T)!xIGVW`*%MIvRz@^aS1 +U&X;{Vu;SWEvZ@y*MP~e73{RobrtI@7-OQ)%mw?Ze@}vp-P*Vt@rciIaVjp99-ipy^*Dc@Am$%U1NV^ +7W@T)E)TkXt44Q*6^V3A1}`BWG4if4{$9ax7kenn-fyZnuf_Unl5p5j#XW(3Vo3MOd(!2pnwd38J`Z& +gR(Gn}OFf_&E;Mw-bY;PW;7s0_nAPA6tj1zWA5lDYvnMS3a!mAp{4L+B)vbK*$?Pk1TCszU;%U0ZHl+frcUk;{5q<% +zQ0R-_{zU?e}ZBE|x +klKhyVB;Oa?E695HNB2{QOM{L6zn^fQB~L2Z0G$m=^ck`>oHcla`rET)pdW){E$w(~@19Vi*=cPMpxz +8s#|qoYodMl0m~@g5x5x5g_8G%@j~0B;eyKawLhDzqn?(}EgAKS*XM~v!OexIOedw%-cCKd +QaHPMZiXqLmwfnojGYg2IYtY(9B_F4Pqyrxb>tNriws_{dLzp9vT;9YXv*xn>r~@JaEBi))m$uMcqCd +~be<>p?!`Bh|<2THr%VkQ>)OBMU5IQI602-FglvO@1ct&m_+acM~6pkfrCw_aO&r1J?ik1gbw|ApOJ_ +w)800$N{uwZVp>R2k`tEg_XT`k#Ir9h0>zD(u>#Jr&xOWs$HvC#~;8cQ17lO32D5NHRb?HhftX-u{1> +&+y|E}6XhT2(xdR(BRwQ^6mll%K780vnMv0jH!NrFh(3SOSH`v#K|VYp@aW-L0kf-4R1%>9Eq^zAmp;a+UGLLtMY+!AK3(!$p#r%A$vY@Mx__2v&WfN6CcAZzKq%AE-AJzft`g7gD0F|tdqMsvt{^KO&5K(QrG+GxJQHTcj~Bza{OT&XD4Lr)un0n#nO|``iZf}S?MD)257U-1Gr;2_!bI`Qi>f>8=O1I|o#v;Wb)OA +3#H~*Cb2iYqYnD{t2~mj(aXetCi +M}J?^j0dGvh*)J8R}qj$8T@f6*bB{vH^Fx5yLQIBEJVN@^QzL9wfKTiLpCqFx7Cx#ZIsCD);y6M+GW? +U;7FK!Q`xehU0tjcf!~pk#dw-_vB*Ax_858BXm*rsaJFbO4=#X7_n$l$Q%BS)(HdAo4SX4(eNUswksik7Xx(&D;x0ci}g|W}H3ia_ABVH`37tK{Z*|iy|)BgU}(6f$LVL@ZB#*CHIqB34A?~sPc&)Q755fP@ +H7{ZusYQu-f?XScIXS?V=Te92Gu2QK5iMj*NGQqlu?gJ%cfB&maU@x%MKciJv7@WdeY4~&Obm-sr#-WF41y@9dZ`+(Zu%4#5! +l%l+CAh{tImg?l`LKGTIvQI)fQ%O7>w`D>p{eRp)YBNX7`0>pXG34c9Z(fdK!mmQ>u_3lSz3+d?PqD?UdL3@A_A0?Oq+<)?Xp +?5{cm%lv?HTvU$um8ju|0*Zpz;17GY=l_U*o~(J1`%;yHF2B2te-8cBm4Y+)F8_|h{iGIW<&-#_c{9!5F +}hS&KTJmfxp%lo^&lQGk}bfrCyN<1_D}-Pv1>Bf>TU64VJ+lp%1qxqr0ik?4PqPx2|RdjbPN&@-D;tXCZyE!QtTIKGNMrni5(QOH|>|K*DoahBS1kCkUKR2G3N(zPXlZ>_s7>r;Oda1Dkl9#QvRyx%*2eI13|Bo9J+heb7Nco6mf( +)a{hIO5G1gHC~tIhrD6$=w#dJctq(`ZN8B!?OnV$Sr +m<4D#!~NuqNzJRS8Oz8pt{+~SFb2QJqnTsKhH*Nf0`WrnpR!B6f%IIyyqsK+YRrA0rS3_5`4bS_m)4O$X{{Wi8x>4#N`Z7% +DEtyF03g~62x2op9_j$kF0JF!}g5%3oU=x?jN!slhKHZX6dAdii{yHt!O7SGgXhX1Il22I(@g64(?ISRzjj +X=c?fwm?gSKzI)N9b;8LMHv7G~LLb0@WcrxYSo&37FnSAkWk*R0pF8gA8FJ$Rp>9qBo +i4Q-1vDn@yJ*8{@G^k8gGx{BRu6wbWfx-EvgHI~u_juZHLxSibTUX7wk{;2E3(f;8JK73@X&|>MfZkd#?fpm%)sjURw;AJ%WRS$mmOO0e5t)g +0LA$TM+G+jO5Y1-5tn343`CoYc6j1bT6!u)|Yac@`FE6>sZtT^&bv=q3C_xr|L*_&1BJc)G_iheP-<1 +Z)4bHHT89jotzrh5rY`0~Sn(RWAQ&a?C?d@ +guDCip`#TOFB*AHSrJ9^5_EqLwF*LfR6wgB9|9$H|17_G_-Cl|X8m~$OtR$#H +rI0#p9{kDd@?hw>{;4>AIyN#Y!Xn8hcj_k{!|w(42TM^-)7@ilQ&?P*D_GRmD}ucl|6ZCru?vt>+@`s +;`eyZblI^_W}JIq&Me`>9vZIIg3^jo=?%~cd4hX$aEK}bc41cKsUvoyoPk?kqa*P2L)~4^ulObr=1%5+|90jou56K#!)O2ot!z8^WAL{WdN3 +?my_wROSg1c4VC$|C-8+aV2lPZEDGE5bB#l$D_Z>Z;p)hP>G^jhd0M2vO%-lpOY+1Xy8LHqR9msgdW90MSzPX667tqVBY78++h+T3p%|O-kfCb1YLSC +1^_waLk`mI?t@aGBBeK-d7r3nf+Ss-Bwr}iO~G+-X(nKrEJ!n?FAYo34M{Q0gjmO*Q4Ulepa7}Yk-=P +dBs`6J8Xs!G-F-zfT{-SO{EAH$cDT!S{)IIbvQfHU(RK3?$iAI6ZbGw5`Owo42h~a7LzQ^&#vUnMC|$ +~>1d~erIW~)CEuEKRJ1rK~`ji6!Qy5%mTXord`$UY7|E1WESEn-ijF=4Q%giAnx(`7bQ-;jtO{>ozdJuOGqtE(H)IX(c3fmC +9WJP2u+;zvaZKBP?ScNvb{Db(v_Zy>{uDgLljuyy)Ids>T@3m@-eWWwa%QPXP*Cih5f%VW!cp_&uG}-T-=koB+9fkR+jfk&@hv73pOGaD~dK68_K86Eis~$)^%3Un1{7d!bW8sn7Y4qSeX#Wi29A=D+!xEDjcy*Jq@p +4Y2X`{XWL@eF?TPTyLS@z2Nqa|Z-_iZ2s8_sX9qNs0b!kQ(ixxgnr5_~f>mebv##U_Sduf)BGaaQ^)H +D_5eko?LD7>5ai}u@Na11MzfBy&>39!;kQA2n7FqW!-o!#-bdA58n=0yWI}yJn(FVzcxq@4;B8};jb& +$s;x5g1HNV;{6Px%VM*Yn6@MrZJXQQ@$Dgj?_V&_L7Z;rwZ^JAx?B-|{R_%DuQ-fNb$u_gRf?a#~&E6 +wbsNV*uJKyX(R%J19W8GT(Z#qte6oVpvWOM>rz>2zj^29S-Fq;lyRQLS{MB1?B3|j0m#YlmZ&Myv|i6 +DmyT;T$nHpHi-p24HDAVGbBjb!!kG=LgVHZ3z@py8ksJGn0hjc|E=YXRkrQVyB8`E?Iwf^xZU(QtH@4 +6C{hdYt|>4ALT3Oog+@ovV7DuW->`Ivxx}-TB55EkV0_e?uH4(SGbzTIjSiT8|p`B)at>oK1JsJd>GPc&EzW!EYnc|N_*_=JmUb{(s?%9S$1mCd1vzWPwxtqHZRhZ1BS`f-j5sXkrDX8z-VtdDLt=oK +;=AXkOTW&y}m6P>rObOE^<)|-!-LpjSWI-Z02V>)*0DvF2VzOC!8xRkmdAXo9eKSkX@3i0k0T0XoRbp +8R*P}=D!gS4OQ2~`ryO>uVzvpPI;P10aBINk8lLl2GxnATk*U4~~?O*dSkk{)AL9^G-^Q9Q#Cx_Upvu +e=SJ$U)RutGlhJp+aZ>ZX*dDTToe@T<0BP7#}SD3($FU1-u@;XKGw@;YK>mrRU6;S +jlI46GWBxSM(pL~v0gspt3Ct0JT`q}TrYdS#m*z7Ig%Ke>&%8FFC#JOIL;XFZ& +*=J(Z%y7uH^?l +0JcUPKpLdjY!9ttRZoow55x^aH2?Eu7p6Do~{J7g_)Kcl_FsKS3IV$8E@)>|%ABMKo7~YFHel1FmDAi +!18_RjP+0 +?eFN4JmBx>ovz^}OhAWQa@P53#-RVnLH{|ct +o%lMR$IzLr50kp`fSXdc`JylzN5_Apfbhg}MrS6fzfxs} +2c~+0)S5=`Zu4?&$UPvC>Nz2U@NuplQug=AoZR$s4;*|!S4*;>AP=_?E{8;cGp3)wtlnB4c!9OBQa@| +y&)9`ef+zvFehYoRwYo}x_btea{kW@QP;dqr;p!_f>KjDckte&7J8oquSg6Y+z?%7fYR{5sTmS7f$p6 +MXWm`d|TLN>q-24F9gcR)Lo_8n1eAjn}*eqvqHY&_8estj_khQmX;t-K>>o9L9LPE3{x03qY?l8?3k` +3gfTs-*PgXqKS1VM3#s+5kG|Mz6sz!hv2By&LV1tQ^h&k7nq&N#w9(^~o+5KqmIHSKAqXCM)AV#?U{p +jt%`6w&0q?q=_H&`SQ`7D&ug$MRy#YheIptz&fNflb-)4N49e-jyyBE|KJIUbSevt(Acd&>PNWJQH1j +k4+Ow}BSiP{MYF{sKZ@(!`l8##NXBu|y`xw}Iqo-~vKa);&+|tt?S1)@pNWy{!)MurI3PYxYI+B0K~r +v(H=MQp9b6kSILvgq38~kv+mA1cM@hT=1Jq9s`;wpH%qDY)~h~X^GCZ}cQ +h6uO&#_DJEqFJEu6-GU>rk+xb(R{4LWqkpx*Ssq};0LAfnW#=X>)?g-xtmJilSztQK0935U@PZRseEr!x^pV;e9DptX +AH0eu(tS&JE!|CBTc<5@Zu#frP@$vrF;LsnJ&iRt*DJf-PoI&qjT*0|UeRCa&rO&PFPb~fQTI70wlAi*?_IuCKa4rE +2$445@Z|QWHF6~k^uQw+(KzWNy5Ect*Olw!GH?bo5ev2G!6xpwqbN-zTl{v$pxLfZ+FXuKGo^Rte1$J +D86R)y3ma7*kDl*`ry)fxLg?JYW(4DUmi4zCMseghZFV9n-S=-+t;V&wgRqOpk9GR!lg+F5b5Cj=^{` +glTZc$R(@j8L&fk*XO!g7hv^CWb5w)X%FP9R1M3YVbN(rVI5p~K7DoKjluPNj*CLcIsi*ltn>*qG(vI +GrnGo&6pcJ6k*nS4Q@se|UByn)YzV5|D+8Dvltp2gv-pGq4gqC6(t_)##4T*jjt&^#t4$A%VKr!G~T! +qq}20L_stCK-Tdf(8BU#d}wh3PDtPiWQRuJa+&DzOxN_~0}4TG=uQzMV;kP3u#Y)`UsWf_C4;APl2cg +j9qh00yXG+Ka)sA5Taf2L6jpP#=HoXss*h6Jq#Jxnt(aZoGjA5r3;*XWCN}rIEGfDvJS`fFrB7iTNG8 +K$4mG<7Qk@k8xWmNgQ0&q;JgOME;%uC{UV#+ZTs%f+47oArH3qp??n4VdB4?1{@I0MKk)Y{(^)J#{tC +6w#ss4yjuTrZ!zMaD`IvE#>PYc;+%q1>Q{$nmbzXHW3LR=w;KB0ed=j7_Ccnr@GOIz_TjtugCZ=~>BE +TcDj-SKN9Z``dTL)Vx}p3%K74~RPt;ozYmln@-uuQ5Yc%$K`T=HqF3*a>LBjsv-gUxPS$+l#9Qc-~++ +t~tx~33$=R5M}Fpm;qij5{nKl(d)4wrAEl!EVyg==S--}&c-wGU^L?ayX87xjy@#lVe&IPxAL@=FMkM +L)M=~x?BA>DjGopry1v{@N%i_$6#sYVI?elUQM~Y0?@gj}Ix%( +&QxT=8}~n;p-2!Q@`0&YN8YRZ!o-qa7qXK@ZwM`wejU1Yu&cOLu7Z(pbLHj4ruG4tN_%5gvu@uH#qWF +~v&lI$F^&(0VKIuqfLa`T9NB?&xcDDqBwiU%ormvXRg-O4VQ6uH)B0;+B5qoJdl&Z1KiwCPsz%}V3gJYNVjFV>iG=QJjDzBg= +Qt=L3=^Nr84Q*Qv(EpCXP>9mD1yMYb`!ufp%-uqfjt9ZZ3-jus@N0(P==&diC^)KCn2x!L^mEvMdNBq +Pu+6L`UMd(62$2zU;?LIOfdb8^oMo!#K9Y4S +d@qL76g@C+G^ON95n&+e+cby2%( +$y@!|T`zf$WCZQq{$vExyM1=o!ig8yU71vZXMB>~_0PTesFm;b*tgSXe7N=`clQL-)Gz)OtC{xW^2R +0O+-Z4#=eR{zkms@E1~RBs#~-^6k|)2xYqQC19&M!h=YL&n>5AdwpT>6Tyx1PvLOi2wpI>PdzgjTMZSCT({pJRL?iQcYNbQLpi +=fR!J~}3#2p|bV#11u#hXM9(I_|wg(Kz2p?THxoBzpPP`;C3ulle84yGNr}TJNz;eP=txu0m`+|D34z +|HnCf?|PZoxmSD>y&ENd{>tU30fu%;_rH-8Jn5^{d+6UX-+GR%q?L(^Jpg1$uCn>fTg1+tzT6$YQM)8 +nRHk=9y4yn?(p0hfh#lVZ;r&|U{c?C8%wAJM9l^Cg{7fLrz;6%zo~7S2^n03qPtk8T{dS$J^IZwkaAO +M9et`PmN9=AiRQTj?OhN73^Ba`32VP(n-$s*|pXUDy-i2Dl@|%x0XrUBNrz0L?M@`Z;<&T4d{O;PP(n +a@HDIt6n2-@gJfL~@gS@*FO;ip_`+B?SDXZ)%syK!{nKWORmNzphkm$uHU?Fy>Ppx+7kk7n@Y=snM`2 +^mK!awyPLKjjzQ-{ETM*{9Oz>PS?+U59`;{^1`n?-O+u=FWNY9%Fm%`*zjGowPKU?q`F%3Lvk=6V;8 +Hiy_qlg&IS)D&6tn3?Q<#(xv$<9bb-z*kYN#44bu|gWmmPl$U?Tmv>?z7vjhA1>on|xBG42s<(O@`0) +AlzLPw8kLDSt8-9M)INi`#vzUyRB(&m=x1Z7F2s)=-Ay2mHOVUIop~5EW3H<76&4voXd#}h59&hP|MuMnUFY0=@LD+T?t^FFLcQwZ_XYgw@4EhdcOMM4p~J+s*xd*77RKLwu@&tWUH|P{5ssGr +@T~}w=vIVraknB=uv-zz@K%Jh*sTcBC)s@n_UQcB#Rzl0|6+t6^>Z=86~@H~ml+o$Txwj5kZxRzkZ4? +t(9^>%M(F6d_{9hXC(xvF;l&6iVN8GT#RxmuppRC>U5v2QxESFSA91#c*(z7+yLTWZ`vB;|Qx2!-bh%#qstl9EYdxaJhOw+3ODn?A~x8= +T%OG@34W8?2SC3d)<42xA`O1!rRf{wUy2X2Z5h-3UUko*Hm-{mr@IrkGaj@_#S7JA(+%Wf2uMjzUfw|esOq!gdI*4+|3E;s6eQk`8bWY-Gr>ZK{(h-mVL0}Hi +8uhI}Mgp{A~q1m_y;oifCX5hsU?vMHMQd*Yy3!S9a>2-e<1j=sqDswHJ|AiO=X+=<)hwbdGx%`DqFn_ +E&mP|n(pDwRk=R*^5{;h9k>xjIt;Q$^H@(~9T*Rp%rk!HTmPEqbkDE3c__;0rR+*=oq6C(nTmr$GOn8 +3Dn_3MdjeJO$)pUWZJF9B!uNzKi8(6?%Nws&zp$s5k0?c@klMH>bJz)lM7#sAONo|N@u4K#dC<L@2oW0u*R&0|mHI*xf3Ps5evd2dUO&Iy-Tr)#r|3pvI1s)XY8 +%Y?YqqZ4gw1PA5QpM0ZRvFd*H`8Uob`(^~L0?HDb2|0zfi?40}OzM*wfxC~APgZ}GaDf=SBhD4xO!?`&u;d +(a0HNbYW1d^gClcCoA*hw9=R#K_&y9eWq2^o?avKGY7KqyBgTcFZB_81y|EZFG!XeXJyQOh8<(1T5&k +Wy#&I$$_G3cHpAE1N}zkSd3ajXL+&C=$^o;{c-__8HJYeDoFUh*n1OzD692<{0y5TivtP@E;%YH?zm( +qnv4uK;E=ebm8J-Taz(&lMy*Uiu*6Z*d%b04H`{LOEnBoKQ*g!9L@V{$A}!Vsmb9svdj8MnobwI?g4w +-&xBu_H!{Ism`#jHi&U2RcEWD<#EG*)H9~Bdd#C6Ps%R;b&;aEQ^k9#PfYG4_*+?&s9WfS9`bT{WUon +&hDE~F+FsqHs?acAcFfgjBE&aq +t>oYy>fkXKBlP-qq~!q?80&Y_d3eJCAY7bUF$tVp)@c62R6pJrgwx$&$7I!WOgwL#Q +a-F<18gjvai<^O`s>1LFk*iZ}6zxSWEn`a$M+9xohr}DwhZhHkZag<<|J()C|OQiN;|UWE;nnxs8V)- +U4l*hF$N8wL?k^rz8kIMOa;_)6FL?uX|N?@T%kVcgt)VmVYuLILPbs#}r6XaeyPt<`8st!D>O}e5E#EAn;WzShEUwLVbyd}tWR4zR0dr1 +g>!;?zu9W^+;ksT;?^XXRCKP|lu8M18_Rep$rRV~_2iZ5hX~c9{q+g&R(j1szDJqA0 +Bs5N2imDOg%>==pVEI0)VP|tIHojP0*1%ABMUpc)6n>HLGr}(hJ7VBp1%EgEC1Sh+zO`1dE9Uv+A~)W +UTy!45Pz)sHP8nQ$ekJ{6Rww&bG%O$s-=~$4C?HF5wU1XJi2@=&KTjcP1(a4-K*iO1@Ki8PS64vIWC1 +a+S6pNHm;=v);#$fX1r%w;)*|vH#)Zq*nDo}tFz1J&cnWv}dPVt=Mw&0nhsvVRyO?D8lzWwrRlN`VJr +DlY!p{vq6hg8aepT>04!=smOOz0bZ)_<11!l5%l^4(5pS>Vno@SJ$< +o-XZBo$d+J4i)0INIO)EdsuXk_`7{XiqU%V=_h?^=Sm46pR +Us9)45tsLT1oFddW;AMf8&qH_4<%^0{!A@Oe`D#E?&|^jRZ)s8tU6O8P98K5^vpvGkcEeGb<1Q5g>wV5Nx1e_mVZ*w#g0DQg8C$lIl8+4Vx`2^4}4sk%C76y*5CvB?A4;%bM4?J&4|L6+}m +SA!>CUwz_suH=jErP0M|g`A*X^pJcv+u|;Hc +B}6ZOK~k1&HTU}$xC-S_SP6I?aD00$NA2IWoR^3mmG0)FFEVzqCT*bfGOjMPrnQ~g +i@iJr$bq*(MB&?CnzUXkE4|5RhmezhgqNQ)Ab#cB!3tCeQr^mR0!z_jhi(wyixaHfMEFU24l!a7R2%x +p2EG{C1N^BAl+1?^UKq-YicJ+)c}=jzi|f~3R?Cpgvld6}JX)C&=| +1>^=S*t*dU2j~t5SRo_4g|kJ2jmCD-$DY0-^q^XB^h;>-pZ@>Ir!?-hOJ%+ymBQRYDaxUx%~Hd +NJU}&VVIyO8IX&M(e+hUug +W#uiTl#kj+A?$8YMI(kGmU8ZES=s(PrnCS2h@fxaGQ8tGckv@~dB@7pdiQ)86e@x~MRxAVk2gHI2?r^ +A?}(B6|J-NL(ZCr&=Z^CVZKV#@hm>zgy$y#q=pDW&u?)*Fi*LoivZ5hrN!S$kR*(-u$3_~~mi@T%fHl +K3jP#1tb;RmhZZf=)5T0asV{$;sN-K*@TKbXWI@j1>Yy1&=Ac?>44l8lNV1gzuk4cK(Z~q)`kQcDxEsY)3d+PeGI&DEklO^n$eFRu3_%Kc +hOcQsXdT~aUyx_!-9>sE@9d|2_X|IOdTKr9bqj&KIonxAN>vGSr3Y{GF)~_8YmCM%;>%`SuFNlxBAx{; +lxdgnu`gt*()AcbKwys{-Dj9aS40Cvg)i~YZ4~v~P;&K(dWww}UTfIR@|GU-<|CjTzJlzjB3zmm^HhA +u^#8=qe^_&I%h~`5wvNBzt>gpX`(~(~LQ=xe6w}oD>b-yi6QgTzJ(uokKrlO!ak}NVE?u2Gyy6EixcVl(~UVP_QG*~;wNj6Ubyd+~n-S~P!=1 +c5_bAqTPR{jm66=)XG;`$DmS)ROV8I0f|H4YDn*(98S9VqGEYDN@b*?w=nN2LVK5>mH%EjVkhX=&JaW +&JfoF;`7rX6aTQr-?g7W{7FY3@b)LXoh_}U0#}OK%v>t48(5~D+ZdPZDoD8U%*K#U7K=SFA*brW;?r? +F;)i}>7mm1fpzZKB*ijlJzG?G_y?w=1?hL&;(+MiR +AZWyl*Nk?WoP;t)Zkq$WMiP*8^hZ%v2HKJ?OQ?$ivoG20tx>yLp1!i{ +Mcz_+A#gF&k?f?}KYIYq=#UkXRB8Ij +XKObLO<+TuZXy+x8tSsHPz*zi?&!UjxUwoadUH->VZK-ysP281t)16 +Sq^aWy@<6Ab)YyO1ZWHWb9*r!;EFI3G>B>Zcf+7&fRKeAx=7gn%Yv1P7*A5E^Dc|-gY@1(&+8fLXk8$ +^T9%ToMn)jZtT=I%#6?msWBJ1@84xf5>ZQqh9*h>JbN;ZGgNUFuu&p?iuJ@P!QU69L#B__kc9hULi%a* +-Ttoz+n&EGmP?}VavgFHFyQQ8N_y5Dsne%s!*b?%ULg2z^VZTj8zVz0vs#6jOAHfmpKsI@d9(o$;C*I&hlCT$=$y=*;ed&TXO`Ah&nvvegH!nYjnaK(6u#VyrWq8B$lin%f-0;>{27AQ0JuIOaa|RYIjGlmHz7F4{z@ +J?2$rDjAg-~YdQh{}Pg;ZrG^g8Gm8h_By-@Ue2tPv05?mrb@u|!q8gV?lqiI@xiH2@m)d`(os**$uPp +5Dmljo+HKQ=)_#U$g6iYeh6>986oq!5h_~)LPTOF8CLPe}>{;5}Yn``~}w`!`kwiP?M{oCdlMEP!r%f +SmWb5CmM%LSqlRNT!VxzdD-s+%hcjHWdfjl$qr>G-pxba3fRo4KcR1QrWBHuPb-E_(9c+Q +B348}9A7bg9n^>eby@O&f6I;^?u3PT^7dvBTD?67&V_M|dLet8mBD2Bl7U4u+f}^#GG*Md>b1B=2bLmy+pZ>v9H9;o*j@y>Z6QRBFQ&yixqB?pSj~$dU6Eq`rU>hEt2c;i^yES_vk +Uu8h?Sx>p(2RI@{Z{y*D>T7vsY|D#$r_-F}R1^@i7@&I}J?ha$PScruSz(oOUMo^kIh1lO?Lq~>94U=A=9zNcLSK~_DMT1<8YxlK4vRJ^R2=VkJI1$v` +7@CWfiyxF|Wq1RK)#_@?OG%eo~ZCPfHwi=e=Ac~}tvxd?gSjbZHlVgD^D9N=8M-x8(1{JG0+6-nzxy^ +)RQ5??3aHJ6~w{GFQx*9vAg2csZa(7?CvW3wJ?uV!|M2v|nBu86k7|xC~Q<80w@}SgmdIPGVJNXTHVZ +la0gunt{`M03HFa6#bip3sX%F%Fs*P_NJsMfWoOZjk?Kp3P9$8L2;Z*mdnN-iJf=tV99(d6=D;w%(D= +8RdkR%oG`j$3d5HL@V_X=z^el=RkXYD!jmLkVypAu^k&su-5Oh_7F+yi3bx_+(x0)zrBXBUBj$@PKzflcZ?zhIG!Vq!IfNW;=0W7NdQpP4t8xM8^WA{ +KmJ@-y7`jX+yc*JlTpHx+*>Jw@6`MWHjU`XSthYnIrXw)%<}STc4~Vj|nmZ0@z&-FCmiWe&ylb(`Z)E +&fPtGR+7|SpK4HeMA*VC_J_J%4(3H&(X(OGFmlQhV8QMCOIk042xS_?hY-hYNj`b#U;cojJ7&Ei3Xxw +6IIKq*BiZsg+v1MU^fd^Tk%gI&`pc+uq<*VM;-*ND`K}=I7mdt=IEXqB-{99rW6s@DvONGF%Ab_91+>3+aiwqHob!eC)42f!4DH_9{{LNhRBVchkvE-X)S@`KMZwM< +e?<)4B4+BsFOJv6Y2#>FQp3m0TVYxztR@C=Z|OW3YzHDDHVYDmSIH5u40}vLl^EibaehGFo7B5b@Qz( +*LgxtatAy3)`6J*PD7%t4c@+>GS|f^%5e9V4U@BLp)RlpIN>zU(8H)ozO` +&hQXiN3YuTgJq@Vc(UtoGPNKtPo}}yx0d)%oNck6!y<2-Oz_+|S?$tEQHvXrP2*pA+#tR+pA92fxE+D +U*CgXw?E`2ktJW5a8r$==$29sQ4-A4xuKYg!uK*m +2gZ?-1(H8#b@ii!}}O3Jc$p>?%vbTO2pzy?(CUHFpp;32}X${#oQ03q(xiRrIPoS>~X!ER(A&%N%bKF +Eoi4n!;;(k-fFOEB%k0-;sRU)7?xfjOSO~!;plB2 +Ug2RINtM^Pb8&vXXVYPtyrXYlb?{|5pVZ*IrZnutIxco%{bG&ZEoMf#sV(-g*l_paEpiW4oN37HdPQv +bhR{L3PZn|hf~Jc2-uYK4VzKE(6!AtXVuLK=Q6=W64m9E=R)-O1T?fe{vV-&XELUaCO(*nQb>sZT;F +X5P+3_LI&=9yFoko3@m3^Mf7fa2GzwU?uonxKA2xp6gBuDH2DI2N(aMb4H2#@ +M?m${0!i~<*YboX6|*!3295)Q(4xub|0JP*~@x*p4jB8240QaOXI;;ph|ca#E0-a!gIE`sHM-ZdC2`& +(FAaRaZQ=ae2K|H<4uHaBzGhf4vN9w=pzhuHT3mkRXU(C6c>q~MYkIp6IAu;xIh)-6y2YW+8WHmnjos +O&j*Y21M{rNBXK+5+3YF|8*>}u0Ob-IYT;cA+cNF`p)2mGN=U~2Xs**q1JB};& +|vrY2jvYtCfBZN+VCW_8F->v#otIbiS>lfy +im^TOY@%LgSc;kD;=73-@sjKV4}wGRFxFjDH@imQ5M*ANufxd%F*UwCQSk|T4sgwth|VL{N6DP2@(TA +_a@SY{Q50#!9tyIScA=KH9pOB>7vcHlldisRxu0I*vctxKU|qo;Z9!zH6gE>bvP^;$I$*$tmIO^%3}W|WH +Tnaf-A9VMDVG+pzWRnJ+qb?_arnAES?@r^`>mH$f4$F`Pcs9{@IK}sx#r$i`Zk<>vg2IEtkMHlfit^> +^g(kvh1?|iedk5rO*~e&w>Qy*IoA7U=A(;Q*dHE81+JbF}Z5pC23M~#$dm+sbryV2WQ8nXC2}OZKL=8 +=`MTJVXyw8|J>M4YVQNb5=bw(4$BLu#ihX2c6lCe@o7@J{@-IpqvX9YxL&1rxRWyVF)Upsf}+}pb&$?`in~s|P52n1Sp73)D%3 +e^*j>`_L>aj-Z&;*2=I7faGLF~=h*+q{#v@*el*jgEp*^Yz+v{I_t2#IB+c$B%l~^=~Z6dpG7QMPzJD +Y0XYqblZKXkODM&1#U5ZBY$QEafz!hY*Un=wxh;Q5H@)+(3BG)vF@p5G +(O)g@1_uCY<896)MFF135#M)@!v1(S~?1#@P{UD!%Bma6kQzUcB41yf5}h#SY}jEAP;mir)l_bc@=GZwA{HkaI7f?Y07|Kj(2Y67tB#Tg*O>Gg(X<3*8P)X5uRfrjD!5fV3N3^v9%^ro#)% +{6g_@e3Rwh4GW&13YTFnYLobWDRHtbw(n#vn68rQ!FQ8FXqpK~WgY1Z#s(kSvek4Ruj;EK@~zT>6IOIBycB)bZzw% +#o+S=BzqqmMMOEXh@2bzyr^pdzdVI8XLH;OezQ1td!Ku(wg+GA%Xj%dn&i=`F_0OfX$!XHz2!&6w +8tFXjg;PrR^pq0xC1j#9=-91kF2OMP)P$)w1H;A#PRi}@u5cLjwF}=pd@XjdaTv82_GkuT%B+oBn?Q; +mEOa|P9)biW*U~3PSwZ1Yba?YHVaOS!(?!w3U=PLH%Z=dUVM= +|rkh+BmvY0Z=fnigp}Mu^miP+8eSZ-dS(|&-o98sO-aM#z-ToGAqZp>PQQV9VM=iE;zH))C=7A*F0U9 +=`%{+&^_VW0(#Lfk@G4V-tp0&q1&Fr!_;I!muBU)bHMaDx9RJH`LEwsL +rRu&}8C%PeTcg-A#=@=ZJSL#axE?c5T(>fy~%tvvc4Pu^&U65bk_R^W)aucFh>Qg`gEf7V!P7#)Ff&~Riibr$aV +Sbppd+#)i&i=1cuM^H2$$25F_uM~YgSBRP+A=!OXEJglatl}z(M!uN-z=ct0ZmH)N8$k_$kZo*luT2y^d +SrPa0O03-lMZz|jR*L$-2~-r}lA#h$^uVCZjgOId&S6Iq^H${x(Z$F(MpLKb%Ju%n!FXIJ;THtj|3lQ#8nepC=XFCv26 +#7vndi_Cw1PRsn9I0e1>oHnOp#VI5mzP$rmhQw(s$?7zg6j$*6k;~1xxKW19Q*?TtGE>nPXoAd!ZI!0 +O7m6;3PfC*slCJ~11@LVt2GEB&jDUX3X&G5))#(dqe7t{TVJ3?!A~%cE)xcfXX`WS!cXLDdwtnn0KT5$Zsc>a;V!D7{4veC +S_{c6sQ^5KBk#5ghY-31+F-4+e=VUV7_2!0c*OhSHp7quR|H^mpw`%F(^UCl3 +XO(BZrw=EsWV0mPQeUu3~BLOvgaF#UQC+Y#&yVj0kb;@#*^PZ#*|S4416Ni>e=XK!JoP-AotCB_Q +8)BuH|70PIcEr)odLVzR<4_Amlm&wocCa4rgJ*|{mtDt9mHPwPo4z97`k}Li8$}2_(aMVGaVY5u&2r+ +D45sl`(yhoW0wB$Y!W>$8hbhgwU+qpheTso3s1Av)69t1{Iv@_ +n1t)xK+}=!Lvr&^pUh^f{|dUHJ%h%b51~!q-`Abx~T#CA~6qC-$++D>=WR#y!p5*DTtB*r_|c{inNIH +|n3@zMNRk-zfZb)CYFy-S$W2HUh7(EkY}#ms}Yj)S#u20Fk1fCqVI|K|;fo35&%l3Pz2L7>Ipad_@dP +Mye5WIIf7YDG-D3cis0THh53HSBYNMQ;lTg3fXLiBHa)mO0pjQB2ixbL|`AdT2XTa_uP}6^-=KV>%e_ +QasK!YxwhOzzXmxL-;>Y8;zeC?V}+75@S~zQtR^%W*6x&x2kYaL=8mh6PlCuafjMq0zQ@cQJuR-k7K+ +Y%VBL4L)LXCoj)wbJMNC(q`_wlg%LH$hh@QZdC0CZU2uNJgWLb+@v@V`-_P_C&g$=g!%u{f+f=?;9{L+^S%$f)^FkHzJZ3Vy7hTfrX`y +sThopn8vju?pU(pjE+J6wFd^p@Pd4{F{O=Dp;mqg@Pv({7S*|3I+s87^z^af;TESLBZ(?+7(=(;8O~2 +Q}6=?zf({jtnyc|uYwi@CoA|T1@BUDxq|Bzd`ZDF1uGRiuV6rkk_QE26pT~QqTn40<|=rXg3A@up5yx +Z?xvmz?U-l@e@c=t@*fgr&Xcg=v-+s?k89s}cw-nn+-bOPkzG&u)l~os`y$USLFn!1U8+O{a&k1^El;(N +hf8jOq0R^z>_{SNZFFeEs|bn(3Pd1_g(-FocG+Y!x2Sx=mzM+ji|cT-VXqsdJa;uHCxF^yt~Ecb~rfV +*3vmIOzJpH^dDY8b56KjUy6FBNNR@qi(V!r;N6y-aIC4?6~n0Cf+h>@~yYsK4t11)264-$jG#1&776} +r`b7ka`W=%+6x@cdGil5ei_88{m2@EaHs*vDw9L&HgVr;bmy(hCU1EPLJ@dPR1DF}AbxgkCQ!0bO5+UYOmZ9V%yZhkaqVkNb{Hw@oV)@D +(K_2kxq}?Lt-zV%Fy>_$GtzT%@G{~QaO#thHzz+k$Chb~>6ejX?_tbx=4J?<3Ov*6kjgD^*qs>;BA)( +4pgAWeH9cF>4!Q?`?%X_w(UzO%oH@%_ke{Am6YR>#qu17Bm^Z)rH{h3tcAG4`aT6rJ9kU4Oyxa_1-)r +ZG_j_XT9^?ib>t2$n@E;I|aA$7%3_`U&8nbNa`7$TOyWuKy&d<(kP#^Cbk`$YzLPjGFW +c^LrsvcZ5=v7txNM2bQ~Wnj0>b=nH>Qb^D^Rr!fHhs{1G +n`D}V5i)>k;LLRvfT{D-|3Fnh^u!Knk{(+wm1JJ-99ynK(S!JLO~y~R&vYVkfrom;7xgWRl$-+82r9c7{E#ATP^dyd_&uo7k(Dhc8yC6cI0wV)yOamkrCe=gqVeiMi<%!I?WdH*bFKjr3 +lXBnd^=DKIciMjL8Wcx7Z1u!$2!^@&q%*!vH*CTZn0@#f^jF=mewi_gn~yvnl!x&6G{4>WM&raQftds +PGX{SDl!8@SgraR0f1`!5aL0fmM478Vs!1MYio;k`==!~OlK1z);!DIp#kTbNe3j9TNE?r~|83aNdjM +m#MI17>4P;j%(X#i$vdHEWh$-)upC{`~y>E86e>*B|2*zZlQ&%CIYc7V24D?N`#suYQaoub=K3f8Obr +c>R2?@u#IV{!g?2f5CHQna=v}mH=Jd?^>UF5}>R5`CQ|#P6Gbj-*3^6UpW1|UEX2WOtPZ8zWZ9~t)si +4kFMUZtgvWFammtq?^{;7+_hrms{2>3`SV}a{`G+e*FE&`BkLdi+hZFZf8xofp8oqY&p!A33oriTrI$ +Cp^6G1^Z`%CEn_J#`d+R&fwwIOf*tu)>p1l?O-raxT;CqKE4vdqCCnfa#hBRR7cT|4+aFzkER3bol=Y{#z_V=gb+3k ++gg=>FI4urN;=%o%9I*)YN{Nnf;_AEtN4-s*G>8Wzd+?X4lf+oHwtYdkl@>;2dwucW417=S*jTgRvB6 +j>s>C`s{$Fe0w&=?y2eaj9DuEDBBFXQ}q=^-1J=Gr1#=o$RBwlPvnQZDE*zt3;7^D(y;OA4yQdcUF0* +$o~>+*O_=4h7kFHZO|oU?+Ppj_IHfB!FIRYucPg0fKt4#1G>C^d2p8#YvT1V^lW5qOH-EfCbk^ZNvA| +{@GviM*MoF&g#hcXoDBPM};4o!i6r7fq@67l3OFx+%OQoFCXWB;QEs!ZEj!zmla6n(P)hgo?9)u2IMa +U73geou={3DhSXNW<>Ct??IjhII~Bvukf!B~0{$J{(-;)G~6iiSWrY8HitFFENn5}akT4>fiz5dD1n3 +{_6)Voved_~*^=9{d<-*k!*H +!;vh3z!l*IHiyG2m|^6bYs_@k4d1j7`A~SC)6sMU3MXbX9bSij1`$BRzI-VKMrQ%g=-#!Udjo#Ww9x< +zqhv7;lb5BXpm7m#QNt@q8`OF@Nb%>)Nhcd|5m^&i-I1a@Yz4DyGt$X3Cp%X$_KJMez!XV|WJ0>nTxX +s`jTb$|ch$^LKfJP$>F3js8!Rkvq}#o`uQA&?z6dH+oJQ!^@RxGwomb=h>fWWhF!Quz7?6DU5S$bMlnx?A*1WG +u2t6f^6J)^Z0dLI!9%gBNMkIg`Zl~>EJYUj53B!fqp8Oatkr{&MBnBpr{I_jL)8vpJTJC>OUnjyTCEU +F?dkl{LC5bS{_}Hjs;OvU4Rb@u=~X70)1HEfPmPr2tA8%gs_OrU=}ebh(*}L$`0Hi=faDwW9&&X8;{F +8o+bNMFSjl{kcAHlW8vdMYg<$WR|b~p^P5c%NE7cE=aUu|709A?1+gdx!OZ3?YLK2qjf<#6{-CvOXT} +DSsZjZawfAT3XGE5@&X1TL9?O^(FT4w5pLMB=r|S^RIuOns2?(^fvm&0sH!%V5oKWpKV}%zoE +gRiDEpJb;B~0{7;?-4pK)QVnyud&O%cuh}t-Ib-VLG!OJ+ffOfjT!1G|Mi0g~ne)db) +CK#nU|kr~wb8RS#D_K$2o7q-+6-uwuZz^P$V@U5nz6`10W5Mrc)qT=FKe#b%6wwMV?E(YefS9m!nXwr +e>F5;2fjLpuS7%C1P@=!bbdPKM`aup-Hf%&e4Vu%^cria+sJ~b4SRh#WBL9>lfbtb%HD(TyadJ$kqQ5 +&q$#SSo`nvgv4Xv>OpzXQJik?@r_78!mQAxCH@3+>a??LwIR#tfD?+p +qP&9Z#7FfG9r +)~MMtmkXAh=A|+=n$E;2-;2`K+b>!|sB*e8NQC521P=%-W2rANOu2V;ji4ti4mzc`{Vq;q>0{0aWLOA +L%Tr@8Luv^p@0vr2ojj1NnC#{|*DB9+dnDB7Ouaen5^wNCrq2NM}Zof0Ui#X)=$x^cytID`f1s!aACw +`a$>3_3fa`@~z(jNPUCLM1L#K;8MnhmwNGA=?h)U0McKftmUgM@3yvzZcElGvBj%_wfd@nO20B66>qYq{)Z87NCzAV%8%+Fa(x#^DC;1kNb@?T{O5;N^D^Ex$>!X3{Bh^WJ%PLQO3 +=3dkB)4JXkbB^CkFMEFb$zp!+;$3Nod!j*PCvA*jjU>28D7>hKWutvn(A|;30+U}7x?G8wrBQs#_lJx +N6P~|Cb{?MUZKB;pQLZ1GClgwqi-JB&Dh&yqCTo8KdSH1LdrbhPO@H4@4d5!u`kFBQ0X$s9#KI$M!BO +}5wCX0vQP8WNos#5gi!qpX5oJh6(d8@=C;)OBwE7JSU +*Y|;?F_`#j+4xUlu?J=umG-XQMu}v!jh_RTh>XI-TkY)ssQ2B>%#hgPib8U7SR3^%A^N9|7P7)1K9mHLciyUfNX{2dlt(mEyAbV!6%5y?q-7DE +whz;}-^D=Fol{-(dL@`66JWPx|<2x3!IgR4|R~6giL-A+(P`=|GnHItVGemkHHG3vL7BdzPE_fj?nR9FU#l&Bp6v?%_x!Y(l{$`n?l&=amOv&mX ++ef9A2Epl2PRct1FcO4`}igom~AthGiTcDX?9xy3bC8tI7iMca)HOh-1*tL)U)jfKWkpzY-j!`wd8}) +#uP#%LK4&S9Zoys!C_nAU<-s4q@lc6F6^d6YC&!UcgG~9!X8ZTy(K*-J5!W=`b-=9j`)Cyt~9J3Ak6k +-CfCb-n{HH20cAj`oHlklT;ny@t#Ap}7J^!@lHTtn)f2?pjbx%`GU7}2vyVhs)UOqceJFgTWHEMKom| +K=pM>^fe2&eQ&#XRbM%R>?X&0q2$bS+Qnvfv25ctS6iFr=ckPE;FVH57mx3O#~sp-V*d>~+AM~Lnmo8 +yXt?+QN4;z(M+vVBvrhGpcP4%>vhN!gjU#98Tfw$pbUQ7B%_9C$OV8UtCD4lGKlTk%0sO7)s5*hx_ju +Lxi>n@BN<8U3}FPRR3M!ai#}AL7EeSEEnsZ_)Q8LE~2yxoM`99af%p-d=7etjQ`6DTx@SUe_+iQVXH%}dW +z3sy|ny_)PyY<7~LWlE#L)5O-I9KCc|4=G)WLKE +BUMei7=Bj4!&7Y5dgHHm#JrJQhMEFC!})X@5sK3q~cI?{I>YuNISW}0CQ*k5-_Ap_0K +aSnNWenJ}q*t)Hf`KY5$SbV1N(*RE`GzXLFfuKbfqy6Ef4y>>lsi$m(^Q&q%746qlT`kgH9*BLR5%wYxI~2)tMC$)4|cy{x&Ggj`*DTOQ|f)sDE~JUe($O9V=6qdndF7Wv;W#Bw8=+ +?8=HLo%TfDpd7554Bg30s-0?q)_aFKEzb*p}p8w+_F+D={zkK|J`gn>I^z +qXbI%eM6$#I#FNG*@-Mn9VS<92t}(tz!Oax^&=X%i(UzTh!i|qXP36DnabX)v4a(RPcbqV?X( +#@4V!)O0-#`9o)h~?oUnEnm{Z6)5mpRU}lI?-_^LzT3|IV|aZT)`n|F&=)yE-otx-_1C^=Zjp(rRA^O7nOUNa&rxT&8?oo`rBUq@TZ~d{8qjDqvQYH^#9fQ|K9ZfdH!!czqQ`or@`Z^9xXjA7#D +3|QrAu2FYE0e1vUNsXVp&D{v_dP1>FjMsbH0YA1ioV!Ab=y6f9G4qkP6yxPp2GnS!-HDn2N9T)__%tWa>Hf*TZU?pME#Ywcsh^ +_8)zovrNu$H2wv(b{kAof<9;=gbQ8WmxU^vcHrzeggY;|DT1*WvgZ(VQfDlU>6Wp%+%Lsm}?6 +m|(b&zo^1oM>rS%ROCpcv_0RRj~MgO{lzx(Gf_ow+IG{}jQg)R9|A_UQ!gA#?gys%r#)?!wrMOGmQLK5bV;E-b40if`fZXJmUy1=|%dM +{7VRi^`W?A4<~3Nvw`fh2!7Q^zROMUU>xZ)qWw6*OGC(?;-Eq-B~w9hDhbvOmH7jP#!EZkE%B0XlL;m +cBYj6{%>*ACPBfBz1Ho;>B_D9R$haHjdnXXQA%WB_`Nsj03B4#`iAk0(;IA~08$|vW6UA8_EbXF%?MF +!*03WzXmi2K9)zf5&Pb|Tw$zXK5i(qxKjDMQo-%Xs2!P3bjJ4j3L{A9^A`yMxO1vV>R@1zG^-OebEFe?Gyu493=9mhjO`N=x>Q1V12 +CMfPwTW4T!*n}|>F%pAg&Uh3zfZ);LQsp?P&xT-zn=$A;B?sQ`y3w;HZU!KX4#;;U +0{2b?hR+L5t*j0dtfcu;XHk7j-O#;5&<@e;L7Zg(PF-f1cni%Si4}?+BKbVxC&ZRuDW{DsiqNIA*!zP +a473mP>!EqdL4?;{O4`D3`2j?FnWmd&~;P?pPt;yMW-bRk*QEC*b;3isuBsSS9oPlHgYlNgd)Q*!3~2 +x*+@sZX**;da{gQ&nKw9ki9p-O=PTO_xn3z-#tULkiC{*+_O@j10H-<`d1RX^*O0;rx5J_ytEG@__VS +|{)5{6e@J|$5KMmwZ8en_!Mk6Q^s<*3Gm%*jy-jc?nXP1>MX=;$8D}HGPOnngk^eA)bIAnzP#Z^Z7Ig +}GlO6EQ*CihSU7Ms_tswZ=W~#FkX9K~%Z6h3DCwO!_)kU%&Cm2{J(*_efTTXI;Bc^vSmbFvb^9gp`CF +ROU@Bo>Olol{;w<=SDXUUY2zi|)AeFe!F*#Y0EkZtY(f>ry7mt+SVyI)%YD +ItFc!Cxw=A5ZqQ!^F=cGHoWo?MIY8Cm8U)wCf2zN9Ik6^CCg>hZK%>pJ2TH*s>A7uv|rR;#ylpX8#7b`p9-{Hk0(MuFf5qM +g0qXox3cT^p$^|JH|obUF+PH50N{x&b{DyitktFu6l{wtj=wDS;ubkdLPyu8_6UHEWJ-yx$?nzFgM+F +6Pq+?63focW=^M57F1y&{S~rx>(;Sno_U6C*|LR|m6fq$$BwbfmoGCl^eYsR$x#beFuVUiVK6i7oj?D +Oa311kE*1t~oIiizLPR*j4_rLN51gamz2w%D;|!%G_x$;AyAK^Wa6q`l&{9wT&hU#_B7FYBTK#EC%=a +kw{6qTlNS~E;QMwl+{((bTS%>y2_eB|=L;e@xru;8bI39|#SmrO?Ip;+D0|yT6ksjwn{wMK%>8AH{?m +Bb;sF5G=yLjlAljJ&!aDo4li^~sOJa86yz+{^Fs+G7E09rn2$l$FsZcx~rayuU@^HJ^%dk?Df}Q7czeI=uv +j+)G3dg=VLj*M$(}h-)M%CxI6!DzBy|`?Y%vv4)^^SpZ?Bm~k}!MmcRx?tOqRueJ9Rtfzh +>RD@6^PJ6Srqs2faXW+U%6MV>sV5jV~(gzWw%z)7WDE8e8$bT{C-<~_SkqIfLzUrcm9eHT8j +-2@_!>(eqIL(wXNIro_34%{oU&+w5Ygg8*S1%SD8_R|dAI?lB6H87`7Q7ofb}YN)mRs1Zx8BO8PMyjY +WsYJqXU=4Q`qQ7-oH=ut-EJ59^3XNezhHu?l-V^4BcKxX3SoZbF4XBkzT%{a +|jQBe`~xl7raHEY;|4?f5qdgvjxe*Jp3VZ#RY^wUp^^4+*`BipoTlh9>bw{B(c@7&0ie9zgYTF!Rw-p +%&y+s6(bJjf0oKFmJ&-~)Ez#0mDvC!er0r;fAtf8gx1&ps1!QC(fleme6F`{EbQYHMrRxpU`)tl;tKN +9_ZR6S1#Cznc1$BsW1+*;`NrHu9EiIPcGH=VRHOd@ftZ*RW0e74`u?tm#u0PU$;S`dCUooYGq<{jHRK +CZ%7%!`O04zn;>+MCr>Y{Siw4rC0iHls>8DWoyD0sGlzua%|G ++CfYr)c38>+LN*lN~`s_kHQh$O$3B{Lp&8{_@+86SHu<8#+DzUEcNU#VdH@JX-qMoK@J(pxG03`)O%( +yyZQPf_~UDE&4{zn9X}JJ)^of6jgy%h}nvoSj?4 +*)Okf_UmEpN#Bmr_o4J7DE&A}pF!#8QTk<+{vk^LcS`>{rQbp64^jG$DSeGsdcER61f_3B={r&SZj`< +^rN5EVPp0&9Dg6pc|948iozkE1N?-q(CLeFF#Ke)NktVaSTYJWIjqcpJ+fANO)5w(MWV1OXal{Cdd0L +;C?%lga-*i(KEeCTl1=C+LSOVx(zWZ$#+YwR0yGo}8LsN--sx6D +d9L>f5_luN$Y;A(@hzqCKP9MYfsNx3A10x^pLEmz$8D@=r-g9+5JwL#wDr3a1D$DnhqulzxN>i4#+%w +QJQXN`?y@qdOZ3$z)Id(;~uKwHiHKMCc_VbTT4+q8Xtkgon54Fj}Ez?TI%~`e`FfsW+#jB&AGiiwvS7 ++q7vN930%uURXmh`+jxOiE2oNl8sg?N~1Yg?H~M@*kOMPDx5Nr;fU=ZG?(|@E$RJtW4& +gC|;p)ZQ3wIQ2Z15_m58{7N;hqqzWR$8#MkC{?p9;6M#Yr<68a_43vQqd +aV=t#Qp~BuXHPu8$qq+*jW+nF13>k}MAzl$cl-K5g1a)0p@c&HM+GHE|kpP +d3-Re_A48L2nuU4W?EwEhbJ}i5NJwpABjnr4zwQCo9@4fd#-{8y7PqNQH|D1jK<(I6cri +Pt9eVYC7{Tb0W`1$9b*`-UD*qU>ky+ZE8zk2D}ex0bHyMY=ys+X%XsG+-)8oK+bq5C@vb3fE +7)BAK3l^-X0Py5)PC1`rKbiljYjnO)Yz`>P3Z^AgB@y9DE;k}elDfIkJ3L%>0hPv`zU=~JNKV{%76MP +|5y7d+B&edZQFJNj1mjQ+D3Nm*RLP0S!ru*+cvUor=A@{TeP^2qUHS`D}ciT=~x_76 +zVWA!S_3GD)weQ?BreBA^eqj`$MM%hX?K^di=@%3jbDi=q8e@9))9Zs{C{2%+EkfExw&~d~NUslU?(Z +Mm!(eFZ7tpq6hai0*Jo<%pjA*87*0~>^4$b|Mf9pt}R^$rm64<B?*z}PTM!ucxG)U>0{D-PmgA%90XKSW~Bri&=XtLoWnc +(g4C0ba&mz4gE2`Bx@gfiIT$M|AAi5ln@NCey8X^X8;k#L_=37sL`n(iCEwfX4AZ>hV?i247=*@DNKT-+ue;DS{_|`st@LG%o$}MY6+e0MB&Y +E=M>x^Ish$1A?RHlat)Cq^a^!F2<>iYo>G>MLGZS;-F{J}lxP4fPS=| +0Sh)?3Gtux#x{H-nfUlY)Qq%#bfgG^UbSPtxBVQHE_fBm0oSyv>8}hT6)`n0RzChNVC}-gM5E4{y+Zs +Bd5O1nl4?sTu(e)_02cm@UpTp51$VmI>i6^&wmO$seA3m5ngKm73HhaY~p<%=)AI7#pN1@VZ^zfgUQCWa9s~R}0~$1gGSLk1*XYpfnrT +RjW(a4Gp)&UvZ-1D71^=Bpcdnpv>`XFI0vdMg*dg$Te4IFOLX^R0pM56Wz!7zV>ac+CzyH24s2eB`K$ +IKm4$|!3zhB^wGNk&?Q4W_cd#}dgaQ{mF7ZFZ%c);($|LobboSGpa|8a3~-5|#>!2jUEgZ%Bc-{w^2o +che74uk(FkA3_02?N|KDk?->Iez@Ou!9EZ0LUBa3Cak#ZT^mP+X>D`yvO;VeVq5(&3UhK&ij^eKJH!4 +pFhR<&u7oRPj#jJZ({C+|F&)0);Cx^O(Xfm2oc|J{C6aMGUor5f|7&vfXXOe{y&_LyI1u +eh@as(V3qXT>g&rwE@8^}NOE{)j)LSqR3(H}_~Mt;EgjfCq^qTzayoBZPv|LpfUkKQWl#I@p2Z3fr$K +jfdf`)&p`b;u2OsmiPWPO +HC>b6bR=RR9yoyK+XP2o@FykgLxL7hpTmjHjrNkcjy_mJy`bZE3d)*(kH54_HwnLms_=^W1gR&b-B0n +gNG&TmyTq@Cp4ic4?*=~bUWgR0Mcp_53bb|szEiD>Bfrqr$U6g7r_=gyry@=t9%+W9NW1N9f}fmRl%4 +{&QV0DsbZyzIeD{=%KZ_}}Lb=T8s~j}i@d(n)_#AsQwV9uq#7G-&l1G-&l1I;sC&;`>g{dw>Swzi|uI +{|b@KdyU~w`d-LC)wNaV524O!bZE4I2DArF$rkX3p4?Pq;xFAD&z~n6o+cU|cS!sT&Tu}xhG=keKIxR +K&(KLJAJx@o(4f_4(4f_4=%kppMKWD@Qo;MZ`;jbZG`XvVGQcQg@=E%iE3WC4oQn?^j%Z{q>!xk5U5sp%(!mGo +S%|9*q|Gp{>>WWe7uii#`LMw+e^w&5MTcSBQpx5Dm`~4O<_|<3F9Lz9wZ;O?1woGKtgbv+84X-_|((& +=;Eg4;?zR8_Gg6sIR~qxB+*K7U+KHdyH$KH_=w1ZNsx|NgUroG;CTlly6)Z&tD`O8rJ8(l1^GP$HZ66 +9?6$wC-UN%iF|RUnY)~~@lTIc3L3oo7=2YAqbdAJ-wXLCd{zN(-~|YrfH&#`@Yc!%I^Mf~jP@5aLjHF +yyOF;`G`vYPynYYSKy?B288kehXn07`uo^V{X(YdI7SWJp=8H0u1PyqglZJZrF|Oa;xcozBpbbMm0_N +FgpXD#S@B&A_NHgALaCz=$`L}dlUVH=JT0}HZU3iUXcv;nF=%mM;H}XgAH}ZA)Blz0f1b%;xiM +xn~dx?f6M8iEq1D=L`j62?MT>k)nk_93EB-bUN<=%VmPhrcp1^~HqjvJG +tmH@q}AsQq?6X$NAL&p6Zl_XXD3m$ +1ziY;h9h;JyoBJ+sMSVmaShQ%7put{$Q6Ag{%nWmm7@M-nx)#ao+dH3$!`Lt=%_|s26&CxCw6c +liW!@*aqSRv~5C!c&G^bYz$jnM+U(KbL=p)Z8~D8>VLP@fO|-N`Rrpz+3&^E~xg>tj5m>ho%<3%`Z`) +~#C&)YqAy;oqlEpTSvKS-F{+nKh(GML9h2#1nkXm@$0(`0;$@%9Z?q2Oi*S*RB=#V0;gJK?B+Xv=bT~ +7{h=D=u^lc+Csczm&?qLJOljC@^_z_SJ%gwC;J$v&(KK^FGvOYzd8OIHf&gFYHDf`h4BRo7I3N)9PZJhM~gnf?%lhEJOFp#iZasVN-Gc02ie0o2mLyf1?mIpw5ZQi4&L?oxd!$5z#E +UDANa_%2+xoqL)Jd@&_iM#1n*XLnHLro@>_1Xg?H)Fh4<*ugHzvH-~v2QH@ppK&`d*GU?5Xk-q5WFAD +zLsE={2JS@to|KEH5JB7fsAGxwsXke{D_^6tCuz6?Ak +O`0SO>a<2f&z?Q`{Q2`mIiStZ=5{nXfG_aZ=6o?W07QL29YK9)Sl`iRdyhRZerCUO{ta~t@=vn#cu`T +&2dJkhDJgv6!iAz7Km+g}IdUYQJbAM4M;U+y&431N+>5ao`qz+q;0XvB0&U*1g+3MHlP>vlbaeFK*I$ +4AevBdh75pKaFpwq8H^UEjVb0m~(`kR#{=$QAT4%1)c#Ae +`{I?OMNI2>gle6@v#4?o2!^L4AJbop%Hc;1A{vseT9=($mwq)oK;8_0&^O3H-rp@EmsFjd}q61Ap{QA +wTGAqaL6RpiUrP=wQPAGUZbe85x;C<^II3UAx>&e)DN|t@z`;-u)kquP_)d0v{?{PJIikDi-yD%A1qC +2^l~e1s-c@wE0BnQScP{|J7Gtb+P#$Q{iC&y|1HI +{gjktU8_m)*}8TOWK;0C%NL#PY)-FF`+oh907?+3VP25F#Ypo{Q8elRA20q&sdvBw_69ODKbAD`cgy9 +a-*|4;lb0S%g7Y>W=@8#;*EZZS@POrfo9WKLh;kFwGF5csYGxrZ!)=cq&Lu$ce%^SvJa-trF}(XfqeN +DCn5*r!aH!XJF_K_TDXeAf)(L6#uvaH9eoK{Z{RNQ_a6UJ+p`LCi8csyX!HHhAJBDZkG$ys +Z#Qq=%pZREVIj|29fkqj+T1+)O>jeIwC@L`GoSJG_5F8n_u%i{E_(N2y!$p+D-)Ov8#ajapbPOq8}Nl +}L3e@{4R`9F{{3H+_bc!RE>ypS{8Rf~qK&_K=hwNTW&YO~VZ(W3NZQcTW291z)lB3JiM{rYFp +1$7FtKM3j?cf-$R*S%=&N8e1q}*zRB(iXixuP&>HzES+cC0#;lcWzX3F@ptMnBy-$!O2nX?VXi*VzMO2hfUrXIX +2lKQ@})aIwyY__q~-#3%a$1-dzJ42s4f_cd)^8VyJ=kq@2+;UWYW5Zl9z9|gY$@!G`I6wM>z~yQ>GRNM)aU$}^ldfirPKdkd*>Px$92W=b&}RrrK)`Nmx>jiELj9B_XA3KDozY)Wg%PMLR +~jr$QqV6yMVwok3w66ZP}!CS`gSUGqyv_tb=J{+&t_M(Z))vmKw*RZq!oORVfjM#I!|8)am`*nG3^)m +#u!Pe5GM`*}3`dlHBt3*C+7c;IPMFZJ0|Sr>kJHL3f>6L1-?Q}oLcPrbCxyw@w%|ySnPCjbF=@ +{sZ&09Aa){uz&~Qw@kQ8bVp-x8zT-V@-{c}*2*v~6NlhDkhnhSX+gkL=0Yna3Ch~-$S}G8UgA@>jozbA9f87|cI0FudS@-smiqH8ASI)Z`U?j_*#{xF>j<)W>lfYXjp!A +Hk@=I>8BZe=WOSSM>4YBHu5oudgq12vb|ZScsM=& +O^jTQ%AI-GAGKWz?59;7~wE@I!&^rNxhXbhP7A3l;M@h-3;YMRu>l|E7z2VVi3kQkRkzyA4WC9Rz{yTi&26K>Zr%FN+ +B$UTP?@m*MG7AvFCe!=CfFWiF*o@K>%E_3OPqlE^ng=eKkHf(;7rFHoUGB|fhP4)(EW}$KKS?2^{?_X +)*&&!8)tE2cgSfi%xLVLS0u&)R`&zJLxY1gy4vULAM}qMJLW%g=8O+)hz24Z;Vqz#j1(4gB` +vp~W?^oIbjAZCU$IjD7g<;j$w~j+7#YlP6C~yNBJy_hJ9h1>}J)Lfefw-Me$sn!a;OtcfUnEXi2F%2u +O~Pod61O&1xHUx~H2P)m=-!qnU_7r%TV+nT+5)0+9~twnvTTGYp`hFr)m>;J|0k16^-pYJbeX=$?V3N +{@K2Cbt$r}Fh +KBOIyu5c46BDiC;$m3`K5^oNtX-(w2buGV{MFt@1;#^-e(&DB7IOiQ(rvPlPsD*mu3eHhRrgc)5a*#c%3iQ9ad2=@^Vqq2F5}CX=rFj?Gt=h+6&jeo*F222HVFx4-5> +Tf73!1ZJxzPls`=4UXz%IJXl|A*|!zjXR%Fb6C0M?d&{xbJ-hCEcNhA3>?8X5D-Uqru6IQ~g+Gj4={u +p1PxtinysGQ^zl4ptckbM|AD=&eeu>>NO>;(!QGVgV1^It*&J%`VWcBv;UX4T|az2$0W1hvDzUA%@o; +Ex@Or7;pF~)?@zd6<+xiR{BQREXPvwdqlw1m`n5}Iu;)t9*}W=ef~ns&BeZk{DfbSb_-07{R7IE(k?ZmT2m8aQl8{cKM +YFxb87z4J#0OC%3SW=y<5r@JI!4F=^fn~Y~CsNf1a-WhV|a-FVX)s)&J_%t1?zo`*E<_#9Yh=_SDS_@ +A2hs{pWl&|7uSXW8o*Ek3S+$U~KHN@coVM{@7{wW*lSzR>U>ov#BT1mpmKaJu)(~q%W;uqnQyS4$tGx +;aTNS=WKM2ukim3o{b)_H%30~i6^dY;1_e`C!V+VnE1|qasW?Td)&jX=J1JUtv%sMOth^NPg?tebEa2 +5XYGs5nO^ynwT+%+e>fZ{%`2(%)|Qr(g;V0HLuF5e^9uu|{&0M0Fh5itEh +g5crXyI@&!WSV0l?e+_onZ<5Iu;C9gNRDpVbozl6EY(YD+DM9**_zd97Gs&hVz|AYdS)q+ak`Rq`zCR +h?E2!t2DbbtL!t?0_{Bz`kc6DaYP@HZvSAI>VPDK8F$;=I+tjC_8aFeUDwza$)pOHEE#q4Of~gq5i$C +oJJLIbq?V#pmP%CC}9CjO>gZJF<4|%*k=yJo@~<`^@icb93+8`gMI&AJ=E~c|G08Giqwe80!sWX70YbBmc|W|}!>p;>FTnjL1JdBwbLj+>L_ytyf|IkF{^6v>R +_L<%Fdk=95@q%R`I^=|N-5-$g|Lajop)taw +(#C+bOhx}K?L>pA)Xy-=^vYxO3*Rd3fj^j^JBAJDJp>Ut*hNqJ2kW0MhMY%#dDY$L}wU=$h^My=6gv> +F{o_Su}XD@7TP+N1XW+x`nsO9KQH000080Pmr;M)A4effhLc0R6}S02=@R0B~t=FJE?LZe(wAFJx(Rb +Zlv2FLiWjY%Xwl<$Y~?+%}Tncl`>+S})mhi;|tm?yWX$kE1AK?bw!9k~6c{(lAt$t>%bLb_lj!^0L4E +>IDD+5R~N1?C#xj{UmZX2^0#2LZPZqC~R(Q2K)8uzA3I2Z4m8`f>*mQUv0ym-vwujJUG5@7j+e!*7No +@ZSvr|dR=8{ThvtyHBa+Acz?Km@bUB@ZtvP4t+HVM=;PVR;WwYoj!sVTA(Y!FmaDpHgIS&BGqEvm>Lq ++H%Y24_L?B;h`H$APFR6QW*Kz{ieJD;|yP$b$0;3Vz+Di`AbM}oeO +B`wB5linspwOY61;FQW99*qgT-e;E17I}iLB%)q7GXSz~%6gSo<6zOYD?nx(+%3yyHKVTrp0w1MAKts +Ov*UNbX=UDw>Bp)3g(UbU6}kCr00tJ@ud8`+wQkb320%AySpWxRc?CU!S8ZBU*uacRt09O&1H%IU97%?VIOU5ASVLO6UCD8Ro=d*XHk-1^(28(n=s2xU|tkWz6 +8_)LlApW^6$}+gjVbWjc6|!acpA#hNH*Zf45)hE5fbZeQvr}j)3M0giTS +iPqZ-5T;OyP-G(*q_K{KQ{gUNpe?pp3RcAmX=&CkOjyK;!SIt2i^y#f#|8@z)u!+5C09H5$nt9~A8ZM +iTx2W5D>C+*J=eFDm3xpu-{;IQ$zYdt?DzY19l%d;R4uo{xSZK(7V?L7@@$nwjMN +;VJTn$uW|in!3(Apc&UaWk#J!-19qX(g3SR?;IHB`2k4s7RBz%K@1!*OB=Rh1>pv?#H^y>B$m)*rbd}o&zSl?#_edQ<^1-Ji*p7Y)w5z^!f4ZWq5(J2fw~DNn +&{#uFGX$_+6=Jn3?3rGjMYdOaCe`Rz^;)eD2o&=Fc3t1<$o;Sinn|?o_J%ljby`XkM +ri5R={$djD^~9b;03|GN9{#ccwK=WuG`J>5#`B`e@NI;3M!rr>du&Hb?h?^aa4-733!jT1dM-v`@H~i +E5eVVG_^)+QMN@qHT;Mx^Oz`kufQSuUjCv#oTIF{xFYt2yI6LTaYFUj*yNV=GbFRqgpj98je8T7(qG5 +vH#}e>_{~6GW6l6W8CyhY00d>HMAT4kL|BvK+q{+&7Y_L#3^1}nFAd)N>t%$ncOAa-M+pyNE79FB}K>)sQfoFb)mqG{sK<08Jdm6}|^0&68E0ZSQQ09 +E2EXdKuN%wGkxH75|Bwd{w5iJgP;EWn!oTjIk4TX0BLb+%VbE<7{QN6DMFKKi#Ckq2?#5IOIhJVO(P;&uqqu{L3SnY+cff4q5IAT}2~i2B6`F7nLmJt +>a~e?96@KW +0MBlolokDKm;Hxyh@WNRBK}c#(>}I!JPb&e$mVuu#nJ^4YpYGYb33hDnkf|HtuQGj|1u|CF(r>i+_fI0q60qg5M +LwWHJE&+wGTfjU>FEzC$zwP2ad(&o0PLK3M_=)phax{rQfS_At5@r$Oeh#>9|81JXvmM*vwk8Hob-EA +&l503G~DJ&IS^bF-0h&IrHQF4@JeVbdIB9Nhy6zntKlMkzZ_0W$rPoVvoLfy&TNu&ZGVkS#lIM8 +U0nGttUeS?s!UP*B6*MNKwmOAS)i_=Q=^)d7)0psK~#r6#hcJ8E(`LRN?Svgr~g=CxbVq)NZaigc~n9 +;j326{}Ry%qHbncG;RvGdU!ryv*9<@;&OMLr#U~iBH|Y8U!GP{Nf$qCJU3OhTmb}Ru0fG`ZV_u_P{dy97X(>6 +to;3e2VP2EVFJLeoZ_!V{gdMr)vBFki$isCz-~M0WNHx5{AkScpYf;{$8G1qf?eys5IG6(`pbP6Von5 +1lDD$gyc8}BnbBpzmv`vwv2v&?uNQ!C%l*=)~qWn%fQVj^``Hiu43omPIup}zOZC)XDM0ha`SLF1LB{ +A`d{%R>MWc`h4EiZC%d@$G;jDw|!9OZ(Be;nLkIa$SDka{ZZh>5fnBCP3I=Shv2$VCBhOz2T0`emiEC +^Zj3Q@>}nDWHJd^ctCtio3d`A@ih{TDz0?9Bu)HAis`w$H6XRG+Pn>bWYWn{jkUMBhsd}TD4~@UbHjP +49q2awu<$0YkckHSr(hGtTGSGO{gH`&V)HK_FPnBt^p_@Y%txV_Qy|NPalX@`-1n|LL%}S7EymOeLDz^f;b|2N3e}#D +^F~{B|AWe!kNg@Vi`dEf3yqL#|DdWu2`{{VS_y@YRw91XG#b +*-=!drB3C&{#50T+lzT9*h@DPA*xOJFT%+3kRT5LV~GJK+kUdK04Nn6g)$OilL5`wV~{%3PinV@6n%wxGhrj646R1iN#ws2(zqbX~|O +;UsbrwKtbT>9Jga}QwMCCHBPqxk%Br)g^xj@AUH`2As4Riad2pZ8YxuO)iz?ZU5G`%#Rc-DF(Nr{3$n +{Gs2f(hVDbm(e}vHzFn<@Z8d9YOfb0VDk?p?|?zt?Yz^l@zy{Ko87FNGev*^Lco*JEuo)K4sxDW!pup +QJnE=66g+x!`A=VudP(?-hT>>|l&^! +I4W#(IccTyJ0`<{Ht43v6IRezi_nT-H%5_a@O1@&AOU=mzE-TWwU&VRv3S?UxP)qZt{#|i@Cu@FS!|* +m34#5YS+H`980>5@+$yJC^?G-PLKpO4=@M)?EwUKqMKQ9R*a0J6s&Ipoa)*lo5M +mbwgE-o)!kKqH16^f+#bZfvIeGP2!NED_&Jdq9BqSE3`~740TcfY%m(%s0hl +EU9q0o)7GdEm<|xq+t_BrytFW4abQu7p$^==Riz;kAn9Omou>NHYvxw^2RSUsg!DRxpA8hTuUZbB=!= +nDG_G1=+!7;1>DaPL*TeA!_u|$k$_E3`sVjt^Pu1D65AJsHSPFl-l+r1r32gM$n +5{fK%$i?mvQLxgq3O@WumZ&cVuk|YlQ@`pa%B)`9OBVr67BD|)-vpFR{z6vW1RJ(z4n{@7N=7sSn|Fm +49cTt1skTvOA@jkaJA+jfjT`?M8DcC!on27^zN46rBoYS6I4UegBRL8Y1#I&<*~PG&^w96o+LWs{g_q +*Ww@;7mS)@SUu;T@r@GV4HRM#3^|IQLOfTkdBIDqD`#7bxq%6ffAQ)#pzxkI%<1U9*+5HyOPg#)TGO@ +6g5(}o6e2pJ6R5LcePKzC(F_%DJ`Mzr15>k`$!02bXw3TtPxOB#^Kg@pd#_!;YgxqRqyHbb*ntXZ0W8 +cdy6vl;_IUDHB(h-|tNXL|AZ+gVroY%C6Tu>A}kCSL^iY}hpdV6~?Rqf8@BmGJh`86Ll<#DpMyO)j9& +pt1U5gSL$30d@fGDYEF{x~cKgGoE{B#g_+oYcL^;tmXySy9+Pj}Ri7SU2~tr$V>C%2Cc<) +aG(2eS&HH_wOMg)3?|-15j;_R=q!?yz7rUYSzp%40;g&}l#n0_MXsGDZP~E;P&_TOQ#r2pq6UXr&Vvb +(}DY~jfapy!_Va$Ka5e(ffFv1L?`j!Hw<)#RVZ!pr!Yy>u?0|MB&vquA5T1jz?ZMFwZ47c;Sly`X=rn +dT+GU*v@aii!!a$unHbMXv_@Hx>FRC5wUO7EDn%7IURAu^1DeZ@_ETmLhBhzOct45s%QFEV<>)&A^|5ot54;62Npb60k`@;l9N +pSo&>6=W940C@u&Hk|v#-07UzukE!9Rdv?8LTRh_T;dN;b~#MTYi!C}f6)BX$eM2cf0{YE6- +bA?eHFr<`r>F>9&n2mAY7wIGvY+B>Qtg%ypK1UsYF3?^JA?9XQ$@KhiB+7b7){AvS$?^`ioz2_iYzegi^WZu04#9LX5KKo$EPZh&D!Z11oq&(m +1R_@VQ(7yYv@631Vs>O)Y+p +&rhTIJ0mT~SoNQ$0ym_pE;;c#;;OIVGALV@S|lEn`u+6b85EX`?p5z_2J9$zwJIDvX=mxStmF25YPuU +}s>DrsTWD3Lb;4*vr>ZFuUU=(>%ngP|br>N`cP|F5hh|B-y$3`6GE*9c +9M5@Ll+1b6HVx{7oGs%KMO^})$o+H<@5pN4z$`Ij7`ooN5+t4PL35@@2BqPF48xVLrbaC$j=gkog(Tq +v%}HY7p|`~hbo%}zJ=LM6r-2pieNIdmYTGUjM|~(NJ^-MNxiW?G?-~X@a@k6rpKKjA>%rj%0LmXK&U< +wS6w-7+!D5eX)$s_afFO0&gF|;5zlc2IR@s{v@IoH}aiWswrHpBsNZ9sEY6k-~@L!gKzjxw4G~yIY;L +6300K|3%I%BhWD;lH8SB>m{A5!?WLA^i*>g|zI^O^&l6e-4L=N~)_<^34gjSXU0nC3rrVI#Qr-d_-mX +k{ufHV41A+u~J4`pTa!7#ZU}VHEfmsPqFJwirUyk-s0Qr8q^^lD{9RC0R&Sl0@vf(pzSeWRZ#mtT&S` +NQR%l1UmS5cJd#+ldDY_(pgyS`)fLbz8znTUif8g5S)vxi8|{HYa%L#SnI_on(m#)7x-=Kfx3}CZA_h +c4dtT=R(ccRY5DFaK%sNTqc;P<0Bu~~;_nYmzBxKQ7+Hr&%!pEU#?9zVjpQ11gDYyp0+w1l6Kj=I@)Y +@S>5-t8rH$LG(~u;+2?P!O@S^|xNn4rWVa4H?HpsrI;v)@ifIbgAJ+kM+Q%?L+cucoeONAE?`pVI_4g +{Bc&W@IjS-q}c>DUV`ABie633hEd*kW1&89#O$w1fD?BzQTr-}QH;?!y#*usdowHEE)j2_PwbwU1BpT +kp=$-^6wQqqI?7o<4M5S{ItDquYi9oi?Z?F~{NPqCY`RJ>elez^iKL1Nx+^;)%A1Yng6FWnangK6L-f +&`&-gi*ap4Ia0Nm%IuF6ad5~1ES={E;}r;;j#(JvNy%0}hfXJ)1aSjU +Imtias3FS%60;5wjC>afMR0V%3s;s^R%M*&dKiYr${_XMcw{OqhB0>PKsJg%pc?xYwc|zbp#c;WKA=X +O{^`jv84m;jXQCUSOu91xIjv_UaNFG2@h#eoD9{!nY*BVV9mUPmbF(tGxcCZOWu&AYq*R`}QV!5&u|2<9>I}7nRwEJGyMQj`RiJ=&TyLpQTbt~LTXEG-YkjW=_Qz{6m~>=ZyYHKf?Dr4@$(;kU +=I1=hhDtmP!PVBQXO8Zin)JQwH#_1n#2z6(~6$Ova`gIxHoAdqVOLm>=O)K+!73ZtJ7ximbfRNT|4S_ +4ThT>^2b`yL%6}PZixYckes(6?b+vPhD;W+g8;M%74`~cZ_^4VjI6ATMbyIbP^cgpISOF7n}M6Qo0!o +vwAHns9Y)iwr3{~*V@oO^T*VfT(nEQhHWjdL6n?AuMuwqXu66j9^5X5W_fn$dA$f0yAGdtc>l}Rqky) ++R8GVwNfU;)W|(%7w6$Da^j?C!s_b)^bb!&%GLDy(FQAkmM_B;i3b5vM11T>th8#-Es~Q+!vBV-6-UErI5Zl8dFz|i;XzDThg=-p +Usa~I&lN?`$>8pb5{8j?@)=4OzD@3DU2mkT(=InXNEcW5j|wIc2U8{9 +?C$^@@S(N1mx{o<%N1BF{<-%;|_e3HahRprv484g${30)zk`lZ6!xqiBul2BR1*kKxnVR+F~B13%p^g +>=9cy_1tp2aivV{tdH|eSG`jAbI=o+XVAo9UgtO9R*=DO}BsA-Ts&4;zfjs>hNcBp&xF6$-ezmE1?4x +zu3NbF=AW(aI|s!A7}55KKe0e!tK?4be^5ZZ_cwflmm^Agdxu)>aa?rzR*#5bb^qJ)Tg>1@OgQ4#Ffu +;LN!hiDt`x*PBPVpVS=ct1AV+&`n04G&;tZtQE}0fS1tD)30&66-eprmxhfPUzARn}jI`?`V-o8QO!U +|3-ja9zBWXhwbBk!C?cpB3ZZdcs@ScBHXav&BFuj*NXq;&bzT{$-uJT@uCOp3k$AR6Ket+;&QGY;$I* +AxG5xeeG7ahoHMTlLkQ06V8MK5|7vptMq0R +b^sV|^+QZ{)%V4z +!E$UP2DP?2eB%#sEcz49T-s2(IBSoo)10B!l?qm{=G20q?qX}!fa-_pxwgs2J9SEa@}>UJ2j+B%ctFMkaAPGL# +N@$Lfvnp5ULbgA*Yy-FigEjK2m$L;Z}bK>X%8^l3r+=0f;#9$%fqyee;##(VDIa3gmChs3@rDtikIFt +wbV4GkxiVKS6cyx!I3?}&Zl6W=D~ +ZGlMXT5+94Cl|gHfc3B#4Ck6{>V%;a5 +xglcj&xG;mp*r;lVW|>yJ5CR0w=F2bt>0kaS4!$eycu2^Mtd0HuO=(7gxwaN9h&9zju;4V$vB~XdnMg +DvonH_?3rbc)8IqtB2QFHRlPrJ-;qeFq40zRUpMgRdj?iNsrg&zTP23&KE#piMI}YkomEYm1p**AJfE +a9gVip`V=fa2hiF4~bm~ICFJ8>8?^$nMl$#VcD3L;na>>7H+b-Enk#MxVX(IwU4Hl%CB$peGSfzcmHn +!J>IrTHP-~c5k%C +!SMKao`Dd(aVN(Bd`&D4=DQnxPec`sRps9>HpY!OkpUF3NwpLhBWD;@pV3eLHy2gD3EJA`rth-ZP?RG +qOn3f%;y6j>m1xVoM*^&8W}(gUh$#BH#b2ECWYX$m*DsU6ZteoQ2# +VpWw^)#u5S(?a?%eE^Mg362w0hOKK{XC;`+4~AP}fydedQmXKAd&`n`BP+T2p@QTzaotpDl^fTlOM=1 +b?2md6+V$h1p&D(9*vCodzHmtV7=eyXd-$x@N+1G0Ukt1xB>Y~3eKgfsT4(K +-^lIf_rAdwub)|W6Yiyg7P#FQnMO42%hWmmYlv0;g>-^lc6x*qDTJPGm}+W+i|j-?yha}Zm9f171!KLVFiOInX(ed$%wf9`XlJV<=%HZNYx%HO>9r3;wj=G +&DHR=@D`(%u@Q=_Hat8p@vCz)7jgu0tJ<-oo|N()`4}XqJo>vfiy)hcS;@Xf-=sTEqF4eGL*9t_1tLM +fx37|;}t(rbf5;{npcumy`GC7)y(J`ddjH@U9ZgNtyNd^tP}zRY&*cIC!FZ{e~MX^wD_+Y;@+|N@MCR +Yfr>i?wGfz*)v_E|C0o5DM;+6EX3~C;-XsIlE-k-ic2gSJLohr7+zj +lZ7kWK?RJKy-R?%)Ukdew<7U+v`wiXoyy(G$MRV9bR1ZhGbj10n)9=n_eBL}icrpBdXCph;4?CpsyZN +;I|RT|nW(CY(Z}=NE;0m$9D`MN9K2h*-1;D8va4M5QgV@fmgSnI8LqQH8x2YkURej#aq&Rt{Ub>$1}s +k`F$GC1GEOKJJqt7+!Q%6Fvim*A!iG!~{4B^^&Y5AGY8A)xE=4YS&8oDq-7zcKDVaZZ_3FDCTXH%p8ppAnWB^As5InfAtXshb@#YRT5ST7<}ei +uT#4_N20!+vZSU4SO`yL^p|tWsM+R7SVsq?>&KCeHH3C?;WHBITr$LRa64++XaX$iV>!6Ka97YERDPE +!DQ8XmkH|cf+?$fa)_yU`*19nk}H+44!-uodLn$>Ngo~toZi-Brn_@`kosp8BN655lu$xxlay3v;8dk +T)-B_w#;5AKs&6Z$^KzvJRfx9EYWs=EJ?RFqm^S!rsC;G^3pnB#X)xiMe7MZDpgJn~4n1#@k;R43bDE +au;=iZT{Y80`Jgd0(qx3Dj$V1e0rwzsd%Y&Kle_7=H5!+-NTAsS32xVr4Q4q&5g=FHGNKM{Tov1?Cj` +{ji%nqxZpP2cZca7Y$rd$~#r249%BGDHUhVGY|_TC_|^F!s7ZQ3h0V3p=F=c6C+V?goakzuqVGOeOfz +XtIP#p$qA_MM#KaniwGRN(i$(|Mw8>go#bO{-KIeMg7d#2t*iogL`rZE;XDlg}s_oS5`Vl6e +<030&EXmVUhAi!+nnFhC%M#6ksRk{u7Nh>*!YfQl>YY%c6?xhhzOy!}6RDC$F|m4jkE`zOj2nm+sPD( +@dj8))e5Zb}5W}+I?VZst0=V)>*BmLMKEAu2%uhEE6FDDI0q_&e(`x5GeUQ~G{(#P5xAr`lKDd>xM-&zodD`tagRD? +DDha!B(~SAC*FXcB<)=~REXj^utPZ_>bQ*hvcrQV%d8W9(9%gkfi%GYhgjvDs$RC2AL)XhRn>p(6Z!u +Knyp52_P;?hapPFHShuybd!{2`;mEJI^Mqc_3x(hsj38ZbuJEeXNd#XoxUWMiv5p|Vug#o?=B^$B=od +~<1iWTL=hCf$7!JkX`bGs-p26Q9U{{qAz-xQWoH +81&JXiLR>t|g**B>zpisB65#5O-w9@&+t<`MxcYiv}l^GJK3ez_1Y6=3OxU6 +|I~0sCvHx`<3g#Sf^bhBUF`^!t?S`T~@vQ-Ks-+3!$4Z|T!}1Qsei`Y-5FH&$QBu_A5GcQM)5=DlS2! +JN0b9kTlJpI?6UWp^$e4Kor@Grm1r;FT^YQ^yVfm94i +H-$Nw-k$Cs9%526go@jg+vtQT^OUbt!;R4;hOQQ^0|m2)(qg}6gyn@Z6jjgO69x@Hc$MfU>4iQa=_u; +C8%W09d$(bKsgfXMGM%9%OMT4J%#ix$;8LbAlY|Fj+K~EGs+VTF6Hnf$pp$O%5)UlJiDgxURu^jnudL +85N?S>h(rJKcQ^nzt%sqMCyPNtx&CvUEeYxGj4+s!x++aV#;#p6&J1oXNYUorA*V5Wt^Q?rg+_l`C)1t+6i%3i}m27 +QtoOpmO->mPc9eQ +EY+ZF_4gQS`@6cw%SbeJ`LI^k0sa)Xj!Sr8zk2baIMLLtmBY +Uv|#V$3I`3Z=G-bf`9nIuNNJF4~M58-kw2|rw3URSpL{WFd`UOmRe?WkSw%7?FOXg*t24Z`h<+lV-&% +Eu}}DKq`^|ZdP_6iF213Hw^oYcWZInTZnaA{;C}+p_8p*VBy5WeNtS|^_mYrl;7f#GbZQ@YM)m6{M;$ +7n1fsq9#2H?tehrKYTZGk58(N)hv?3p$ziv=35E9_OSQB0TN+Y4Bq4JJXcq>r^zhmoa3ZItLTwJ$GfYHXSCZ+MakJ1#j9N2Da +Za%MnoE00H?0_vgnL_wW=924blcPN(J=dn=r{=c`Ox@x3nXy)e;@H;Mkir#ox%Q-#LGs5hWC{nz5)cm +nY|r28JBT@A7_l%UZv(Zeb6Tb`7w~1R=nTbHken1+u+6Jo+yskjU8NmF~(#D!4UKLSv_=?+4 +fzRvkNK>3qk({JzO@O?Bo6aDS!l>sxA7-xc59-kbY9qk{zPk`(1*+%(p@i@NbJsF`i}4>f0)kQvCGY +Ct!td|8&wvtE=SRPO3hnT3c)3JI>}3eUpmZd@y`zg&KgdwY0gXh+TNGeY(eXL>lX?`sx(07g6)4;pWG +cEx|+vYJqy%p+3r8f$1ywlyR5oH4VD8vP%;I%X5RFq4#*(dDxlZbPUd_!eqvMygI?X+cD?7ZPlggK{{ +*K1c^FiMNOw%n-fV>er8T>Lruuc_Hpo5054)v4}luxWlmR_Q)vt(*T4WL&~1be_9P8x`(gkqSrnf?_3XT?y#+9bZ8&gBgjMl +rftQJC3c(DQ1hh#-tep5p^}=V4@`dBPR}B)o}1I;KPDkhE^FYZ58&GwYj^;@sGKRDLV~yQSyCbrS9xW +LDPFLX(LZIbu);8bgMQCu1_cLNnkmth9p%&LkDMpcu#xndB)lPVQtAVJ(8$>UPm_jUD0SJV3r_xtuYn +;&&d7Hd5$RASN@|<$VU9#@4lq`;*_oiBi5Ht0EP*z2qK3d1L?zi6{EnJeq_-9-T +hAi##-{>518QHq*sZJpvY(pFhHb%c%fvroc^cAjE@LSrv1{>ohBLzGCr9^i6Ko2#6+z_JRZ_q3pxZ{E +nomCPXc8I!qReeKsRR%(y=HrV#gfi6iG--Kml-6>o|PWO3@O>>T{(;>LZ|sTF}hJXKc1*tZdl(;d#Rh +saW31E=DNGgkk~NqNz#M6b5CsZXV#vuv;efI)0SS(?5TBzkPDNFSGiv8AdiNDt8n#6HNMXG<&ZuHa5^ +{*AvFagdQKnUMPcgwO_&5#WG*|6p(SrIeLQ_ +i#;A56^H3Da>PclO|$e(h;3cG@sO8{6r)CYhd#Zd{Dk7vms@|L?xq{TH>2;vqyVMH3>j#r;EbMSU#oA +X;b|O#ChqZ-z>J%F*Zm3UkDU&c-_Lrn{bF3tWg|sgf?KV&3;0_F9?*%nc^Ln;x)%z3LuTFU?DAEImY? +><4wv$5__${}$%5TKq3yFm2&Kg~f36WeSZ)-2}>-mR;+tXt%GQ&AO*jBsj9`|2f9Be7CYYPj*cWe*6h +Pe#=zQSuRjTJw~<8oC)32;d!ub3h(0L=YIIcCF$&uW*nwW*PTtiXale3;WaQ9?1G-vOBoosD${$8f_0 +f~6OChig^$UD3W?z$Brszzz7+5KqrDl7F^!;$Hl@uu+4YE0!kVw3Tb|?9)CBF!kTUDpo@r+#@|-0Wo} +l#0YW^yEs;aj%S!raTTI82zw(PM8MWd@=Arzln>-eW9)hw=IHFE#-dwUB$)~*hHHJ45hOi|E$57kWE$ +Sj*^3WTjzzg38J9K5S<(Mdoa1eG;3%hQroR#}X$lfdMiCkOjSC*Sg3Q>-&0Lo=*<&nu2$@3B3O?qkv7 +ac)-@(W7TM*xbz@NVG)S$q}hbFVFw7i&UbWSo-PILyb4FbrW! +0}$6w8$*&I(F58l;khbcnoJA)m!)V)Zq027!`d1(Z4Ya*X;o@GhyVfpA0jp%w{z~pD}t+xDH%a*As-^ ++LBW4PB7_k0460gjr`SI5yF27~RdZL0aq>pqTJ%?Y*Nv-j$2SJv-)LhX1RV~Tzbbw@zgQr()F!!o7A^XG~81LtMTUsP=g0 +Ry~Fj{Lq!1PDCN~~Qg*^g9f`%#jy6b9?2V6xv8D%7f)`&(EIco+)-pGu8ww}K+$cj^Fy;ew3Y8MQC45 +S#W%ZeE)^N+mZo!ea`ZO%68Lx!!MZFk4E-|AfI7zd4M-dTWjS0+6BzWs<)afT&-Jji={^1P4AQ5M`S! +6KTOhN_R=>`G|9miiII}z1=Z;W|K_c(}3y10}M$NK_Lx}aoKRO?YRRiF#L-nF1$nG4rx+-nF&$S-fgX +v8;CJ|tQ6Hh@cn+LuGZr@dORoULf}q5NhK;L^dEUSIHjEt463KFMwF_C*eoZ#Tk}kocK#d(e9}ZK6@w +v#ZrcSTu7;JyUI}yXlS8TNu+T9N@9XV%k@GasdZ37IeWKm_SA%6=}kopr#k0o$iMYwYmC;tjI|krX6L +dJ$bP2N*F|@Y;!0vqwBFA2W}S!W7Lf$Kg4DU?}YG_ +&?aHxTb9Im=P-8>xN&jJdh1;W-c>N>yoX%xm3nnDrl;%Z~MDlBNu^8K-Lj{0t@ae-1~@q=^rk%XD5TZ +S~2-QpCV)~>a>_fyMropu+h@9pd$<=c8zm$A9Y*}DiJy%doP9X~4f=ujqjC+R4eds3$*RfFD>hB*#su +`Q~riCS)P*KqDA0sSjZ=7WUVq#d)nf^V#D)>S2QZp&L0a}ElbrK@(W(wP(urZ8Bo+iuZ4)fGI6+C2*( +(D@R~70%u{)`u5+YavoemW2+CT0+BCY?{T(1C$u%|_QPQs@F5=}by?tTvF1M`+84%my +Sz)N>M%C-W%>A6T-<4i0&>%s(N`TI*z7@RM_&-of0|XQR000O8@1eFv85V9LtQi0RpIiU{9smFUaA|NaUv_0 +~WN&gWWNCABY-wUIc4cyNX>V>WaCzN4Yj@kWlHc_!5IZ>}V~UYvr)jjY)84Gxn?0@T6Q|v~D=E4Z1<7 +nAk|inGZr%L$of!Zmz=v%2aeL3YjZNY)7z_sU!hrj%`?Sk~cpgT}A=~7O?&nz2+3)PLH*s>4hRe&G*> +4;+==BF(_;tkIUvhSSlV8RWyNDP0m7j9gCrt^P@R?^WE9|cW?jp{ +rm6UU0@-!>+J3Ab>6O%6<_lxr`{}HFrO_}{5qViINS0xgHk|_Wx*vhV@Vos!#Ndfk|a)Zwun=9etOiCrjg-44__18sWeLbG{<`Nm +rCI!<91fI1w=S3cbJ7ymitk_ZEEkbd;<(yYq#Q&XyC9D*6S1~OSmOxh) +!U*<6wwV!iET;rMh4l+QPD@Ug1I0P8f;L#VV92jj>##@1;;q`MMC(0NOJo8+isGEn5U|gmq_mlyq!xR +^jL~$oru?U3k*cGJHK-vjnw8|?`6i9b1v?h7g|e>}>sS}|U>kEUU4OOy +#W(T;(%t53w7$(_`=FIWTP`$Apb530}-mwBEHpFNw$LFOf-Q@l7`K1=z6ryMrjGf*o2I-c{@zK{k0>e +A0Hr&A3zQ6RXxh80%Y+M*bfN_mpD_S}1t+13--aC?f^VQ|`m)2XMVqH9PV12`15!qz*9K3{-lOF)v`6 +cEB}nxsGm5(hOn?egQiL4GLd!86Y)1-Vojrl6IgSiG8L`1aN9$?c=#+v8sb?%}VupN^f^Y!$4vMNNcihlj{=AU*@o(>~e)z>-kJaP@?-vF5;bbLu$774Y*o#d-fy(As)s4cW +?H&*nbcx-4*6GGtrW-9f2st&_$!Cq|oB$Bm6ZvIU4&4dh+TP3Xt%&5c&~X|~U1H^_wkW|g~4Go_AC*v +YY1g8TF^93M3|e^dB)%9LB#adYqa(8%Z+ +*GP;X0FGF5G^GQe +O&4q)9%W%3Zn;$bVHQVO0V-I*WYOrI=(ChV4<_bJ1L&Ef*z3U>77qo8nUE4DOmCczj67+VAdWGS%CoK~fdbnA}=)YH}vX&5JU+Tag*pPSX3&A@phLp +}6Y#XhyUxAer|1DrIwx(tKM7C2YnC*{Hn2V1?|?XY$+`^b61!dz5HZQKNA3(Y|nFT!i&u+gwPn7HhHy +5Vi)F6>RAwj?8Nqa76AXaBWNy)(xnw}cqZpvaJ$zj`VRpSf2}$UDWIZy!}1dV<}ZCDBY;5%S`xHWyhC*1N)Q)$N?H +o&JtUe9|0%ube>Qa1ClfAoAGcg=EzD72T7_!kQYp$6J&*;IS>dzATa8+%Au1g;ohfG_TK=&S +l)}p;3+#~!Q{dYJgDaT`u4Mnh;0oD;3T1q$(Era1yZq||05Cm=9sJISz?1aPj|X(lPtT8zdea|H-(9@ +@?ri$*wC4A2U)$jHK62=f@_-%N_HSpm!EG8iSPm}uo#t6;L2o;WK^Mv{_&(>`2SGTnM}GI`FT4Lco=* +@R?ag@&K*%@m5FHYpOmT9s8n%+kb=L|_`5F~W->PoIiw)Kmo+byYVoD9=Zj&I}On0#2O2YwUsJ#{5%U +1JV`i1x6SyFm~T?#HU$~gppkzpa<@NLxXPjGYfO7!I@R6B&~jy}!8St#4{BnCqPKv0Qk)u}o}w&*IbN +>a^FJQ{u`gd}o6S^Q%7aw1uGtN9?kVSgaXS8)Iqd0BHfQOFW_(2XeWT@v~lyNj_URZWaV75oN7UBVlm +`;%g^1%|DV1^&&TMIHVrf#Zt?ohI4_Tu`AAwy1*N1!R2I01HahViSsh%?L|NRr9Zr-LM!rj{0icW~!N +eG$O%$-vB|$i2#P;X&5Lylc8OI!tjhOh?l9KfcNAwe;bGM3LI&+gIx)7d(Gxy3Icd_=iqB)J!6^Kc3CX)sG@+CZtkTse5Hm`BYXjq2BP>Cx;$Bvzh-S*?~vY< +H<6B(As>fiKI!_En5=#$k!jAK+aXvvtujScDM(lO?qK{YB2xYIKNL6l;Nds>@l2Y|cdNDa!}zsM~i+9 +zb%d&VH{H4K-pZ2tQk{Qx2;j5WeX1>lkEGhez=h&@2AP{G2= +6l`|tkqyCJYJtUdXm@kZLtfAe*0HCEbZ>o5v|oGibJk*qVArh#4AQf-PA-|`h(WAx+F-=auSH5te)SO +F7#Ma#mpYCU6BZb4=J^x*7%wGtLRL+>4Ii4{t|pLrT{^uUR|tNU*sgT@=&>fm?=Lf%>#i#W%SKt&G!! +}}jpG4RLh6%X3l?X$nfS3nE!3c>VYz+TEnCc6i*LBN1aJ|ukreiyoedf49n1WuH9N +L3SffS{rCph6Q%pT*dn0I%S(6091;uyJDWgww08d3VQtpV@j-O&5JvKclz%1o9X*6zrG*`FtMT2kZ=$CFi#%|Cmy)i`L^(Z2X6iD76($ra@{M&k1SP_AL(uo`$J6V#XrKfA@hi +zJmRc=*|>Qv3rsClJ>HNl3TC@S?YaI3hfw#?~lt7lH6>ri4_XKL9Se3ZGv|y91C^eFtQW(P3xAHLHo +o2IkPXN$rRSaZ*F8BHU)M=PqzManzJfj^CMa!31Qp%=AX=&LF6;_*GKQ1DcO8Z5V9{U6I}cisM-N_+9XtNvt5Q3-`HMyF@tq>q$Qsav_ +5Eb^e#9?n6@6jK$skg12omeC9pgVbN +Ip7lFucjXiO{`E_WQy$&Rd?QW}D@bgSt}Jo60PVGU!Zy-=`G&lkG9xO45CF!i=0_Z7sCu +Yz!X+2VHkbFNLhYKH>`9N$}|mi)T`1@sal+HfqumWLrq|?XG2&Q8hhDhW@CF-78?gOqNt%K2x|DxQo* +S+b%=o|sM9i`U|g9Hfhk)#$6Ud9lQX;+Ci{x0aF&ay?#o+Z$$a)7_{+<9K82MIxOT2xS!o$zZNOhU+A +h-L6zZxX+bl$dw2-i@cCad1l(AV#4=&=X^_C+H%j!y5)RaoRJlU4U5ZEt=wL>MSP$z6X!(7rkg2`0rS +((ykjY+PyGu#z^D*Ch=7Gl8B;czm+G>}%{1|?*t;o+oVDef3bvt0`G#DkIQfT1EP)eaT!Vk5zOYd_2U +r3h|Gz(s9+H#Nxo78;rxOB6dsHbNEQa!=CC8@Ld*5R$BGAqWb_i+d?FBsRrBWE(tKF6@6G+v}Kw8OlB +oM`{D@$~>z$6Q&5QOE+DJUKE0}Y^U8Eh+zUCUU4Os;g*-Kw~X%z>b+gCn|Pxlmu3@jMigRXvOFZTLyv +n6QFR0+!B!%$>&gI-s@W7>?Bs5^YSVN37)$K;=}DB%C<&Tc9p44=U+GC&gfWdA +x^eFry5}f;0pzGYKMQ>9QFZ_aeBD*L`OhPq)R@Upaclf=w#VtAI(+r-1tNoAb9G`5al8MyXblKt2iz8-#-uHS(1^6pmpiL$g8^~C8QfD62`3sRBoUvbkX1}s8BNnE$1yX!P9Ry!ztbV* +)kR8@rq_%{MQfbe5&eL@mA$_^2tn*YmaoTZ!sv;aDko*-`z4My_3n2%t1D@n8B5lBZ8bglz6q0E;t8tG!w1QKW-9kjr1 +i#^|i2bskJI7)FL0Tf{dDWq8v&w%g? +FMHCJkF`03HJTNB%BBcvc?52k=`WRS%cMsm-O*ZIxebL~>OA&bJWBrSl4Fk*JFx^u;zD{3jgM0PS-vA +p%LpFdxeeckvhgsi+QC@nzPcoOJGKlwS@>)#M8GEngv>L%~dkAyemst_8ZfT|;Yg=2Z&U&N%aALqI{7 +|b0s{le!=AlR%U1YUvA~14cp+Svj;hcB*Vu3koxX5_F$Ypz=I}W|xbFcSuPeMl(L@7?$kiB@p>`w!b? +Z5&mq05~2c-A{0V%o1Cjpt7LyqW)O_AC&aB8rQ%L3WDwoc4ei{vIwQJ@xiHb^$Us$>Vs1c_|B(V6#uT +DqaJsgQMrne&Id;Y!|kOsaPY)c*|G)lgd6qPPT}(&d$y(mitR_JqdR*yfo3kdu>yPTlhWpQe*&~!LYQ +#VF8f@hw3Vg32Q`mkuXth&R5|&Y@S0`fJHs!v+Ed5@R`qkh^0LlGS2rLQfP!3ZXP_8ihLDiuN>@J#zrOsAQ!Uxx~Z@UE+ZZkM +~6;pGw@qQrU@tXgKowUfS=;Z40a{%dk(sr!{=(9UgZ3F9w4_*$~S_ODwN8PF3sH#&w2FZ@ahM8Y^P2M +rlWL#_R-;Dire}?`4Co*RX=lK@&RA+(aGrF_sMuHG)Vf4uyI%ZyDxAyB*DDKc{y!12y2|u%2uv5QH+b +p)NPrr~dOENV%h(QcmpfTfp=d(74A2mqhi@6k@jKPLb0gOeAn!fJ+^N>_G$32MDD|KooNt1bw|lHz*S +n>kWWX0AU;QD?t}Yy`Y&Qp9Xzq_q@+`%YC2#z`T`kZ@Y#-3P7+9PAVHKSUr3H5d~ew_LA#8b#XFG&26 +>z(~nBrS4^ZDCmV`pr!}w4srwr0Y1ZUZgYCXg$57%6Muh{Cq;bGAa(e8>&oepDuTx|ko`3o7eJ%Eh*G +VP^w=l(9kb@uwEwnJbw@ydPRHU#*ktT)#c1)}aWI~lCSHmdl;u}f5t||hfUT=Y09p1lC@9;uylz8)s* +I!jMVMVhyZnt1Ler}1fgzUx))oP+Y1#EPZ$Z%cZ6jjpXF}6}A1>KZPTvoYajY(nkTzL%2^ejwiNJhi{ +1Rt!IR`V@k94zsE#QC{+q9lI?Al~YXOr1GhNyTJD3PXpXWn2ki11QhwWDhjO#^hVMm}asPuIcW}!?0+!b|3hW=lHb{3@;^7mzBJUkmh6&4@t?3SU0-Dp-@)^){ +1iVBXj^Z}8@iyh^bg^Ph#uvwOPrr%yFZ2@>}DkXFY4b>B>jDH`Yq_6rmL!CnT$RCPdlAJ*>_Rf_qs2Oi=^<}ogl02xQj}cP}@5`E(`{trpr? +UCA8H1i+PlnP1QMpI%2Krc8owyh4{=|FkCYpgfGN~h0v9@0lW7MuAJ4-hJVW;Ya1=%SjZt0(eYlrs4y*bUFBr3&3mtNBmd=IM?_mp}pU5Oe$}$3=bz070kGd>1YVO< +y#>E&;rV0`F$64;6bpr80h17FW4gFt9jPgS>GNt`dRbMdVNEmq+s@w%#oisC=iw$wd2crCI9W#T*gOTc4 +YmUKpPGa6-}oXZ~lJz?de77$d}Oy@V3o;T8U)1_4{hA$63YCj`M$c7-k74rapS<+_n^068S@NTfWcrt-8jUB?-YGv2Z6hB^9znf|TqSReDF{_HtA99d6Mc;0 +t4Mvpo4$)9KcPo}P4i1)gf)}S{{c`-0|XQR000O8@1eFvH|dfFp05A^09pY68vpwT&6!QhIn9T>!M(3>t8g;azUJ8gBXDZ{h#{@Bhg^ufONdE +>6!{ddkI-{{7o#7IVQid3tbAy3OAYDPBFR0Fn+E3DQjep>&Q5aDE%~y`S%atWsWffYVRaMgUX*P)A#B +WF6^i>f?dU_S?B)&heJ&jwuZSCoc}UZ5~~=hJvwSUH9uCdHl$Y9@@2tyqO&^=~*12RT*= +r4MqdHMhqMF}KVbyrCh5`Cl8-@m;hO>Yf>2kCM&xud8`IkaNJah}jUCgf; +2qal*qSXLs)O(Ts2qX_wue`aC;hQhhe7Pt8;zMS~U;tPE>bcXX2U_Bzd!ZK6?`U(j&ukm&@^4~=ry8U +Pl`hk3H)xq#i0#$gkg&x$NlGbqc5J_(SyXpF7Bvh-5qE!eU1!8g`t>X;^s#a+7cd7*P?-l9D#xQ|l{1 +D64$4+NYcWDZlVwvGX|IhayYqNXp1gmn!IG%~4#4e<^IWWRd!kK!$APz@GaS0lr)Mq1vbsX0c~(zg8@ +#r80;yGc)&huz0<2J=b(@?7*)_AH&ELq{Q+P$!oA%~4;vfOutgdD`w;DNl$mxHI!A%0VKxwTP5*PYB^ +trXjiFQ@W%Oy(|0a##Af6oJn8>tAL-ofX!v1}j4bREk4n~}JQ{&j>Uo@a@#8;Ju(;%54LBQeSnpE43n +{ud^@xQ^1iwJ3%4EEm)Tz&6a0=kfV`&{M!90yIAllHkj4{{-`Ig8VQj@?g9Gsci?4jL@WeW;diwKTU$IZNkB+2Y +|g5B)2Q=V}l&X$c_t928&&jvYjf-OMU^5#&L&(#|(J=T*xy9Bqxu=J^joiuhwF;h!+EJ((-3E-_O2G3 +5zJX~2|fZL)Yc*+W&MA}JL?8<%l%FSI_pPF+-6Ln0d@>q5`vp}=YC%QlV4tKg3f{?W6tp>2%?^CbS)x +f<{K^*on&xO0t%ZWcgHoU5*OMEck{#0HQKDuHj^f@*4g8grj)fNH@C@}DmVLaWF1CP;{|e;VzEUS +nkOZxa*LK)-r;V!AHwCNvZW=*6mswLv>Wn`-U;nt1MVU;4;W$Tr%0TCx(uxhJ&MIT^lEa#*}pxjbyDN +y49VJfIZa9_b{?(&LNk*~kZ~Akx|U_zgxRWF<{+j(o}e(Xt#tdk&sj%1WaC92xyTg@R*MDsQ3)&;em>DxmlN6ba}5XH~JeP+ +UxaEp9P2VA|E{nD1V+ELBwXX7y +-(C`fCg$R6nG#x(}B#2xsog_m6W~i&3cgjM2e{D@7Q5GC+nh4|4Mlyq)0CSqbSnK-|FiKI^!eWk-ru* +?te>dCc=`>a|Mpe@bv!FHG09*fhc+mZb7>@Pj{<*h8cq=3y@<0l(@>&G=7EXsn=dsvoP%-d>ek)$CHG +ne%kO5;IZ8ecVwjX$rqvkoFhzRr#*fizd7>ve}!dZ)K#hlpu77$XMwGh5r-L`*U0B@zi%89`zk-$q%V +exs;d(|YWHgpAbX_vm_I7W&rvR{?Ys|`J>+^t;T;oCV>@1q*bd466lN2`e$Vr9nZYdMXZ0J(m-K+-E(53yGzY&^$NJ1LafsC*Aw_vy#!>cje;YJNZr_fYrf{l| +GsH}<5?(}TH6}vqKdQJW_WVIMK5t~-)7jHB7oYz!2cHT&{R7jXIfWupBkurmd#!;%$ery$%h%E#{=jB;#EHw1M(%atgg;5q1hG!EKmjU~Z7>5O}NIQcdxTuXzTC$f +-7yinVcwSbDAwVufoc`DtMjeTsWTpnu6Mp9POb2Agnw1(9OYO^QaWrMe422{QWjHv>UvlCmh4_mVm3RCXw!4^4}JO{1WIS)|E8f(nq+lvRcEGQ%0;`jICd +=0wCMpPAx)-w8L({xb61G8y$Lb}qEY?9iKG*qG{ITJ_k4Zq9S|MfvTa|z4V6&Mu(xT9h?;q0%NHra(vv +s&~kl4B=j_MkAybo0YEDlFjb^0+%1r`dBV^U^wvmOt!c^;)9uHklg*vd8Y5EH(z|>l68^Kzo8Cpz-q1 +%z_K+|cavZbtTP`VI>Po-vIO%9tj_^%?a}IcGk;q_g-k$wCv_@s0AEwRIaDZ4t6Oc6&s+6_mCwZv +V4%U2~80S(w@&Dhr~{LsT+Ey{rA7+ByU0EG{-U4R@O$x$;~Kwoo< +CQT3b+Tha)pJwgoD8>fD2EOnF4t*Xu^gpvvxl?O;9Bp6~G35#Lyc}ARh5a@aSq=ZuV|J$O!;JY5K+0C +8pE)Dadyck(*~aHF`d|^-Z~_#NLCvfHD4o;ZR%>DfbL3ol!Ja5IFoFWbj~WJ*mKg%&0E{ymC?o%HJBD +pvGb-+Y;v&d`?-q^?3m@R^7<7)vGwEYE2By||@t;~irx`et4lU1*#*HC-sfk&nRyD=hF7eQy6zT;)!q +tsV`+YW$YE`7hidL0c83p_c8*I|t!UnsP<2)(Pp?Q!43=f~t8XtXbN}N1(wHrY6$=S{!DMLA`JI)Nrw +nDdk$6RGtm(r_zYpA?}H5UM09S5-UInrPgf7M_gDzjQa%?10Md@Kp1EE|ksEv3UffbJ(y=9)pt;^IJ3 +DTsdHxFT`y5(tuEXIH(MM4b&W@%zURFa1`qLcx5d50`P=^?P{JGE+k||6`!;^$ju7(BJz6Ksjp$>itT +?04L3P6-e{2vumfBM4WD@<42GiIxXs@e{n;HcxZ2F+&LjOzl@ +SN3i$pMClGfuzw3H;Ok3ckT}3GUFeS)@HB1_-VA9at(H0Xl_bwfzsCxj6`QTJG2ibcM0uwj}L9fvz5j +xO|9B@+^tBL*;0|vWz8iW`4QF;y+uZhP3waJa +ta5?qrk_GK~?T4lx@;&g|c0`rBKe6mrO+GDYsFFb#j8k857bUPm1#eRk9fGX47YGMUju)l088oXu5)I +X&=Y-Ne0_%EZZM%9cB5^Y+$-V#=99m+eew#TE&LMIp;78x$jMik6;5UYB3N3&gtaNXg)b)&`xA{|XDg +r134fYASb7WJC`}`$ou{@>BK?iGr^!jWd%$sSx%0jHFAHm;at?71^nM7aHJ{n_1wC#{(69IV@EBZSHH +pnHA{~6Z^Q%N9A0yLV&?-IjW^L7 +Np4*-7UDB;rfe1E3D`o)?Ao_xtnY&;=J6D1k}=QKZL&VLbtHfMpjz~!-6CXh0&oWS;&fPRx#GfOIRdm +JJ-9xej5PBwuE7NU@AdB^3$zTkpCQmg|dKRvt6D=-xnt`O`VwNBkelu;O&bO93#+d)Rn(RH0Di-i^f+ +MPtX`hnf0I|+vxVuI? +d8#TLsc9c9@_4TB54^owFP`ag1`KM`n#qx*^QN)oPRik+<&+P!S@SK9q?=EQd2mpR(*WgrcmBT|~8o1 +`Q~H_Kvw6L*ZV|;N;*Cvs&9A}4==Angu!>-wrqwcYi2+RYl?TfJO%W=?E_UJfs3J$0p +DbN8F_(Mj50t^v)Z^kGEtbl_{vSMM-9ygQ_@zVQmK>{?yyz~ZrA|Ifv(0&iad+95;j5b**S_&qVNlv1 +DsfHn5C?xd5U-ic|@AZBUBKf4v5OlGS`zK&}Z$j7DNF7vmsPZ0;+k*ZC7bh3&Ukb0LLm0q?Ci%Ko(@m +J%l8wpJl|vG|Gk4e=orTX+4m})UwX#REfCL58t&09O&v1qbfgHLX8$qWhqYe!bHoAgEtb&e#DVM(G!h +{APFq8h*7ijP^57mJ;(d6887snk~42`2dy)zCa&=!QElgr}~sdOhsRMDHTsW988c<8+hBm`r-x#mqNS +$w7PsAdVIRj=`Q{n#d|UqG)-ccI)PCwu6BdNekI){sQ*;MjpI=_IT2Ico8>upn|>m10HyX+`@s47!G#F0N13SAfv$l{g`;50zw +^0E_kN$Tw6y{DNBtz4b@;5WZ9q1KF`Cap0y1-W*?gCCi+8YQ8l_TwxSF5UFO*FGg}1#U=jhC?;wmH%Q +l?iz;K)46}K9_`jT8IoGg*h&Ga5Ga-@G0 +U^fD^*G5LsnhI!bLr5p{ik(t2Fh$>=8&A)K`Wun{8LWWbdttnRWZH#;{vcRpSD~NcrM5mpxPUn6DBCD +>xj2WuLfvDB7UUVkB(tzZ`dRf+q&{ny$ix69cBLKEx;TZbb3nM_SJXz^{i +$nBq70;p;=(1(PTr!5w}$>+lq2wKl(l3Ti>yj(piw2$dQGkC?8r70rUV@D84(1xdE;8{Uk#OqF);ge0 +>QLg+%EOFzYEs;Z=S+Ok%)|-&l!;eRVaM$hUh9NPWpxBq_bZNQzwJpUqeEiYiZ$@Zi5q2d;JcbcKE|L`Q4YJ1{)TJ5Fgnb4Vh)p{7n3Uq9-@Gu+J?Ar +e>Fy+>A5bQcJzF8~H9q=b4n#VOn48Mpq<6!7DOr^}Kwt3DPiKtlxY;=6(^M>%K9I(-5x}}{F3)-mzO6 +KiPxRnd8T7lo*q|tyL$#=lE-7HEHNb^F{XPFed>`061xKnsmj(PrAe#lYvVc;A5Ri8_TlAfR?lYwb0X +Z<;ing*3u&(61{WvCB5&Ll*btGZNAKu^sfs9ZruQ8Ml#K)Z2e4P1TF^>nOh}ir)WY+x}G=B+Zr&EUU6 +9E{e)WX87JT~kvUdAvM&G4mvzKpt#ja5c{X6AOf*Z=53WNlVJ(J*7x0|~KEp5X4)Wux4^cp`VF4JWvJ +CUW;@!&h@Rt`nxv9}eS^MP1yNxn>Pm#sXNzgASY(ojF$)K#5Z73J56rwE7G15S5+KEddK1UdfC-P~sO +G5udL#rhlNY4YEPPOh{-NjsbbZ=3*2k^nDliJ3CB+Rd4J9EPZs<%EXd)hM_1ruJ8;Iy;{EU)gJTFm*6Lm~M`*L +Y|nGY3!vPI3$yXgqEdp_v_n{-Xd_1#Dh+6{-&yFvK0x7r(U-S`0wptAWZ4Aipiw#QC3sl6-WrVNhzf1 +P1i1MQl;m`H_@|UW7RTn7pH&(Bdmto_;GmumaU@{njcy>&Ga7&;3c6NyWTQ|=31^%Z%Y0(!c9oe+Riuw;OTa+mydArX5uKF{v+OgGx1Krb#xp>e}BFF7Vc?R`0t}0Lw +V(MA|te7tr<0cf0SAz?HDxu(_D~2%@T!`zI!EStp&g1imE_^=uESM1bkFr< +rP4;@GjlF*P8oYk?c(DHpYQlV|lJ8(Op{l6{DXU}v(^kgRP!D``Fr=oT*2$2?8Ac8EjB1$y7zu`I8Df +Zg4CNBYV-21I5}D~_v_}2YuGTHt-kJ?`{-1R{u4d{>kZ6=2G?X<|(nnu|H!k1DMK3PX8|!bY|Ax~8uD;>QUX0%HH&iyNtHHK>L_y~IDF5S7 +39m%?`kg-dMk%h=LAcr(-Cll(10xVV%%sE8;q0gvJ?QU{TyZv@8d_n4SQm?}jmJtihlkA|bACea835D +{AQEU#RzOHiR@!+lEoKP}CAUzG`%4UGsO}B$fn0j@4r57e#sK3pRsw?t4Jj#*y&h!8wQNTf3}lJ}*$S +hG&IO_{brI@{{vF@P0y7#?96*k(5WfNdLtVIOr@9=e=RM@2F77Zsd@#1#w~HhtzA)UuJ4fojWYe4XP& +q=C{|`{OE$fwS7AAb}x(En%@YO&BeL+11fW-QS!9A5i+|R4QZ#2Y1XQ4OUWabzZ7ZCF=#t2hQR8wB<_M0_S`6lo5a8dW*3Z +I^q{Thj}r#z{PFGl_bui^a;RMOkCXTjym4*gxvj`4`7nYELQw7Y~vf4zXd(c>j1BBFdu-C;$bNQq&SH +yFHGkQol?3@2@ANgf3uo_#Z&`Qv9xk+<0-SJ388;$oP_tqSr*m(?{vcW{!WdU2rV1vso*--K~R_GJujO^gWvr9g#A~D&BI^VJ +)EVeFW`WWhG^T5pKt@TNrflTg2d0)J-dGp>gSK;KX&aAH&8x3+(~ +TfSZ?YGeBva{c(Gf4-9FR*|d&>-=s#3*(_bNu`wz&Bsw@EnIJvCi@MFoFzx;Wh0tYM%8lb)hM<7VIoS +;|ADP0lX3xC7lNF>#f~YgvWm^_87l_eer%_0liCH0&|4xeWWoyK(>17Ob{GAa7R{7D}0<>w$AtC2X~P=sZ?`;ej@*<% +sj>cA>CP=1Cak8LsrgNQ3DgrW(MZcNqPt!%4DL*(Bheyxz}Q1ZcG%A(O7!q*g|OhU%(Kq?}hS31Sd8o +s*28K*gl!XZSpAx#WDmA@6}sE7`MA*<2_<0!yBS$;&Mt147QTyZ?k9Z!ons7d-|eMo#T0+l*pft1a4> +2sdGPRnZR;;bsgkEBa9)jLR+BjYXkE_z?`xE_yr>eiXx*ML)!F3WQtHgxRq|py`%Mq1GARo`lI}l#= +=qEQ8*UCSoLz>n}%U7)CopH};l*38DbP+)lIGk;+Y#cD^J($Ec@(Z%61Lbsd(T6qnOi$Zq~n&cd6A&xdw*M}q7_JxGYBB0{?V+{_$k@he*O +y>`rpLW>BJ;|zoq;fhYa(o#W>UjTaCyUaJuYioaZTjlBl0wQ-5~M>Y9F|Gh|F~pboD`(ltHa53D+34K +UX=<9W+T()mr|bO>F)?69|IRJ)&l+Wmp)l!5lTiH$Z?$c@|f6<%RUWrbD@Hxz2vcO8=dGyPW-U2CiJY +?=+0K6fgY}?dYL0D=y3V#O6lkLK4WbP`OFXB&)LXqbr@m>MDNEEFW%Pp`REldca;dO5 +O;S=wl)d!c&g|Z=mo?zYblAi?OG=8-|T7GxJ(zHY%4F1Yq?B6Pqc);3bVZzM_clq(GtN|SYwlI&<s3mW`@H1$_i +-ESM+XOLxJSTA*ztoX-G+UZIT!EH(n+bCd>~F3+G9@mx32ZQkjWg0PuVprZWz+nN2?jUzg}m +_BM8n3&00>^S+3h2vwwlN{o(9WQnx{}+nx@bU$yzR19Bq+9cz_~uXfk{90zN14Y#)}_NBaFHw(mDomg +Do#TdzfNEWUD-gw;K~x<^p=Si^s`rH4a%Y`^%$FJ48jC2$@9=bv~3Gq&1IEjHI`c_{SgESv*47AHX5D +tRd3)N1O>Ng8i5SNTFgdKsC95Xc1@%1Ik0H?R8@{gJF}D*;tW0%htL#35(Sx4TjB97DnY_6cp65HyO#L3GL +17gTtmC*1QH4JAyq>&cC6u-g!OyCQslq)SQXQmQ$g7a+TrfJFSfsnNZ8=#v{3!s9c`DGZQ0nA>#Ag7M +o^i=eT0$$@(L}X?19wfB!66=U@T0;GB>Kqlo^R;!M7uZE9SxO`4@Vyp@xtk)3|#Scx)K{bQ +*B_(oN5L9ttX`iAnDG-bih!GIB+pJRamZ0MX7VBQe}5*-u>jSfch +O<^_QiRW@zALfSWs3C?l+%4`-8Ds(eWeo@Du+8{VbU|OyX5=1_U5C0;aO?07ux59U(zd +9mA3p0pYtrcz^ulgKkF4IyzBj|S_)3RI&w7zj4it8X3ArgSAR8ALrjcpegkQs*ov&9uT9-SIgn_GRo8#A)a^-Q5jZ9%x`Z6j0wwIsmnf5}Z9bdLQVO +fn>GB8Y;1c)E+43o-O3&;w|c;VwdYq`69VU-v^N1SAZ27D=f2kmovO$5X#=8b7F8Y5Ij^e`_&O_pdh$ +b%9lt9PbWhTC{nEwG>Zzxq#?2lN%cLHRNBG9CD_Mea6L-LqbP0bYH<)ea*7QCyZ;~#f+R3ol*(?M9{j +{mY0p#ii;+4%^f#5+Ap^l#!i&v5?1o(QnoPS9U6@_LbB3++Y743dJN;z%;xo!MTosDsLu^h1tqM9Yh& +Dcv&$BhT_z0Oq%KSyf81c~BchU1w>#rh3I4bn_2g|mZ#UNTcgGo3tO=9p5xH6PM3$(=WE8!31LHkIFa +9{y@TMsPE#*OVTD=X2Y2HO@=QDWPoTHVV*W*khpAo8Z5lRmRnhNaF6!z_Ourhh+}jP-ZZ~} +$49kd8^zK5osX1_kdfDFfB#bbziDBGc6Y?mYKy{q+IU~|{i~N~TxSu@wJkIhFskSg%zK1+|$Ouh?&=e +0HJOk*xjJfDTK6Jd1M_-%(@cS`LBQoFh?OjQ=%uwFLvEwXSe>Cgo({K=3`tE7N4s$KZ +xTrX6w(0&=!@wHR9F|2CX*HXShN|Vl@6O;DaajOdhs*_neQq=$R)^fXr}x0_sI9Lx#+C*VBpaBz>DJp +ZDWB@-6&e$Gtf#UmUx=-y%+~JeF>ikM;IPZ05&)Yi-g!QbPx?(bwt}6QA4i#{|v3#4Wy&4CKA-8+W^k +tC5xOx(gL4aK*PwDFyqbiQa5_$mT}cM<*^l6nDVM|?30dKuyok635uD21#YMAKcYEo%(Z3PKu_BPb8Q +a25u>+ljZe7qjvEv1ulsPqwbHWB;v+s(ww18eUwS`tyY);MZ(#r}{uHyyJ&{pg8|a9kN=k=LKn*oQsK +msE`A(6zsd2tQe1%`H$!d)dZV&{VcM>LqhZf!u_f1c3bqfJ=i#ys)Og +!rXWW*M4!S35qhK0qHt``|cCQZpPCP*nbcn4|LisN3}_0osjRbHeJRu<@Kpbo81|%*GA1wWB)NJwiyP +`Nd7}sr9Bq@LL?{e@8p4)p}nS3oXsoyN#;tmG6wpb7(5FJRiT`l$rN?n0P)7uby2czK&`P39x=&M_%e +T|a`}!OmcSkNkh^&2U4pzEm!un&%emX9lef=mp$aoUbaw8>L!~3B@-=|K-050Q=+5rZl%E|!Ap(iXm{ +`q&%0a3GvVn(*%ThU@-oul1Rszqv1(@{!Ei@&^)mjr({%lff2E-s*Gx>59V#33G;0{%`-c{@TXos16W +T}iAxgfjqJ&1YF`Jq$`Rw{XrcRnb{&ch7n;oR-h$g#5*hTfYi0lpO$UY?6c-K@RS^kx3BTgnN{dA7VtDK19c`L> +<(V}wqR$YN4zTezXtywU|C_~lrY?~S&(f%6HfM*_5#ar}6WEVq6Lj1*mSTk>C+j +Movf8H~!$htACP2y6@NsHtK#1RAPEHXklqy`R4Zgxa+5=OTIgDxo$&R>zc2`&T-@4DBwAkvVFmO|6NE +kFA5$!3an?H(Hn%|Iw;Sgo +;vjKuskHnmz%@8VIY+$F%%SuM!E)`}DmBvVk3r0|NKyFI6|VG0V8lj8+RsB~W`IjQBcG+Su(Rq~^mAq +~-qp>9K2Tp0_M-V##IF){!0+&*F(vxOzK^+&_+iLdMZ4^u +Yw5#B9sx&Sci3A{ybM@$)GJSUC`~en}oeQlgm&dGCU!5TD$DtjP)aoXjIaIdS=X;tfWkFOYJDjI1Y+tV}Gg>K>Q)&?s3 +~jU%hurdrg}>=@hbGRENc{Y(H<3Lug!Nho2I@HFL*{V+!ZcUG+g9`yPe(v=hX*$YZ#RM#?q?Uc85$Kc +t|ai-2-qVEGx4XSwJyk=eWnvwMPfRZpE=^21~n7W{W$J^+{xw32e>Gugn8{Vlr~=-`4#(09r`sVL|dLG}4E +&JHl#_aH|&hs0(y9?6}&^G-qD2xEzHW5c!NBo35VXm>!nWF!#?**A~L)F~Ih ++SApgj#5AjeT`9~BCVsnUT4hhb@Q&0h54FafZgg9Qc24|*^gn= +uOIUBBNY)I$ibjErxYQ9Kyj$_hT>h6|O)EfXKV~jylzlUm9=(UzOgEGD7?1j|ZK#&DHrF1n-t(b&^9% +P~1Z#j+Q8lrB2VLd=HLl2qMWx-B)hI1B9wLorAx0p&GrzrC=$~ep#TFx80$*g{gM#4kgY=;WWzbALx8 +0cQ_I5YI6(`}vE=91@7+aJ(g#$8XwVTPZaXRcvjsNbU=|0__rzEnZM8j>xJ!7_H}P#Njod4J-Z?_I|6 +Q_u!sQgJ4+3vwXu~(K<1dfJCT;<#LweWrI6syq;RPU7beeG#-TATnP4C3%opeEDMPU&;$m;O +Yzkb42f5c!tTP}jRUu?#03`P@r(Qb0+pc?`PtskJ90J3K=I4RkHArbn^kHH2ybP8;q$o{8LLkZYxae; +;%7SfWP?F}iU{Q#x}cn^IGH^^2WXv|@T!t4O=RhM8IeQrWRQeehE__Jifr{H>pfM*=hC{b^Q?8}=jxzZr>i8|b8Lw{@so+-jR1 +2`#({;2|YtYTgCyGO?M!xLFx?Q{0m&ubc41aq_#Gd8}PUh#HzIAdWkD$H)$WYr(m_53h2lob?3r)^Ed$osQ#c`F6wk{wE +Im=e#!knH?B;9zO(|Jn3nuF7!^Z7mga?iw(eqH0aQW-4o3mMdLuOn%v~cN8X%5Z*aN@$w3m+ +tyd>d~1b6ZUo=y;n_83R+ts-;6rstHg3#LSM);3QyEkzLmFX!;yCnhAxU5Lt7Kcvq?*?Em4X=$u%b<=XVLc +qrX~hA--^|kYk53m^x|!4F22%X{SbEcF`c$Qz;mMgsaVnTC&7hawpU5#y?;CpvX8RjW>5?~1}@G7 +qI|5}SvPm{n<1NRenEqF|KUTt9E0tT2$<-ve~*H)CWa@vx +}8kQh#~a6GiegypD)aoHV`oS@OWVPvq*EfI8=5;iQ0Bf4wb{NYc{fdcwCUeG}@m;mE5Std(6)Vz{yoh7)=?V*=HHttMe$?_C^aWcK|I&U9G*8&9&c_%4T}0Lk0KL#LoourzBO{U%%2=#i9+7zGUw7OXTD +&8)@dX=6hwf6o$8+*=wxB^u1e&&v<6dRwB_NOk0qyzCkFz@#l{d5Na9?vp9zRsfqet)%!buLi(2bM}j +-&Luhjfrv{%kbAx7qYfSqH@kjET>R`g3V^{f>m%}NFTFFxICn1H=%vey?-6O9m)-*3Fs*n)OW6cU=R +sKMo>Pr`AX2L1`yX0eeBL8VACXgVs>|iLrakNctel07n0PK0FUHB#SMlP@reZZyn}WMgm2MkMTd8GMb +q~*$%17s)9I_7Gd_rJkz3T2$*Y!C2<(ae#I8@2y=<8=kcbb63-vZnMGnMn=Zo#=^H{e=-9sMtWP_yZe +&yETigr+%XNB0}7!Hb~Up@qJ93rUJ`HrvwPTFwuKO|qT(jZ#*PR;LA;a5?(nogSD9oo8Vhf>H*Yz!QuKa04U1!5XT<(Eh+?i%1$a87z46Ex;XA-L`#zu +m`8AB{CCPz+FF!^Ejx2SF#$Va+z3cDm_z!{Ne)1RM7sAz1ZqXYLcGwS$xJnd4&7PqdQ1r>^FY32gr9> +ColYcm%T(Q;z2m@k*4)|E+(m(rxIg*7(mz7~OqF1^wgpA_3mGn3K^YDT10L~O0doR5Gd2)HZ(*w`>)0 +${TNJU>m&W02P(CYIu&0!{hkF?Z3;@j-fi&dth9;WzYpV5OqKni +(qw*+YZRM5HK83dViudHno(nrGQh}aEKHM=8U-*&8gqw9%>aSwB5Dn8CUtg+$|+`w*ji0XXNb-J1%ag +*lC{NBQVhiH-Nz>U{&MHh?bAZVCOitCR*Wg_mNZQUx@+Io-L?Q*=na@cZha!&a+-0f4!+z<1LdSUNXj +4}TQ1of8}u~k)pkn;NolRr!M;h-<~w1!Pi6^E1xx|mxVGStnd}@ji{=5o1n?x46ujOd^Dgn_bXVi6s5)~JZ +Ji>%{I+;l#UNNg8Fbw#dc~s^tU7Bl@Ve(3psJUfL((csODMV~pn>oJ(ug^(@t}V&$(k2ge +{d2%{w+CBxa0Y7`arflc44kI8Aqu#10Hi3csq0zC+19pxAl~A{?L(JO;u=b2A8ymiLj*&3Q{YkF4Ee8D>8vAwkZESTj;FkZQ?7!7UdFf#`_S4uMA1tqNbOWxLn +Zry)POLa3wtA3~!$uDmSxIGn6(SQUhtdk8xtC&o)|w9Xxa&UO&oNlb9hrGI+|E1>7zNx&IL!M^p5AqG1MT3Df+5R=%^xKWob9BrEDz!86kR# +$8j*ptUz$#s$avOr=Pg$qeD%S66djQ(sap^Yu3meW3i&B3biKx1=Z?CZ*RT4?@Ru3zjgxZ18$p`I9Bw +YnGBP{sIb4GvGc)IH;g50#7~?SnDrGPPzT0v4J@ja{nxT#X_9S0aqZm)=QseXX;Re!LyqO*p()1rVq8 +?Jf|&cck!Ge=^?37Qq{`i){h7)3Q8j~ESuxus*3PS +7o5bp#IILrV?cALpahr65EV;c}3IyG^^&r2%1LsrI$s!3rSoEzH5FuGwJMz}w`aZ_Gn0wrZr0hhpOlI +1<;k@_>bySuOm^Y4CAOD60Kw^ju8J>LcVcC<EvD^9XO0|vosh) +VJHP6N&u@7s=koyhAqs%IkaW<%t8=$4i7%K_M3I};>Y-^e(L796dDhK^#TUnkMNJQkN|&##<#M-1rn< +Y?m`Esk@Im&~&3S#-fjg@ajSzSiG0+Yi@f;RJyO=ojECN)AKRC4l*iR +c;L`l64@~B_R-)V8Z~HYR%2Bkcr^Id>nln^pMdy%Y_tGEWK2-W(1#bB6s-D?~{f2#E_qSkQeDe0 +_sfhDn!yS6d@Rm+6{FU*Be}Pm>IA*wep&35h1Yhkqvs_&lOIY=!+&UOmq?-!Y3GyTly%RCRAu?MB>P| +OPO>5K$X1)0)w9+CAnp*u*M{Bzj;n@<@YVf?kj;#C@J_c^kKqnCRR$*?A8Wou +g0iK>ECNpe$~_dG<5r95KnMgN>+wnB;V2#4P6wx=Mi~0%qD-hL!+{(zY@~oJu)f`eGS7B+agT9@9%m6 +sW0tsjVz-Bu(J`>UQ8V5KfZSN7uK<#|S&u$cDo6Nd7IIAZx&XnDt?6O(F6mr>%a+7{EUCJt&i?7V0dH6~x;#~iX*AV3)v$mlx!e8-SSNx6`wrLIzRTi?1bpZ +A+T|m?&Z^jRY9>y!DTa%aO?i6r$HS|Z`(s^>Kqcf=ES&&QO%WWPSG|omyrm`~aEP%$ZWBwbvjss@@#H +PI@S_FlA$r8Lg2SNLceyH2^fS}n3cK0x7^Q9_lr+)L*{2 +GUj1xU8sJx*2RxdLHkts8;dp=qhg&2npdU_Yd5C#88krc*{lHr24AP%A*&54)OExlT)taI+Bi#?kud{ +P*)q#mtg($9R_7%P{5Nt#&!cR_o^IiUNwdMm8`RNpyvs1ER#}k#mX)4>J-%-Yg{%@w&510*bDQ-AGej +^k&vZ&3Mel^YjTSj@$JiX4%Y#pWnyzLpn=^d@k>+Xf^2l+l_D%`+OOr;N2!%b?fCK`f8}N$ad-yniv7s<>XKaOTxUc|fwmQ7%NEq**TvAls;UY#4A3+@pYDzVR~13 +6cWl2CY(LPRwl62q@Mq=_FM{fKtA}Qo+2tS3i_-P+?3NLq7YpdTk|?130B^$@1sm?p)hrVZbL`&+h#~ +$kWcqQpBl?(~5&1^_J-j19vUVgP1XCNYN&NkSU28bxs*(KdpDCh^dKNA#>7cGr^gqS%aUfCaOqG#8M17$1ZA?Jf`0MR5%U20ox`_3ByOkb^A^ +;;olHTA0Gdbvyxeq_G_VHs(K8?v1j6Q004L)u*oC{SN>15KKrJ!HASPbm{=!p`~r|V!!BF+-VnXt8mC +sJu8NCvER6h1>aHj#!FN6tO2acJ>YQnJNm(rN;$k5O4ibY7v&U~!@6zh{VF@UJoKKr1S??o4=VF_p?# +CMG}SSP(*MAJ;+FF2pe|omm?S|r?U>^=E_V+-ig&s@jY#AOn1x`Pf7{RlM+*tW&+E|-af>K2)BnD#$W +>*bEtA(*tnL$|+xRse=bKi%>I+s+*g4oVAQ+F8KvB%2E8W5nA=Rcr<@?pg;!17LCu<&<%1Z6- +~9J#Nh#e%&9wmayi*dc)&xd`q_WAvskrL*kdOmQjRUXw7U%TV8hiG0C!8z6c}D){;$+yf$XVzZAdCU` +$1Kob%y9yYa{87{u7|xtX-_wF!u%jw14V%*waS*4`%TY|gXn^R&`n*Gao9wx+cRuH}HsY`{gEJ{lBOO +G$dAUA};s%`Mr0Cc!+Q_PebCPs_$+eSPmP=(v{IGn90?VVjDB4i{ffoE5^Lo +~=N%iPS;g-r(CqiWP0(ynqVuLh=bdJXLfP$+u@0L~C;e`$(c$qO2KAtq=)~^X$|dt2t8&RA+xO$Wl-d +IJQZra!CO!Gvi9RIXZxcQwL*G7y`u5=K?1G3I+=TLR;vUT>ew*-n8G7`r(VSXUVtYwJfTuq_WEe+P^j +l|`rrZs(IGt>dDHl@lV3CE$qgzXG#jmiTTeek=Zu;a=K=+e&`Z6F9ao~=1JQBv!`(I&piz;4|wV7b;a)q>gY>^*xf*5R|N$)zhu@-*2;CBtOcS>uSsbz(!wag6VwyZEK?G~kjm4 +1A*^w7#NSO#TM+RaLb8KM4T37X-61z4nk_n_%eo}P71$n_;tbW6#S0DuMK{O;73Xy>rqP|?}0akH +-&c}y!+tY5AS|>55Ri>-cfi*;T?l_EX3n(G|tj*iN-4PqE&wF!g_d!U`^Lcm&{&^cuqa<3%Hkua)K4sXExb0uZ!`S1!cT(VZum +9B@1ORtzR3Yv=fFD~-r4ZB!`lvT8@z4sw!+&AZvox{ym@%@6Z^)X(ev;;1iz#3JHKaK-;`MZ>v4U-!V +~*peB6Y-OH9*vN=BhVQ^6npfD6?gN`A(+L?!mAyV>zk6)&x}`Mh{STv-BrbW*Pd0XvBQ`&$Ws!lJyNQNUJH4uwUd9}r3jU+i{bwMfZgAZvV8`KXXS*Bf0Rb5p!k+2uY+gfuo+E#le`E-_t0sy&ab8OU%*THp{mrYs``OZRc{H@!>*B-gx9hgSM%>-HxIFeo +%>UmjV(4mi56?}U}*~9C^qlI)2zSxIZjSn9i4^c_E0bfFc5zn_K;+Kaf%ws{RHP6+i7DteUlllATMOG +lF)okZ1&(O_$({V+)pxUu>u@zYH%si%WV@MU7m!qZ7Bp>gV?_2HZgb~-V%^bSgRdvjhE8U%Miq32@pl +uRe*n(#Iv|%-9Ss_-*BM=7e5C)+Fjz|u!p`c7!HHmNeJuAKW3@4Ioe##qvE5_;CT;oDCmOtDi3|Qh*^ ++qx5}@1jw{g_BHGM=smcKI&<*2YLcDPsO&}>$IRMIkD1)A)p7be4Ulsi;n4~CW&8amgkDEI2@f@lo23xxTHj3$e7iauzf~1#{uuwSseA>4n*GKWJD5!eyoQT +YL4S6T_4C;4+;$fc1{3xGCT?x9*7MHy+T%>_{b$-$=>U52S#S=6a%JZt+<$Es-9zL3t0eI8Tj) +JWL9GovW@_b3mVEB**<=Asr!IMk)DS*eeUMSE`H{W0Z{b#&U))LYP?7oDp&F?JN!}&1Wrf;tF~Nl--MG$& +G;lLtYG?MvWMoRB0aHq*B(TrC-;iGV%mVHTqI~WpZ)x76qC$RbkCC2QoHnQL|kxg;j5kzqY70m#c~K% +m}vcrT=~V{=xLs_T6Jju=cq2-GS|Mnc@xFjUZob2#(Y8OS)c*ZCPrx1sY*`2|p|+SW_~MHdxwCY`hpx +Xo02OXu&}cd-ZSNm9hSH8DQIm`ZXA@p%9jvAO7e3Bd4Pt683oGdqeu-SG^jWTSuEqBKhr}Q1cSZ{B;9 +ZvRYn3K<7sfAJgK0M%3VZh}k&4^~Qi^G)Ti;5_doyAUwIwlIC- +n`I)jnE5lE^nWFu6z)7W#Pb07apoQbqM;-gpiC29vZ$C-%9dzT~{W2v!V2HPKyM_*(4@vlVFH=ko_0Q +=hrgdvj8n5b?8yV1qFnW>xH^#Wjj_M}!gd6+!-4cBTvr48S}jHeFGE>r6*`L97DR0l1o%*~9g-jl +cdL;V(w#bB1mB=kXoy+6;13>7D}wA;#W-aCfqJxYWce-7YZ +L4fp3!6HLcRd#4w3@oT#h*QTK5=Qzi%bGj(oox?k9csfBAFfo?y +-iP&ID-dBQ#6)#Yrwh2>ZK*hPbd>+NFjXSlP8xb3gvviufjc*m{Ii;@U6rTeP9^uixlXV80op4j?DSE +HW68Mmz%H?=TN7v#FdIlOZry$NfdH(L9lXIbq4FE&4<8_x7i+phF}8=XMO2KLDv%rnkl=8uD!j+cg1T +Gv$hyfA-O+SgR6HCBBaZwLU$XfLd>iosgrMp)-D>2=kly_#^Z|Dzbht7g%0jXMUM!{VcL@Wy6MGn&=A +T902}d(}-$yGJJev7p4?``ht2URdN7NM%1!aU8wz{Nbb~#SE&*%W +axfJlwX%Lnr?xez})yNllLE$zy*zbP8^tbPIZ=mA=GoQP82J1}pdQX9-91;0mh?IJuvEAl;%oEO7Ed= +yp@Gmfvd8D+O|rHn6Q7%XE1P{qjHYYONb&k(_+~j{l3jHvy=s>iWhvlU|3s*TljpuZlyFisFQ5f^Zc~ +3`J2>Bb1AROu{)%30%BT;uX{Pv7Rh#Qp?822DMQ^P1G#M%FGJO>d>{MG^9fJfBp73=W;+N~p@B4q +xfpzyedt7Vpwbx#I7RU5p>MQRf*Em`J`Nf`f&Y;rH^a(1VT7n`hF5V`_f1VWMKVn>{aI^TW6u*bXuQ* +e=P>c~3ZWX^66jB~4=9udotRz2M|5U>Z&j_Bdy^Db&%<>iDa2W6@q$F=C)=-Da_rxj9uodeqEQrQTd? +&1!xrv0p*{+Vt(yKnDXPbGo-Y!m!^K=}l3iHpC*TP>1`193;g*aQTSo5`~D%9Ub+O|0LHRP1B00%OzY +*$oxs`e1-!V>ZOBK@v-2uHCM94ED&unG?<306IB#DJG^RXeg=dB|2_w*5M7(GA93dyG45%BNIg%8ia< +#4^96g>grL!Eid1r5H*T?|an9L-rdB&f##b=F>w;jSswpyK?*s?|cMP)AnLyD5by7Ek_T#<#DAek1M1 +W*v7NRu9&4ryW%Ac3fM3CM@CA%^kFQFBi9z&;l1KcdbJnh)w^Pp>)oRwh~D$XJ65h&_`94uEBxr)_S< +dp?e;QnweTHzHR>o}AvYHPYH-DPc_S<-- +0pfeSD5L2rPqidau?fu9)skY!}XvxSI{febsP~SJPZ^bw!i~6e`y}hz(b<3;3UjsW5HpV8ODNrFlA%G +J1`d;3topg%~d{1wZY+efjRh}x?l+ZdOx61QE?wSmkMS4M}!j*yCk60SkQ~&2GNhg@!BM$K +;zD_HR>sM#bP`=rdY^}7{yyGZZ(lc)U`}hSTQ->ZspjT723dexn`*bRI#cUfG%)zS2Ymp4I{k^4@!g8 +v_ZRZH&c(Pmwbil?ncCUbU;;ZsVK+D|5g{lF$%-MHx&orr8?92;4h-c&thv|wbi(4r?8)ETs=@MH%^w +)?A7U#zr8xcSoj#ZRf+U%McaY5l%N#_I$={BLtO|fE31IDv7iHv_!B|QQtKp#5Rpkm&721HwWwKbu2g +LC)~i~mnk_A%c?pZlrKn@Zf@g8u!d1uEYRA-?iWAt2)7JLeTscYQC6Tvx2aEUIW~w;I7o3O#w{t@sVs +0US|11w&#F2ZJs)u0O>8eCef#PaXv#Dr17}asg*;0)f5!@qEE-G9Bm$5ZPg{x4L)Y{0mqaIK-;vx+-7 +sz&l@PZJrF?{d}Dh9>;u(;{O@h%9n@9UiZ9R#e@O{+7cJgQN~^1Q_z4 +{w}H#W%*1o$^bOBhDrmULv~3m)UxX9^xNv8e*`#NZS|Desvl;x{KT$6(P{^5EEm79Rr#Q`d@~msU$Lm +Xu_UO0)HiSW#;LI>fvP{HgBpYVT_LX2440A$OLAvBw!1YMJDc +%hyu_q5!x&$2;TrlF6EjA6`l2RbQI(Mu!o?{gQ2V=!My}))`aSpsr$Mq^Kt0x +{uJD04RwX(VX?6|EqPwzX`J0e#UIPt`yErSh$|WiFV6OEYpKe7V1-&9Jj*w?yCd4yVKGGw^OFprA@9p +o_Jg=4H=r~!#NwOd5n5#NeQJ$Za^*>?j0a8uG!|?YZH +2~RKCWCO3>Z#eh-Wp!)3F&V9QwWAX(&wr<4aBpLY2&#h*2_IAWAxBsM=TYNx#5Pi(x8IG)tgNq|tXz1UhobN$NUZUQ9N?9|Y +Z{Kflc8pQ-me;3%x`v)XRpc>DtOBb|LodVbv9W}a>>V5HY^ERBTpbq+;za+x$Wk4r%oaEK$d{Dq=ft? +c^or@CXs|aac$Pse9p560p-xeWdr*3dm2cP{i$_0PeRo8Uy01&SlSmt><0E-+f5~#V=$3h3qei|C+MDNsO9xZm8_zv`ZZGahStGZ +zU)P$9Nl*0AaRPdI-~`bP}eo(oUFuN-LN{6mRiqR%(#^LVx9wF#9Oyg?YPjPMCqp8DS1mP71TLa#)zd +lzqY+p}eyU7>4qNp~@@5DnfZqn32j;!W^%x7iNsIR+y8OB4JKb@`X85St87Pl?B2~RFZ``Pe~AFsxn= +enaV_AN=lS47b{`HT&4tTDC~f0tpvb!2li(uX7P$Mh?Vx@6?a!CEyXK@vcm7f>pHw%60hisDiz`tqqx +c!;uTBul@sE1GhPpf*R6Pc_dcY3`#p8G*GPjM%|d*{xw|9>9=%Uog6SRNld9RQ5H<@9A%ip9s0X7igi +XCjavft@hxkZZn8|7^rVyXSn$2j{#y7-gnPwBH+W3X|*fg74RGZErJ_VXhYt_aa;V$c`SI<`%_PdbY$xd3!vJFL?VqeZkF8lK=G_iTAi>QbthhKG5|9muln@B}Z}WH0r$@9}PVPCoA7K_z?FbSgP +kZZGlJdwGvIvBGbqC*eZTd`AdSpfi{EKx>gUCppLg@qb9R`w{8t>qonyfv}QN|si+_)o(JIB!5ReHPX96@ha=&>2u96 +`bi{MvFSS3!y)!RUJoa5XmmZC7Dp>Gswv${0)?QQ;1t18f&-iWuJv$8%)vqQ?F7RJ#&7ti)%g +Hy;~Yx5BK_JQ6})bW*@yP1g0&2upVyPmg`*)C*u86>*2Jx6Uj&=kO-C$6cDT;SV!>emcMH~oSH`^^m~ +Bd6v6o|f75!n6w|ywOb`ESElx`+nuYU#3RkK7L{hxsi*m|CMq&*HeJM%ms?+sULZ-mY}0v!l_bH!zS_ctCD@xs-)AXR=SQrCjp1MROaj +{P7Cdi{mXz#L0rv*hr~gq|{59QjB9->}|L*thmmkYw0R=Jr~2OsVUXY4ppTF$v`nPiuuPf3od#Hr5;{ +RHFZi;Ot_kBD8X$6T?kBeB~*SYIHy`{+p2WlqMefBY_A=v;%u!Q#e!a9C3SS)qKH|KJ#Ru&4Jj4(u;h +hEfuxw;9#STC9f^*yu>jh`NalsnuTY%gXE`q->rXGMQ|C*190)le2N3UgNImnd)fk^ga0*3X8wfbaF{H5tnpgG1NoIjHl>rXSj#o(DOkDLY_PtXFC*lt +y5SM;BL}&M$y8kxhqP$HxyAssmDn{ofb<=z_cWs)F<_7p4qExlOYCy+P%pLyb%6o?w!d~T9D#tKfBUvaJ-ACf|Iq~JGet9#ox7M4B7KLAhA!=boN3rNpWQIeWOl4}dM=F +aI7E8%OzfR0puo}7Sh0|on>D24$&>tLRF*V{T%_jyi7QTeZsvPCQ+q;=O9h6s`VJXmHh7@X{JK5w1>zNqD7YoB@kPV5d*bg`Tfj2sbi0xIE5Wis_>?{lmOD#S=X`tST~+T14w +d#4$u;gH3B{IkF^)1NMJ(F#EwYrm-~`_qA1id&}h-A9jb&jc +P-|^n2DjzP(ufOwKc$z`(RlCyXlbeJT8irxkeIDw0P6?S; +D&7#Mh8pC4N_=76lPSL|&=xe+#x8Ert0=@Mt=J+)p>C}g>XpVqO~8zwBifKe{Ujc3;ueE(=RxC+V^tB +JUA&8;tEFTR)7iMgSQX(xHaN)?w;_|SB*(>yZ;{PY3@dLOenR#kN9Wz8XA#%&q*jO2xRM+{Q8Y;*nWn +7P^n2r?W=UR|zRn@^ep6N;{rWAsjchtP{f#@PR2R4QtP1O5l5U_lin^%jIK7NJ4t5ocFA}nP?b(Li)KD3-Uddd?kfM3Irkr0+9lNNP$44Kp;{@pr#1~YLXm?=R>($QpiQA1*K{%+ +(XP(x1hy7UK}Rq83~6FRvS9X=6cxN$;T?VmiwlFzzU=iWt_#TM7d +SU5z`M1szl^;@v}Q`GY|MHXP&22c0IhtV)tv9nd(20vmUh7FQRZu%MD +4b_KYE~Ng<`ODJkTAX`LvPdohJoq?bXBv`W9y&3;W8D*+}@@DCmVb?$RbD +%hqG_oe>fU+o2ocn2V#Ppfui1DAK_@ZswXSn9rPaI|%;cuD}lX7+5Bd^v!!;~5qe{b~$Z1U9yXPDyjQ +Z5a*FY~{hOU*(g|JxV#EgrPc(fYNb@&2uGeCe{+NUgY8J-;;KHG>kxv=tsRqE2TwG}K7zEpu@m3k)+UTOTWK#2q;;pEDBQbfe(Na{W2Q}?HGRe&Z^n<-o-j7Guw>b +EbvbJGM74>-%G=@*>MC3#wGj3ZZMZzxKGHc +iMP{|DEP0DneYawoeO2I_GX_Hyo2>xyK+6NolE!%u)N%`0iMH=2gcP>X}zE_2J(HyWC~!=HQ~7Q+6I|EXEBPjzRAtS`6@`kBn_;-onO59GX^Xv}2im)fmd#nf6 +=*lY32RwIpKW6*{;wKb8G5EO`Kbghi4!bD%D6U}nW|kVQ3DH^%>mAiWzXkke|IP@ +bkjo=5w0g|`RbJ7QOCg7(8v_naj8U?M!iAfO9aAn99+xa$7E{2UB1<)N%W6mTrHjvFD7fF{FYRR%aV4 +y=Od8gexYlNh$?HJC(Mc(6B9;fB#PN4cg3P+nFeF9+v{tL_RvliNVwH_yh(K&;9jO{uU-ZXK&s-U}-%3e(OmFc$v916x(7^4YJJ8y +{E+f#t1yut-16;GwnpX$HoE$1!6(Slpfwg|nxYKCF#XNF;O4IS0onQR~%H!a~ZV-j48^$dLV6o{s&Pu +sx^DEg>~cv8)w$)>CKymA*117T#A&V{XFJ5n<#Oc~5t*-ECjEre +D`)ZmqT6FkZKSca7mMvv4{5s*^CGhhMD$fzlv~cZLh7kw$Wpt}sxto2cvKE;~CHRf4DZV49XTXLm5ZApWMe~)$b&C`YA-bvMW54i;vBg}8@$MZLQgs8An{CH^GOqx@van{9bMVxI96K +Wd2x$_@bwarI*1aGcnKuBpFc6Nc)Y(M-~iF(RodxbtJ3Ke9X%Oy**4d0aYa#`Go8db4^p{;2bW-`_Ad +L#0%I7vD*Gs@ElK6Zhgh2P2F8w@nQ)xt21lEg +nS+i~AJX{Ho=GGhC&s0;5WAiZi|vNwn>Z=j6e5CTnTOp&8j!<=578O5itSKpXLLFw$VN%uyycDznx)} +lM~O(O1c!1{)F~cyQ!^IAlk=@>dTuB6o?G4XO28T30S7vjTt3?4fMZ`zM&0C)16eH{rPJ3rSdq8?-oB +UuC}hqGef=L6hf%|FUb*>hvB?PivmfQ-mZL}UH5tfYqq)*C#M=Mish0vz=K(y;2dA6wLQnzbJ +;=q_0QYuh&~^?@)jH>oa$Y5% +=UXBNj_HjF={@ +aQdgS8@*uJva_YV+9bCl?{XXA%X`E$*?TOKcm?R7yU&A;UzUB1JKi_$Y(1f>)LSwbcfD_~2y}M3TvbK{n~--7kSw$%=XfQA<@3s9SCVdu%#xex9lBqXkj<{^hQf9lUC(-*H(jU7VWl|Bd0a=F6R +sq1IB;N^7SIAQv=c+yD-|Y)m!eg)k7Xh{duWHeh$yDl|WmOG#8p +*~pg-s*Y^4c#BW58Ym&!SM_}E`O_fxGbO0*`4w4C5eJZVdDOw;iY#ZS +&QB%HBl>VrPI*zz$q-9xV?n$)Fb%iA<5mM)Y}`eyQqn#49K}PPCdTiH5-bM0Q&?FX@|iNrNeCkQRYBw +_#rZng!|7u}F6Yk3zbe+G#TG{l(blB(S7zW|x_wk#hG}ck`c9?#bcTYe!=@)3IR1{*^%g_49_VSH;Hy54nx`Q(GjwFj#-C8zLdHkq0X`Jp^j;vSIN7#XjVC~QWty%=b +V&%QFmRw1U}M;xD*fNvu#>Wi_i%mFEO>ALdu}{l`Ac$3hk}j*@`-HT=H>5A1(3#dQoqQHH_uO))Lo}w +TwxwGD~Tx?!GL$qF%e=KE@X}6{A!IABm|#A-*4fG1<0uAdv?`4|nyWV1UgBu~u{_!&8K{x ++4ylwr2&kmk-*i8FPBg%xngj>S2Dz)UCcW;#BYrA|>ZoGxV7aw)CO^l7uSF;BnN`u3FpH}d`a4vie~; +V1d)(BZ&$JswNL4ACbxHZ~4d}&+n64rv25SJOi+LrA;8k*S9O!WfGg;I=hY5|u6j0geH{*)^gijvPVi +Y&Rzl~-hHpRf(hpH{Rsyo+EjlEepl;*nMWOo{7Tm{AA0$8Nd-b0)$YaxwvS<5`{kc(N~j=fH(+Blw%J +RE#epFWa?tVimLo8_G-tXg!$q0Rjo6x5dK)5$+El8yrIvkm%8+@7J_orayNK5{E%WSTxlD~{#4(&ASE$tFLI+N?mP2A(zRoJ`eh3H=hx-r3G)Rfr`&|o=x?~UV;B=k8ZH`-iAnLI|9P0Zop%Pnw~#O1SlOf2^DS#4W=qQ9?~` +gYdq#0+xcJr7V>|L1AwdGbfbUM4s|@G-&n1ndH1oeBC8j3c<0Ad6r%!P5k<66_&3NpOy!hTz6Z#{3DU +5u_4G1U7?wmV{HgJ67(S$NHC7zZh}mL6$I-DUL@E@aE8G9XU0qf9SM373?mprFqt5 +cAd4WEU>(7e1g{d55F95sPvCu#v0DfR5lkSMN3fV+HNjSb*9rC$d`zGaR1+93QF;Wo6AUL9M{o~8Iza +)!I)crY)O-xByf$wa4Gv{dk)bSpS}5!FW++>o5$baL`9LT$O%J^`5IupN4#dL5Dv|L7r@kZjgt739EX +(3#DJCmpjx{@*u{4&==CBNw#jNz#k0r8H`XgLSVeAnCOZuFQL~Be&a=K*ABKtd;g-v1;=yyB|Vgo5e1 +ig(HX+~J<`W=&+JtoU)g&Av=;u2D2@jlk=JuEdfV-CV*$>~yZn$>L0%F4(xGj;=Yf+ml@D>hcO!6%E2 +nlRSwlSSMW9TqjA)@IU>z@R}lvCuL=%Q4-17=7j8QYufD8CFVpqD>;3xIh~?fXjOeBrz +cCv38~3TMf5Ev!+&ymB2cnYNb_uYE`6JqWXM_Wxb`zgNoMkzmXR$Ht@EuEJIKkhX3MFPIU~tDCm}Tzi +BV1gr@nJC(lV1%t%>G7{pX}+-D*yf)8~jh6?i7pB9)#kWyy0SBA)(*V?=6dbV9O9JLnz=y3;cxvo$?K +o;%N+otZGlDzb|hAR)C*hPmh0fO`4mqTQ+%-lWNDeoONR>5TL_)_&KYA3APhD!H>A;U*-~N?;RYjIrcBf?OwN+zgw)ysLP-jb@HeQ@_~SFutt1 +WlQ$~?tmO!E_{sF;t>CVWsri-%9pzlQM!sIz_eziQZF3zNSLmY#gaj&cJGqj$cG-A7CXYSGD)lCLgg$sCs~s0|m7Lk^oKpy1u`RN&p((j;jwICK0Q@55aV^nX$&03p->9$tdJLcTHwfBeJ-izt +opuMkldwbO5vAeYdH2#ojeF)|dJN=)HD?9`83y`muBYqa>E-Rythu2@%T}##Xk#?By|JBd`< +rg|>(H@N=PtK&HFxXY!@p;*-hFPpE#UUP{rU$E7#K8Y@Q|Uyf`^BU72j0tnCqcawVu_>{ZNkIeqMT{pEpqb5fzb)TJ8SZtz?f&I9UmqXJ@xsDFVvN8*TZ|2Nt@Y_WEM} +^W@{=+>CI)-g%zbPtY!r%7w$Gb4&tPc2I5TrmX67~d{r~!7zUHrw>+f2(YyTptCN%X|(7<0^ANg*79@ +qKj9)7vopXYV{>0!wW5QfJg10=XL(oa=?H0?~mxmpD+Enf4RF|H^~~^b +-%Bd-deir+lY&&m@R*~y`b>^2UZlVbgU{~{otCl|Mib`4?XT9oW-?8(JH{W{uop*QbE-Br!ci(&a%MKho^#0)wK0I>t*zpr5Kl=ESQ=gvx?9At1d|7_ +>tFO;}^X+#^#rMwhKm2&1@~59KUizi#a`msj{a$nBD*tace2q73*VXX-Z`1$3o&LXF@o3!r|A_pLj2x +bpHXNfDj3v@@yE&R3GhUX^!=j`6Cnok^B6QlAXvV^##n=S(r^T=Yn~<^4^?n!iTJaid&6IS@FnO+=Ei +pDuP8D&Cqdp7Fu*|GvjEzJmWX-|2@EGgtELqc?$0ekTS4s!*BVNRbxDXHGpm0kN2f`yP!m!u`NzO`45 +OIvjN)~UE=gC>wn%z`uV!BoPm@KPr(HZH&B39PS1PNgg4*uZ}e&7zESF#}oawl)_E$}522opkx@FMgG +OG1`#Ce(=n5JFG*T@&t_GTEQWq%e}6mzYW!P^>&s__Zb6P-u7nKc`3Vh}; +^LRuGF=g6X~N%2o{buW`hxfEkGndFK3E@tF1DV_b?{D@wk7+*+A7QtDMZbVDQZ1>KWnYw*hOVBM!5(! +`9o^6#RH)n=kcDgxHuI)bRF2aonY}k?9sK?r{TP@CW2x;nSW~!RFS=h>}R?4d1=-mOalpJAo`ylhdvJbnT%w4y^->U_>4v+INARA!+?mS +Mf9!(PX#aYPdzzjYl?RO9@$S*4GhTZ5{}!H1`JR)p1t&%RQcJ{r2wB+nk_bgWRm+yMefSck4~Krec%^ +Wz*xDENmc5<8(DpR(ki{+{e0*YCv+58RJCZ +PoWK5H(L$gSiv7N9Qfx%*{!0Nb=SF@Q{mQiMN4K@@_7xP6Im2h7|Cl{9jtXSSOzLBzBbhxjHaRUb)v8 +zhnTg5S(#%C9G%^!s*VSUF!}{bsj6L#d!#H3KBg_MusekY95L(CmWIgwbotk!krE}BnWnG(gf2(`b?q +B&g?fz5Grrp2pRo8umoBOgpq0B~r_t9j=Y3~ii^I1Tx+xKqor|S9J*tgd0xxS6Zw|-#Lcz-dtuDg3Wj +-jFKiJ^_V9}W&>M}zCSm(+{D_sF{LN8Q|alG}&%-0R~vI-;)o;d<_-$fm>F?rhq9;Izi^gXwio)9&GO +>$W(KhEws^i+GaGJPR!D#(|OL;boe(`H0}P_Gfl@o^W~fbw`+QGwp%5# +Bttkr$gle9y1B$Unez;vZPAYS4z)+&X|Sy|L@>tTQOo|=#>jmgN0B}F0Cs)d_NKGUsP)I5i)vm@bBR; +q;>dQ!CS7qO^~_IPTu!`MwMEIT`SZn_rd!IdV*TSrenusf&;%xFs8DyOqm(Zag?y%y~so=f +de8n)+#a=$<}PvyvrI4(u59L{qKAkz_;VkQ!?h6N4<+YrHjK;WgImM`l5s*VuneY3b9Q^&G>}6Js-z) +59}lN<2$o8iOon^Y9)P9>dsBl*V0_XuP+ioTGe5P87UN{YUnJC^wZ`Ng{a1sk4|Ohbr_hEhmo)zmu%$ +r=RyEDRoLZsq2Ysu2(eX5l1hPtdldQCMR0M=TZN<#A_1emdFa0fm~HNNJW-i1cq>&yd=}glHiUn*V2W +1g(R@l&d?EeQjMpocS_XIYaCcYBO#`;wmv#ilQUeHveOO6Lmd9BTDN1YS)y{M&ry*kwEltIoSZyozD7 +mqwGxWhV~MB%OR^=hC~OuehsggvTCDz%1FdA;cNO_h+s1bB@PkERF&s* +nlp--LORTKDjUd?g>rb#2Jc3QalzsWA2ca^6iYP4yU)Dre7w<7hc4iTW5M?NzSUFbQMZ-0-?fmNI1t* +!tJ;HI>C8W=neFT}dhrjPtCW4MQ$8-17eC`76&QtzV`;SaXCs*GP{yFjZ8C +{W-_~x+2=&4*m1Dpcqm&;=3+82wl^Wy0gy_fr}^o3-?w)$Dg__ +qHvkCYAJp +XzA|MvXRx**SbkC*o7;n82RwfyVpd)50!y-y*T_Q=i`72nq;n1d9nW3FZ;ZB#0r1Bp5+3j +9?H!Ai?bfeF*#s%mkeY{0MvrOa!e7ya}qmB3VPAe5Lv?C-W4+QG$I0?+|Pw*i7&w!3Kgg1j`6A30ip9 +$`!~eOcp1SEPJHGA48t@%+n5NKv;JfW%l_;2lxD`FQ06gs{hKLw0V!%$$z~t5I*9+7rvb6FdM^|-jBx +P{*Jcls@Bg&-#3H+8U*xyoT9az;3NSqKx|8d1rp#4$uti&9)uar)c(&RCe~}S*9lG#{7hgXfBgxf2~v +?UcltDI2v2p5x0m3*K9r4ZnCLs%&<9+hc9-1zH5YmOB-tbX-yjp=j*^>`ygfuQXtfx=~H`hJhYTq0Bp{Ev~N|6_JlN9K93yWP^mVQXfBP=Tes;=kbs +`wYg89gAzgS#okRlVw>gD4UJ`ZS0Xp9%0Wu`z(9&%{N&|NeTPplTX;yt5=ymB`ZABhnV7N%^o~#Yt4* +hixwRbpGWwG8e8j{MT?d#gNFKwdUbG0`%8|o|4~uV6tqk;Yf!8Dn_eIMp4d* +E^->-cyI%23s_@ty7^*ay#4Njy|CdN#{i +gIecO1cFDC~e=&5>Wfq^~Nt3;dVYtUO$ExC(LL`|6~bQRJZ}mExywpLY)W-n!xN5h5W8`C~ZsQhvJ&s +=UCV@`fvg1KW;2e1v>pYLMc8?$H6mR1f02`hz2zyT5o?_yv&t`LGeZnu3cl3Bv!wO_L8-*Br5x2>(Yo +zcOWab&YU_f6CvA4b@yYi~L6vis}siVqfkl)mg+Za8sR`VTJan&a9?uNnW{^Z4|LUS2yq?@USse&@=) +bnm_k&qZ)xc0&Zg-1YQKq35*0?Ir!Y9@%kU}`Jh3ASaftW4s2sfmoBZt<7?KeVb4GRJbV51*9DJ%{PD +-^n{U2x@p&eOf3}ef-L|tiO5(oE`}mHe-7IhSh22T>GguxKQPOVC^L9Jqi4*4M{rF4#4tmLZ{F@n^|D +Kd{@S7=9rtD4{Kj;NA<9TjT@7*(|#IroUY4`Rii0{qSh(C|>A1+_s#snAN$5?LHuH4kTD +`#FBuqHtF(_90inor21P?1kf@8am$vnLA(2w;JMfo$Z+kt{4Mj73F7iM*RQaUzS0i(}KLPiM1c&0@KU +W7yoeb6HAC3QJ2%V_8{QLVo1rXX`S;*kf6t?Ct#F>?K0}+Q-@8L!6EHkh7T|a29@&vpY|7Ht|c&vI(Yq#o3JSIGa<>+3fS2<>% ++KqM{7ZJ^AF5Y|EA{qI|b)+s3wU-!5d?JMX;1PVC*rmjA@r_Das)d+$AV@Z +drA!3Q6(W5-c(_NVqCh +OuVEG=?>dwIsf2MU}k`RbVr}k&Wa7*bF|AE#V8;BYZ8}&R=0C`7vFdGG7Ycox%rF_>mNTJcXZ5;pbBL +#k?(BN#Qq8_?Ibs357pS;m^5+??vH5Dg50OUZU`;Dg1L3eh-B|M&VCU_%A5@*A%{j!e5~9Rc_(?_aZ% +sx}BNSonIp{wrw@_@t>nMZ7)^A<82u~HGuKYCo+C+0ps7VWxVng#;e@I`%?Js6h4r`-$CJ{DLlnhnM~ +oAQ23P;ej|nd7lkjS@W(0qH*Voc`G}#aoJq>YnidqE^zS1ie=13d;pQ6|zk|Zhr0`2A{68uD4hnzLEj +(+(V%W`8XS=aAEP$%*5O#z(zmi2U-u7iyAd9zDv6fe&kLb`e+_{#Z&lEVF(;PF +1}N{b{$lAfunzSGa(t}ia)-+Z@YGPjuajOgokcsgb$B^YZ%;p+jY59Lv8$RNP)t~j|z*PFm9Y>Tzp4F +(82HKn{R5}x^?IANCEEA;-UCE*6|RJY=C>XB|2){xM)js*E$}^z4vV*{?XA9<1En;(PM7u*k1Dh_gnk +)9naMG!$lH$uEmdl2QB|Z`~yOwDT|{m4G1tF~?KiVu$-6+*nmn0x%{6KQH2934ja80F@S +_#=cf*$)j04~eSltnv@VA3=;5Wf?rYp0iv0lr>Rd!|OS-adn^Qdd{4e*kf$t#*OT$r=DV)H*XfY!fUU+CiKC#-g-;u3Llj`%N`?rV;kuT`}XZ)AAb0u&<)Og^(Fi2tFPF(bL +W`T>15~6pJzY+bV29_zx?tGyK?0UTYH(aSLplL?{0Foe>ZCAhEhXE^>WP|YUq|wL-!yxbkDH1{B<^f? +_v}A0k(jjU~Bmq_6q-o+V4uY@YEp2P>(*78rwCuQ}`hiK9s_bqwq5*`~nL90EOR3;a{cj2Pu4QJNF+w +?|4h#mcU_V3>xXJvIXckJlbvDNrTLVVVtd!L>?d-v?$)?~c(2Kw& +Utw-e{}!NAvFe@pNh7gZOXq^K3_7t$MU<(ISBASGS&>ygHLB1? +fWHlzu>G-`+g}`u7j$P54v#w*>_F2LyBr5cGAX2XnIBx~VgNc}B)YU=YqrgT^L)Jly=iKNfCuRmX>LH +^IHai@8ZTdmWFy#H5)U_^@k-zyDp&UzrvJzF5-HzH8U6$W#E1W3eG_=e0cFI~EHf%>KA&YU^(N?BQ%!^6W +PV8nY+Sm@#A25PImn(fac|;PvC*f%5wZ)xklCW9ZPKy?`I#CGbCV=n#MN%{MvW$KQD44T1MJ-+aTr{q|da^ +ypE3?AS5k4`E10fc-fN^TaE!yppqX=gu5b*(`Ru{jSW+%!t*iSI3ZE4cxF?Dd6UtZw@LdD!O~%z=6m+ +zley4K8W|v;(zhtMNYcR+8#Z645mC>{r&gf^OBMhS3Vy(a)f{S>8AouDj$J6-pk9&`DdSfCcZ(F4y5x +4lX&jZPe1)sO?>w|#i{)E+i(2mpMSpi(MKP>`SsUde@SWm3V%fBKd8P9CLC5H?4QM-^eLp}0^qL$XwU +&=q66^P>CoSGs85RygtH5%%w6Da5BMwi@7=q16_sOm;)w##uxHO6fj{`;^y$;049=cCE53mv>IBtcVV +*c~LICOp$^$0K4Rr@$-hcmnfj`QS>OV(0T)nE#NU0Bf|4#NbaHl#v@Xz31RaM2Q84~CB=IBmYqz2M-<;0Nf88I3ViEsZ*!KJ7|Cm0KcK0pp1aqjvqOO$a(+w +I1ec0yk80DlMZqI{5PEcQdM<=>PqK7ga58wyVm;q`wu1^el^KUl!u@J_#)4dub>BI0o?J9vj5_XF9hH +nd5-)BzTgAU0=$v`DC4Kka~|`j5(8HVu9UvO^aef=o(Cb~!yT8Tx>NA|z)YNSFGx(FNcLD +I%K`#p({z^STJpjK<{ettcr#KJ)i1HsaP#Fw)pYwr4L;5G2SJiNybd2-BU9PE#>%#x?<;&pZRY5^P-H +8_pKm(P-HM9U1@DXrqhz{gC@*HIZz5)M3?oyvkAaobuf9Gc^4WmzTeh1+?oM;$Ke3N-f#XtE3=l<{1u +8F=L{He|0y8H+KQ+vb#^~*%(bL1<^0(=GD(CI)O2cLoOQ7?28^#V`qS<&Nfxi|*|XmmXOJxo(E(m>jK7foa7VjIc2Yx- +zPXv!PhX1d>{>rJHsRN)v2c3?F%A_GWe*gV?{#4GZ1`Qh2o#c4|@CTpNrvrQszOGM)P78P)eDvkv*ZH%HM( +|DYNd9>C9fAftvnn{BuF(+lCFkP_r^rv;>N9B2>T^HHB$BB;NhWn88oIur%2s;v8^XVP_wFwKr#2q#{ +59o)`iu5JFALNMeCsp-f0BE=l3#TfiT3a(jLlfBC);{yfpJg=lz6Qt{8 +e!1=vSqCw$&>NjeAhD;jwS#5m=4SIbB4SIcsOzQKth~{#A{87))zL1{f0??pCeL5PdBRVa3cIE~1SC< +XvFE0(@&n+ez7LMePv8Xu&E$A)2K{_> +GfIDF?#Q67=OqMo&SdqAKnXPp#$nG@CI(cU8e=IAMzgk8putwRcPDr>{>pIzezM~&mGRUEeqi<5)Jk1 +^Ft())~1E=Rr5#l70Kb;J~y1_B}Q^&`T)H3GJ%Y +D*N@Tuf=2NF-W7N7cZr5Kh=$j5hz6<)sL!C`X^n>U8VzeeL&|9Wz&xTMDT3!FS_BPvAd`l>=@^6GYnc +BbGth=Xj{t1lx|P51!V4UFkq+)<(o{XUa^(s?`gj5_wGZX**PIQ@f8ek4e@IA3FW>mAI9I->hr5^^?9>K!($o^|3!SXdVUx$N>*vWBXkUEpT`qy{7$s +L@3U*44k&YKf7ec&IB{Hhdio*Yiu#B;keiz;XmIDRKPnTLs8jX(SPea&?0eazW1v14YxTL_)1>|b{89 +Fik&!3|{@ioV3Ed02Oi@u0U$}6gi-xA?XsS%`KqkGOdmZ(eXlOvrH1>2rKCM}^rj%qS@7=pMkB^V%Te +fWBXqU6Iv$-TmeATK|qF#Ug`R79JKo@F=7T}Gx0kR6Z5cE;>2k@XiA9+URHNR1RW79%ceb#l1^;&&iL +v`Vg@PFr>cZ{U#OxE%5+qdtKq@<+u#Kc4=$x%@bPe1)Mzw55MaC;0dE-vN|Km0IXw{D%l2mO2C3mVWC +pqSgT_!RCNs0XUL>S7e@pAKkR>v7%`$KIyyQZ{6oCHmiqm +Jw{PG6BGq9|ZhZ0L#hmH{$M>Cg-YIm1_uhL?@B?rMt|%j&uk`W&ec(OxbD-CuEKna%r$v3Ha&WKD&(* +8Xhj%^!J@B#XVV>aN;C1WQuNUJWNL#DR+-9@kCK2AFM-P7Mt+#U0tpzT?19ih4K!XnTX#s$z^td5gKi +D{%zf%}W?X#+5pnZNJC!Fv6$6Wr|`#X5mFTb3i^1klzhesZHgclSPTwJ?$EnmKT`7d|heK$`{O%?f0{ +Yt@0paJy)bOJZfQJ)r!L7*K5-=mF2UBP$+`jN1Mj)bxUEe$+G{;yvkkN)iV4+2x&eKIpM^UM40yYDLS +oH})?0Mu!nhTCqtjW1fXNR$KG41H`zrvvx`e|^jseFK=N52z!k5B2Li+HCi}2l~(KPmaH#Zh`-am!8V +c&p(NJI&R!JzHHetQ4XL1_>UevnopZHP1vIhK!XmTLGSmXF9!V@d=ETff`>qxJ8wa!f`5`F|K;!RKji +h-Uw;sNh`)kAcoP6#!gw?6fEUJ`Wmy*WH#|I?hlYmoe*OB1a)3L+)Tg5%-qP!aZi0^>55QND$0$2}e1 +mYpbldgLUkLn(?o~sE4CzjJSb+Nc?z`^_8jwF2H>CO@Xh=v%;N!=S7reE3^JalR@)~)Lci@eB0Qm!Z= +%(Nw=-Q|Ur~{}Ih!--LaKB3N6!`i1g;Kdcy>H(>g{gBs&94`Kr0cH#==lmje-Zdl*>ch?u&P+p2P$t) +{3dt+Z4~lY52KGKLXIL&A^%@}^;Q1z%P)&I@L&J>mk5WvrhHOJw#}k8av9;ihwL6;>b%GG&ff_A4f+q +{Kh?+8_(pw$30zR#sI$bULYGKOOB1q{>bhv(AZx(iIv=7QpkAU(z$YjJ$YghY2=9m&WrXrTdrtIX$0F +pW&voMN!rz@&-FeuZw}Bhz0uP}sJn+B+oMe`0r`;dmrUSx2&OjF70so*+1OV=!>xn0xz!>9`o}Qk67I +zo^y8ci3T>u(%x!4dL$ZyCXYP&^00X&7awt+Eyfj`Pd*C8;k1HK0@AHS%KcDY)@OS5b$cXxFY +<*f_VvK#}%$fY3|NN)mZ})uH0sg>C;B|bX4FK-?{0Ql_8~+=)3;f;tztr}u24A8L0v-BzKja5w9oi#z +I*_+JcI@DfKKiKOXT1&sK({_N54{QB;2C}XfMn*gUS3}R9o${`ySIz(I*hw+(^Q!No_z925gv5GKWGE +K;4R2b(4yl``sp)&k>9VuAGlEc68ul?cY)sjYKj(p%u}DgL)pL%<)F{Wq0AtQFqeQiD9{4jDUH7(XPU +&{ef&r7OEpy{(C?xD;2ZOD0Pq&f{rmR|xr;nNeFeV*f7Aow$IX8u?gD@J@lTQyuJIqxfVLC*3*;a80P +PXlPUJEAoXC5WgFe2Ca=X +jeP_&A8*i@hCU_n*nKH-NWCq)tlR>aoN3SQ4MR(uZ~)@sGPA;m8wZ^f3xYOnI4+S{wC9-Ui@z9+BCD| +@4!D#Gr4MdXr`BDHrGs}W_H!gQJR^jnOrqJVAkEYV`hKh!TO%&8u+j#bVZE!5ga6_s@Gq{H)d4oj|Vp +PAT2-AeFLe@A7`~%Cz8G&K{6l9u(9k6I(K{K#;1t;^J>l)e#Lp@$Lbs##)2`YFmNyDGe6|~#*L3h$OF3dfr&XZv*6!Ux`+F0(%i< +}?%iStqWMEXBAk$xAF;hQMUYWMkceXWT;ey-{KR|zhX%soMJ^DRV-IaACxVx9~0D;N{USnNlaI6wOHb +jLBn;?T^w&AAtIx +>C|6H(fjx4=OSI`(a00M&jY>5{lR?M-QTJ6eV8kIy|SU9i#pGRdi)^LcVGKZf6W8(1nt)k-<;;p+T+A +H=4x#WaP|+J$A7QRo5p^n&im@?2i*A)^Fx?t96{zsb$PNY+7#-)CXk*R=e`aDb*>F_Jm5#nQDLqV^Mupi7eNo`>7yN|{(gE+PELyZe7CO8!h~-9a&EX7OT +>6C#u44q$J{ICkEhn-$53sK26KIwV*)=0ysOFwJ$>ju?sKK}=ih+~o^9Iv#HNMncf!)?j +H}0wqqI5GAdMgE&C`kWsh^ave*OA5cRY|b_#7r4%(r1o74r)i6W;O9%s-qn{Qfu2vj~@w$JDtt)CtUY +x~C7lV#$&v>3Mm1DeiNxzyaeX$O}9eU&mb2OWJ%N=9w@a3Vy^K6XrJT+WgY8IVwE7JXzo%`0;4%+;{! +->(2$(p94nump(8`%y(g~2xFQU8`t>}X4NgN~68tcZ7BM;Xtf9PaIMMVi4Hf)GPT|| +E$`Z?$ZF31Cz$2TR5c|*)sVO;eEZEX7qZGHiD0`nu7E3{c7TzP=UT}ET>)}8-Rx0WtlnojaRMV}u)zW +{wZjr@b@&fV*Zg?<%`|{G-I?)h6 +y75|r@*g_(vSrKCA9&z_G~~mB4?Za59^@|CKFELY0`ddAh_v13oPPZ3B>&;7kEu@77z} +-I0wdbk;mv?QC)P6rPrSe)5`{B@!r}PUU}{$zwq_Pwfrd6^5bK<(~*3G?LWousiz+o7k75ls8M3v6?4 +%9Wyj2b^?Spvy{>5Ax=sa+-hm)O`M?Jxr_x(E0J{C1d!j4`p)axig$MqW|1+#~neTp`lAaM{ +aIz#_ZX%%K`%f`TY6w#W?Wl)vLwWh2Hl;p2I}`>uVd4ANAX0JcyJ09VgyuQvd7Qx9=3H_o5$&wjT2`m +|G$}i_e%bL(tvWSabcd(c5u-Z6!sIbj +Q`FS73^#t|Lae{rHKS*1ouaEH~4(N8sZ;a)F2Qik8c@5ML_jv@A0ptS00T<*2|&?%cUNARvHGm@q-$rjPsS^F#0lzR~3c)+N6B>Z>@Sv;B3XEz(DtkUw_2Jq +7V$Odf4MWDe#QX3d%<=9p10;1>__Kp*3UzKl5)=Q>_|wjvJN0#fe>H6v{ns-F3ONJWhjQMwZ5#OS2g-{grjDQd)dzb`On(tjzy3(RHTu+awT&wGsI&J +L@JD-g-S_Ug!Z8)nb>z;AFTQwz;>d +XZ`R9c_`SISgX;ajbPd>TprI%h3<*Bz}C}*nEAG?Rgd|GK~DaKiUr#Q-q|1O~(qHhd-eVO_ov7f2yph +l5?{n%F`s-1dx_ytcxhtu^Ly-q=v#aF0(Cg`WfNv#=FR!2W(XoHa!>YCmsa@PeDeo*_sJAb~W8UBS}2 +V@iK5pdP_cN~3ZGhdsb>V|W)z7zV7=)a<`fWAr~^_A8WUYKh|pB%V@|B>!VW3k1Z^$h?=)*u?eC?qHA`bV*`MWx%gK-4(*^qxIC$vHO8q~M%w+MX;`W|#W=$g= +V(cgG+Ly?FBeU3=N1LZe;`gAeR4H<@fDBt%K-(edm`jgPzp|_*ofWA|Xb*xAu_DjyUQocO)*keK;#2O +LItD!8xFZFftqovz~-k&qarE`PW?Z`iB7lhoxoE+8<=xr&US90&*-w3A35?GgG3h#PX5+WtKE@Q~BM8}T47FjoYc&}L&i31QLCM%%q_-@ZCw@#HptG0a53yfk1u;$EcHi^@oaN?Q=PB<1{IB(69;oM@J9Dvi-yckY7#uv_7^Jam8s&v9hYd)G!vp8q1ndZ|hPFZW +tMkHisThnHzE-^1oOHI!n*`AD%sDo;58YyKkC)iF@BU8EL~4veWu49MIjImXMyDWX+c1tXbK~8R; +Xt59k-z{f--2n$07mEIC`;b90@s1*zdEWVUsVoRuss(Z0zh%ep|ORIG_HS;-5NQ>}BY*)B(SXN$NLj} +RGeU1&`;r{Z^H_k`@I^o1Goty$g8a&p)lT){B1ds0Gbwzc~mBl{R`%YJinaZ_Wr +)l`+Yv&bJp4G-6!!CT#X+ijY$jAiS!|u^d}?8XtIG6l2fD^?Mw&IBs!lirfY_lLE2-SY^2%n|t`P1-4yp$}UbJ;!iB=5uf@&SAZAJ3=q +S^O9;<7aqhu}AC|?}_)tF>z9qi?iZ___wGA4L^v-WE0t3{#N#o(bAVj_LoCtyqq9kk@IA-OqCnt7P(g +*kVoXl@}j&de~|T5Pt`|B)nC1&CaAe8S!JrNYNsj$^&hEnRjF>OJE}%Krkm<^I!X&YKtHd?=*2oiAJX +6JN4l5!of&KE3bKF4q;gL+*sDa9_G>u2JxK&?^`nqz5^{f#7UV6sVf +>}eLqBKYIH6SsUAAIXpM3)~lxvL$pkM*dCaLkGW+&D9%fo!YGmRDzzYr|Fq`iQcD6bbS+HhL{)3Xfw` +CHq*>`bJ<)sv+PovZr`!{>;?PCMmjGL;q~+lg-YS068wGDd&*b-UVH?9hZ~Znq$BB05Sc_~k_F@~l11 +`CX%iaI7wCudBJII4SRw1dF@KJa; +HHtlK_rf1fD$RK6Pi^H}1Y`7(5ZQ54wZ0!NDJb_~7MWYLFDH0jF*bwg-EH{lSsopTT+9jjO@k;9*$*& +`@Y~I3Q7D)EefNp#f+J8i$Ud@#IfrGdWIvB+t^;yfg2`9q7yF_dr)8n5P7>P^=Q`#otAtI3&tMg}5Xd +$~Ll_RM6vTa+A!H2jzJgq1vd+x+!=q&b(*7G&QD?wRVVIXjAPryWbwOWwx91oDIT`D78*Ua^F!`upR>)PP2K{oW{aJUaiKb>(K0(uQV!_YRAhu%dWfj3w9>;27swx8?g`|WXO%y +BHjGm?sX=B!ubz)taVg1-JH +j+(Y)7e6{jJ?I)X4_akyUik@(`$f48|6{?y)>$ynx~ekY?Y|z>cjfBjxbG48`Hr=nXcf{*=C*DV6x0s +lWlTLo+&Uz=10@OM%YN(%+3SPX4&mF$L84r`>B0sdpqKUGp;Yp@jw^rhPsVzD@<>W%X6cHDZ!FpQ}9) +|A1R^QcgQvYC-n3xy&A9DZ-r;z8d6DjurF9O>kXv6!8?jrU>TBQWs+PZcdFxRml@5ohXxnGbsMAhkTY>;0-B9hptn&j`q+Qux5b@s4;+mVCXg)4@HU(S*;0Uua4{~yrT930g0v)UN +e2=|(tsg(l%#=GyQ<){oQak#wEHmmtM=}L#` +CaT85Jq7sxZ9657)$d3E +m{2^>lAO@Vde~7ydW9>ZkYQoZ{s?QLGd>K!xj&uRS4QC&@%`$Q+q2vt+S6E~{inbx={tsJ +9IZx~C<|r7EEk~?bR3;R6{r#=;W>CdPR1#CIbMlZ!%k$@`r{lg7Xq}706@R9edY)2k9Ad4P1na1m?7a4DH~eTvwn^G|a^>r!WC_Yr0 +EvbKHEF>{8rvx6-Y48(cy#Dfs1YnYya0x~i+Xs;j!HtN(}kA5cpJ1QY-O00;o@p|(bb%7Xa +N8l0001RX>c!Jc4cm4Z*nhWX>)XJX<{#THZ(3}cxB|hd3+OP`T#y@5}KBl2}d9xl_){cidO5<63`4yW +df<-f?5?7ts>soP6QRTbyBzCB`f<~bzN^=T@_t-T@}h9_JAIorKl89sn;@LU@4$II6A-QdETT=fqwV< +`~CalLo@T<&wD-h`%b}4%LKC^2p0G=3_++A_&=}k-~V;O-=Hz82MM31Y&oma6xeds?D_YUxE2&Yba(O +X54ehMfAGPF6xSVhxr&1iy6$<<<(o0f^}s`S-gRMmda65ChkX6}*QQ-jpA`T5c+s^<>F~79$V-|)PhZ +kpdj2lSO3&FzDU`P^=|Ku#6U#p<_Pm~+zq_YsKGxSC>@)KP;m&6U2p65vFe@I{CY&t{OiB@iDhRyIW9LI+5@PRAt5x7t$Dcx#i3ZW>O@bJ2S-epEaca2FtFZW2L6}5gbS6s7Af$&`imGqRRUiO3IAMzF!#dZJ8xHR7lh>#c%8z9@VCBiJ}>;gkY^JbF2@)E +csM)`pOUZY!Ua4d^$|xl6`nTJsr40?6c@oejR}m6@H==8IbFWH?tcg}uEoColh1{4=PCK7^gj~+|NIw +V-}=L|>;>UGXF+(nYt{{N*?t+uPG;6a2jP*uUJi%cSrC(Lc(#euN)`{^TLbWE~9A`PO#y)0`hN`*;0a2&fctDZi8ppdhEz;H`mJHIc}RAR^0X*W +OctQQhYpnx6HZ%Y!~~wynWGS%sRwk5&}gvezr+m*QC8S2>aL~mscqxnYG<)64=+0$Ltq`xQ`|W+tCiUt=)Ah#bsN0GU=>13^PO^drv3UGq}kGS()G}$H^6>??mYV?cE?dU7&;q~?b!z)t6ht +Tg21+THbBZFkU@N|TASBx7%~gE7x^OjN!iWXJ_imLgthg)x=&7L10Z1~xhcf0p8cuvBjy5&|FBg>Q*gsMJ4guIfV?zMM`~5X`@}t2xywKL|y>0!uS~Eji +*F@%wH3~f67LO8FT5pBqc~Y)fNiE3y9wJK)>t;XG`LMr(eT&R-du6u4&u-50v-`Y$_LFq0bc;0Swp(j +A_g!Ov!7p!6vj45j=uL`CajxA75?HnNbzQ= +V|$d}nnSZ3bape=R(`0~c!5SCtSHwop9iY>d@aNGn%DzSRVHJ-0|+{_D1IO<*5&Do8HW8PZqM#$X?*` +!s=1in8Zq5^WQPNDE7+R29F637cXU|88&O2y29)ovID4AX-7w58Wmf#=*+R6~RI3NF=%)%%M4OVD4j>T +SQsv80LU_699s34%8=GB&P_%DSz0Ri%)b0KN-=J=Yt-)+Z*>5QQx30K8jS{2qo`+89POe&cHB|kYk$E +jF8cIg9_Y?9TgByrt#9Ir=UGPB!#kta>Er!JThh)lQ$hEhK>5See%MR8q&_F}RicNxtBnS +Qpd+k;@u^Z}|c@WOgHLNgt~>9D|@4)|8X+5hMi%LY}|Di>&TTk}578j_U$8(9SyRW8FaWwRf;NnTRp6cTN=w_L9%ARhhBH{=_c`R&&!rqE2bi25 +&K+yIKAiz`n=7Zjxpb*?w`h+mHH$NccuR0AwPs2`r!t)MjG|zR!EtHqx>)c7N~CRHk^{9t8v}5;-ELOtpU%!A?2fOyc<_SLw$vjSW4?DNVev388dA+i7m?J1fDN9?LG}T_aX;I6_#>H}kUO^fGq(j;HAEl&$lnuTjz@I&jo=}FWRA^-lqP)uE$*#Nh_dTo0=?q%bwD@@ +pt%67=$rto=&V2_{pThe9YBveWVS63h8>6t-la_<9%dWu>&>_q0B6d~aoKTLc+ +__q2_pgz%4(l!s*Oh3F*jLK=-~_MX1Pd{CfqDv;eMbqSCbqWwn)nzYvSgSV8-G6>v8~^tDkK;P3x465 +nOd#*zs!#192!c2tIjnHg(N!g_0Mz<(7VNMKnu_hv`DMFpUi5kQ58%50zv#3jkt9xoY9EV((MtgKGHc +QkB7wo7qBPj7>F?T#@-KWqs2H5d^&ljgLzl32t%cxX>T$Dpa3AbbU+YCmRRTE+;_?Knxv +6dSIP+l&FE=s~C3?yq514%eN6JNuP@lOdpKzZAcWd0A4ZlI#2Xq;)RshNt89f+7X8F0j6O%M^+C4P{7 +Utjw(*mIzR}MbCZKf`oA$^j?6^upq&V{wi}<}WCPZEx;_f({n{Smu+zW9U_Ar_o+CkPz@sV9&=Kr0EP +Hxp^)wg*L@$Tgu&kun_+(6CLVPdquz(8W%=blE2(^7&Kn^J5DcDEZ@sXKkB0=<%BI;NL4y631 +_j`0IR5$x@#J&d3y_0Zgsh8nTZ~_V#e);o97R5m-eJm2(K+477GyU9Phg79prp-2j3J8EL?>em-xJz) +k#-Ia%D=}FkDBqwa&X0iNf9HaMXmh$W}TSnYV7%W{Z^NW^sv#-pP$^GRU7pjV+m472B^?o;GNE+R2b +Xx&$-9$~UKZ^N0(jOL0ExKLQmD4t^y`W723g}A1BC)uA8I8k986CR4*x=>PovXw3dMo3A+qFL%22+j$K0PrFJh)J%X@dBCvgRmIjK(6(If8oXrj?jiWX(=0y=8uV?Sp(Au +gV7fk0*B=l5FD>ol+Bku6h0#tA{2+#G=gK%fm$8B0k`B0+Y-m%Bsmaqo!Zs9aPb$!HJ3NaVtyBZ_Jhf +Up`c6K3mAXZnK-AP*<+|(yBirrmcAA;0XK(Tc=%(!^8u0za;+agf-(pf*mY+SPDV-5cpV{ +*&vpRiiS2HgX7IsmF@k( +tnX+UgQNTl9R+sxV6mwOL(b-ez!LE3O=`hrDo!=irQ}uEajxS^s7s+6oO}KKR9}7ia7Xy2HaWNy*Yrp +mqE5M0oITYB01ZMB4_fY90kL~ET*MXj{{wZ0}XumV)uN)P;+|L8i;sR0k#nr39N;2T8SeL@fvKh7woW +8`#lJrtX6kRm8D$91(rs866K39(Jl)>ldN3~H88{-SvPZ9iQpy*t370d`0ZgUDIHx(aZX_Q~ +Pr+`QV20Z*-RUcj?SaU+(`)%Kt=04w6dkT8_L4dqMe6?X;aN3wd5@2$50x3tzx!k_1uG6)1QwZZUr{2 +K5yJaV3_o-h=9fNjWb_OmV8=TorZEtv6-2^l*Vs($vZU;M|Oj;YQx;=qq61AJ_TTOS~;LOr4n`mjI-A +{n|Hl4H4~)qq=`Qf?0vEwtsAw=1*6ii=QC_q6-ODed{lTQ-WnKSCmMvdp$~*}GhV>dsqelUQAVNJ(a! +Y)VFT4-ShD@+=6L+vLoK=-X5hvg8Bb>1ivTpAT3EaGKw9_>qAUtI21FrH(^-3hX=|Yxj4w`7#gdsrc$ +SoG(s23@w1jurP>><4!LOXsksLTL2?ndll|yF@z(hb{fh;5aTo3q9uecw`td3&ZF;)Lxw2te5rzlMK- +qjjXK$Aq;Wy!b&(v7XKRmsjcWx*KD}q;^PtyS_mKFas~65jMsFl!RA)F{a_09i9jq2+BRZVN+4X&XRv +)!-y4jyobH%lc3OFaqpofc=2TqqqRTd_X2~w0w8)QdvD}D5(Kf1Ek;!7z6FGA^mRHX +9v@MycjptpD%)KM~gAQwibXi#&)9iWf<}leA`*GXxr&Y9LITa>&dwFW(L@uuoH2S-crkXb>Q!T8Wo_H +q(%k_Si1m6nUme#zRiceEdb=U$kn51%ZhE-bF~`exy}N3dI9F$&{|-9!b*-7!rIdgUI~H6Z9<@^^$Ck +wWCN-svCYVWXqWn6!?u-IEox@7oE{a{b7 +usS*qmw8VlQfHe0FUKzgmGf@m5{GB(IYmFzJWA1ZGTp20Rmw*pw9=0%6J^uh7Lj@|@4Zm$9M^X~$OFq +oWuAo>ObG9R}Wu>A$>SM%dGe|5K2QhymUomtun?mJK@wfn5l+GFuvBxw)kkyJUBScz@2xgicjJpoZ&d +`Mhfi0?9i +>#NxPCt=tuj)XY=vm>G-0Rm?&ffS9?toD8v-6)Y}PambZC*YEUm8HWX<7@0qh~k)C#@24DJy{1r5|!k +XSSLFSjlQP_?b?fCyfLizUbXdL_JJ_uQ9Dh*Z~Xx)KLH2^s=q!D5zfud{Lt=4Q-SF@?hD`S)JI9}wI* +d4{MwX3lDPV()Z*m&JU5OT7K%*5LiL10evk-BfHb=yl5fOF{r$+3E2vB2^gfYp#|KDaEeLQ|pHbQ~sN +YfgHJ$h7cjdd4i_~K#<$U#6k}^*Fu>T^}u_9x%O_?yTK30oL+-=$_RMxiOTiyjo=lJLXz%%&}_sW4;> +NX>`|Hf)l2KBf93ZbEa_4?KAl2cVCY9^vFn^>pzY(5{cn?1w=&iCOeeAEiH>cB%!ACDL{Rr~liL6+<|=j78JO_(e^BGv^bSc?=K<;0*2?s5h03(bsj<8yQZ9$Q+B?2j6 +l#pMKSLBi`^rJo4k*d66v{D^1u}U!r~EZ2#$El@Hn_QD}3_CEaR +qgbc9mWBjGE!4q63uMhz +g6K18Na9jw$Fp)UPwnT0ri7q-sPv6@&=tpb#1jqW2I?-ZRfd=kY_i1U46>!GX`ehAVr7zT#De%avE9<}qWd5{;GNYKjDjmVTDw(#uiZN}fVB)doL2Ii>jvGVi;WZ@Umm5J +4`K)91U?nO=F@_IqHi&o2c!>j6LFl7E>xJ2HeESwECjWr;kxs+$$X|PeTR9?|RyP1L(5{o?kxDj8FKQ +-9!*KkL@@|6I;lQ%}+KoH!dW=)2+l;Uo1dq}-!^qx^N}0%+eCUc!|~voJ@ZVaKbY)I#|@-+C+R#EyPc>ucX1v$5V`D9s1~@1-F{Z*u_* +%$nCdFKdTd1TA@~v1FQK+o=oh3doQ@Cz8@jkB>dxsz8`9Ou8@7>x^ma%pGf+(`hF&s}?)GiKFVg43%w ++%F`5r0b{p>64(`nQT$0@Y;3=7HeBTelms}Hjl)$(iw +=BgRYS7+0f^q1X1Ks#=I7e~SFGLa2qJ}?J*e$0&d!E0QP0mUzoap_zj7wwkKFp+`pZQ9>u1Znp7HePc +8co3P)&9M2eeVyYUZ%pR8KPGeC8mDo5cAxRngexOr^Y5pz&rm0~Y=OxR4qJuuti28Ek23);ogm3 +7x798oDT!F~AoNZ`1%r^Y&TaaT+!Etg?-Rd`h=>~~7l2!^E>;#`dJ|K$7H5ppY@%UKp`vq~#G1+VcA`^aq`S7cYPXLm#usZ$mRpT*Bt<*z0L~UJCuU=8 +Vi5Mnr9{eoh<$@Q{G$1~ipT_mD_&#$VAS|`FXuEFrhv%FSP;s(Jy981JW2Pr<#jTkJ{b6;do0MB>6KH +Y~5ah{OTW}(LU6G5TQ?bhfZhz&-uW3jmbRytGQn6?zJgDqZ-oKYfPwKn) +dFEe^#ttK?JvOAbRl1*A$1RjV)gfi-!pN(3&ZH%Fap^vpIf21hV)XxaM!(z2oKfYc`tL(K{gy&FVmc) +0W%AOl%%y@g<0=-2~gjNI45O!nK&sNnM8b_xb9(MqA*`~AZBH|{3ya4)?R6c0f%mn3Lr=6W19jf(15( +RB@mvCu2uTDRp_vy-FFpsc+SarK(3?p8AB-d_mv1YZw^G#%eLUM^Rw-~h}Y&xRWgk#zqv{6oKSo?A{| +gW2QM5@iPX5Ztl9^dt&#-rE)bxvuBw$^l$fvD!hKz|9UNF7y%Fo5VA<&wq*mO|1=BxCNM9IFA4cgtHq +>Vm^33YV6LxBkKtdqm@NDJlz!Heew4;m%AW7k*I3eZrkP##@&8anBDa7qhSE4u?w%%+IUmd^)Oqey2= +hO$F>rXE+J_SF;hY~s@) +fqQwK;Ui0g-?O1)_G;9^%AOiooYEwln`BQ@@nFpJCxASAx9q76j?$ChC33w>_IzD@HKr}ZUU_PjT)Em +X%aPHY==X8!uhhTCyRnU}+KgYhT01h`rseUZLQ47`tJCiPfisSM6?}vcVw#_rJarHkPe;ocRUIuxLjw +JXW9pKRiI2GdG34V8p<)-s;zW=x7@-_>?7pXM31GRgP@J?bO^`I%J_ceSc{F7PrDlXjH6mvE#+# +-3BY;MS|D$7NgKA5(e3-Z@G#pkMy)NT$GNt1xy2Uv5!TrG(!y~Fawm4ySQMFN5|zkIiHCc8E*;At*SW +s=QY6M$J0C8JtatHcJ+js$c)K +mMOyJ#`;Z3vhP7WgTu%B%Kej1|Lbc+;Y5}>ke+Oub3;?-U@%TiEOK!WUe2#@!hcanyBOU%{n2EgLl|3 +GG7G=QXgt}MAXdZmGUv_8+z9(83O@Mjvi7d|o@x@Bk6e+_tkD87<+ujF#s(^Z@X(m_eG)Sho~1us%Pf +|3Hg0)b(yJ^~5KBIw!2CVzN<55}RuTrU|-#s+HX!s34tz~o!l>sVMKqjO<`xt#Br8HaImRW!v!B#W_K +7qrK`Trt6MB@EDZv}nKAMq4xZb1bn2W$DxLMC>r@(uxlmMm{>l0*TOr0#f7IRyx;n +&;%ITwFZHt`RFP{r1u4k(ybui{fhndyKFu|oK)8GKQ3e!MD(L=Y#Bz&r#IQ`WhiA8#iKVIjLH-03w +3he9j2)suB`5#;hb53ysgsshXWg9??7G$@x?drZHF_Z$cKre3zv6s^L3)#K)nZ?lW>BXWHsQU&e7pO- +~%5B>0PQ!?4RnJlqb-voY9fpDPyB$|UWZaP-aGKNi!-KSv*m`t1ZGmxnd0K0qv_J5)TAsExF-;F@mDo +3Ke5X}(AFZNgq%>d~VfEJ62}16T7G)^lP}1%oy42HEU{Vbwg +X6>H6XsGU~+ag%($`1rnrAUEUoA8}sY%Vtx8+5)4DC9Erm`xe39vi3(R*zYfv;a`V93M>N0{!9uT +Zi);fNFDO^>6qtK=$BJA6tP7qW&5DMJH_CN<}a+m!Ud$nB*g=y90+0`GqfqMu~cd|Suq^Ye3)rO>Sp7VV)f +(I|sZWv5T+ANT2l|h=Hhvq^kI1o6jT_ACL>VxD5`6#@1f%(jvN@w}@LzD`375zoe^+n4yP +%iYYV$Owz_-bt=uN!y6T-XhOXYNa|Ae`1-&28~OKHKD +W-(NYoR6pJk(pY{VU%F5Ho^4$HXUZbi7?L(aQ0?A2Iis@3?0x3p|e0|ckm(YEhwetoGq5WgroT!gu+f +jwpztu@`ZnYI+E`#KIV$mS9_ZJE`|E)d}9m&D;*`nN((x*sl4i7o;DfYd|{WKTVC~OPF*tPnxLI~xMv +Fu)J7fdp&Tb`!!9~RQ+%?F3HXz1uI3QWlfxk**r*1Lb@w<6oL&!f<7kkH*O`b`fK*$T-K^~xLpVo{JY +kn2(+2=+Uh50rVu3#!{H4u1@&QN{f2cyu;E5%cF%@PRb*BF@1rN)S2)YBTM#I7qOKycpMuvSKru;YiF +4_u9$t+-1(Vd^W;xC|>L(Ff%H8<06)H6JUW8&^7lTGB>11SqCl8h?ZsPWVm{{~y~`Z}K*xcA6n_x1XD +;))wgK5<2r&r`E-xReQUKo!Us7CdiZ`j<=l1)U$&`lKbvp{n2xc6AylKhU#o0h*!M)fN!7Xo +LD9Q(StQgrPxDS7b`-N%a^tP?KjzaXq^C&S?`awC;hN +bD6rFfXG0LVu8(ChGT-9^iFu)4-weWK0F_UGd2v9*%BP%|>vz9I=|$B^WoX+AC;DX4Z@vEcJUT%&cM! +x87x;0gDzRZ=;ClC2EzXyR`GS_ektH2{s`w+R(U1=&-L~8;&b$A>O1rIIiAW+``RhhGP=YJns29i=a{ +8B+pMhUp;mrIHcYx_vB24ocfpQvE#vEezrkciw)-Hh@o@QAI-ekZ{ClTSnaYFN6QTD1kzaxnKPpFPL +}nR+YHCe6+o3ij@cU{c`j6`Ul@z5qsVJUqe>F7idKFGtm`K&;ak&uxqyE`gQHaYU79njpW0Z=vIw`eO4O~y- +KLyyZ>c5~|b^~pW^U=&8&{{W0^#!5WAX+9vW#-n`&5#IqId<{~LQ@J?jMw4=ZxMHxlLNa-p7LJ6ieMy +G2#4MS=lx!x9Eii8e;st|Wos=^&xXrIt*$T|x7G!=ITmu7Fb`bl9kScEVpha=22h)`_$#Xn7Y7Ot(8s +4`xyl-o$Z?~q&k?ZaL$l?PQ>Xf)L8IjyPRO8ho;kX^Z#j*G(7pelVc3=~yY{d-#o0v$@dT-oIvVR{s) ++MQ146W)%l07v0aeTg3N!+ux?l_+AYW3t<#L%;7GjpMt>Vor0EuU@3o_cOeli3S=n>I+5l;z=zp$i^7 +`p7nGwiEntXT4bNrp$lfhG>%kRF(%oI_X}8JiumPB424X43Hip<8(Yz5`K;6Hk;a?A;)mB90j{}tK|z +c*p;IRhogc*4Lu<8EMe=4FHucn3tK;?m$b0;LwwnZ>fk`cy5kdA5J#;~j07P=TJ26)qFu6uOrt9Cs4xjZo+1-ucVB +qqv{+##Is(p&sDx7iI=e&Eo6Mq5>t7igJ7CZ+=AXi+2Dg3>Vw0hPLYq=SIl)4Jf5F%XHT}QBxH>CqJM;0+_$hVR_( +wxD +V)_OoCxGKrvm9SrJe#L#hnbK&s4!reOCASCZOm6B_tgGNdY!E;AvJalEbj&Hfk>c1t@^TF@6Y)Lu-gS +5zoa%tSxvV(bELG@hD-w+5|y6=JW8*cVw}M^E`im5{k2j=NY7xQ~HY-)HAss#nzvY@rjVzjLaN6psU* +T+%1J?`1_9uT#M3>;GjbCWFJvdF6v_Y=pd<|HEFXp12T==W|GQ|;r?CdKrRC|e+3?35m#CsjpAV~)Ta7?T(MQFnHb}G(doil@hQ1hc`MesQOd6ixlxBF_#)Fx`cRCm;IUzfMXdrJKbh^$3B;VTm^6$yYs +o@jao!r(ZO&1bUrVOG;W<8cA!mYS#+ab&Dt#2-Tla#o8-PVBBo+xz1#>(3$dn(E&A=W7A`YzyrG=_qH}M)&!3 +5YalOLV$2f}Z+VuigI98jNx&O&~4U8%|Pt5H*MZGuh}gqeA)cPC{9rl#J73P+E_dvctB;ydIaVFLDiRoM*Rom-LtK5IQ`A%C$n-43 +amEvZ&}Yx9UBK6W^Mt5Y+qI;`+|wZUfyF(!V`p(AjY?9lruLbz|#>u8JNF +*5A+^TTs73p7RSvWR4+jBgea~qb`l(q@r(q*9X%O)bOO%U`5Ri_Y(fAXD%c@f#LfBHyGtj!@*|I$=&; +l`0TvAc_r0go<5D_HJ+~`Ym3oSm>{8D{6wQos+Iw +iJqi8%zaJu1{d00tC@8XmkJmd}`cb0;m4KAFO_`!bol2$}O;s|~E{j+mgr$;?I +wREG=d+#aHaj6UarMDuI)~+LulI`OXv|Qzd7~l9wMSnF(MiFF)xF*7FUQqwN#g1Q$@;xeQScV3#HHV& +MrSM2)aW2(BDQ-jLNHA28X%S@Azdi%3}!2gpb1^iELI(!vBQaYVWE1s4;_AI +=C6?@F-2&k>7y#;hxsBl8ErwR$_AW0AsiR-%VImU7jGj?NO?J_d1}qQSxY^W#qtLsy0@(3Oe$ +-ovYWL1w-73T#ZzmA#)s$ykR_S2*kV~4d$ZUe%V7O{JnybzmgHELzum$iFmni!A)7rB3J{>Q*j*;`^V +wz}tM{|7@J5JIWRm2YdFfw}$2U!WqEQgey4r?1Hd#Ff*62Jt{)`7%ZFKlSr_9}J=As^HLF^|!HbMlg}4{a%^>W +gp&wA#f@dwi+d=?!2}+^N(z7xzqc6rS=Cwnf$eOXTZmvCP|+5Q$Fq6OJi1*jbZ6c9ktuB +|V|wDp)4s{)Fkdj=6_U<{mi2HozjuXb7gG*Y+4@+|Ak%z>dbHbt><}ZrI1 +|~V*Q^gR9WbeV&?}Ehll9YjJgDWgK(Lr2L8%*%ZEfdLF%EhSil9>d&lnH5XQwp*(Q(>fUu(JlO05(Z@ +stwo1D+0N$ilINjOZ!yk)4|)Y!0Rd8qjeGn{)YnHz*9n?JOyWJn;f}pFItp~TIA|uR_!5bphZ%D8dGr +J?!th1^!F&oX4C=_ke1}x+)qz>ItW|!A!mBoQ*@>#I1E~|DS$=pcH&8!scv$0VWKg^CaxguYgp8Wp>K +)WYFDf5DN~*5-8P|DldL43+nDXPc7WKXG;&w1-V|nuf1@I?_%3~CNZ=U@|GP#v +&ADLv~f@~G|>G`TyTvpAAkqVJbT2@k^wl0V)@fpxo4-+>|3(<;vA_GdAa-~LuxW4aoslH6%+?D3;uJ!Cu3Mx{2%9+2BjT$J@iA8dyQo|IyFrmyuERz9cM)sEB1-hUpmYEoz7* +s`P`4AhVT}+3kfiG6jEGLGxp`&uqYn)d@?ZL}N6dOUfC3VD3$L$S=jOu1|`h@hiYuqo2bQI@s3JLA*?eP6bN)x?MeLdCCdE77vAF$-GlsVV;t+R+tMyyz-N{V&D{UUC4wX7?NSyEjw|4o +KN!pW+VDXsN1OW)C6sEQH^YF(QoZLP9A7VJ(^SjJ7DqPCFb}*K`abXu6ooQJSBD_)|A}$2a+` +UM_0Zj=Es!`9Q#AYu#vYhp|H=;@YjWzW(@$rbC0t=(-4XvGc!e&8Y6wB;W`23)^lh| +Y*dtd`eLUc*;Y=jP?|dX?$(!kMsuD-#;Vg$z-v`bOo(tErfsHBr9-*ZHtMRRyi{!b9~dWAi81*C1g51 +Zvi<7$XRj6#y!E%`kczcj#&H_?t04oQb1V;Mpra{ShwvvroJ1)A&g9p{12i(;8nOFe{1;kCrc3i!*<` ++b8;dk=T0u9>a0VgGi{Yfc)8)ahj&RL9fU;N6#dq_X9zzkL}ezg4Odjq(xCl4buI2+9O{Qxth^aHqm4 +cQ=;9qgIjXd^@Rx+5!_sxU<;))n~B#UNJu#M$wghN(H$JE4fzsHJYlC6-O=Nm(O^U!Xb#=&IVLXs5y{ +EqhpLhAeogCUZ-8|m#SKIzE7iC~e+C}o=fdgC(gE8z;IgSd0EN&hccATC`(sbN0~!e_C3v}3i|)`;d%)1fP +}S-tJPetA9o;c;9;HKjKQ;FUZP)f5tNDE7b>c!pk7Ewm%;{2#*P8p4TR-8o=w>F3?rTer^PzrpCU2A3 +(E_Loueg}UEA>OAYffj+2dHm>TA>${@aBObvS&weI$hrNwWc_M@m#~N9gs;+)UJFcdybW)QGeEuv%p8 +>BmRHj&=dG`R_#|iZN;<170v!trr1Bf_>b)n?JYi2?%1XNkgN;{WCGV{m(2|Ytii9gUgfWj4hZJ*Kr# +f(%HVnP<}F)>%2Bo2<~JIHzhWm+D+c4uD@H@Gy;dCK6)+S0_m_3yHN7QSm_K|ijM}w!DCdP|3;eZ0d3 +b2>*9L!`!500wn0z4C4u(G{0YAJ5ytLpC6@sURKW+Ha8Ek4RO>+y;*#@0SJ)ONOcHtj6z@R%}B3*czpKbWj@d%gt<4L6Qn!FCl;^uI=6V1(5VIXRLTT1fsD;~G`)q#domzR>7AAURy +B61**n+iV@F=i&j1pI0($aU6^&l3t4*Ru4D5HZgO2>A{%FFT{0k^vs>*y5-28Pp0}e~%2Zl +x)s;g6<#n7$Bpoo^EA8>2zDE{#0F_txN(!Yk-W@s8;`0iFa@219kB=7>;T4NoJw5Wz%p-^XZ@oyN3gQ +g&fWnS5&E;NkOd5tEZ@)=AZ>$ZE|FK4AxOGSgl508n9G=MlQs>ay=?c3<;P_^t3k2;?isJP<{I9HK=) +Z-9zV;%#a_QDwfgg-t6+TlJS1_cvb-`%IR@2Jl%axMZ4%)2M}kzxrV!}1?}3JEeX^@|DBI*qgyVhPhZ +SOe>Kc!GaNVF%{>NTQ>OrdtA%p1AvWTK(YX9C$^!SU-y)>ean +n3$%6UXikz+hc`O^hZXGXW$ipRJdGByFNQS6L^Jq=h~8XiKSPb(;a{Z(KvyC7eg;(A>;^o13@kzmTMp +=aNaz>~@*$a+@b51+VIm$OBTjoaJUdYA-jQoS^04?VoIx-A6a7o;ijXK9S`)LsgH8YU_z`o>NaI=gqC +;vWS`=RHWfFg$MRM&e5wM2l|z)U52FQg7`TKD-P3{c$4g#{=2(vm(oumoMz0=q*t$m79RptT%@PbB;LD +uD%&eAlxJ>xP-?KXiNl56k{HxBj|YAf9O8TsYy!Qqf8NwI6Ac(Nq=I`Ha2nK|yHT88aIo{j22y~)M1*ts68>%GMIMve? +%xL${H7O&sanoZbpz&0d6U%yPl{3-)Go9Qd49DIgu9-C)e=owjlJUe5qf^9eC$z6f*r~o>goLf?X{5a~tg*knbAAJd_jbI~a2jn@sDba*ff&bk=^$-;Ll0!MJx$YN+q0#Cn) +tY(zb5MId$#9XoN9hk4{c4pH*l@N{!q?_7n?F#W`4VN{yz<)tjO7MjGSpe=m_W8@mj*zUZDF{O=UTBf ++tg5lQ#@c%FJ9us(vXHxF(brPyaV<Nz`@0!ZEvpQ~b>AkS+b6_AOS{5g$Uy=f9;hZi( +S1dsH+ETNzCmFncX>PgPiYRIgeG3IY{CaQdQ@QnB(nKT*iMne3NIuIe8V>VF>dm~d#WQUZC8nhBp7j^ +>Q_3As^P76ykV>`Sf{C8pL&8Zle99dve^5mlbtmgY=iS +Qwvkq~?fTDtokZr+&j5vGp2;T>Y)&lT#e_tf=xzMSsBC*DW;Hr|E63x1D6cGQGO;eWfU%Y|pq=N7O-e +%2|eci|@f5muR0Z{n8XW+gcgMje4I`vA_{V3@Z9-W6xV)S+re({m*wpKfhPUSh6D2A)D(k&P)^wOw>Y +fim>u43O##wJT?o9|->4TiWeX2EcDh@J-BdP^GRg#+K+ngZ=gH8Kl%sqsE*OM;?l~^7TO(Sm~bZDyx(Id=*NfO%hI=hg!+!3{p?# +QqPUYJ&*tDIz%NsW@yxE0R&Ra(Bffw1vkb?fIe3ok<&RL~vPkr84W~bg?_DObe6>KXYe9$MnBG&Kju; +IkDd`vpO=CfDHh06zxxtS3%YTsJ$ibg1IrEsj-2fDTO8Ob5>_%h<#$ytQe*d`z5sfB!_A3%%jTflaHU +#qG-YT#hRRALU{dl1^9g_UlEhqr2$4_)@)g~;*!=}H|-Tr^XN?Dy=;@PUCK<~x!0AcKhZ;AIn3{6CpS +B^`u%SIJEgPpNwTV}0MB^R|}ohbxNC-!&{RXiRlhzbT;7wYJOZ*G60v^1)`zMpI6_(h(yR%5Pt*0D^8 +UDGdramibICj2E68H{=mj5?YC;ifS>2^hPx>);%&Wq{Xj=a6~IpS{~~2np|N=WuyCCm!+FIsBY_P9S@ +?T*=oe#Efl`E3;$G1w4BKK#&6Aj2D1I@OSKhx967h`mZ2`QODs@5l(w=9gq}uNZn%KU}e4Eb79Z;T5X%Fg+$tJ>fYKY)CkX(9d^E`mSwi@UYCHs3xZG8sOP~ExNm>>GN}~J3 +oM?&&H;2?9=oYA5hbhIQ2NX?N%i=z8JAfF9d{F`h}sLE_5OoXb*4E>^&Fc1TR8_22fnfq1b9TcHD?iy +cUBZm!LQTQ2Z)+ehsesFHj`X_r%Y)NK6ahdFMk~;b*9YL==;o(YhQxrRg+oBz^jwh~~!K$c1M#kS-;U +NypiD#<*A0jYQMMPzf#c2F>yr-M4+H2!mT;5k9*d>)2JulYjY?l2`X6FQVktvE(|Q{CH3D?Uej-Ecx9 +}$tnl&H!kPA#95I0GM?LTD6wp%pVB$u3Cr;)1#A=da(-^!dd70Hq>o1!%0%O9nP1FW#a^53%GrBZGid_2}`aBz7B8h7ExpRQ?6IUN_=vP9m&%ck&ZBs7Mj( +x(<^o=)~VwWMIFTfMA^dZ{rSh|hQ{P9cBXF#e}6H5Tma7zJxt>tUV5$E?8;1b~1k;gyY!teVHuts!lO +Gm!LhKH~&@Ku@D%v`n>m6`lP-_l%x?qH4`{3&k^TBVA?`WMm?!EaR2nIItN11MR?WD%0JGe3{3 +Hs8pu(m(6Dd$@qLpi*^^%zv7LE=ax#!5e|#4Z%dKuOda)dH~(AwtqnPuIU9dz_tfijUPy7&?zl3;|Gl +@lKe&uKz9K-jPBFjC&i~>yfT2?&wj?H&G{9n1?a&t51rGns)4==-(W+EcxUP_)|mt?e{HN|(Fcs)&n% +o?KPz|alHW(q8bzG9Yzb0`P_uH|d&$8g{z{{p{yphmBXG@anau13tO2jM3z#>`9nJpi?f$Vl6isF`JE +7dQz}-!itM}RAJr~|DioKr&?<4qYYN$Q93K#fu{Cm<1#S~H) +rsTY$k&2YVe%&|hJ84_gJ3NTSrcCipTT5rjNOA<-nhu6b|pQTu6CJ&!ttimLaH;3?x+IPGy&_(S(T_?ovy(cj~diWKR`OEgdXT_5R#m@tWqond +XhMs{vs6A25H)854s`xPowp*t|wj|{?#12iw7?#ZDgft6Jn4sgd=GPFxgxpwf{3|<%KF~$gAqaFmq6- +g?5#~i(r{PGS-J{+=874!zOo?PNXhUlPE*+bn)snpc+Mou|f^Y;Q=kb4W_ +!8_1E{O7mt6g$fY7L+nf%#I~Ft(HI3Q}7DZ3UW&jB+UFt#l +~R*U8SG7Vesmv!PpR1rvS$-v8IPwhYaE%TcjPM#pyXpGMhO^~cclM*J0CJ5pzJ(ColpqafBq(*HxrZj +M--U&+P6C@-w@qe5jUuq}zxD9H?333L|^aHUlaKm^rk}VJ(9Q=x=r^Gm^zcfE>hOv;(56ner;xzI3sZ +N-mK&(9+-%cFgHjL9S4ky8{VO%T5wP0Kmz(q5J(|4^M;|Vf8K{(BW|F`*B4fDfwLiu>k_!~rP>Q9|gy +I=vz0s=Sl+6szhS~^++=IwG(LtyN7e^Ko;Hq1`{eOuL`*-TYwM9KOX%VVhj_Lm|Cm +BpXUwec%Iiueu?}|0quLa=b?;%uXodM0ghF3IZwgNkPC%T*S)w3avmht$9 +YC6+;Dy?c(BxS;+L}-LbCTTtFK*TUbO3InWB9q8h&AvgEPJ|BeealQEUgW%>YrI~pHV0+QN$c?QoFaQ ++gsY5M2aI*Fhyb;$eV7N)b0~)E+sv?nQfwL6K=wL!#8OIZT#5wA-WgNidRF&?n_Tb&#-Us}FSks01G9h6ghC7$6r6KAF3A +JxOFlac(-!L93)$Uu;d*EWnNmu{mrrk)sDfF4dbI74Fw<(Ztr0oiOJ-F%r=jf$WE!H*;AV;c;|qyQh$ +Dd;SFOv*fNUhMYf-tP{GOHs{71D9V8qx=t{Pp#gH``vS(>d~(YmoU;UVm>VXg1_xFQm+(s(b#$=5x?%vnmUS6Jfu(7p`{t1~#Ns|y +=gX`D5Ei|PM~R_g>I2=0itb~WC%(H3M>fAl_A)c71!6Vemqv>4YHm-RxD>B6VH;MHM_X)IuK}tQ<=6R ++_G7=JZyr!#5ue4JOt^Vj$nW1WG=c@MB|aY +N!xr{i#$4Ri?w?(gfMepXFhjDN|j$!^}>=>x$p4lm#J8GamqHtbO;I-|8GZv3LH(El{dosW0kq%U~67 +Y)e1%sM_I6ZtK_1I-FVdfK1*T(=pH0=&tl1%l$U4af2O54^X4A0*ES@#z6L8vi(sI?yzcs0-DZkLrdm +4aZ)7z3)I&F=g+LK6@Nj$kD55g*<(n$ikg}hZ>%wPgq)8UP_<|US*(EI>|js3|$DR+VKx@JJJpPgQ1A +(5~4E1XOiQ=Qlf=;hCTmTeuljQ!)5D{cqV@E=l{-^jMkQa7~@OIKK$Q&5|Up!txrPQOa1vI{O&{I5i& +pQk4KO`==Di>b;2n=37jkWvLoh`@Y4r9c&hV*UY~@t3u8vlpD0pW`$2!rH81~fJ_(%9HLTx0kDc5_-! +;;T_MyTo&yJF9x;ouy!!Lc<@kRm&Sma2a3nGZ@(I?>Y$n!w%`H~sR;A&TQFkL&l2QvM4Amv}^N&ghY- +;#6a)?ml_7fCmgctsO%p5i*6&8D_`^|Q5~mY+_9=i~8y>4{0rB70R6&xD +yYS6d7L4SOYTn`_T*>l_x7p+2C&N5VA&T)IC-1~ +-!^3{rlTHVRPR0e%$+8n+>l_@aEjl&+qo0&`r2mVlI7q3+ +l>)x)x5-T<^y;KBoeE830R_i6PnG-vW2<>kb35y5~q|0itL|6n*Sn1cM;V`6y+Hgf9tguaIHx$3=s +J2?B@o(|r9GThhGsk;3+vD=(}I1#(eDdvkX#p(647W8O)%q|42k|F5ls8ejlqI8)hRoG-BNnBB_+mJy +W@GrWnD`-hE>q$m@50*DS891GN#m~C@tc`u+T@vLt9ebB-F*a%Cc!SzihGHq-{nXxmu5>!>JyTM<7eV +Ef$}EbC)I|icX|R3;K#{$qK;SJwGiTxe8yldd;0Vq7F5aMZesC~P{`e}*z}vESKegq5xl_uSc!a5Je- +qh4t>-W3k(}@w1E>Yxg_`*JXjg$fu*lDv3Rn~t#ath2g~x0keM1G8Ng>{ytqqId9c;~h&o@CyyYFu(t +DG!Mk@%)P^^RfWaK}AGjDMUYHmh{SrwyI3w;JtvPH!NRUiy$>aGNJO9n9N7_KZ!XXlATa#^brMv4Ns0 +$aup;NNF1+wRH@7_!Qh%RajsSHKGH&j-M)nESEwS81I~?g6CoBGqLnYxu{8IHR_Ks9NJvyH$PWRZu3) +eN)<_a{hj{%^2yu%_eElL(do!m;Gi5;R(h9QB(cLjyk8D~d=hI8grDPEYvMjJWI=`n@BkgtSVP~1GU_ +GIVL8l?x`<1^1a2sj-#V#q;SgC|w_%F7VySJ}ZoHyT)XfsxC>McXkyb^gN*W;bxs-oGYV|$~G&e^*Y7 +;{jp(Eu+$@CA%6i5kOYg&n(duYyz2)?c4pK@U)#v|tr+S#1oDd1u|CU&4hT?m|3E*xMacJbORS#m{}X- +H*aqaW+prs>P|550CSJ8H`Z7K(rqvfcESyqTZ%O5Xd~sz#XV3TOQDQA%wb~8GXk$pwhYYB+kSzQ|r6u +{D5b|NDA`~m}3O%C*W_}Aiq3zNQE=k?&&G#IQr%UXJ7@0r^l<>xn=zTQqcZo~!yAW#U-A`^)JMR%ghi +LF06hoiU%R^%5C3;z)+@*Gwh@s!;lD{CoED)Ux%D;k&D$hmmW*H6he7X3+P~gJ>^58)^bCbNiOFs)n2 +1n$jhiOFgRHMO{Ggtw9T8-HbWo`nb;fpeY4nG8iqa@OiXv7^7eHza)J0oey2VH<_{iriW^W+1n-u7mfuO?^a4-K6E=TG3&LjO6{k|g#pZlg1=I6{jUO +1(2TJPC9r>PP`QnUYD9+8rYaC$izQ8Sw&eUT!!XU{KUZT29@@#y{3U$*LC|Q*s__~fm0ag{6lBIU$K5 +3TBb$CW?liq|x8mo}jq1Qkr`k`U_DX0z*)sZM{K{Y9*o-8pmkQ6AJK)(0YnX{sJlT&bzxAer_K`91gZ +VW)F%=jyWpFB^Bd~pkwD%z&Kvj@3XPW5H-5n?T@Lmwc0fmv}=0)saHA%R8{kiZGKsGYuIfIQCp7xY43cM26YyDuR9#1rpt*EyYzm6? +_$-Zk%*X?BrHYY|H_^HS>kpU=#^%YtBbPUrXiegD7n!t66M@65c<^UO2P+-G{zZ>G(UehchNgx0PuE* +h3;_e1?kPT#5=ad6RI|EhFpF;?9}mZeRF@)|PG9$2(c7in*SW8#FDIQM->f8pQH<$vB#g=?{gq!~)lO +dCQvxHTYY-WGtQYB3}*q|i`$jdbr2ssJxs!^x-PF-S;q9Aj9wPgG#eS?4fJK~0oS7>1oGF0-a~rnBSE +)F58khY*h${DYy?Lygnc2Ed&Vlm%5w#1PZfp7xM9r9??X8OpH?IL>jc3fB(Dmiul(4Q?)ix9uuY&nPkRXt=>qs>IWU2J{nH{8~letX$k(QkxdaZ{ +OszUtalnN-!!(xR(60}JuCY1P-#%cJVktCBgn_?e8K@%XXCIld+uWKI7zg>hbes_yZ>HrMgLt)4;$Vy +%#;s=F>=rZ;AS+pxwoOF0f5F1sh$Qf8lQDVsly+QPS3Az|AsWpTk~M^N%ZjNyhH)}JRiK20o3@;8^oF +|*@b*#tc`lFjAW+#G$>K02}7`>PlXBJC4ryizAd^pnI^)AIwd^T6gC=Qv_6>viox(!cF^P>TT=mI^xi +ps0S$2JlqB;6IJ85=Lvtydq#izj`YORon6JD(%L_~^}sQmA^z1STpS3>P?(^l^>@;`pc;1JEYNdO}lljiI!YNOJ-jDqs8LM>`f530+!YC~b<} +%r%CG(Zi?s@>t`zLYWS=-qq-08%nS0GZCp~!8GmEs|$h!W2hn+C|J<*Iu?A_Td@F#qemaJb=>JG$ZzG +GQ_ST`x?}Ot8V9!e1IcR7cz7POWxEI>M8s|l^hbEmQpEw=Fi8lZQzq6Q?pOB_MMQ75H+Qk6+E1fO5JT ++bL1+8pLSsw$s2cO2zIJct3@F<2(aLovxu|2aPiUTtiH`5g(HF7Wlf)=D&|GHMJKl$QE#~$neUAJ)8%65?GTzf$?*$VOwLTyq^p&ecragDloykN$=8qIsb+)iB{Sw*&2RDRYd)8PBfWqw_XA%6P}rQM_)8cI6|%K^h;+;!rx&y4;FD@Wp(BiHNVJ=9K4nw;d +=(eAL6Ytp$wMm&%5pitadmRf0!{zhse)B8fCXIj=PnO#T%QE=xd?Elmxdw`~Bd|aUnLf;hhbgA43OZ2 +a@U+7Y~-t(o(B?5iTWnoac)t(=w%`@n#iG6|LivcxT%9%2F8Y)wr5$R+c}&`&Uz~fT9XiHYA?;w3bF +H*v_{sT-wBuZI=PGHhgnfmysXZw-SlV&cuG3fAF<$0mb6f}RI?orn4%&4(3&p^;Jj-$MZrkwMd~Rlm_S>8#j&$52VvN$0 +&pXm*jr8#+pMOZ7zq(QqGJ`_xCNselaG4Bfmr;%6vq<`+N}n+DDU?2Aqz`ElzijCt1@n)< +rE4ZifZJ%1*sETXSjkD!pKL;MO%2xdHses>IG9AuxT#Qr%!LAN#FxMJM^$e^5&e?HzGkgh9UdRVzM!v +{2IRDvyea{C3)s(;u*+ +vARSaO{$E;H^5@pWijlg%0zy>(fk3@c9}`FnE+Zl%IqRSD90udF}6D>&l0pe`>I|>9dgU4?E<$Fr@l7 +BW(Od@DBDzaZLapUxN-gF^J)pA)oIJft5)RZ>-!v>uPDFQ6V*v{hoW-E=4T|PenYK?@$<#5>q=%zPH^ +~Eip|yj&es>pyIz{`9h6jP$*+O)`cmNT^Tm>iN_pm>E)3O@UrXuvl{3IDjw$pY_o$N4Zy4W-&s9GxH& +%aFCaWX&GfZ%St-PNou`DLoQfATDoyif+eQsJ?WWv3B$9KlO5==hjIl8jKRXBSX8qiW!xF)W2FSTI`* +PGV)S2r!or0(_7i>RH(J9S3UO%1GnF3*cgaZu~GhP*M)4|t+pYNNf}arl7)mb3*d6BRUmOPvk8G~?H#v4yH>aAvx`|_7wTI&XHCiZ1^bI +Xtw%A4tg?hI|4aKOGt>;jN>k@7minbJ7-UPZ0WleCRRrD5HyDChfm>g%S1K!8dvTC3AaiSikU!24uz3 +F|?6eqSO=ijo_`l_FDlTrss0o#H*w7h`Kp-OlgZns78|$!;&<54LrPJz1)Oez4)X5p(&{+N5Qp`I;2ArQS#k_OXYH?+ZoNO>Vu#U&EOs$Wfhk0IV +U{f0jX@>0-8xb)H%Y*LdCRfr-7WX?X#yw*jL{>X?cG*nb$yl*SFQ&A{Ht70P3C)WgMbaW&N?#^=xvN{ +E_Gn9L^ThIA=L_nuXNY&0w=*oGy~cyS>>`dN8%@MGeLzuE)m|^PZK`EgakfK}Oy{*5rt_#s$8pT*y;M +$`Pv${yb`f`$z3hCW3|zx9p6VyDk+F%XXuo!R30d_RZktSPB@@o66dxPr`k35jOzro^Fm{srhjlwj0vX3WK3Io0L~;dQ?Vj8&mUC-_g?!8uph;8vlr>p6IcrK +s~` +>;Ho%Yq%hR(%6PftJ0CK*8kr*x7l5`p#txlqx1xL5MUgnG8`K9esB8{lpE!gI6%=ch$@A&}o6Tr0&Q; +E^i$9QhJKG6$d4S_Nb~SaIb|~VsF~$DL!CH-A<8-Y%jApe7keYrwW%W3hU`KN1s~wnOeM?+B|0IYqIt +cMIff=)WYkFL5x0AA7x2xRc|WZk+_}Yq$n*QYT;(5e??_ey*VH%CTd=2qP>%-Alfxjv=a4tqr0$>XyB +AO8d_Mrv`g2%&-_MF +c9ti_(Ji*C<;*AoW`{{8#K%Co(@2WM0^G!l}qOLpE;aUj>e5#J4_H2PQVALB>(cZd2w4E{^vr4N@rwHP$Y(I!Z40+6n7zfA{Se=5sUYPvLl^Eibd>7O>KcqfW+6ta_@cj%WDZmW_wi +#weD!)9M}Zojy6vs3VgJQBWRMfv+PWc&1MWC3C>}5KTJp`MvcrER6HE-*yDW4?M}G5dyNIxai}tN_RB +5D;&BJzF=xm7IPd?xCHf0{TdY&E$Xgj=T(>e*IdoFgq6TH??XBc7b{KCs+=^u3ZoG`XY9Hc^E~z_%k? +ESj7_&$&fvT4@_Kq*C>Ln8R*|y2_hL>So8w=lKp@LeP=+nVA0Z6qrtZS0)I6^-94u-{dVLd7iVu*?AW +A}0#sg5S>lzL&6xiRx|lPAA70AY$5FNuS!0Zf;(YZgNzlo1;zQgC_AoQ($#C*<0s +zrQhI!j^xv}I>cmnr$TFmLGx!6Wh;x&}T2ARbpO3fi1Y`wth0OG7;A9)0Ku-~2TI9NRrxl2snSM4XV_bYvR^IhW9lh(w13fQ&-b +&*6S9jR_xn@L9yz6r#EWC7U}eaPM|otp372wW-kNd5u&ipKQU#0!zt|rrbWXWa#vGYJ=FjlR^r{k=DK?mv#1#4d;o2)xH~k2Jqf+L7X> +H)=uouptxo2DKD#AJ2x$Ktr7lsp;$bv7W`hnfUXu_fhysdAMMu#c+RqhKYXDtrsXf+KAbgdG_4VWeW4~IAJ2!-}Jg-5mAr5k0TOh(XKUv^fOM +DNZ-Z$EBW+tKD!;*T)QtnrniSM{qz7~hq<_l(j!n_Gt{i|XcVoH#xRd?Ivlg<8tJn}Tc}V<>+L(_yJR!O{Mb1zT;<^%9plCOEt<$)hDL(Z> +uWSay6NR%=H~KT9d>+#ReSPS#ixhnV2{QH8Jq{%+Q^it@C +x@7a#vdfQ50y{4tkYX)&=Kl-^bXfaKdx_^N!x{I-hg&wp^@EbexXgeANs4yEZ$AC3-p?J2zK)n>|H0* +H|55!TFw`2MH44Ehv#Hqc}|RjA8N9OkD#3p8Q1pTWC+u=Aeh+E_b4An)uvt=%qW-5)@nv2I +OT1qqn=#(udl0)_1)nzOx7`t=XNhIT9Wl*(N~ZbZ*5t_|h3Zc>f9H+C221Jz)tGQ=MeH!^^*U19maAZ +!$zZ->cAQ0MnRgQk(e2-^6xux8bekp=T8uj5POPoPwh0W%$W!6OnZ&J}_dejhMdDM@a55~x0WQ%)znz +H<63>YS=?T(s7O_F1YxPW5ks#d88$L)378@kG3K`P&f!1qUb(<@h@7|m<~I86zs+$w98L^YO}%$(y?K%ttZx?cB-Ap$Y +;x2%E2qiYBnrezF-qKZyDY93v}6`4&C$?eTs&54!9r26hpe&aY$ZV1q^pr<<*`&=zbU9 +adl0G4~~WMm`;lKKI{u^>dZ?a`xHybFO>zc7Kh(YsoHf{^0+v$f;|yO48;dAb(V`gXOQ>%6Cq` +n47^+~st;3mi-)VBm(AE>_E9oSWF}8Ffp>iU!jVc6R=bgS{EONi}p-$TdSC*o)V|E)v;6X)!@*Wyo*H +SWc^8|5E+ll9(jJvapo9L<@dqLuVt2wp@)kDG0koY%QrlXY-4R>S^yNHi@KT&q#w!7FTPp +_r0>U7lEB1_O4=o1)5o9o(;9&1cI-l*@kPuoqyTOdGvO9zlD%pv!e`Gs+g$$Ul3u6{&8NoBc9sMXwCk +mf@JJnlr=F)C|3;xwp0TW5#xP%X7cwIf7pidA*N6_tl)YnxFTz!&Q2s@T +9N^Gf1jD#vjSJGEQABLprEix&@C9DwZ~hQ&C;ulj|(vRzjyT8NFG=a-zQrb{im;v8QkIh@YpQ*gZ8_c +pJjGCND63a6(te0HNpkHpx;%&3J`Rq3#K@}$kzRC2{*-X8i5UAWz}v^Um3M)c?L<@f4LCF{Ww-Ga8_Y +#}VL6Xz&8&pnKMM5WL&-cbZSgLkBAEG3nC92gX{6t_rJf8dad$FPdc?p?Cqqq+%}wb`4<_w;$gl5rvn +uju3{)j-4W@Gyy+Jq!!qYb9nf71-`$yR|&-8F&r}Dex?*GL~%KZHnHT-@0 +VK-V}W~ue04N`or1nOZIyaa`93-$6voTmfqr%N!Hyl&=C +|pKu{f%zfLLbl9({Fo7w7#p?bddLvw4>s;MIOHOLv5NTsYQ_Up(P?Rb+L1**ys0Ve`0nLgZ%MeuHCY^ +(`)uz;MrXJ!>ohNtOpc&kBooqXhL!yMX;lw1>os6WM-zdmxy+*2O1V1_{jeK|oJM2ML%uFez<)TUf +<=QlP9(MHY+fvz&%{bY$7wTFP-XY%qdzp1wi1hhCj|4L&;8^rGZ@h-nIB9oLb1 +h?-kBWxc+mUmb&+~)pSv?oC`%GDZkuLuTv^Nw%U>0Pa|deIl31d586NtxNGP$HYduM3W9vz}>ucAqVV +TqrwM^;`RCWpLI4>{MRX-Z%*h^hvwOH?f+gd#fHtt?R&4Sgp)T_P?v)v2sa;>mxv6Er73l>?Sg@R9fn +wTnfj_tuBl##1ZgyZz|g}TWLRaxbWsvqYW8%lAsYEtw?TeM@bxDuIyMI~xud}geo+uHxISZ^hEwf*2L +4ly^Bu4Gv4enH$+W*#)3*>A0l>K09`Kve6k-t+}kIAnPewN>S0-j+3>sRpN{4{tC5iMFT>^W?YX{p8< +I#*U_oLOF1B!jk;UbXfdVJP4ezdpq|`M$%Zf5`lFqY2&a|&uXb1HN0D_*%DVV`BYU=LymIe5TlbZB(^ebChatXdq;X9N@HlU?~>TTJW~K1->wl*}KRMa5(m_1J}~H%Uz*VCmPlzF?GAnVP6}zqb-DKL&Xk-+$(^0e +xuC7O15OM3SZz=(*yEgx>s#~`!TG3bK(etqRkdVK_vgsvkvhkZPVWsU8BTGkb~5>S^gm3}bauTQ(6IKHriAG1WCFf89Jnr*N7V7m@BD3?#tQy(D->tr{HQ#8eGUwxfVX1i|tdN>=CiH#lsEAAcK`YvXN>7! +qw=-@c}t?|*+zc~_TNZLu>{nc!fujO%x$%1y(pE)OFV?U#}y}2_yTbqT$DKaL<#}wz!0#%(4mJ3opY! +?PcTH#*z3G?p}t7VT+AfNTxybNx;AdjDaP`#dtW;lx7(vDj$p0HpS1?SYA+LEPx$ayqNHL_=8a@Z3A< +idSQJYFRJk9V}hv7ePx)IIt;iQ%jCok#CWv>F~Q-xXZTXHE^35f-4vbPqrz1D4b-yP@WDaT +pVzex2g@Mi^tnlbj3BI-arBws&~8hrMvT`%*M}un?<54u1fcDc>9pNm+7><-pqAhs~VQe6+ +?#99dH(pAPpFdq3XH)X7Yz+pZW>1z&7Y{hUU5t#U*ErI0k-F`yrRTlu4^@_I +dq!RPmY~cUx^kyx?QThInZ$y`XzbuRooN3&-rA9=ni&_S@N2gs=-WWF%y?TFT&KxyI9LmZFKe{#tOVt +Bb|a3$zTXAyE)W>0+Q54S|(mPOkSq-pi*qvE|<#*aSooR>Scvtip4P|P;w>uV|i_7KkQh(q%*9O5o~^ +jb<09gODR*I5GTSl41 +Bq)y8hFgk2mNa<1DJ{ZxsGIYC$^m&d;;!d;{+`2>sFD^>Iai?R%j&TcuwYkwp5dN +NBZcPr+9Acg~TCuJqio=)b!-${X{Uk8F0(Up;b5=I1h7Q>r*#v^GRST>sCCquOBYhT)N|CV4aZb%fk! +y`Dlr!I%bKh!#%N^)D=`Nk$B^If6QhLu3O#bS`?Z9)s%eNF;PN?Yay^{!KZ3T|OcE;_7N4~?e>! +SW@hVYar~u7v~hiErw;!#;rgjVTxBXkI((exszj18?j(v4(+O$U(=J{NNozFQ#lT^E*L(KA_L+H6!r2 +P0Q1Gt`zNz3Y1y3q?LBW=nBn(q8>NP%v4+X$sC(aFK$`6?{p-4;1`F!IKL5{wiUxf}IuYtze9T6BSHTa +IS(6D)_j9FDbZQ!NUrkR?zE;qEEp{1@BPsUIlFmE?4kL1z%Heqk{Vt{8GUm6l7N=XsMu4!3YJ-3XWB9 +x`KrYE>ZAt1+_kW~8RrGIFwwGgI=7St)5&V+#4(Y}Tw?o6(kI%*;tiGu +mcajj=}U`Qsb&&|!rqc_%+EMqzmk +d>2Xr8LNzCBpR9=mCEH{d{^EO|@v)Dea_j@rm>SLNPrrCyPFjk#9`N&$nhx&zxgSv*%@G&oE|FQnRfx +R7Q4&Eh8l}W3EWvXFS4ZWTycoE5$TUx6dHAaZZjs&mGs^#(0~Nf@bC9+lba#R!SY@8JX5JV_2Wm%)B1PbbEHH;Hkhfr535|d|RG9)kehAzj$fR%uGtjkhFvDexN%$$7Z +x<=h$b=H0I}~q*?{LGIQv&br|N(ufFy8<)YmxGjHs8$#2_CLOLfq)!O^!`QiSZ2z&>r0ms^pq$&LSMd +7_YJ7qedS{IF()|6bC62jef13C*ba_Z$>ZM=bv#>=;*-5}lo#LKl42WDsF+3YEqwV8z66af(~veERX= +44x`)b=4}5ir_7qAUHrgX+?qlWWZu`JF@VH0$h)RIA2C8D8Yc>JU&)K><1*8A<&e0&rVG*%UUBF<*b%gP{`CSimOpcvS*?fGD8LCPP +f3W%PFL5s1kQI+kMN?rrIV7gp+M*6WMtc1=ph-XKPlbRCCNz5%gN +74w;3m92x?=)!(Dtylu8ldd?A%3I(ud&&tjz$iAJvtD?jq>pJ=PB+FofjS4Tc=b +O9bPX}^)xw#*$=PoC=-p#$dp8Mf??iKaiE9<%cRL}kAdhRfm&FrF%>LK0P_RP#4weOqYpDHYW=GlZb@ +$mPGi;MHdGa!N`iwMT3(|2IAJDQ@U{LEe!69wiweN6CM`NeXT|&Ed>mJslXZWqXdiROw+pmA*fPuF~4H_IhWa#a~Vobw +h&2b|}TH+H%B_`c5I(f|4apNaUoHY5)yY8NH&%INprA$vvv!>6OnQ`B&%&hF3-23zLZT8s(g>&XUFmL +{Xg)B8SpG_D)qF0o{2ll=L6XP`cC)^PqJK7w_Mq0HxeiEtKoPu#SA>8nvkZ;W!J^el^)A6-ZZ&LB;eP +T+!&6J8-BRMD6p6l|Lelj_hL@B4tunx~DlrblaiyPa&UvG0_BCGQ>DJpufsJMtS#Ph+T2Nx9udV5ojE +MB~r1T7+>D7k0}aW|}cRPv-E;x}bVaxyyh#;~F#MHGusw#=M4Q?GAYn44RWn|ob;{J;Jfuloyg{ayd= +`acVmlpFn(Ht<(BM6uhS?k4}-<1cdi^SH@BEw1r@n*IM5JlE&x%>UC8psW46*{6;K=xYBwZt|~I0{-2 +<-=ZIXf%NC@a({QzBrCe>x^I@=TDt4|=<0L_i;5SOlrDbop(SNY9m~p>KfGe)pZ@&FUmktz@h6^qYSq +(!eP;Eu&prRbi!Z(W%Bz3-`)mJr{hw>zc=N5bZ?Ai2{f2kn+xY$mn<_SM*}84}j-9)9f4FDwzWoOd9y +t@-iXPv?KWaPiXRUw*xE^&0=TE6Bzxz?-Td| +EKBypZ@-Tyn)jA`~NHWZ?O!{${LK34f&+ebE`3l9wRJs=n?)&Nqy4N`bbA|5@V($8QyG7r9QniPm6y? +&g?qw(bR*6bDTBTroAxPXV~*?j3wAJMS2O;X96_k=4D_kB`GB@b*73x!a6r? +bCelM%6n_rVLOO_#IBZ;s&7PN*BGMU=m!WKojh|`H%XhgLn`BMPwz_$Yw@X)2PPXtIXIC)AhI9}gaS# +q+@Lt3tNKW#lmlTGAB8I@9P$J9-LBf;JC9DZ~qJc;uia;1Wv7_%8Jz;z(vs2@f+KFkInG&DccI0^Kmg +LxNsv$apx{8^ymx69yVhZ(`XA-ybrfcuTpoiAowH8`a?V?+(=$zo{4yRLtRg5d;Qb6iY8Ic>*knLSBo +amv7agp>4nM{{XL|@Ky_s*e_x}|w@&|OOx2we9*-)ghDy=E90$Tp_gYrD7F8~MiiH}9KFww5n~N)@I7`Zf +HeJi4dVFu%HY>26F>Sb@v+Vq71-Q+L8S6C+T_w=UPQwUK;joW@4-Q5%XdhFND*$;n7JV%%;{kKg{@bg +NMlwv8u}L +}KooDb#00$25P+xQwjaOsiJxr=(@%+olu@jO?A8Hl5wfqceChLu3{W4_>sWL8jIN0XYckd&IUq>Sf^2>)D9x7zMK)(ac>xuOi}Cfhjf@> +7^QMaXIoWI6+`2#?78n`80>}E-w5aqw=u@H3Z91(dKNM^=%9wv9ifcPAoH +P?P6uDsfpF+RICL1_oOOuwVI9VXRJJ)7R1qL(ZN>~^o4aV*+>Nn4WWHAM0|J|{z%<~}47j+$wGCseM_ +6q*osSpuAzXaMHpy)$-R?aY>)XREJb2X4Be_}2rmSUJFl!mvhPBiMvgWyrX*{}%!l(C;@tcM-HnJyUR +b+nIE1}NUgZb(LSb+F;6Xw&eNv;<6mR^J(nb!N{_iiV +L;BRl(IG!SrhFvc2NA77V*@IMpN&jfQ}S!Vg8Bti1YGau%Abq<8M`f#+5=je%{*B%-A3jSfjrksUXLe +UQ~Kby;!}jkclSK+7gX8mpp+-1yZkmvGm5cUTDopLY38M4Uc)6{#lnn1#6vPg`y|vEeVH*WfEmYAzld +brnAg6hZDsJm))j%*#l;0jo1>Mi5DaMJ!`h_zvo?_i)+Vo2O+cmLpkGC8zNZZ%n#nw?@Dk}wuT8HohO +vjpyuVLET^l{6*Nn9pPmuDbO}|#Tk}uSM8gC%Jv|xd65?=&As2mW#LdLtwK}AR?o|17Vz%ppF;&3>!wc_%WqDX}&!oq_ZS$$(3rsJzs|Kb*|i +i)1d<3GdGgM5p1+=D9k(j_HZ_y4F6d_4pR7b)+wAJ+@_y|G^d&zPZh(1&Hue&Ik|pvi8X&;_sb=?|wJ +E*3^SF)jg%YQ5#1WLUcSARMV<5;Gm(xFV}Zk^JE{A#ejA`tX*0Q)-KYIwHw=}MoOE(^$i=f&R!z3RDG +kF(T^Fog)pNnm}IF9$x&-&)U{+GHEk+`4%X)P8LA&HS*87vnZNxV{e6rLy07*-G7o%f^M0(vT`R-?oW +64>#Z!tj$tdL3aeAHFLfyCPWoO4lC=)RyAJ)N4wd|DPW<#y{ +DfTk5pIMd>Dv(U56Po&ntmkNlVOPOX(T`6n^Kr2D9;r#pAD4Hl-GGJE46%9^+|-x!?%BvXH6Cn&lc74 +ETj+g{{5aEbm^XTYZF;EaJkNJrMYS;WBZoYrYUgBBb-_`p|a-BTE5vL*Ke9{vQCw6U9g@76Mex%Uog= +Z+%Hg-V>09yNPdC+{BuKkG^e~sV{LSIv4(KNS;-;2{Ng&=0tvrX6t*R672D!XpBjB-lY?Fr9xB{qSNR +E`yr434xOr|!U%vreZ2qhx)#2@kr)~PT%xh8OTj_I9U!kQR<%&mTj>3p?*TRFf=;srm^YK7_MFjXaVg +6KR{3-wZ$NIW-?oY3fzJ0Z}oas9GuuhR7tkb!+HNlmw4+d7W%ng|4pR9P5Ec6e_h0mXA_0PCB87m<3t +d@r05$U+`e#9eR7WgO9b--`Dn;sEmfaHhjn2z*uN@pK026-g%F)U*D@OFRn7vlJcw-!7Y-x`_(kBY<93|g?FykG|vbvuX9&jR_u73p5j_{)Je%{P4GJ^T(db1|fJ|E^n-@W1Pp6dnJUuUqPE0(ysTq}3K{&@rWRN4Jt-x_HXcEht$T{GLeex +SSC`x(!^RbQ+|HNjBJ(W_?%h<*tZA`WMgyEtgdxUFR)lK9-=%Dh8!UyLzZOR#RG9p7`eNo{2drX^Iz=LNvJMMxIP5kA)y+QcjvZ(>fv}(|Sir7Lmx#FtZ +xuv8qpwWwDt#`I>7~+}Jzf61A~2vu>O%kN)FLI65? +2_}p&QRKB&8{NHhV7EV`BTgv~iYNj(+VmA$z7sGA*t!)tUR +w0wSd5yJYPL#`GCS(_6WT%nL!7ni~6TmX|6lr5{xJU=5D#V$4!FAi&ZP}gxO?-m&{_3-jnh&Y$E5_VftpKm1LN +FDCaWASq0WC+B4CbGW$Ajc8+i++^+NQ3i>1);tE-{N4#t4QoW$2?6h&Y8QHNpcH&{7z%?0J#=%3=FUQZxwK5yt!=+^gOBZ?~u6ErF$u8*wDwrok`MvH1o6$&&NzCZ2AvHe7g(>^0;dDs;U +zH_4*_tOv&Q6s`6IxG#SK~8MXDKRnUa!9>`-?>Rn3Hd_W?_)plrQKc8~a>xlk$mbIH4cJLOEH8*lMZA +WcjDuc+<^IMU>+7@=T0Pq67r06r+#3n=sFkB@-_2l|tm!^`S6JlDbPKnJS)6RY@HjHqwTg_yA8PauM=t#OTl;IveQPVONkicQM=*!h1+#Z#?#h~Jg(f$lzXOfYwNQP9+hr?Exd9EXyKK+rEE3T +rGX&)|w$plv`tV;YW4XCD)mhZopmt`J==C-uVCN^nY*s|5qRI1-tn?l<`y$YYtJCa9jtr24N>W$}SFX +#*QGpg3T24QSX|&y=$%F0vc4h{>l&Kx}`Gk@1*<(D7Q(uW0gBu#Tl#o$0;~TrGKaTcBb;rVzO*PF``W +8DO{VV@I?yeVg(ne_a*9msY(aC;;`KDugd+b!si9`y_c2$I|{%3>itpmKDepmg~qeUd9vL8QP5NIeYK +*)|G3f%$Ls2c|IFjx=p)}78-4!csQn*#8ebeE-#5N^<9`#ymUgsXJ3@C_?b%4M2T5YB;YF)e)IFkpEov=e(^O4V-$S*Cc~Q)Tu0##Ja_WBw(Qh%&gbrKJ +pBdF3fmZ}z{VWE_qdTwJ$@gqUaBAdqhnuIUS_QC0vR*#gw&hYRJ%5|UiklG?TF^O8|&}?;rBXrV_r;a +)o^_OFC>3gf2G>b-$+;)AjA8s?`m;1we1?7?VB1d_3NynT=}l%N7>#<9ygx-J5RFt--}SaBe +fKq0el&;&V|LMG(4xk8+hb&K;~`EZ`-w~dC5#K%?jVz;t4$a21~WO9P{73AOSYEGM+`FwRCXwAA2LZ~ +aH9wt<=y1pBKCj7Lv5#%WP;C2m>9sA?FR`*wqk4u`CACSMMh8dwFHlmiL8@*VtxP!>lkpB>Z)yjT`;OzF4CWTo;uuTUUH<;jHGHK +*Lgy1RV?<0;s=t1&Eb_>By;fy^__ +E3TY!zB-+2rjyn${D$y?nP1#?Y}472<{;hMfSY}ozXJQGX& +oqD(P|(yfcRAr7$*vuaa3p_O%4RjZv~h&_0~fBmY8zsnluQNcJ>>o6JNv*((TsX_oR(NiZ)?@r~f5k( +367nM^RyLOA{);R_ZipMdQ~5kJVk{U~vU2{Zp7;gBSWGvK;Aq^w>V&DiK?l>8DBf)RR$@EVWj2$oiq2ljXb{oMD$ICE#3I3$)=Lv3{MCJzxJCRcTnCvkG +)1Y9_5*`Gvk&@Pvol#eQ;dCmmWG^CkE|qix+0PT~nI`#mE5WU4GW=dEV;g1?&Sc+6aBPO8eLTU%_mRA +j{}O__S<>H&;HX&==R|@rnZyqYlSojXCFKOrm`$)o!b#aO{A7YpWJ|hM5nQY6fW2~L+z5hGbERxgBiJ +X8@&x*gV7GiqgY03L3$zg}WdEGt!*-&T?2i-lnl0r4@F6nG$bShzzXECZC+IbY(yx)Qe2&yVD+pTWN_ +*G?gy#d&zKYPiak~Ct?)!RjquJr_yiX~mi1Rq*N{02S*zb&J3M0O{^5 +C`#z(riyK$05_nC3wQ2>~K# +lN68adkHpMP4tr8m*8_`PNKXJZ1Fs$L3V$FPmpO(x_uSF2VW#PBKs182VayrAJF=e^gs3ry?d4N?wo` +VzCrQ|JHZd$Bpk?ILGaw066f;-zobUOE9Y?eEVU`tN&94iP2Z6?>j|zUv+Ct6=YJCCC9&r}l=AZe!N9#l3;D+oTux@@P +jbHp_GzrBmJoX_GEYnRwXy^LqU?a!Q-JV*eUu&h3PvkC;4EbaT&V0=qyMb317e*#(gZxA`~fd1J0RAh +!VcI|*#VQ49c!WUl^qakdXXmJv&s&L^`rC7Nr<(f2oKmz*|9!!gtGr{dE^-+o}xcVO_HJ(Ow6qnVUBQ +#oKABK*HrW=R+B&a8zkaIh#q_C2gGHj;@ESh}A`bNz$!a7K$u3clQYgZ%!lLMD>Ghg=b-XdRS*jZ3;KsXQZvsa3IuM`x_n}+~r +`Q9rB_}+{3dMCN{y?cdQbRG5dbCzF87w-$^)#%SqWWGbW3l8WnA%1%L73p4x@Oux +Wrytm<+*joLO!B`1H>H1t-s7P#3uXG!oq17&-@Es~4(V}Gq<;e6mu~t#=Z*t=fg1S%zbgkWpCH!-ych +T{y0UcdmAw~`2He-iPKl=gS28Jma(i#w9oS>l-UCEJI{2eM_K)ILXJtPaOO5qc7xxQD+cPwFYP<A?BBmqbNv0_o +1DTE-a_+BW{kP;iGBT1SB_*+OeMNhoabVBz#7t_Yu;& +!oOmGj0lqGM6I;0H?56ZtIcyZ;SWDgT}PIMe?4_K=f9@U-+gMrgbAC{6C?jlaO$ +jt`$u#B_Ef&0tox?BCro7v`SY9Jo`Cc=EJykaIsg9R#WhSwF|`L5bnM9en|9>PQyF#xqlIazj6w1VJc +XjU>KjxC!N%O1%wv8VE4*n7o;**}Wn*^|Z7**lNtQhRX}JNW!87WM&W +w{GFA?+(s}ZR2dfhnx-B&)JlHoW*|3*{I{3jXA+tKA8z$b9VQ4oTXNBHvJ4|#l^*}tgMW!T)C1x_Sj? +Wi6@?5t5&UIt5>gPFTVJq$lo<<*08tVep~3WjT<+zkG8I1i+<$n?HbOuZ{N;#@7~S!?c2u=9XiB5{`g +~d{P=P9#TQ?&v!{-+kIr%S)mL8$xu~kDV&~7EX5U=qtfr=hUA%Zv$O;}0>Wh0(-wk^z^eY(iA-QQzg} +nv(DZC{c%KNgr`4~2b-_IWBE7{xp4fZiVr0G)@Nbx&U{0NFal;S5+{5vWB42)m!0JfCkucG*`Q~U~wf +0*K*bc^4O;>S?@yC}Ym;xDK8uTuOi6#o##KSuGtr1;-Z{3?onmf~M(s|vLH(XJ)V4oB +ZR;9phw{S#j34XE_!nasKY2gnr&lsw^9JJ=+~NmP{LU0Vg5uv!@u{zSfYPd=z8;@L@t0Ekrz!qFDgI` +Pf0*K*a*I!mk7O#!xzyNL(Tw8zP<+xqHPndV#+HoVPVuKu{J9kWF^a#A;(zQGpS57gtPPdfPHY7Wr(! +#h9U#fCVeyOy+{Jj`T*k*d$oT!M7+?7&<8SO@{Ll%v_(qC9km4s&{OJ_Gkm4_=_%BfWw7GJM85Jd6YQT$F6zZ=EBmEzw{@h4OK`zii1ivJSD +-$e0`yTz~jOqGwjS8VKX({Phn*b{q(bq(#@x!XwBThs7__;|B9A$Hg>lX+^du|3X$&xj-j26gk-!c{i +#8Lty+y5DguOy0G*78A8W>26W#~5>M%;7me>*xx3mpX0r0*@Sg%AT(~lLO(6}~r2m&bniS+wM +ClQO2;u4Ys5#kFP{|W!8=DsmNA%W6pJ7PquR;?(2>;2S$O{T{5iK7qPLGN!FF+!lw-t|7#;BAO%5fPV +QP9iRk=qQNjFhYsPu)!u%KTm^q#IUJJQRZOs%h=&0%aM_>v9<4~P91I<9o?d-_dv47PDSeR=GyO1jYW{r(S9CHWA +Hw97>R2Ft9=jtkbuQB4`?xZYHZT5Xp%L?+|!qj#Xn$Bl8N{j@Aew$o5gGLzpa04bbQ^{Qhq3XGYMjR+ +}P;Uz=Suu5u3RQxgRxrGgw2HSE)Y*@Ya+>P5QT6=En*s-ELvcNjh +)%JL~@OHK&BaS_u7t7Wzieqb@T)=MIMQsYwbC#o=P5fH6843wL`skzVsi&S|Pe1)Md-mC9*$XecAleF +Vz4ex855D{EyP~adq~c}v6ty?jP+MW!wryy?D#T>!(dSZSyW&=gKak?bQ2Ydne>cUypW;76@t>ynZ&Li-6u-8f`)@ntzwMO&t?d+TUr5`wZ94&mh +>as{gS+2&yM~rTHHc%7ScJaYuD~w`vmwKdiasMZKp2XyHnTz|Bija`-HRhoqLA$ +>EP2RfC9Ae^Sh;er>zFtqh*(za)Z=6WA +^^zrW))Ku5Bb00h%nt3Dr*1;aF$kn`yPqSv>RK7ZOZRgpZ-cpnfjH1To%F&)&qNZ9!<_X1v+;%US+Y&+ +l0Zs6D_JOa6m8cI*hI!i19P)~s1G(kx;t5Vj9t%Mob`v28%(_#gFns&svCGCcT->Jj2^eCC;FCQ-ff- +r2Kfzy0BdAHJiy=j-pk|Na!g6X(yLKTG}6lb?V7`5QZT?sVvMy6_=GaLSLMDOjb0EfnCx?_ElXin(RC +Zr!>N1g~1$WZdAp@4kE3KzhjD?@4^uyyZ`!npfA`&Yoa$5l$tRy+fQp|uae`C-o8vvvz^R`7!s&E +Y5v^YxK79DEn>TM>IDGi<{!Hc*wv4o4a!UtrLB9GZ1G~0`1zSZrAZ%7vR{u+vE@3zPt-k~R5aRa%Dua +jwM?FMXa1-+s#v9z4ho9Xce!Ar7?>;D3_hJoCmIZ_Iz^op +(>vw3pSh0VMzD);{Vf6KXGcytnAXI%K+lx^ +3$hJ^NNZJ7oQItIKV&s^izQ+<&VG}_R7ji{@G`r2{&lc47GU#B$+$^P80sfi+4VpooXa@LebZB +^|JJQrmr*`;CYdM&4O_Ns5%@zsjvqfR^5Cnlz7lTWh%!NCSip}y`bZd*4de$P@(pDNarW%lBk)HaQu* +h|hili|S6gwoe2}E9C- +w}f&4@7QlCvAG@9@q^_iq$_{W^zPPh&x8U~Qu!MTtPN8I#9+TXOMf83k{-N;2HN7=XVed2_*j`j!GJa9^`z`K1o9am4#cka2~el_v25xcxBhFT?bG;E +JrzmZfS@P$a-V)1^(kb>IKAuo^gLBo}@Ag8ouB>o@j_88rFQzZ|3=t%#)4bfBEudPW4P30~$1=(a}(z +G(^X*zy8V(ZFri$I4^-edH*o}Xikhk;;wHwpYRRmV=6gM0u7(4@=P)_L@Up`WqF29>h^&w&%HLvGEEw +HZ)5mVJ}--mjOqv3D(hxnKx?-aeH7HUD-&1D<=TIKNZTkbHvkM8e +7Psatsl4XQl%hE5`#+Ld%tC!(R_dZ}CKDQ*b=&Ye5E=lE9zZ_sa$h7|@y8D5bz3dJzyZ0~*lg(P)7m>RPQ`hIg +oM(PqH&ZqXpVZowe_2GQ^jqTv;yVdE1y{QTLfn^HDaL}wP|Nt9NeRU4!G2Myy7eWA(!;K75tAulw8@( +R3x8*tZXf$oRCN52Mo6Ll5pHas6JisBoHhPM|C=4<9f^Vf)m`sMjAq?1-=nfS6Jx5Bnv|RNv=yl%YzR-$X|QyH9^nK(4oi3?c&oZ${SW*#`Hzl{?gkuy-;yOuTr||D<3_Yxy?TXzwfRZDe +OWBuR1(GCQ|0+hxAOdgqTwk;!=Ffwmd`TrvJ6QB9?{02`Z$ma*5M`=a#fz|JvVIs0Dt7Y#bQA|@K;}bRkXd(mMJSMma*M<3;nJo1RZ2mO2C3mQ-tpq|j^KpzG)K%YVmQ5WJH+ +Z<+o_+{XKfq(eI?AkWQY}v*@d4^7UvM>qg|7QPd$dDmrNl8h?kROuumDKMa@b=qpzeZ)4(>q>RSjeeN +aJWZ}8YS8Y+qZ8Q@&Md{EAmK_D=j}jA7l^x9JK3@7bp)X)1o|6KDd|XSL>DMz3)7OcHmPtBRqo!4SM8 +>C!P@FAo#W_%e<(lh)u4S++4yKmU +DxEPv=ohz!&&yW4`Dc0HQpgjG#Q!FYlW?Q6(A@C1Ymfi`#9LYoTVNtgU7G&FSJ+O=yRMjzr|!5^{-16jg +&GyH%T#+>bTyC}c0v9UZRCWiO!-CN`X-Xl(ZIvSEKt!!uzas+(d0)OxtJck{4qZ~m0z#nZ>$Pe1uCjiMtDbcUg6pVRzX +EZlDV?gtG9^Ll1G%S)!hHe}J225C?h&x(E;C2Yn(K;10T;dFC06F|PLT@c6yByYScA|HSW7(4gtXhUf +slp@XRI7X1Xs6zbXr#`FdL$Q!K5B)Ip#_8}EnyfUZM*wn#d7H!N^o4-Tezz_ML&B-Cppo=hyIUsp_;Sa=J;O{>ENqWLH{sS6NccT3Q{RcTfeT2FbJVu`ryhlE02c2w5jNx<+jTC*>9D)wX{y?s#x~X6yg3!8 +fq(;SV|PiWgDkvZJ;=;u&IIu1 +v@G@Ou>Z;atU>Sb@%NU*}w2$eNR(myx9%fiWu)BvzyF?di_PXF{4s{Jg~6`-wLL-Zv@r(30A9h47K;o +r1P;18_Ukn<_=*7wl|pgw3e^%w5b`uFJP;=5=^g +C|;_2kj>J2lHijeJAJpFjuy=rlFyWI?vg9@*uwNzV@O1ng{R%_1E{Oj`NpGCW>*)VXhPNgm>-{QFm$IM?Fsc{p|Vk=ilc(->tQ00nxU8eL<`kOT>6C#u44WkGWUOA5W +?$k1=YF26KIwV}d+}zc2NJ_I(2or|2IE0 +Ow4y-t_WkA7#r8*5#!>RU%}jjnB!94pPx2Dd~2keJPzGkH~-NlD=RBYS+#1_M3hDJ_t8EF-M|Gr06hG +BhL|_Rd=pZ4_|-GzyJCZDiihOG1KIlE4$J6QKw*>17o`2G5S|j +7F}cM_2xO{(tRVe@I(L9Dlaml);#P`k#;dC5Sbp`$LLGW$iR +xPu_Q#M4L$ +JB@fZ7RcyPv-+}-!?d*A#1yt@bRPn7?({SzF1U0vNzrKP3J?~2&8$Kx^k`}>)Fhdyy$zUX>%lm};jq8Cx%rmWYBk&1+L#}BaBz_MF1YOjo +Z}Pt=X)E0kKHmE32oAHcPMS`ss9xe6x7mn&+I_Rdc0DJ-U&==qWd>cFy{ajpJd`CD~jDoHIfq?<1s;YI|=Egju53Q}OW`2IYSyffV`o{f!JU)bSpc +~FFurG0Tc2*VQw!%RYA +6BYQ0`e#r3^Lw;y{g==i1`ApF>dhW)z#JUL&9e80f+J$#{Zwx53U2x%*>c0BO}aL4BiNz6OSn#5jKMl +I9&dMmM~tfgJbRSxFq@j8bgc&{-?RQIlfQusIZgcKZp+$d@D(sXLeK1?k4LA@x1%~l|!7{71Q>U%ER1rzfpR8VRUr#V?xMZlt=xh>-u}+DB*lauUwTIQ6dX?8_X7N)1C*?e*thIyuI`kU1Hh^H+rEy2(FkhZZ->F)v7A#7vN>xa|^x% +gdtA5G16bAS9x4 +F5^<4e%zcBlMM@?^yY4%zW1$*9~0>+X?m~>{r+duvM(oR(hZI3$a$%p|C +qt_yp^xO$nj0h^TNhthiZQ+ak}IimW3bnOKPnd(-$G0d`v-_RR{m|8petlKIsqAE5qqUVmX>f$3^|KMwddbS}&X_-Sfi@IPdED*dB8pMSn532i}60 +zTvs>;$w8zD#BR8>#idr_pb;16&|hgfT&8!=Hq@u(Kh%mzS4!)I|zs8s*tE3nvp<*dy~YnTh-yzRwUc +1yRgqw>{y;wG6z`hCSiFwG;HW_{{;hZSAChx7y$dcdeZgtkyVp!cA*WB}$6yp0%eFB}I12TBcC!lx4} ++?ClXlK5x5RV(ALDpOal~$>)>{d>&WOFZ)|M3tWERIj8J9-F?O)`kd{a7D?``lY+9x-(F%lbJ}XLJ^P +F(7Iy}_WcEhM1GaWHUXRw4C0AF_)7g`Frr!jmjxGvCdbK*}>GpV~R!L6&nELaD5Uq;WSH3KDOJ327za +Z*ySmA;dO*1mKLX1mMpg7!Zej1120Suy|{2kUyBQqgQm~Lg&d!@>hkLH^XKhV6%I$@p +X2BM?irUh;&AV6vO?C#I@u6^G(hLQ0Y$)4GmYSpHsYPm~>QLQk +NbOUjYPIgrn{>Ax&_jAe@6(6$s2=7QEfPkCc|w6jEK=^C`QZ>*ahqn`mv& +}sq5;7x}|Qb0?8uTB!`G3k61|&DI=Annm9-kagzWEkqGG{LnKNRGC^Wwo_tRDNH)k88%>s$t>tK@O09{FE~G`YK5a;gYKk_Y&1-?N&{#Sx<2W6s|8M#SP)h>@6aWAK2mtS)wnkH~Y6$uy004WK000~S00 +3}la4%nWWo~3|axY|Qb98KJVlQ`SWo2wGaCz-L{de0olE3S(VC&5z6-&%VbG?0j>+U&;)A}~C{cNY*U +B_i839=bWBp*pxQFix#zxe<_fCMGkZTI%xEngc;6fgh=gTZ`Zu;UFM54~|VNz&^*Z&6K$zsEPdo!*Z3 +D$7?za(z>I!K=Ra{OPlAhVah|@5dyKSKfL2Dak`9_BI)dv=kGs%Dn1Ec&DrCCQH5ZY+5bjLU?boMLLP +A1m3|1QFt-5msUkGT2vW)yDo&7i?l*m=R$aIk6s-fpC5+R=gN!IiTCQ{_~Pv7<@<}1vvYh2<$BX1n|o +0-T~v!gM3I-w^Q@=QWw)&dsj^tUHe9q(QM!hIBt4BRhOgaP820fK@<(V*Dyfn=HchD$Z=X^*>N_9#=W`?n5AiQJ@EdTbV5u$J4y*mH#OvFHI^zo+x$pJpb;~O#PdF^M6zf7XM$N*rq8hF>Dis)s8qZz6|t{~B7}zD(z_sv(s&NE-S +73NCs61(O9gg!#~VY30GPMD5vi97F%c7>^(j(dTvbH?vp4Yke3h^C#3$)A^ZR=={G)fL(dpUYo1;GiR +6o!Co|r*xs1@e3xSGNULYO!h>@ult0{>Hd7rX0zS~==^`|!(nmiVq33AI)V*KcF^t@q>MS#Gl(VV8T)uX?9{fx?8 +SmGA8uHG9x|{>d1IRiJlp_UZ@t-R3DY7KN;!9~J_>j78uNeVDb#H{OKu4M2K%v=$%dCs2ZsfJKpW!e4 +6|$2qa)p_)ntiKTRVy2yZLqi;;rL`=O1)>LvQqIi@95(qvywgI3nvChCiz?Ck-B+}9M(^d5P@a6mOeF +LV38^(Dq(n;V?pgUWE`|0T7hv@V#?+)I+J$bbr=6qY2(8c%1N3Tv^A4ca#e?9d3NaQcpfnFG(3jrHd> +iK^7DNE9T3igdTu<$CeJu~0-dWsiDXNORs5X7&62L^@j`@P_gr+-N2-(CJZyxQ&ehWPa^{qDnL7vDVY +_X2t~GG6un$i?#2cORC!@H+Sq@`wIo31O7rPx4D#@Rtwa@@DqC9yE${16D1ItyRVk4}z%y-sh_^7#*kFAt8tZ#6n9{14^hov$u`{!n~KuO7n$siLo8%Q<@Ms_}C`b%L)ifBy +Pv_v^oZIN$B}Ka{&c__+T&1H$QFE`B&UhUz1K=PO=Ce&ffVtY4QtvFxl2OOX@Hd?FcUl|>{A;Jy&gN0 +Zpg_PoqkitYk>6*I^I0t9UI#}pn!8RCVqfcU7^^G+RoGz)NC@95jYAhD~8p5825*F+;&^k2tw +}05bgB&4WYk2WwLZAj7ZpOHY4LlGRKt=?vTCQ#2Qq{Nun01|Yli?yqu`Mv*)*UFs9N2uL4@SFnC1j|r +PK0@u2fCWB1-#n39e8(Mk{S?f1_0A}i@)oB?zN;1T-W;N%iF8E+tVbSMDuL2n5n)`7qc1T54*FE+rKd +kXiODY(`F&c#jKJ8tx=#!sZ|bJY4R=pvF_?Di#xiyrhl-ta+S^=)+H`g&8szCHXFcwe?8)hI03ozh-5 +U9zJNog@n|McZ$aGGvr2Q#0)ZZvyURd0At7V3f>OyisHd!+WIYxakT8l6fG9wVX-pD6YG+k2!lKMUyJ +5lLS-**onNXXH_nr65fdtiN9*=KPhrvdv!sXMeu33+6vg{VhDGpNel%H_H*c|2SufL|huc!c^cC<)l6 +B0)fRt7whnyD%(52Eyf)5BBm#q_kK4ftkx6F>itZ~dA+EtW=&{LP?UH41!=08|13Jy1`a@*vW&@D?S=>!8a9cktV!uNw)SK!_T!VVq?6)A-> +gTg)aAcLqxE2fGa6@s5-Q*gCDB@)f_oBuVwk{t<)+lFU*VyWjk+7~jy3ak^^$1_}}KpGk^CxI +m^sR4UQNle40Hi97m_>;wazVh3@*Hi014WBs*M7j~lsnz#2Y+;T}%$7aEd0dTe0#&)SZ07Big3><#nu +pg#2AfSXhBfE+TgA*_lEUDpa|4s=+40TTBja$4%oZztljbW +syBPyqk^`Db-k0waQCmhwg^e_sKmd4{H0?y%_(xu4)x$yrQA*m{KfR9xE7ZK-TErjds|0$nU_hx$ulZWr4OIEXy7S6q^dNLxZk?t`&o7X-P=SdQdCMe&P3VoqUG;`Xqc0r77BEiY=W25ot)^)gp)PUM6W3Bz+W6{~hVHGFdu)h-vNBsJS0$E58Yg{JJwGz4-@gBCQJw$aqR4wh4#1tyPRG; +PDiM{AYJ6GB1|Xjl8oMh!u7jrS+9B2BhS+5It|Erir{mHb1b0Q^sk;{_CXRHFF4g)rpLlM*!^l77+_c +WPP)9F)nr*cWp}|1%cly{6s&>4(F^x6NgGzd5J5?qmS1*_Yl#l-Qbn#lW0*iD;7NWXb*pMvCM5Rhj5L +nU-aH+Qh6n2nhx?hS5gljTpu0wWK1fZ43%kh}!5YH3%wW3Rw+}L6Gra9-^_{o)Xy>HxtFvN))Pn^yMH +6-Gf?JT;LKu?%6W#j&};<5XBvu3|6q`T`$nX4dM^NBH=JWQ%Vkl7Pi(0{T%tqKukL{I#rEUPxQmt0y6>7fBsqIXyHvv}t2RKy^r|+Ond#KQ#ISm!+Z-E(9K#?lP#U6m%^`2j$Z +vp!U_1(Ku-9pi9qr06(Mc;+nhHqq-D=?;8j1Ave`v=Mg-CIe3b;f+EHFSL2QuCF0S?7^1b$qOlccR{>HZ8_{CbJO7EuB93*`plFQxh*V>GZs#uU=lqJu +R8qbO}H1lFOf6xkA)q->&1rCcxMKiM*X|LrxHqf{&1X@S}i3o#>WOuNGk;kp4mK&Kn(r+&ZhMoB4gf? +M;z13DnF1C=6l^kPG%hfLN%6K%~DQQYC`h8%<+b%}1mwMpN0ZpF~~9Fb}DrXkzlERigPBP~X}?>m^5W +B}6;#h=FZ%0$Y-+rEsuPyzz2d3)!^r%b+>5(|{XH$mR?s1Ul82R^_Nabp95pe9AlyCneCX!XwyU!9!2 +Hprg3XHmAM>0HgCVH|PNR8!Jajo3yNjdyDhxk*lBx`@8OT5Wn+yU3_ZY+C}U%7C%(uSch_oxgc|aB=w +BDa>t4BKUAv6L68y;yUnuDzb_+jVdF3BV{GTC*;L>TN(NyksZk2?V%gP##pTQx|Dt$%U#smA{^E`uE6 +#>c0{4Lm5XsQO@I~42GGd2C|QuJf5c{M{9+W=1Vy=dlA>1#1w1x1Pw6u?)M@-fSngemeyP3dgxX|uE6 +_(Y19}ZO_%1Ml0B{Vl=Yfx2ZK!}83B!%>W53@wU47^?lo0ppLJdD_86hBCuv7GtHMV*&jbR6fv=fShq +OP2Uq%-Q^QK&J?mGj7x(zfN`rA4OYUf)^*^! +QNyydnr3XH0=zJ5)aFP@BfKjRAzbnV8$ExZ+D-DYp?1Spr^daNdhX_WywmC5cDy%9LEO7qOkpFvNzm$ +8YHvUAh@tdk*Q=2NHGrU@K;Tm+f&6bs3or3wIR-hWDw}a(7`p+rB%aWzWE)Zr1CZaiKwD-X|{AO>jXMZt5c+lIYz7t^z)V-^fpP&MLKa9qUHD +|sY$^#n_WZ428JE0zpE{(3HZTIUnXsLu6jm5;J0m4O<4+gtU}7ybzc#r7*|=b0tFg`D^P(4v^b}DXvF +VXz&3KZ9dxy#q0P${m6wXol~*p3iXyyb0;d)B>#-&um+3^~9XMf)T|h5X#LWZ#0)jg*?A#sjX(=0;+q +Q}pYZX$(ZQJ$S{IM{V2SyRBXgwF9cTko@F=xwij;C +do&3jO-K^6(q3oucqGpoSUE8=+KzT0PSA(@2kekPTWh2$473haRs{zO1QiLLgV +*S5{Lo4u(yKxN&gdQmNdN~uAUoIH&H+G=J72o$r6v^)lgc7i!un>_M?86C92t56kt|$P$%x5Uts&A6K +8tHeu;yrj%^_WN0(`%X^&LpYDJm`=(u8CT2NoJUS~q=ZQ_jw@wf;Ld3#frbWP)TKIg +iL!|d5cftH2+R9N0$T~2Ne~^-O)~hf(Hq| +iW$`xP7&rt9j8Fh0EP5B9)elG@qaH{@#uI6vkoyme(@;9)NyC92y43lA*jV&uHv;`!3m}?3o4{~e!c| +j=H0&9J7K-5R(6i3?+M`hDy^qeLjvtM9;S{=DlgG!8nM8(b;AA61+8Ed<%uGj%|`L~mZJRSxpouAXbcr`d&a|J6VSIKmTpI@iZnom_c~kP!LC$XgS>PnKv;X5-HF-iD;rn_o +KPyVmseB~Nr{;$?f;mjp@9=D!B{8kL5U|Sf<)Tu5+iN|pJi6u@=8+48p8SQ1V1-yfq(~5c@^xl0?j2Z +yVDNhNm~8!pk*|R7wH&glw>V=rU|Caw8C*cnU&+MEN=*;B)=hnz}m4YvE)!@i()L~zA4AzD8}8E#VqR +`KF)wlMCBI}!eHeBr@)Wo)#@;>fDRycLaOCHpQ0Y1pQKb|AIPdk;)*p!vPD$4BtJRJcE`nZK+$0p&0t +{j*&#U-&xpmC+=NyQ;63##oGic;)2BOdoo$jpBi@8+j2A^A(h4Lv{yxc26lblG_-$iV8`#tRH;jx=q? +Y<=*>azlPp2IWALP{gn#<}|+zgqlxXa7uS8QvoilCnQh+O)(3v-d~{&WT2P*lM@DJgi3$njpMg7EQKN +Y%sWG}dAtpRMU5N7Jx)zb{KG8D_sN!rHzJKktP+49hSj<^LS^Cr$qGNRA +|1jUr!RV<9HDG)y?95VcFm^ +s3l!&?SW78nCiU2FUG`V~u=S#3#H!gx8@uuh;<#Htg7&iR*a0Vw*d9G&9W3B9}d}l8MQg+ya{JPzM6> +X_${WffOYeXqce8Bq$rezUMy+pLU$g;o-f9O;e7}it}$im_}@kiBY7m(L_1Ctx8O!+Cf10Y}}D7&LQ$ +{lYhI9Qgks>YPx*^=3`7u!_M4%tng1@re!u0Xdk^^B%AhOd~Vr06zOomM+j{jsfaRv@$j~jhSZoYeRP +RLk5pr5c%Ez?s5#)fy6wx`tB{oJvdfOu~&om{6_c~n|(ym&OQq{g+KAE}BbqjnGm?o+aiUHmeln!TpfCO^CWxl18u +LWbH)35m$iyikC%CLssKlVP?$@kVUF!kUOO9}0Mi;_I2{87dAqX9isFW0pFt5Vs2pPw9i7P;JyJetI{ +o?Nyl42ZLODJqYTu-63Fz2H^GRm!>eo)yb{fp0#xlqy@kZ@~^>e!Gzn +{8h)f)4U)A`urxOD0A1GCVMrTB;gGNEF>Ky&Wn#?6OoX6?&$rr#w80WKA^2BrLkM>B8t)MH8RT}=Hw* +roNMLJ%!$*ex;2uwM$sYScH}Cf*u8kJA$1^^^1lQDwb@(2r!EF!gfyi%#hANAu4r^SeA34Ldg1n=x9g +of>dmNAK?v6aaL$%JD{VM9;7=i%o)GA+nJh8?_$9<3UVzKJZyJGN>UsvcUm~D10s41IB#aOnjkO&6e=gBk9of)rZ8-e%#o;mLUp+TN^z +V@&O{cCfav$6?Qqig3+}r56Rq`$?sko)JxD8E`W;m^9b5*(PFbhN6VIirZM-?I5k+8hgT;y6G42y3$V +Tfxzf3}ocgIyzfKoyh^@bH*f!EIZ^Q*_b+N++J|Z0noloC&+P+C!8Vx!6u$Ze#uVQFGKXvm-XLLDqsk +7xB1~QEuI;;#&2bFoMQHyq<_hg(-x&efSv7>E5DktE-ESLj3__Yw-g>o#%lryFuUK^MhZ=e@H3D6du= +`63ETn)s^5e#r5FVExJ%+*MRz6J=k^gDeJDsIt)&hQ-d3Ln`jpwnO|L<`e9P0>AGhEKNJ(2n@BU&PEt +mEXHznot<6^ZTBfETySzHql5k>Lt}PFp;5mauN(OV-@nEgFb5_XyING;5H^+SO@dNwDr$#|i2F9!bd8 +3t=fP$~jl&$L?sZ=}aV6Hc;k9tht1G*M2UcRn7OpVC%LOg%1tniL~S>40;pK +_^6u9$UY;t|kr881ELeVr2Z-l1}u5%A01~v)Q0rMwfNdOnV +Nv&?d0hl1x+mgqlWd)WW$qfqxbzOnVujR +zjv*yhMax32Y&qZ-grKMW~DudeQf-WBwi$c)?+mVt2Y=h&kKs1k%4A>%C|4?a-xYaAwd_(77+xaO@7k +o@w)BfrtXk%sSXGz@<%rr)Z3hzW~Q5^DLdvU1>6X2{xAqoj-z7J<)(`8B7fvqW}v*(Gb +#q*2JJnV^Mk(*hZ-+26!~GmM+CoH_12lpj@k7;Z+DgFQN{v3^}_6h&DIbgpzaAs(`dRVWUt#DcXI}IY +VMP?wJ)h56XWwpjp%4Dr1gy+KQC2jZ)GJb`=H``<#^}X!|QkjmBa!rW;!2z;{0M%UMS;obuyGMXj7$&dmzE{Gcoll%C|>s!D;#4=SWzKPUn`8IOi%lYXrgxlttR~*g8orkrO(n*e4f@kpX7 +SZ907f<_}_I_WH^CQgD>m-Xr(Wk={IG?!Jfuo>tah?R%9v?@Ma#90!GASu}1H+I_$V}O)8v_Y(pZ~P0 +*a(%#*W^ISupbqas@uTM25Qio(*LSG=w2@Ddz)BPMK-s?){YKPzMFuQW;#-Vqexf(;ug4BB4k!R|ePUvj3#Iup4r=%o3eEwzMr~5?j9X^N;$JOlfiXJioh7SXU +28Xpv8`kuAmX#uyIt(t|JlGlDqtLg8`*-obV*nP{*_{;|(-55i>q)RvzRF6S@`8GrR|(MesMd;#9cow +WN{X#H;+jRq)!HdlTO}QtSS?1~nc~y}P^U(fxY}54>s25_Kk-N}d0lh^Z8xM;?i3U3^-!OyBN8IIepV +8VGJ>6Pop!EYmELq+M1uuMWg|sJ>Bqyf==}YgH%EVFMQ9#>%258R-z)zHicj+-&FK2u0{K&51a;Cu?n +}^@hTgM*{KvelRA)d{NsOh&b4d+yOesO{U#V;;Fhb+vCQ{{ykqppS8euPzc}{jxes7=G!#knrwV61@$ +BRRn_Ht}TbxT#LU0~1qFsi=pP*{S>C2hFS#KFrWG`sTcCpB0qSqCdXDFcGSKw2L`HX}8;AWST$RjV&@ +!4aX~d=^)Lj5!^Aoy5g5F>j@tlVxAtCg=wrmb?8Z_%Jd4g*U&0aUopG`QNx=kmXl7J2W!`b!l~d*Pty +45OLs5T9uqi`)BMDj|t(l?)Xr-utD_u=J(&yjXU|+<=c>eG#;mM^B`^~H2CxR_uod}zSt7(H|qccKmc +@KkXUeYXSWB5CfnIPK*A@kQlo?ivPD~qG{JQoH``m@pht}7|GRycg@>32xfY;L5^M(-mB)wGf26s(h> +@Ul>NF)TOQi8VkNj{loQZ6)oqI8_I?W3l)&d&h5KTh#+m81xD=TFU9s}RY7KIA1*8&+b36vb^=5B=zc +}X~Ogc=d%#o*i-8%d4mNX0~hqj#s#>DeK0Yi)2Sfp7Qwc20QNXO;ldj5_v&8=MFPDbn$3Ku7&+h{jL4 +^U1(Wgk4|Cq1v`?;M=;(*j?s|@E7ljvZIp{;BU-`eq$St@XW9Ir +KPL!fj7g+Xsy;mpiP7f}QUcNnyE)Kpw=M$y2P=d0`togdf5{w;$DZLQ-emRL0odHW*OJqTcLoqMiBh_ +S|-*cfpPgYEKZg@%Mqr1+s%jlhy{2r=7_XTnCa=6Bz^(42iX|Qi-NGOy`-^M3zGNXmgYnxx=7q$A0xA +4t1p{{uM`c@b_j`@E8P)h>@6aWAK2mtS)wniiGXZ*te000sJ001cf003}la4%nWWo~3|axY|Qb98KJV +lQ7}VPk7>Z*p`mUtei%X>?y-E^v7zkHJm@F$_fS`HE4_5CpyP2R$J12Pm6(yN0Y&#SYc}Jubb?j69>~ +7~@B;vyr0oD^tZf`i{@Twk|k9ElbU#qVY2FVA3b7eSpPiNN$))=+cf9!dWW+a-E)*mQ{Vz%UGur<1X$ +7d3k!qg8G)emRx?WeOTIAO9IZmDwS%OnlA)aSVwNRd?WOm6 +nf@}gG#1N7yaiYac~8Wy_KJIwl^N+HG={s2%*0|XQR000O8@1eFvuZk~a&H(@b%L4!aB>(^baA|NaUv +_0~WN&gWWNCABY-wUIUt(cnYjAIJbT4gbb7L-Wd3{sCZrd;nz3VH81cjX~F}9wD0y(Tf1_T(=p-E4}A +jmSEXj3FZqPO_(C)rW!rr2~5P4YcGKFL#9yjy^@l`@ArXsKR&iWxR#Q&`!ibLwy;$X7GC{qXS?_D6(o +9UZNKovrDQa0p*)Ybrs?nj(O9i12l@T5osjg3biORIqy3?jJYzPy2_*T}*~PHknNBh5Xf6M;>bHK$%M +YR#huBNG-fa-(&06$jI%BfM86WA_A;Wk?%ZXoC~cvhb4T^q>xACwX-MgZR;dva|lVTMXCF^_GrSunEh +akk?ZalgcSi0IN`$khKAu;VneX$>ucw%8;}*&Z@crRD5i?eu<_bJ1OggvXgd>&xe9~%-gPm#4Rf3IX88W#oe~#2%q$sb9Ct+k?pFiVgugtty9 +AsHvq_3pxGm%qeOL%2s>dWJ-CdeP1uIlm0sbLOfN9ad=Bc-Y7#c%yD7EkW~9K}Uhcx}Z2DW*e6cq*A&L?%19gl05W6%04D$d0B~t=FJE?LZe(wAFJx(RbZlv2FJEF|V{344a&#|qXmxaHY%Xwl)jVr&8_A +L1^(#6Q3=TK+#MT`acV6fYj@L$vBx}Qu>|O+c8j?+FqTviP56kr4{`aeAKW2uK)(LQkKG-CuySl2n-d +#PX=J7X=&8k}G<@TBB+Rfwtz+X;IPfpE?YJaHn?R9IC7c+DAS!e37l!+X>FUTt5+5mxiPR%1;5s +2XWI<0&kT_C=WGSw0JD>me7CRa)>MstY7YKmo3$sKy4u0xbf2}?Mjm9#2EXdKO}We3mHWD?io!C2`jf +5evSLuF0%@}vi9I=K>%+4X1Ap>h`Q?nhE`I;lv&H+5Z{NOo_u=LD=G=U!J9}b3uk5}xuW9Vdx~}SH_3@3Nx(T5QTT%;@a+3Lox5de-J^`-_(^oHRx`XQhu-6XCnu{SYZ^o +JCojuSd0mw|Tk?+1cuV&%LI?JFd29}7+`BAq?AqL3+YG{##DP-lbJDzO}D8UiWy +AGSD=Fp!73|I&~A@{2Jm2TW*SC=Y>3Rw3`iY3-{*TfBZU{zbbB9&Y6e*Bc4(GXRadNO^`$iyz;v*F0Q +sHG*1rmJDb~-LRaOez8h}JFaX0IOz$GOE{v1P9H~$c@@-_$ah33(jTAGU#u|(ib=)@dM@FvTPhH&tD| +0C>Bb=wdcs_Q=he*;Yqhd6Ct+l>jdJlQn$YHl{`rk$I@mfQCF{OPyfJbiNZ@17*G=VY+S+Thg3MSf!q +008T15C)3Q@Bx5Dyb%sa42Z(hXHGko-3GA2xhe8E;nipEdA{MT?KaOsjWSCZedB(?CDPkEZ*2l2XH4L +t0Zt$`2~h__gqTzGH+k7s&Gp=TEc4Ili7a)UHK25LBJO2wrV3*^^XohI>tAi#t}fLnrNedIXxXDT?}H +ucK@m5>h(0e0ahLldYtd*l&&=xDu5QR><4OkCM5SUX1d5W7f+^Xpvc|d}#8)D6vza+Rk8rqm7E&{t#S ++x#FKqUUSXe|f0zt^{*dHPT6-W%;zp~nMcOMm@)5=J)6?xrMb{Ymv?Mo(}EZRv +FOl}P5H1LJ2hxw&8~vkDDef*T!E^h#M;lGxzT7c&<-qYavvCmQ$Jp37|v8(EBhYW(B{8^&T4gI+Xe`- +pYj!iVQD&x-~eZli1hv9_4`+^U%g2{HJWyTUV9d===nVG7tHd!iR?A<8Ck=cjP?u6S;?HA*30S4WDTj +ZU&fCj+cLe?QSdcJX51VFl7<8vlQev0mU-LUA#Pr`0gu%+ObK;5+J96H_k>`dJD&de&G#=umb!5;nV> +SI{LCS*V8@V$z>A=RtZpikI9lcgJjKoeEdFm(WZPzTjKXmO9)f(IHyth)@&=&NZ%moY7u*CGewmGf8? +bteQR5SdViXuqeSJh?1WU@ZJ5-w1p<%odqsm-7qTVQ)x7R&5fLDSVtr$@507$%i^Y(`~A27lP6v6-YR +SN*6G}ip)oD+`JPdTQFUS#gHs>l&9^vPtkCy_vTn5C?sn3%0?)8-`y9J}m*kxb_EI2jn|h+6x+fk8=Z +k=H6=G~#bnE;_BhEWur%tzgG;66$o%5e~K4Q+;+X**$eZ(jWh;Q6HNFroI>TC*SBN&xlu&XM_6#`XM? ++k~$1DL2fn8N@fBI98L`w0SqDatpH@Z-q^o)wuH1CBK&PpEgv`Sp`d7j2GI;!2mLKA0tN@vrRdh|b{l +0K1zUaeIetQxGyxlV)Ota`W3qYaV>nPhnT=js0rhk-oS)jytu5Dyr28o#1yd4wHdg>Muj>*THMUJ6II +}Qt>J#EclbEZU2Il0jEAsNDIj4YaE~uSjfIX-23oVPBlVHzdg_mX4S-Ax;+eHj6$Rr@4sT;^fAh@6qJ +nI!=jtIOTwCg~2(ST(IhS&!VO*mS7y%7rtQxb44)e2UdV-Cdj5G19RR0chH24M~W1Bn4hO;t9sIDo;3 +tRgrNtSB+$vk*vIca~VTtcrYP_+gHMY}tEpg$U`vdQn%PdXJBfsKg21f$p*jx46`Xw*yD6suBbQ3}nU +laV={P%G6*vbL3vJJO4U>fk<)cM5J0| +C)B!R+y4+QiOr&-R(nK%%JeO*BesN3*ARYz6Gpjv!;kZZ??mRZNG=S$H7V1*Jwnu?nLRNN^8h*otk3`8u1d71;i4Syy%Z1n)svqOlstpS53O{Td8ck +|`e?Uia%oLS+&P_8=7x{CO`nQEwRtk&EzijT{geWH +LIS;|`a@s9I*T5p(Vwr3>exu_G7(=#6_4t-ZSNj#fdh8Vw(e#++PC?hur)RR$ysd9H*EfelLs`gf|LpoZT0 +s9fBbxMQ);BWR)oDHF(@a{rZcJZQZH)F(7bIj3IUEN?%*2V5B|lZ8M7KLpX2>)&@dmVz?}VWd% +O26KCS628$_%mrCLx5ZPR*^H9Nxf~V8WV +$A0-kBJ$QYfL&`i{)pMvhpdOqYC +l$YL6=q%0TYP@{X2?xdCNaJ>4%!EnuNpvXf{j-Ln0=F%W6rHc6BQ5#AX7~N$K85^V+4Vb`Xw>76vzy +0<kXes8Ac@KNtCncQ&@?+;kxZ*+Oy@Xo0z|svC{xdj*jw#FPjw; +^s*BN$d>ifM@n7Ax<@p6LCk#xao>wETr=lraNLfDS#sqe6%CLW?BR9dzm320hlMDgt=3e?_a-5Mvhm+ +I_io&3+ZfQ;O7QLdq55`R_%)?Cbsl<5z^ZkHB=tSvCWClP=od>Wq{@!lK?rebw$)bTTjh%<9?r+Pg$K +~ZG!Xg4WuF17F6eZwy7;>BnQ4lhNru*P5auyY^ishLeAMW7|3MBZFXp|5r$LwtU>MB?E&So)f$T!ebg +ls(7;AShpmGmFny~DFQ>?j-Rr?AZQiiX9lAvv0+xfqfMDeVnyReiNUNw;-2DYa<&E}XH2E$svRdp&CXK8U7Dsm0!%#C>&@;{y29GaEp8}Ilo}PTl{Zai8!p= +AJBS=G1mUH(Mb$L$4Efb_^uYCE!Dk?AIo7`Cz~sIIe%8hxt=Und<5FBDHXWc4S&$`QV1sly7wV&t5s#|+7u70g(`qJ0hD_f=y0sG0U;91q7svVv0=?7i%5;^NgprImhL!PO4EgW0n=ZPv4z`r|9Na7c>kYlp+;Pgqa~y~3EIX5N0I +cA0zQnX07`Q{*?!6Qleq!svaA|={sh#hJ}m04gpUKW0(y80!J{0flAOusqS|h4zoPI0beXCM$sT-IzN +EuaUf8Z@*xJpZ6jiw}J@dzbUAeYgC73GKQ}KRNg)!w|1)LO9VG?%RbR007o5>P>J)2O%kBI4fqG3ute +M&S;qf>iKJHbIxorvk>4hPXI3_101LR(Vxl!gzimR(-7bQ*>`xUZ{E5PYrW3`k-W50{`4wD1HaJd5et +eb;(!=`d~qo4Wm-n%@G~Qy2#%JBIIzPP+zxpgmx-hgiL}ZYR*qQT>TNC6jdfg;_R9mtW3Y>xL>->oG! +Xe2b&%6s*4pVV|3yr?@@SXTa?*(>aT@nNEM9;W~5yI7DLs4;Z3a5%=u}{YCL=7gO5v=_P=Ik7rXiFkB +}ZmC`WDL#Pi)?p=5ifN9%0gJ_bDvMfhun2pfkn>$JN=VOYs0vS{v-2?m;lIsw=eu?idSN3RLAVIj)g$xh%WBWf&v6JNf5W`2J1%OvG_iGtF;O>M!KjNi!|h};w<4rMQ-Aq6w&fXrdDXAv0C< +{*%RZxkzqi_F~4kDPr3VB*-8t;xieS}vALYN^)a_npo2aRm*%q^NMqU69+2F%9z +r;1C=+Ey%B#S?<4;9Yym=G +Y-9unAZQT*rofe*ugmJgCT@7f;wtd&*1DdP8*BGme& +%(!o{EXCGFpIpGGJ})Bfv7{NCB(SdsN@+@9uia*c=G*Z%ds*UxrZ|{ +hVA(I0o{#^!cXzy!1Si|Dyi@5Cgh?ffd*erk5Bl#FG( +wtW>ptUsj;s!^Jwj<2adtW`!&c16Kh)9=MLisrN*mj>=-Pj*h=Zu^Mq9nt!EVdg`3(76qrX3hy&cDfBhf;m@k{Jo34dX&wj8-Y>4=pZ%@%Rn +$R-wz=nxl$}*uj8r(0H4I*^((wR`GKM%6rU+-O1r~Tr#fOstoZEYL3@je +f3A#4|C;Zy_alixPHyj5-Twsv#JL0b`t9QTm#_Zx9P*g}Bm9$74L;`(t!U;h-=dydki6ThxN(~?QUnZ +7@7&z+o*=4odQHTOW>h1KYpseB>E^HnN*L;km}JIB&UkxVmOFwB+n-+@0e_$P^#3Ap3WR4ewiaSD7In +qGYVrKti$A>n%ge>9H}C%Z{KI?9Te-Bb{esERGm}I$n7O$~!d#7W+}Y)v3l~!?I%M@@@)5JSR6QOBi4 +$1@#UICDF(h*jEb^Y0bobd;XWS2!9H_#?@CpNAJhG3MkCrTJdX8{-Lw8Y6epl +d;08w$}!IUObw#%fFC;ZwR~Z5=Ol2)eHDgL|Q`JRga)wB$2)-+pOw*?_1T>z3SrUz!M%?%cbXwv&)&& +c>l9DuLpm9&ZnS!JD~nDTp?|M+9bMzAy1^qX#8@%Af-Js*qYPU*#dh+q)-@;c0QekEN6gCc-5PM3Ny7 +T+mA_PkZ;tHF{ACtoH=CB1MpT!ccXm7#%c#X)3P#}ur>#Axo +bP>y-k&JxxncmRM2dUpz9Y_QghF^lQO)1>N6fCQ?mUR^rc2@*xy0m3?BAI +wKX*W5Yxm61Db&VDRbs*g{Rz28R#(inDbkoIrpn4`zg;ApTy1Ta-4>Fy>#W=&2`nlcWa}C}(Dp?EpK<7+e31M1jO(%dn}jp*t0--{r9*e- +p3w5ZM)=IrZf?cN{XCWBAk>vl5O^}R@DqQK)2S#MXC3A~;Pat%UgW9}4XUV^G=K>=P^u; +5jWV{Oa%{L5C9CW{aey?OdP`dAs@MX55_B#=BRkK0U3QMPd90k-ap>!!p{3fff$Vl8pI>t|P?_bEkEB%_0KCWe5Ez#xv_b4+3$U`BQH0|gNJ$;Y7I8mHgY?`sZ4l%Q{FY0`q#4*+*5J$g!KRhW8HKq>-G5#jlL=x6b9MU@y$lqg;PrLfl@p!HEUF +`Ic1{Gw>@NdWC{{6%4mlC`2tQu*C~6PQP>-Gf6ucVLy8{pi38V(R-oD6NT59kbKIAyVdFZM`UF7+rpl +Ny61&$buT`hNV8vfDCv}mvSt((!-49~>y6`j<%#MsDt{075DZ>!OKId{WlN1%^2CHbj(NH+EqO&bCoP +tKwvw$NBeH`W7<1&sb3_DF5N(0|J>XJ2PKU~;wmTfZ4B=DHXY9q}Qn@3ANmTOv&lPSz+}8#`%>jKC3u +Q=tw!yhApP^IYaQw)Y&*$ob_3wRNV{unQmIe@N(hJ0)j+M~^Vwu_FUJ4&i|ZjsONf2VjmJKGMWH&K`S +yH#~a0;D+EMxZay$96xbfU`JFhis<=?ug~;+0ydiOVd+MjwViEp)5h)(ae_@gA^7g^7{u?#9@kl^#51 +kEO1x;X52#(l?{s)1#psOc75{0iVz-Bba8-mJZ_ +=*DA_$VP*wc{1q@L^oI?o}d3OLqg0*DK2Qv_GuL^5RG8vZM%u+U!TE%|^+xng0Cbm#J%~mjZ3j<}*^I +eR>%^9oH$WeXjGBg5;TJm$R{6t5ZB)!5kIcq25Dn<5Gm~d=u0Yduh7oATsYRD;8FT{00r{s)Jbg@6aWAK2mtS)wnlFj0Il``0021(001ih003}la4% +nWWo~3|axY|Qb98KJVlQ7}VPk7>Z*p`mb9r-PZ*FF3XD(xAXYEzXj+;Obyw6vRlxt$7+;hq)QVx+eIa +wAOpn=xnX*4}-j4bEd(>&H79&6ZRl#Au*?&_K<7x-8b<0UK|qBkOBFW8?s)Y?cTC8zOR7H|gZ(Pj-qlYBV+VjP;N0RE^gdF@G7 +MW8E&q`yf~Yqa|4fT?mZgayUzMfr444XI4&FFF7ptHgNIA1ihN=R&Ruj7Bv%DfY%gUlV>|{KayWSBAR +-wQ9Hu8T%6)+ONSiL6MJ9)!g7<%^7Y=_9e1b#;%cJxHTL>S^J#qwXDMza4f?i=j8lNm4)#GpgC;;iLa +X}0!9y?N)tbu47erS#WumCjf*OQfx9oP;;$ycv@jWWVn_Iaf5(pIN4=9Pb?nlcOA=3SI6v`u-d=Zf?A +WaLz>TTm#hLB_;h`U)oyoL*F7La9cS%=Up9+%VdJ@(~W>^2#6_$0qHfMsKy24Bp@#lY2)hv(l0&~0H2 +3tXcDccb1j=c*%a%{jqdZNd64ybYR@6|T_VRKw|^v8_CQbKRIxei!za&3BxiyN_v4z6Ms0y&_jp&Yx| +y(-s@{2$GCM3eXurcVC(f0KLOWbOtl9~rmLrX8m2(f$`uO9KQH000080Pmr;MiDJ^gpvHj=;lufR&lBb7*W;<& +z?Ter`#oz~YR_OskHd$w1hD9B<=ky?WE$M$-E`^^jh5+Fg_*>>-T)q8Cu5*Q4C`JMsXXQO8$7G<+Iz1 +(JHF(19gCu{w+KHJMycX@odD44%DU>h%9Zm`n@XUBKNB1_pgn-@1>&e_|nOlM&cXK4VP#+SeWudV9uB}ZbVUkQHY=@muFYl5U6WM06n9SpZr{R)&!`92|Fn2!{=Hq2}#Sw@T63(spdxDKb^Qr +wH2@70u>ly9MIh%-Z&L?`^ef-}*u4c6b_{n)u<|(t=(Ob0{M` +L3nj2^U`Kp}J7`+(o_s4T*1!eztB@yXGD9qgS>-t3MKU`G^L1V9XkzTd#k1~C|{@kA&{{RVs%g(;hI# ++R$&j=}I@etCWN;({%JBBq?DELw!=C7%%|DBg*Mf>ovj16Tm2k;nWRz5|OPB5ajsmwC8kh@f*44WwaC +uq)Bc%m;*VA>aY_Wji~pmli!jptp*qWt_}9ga +#^^fEK2wrxgbbh{y&d;x1D7}2~r{mPbZTJ2D*5*k+9JN0kg6>3QF +ep#=r+J92|$x*eu;}RgV(ATNeZ5dGUwG>J=e=5n*v)@&)3v^(yXW-)+mzr4}zSFtjs~tXsJDq( +;3KT-E100SNI%+VRRKmU>pQNT(p{Q>GEVei>wy!X?=`-5?SYc*f_Vqj8+wP$u +mBs3}SiP*eVCgR)4DhCyG3#+4kFEUU=4KlHY6}<2z80ZtHQBux0cK=P}5s>@u>xb&u;E^y;W0`P3Xnx +^QF%1R(eLVm$);?%zBbo&QR3PDrsk?)d@W#~bK&z9FyC;*AgX4G5H0ME-Emz1pxp)4XfA+WEE}s1`IR +70-lLUOb0^u={1S@geics^*sf`TvPR^!a0Zwz7$4NsVysoW%mK00C=lqQNtLp^ +b>^@?Yew~+pgbQ;zYj(v033@Qvkq*JyKFagUwdhYsjv{q$HYBeeJIHvdBKZ8gZy#IOwf4qIxK&STrFh +EaaS3vz#xpYwp;IHKn@K?1ssW2Gg05pan2_j0#;apo2ICr4JKBg^qlS>?!-Y*0!|)^{i^BJ8Tw5g>P- +V>M<}#oro~!z#9=zFBs6#BAb3`tdrDrOur2-^Q>I?F9*%_r*?o~g++V0mE^BloME4fHAj=iXfF(;okZ +cBX^Xl#x3yy1K$KIzS`xkAFnYhqtXd`@W_|Yd@YDMPHUqmCy^G|I!DgZTr>tSN;5kU4xDZTwDxl`TZa +`I&fP6{|>Br1?5ylC^%jRrP+JHk=3U0!hptr-2DB#(G->S!`NGBf;PR55vA7HzT4uRB8q?e3FlkrbSC +#QDPv+Y-oHj@uWll>!XYP>?z^||$61G}Caz)~27a|+X~Ol7GCKuR8bI@o)lEn3c#ssnh2Zx4UOZ9*aZ +Axrt%3`rRZuL +T-S1L|LPsS5aaK1Z;3Gq?!B0cb)Nqurv2A8(OrpF7{(y=z20nx47k~?mwPu?LM9tcmF(^4FVgK9j+BU#fNLt7bm +SQlPS&M|PhO7}j@U@a?&%d&+l&B??T7H8j2xb4F#g!IKgHOV&*&*!O5ZgTL^A7TNuT#96fp7=a06CHZdL~1*)YHw-``y_KzS8c^32~a~ME7O{9qHde +|Cf;gH13%nkG`%%qAQmS0TW+ut5*VfMd(zcFS&yO~984r_MV<%_-BF^MXTV9q*r|H(CUse!tn5}>eNQ@1E}V2B^4u|JyUkMNi&ID*B}%a64L73xUnSC7 +0$yPt8olyL8}=5TAwlO`ICY&vTg5O_pE53~Z60_u=iy?)!sZk4}E>SrlJ&Y+2>*$=x?W_at2tg>{5^z +Kf@MnBQUOL1O_=pU#4(vmSfe0@D06EvvKbjf;BC+UUE`w$XK?sY5K93uFLP2WNd9oR!jOhlso~R>-|% +A$zY{k3?~oaB>usS+Pq7Kgcg*2E +rK%ZgovP8QTZCV|rEM-ekpzjO@Y{*i6W5Bbmmp(h;mtf?98N~SvdXk`li6Yv1qRhwOnuwQi5~9Hi^MW +2j1%S-6ESah0phy-iiWtbTCfd`Oa_Ef +{(4{K>iRpFwYcaiRVtK+gu}&HfwC{=ao}|J~r*$LMtMJb3*p&5HT~Jt4bQrbB{k#Z!accq+3xJ04|qK +-_T*oQs{FDB;UxSa2?)aK(ERD4N$OB;dIs4s(hU(J$XH9Pj~|miWT55b#ML!1O5uBIbL2j|8K7p2sVH +KpN_y0KpP{5@VAC(w{!UvE^c-?R(G_w22vQQV8~*P{0^_wB?@K&a;%P!$$~8D^t>(SDb>?*AAPhw8=-56^+b^J%8YE3_BW=cQ! +OIZqEOSBWmZKNCS{o(zC3JA>ed)zRD8mL8EI$jm%g`5{trDi>R#oO5cC1+7XL{%ma_sW73MzQ5h|z1I +%lJBu0q^zL^3s#RfBw&)49*6HW*UEr<$MU;czMBQgXb>cR +)p@|aXDl`! +LIy~Hbi4FixcjkmlEx>icxJ!}yinv|;py8+m>0(E)(@+P)W`_)2A^!Ig^fJp4MQ0a{yv(F@kK5(U*Fy +sv#)Z_v$RXQo9wrGTN+k7CXS5RTTLm*HaItm|J}o-!Sll`Dv7x13kf#TjsOvNbvCG-3?F;8fj>vIi7F +cxPdQIp{k@EZz+le20e>$Lc2}=W|ioB}fF9xpleOT_^Ge@-j5nnfma9&XEi+J#C2^)<`x(jDp&Hu9P_ +EPSjKfov>A@E#+>)LdsL8(pm+E~)1inX{}-oM738n!td(zb08WR3JV&8t6c{GEo%nr8Of9nABr4$95<=G0wF!)UX;)d!>Jb28*q}AmSyL{j7_9WtIHRsaY)Jyfv>sj#qIX#_d-7y2k=yN92KDl>?F;0@Trmn +3tj?iDv7iPI~N#Wf%oYx(!yq>ertjqs`9sw;xZInMf;YdC5_WVO?fO~E0&S@5*pWCe<%eQGdrO~JTID +g6b~Hs?{1>5yKx^rJ)vc#z|tc25rWJ*jr^(VP02B@ogq{bNGm!)YxD1h_`iP{fg*TZMS6w3fo}@Xh|g +_>|CVi!-C)o5K(8wis4-v_Jf?_wJYdgX6z8n#Wf0l59IZqDEe@x|?~%^Mg+Z>IJ{$<_jg->19{S-o}0 +Z@WeB7Xpb#wr6TWDIZa?CcaIMR{FZyx(fg&5O}|SUS)q|pa#PgcJvm5x2r08>)Tn(te`fwu$w~Tt6J7#rIDWFpA~#{`c@s0%S +ZT5NCb^Y6J}rSSZdo=$EoSXch1Z`yJ~D9!r}&{_pQ!u-51RY~vD2+cG@C^#+D<2@ta* +Iug{iq+9!VAd^d;b}`mmz}A4Vku{}0F^b_JY~>c!BB=DP3a;P9Ci{UX=)o%jV}Y1BFhUt^Nq4nU3oV! +hp$ggJbG}cqwS&l?DqB+^N%#4BA%b%Y=qp&orNnKz-u>q9jC~!cTU&k{(BguRdCyBKm?&<`pn=JDj!=5_7ZA< +I!T3R{Hmb=zncH^LF)rZPy+~qONeek7M^e1fw2?o26OqqKB#70=_re@Y8ABmerYoJ2)ErCXhXI5nZ*k +951PqRt`i=iGQG<7%XUqH+{<)v*Im81Z(mR}=tbdvz}0NeVPG`>aS8m7JEVJa|X0)tc$7^4QaI$+lJ9 +lzD!evQ*vb|dKA$NMm1M`IvX4-Pb6q7O$H1(lTwF^eo)hE1acQyDl?WPQM*Dm2b#OqEgy(o{0@h3jNgbCNT$fQNTTri<{ +Je`|n(SR7vA-&H5#8ix9V9VTJ{s>f~LKioOZW?8GVvuM{13X5AFu_VZCb<;LvI)i_-UDdHjpYHcA +?6b^@G|*k#^xO`0g=yxGvkUZ}kL~c1Id$TFV2>seu&I0!0LmMalE(NN}?tGA%HZnu(2OIb_oTHsKFk; +9MnqHK6-|;OX0j&QFF +$RyY+|0u(LPJ_gkb41#dpv7fRVRFFe9E3r7<+&(UlYKEk9`E7 +`&7lvr1F6s0)uufj4(i()dPDf_k5cR47iu4=m{5fSmie^knZJm8O5H*SE&Jc|^JQ`Ji>E1B>INi(WW+ +r_geKOYNWwwqK+r8-wg87&-Us+)sq=e1u+InX)j3)D!9UQ=sgYH+fVQed|(T!A`irh(m;*wQM?0}>KB +z4>;V7o$qrC~h6aTGkF8V8ta2*LwH*BVDnw?V6yYS3^&Wff}|pEO}~@?HCE3B9ugM6)v1la;Xz;d90F +lqXujO4z0J*FlZq?0=>f+D2ji>tHi@Wh1)`zht=q17jLC;GjB8iYIp3rD8UO@7QY>VSt&cOw&)mmM|~ +QUcLx6hYSq(=nBD%usVizX%xf!^DJwZY4mmAS5^aIiH)iTqK+~{i1e^jrAK$zp}oU>c8bP#UED+gXQC +k#7IYp#S&e8G1E#N3UdI7S>Y0$0X^e{i#;g=!6dFM((;iILWi)W93(ZUqtl9oM(pRRoRZlVnq)c=&!0m8`RnRFd+KH!Z<1=i9@Y>9+i +)SjAEOVu8`2>Qd(>A|)nYgtyp6vZ3Y3VUVUL+)}A}s?z2SNSYGFxZwuj4qg$3M$;CJg +!SbL@jfQUIv4OE;rA$mtLRkRC8iX3#KJX@^+Vg$khNIn1c(idY+pN?Fix*GkZ9A)d1F{?C$bRXrwn*T +PjX*hehPFwZgsw#EW;>N*8~M)E!a!4tC*wwp`HZJCF$gCP1&<;A7eMZgi7WHRO?RT?gUsI-y{AO%_Ok +}uO(W~P)`oHJu-x3<+fR4=i3*NMN>$1k69CC57-n> +C!GvNa#VRQ70Jue+*(%v<@@L3=L6^_`?tG3T(pZHF}u3IbXS2g&2o89h7Vousq_3pQcbSnpC;NAxUZ3 +K`1xZpjuzpo<(%28Wg(!v8^gwn|9LWaq|C$5142w*tz=XOU&|XU&T1^ps&u=pZXcjaozDCgeN#D{c`{ +XH^b*mX8L)z_t}wZT>Pq^_lehZ_%@i(}V)ZXcqybG8T)f$4KCrig_G0q8l-(A!&rU+ +ZMH*h5kqY!``jpNXAcOj#45CW>$6I7OFz+k7>1NS)D#!uv3CP7)z1t)t;j_kYXcD@NCBALV4j~RG7Eg +>9Jud9O+VMZFn^PmhsDgDEjb3MO|Ct#{x@2S7BbnQJI7}PKGWy!u*Mk{Qw?3%uDHljek5OK#MS+;njT +usb+AHcX3+Y(g;_!v)dj+a-$wclbwtjQGTEzR+;~(_$I+IM)5bVx9lfjvRZ`9|Dj?(k-Q3;Qx>4CNJi1ZBD_;(0yR8bQKuv>Q%^YUvEvez^ +^_`3!dPYgZEpTr$fezXkdbhLnov|Sem$8noVDA0AxUmO05JNF-@RIghM-4VbsH@K*3wQ9fgXtFaRe@B +&z`SQ1ce-H5Cub&Vp`^s-SwUQWrDgoEFxJagoMzJ93LuVp3nNlvMs_hxHgPgKwOIZroTx7hmbiKdMG^ +Y`4QkFP-O~%_&sxzqkPR2E8GRYrvRhYutkpKgUx|3WM!0)wOLVGO`;i36Y8CM9Qnk$a8j$<^JE(840K +E>zZqGm;O>kM$uYFOGj5RW>`&3g2#*<^x3CRpUi{rP5JQy`*4b+Ml_Bvcaaf?1^}G~73}@i>nm(>e7r +|Y5Il@J7}$ABl%tx%5_3@O*IAj9yudsz^~i)wpf55}47IyE)S_ru`37c)PLHL->V^=qGzmMgjM9A;BuoF!2DB +9gPeC@vGNc4I*gKnj|GQKHfc%1oK0aU|8>|7|9Av0Dl%wJXXdbY8BVW#Bh@SHv+3S?HLyyd_n)or +Br7H&Pz1q3##<+E_M&HPA8|kCqEvL6c@ZO +02NsvEo;oxDEm9ZOi4VAleoA8GNfz{Y3wED5kyEy;wZ!@i=7&-VlskVW~vTJ?E?u&EMZ4qRc0-3^jU4 +$xeMo7ctrC{RbJcjKkB^=qiZ^Is2aFw&&I8#6vJ$P`KsxKG=09wJs84 +jyIOvikEzw+^)lx3X9CnSuL+GPOwH?^bH~=?@kfzxf=SS`$oq(P2P*#QEKCh_gi0&_#Wf7GU@mT{9%v +d>vE>iTdI+6TN)nB?O^Q?&vw)v4`XbC7XOv6i_Kcdoijye%fhj{B_8hBmZ@Up%KsSzC49!j(DrRfji2w2|@T8gVY0X17E8Ftbs5=!)y{MR*P7O5P5@w5pH4^2P=`VwQW~UGcl`k15Si +{33Y%F&6PO;c6YeTgTVu;+gwS2KxiRq!<3ZA3XbE@ZGxlg;AJ5mPtB}z5|VdAJUO|3Zf(v+;I~1anU= +A#J#|inczB_XQoE!nw}vb(--EW&eKgaO +sUV8l1@oGB!kJfL)rJ1%3zWc9&HXFUN%x|?}b@{!v@N`?d|j+#0ksbhI&^10p0g@JMfIQkxJbA+O(fs +w%CKp-=!9n>;+RNSrF5z{`pJF2s1p6>8qDqhfzcGdeqk=q+dM@9iRfVuY_xQ^N&RP>&K~y-Z56!T>$cUVttgx@6sW?eY)rN3U4;ngR0w4RqRLXJk81 +6rys*6fzo^{ba6Xz!X0%im>-ju@W}Sa=w_Uol`@nM7L7F3Oq;ZZ^lD>-CM<=|@#Gg?n^RwyQ!LO4lw%{U-K0A&<5r)!mr?t{0^T +)?~9ih6qGya_xxj!swUeotS<|>K$E6CICs}{-fF+2QKBV1tQCak|!qB9gaVbdzN)|d8yfmEp5W#a;iA +7^0^8h>K}@9hWM(XTH}9pIkv6b$7YZzE8`8@uT%5=>Q$o)LmTu6SXu1C8x_PsKK)KW(FqJ*?Y{M7)hD^80;$0vuHG#Nr&pHDtR$=TAxxfmJ(TOIWJ9p>)zuePU@$QoyT@I>880VCDAfBGO0sSaopYg?swh*;*FG?wCCRQ( +{5vl1O@|OFqjz(W;VCK{j;$dRdI2d&Xd97c4PC8f%rUM+!pEVs*1YLd(rOB&Te!Z7iIKnSypi}PUg`M +bNKyVGxd8gO@4%W2lIJE^~$J7%B1+5Oa~jA@ZwEUT&HE3=2;Y_WfWZ{MKZpPW<{J;$+RCumqn69QGOX +suHs^rz>_MEqBy&a7D-X&8NkTLRh(vNHjCmYngE7aJgTk$UYTE3H*t|*jcF8@Wj;w`031#8$?`hMs<= +uC296Un->t5oZ0B66b$ZfXG)>|;V3;9XC~>agMmK47l`kuR0X?gVbb=83SavdBP7y0rB$}t!DYqzKWJ +s`uWtsE=2BP1OuJdVniGLI7@?trjr{z^Ynx@#ocv->25+6>I4C-O${+bt2nat-5BgM|}C>YrGc^I&{1 +&(_a$sm^8%bTnG8fyTIx`Q|?m&+mp1Yq2#+!X#RbASdo{3DrE{FIuy%;)p`26|0+WYZLTTkg?ZUqFF) +oPSQJmrO=cmRHaV#tUbRF=L95cjZ+Ky-qPLE$4;`3*RfbhYy<3nznI{f_j;OKQfdU5dj +;MF15Jq2ih3KnIg0mi$Z4*4lGe*hR9JijKRvlPgWr7^g|mwq!n>pML+J0p+0i+m4=`SyokB} +E>`)B{_5|ym95N`J5_{^P2>yP1j$d&+34<4h2gd;K9IKnfaqce*An?)Xa#<~lWHgG>YowHDQKVS~Pcv +G(8ylTY=PZe*5fw+uyeZNuK_Ul^3M5`!$5j*;ldJS|QVy{A#>Qy$8I}@M2eA85=ReMp&nf==4|peUBK +*L+ox%5moetE9m%tYasDMv3AN_T?vy(hRUfT6|X%DMSfrDWss`ei*;MX3o;^A<6XLoz|aWwpH@6qnw& +MP>7KD&L{FbSe)_}$`j~qloPa`kC+k>3Cx%ccVutW9&jIid+F&4)5)OU8q=2bTMQ_>U)uFY*fYV-Ug1XJew5@V8A!ijpWNDSyY12VNv7-mxBV(V<-Xtp5z&TfE} +qEl(*OOH2W06w7*NUX?{~8nE{^yDta>5iHbNafpMMW6+nc6OmM#=up3f!#4RG>>_^>$N;p52>4z%zYU +DRnqx2%`4j&F5^lLDAJpaUE?y2|HM+65TUdGfqSfX2>mug5v;ILCn6nDAEJlWM2|+}Wje1?T)=S|$&Yda$TqPG>Ngvse39Vfs3!yZO@jveR1$6 +B?=9Rx1!pR-@eRTl3w5}&(q3173#gN~$B299*PTuj`fL()WJ}y-VU@;{Dk(Oe9iKk``TXebhfwwLa5q +qCo@BG?3U}T`kxvrX$w34f&-2Nra^vjq`RUmUsa}J+51huUT_lsdn3fx_PTr1S?>Tx-$Rb}UqR7B`6F +AZ=okX*2Nn?W&5{MtLNglm-EB^Xr2RaYj>e240|Y|QE)UA#Pcj{qJ&URfRIX;CDX(2+}Ev(pV2=vNoNyg8(vho%>W)!A~6yBXlUabT7Y +(1TO__~d6@dKiRGtgj18BAq5`HTO2oe|fFz?FQ?W!ej`*#`B-fboqzD@|rNCa*<3>^qa!IJ4t{}YZM; +^s}f1N)m|LcEj|ubo2EdRRbJd~ygYh&stZ5y3!_qTnY%5ZG^A^N7pet|yGm!vd|C2n;|jnUqvO+)S3; +HJ&T+@60wsuq=Xo|GDl)4GC5}5kH&vm*R#nbH+&t$t&N~)js!F*4u_O`X-v9JMcjrrR#AqcBhT9;F45 +Q>r1^YZ~K35=M0Y7>F>R4Bwt*$iTu--@cX5Hv5NcCm_Eg +tm<|Fazu3n60!ncE*B)l?QNXDee(u%fWsFfoUe0~YlQRkqXYd-*h_!IAE!uI2q+}HQu~owhQZ=$we=( +6CH+V^L$J8J()y9RkXozp(&=pk#zKi+70FU)iU6i>GSva{Y}E1EhQ@Ea?%*0opgs?4w^DnCO{4=NYu) +;t$0CRT>_(;NQPA`kS$~X94kB5B8$=w5AQ#0-${p~MIXXOkLD+N_adm}~9r7ymy-a^6Y3~}v`;I$0on +<=3w=@2;M8-(J>B}1U;c&&5m%#2}!p67J)wICtb&jU4G2 +Xpm?MBl`}L=yg6#xa0lkb39)rG-UatisyrGY3h7*^zxYY#hrY(i&A0DifthTOTzl&k~?-uODe*Gz+9- +{&J(*J3mYN=U_oGCT=0=yuof?{6fi9=od?a_-Uq7sjGOsRAeNjJi`psy +uglF5>+AQ$JabcNkOg;#!szg@hS3PY!YGWr4@Z_f@7UT8cbyHrdIEx*ZNkG^>O?(FE|P$6KIWP^-R^z +i-RbKSI6lo3q+S|(_*G3vak5rJ6CoKt$@C8i?#X3Xcdf04Ql7va=gTL +=`m<*%_`tgzJ3U(oM4zZLjI?Vp9KlSfH@yNjF}i +);~)sGVR}%6`D#WIa=hqy>IO6c@DS%o4Q=iBV{)HCgEvgnp^@O&$__yS+DCy3fn%Kvht#o-gi2k=XnN +OC+ri#`q8Eolcv61q4hkAdB>{IGENryfvU=88XTMf!B4tgGgPEVs%4Qy<%c~+=VSCB>Wap>jVN}@UJn +%alefo=JV=j-{5nXtAt)2{~Nke}H|FqkHEp +EiT2QhYw+v*BWC+LNZBpq^~*nm6qO^()uG97~yrdlmg*m9uufuAaCTM9JL13__~-wad-OEgzOA17Bum +snx1?yI)=sSnztU?=X%e01V+lBOgq(b-g|hi4_79eDDzrz?s{?r*rk8a6rgA$wtTl)(m^PJbdng-Ufh +DL)hGMdqYlj0&M0{R?}a;<7H{Y?gGHkbt6wJ+~V_{IDNAb)G%g2kfWa@1qw+rf~_2$v9Kx21lL +BNPsU<=St==Lxd8A2r2F*#{Vv1U9`<_M!+{pQ?DUW1D;Qp0BjE$R0s$*5wCG+cu8RN|BEzGN=H@B|(F~@+(DTwu1thJao0!alb9hB_TEb8#C9K&An +$1NhFqQlgrXNb^xh_$LsqoOTd%n!*nDZogf6=26;C>253_qP^&=#VvK`@fav@uOVS1w@b%E6LsgQPMm +bq)p;$`C{a1Rr0eGmt}}SEyTqbQRqs1{%1Ls^Nw$ZJ7x!fU@okJ+WD|DkrlU@nU>{^U`%FcKGP&GoVq +x?!z8@|A_0|De~~~6IEpR_{rYm;qJ#C)6ZR68Lw_-9BxIZ)ag{;Ze2(?U)-Y53ldegEGDoSmX#7K_wk +6*-2E1}>L7vnGTB0;b_BJNjMPtnqZj|trK*>fbne+_*BhKppnVoYdXg1W#ThoU(%SOcv_qbf$h8+Lhm-R+9Wr_T^zQ|bvL>xzj-z1gRM`!BI)PD2)C;et(zd3q&s@^O*J$NP9v0X%7MIDf(`%(|zk>0QB-PrF?(f=2jcTmc&Ta!l$;<@ +pL>gcwWNBad2h7v55@AT|y`U(g-@`}EE10l>U)ZExFDGIsDe!#Ud +ui*n-{S|?B;ov@wC@5hhCe=E#Ks5lVgakMi@KnN_lgEhfCv|ueWj2H`8Db~=#;W9==gJ-&S~~1b!Ct}L2;c1+c-z@@p@hGa!>~(nZuOC;zF4rNduJadHN|)lp1W!G!6 +Kz*^@_2im==~?uXZl>ed8nd~fPUf^`IR5GaTb8EUZ8I|8m$y*A*7r!Vh{ud&m$01lX6)&OoBXu>qI9G +A&|FF{hfBW!ZhMX&2@s@ri6+MNblO{8Q)2E{0Y^~n^+zb`?tX|Krr7#-&~$I0hpj`Z1Ob7GA;yxgAST +OMdJi$dr5Y?>_Xsxv5AX!|34jw+NyD#r-5I`({>8tZ!=8Gfeq5ZrJ$YW&`}YT +I=%XpLUBx9H$aZryB%Y3*9i1GU{nBw1aYFB3`wWwd)EYPRYH*33kvTiZb?Y9Y4*ulHlU_X-lX+eyG!j +M=P_cdvu#EB~Zt}q45oFI*Ca|t9168G14S*#`fnc{;zv7B|dm1rI_2}z4y(J?W9d(st?*qMh8ZXe&Hc +qOWB*_&2G?mxbVz7!b$z9%m0sMG=t7>LRG9@$PRs1<2f`s0Zg_rT~$=<+Av=ll_bjze_+<@FYAW;OVd +iHy|KmcR-yK8MTXzUYnwq6+rAq?4aG)`o1jnPeYk4|IC3f5R{f#4_k5+oHE13)FAZ&kcVwhb +jb!W*6XXoUXV}I{YZFICvyl1iU6xy)dWxfutlXr@00p!E;IG +U({}MwSF`z>!76OKnBU&Z7^E`GcBndwa^KedE!T>8n30SDLQ#gkUTD%W31OO4$)w&DuM(%a$GjW*!=v +}6$iLin<+0tD8ckIV&-2vNu3-7c`z2x3-T1i#uZjpo!>hm#5JH9q!xA()6ZD;m-$Cv57TDms-H~&6Q$KLxU?|1jZTD&LPb`U5I`4Tl3_A}SQY +{%CssN+;;Ka3BLOfix7`1Rp#7e>{Gr8FHJkRmW18XPkRU|b?4EyKs^ru;&Jj840hOMntnUx`WJyDz;|V-IxHS +PH2CI5G)?BR4;lN5A#?E#)nSO89_`>7RerkHfI!y}aU7y_+JlYiNV#qBb}gbW+x$ruFgSn94#&f)E3<8j10;^XtyT?|$7KKKylOxP$+7q6Y@(2jq^wv-|7A@4o9;_Ef#$4L}Ska +kjdh0kC`bluYl7`}Ow^d)p6dIe#-cd-;6${o~!JjBiUkdAVMe6-rdm(fR52)2ENW-yZ5is+Z(|ZXAev +eKIlQGt{)q1q}Kj6v<*9qcabmsjeZ81F^j$?vf7cg!w8i6DWA +*Gh{*e1^rIyd1;$;mQ-f~kY|O0oF~DWzz(JL_TKTv_og_^Sp40F+@;gZ1wc#r&uSAV85txE}jux>LHp +xp6Z*SsaTCO0#0IxPrk<7AsXT9kV!(WS_%n4D1bva*_SKZ#4EqF&_Ez{FDAMQrK-U7rA-we;#C4q!KT +#+fM&-$?U;qEpXs!^$!;eFEavI+pgS$)HPJU0beoePwl=IJD@KsTJkWu@*Wkg1+QKMw%HYcT`7Ip4?W +j#cyH{7cOu3aN5E>>x`g5LwDqnn}<9i^#jGf8 +~zPTU$#(U9kBGHlilcRw#tdz#UYLn2yv;6!^Qu^(Oh{D_W^x*twwDaXsKD`D3e=T6hZ56PW@aZ{jFe} +Bkpy(D+L)5t1ol9@Ed>$(hT`}wYI0*q&Enx7ijaT-DZ=|0|8S+qZ8n|1*Sk0}EV}YQ21`WIhk9+A}r|*YeR8U$g{1NG2=chfV5^au*ZcR5w>9$tMxc;Q9WJ-RgN#wKQ3 +gt1w6)$}m%6WoMPAQTjHBNjgFI^=dohVOl^V>!m7&zJV$ +(`pZS7$uGx{XipH>WkU*yG80=1K@Sn!XbIuY>Hz}WNGT3UUnDWoeFHP^MkZKZ<#}w5O*49kW{Fc8@a@P|?L(kGZR^;Ou}3Q=P?~P^ts-!qe-+`R90NSLlABll0aY78_?TK4x +*A)+n+ri0n||}LQcVRk&MT&Tr8erz@+NtX%--lysHti-Yif0dr*jhh5c&F+IY_JK^KO1}L5ro)9BL!A +Fyqg(vR+;!c38Ohqli`88iog2Z4TJ!L%<_0OP`RTmPaQ)3$_UGL~2Si!B>S} +*1ipKl*mIYZANu%pvu{7_PfuIJwVU?e)avZ2?CzkxcCznUtx3#YM_e945HG6_U!MwUqxl;e +M6kW@JLZuh}uL1)+zR|FJuAg-0*iKuTn1DkgGto#8Y%tJ&tbj;!|AYOQ^$l9*l5?APUyUNFdxo2T;va +l^IpOF3??O!J{B`Okgq<#8R&* +O5(9wbO1mCnW**tlZ<3BCfmDHxi??uZ;EH5C$68qKVofT6`)oOeuRdl +VD+N3C&dmI`ZVBEa*sifY$?S^SbN^F-C$&OFBC?*)?uYs$;NieNLz78KNg%){?Vk;`W2oXifKv%YsajMCXTv>H2y%SL;B^wP`!QN%&t8;7ASL?RgoWRItj4Iw*KjQx{DTDMt +Lv5dMJLU;Xz^uAgY!t-14Pi`*Z*)Np@&cjFXWej%<0jm|WTv76{8bS!5^6f^;OYj^4o#n{w=4bCBx2D +>d$s2%K{$An_d3VwFp(9F8m0q`S8LX4kPJ#%!^u_4DQiTTOb3`)E$I?F@!07!by|>UElRnZ_D{cmjwi +<+0F3)qZph&2832>^|NRhg|^w=! +MA*#aDfO)*34U_BQN8Oh-rwjV$&y<4?j`9jmHd-Z`i*@Z`+~)BOoZg!529`w4s5%zD;MfWX3_^Qfdgx +Q=_I~h{h2;aUjA_a7b<%LO#nOa?@9!#S{+c;Z9(fezhu>Om-hmM* +ov*#Zc{-s&uHej9hhxX8Tmwb1m3J18$bw@L-}@z;+^A^SpU&6P>0qSrmb@BEeTqp6Fg1c8IjornBnxN +5W|(JSuk?As-FX*m;=*?%&hkkxc6?eV!50Q< +eI6pl6d31hw@$IVjpVKdZ%E;ovHSi4>YYfQ{*UxqQrAwXN=^5IyxrYW}KYx4XNgZq`3a|~YU1-x;Tan +M4be7T%jWELk$9Yl!FF5Qz)g28g@05BK}- +qXqPAx2t+*^1}Zkuqj1VkvQ&RB<{lG0of($5LT#>+8`BzGoa|6Qi`Kn0+W_=;2i%=@|_USQ%38XGz6S +yS=_q*M3)a`39fyLX=Q>0nk_Y&i$>;0%A9;bL@Ozr!_dr25EMPIi#DG5+@t2Xr4I!M#E)WD^q$-SatL9rv7Un(oGgEP{aU3imITVeoN+#o0|n^i|gQQR@=$of<f +V?C7NVnZ#J7=%kqZZYuRTdq-WEehzB(0qg`HwHf5}WK)IGsKETjHQO3ofL>s6JXk7FdaZ7|s?ELzX7V +$5sqkz=N+%aH5wj}xbpkRML1V#KU{rM%S@pbcHDWPgjPdNtKgyr(hkIpouRz1ez0EH_QgCKMWHh2Je> +8$`h{b5s*CW_Z*-~Jhk^(N2>#tq25*81ntW(c$!Dx#j>exl}D%`UP%W%Vu35B+=b1>|yTo@|V!G5P)!j~C{l}R~?7fGkV%3^E{cGP;x`AA{lT_2Oc(%?B!%h0)A$3fF!=*& +!P&9@;~7#>j?HrW=s2sV&$!d6=AhU)0-E1Q{R%dc#tPV~02k$Qu38o8S~tnNcF4yL#p8Z#!GhE6pxN# +%Nrq`(O{gBp`Z10On+V-uH1WaQ(t2mwulTvjuNj~F|^NTa!G1oRe#qIsUv-EGInQ@7%^fB`K+i;@#+c +0Ts)MXGMmP~K3`J?5ZL;42$^*m5?K8L?*Fr2i11xzlOT<~L6!#)dbiGU7mxlO`LSGp9N=>xv_{JI}Fs ++%z)!jWcVGo(V9JpRQ>%zlJE*M=693C(vs_r#6VAH(4XG)I4k*QZYD8h*Z9Iz0;kf3Pk6O&Q&b!SLg4 +*(0q86;3mH9bSVQGl_%#Zjwgi4hd6@?Wt9w3xukhP^6rY|@+s4r@m*|~L#9HpWa3X(sJ@K;0Md& +NDAbC|#^aM>J(QluUh@pXU^P#?SmG&t5f%(2Fv0;(%arohq`u+zU+tPFhsz+Djs}I +a_q}!8P$pNVs2;+McasANFM1dUJO8^5{L~fzu`V6imt^Z2tOTdq@fNK)ZI_ArxdOw+97lvN3FPACT>G +p`PLB&|Y7bvlN1bJC^|1t%9bn-vo3UXUe$=o*W_45^rWs94ZZxJquQAY7ns_3aYCtroD`XH}e7yjYci +OsWv&%;5Z>qEIBv1uQI6Vq~r}mK{n_8=z}$Qm_n0WJ7-B%i$xvSFn|~XU9`oX)T%89X*<2zI2Y-Bf~_ +@q14GAv^~%rgSY9?ltT5bNtA^SvTdR!q*#(r`G%}pwe(!0>3|P(z<@Ch?XwQZzg|0m#bq`3g@0)UcYi +mohsfW8OTe54SKs?c`Tpz%>E7!0!zYg@oowgc&XfGt9c-0hgwie&)Q6A1YYDQ^&g&NOEyzdHuKaC_1%>*8 +6ti;c@ufO+jW(x(qw(l?K(%EwFQ!c=zwN2PG>-kqh`6B1#Z1BFUAIwqKiH4za19_b)toTen&j|qj+%ArhgYR+NKDUp1l2l`{`QW1ESwujEn&GS6_j#zC^5|BGxLD;3525KRGKN +xQB?(96RM*}FqmXAa9LV75wVXy#7$bR^s>>1Jy!$ +%rDY5zuEZW)4skQYlyF_|^bNK|9OnYFd!|oK*XqScNi0gJ@pl6CC1hkMr<=dL1^9jZ>1x+`BMX$r%J& +S01EQ0vz4ZDT786s;>DqX%T;bxkMxG1yZNCw!d?cV9L|dw>vWw*Gc`&k|XieqpSP@`1v@QrCDa=aN|L +-4FIZ5^f~YB4*jY6H8T{@uN-ix0v(fY_BeZPe4+kwpT#^@BxH+WeX~fRpD_oWbMh`@&wnF4w?c7fPm* +LhPf7|iU7~%LL+W1DY0i1w069*sjLp@D#bdE=Q&G*H{PRkipn`s`L70|)t3GpK&oa8m2Jt6V#2*i-w_ +EVP2hr9({rhXSWr3huz@Gi5?WP0Pm`h7&jadZlS5kWCeSmzIJFJLC)<~o%y-0i7wn6e$C&HNXiq!DIK +0e@4e8Bf5%#G_CX_u77=2WFadE!bwv958qdrPd(wLQ +bdAB+Zqzbj&3kq57*pHG3|ry@8U1hEssmQ2wKr?sndbc(uRNhY0d3CkWt9-u>>bIsr(#14=2(_3Ueab +-SpVJ(+d;epfE_cvpB-6P1N+N|HPsxGwqXm9w?1*E)Db*YC>I19H`s#a~UELT%}C!VHbNzOfd{ +M|?Ez2PdS1`EpU?LxU#!?kqk?LK+DxBLC-dNa4)_uuV3-2HxKJ;MW4jR#cQd-(9XkA6XMI@JXqLK}}B +8wG0vt)Ky~_Z~M;iNQ5bLFoG1cjRp(20<-`utgC#7|1KPY!sJli>8>YBbmn-U@@Ij@(W;dSJqKPJ$L) +jf$|eZ!CO&xn}?P$@#5rV9h~9*1-(E=3h`@|p5&9sa*+ZDq#*0E)h)B7k$sPSVJC^Y{3Q2QC>JZ)79J +^>%yXB8dHZ8CI>)4cGr*3CaTzB}~qo)t|9)17VEeMn9+=;;ZA@a3vG}zZbtyOuJT<4!rBbY9; +X`EHOqEuJ_wJ1}Q7KN7565hH>jIo92^;V!hu%Ojuw>&ZA3-&xgi<52i!NbM+gh$h`Y>Q}2K|(%n#6l` +Rz~dnJSG{osG>in+E;z|06c(Q3M|;fhkjSJGg4)qK@uPxwge{3=P<7&ac+pyo?(^P0P!b;rd#ZZPrS+ +4*rlHrS+bUgP?M2(QNE8^%0W%`GE2V}@T=!eD``+=x@Q5*A<{1B-oIr|1Wyxk$qjvp=*~Ar0>ORjDQ4 +{9(6;N`Mhd{#41ltis?Z;Cut4lq(jW&rhI@9_LV@SdJkt`Lkaygc`t$7qrK@bBf2O?lV_jP=Oau6MO5 +2M$h8wecCYQvsUmDy8yTc_{dlPAMLgc%6DOC4gt)>k%f&=$p4>F_lxFKiO&3n*TKWVFIDU@$nSjD@g; +&1jdKRKz0G)7&7f5FX2|QmIil>3m+dOL!>w4+qg%?Ocf_K^6X*9b%o^TeXeSoHQ%Aj-%^bDI +?Gl+b__5i(<(FUNeqQ(2Y_y7!9Aw}{ZFQR-3w6H5zC>9{{;SCP<+%J^E%Mwr5|@*uP*!@S;LzKY +fRL+IFE?jo=?^Ln+91e)_L7+#|xtTd0u>c|WeJ7U0K?^NSxxgWnzgpQysua +fs>Go?y@r1@zBV_aE<=y|b@QdlYncQNi1AJrEC8?b+t#f3+Ca*#{RAvS!ty&sxs*L4=wn<)lc*bZNpI +Pt!Y~i6v01xB48n;iUYVcFP0vN+q`F +Sf04sory=t~Oh6oJ5xiH{4cw>EZW5L4cyBmqxTo@xkpwBajFzP{Wcs{0S1|GBd3^_+?drI`dFN)I49x +UfU?vqKg%ZIlwbuq32;N@2+=pgPTFf +>jFDR0nRqGjZQ(j~^Ysi&Hc*)a^_piD5*O?O;$ew{urof5hq{-0m7j}LmkW*s`{vksORfaIm~BSxC{2 +s$-PIuE6)0}6D}9rh^cMd-901WL(kM5i$0ganD31QRN6;Z-smCyCi}i}?j$MoEAADuOhy$F08Eil8`4+n<21YPFj(H2WHM$91=-!puHDxp)(~QL5*SRoJH)pae +-z`5w~IOAV#R8z~bq`>gh$WX7*vp>>JbP3QJ9n9`%w0@B{kA(liBJG)u}Q0V>iIe#?67jJmxBODDFM4 +jrCmRWLZWa+X0UgyEokvrBO<_xJ&YcfnM>4-~lV$h_vj^PxE^uIdS;PX7n`0HLo46C<)bi)T}u74Z~v +psAuL(?!4nrgO>pjnKzQg~wbtY?$9zEOh0k0Wui}Q1T^4IwLC@9W?&19}Ne)50N;xG~FceN>Kbo{m??$zNsW`QK*O5go!X8w5psps5a&5 +zPwoEp%G1h;9-@t(Mrw`=6mW%49o(p}j_IJG@u{c7|OXIr}1D-3PMOn7ENo+8=@3&N|5L_{fQjXk+L} +IM!(5eHZeJ>I^xAR%>y(>B7a`%8?=0s|ndV0FGPacy_1`#q* +b4jBzkRzt=t(ahiM}ZHkeAzK6q=uRQu_F`-&3Rxaa)*KLbk6-6L-X>r|tm~EK06h_wZ_@NsJtUzLDYY +LW*5p0zbYOH#$zfaP&Rzw{?4Q@gi+E8q@RZPRuW*7~>4j%=e6(dz>J(OtbmFW&IoOFLr7h*0fEqh_}> +<*h|_uD6S*l_x&F#dqO`@+{szBqj0gS&fv9MJ9XZl~YreOxsJ{N%&l-tNb~wD)0%zuJak*h1)Q93reU +Cc`FT7ef%ot_+Nnd$)02n>)kp*Eb?%6v@%P9}V4-qP+1BH{U5;BH;8n(GRM^{b<(jk^=G$Tj=2fBd3IKBxK8x@2Yr)^N?=4b= +H{H;N3s3PmrI7g8uik19$dn{gdrhz&iCGSm#4BT%k_Ew|c{Fc|*&4Pds$KfV#sJe!oxfR6h1^|QmX#t +QgpJT=3QQXM^5TD$88MqcB--eH*8kRP?i8DpC7FdX}umFdyxmb9n9u@<@sgRE19rqcvky`E~#@I7T8t +sZFf7=<1MR`m;li%~D3>|BLAQp*>XDqAeW>(ZNF5$Jf7#5`_ZaC0w8+Lt65myrG(0J}yxEIW5WOb?Bfgo$V{+`x=)zPq$bFHt +O6K!KB(3Y(OAKaLSNjB+Je?1H>gt8t6S67b=}a>7~RTFY)llisUb!&FD3!8KaX`WM(^2H_M~za#r>b? +!%~y=3)A+z!k|Q{6|S&_zJlJ4ow1-SDDoB<<}&a%8n +Mi_>pbTKgyDLu9T@J55D)Y3l{#5l6!Ned`;sHY +MD3Qu(~9T119u#=*y;i?ZKRUB#qvqSY31=*+DV?1(EQ4#7>x_aD|BIb4R&^)f-yHmV%;#7)~Cx9g53P +u$WTb&8$g3`xa#+WNiz1Ob#&|fu5tcRe9Z{Ny%;{mZ=1|T(MB;ib&c!6@igVBJbMR_hUzv+iX0n$4uW +~^O#VlE`vI0RdR=r`>D7BXmdm5H{B +Ef_u%N6IzIVi|f5f$GOsJqS=g+KRX6k_D-ok-F?)6g6RSMki?HhAK@|$ipnTk#|5!n7&m=T{oBG@iQZ +9!V?;x83)WQVr7RqbLQB>1igPwtyclL|AzWazF~kDhT01!OnfZb| +fIp=IHOyCUbW;%shub3*3|dfs}a8-ZhxyJ1A(Nv7JW+9~22N1yQH-BAS{jQ74EV&#P>dFC;Ee->BypZ0LFNrK+piab)}hP#t=eGtbi4T*W1+e<}yH +B*_Sjjkq2wQ;+NUPR=tPFbdNb0A`Jb0%_4nLm#b>GdhV!w67;P9+#9jg+n>2E|cJ5+X|DpnU`C>nMap +L8Ai_3iASunO4)21y|Ng(+OzqKSzqmT?EvaMQNEcVOaZVRj4dh}zf5qJ7}pNZk@(D?CPXb`v_msQ5zm +W?3n&poBrCHG(;{IsL!@oZL38qlcFRV~atc)Zr=5s|<-=8z!)k#ofa37g677lsG)3R~heyh|Lxt|DbJ +~lR#O#tKkL>Ciq>9(2UdE+!$m%3K8)4Lwx&;PuIge-9SJG_+&=p>sA16u1nWHTr_PJ?;)w$`jsWY{@i +A|M!V?{+}QqS^fqElQ67$cbKB%WL;w>T-A`$>*{Ozf10rM?yc>RK|bXU;QNd0Si&w5rnJ6s6=hbdO0| +$}vX;j@#{d=h5!o8rnWz +NdDoCJq7i_(fYj-VKxs7;+aYS25&Vh{<0pLS!f4-Uob=IV3|K@&KYo@FF^rYvfsY@Hd{ET%Bu(9!no- +oLSwo;&og%1@bu4o=Z;gS#U5H}P4iBI;<|zLscK&RyZ0(8Q<=W=q_T{v^@}!@}h0cg@X54^~Xs5b0U( +?k6S(p5uCG-4-j2vXzsKYd<#IUghRG(7@RkC7BdRYTA``n{^1iQTiQ$0pk +7W)9G-o10R_ZL?X8sBb)QwmiEKq7H)e30B<0do=X65!_xCsq|Rox#3dmR6DU(aODXPj-OIxCWQa=w*tsI9|}8o%ghZ_G7li{MxS`>syeFlLeF?!J +6-3DX5~$4p!dh`U==J}6*;>%-}#wu&|Czv@FVCq{h#XN6YSDDKNCBH}EjH*@1L_7|_Vh|FCr1NWon^- +`rLy%r(*E*+&&wWNL3^RW1-^Bh?{btLuH&doFz8OTOtIHlS_(!JV7rJUQ|vsviO_4)?NY_>hphK +1%$7!@XWcyh50o2x|Ats5{CB*O5h-E*iHBZUr$_s>Yd5|*Vj(|zy1d%UzU`8xDnDgSD$axM;o?g#cY2 ++8lBTOZv+*F##oBfYWF?Jk1CD_=Kp4Ccyn=sTns#R;O&n1zktYt+F%(M^AuRn}fkqe*U +e5Iik=ER;-P~O30a2v6XLU8JF9xY$Bu_liwJ1ZAjl&8h3g(&&!Wpom(}1Z|q;8{!D0{CZZnfFfY>_Qo +-)F0y+(k3O3jx7-j;8-3eX;R$S%3Y*Whqq)#{jkI&tMsz^7X%(XAIV18ZeR`q1TLIJw5<1)?owd=pi* +>jGp~{_f3(1xvfw8Z6^g^f;F5Re%~EHeTP@L#9;ku8>??)99`iYeLQpt@z<5B$6wP-sm`Kq7pv@LwHY +1E=UQ)3hI6#08wOdtlgVVO^$9$xtO*$<<30LAhJ!u5ei4Dkl?{JOKGN +mg2{xbs#i)G(FV^DTl<*>VFq+zGobXKE79G{Jww +STAf!8DpPm!EN56Ox|&E78sJcHoTaGtZL5dZ0OrKDcl-kS$M&Y3Htj?LB0b+ +t|5ED4@LZN+@KyX-I^YR!ct~2^|jsa>G+f}|jMeC$?7dA$sX07%){iq&9C%d2JdgbqL%+6K+*)m3g#X +SybL*s=e6&tML-QuO?&t(~4G)DY+Y;!LS7RkR+}ggrGa@s3B7h +NjyKlRY2O@8R=Jd~=gTH<*q9ZPa577guBMFAJ&-+nRhfP5&PXQN*4g4$tl^1q^35i#@KF1Rll-G~UVUdcpi*uLH$n$b=iOFLz9uhJT0>!Z=7ZnI;gXouhiG0oG8q@Uh*2? +Q52yT^zGpBMpx&;V$MJBEIVBXrjr&Dt9;kzB;2>zRl&sJ0}l1X}*@+BbU#9%2R4nyN3%{wkX+}W*wI` +7co+mO=*FA4S`2}rGUmD;NuFXB2mTGx^JLyo@&{AbH_u0z97Ss8cPESh=@HRB12|ed)Ott#ewD{aN-YHjOGH6c=Xs0VLYi3!OmTv=@ +p)S-elSMzWZsYpJ=iw|YC;3gEC9j6CHbzdJtL!d@4|)zeNry1#^z?zN>kb{VmB&><9-pcMjs$ +_9@ZpSAHBd9)L2T9_UZ<34k{q+#^guJhf1BsZWpzz4-xw6MJF?v9abV%q;Cys+es=h(i^bir0~sH^bP +X8rtZ%}cCZB_m5k3EMa=fnVWfTb??I!rb&x}~NueL1lqQ&BBQT%1!eD#6;d<+IcqUeB}{E`~xJ4NDL8 +>k>miLGe=w^u+8o6HNh=Es;3AHOvShV@qIe#ySS?81ir_^{*A70FPJSB%$slV%Th#fL4P-^90NwBwhR +E=XcE?=?1r?SI$_3@Cp5j@3NMplp-OUL2i;$jr&p7OsnTbXzK0*NOewFi|a)%?sD+V@x3|K_nA=;w@a +Wk>@|PbQQp&5S~*rO5?yAzWv?1c(ayUqi9N+4|$>RNV3VC3z@Kc8ZVueUPWjN?EJk8APSNnq6DmIM$u;5w +IFfl^E@2isJm@21c`M40R8duFY%Ms;P8XA2QxKHu0Gii#y<>l3GG7#AjB_418u^jgL3?p*#G3yc}z{S +78p#du{xJ0~$7W%E-70Y=FL+yJ6vNe{N;T!ikmfYjfo$O92H(k{BsTG0w|mAI(B;04+>yhTg1r?wwz% +oBf>Y`xcv<=F5uBJ_3erjFP3fPkW22kaAF6OJrwhdV!6J<%f5f3yvs|MZe9*J>B1mwgQPDs9NV<`PX|T#m%bNvo@Td(_1CHm>Gb?kXjsO9hT^R0g4?6dz{d?0+gS6#-j4rEH(Dz8Y*M@pnxUn%Ko0-Xd*O-#&_P +w25{wKnJ_Vho^eY-~?><9CF0vb7d>spMx_hIkJN2BEpzgcVldk~@iWzP*I(d7H2oldU_SR18U;4oNB` +@C-d*y(#)%es_=A!XXZi=4cE8(hx_Rs?dZVMcN-NJWCSVi2#-RkU+u8FCuvlU~Ln8+Q*eVpTY5%w0aswRW5oyP>TmdU5x&I6wpb&^(2K|ylA9w!k0$G0j*fh5? +FC<5{4Jf&$E$C2)SP&MgEU?0A +m1wLXrvtrU)o6QBqOa^TEeHlTn98s3Yfj6LN5bscP?fo+)0b=CU(N1m!~UxL(SJr??=H?1>C_@n_Y%fFs78ZS{6B)Xc0bgvZi7!I +cLvuiPc~cZzpAw)>s(3!vp{lE^{muXsE2$e`0f$ +`4ihtrtr8+pE1TVSCi%-r;wbpJV?oActHyOtMrql3rA{pvZxq7(3P-NsFS~{uGr>1Ih2@DZWUrUhlu` +||@Hx#|3GoPw%-IDurH6rj8gRpV$IP4kufW>pZP%eJ4F=vudeiSCGukesCJ3`^$%~hdYVL}o?9qh(F; +B<^rQp~eYwQi#LLD`?j#l(><^-&pLCJph$jM6LPh_rIGhQi9EzmtErV@ICej9%n&*jJ6vs9KuH^wEz6 +y?;>An&y(?YFUs62y6kFzwCrCY5|4QL2B^(oIK1LNQ)1iCFl$WEFYC1b6`UAKfqF${Azz5UyrA86z@g +xz!vAs;spb@b7P(-c>TJ-QhIIa^;F+k%fi?=v}2U9=>uNiP#7)-B;WAxn3kzEu8^^d;T0fTkF&rJ1p$ +Y`OVePss_^8>VDk-yRVW*t?zUJmN<}k5S^XFd8}8|P_bRBZMk8c{F2m;D#OL6`zIlNwHr_GG(>Kg(KC +YZz)@0%}@3aJ07O%+XX*m~{o#;rpK$%B)X{pf0_#7qPYh4zU-p+&vFBUm4{P8@|thlzD)#e?FTjJ&jf+_#?z-`(gif4$4XR+kfU91Pu;NI7wXzIl(QUg!p}m=rm`2i +Zy}noRqcu)O>h+_)c~>zGv(IUfXK0{mVi!SH5fB}HHW6kKXvP}o70_rTsE4SDlML{hE!`gZBbbv|9lA +BxzJX`YAGvlWyDo!Wchv66R1M8o7SkR1C;8bD`%`?$;bRuRTfx#$kyf?Ia$O`d3e<$v`gTH4e6-D17g +#^1m`E&(1|acqLR?ofVbu_HkR{U$jdek_;}z|}#*nm*H#H5=I7fR188l7Q%yJi^Bm4b`r`sF|9n}IA) +ZR*WZZT@UTeC+MyS;uS4l{}Qy~H0Bn}Sc`oj4r-3t09lTb$`lF3M@5Voe&SJM|-nc-jAg72j +l28vSBy~jw8s7Vz`X*5i{;&?nmSmq!2Tn2V8MI9b5;GyF9UVmFHTi!oK?ay%nqCl<;)3p}s1vqHTuO* +HJPe?d9~7no&sq8%bBkHnX9HLKgX&nq*IA=xk68wz5{PO|A +bHZfVOWsz^M}~oQ}A;r=H6kMfP{(9LHwMJ$ALyX0bnD#Z}w|4VTg4>b6WL@!Z{4IN`(8XfG_9!LfLU^NAeP-+8ARsS|?G`5w@4AUWF1+HI@}W +c_>VBC$tkh9HYyJ3p6r>RBn0&Z%RWlhM(ByZrzx5xv8$w5HwyF@ZxI;PNqeN*b|EV2nb_Ax;KX`XMF~ +vl2aH4I-8iuIqg$|I2hP8>|E>dX^YLh+P|R?l`5s%^Pgdz)puD|FXB%?i!ln&($Cc6W +kBnU0z!uyll4*hSK7N +xvE8WFJ-@L-9PVZjH=4YN0mn%l1C}8j6!KN|~V6+*ds#2;X8d?C^SjH3Sv>NmuEv<>ChBh_<0%_H4TO +<_)CJ&p!!A(h>(*;J?x|LOI7l@cIj70?6{g;oGg^czl#u4=F4KD@5;DAW%w<}G*qk +5$TjPV4VE{AIe3^^C3M|8kW|ibu)sTO5>|kY&(qAQ8+0E>O`VW#inwl`uyQBWsB$}Pe6X!<_*mA&sI^ +2@z|sRM?Rsx4=MY63ijjW>d5CIt5xSa^DRtJqNCBU?T1`;v%Lk4AOx!r(DGp8WzRA0|W0~45_1biA=1 +7aq($ZJ0*B?7fakk#l@-9Mr!rJbI2Vyo#Vp(GsWTNuo`Lr1K=HWjfzL1o$`_aOmi%!Gn+d{0uD3D(y1!s?(By?WVjl6T#XTA-OsezJPy@l5_yBqvDQ`1P*t1cFX*!VJ22|Xmb0COE!^66CDX3U+87 +05Mt+PQMQ5*x8HaGBwz^-wqMV2hine}xesCChXww;O?Gav1nipP81eRZiz|ufqxefyUg7&9mPNWgKR*E0wf72+FOU$MkbXff3x<0s1~&DBGqxaFYu^$W?Itu4Z2%RN +2}%{>j@wIeN=LfoG|jAle@97Q%D-C-1czt3+NMptUyB6QrLEbNpy-pInJYCD)7Rr`9TG0JpX^J{D%>y +EEIJe@zu5{HvV+4NdNi(v^JS}zb@?83SEhPF7f(-(F6UvZ>2!r-c8Msj8*$8&54@gn%?xUlQESjD!XM +a(*NHo-yPaEIo<>K?aNP#*>vjJkiRk%`Qwj2`8iIj3K- +Q@GRLEF<*;RVK7_){>Wx=!Lo!ZdR60&yN0VSi!NO8I`?Q +8eC-GtP$V^A`uwgd_?gSY&Il-k+4wY%h{F0u&&a=P6ka%-#pJhX^G193{%q=q|ip8!Ilps-?GzZgP6i +D$#xFkM&3hXz%rXS;N}v3!wKk$MX+H*oGdH6)q_H1UxjI`IQMEn!t++?UDu>rGUX!ArgY*fz@*?;L_Q +}5FA@4NP7fVDQ$gJ5xz{5)U>=R&8SNNU3ENttM9X_wwjEPxb{@Q_m8_kRi4Y{r(c +!!(}&ui?|YBkb`vkUe(nZ!#v%-802=gu?$`UhSJn8RXp*Kiid!@rbO0yXese)KxJ0 +d%q5A+0>j+sTgFg$yqwJ_W-Z4ws{^bhMbVNf25(mUu&?5x0uUQL4xR*!a$tb{8m5Wm2-a +L^fbFy;GG+py06A +TJ!0!uAY2TF?f;W@IJZ-q_GTiRzf*Wpsf=j?_|kZ +l{ZO?u81p?qD#m`Et300Z<`rbXHkeikUghY+Z0Rc6HZ8Oi6UU-m)f@%|hZl%QyQqNvk@7<_e~8RWkP1a{j)ueW}i>Awh?}myXVunQLls9w{oA*97+sM2?5d-d%T*ok8$^6 +#RTl7Maxel{q->OAr!_uqaP1&&IoVL``a?7gQ6#3#v^|^%wt!a*@6aWAK2mtS)wnnC!`z(q9007DY001BW003}la4%nWWo~3|axZ9fZEQ7cX<{#5UukY>bYEX +CaCv2tPix#T5XJBM6oXC)xTZbqrI14l`EzI?hlM?qA|!k49U@C+B*)o&`i^YxZbN*LHF`7er)O)e)zk +j>FBmN+3O#soZ21JvCTt-F$VY_3(~te(5p+@Rv`Qm3)KOzI#Zbdu6r~**C_#&f`XIeIf(fS64S^Tj(PAq2|;ym2XVx3qlc4eV>1`J^nD@6aWAK2mtS)wnmSZa*)hP003E20RSNY003}la4%nWWo~3|axZ9fZE +Q7cX<{#9Z*FsRVQzGDE^v9xy=$8rH2~t|XI{n +XD>l&iwZS;=mrOAlrITmAcS +FG{YHBFT1-dxu>TW>NfGnv`)Kq{Y2^O_`$1lim8>y^D9xdw=M?&33W+TmAK4_j>Ao_jiXhJqtHM9)zm +k{qHJhg?XzmJ%i~bJN5tlp{g(rwvT&xyibELj(Rsqx#@lS_vg=_Kl|qXuRZjFw65eEYr_tbvtLO?@4qhxTX&^sQ2*OM?EUhYdBNYmciPs^DNBIcJWP`?BcU{S0?3W$z +DU&d-}fDko9UZyVtLuqw+M3*Fk!AlkB4GrZ^i6Cqqx=7Zs#;DB3ETa=qPQyHvyckjtyqR&gHh!uXMCC +k%Fq|7>?1=jE9y6z56kY3FT?Y4}z{eMqC-gR-}bdre`*K$+15-$&txn3+%i{%;R8&6DEQu6)#=-9B=9 +Y>3ZRS$=nx)JW!Wp?(y-U}uKGRQ4S+be(l=|5=$S?0w`~O7ky +@xM9zIok?vbfOGNlU0W?5q7?pJ!oQRK3-O@TS(^|d$mOep7Xa(P`0j;aPss*Uw2mkgk3d-P7@xWTxifO%Se6!+bwc7q +RF{a94-7G07fY$JI3`Fn3S(#NcuB6wD%f{};zO31`F4|E$Uca$7*qD)3w>3wHeVT-Us>I;Are}G!-zz +o^8C8=>W5W!x)<Yx?bFTu*+K9hPZ)Rt>?|F +6yd=-owA$e{`x9tu+6^Rvw&eWS7+q6n|F>z8O(YS2Gul^U`SWJ1TFzNtm_s$2-jUom#Oc{M#dKnUx~@gb~O88w%x|kZKN*zOT+r +vndZHvb?Yzo%2)e)8mI~$YlM7Bw<36u4bqmp*r~&mMWks~ViYW4IouX|D&Xl7M +Qy@4z~>@wMEaIjfn+qn`Jo4DPBe?l8ucto{R4TFdtIpo&eV?YZUb#g33Wi}P(Jq`3(YHE|(YsqT`m>$ +;=sLyZ3stdmY@8tO1by^VdX<>GImo=R@uZWDNi+Pw>-g!XpL!Ld@?X`y>C;X}n{HdHJ;In4iE^cNb7y&$36a&no?b$Q +j)X1a%3E3`d7*=xf%28TW_Bw`r-k(5n2^#KU+%IS|CHx>wu`ev(JewYH+llP>=!){weXl}DvmJL*+w- +uM+^)zc)f@J_E4{$N5!MRryWm#$P(GRw^3KsXvt)&+&9&rEf7a*Z}g{@k%vtMk9xX>UYy2q^N{hfJ47 +H(YBo=2+t$jP>};car{XNgwGFHENL=b(mYZOArsU`3Ea}pEy~ejmQR+=$gUCwkwcEaaW{y;5#OX|jDw +U4dey%$771E_Hd|Kd;z;qrSKd2rwKx_hrbYCs` +ti0IJqi;xRdE;8pKtHNg+9QkT<9+SBN)iko|o)`w5_`Lu`b>Vik|9rd{ZM#laW3y2!kdtd9sCe{ozZ@UNT1LO3ZdI`H?u#KCr7)=oTv^~wT0WO +%hqu>YT4J!D$BR0s@F7ks?0SR?l68{gXoThh@-llRz?jI7iqP{|!b@Lugp#6G +k(bIKm?`ESz4S9TZNOFu*(Ni8ludz6fPQe{|{}pTYn6clfHuCJ|AJiJEhVEhhiuUf_&QY&MY4Na94E0 +}Ki>pGCKs8M@@Twgl;n-Cgl4E;9tDBCp(57`A;oyWWIn_r~b(vi%wPyy_+Z6ZqvI*v|`(P@6FO}UP)98n@&TXAKfRpFK6$`WILvZ+p?dqnc}H +Eqif(j7GAKdId|@Vd%XHAQF8-5t=jKr7)-iQ+ENnA2^3)fn6C99eKJDYM`Y8+Q+TTh6yHOICUhP2kxZ +;h@EJVm!WL=D%VzXlb2j|Jd>(9%`xk3J&aLcW1GKbo+{P5eEPP#VX-r^&C49e+i0ZH8R;zUPmwliT2)0iU!k-1?ebv!lX02(DYDkhMBHQwiWY%+;x^j#(dF^@mZM%NvcERo;?4L4X)SVl>C>yAWgFy9i!YCL# +7oPpS!M40NVzsS1oTGZL(?;t?9&{UVEh2x|&Bc#WL0{o!vn}ko8p;>ghseHh%i)r?bN@idV@_SD)vZr +5qYmuR`@6mO7MF9KuVTU$5qPqptwy^O03@8%J96{P(?ky1`116u1&nv#S3s_uqZ{?aj^2H#ehivV8sR +U_PIJdt2e#q{6qvU2OdH=5@`A=_?i46-QX +9@Za9o<5Yy%Uddl08G5i*dG;mVsTKL~uT^aiF_eF;hw#_OYOCGvQ?=3`Jw8Gc232J8I8pV-QHpJlUmf +E3I8nCzT`RMrG`0RbP7CvZ}w>+iR@1*-fB>?e>#=`7`{3?QVo*nk5sJ7eS)DT9e@NuckwG$# +3B`10mCD$hiPV_iBAujQD8K3CMDv8smIJHt%$@-9=5T{j^ot#6h<4;g%FW?R&Ct2PMPT+?p@S_v>@d^ +Co1b%t~uk(XWQk)v_%_;mzqbm_J@~=AEJ+70Hl5Mb#d&&fFGIzD3awtt)RcUt}!@ply=}C22FW5DewB +C$KYSJFUVPD-a(q+paynL)&py+?B+3=JJx-LK*wHJ?{scvpt +M*T@iPcyiPEnL6w!&R-LRsyyJE)soR-O4_o@D_KXvog-)|Lp|JL8knB25Y>=H&pLgkT5r?Pu +(k7a7!i@WT(gC`Ik969CIO#^Ifje!6m3nXayZkZ2pVX(u8#zL9LY*E?h}+F6i|Tgkm&gw1tFohY;a5r +o*Lmf@{h;3#xT{g^xPbrPcz{(uYF<7niTEe<=Kp8jch$il`u$Lp&+E~9VlMk5E>(qlz6-+gP~E}lJ!} +F*dUhJ%;~qCuqknz$Sd`DhJWK8J4e$=-H+j60g)7J%O1jP7wasFqlNGpR1-V1XT7pE;8g!Sk)olb(R6 +~xJ+@{}E?p#$)#|azv&MKwnpUb4dZp~$?-zUn{u{F41EE#Ycce5ESM%QsmRA5l!r2HKRbx61ZMwVky;HuR1}*)$U +rVUoPgZsI)D$G2R2eXH%8isHAlC3#dA`Ly4kDspH^nj){Os}#kNHfn-L_o8H-lwQIb^XT3tzJ1n7q>w +EgF*~e!35m(_=wYaYrTX`qs(%k3J$lqF6Iz_Y=6NMgFZF2tYwx8RPm1y+o9R(LWBb?0{53XzP0U}@`}b74`UL2hgw$%I{<{rJG(Y3(DiJ3;8SNES+cf3FtNP~XS%_wGTZfFC^WJ!s9l2f9Rlq)1i$gUT#@@VNO= +8N}@`Wf--8)*fm5t8qKyQ!yQdYP&HDDdvRO7{^z_mezV!g3w#N@&X3YL;~R*hCGlq0s|x)l_V +QJqUtBlw=l3a40k7M|{3t#iw?q+BHc*Unf!gbtT#ZQc)z*FKtz(K=FAOg1C)kNov)r9nq+XTjxn+5p5 +4?ne3~*_I{KUTH(=9v?49b)QQ2Ogzm#84lnCJ6`z5s7xgIlmQ|=Z-2_n#ipsxr2dFqKw+U5bVqMn25F +bibqimOcMxi>X{w_s~@5O_liq}EOuW7T1t9BRBy<27Bf#$qkwRdB)O{0}n$!V~}w#^Z^Q~jb&BP1A;L +wQGDb&>zp3cPxGD~XH0)NjXCPsiyS1GNhOtksCt{A)$`w)f%9lh? +0%uP;7+ym;Sx-uug|k1u;K-@W^D)8ueynjAMxUi5m;-hKN1Sd+8isBg+m>T<(rPgVT>)i3Yfethz}ck +%l5s~SiB9vWz&@!5cG_o?w@Gmc~=`uHSZr0{b@T^^FbqrYHIZ$wFBlA!@;>J)~*;e#P46dczL|s(8$1i)RcSLG}j26zu3 +SOYgfy&wz;F_(7SfED0aX9q{OY2$^oiw7RW$xcJWq8{)d+>jajVoW`ztC8y9atb3TH|&YQLIO!chR0v +}(!epU;}Y&=6<^(q)>mOj3J^6aAGoR`4}b+*f3;MFglMKHlgw~GKets1#It%5mNXjj3=V&TXdm>*dKG ++^x-xbSw)SplQ-Y0s2>-jtnnte>Cj($8K!xp;q}^`f#pmFs-bY%Z3$oR$l1EU)W-g6+Qkcb^s2ANnYF +QCZM2$~RW)lZ!N|a*h6W8%|p*y#g*A=$juj=>MeO3ke9q>M^*g*g!%T4tSX>AEgE#`h&jljGlx^9yZh +xxNxDL+X}{mzJadt8v03j;)7_?HxAa5b*^^wrk1{hE*x;W-vn*-qd6Gg24N1qLBER{=rEWV@9s&q&UT +;%E7^V}xE#$4YQIlEKR@iMP<>lve+mY)o7!+Y5x|85EkZFC<9P^Fk*rPi!wEPmlQe1vX(XWw2Yje=$` +owOu!Rl$Uip1R8WbDT;$R9~er<*>J}2-^Y{qod2R%=_8J6$k>N14Fm-(`n1O^Oyd7=}QWG|NV`z +PE)4wK+34Hz*eAVPt0XdovBP>BDv(Um1qS#!G(sl6p8a1M>9U4?oxA8q68CaDcSrwA4+3*qi2}AwiQe +NS`IE>M7+iQGXkD#}kk#@AWf{p$Q5+4TGGeJOm<+l2$;@C3N9}%^KI0%mB}J$*#o2nkDx%%1RV4p@^r +t`m~wV+a)Thl0=@hWp0;fdX@XSwMmR*1fW%1rm?9-F*Kh`+?!-~D1e<=j;CldKF*~WxLqdFz$CMn +{l%2&@0d2_&#Vo-)es>lv``uSP)cG!RFL>{9?29Zl=QJ^>aIb^hOF5sp>a6SfNx6ThS%@wrPQ#pyl6( +PJm8e%z^6{n^L8-)VrS#$_dDfWP;*+I|s>0vXP>}j4AX5<56&rzY^>p-h%L{MI4V>95-e2eOt5~MuX7 +&SMCLVNZn(gNuAvkweLMZYlEu>UMruVW+J%0~hshs*~AE;gi$&D1`#mUs*VDPxew7~}pqL0Q>?+E%tG +k*Lj9nJi(DJ|Qz=Irb1>Nh;kt_Y&y!@Pu{aFp4~cFN{I(|9G$;u@mYFLL%8_Fam}lG3nK;Mln2dwv;7 +Mt+ong1S9p+Cl0dmLca=&UA+&K?tAB2TS+>9t2O3k_ax7=8`BL)eogT@UX>O_-=%o3pL4Uw#xB{%IQ9 +u+jaS;nY3zJ8^HaGEp05Iz)JHa#WIoo19unexXb6#kqWeMVC=`uC3N9{<;E~TW8}w4;KGHHxoal( +f~`Av3m5igVV2efyLT3J;ehL7B>^W?CFtfMjZS72^m6v-A18Tq{6J>5w31w6wg!xj!uKdA?sw~u +;n_sYzyHq8rcnx=v0EHq}FJ-4O927jIOK^^**R?4kex?&2`gII5e;6$-lIMpswQ4!HNSc4lLI{QyfoS2}F8(16cBQpu?S9BriUOsux=K0W!@5>;J&9*Uw3;r^wtNFhTK+H3i*-LVm;qJdo(xsB{4?1%OXs{#vxCr1p`Jz8 +NlfF*iR!*>TUh?9g>g47(G&{u0!?rS?^uN%3F{9-ikIjbqinpSH5ujIpG67N55`67f?|6NhW&4UZ&`3 +fT4w&}ISO6C;l$bNS#w%W3(AKYLieQ|*;yp5y(1iou`f3o{BV7yt4Jr7-OCB9%wYyD;8WBXRk{3AO}N?(&3WjX +$rX6OIHkA*uX!D8hFjKRG&R0#uwc|E6DmlKnDl{aM60O+9}WyPlDWKL`6g +jj|EEKg&&OGzEfs4RX8JW`h6h^xDY8pPgQtR$dEk&EUSS_UQk>&xQOgL$rt?zYey`h`PB1VrO>6bL3s +U4yv#1u~`9=^)&~15V(3RZFU$hudSg(<2;mrYVTWrb>#c{S$42D6C~0N?K?PfrUvlx4cg;y<5WshJ&m +iU4_fS~FPg8tWrxM7q^aC9%RfZ)vZb-z!;zmrc!zVQd7fq{KZ3>65fhn@9RiC->}yuMWEhMrjOBceEw +t?%3*J8FNuX!i)V>`0(A;sTC8m%&?@};PM?Gvl29m@xO?^pWhYMCdw3s3xFLv?JMT){=AcBs_m&R3}F +bFzgUfOD`#>TQQhf%;J9s_mCc)Rquz_Mu?1OrC-?9zw{ETa^?w)H878%*LX>~-pn5_-5zgfWAv{IR}? +jrWD`&Y8$ZFl7RVJ&Gu{cy}TxmZ*t*1W*IcHiLz#)0I6cb1n#cdICHOn*+0ilh?r#QYlSn?DDV4oiII +ngJX?34j$g{)?n7k8?})fw!#zWBi!~TPL;wIuCN({HH{Z7P?lXJEGbdnVNK9ltg%L_1J)l7%L1OxaOQ +TE>8$F89H|LcfnCs_*L&HoQh-7c +N|V7Fv6*DuHI2Nm7!#c8NK>0TBZSlXgINcXPYZvkbH!s`i +p74e@qqR-S$jK{+k)Ua37gqyfLeel}A00|a5Y1kl=e&jTA}@47bLqkYdqo5)hVG4M(zFrOGGD=)B5&1 +U;77e@z>Bp`_!_-H>kVvm6+XcCNk>#GSB^gcrt7Ra7%BU}F|X2Oi@e>!ZK@p}I~#e3&)oZnx(XxyZjK +nn*Zy<9B#_agMX1ej9@`wT8quwf+iy>yllb$c(J#fz2~zv +u&~J>1!lq3(Hd`*d@gBZL}%zCMVx%%;@!v*au6#jCr~aq=!le`TSUH4`6P0P>{$7*gF*yTWv{Gg`BET +7tb1sqtYG)l#@qZ`bvxnikryxRb}xw)@Rl9)M!azx-Oza04J{HoXdQd;VyLBP*t6C5U`25`AVEhyH3G4@~*`k2nHKX_2J#~kBl(W@WIlZMq +PhsO-Z$Jf?8@qgnd3(nlJ`}Pj)9%6LDiY{lVT;jQD@ps2%QDZfHet?9{FzII6HJ3Ojcc7pOiYYf4YTD +OHtnRbPX^?u(Ikj9m=zRZe#R2rRR=1`^@TBcO5cyV5?iT;cP9P2;%FegdnSp``k>6MRB~9diIOQ<4vd +6H~>sfkJ0lJ+%>*!%CG|&iMJ#M%kXYjrW;=kxgWK--O?M+yuT2{{yz}AwtU^_|gVLZQtESStD>xcrkF +M&W|tOy?@&{A+Z219H_oXYnBSq>^=%Lgsy!Q%ic`J$DowsUJcJ^@B*bPIgID5!f0$MA;_Hd1x-c*>4}(31c4PU0mqI`!VKm5$qI2z12|{Nu7DB;ay +Z-l#4(USLKiNW(>_)V&eT2vL&FT-r=`f;i3!e`p;I%epD4_-6u^ZGCD}0}|4D{fu=jtmg~|-~Cl0gBC +3N9{MVJLgQTihg#*q0BmS^G8b^{+Q^prk!BLNV}6WtYPCNga@b}T*oi +WaY^*sm{$DocL#!VnBZuW2(S(-9(%OB(`wqR0hWOD|Ko}Hf>6sP&qchVOn`=47rlG$Gn;wT{e~F_t4Y +FbUFE(SS$zjZh;9nfZ%-sKE*JotqCx}0?27huIF&gqGrx7!kKl39ExM%n?=Q88I=g(rZFiro=yI&-s3 +kNKRbqY9DZMyoiJqTuf{cQIaM*%-O{WX*KvstRTaU+z!upx(a@QZXCaSr~AG|^xX^EF@CTfcDH6io16 +;yn9H5|x{-1dm^YDF(LqK0NxszC6x^esKoF=*58M4Tow0&l`cQ7eR~&88bnth#0^Nf>wudQ~xRiHX6;KG5LF{L*?0$VE4Z!&^#EFG{BMBp@D6`v94#G4ojv)_ +2({OSpmSRh|LVR&ldi2)7vR=-$>w_$=N`2qmCDUByC6g1#>R3?NVa7f@H&Gxt?jBP-naFHGH7z$+%5m +HuAQ^y>Rl8gZg@@+x<4YW7B#1aL%xeL&7qfarg)C$j=GwND@s +a0IJYm^AnSAp1PK^|GN6{2~l0$D2P0{0H>r4?!Ju3{}&N?*9Pb^VT~c8qSPh?&!=Gi5&r-*%H{8vdHQ +WV9FBk#(v`kb=(js!!9_s-$-EMs=8XzZ&8nq +XRhS2j;zxGFI1T~tkZ6UXqg5v^F-+o@U0%VZsrPQW3RM!=37PGV7nf{5_u6(WmBDsh8RWA^0c2iQP0N +~SjSnTO(v+6r(bOrt2gJ0(d;)@5__q}^oG0g^vZpzg_%`*D!mjtO<`bpRFOro(MnUIyf5&vDC42Y@b9 +{fr%LzHnG8bkTJMyTX>%G2H}qnZV0|h`lsAvER^;9579FEQN|@M6@$&kb+#x^l~sX^z$LZ$AAwAJ|Z~ +PlZB@K39{jqjeq)%;Su1>&dUSf%>F0pR>W}XR={xTR>*Mb7W4BXzyk)OyH +l>_N3b*H(fJYVOnG>I+yK60IM~E#fQA#BD}pa!*~~-cKcexOFr3DR8;H;_OXzKchWp%M@ZV?h4NW^Yy +P;`k>BLK1lcA^{(>`Kx*vhxwcqsPbp|_YYLf;Pq=J!Cu#Pe{VVPbv{G)w}HVHz;M*BB-q?Q0SvmeOky +BNn@BVuyQnjcFM1@Lhw=pakl6gZGQCsldCGa`NXNE(b|2!ZgvcA&xVZUO-(H)bW^R~|%YJt}z)1lmOcg@Uptk34 +0CSmtchjJXU|7Ql(p2rj{Gv&DrVuR;{W)!z=QxKGHOh7c*%BIZWVVuV~<0B0z)9>pUB-o1>^C3N9}#k +-dn4b^38H5BjyFY#cT3&new7(FlplZAO9z%9wEFVH#KGQEWsGmVt*tn2>|zQj)a0A!TJYh!4iR +goJ^3AIK1BY?N05Cxw(!?F(3!_vt26jn+FKP06OWnLu +xPJoEnu|!;XG40DBj|Hf1@&6(i6dN2i4PL>?#ICCmcJ}E&B5&yl6zsp!QJ*lFl^gCJTEP;WlZ1{1Po3 +7UrGo7~AwD-UH)q(w2P`P@4q}mWz5#+0AwQ{lPV~+Wj4`CWFu(%>8jKh(PJ$I2y8=>{G?>US&?SxMkY +w}_sU9F@8P|Gh45SyfNO*|%bV)xZc!32MQ5&fkrKv>VW;N^!jxyk#9R*eUCvTI)t=vDSjNtu~E8`)Va +oadt4M->tysrkf0yr)jp3y?_gHg;t=|WRAEIpLKd_F5?n5ica3 +MH4X?sP?HluWlhdmT5X%8iAXa{k&lTLWZ_-uFUL;Oyng;+(DhFNYn9U*kC5P4>l?g-vNl%;92{QeKX? +428n()+Hpg0gYb7jV|;2p1`+3|G)H&PoxkK+Hf(yokXL1FBHp7jaK5Fy&637O4n@GkBOqwAd6KHzJHaN3*lFUgws`ty}R#m^|~l{BRIWCDaT<`j{+gf3ig!LJ4&(Jr=LAzl +Ij-(!gQaZI@&fdDRCsQ3&5<~C-Z6(8OduNI^CxU&ZTHeQJ_83Jypc3_Ze0befWl#rQ(E?h8T3P|`-P< +Aztl#O@%1H3{M>&JWI9GR{NX2b|u4d9f=DK$DFsAv?G$QPJVjou{9c;U#af^!nSg}U}4iv3_@_I@03R +fsVVq6ENTiZVYDv5I$0jQNu_YW1@jaVsVbJ>2?C(y!yArWKAu!RfEkp+N!qWCtfY5xU~ghrZH!|gr}%YZLc(VM +g}p7i$V!&RW41zSraoAly}HLh8(E2S<_-4rq4)hfY*600ScT&)D03Zw#oCTxX_s$>&p(pSH?@YU}ImI +h=mM*xc|(A%`!8Ofi(BUtUScF*tAt-F<@LNKmb9(dm*R|peB9pYgO4My%9Y|hnQKW0GjKiIUZJO~HFT +AY>^bm0XX-8;Y%su1IbJe1Id7d$~N6M>ilF&Bs#5KBf3iJ`GTP#aT5j9N}(30-)>RLi+Q5JRGGV=6IY +#Dw}52n1Cn2K$^4%oX%opVm`O*%Bkz9xKQCHRHENE-ntm*B7uIW~OIrd5nZ@MLL4WMp;|0)<-}fqJ;~ +IYwIn0qi@&Zm<3mn*BmfFtK!Lev-T*Sgs91yK6Zp_Pis?os!%h?fRrsNZi3JGKuEn+z;3c +dYkpVNbFf>_XLUGq*v`-_6H(W_w+u9Ns#JQ1WuwMIK`(G>f9Ht~5=~xRd9P>q&M?s4ZM+8um>omZ?VP +ewX0R_W5l5Fs{W6=v3%&DCMg?Kd5ch+=1VS%r_&9Z3#n|tkOepKat$!aZL(+7uKH$FMA<}>a9x6?G7T +muM2bx8O}{9IVSS!&M-OqsTLMP@DB;fUzdAIOn~Rk$vN2^b((SlO8N>`WQQrrV4VT@2*$RqFqgM1>Pb +R)1xl`o9mMFdb8H9p|Mb64pw*7Gf%q8xa9ElD!F%oL!Uvh;-%b*qdORq=>KJY)0itQTSVnQ)jr=l&k$_FCY!nJVS_l!cB%HFrFc`Q|y@~UXJQ~D%HnxsKU6(~HB2EHzBT;B56A> +G9GuxI3Yz^@u`zFgS-KUhX5oo;U6%8a%ZXB&aW#w%?bigqIFiqm?t~^oJXF80)Z$66@7hKBTeBN)6#! +JTs3CD^e30*i~qiE>k4++J6VgX#ZP_he*lqMYY!D(QkJ*2t@ghvzOHVNnom#DBD6I-5)WF#Ej2_uW +K-{>x06_@KQl?M67_q`Ff2cjvI5-JDQKQQkpexMbTwS<+w2-HBJdN&VB5wELKPgbrPYWL*S@Bad4`PI#QG!*7!sdOf&ZBxqO)Sy!Up~>KM6Adob;G!?s +r=a85#MV7a2X8_q#LYMu2~JrUhKdPsPAs{ayCg4D+S<_zR@Ef>V^z=!;A1Qzqv?P{&b^-EqUw5LOl_Bi40MEZoy0=)2%3Zst5%OF9_62~B^co`7yd!%GHP65Oz!wgl3lmR2T +sr4Znuo&29+GC*9?uGc^fGQIozd?W@6)zCZ7)&<|2Mk9@P!u4?Z35`kA#3*Or2sBmD4Vr?2Ajks`i4y +fU*U-}gd;SD5fLMxrOBexh;$Ex;Av0UOQHn%6m$3#sd%Gt5YP<3P~aA%Tu}>nHZ}+%2Gf(>k@QH?r4Y +staJtEMju%hTrFod;zXYr%{wu*QvG0=PDtM7XPVkCXjX3~=9$249!iurx2robsL%=1?$dOpWv7c^G*LcR{8duY=Y>i(`3V@lyEa#GdbD(I0wEY4ugvP{` +4se5h1(V2%KAnsRmvzND1OuR-BpFWqJb1o=iw3lW5y*oWjG8H8TMa_0<|Qb;HYh@KPlssnuGZC1o`G4 ++|SbV7o2dWj9bwtbpgVci1N&R97wzO{fT|Uu0KmFg;%}W;l`#k!qP9@<^ +JO0ik5(A=-8iH)fWpAPzSybQa@^lcw1j +cDtjg(q*ERkdy;|NpVh=W3y;0oC`ex&o4j6n4N*dDTr6s_) +;!Y<~+uh#(<-=_jQF`T&#K_quArO0CMUMJLw~MlU#;EEYD#G)^Fg&*ht+wb^Fz$D44}SRW1?K?#O?+B +uC%$d}H}Od&g}W9=QPBM$D=um8I=;w?>p45|{ZhMX{y?V1(`)9*`l8y-^IAS`{_LzbJqaP-kOYBp +*>T*}^AU#uJhAs#@pSm)=l<^<*Uv8)bR?_N1rBR7f*u2MdNMVJzA7fh$Ifa74p#lT6&dF5_d>>G{WXV +}689{W1r&b};fp~a=U5rM_GL5W^|8*~bUxCweL;PNV{%>m!;!*sHGhvZB34t^=vgMo=fq!}#5e3mrF3 +6w@qgj5vpzqY%JWg@KAH7j=)os0E3J2;>cGK1ExPiC%;CBpY5&7Hlk8C|^-iEmazlq-g0;2o!hN$}ON +s+{yNhoU%w6m~XN$C{MbilDgT5ONvAfQcN3i-U8g;+QFqj7RfH5qqUHr&@2cG>_{A_3K6^ju{bF +q^)F67tnrdTeyWRiW(*@4LwG%K=LwSr0_n@nh>7CLU#o}#+KjuQK!>6@iu8SHbSM2Ztc$etQnT9_2Lg +_fLTFTxbOdmI$`sEsY9}=UGQ1yE>7(Hn-Q6?>K_$7VAaAX+$uU^u7Qh@d_#ikP#R_`#Y#R$L5DQ +Q0UM2bgaz^cT9G~7Cc}u*->Kwzw#ow80e7a;)7&78w>L`5>XEtUq%-+z}0iv0ifFJw7ZG)% +II%P@2`Z|@lTtT_bEtTwt|4`zycz8P?>yc2s4+8juO3is%ehAtBkX8>5Iu3omC-QEt8+N#>9$GTjLNTvp#K2Lr>fO9B=Jp)^n +Rc*vU2=ox4QE@M25-ABgz-d3$(oZoMp5)?_kcm!d;G0*l@@`hpA(4&A;oN4c=a&VuN;ils%^q$) +VJ87`P%anB4rAE*-n3yrRR4s}$`sUvmB0fC&gUPrBK| +^ngacCtRaSL(SyoBd(M}|5WVP`R6pR2I!hQZdTP$E5P#wZaCgapbrn}-5UXEVgW?!wzRCuA|doh;F_m +b9$YjvAz-riU@3*sd83hKwo>`3fkS{)|pdBLUVL0EHpo+ +}R2w1l{-Hc!;JG4UvV?oc)Cybyg6B150BamZb2Voh`S1Dpf@KuU{5qy;*WCUHM7z?h%Rf;iV_$q~9i- +W>|OCck!$^@DOc4-CQi4$&=k#{N3h`dVyrf`?yzXhx&{*_>Smm*}ixJwaB4DM3kQa~;b!jV~=TVK0BC +j{T6paM;(7QFKvEVL-@QlQ!>l~*HBvAksw33%>Ba7H7BH%5xWfYgTqi)*b*#>i`}q7Y3vnvO$!gC-zw +^8zUj5p(kbDZ#Adb(FV~*TJH_n?U=CjC2Gsa*>e^Lp!%J($Q6uAEx#D=TTNoyp-;a)^BDWZ=q?A +Go0kIPG2NEF@^?}@pr{p2JGB-XVIOoO_y~vG+8jyMAQ-WJo(1=hXubkSj^2)Jew2eGs2nGFcBPrk8r= +^f*nf?vQu#&JbuZ~%UezVHLXt&wZzY>I%;atFTAHqsshE!NW2`B5oEH80z%soCTufL&Kb6Ffz5} +67J%rtU%&;1F}7Z19!wdv^TKbDoen#(ur_MM=Zda3-E_Xbne-{Ly^4+eB+Hx-1jfKPxdJ1BIuhC}Htp +vpA_6TOShA+);gF_K!B;>G1>)L^;B!2JiVVwu5R|eoV(^t8PH*(a45rU8^$AYTXhjUBJAf;KQ<^3+M- +^OdP-DW#$E`399e3G_t(vN1Qn?L^4KxM(uwrXJN((MJWMiAa?HnAO03!5wjr!m-1kEIaj +j=X%iJdc~<7B5m>;umZdS9I{mAL6w$be+Jp1;A5DGv8^jZcc_HK3<=8VQv_x`iv$>%P&H*R7a+}lSn8 +W5zzhgOCJt`XX*jhJ5L{@_C3j6~&pBaao|i;$^3&8tUHQjF;rN49g1;JfO~*B%0#yCe +et7UaR&HI)@W8MmmQR5o1MK8Y7&;i9le*;lxy+It)^U>aaTxfDTAZ;7(3y!$0f?wTLh03|n}B?Tg1lh +Alk6Q3D$>Y~cZ7`WebedIT0LDQ1M2d73Ov=sRbySYuQ6hMKo!h7@|0vt*a_Qi%{H%+0$&(-kZY&VAF2RG$F2fvH*=18k(555`2+xKvJK>&SHGD~ +vCa{PvZ&kpB4ON@Y8bd$AzE%dvc!X@p@74osxy2J8grke#jIi&FNbyzcK2CnhIHe=l5zdoK+j}y4qTI +xJY`zFFL{>|MSY`BW9D(Bp?`8sCd`31`G!Uq3FCqyq?HhA5f%Q8z3MIZnF$dz3Q$MM$&YH5kIr~R|tp +Y9_C_iO4#N&}wEU1y0a{*jZ%8Ogq3QC_qAHnBV2yxwbK +nTk_m@ta6O#%dE%d8-tFk9B)I@rpC2&W2g>)RY;W3M8V)}lD}O<4=uJxd^gd|@;QjT$H@0VoO~MrIdI-_AfXEv%)1n-UW&INV}kS3{&> +ISKpDwP0bICH8gpR0kJnwxUnxo-u@ +zy6kG0q}uct&u}+?g=gJf=EA{>j1e%eh3;H##Q7NLgR9izI?)lTl(e!7?8h4iFMPh%*}!Nk_wBeao-e +LHgutw>XABh-0A%gX#FkY&Hj>KxjOW$Qv?j;Q;OL-WjEOEwrBD30ljKAr<1@ +Ch`c*Cqmc3$T#Tqf?J{lc;nq{1%lX4O8bR5&L21!;!OQIHc$QkFM +^d8#NNHo8*$s4214Gdv~EFO%lnAd{lRNT!DCr=WMN**x5~htqnt2Qc9hT(13Osgpk>6ugO0l;@k_G)5 +}36*$K|RUacGNdxtlm*w+E-Z@*~$srmo;53UeS5%GMv?akLwIl8v6daV7+Xyfr~Ik&|_k$9O?pAe=ce +>hPA2KA<>m`2&O#ymfxdM;>rmZspfgjnLfM9X6wV%a2{0!(hE-Gm9QdyrnNInx%D{ib`gHi%QTaJ&i= +~EZ&O8F^u@$^6j?(qIK)c)tpf5@!(^1x0!Hka9!j!7hOP2^4qUw_N$A1@CI`Vt)@Qja&jBZDGdG{j*X1V!S~xIU{>+$s=8umcE%LK7w?;BQJ0ox8@U +!rF2yBd`6~h)b@QX~1!KH;SGExU;hrbz&?8`6wm@Dote2L={hgAb?a$iIM&5X?#d(_YXJI)wP>r=%8e +30XdGoEG&zc}NG@whQx3hN``_RGzVz`A$;eea$!=9K>!Z{uD0RH=?2)L+f*{h{|?Rhj;6zoLKs{Q0w{ +8U>2#4)ptg&H7EfPo4rcXz0u%03EPlQ+DtKuu(G$=D1S9#x30iV3P)BBFhRkZDD=D&RZC@JFD9mKBcn +rhHgY=5$t(O_uRnd{RTEiyYoRi1~b6S_<@)CsD)uZ=4SlR?%a +$Yc%HZ8XR@UftQ|jdJ4?aZ@q0#X%-cmm^_lU**w4-QVb14f{HWb_{N}{789&Iu{CNwT)p8y0!YoqG24 +wkxTIdhH>pckf`j5KcgW05C!}K2pHf&)-z$Pth0@!&ALw(b>zA5UP4qDg%u(pjU+L(@7*a)z;-6`6gP +FvU%uz3rcx3FMWB)6mSU_PB`Tu_8b;^1ae7ncXiB-G%f$Y!(2{LC~{(>Vo-ZFb(Dc}pylb=8CFUxIBe +i?C=B^^XP{DjzW}VvSobFAa3xZ>O)1=?nJ*weo9l^%vliu?FwU`cDHNP0tVZY}u=Y&X&Gf>}>g~1<#hiTJ&rgtcA~(!dm=nIjjZHmPG +wy+(O3;btSYGO^`RzF)l&h*u^)HR;(P?RrL6HPIPuuY_jFK?iFJniOw5Tv}G?qbaI! +kS0M`yLDUD{dUq3A^2lrAdV27|%aE4DRm=9R-Z&C2<(19u2(#UfR{f47Kl%Xk;Xk(!{}S}elLI9g@-H +YnA9yLXWFaxhblMXgrqKMlsSvvjB-{ig-#TzeJ9-{m8V@#u!O`2uD)Us`C#CfB*eDTL1w>)7`+*t70B +HbVvWSz~%<={CozZPK;JDzLk-J9gWSy|!bg?bv54uxpidY`z^^Z^y>lvF&zjx+k{W(;M!I?N&ji<7tv +#59afMD+?92)(tj7%WLN*+~WKG{m-CPtHa|Y?VfY26|s>IMmAdLslnJmD<)>gNhSh4vC(pupE~Gazdt +xi;~ht; +FncnX3wp(S&hpE_tOc$p^Jo?GSs7A9TrtM$WsYTp{JEw3;1Gy9P}oJLf|oN1X$vkmGTe9BAb1$Vh4Y+ +%W)Z#6<8Tl!wC3=SRkOIP6}vNj{lb`+Eg-<1`%>v;K83-~+&UTpNR;FO7BG1@~Irz`0|ScBR= +p>346s9iQB9R~|7rk2*?aQm8$yv0cthE62Sjk5zH#h$N|U^&YD$z*JY@+JCAMXX*#zQpTl>o3#kj!De +#R+%_Gl{&J85gB-ZXp+OE^#By~{^E<*xQFANQ_%$*#8xwsE1yruZf)<8ATqkt*62{OkQqS?<64_S>7An{RGL-(>m +vTWz|2`z9zi)qmc+zW=ML{=WVQ`+e19m#QjL66CvNw|@Aki1X&}N8eSQ*()+b{=T}N8(- +Xp@m{|u^w9jp)c+e$O9KQH000080Pmr;Mg?vhtp7v+0AtDl03!eZ0B~t=FJE?LZe(wAFKBdaY&C3YVl +QZPZEQ7gVRCb2axQRr?R{%^+c>h|_xuWua%Lmnv6M&myt3`ybzVI=H?Na;9=pCdSz3f-jww=2QdZP`` +oC{g0U+@tL0NX3zO9oJOC(SL3WY*dp{g)1i)Hlb(|ld8OZMqglrC3ASx50%Rb=a$ed50lqa?jdtF*`u +qjjFniiCa2(wdcVR^6E+h*i3pe!66NQk2sw{Vd^Z()#?vC+9r3u{t{D8Hnp0Ue%~$KXs!J9 +xjW>01!SeJcR+?3yFgshPS;9)ukE!}-`spmLm@ND{E-!2l>pGQVXr9fAysG28md~5tvOu+pXYA>DT*f +m%LUkC$)htc_zFM*J(W_zut#~W4SsG{0Gqz+M@XuMCr1_$+*er?bSQa{rO6|9=5+U;hC*Ux8&sK3+vF +D#>Y*o|j=JArz==^=Fm)Xm_W{Wb$D({LkuiHK>^4c({%wQsI}3ED%NMwkw&=F1*=cs_Y?kmth_s*8Y`%P-Jtg1{n?? +Xd(NjEM#*4-=h14aV5Awm{BodT?L`?c5CAU=7_Q?qN8AA`7!5^dFj{W|c6=jmzIC7uc-?uCd`j4?0NO +9gmidk6>wJc*L5!3hM$dRbmW+`nidXnSV4ptaZ1d^U7-1ap3OIZ2F1Q8VAdz~u)!JS?jPFR09@78aD|mcmLWT>&lycEVvwrT=P? +QtSr(nObigN)CDRBQ1TtKWdqgwn&1CfA9u4qX6f0qkLM7jD}#_Yr;+g9QwLXNah +WDW7cB))X(&+eQMFA?8-OS0fUjk|#om@|mBAz>w2;|!F-2f8Pz5!(IZtQjh^k9g!j4xJO8^-!5PaJ`* +nqV;Y<}F0-rKVW|FC28w5)0|d+O9R1OOB{6;yB}$f1Rtig|)@Aie5bf!=g;cCm{b=*=k=#~mEJEiWhL +6Q7hLMS9c<(lGJ;>Bl?zo7Fk;40w~k_{OJW&PZliC6;8$|F9N4Tg2Bl&oU)SYa%%x-%Bxte6XEYwxoJVh +PB8RTQi7f%X0jFnXaq3l$eeAK`)M@Z;MNn?>d{ej4>mf`k)X=GU7KtmxEigP4fbx +tA;lT2j%17b6%L(0b(Ie4h8x-VS)t{_8W(Lc5)9vQPDf`9_7nCukV!@#JyigIz*K51BPPpO_wB-cNhM +)*Bdsc>Y_wRUtFO`SPNTS*#@J(H?Zy?~?w|s0L&j@9*7r}J0pdD}%}d<$S^f4u;XSfN{{DZ1oV9|{Z5 +!4E%Gw&y@m%a0CYJ&!=mcaO+^k6?gYPqG!D;rKR)8X5Gp;zp0l^J5x`a_RGE~XExv2qyz++Gu9{)ca# +Q!5{2w?zqqry^qfBU*s}Gs +!g)6>HlhQJlbO;u^m8npP6?l|l1Fh4eW%Kk&p^K*U?$d5P%Dujhc#Q1)9Hwtk47KeBLxvr^nQdaOG1k +kW09j#wc)ntX$$KkY+i9*Ww3b1-Ywp=@E!Psz3~W{(S1}bMu&iw)hbJ8gqQoD@!=m3I|p5>QI6Ka)}e ++#>_MkBPMzP^fLPEJ9dMf(m0(w{MZOW)>~R2I+Jq%f75al^|8WfpaHcr!B8Cl +{je-xWWhLUv2{8UGwQOq@xn*uEW7P%d=G9)j+G`*78!j!Y+FTDdrXfnp#rd_pMN>9wFPtPo!D{9RAK< +*jOAnZG#=o<9>6Z?<*@GAREY+-N4(DJ_H73=-i=Pir!;ur-8ne0v78#6X>?W+MxxUZlFaBMEfQFP^Ro +B})*MU-Yq_0~0g_kj4h*J9P5HgKltRAKG2pa`%9(g%cpRM`MmJ3!t>6KV^gW +jJn5LK+eyur8=GyGz@m{-8z`p<#z6dF??Bs-nj()61(5YEl(oc4$&mSDQ2~B!2EISq3hQ +r&&>vIPdHO7Df(iS2&(s( +Fu1+_iJJRwQX|)GSb~UsJTiR{ZV7=9C%Cf|ehY93ZrNY*UK)1*bGq +CGs2MR%n*x$%^kxCGgzAb-Lg_FE~(!s90rCk_CDEnV9& +oNokGyflhIj2S%^6h2C2+%5ch@i+=bhvnkNhRC^3G(F|>3asb4=k^vg(S`uh$bkq!b_#urD8Fs|in2` +SQ!9Bphz28>GHLVQJ!b1ICx@f#1Ws}DFMk*{%_#KU_N27oJ>tB;~4yDjgI-wUp=u&Sz0jGZ%4upgf=B@wGs{gQ4-axsYevidK=JYD3*xk3XsmF+`(-UC}FvcV8&6TYGshewj62hREAXAz9bq@OCuGSrO}&eUa}w8u>Q +AL8Xvr99ym$^TSuNO%f1sojgqrCo8eI|7Q^p&Vr7-d($xxRWesy&Q9*d{4j%lS9+;)MQe4f-bXCi-iH +9HPp=*4yR=v%bSqY!H>LlrW4t!hspb{nWM^EJ=qXw!Pavg~`+N9qmMP;T1%%O|3d##qSUfyw9(rmuy^s%_{kVYP +vuqgyseZ=7{P%1A+gTRjW-MRS=WTfe{fa-c>TFkNLaKP-?K}R%E>*2SVkEQ_8Eu=xVXu{dAw)g>PS(XnHCXw+Jg|NA*h7w6Oh|NS@q+gY}m3;xqN6a3XCO*mrt&wt +WSt7LT{){+9ax)A0o5A^CnE9@+lub0IPwo#5@`1Mx&GRh(MXlVd{xo02V;QBHIV|w5#jY3IHvZ+>w9>1r@R!yScO +V;8+K5=3Km=GZW{#xUQXIt^k8a3>lEUwA7kr%Zvye +uxr7f<+B&^nNbI^w+4}4-D>1B-(Dl%v(GDF40@gC@|jf!J!7~lJ1>vFU-RE)SrihB`5aU=DvCef@}E} +8Bw?2+NvFJM@~ru7l}+o}c@2_6#f#$46Z&bET$gh^qyVXb*r53Rfqt81w-rcy8L-TCyx^tj$t(H9C|} +2C8M}kRYhfoW%qI+j(F8_rz#Lziq|E00m7F5yMfrMfL`9v3ar?tFwLMNaH(yD2Z28 ++0+o$ +Yhuo^*|Du!rbFLvg%jsMh0#Dzai>hVqK3c~vYHtmOQo#K_X562W@BJ#qLATP};?A&p3#Q8YMyqGc +SIzq4kM7jc&HhCIgIFGcdS_x5I=1V`qJF3Of!yWQzCmy1Zn>V#wcm=U@BN33psR*xP`8M`ZOh#uR<4y +@kk7DMDA7*dIJ)a==klx$80EbcY^%J(D$607aonZnU83zo&9h_GQrRRO-!L +!5y$9fW%u{IRqj)%w;H7`hDYfq5naWKfa&RMns<|vNk`HA^*)%bYF4VMH}NN^D~9!ER4bcD%sTIS*M2 +aa8ZzenFQ`r_Dj+BjpqA;qD|(BBAgbiDhfs9(y#u!PQeoj{~}om-v6&)o>LbyEJM-xdXC7g<(pPU`)?x{7 +P1;*HG}&CV^$bd$s?lM+?(1A{8jd*cmb38qgVHH@gaE&v?k(Q`5(0SyXM90-YlEz=qUd(+AQNhTB?@G +zaCzl~fQ=KQW_SSlRa5tVCs#IVoK1g}s4idpMbjm +ygU}Qtt73$U66BP6Jkc9SI5Gz-R9cc>mEckcBeP+{x&nb;fw;A*yNq>6mF}{j2AAntFe~vRBKMY@hdK69?lPT~1+q;J0#lciIje!o +t+Jv76%|)Q#4C+bi~8U3WgI|mAy +9&8ck|6m-G5QU{Nv=oH5$3J@u*N&|~m!+Qpl6v-q0q4h|sNJDlUy)IhX$`o~4A +SsxIKRx*K!$CvU0DzwG?V}z!psBw3CWuf9t#rQxxnXBDo1M!&x%df~QXI$+{dJ+9<5)q{kbU`oT%!;R +g$Bd&&Q2k|{8PLZ#J80dbY& +me)rLChdsN0`S9U=cu1L;9!}KWP2qK)VM5OnXr>ax5BV#Mcf>dK3OC82_--p&_;%DDLJ(IWi7OL@%fK +{fhKv-D4%3f%2HH3TD9_BKe3}_B&bReB<>{|1=f3Waxk%^g{TX~p;;^@wCoz+=bv;=W^#qg0RU=2PK@ +AILjsP?4&**BviOArN5=l?$c;Tl@_2bRKu-Ae1n$`yo6J*I-H%Rvx>F}Wy^W6xo%@4^B9iB8x#eME@R +~}3AL-a};l$~hPH#Wt7{JtpaF&=EEtjYW`9?4{YO+@X1V|d|9A3X+@rGGan>T~5xJ8(w&5{X(kHDKS^ +G0Q%Vgo0UOAXcu#(%Qi5VTY^cNuK5Vx}OpB@+zzU;<$6%IJ1&lvvg|3-{r6~pN2IEE;r$nKjH8~I39k +2xSreXCkT^nY-+3r@Zmr54EJGqCw#R0e?anpaFK%>Y)lAU3<1+!_oR<4u-!ph7!oERjfMp7cmsy{?f=vz^d(f+C>+EX^-Q4j_74=ui6!N~V9sI +c76cZ$yY7&D60jdfp6PRIRQlH29q{uC2W6z4)_a?7y=F^pRe@|bcQtdhnv+KC%Z+n07qg>r!1aq4Tr# +ib8_98ExItV+e?NIK`3ra5PVvsW^LTcF*WnW1%eK*m$xvGB8k`m;^2zuN +&ANr?_ +wBAgsxgvTGAzI-{U)+>fn8*Pg6qMABE(5*s8>b=HOiM=OV%;BJsicI1?g!>v}%I?igcX;Hxz`xZ}>@p?l$KP_i=pE1Sk=Oau +E;{JSS;|-a?5T^Bp<_5libC10TU2`L{c6(9jQ+x77YK=Z#is4R^e)veWORpUOB~7iNNVvYlj_R+#K^= +U1*Vkys1Z8bzpf6PC~Iy+S>GE=-+t>36g!>ge~?DEhr8-9ji5N%?f?`KIK1jmX?pfws-RcwCd??eezyO*5I*7A9&V>!k +D4a@+-Myo5t@XT4b$(mwRkoi+~($`5z$BSCHime+LgmJ*JdkVt?6ylbQUN!$kSuA}j?M)Q2=o?9h{3o_m2ZIS)O*>%YS_Agv@_o>O<r|eL~bYpV!e`k5p!7D7eQf`Y^^#F3_w(>Gu(;w<3)%N;AwSKdk^SItDK*3ww$E1Q4I!aGqjaT=@ooW-b +d)&Xf;wh~rc&Fzi&2f|t`**gT=zlI*xs7IJ{L@yy!25b-*1OSvGPVNwy<~HKJ3`8HlThBoIE&6vc0eh +`?2nVA#EeyVRc~ +3RGd_a2N)wKute9Q=xGrk?HN*TabgGm9K45a(C~02eO#r+&-PkiqNF<))%~QOi@O>e(QSx8w(##+!fM +Q-t-ZpMq;#-qN5Emeyr+iK7NlXnE)S#KOQqCNk$%d;n%y>y0YMu4Z92)r9I~PK+Z^SS8hUw5%@X{FPO +sq=ADXv0I+B&O+CH0EGa?d_xRySrIp1Iq~Qko7T@uare!iHYf%vpKVTsUtw_fEcWRgh3+ea*|gr83T5d|s~1F8ph`a(fu?q^*XB0Y3C}7xplr*wW0LF`}Y$NhrQx+Xb +T~wee`aT08$J(xe;vKyP^Q6iqVS^+6K}yU2yTLa^WmD&!m~9Tk`(eTfg<#s+KB|K^_ZbV<3>4Y>HwT^ +uBagnhOuz(xR%-E#zsO5k0eCh^?e4s8flGqfG}oJX4JRLwh$Pl<_eVb*s$jL2lKT8$6%)ZKbXjJ$L-v +wH8TQZzdUeB*n8S^2HcKLzjfwMye%Ozz@z6R$a%OApB^TiT3oL2AZZIWHrxYAUipA5y02Lz&e1kdjLu +$~@5Silsd!keo2t_-*z^)g&Db#w+KjqF$?g?LoR}Sa&1m^a?j|RxEB(%#p%Duf*d6-y!p8$VbHV${D< +@Ps$jr^m0ylY1|4SG(4jpU4n>P)M^hmyc-JNzQV)|vG;4@hDXRC0i;XZXwlWR-Gzt)98#z-&`K|2a?N +dQf7WEWZ+?argLar|^w1$$pdRu+k6c;#;O$hV<)T9TmoR!g)YE#m1w6UDg-OLWyz;!-EFW{IttY|(!j +&%`sV@dWcg0k+upS~Ji?U{k)qb0$*kApTUj0!}b(z!;kdJ>Jp<4e_x>B4l#2e9u#{))W_;p=~`aN+UZ`d)mRG3mL>EXr6r1O(`-CLFDz>qeP&ubN_|bYiMcUs=ZfdUlD=YH +OEIULJmtlxZusVKrHPx{ezhv%d>>bhS?eJB?kM`kT;}eQM^MreiPVWmX_Yo1@>Hz@VTn;Tm&Q8Gc|e( +Qrjcp)AsYExvE&nL31?mwKd~IoVXO_1+bawaFy#0`d_2M;iH6b*co00ER^eI>Aw=AqiJ*QbL}wW7jJs +X(csXw@AS>4pRfJu8dV8@9nq4?A6~J`_tvHy}o1p3JqFbCc>}^qmmtzUQ8P-$_;P`- +p^7SQZ;IpYbNn=@#e&T8E`Xk`CVAKzA={WrYWx-?6mALfdV>c%@+{i_)alRd&qPJ|5+SoYHFe}i9Zq~s{W(MVtF4F7q8wlV>L88(1Ooi4v=Ly +HI4jSD@A-2#iz_$_G$g6BBaPd;yOQcf!u6GV#AE8~ +_7uSKC`ml#~;>fjVaopmpG6@s_(KQUJqX#ieSfL)zEtNZACh${3>>p&}g>CU&pvI()7)}b-S%!l2olk#xdaj_O323a +DCc(M8aK2^|)gy;yF8h?l`_^X2q-4k4(E6YGy68tKm+hdZ~tGX2j3WBLeb9$P9Eo3qac6KJ1$(sy0!@ +E`F?!+OLxC;u^029@en$M53<~eWxPc4qe$Iv6AE_T4ChyKU~eD+Y>3H#Nhpdy_K9;^B_7EJxUr7E* +oDVUFD60m=Z2OP{5^!}a!t%ATs5-=`Bewt&rX{DyEbe3HQ +P>l*8Ghc#X^jtgj1hIRCh4HO$&BU>7)jr*NGtVfA7GH2FKli-3Jf$9r&OmP?T}WI#cqRJ+xA%y!OYgY +bJTHE8PI?qWrr&i4fiXeZ-4JNx`c8ULEoDK9Ogzok&;exUCUwxWa8uRi>E=x@6_AzbSf-RD{G-Rrn-!2kcp&pGPvak(3i-1&JO3t30uJ?Lo;HYm&o8C``|e6q{iWegXKRV!q6W7^DidgQOrXEECy@?Zy}w^S|3 +gSvi8jmlp&%E_C*?Pf1TmxeZ8Rwu%3|hJ{Vbi#yao5;2QC(VisrVPjrQ5WUh6bBxq>4szWA;m$auvK+ +vbft&TMyM&wgPnGGuzm#`b2(GdlZ=rnpx=U)7IbiuZpqD(5FVK0^xM-$}wUEq|nwx{Vnc0?#=uY5{piM#~&_VYwpqabGK|{dzqd*Ed3+R>GIr +HLr4C}z)I9d!@qUhL2hQ{I(9vC~ +u?YT*T$8t)4cK}td!GiF%Gcjhsks0bjB5rp0xvfR|0@5|vWCk9ZeW2*#TcYHLk*s0x;g$|O#qYFr1oB +)rjHeo6Y`x5Xpup6tL83A7tUgzQ^S;OpDZ+IKH +i;ha{$2HyyQBbAN%Pg;2>C&WImx$O!s{tOmSF(V8xV%HkQSv;#WKpbvOVatAmE7qBClAdGn0oGiMiTSeD8@?+7CDfQZg&q&XQC +t^bEP(MWot3xT!T`bh)C8ZEscq{-R-1e^j%(HZlOFRGvoEhomzjS)x1*-(BmVoVx%|14&45mKE*n4av +T{e0dBWLn6E2t58XbG1dr&0ClR|!KdWJ)&rbMIbM=REH6AL{x)gWyH3YtcID10#dg;>__Y@>G;>TeiZ +<8kU%o{cCG>i8|!#{fL*m0Tx8!p`4*#TPSIo$H5abccsOJ?2L4Vs&K?*?iw=?YqSB5#2|k`PbVfYjEs +|8X-n2_!`cT)HNCqmfb+`Na#*LxP>1Z?hK^Ig^XK$zBlWw7vHr;O7QNOAHACnnZdv6#z>=or`_9*2TpBESo;4H6LDG{N_3l3&6#-A?wQa42^I<32|>7r(1<$H9Fuli?Pkb!+Km8xxc;jG98?w%{pjRv7}aR?L1-+|5l|B`g1z0mYP*j6TCAYDP9r6zjasf}=aV^12Hq2za0N4pfrw_?D9#o|nbzk^(=g +ZEw^3c@>U|pBkdudPpk5G(O(|lu_i)5_{Mr+)&Bz~6Y|yn)(QHRu)xoo3 +2ky;o^g|V7K6SepQUzUFP`}j_f<4F^FR{^IBtA)xmQn6vO8n-hB2<+pgsqn8nBqQt?5aHYs>**jqerAaJ-6QSYQBDIU@~urIuwn|9oRp}Ef0*}qMXkx|% +fd#n^=yQJ4-<Z`)*^!Ucin2o=7wN2#ceG)ZVtVm?~%>9K-?(czZLQ>I +fCd0Y+>VVg<}D=v)YzU}vXMu&R+|hvQ-cjteB@R!; +XBae;q=jvu>J;gP;|95lItJ=&K^5SAkM0yj|Mm;HB;(w>ZE745Z-KbYj_}0?7~*A +Mj78uza2^$K@(ZG_rW`MT{)W$7|kYJ>2pcUt!n0FDwt+B1jHxVv-yo>4O7)7(***N1x@6*wbJqYAx}4 +nSNeh^$FHlGVjVDA2aFB8tATXHD4LjVKLNPZS^PM;#qYY3E%l@h4B{By1S=JMyd;19v0MIHm$(LMp4V +5(UUjir7FFFGAGv4My`ni!fVsr%$)!dy&Q%%9$uLRsP!d?2_sfCuvN()i0UFp&F>@@C`;u(dNOUl?B4 +_p_$8$yzGk!gV+}lHVszfGP*IgzYDpZupaC{Uad)0A3#}t<1OVZ@0I +9p3caTfjkm=feVAk5Pe%7dba*|@1Jl4RBH`)5U6!&f0(`>4#`bs7LFABxs1^xbhw5owM_Dx^;zxzc!A +A;mQuo9}88OsmNRRj&9FnPW&?whh_RkZ)-dFO1u6I+1b>I&S)(kKWSc}*>Dkw?Isuzwg1_Afp;? +&`Efo2#1}P`pdQP`2{iEX4Qs%NN_4X7;l#9%&KS%$-%Grj`4kVjnOMbqTn>=47+u0HS<}(KPHprzcs +UB8053oH&BtG@7ibcA!>y{qxT-BHd);BO+fI88FBPy4xo#4jl|Q=SiW53ZO&gZA3O^yoMZUVT0v27qws|&3A19&dpE`$dG>AjG(>7|&*^5Lp +*OIP5v>nauu)GLm(I31-CA#?+=j&O92d;c=P3Z^r*u(ShM(-Ipu5wJ0GC*~9+#&3X;KJ*wgGX=MkbY> +?K9oR%+Y^h-U!a*1o7?f%@3~~t&<{y2c)A9P_O5i?G>VY$S8ITsG?b85_OK*Q#x8T*atsD +q!-xe1#W7kGWdO_EI2qflP>s`&1;KG&`DozG&+yL2f0$e-{XN@Z6IR#WuT>$J+D7c9ZvzALH}RcsGu5 +#v;0HUrh0vg`Y82L>|SD<&ERW?Dco_9{`Hvl~xMYh#-86VVb#1`*B1KvSWK~;aLXA>4+I|(9@INn3N!&q&=h$;<-hY+(BoJY0jBKXwR`Swl{Bo&W8c+JAL6ld%7*}DBR_04?b +X``Th8TH67cl6P)~X-SEO^t=okXKi2Iw^5eT_v*W;`H>3ZTKvFvvdOZUPsERN-$vbr7AJhK|-6C~=`j +qBr{pph+ZQd;)alo-b;Z%FtRo-4;#%1Fj_k~~is&cFL6>cgQL5JFn${*<2!T#=19&*v2$@F?}XY0PL) +Vobf`a>%7U$z;zK?uU_;V#~-Atd8|N8F0so``IcjR)@ddVu`qlMQs(vl<1Jj(z%>-n6 +U!izlHM(3o#0G{RsoTQkoNdm)zW)^LV@}k;hXTBziQaG$g1>$D1jSu8zvr&B@al5F{6LP{`A^FMK1c! +P5ZkkU>g};@o+QBd>4)4$a1kapz)wiMMT6vMP#$Bb2Mc31Y2_UR~l`!Iz(CS)~b5TjXYuno6UW|_hQ>}wI}n%>3zh9&f+3(qgEQFb)A;3ypQj7BiB&M; +dCHW(m;1E1VQV)mv?tv(tV(H=_Pqt_2Y54oN<>9Gg&EkaHa7R(l$TfA^%B1SfM+UMXEF_gmFa06^A7X +X2b)2Zd|2<8>p>sBw-gbHrHA;c1s@E>pHm&ke-Dq*yy&Bn>wcHt|F)mlvJ8&3E5ljM*o!l8Jdp-Y>MC +ESig_b`W`vwG&gyYTb4SNLcE|5QO9(4i+q96@1E;1y#iw~Z?PK^y%c

F|r%J466&=XS+650V3nv}P +!aI}_omDfY}B_ys7tu4lNeAW);*4<_FVflXI`z31Ww9i@^<^Dz(ab~f{dfp%t|M=!kjVOEYwtd?_j^o+r)KOX)h11%XZ&K<- +#Y^KIRrIFqjwm6Bd|tnSyNRB$Y)da=SeWd=i7`?C0C^{qrVj6L($p{+d^w2MDC8$zWZhZ1g0xqL}gq; +)d+FQ9aQ|8^Cp1-nP`QaVI5qVSDZH@g)eu07d{oWsROG5j+=xq*0<%&O5~i_P+=<uVx*f1<)_T%t1Rx9t;X{<~MhL&3@j$e?p?BVLJqX`BSyy +-BSA@RFWl1f1euS8wdo@gcUwHmjGQV^l2uYyAK|j$O==uGKYj(md2*_zX7*qdA?`^_J%b-7uMYJ7< +?50+%eFo!epnH6lM{meTt$#;4-)IOJD+!pbyL&a*=fxufI`(P9Eo)r_ +4*E6{Ki>ng&C|8xNedBn}{h+)}R_-f`%w7K(dcyjPg9i#9QlHq?#c&G)xELxb#7tV@VLMdB397R!+a$ +ZmTx9i@CN>+Zr&ZorYRwErtH<_D*EFl;qt>j(r`AK0 +%&NAUT`-ewWra0M3oa-bt{Q~E~aX4QYBgXlYUkR$1nH$+knydl=(>o1wCfVa(FPldlitTLMkbRW{X$MeO6DYa1FT?7M96T`$xH#T<=Ve-Nyy +3oF`o5=DNQKNRGhSJnEgeg7HQ21+!Q=;3+bTen!6Zhk^i{h2jS2NI>F-i93Ww%Nse2WFS{+KI8f9ndn +y51n4q|-QiTO)aJop(g@42{Y$CTfta#YCC3XMc$ZpW$|%;2rK7Wp0HAY7tv|WwW_Ff$z1Oho7i+s_{m +9`;KK9(srojzSo7PbJg8|qdG7}pNo34?_AB^GXn_C+M0yl(;4KSWbCXCZ|}|oE`g5meUcnMR5?D0j`J +;Me2uH9$fNUOgI4$IJeC)SlE<;Kx%@A4^^g7MUy^^Cr(dosJUXBV&KUxw2a?!tO-Me+&jEzq)NyRy?% +Z1DwD)k)zUw*F7q`b0y_dr(lZW=7R_W;PS3n0`gxBLMybH-(pCZ{$6ye72UHBn>hFHu4yt;p5H(H(F* +o`c4Ehj#E6#{m!w+!Kn9cM&98vC_=l*Q)PX!^Kmi$Ktz +V-(oeIbO`rO6KH8A|f61@(0=iwe}W3)*cNdWtU~+3U&=-G&_hId$xCIm{jf1LRa3!H;_=~cMJT@Y*DAV+oCnZFS8|a-$t89-8T1|goS27a+Fszaa~NVKH%g!pA{N037^J{61ZA6e+qiSe3&C^|)3Q +x`aX-r)RM*ZK@c39F=0lYVFUjiUw10h6q?S-2+&0ajSO2_$74V+Pbed|?Eb?X+j?JaK%Qf1>l|tjmtz +AoB+A1?-2CR{&F9sP=ZcaH3mXdCvZi<`Qo*fqf;;&OXz2U&7+pcjs)OCf^_?7hms-W|j+pVYuUOl4&# +FR?csXZD>U{SSl?x2hrE{kY4vu$K*o98Ab&!vdxE|cs&TR+FvuS3!L8bY#qW&Can`<@KruKDx}u##xM +N|W@L3D*kIX!kE>b%kGP5O9l$E=&)M?fG(1MI@!qkv3=)&H=n;fZthB*iXu#A$Kh4458D<@SpAFvZ#n{qwnr>GX5U>{ay3DvTg{N4xK_Ac +Hs*-4;Em0&TV{n2#s{Q_Wp-A#F@hlql$BrD<(lD7~ZvK@h;m0AnWazk~pA`O&(xp7dwp|4HIspGYO;9 +;?X}=v+_XEEu4GlTj~wwlHPBI-DdLkZ&?q>rE)XuVjoVSL$IV_O7`E2q&}{Cmv1Lj?0fFvI7@5TWk_S +Gn*F82!qtmhZ<28zj7Kgu+i5ZBy+Y?@9mQEyG{b5K{iS&S-RQ|0_v!i^Z{hlMGJ1*%r1?nGx60WINoQP;eGOW-AvGVH{va~7H9{Jf#+I5K9l<8ez#ZGzBUA??ylFMQt +x_l#Yy&N&aTY1hMZnqZPjyM3Bk}^lAaPyJ0O%#&P8CA* +B3Qw@`Dapn4q&|lGi%Q(xzp}|f@8&y@81@9evOE35px$86jXB7^w-SB +9Wqj9dO$FR;UYvA?BF$g(M{=Kg15C8Z976c}&?A~%#Sv+fK{^wDg)r)MqI!A>7zW+eqyHU{8fyUKp&s +g8p?@dj-UqG$;5`XvA&C_LEvssZ9CDrA>pVIHJy32wa0-6V}i-7E)vM^nYMYkNc08W}`Juqfjx&ldx@ +QmNz#U6JvrOuoIf#nHSnX@PKwYLVL2YObfpLspP&uji5p!RZASGAf +AS=sA^THUHAY$1A72EsX*~b+ItljmS2}=Yhal(S*!isSC@;A#o52fnAALY%OCXArtPid8zX&x-@hwnY +0lzuQN~FMOa*K5CqKw1J@v6zoT>HslhFF;93b~5{7!q*FS@0mJwD~i1V%%s!i23#=*5q;(x=)>&viTd +Kh-sgV#yaTUOdyYq?42FSk*%2B}!GSe*2#uD>vS$gx9`wU8zLx&8s=R-kf&J@*XU;=sV9<*DAhty;nv +YGQa6En_4$MBIYbIp}LmB*W$RS2=e$mo^dHZ{RzD)`>^ +g&+|lu&(c3{w7kptdJ4J-+F4tV6Lt96Qjk|Ke!ASm)!y~pUmf87%|k* +dc|=;}_i7pWiBfQMhF9kx^J2>?${Eg4TyC9kq-9oj)$R=bMgG_2m2Oq-xnixeuFGw_=!&<)w?KaVFz#O%=2#ap)OW53$R6LuU0?+JKl+UH#*^rl +ssHn5}mPGyawh&_u8UIYXOfUo_&M6z#^~x4w3PFB*bk4BHd*MV<#~ZDxg<1-OGtrWO4Z*+eWyGr#9*o +sX+Fg`hDnQ01r%4{tyK~Kq7qJ#e69UM?wFA_gP()Az&F0{~mSK;+NMFOGHz(1;e6!!Y4bmv|^>4kd;2JqPvx3B>zml_tvv^ ++cR?Hf2#PeGt69nLggKDtT+w<#?9IiETs2T8=iyaEx#P!}fH$XX2yWgYa2m7V&W|GV1Yn3C^Y1?}cL% +@Vz?QV!(590t_$l +;T!eC>51x9Ov65Cci;IK=7LsSoySjPWpr^NkZ2yTkUxvD0YKukc0>|-~2j-ps!g#@mMjwh+wjlNn`(N +eVn_7~*aw}Hb-0{a +TY<7;K=Ukm%aqs++94WtpWwKUG4!b|>*_+8u7=!~ID<=@E66+LNwc#7eqHpSqFSxn43w&r-veSAcrH- +$)cCJVnQcv2P{@De?J?3z3u_~S?oi?<7$a1bxsUv|N#A~G9`iSLd=M +Ydk%KkzgcSg`%=X}TGjeqXp&5VKA`R<6_1o5agG9;*q>wbvg+4hKDtprgo31y|Y=yMi7NN;MoYqUJP< +k?Km84p*vmkIl0_6P8lamKw~$$7bu^E;tn0$3EG_Bz>wY{?|?vf4Ot#4qf15ME>IP1{Skjv7-^^Iv@z +djT7e)I%T=}2C^XG_;^H4?1Dw5bEQ7oSrJ6by_9!H(a*nVTxEp)kgVqfzE`LCW7t&HB!{x#=E; +hmE+oaTa&?>&@Wsx?e9J2603EQ>R_LU-XOh>eP8yEt+*JZkCHdZ1}Q2IT>{}LbpEf&1$iFD~CE|{=8Y +Q`hl;8UYjrYz`t1c{ohFN9W;rIb@O2eVqy&%zcydVW9wlWFX$$i7g3vepea4ND~g~m<=J997AGV>62=4oO$Sq4rH4` +s_wqEX#X5RRXuW+)%E{G`NCYU1)!ADq0@v-<_+@(D4tQr*aPqZ}KhtL>C?XjQ(p6S%-9aC1FZ;9~Y5F +gOPx$%IxWB$>oBb{PB#^1#UCF>w;h$%td^P!vI#89OCe2F@fy>mF20b3z~fgrSZ-4B4n2Qfh^XNu-db +2uqV}VMUy3t~t>hT9Kb>HzG=#C@@-4Oq|Rtca){XF^LpW8b@}SBAPua{L$5@2(@q-VyHB(G8Y`?vr(A +&#b}3x0D(m&C0IhjNp3k6ILst1V@Mm8n&f9Gd}f)er^x17IE!e=;LM5~oT4!51x-;}Hwa8t8BR)3q;6 +_C&`Ld5+etk*md;IXq;oiy`o{UxpA*No9J1`2Ga>a8;uxRPkby(FidLzIVlo&9Mx8KBlS~UIg%&0-Q) +c5LFjEU=N?@j$^*N&{GV60jQ)GHg)2tX9YFENeMu=s04`zf|<{8TwA(mOhGD0l#4XPO-mRZCyKO&BvJ +@a*dS%}5WLbJG8NR!$e%Ltz=Ni7H4GqX9CF`AT_gE3=_IQnGESZ;(zb#u04bh2fsS(GeIh+`*BNh>pF +LYBqEG3%ZahB+`iAr7>1i(&4;)!bs36Nb4(ETUIu +0@%7oODxmHgCGZfQMVus`;b%KV@!;;}*Etxr2OUj?pCP|sn6sbN%%QPJAq_L4nNhY&e1#wJVnTd<`X^ +FLfoy_<{XLxBZvWh~kg4lB4VHIgqJ$c5RsgGR4;<*KJs_~NYWVJF5d9IpWerQx>GbB!Igqab}Xh^TSY +?k17b1m%Wh(b2XkrTMOk?V#Y3XL0K06Sr*?dWS%wkixoo*s&P-3WCf)(zuoRFGC_;)*HK*w=PqtTFa{_A*;f-9Fi +$A6IV$xrPZp)a%C-7q*aY>%)R+o)5@0GgYqLYL*s!qry5&+=%UM~=K|kl`sDZBlsJ_>`F+|KzBkwYq& +Zfnh~-hB9xzT8tysU^@cY|EL(d#iD4=C#RXS$2FP}B^taF-U&Pcym-_;BC?4q7pcq1Q$wjN!4dcg4QV +dvB7>D$vYNN|A#TNNjx8Z7ks|bwbNlV5(ARMWG&wVtt}TSWEd~u7{{7 +h@*FrEH$YZEzQvul`(M=%b}vS)QKpoQuxDMeO5AGU+2un4a5RnY_UKeql}&zSZL;A(VR+HbC)o>Ias2 +Pb(ZD2QR;?bX*PPT{2fIB7bbp0c4QP3h=Q1M{em1~G +AL6-bMcnw>8zOwx*N?MRWPCel0mki&}~+&CL`UElOqjB`J +4q?#UE9Qp}FL;gbKUF+96l7+@O)=q?H>qvYe_?vjmx0f}DKL-K}Da%BH}qX&ywxu_YQkuICosJfyNIG +&?RQSM$WAR!*+w_7=~{)!b%FPOjz_)x03fg?YdzT&k$7&jtBhSa=Kaxv)MLVKHa6hKDy+J6 +m+MThEwHqr*&9IT-e7pW)(GOF_=w}xQsnN6aa+=G4iRy^J-<>_Wz)h!Ta7dtC(H< +}@(b9AR_^4X5qq8lX_y|Y>m&R6S|xHwqK&HHnHe=nDEdU-1zzg_=%HIS{HkYMQi?PmRO-%n@Pvja17v +ZYu}H}5acyz80s=8fYW&PDSn3FSRCK6mB^aywvsyLk`?67@##|1?}VxeCy#?M}`6UTg;VN0BM-PIg4L +P*`tT5`%9uyV9%m=8i8HwCj*doA=|e7#=n&DK#eDp=2{Qwh~WurPY4D8ANLZj%Je@u`!MDD1l3f;J?1 +1rhAx`3)yth`fw}vkL>>eFzmUb{@ytXltVnU=;dN-)wQ)(Qf<$o!&j|im6XV}bj|sLUUB8}tNrY-LvI +e0z3Uy(ch0MAPZz5DZhsl%87Q1~y?UwM%<$#%zn%W!9&cY7eX8{iuh;K|IwYO!%fC7o(~~>?cr(7?k$ +x=XPMB2kPacY1qz{z4Mc>QQg!cD7kUQ9SHWC^C@8n8c9KrX}J>8a5qGyhGy_E;2CKbf$;ZAJ$AndAKs +O@&tu1*h$_319A-rg+Ro{p;^z1;%isQrBv%(JC*eSB}oZ83bi{u)P@JeZ$D@cCUJy<E?dLJt{jAd7 +ioW6Zf@YOdZlM$V2&;>&v+1-RZnKde}*$M-@FY@d(f4^0WSW;(R9S4Z1wl(L#WkQ&~1{hkRB>WBZhy87|#>amXGzeF{2iNoGXZY|zJ9GjUlqni_i +Z%fTnnuyiL#KmE7g0wE&*d|R`UsTHoHKN4u4sd4<_$(#>U65(2Qc7==tLOtlMu89Z58EnMWODuF@#zM +3ZWK4Erx}sXa|o2*9BF>L5OyUb}|Qrr65syK@+0WM4*g19JHkl#6*LRfEkKD0F*(;RVVb-G+_wSVVHo +@NQ4oZG-T)?t`Hc7wNSJHzwtrgQizE|QKKW!>3r3R=1Ms7F%tP|BnoK+ct#N>jv{nwtWH!jP_SS*Y6C +?D_(DJkvqTgT1BlF3Qp_iouV7~Zgc*QkVMrZ?1&aVbi_}80*hMFSSOPOiODq*KV@N2*6c&stH(2d~A{ +JJ|N=-A@n7LN)Gs1^q$rvpe!;-OvJZmx1Ce(puizx;9Ct$fl)^XPZ^{Eqp*3?lt+=H9kQ*QFPa+CW|@ +geKSpzx9dAMPtJc|aC}2$WHWgThOWB;iO*9%2h}0LNp*#{nD%a6D;1;Sd1h0E`1LUPFeE;y{W691c`C +p~A6GxS((V0q?LxHCDPt?6unxOHEZ%>@{Mq5qpi;Yac+?ehA8`qb9Bc8bR1KgI_=!6M%pc7& +;It6NAP*d{M31$NZby5>c0ah~%Fl@w{C7`gyFw99E`>f_6bz)Gm!XZ|}O9HM&a@7r%t#05&gOCZo8d+ +6SR@DL>!mj~-4e)Dl=ro>kuK{8W@}wb<8stV3grFEESeg)0bbd70#ti||0FZ_NX#hwAKpG&?0Eq_a&> +#^Sil;$54FYKpNJD`%*!T^drwz`~2D#A)nh?3sP;4!>M~m26#MUCV7O}MyRg0)vTKX2jwFs`I;My<(O +{k;hYALuD!L<~e0FGj=#s!^j0;ik6)gtIT71$Rd@j*jkMW76n6tQDOg82o5Fw#VDsPh06dK`WUKqxr$ +I3~maEo!oXqf-D*(ZrxMfYVg8aIW)W(6OUNx;b@_2Av;)CZOYh0r*?p(H7Hm<)B+C!0R{pL1Q-ZuAoM{a>cB +3ROnwMOqd6$1jUrG8MI;n8pdC6fT#O+blSPIZ8I7yWEGeT7yyp#dAXdBR)R;!yeUifOhN2Tt5u_pzMM +qI|@CkRI*8(rWASM8-pb>$Q&Vy@Mbx8$vFcQ#6fRTVkfK~@&x{!l5pbDNYCZQNY>hhDc1x3hRH52J96&LL(rHy478z63)-Qh+?17{LeqCuDoGlFCSa)= +#dm$85m*5_EJR1;u%tD08qf|M4zaEV1q-R_%lTy|z?!g*E1SGloi^qQflmHizm%1=Etm1V-t#r{e!cv +UE0cBo8(;muSHT$mht$8HSkwaKD4-5b!;jUmEqsau6}6abuXb%f$J&+3RRHmuYtx+ylT0EqQ(^wLqVh +?^4KpS|PSmVtrCQbyz8VtSs8Dbasmy4>Z^=aiYI>aRVP}@& +PHaU+GYFg1Td?I{9aL@z3(&W97xKD$$^fAOc^-+V@|?V2U;d*{!qZrzKaS}X^# +nXc=1qA}kQ(|3Y*Vl^C_ax?kv@~Xw#!0xQEwdV|+@&xxkPu=%QgQto~u-b>$$^+UZB1@CY3^_>dl;~G*n9Y*PL)jlad23D;%ca;#W{i5 +}adYkt21mDOtU5bBuSPufLN)t%f?f0`1xbs6yeH_4MINzEt6j+@wnZOg#k$es&N!i +a=>V(fSr`^Z`!_D7EUkn`qNq5R{|Hk+HZ*fc_cx2PWmF($Qo8&9;qmx{>i+0JW|r`Axtxl?-Q{lGUv| +6wuQPA88_=3=t<3R?dsr*qYqPK*z|)9{sg7h8+Bi8#K8chWm@xuRnbFaQ?wRUvJ*Np1ZF58m_$l6~U;t7V2$+G+<}?buk^hWE$UKs4$21_}Dd7lg## +)x?JMW`?Q7r1$M^`FxqWpOh*#t$vw9RCSDCs&dw$ZGiB@WcK~~Un~gof-K(HsUp!x)T+3_Fh+RO)-0FKOI~Q>J;9x +s9=~*UQTA}cOLGuIFSBcp7gNq{Fj>GQ?li`sH7XG&m*NAJ-W%rlFb`?BH6=iYn8WuQl{Ga$1Qs7Yhj1 +H3p;j)-{~Cx@@o8{lrg=tBzM0o!<3Pap=l;EkUk6D5x)*Ei$j}+b8-OCj*Mb#EsQOE;ny%d@`l`OL9M +^FwA-6^+uHvg*=ep&JC-rfG$j>@cUSM4*~PIB$vf#Z)>QH<&(QYOdK=V7(wIex2mbh)h0TjEDoVHcapc +b~c8_v+U;>bHQq$UK3&eINi>pMv8~5Y{X8)2YKM4!;~)(eDVAggW%_d!O0K{{m1;0|XQR000O8@1eFv +ooa{)(;ff-v3mdjBLDyZaA|NaUv_0~WN&gWXmo9CHEd~OFKKRYb#!xda%Ev{E^vA6J!^B@$dTXmD`2R +$M8+hSlHV%JDeINE&TG5;xa3OKsX%f_VFdzM0MuiX{qNV^^FYr76z$#AUDbt^c*Vg?Pft(3rw5!@#WK +3Mn6H{uB`z+abXgWv6D5}yOk8AXBdR2;x8?|*phHY(;}~%ByY^%llP~Cs4kPKIJ!)#WD2;|g +D9z|Y5G<)?Aw>J6xB4TMHeKI!=!1xfB_#xnN+nnxt)r#fyJvKy637%VfnH#Ep+Rrrh?IL-fwL+)!qJ9 +1Rtlz;awwY=pYDg^oCkbs;a1DclA6v*aX&UJ{Ogky?K9#Yw7|y&62uyI`@jn&tls2We@z6&}nOHJ9<~ +-L$%G(HINRLUPr||YH2kus%TY~33#f*W#INE(G>Kov00h`RzfQ7rcAGSY4;TWeRfJ;Uci^rlta +6VrBL+D=W|sczdH>o)r9^gM>Gno9*Rs#hgSTYZrgxoEemmU6WneE~UvClRQ^Dv9bwlqgGSK1(YQKai~ +`$!F2D61d0h@aQIOE)@u5hs$aNf(cru29*F(m(~`Hn_`vCprxsb*=i~PW|U@`SR@&PfdZ}cHlP%hS<( +PkFY71=z-k=`yplV?^mgK}UsuP^$H2qzUm$$E)9 +-JItQPyf8xIh-yvQ#m%kn~Z!#-t^=2CW1Jjb^rC4)%*af*NJ>6Sg+LJ~6AU|F&&jd`r0Jk~8wbPI{kX +5gOcF;6v=XS(H?Zh5{rcF*;g7aGb7-SS$uyxttULp|nDLpjndN4n*BbL@`wm=g`HvmmQpJCg;c@E`0w7BzU-0mee{~XJRak}PY&tJQ~L5uetC9s9{1789wk#SooH3 +2U?J)+IcSq!f2;lSQ7lewVfKIg2A09L;NTdDWNBOQIF99Glwbr~Q>PkqMbbpGf`t4sxfapHbOS{M_B* +Yj;wIlBD4#F&^C%^sC=*NY$ixh6UX+0Ls2g$xE?45ul$zkZ_7+lHVaJ=u&}B%d +%(!YA!2oB2Z+YsL}=}df&_c^ryYPUWmkHCg$Lq0+{CFqF0M-K2U37J_|OFWGf0S{b4^;t2v0y&g}?r0G2ujMbM(th%6&ixZ6~qz8IVDa!U~kIx{T_XZzN)XXEqpeT!2O(8Gf$ +6M2uu_qUuU_W0d)J(U3eJ;!b>s^L@^e*D7|)Kxqet4g4T_xwcMLakPAY +ZuQfgIM=#ZIdzA|0@E|nC>Y3u2ce^(&)%$bat{V1#rdB<{wXk)A#U?w~&S)d1h$snyaFmouIHs$}08r +1}%ILsbPah4tql(-e3=9KaJn#3v6E$raI|rUZ{2)jYYe=hQ?+h_USJ?5}+clhXungbu#> +|o?i4M3Zk7yg6)iL;^1bpv&*29tgFoWQpbh8hUo+xjFP^-j7X9bLK;Z;;(nUKoU0R?qvA79%lNG{|}J +`=Z*E7@bW+j}jBof<$&AqV<0$d4|X4?vV{mQm`#>Gz6Be2bTu9kabt{L7F~f~i00+y(nmZUTqakA~K& +_Z<<6Bw;@nA7NL>ICF?zXHRP|^aeJ0A9Bd&79?M?d_?YB$TyKfx{l-j?3{^{+Tyj(R}_Y|vYDh4LObMO +uV9I%a;xA;jk$-(Dp1>e#Cnu&(KDd`5hQ*c%=_c0X)4$D`K{`&dzhmWEz3yA8OO4yG6R#aC}QWYzZyb +pKHCG7KLwTQO&F#O$@)@t03rdd&ontZ8gk>@g|8!l+`xV{X^ +i|4Fvv#IT`)zsoF{!WR +{YPm2mu5u_G|wfJQPBM~_m225B)rABvJWUHmjd1PrWq6X7t07v0uoc{}u;bfIHN9YNE0<3|bcE@{<$K +A1k+?{q)0M;AmkV0^;rOQzYqju-J)Ww-50XVe7SHOnV65#y`0g)m%Wn^VHku~f +Rw8Be@KF@Kf#9JO({!GS*+7nA5+oxySlw*E*na_BoQaz9#2E1%zW)i4&Jx69CV-JEjT|#uH02g&2+JCww%8;{)cE-19Fo8O&My>@kqFlfj5Y<^BQ+ou4Hk*$py9km8n3}9I={|Hf-|2jv+dH$8&> +zJD6r|gq>;rlnahv6g`xu?0b +Q7>LK^WpOte1jDR-J%s^T86#+pjm6fV+| +1}j-(>V+#vI$xYo&KBNLG2)- +{QXepSG(!$0nzEhsK=*&80~sVoF1pcz=6cnk+m;2hkqnUHOxgIK(6~*hC$C(=zN&?T?xBNU~w)rgEb9 +oR^TekUj*q5Se~4{#Tqqt0ON>~5qRF%I`JfsEp8}R;GeGq?qPDBq**e_#3+)BwWxpc{uE72PJe(~0>i +;GnT*aw97$$2GpFcT>-o|15}-F~h?6)!dHVd-fusIy-rxyclxhkUdVN1nqi6|>*s`U~&a1H|)- +9>5=Vz>!bD&^@?YyuF$DYuv53=W7H<&Tl8NknM;pe;v;lreNpV +Dgr3eDqR36p_pyVwVL@kq)1W||065hCD7}AOV!$#gPRDlz1an^=j^TsiI0OD`Bm*jg(CDm7Cl7T*8W5 +CDARYr!&1c||J7_YhXaLZ;`kJHj{+0Xf9X(CIu=rX$>DlM&?tX}pqX{N+29Sg>Sot}e{=6-VoC_PJYdXQO_;EBN(sX +s_>_Phz5t@aa&(@DP4~Gt(nJZ&>;X&XEj-w*?&={QXZ&o+p58dgHzZfQU7ka?+xqH2>tU)VGwo6tpPr +ruj-$S*dN)A!??FF&Y8DiPZ=J>xVpTk&J*Tz+xG2eK5eGDx=P66)-egDZ#JTG=uS!hNO~8!>3* +DNae44FPhWw8C+`u3^EwCN5lHh)h>_(NJHNX;`$^-zEcGYP~!eb}RcQ9dkS4q_Hc07qim>R(Bkdlly(yNZ?Cw2xk2e=|46jcS&*HCNZ+{r?-Nw-mks215&3BE^dDDvw#UW~ +%|Nfyy$n^d9P|>YT`=LI6XaIBDeC_1GWVrz96xYo>)w`d8c@w~&WC!S6p%U}dMt7-E9Z@e984Ntn-lN +qr9KJ|2-ViM>Wd&J-LFYg*eRPx5`3}m>G{G~L8-YGURIJ*$r7>MxxksR&MJ-H6wQOLb1?Wi0H{Z +6BToEGK>ffu0E3qYzbzLM?S)Q%!(1ch?}E?}k_)B=^r?&w4KXE;YSsft&u1yg_JolRtVu2Q-sSS{ +{PfPbQV5*Pi2#W{O>A>e^*I#9k6{&ZX$KyJCr-7q)P5VE$bC%!Sco&>3%##mbq8K4M<3HumfnkVo-ua +lvN58v9nKAa1=UvKQOO0Ej!I(VV8!rGZfl>NT(F3T*~nbrxIoh8T8dAlBS_>3K|n73 +L~}31uQ3{!vRnv~+7PSO(ZG;s`w{z(rJKj2wB`ysE;g*^pPNN8muApQ@_a-F5YQwrp&2qw1c|j!Hf6^ +zV~Wwvc}pBy3)gpstPk%Fs*Is3U55K}h~h_nLTB6=h|*X0mUg)vo&ND1dO7UvA@uP73BFDy*Vu%^TQG +_V}~0LgZFakXK^e4O(q9vq1S0Ig2^aA}F2EnZ@W}HRs@;VMKJ$YI`=Z3`{E_BO97Z7xNipxf+)jd(GS +oQb>_LqS56{+ALl`sk2!?RHIQb7*Y>^m;uxeO`hAefy!O)t8P5uhy-F +4Gq@3b-U^JNnsuH+s7sU7qV&>lqdB+Y7as!-V}H_6v90r~t6ne^Oo-r^*t_%`)-gnY6LP7ccdr9@;IGh82JxJM^X3!b6tG-eENJp+9Cej8La8G`}E@NiRwulzccWA9I_r0 +u@>H=y%yf1y%0R;amacAJOl1Gt|9+Y$n^Un&2x1EO;Lk6rvL$d>|7*PNvg2be%yBz4Znj&BaK<+-g9- +w!hOA>N8v0e%|JjS5q!YRg7+5<$Jr_8*=1qjnmg%VA6crUXpMt=GWky5k&!%%z#i@C6A1 +ja`?O2f`>45SJ#ue=5N`I(m9_Y7K#V;k#&!r*HszjWK}DlZ;xU}jmBwydgO2u1Qp=plpp`8K2ov*Zqm +$kNf$vDRNi}I@y9rM$`tu_`<8pMwd=!9$s;uS9;#huFB|~AuCwKIKhfu-Ddvj+Nu~;W29p0;a!5K`TS +Mz}yJb&^YJHvQHLPQoZo2Of?kA0^)ES7I9Q*wfVt=x9}SYWr7)1-k)@q!j*zD$U@T3t7d%f +Zqu}p5_3*Y`UogkkQ2?ZN8T*~bGw#fGHFbm+C#etLNA`QZSE&5!X!t6ztl?);D*(Rj6u}? +$O0RUBt`mU$&urS`W~}^CKFU8dpnK815-6!%k}&zmXVMXrt0tl1%E!fdR_Dl9P2?DcwJB!jK?;558N` +;I;43#zWgId@_&vTREyQVNXma*60jIMtJakf?Rlgdo0@|c?K#*{5msoB|I6@7*Aks)%KYhQI=J3uKZxA#C@Kv&$c9Pw8bpL?QN4w`+ZCgNRV0ujRfI3ty>o9msREO6 +7pTcDJm$Za3`b)w29tY_M6Tbk5&1Q!1K7i}V`nEmapgouF?#sEB3l4$<9d+9nmQ&{$4p@W?*cUXG(>& +*>ILfO34~EARU1cJ%kZ|9xK`EW!U)3#=`}^6xj81lhs$W6emOPJw%Fk~>*CeM|KaBUeIQ@$qlV28C?w +@9YKN+8$p5=OQZN57|2F8bQD!1}v}}8>qO)eId)hgaxT9>R}~ZtWyTx +D38+tndO!$DHn)LfBVVT!yB89b6xtzA;Ei%DjU5HclYI6$Sp@n&u=|t33v~PQX5GS*e?sMj)3;>B4I-J=Zw>VCJ6 +;J|KMrGy+zy#`a@zZ(I=p!g64;&ilPxnEVI{dL@ZqsSQcWAojR +2eJ=B=Ax@rv{n%)P8=);@m)Lhulp0N($M>axFP*+7@MmCh>6iieK_+nZ7H$pyAwaR!(Bb6L$4Hz_?LY +%1G2`?7UF*(G#rYATU^2OclFGzi3gob@(9_%Wtd6o1}J47iR8qO3c+FsX$ebKh%JF15?BNo6DsBP$i3 +H;_W&fe*z{aj+WAoyKj16(wATNA){`lZrvj9RR8Sf_?}lFPdz)Ye1wRHpK#T&0;gWQI*I +Z9ctbj1jKi|S=|>}X)krLhgvAZCzb8P=WQL7(bc8I>#3?p)oI_yL`4 +*=MRfZx4OYT9quD>cGM#QL82`L^BFpS8QpKVb#oetaz{(Qr(R>$I%NSeHur@Z+>UmcQ191QTtlJ)aF2hM~*^ +EgRkzPrKtG7N$}(uXp09=c&hC;T7IZCTj(H@pd?iLFrafEdNF~WH)&lg>y=Rh&INd+o +3+Qdj;}ckuDZ{HfQ58ru@aDK+!x; +BRXK(5&@(g+Bdsc5?lY1sBJZ?(T^F$abxavjaw-^h-C^<&Ds?#@fLDGrkjNx49TZ~msePO|Qh2hVCQ#w&pLZq9LwD7b&2geQ_~>_JS-NSd +%sCk=Lx{&!7@^@74gu&-y)R+emSA;P%*S{ziGgkD25ip)j*P3C!B%{T4pw)b)9H!OFPW +v-L^kj(q*UbkK?0WCv!vFsYYw6wSFr+up;UCU$Np;$LzqCZ}Z^$9B>hJ&LvPYER6&^vDxkD6R`38of2Mbb`Ua +25`E`J5;%zvamk#eb-NS@;s0Dp7k~Wj)oin?$*i7uBAOc^^7iPElssJ1Ji~gw-fSq2;x +rwko(IVL^#yDXR-JxvYB)AXpah6HjjS{dL5?_ZfJ7GX5IJa^b>jA#^c+R!FKc|CuC=`r0w^Uqw|2p<| +Gz4yEQHUB8qK%B(tsFBIdoE23a{wrF${--i@^e53BZqe)cACP2C*PGF;`4$f(30sY7~G1^$GMzNO8@R +7Idli4r_@1UoAPy^g6JPGi+!hq+jzV^{mPblO`rZpDGe8iAWTBfy>iM6XLXb+`DKdIhdkx$Ms>ZrhI2 +BrgC?lBuvW^b?WtO`UQ329CZq&TfLiTzsO!a0|8yifKgf$7Kl5{{c`-0|XQR000O8@1eFv$tnx`Mic- +5{6qi%ApigXaA|NaUv_0~WN&gWXmo9CHEd~OFLPmTX>@6NWpXZXd8J%?ciT3W|KFd2qckfimXxH^ojL +2o$w^aBr)QHUCwAMJl^iWZLK14eLXfi5@qYKc4}b(EkyLhlS`i?Ddx4Al_~8=FGD{+FK3^7jk;(boQ& +E~^xhEDn35#6Lxjym&wNY9n@yIJ;S>66K`B~sf);Y5oq{$J!O)Rv~yzDOk!;1ajiY +CDONjVzlLSs1FtJQbOip3qpQ@)@_Es`X&p-+^mP!6(wzklYn|9$Ri@W^{Fa)0d!&oJ|lnfFqpX{daWgD77;eTny8b&(pp{`k@z@vG@ +rjQ@Bu{;y}_|CrpKKdo1XCyy-NdHz~t!iRPAw1h>E15d`VxGG+C59$K`dw~R?>m`((VZbQxA^g7(TK? +s`;qZ0musrW!zfUWJ6G%St-e_G!(#zKp7Fg$=(q15P(baJ@dD7M7o2~|+M5B&2pmV=oefs{x_0)mFuWWbwQ7^Wg-Bn`=I5kDUb6K5ft}7_Ro8I2{`E&%NVu=!P{q>I`7Q)Y%JWPuz +@+sAXq*u-;rlYp#Uhk*8OlhayKZpy7Z&L1|DCrXh)jub3jbE53&2vdWSo?INB;5eO1{pw6r^RhC1 +gb1L&48S*6;;O(fm>>7EXM3~Uz1C{Y*Ll-7R)FsJWZeTuRofMf*lUOPl24E2#43=u;$OLNO-l>!%Mmk +GyDSXX{(OQatpRAvE5MO^w&HhZk-_h^C)9+vCmxw6(iD-^0PK%rix`Xtc+^r;y`EEhd4aI`x8%lV_kIua>eWL)r-CfCX#DnigpR)tuQ)ML5Ld3E`AQsid9Ntzp7p|a{!Notw0tkW!6S$p|{KUC5pqDC5w+ +ANO->+`!-R7WDD(Sa_o94e*IsqlI2pu{A>+V7+(CGo0@ctHlKd8XtNsIW+a9TkXS4sv3{hq8*e32Iaa +^?Xe&QNyS}Bh5*`v}^^z-u^^^TSh(5RrA2i1>A3ACT7G^a( +0m|ViY86snBXZ4L!Ubri4Uf&*MD|)PQpAfB;p%XKM-N +)kW(=l*oot-M(n?)#R>uNDtU%tyA^9R7A*_pDngfe*6b$w6cfXbmpB3;Ogc6NX^AG6kkl#OI((UmDB*7ZQ +a;A6r~MU;95ixb_6VsK%Jn-SK>2`<7HNvSgq{ngI#Rcz}5-3XIu0Ba4;>6*!5h(^w1oI*Twv{&64BUYgi-YBsd8yPL +JnWDx=netR*uW4b?CkLBgT?2za>@c=I}Lcobh{omQYrGWk({lm?ukIt&{#tzzZ5ECJIf@Y^9=Raae;uRw7rsp>7rhQ?BundupTnrW+otfbJIwwM9 +{1UMngJyfN(kLT0o}@*ga-DE~cs727uF3fV#F^&Q@LfI0VlUf}z1(RqReuCq`KNDq^0Q^-U1i$p||*6 +s$O#G899pkX*==CALYzf^~OOBH2wAg`MQ@Rlw$Bm3te77i86SkiQQ&2qM_2m1Fa981eCH^FWSwL!hOr +svBnQjhKT*nm3_2CJ*5uEdvG>OHBZU7NMb6)~yaNW!&y&3B8uIuySAe^)ggct{!KUua$on8-)uy9XV~ +H>X-@dlpqHyqzCL>52{->oHhoq?Kj4iz$P#=##=5%OWCYY3vu=Wu5U1lmX%t{yRuMj*iEsGbZq6JRVp +%(vkYJlEdfT;`c~>}3tJfF-G%k%T+?d|C@u84nN@Ev3DyoOT+l;zH+EnfnB^K*>kc;x2s3tj2A&~T8) +G=IbzK1d@f(NJhlwtfKeiA=Xy5ENO13{6O)GEQ(7>ArVhZ;ofKkP2yI3UT@fLE$5phA1^uaFP+uWQ;% +jq;xbr7ja$9D5nDk>GmnZ#XfX~u*$skm(+%!W%pG*C`@Aj&YkUHdMGo5@AN6q`LDJsl^gp83wU9%DSR +#ti$?NO2IQYO5`oCajB97uPwA9n++`>n&Q+7yTv8dr2c%J*Qtv^3g`N+)A&^Ui6n(ah78ZZoCb|xhOQ +r)E{FJY{uKF3O~@F?-&pnNB|ikT`LN|cg>^$Sbju|Lj!@zbz1s!sNDeIXAfxbBX8KpZOG8JiB#b9C@~ +_}|6b0B>qZvsB!9EM0^KJBWiUq(8vjWbwhJp~*r2tgc>9h@fdq|?vMi~zkr~Qj45&}Fdb+A;-cvnK<)JVRGE+QV8ZR8uBg0uaE?<&YCGp<|y!(9K#S44_$8NW9XM@B9rD`JAi|TksGg>F>Gbb7FwtX@M~=g8!ja2xP2?kZJb5oY;3-U2)kN4tFr&ZS%hZNSyCl-@8mcT +0AaIC?Dp0tXw-xjN;9MA$Ha9XqOTw18aty$5k2;(wQH$M%xFDvHIG}yR0|wn(SbvP=5~3Z&KTvJat{ +qK$M-%@eNuoD#@DY%oO=JR4nZp{)m7W)wBGhCjXm)ls(N*Ol-PA(0VXkB2GOyH_SFbWcRW_m8lv}EMG +Pgq7!+bOa5h9^EG^J@AqMvbEVJ*MNw8<#7L6d5@(98_UNogOAe0y>6gd7XSKYdp@joSQhTJtc0NH|~H +$%!!k(PriwUpTZf-G3R;@ZzBoll&<%?#POwo&MoF0Vn%%n6pREW>+hx2v9CR&RCB*Nj=`nZDTzYDO+!K>+48kw(o#2WpxhjIQXLipt9-(s{`L*^S2S@d+{ +(4C00I(Q!{A)DmZ=uCudVHQN6~_HkSfc)c`@<(qu4GQ8d0Ot23aMW3jY(L8>k!SO{kf?TaHSRN*gE{< +;;SxI6&;2{wN$jH@#ST#t(g&yZC&(junl)%l{mqAzK1xrIbF(MEW}W)i3tNI%KSrKek%i#u`QEeu$wK +$)mcAiiR6NulhAr_6xXvk>bxb?%<<{saXuaJ)wQsZ5)+#kn;}o+B%}e%NGDmtx+sTE1ZYnYpNJ^ ++mDzY}{WhXI=9#Iwyv3sF{5kYHO;uM?P-+@#Be{Z94WJ_@}{c?PVGlN;-JK~ThC4+BC)0a7MT<6u5Jb +`KhYs@hc5ctWEV##^gRg#)SWgIiTT!t}6=6kuI&3ik|ZIn_!XliILB`b(Yw+lsTndx0jDxQn3cVT_4S +vyyHbJUhxh`>%dn)$cynF +ZIx2qrKSMRRgU;TV@J;L*;R%bxMDfLW>oO(ZUPO9!xcyn{}>8J01xw*QYc-M%t3>BvbcuS9tiwDHU6L +jzwFbf19Jmfq=rm6JRQo)VI&QP!%-d1o`3c$yR&@C^l> +@eo}uW#PXf4ZLk^64k)2-1pUJ3@Sk>fsaZuR(CS8lIu&2mpq5^Wp7>ch@d|!`HO-?D1eZ$Hf`+U-IjZ +S6-0JV*&7VuJdBK91OjePtBwLuJ2U-}4@I*FnL4}y5S$a^_V((l0|T+sWano +Kq>vur9*On#_A|K|x^rz1up+6atz#7RY++ENb=VCS<>+En&n6tF?6 +TFgql6g83E*EKL(h@t35>u{8QV4!jbN(#A9YP4{LE>9gfRWq{Iw9OI?N?%CV%R<4Yg=Or=$jbcS!x=Q +Hj+s*4K@o-TWFd$jxThZh{Wu%FZ&_%Y-xiWHx}G>E}maV$;vV+w<46;ptWe`x@_SS|7K{{a`gX9<7e% +oh=-#jmgQ+m!cuOhI5x91J&w(E~h5OSS*f$t;nF +>q%PT75W&slw2VHt2f>I@5RsdxTt&xC_-GhQRxHCH>@V-Ni*>Go52761hL)N{QkF^^l +%B@h6#Sy&^rcU9lCoU126{crF&0b^$vlo1<_vzm&;x-hqq+}?R8JR>{bJP6$QtiqOl#9%W<8pSr6+g8 +ILpmN2Ow8NUkD2f16qR{J8E@XPW#e)Q9lXACliihiO>2yPTCMVB;clSJW7DfH=p(Ua$9gFufSPc=UKO +)8*H+f4Y5`-H&JY5B=#(&+c!}`wu-+>OIT`(^)V=@H86^pL_!(4rk|x#`$#mfIGU&!E}stp>#3*eDUJ +;$>0T)AHE^lU6jk)_+}_Z_fstmS{3F)$oUimT!Hga#Q}(Y&@+5dh!->rVm@qOX@*Xe4t?lRI0{{my+w +zIfxea*IzkkuG!ZEtT_0dWFr5Ac#Kv3&7s`>ZPRq#d{q +^n1Aq>*P~hR1b$!BW +j1{MFbn?mZ1nB_%qFi*Y2Zf>68_shsQ4j@9#a1y%^%Y3!{dk1!wf$^M}0NpYM2}TEix(Y4xS$0+T!2; +PY;^3ubwUZziZ#VCj?K#5swHoe8xVg{R<7FBj30i`JpqN&lNnG&r3%N@{300ze{lWa}oocD6BT%(_4025)?rjVdjoOQeL!q7;#qU%Z}Hrt^stLZiiR0X^J$UBf3) +IWa$b+WB(4~Em>|P{df{H|9C|lvr9Ju=H}I4GAdx!m=dgk@@>C#2IGIe!)-_>HI>hBj$`w+l(I1o65j +m9-;>+;NT}BA2W?YW!&_Pi6L=`=l%F!?!qu}2TKc6=N{C@#ZO9KQH000080Pmr;M +p7qp>NR=S%sBOOcJqI92kOW0iqFymMoko^`1K>P<=imSYMu9& +i*Vm&ci~@RnO`Pe>4?<$zFyD!lu7RH2!&L!4IM7g~_jMW?J;c#0 +*Redcw+zQ7?2thnD_sGRtv(q#@Ec5`XysfKYAp&fq#Ll@SmRiuK(!K +Bg+MeaB{qp&L1@B`8U6TVERI0hGCG4iNlB}8G?x6vl&q0kHk2gKOAq&NemzHDt{x4x}%{L1pze0>GJO +h`N4N>pfRDMCVVnOg0w|ZcTR375}O6SMH!=ZmLl*hq#05saBf7Qu7xByTq!dy+OGY&jj1vc&{;Bi0$K}(t1Pz1o{@^T)1ALb~+I0E!9EJ +RpQhM8q8uk`PTMkpojkb0L_eO0SM6VNqnbx8h$0|9R!nlP;iwN;I{cU)HvCaYElpqS7d(?%>sQ|5fZ{ +=2?E6BR)?Q^x~3X`f;EE>&9SDPk-9jz&JD=z-aj0@w(~{%M5Zn~W!l+qyK~pnY@CZCo7@1N9k76p0RJ +{;YT0|4`P0l%HkI=ZYagmySYJNzq?MQ~ElZ-q7F--Pb&ZU5EWZ-)Gg9YwalVcx(|fo)PK*Ujy>XXXoe +Vr^F99n=R>U$qir#hyh(vDj%C#&JDR}{ +zPIXkvb7XGG4vvbG${?)dolu|{_A_17BNf%N!qXWA-{b>fbze08p^@=a-#^V3tEQk|ck>8oT+8m5PTK +*UDF-X-tv^CPT!ets7JdyfA;=3mqjAU>i3ula=}^@aTA?@ej_UDo`Er1cN^%|Dyc`lqbl^3;E4yQ(C98=9#2*CcimvO6xq)rejG=Alg+P((qX +tx@z~R3B>X8Ey7&VetoFJC&{m=56lpQ`R8#~%>&TG;DwQ2Uc4QALEg;63B;~9k>lFzP-Nu5U-%wO#P0 +pzmTAagB;fFPmpp&l13Zfwi{0m6q<2T2K7}~7-zT5RUt +Y*xJ{6GB&jdfGA^_)O`c{p=$xj&Z+&c`DB@rNE2mwEM3K8#<-}!V8Lcz?;48v=Y=HP?F!XoLB@(Lp-^ +2rGX{7<&wlCxSlK#}@UIAC<@Sib9fMozQTST%x3JH&uCof?QaD$1fT^~y}T;@}xWzBtW==|@b#I5$y9 +PxvfXvGxPjEUgFDBdd}@X`n@$MDg@NIp8YQ!iVmN-KiYpDDFORR +#Gv>0&IM>S;>A}1J1oNG7gzfeVqJb(sg(Y$}ft=y<3-z~?lMMMhCTawvmQKgaW6exQfwFO6#NP$txr+(of!zmsPBc9=AXy8xzd{~C-Qn`zqF9cX=hX;=ZYmN8F)pv%*H;9HYEuw{s%C>Wy$h +OTy_;@2i!;urPILBXz39%b|mYDB*GA-_tU$y3ndVz{iNJ==kj<5oX9*2#oUF*8YK3}ae9$Vo$(|T8B)*0M1kn}keta?t}HQ3qp;8qpkz#G?D{vROCSP +q%p1@YL$3Z9S(ks1qa+hHN+N;lus@w)BLc+*oSTG2H^4K@*5IPhgyv|)fQ}Z6EKl^OSn>H@tkvB94O^<%Hov?j(+Cq|jcFX0# +PsrC)|8hUq{p(Rb_GL^#B8an;iNwL2fo;|s$6A5fipA|o^DD~#OJQzsE3N#_Ux`2Br#(9O7bP2`;d>4 +%^2pgb@xI@J$Op##;i?RD}v!#t1BFxk;tJ*-$$wy^nQ4HsUvgjAbKqBsZ=_TwePC_;7fAKDmc!7e&Qy +>V7&_{_FNTtbh7<|3nSg=#WmJHy;R{9jnss+|01obP8B-6#RtOF}+l9ag$AEM~5 +hGCCW5m*RNJf>Vx@6HEJ-A>t%z7+bJLmDjAujLpe`Hc=g!99AJsz55P+VC?=k1oQpoj5>gtGlVJmj%$ +x%`lHmdf8AZd&j#oUB^x{_}VmR&3-8Eu4zAF9^_YuIgbF>3%dAPMlA=bL2!;z=h7(bMB6bV1Q^LOPX)3!+ATebQ5IUuOMf7bMoCMg8^nJ2ZN_DR`9{l6{a +XvJ`S|vU5_Pv=>h!69C@tw{g#Yw8R_w!DN>0ohbNQMP%I0FdGytUeDyrS!bSsYV{o73iGG%Qq+fbJTN +zt!iu|JYKSEf30m0~7XS~P>v<`5cW08)9ZvxUgmd*)uPM~uFwVgmYNUrD)6riv023OZ(sAiR@exmeM +N~fmeRs+{hD#3MX2Dj1dlv*x^>7a*I$-vL6r>d^c=*8l+Vs2@;VpR<&>n8@dn}Vm~Yp9G^33$TWPnW7 +LYgJWq;!lJ@Hmvr{y7l~fm)c`$OA;R{7zuiSOC5`(@wBi>@ZGz2;a!Ztf^Vrfk9w*z#=gQqjm{@vB +C-H`>M{4(1|Q9hsgrub9!6EH$n+xz#FBNO5t>4Cc?H(TE>zWN5ZFYLfdRq|nV-ThAr57QWSAme37xok +3h)3_3+!ED0Tuu0s-K4t^7&D0Nsckiee>j+#|b!(uecQdAK8C3}4|5}h#Q@2$8;@ls^k-Bknn`gt7P& +^9mwXz1@hHy#{^8oKVM4}wDrLOeYe7tX;}#@`mPv{|qOcq=pHxjt?fhD#RDcO)bcz1z!}MA-pRO9Z@_fUO1I5FzEu5RXNlJCYuRNY6J0t?M}N9oTMErk54K$A*|>gKdH_^D&6D?0htp@9LffR4a+43#<0RC3ay|7gnvxp)Rc2NLaNj9Ooi})dH(Q`vJ~i$@u2fWRqInbPJqL`t~ +t!+s4uCD7Wp8i_43gNt3rnVv^lUB=!5z^d*vdZf&_&Mh5%z-blG3e>7&r9`V7nxKm&9L{LtPSo!%6&Qz*!$atmH@Yhk}v6luP$|01roK0e$U- +KWzuU@(|<_f55F#Fhi5ZsvCIaIIdT=rG&S!Ahm9ITGObusKg&b`aUzBr80%Nt>Yu<0WJmTr9}^K_usf!;PiZzJ +nRD_ONZdA`z`l*)lKub``K&!yWDmF#Gj6sqEPi|L?RnD$_jLQNI9Y{g>jM_bjqA7Lp`>Mlx@LcPR4L2 +$-Z6;I9eAGOu`5mo$l^g}?1L*wuWuO{U;E3AMNEBNvxN|G`~f1WV4{D7|wOKaJ@3NhR{+oI`ryX=|{|@2@>h4wxgK +{aWVx^Zr6@EblBzc(mw%`;r5$M|kuxvXdWc$8X$8ue#)y6j{D^M}tsYsACe_vGV69#}{OStHopNtO>R +7Hb;Kj&V-7K?GXUrcf1WUh&;v{MGMMNl85R^I~C3Glk!aBIxO3=ss&l~sD1I1M&0rLrv@7wT6Avvi`I +&k7mi`Xr-82KJbZi3y$LTi9{}WVVrlNR>D!uVPn_DQG5+?v*-~6neMP=d9wVP+v5+6x8Ti0Jz&E_!4f +qYC8Pg%Tz^mRSoVP5&y&N@$0KiWS1maxs^X&CrL&5Jw|%369SOE^pf4r< +1gIBBAqTv0ASb*PJs@l*Xq1m(M>E&4fH$d)=`Ntg=LUj_TaCLvciwZ(nK%9&Egb9bj8d0cBJ>5bK7BB +#_oll$`EEaMT=B5#T}uXZ5zpG^r|XJZ1*hyZ=LaM`+k)aNO%a>;Et8rx##`#Ej;*qTt1s#PVsUM<| +Mh4`2V)#VCe4=%*Sxf7=;Qf{gzaul5B+m9$CFTIjaU6WZ`eA&U#_Tb3#1r)JOV^JC +O6h@=&YW!5}YLrR6g2AY8MgGcTN24tJ1`{>Q!`CkDDchcED}V)EC?r_RL8^rdidWk|-Zo0Fap;wrsow +xyqCl&~(pt68qK?wAah2cMlGNG!O{Y!#(F)qnd~jnCi?2z2NXoyCkuRtFg&TwON`F9JnYWaf#H07b5( +VQu4Y=)V?A%e}gv4a=>b&W?VjEcEP83oRzf~1~9ytLE$y4G7sJEo2T)N74l`+0}jX#-D=ugeiv4FC2X +X*iOo^NM!!eNz-#(p~!8^=ZQpJ6~}F8IKn^vp*|fRvUmQJaid^!w}u*EE~#mC>A;VU};ib^_2I+!8Y4 +*T}+;Tv~|~?kA2l;X6wl_%R@+LJm)x!PS2cc{t3DL62Q^Y)Pv^Q!}`YW~bD0q35CFd!+|+VTkL_Rqw +76;%nBR7043oUPZfFkH___mT~_`i$f)1{%=%hrz3z?imTFj*Aj9tJuAPNQ0bsvL2P@msnaXPaz7*}xA +5v8EfU+XfHp(v-7RufL_DoB1R~xtH_dVaa)Ds#W+2PrBL&o{lZ +XJI+}0mS;8$0zIG((Np;E-Pm+`8A?=Vm14T4R~@gki%lEXt@Sg_qrfn(3`w+ +-tSxBcqU8HkED8c{9g(%y5=q@40hc75y>`mA6r*I0MFWN)MkN#&7 +N9$RK^pY%n~I6bf?m4s$1&?h?Gq`I*SX_(67-uR?!J`3@SZN&U~vn?9`sSjGLpr|RbW`jJTyskWBYd= +tO90E}=(4h>2}3+151oj7oyDlk|rYgd~syE2d1zf{IL1yr44)z;t2L_vRIR#tS$`$arAS9AWGA7b6J7 +qw>)t)V|Ves-dQH}RpP`(SDvFg4-UZoHV@I=3nU6TGOX$G?#?6FVsBprnJ6jc{uXP*Q2ao6Vqv_mp~>?mYACxAB<|vR|x)SxwukzlX-*w#~kI$eSFd(PX- +rm&Qud--p1UI`i=k|GH`AQq#&tkojO1>`MW8*YIyka0C76;HHC{=5Vuk$#`q4Z3P?XR@)k}rHekcv)Z +;;K-H^l+WI@Y+V+s$?GB`c*5XXMywDDCs|!?0Uu~>HkBu(3)%C~wm?Kxfw9AoqSh!nQxJXrNFSk{C{! +K2obx_hlNugE;CA$tKl_vaPQnZ~4ems%=N(&hI;`?`;kWQ8P*-_-|)ys?Jaz-1{rwl0Q4}9Wel%woR< +a3!`av~0oM>5&Quw>cU{_-B1DKC=*y92bVA@~&EvnnzWAK)Pk!h{xdr%)tT6@Cxj +;EN~XW{9h+5_^a91l#ixFF8?% +%Tyv|)rv7#)G`lc!Jc4 +cm4Z*nhabZu-kY-wUIb#!TLb1rasjaFfA+cpsW?q6|GQB=wlH_3`&3zh*}T4OEHtw2-kLmCLQbhg>Zq +(D-M-J<_}?{RVXqnTiYb;EuW{?=A)%~$x;TN~Ysi#s-zbz`qr8^6G-P=x3f-1>Y(`1PjMvL17A%;WM^%}X}n3NNH +QRXkH|9g1ij@v7t|(CZlW$~o&Ef%zuNXjBxcu0g;BT_=0CB&XyphlQ;j~?@UDGe>5X +csQ0AV`<6dLK*GRn3iU(6C1HFRl}R`?#+*Ptyip2e!f$6`Yid_F_%2cx^|jHs-XengEA$j#VX(RZ+5; +d-xKnk^dru=KT5dX*>7hPaP4~&7W)UTRuDa@s};uAffg!Bl#)s*?l9cUL9R>kM$ +Imm_Wyn68`&N*DKeGT*?}2)1fZXN|&MMB1w{$ck>m^%b-NtGr0*rC$4A`DP3U4+2}<>;=ZtkZLCR2?y7x +#L>j;`8(qBYDS|i^fOKrR-7QP!HiCE?R+-2P}L^lbN+5^{H}6c85DYm>(mdCoP}YZ_4YJ?vKxEXC^PWJ|H}3g-I9Nr;qKs5LGx15K=6TmyIpMJS%m#GFp3C-QH>(J&gbKz(kH +aj-s%dcWrKyDV$z|DI*iLx=3o_W@07N{;2L&I7?>xme-n7pJ{RLSJTV~Ed(%gbTO9K)*HFT@NbLW%q; +b!rSdT*B)*g@l-u*L*7rRdvB2UQpYaVp%ic9nrhp=jG;f`7Pte@1s+o-Y8=#MwyGR@W8o8It0`shd_R +s6N9!yR>H0eHMkC$;q%st#ws2U!UA$^xFlUtYoUj17y$iYc%~anLLhgx<$A=L^$0d$hkY}l7H+{Fx&; +C;0n|i#Ys+-e(B=Q;uAj3c)s=-;_nQ74)P_CG#2gDzcc>adP4IP(scfAOCd`N@v}(r=xSZRG6z^_etRQHnZO9KQH000080Pmr;MgRZ+00IC20000004M+e0B~t=FJE?LZe(wAFKBdaY&C3YVlQT +CY;MtBUtcb8c>@4YO9KQH000080Pmr;Mk0Xw#FYR503HDV03`qb0B~t=FJE?LZe(wAFKB +daY&C3YVlQTCY;SBUSQ)7D@$IWW)89uCN?TQsdFwQuL@62&6#9$plPGn=$zRQC#4h@P +^l$Q&rhB9?Q-GKV>h-NwYP^>q4sfxGn@v(JT`YSZ&rS%vp?t`(YHoQUv*zlO9KQH000080Pmr;Mt=^F +P9OmQ0B`~T05$*s0B~t=FJE?LZe(wAFKBdaY&C3YVlQTCY;B~+m^yKgmD2qC*-1OvwbjWV?;}0x*!Q4yH_61LHQ0 +XiEPze$ZW7Y#y#!-VHdsHDFb%f#hP1Onj4mkEr5@E4)eQzxN_gHVh_(E--Z^R|HVD_;7aL+S@3s|1=a +xo+&*f*w?D>ZEYtY2tGghhAVF>VHT@=cf@zr`M)-Hy+xMI@PIuGQ!%lk6HGl)OZ0Cs>|wt7XRvfTICQ6UXbM*f3gy?T|dg4&i}|%D8d1@w_D`JLn@gK*i#87bQ7f!A?{8lzl=60nAKIZ>_c9Z4-H<| +k>;(#zA*^r4V({e^%KiK(?hbTqwnJJkh`;qsfD>q&6b>5bLtmRO9KQH000080Pmr;MiqB?I=BJ=0J;h +Q05bpp0B~t=FJE?LZe(wAFKBdaY&C3YVlQTCY;Xh9;h=dE%~j=eOuXk|Gt1S`fSwn@5*^55$*UKX+}A<3Nhn0fQ@o(C$e8bWE+*-itcgg33yma +u!HL}!8a_ZcbqGdEnxjC7J0sst*y1mL-vtjAri%;_d2DuvGqH$h_697h8jAa&FMBKVz)WFJkc-4Sqv{Icc-TP#k +f*bNj$x#I@$dLPP7Y$DiI4Xt1WkfLVVfF&>7)`S(dW8%o|TxiVmWGMmIPt=491@jam8NB=N4!ik^2|gB$X)28WUlC4?x<@_lFnBjIv>DLD^gjnm-7*5SS^>`e1 +&L!@(4VhyhMD +0o^;gYpV$0_8snLFr+v!-}RwW#^+bE&mT&ohk4%GDw#p!lR&)do +>WI5OLeDJ!nIqaIH)!wK5%7?{kB7759ivc4^g4+NJFox-U>TxR3nR@ubK6P-Wr+#d~FK<W*K}&KMbek9SUMCUL{^W={xPsZQZ^d?;iaJP)h>@6a +WAK2mtS)wnh+{%D|ul003|h001Na003}la4%nWWo~3|axZ9fZEQ7cX<{#CX>4?5a&s?iX>N2baCzNV? +P}XF6#eg~xbrADkmUgaW0Wp~L08J!jlw8KwdGc;BN<8Q$Hv}$_e!!8Cvuu}8yoYVM3!`P&i&GLrPUnr +yjs|W=6Mcc-Y9K>T^Us`EYJOT45hdeMkqOkg%pJ~Ux8_&O@bGR@C}}K{*0i%l$t;` +Ie9rOZ81&lsPKmM|C4(TQVFf?BVVV`l!6a*AcnxVf`KpA>)@DXYk`y&F29AZaGp&`*W)B5#EJ_2BFOQRBYMX`1*!SXS~1?M61p^UUzN3h(Jr4VO6&GLX%e%Wev_SbX~dEm*&+*)?%JJ$ie1ewcP^Dy +6}yTP{IJSUq|&bRa$UvEhj3HhxKIlwS50h{~@)&@4T(OxtsIosJ=$%^Ukj|JM-dk!-$#N~1N@fV`pW# +ZuTNDm|JB!&m&!Q39zfk@UM;WSA2)RERx=gUqt)kxAhIzNh#%ojRgFMlos*&IlJn1V7>v~swNYM< +5}835hs9{KkR1)ZI}MuM@l@v&u;J`93h7;rhVHxxOqPMH>?PBVr+&sQ5F!^er)=XTFaw=)TqNw{0bZ{ +%?P6`oG`Ra2Y)_PYbvMMgJ!uQ$UR1}uwrS!xw_eImScAjTh1w=6rMC~lJ6128rveeGh3RGdfc*nGYO+ +I%v3rG;eK4dQ=@8S-GJ~F7p*0-XQ5HV9S&vI3#N)c1)qX*Eu==KQH_=LW1Jv$*2QoV3S?>;uQ;L=SwW +{AfE?-(`{Y>nSPl8iSH#I{8@drB))X~f8`0)M7`Rw96O_B}dWtz(}o-4cFC;xBJ{u9;Nn|uG-Y^bQ^! +6*F^)~F_n@?Y75cl;pakIQ)aD_Vr*LV%MK4`#h#ZBRG$s;0cTbs2dY>(8O +)JNj>_p~?x|H%#qBWHl6Yu=U(EwyiF{T?^g#ZeJiW}UxgcE~zfxL4La>vo}2hO>`mcRU^A9!)edp?SU ++_6E4iNT=AR1NFsIXUnH9{57-2Nd(K%&xBMqo1Yx9ZFtbIu&6ldbsRJlEp~=ERH+5_Q5Y3#bXRHt{ps +o*4VE_Fk_vBC;cfLdKM4YfoxTWMWSL$1mVe}Wc?lO67gM;uVHS;v)zC+5FG=Ce)`$^tPbsrj4N5Cm{=@v_@9^#|mb?LVzKLJon0|XQR000O8@1eFv(UWfo$p!!b1 +StRjEC2uiaA|NaUv_0~WN&gWXmo9CHEd~OFJ@_MbY*gLFK=*kX>V>}Y;<8~b1ras?O98Y+cprs@2_B; +gVuoHVmFUNkQ69_HlHuIcB|! +l&hqs}Y0LP+sA6m7+&!mEIRznQYkLkuN=NxnZTU#H +LM!$1azJXr@b>ajBc9HNqEbPZ*^@CEDW;%|t5h%`=~)jpy^wK&X2?sFE&arTl3dTR6i`+j`pFM%Lndo +8Z&rduT34^PWvUTdwUF{xIp<3dn9NCW2c&`OcK?5Y-2ooMg()Tx~31h!=B%%xfMcUxOg2rxNNiopvW~ +%-3~^EPUxdmZDeos6?_9p*$qTSRqU=wjA}|xm|OhOyExbfC6;P(Xg%DNDk+vpqtvA;E8sepivx01V^& +6>mq4O_=5deGJFrx%e5?RVi*a81KFDI*g`V3&aIV#*sUa6=GwsbRbD;>yznDPF)-e^50HAILb*12t`gGYDQ)<-H&!ysMH2HBrC~9S8ax`FRr!66Sd}L{W +J>(ef|3NEqjs-lBlAoXnZ3?HEYOFt~YiU4O=qMK5oH6ACVOABQUP4`$cc%DREQ{ci3|gLjzFSNxvf&O +6($zz}J^{gwJyr{L+A#{F%v(jZAuI8ki!}`NjskU>;+4h1`>3T%=1^4i`u-CD_YigttRM~eg(AlkO8sEmML=T!`G{U&5FS8T!jmR +lBJ4s>v_J$x<@jc)ib6dBj264Sn_^4X3;gOkYc>e}b&g6L=OkqbaY?2F)`(a*cA_U!#e-JcO(cTqPnV +9Okgr1>ysclPgyf24^)6)Rg0BN|DJoyU*A@7-GZ*1GME`hn4^4@qQ3-ak7=JZ7BOLd6J>sBRm8TV!v1 +D4$MiFK$0QVSe#y(5Qg3@LffH7!+-DEgi+bN)fSKE{B?KSef?Pg-D51|xj0&a&<>Sjoh1s5r1bh}hAA +`bdfa`DluxknSp;MNdd29vZw1!N$&mJwFIp6$fgGUPxwc^fT~s($#EpkfJOD{;j{LIi*JZWx-Oh$9$E +In_Z4QYvXqH>h~hQ=s=QQQpT8`-#=bsnBn|jMn(L!3Zk+%hmO_uCPz5N;jzWlCP{+JP1MU?Vi7-Hg$zewCfQv7o1OWmq-0^*m8CFLfVPsUaQjAAg0ow1Wm_^`2~0p?Y{i3ioWZKv4~3+Nq-(G=hp%A!30d>| +jSUq~jgojip2(L_ao!7%q}HLnIN1WUmMLGq4hPFtQ=@Dl!qaK~4eCQ79fM3uF72;Tddmibok2LQ7+y4 +%9Z!3RrzPR*s=37lq1x{IgXS2(Y*LpmTxUZ(gVe{MFP7hf9${RVoW%WCsmcmq;L7D!oqG>JH9(IA6l~ +3eMMXzDa50j#Mi+L7Q#JrQ|S;f@wC?3WWWJ%q(@_EnlGg;GHdeZl|w+$t56pN>`~1(8~UZ(#ivLi#|x +w4x7FsY5YTYuRKKe4m6;p4U4&^Dwu(!#~9SsOzG4zt +dw}rm)I59GGz)mt8q3SNKKq)geF=YYH;GiSAPL@Tx54)ru(4Sz&?tueNJv-uGq&ZLjOi>dQ|8fSbbv4C?Xw*tAOLeLps~uA#K=BlWaO +svg_mU8qmp?UfvBw}sur$c{K@njR6yr#@et%a@m=l0U_9l@4@U2dLD)0tdXtYf{Hc^B0xtGY73$FJyW +XeI@OnfH^NOfAe~()JpvxNf$?&`5yac+dVpABjNf#nEoR$HRyPj!qK|4y^7}S5efU0))0-a#RV&l{3s6e~1QY-O00;o@p|(aiujHYz0001B0RR9g0001RX>c!Jc4cm4Z*nhabZ +u-kY-wUIW@&76WpZ;bb75|2bZL5JaxQRrbxunP!Y~ls=M=MSq4WTPTXA7mx*yVJ0)uHH`G|UYo2C^D` +W6H8emw2n2#7kxo=74s52zYR^@d5G>x7TCgfU;8hSQ4)K|(q}l%Y&G9 +{V`p6w+mehYlTk$!Z%|7E1QY-O00;o@p|(b2wOSR>0RRAY1ONak0001RX>c!Jc4cm4Z*nhabZu-kY-w +UIW@&76WpZ;bcW7yJWpi+0V`VOId6iU6Yuqppz3W#D3L!S@n)X`AAq2PA(9NN+U4+&iCrV_=NOIEj*L +UQPWaUi@nS)@y-g`5a+&bHV5bY2KheCkrdg}tngSUDJC?>yvMm;I7tSMkHs&kxB$K(;qY*L$>3+LtX$6_&Z34lJ8* +yTKSNr1LpYz*=Fr{{<5*yz~)fY~1na@qJRD+PQ}Ix+U +e|R^D;=mDDUIO#|7hxJA#78`%+T)D;z!?`~_QD;aZh313)}Mt!WSGR>$e@-I#Qf&276oU!4pCPKZB(4v4|b$eCOF#+HBL9k!}C2l%8uuAJgDjfIt3(sz&|w3(Ilt3*Wk6)T +J|2rq%ceJdCL2uP|u5@R}*jWNjKg8`Aa*be~E$PCt3R8kX^t<0b?Ee3s6e~1QY-O00;o@p|(Z>F~j5# +0RRB%0RR9i0001RX>c!Jc4cm4Z*nhabZu-kY-wUIb7gXAVQgu7WpXcHUukY>bYEXCaCv1>L2iRE5WM> +pD|&$l@c<;$Q>7l-UJ|w3EC-gbim}n!Zq&ZM1~;TpeX+(nJ2Sf;*iInj5PV>i5@?z&dr(Jbb?_(?E}^ +GSa%4>j!BA&=l$t!U(oTqB(Wt6xuV=)I(r4tYHu_0BWKx>Gk*~z(!|Tg_dlf?TIKW2B$;=@-FLF(W%a +xTdSe}$`vPCgMG%*XAQ}bpGmICh1Zg=yPcJ{8QSH=UhZCk^Bv_bc9LFiOBBKVQq<4Q>Bq4_&XbwYoL@ +MDGfQYlt44ZoqFX&~jQw;(Qx+>e?6Pqnf!F6h?BiX6hb(gB~CE$5m4nh~bpJRA{Lm(<4?f6job7)>AL +Q{1$?;dS!AiXmo9Cb7gXAVQgu7WpXZXdCePZbK5rZyM6^qPhzT({R$m4V#lY&4R^?rcQhqu^I%8pC8IR^MOBk$8$P(x>nm(7Z;7d>fmPAfN_F_#78iLfKmrxN#RMMIh +{LLjt3fm-}n;#W+g;YvjnE{}tf^P9YwOWBN5mGclOAaz4o;Uq98Tn4@n-%14LNQBhCPh*!(4U--Y_YO0Q{E +%6$3y0$F&C-?#H%{0kUdO?d<~gY9?^nhh--kJRzDDVCWx%Pk3#PYB`eEK>4$kP29AdVT2hxq(CKe2HL +jZlu3k+Q-?zvq1-nrM~y*Af#2iJZ}H{?CqJ`(31c|`m*+oIw(&(1!L$E{5Xok>dks!jrd@r0Ogt3kUQ +4PswqREb3An`SZfo%L?gn~}y<(u!MzMx#*}L)$|BasB$$f)$*`{CCK$I-bG03h#)}s!t)ml^JZ=Tax7 +xS}k3?aE%2B6KrT)suWdkdi@j?gym!JSQl);f+Z6&XgpP0!myO|mWW*{>9)ZuOSla50*wOz682VteGX +~R1nL6YayES&12olHJ(81WbwxAIL +_M45-vg($24Ub2x4=jalWQYCV2>UX{cQj=P9~1NSLI`cW4P<( +f2xG;7y2E`xk#X-0n@!9IsF;W@ytbnVk +B>{*E1`K?`;?;zF`|aI5EpCOCD?QJ9iFj(axAy*Yv>J++Ia?4?iA}d}9m@LwmK>`s +u3;Bw(Xbe#n#%09LYC;bEW*Bv!+pWRB)=aLUYvb4e3Wif2K`h9fYTO|*Llt?-2*8oLnZ`)YR=8+Ui?X +mpth%}Dgy^ssz)fLT`OhRcxuz26r^h(w{8sW}pBXJOIgmi(eh;HzAuvT0B^awM4r(zgAv1n1y<^Y9e= +nFZwU(k*7YleNCr``MMPHU;9`Y{TI2dmrQb|^y601+6jNl1YxDpf%N7FYpTM +d&-pXjCiO-903`9h*!2rf-RwOjGh?zJP6@ba$ +`(;srX(;?FcQLEQY^R5VVP_CXN)wQ#J2Yy+u}gu%334<8Uu0zg>01_zP02NEln<|8;b^3{PE=D-a}o| +gdLSZ?(UbTi&&0V!Pagr+Jp!hDuMa#wK$5n7X)68{ +=_T4cg30iA@v$ctkO6baKRHuZ`*V=!I=v}xU!4HOo)pBC$^kPNnoK_FJS1=hG_$*(2kM$A#I*tPc(?q +aqD!-JR?Jk3i;DO^z4chStNzIm4rm!K-pZoypEc6U`fx9wl*3 +z!fc%P1um}+aX0;sCDG3JDJcAKO=4Yp;IQC3$vkZ3l6gJ0cep+Fj-t#+t3Z=8SvN7%6$3B`lu50iyN~ +e3J=9q?k)YLt(G>ux7WhA7KOy|@lClScBXZUqu*s9@LFWh#3#@5uSi0@B1ts@`xK%b8`8+B|9^|WY6B +2ap3HH9z+Lc`@-XH^J^aLdX8V9?Srct*wNN_$zvxySQGbOxqUywr +E?C6xX?(|u38@&&e#%m2sn_6Mo!Z#FD0E%jQPUYnwh{Ie)%htxIvV+=Qs&xW#ba!*T=3QPzz+(ffn2M +Ka;oRPOa0oaN6<@DRbL|zvChgk!d#7J +*QO3XLKg8-tyyP{JNU6{wEpJ;iWPeH+JO_w|NolpUGf!JLSbz#gJ04dytYqu_2l{N*)o3P3jvGb0|9P +6g3DAdU1Byj#2Y=IYIh>!07w$s>U$q=qz(ES{A}Z2B4^htZOUFC*`h`vA7$@nlAh$=mmTfA#VO@qov1 +&7>ybIM}T@i5(20$%8m~WbyOjdj8rQ5d0817bN&UjeMBy$K-NGp7tMD_al49-XUcC=wwip4|RRydkaO +2@Cau&_bt5ttt&{_m_$RRn7*8ueuIUdn1nz!bzI}3a3wZU;tsLFS5)a~m#I?|Xz9Zgmdba8qxgq +-2?K4sfn5B(RXsNIXJ=hx4BVxnU-zah$(+`)87>64ij#bG}zaJYerk6xJLkc!_O=Esaxr$&>%4oYMq! +n@GXh-l7RF-3iUR8+mUp*)2bTAHGLjMd}ix`pexIke)S=RWp;hr=}o6|19GXn&}7ceUhjJC+_bu>`25 +>TLA1qJEFfcYV5u#iuF56UbN7|<9oT2j-wCm)Ae2-Oi$3G)V{+_ +BB|{i@gO`~Ke(25$toyNd!}@pCn-ZP3iPRv87J$T9<}vff{aIW^;sH{gR}&hzbM4(Dvw+*Sye<^4SRPyWavnt@CTUowOE#pHoQVO%%b?lS{i@lY +$?&i(9wd&{E!eM%*5@y-1L)qSP?!6m!}YJo^IRpis`wo#zJ#vwy2q-@Sf;RkVCC`6?O(3$xo4o<@UXhoaPZn@II~wJ_Ej<2?r?+V +2(q4dA*?T>7@YLH8b;m*|{LdGD+Z$Q{4AIJu1G@;)A~7c7lf@dan=);YNI{C-)z^`~9~Z;IkRy&gZ{R +^VYo$K$c%;y@cfYp7m}@IHL_K<4k>y?IAo&lij5KhDWd^ZC{M%4@u(j!^ir0FM~euaJ<0-ZAaO1R{sZ +tk_xio%P*8^}eKbnPocbKB}cB<${q#L*~(Fgo-p5{kgij=UHlm^*m2K(3flmG*Z5-?)KFGiSb`hO9KQ +H000080Pmr;MgRZ+00IC20000004)Fj0B~t=FJE?LZe(wAFKBdaY&C3YVlQ-ZWo2PxVQ_S1a&s?VUuk +Y>bYEXCaCrj&P)h>@6aWAK2mtS)wnpS!Ul1As004ak001Ze003}la4%nWWo~3|axZ9fZEQ7cX<{#Qa% +E*f&U487}D5IWg_=O0j@hazi%9TpVG1`H?yL$T>pjVu|G+@=`z-$(f?w +v%8zbUN6UNIpJ3(JZa0Aj`_eHx{!DWK|pMLF}ASjmNCpCs4>&>7>yKG+O4Sz)VSxRw&0<88D8ON}V{S +^tLDpv;)+g_g3x*%dI!xs#^8_X__1DywKi_NsE`p`3GZB?)51wq`YEcthQLnV^)c}mU<7j@cR!djfL( +!0cCQb)}q1$G(BA{as;Wbaa20P)f0HeWM#0~?x7lpPEy=O{#TL0DLO-1oh+}fsU%p{nzPw +6_VvG6m{$JY6K=Np~j#ca&w%>i}5?2MRVaKJm`6S7T?;>&FF(PQ3!*GgZ +RDwMXUy%x?*0vs+{-Z`Y%`aqMKW+4Bm58Axx{x5BRGxj-Sg0#OhBx1I3nvAEvP)h>@6aWAK2mtS)wnm +^#hvnh~002!5001oj003}la4%nWWo~3|axZ9fZEQ7cX<{#Qa%E*=b!lv5WpZ;bUtei%X>?y-E^v9BR! +wi?HW0n@R}8#Z)Lu9O`f)PgLz)fR1)3Dtb@x&f1}%+kHk9acC_8D<|K1r=l4Ut@gX9w18a_V0_hzWkX +mky^vljDUTm^0or7LQS1Z(GERU2EFY6FE?uhC-_;K5V{NnP-Wu=cK0KQHcnfx_i=$pw@twQ!Jo)B!=q +vIv7dLTae+0O4teEyxs}T+P2?0l_hjGUd*qU;*JCy|xgxOoC=geLI0`{x!(j+-jnR=w5r{YKpj#9VP^ +t!N-Q!R6fb`sk(7x`sFrNWw6*HA(S-*IPM;{2&M|?*E$!rYPr&cS?@%Y-Ma!|tZmr3db4FIBQjL{Gr? +BxMS@N|MP^g!P`A9-N=@(GX7XQNCpj;fY${W2jjWUKC`XQa^#Vl(3Rs2e5 +4X}nSzsVd~8jMCHKj~Zkdh=@c374Jc^CqiP(Mr-0Dxx35;{ifhl0YkA7?(t)7I_o?#ed!bj6VnTq!}f +nrKdkCl|{0f+@g6eIYd<-o@X!JAbbkiBmMb|bdKRdgptKvGjvCn>C42&|W*WP_wZckxtBFfO9RKsVVS +)p&YwMN>nrted3%Do}Z>Qn%7CbG09$grUXBg^VwEVTdyu61q05|gaq7~LD4GmSa?^RH5h%Ya?$C3`HTi`ajst +v0`B&!_O=!^1)Q4NYbW_>T|q6VEq&(p@P+&knlS!v_<#aae~dR)y-FP*xGI-MtB8rOPfdacP{yUGTWI +2^oX1A`{FWCmDQ6a9BjV-rru^nn`GnGc|lRDqK0@J+E1fiVe-7e+hj2^==>rXRuLNf)U&hul>{TSlW! +ivywB!|3M~6F+j`C=tSFICiKiCB*4d=BcY?Km*_w{Cd92PYaV(x#w$+*@kD9P=RGtqJh%4RSiQ2Tm0k +fbSkKe`TnfwONr|}TDhb$E!*+mEo=sI@r2}8u+?vv~igB=H?KgDhM_fL*YOY{>Q+v4>E#G3hoi!Neq- +3)-Or}H1QkPcZOkTf0C%wEJH;U4qL>;runIsowWIdiYD2ww(7Ir;0?>=VM9k}-=>D=pM30o2;*I<6kI +!^uK`8*wdcEUJ~r*1Iu8(9D8JK(nk9*es)6?pDyzFL|n!g%L#oi#Ty3qyh3T}@69n8Cm)zL{lM&CZ02 +I88^kgqp@Ys~up@pDla`_qShfKSLgeD!)H)1m&|B$t()FCY!-8TT;DBmY;y6J4Xt#c!QRAv1WYApf`H +^Zz3HM+MyM(b1r!iL$Z{zlcJ&7zqhD=unNaDuVj%r<9}(q)zUMYPH(<9niUscwkvfQ8+I!?ywNfmoXB +g#Z(U#Irn>ds`7t-`Zc!Jc4cm4Z*nhabZu-kY-wUIbaG{7Vs&Y3WMy)5FJEF|b7d}YdEFcRZyUGuc +mEZvf}j#6U*Z<~h%s$w-DESc1VL?V1zgXdPL#yvbX1PKC~lYkeeXSf9C=5{a?>A%38*98k?)J|o3G18 +ZP?x2vNdfZ?(Ue}Y*k|zpKDdMM%>xoQ?`&Fq?W3lvbL6`T8O(!8qx4dpDYo?R&I;C529YErqJ@EhhxM +?b7$_i;>0d1ic;0u@Y-m($FjYy>=>GQ;PUxU98k%xgf@y{P#{=q)dWJ~?^9uGfP03bx_RJJD +#y8^I*)6AQLmi<-ec(ExC!=0AzjFyUdre%STC6~ZHArKl?S!Rv*8z_$iCcFz!as{yc4Y}*K6)v%>%Hr +yCM0Pu*vQ6>00_&owbU?Bkl0DbfX(GyUdye0NQG^``fSr;N8oshW0lO+CC+m}DO}lCU8#Zmhh`? +;@Hupm!bkMtrk0&N;+1CjQ3Sgs6u;Sn1ZKPg#{Z$?k +`>__Yc~4xQ_Y_0zYyKwWTxrP4yF +Jfwiiwh$RrjhdW@k&kJ=1o3HibWo}%|kXx)idvT1--Vh%Rz3?^eLS(R+K)B^O%TyD13RK((C)2ODS!X +^yY;1?Vb3vT$-J^og}8HyPyW|l5oi*%7&aegu;YRa}sOZ3&?6XygB*L13CctiF_48}MadOk$}K}fMn` +O=~*K96CGC6fCT4sH47GY(+t8FX-*JOZ$c%PZLTNUvu9MEf8*QM&^GO+Kx|8DRBsKT-sZ*r*TUu;zVF +Yb@iG+7V9N0$6`b1q2Hs*LdMzdy2&FEj>@kdW}S(>wkzG)SdvNQx=LRC|DsDpp#lzH;=*HdHjW{zl5y +ZkglR$bL|2Y2_!z!MC}#ehA6q?_gP6iVL$xv1H>G?RxKQ+p|~c@TA^V;E({cJ5amkLSXTTsY(y_=6#y +{x9DnMvI(B2%LaRGZmkk}^FvuOgo4Agn!{QRKgFK^u@@TG>6 +yrX5sNo#cVVNuh_aLcVD=4Zr8>OAI00+XuZUW_w>ma1RU%&nb^L9hKTn%$@S5oHyPOJ+KZg6X~mxPt!6ZV}i$Y@7K0K +S)DmtSXz0mZY0W*0vb)*k~S;VcowW1uALCh|$4ylVKW$Nthi8ZO^cep6A8#~9i-sqy5Nq{>Yu4$yg9n +Kynp)-P*gw&%~D?RL9j_jRF~)w8n~FJ3(RNd1EYIsZO@!@>-^1ZF&mvlwaurQwB^D)1$tD>N+B_?}n* +OZSF}NoUGFt$-+nAr+KZQ|hx8eDTt|TkO-hA1QKN^%g2U({2K1NSc*>lFY7C8Y&vCu8et_27LkqQwei(RB!bH&+hH$4YoB#MY};X0Wy&>Wbp@(aw+6~!Y+7~@>`G +qWCrJxrgGnJTKEi2HYCgmK0G;mGQ#T3@eH0x}+{(nF>H`)NGuG>H-Z<87yNy&kJ5I3M+Gt?|Qld}27z +#X&scmAr5Hlw_O0+P3bo4_q!ZIJinC=UEGVwZ&Bk^-lAtjF6e@8Ug7zixI0+{TF+*2kvJcLM3@znk$d +^%mDh+r3|^M=%Vi&`6-C-vQ%wlsUKs%N|a9<+e6dw|EQm1^L(t%Fp9Q4k`RHe#y*gDxTbibcQXd&2Zq +lyWIc3Y5O0d*4bULQ+fx^bqI(R7nl7OXGRgMnWC5P#qwsCfe1yh)v@PV6n4vtY@~guw#U72r!eyk{ZZ +bV*~)#u~0?gh=JgPo+_7d3`qEjlnFV5gbgjxmj0nS08bF^2MTtjm_%Wno<*df-MI2_FD(;rg3zTKf>%!Lg~c% +;wa7gTJ+WEzBXI?S<$3B6>e{bby6_xp1=72_BHoY=M&ys0FniMBMRoH}(7#~w^ibm(c$b5#7XM=g~Ox +rKlFb#%m=s78iOw7KXi<_RKs&1GHPqs+;HVojdZ$z7tJCGSPgkBT^K+F}+(-MptM`*L*d4 +%#{+wE7(o++vezFcT;+lfS@Ojf`c8z0HPDlr%6^kXU~(T4;>pGl1qEC(9ZgH6&1XPVP`95Yc^3Y1?=G +1XmgY%7F)F)PkJ_SIE(C@%bt$FV-OGXw1e#BuGucuqI^d!{5nWmd;|xf!FiaSupue#`C6Ld#K__5Zhz +>`+6NJP8(v^iD6yM|_s=e!kdUWg*55CLsjCyJJBKA){vFnYO!wpovs@w&=i`^M0n+B8f3K9kM=d|Z$isrUxH0!+rhVdqiI1|x5G3yZqgn+=Q^tWX+;6Sd>qBRX}(o3*{AGrTgM%5y?0Z3>zj +zEZ-Ys6qdp4|dYRVbd+sLfEpe}Yj{xaBAbdGHjw0bJbnY}29 +#h#D{8RW^Jj%ODSsL(}kj6?gyeW203%_TYsFT1)s}d#8le-di`U&j4!N=Jb@%Y<=pZ)f6JdDGJ)Ng_&Crt82@% +>-hPM+nyJ_l7i40?Fc|2J%fVTPhKUS~M%3RXkyNeL;pZGt)t>&XB$q&z ++_%}$#olrE_TiYpCfm%+Rm{|S>1t6wzdSImm{8d8K%omz!-l@CSjp^y#W>lNRJhxbAi72f{)v~Sr6q& +foTf!YBl;W#+-~-B$WBkZ{SCu*Z7TAx{)mXtLp3~=tRou+3|TM4$8o?+{r1}fUg<%+&j&?Kyd|~%*!X +cu$_N~>kz(<(UR?8)?>dQ(G$Gs%M=tR_!k1h1Fi?7%wQVjn^#4E5G@jQ3J3*F4A;bVW-_5>{M~emIxu +b=_zm*(y!|U+~Jbb4=js0szli{oiUE(2vFJ_*@Nu~%%PAlyfcC3XdI7OX%*$7~0XSH7R?yNMw*F_gwd +eHEaPaCo`21jm)3anMVtk;C06QoKlaPM*ATRSTI=-OHF;}92s4agM&EBcbu*4p8J4e|?1Gp|iVwV$ +ey>CG?Ae*?y8qW}pZU~QdoOT0qRMy+@1@Y5f?`ek)|Bs-fCglDLP)h>@6aWAK2mtS)wnkwpF&vi%000 +#s001Ze003}la4%nWWo~3|axZ9fZEQ7cX<{#Qa%E*=b!lv5WpZ;bWN&RQaCw~?X>Z#$^t*ort0IWJDn +i$f!BQYi(yiE%6s2^>@ +C|FL4JSqao}rT7QAXP)Lz{*!+maL&<)p(Eo6Tk`LFA#X@)CY43N>vgyk_VEfM;s)p5PxHSt*QM!xlG~ +5w&I(mu0~ERgx}+KR?v#iqxd +xn8P9Ghcg5ZtfM0|+MUVGWrZ0-$DDV6P{z~t<~vz(g(x1urYJxOyeLves#S(aPs9QekJ!uA7O+!)&3r +b!?+BQ#L6wlgrj=umjoyF}Sq|7WOXu_45Ssf87~ulS2rHDEp*vh{$b`T-pdD*Isg2{)uShd3KW +WmP&frn*m*aG=QUP)G`Z|-KS3h6R(W>p_3!;sKqMx1QxOV0EK^~{Xm?SB2{eu<7ZNMa9>JH&s-y|c#5 +J?=5{2u>*M?|4Lp5`*~V(}!dp^iA{NrgXJtBO~zei?;D +ikJoF`lqcUndD`->>ZJ5SA8Xw8hZA7&@V5y{JgsOiNE-$^Sda&<*p`^%OfA175Rc?Yit9?k0YQmiIJW +l<=}z0_M!qdOf;ka{g%wjlc0O`ri_6&m9O5=;D!98c4yUszg#9|ICP6l+9>sRBO9sKQx)>WMF0yR`gB +_MSU}Z<9j@0cP+2SgoU7Mw%Czzrm*KS)BWOHkFlvy~8FLS>s>A)XaaB}}qu6xqo0~i_IJQ7(P0j}h+) +Jw7J`{asttY^CWDJ7wCh#Oghz7s%_43Qekv1Rr=m5pd+Xh>vZ?-=&RsuWq+su&;& +`Yaj9wPR#Of9Dis;Rrye2LKlwic2?&!;9yi4X)^ll2T*>P;ja#yh6!g0zc(D6c$k`;VWW_hawrpi56i +OpL_A%K*8e>&8E{yPpr@kEt`Z>_ejA#GnoT9b=;yOUL +9wxc;#HF68?$645>v*Q|g9I)WD~g=WgGY&Q-aftA|vmEknc4dB}9CXU*Y2505?TQ1%9*{Bf<*H*bHC# +;>dT$d+4IveZl5_+D>rD!Tko4nTUv17wd3E=C(ruO!ypFXd}%=!UCFt#}CX7=WNqJ)JGY8T%mB!evID +KxWd0bJCa{YKq}}RJO_P`$*3b#%`$)-GWeOX25Wbq+)OIAKl>^j}8@}DqA>lHWc1K7jG)*-CH8Dkrj~ +UE7n +cY8@*_zV?k{=|9=rEg$Vu+IM9fR{+wsZohX_|yd*8Q{jjWO}>nnL6gjz7{H)2wZgcwnxE4OEtqs{$75 +-9{mAuc1fA1_s9E4DcMYf)TWo}S6llMYtRN2IotRzV!l{4i(=Ld0v-IF1UB)IGtNQZSsnz;#=7D-fuY +m4b6u4XP69(EkNua~ze!NT;hMkd^tmyFlN>G&Oxso5q?prEve(<7{EijTSPG9`%Mly*&AHes-}a7Jq* +{llmLm*T#nvHqqV=ZA!Y2_R&wu44I>}U|I5<{>2j66ZkC%IVD1XU7S^nO@PVVzwvhRx3H^OY+ve&FL@UI_n(e`eI +la+T>w0ZJ${47>n9;Vh9nK6I(-&N +a|9zEgS}kK!wwo4{^{FkrjP_#xg|vde@1=^sqgy5lcFs#5Vs3M{y*2EpM>DOa$kH;&H|mSK%3s`~)Qm +fDSjeBo$x3#vg`agD=g*I=DA9OKCjOE0qb1xW4q$kLDD#e2LR#hN|TSlasiKBFB<++VvWC-OnKNs$Jq +L>_Gb2K8Smgb}X$c?{dC@dL5X40)tQ1cAS)Hbd+j8gDdZYEAO!*kvsPXZ%%u6Mz7GDx%(a0>#-Hs5qj +gS3-S6fHwb2iU}j(yn&f+hk_6Ue(!excP`$P^rCOHcYm?;PTiT@Eo!Zr(QiYl2+-&v|EueD8OTNJsst +E=c*4i0jcx<0p_#+0Z>Z=1QY-O00;o@p|(a~&wD2X3IG62F#rH60001RX +>c!Jc4cm4Z*nhabZu-kY-wUIbaG{7Vs&Y3WMy)5FJ*LcWo0gKdF>n9ZrjN9U0*TFzzCJ4*=!zzm4S^f +g@LYPWE~)d;u2$NB(tSRfgCw@xB2&;xsh`@q$qFFmoAam5_#^oIdg_y)zyY%*=omkHOn%RZ?;v<3B7B +oV#isgz9(dvKjckbl?mCE`J!5~tjIa5Y0*qpg2Xo8rr854msOoM`JUoW-~ds=PeN3f@hmg*;QM4M$aO+lTBL|zoMX$)j6EuCJ0_p}`168dCWUgkW@;)WHgM4B+^ +3^}{1N*hC50x-=42uLD+^*ogXG>H6+z%eDBr;-s`!5E9*&~+@ubLc$pYGs;E9cuZidqnbv2=(6v{G?n +0?q&x*vsG;7(LLW3(QRTG!og<{3L_|bX6z*=Z*OU>j3~rKth~5~SQWl+0A_xRK&%S7)(_q2u#JyKh!- +5=49GZ;%pg>;2*NF7qeQ`CihCl@Ph4VVUg +SD{PD}m9RN|eyv9;t-T_J&9H1vvv^oDuezH#{%b7ARTeb;CXIPoF-KW5VxQ&B%s6kvm2x{NS)glP~a{ +S7cei^SnvZ)WKa`={G!SX0nSV-W*Hyi~U;gKO2Iq;#`_$nu&Ofn6*lUTh#Sc-q$Py)o +F8`7r)GGDcjNTHw+7TWqlyT26$k&7ux|mRx$4J8&(SL<$yb6ia`HiDSM_mBdrcGv7UJPOFlePQp_*il +Pt7db}1vxe_TvN}wYU6@OS(2`D65Spdf@e^*t7mp1}hU=^%%pG-aZ=ynTTvoe6L!ft>6`! +4_C2fCDcdwXK7|cEwZvdB?z|%#tqw)mK-cpn17uk3cA_B-2zri#1-4IIj4Lc`OkX-)Cx3vrYBDMj6@g +Rw(05C%Z1hbT<$Pn&*;onm884I&0B9RXj!l2d$0(>#w`O5ie*+h(fK5_Ea|s_v1{8@AYW88zB9?-V1U +m;beMAf{djW=f^+Yrh?80rCZn$ig&QM^4PKw>UpOuBfd9Vw#ZjGTguQ0aNA +;orcY=JooWV6=a=n|A?%eVa6(?=c0*0AaE{5K#Y0PaXt?qBqhWsN_eGx)0|^p{FpwlYutr9w6f6qJ3Q +_j3HK^PEib08jh}*qj(rpWMhic=BmDcJ!#A++S$Fx>%!zN(og48VtB8j1!D4myHbyZdHR7avIvFyvWy +pI$(^C<1sv`|0{N+zYX#ZXZZ`e8(_>e%SGj0lh(U_3&A0TLikBL!Q$P7d+dujiQ1?PfsfUccEhBr{>s +W0~OrlE{EyNAt1KWpD>=oFXcRclAyT;lvIF`Zz+1!gP8$w0%`6a6C$1YSGx#=qfQZQZhP7@&4Bnlrvy +DdIu?88}#oj3A}Sh-LF!)BLyV*BX7a-vB3$4AThoiIB02Llt)=ln!0chpI)m3$ +=Osdr{jgw)?MJU)jPTyU^dXoer~xv2LF=9ID^g8WwNg8kYYZYZ!47M>sSo#w5hZu!o@k`0M%AP4?ma` +mc2U#y_u_i-;g`RP4~DZK2>k&6jnz3V@_)0s-JExn>j$LLH3q|s?=@Z`+s%^CUgO&x*lmkGqyvvQ +T}RlSrz`DNnAH`~2&VYXBy#2y7qlI~vv^9nafTPtJyR$v(*{WP^^{#;_Anhlt{=>vKZ-ha$x%ZhF%A< +yPT&bS>TQ4372AatE$4>}(k!WLnNH+<&f(;dl{-w|i*Bxj94&4ymO6PNbO&@;UuMz$&r$O^691(JFUd +>tio`0w$&cjCG;v5HwsO>h9(F%-nnU{}mf`cduIe~4WkC(A7PJ)j_w+$+sd0V7BvZXVgcL28a#rPT3V +P!E0Aae#MYP|w_)+Jehrts+|8RUPBK-LH#Bzu7#-JncfQ6bXHt^Qe*^)BpPPD@J(c5YWuhbzSYY +O&n?>u5Ha$xtv^>qx)3d5*yIwc1S?TIb%bGf}Qt?%Zm_GYuwO~sJPYoGX=MSGv}Y@06u?tKON +qHxO_;SSne8FkEUnW{3IJT+i{Zxr8Ay*b<5puLIm|uKpm!83g+WA5_m!bS%Xdw&^I5_z@R2n5k+g3UT +k5pM7=l`x4^!sF{hC`(@u^W1l_kUFg2=;%4AxmDVF=^Y39J8Tp=Ql(>8B_L&~)Z +fm&wj8fFKhfthO8;5qWn4eljdZ0V25F(86>D2;Sc2Q$R;yPjLc6s`L)V=?Kw%jR8f41DRyAA$)b-<3V$IqyqYWVTss3}3$}Nl*&cK{|8MaW_ZyxJn(6uUhqU +p0Rlg<_}cixH~d}G>aZoCnuntI|5jy7t~(9LTB#lkYS`2B7>8YAE(gqF$g5?cNT-`;Q=kpicw5&fpUZv8Wcb5S!b{#JsNhtNddD +2srGo24e580H%}w0#Hi>1QY-O00;o@p|(bopC$Vx4FCYoHUI!G0001RX>c!Jc4cm4Z*nhabZu-kY-wU +IbaG{7Vs&Y3WMy)5FJ*LcWo2J%cx`MhaCyBOYj4{|^1FV;mVqHEm02fW4(LSz65F{LNYWs2uUEJ}Vnw +bj#uTaJl6G{x{P&yL2f4dkQnHad0&Qq=-a9ipGh78h@V-o&oRL*o5#DUKWmRXz4XM|Rq-lJjhtvpKoX>UG)FfQF1#6}`!T|C%PZ9 +1w09Ng7_48^Ut7VMRSD=!OBGHLc0AV)T|QS$)q~K`MZtoN*~tTHY5NL?c23kStS3_dt;rMOg#FwqhJ< +(mZb^BB&w%E8$y~WUDNJcRQiPs?7899)+Z!>umuHP~C*0!rQ6@+ztPEGPz`5YXas=$_)z4QC*}An4Bn +sR3-4&8l9ENZVNi0B}h>c)NnHSZ4ElnVy94m2dE)PBuP`vQ4hAsYC_2wt?4_E{x@0`05J)IU@}=%V6! +-0HFZ<5I40Q!*OJgBFY~5mvHW{Z((EqdSy{|UQ)Ee*vN+FbR?(bKCJN_X(&hT^is?JPRe?xJU~z6`vymE3SyjXVK?n>@e7XA5#!HEdGTo48^(? +CTbuR1BovY{3V^;Lq^tpWm*Z&c21w(^)W^Ow^LbHLMrF3WCw8d>96lr@<@&YQQ7ODdz-Mw!wFo03Vji +FD$8NKTil;DO$>Vd18~&9fK#x2IAw7c7OyAd4aAbjn2-lK> +j6}EkzD35c#rSpiCewazZj`g{$&LKjiGew?L{gT09QauH=n#7&iZG}TvHr!lW_ +nSvKToc(fo`TNIna>QQ-YpgF!Gz5l9;4Uj09?q~(K*z%P^skS@a+u +Tsy!UhK1-pr^BVL&4F~W)rYGbk-LJMjFu@xt*%LKRpSlIa9Eq9Ovy%|EJy9`PhQQL`v#|47@hvD`;!V +^3xx`QnrDwSBc)`ot8$BPAdK9+RAtNsY^Kf|-6#k$?b)!rADkm!`~hv&Itt*!4L80aOZeAePQ +7<(ldo-3=z}SpzqrLdy_!yJT@$t)H%SEtFx#sikAT`bMUa)QXrRM=g*5yz6XTYRo- +1{1B|8(Jr8UE#I$X4F-Rk$?yd^Y-kZsftyA{A5UKjJ|DkT!F_C?U>utWxti_S=!!{lk53h$ht-jD^SQ +B7FzQBTrsQN*9D;Z`xUV7PtAEQ?13EG82gQ!}6*W2*&xCn9twO=MTR0j)bYG*JVsAqfD0(OSKW<7|-(y?fZfhFu)=re^LB6gt^v3BP8J^EO0(w1FcN_ds +1ksl=E5hoo?N>|biB6{q{Y2Zvf?c#O!bDlk)uI%lC$38<=p+>!H%S>s8r{9U>*G7t2X&4fc=)$p4(Y4 +w!v@fLSi{NX`}B^TE9j=k0vWPz*AW@<{^$}B>%$|it3xx$=Qe%U7SIo0RJ( +RA>a1JQjZD>sIU1{N#bD?+KdACR;Kn~vaulvMob%;+RA#J}1KQx6~`FZl)@~ +}h7)Z?dtbuq*Lk=fd#7N+6JXc~S@4t_xTwUVzKwc;G}wQMOuF)ojcCwlOzn#fauv1rG$`XxrE`|eVwB +c+*s-%c7;X!oA$M%BwK+iWE{T0`@#dm>}T+Mi>e+WGamBTedT6O<}RICd8f$3GBK7{}`E=s`eoG^N4>_6*}NuJ-?niwRKXmDq*el1k|%@&&Ut2@e< +zKl6dI*XjG3~M6h(7Hc&f5h#vbYiHa9(sW3>e0mEf@(#e9`haAxJBF)Q;U?PIPmO(^WFy`mA2r3IPMY*3gs@Jf2|yHb28fQ?{^7{fX&iEvlQ=W +%pIXTMu7YSh*xH>=#kMR93&$4Lk%j)tQ!gO< +zJ`DvekNQ+t7=$55OZ +qibEn=CFit(~*t&&%BB9+XTZ8Lr`;Gf~tk)a(wvk>rYMc|m(@nK&xjt0`%+^naky59tsEvmgAP#g@E} +D24w+EoCakv0c9ZYXJ6oA)F@C@F?AdSw~PtrW<>4jqlQ?kb3D|A ++^ic7VNqJ!3bQs(2IX{a^3PXRUIA&Xcqo~Ko1I@B2=F7u7RF;IrX~pK~ADacTCuRD{jps{q9UUj`EDU +yk&)9FSVbG$5#RV6?A4Zjz=i~{low=jz}pW{Uo@yMie+7KnAvs`lwulH(`M1&w8f~3EOPzoo?cTxqB$ +io#*w#W!M2__Dw%XJM=r?y@efUX43d!;ZgEnMT@dH#up>1+F80))6`nz%g~U@dq{4~XnIuZ_>!H&tO8 +<7D|q8pFy8FePGh@Gq{ret&58r)gYiT81_!ZL7QxAve;?hGXReN)UHeA6p1t&-HKpkn*l_S1gwF0uwk +wOYcdV6u9K3}Tmf +q#6rYJn367IVo?rB!{&_eVi%0N}NNM3YQH^keQqE6C!74lK1^OOV;WXG^}PjPgSR_3zWUX1-U<~V`!$ +EngQlLa$y2Qz3&)`>W|Ks5FAd7BVvSD5N%R7Mz%u-|188d(Hn@q8n=}+oRW{fzJ7OcDo@}|$GFNQ~NP7=|JE4 +k}*l9UDP`cNnVWX=Sav}`b*{?(LF)$Q99y~+wPAyMU!pHPK4nf`ima`OBy)4{V5KAlI-WVXIA)gRXdf +kzA|jR2S)@o6wfYUFF8L1G#Vh1bi#jh|kC;U;fYOpn|dbcz!{W1u9>Rx2jQgM^@!jt~8CnVk`e;55fz+pNNzf=bo{(2!;}&A6O}*XJj1s*2B}Xi +*)D6m=LcnPSKn^^j-kt`ve=J~;yb5rm3$ACDc*YJUlrl>Jk+|{AxpDj+Oq@9#YK!BP6SAh7`GMU-{X! +L0P@oc_CFbAomp$&%$_Lray0(9(Fj}Cu?W~4CreV-N4%Dy^N&wpAVm#*zO|dR-i9llSA9j)-nbdhYQ? +h=bnV{zMyyf5?F%ou?@GY+8Z)v|u(s7{=Ey#J&PuSDRp#`{ali+W7xWy-Snm}`05xRqIFQ)l537-%7L +ia-mUFn)s92YWsQ9rn0k54#v&<0S8s%kqOa?qm}306`M9ZX=wJ^3$CO9KQH000080Pmr;MxQo)HHHQN +0EQL-04x9i0B~t=FJE?LZe(wAFKBdaY&C3YVlQ-ZWo36^Y-?q5b1z?CX>MtBUtcb8dCgc`Z`(E$e%G% +!RS{I`Y+=}AFc&D&Y}muvV)eQXsbMe@ZL^_8jii!#MgRNGA$6DRI@`+xB$ml@=XWl27=|w)RZ{ZQ3YC +M}z+Ppg{$TL!nW4$} +_k<;0pJY;%}}4uQdsRrGiv*W;rk*$?(AB9oNnr204EKdnh;=>h&H}iK{3Qm1HUq`$FFAUl_gEAMX%J^D3+0q2TdX2sz?*eYZEw`< +U;S9o}&?2|=mZ?2`a59}<&?K`H2EQ`5AwTbBwHZMBgheSO@vefPvd$b#WqFd+7Go%lWf-`6qqIVrdN< +=6R!X~e@&kt)Z{ih85e^IZ@-+woq=KFU5fLu&*k{n345Q;(yjD3bK7W4qfWbHMrL!0#`ZFg0bWS;y%y +>-SGc8nU9E?njBX|&Y2e+k=b}n)-WkL1^PF$@V<_@zt+k5yCeu>rLQS-k_p%Gb#FvC%X!LSM|?s=TRJ +1>rB-GI__&t!>4FwHN6;hsM!RJue(cqR#cP4*%e_zADx{5lB5n7ux*frx4uI6)r#xsRDW0+98k$E--Z +iRk?9>o>qZ7s`0RkL0xv_dFzFF2x;+$q~RCmU4*ha`li?B0ng7=Z@rrpldH^>8e25`9|pngyO_G5hr8 +sXqTLOQ&_Rb#Ll|TwX9=CpDe`6;Ai(XkOB|e6+_-cxP_3)Y8DOO%F{DyjO~4biN6Gy~IbYBek5M6RSQBMlpuUAGpC1 +{r;4d=0FtU$@epZ9tdlJWCw7PubB___K{@IL@=cL;I8oWA!LwkUhcxmG{dLatCyaL0jpPK7|h-K3u}< +>-X2cLF$^!4#$_7d#4OSB^fGl2*yn(0n7jGL=O6n?nx5tPuCQSUmac4H>uN+h5@UD41!JKq88o01!5~ +raSqDy?`p?1OR-Ka-Ov#E*`dmug6A2!($E;106fB7ttMLMpJQsnX{!XM<(rVcg{xlHHW}NBro??$V6p +Bj4H9@{PJ)#W*P=>M#w-h0aR)wTaK@;6BxH<&gWxiQFW&G=7#Qia;A)tBQX-E=^5U-}fhXeF*XbOo>) +;7X|FeZ22Yz&me1~dBoVN%idjPlDZOfj{P%S4)RobGott&XSQ{P{}_hW>dKwMAz%g +sEM?uId{5%u8Fl$VL4^iZ4=6bGYA!<}bi-ZS{F)Sg=ZfN`8QPv&zBILzl$+0*Zi@iASmRO;Kwi8^_@) +)nQg6zMP76xD>?p|kweo2%uYZ?DPxkT664UW9apCvIr<)A#fYhQ2e8;b@(E3>RJxumliSCr+J3!aug$ +cq%id82)8o|G!~vU7L)-vFb390DU?RzLEV$i{6=uKb*Sz>X*XId#cmdS}PrezvuODH#ACG_fwtkE!N +*?9Gk!Ugdg*2=Ji2}gMR=}O9KQH000080Pmr;M$N-CuL1@D0A?Ei04V?f0B~t=FJE?LZe(wAFKBdaY& +C3YVlQ-ZWo36^Y-?q5b1z?FVRL0JaCz-mOK%%D5WerPAU2m(s|xK^sC%&$AZQ~8jnXtQf(5-x*^F0Qf +lE1Y0{{2U@U`T==MAsLoE!u% +>XPLZS4`5XNwx^F=lex|&qP_vMZ-Ti9K}AVTs`dBoHR;uaicp;lH@t9Dp>D~T%{M6=WkxF)|+%r@O$& +_)e1j1tAF*->aUfXJ->YEKH=xZ<{f^$S^v4de7jEP329rpk&L~i)g6;4v#!P8tT@Pq-?L!mePY;u+Et +4Zel6=Y*q0=Z7I4IYh3n_*%ZpWFiS{OO&`2PEH;vzB)LP>vY}d?L^W2>6T0L#ASJOQ+W9^5j^!I1B^X +!k*nzmRJwP+L-s&VGs*SuU+Y{y^>_GM2Cc797GEnq{Nq|-;(bn&6)BJ0e|k|ZhFmZ&<%ZO#Dex}xGP= +i6M=f}L&Tfz6hBSJE_nE9rjEB%!iCh>}2%EPQkT1_7G)OgmrbKHKfpgN+(c*D!obz=}r8Ed6%FXteM$ +3gtj0S0UN8DVHt!?j09jpylcl53{CS~XRWGLYmz>yo$^|lcNcH8yYgCUvYD}P)K4Lc-~`P`EuAN +vcN`rp<|d6?2O~a>$gHSn(~$OPWcBq2RwzpgdFMG7T;+Mzuxbnb0MWn|IJm$uh!^}xLOqBUs~0+t@`e +FL^#}L_ +p~~6)rM5IKs4*@2-vID2^VH>77$FkCY#L?5AncRRR*E3vU`j{fEY05Qj{^k?C8A9A@yr_G|WErd^6zdZe(5>8y=faHLenqW1p~{c%IIpRVkVroE_YW7hw5m{o=azan0 +Jz?QsFS(f!w{K<&WW&=oZbJEs}24v8Gr+PBX;G!Ho2|wZyu79vlvrs^#&4yYxA +XV0dDX@J;n3MhCy5hx)@(hnWPKkvOL-t{#FNoD8dDCC5~%#dX5EF#eAXC>_L|s6PtF3GUpR;k#c +@%e^r=T3Qo=CCSgNvcF~xzeZ&3XK?MhVG3{j7fexJH36TmyGjAfa}McA*QMWrvIdvE<`5s^=38K1QK) +gXWhbMIT`a+|4jWRfznJ>@kKh6pNkMHOYSnpFFw1DKJDAR11Q2nxV;;O(W&3sY>w7bw81}xXdW~t0qwuU)9~DTY#%XpBGv$1m>~xSJltQyD3Pfb0Bl>Ih=aruWarVmGE6Ok(@&UPHi5) +ws>2p%&Q|LQB)%f4x^`l6b?uZS8~EgCCUWgNWTaqOote-tPs&cNMW>(~IJm@6aWAK2mtS)wnm+=3F +G+z004~z001Wd003}la4%nWWo~3|axZ9fZEQ7cX<{#Qa%E+AVQgz9-@uG{kx0la1`C)W)FXR7z9`fJe$-K!ny2XI;C +2auAa3VRS}c0;E?3HF^SNXjh;p<1&=MYm8cLaTv2$Z7s2R6o($rVqvw!t327>rddIXpLZ$A@>MzpnI% +A1pgn3dU<1RBi#Fgs`(ejfxvt!=JV*u2x(YlM@Rhx(jSG*jE|C%)v{QU`!p%md1f8a6-_1@kJ +Jy84{$Z_Y3J$p)NXvfXR4HtXo24TOw4sBtjj3pOsdfG8VlR$nUL`d9Ap?>h&>T%K8x4gTAo6Tj?g%xS +%{Wx9Ja`^rzLDR>p8Jk`zxHG@sWUcCFPm6N58cMYueiyUGe~za5aM-M8Kn}YkaOlZh~E<&&Fod=zC)% +;*ZliFcbvns!Kj`#ik{s;6hRF}HKSyVS>}@xj~QiBzIImYcH$MIeL!`{sK@-0|XQR000O8@1e +Fv1Mu`H<^%u$?hyb0DF6TfaA|NaUv_0~WN&gWXmo9CHEd~OFLZKcWp`n0Yh`kCFJ*LcWo0gKdEHo1Z` +(Eye%G&H)fcH#g{Iw8RuAYBrzo%_Mdo1}jLcx9vrU8+1(I@O4E^uBBPCh3rNk*PV4GenlXu^J_wkOTJ +=bc*X0v%^D-E+56RT2b%lMs9va&Gq-xHRLwJ<^z39AZ`sT^ifSkPRWAh3FK8Zdn31ePf&A+u;}8nkPj +gNFQEWHx|@3`)yBxtX!nN_*cHqy%QqYiQYE=peQTSIh{qyVXtN3e_zKX**2!b +5uYyoyW(EvYHLL&KSEMWzOr6Ekwf8nHT?9=SbBmSWEzU`S>xmQeZ*DbAQqL7w3y +6EJl0V^0wE-bJ(O~|-mwn7lYz6iT?1m;+o>I?d{aG5GB200Ddk&~27&=g@cPB8E+w)1cOyeM*bU~2Ag +Ya^r}k?tCZrLcw)-tm2xvJcEyp52otFETJ#CXKt<8h%fPbIBJhq*4qM{NzH0*b)pi_W=qlX>O5?O{kleoK@?R#CWSBQBI1YjZqa-O&-oeH1_8RFhiVCI-|L;(ha4L2IG@cj$4o&526{9||oC>bU-04_?>D_xT~WgLZNbtgsk3Ad%B +Gio-*!iq+pV%Wd`4RZBV&#o_B`dg~|QTo;$_e!8s1o5MWLQEXmb0yiEJb-wKy9{lEhQO*7;%IyBJ5#6dLEatB|nWi0^$anbOnvx#_=tNb+ +mhNhUM)Fbl*n7w8vk4EYkPYL2Xc5>^&(%U~%x}O~;-I@PCm5aC7Ch{>0`+Ow_l032;y*;YY^iQeEp6kLh5~+ +XHJv$HYm-uT)w^CF0W3nEK_frfy5K?7a(v2%<{wcV0e>>2XtmprSXz%}oIQSb-O9KQH000080Pmr;Ml +Bey*TDh+0Okk)05AXm0B~t=FJE?LZe(wAFKBdaY&C3YVlQ-ZWo36^Y-?q5b1!FQZgXg9b98cLVQnsOd +6iX7Z`&{oz2{eO-C@pP1lzSh4q1}JfFtkm|J>S9YGAK#-$DJfJ2 +VVIPrEHDg#XSpg2um`O~X)tW&KE%A@nk(r;DS4z~3FrjC&gfI>$^&?+Is=yB9`<`VuxqB0=egr; +j_ZuH>ci+POYPY?)Uahx2Y_8V9uWS1gY;S}A1BCmV8l(O;E9=cFST&37@AX$7)>pgTb|18C7ad6Wz%+ +J?7G7$@q|x1WrFgs*n4w+sL0UaJXAxS_vq&(lAt(@kGLd58)liFmVSYISJ7P?1f+<;H=xG#5yH4Xhd? +}Lz3owreSWy(v3Z4)mCLyN)T-KY35<)$3c>pEx=${u@aaC$q!rom^RMEhZJH=cWORJAdgD1T^*C3UtF +;0y-Fr!kGJs8cj*SY&mtohKD#xq9|HvlL54)@x9=454~?sTr$zvy*t{SrQi(q*|se3w<|v7GPVuF4D%sZy*`IFnZR<{6zpka!wx<$V+#I2t^{+kPc>-Qt=U4ThzXhx4C*3nt&Z~ +(D_iLm76#+6kM-y8Aakh?6(z1U8Yan#vG+pVH4%E&yl(o5QWyli^U|K54{0xHes2j?0~8c`q(UdK>0B +*n3-z-2ojfg_&c3^NG?}=#2WF3`PPUcrUIXVe2xhr?4%oqS#L=%mr0I{UnHW^!RBd1*()aGuJ-l1eRr +eN@&iQlgY-{9=ojZOAjdd;GRzqRVlRxjz1%=ZYR?_8I-BUlDQTVmlc;&Z8U+41Gqjf}~j7KC*@o%4-Q +$z>p4|0|XQR000O8@1eFvGalF-DFy%lXcqtgEdT%jaA|NaUv_0~WN&gWXmo9CHEd~OFLZK +cWp`n0Yh`kCFKl>iY-MzEWo0gKdF5E$Z`(EyfA?QOxacZjics%q=$5_Y11PYjMdzU@0z;rB+U81qfTY +p{!~XZ(k@_Gd+Ub_3VSY$t-QDkw_f79)U6L%@wYrro%Lp%nb5_#q+vgnc +$j9D%4_!5DjnA?4DIcEmOrGdK}FjbfzC0wyG_ZMi6zRH>m15OkkOwr3AbhmrP_Y +)e%SoDOgKfr8djEEbD`?Fg$Bo=j;Osrb!;z=!XMB3zN1x?=VXek21IROY35#{}@fnJcAfm9t1C<7wiV +nCfKI98skOLytwvR`1S!Tqa}**6>^}W3Vw7R4MYYu60yz|6sZ9u+jD`;}zFg7AYon2{_Eri?329Sjj4 +F+;t9gpPC=QpORHTy4wsSI2F@rQRlqc)hVwaiWL=?>&p>)hLF;xf!Icub&kik_IT_kKTZrB)e_E}RkU +RBv!R-HD|nvq;`vbOQE66YtrT$_kD&xxjfc}cBqs)Iq*V}GpyAua@bW8oju{e4G?Lx(x>Zq(c~=3JpL +-6>TqJ;b93>bw6p2qMt01vKk)J-8?Z7h>#7LlA^aLkY0f(dO`gHxm9s_ma+II&mn-QWn1bOC?Q+0w>o +vJzSYACEeW1p%mn~dO&gkVZ0WJsxmbSVMZH7UPAs0+V&_E``N9S#3{!hjFd;n`;y^a9K9{H!3I_OO4Z +F-oh=;LdAF_t9`2LGOqH%=Om?-jkAznP+9r7Xe|uufJ2_i#%u^||>-aNtSwev +QRDO8eJ{w2^1N?P+^nog>wRH({B;*wy_Ej9H_s$FMsOzK*X)JwzKAlXWBPM{4!zNhg2TcId(vapma#A(j&Sn~^!EnOwFP;`haHYc#UQhO+P8}%?9mH=; +J1$^51Qq>GoxX(?NiltG2$7!`HxRN*hJ~#9YQ??7^Nn*XJ8X5^2;d>)1zBSk@+K&LEF0u*x2||Zh#-T +NAE_`Sq9rym+^^AyWeg7krXrBFW`QR#R*()2yl$(4yi`l_5+OnrXC1h{x?Lx3Z|fV*U|j4hPt*8WCTC +bqbaaV#`TpYfcUL#-0~;_go5vI2kq0{vVrUO(^L=m(& +)yC=W8{u0fC&K+v{O^QJ1Lo1mMN{cgAgQd@PO`eNQR4s-TBHp1=p}x9iVG;O|y%&Q=@DUcAyZIsS4maHJUCR+xsgrqEZMdc&uu5_MUNp*gJ{2#Bvsd*L6Y@++vU-aS3hSfI&KbRD%p*a>I +I>hp&ds(-Qd+P`v#Y33x4*kdChK%&97}5u4@SlHquW|pgnR`z~%do<+30e@8;oB6)9~c{ljhiSpJHeF +CVtb6{)tvKa6vDvAJwKfJE^>Sxt)OAK-+zeX4X88L%rL?cagZ?}-5wN1@w?B}uUEE;oV0LeK#D)I+?L +`7s1XJ*e9tzz6EkW}?I*Vu2T_1H~}Yc7?(z*Q?eFuL}RUFOK(@LT+W-sAmvxGXFeQ>f80*D654;f +1Zt7k6SgFo%11-~Dg^omzG~eq_IU?caTGK=wDg6#n<;C)jFqo_9W(=jsb`dwctad}So36^6J~&fNXP^JWS3D;{`O-oFY~)S@Qis6NVK4TMV|`YYK5O?$ln)gUz=)&5$|as++`h +Nnr#nVF=~A7L} +V#Qa@sKVzfULIv7D&OI+z|3bf^37yPvL*=k~t`x?fF~t0KS2Z}Y_}CHdlNxO|U@J+r&p_B#KxxLZy?-sHu%>-j3b|2&=L +DVbeQm($rQU*30)vL3p4q8fT(ww6L0Dva*cJITtNLk(6IMbVm5t;tFOe4~5=Dt6}CAV@A8of0aW4~(r +SVhz0NS5gt!SrUW^f_Ry+E(c79TMgz+6CsVmAXJoHl8#S2qGD +~_d+VyldHC>%V*gokaRTKz4j7!iKbHhQXd^cuhM@7LdCV +9Oz`xSkjgfRouz0gM{UMU^Rq5c*5hrEyZ{6%UIGmx23R)7aM_5Cx3P?TvPUny@OS4ygQGUwc~si7oSc +eh=WYTKQ(zHrlH(cSov7iNCQ#`x1aNutBJbOB&6U0qWm;MK1#*2xO(-UuZXwOGT^vKX@$v_?}z$na-j +?qMr27hw5k0iEtkGqBh{!FHAe +to^pZk_4XP2U_`LVMbYEXCaCu#gF%H5o3`O^x!Uw2001^Wd3~UVSQD_{= +QrbkegUIbmlEQ!|KYc&{z-a+%L(#%$Ezpt^E4ZhmSQPEx2|T?>D6JEemFDEpMp9%K#hB239CH224<-a +BaIbAMrt|5C%JpdAGsE*vTmI)>&ixqQGiHTb53kILhnk&;!6-OzZ`h>`P)h>@6aWAK2mtS)wnp?~g_C +^&005r@001HY003}la4%nWWo~3|axZ9fZEQ7cX<{#Qa%p8RUt(c%WiD`eg_1E(!!QtqcmIl0SrQQ{m4 +TsB2L@OWh@o3mS#El1EF3%XIne%l>^PxGn+k8XzjycE*@ZO~a9%X7vB){dsy5bv*pX3?(y709XMvHQFSdw|vU}u4U2bKoSJ$Ss9i^KLZVfE(ywk@D4stt~44 +R=TA$}CNMs5<*Svb!&rz-RM{NcAikZB*1Un^oSd+Zexxgt=qBB!=ZvKw9#|d#9)VHjLEKQ>v!Q$-y1e +61vK`w*(=j%1zP1gr%Q&z8q4Dfe8GS%<|M(lsJ35@4cSP7Il?)0ie3N96fkNH8hI?3CCybYy<%8T#x4 +LTAvV)XD`oH&vrx$CD?VH`o%l*%c!Jc4cm4Z*nhabZu-kY-wUIbaH8BFJxhKa%p8QaCx0l%Z}SH47~d*h@51= +@CPighxBpiWlwu63PG{yM6E0tBAw0t{fbr+JMkh#%M&Hej5rj#7<$mU8+nYVHQ0U#k-_XJxRFuka|Nw +ETC%}cFnZgB7PYgC(KsrKPBdD>(c*>wD!C!}wv{X+20PUHh`tT6CVRR-8BeVFeZaF&t#^i2LfbE2C#9 +ljoFSU-)%mh~Dj-FRU2ndr=oU0Pe!9;>*AY@fuZ@UoT559x-6TVJ4sRc{IcHjd;8i6M^zC +o2x)!h3XTp}8qY`mu8_ZUM|o2_&54naQ>!w!Mc#QdH%pEz#Y6I#C +$Bb}`ggE?f>OCMUBS_~5wG6UpY|*Bv+mDC`IW>cQn8qN6Fi$Vo9pBgaG?@0t(U({dDdG>IP_=snwV;8 +W|d2tY~d%oY4|UJfAoXH9zA25zu|_wM;6DAyS}qO^QT40#35p5PtPyG<0FB*TN%7)`b}|G(mye0kvmP)h>@6aWAK2mtS)wnj@&Zq6M7008d>0018V003}la4% +nWWo~3|axZ9fZEQ7cX<{#Qa%p8RaCt6pdA(K3Zrd;ryz46#K2fM3wATPSq(yt|$+sXNXlWHMN|ORfCC +=Y>sfR_$PWnJmo-EGpaArA#TW3!oW!s0|p_D+U&bk2V;H~Zh%JI8^hMvijH3jsBYTKaH6woQ{vo=z6) +RpoXO=Df@={)lUJO>$GJIuzi19_~&jE-MYV;d&Cln3Q;#`lg8l!yDzU*gX!%WAE>ANIwxncro=tHG9S +kf9)@@Tgmstb&@*xTpnV*_qaYofsdKsZpGZMPm-Fb->!q&|Ch%S1-NHIcCPXgru>g%`Aj>Bym%o@U6xt3=E&%SG@E-F#fpo52G9#JBKZutMAs}Iv +OJYZ0+7@u6n2GJ(uF3{Fu8Nh(Yf4nio +{NccNfc_2cYn#2c$>4!-t*M(L{=q%7^ZS_auHc5Uyh_P8TJD`rh}U#tchY>shUQt+VWKm!G{VyZJ%ZG +rbg!X-_;ZxZ!KNn$VbyMg(}|2%kg1HXz)_7hM +`0|XQR000O8@1eFv^?#)GSPB3D$|C>(AOHXWaA|NaUv_0~WN&gWY;R+0W@&6?FJE72ZfSI1UoLQY&06 +b^+cpyauD^nCuxC5xRnnpd92VW6>7@Y{XoFmupdZpepe1_ESP~tQTCe~6&I})-{95O-2UG}lSJH4^oX +3x&j7FoZR^@6TYmu+F?2^5$xm_sTT*|f*YXLu6%XoDsjnZ3&bPN}mJj>pRFP+rFu(w;gR4w~H{}=1pS +{TE&s$+b;uD9^;hrE)DMfNMKlI<;%hE=K+3>I*<7W&dIwcr(-a|5qrYb@TWg@3!&szi?T8ial@{8n6L +*^3u1ND+3;kn?L$Y%(^g5vbyLO7E@SUS)ZnGrW*E=Ow8;nbKo%Uy8M5FKbj_i)=*IFIZ~{ruRH&Yzzw +4M8&vUlaEtIqzDJv(_Bj4{`u$Fvbpfw0+-r|y@j{R64f{hf01eKE!iYZ;n;vx?{z1lYjQ1W!3|n_mb; +Gde9b{GBG^c~r1w$FhtxR9@+_sEup5gpqgH&&ta9{rBTK;+S~bir1v9)6%!Lu?bwt$z0pJC^U#jkQ$y +&uq)wNb=l(&KnoiU>*lwrqUzaX|zc+=HZt|1SsY=jAHPFwm51&CCwfzU-|e$iTKNH+*;!OEILghSRb1 +?FfUPDo9(c%gretl@P{axu9Mti)>&;lSZ#>je4K112HOd|b1osw+dzrI1UR^-&I-@P;ki9V&yn=dA!n +MzwM22lCzt8=QL|w!$$Y=@>C=!wu}64Y@Q}@m8p`6_sJgSFaQ9i}pPQ|Tf1)fK?o@p4q=2#U0R&U{yVG?o=izR{bqj=X>7r{(t5j{W>6Huix4*poH{)#uHno>@b0@SxCt@*;@>rv)4vKvy7i9gC8*Z(hM1mO`c~=zf*=Tx2K8+Ol@I7Sj-m +CZY;HZq;y$4aZ!WJ#0@4gU6k_Uo;l>Xftc$H;E0RaU2a?L)DDZ;SK#*_&+@4>~Yvv@m5i193qnQh!_y|NT{3(LdRf|1+cq61q?wf66kKE2PIHRuk_uj8Xjk^XX!e +yV4UoBi^{;sJVod#5_LrJuS*g>DM4)AekO`9i!hT^z*cig6aX+(qL>-o>>C<1}~-b3&7d2 +J8gWIvnH7T9k4jOJAsv06=SC3AG7ujclbYiir{RVg^#|a^|amsIC#p&!}QSCAxkCHhZU~ngzQPFpv5S +!2Ef1iDZJ#(}S{5(;O8ACirXk0=XBoOV@z7h%N`HhQBBHW6J)?Mntv4ajA^;Si|8qL>S@WWV$0>R*pZ +=z~9Mhxrj#euENV6f=V7mCF}9RQ;Eao^UtERcrfmd**_4@6I|C43R|T-$hs3u;&FY45kfBm0R>PI3W| +m!P6b+UJ4DK~67&OW999ExM$bkw#Ba-qoeni5Cj@tmE-&s!?1D`kn}4w9_X~gZtK9kaIFEie05185Vg +LM-$#8?GSzPi25>$Ta1fzwRx3F*Z7BD)*?Ev8W&Nib1K+_qU@PLrRQ($X3_!}2dkX>H79wygw6vjt +hXbCtmu9$-D}TO@$`4c?IHUz|?#@_HeVofev%|gV))3ULxnWuiv&=CqcB0| +4lI_HY!~i^>yha!1!sPgaLUoYx=X2S)`Vjs$7EnU|X9kp?u_jKZJC({8Z!A6@P{!IH#v!ispHbys9tP +xiJ!LnGz=9?=jf5^*K?-O_9A|Kpl@{BRxI>_+w-l6Nrn3}@{RuwUKFnVd?aPgpPkGQ?Az61v8 +|jWjaBE_hWaxI}AASx*2Gkj9+HE*zHl3?k8&})P65u&j84| +f~iTlRN4Q7GiAY>!XJ}Pd(?KiWr(TVrem5=gFk%EdPEiH5J@Z2@w9>sGzor(EB{-%p>eHk +I*OhS_9}e@sRy*9+rEjp;X?@U01ORk;F(p)JV#fReAkC8DGg{U1&W7-wNw4c()@{@(2&;$%rv3 +eM(|hNG*kgLcx6A-h_ruQXxaEHR~^JS=ev?C=Qq32K8d)_7(dS_yOvV|7QfL^i4(N~gcR-U5v`9TXAp0s8yNUhZ!pFmp2an`r^95894|sVK +6@Yrp!O?*7WVvLb<#RlA<5D;MsvHIS-S32V@=JZ&A?^q@?UD}oSMHdPE29bFeL(UPMPEU9J-uQc^t-- +7kRlwU14Q=!OCehNlQ(Pp?2hYax@(^`TkOu`-p1$2cm*Bd2qt-+PlrPj91jk55~<1J30j*_{}ewJ<{Q +n|#=Xx{Dfk?>HrWd50z;90UKhiExI6y$bZ^N4yoFbsj;5E7Hq>xWnE|n%C+u?|i9Nd7VeAb}Bb$7d;Y +Z5wfl?WaVkpDmbL8)Q$#_lA1{FT*$6hDu8nJ5*u!CpAdX{Bj8@6aWAK2 +mtS)wnjn_88;sT003DE001Na003}la4%nWWo~3|axZLeV{2wMz5Z)0m_X>4UKaCwzh%Wm5+ +5WMRv7Ak^BsH-M92C$13Xn+8D92%fUfwopQ5lVDOs*eA@OHz`pm!0rpiRKPxXJ<*}N*0i&d1WevX$rj +9N@aj8wG@@X)V~KoJ#Tn{&9l@&klXO2iHaWN>h%}XI0O51$GE_322ax1*ZT2sZ(sb17lMOwJjUt~pO-Y3LlPsHT>@aG7+tG!nmo6l!O +8!=1TC#$a4tL8iPF6x{jN&!`-&eRbaR2;UDXF?ZigArc6^g>#{aV#lMBN}<=nyWTzgZj{*m=?G{t{kvui)G0%(35`38wfJe4pBJA+;A3`RprND2(^~#R{Mrn +Cz5}7D!!_0tUOw*}bHHf7eG~si&8S<;;+aML0uX)LYS8XdQYC$_q6}zu>%^V1k|BIIjC$QF1IvcKKGP +*(`om1uDFQh)3qW4Th)XqBIGIG7!7j!i8i~(!Ek_j8vjT5kgq_4_Rf5ek9N81m4K2W7?==wm7!ukPrj +2n9Z+5^#_I^jvE;RwBEIrXtS6+Rj6GTt(?nND@Odd=_&c5a0zywJ8V%uj;%|L6IgW$22n1>!b3b0B@c +zOtv?RdU^H^U?hJ&8;iCx-fJ7?ONnyGt`aHUMUI%(rxGrc65o@4ko59MXpmXQWTHf2kkB0C~E^-RmW6 +9QNxqJ?LP^=b8Ym{x}$lG;-su_NYrT)P*J +}G);MF=$Vnlmg3cW5?&LkT<1QY-O00;o@p|(cex-=4S0{{RT3;+Nn00 +01RX>c!Jc4cm4Z*nheZ)0m_X>4ULZEIv{a%^v7Yi4O|WiD`erB>f-+b|G*&tGvkgxV~4?Q0={ZL~00w +?X?b7{e&BylAndRFc=`zu%o?D{*Y6gy|)cbNAivPb##kAj^u{)|zJ-h-#;_1-3G(tS!&{c@DYwD~wQb +GHE2NsCc_qrrnu+*mA9IGG)pkCC?)p$_&how +2N+y$a$&7)AZ7#F}M%-X4xpmr66wwzb@IP4XVT}k@$lt&)I?dNs>3xbqPB`ZUrbS3$vn)2eEatFdb~6 +XNA;UahJn0&vu-?DLS0!6Jjjga>E|*Y};l+u6S4LHwytzs)5kB(ao|PEhpw%|`^lTI%fCI=B4p|bGlt +7qHjsU)wY|RmbLoLN~&Aqf_6{<+9jBdig4hUT48GUOY-2d^R +!lHN+c?s9Iowx(!yWrMj1dzbG$}db%IM?aT!9{G`L7|Gh#@8V?@E&filY^y~4K*5#URT-b{cW#K*jp9 +N&`Dn<-N0Vgd}ra? +!q5iY^@0$Wv{BbL6<=LUljkSeay0vESyWYYLA@?37B9g$*-~SIM#QI??i(>D+@c@}MK@PSGz9?9I?z# +ZAfiE~YBar0Y_dViBbL!%ElVM{eOt#ex*Fo*kh4QVPO|2cI~dj=PR1&SgxoL!6`xjsXl&^EIGe{Kn=98P%qQ*ed2CurN1m_-9(D;3#Ib4{3P)h>@6aWAK2mtS)wnn7QAQDCh002!G001KZ00 +3}la4%nWWo~3|axZLeV{2waSfWx{KAy13 +W(VKl%3!d^mNLy%@*$JCh?eWY9xPp`7lx^fe!QpC*@NfJt`uzKR>IniOhjqKggpsuaN(FK4V-cg92hrjSd2UFD`E%E~EDkR|m%|L(PQcGB?p+FdPoqjR%~~#ezRcRXIkY5 +TymaPm;4gmGYUrzy3Wj1Ud!}kPZf!Rt1aWtg@9Bag2mYTgK-`VtZm4)zZ +qrh#1629Yz;CZeEPuI90(g}%v1*+itt+HVmUcaY36Oy#`;NldHP?a4I20t4lIX4D1BTm4mK5Kjuv}^! +s!vbd8zy;t$iYefZKJ37kxUE#W;JI5UdC}OJ+u&idCAW*2L-w5L_f5?i{Idj$mB`CL(7;MAOF^zDp6w +)jhfl-+SueFpz%dxG7y+Mg@YAqv7aZ)A{8UK|@>nml*Wv8!%;|92!Dip6LZCqV<1g7po`Nr_$iP`ZP8 +-J~Bl2v*Q0)mEk7gC==@rk>%+{Ic^j4L@5cp7jU?D*mma1|eT&Y?**YQl4S_)0UGJ#NMJYVs(LBCH#i +xZuMR-{M{q+CBn^`_toQLoHhQO7k^DmB^|Fi|GLt&v|L>IkKeQT&Et4rgqT7zkwR2=Mp#uLp1cUhk*n +s+2!fBKCCk&IV}IC0_3jv+X=@{X4#ahwU~;2eO}oT1WN@>=qeqL4k2xaGNXyd2CHyR>d5Oh_MR8Se6|;qQMJVlbVfv##r_cibrA5YsT!qb^1Uh{8ICMJdL={--yUK79Yt@qIqlZ5F`nxRM?>dzXfkp{;c(w2XFq3`Fx +!cGAG)R*q?xfg|c+Dv&Mo8BPnCcdtSJ_+^~iBt&(=R)OMOh<2E_3+OKXu4xbabKlKFf9z8GniXQlQJR2_se;1^FZLvJaD)#eOP>Yb;a93Qp4VsF5!98ojv?1f +fFWUzUZH|$oDLUIY5@nl*r2?wR=d~hHe~*POdFeV<{mcJl53GDoi?q58&5Vy8mBT)VSxJffi_o#&@$; +V!j>9_k`BX~OU;;FZ?tX+FMa(+WhelGlf!U>PA(hta3^O^JeMTvBnUN|VIG;yT5<Yva&Y8%E;>v=ZTbir!08D>{2L}C5l!5Z=OZ6sh!$W2t9geW +nj>f;mpp-443a3p{STob)+Trj0m_O15Rl3|%*cV>t4j{Y(^R5iU{=R9v)xbEqy*7v@Eq!qacMM;@X~1 +6Y6rKvH0O!3v?HWwHhTa1GtVor;bI*(Yk6#xXrVTWkATHV6Y`$N=rzhEE +^=4HTa~{-?fk*eFvq7fdH4BPLECBko9Ya=Kz^Uv%_@H3n>)<^0hArXv_%?&6F4%kwGwC!-&iKVIB~_a +E->Zg2iFZs-b#10Xw6zxwvuK?~M6OWiEqlMb2#Ck>Nvo7$0PX@@w2l(xUx_m=wV+^{$J%9QXG>404+U +Gosn952Ntn5+}6(4css>Cg4k>G3Zowfu*)D?%r&Lzp7m-(k^ROzSvv!t6?cRPssC)ohT+JA;d+*4#R1 +h3D`M8ep9Mt;D_oBrv0nsUq^eRvd1{l`pUTWq4yU*N5-5R)Rd40y%WX)4&VvW8V +5J2e+i!q8owvC!wz)z?adyy@$xOK+jD(mA1JY^5PMqbJfjc?|G&pmZ^4*U4Q|<&J6c_U`g_`a;IrZq2 +D}9Q+?pO9KQH000080Pmr;M(0v__74RB0HhTF044wc0B~t=FJE?LZe(wAFKlmPYi4O|WiNAaY-x05Y; +R+0W@&6?E^vA6SV?c(HWa?=R}eA`ORcKf%`NEI=$2FBqD_FHC<=iiz3~vH#0g1xJpaCri+0WC_|QWM7 +}1b#{rJ8|GAk)cl4Yw}*AlXfuyP}$CUmI;uQg=ucR~vG#1s=%5O@jAN@%`?3IZ*6Zv%p(u2?P#2;ez~ +jVAZBgx{nTa>VdY{&B7`ETHx3|_I+8+gbr9=rU{JM(IlI}(Ej&e+P)^7tvdN7YRh0cf(OHB-!@r +Hr;EsTZ>BLx)tQbShZ?vGV^OL5R@vDGNU)b9gRb|X48t+X#fC^yFWU@cpjG@4CpMAGt6neQkb2n&_wT +quZ8YqC;ToK=sJvo%~TfH#h2LYU8F;iKv$?b1+RIEud+BAAP+f?Ol#3|X8+Ga1b~=pt-Ca-%!6mgcoo +LiTWIsoQF$@C-T9KMHfK3nYuCOWb?2*(w}}b|Z}TuHau+Ku=WWYbv8RKg7u)jeZ67boQ#mVV9BbJq>E +VZvZKexl`V2Ma|e?y5se}iH^(UjYtdjXEiMx(N^Di}%;EB4YxA< +vOT>c9QQweQJLuggB^Fq2@{O>O1s>sZoH(}R%=^-(XS-vILL(E!}-?m`|dkjvwy`{{gbDiGwcBQBE<6 +`Wt(KxV+UZk<{J-NB=B65s4M3q)_yEZj!y8Wmjtt>Rw08<&ar&1KZomA_EInan(PYGJu5iMMg$1<6Sy +9hcyvPuCK8mqk0UOKh|xfHeROZv3h%cZ{V6Xi9W=H)IScX5~;6CE8K$>hL@rp= +`?AGimDs}8Kt#oN4(qkx1<2!gqhoYQz9IIeax&uEHK5DkA$WHxG(ELs1`8>+3eEXQSD>*qavn_uF?SA +CWaMMy=*_ek9borj16Yb5@j_vkZOB6&ut>E@0vG!35^B>2oYsi& +JUZ6wXOAb-^x1m`ncVYmeXhlMN@@RnT-JLRl{|BJXCgCbrm_E)jn2m_F9uJT3O(Tu_51^ +GaCOE7z&)}rQxJ54BAGSkVchw&a9IWqkTix@EJHyh-cM@v&N%b_W+nwq1+NXKF*~HI3uWGQct|MP)G +c&q2_f8@|SNFLe+Uq@J`|(Y4H1pP0rO(C!Q40v9v*E)6|4+nbsmyu`gVCo3}xV7NXCg=|rKtvCpB!L) +|EdM$Xla;B~2&Rcxt^usWu6JU9cR@z8lP*^#rG%p`Od+q35oLI@gsVuOt!Sj-vG>tThVg?&#mNPI*0) +UJ8y{c?9#^aoSmu2gX)(PlpgDM&UixY1%N|Ge*gj=-9vkp67@vfJR;0Ek3WBKY;_k#43s^pIqrX^b=% +xz8*vX?lGXe|+uz_;7aN=Y>`r5M+^Q&>@0xPQuYZrL*kr#ghw2`{~aCP+(EyW<*4X@H^zRxY}83XjY*&z%J +<7b%@JCfxg-2zYVS@_V?r8q|Ad@^uF*=mfS)s$ih^Aws~+Js;c)P{EWsx$0k~mxhOou+zX%IiWdh#_*XSQ6HY}YE0#DgGB_Z3$Q9 +Sk4`}5^MJo`X^0!iS9k~v!Mdo>l>;a5&xq0o59)vZ~g+EP8*4G^+PpnEls)JIcJwno~b*biW2YEn{@2 +)ov4CTN>C_L3fGV_PvYwYFtjv{o4 +(*ki5H3@lpd2uMy6bf7}d>a$0UpRd?fFp+I~6xGvvmA&Zm1`8Lz +3XKCDHp5E>rZ>c54j@ErNp%|Edri(id{_~*qAe!%n%+g49vKrQSz?q$7RoM@+ow3z%&<8kT!IRZppIj +fYvm43(m~tKeyJx^kQ<6OW>>E7_>=-}q+`ZcVT +WTJxH`MP$|MRWnTyhLfS0xv5x;Eo7O%}V;2G6{S`W4V%WlU~7#0Enkl{PG9>nT*L5iygr>?g3o(N1;x=1tw)y +52i5=kgQlPb9@R#R?Y#w@GnzWScKnexxKp9|-LCQH5w04F&E}I0bs$Itn5=+IcGyLG)*`Q`+8L=Kfi#MWf(b#D@8Np{^u$HsxD!McCn2!DZJFuk&>KF#K8-6khs?X9G9j9 +Iuw`7#>FM(4u$*^(DEJX{Ol?U?OgrbLy_|L~0xK3sc!Jc4cm4Z*nhiVPk7yXK8L{FJE72ZfSI1U +oLQYWs*&An?MkT@BE4pz9bUGY1C7r9$ed1Q6nq`r%_Z@Xn_Hb1iN%UO#JUVu-J7}F6=uy`^-DDyMVRo +Pnw#8h5NgYpJ1b;Xe-F9t7{u9f(1NMiPB&NPFASF9uQW&DET+yym#F!8V!Y$7nKwu8{fl!}biR5 +<%?P-kb{?{xx?N=OJ-86;TPQAoVQ0tf +T&3a*6*9m>{!jf&r_>6O!eEjI&Yn}(ULBM5NCczi@HRXkub73@!3(?C7;+GeUmuI(Obmq(^{r1JCmsk +Dpf#1PjP)h>@6aWAK2mtS)wnk@1y_>KC0089#001BW003}la4%nWWo~3|axZXUV{2h&X>MmPUt@1=aA +9;VaCvo9-*1~R5Ps*cI3*8FCq}w-4^yT-WND|NRmoJ+Rn;^h2M%J**wi+mXxjh2v!PM4AASM*K7aS!- +3Mb>s=Cv>+*z1iym<@PN-~i{Vw<9{!8jPhEzeLI%%PDvYOp(mMa?pL43QANqBdMfm_-*bae&bf8lAr< +hE6q5u@0oN&=@2NZlK@-0iQFhEpQ2$s%pWR%n({`cRtNP5)sAYK%usl5tYKgDyOy8+;UllU{qmSrjb +~3Zmj0p#-23lMH$t544_sq38O^is!BN~zDSDwkVP|P>XD?rKbaHiLbairNb1ras +-BV3(n?Mk~^D9R7#g+(8qn;A=Ky61wjj&{#MmeDc2G|PklHJ9`|Gu->Zv3GXrH3BM1(uoj_RZV3Lzv2 +Xt9VfwxVirH8D>(jDuc*0d2XDcGlU18qR^N@BQjKAN(8@VDZTa;7k;49Tnf1Hu3=;w2K&-rd`Aph*}$ +4@K}Z9QMxx*va$X_eYl^i2E+Ccby5dZv2rV~dx6Pi!BZ}ueg-i^iZbtnzt@7hOU^~I3G4<_a(zdO~I- +#Ca#iZIb>B&Pdorlr5@lfPX0;VPI%uvo%$5zc~Dun1{&4}SOz--B@G +0+LO%4ZhaO>L-!hT8NqTD?&UGkjtGQU1Q2~p3+>RXjp+z$PFq%<3NpS&9yy9P4Y5gsrZ^3X1YHYLwQc +FfbOHHOlHL+@o)JpYMQp~-FHlPZ1QY-O00;o@p|(bhf||7z82|vUZ2$lx0001RX>c!J +c4cm4Z*nhiVPk7yXK8L{FLQ8ZV`*k-WpZ;aaCz-LYjfL1lHc_!U}~#ODl{Vd^5t}<9K~_=RF{)emN%{ +~S%54wGPGdPIRDeBE2YsI1Qp~zDQz~Mmku<<&35=KtcfVcLO3DmkLHJ7{7pTmvUU77~xr2E)G8be6?DIi +VzL6eENC9gNo0;J%0J>+z%Ws(Aj<ikcl`FhU;piG@b2i%o1>Gr$FEL +<*KdNCuTQ={etZ1-1ipO}9G(0<_@CpGuZMvKGQl+ZW|1TQfMkp$)DxuFsn!kxml-2eEOZoK#u2P5oi5 +c>2h;3Y=P4{FSm=Bn7r2oHpf>?1Nj#5BRnn8jqQafaJevm>7njR&nd^%SoIlIUK#hwmfpuQ+_aQ9(I! +3U=V3EgZ2`{7(0^QlE-iYj<^jnrCg?$j0I(Hrbxq0UB0+~jYc3z}!I=v{@3tbF}i!SE6R8gXe!n|>97 +}dOC_;wh4tEVbjS6>$@FJP7(dNnvsuT>IHPMLH%?|-k7rGAy?Sw1+}3EAQnIBs2l(~1msKn5w@Y +sRaC+&vur}oC;Afh3m#uw^b4I_8uaB7@bgB)hQgK;!<0E-iY%s6W(Afy;OGi9;FBwDa0r99@LL7StaY +p%AlKT8ZVe+Y5u?ySXp6(yz2zE>e{r0mv7CTR)QaCR16IXfphT!L11v|uhmSi#tm8B;E5Sw-M!nuf%FI<6%>W +E3;EP;O^$oDG%A;8yUmsKhVPBCWX?*=UesUFqm(j44y<^`T9t4j+?0Rq$0H~V^%`p?kqN#{HS3y;83E~%6i5w@k3KeP7dcokv; +=LXGu>UCkSQ8Ov6h9A~S7FzhD8ZU=amWeIV4c7|3P}<4$w`|Az2~rj{SQw8fe+6<4h}0U95_7V1+n$T +1^kt&IhY%FlVCS^?e1g1v#~)NTo;QMp!MNtO_aTwl^huD9)kgbKlVFb++gH^#NgqkMTrNPKK(j${Lz6 +cE@i%UAK-^xtHjWfj-k0bYK~35xHUnVRh?wzF`Nzb989*JRHJla1iA%x2L})PcBnonr6iAdar{-%bb| +}>Crvlf^ida0r@E|+gC*^v$>}gmm8Big%RINyAxo1aHFeMS&%0pA#cl-gv=hVz@6`d*FdDzk(QLCzG)4-f^ +#CieM31Kf!OB~tF*TI?dXc-e?})r2F+{%!j>zNMdt$2`O6KzH8bWv3$6d2;Eu{x=f{dTUKWlbdVQN)H +w_s+ETgf#b#0ogul8GH{5338~LU1 +TK9U}k}yY62|hG9?30X+BCOrw0&sv`nnoPkF)XO-lNatW%%xI{=L&Fi_#!uc$cv;Wp;%yE^HqJ4^CTb5#pI&4AFXob?t@@SSIxP=hQZ$6 +)oRdm5O#xOFg44(i|dE9WRRbgHbD?j<)ms*leB;n+kiSpqwqZjq84;qiCMQKK<^v~5uw}wP+-|<3oP0 +?qACe;`w3i7z+1E{pN$vn$I5MAau6WdIH4W?pHMK+ +aeahgS4}Dnt$<8M7vR$Dxt}#BY;exp1YFY{4o9hMWQq&$OBlluBkh6+X^q2}5BQf7e}FdIEpP=oXTiA +PXDu+5oo&U8*n(MMGfQavh=#i4$F)b8{I|`l0&keX&>l-GA}jbF2Cf`=inAqtWg2(d{Ap`}S}!=zPcE +eCRCc?1%To`5qAcoeq9n7A6qmuz)$mAgNX};FMyaBH;NL^J-3nP<(b-LG==%OHW3vQrAq|-38dYt_nCA`*=WYLG^W(=)dZ2PV)Xr0sGpdha7(2=4Bb7mtPl~j5gC +m@AkZmxv!!gI^kwFZ>fIzDu_G2z~s%pO;Hr=CpPUrE!!zO)x&q;t~ +(rL%~FWQ{uw|FR+U{bMM2encsrHSRGwNYJuJf+CBD(!0%`Q2FE@eexo8=7hsH~$vazBh@~m3xR`N +e2kc>zG~K#g%4xHUgWCQ#caAX+l +kf8&?AxFR^?kN|xwEA@RT)T2q?PrB-uQ{TI(ixM2w8HRiUMK(TjZi65ZqzdXp6GDR`;xMyCo;~Q;=KI!d>hL>@b1t&e?ZOvPiWtqG7bcM6s-IHNmu^^|L7=a +fyCA5Wb-Fc?+Z(he8AUffhw7WU%RUj7Dkb+GLQ@feXyra9U_l9ozWp&Q?2q{i0>kgR}i7|9Sq|qrnR~ +sa|9vZE8O}6yA9s@}Gk}8r^lqgpvNEz?_mh-=TS)T)Yp@o7fUebvwR|Zu96?C5st+(WSZtfcVdKtXIw +R=3NkJDNSk(TB+5(o~$T0E(l(HVkmZtBxh{;_}(p`eVY%=BgUn<20*5T&#=_aXfZ6-Qy!x$;MHq9OB2 +Ue?qL&7nN2y53Y<=PSdQpWb)N#49)Zo(mFCCU0&9y@i}r1kQS;oa4-j%!T65hlVS5J^-+y+dp8RatkU +>>X1_*AqL%#8I+xql<_?*wV@?PgDt)aishIBwZI=M^gP=or^|1cWTExaBT7ub>uZ~2=?eThDz@oDq#$9O->_JkXxn9c(*lj +ek}CGBPAXaj`w_eKQoPBTBT1pz0jY>%qAcSZBEdcq!iymXXa#OCE{rTevCPRFthWX?$+pUUIYDUW|;aI-eId7 +Qt4hin(tav|DHh +;eaKy7Y(w%s4cJSosxlm|=ibs=)@E8yo7K)N9FlMqjgyz%sGbHX_uTiDeZz+O6eKY8HL^XY~w7 +oxSyw6zJg0y?6m2HFTBm^W%*6ZP_7OL|}CrL#)>seKAV(9?95&{X$z5<=RFz_z;gRqU&wX6VhW@GdTO +Ou)f=%uC<9Lqya7s*u07rmmm^x#c0x=IIrz)EYpB*W!Jx5ZEQr!+=c3t(r%hLL(4{(^VnC#*_`pX +ov&nzTyLzQdT4ZZ&nF(?vn-&jL>mGPzOicoaZ)XR9F6*6hf8F1q!CI1Cq7Xw7Pjtc2o}V>pX +&_sRV6(Qv&qmfg`uiDHEnySk|JxLV;goiIV{pw^iuP5>{8sWT|5mJ%Q1*#^Rj@S^sP#j@1d?Ako@JMD +$Wv0o!?@A?u*T*$_=-0&^@sDgvsJxhsb@h$1MWq6xiA%>aa@pV3nJ73s+fwMf$|?1Nlartxl_c+AOAk +$V^992({39lW2iXrQ6|D^4ieQReC2xnJ1?dIj^lWmP`?)!({pwhOgvu>Ja24Lq()-z_

FA1QX;xtM8WuJ*V9m!(|8$| +o_)J@FAj`i@Lpa>9;gG_u-S!OeY*&jnZ30Gcx}`~e(^GIB9_&MujKiT*FjcN%z;yp{`~v*;JmhpoJlp +ZvTNhY@BApyO1IGQXTo2iBTZp4Ng6cN;YOck%&a`&-10od_UmU>Dngo`pVT^nu0_#glX9MIof`U%4*c +EgcqzpMhY*tx!d+|$}55)UwNF0WtNjmQ_+E9PdG-{5jZPV(qv=aaI)HGoA@56~Z;@LKRU&8QXN^1X>f +70j6Rn-Jtbe +hY-(pvXVi#8EE4>v41E7cULdLaCp>)Qw`O97!1Sp1w364yG1{Je&z+@*+8xlU4NSyLI~W*+6B9w0_{P +d=ZS8TfbNEP?CG~|k;l-HkBi>!e$X$GA)bCmqnXTTLj%`2x`6E#qH=G@LWy>>g|!jZEFZJq^&(P10o@ +QVhWZp{ZwCd9jjVw*rK_7YG0{%FtT4mMF&93PKfcKk#k2LyN*XgnEltq*@{*Ji`GD`yR4UIFLa +@>9}+q)*xcDku?0I|0`{}J(Hwp#SffMU00KHVnJi3IQ7?W8s=z=x5lF`Z;xQm%f=D;eWCk+(VAoTOvk +qb0=`=D;0dE`RiF+RMX&|2M?nGLm|c!$Ik`$U@X%7hq$^rg!&Mb)7U^9ajm`=P`WXBTnWOS$iJqA>dm +KZ|vh@6(Ijx*j}da@GUC1Ypxd_f-=Od%opRDFKi^2xCbG;-Q@5ko3G5Yxjem3Tw&m4F^ke?C%L)mQF`d2hX6Q&|O{Z;Zg&_YTd{h_ +I?iA;iXd43*ES!$5h1rHDl1BuaeeA{}K(l3CYzRwOF8>>aO!jP1X?s@hYHQFS|BK45QuQ2QaSg+DQMj +5WPgWk&c^)U;5e(GKh2L-~E7iwsrR!X|y#t1S;n&JpQGULhpi9Tswyl;_rk=X7J7lgRrmn=DeYJ79-y +X_|g92#o=walMNRNE~(?D1e>$lNiogQdEl2Ro3&gWsmrG3nG- +@-5BZb(Hq#kFL+*?JQ5isuoYaLLr9Z#*3v=1oI_V}q@4vh`%B=^*Igx1kbHHyu;wc*N6v!`^B#*)LsJ +Ob=tehKoZ9DkB`xX=$gAO4Q#mrc8os0k;n<0po07^`1b)7zDqdKhB$$5x3CcGk_|p|PQJ!0Z)l(r+Fr +B7f_lLvV{tZjr7Ek5OQ=P=qNq3@zJ$A`bsB6wmUjK&#Mj4w?cbeoqROFPw;UkSsUM?DX|Oq@~U|2oJw +yNr}7O?U%HEZY +f7IpGUDuMot#UyxU5Y~ntAe|TstY4jjF8)U&E9JjDBT$ET441{v+!_d*msR4B@Pwr2n&*r@0p|K(S(p +hO!MVA$ELm%A7wOPd2T3txLkjaym!veN?&tt^1O{!QnF7%J4DDX3YVt7wTnCB;cVZBUTT%9-<*P7$+A +f65L$_M_gZ$c7>3_>R)bYN*hM&=MNxO}iLp{NJ?x*Eph +dF%SnO^#j^&2kXRut!s^;R`r0spV4!;lHZEtR4jGORYi~EFp-ZBhoks-E%T;!J9k(;R{THMZv-k9k|6 +(5Fod(`%=zN;mH*&!5>mI$G<8H5h$@2O9sYV5F*8asw!W#-4p>9~K6NA?ftoXt5+%QeyntLai#yK>0` +au5PrqVY2D8nOtCN~Pt^DVz~pqQqqn{*l`cDmc-JKE~*Y2{~vF|Cc~L1Fg@#@ +w`Dwn5#+1?2Cgq8+qZ!lLi2Eg;yj*4b)zm?i-J{d_Y4C&YWS*L1CZflwOP#?8wd(N&!1DytSf%?V54> +FEDe#;_A6CBNI7F)H36CHxnwbpl5N;XnzTwt$6VkG@qeBR>i}R$n#VbubJ^4UdZ%VO-OT4n`L5fNgK$KRFsiYKAPy*m-R=J(p6!fLz&&;7q(0q7z|4b +jY6M^b`x8@f6SEw;C){!)Bd=OPTE73(Uh+8jN4=ktK`Slfy|BbA)Ep8Qxay$>1bBo_unz3>)&?GDlNT +>n!H=R2oCxe>KOhP}FCiO5y+z7vBHgbj{0EcK>2%KwhsRA8W(WJu!WOHsNwL&KiD8H` +?8VF;kAr64;%`9Umi}?fMUFXl;fk)7kE7X8cYjY#BfLKy?+v*PG-&vuLy+0~Ih2f-t2|ZDIn$SCA6EEsgXL|Sawq!699 +MG~G2a?XTy+dsSL3jh9NhdF;@R#STVYYVmJL(Z6+tXJNO3aOLs=+N)h^qLJS{k}Bsl%6Yv|U^MjMrj;O}BNZum4t8jve}9=p!VRd#z>#HA%Tp*@L;^I@E`$0&(Blc +2LBwn@UjG{lpz;}nr3a%ix2d2jLx4~>Np>As-@<}LBf(+!^v4{>h`=P_G}@HU&Ixpo~*PnRIVuJ`-pG +Q3=6kDK}1^D+@4)#Vs*2NThIEc2mn6^@{E51pnZR`ZCbCmSR@uPUT%C-*xpxZr_8&`U;Qm~j04L@R4v(u18%J$YVAfeMEui1VH)+fTjlB}ieqgrHeMvKGDi28W0DvNn(0S7PIB{0Y +F4_hc+(Kxf?b!k2hx7UWn>4}Zo5KXJ|w&P+t*cc)4kXz!m!)6;}~!<_a#-w@9>RXdO|>EUP(-9Qo785 +DiIMz?hOveVt2XXsSkDF%@;yu-1-sNXgoMAD#+!I%z;4~k2fCshvWkQ)hCxQfiL*)N=O +%Euur4?~vi)i07-#S%R36hP=OZgDAnCdUqRZ(7;8D7A;z|XwjlYW45(RT%BaONtTLgLX!|WL1v)x>B +(ei?2~?$T)-4F8s9m6X^t6>TL*#`YWq73FR2{^{_LRU2QYwIFXemI)x-_ohJ9NPYG#VVGNROA{|G%v#KR~Df&Ezl^`(M^~#`w8a65S!XTtTfAOoFVd3!IJNmF_rge&v&jIB$ZoG#2|@3JgQ?}+{Q`M;)2=%?>|ej&xrE)KIRr +0{BZ5cxvFmjkm1Da6DQoYtAMk`7OC}77-7Ko(u{I=BTlWhmhs*xB>)n1yl7~!liNynRaOKQPxH3Q7Ee +5bOpzg2LiWZ?OMpGi20X=ac!VBu9^K`?Q!tN8Ilbai1 +g{V2x3F=9%SrfK5mEMaN_d;ozvy0*$hLbP10HS?!X_?X(_Ld +RYGh0MvbN&zu*hL`2`BT!GQRHT9yfKbz^^KQBwA?%sp&j+p!h5aLDJJ)(K;lKbSETj9*+avpYG@EC(l +bh{izeA*6?LC%%f#{J)eUq?_mqXtceSi_%Dgqf|iC0?AjFU-t~+dy4S>U;rK#+Z(|q*mK&^pVrCNqni +$4T7~D}}bfg!l31JQh+ucLcS;kSHnV>KM_;XrkZQ{~xEKykRIapsS%04?eMgr~XfFS^&h&hNcgC +45l$Qw!02yq2@8A#E=|X8JkHbX!r7XT9eIy4P0EyZ}zcmdk5k#X!C<`eWg1K&%s=XBC;l+9*-I1E@ML +Pa`S$)D&6~j(4;t-K7wfCtGuIOIK;!gb><}gcK>2h5hf&w>m(7Jsfu~ +=u=VNVYPRsJ;RO1Sufh08xz?i#A`kb}k;1ep28FKbLZ{}b(n75Lw0DTE>Ssuepjot{x+(P>PC>qGk6W +c3m{}w?3Dgrvwy@=RPgQ10D1fsA0JnS5zr)E~?dgMGbg%v3XKKUo+y%_^_ui0pV8u|9Hxhn{f;>@>ci +gJ(GII_QzVU$WwJ$-BhJti%A3{>riiHv{J*${5R_V9&K9d?~;Go?FA;t&lCB1Hn(=sT +TPb>OhccfvU50;L~))d&J&$^wllu`c@Dn|b+71%5_Nf^E>DEz-ScJ8cccG{2(|Kty7m%?I(WL~Xw25Lzai5W@nY)l9VHiI%)SPX3t0&8`11#E*qUSKfyylUv#K68ZV!x^q@LYndhz)orS=MHQ8vKjl6Yh@x!X)!J~5pp3 +E|-iXA>u9smqdv3I=uza1*tc|C^?liUBtaRzLW@eq?<-RNZ~KUY*B;ngmeDA+nuK%#iK7AJTVKSOy%IxyZqg;JL+Dsf2m{|3NO*8CJNM +SS{8NuIvw5+=V&;sF(Jy7RGJJY_`S}fd+pGAsbtW-_EI})sh1ClCHBA-m0*aeI&4NFsmmjugFGUhZ|f +XR0k8YikXNPhQZkZ>=B>iZB?`Ah%9Y(!3YsB3_LnSx!e>KGG=J$!5bi@3;Z>;@s)B{pP2%VQ(-RbzEn +=n7KO+&Hr1To;&PJ?QJ#=3GjFea2c^v3a4g<%1h6lkmCrONi^h;@(a}r7VxSh`!GFOgnOZ<$bn8l^ny +C3jN>~>cEq@$AO%Tq`7GpB3vFT6cpUJv=R(;kN7UX8-`zM7s~v{1@>`B=MbM%_gZZXk +Gsw!rCE3bP;yn#`!L5e94)`4UU_AoK_5&{_{?KilHFeKWQ?FanNBc-R`6$`P@EjCZ{JP#q(S;A$sF!{ +I+epy9J>x9@l>Z4Yg#3dpYJ+k$?`qNsOh>#tf>N*--jdWZi5e#kt{|-?C0HH_!7hrU9Z=CfZ-8lE4zp +N4v)MuTCzB3;q)0Lp+%Xd18*>W_^9;I*d{5M0!0cVp|j0@JiFX#@*|F)*Hc8tUHh8zJ +}ZUzUHh?d$v$UIA;PjD$2r;^nk(cnlD*1s;iEu;)??d)e1HM3`WC=0 +kTM-m^~ARTw|RBNg&_4nZMO-F7Fem(B|-7Ya@=3aLaugv(Eopdk$gs!WK-X6rj+u}8VLnn0EW!ynqi{EwLQYJUf#3f;zdY1TysV|5hHO&0r +LglTCC*FD*548?*`i>Eck>1NVHasW^l9?vOPGg-Pn&@e5zU$Fq$4;Vq&7miX0b$)t*G*QiWCcrCFxH$ +w@+mzOoy=^qHsr8xFx%MJybmiODB1P0rZc^hS(!|*WcCbmS4@Nyu)uDR%1RaTNQY8s32DYWV}AT~0*Y +O)Fa3}h#ic!I5(7bu+EC#p_D+xZFYa|-o<=JVcv!se`G)Q_Nm=F)#KxjnU2;J=9LBT@sL0Cq4Tq_;ae +n7;lT^c9yASQgZ{PLqW(^W(Dz2ua{5cmq>I`4kie#tN+hp;@+ln-)q4L&mwmJhOXsiu6LfB6Lh7#2BtiQUFr +k}r;ZK=+!6!xI5`A^=Yn-%R;IalcDpNhqpO)~3JSM7cHv-g?7r_nN?ZrPcqk_(Rm~%wzok+YBRd=H0PQ}}9QjlaqyxoZLGn~xcrrq +_zmp~dP{8<{$o36n_NZ;bBw}(J3(P5_&>|u}WIXjey0iI#(7wzr`bg%MJh^*Ump!Dj^B=`(WYh~2>j& +4%Gu4kOXM|e0Wcu!~>XP+e=!fr3hDxGWHXOwFhCw^lNR6hf8(>j<4J`x52%}Js(>AqC3-s?QN*Ce?$H +2nDYssCUi8cYvgXFRj^^OeBk6@ +3;yCGOhBL}(qP0=Dj~mEnb7pYy*`>dIW-99CpLl-4jKLn(RQN#&ikdV7{TqIX;PgC%M1HZOq=1^J*)_`g(y4`g%6YN;V +f6bvlxtKEyqrxdmZF&6V-U48c($1Y>eXq!ALKicNK*{!C1Q6fDUp~4s2^TZ<@C~3;hx@4+!6e=S)gD! +W|^)^6q&N4_m|vnr11N_owA(WQ4Oi*0JvPqI<0-`b`LV&;d|DUD&nBh=Ya+H>5iWPcg`VjfXoR9)3Xy +(3<6L@AgZE2`|Lyi7q`+qbF+ge#|`66|KVMBLo= +0o`lr_39n^RvV^Y*ZoMlmfdD?qBi7852gh1BVIsGAx=|S8*`rhBHZMuhwsVKDiGi`gBPAuON=RNOvGf +S=G0*cXN_-$d+-^X_^Tz(JVy7LsHGF3bfSY!bkK>aIZ-vIni{iR=0%8TlTav$K9Z#>aetB(Dd%}fHUH +oBf`{qth#OFwCZf+omzk(B6E$Wc#7xANiR>|vI3^0lM8TM-6?2|_GLWG +_+aB`Uo{k(cHxrS72Jl0ZL=OYeQ-{D0TW`i=f8QGF$%u0&atimFg5CHka9bd+dhQh5wgm{iq*7$s42< +gGX2|GQp5FAF5OpwG`5l1M5NAw?pZNYoLjIzlCcGAvXKsoFq!!My!ybgxN1Kc@o=5KYpP|4Q>o66&U( +rO_qGWflxAq#AXTG!l27m;XPd)RjqGv$jwx30aT^)uv2|M^eXM=URVKx6V`{>vpn6=dIJ_|GQqWV$M( +7-Klhy`~H+&R;?~CX7hxkU<=#q@ +Oe$3|+#;rNkN}T1uixipg`W+uuR=%7srT31A>^Qkf9kOe$c2mPzRrDHS;s0*aLSfbd8egLU%V6WuG97 +n7iV61Gpm>q%%liG?SD>m=TsM46NLaT4)OBDqP7Hi^t8@z{Kvb$+6I<-#YFER-yitdy*jtdy*jtdy+W +t5Tv;qEez#qEX`T4-?%h7e1k6qhzCGqhzCGqhzCGr)1||of4fAof4fAof3yvp6Fh=@ChXcB?l!3B?l! +3B?l!3B?tE!lo*r5{D<4=w7+-2_=J)LCK(GP%i)~fE75f38gXdRVIS0i41EZxtd6>CTgpR&}t&InrN#g+Nz0gYTk$0Pjs( +b_=J*R1*OzPBsI}OO|(!GE!0HsG?6+@R8A9>(?sAj5jaf*PV+uDX`*}O!Y7mjD@d3o5~hi8X(CseD3v +BkrHN8$B2JpW)Ea^Vw7f)&_-Npv-dq$Wz9iIQic!bD>*(GyIP>61+MBnv!A_D*uS^VZo+bgx|agpy!|oXsRFGfBEkQYe#@$Ry7(Nmxws5tDqt +gzlfvClgwHU&_y|cl#wzA6?(Re)+G@^FLp2-u~Omr~emFO9KQH000080Pmr;MjM6X$V(Fd0F+Ar051R +l0B~t=FJE?LZe(wAFLGsZb!BsOb1!gVV{2h&WpgiMXkl_>WppoUaAR(CcrI{x)m&|J+c=W`u3v$hd^m +fL@e+KwotMp4IgXup*0Ei-Q*)_Q%0)|%#f?O2Nh%)SuRnmmgKm&?Hrd&&x`|?00`c1Y^wW(d;b+gL|B +08!uTRg#+3C^o`Sr1Qd3JI1SMfyMXR~MGW~IbMQ{Ipa7>Xxt6XSJ@ksuA^4bQ68*`sb=^=fzgBZp*rA_19)wH~kmgvAC=oTRv}8(W!;Fd+d80 +4^=d#ukE8AYSoFoqkSQN_~Coq#bosZakyTKD^s@>SE^ObXSJ{^IjXC!DercAnS1U2kGe#Nw?*?wT$bz +mrre0HZhThGRn;m{v|?+@+7(Ia#7yMcO+=j3y8 +B+bKM7Up>t^iFs%dqJNDd@Mb3H~v>w2%~%>1=Bx2EB~p7f(wYi%@Wc`zvgTIoWRRp0GO%U*xb9qNTXX +jq9mC3dY^?$(j+LDv<(oZh^-cy}WX&)#JISwx@El)eu|=y{e|Dx<@^6-ND=A +tD`r%#o^1-v(uaRX7(qiH|NLK*W%>jN*s#I!>gOqqjzVASK{*B)#b(Y@qrN6N^IVl0QKHZ$vVHs}9j@!@zF)6yLIV9sluJ?7T_hfwQe#J>Z=_w_3+X +q~pr0Q^BA2>SQGHr#6Yq41fAy85@@zI+Hu +Xjv%o>Po$ +7i=UZ?2B7-&~x%(pO|0&)y#X&s4d-aC(0FR(JjC@a8bMn$3Vz{eM+9#eGo~B6&Vv6^&@s-*>8-Yv~qu +YYl!Q;cB(WJkI{MO^$SrhD+41ogQ~@wiid{l|=E +s=AOGByN5-K5Ym#2VcD>Tc0xLJ~&;!ZcB2D(_v+s%f9QXC@2pC^_i9#0%*x_G~(SMU{38Q3r(sQVE +zrm+zM97tlQ*8^`zcRkYG;`N;Cx1*Z_1ECT;LlPwopdw;XPnGo)OscfjHV3Gpyn +)4Zx;N(rApVS9FSM;U8?ORaqo$fE}Uu}4FN@zmwC`6WK2m!Rwo^XY>)yAO}tDnENnD!OqY5&L8TZbG& +3IjWUg-u4H^TYU{M0mQ%F%6TO~=9)Jdu(rKb*CslyjssdV)d*MH_qzNGq`sooQQ!X{}~oj3*~E2SUl* +GW=Nqm*4soe{v!L%F6A=`HnR$9^R4nNl~O)P{K|f}%O8OQ%{H7#OCJdn}tF^N6zo5EpxR5bXmvv_ww$ +2xkD4j7yYc6nlOIMj*{3B5IMYi^Ss$(*m%HAP+u)*s>vyl3nthCb|b+AVpF+;!!)GbfwZw5 +IW%U1?_S2NXdf~PnODM?u%bLdP{(m7dzD&P=d2ToiGbB`W1K +jglV_sMUFtulzBczviMRTgOEip)h|0NnNpHVcd%{$S_$Z86p#i?(OM=gwwx}oK5dbd@Q#zbSbI+s1rw +QW%cq!rs_$<1fJ8z%*cPxd72^LOTMT!hoBZ)_cfis9Vag&q&H_E~dMB>6{gfAF`_!JRV%;ZNKy&*ken +Lu|s#3*142?0H{+l1$b0U=Bw{^YwV3io(QM@DcQXq_@z!^jYw9eogwQWQS)(}^z)F-I6A$;BR9GI|P~ +R4ehK;Vp;rk;J1zhKrp?3f)1tvyu)Dn6lk=4-JkpDeVoUlkN0tbcGTSJP9yNK=AAu-|}(gk|Dvba1Sm +$74bY4LLP2Rd`pfQWkb(I>mi9!04t+0(O^%-!!!a2xlJx7f)ueS*8#azMuW(d$N@!I`5=QCPe_+L71hv?GYNWy@%Bz2B>X&zy<&J&A3M^IBT^oZsKUURQigeyMTFll!Y6l`M +zr6IBXTF1$FJkjaC0|yq4bk5DMJ?6CKL7NZh=X}bNFOBMEmHAPZZk3(j5yCM)^)KyuC%!N|@@UmmQ?X +F$&5;K7hg;5Im3Y(IY;SYw(_p=xH2fLkT>rMWi1`$WVd8;kz&(Vkz2-fwnjR5P^p2B(jxgH$dyXJEVK>@AA4UIQ!*8gN@p588Oc-Rbl)RP8gf)}6QaEnf2 +aIP5{wkHC39k9ckaRs7(8?`C>sWZKrC4*-uEn+mW|(ke3O857L@x0j-g#P*_TK~wo=xFa&VTGgxsQ`NA};xDN@ +W)dD;<2=ffjG^i|1SoMU0~x|Fi11;8G3z;mfo&TmHz`shV+shLn@*S?rHnHIHp(V(tCx}Vz~F)1P`;t +BN`htZiE_SRRv*Ui<6RWK%Tbx_YMlQ5wih2e9rZFWCd%cL*(3}Yq-Me=vP|I(9)1H7CP{&!WNkR);On +gyMAn)~RI-XzsWwuQp3(4dLFOCNtp$q2k*XkHpG2hSvFx&lGYwBCWnLV1q%>4LSLJYL{j{b2<67VL8f +OpUVVFm$m5j**(xjM*6p4t4tk(u4F)Jl|=L*0aE*wn*46UBw$Jqms!411cyE1KWN;SUt>T|f8faYV)! +=J2tT$L(}%8Yi-OL{Es_!~32*)Sz9DWJ?)tqREj+_SsqhwuS_##JA*2%!U&sn&)gtn~WqvLKaBoo(b} +h>@%Ec7>bZw$t*!tp)S0u9p7RMhZu%?lr@c=s#AY0iD+ArN0gtQN{!>O%<+v(N_5Z;E9Fn=gnK3)Y>? +04Pd(aUsGOeV!Q&ga4Gy;uJ|#jMlBul-#DRVN;JGL6#&|L-^fjOqC~kb0gVGMP^CT`vnWX4>C@>CByA +!bu_DtB0z#PJyJxLa8Py9k4JKE9#DsaHWwIo;CL=yC{VMLTL3Y>>I(x)S(X+8~^^C|ECEw2FCVFH3~m +=H!NYLranuwn#c*l&hQ105wyig1hMyV59}TIzMeoJ#1K^3f2eP6!HDOAo;i!r}<|`7iB4c{nqacrvQN +B7Arz-~@z2ft!`E4CIen+<63F4^&fBYx|?y;G_wd7%^t-*&>UGZ{;wNOGXtYYPbu9i{s>v$1*WQ&VJ{ +fGo}+ed`h^pXWLp$+46jxDFNXVm+}-Ocof+aepe)k=!PSY0EmVVFhbh&j5F>Nl4!sbj&H{jwH+h-4m# +pbHF7DF#E`npSt%a-=X-zLn}WOKkGH20&&|eB?CUwgC&b|=k9htFoJm0k*p}x-@W>lwjB}sYBVSK<^k +cUi{^SZ^7iOGu9+ZT4m@~gxp1U9;I_z{I$Ct(9h7FUy3d9Yy@|tv<3Wf;*rO|#G{$-myJC= +(dn$o)U`Aih&H;A9t`LyF{A@g#H<(oO2*L>Hwk)5oZY*5&sUKWggxO4SCcql<{b +|XX5k}-fyC5kPE=w4Nw!f5Nu4$5hl=vfirF~@|f2G%&2~UHk+@DwiQ1Y+oDpfa_8I*t784wmhF!-q5m +z^QrzB_RoUI%?zL*Y+_&ZCpZR)V&d_yxx--h+qKeD_z-^-e-MMii)`$2DYSq(arfBu{myqyV-8H;? +UqY(ny@uzIs5a4RIOf`s{MVl}++=X%DO}*TubApjM@s*-f) +kkvT1^=H^&xe=xYNlsWmV6;RFByZ-F)s%TkXcS==yg$p&D-z(Gfg*YkJts>kk_0oFSM51`PGw)}rVi3 +~WVC|{g{A*OVYpNL=+^p8=Nelj7>q*bqYN#=%-qj-NXU~+S=lUpGZ3{*R{qf*#rN8LG_@eqg+XHc`@l +dpi)NdA5H==u}Jzy*>I9fQeYXieh%k`m0zSd2Mi5@N%FsN&fUHcic-ppEh{OI}USy@c2RHF`r_(k={* +5|9bZu>*WZnSPy`>KKF9?bdJUOGJ&*hP|@>fX+JiP9p>vG2AtR|>vJ->5$*ZtP`Kd{Sbw(>A;)jbx0~ +M&_VtKlkt +pQPx{e)K5fTLvQ!0yX~*+8Q6X(e=Nm+iR9yc&{UVbK*R9DQeXSa#9+)`ri{K6&-+GCwHb3jP*Z8s8;_ +?avu7#dKTM1LUZ#7KJ=zN6F4z=2+3Tgt$%m9>~@YwfmUH^P~JqU~To(PxrzcOAjB%rwMug?Yn6aYan!Whf@1^+j3*JV5i+}y$WWWETCGo +Gv@znK`qx}K*5Gf}^e%<3UGOfS=6M8>6e4_U!xOk|%qst%C$TDymOpQnU%k0jqCW`(a)FPZe70*X +pb;=49p!)BL3v~D*&z5y6aKTCr>p@f49KYQp!9st-!{}OurtPhw>|t`ONHmKB@12)FAqMG5bGIO9KQH +000080Pmr;Mo3Z#j0_6^0PryY06PEx0B~t=FJE?LZe(wAFLGsZb!BsOb1!gVV{2h&WpgiMXkl_>Wppo +WVQyz)b!=y0a%o|1ZEs{{Y%Xwl?OIz?+ej9E*RSZB)Yc?b3Zrh>#wNQDgn@4I6S>P6z@;Y4*n?yWM6r&#MPY^XL +)=Zr%@sfvV|6LAwFh*#z_+4`~CeYjptFBdLgbKDvMoLQBJm&4{&u?iq{8kgq+Q$FwrZ%BleR-T##%bE_9*u +uX<5Oa*(BE9$&8z=Ii3k9#(|-80BBYd7Rwl@x6E}fUp#0Ce9zqyDVMD52}**I*;-PV(li^S`^t$`3=C +{iHB?@=20qgy@-q2JcuYolrDbBa_HY@i}>b&mR9Kk;SlOl=l6x-@WbgRaiR+#6(4k}b3}8#x=!Lbluz +QhP75ufLM&;mxU)ID}Fz|`t9t~mDoT1EPmg=xY$3v`uq;EU>bLkzuHoKz +eEWx1ft5Lw0ru>+ju4kx +8;Xg{K9U=XZ(#C11Ct9~MsZTqp?^kt3jjxBrVhMdG;v11>r7yn +aF=_|Z*U2ud*!=n^`uUD8#u7qN`XxaME}?!D-@x=yl4ZFs-e*Ngq96C68z?D*w=xW*5T7owGV~)3Pk- +HVsJ!xESdGVfbz5bLnBPTtG)M6ibs?;ZRg@$TVv*^B0u=f?>V^u2%Bz6qAyep>Z*eNsSiWB+w-KisMPvKu_XO#ek@B$)~Q=Uik)ks0N0cMY2fYcyha*B7$@*UXmz-ggz=>GLiwiSPJ4MF3N +Y?+V{1kR9Q>s?3Z652X*032skui&RFwlrxAxY=(6S)hW!$@gSP<8qEZrCQ#i4k_kLbXl)8rLWR#Wyu- +T;$TXpX3`~n%S(%v-8hEU3;hK>Oc@D8g>-ao_IRvW^>=2q=m?1AP)2jwv6u3}8q<};P2rQW3+Ql`+HL +J`_5fr$=Y`_I^pimOx!~;+&32_N=aHSOF6yy}-6yy}-R9!c-z$5mRf{KEQf{KDl2-?YWhcf>}Z8c$ami7GwsV1et*fm7Ss +spB1UYBsdd_RH#m{PK`kUjmT_`M#Id6mgxeG6(^v1L^VY3pngO_&}UFTrrMEJwVOU8GdF?v#`88$w!f +y*UsLIar&4>$w8x92F|uLAn5jfZ~cs?Md{tw&003bjX1GnJ;*6yg&|QrAr>Qxj(zHIt~CO0 +#+%tf$g0;+rB{k`Rol=H#7Nbs@U5?#ON@HdE>O!)^Y=;YRmqxS^`~a9h00aMM3H+z2TfZuL~c2_Jt!C +hUBcl{iEf`j3@P=epPfir{Zpzln1kBF9qkd$Y;TESxEOA6++M0^v?DkyE;zYux3k^b_o;S*@MwTO8VO +&gT-rP7o+KZ${=xl-|~GX<7z;_{d9bT=5=LH?N>kR_oug`V9kez)xGXyNbg05kmJRt4sFW=}K-9g6hR +b2*`yO^mvkM41wQww}U{fi5YsyK?FgKpr3=se4CeNtPf-O-y;}iUaf1y6p*UuRZXG?5vVQKdg{Pp1{@Yzze=`W=CJw?LpIdOyt^xbb@od!#eerHx2L_E?b1!`}5flrpgFrf-ey|elmQhD)P=sp~Y8}0Fh +VD!Df{iq6JWF<0HK=Sa4D3wL>c)096srlh7hbLof;H#v^fUEGiY65@mXu*qlp<=Jfazk)Ra-WlpK +4*EN90D)q@c>Izv6ExjX*9s5sW$Iwl2|+gf=+1?WQ+Yf7*CDj05TC!2`L~BI_x+ib*g;V5x@PY+J5i0 +G>-_~dVBKh=R_wQ#0(KJEY4m6>JfRK@g3!11ry5^8D?KD`pYee#@beGvbK}iSgrP8=iJ;-Yo`)ohnD^ +w+M*kAMV6xq}4=V?W*_rqT`1~xi>mX?MWaZmqr#ppspf7tqFuRUDB?Z3OnQbK+Ts2dk^36fsQe_YIR> +^(0WIFS}_MVMeGUGOwAD9OlPigk=gK%B>iur42f#XtUYqP_|9wYc+rrXZun-{XmvQ?;jOK#w|XOd#BJ +nNT}A&*M%>C!h68&FH77IG@x@o9Z*#-4pqS6TJhVq@ +lLeQ9kQJ%nKru{iVXZmf{&?zm(f0j6p{WBqlg;VJ-K9)wU6T!hZY8?n=IOgHkz7SO=tgb?WqHoE;oJrTTd3cRleQJnDIDWJm;?Hm +Raaiu$1;8XieohF?PJSiR*TwtS6Ff5!;nkcsMWzK|5uVdD*x#ama!5yUn-z>g>*T*Ox7y?MiHAL3R*y +>wWl;C+&Z-x-U2CM-YT9-rF3wXBN%`>qa+P>AS%UB5)^Ad-l0=*e&@r2i+Rr+2~Hh9uDf8Ve57u`|Q&Q-h4|w@@6aWAK2mtS)wnm(uw`2Va002Ej0024w003}la4%nWWo~3|axZdaadl;LbaO9oVPk7yXJv +CQV`yP=WMyBSX_+UNcX0D%@#+nF7(0&gFYGLtU+2j!d(B{B$;ynK-Iq66+W3!9&6CSK%I_ +&^S9u(>BD*TT!LYaNKD%SnC}nv(ONv@O0#ULko&7V*G5$82C0F;7&xD?o9JtdG*9CMh++{+WO2V%4(C +~VUHOY4I-qY^a>dfD^x3yO0d|1CUUs2H=hp}5r`tXY1%#sX%N!{<$MA#X3aSt0S(f|kT~?GNdc2FVTn +fQoi+~HpKAxjz*$>-4`TdckvgJYXhttE+>j@x}Uf)I6F=0KPQ>EQRc{C*)9Y>2r0=F-s%X$39qXCnD) +9s7wG)Fn$KKmDY>B%tkAJ=xA=ZwKkzJ?liBQ=851pZSRsga~c`j2bN)daOQVn?FU-yO6NZGbjJ8=;MT +5ppzvCVe)93=JPb4lyD%JKPf?U1C^>VIhWv7&gGL0fr5regO3Y3>}0^tqE&u*bqa8m}vlYLtJBsz^rU +Y*9ar2sm_P!qXzZE5&FlKngRFN09FifN!?H(MzCZga1N_R5Fb$=)Qpx}GlWxPSTctA7~*4yk73CeGmo +Ku3@689UviEn&=6{l;T*W(P|F9Enh~7hLtKu~ATA&-ATA&-ATA&-AT9=IkQ0y-kdu&;kdv}fGlm)oaS +3rrF@TuF5Q!m@&M_pwkN`shs16_-KsJEt0CK^wQWHT<0Pz6gI}qQ2IFc`se2L^sBwr%=63LfHzC`jRk +}r{bg(XsRi4aTDh)WpBU;z_!3&uh<)=>13|HvAwW^kA>k|AfP5JaVB3N`SZ2@<8`kxHBk8is~gF~o!+ +CO|wIWCQw3>Y=KE-wbL1H%30f2?qEvIL6=rBZJ`(qw?D!Okp_U!FEU<_Yp4^)M{d=2}q2F&`c0Vj2M9 +)$YudS5#j^7#@~>pLj$q_U0{n>YOc8V%JaS@sX)}8+31;#eik-*G7nh{v@ZJ)?RXFIPDN`gxW{X2JZS +2=t@A-$l&fkS)_DEO4r+2B(x561n~J7trb?%Zrz$6c*&z!Q=T+o1*1SiAMI^O~^8{JYWxAjtOCnKXHD +WnpID#`VA2DFXdc%q-iCwUbPSWt1T%O70nOs_OdFFcj{DvRH{yhfAbu!CDTXB*ye}S#fPw{ND#g6H}Q0hNUTdd5=XwHiG&$~FC#>E?Ci2noqS4 +m!!0Eaa1jfdNV0T=qd;Bvjq+Ke;Q4BubB>^t!f}= +#Trs0|zi-oY#M4(}2QPt(O9#l1rNqRVNA +`UqhZ#9Xs*^m;+k1-RinzgIt$!L{H`o$|J`zQ)BSaKM{6`+ln2^E +OTz7s{?pSRh*qWP^T%NZ!t4SEFdIHpNJy69cm%gEj`ziV$z3(tJ?k!LZ;l-a9R@{T7yXwLel*=sGkMY#JH}+^0I +9Sf0cOqV-l|vsS8ig=!Lg^>j{Dme#C~SgBwG7U=vcB-k~ICl-@Vq%lJsgKqM4$QvA(Ro+GBGVdEC3ImC}MT4CMQ$gVCXc$?rv1SgD9R*#c@D$tFY^bZBTXre +@X%{^=2WsE#?L;3Po?ZPeSaIJK;?{z0y}KY|MyLDN6D=!iZ?&%q8GSNovtTb&b{4wUxYQVoWG7KYMek +0{x%HF=5_QR#nXz%u9b)C|iL*tlT&W+to~?Y{%-!hVmmEGn($^w(`>^{>Ty>>XVAgnpN)-AO_&1iFuD+e~cv=($pqbt6Wm8Ea5e-G1 +Y2M4PySe^^vbMwKoyTEmc%tbi8|Mt01u^LKV|A}Os!+3Ufqre>zv&UP1bKA4P+&(EATy@b8Xl23o`)^ +pldsc9xuNwn9!Crs$bBAx)(Zhi|?r!rd1+P5sLzawk^^Ju8dW^l8T3^$8@rJox;-xQtyjalN(KGt0!* +NvR$zPD|e$AnhyS=zyB-3bqmK6zoLt;YjHA9$hkB9W_i%RHA9543MYkKGXC@#x5hrmHJFJfOARm9~?-D)EBj<|8F#rHJ0001RX>c!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D?FJo +w7a%5$6FKl6MXJ>L{WovD3WMynFaCz-oZExE+68^4VG1y?S4WMR4%8u<6_aV(D-C)xsa8eZgbWm(M5v +oXDNp9*p+<(7^k|~mUah*nsdqE>GlF8vSGtUf%w4uGd_CI=i`tJOaF3wL*FK)YS7h%tOrlO?(kivJ@#L3(8wCA%7|I +Y!)nq0UIW9hL7noNsA8vrt2gv`)8>Laxtg7b%EGa6{HetxrVBToL-&m6PrxNfM^vzpyMc_sg%uVDl(C +N5%bcMlO)d5@NNY+UuFA8=plL^q@U?JjPBF$kzNxl%qdUkdYwNc@y35p6@_(yNp&M^5RoQ +XIS6lAoNec6L%>P#APvoVCu62KSiz9A7}TenfLAC+@@OHARRG9?5r#FxV(-=kkN~G{{i4>d@ +yh?*OU&C+!yg!|u{EivNZ_h8zZ$C-v&(3czPj7DM>}pEKbbUO%JwN$yaXh8#57X^|N9aCGmaXFQ#Zh-%z-qILTdlN<-uhvab +FzNc!1nW6=B1$ie5Qo-3%lFo~X{D?fP3%9P$` +va$f1wz;kFcL6@9{t}%uVrT74Cf+^^mVBAB))Glj=8*4_;F!BH+8v_*XlS4GA5pai4!(|_=8KI3ac8L +BB#fQ=wX&^ox%7)?L7^2b{*(40C^Q49C{79HlKLH>212fs=jSu4{-tM_F8dy#RE$KHHp@E-6Q0;@O0o +n-9qs_Eo3Bf!`dkJ&rIjBAmXR>5r3c3e!y38H<8DmI20yGWKCt-Z37|1B0`I7=>hDiDFZy<9*!a-a*I +6&V}MolJwoIWZ7&N!fD3L?*l1D=)K%wY|O7-5(LS>}cmC8<@4;m)Nf8j}!!mev#QzPt|#7y)ZY8U}PG +yP%2WbTlqCO3UOk#tzX&5>BcE3?Ee#FFa@8ah}4Mq31_6`caMk&#Mv2M&H#)iTtQWJyj!|weejpQYR& +R%}R0{XEX8VO2jjf9l-+cXY?<^6vw$COZeNm1 +?vNex<~DjP>c}WRY)2;p+dC)@?yqex-pE;&jDL7y|TfnwiP@<{v3@<113UI+p8M7qw|e-d^-+;tOycvkwnSl +DP1O9DS;oMOffWFQL^_tg~2U@@S+<87|?Xz_L~Q0<@YQ7e|;Y4llQjO$T!DPZg9|fM*7aZkylKp%I{lXzH1(eS#kA!N@K3MF6{G)j +zZ}@(*QkK&{hxBdh;utyyAo#%=F2D9XwN?-ZfQYCcuj=(3fxctm}eiq`X*FjW(I6KdKbbiCVvVhD>FF +`YvvBz%0)7WZ$*z=_?Nu)4b-8ZGj!3^2t%8s1E%tj=5fAYW*AL#swv;_%|c3Gn7{#3Wk>!)T7X3-{il +%TT#&au^o2}pqykCSO*6t8zu~ESkRG)-x;S{o$lQ@VDfIn@rRQI&0Km}R!+rOOQ~jLn}|>JwUjgsHCuZ)1lUjcyhk#XPUo8Z(Th@2&enTR +rGzzaARW(XS`=-&hED5!h;s#H&nio|Q0nl9MM)Iy^Dm +FrsvE~oBqU9ZYX-kRvOMDnXeW3NGdH_tEq{g%e73~QG4CL65Q*HRO0D4hx1_}mhOIz{z!fN6)xP|NPj +HgNi+VuLsGV4L?%v$t^2=3#d|P$P~e&-A?;q+T@|tFgIk*e)D&?>_B&gvEi0xsCD8wa{Geb!|tbmRqx+zGc))Y&(_K?+3gAvONnbfR|jIyYsimYXIyvp_y#PTKM)d(#lx%`lXoO>yBp8U1HC@1iu5fl+eT~kpk95xef5{h+cdMwY017W{(z8@L7zHC{F$ioPPsQO9KQH000080Pmr;MjxVk3Z4l705&WD05|{u0B~t=FJE? +LZe(wAFLGsZb!BsOb1!gVV{2h&WpgiMXkl_>WppoWVQyz=Wnyw=cWrNEWo#~RdDU85Pvc4we)q2^9dt +Axc{uKN5)wwM6~loUwA>Uxqj_4HqycM;ont%0WLNv&_bWS2w{N+TeOOu@+uhYwUtPP6ytmi$S&@cY({MRUitT6SSrS;nKz+=~?$PG(^K +lG6U^0ZGT{f<+_wA)N#P4VgBfp-NQzQ;l=%rw|_dk5g#0pBx-#=&ro@2i^L?bL_v;N16Z?r4ilE(w8X +ADDGZn=w1-U;Y`qyaeKh1b(8jfKbHbJW5*Q9X4m+J?*R0-6kFDg_qAlyzL1Am0Ym;OkFi6Sqd36 +CW&+U(~HI;D1d9@V&!3@3ACnT^23bn3 +ml0XFodFS2u^xbG)>ggG_b(|wDj%b{_D-dJ)K;Cr*9|2;mP&=_fMdO+c1k@$T|71lfVaKXcc>5IsTIiVd5vSe2rj +9q>$$aNv`^LxHkd7U`#LGPX#xR6mo7%9-?G2+sKDO6h3GAVu?2BC-R>tj8dE4Vjr=CP_B6wT(o~}WYF +l)rmg^y7yby~f;%if_n*M}Jcy#$rq5B5GU?R`);dxM=c8~PLG*Bkk+wfNyZ&>{(zIuRvFvt_^Bj%x66 +B2#JV_o1(`4!e!HmWc@(T)*`h~dRfZ;Gp)vq+;&;bXy+V`H-A48Q+<1ia`k13hGK7#N5WEzgrsh5Xn# +(Kf>QDsJj&EBGToGp~c)RXEuV_xb}NGvyse3+UxapHg1lFdIOsV!lol!`ws3Ut~_>xj^|$ +A7DAx&IQkLR44_aySE}P!bOaI!7X2QkaqS)1!jb4;(eGd>y5r*7ZAH_aqv=B8Q3otoGFWw3BD3XZjDt +ovkUU^ojQ4O4Z&7EEvFQO#uLnsEryGVr)?s$I_E||*s*h_IZ2GNejvPx!!~m3#04^QAhola(#WJUdeu +U2V16x8IG8P^50`ySWl7fxIFrh*RayzUB?p^c&7z)P8#B42Q0%ihN31+aSMJ}5Tk|a!tN#XDW7Dyh)A +`lB8L*!$OI|TGuL1uDfTLLfzFU}T0YmP;UN!P(bz;(IvJQ%xdDbTnuWEZMII1sSD80fHbc@jh}B)E`- +#RO*Lf+;%npcaHkmxTf~=q%~-BJ>UuK{5;|!A!!f621|DDd8W<^RSQX@H3deof4s75wTyv01yebAYuo +xBsdjTCa6cmNPvJ1PCSlh0xi_Gh{G0!B3PQ(K!TY;1&&u3kqDimg*Y}vmNkNHHRxs0U>$H-y5a&<6dN +3hq7?f@qW+qyaHNuBFmQgy_>&)_UUr2v=LY@5j^lLnJW``mT71|Y^aany3e)CP_U9Zr{Ue?Z)iY`;_O +ucOrXA7!-TJB?WA%24nwg{J;^)|ILz9i8`8c#kM|_~e{;tg|@&}Pk^ED@tSrhXn7guLK$COsHq}5H%n +D$y4HUvIj9;^ +X842y#sL`(J1zCwkUEnNdQS(IR94%3|+bS2#HqQlJkv3^7<3JeI!1P +A3?TF@VTowmq>#RT^=3cKxL7{F-HdYbTWv)cfoD*_^Cr9Vn|2r>~J#JcG*JE83m)68Jb77hO!mvSsN$ +&|IFNhTgs!7y{Kvv|H$C@%hm|j@56Rv@vngdN0DWB8fH@AUCu*vQ$+Yp#o+=bN(T;@g~%QbPCyz&W3x +5hYdN^#&CDD+XFR*~u_gSOaP5eL;ADE2|uz@QJkh8IMG7uLbEa$hL#5OqbYYTa9YR<1XzY5`fYdGRb3 ++RHhbQXH5SsVN>-ctI}{6&A}`w}Qf7Ezc?PUN;I_(ZN0;ZLFymlr1kDwxP|M7QW)T +~Cp^1g%7!{}Nf$9#Rqrt>vHShcz*`WGQj6N+**Dk{>h5a=Uj-IdFiF80QEpVpVjYdaN`jQGB0RqK9rr>@Fw%!RUP9J`u0) +lJtio)!m9^VLh*=HbtbfqF{q!Un5}mPJJElxCiobR8(d+Wddxd~4f0eAe(nS=zG0=B^M_Z6NJ(FbP}d +N)17^4m-xZNnH0tZrG)7ZELAuzHHU^z4o~z6$t9P&lWpVU3ztAs;0SqvUG)CC;KSo9vP}*!H;F5{c!VvcA=5Ywg|!bp*xMqHR-**5Y +7iUMR;wS$cyPG{mN~)oh!Qwq)b_D(!w}YTg%g-LB=r&Jp~7Fpy;iVlh}g1v_>%b;=|2gXX(csMo~JvS +ZC$s4Hch4>pn4szM!sW@{dX8!D1{QZ=)(ZEs#{cYc=&8#8Dcte%*f&x!dRe?0Lm|1>NAI-&S7;ola~h +f(Qctq;f4{1q2}1oC0RpYe_Pn};hejs0Jsu6*y1k-gr}CjQ6^ZllEKFC~Wj4H{^j!$F@v!pMkzC^b0? +pZVL&OO>W72En-(B+4#OB`Ur4UKPfFdow;r`_1|fe+=>zct2GCn8N5U&-yP=O9KQH000080Pmr;Mo_n +!e#Z&`0QfKf06PEx0B~t=FJE?LZe(wAFLGsZb!BsOb1!gVV{2h&WpgiMXkl_>WppoWVQyz=b#7;2a%o +|1ZEs{{Y%Xwl?ON||+c*;auD@ci!D3s$&61R3%PHo>C=FN}}w72K~NAFHPoSxI!>G8?=^$EQ@yEy(kt+Cw;_UPt8(nXQnCs~}*aXyojl +=Lb8XOgBdt{)#4Su%~Qyr5~C$gH9%Z1w{^^fXJV1S5Zw-(;H4WkLBJRUV(PKbKWGjpx#Go8(!E%VM4v +s|z@$%e<)XPYW4Waz?kymB;>6aiM(8mze6IqF2YSiBBdGTzJj*=_pOHbXcHbtQ|(Qgis>{4<@&5=iNT%w&ORE*H0HGR5GtWGb^#Qe4tp-76mqQ| +}d!>jntD&*6T>?pu-xo~yaP$)dy^68l`w)_5Eca{Vf<6n6yG1&H2iVf@r#BxjKHt#M`4{^A=<4d|{N~GB*n(+1MgD3}$>SUnoDrfb;;dQ%I2?RB +xjO!c5l8P%&rWZ?DD>}7Z_ZDyuj&286&=y#(bdiA@#nLnE4uuAb$M}pvQKm^rKVVs=_9$N_zo@~b1*r +RRh*<{9r_ofw*$1vInm +)uuJcW45S_q4B5vS>rX1Od?fF!>|H%c%{W|jP2tvn3j0jW;nd->~?tQJMKx*Z-;xqQ5Z-&gZRHmw$ME +zy;2$hT +#~7V;Dv-j9?hSFoIzOhY{=|*hR35U>Ct|!r)*6!wC#0Fr2_}0>cRmCkRV9pTKxB83@L3APfdF8Q?Rhl +pTPBv3fYdF~$+$z%}>~DrS%;MNK3&k|T5Fl0v3=$ZmGBZ@?7%0>; +MJ{YZOcHW9fM^8rFO)bAV4ws7@(AP#2uDB{LWv1P(?|_gws;2N35Y77NTmsb!KfH21Tc)$L!=XI3(QV +{Pm#I?FOgCqY(PAL*g!zK0%{bHCAtS5z)(3-AwZ1+au!O~p$Zj)gu3Q!l?1PY;3>&CZ2sR({?cwD{-? +XipX?&Ki3Hs)qDoP95>+)j=q95rx`}E6yXhuj-Az;-|JS;SY83r$GHklZLDNkX8qsu<(CQ|tQDAluS$ +7lFS;oF@GJJ72!Dbgfrc%9C!S9^B!hW)pe=KA+mE|Es#(u{AyQIK=>VOOT*<`ps4o8uB&Y2im1_%3MB +trGLka%hjRsYz26itTeaVGDvNy3)bwqW~=vB}Rt+v?8Z?7oJpx*QvX8$bM+=Yj90@Z1rNJH9%vKk7U% +4}F8Vb!}XzZ?-yv1lZuue*}&d0=@76KDxH{W&Kd|-N!u7wQHSDl@Kuvyl3nFU|`!dU~1F6~-yy7J~(HlYj5+$L_jD{Cck3ztT)+ghkq$F2Fzxv-v#=9@KVyI2>@ +JZ4sAtxUTAhSt2btF>8p@ygV%1<^9YTNU!A6LAZ}E_Z202Zrgo7EJ!dz*VBU+Eo@@#fO8gChYy0-4l1 +AgZhTag1*w-hqZOcnm*ueh<4KxeLEDRd2?k)zmwg1n+3fRb!XS#rW@#-Xhya|z&&Rc0%2v_tPrLexix +RSFX3%hUdzD?m1yEI)fTonXIAW99hjk_b;H_)!!#Q0#$ad`SM6EX0c(}7jcshakKl)OU~0j1JM+6p&l +fr~i=84co!``4*sediKWmL>1ZL^k6#|n;tpme>Xf0e!mJZC{16-N91N*~QQnuN*70=qC%o=3eXt#lIA +iA@0>si=&q8$cCf2>u6p4DKhxv;TV2>LTJ>woS9vjqY>$Gmgps@+;CVsU0{Q>8Mec6MbyiJ@h2S +b-D-4uqJC<1Wy3>%u6|+Z^ME_uPw#+@Dh&srGt|jKzg%4%7=Bpic~c8r1UB!Rvf!x&mxF#gb1^ho(8A +F>L3>ATc4IDe2Fs6kW#L5K<-laY%x-F;$wI#;nmGL&*wPA&UsDD4O3a+0CaG-*Hv6UugfpMpQhFSO4h +I@=e~`O7+0d1J%ZI_!(}BJF=+;8$&4RnU1-=?s-=Xcm+FCGByN!(X=InE`#p>*S+yt|JPwXnu&QG_=b +*hoKsj}5(wBTmJ;y?`Ce!#73Zei%IjTVX9e>`g=?;#Kl0#~EmT|!e#eU{y_@vD#-2l}B~11^rW)o2ze +J5FH@bo+KUt%0x%yDIB);Of9iV^{O*I?~2!WS&`tgFyE}VO@E2z&ihT+nQ%>)Y0p|k@&05Eg>W9z-76 +=A9NA8sGKagTzAvOdr#Z_fv*;}+aGj_$=!$8{P)4zXS?{-)+f!y(9eX8Ch+Y6yNY|J7W`6iwdrpA90a +~Kp}U~^5wsz6Q{(>K*qyJhmB1G(bI$s*UW>q#>~|lzccmz!>70^l +J6MRfB9i$`FOLOC(}5+%*#Z*IB})kScN&;pA6M287rf&QqE7Zd-W#wnXD>Vz~H7>$brUJ%IZ9Rl(_xV +>Gj2%C_0$D5kCe04uao1Z<%clZSy;6e|2a;H_M;OHwxk^xIMZ{WppoWVQy!1Xkl +q>Z)9a`E^v9pT5WHmND}_euPE*4w28!e>Bh0+jP64wo6JU+Hzgje<|DD&2^s=kz%%1L-G9HQfu^f5PM +pkXZx9ChrRu4ts;i3(@80$QqYtMa&#&m>{N(iN?vy@UT%Y`lwv2t}y`$-)qU$_H&i3 +Cd=#gS+1f|&FOw!N!(Nw+ciUa^0 +K7NW~2|3Wu$@{q?*^a}xDNo7Vi>+&&68~Z_365r=hzSgWQa;2!q7Ueepdr#|ZMYAZST+QR677rpyiqi +S7S&sQn**spXb<--H!yJveRQXe3IQ)3^i7r$Dr1VjxDu*>UtNSFLVe&;hQ)!_nDrl+Oibu=TnFey#0H +L!C;wyIFlZw%=b$?ZPffkYjVYD?8eS)v|qEh3BH(uc}kOtFN%r+7hWR{HcUj}beFz76j}iuJFLpq~wVIuIBXrC$ +=b;11Kz;sr#XC0UmH^dT!sJ@oPza|0D6yLCY5&{1j~biqk36o3C$j(JenbRia +HQh#VSgYHO(_sXah-oN8IRu(P37q?`0)n2nld?96hLCZ&kU<)2cZa+#hIB +C&oIYjO9{`n@0DEI`XFHcOx0-?rC32QXsQ2HVm;T+=(@T}X0I1lhFe46Nc^dIW}L!1*Iag0+`Vupby4$*vw=1Jfat~9|^0kHz2CITn!C;E +Q470p47hDJl5#u6un3w;mmLW|P~(S9g=2~+ZI&?blA0YW9v%ArP}qYOmRP+y@{6QofcK!E0iv_@P$E+qJp5G+BaSv}sqPCJ*Vs}hrHQ1WCYww6Nuxl-v&6-O{J_y^h-agNk_ASCab$iXN)9N +B)v@sJG|4?-~>>uzMmlK52pPYeP?i0)3+1F|o6KRzND1j7)*r%0t2QTk9L)rk+`=!eY_;Ha>eK1=UN!H?zH;3Uuq1V1r@d^jQ4GXa@{6wS`)0kZX`-Zu4u%_M!aeBjP``qz@WV-oeH@$9VWpnSja!oW?pn{3r%t(RF2i>eF8ggB~o7HKev +|WvS)ot>=Eh{&XXr#H@htXmY7-MV#lC>AOwtlbouSK>NOfm_5v!Mj7y|F#PDEOq1`RyGZ>smv?-qFC>seu2TK) ++Ap_-R<;_^!WX0JVrEm9UYnE}W+ZJ*Ygm05M-<6-Ue1ikayd~2z9k!HOn$6*v!FKDmi{@qh4T-YV=vD +^q-e^2x)pfjJ7fII(JH>&`M21ikg*BzT^l(hDxu%czmwE7b)fxD<+_f>t(RFuc*H*n*~UW7yj4?!%&K7p>hkM>r%}BMhG1)92jkG9 +m4(LS|7GgoxPD~U!yPZ`MTtB>8!?XMewr!83)FJygqe@gwG1>tx#TbcwHyjiqx%8Y>91CO|v_51l?N2 +J^I=_JF!1_gl|`hQ5JRuY~O)*;J|(93R?}l5-|}`Bj6=yTWFfDprz_n2>9!ceJA6wDO&OMC>x8OSsJ$ +4^~?4cspojsUY?Qc`;px*Hn+TLUvRaVGT^Tc3cahov20-=XaA08rSfdRML$#G1kM1_iH5Ejyv4J +%k7%{=TEW_FnGaa+3wz`9MP`M-)F2jM*B5>MaRfZqy@MAd4U(xYO;PX&xtF&!9&Ta-cf7#yU*! +0+sN8;bU7P_>0+gE!ZwLKZ>hdFTndt?)=i)hO$&;JO)8wI>}f-N@wUkJMUcuztRox$$is}SsBUbDH{{ +g)HI+`j;kEB|`g#QHd(B5#`qKpSS;D_PqMv8ZS6V+GQQyZ~z8<;MANtMpw+@$4naAJtSpK0y +HRx%&UdFR1xyg!He;;wHzfr@;U@(#T%ZqBz7p0b`>4W}u^Fo!S$}!+9N($v0M1?A^q9=v+pMd8V0Q$- +MkN)^$kwjnA;Sr_TpON=pP)h>@6aWAK2mtS)wnpWes+oHR003|l001=r003}la4%nWWo~3|axZdaadl +;LbaO9oVPk7yXJvCQV`yP=WMy}$dF$F$T%u_;whpJU0wa^W@;;44VURfZPOoEt!+G85^`%Fci +yJRR@ELI`+T*XBg;j3H%%#WE;;D-KZArZe2KA){gvs^E}}Ha-}@8ju?Rzf?<`~z>4 +&SQfO`n;agT)&12=*t$)b6lN}C*U5=X!mXkMrP78u8I;->PW1nN~YWlJnpFjgqLiu}iNF9~>oPOl-ra +>*1~-J60uQXhDz&Cann_<#m6&^K&9cw(@M*lZP4&;shhukQHAU^0eQ{{eorMx$1L{BVo9SPC4)0>_s4 +Vi|BWj8RE9RBLn`4cvD|)(=Fq+TC7v{6OB@-EqI;IA9M((1KxWH11lHUTXxy$!IumI#nz#V`+*hnfsE +QrFe!W7XmYhlf>mg6o>wR<&Dt6z=yf}%CO8H!&&8niyg9DpH;&^gwHx&gyadm1wMmNs0zGEj=h8Jxl> +)VlGnF_v%;%Z;L1cLH+%`O1P;P&K10)XAcU+yTSSUf?^}qi)lIYZ$!ye2fQf^WLl<=VcPB1BCBv9WoH +W&BZCOh3gwbR5XpUJZbeI}yVXBDBfx?PLsS@i8b681|_1@6>9Ir~S!2e1l8Fn +B3X;Py;CG88zb}^Nqpy2MSFR3f=rI$3j7!1a9PUj+1oB71kwSO6hS2#~b;0v~Yub)cQ$edep=6sSN%q +-dKR+1028FGoG>&{<<(8n@`XVp_@CSG1ls#Z%Mc}q@x5G_5v6CD>958c0p)PDaB)9krWln2Cij*S*V< +HBdfIZh2Go;0b(5#N{d=R=G5TIbJ)7V)*t=W7#R`+UAO@wJnFv +3^#L-HLg!h|g-CgiCK4M|@VwH^|H$fMkB&5#Qare1mO2?}+a%oe!jQ_%=vxgzFGrr+E@Cy=ffrbyB`T +X7&Iii_a!L`(3`lwx2ff*|u?E&`t-w0&YIpvm4->iEp@(UE@9>;4ds#qpXgyP{@T=Xrv0saQv@T|4+T +g{eO`CV=d9lAYW<0qeX$zO*tmF$QP|us~rDnE172F$gf0PCu*Wcdo|7ESJZS4YSs&XOBCIy?ABmI)7) +Y=3+z9SY8L$*P&o~~<$<^;@m8|Dv9ZKM9vQ?vAWWwmkBZZ2Iby*qk<+!IU)|Kol<2K0@i3{%NSm6B1z +YyC>U7a_BSogu?N?f@f(mZn|5&(br_MQGHDJ +^=0qk_XZA6)qgTbJ^>%gdlUWvvQ6^EhM7ax$K0_^UOaon)Oe!!x??IKcNCt9(YxfpvaR(bnfqew!4+E +Ikyw7iM?9nK)7PtNyJGY;{NG9-ZK-wQP_D5j&z<-b4A=_>Bwy9=S;~t&Y}@wZ`Yz%MHH^l-l_deJ??Pr@HvVPC-e`=u +--IGejc(GNO-n@izuM_N^oqp +giWHyoo!fUV_~N4Yp_}%7r%&BZtKA>9>8AVG`h(73FG?3QUNAixIhRVr)Y2i7wA9l-WgH8dDEY?5LK7 +^6vFs>h$AQy^0zhk}t%r`1P6BqzZyf6t8`2TE0@uLz+1Ws>7^3AeQ8ExtYGv_iR@!7Qa7+Vj*7Crxa2 +(Ps%{=Bq3FCdOQiNJKDz_^1yj20>WM6A7D@9NDM$^ZkSb+pn_xhm2Lwyc5YSk8Jbtt3MixL%r1YfITv$R|0@B0(#vPFG#&x#Fl8YHt=1~Bf*fR$wumR4S77khs1d?KS +wB6O$WKI_R9v4q~o_A>zqeXljP(Ka5dAb`rk`TQ{hD{ojq(kaF0q1jp%Q?RczB&jmD3v>+sz#$5K$4t +_UDX|!YDvwC5&C-jPBL`q}i-i^fUU}kgOg_nJQ*Rxrr-x>f3^%|oEBbeXG2(Is9txc6~ +v~?cZYr?kvz0s(DYy4Vo5KTsqoO`I +K2AQx_Dh08yIA}@iHS6JsGL;YN@QvId0OVr?gxsS6vfb0+$jg!!O>w>&CK8oy%sx0(X1kCyU=Yr?#rk +lP`m00p=?JIP9kB*qb3{fR|zCzueS%W +#;=?zEqB^!QPRB>-}WcxNVF+VQ^=&1x-VqCG$KeqcF8K>+p+UYT4pv<=1kwRSJ!B&sX|FoBdkg0<%w! +aE)hJC8)jb`?AB|3`+*xO`;aiuC} +V&Q8{-#28lVhWP=_GlrPbN2;Hhf#WrLZoD8;Hi}rK4-5)-bhkqX9;@35@~Lrb3#k57koB_QBdT#JF)W +Rj>gVR_^x5Th?yi7_Eg{(*K*X0)?zs6@thcyw($(ASBNz?4Jl*T^M@7!Ho3hf$d@;pOt|Xc3hvw(%KdGnmH&9Ch1QY-O0 +0;o@p|(cOjE_560{{T82LJ##0001RX>c!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D?FJow7a%5$6FKuFD +b7yjIb#QQUZ(?O~E^v93Rbg-1ND%$buNa9hM4}wftJGd}AB+o>mVjj&MbYVm7JCibEM9AOoyhm=@2!C +l1C{P9MT%$Myq$S(ytLc59~zCPvjxp({&*3MX*6H@Kj;_OcB@VCj?+?$t;m@qU!|Ocp$GMkkdo0V7cX +2JWRe}zhFeOx<%w0A5VQRsi;uzi_Dvu1RHNZ%_lj;MOFp;0W#aWiAqCg~|Ms+#foD5f1(QQ@earH+3`!+w7Nikt8rc~Vm7u!cfzxPIa3VG>{ER*OxE`8wwA4@8I_n0}@}$ +gLK8`atN=l2sH`cBk?h5$!7cF{xZ$z0F%IR09I7R8}aF+b-HkPO3p?DK?tv%1NGS&dI3EzG9qvs#Hk{ +%SrQ8m_t*L&l1bi-;_rEUZo$PZMllcTRhRD7lz&}Hof4FF>KvxEf^$|oWN^+YPAyEIb9 +I_QIk+Wv4b=zkb|><@@m5hA~OXuSCPA8({~tCeYdNxkERv(>6B3avJf02aEh&qpTWcIq-gojI12Hv8O +!uHwn(2E_anrU{9@&!Pr|m&wnI6UQt6d(Z%FH^YyEVG}hSx!5Jwv%cc`5jH?c@#Xg~7b6A;H9#A&{nW +&a5V<_ezFr*`KORA?Rw9|f-9GZ8ciMHX<;2a0TMG-D(RwX#f3DXZ!)11iyXU&7*Mzo43P)h>@6aWAK2mtS)w +np*gXPQh5004$e001ul003}la4%nWWo~3|axZdaadl;LbaO9oVPk7yXJvCQV`yP=WMyiiadsh?M|=m{cBY56(Ejjtg+5@-!txV{1p2yppiPZtcJCZM6iqrQ1R_na%Dbz@&{ +%pXPQ;I)~fcOuJ1#*y-f`#TA=goK3Fg6LvcNboP;H>b6^Lwz%W$Q|#aRp&PKXXvLYIu>0treh|3bD86 +ML9P74X#qfyXRbvy^B9>R<6R@!SUvhwkq;q3^k=AB73LjUS>odjk!#>nN7Ty_mZxU$ +NyjYq9!KZYr$%m83nL9EoIlx;fBz8p&@l8WcEfZFfkOkAli +AsCz&JU*m|iTti0IER7FUz`oSlD~u@iQEGFx1n-Aqqr?D}SQ{b@ewGB)SD7-BJ))FAJMcnwY7M=+8rp +1OXJ$gY2Z)0;qm!HV6vj~q_3$9=e>mGL3p;to5Fl2lZ^JOQrRvn;YeNxfw_58sx@TP +vZsHV9R3grtxPACMbz_K!PvTgF!Y|U~lD8m^(~I|Zt0n&Z-3t=-j=gTdEy%2n`eY13HsNkGM*?oUK@d +GL^D7*K`yk-AFuIR!u;CT93D1n}2=-drx+Pk-MhG`mT<|SDzbE*;kscTPo}S+q{Jx&w7yQ2D_d4oR-~ ++)QjP$tR5A=Ln@NGTc7JOUJ9}50Z&mRi@P|qI;{)pns{*MHIB>97m`V_b$_|8a=3%;Z0j|G3M=Z^({T +=4tKQ{b-PyOQ6haKU%iT6`(^OFe%n_)9(C6MRq4_XOY5^H+ku((_k>ztZ!$;B!5n3qIHL*Mh&M_+|zR +`g+}ZlZ!=??zAEom0V*Asgdmz7*(`Q(=bO$6M2!TQ+-i1;TXB5kWm~i+Cqg#S-1RK`|Qq*r#xJ^%Ycj +ifpl5f3+@p!uQR{AgfCVB!2f#X1#XgLwO{?h3K8vO@t}vScJ6xcEeGn^)e4~2DOcJ_Qlc3Yov2p|xJn +4!dr|R~sQK#OLhjG5$AfXJl@*!b>lL3AakECmN!2!MR9i3O&mc(ME(j&vpoByU^&N7FQ<|)(i8FnJN>K@#=>8EAR}eNk +%Fl)B+8+rLOz2aC9x5~L>ichoV-JFm21PD@-90$^2V}c(UV1A76Vz>vKY!@Bnw9tWAPymF@N-A2*okJQfq4+pMA#s$UP&m#|NE~G-dgIgcafU+SI71846{~I77jhm45@q84AV6848J`48VB&F=1>L=I5A=4Bpjv7|p&s`gik;@ZPk;azU +?wLk!v>W2G^YjX<>1VcM7WK4lvlH%vZZkY&HpMwVY&Mn9Ys^ME%-(H2&ay6joE=D>N_O*CpAe&PY&Rs +1?1sXz-H+}ji6gtA^;?M9#d>G{}hC>- +03ii#|->^GnY+9|PGvDHqA9iIK7^qS>vQ$(dt4vHFe;w*LUpg0d2h;ueTjl@|E`hYlpobAPV@j2_#;< +J(pQ0EqFvvOt$ZKn8Gn+v9bBW4X)}dmZ6@&_cCn&&lr|6l6m9NTQWdPt>U5x0(Pqkfur`x8( +q?h2pZ)iPELK#s83cjQW=f)oVsLo5qH$h;mn#~taj0MLQ6kV}@`%nQ)I7khPXnl=AkPDE6wjO{W9^<} +^!8_n@F^3`U5T8cs9I-OQu_}Y)~JDDWmioj!&0NKF|4l!-*`s)BrWUxX|HefS}j>NU4H++$S0_K7JF7 +dQzU&p@nd-wHGQR9^O1aVO$d3GehEm=$DT#u*t19+c@~9Z&mwW;Srm>vi^P#&ph8#c`LAwo5|{g3s;Cb@ywYk9iKw&nSW*k{HfzOXkgUS +SWp!!d^E-c?{{G=&-fGR^-@lZLQ~1wqayl2U&I<0o{|LNaadGNf5_WM4$1YCd$i>^{S1@h3jr~CG(DX +x={2ktdP((rrI@u=RB)aG9!M)`PTSYvPR4)osSJdBtQY^PA@3PMvbPDt)Qvtazmka$A0(9#?^02ENwI +6Bet9ib=pAUFhzMIWAyusfcauNDdH|M=%-K+8RW!Z0cyYoc9YIooJ8uAKIW-U29UkB_HF18 +}!OC>o@4_Ttu46&Dp$XoK9LT@yF>zF%@dM37d+U8G@NjNK&Rk@v*7MqkR=erb6+tshA!00xg>g#mA;X +;>c7e9GeP>BU7PpY$_yZ78->CtY-!+&#gLw0CL7y8W&b*zF+wO`rXP}hcLtWbiejHyFMPqv?DhzH +}SUBc^|Mt`(F+uCgwru<`9QR{qrA0ZN(!#gcX{gI5(`}=>*x}G`GR&PaFJcgF +kKXrw#6Ga5|}O@l$1Xq`donE@+nudU~?#f*Ka_PVa*12slciX(aKSYL +vy;3~JIc_P&qMDA4-M3HuWcRrR-UIXECicsTFZ>Z3UQT>*6FZx%b5pe_bws-4QDf0}jDF1-X%fZ2GzL +dTF>s85b}UA8QEI|A4g1I_Y{#$c!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D?FJow7a%5$6FLPpJXkl` +5Wpr?IZ(?O~E^v9hSN(6>I1>F`f5iYnVSDSkc6PHsx0?dCqa?=p>m>UYxt<{~G943@MU|wJ`u_TTl;k +hT&b7ep8VC@PGmkTGW}c{vi_<^qxOcrF^?O}+=)2VEkGlV$GqxAb1x=QmMoK)1m_^i;b526jK>k-m5u +<4=p1IQ4371T1ZfMR84~!6b%+iAZOuKcKuC0Y-CL +vS*Gmha6KiCx#A5Ha}FuNXAcTzHr$S`jNzfVrlC1q6B&e?OCcWQ1XD;9v +hjigj{>PT&@>7WhY=4GqZeAoK9*&>?ySULA2cX;!i;&b6RsFa;2z0uA>VSXBvuY?$UgW7G^bNNY>d;~ +$cQ5TCoH{*11YbaNVZK2HKMX@B1YVJ6Gdob?1f#3VLOV{-4FOJ^{+~H_?cOQ6eKbYKmu75x3-(a)Vy! +^#M`FoSzzu<8{@+RHsy;ah}!Pd%&O@)P8cz*$rtfc#5)_qk9esbJweoNxXi>K!!=pO7)6OlQU*EFG +&UnmLJafGs%9!W=_IHHaI6|xKjOFkZ9*2jscW0}g;UHi66oAK06Wc)ii8QZ6^PWC(41e +^N$~(L4;yD}GdMVAl!_B3imktiNLUTZJIRi$O%aTQ!pc<$=$TF{v%UPOdMecb`>*n8q8$Ok^KloyFa!<4GC-?cx*&057}t40ZWPd-P#zlM_b@ +aIbIZ80meeas8AZ$3$^vo1snZ7!gE;XH9MuXr8zxdC;R+40#H1gxZ93lYI0$lr4T&-{WYb=1}Lyqz=a +<1Khi5swQSc^r2Ce43UY2(LLL#?DA+>uK?hU1i>WWr`*;ZOs8oDznd98Lo!4*^xhD${>EHqEsFqbg~Q +ILaWch?e+dF(yseTKsi`x(EbN*G0Jq1PJ$m4q@ZA@QB!*mT`h(5(_u(8dYdtD7G#wx@o~ixdnuXoIOG +F{d)YVCOw3MVq*G#teyh_~nRkL^AM&=`s&+xIPbMW#XHv}dFH5Sdn4eR~S-E&8v^OKXq)rE;MAz5*8% +=}Xq~A~w#ovnETWX$9bmpE?Zj*4Q7pcg}cp=i{4<`BGBv^lSM?PkuY-_UnW!|4yg6(s>8OtBg}P@-UOdVO +{+(XABK~azKjO3Z1=p)5T>YQKL}c!Jc4 +cm4Z*nhkWpQ<7b98eraA9L>VP|D?FJow7a%5$6FLPpJb7yjIb#QQUZ(?O~E^v9JR&8(MI1v8MuNbLcK +w@)*6}{C}_W@X-Xn`UEs;bornZzMhjg4%l-Q2IgaS}>W!WDX!kjTtD&%8Uixv4(T8;r&?n2h^_nKyvm +zrYQ>S)d7z<_?nti7)l*>I +;AVV+})M!7WM*Cz>QMB8|g89TSDKtK+y;SJ~62n}oOzta63=LqDq>QJoh_YP!1YJc2>iq_^TP+tUD$O +0}at;e?t6@PkRWCHiGU-cU6x+m@UtKr;LJ7c>sArfnzEx}oUjQRCU?j{F6G@R;cu|5s!ll*Aw|vtI

+McQRmMVnwkCFkhRNp=zfOMIOyoFrgY#f +e{r{q5FBf;mk+yg!xox3Pi)+%5-!r<IYVO1N)cfa3>*ojgGK)y5#8Q+GG0E}=!fIwY~Xn?d{{si=H10|++R()3z)AK^9OI>U~?%wl-L +%ts>p984v}&vv68qXgmImv{)Fw-7$6TIA}{HyT00>UVKDnxgT#9X)FG7w5y#p44kfsT*is9_wc% +F0@S&sc};#T-h6FM#$5%J8i1s=kOEJW%dmr^yMC$+Jr(=K9LZP#smalf`)fR%@ma|Z^q?-yP^H?>-*a +A}umspbyJ&sXc+`xnW}a$th~DI&vc1Q|meXEhXpSs_I1yVPZwZc7#hs%30INST;kG+& +KUYqzvI##V`=+x0HTd96u&|=@j$lgsvgAXW@n-k!_BMyxhfXJbXcSV|Vqc$2@u$xJ99ek|%@X>06czB +Bm~V+CU*u&Nxra*JPv{Jw1b-!T`r|Kq#1`V0xT-!{b{k3qdK9si%0V5wsI$;hfBDoP!EAFk6&ah+Xvx?WMm +WWppodYH4$Da&KZ~axQRrrB-ck+DH)o&aW +6LA8J(UgH|V98|5TINWvWugo&!C7oo)-!(QxNw7X8?{`#A>4LG(*)82l9d3k2$nb}#NoHQReA6|{7Fd +hwtQ*Q|8CvHZ@Xh`Ca&!6%v9+L?|7H=Hal@DU@qMFlbh(||$tQ +#9IVTO?5&CxZLTa49tXRa>dDKLiXjsdBlmkQoeMm1cA3CKu&ra`w^8U34C;WyJ!Vs2c!ar8Jj5d=? +4K)p-(hMutG>QhDp>R1hR#%qs8^j?E?DKJNVk4&->HG-6`1;)1;;T0i!FjO@FF~kreB!UUE4QdI~%QAx#IK6sOst>8o{@P!9d=(9rvC2Y&C75fcv)wZJ3 +yOCA#RWhABQz`4}Mnoj!U+x^(_^a!cj4guHS#V>@;)u5RP$YS|8 +9L@p3BB|A>gyA*ijW)$7MTjGNJVr75bgVr|o5ELUpUv@*}2oW}6r1G}lZ^hjtE4SP07{r`5GwIvS&}k +lWMj=)N@HTibu`GA^i^z*z%pPN{^NXN|A#)VH&vR5}fz4;&tRE6i5i6zye0!aW$j~~#&XY1G8`EYxg9wF_Y4!@cakyQebc@&MbUT@8$L_ozXJDRkE%dWu&Lt)rQ_QD|Hvd$rX +Jb0A|Jr&>|~8fltPg=%noRsF^b7;r0$U!$U(Ykz&pU?1s=tjPb%edleRu +b19DGOz5v#$-Cj;V{w-E&oxm`F*8H?Ukyu|3Ce7q1oAk+`p3Qn<_6d`vAQxpWZJ}pPhXc)iu3uaCbi~ +*^;D)_XlH|y!}GSS6sU?@)u~(H#E&(s!Pu~w!x)YqL9gYv!stH=Gaf(pjusNk4X{o0EKU3|5*y{UEj< +XgWJV&aXlZ>pYcVz{VTV=@!=^ITzR<;=~Uh=(wJv62+P;J;q5Awvv)1Nq{_aHqj40VNIhoH&MuA40kz +%w4^T@31QY-O00;o@p|(b?oHjaF2LJ%L8UO$~0001RX>c!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D?FJ +ow7a%5$6FLiEdc4cyNVQge&bY)|7Z*nehd9_%5Z{j!;|DR7Wx7CWE2XYDYR;#YM5>V2jqZ9$vJ*&1tA +u+|;5J$GNUGD9(-#8&a5<|P~oz+TU&-^^^Gv?$(zo65*>0#v{?`<(`X3%4QtM!3KeZ|QPDB=|%UPcjZ3lA4tap&wF7k?eweBLRyD2etsIfkyfvk-~E$f?KO +q98%Afl!XGn@`&-|3j)K4@pRwg#FfN{`8q)?U*&Rz6|M2Ar39l}gQjKK2%#l6p&bM;R7h%bh75CCFqW2sjMk6Z3xpLh)SPt=x}0&@}Drwhdw(bp^wfN`7>Aq!?=`^cn(m7tc6N +tqFFT`ar`3c8Six4+w~gK4JL5oIotdA`a?^fVA*ie|mLuJB9Y}3;fm|kK4oPmrqEGuE0}taEe4%Q9uz +Gwc>6l*C;pwT=&M^E97W*`h))Ti;~{yPlvt91e}{Ov|-d9Py5~5L3<3N+wtgT(lgPygk&aG#?%>kYvK +h$t{7Splf2^iyb=rAD_>2(`pIjK|@9FxXW4 +pV96VYW+jn5b+v#CrQtC6gyM3>aWEv?I>uXsr#wAlVzGdvJnQ3Vrq@8g}!S=7w!G_rxP-ag^u0?sO-Y +YJ11LiUUa-^EDb%6+YKf0gdG^6F}&ZCS@c+!^eOefg-}ogY<;gMZyV@JCy$9rqQ&U%{mb2nVC({tCj2 +iuz!7fJ)2&Qdy}i1!3CUyWj3t}8O5Bmg-5B{sSt$CzS$LWh2<}i=^UDsO2rFYA$HaNVpHVLDp=kynin +veQLLl0nITB9sHOXAsjud2iD(@vGd2X}#PrxIq5(1H)w}!eAFamycgK0C)(Whs{vkHw-fFe}{QHkuiD +^}`(K!rRNQz`R8i7Q24|x)f>UmAWAY$q{|iTl*gsBOC~Q|=^kS3hfyq%KXK#E-$k;4E2Odn63wgC?J3rb1J>MWe#GQk+hugB`el(E +>OGJLj`BELA1ny*6BpFM?Zo?z$V685%wusPV;)wvd+q>x!8rsZG!l$`2&|OJ`Ei5|VcrvY7R<}EcKga +nLOD{T)wy$Xjm4P2*N{D_c80b3cIxDq5noAmch-7<^Ycx8Gm&wIlppgKrI+;_=yagtfWm5g+}>0oJrb +|)64u6~fBCK$w)TG5szrjWjHenITg};^r<2oh!0CZyslPWeVbQZ)p@-WkLV^sE|#6WoH`3GeW5sp0ADa(ma<*RvbhAm$vnn3Y!hCC7< +riHAxIM?6Zd#*f+x~nRl<}~VYPNll#=qVZU;wPTXhwA_1W&7%C?X60&(>Dm_|T%dtLE8uGY%^J}Q%0g=uI +@rGt2F5-Imb2MW1bXeZ2EO)P5kIuPuKb9ayXv(5;5k@VIoA|7YmG8AKdN0Cf9y1PC@>6fKL4O<_DThO +<6oC4I*67x(@AJ1}ahDV!zvBY=$iiUI*ukg{2*vlmg{8GlhAV%-32XpnG#A{iB_X52A2zoD2VtD_2kv +HDdAr53otycL5P)h>@6aWAK2mtS)wnkt3AZs23003MH001)p003}la4%nWWo~3|axZdaadl;LbaO9oV +Pk7yXJvCQV`yP=WMyAWpXZXd8Jm{ZsRr(eb-kEHZOMTsCE`xB%5Xd+p!a)zCn_)$de#T +Bbx|C8YGp}{rV0i`6fGyZmTD2bk59~GeagxyHN(^(U%6P +0WGMK<}TVy;h6)Br*v!zmN1C4$YI(K)sl;R@Xg)ZmdS*!*RHL5pE%1-)H7{!*kk*cAaUnv4GiPS618D +A-u!8MRV14hDpYt~X!{gXAEEmfqp)}>S-f|jXyCt>%nl{v(b0EG$DWqLBgKqQjiq#}MM6P9jmC>IH}V +^teencjK$G+n?LH7SKB6sV}1dA{Tpv5t+Z&BX!HZQt90k*X@56BBK^Nv-FBtU~v-rDzRp3Txp&*rl}9m=lIgw^ +yy5oK6cpwQ$>z^B}#*SDVzyc97huq}vs`7y(ut=L`_Hhu`(Cq6htD(cb&{$;{qH5zgAghz+wg!*t;Ko +Pr+{wl6*k(f3#{gOcl(;vk6+;Ajyu6u?RDHX{WDYI_urB +0+HO|p3il6CO9KQH000080Pmr;MtHXtFMbYEXCaCwDPZI9bF4F2w4LF8~qjOB!N8!+I21J-rj?tr!kdMWl%P;5F8PL +^CrPU`*oQIZwgL%aGz5Q^l(*N3ass_3m!^6)d25rnS6;$81ZV8x1D3 +(iIFPsVZ%53qi%Yl{Qy&|7ncjff)aqWGITiGR$6Y4qiq{FJOvJ4}x6pZ4MHjMh=W^!AFq`jP#zE{dYD +rUf=76!HPtcE)R|4`A#@ohBey;NlPxyLE9R=glT(J- +l_b29?YCP(!AM8(Y2UbblZE6P5J%Q)T+S^qHzG@u)JMh`VMf;s`p9FJjLPBec-m3sr?Y-A0q59a#Vm| +oW_xCpDs*0ExQ9GwdSz6ZF0-9YQ5;V1U%4{>lYl^kL8`Oqu%m~e|UGkA)cx7Heap9Zdkb92kh2*O6WO +m^X;LI7LoHx5;^rIoLYt!Mi1bp%%w8H0NHj{XuV=UTM1)g=>kokPvTmb7Le0I9k2G#|@Va#eUn^^hU| +c>DXOzs8_}YH^)Wb+LCAKKHVEQA2=<)P!eG+-)DHp8FF*LT2#EVbiPNSfm0EeTq^I)2v-HJln!pw+(NJ@wdfq>SG +sjs&T^cu!x(0vrjYLfPC{F#;B9Vp8fgEtC=hQ4F8l4`-DA +`>z*G?KjPt@Oj+>1pjisEZgJ91WPJfy0n*04uJc35+0A +n4iB>^;iQkq-{*TmjFeaE%9rVk&fULJsyu2U7FC*)DT{vrP)h>@6aWAK2mtS)wniC3EQieu007n~001 +=r003}la4%nWWo~3|axZdaadl;LbaO9oVPk7yXJvCQb#iQMX<{=kUt@1V?GE^v9BT5WIKHW +L2sUqLtsq)pdCoqh;lV1vu0%{6G73)1vM;TmhM#I;##B~{dVcYC=1e$Na^iF)zczWowe8V=`;GtUgOu +FH)`%REZ)(#6eO{IYH2Dp&6BlcqjgoCy5Zw6M9YmCW$oFZ=RynckhKeX6QPeB^gO +)OA^32=PLE&SkSM>&=;|RI1lHy%3*D$HNGDFLh2^G5a)^##nZCKl){AEtX4FG^$=MW25r*toum63X4v +LbZbq%jQri`*bh!EgqX%rfMbAyGd@WGK+s`Zp%WvPTqXeSzy9+|E@DttL%H7HdB`9)+QD9lsC +#GrCqYjux5(QfZXW4r_!*+ojRB~Ke0l1{`~uQ5PZ3mdA?kVg}98qs1$a~55F0ey)TPK>O$4gTtq*9{r +dSwI6&33Q*=e^K5g?HtIE}%P%WO}m2<}wleixt&W5L_r~L2dy1dt!f_t5#&x~9vL5iN``cA=sj*r;g> +hxA@@CUsxVq1x(WG2_w8@V_7Z*_ewNLeDy6)`M#6nt_g5BN)oTuIZM)lST_E#$NdR_ag|*^pUcW96cf +wcH5zx{HBdQMGV%V8+r{TgI)i{FIC;ZU*?tO0H=P=Svx`U&O;NUppEY8 +23_taZ_Dhm~y8=_8@jvBn(Q~!I&05svBCj(Ahcr5IjPSb_}Rs)L{ignog@K1 +0YU94K-DkwRreE@ifc+)S@kkx>xvBY6#nUgQuZX&LQwbK8m1&nE2f#ZaxJDyx{J>Cp~|E=^(kw5+U8^ikwoEjrG9A*aN*p)LYp*Z<)%EoVR +1abwoFNPL3+{n8agA;g2zvI3}Pwb5nloWzR{FQcGQ%V#HL=k0oF1vWx7E +~+|dL*;Q$%Y099>?Z6jTRMm6|XW*E5t0;b8?8m#26o&#{+=S!T;lZuWq}(uPi_mK^&inxyYqW5~OBFa5E&h84$RW)Dg5t%MrM3O-JG1 +v?SORy2@?dc%tr23-0+ilzM3)&VkEZE7uAxw48M +f>wo)NmRAIYj@YIzNJWotO8e>0@c^>q-N(A*rL^qy1EuEtwqjY&Jp#;YULUt5_^?qK!ezJ@IAQGILL2 +qvm@B0fOOfV1Tlaz|rRm?{hk1D}4pLS(WtYBN41GRv;7nHRQ{A}`CzX$xr3k3FYRyWf;1 +^pU~_{KEeThW_nO!w;#Up>bw{^~ +`Ti^Wug^v9JuqCi&w8~0toWAOM}6puKJ*`c{}eT{Dvb#x$OM?N3;V) +j6_LH4ZiTg-Z;s-s5r+o8Rm%|+aK5;#J*<|8iS0!<0XHzIeYxwzGsq?z_6cx|L!7~1$K6KSa8 +h9f9a7vBz5=AYPUp7h}Cs(8s|+%Em3f`9iUtIHGv(YDEi)ZP?z%z?l^lZ?&q-X2K8OIX{;TUaRfTE+e +Wso74UPBwViX=(tczF?NjNxM4f{m^ta_fo$^}Tpo|vIyE|%teo_bSdYF(}qAUqz4F)q7oscAbO9?{rj +EORh&Yb%4wbZ#0*;e^^O;ziA@~t&TGU5t!q6=9cY{7te#ID=|!Kpp<3w9DjeGx%PTj{s3MabvZ5`AD3 +k+!}mTMx{H0YB#_0@+!F7$ +aG-qY_WIwRB*b;xT#Z_(F>vUIR(n(C6UQ`A`|@-Qk2m2973gC!RsND~yK_B)_5O=pb#%=QSv_a~()cg +i;#93_IjLf!#kmv+EaA>JvfCE!2J!0>NnM}J*xIrhU&vvZOaaNf$&12(OIE``wZa7NM6?4%{KqgsVjB +e@jZUUTXu|Lo(5ArQ`O+k=*CpLn}LPM|^<*)$+zCB<8DK0t0f1^fzq?CkH<8EGaOc}K&8Mr_a#ig +P+`ewcAO@=f?V#a3H;DHZ?czqaDeP7}Irl}+5r5&&+G`{+G9I1qV(%_&GlkW51D#sKqZd&Kz9C7>1sG +TLFQ#}9Q=lr!5rAJnW#3HmpXgRR?LAKS^HR+Oi~h67A~N}%rak57MW(dh;KhH7pDLN!2>D1DQm$tGaZgHdS-5OtigWAuIcW&Sg3 +Y&)*d0GS6v8k0KI>gD$U*IBTlnZ~~qP2G7ss&_3vzE)^XVGt?zpkGv57lqoqA5Qv9pjb3TA!3VbUZPQ +e_Uip@&gE7vD{sUZuoRQw*C{5F7+feyeK`U3QYU^(JsgZ;`&7&*Wk^hbWhVM&?!eUr*$=hZ`ZiV1eGlB&VR9lz+S~HLphDJ_v0tLM`e +%Ak(46HY5@R_RHrOVEPt#HunNLtyeDmv3PQusQY{x3?A=3DLv-zUk7cVLYcM9C}@^ +0fy8Of${QnZkj@6aWAK2mtS)wnkFa +MEI2p001*1001)p003}la4%nWWo~3|axZdaadl;LbaO9oVPk7yXJvCQb#iQMX<{=kV{dM5Wn*+{Z*DG +ddBs|LbK5o&|6iX1mrO@gs?d&|Hm#`LD3HG3B^&5>qa~kngfEREt)_PD+=0SOcn&mCfhB**t1;QIpYQ;!N*GvM~7{Ha}ilnq8b7nQcG9zTGCZ~(eh*QS}P&3H!Bs!RQJL@crKC&_62+U1rTp{vhvR-5ipg +-JfrDAIwe{WpM4zsitx!N{^qmHM=V2Wf-Rk})6Tq;zI;~0)Q$!e7sdQm8tV3HU2EJ>MAiD19WaWISv? +wOG2BMt${M$jrT@xly(25|WTBxRx!d8trfpR;3{wh$iRKr-JZGF>r{{)qgci4DnO@A2)8p9`7P;^i<3n_?|LXOayn=tD#)(5$k9w{jI`y+>jW=Zk@L)qp+=(IJH>48$KF=W +P0SeiJ5)`*5m8eq%AVVs1uoi^MOukIP)2Yhmc>z`>1>G_M$W +h19oufW$N+KzEUUmSgo2~gHVy&zMZT=jb)0KU!WY_eTE!bDIZhF%ETEN_X;EivGO*ZwNp5dpJ9(;ZZz +ljrrYU7St=AB_sn!Ghn`kvpZfjA1q7LJhRmFMHQQQ>_-TL%-EmD?%uLIl!N$kZ+os=#{5<8B{ +KoRQ_>{)Cvc$tO3Zh?Zi6)YR$#Ilh)V+&dr%9yj@G(&OFd2Vk*^~H8((v^s8R(ZN|CX^)0C7l-_Lc`; +NE(yP1y!_r-X4s7Rjvh +?H-ZOBGyR!e#Jmb!X$SOWRPpnKMeRVg~4txHKCh9d^elOWn$-LAi!H%NY-eLBuQT8DoFs`#bQieP_dN +o=f&N|%h>=?C{g39Uk>{fs{7q-;)++%&_uxDSeHGc767nJu$L0!KoG+a+9_lYsA9;90@SIC@Rm)H-!U +D88d4}~+@W%W0xX#V0fG-hPXye?R>n3#!^Rh!d`F^#F?llzYMS`#U~A92^)E)Qb}qPXQ9$l0?jVsE6S +>R-+8kr<>yX3PW^$L6MaJYk)8&~|NDNXG)@vIGdL$JLatHcDhl+;-5T#zO5J#v+umi4sK^KsxUNnl8@ +ShAnP}!lhL!t3*6{@)29>rESqOtvL$yLtUUh=e5$XJNq`==@_dg +etb$gy8Y-J5{YyoRzWviorTilZ;&=o$Iq=`Gp$BTsgNAgwD8yOm&2A+r|0V?Dz|abppyXwTo!#}ie9h +=o3nwRJhv3=#_8q~}79$Lp=9@%v +(f-SW5mf9RJq*=4dV+B4*as#g8B0Y_ofW^^iLDisN!m7mPUhGkHJ!1WbMHjZBzH% +>>0`M*r5>cZzZHymoh^U3-^vOao@f^+LNqyx`OkI3Mnbp13isH2E0OEx*;Rcxk8FhguXs#Lo@UTpLCYz*go@5koJUWp!1|pdBuV5hh~Ydi(ckUu-QDxcOLwLP0d-sH~)`%q +a}F>rWA1aYnmG7x(DCDCib?&CJ{UrXH-$${tLzKn&021cfybfrqF~h7TxZ6tawJZ(TIFUydJubAa8Mq +6nEbj<3rT1)raODLuYa96mH2gJbphYTT7m-zOq|PuI$zYlD@*YEuHe@u+vGEo?bCG={@Rq%k5i +vW!6l&}nt$3_2+E+YHbJ?EPh8!Gx}#lTa@0RO_wzsq*8caXF$1>LD#nCP;Pbqs0u&E$I+}@^?Lbj)uR +Hm-L4*|`<&JFe7gKAUOs{9j#pT76{G-RpG&^?W%G^XB-RSI`@0mVI?A~1%*>ZCOfnRJ}vDWuq$A!XsP +)HEbsFNP>_mtz~Z+PP6*OiWygZZ{C#G+!Rtz4n`ljSI`m8Rj&;4e@}F+vO+ +KXO$hJ?Xp5=@9FUi{5sA0YNOg+@1B3)2X=INcyiKr`-?0)%iiw$tG3CWoMiAvv;5ai?Ub41RkdpWf)A +$Ii_Ny*PqS}#b$y~fFV(isUQ#2P`N9qGmm>zi#?peD!+Phmp1SB)ZMS)#w`y6fs^vxYW7U-H4FG|mkn +`kK+h{Yyn8tfnw_25N+qPy{(8IS~+qcW$5v?O?_I<1SXIDkDR;Bm!Rl6*3qQ4gPPI=E?7oXoLfM7V!X +aD;UxA* +(esLTJGMa>q2zh3-MIQ>#UVz~38PIjtHQDH%9^; +_1d!4}MUN;$K_p))n-zx5u8;qI;z`6C$E_&*gHt`pwnqD1V7CsGHfA$U%nEf1A$Dgi?S{_|`4n(ty^Yg29z9pfZx83@D$)C?xRjtmyE{e&K7ObnCTVRTRd5)}DT?BmiO +;hi)o3{HzY*N(I$2k)OZCwE~L8w;irtN5UtHp*O5;^RKXN}nE$QAM)z`~LxoGL(;fv#CySLLqorJc+U +(6U1T%!+JPw?&VD0RSiv$5UYW6%3-0$s?@IOpGFmF+`LX$6!&qf<$Nlw9Qgw?aIOs^aKFm6IL2Tk66e +g>k1TvY~Sv(4S>N8wt|Csu!bXVm_^l+V5C*2R49vJ_y}}@Ep7p?NQZ)6+fH30-vv@_OVpi1!Ga6uv?p8m0roUn+YKy~1iR1=XuZ3p2DL +3~0eGDmg8+*(>3D?t3=D8t_4PiS6|IL#d9#uQfm>Kr>s?2nFgw27qwYa^JuSp60`Z;bk#z}w`1uxXQB +P74`DXMq`}pn^XlYmNt}YD%6AG182jHv0K1V(TTS8qN)lTg2Dbrfue3&gDiRr6bCXXfH^a!ZNCep%+2Ytv; +8lk`)u_wg#V|yuFz_CWtRCJ6P>A?f`fC!SAF#i1ci*KKPeDz`e;pOWWZ$5sQ8seNinlfiOIFcN?Oe^% +k-_pj6QPMUftjB7>GN1lqC;iiRQ9Fq +6|BcxMp6wy_UDq51Fs@vZf5QP82-V@Kz1o9UMIjj{y+fexARBtvIV?+HcZP9RrmH#zEbb7aHpqp`aRp +=_a$Z+ATz1cB?|!<9m_u|v_OfwQru2uOx2A+u3k?#StrZFk)kY)qYp+i!N8xi9=?*~7Gfl^V%gp$m8+ +p8^DO01kI`mc3}mn*E_z*J^|+;kxaBiEn5F*aL83icGS&Zo!J!lIH_hWwG9XI3^L7M??Nd_6X9%r>4C +z<_a)dQc2NSf+9eKq4>gEw%n(9hBvlB69FXii2R%$C7>{^{xy&${Wck>*%o!X&Z}nCj!(hj>j-0DQEX#)D%<#8Il0L0>C^09${5E((@dR5XX +0TiwlK6DNEmi1d0rqAA=VXij3>#65})T7aX2@8@rZFmVtJf*3e4X>W5;#G%Y)Cob47owJy#n~iM@#aN +qq-+SOnJMj}@tla`=fu2vJ)+16C9F%;J|Q7!K>~>`Fy;bg^KjNhZx=LBe&hAe|oOb&QIT&!1k);;dnU +e}{}_{Ch8EGSKr)QK3S%YFXVytOFK`YeF{z#9N38LH>U8K6M`ax2VBlk+)5Dd^sV$Fw`1sXmiY*R;Z_ +XKj!evO!VvO2-*MhvUQ~yk62NGXc-3aN$;bdh3^11K>5-!)I9}K74e!-&hh8QG=9??v@pV0ge@7UNVD +-BouIHgQqQ5U=U#^_z0&PPLG5}3N*JYZ)en7?p^Z>cnAVJDX%WL0B$G!^M>R^ayjE^D(z;Wq!AnJQ!) +6(2qfiP%~@g^9Wc(`RrfUE@|9?dsQR^d6Ix+3bZcxR19v_{ +W&p+PoLf)QT7KkV4t#yw4n1y2V5aym!n4M$RBe>jk9U>$7D-d)P*C`x_j=_EbhUgV=K)bUAZq`0E;%g +BK6rZyeHTqpZ)!ZR1iTBTw4a{&%&|+D1rAGsoYKe|!RJM={sgn5svH)_k#UyPH!3=z5Uqo`|Aq=E4?p_o7(fig5mPN!ZcGgM3@i&#r0 +<<_nMx+p)u|Is>F&Gy`aqEpd}b@AvG)XnbT5qQitrZn*92dsS~~BOnaK<rB8!XC_ +M_@kN+Ou+#o)!25CN&^X>%A|u9wnb!)4IHs15XlY7BYo|FR)1Q-j#d*0A(ujya8=wy_+szhi*~_Y~`u +#K-&xS8Bm7~mRK!9#&jbHTU(5aE?7M+{wx@iU{U{4S+dKcL#FIkdGy4bSc0T%BiP5@p0DAo!`#{Ik{l +q(1h>uO97fff+tnZ?II!^X)_vV2)H8+YabD%8G&huIaa8)pb+V=y7nfB>k&|W*nrYR$`}D=M3M9nt3>cQr|-C&I1vB +O2HG>)*0$BULW|Pxta+OaWe~o9#arYM8me@@O9fF}v%l6trUmX;HAS7HJEu|XC@)*qz>V_Iu6$M|c@3 +Alwe~X`Dy?_w(Zk1IKlTAUvYQ@J{FY%oL0lb`6^9FuDr*I%0YPOFH1v}mALn2F)8I}tyeU2@Gy>UPmc3VK(dA{S(uqA{$Q!=se(;j-) +;?u$dw*F-xWX%!lhFWo$k$si|Q^6G{Nk)|9_*-b@Y07ybk|?2Ta%)>7O{R1ra%WDd#IL +gRFWH2iU*x(?0^EW~Ml)*F`oN*jY>A4Ataz2cH{wsf`r`v7zqFGmxmVh}^s5ig?xu{ifOHAj%b;o|-GuA;(2U;Ysz1@c5T(H{%BeN3$w-XO1e9gG-C`CE@o9bGN4Pv1IB9fu +x35VE)7NW$U$LxS^FesYutT6cVC;q))allv(MBCFP6KNq*<>Yr1!-0`(Z3A8A#Uz}V3?w!*QD}FZ4;V +QK4$cy8D4^M;s;-rsh9u~dZa|c(x@*ryO4xT)wDLIrddf*MyVXi{c*=l(l4HkX>twx-smSac`9z4AM` +JtQ4E-VzU|2wW*l#^Izf&j)v)j6iOub`gzLOxD`lUZZQt9q8zn@R}|42lk^zf&Tw?vlzPU+@n*>h=EESH$l<~i4FBf#c4d)tzf4t^ZE;S;I_$pRA~B@Oc^ELf2#yvW;tpB4WG-FyC +Mp_>o?4oAyOVCgw|SS|D`JxBGQ%5t3bcjzQcCL1be#ve$2qEY)!`R8oo +?IE}ujYCTxF-~)#e)X@XkHk3%)V`9`6GZwlEBh`}9OB)6h2fce~O)F@1U6r9Z4=TDXnG16d7q;@wME+ +!J!{rtJpbP(~7Hn$ZdO=-g`K^&;Dew)n7xdgh*B0~x^fG|Wz$|*ZO`vUUOP>1-t_6VXPvJol+adL5p9L6c|Y=HZ9yGW1|hX(|v1OnhiOm +!%)eCr)xAEgHc|t9w6~Qc#Sq7Lk%6r%n*pA{cL$I>wxzL`NP3_%8fJ~j8hjd)ui`v9ba49T5;1j-E)$ +1kAKf3;hwdm#ulWQq*lyc#EcYUNlJoK&fY=qls&=c^z%scY +aM_js)+Y}iP2r!%;Xa={e1cEE#((}W$+H(&X=gXSYyr{5VajV4s|0~*(#rke2tdZbF~eZ8ahq-~R&tU +}n*6~j4~vou*jy(iXm~=TuD4$LiL1d0*M&uNl3RxE6CRKqNAdjMR5}pIp;r|sB1vELJinV_@7F|*U1(zeD +qFH=!6BOnC3b^X)yFCEG(?mt74A97ui>gjCv-S-m_!liO30!a#bxYJT@=Ap@M&PNJ!>XNAKK899oc9W +XbA?RB&s8k>%{5*qEG?UQKg4D$Ux*yv2x{4Inrh|Az%LwST=)AOoL?+A;)6T<^GY3Cx8}h6K)6^Sy@h +*D0cz8r!`d^hh@^_Kx9NfFq1R1$Y32sFdI#YmroW0^z?IJr-j&cxCBnpWcm=##TIdqA<C|V#KhwEhxXD4igNzVK#sJQsbVaTBhEU(2ZJN6WVL= +N&k(fu*r)UnXBeiK@4;NA)yTePY{f#qjGq}v_L$34qlt8T4a9ualTzC#ban~q67i)17KUWmBVXt$k|=nM0jeIswO%|P8Bn0?Ye|m!*w9F +L;SCEeFGscOlG9Awx@V>y@_+}2%IiWK;m+v<9&WkT#Bz=M$rsL(lceKa^9<<3HRV?G$pp0_gv1q>rBh +tY(A6yw-*D(vI(q8L=B+jHil+|pl+p~PJH$ewlb?Bq@N0%4$0 +z>d9G@xaFl<18-Y8TD)~)2p4y!;&|BJ;6bJptpg|QQ(!F(8-XqQnBs92FnDjXTu99pk87&i-tGnJ*3E +`i3ew>rr+{QqCF>~h{j-sKS16k!W~5!QREXsN@J*)Z6I{0$-#ZyxqUxOO2Qlm5iYcUyH88Q9k>oV(X +E%}SMCgBDBys|hue;33U1!pm2-BP@#QA&quZLZ#qPPVAIL8De$DvCB2-YyBy9#wYdd7u-CO?)C1K#GK +9mRPybu#lfIF#VPCX<76yX#(IdIx@x&>dFb@XQAcK;zk_0yHcn2$M>PJZE(4$lc}795%N6Lg7{DG;vX~~TDMO1d~k +J!WT<-U;xFb%T^{4d9>!^<}Czr6!}%SPY5_%I52Kw^yZK8|E#W(8LL^%>e=wqp>`N@sRg4dt9{*f#UwsFGc4q7car5OKq +NIP>Qh((}+rQ}=ZC;2T32vb*R6?m!($-FzK{^4~o>MOiaHfGd1`lTuVI1_*{{65!mb1g?_AM=(w`+JXWx5@URRcWt|0y0N1nylc99;-LPP +1O3yM*6kiXvt}-E!~vloAPOcnN(_+*RD86{nR{wb3RJnJ+eNd9l#CUS#lTCzoWhe792_xYB+h0jbhxE +%%p2b00IJF}G~#EIq*hFMHt7<>>a>-!D#0_y0MhUn%JWi|PCejH3t^#iDV1ba~A=N0x$myY0FIN{+Q#uhfW~I7LG>w0_akfr} +gU;hP)1Lq7WI#*|=#yBzOwbz?e|f0yGw{OU%79@5F;hyNWBGQCULYPr{cIJElSAyh{(T}{rfB%Kb~e^O|#!m!c +2_tYV2^=U**3)P)q3M9S@g~*nKDQr!RD!4lFCm@-U(E;2x#la2KloD-ogAJ2c2|x)k;O;H{`B@!q@Bt +*Cx6QK-F{JLtlvz=NY-(Hcs>u@RcnXY>;to&%k?^6}j(OOMFvQO&&d+Qm~gW=#6RaHNf|2b#+d5ZV34 +@1^$1;!S}5gP9W1%^>MC92N*BJ2WA+biaFqe}0xm0B*jT)|*e1WN+Mmwd-kPwjO4K#O~>TrF+cu4w(L +Uz?NsynGD~&;jw)3v{+mxspE<;c2tmIMuj9yoIel6 +NkRR1c!;z$vJae8II=wo9#3UPZ!L3wL*AbB=QyJChW-nHk&kYj@z@T_gtc;#1lT~So#y;2uLgOMG2ae +nUdH;WR$T((P1H!`W_94|4`{W<+gAy!&l^_zM$Nl}0JhYay|q^P{vp4*%fLtw(O-1%Wk1r1_-MWQPZo3@4WC_ua-DD=4CoJSNb)qzygx;_SOK8Z{a~-w5@HabP +6z`WOE_GXjo*#yOXu~-IE0?qG|xaH;iV^rv|k<#99@ShQ^{_lZky3J!SxmPkzmfr6H$ws|OMmyA +@UFKLJX3E^8w32s$gg`%#=XAQ*#&w1(){pT{UVJXF{L8Op{N|f)4BsEZr;%JMwr<-sNV#RZIrnZ8z|N +h~a;1zLbvn1%)gk0^Q;W)LNbYA;JvPB%M5!iWs0XQ;w?V;ncc{{c`-0|XQR000O8@1eFv9y +Tnblm!3)77+jdGXMYpaA|NaUv_0~WN&gWa%FLKWpi|MFK}UFYhh<)b1!vrY;0*_GcRR$V`Xr3X>V?GE +^v9hS6y!+Hxzy6S6D>R5{ab``-V3AP)fRy(li3LeI#b)0#;`1sXvmSs{QS~*Y=nh7!vYQq-Dd{zQ;cI ++~YgFiwpKMH^8Q^8B|s%X?ne^;Ks1;i^aoKYo!Ni>}uR&`04uX1BtyQsu6IQQyz3FimD80nU`A42i_=^ +f)0N^4R9?f1s}3;30|g`P~We&A9Lq+k&K7ECX%DT4YESTXRtuM#__3D|419DIp`O+aiw|*Xnh529DiA +BNDTUq)lrBVpr&2AX7P<5t}=!N^V7lMB@@7am8sAfhI~?koNOpSHWp0JcU)+$!cwa8C3$6Cfb06*9y; +rBU@foAkhp&{#gg{{-nWFXjTW-a4|-8OJ3q4f+{OK;7Sz2?nb>yA~G +zzZU-Wm3w8&5-C>%)@z)tx9dp*KwEDFDqr{c`Rg|t|(v>UFOsz?hS^x^g_)3Hv@=?(GxZ;|Zz6{1}(a +w5uqOqlPggIlsukqu*sNq7azKr$@y!TNy_6MfAdu#$3+z2H@N4Q8o6@4t%I59bf86{S5HaAL!l}_fMi +ycLSKx3q%cZP9O9k;=89Ui>xq=?`*<^7f}@0l;8kcDdcmE@*F?TfagtkDy-yTP)^o|aF2r+2>7_xVDdPqYc00%`u=8=JTCI)hDQB7Kvv;y=q=(dfcV<1IsE^~#Nkg9G!sOw

bv<>mR&uv2OQ +&4%vI14W0?bu)78E26egshx>3;uy?6XB0{)P;>EyYyCv>NBDg1=q2I!{k;J&C}2XKjp +ba1nl-!wO;i8>qWaEPEJ|}K#UY?U+JNNI^l0Why_kbN3B^dB<9@TGBTE9ymyVOs)B9_|2 +oxbe_}3vo!(Dpx0B^`Hv4^sJNaZ4s+G%K3KTYCKKbeMhw0?@rgQ$^WZljzsd4@1cy(&c0V@(ax%y?Z@ +#0yZj((;q0`yvyBrFpbGXE~&uZ>V+9iqCGel|o$tg#NTyYNc>6mKLa(H!vA07t^hKrFZ}5zlwnb(Q2! +AAmA`k+&*eLe9jF8kM$!P)Ki_?V;cnb6$P`kzRICEaAmR$+g%x9V94%dGlw~I$xnzD(`F&qU*@DLhlt +eOHMvPK4>-KL)KBgan1fRz;k9{HAz(IoXks+eDQ%LiTmN!i_3pdO9KQH000080Pmr;M)O8x`2`060Lc +~r051Rl0B~t=FJE?LZe(wAFLGsZb!BsOb1!gVV{2h&Wpgiea%^mAVlyvhX=Q9=b1rastypbu+cpsX?q +5N82qbTgx+eWlxDc?QOSb@PSM=q>kOVd@Q4SkPR7EO{H*CLscO)f|lALtK^d%9+d+zPw-O;?LM6C!bD +9@ut@m$WhSt@wJ)V^YJHp^;Jkf@@`E!{Cm>;}p2XR}$#GO}x!lpR?>nk32dNEuHt}J +Rn8NtxG0~9L@{+NRn2G-ELJlD&wM`De}6$VqHY+Ozci4?9{_SrL`En<;Ao~dt}0s7g0!j(3O*k|wp}G +k82b(&Hj{#dIU@#>Xi +TP9ZFBOL)`}-hPV0ORv1M74BgkmGBwucLasz(uZWKZ4P+n?;Qk2JM?_XYA7#ro1I0OLB5@`gBRC)Bv*C0ZSE2$#!qPo<4t0-ZSIWv*?*mpD}ebZGaj`n9krOx~^&@3%joX4Dca9 +ka1(IDD%C?8g0D~td}N`t6JRg6ac9NEltT2kus}oM43`xKK3C5kCzq_BW&J-`PJ1`eO0!H%1}ch5n~b +@$#{Mw=K(n)9uK;$s^0fzrl_DRF$>)04d0mUzN2#cky-Y6IP>JTQ(dGIHB_? +|N$LWfY@5tM|x`F(i^rFW1*!=BGY*cpq+?v?#aLSwAx304USrh6lOEM`2@%lbKlGEX`M(Y(gZb=S4l6 +UMgP*%O-EKftR{RBK29I`W#Qbk+F<8g!B)kchLMY?y+$k!7U&O?ilp>Dr^fkIypSDqLzQKh$gT$0X8A +}TyQH1Er*W$|IH=ETcsn3N~#Sf6VXB!sg9c&d2G6{oo=Av!`zm-J3Y8%->7>osm)uS3c5Y)Nd_0S}j* +wecHK!lKon-<IUqm(J(71N3+3jK*50|Dkm$CV&0iec{XOtZ%-pFDI=G}82b^Uma?WWN^+(qtC +{9m_X#0d%0?a3E1)C0rv(VDRx>Y!K_*17BEgo{!E*40-ZHcSK8LtX&oSy=1yFnJQlRBB4`5291lY}*-S*!9g%#2K_^p +e7U?)EVAFtQOcGpyT2#jCQRJTlU7?)B5hgLCQ9_PviOB)AdjkKQz&}wGZKgA)ErN4-dEHk*Ac5v~ +?3sO_O1fK?dafAO%4xVrM>TX#D(1yu3tl){*-`bKV07nAL@Q`GX=vsv_kg=x9G8gT1qq^0f|sG8V9!> +IVcDXA4-oX7-f4agXvt+J%;_O|D4)aBZqv~Zdob>-VHDBpleAm*Y{Z`n-1pyv`B5ae_Tt=PVvsxhQIy +@GG1@Vxkap{myrR%N7UK+P2igq46=y~46{i<&1WxmMbP@_NC*6XP70@$a)7s-}er?>I)p;)` +Q+1wAOXYmo^va5efCOp`qUI&~VWGOx0}LUfT1)UP!#|sFx;vB7JMmEm?+l7?+{1!3a6QX9zD;BuYB_h +IDuCh#+h38AO;?3W)OwV$YYu-@%~F_f`!#K6h_7c4u=McryIn +;h8K3*EnU3NrBBIz=m;*Ggt7R0Dp*`;&|x~>VZAben%fMEer!Z9Nlg`c!Jc4cm4Z*nhkWpQ +<7b98eraA9L>VP|D?FLiQkY-wUMFJ@_MWpHnEbS`jtl~qx1(=ZTz&#yQQO-)d1goY3*+RMa{`Y{%Ec_0}TVRsv-;_7ecLwaq;;#=he`J1>{pT`6|SIM +Yi)5^=vGzSY|?C=06ixsC*l8fYXIwl8*Z&oH*zzxlusfUY$PwSM&)3o4b-AWr?s?fFCrVoGw52Qx~8N +VTjN9I;pr|zMN3`$#?slet8b6cf^gg+=sPN}L$D-RzO{{Sgas+A1HFRub_#bHxR&@@;HrX3P~2&F^&m +^A;5siQ)i=-ownj=(oW<6%-Ja$#O;1D+XKIOcT$LEPPD6&sIDlvZG&$z0qrZA6Dj-l=9AiChfCP*0Z8 +!j-K7PT9Od95wG9;UB@e|9jkM`pzsRM;3SX<*fS4sY4})x4N`AC;9f`x1;P!gAn>ZIb_f)O_vo(7$9gDqwV|aDKNe}$i)6@0diOKfG94`Ehl~B#KKakm?M +blkIZ2CjGMk;+pXR5Uz$v7C?5r1=f4VPE>fN&F7h*Dls-kpjx`t?Mnq`AanEZK1i}@ePBWupvrbOKBE +w>oJIujrnz$>_*FXufsq>5744R@jtQn=02q5TbV_~4dq)8Jl`BZY-zPps3O-gVHUU7du6M&n_-XS2r} +UTWp&3moXi2274ztB>0|dun~8A<$?!gxoji?zn6*&8DO9$v;p_0|XQR000O8@1eFvTdH&$HVXg%z9aw +uGynhqaA|NaUv_0~WN&gWa%FLKWpi|MFK}UFYhh<)b1!vrY;0*_GcRy&Z)|O0ZeeF-axQRrtr}}@+c@ +&Oe+7}EkX$J0BgO5)fD80;>9)8wEt2dV4%tGcW!mOOmUJSO#8>Qp-x)qcQj*hcul^8ABxgA9m&12;)k +soQn+-2FlZkBhGeRDbPkXtoN^&wG@L4z2jP27fq$~)J`?$t +?U*^LS@Vf|U*!}R{zZ$HDP|M$f!<#*kezxpkPZ89%Y<}1sn-t-1iKREOe=Yjf`;g5`Ai_`@Q#G<9mh(5p(nzppoq?FQ^bqIF(80`>&Rj8&x@Cf~y&YvL>`>5gUDbTYZTe4qXE>_7khc=3-*I2%Vd42a|fLy~g_st8^{nnJzM4B +z2dQR06hA&TslH3BG!;D(7}ka*IGLnTbLl^z`(sqfcCQQZl$t{Os{C6^5au^TN4a<>I?2rQNYw4}_F+ +%Q%HgSeXCkZP^afGn602qjHj-&H-w`2_<9HNjF$th@yEE!;9WW_~J +o0XyhRtrXj?C> +I@)s(zJ)zpmOBlaymo^1P&KNAnj4}@pR*qJd89Ce83;;3S#)WE%SLncgqze^^DYMUchoZo%#}kTUlc` +^8^3^zimoIV{rQ369eR>Ozvx@pKfVkmX;nKEg1+2P3*+=2vZ26e?tpM%HU27J8me4XIkzdNJyZHgY&t +}*C$LtdX$yyPD#p;rjrS1suD6$S=FP-23!1`YConBGVeP7?K|p{qSr(GbLfE3mANH#?s~Q5g6x#h5O} +h|g66V?@U^#51Eb_1s%`-z-qO0*x!jW(Vw){IGqOo^p-2EXs%eQ>cE(o8JBfF5&?_SBkO3V_Mk+{74P +UKTsWL&{3R&&=|5P=Rj!MYnX*AODlzpwgK6el|ceL5y`2%jz9pr0bv;N#B{J_w^h6$GHy=PeXLAJp4c +uD;9J{vfY#tjZw$2WJ0iX_uX-^?uYvC}-p4h`%1k+$%j5BX9&+tqRp%54Y;9P$X{RjqbZ;)+9-lxP+^ +mF6(NpsV&R>yE=_S%LAb*9gGN<8{F|Tj^O7hGS$4BRtI!;8*a=zwll^%K4+11MC0Zd+t*7I73QFHwTyCI=i4a +YV_{`_nj`Z^TBSPYMZP)C5O$UNgHs{AHo?Gfq#r5fTfw2)QBlv;LF=39vKTu7`RtJ*8xG@8J)ao+^%& +_L1vO0`sTpFrf;au>!6u03%WAiNMT>CyCo-eAs9)nAVg^lW5%#RPaYgnvko2Wj)t)`+xyD96gRW#hAn +$fH5)u$zJ@8!v^Y1Fm?2xWoqLr9&T8JxhOR-WTw1$SEZa5TQ-)&=n1}?~fLsL6(`OWr#cZ^gs- +(?T@xw*TJuo{ElE^w%Uz!Am;T^{?#tWrj{Ap%CGrHNFcg4)UNhAj$v=CftNECh*82P)N`LB)dDumVs< +U>U$_?+DY?Q7;=Z=vzv`OxtAbEe`Bl8Mf>1fsb!QV%t*C4!7t$ht*Qb3X_uoO=r%?gGG-CB^#XfN>P* +Z2S@tUssLfJIzk?i%eGdTvS9@P-ZJv*#d|%zu{d$A^&sVD%ozs(qB}74Z@YMNN`88A@;o7zrYred`Z9 +g#v(vFIB$cf|EuK6(3HdR-4^;Em^9Px!;S4KzDB3X>M`k4&NQ?_R7m3Z8L{A*21JN0jYByC*1YM7V>O +!J@@HoaH^8s|`Ddi=!Ydh#f<6fZEVwl^9gs2ogM|1NmQ_rJ=scd+o5~;pQ)qxpA0!!&gHG)U}n(b(J* +W&%`7&;sd?2AJIksJ75SMkw>GdA*AkmFbI_lP_uhm2}G`SrbU0M~h1*_Pgd)_%wM +U+^23%>7)hTOyr){4pZrho)*bdVr^kwlyztOo_KAx(iSnrytMH&rYwbeWMquxwCT0aI~mL-N3NZA!aT +(Xj7Yxj=CSmUTh40Fcy6cU7~VKGt~tTLE`M_Q)N2a*#M`~lvEmBO5T-_!8`*3Qjh`NCt^*sWQa~dsB)7%NGOXmM2W-~V7)Udtz=JW85lLzk*4`0%}{3^5r6+_u{Xb3w>; +z@4=J2G(XO#i{z>u{7AnEb;7T0dKOnZmnySh)5QM|T#})MFF}{CUhH3~Jq8Y8x`QqAIh$Jco5~VKZmV +*Hwt!$w4Z#dT4t2z-#V%O}&N~Ywd%()hS3ebwN>hSZwwhd|g!%A0N7Ztn0Q!*KguznvmauE249tTja-91oDigoXRYizh#M{dIh14KP$w%EJ`*?K_xa9^rqJac@U=U%T@CW%Xk +-jaOk?6_OCz0nIC6kaH2R&-4*MktGRzl;jcU(trZLetneaJ!e;)AAby@EzO9{h@CjKZG#5n~TK>%gQC +Urxsd8c8=$=#LT72fKQo+5LcT<4lOm%)xE#71nxhOmzxn8;hV +KR8=jPtl0OkpxGiUTuZb*2~|HGkXr^>?6>Qd$q{(>B3k?jWIntWOD7q|p5kq +cBhfvkY+K^)vOwHkG{I6B__b8D?fsBPLN-4AGd_KQE^-I^d6ay<#b9``?PUNg$_gqD^_0m4a(a7w-R` +OA#DCm-}*`q+oN&1{Uh~gd+ndh)EH2P5lW@FA!HAxfNs%i4j(_fgE85f?EKf+JcRSJ +leZzfJ$rXHKbu6~Y_UG6i6NzK83;k+rQ&&XDM=2on&1UnOg7vkJacg8RJBe_8b%P3Af24mW^V9P +K;(L*uS6Q(Id`LU)2|;Msh%AFl$_J=RlFx=?St?m7!8C8ZN0Kp3o+mGYEO?_5TgpccdLw;!pr?_qCDu +{eiF#28Em$VLa0RG4!&6*UQ>TYnfi-8TSp;{T+XW&miX^L3jA@lF}G-xnW5YD_)}oRB?uwF7@`|R5#6t@=NDJ+Z-TqY$R))J77Kw|E*9g8XRELgW +%eG;Hffcjmr*0;%nOWe`}*9{a=770HQ<4(Ay8-;qJ0*j=ioKoLB-iz)p)2y$)&7|l&S53^T)>zo5>X5 +H#k{VTCqg?Es6<@hxbxnG?2&B@zJTnLjI&(()4i^SzF9@D0wts*}IO=qe6k)6cBqLZICoN>R8?d!#-= +-Jl$t6)Xx!Jke*(a2Jh**#E3>P?j +blw9H{_`d7qVSXMSFehtT}4}t1e5f#*@|wV%6+HOPTcD0~ym^EGw>SmwxZZ9*s36dYePG=W9>#Zvx +gh-fI(-VT|rzxHt)kcd?7N&EU`sQ_;aGDt5xAgz;_?>uOc9Z6;Z|zYt>K(p2neP>A4)y0i^85BsHwd_ +1;18>;?9faI~2Go|Xy)9XDgbkOJ8TI|yI-o8GYo}?*-rc{wJO!te1!BR-wuh2n-K4O(D*fQI;%^X{CH +{(!ejrGB{p<3irlBJB`91GGTSElpM*%p>a=ArR-OGw-o$kP``tM%1Mt=Ap#Z?HCD1*ciem0*^2qt18M +RQwcGT3HTqj-x$;H0;z>SArQjl#pRhX=LGCFw3X_|f!{(T8u=p +llj`#mqqc849raSuO;I!WI>^*uC1o&$V98W4%;R8%nMoqzmN9Lm=SV+kYR;YW%_!?$1(Q8A&=Z-bfqX +hN4BWLFCRqDeI-cyKLJFrHGG7dtr6@cZx8|vQueb#w$I<=G=aS#=mAjDS7{{`wZTrTWcE@thJJ^AK#J +n}LqVazSrTI+It`IpGlXF)>VWRXRtecc3CMI3S!?LFKl)f$CG+@DFX)sRYB6(;(L?ET5lA8)EKquC5x +Zt+M#X1(pu0&vv(`Z-K1OYrX$OgfwHNopSx*~AZ#EiL~8YVantZJi##+~>xVJ>G=jy}Q|biH`GMU}C6 +RhafNho+pk9P;$+$BzyyqM9Xr7ids^XZ9!1=etDP>^H=lro5e0X$tL@mtmRfCjG%KpqVjIT&jxwcAy< +ayOU|_2OQ=U!wN}B8o0L@c3+>LdmZw=P6L+%vPD3^*w)(VAfoL!N!~Lb0x9uqIlPw|42Ibc8%so2xD7 +0?+rU8ctzmJC$wuar1zF8ZAY1xg5e1Xcu1vdiZYU2?44WFVFo-rg{E^YMPNDbfZ0M&+kH@ghKFD>@po +K4~e|?=B7k;wdxI?n^a9~g4<2&Q=UTRHy(mfA@q;neQC^QZqyM@VMZ?j?0MVg5Ce)rkXnT-AeP)h>@6 +aWAK2mtS)wnjq&8Ttmv+*O1d*VGnj&=|Xhr?&@4W| +r1V~7Bdbv*cgDsKZ!~4SfmR5)P8G}o1ca_p?qxCLH3n@y?cuijmxjGX+rDCVq9WA<5s#1fuaGCx3cki +>T&T>_4SzV=1Lc15V+={B9EgtB>qq%Wr7AK3eDhiQmS(UYW=bOjJPu~ch3H4s4+AcJR`O7AR*e6x#3V +;x_m+utavTVy%}4{l +B)wfo3T%Sxw2r=sw@pXJ~_7z`x*NhU_3nhi4d~yG+GvkvZ%S&WWC6Di?pa}K=SM?EqGl6d3nLLFjT5Z +wfY9L@#X^=+FBX$p6#3N14ln$gEOM!8z0m5wuGyn%MDKCNHHRl2Ws_-d3G4_fQ0_?vNNjh +2b`3XSp@+j-Xs)%gXv|p2x57h43EilY*;SJkvR&9g>b9_e5JL};%vo7!y4&6KcEAT`{nb5IL|<%C@~E +89=4UaUeSU4Wa*zH2ux_P2fW%?ZoxkI9{J@J^MAjUY)H&Vz_T8Ts-+z7g_%IFL9bn$az9$mHfDlFw`c +o7UIDwXZSCyjG>p%Wo?*37wK1%4@FWKj;PwcN%OJA=kXJ>>y;I+ss%eL^>ZU~#EQLzU7GHyT-E)=I=SU9Ma#aYXE9X(h;U;Va +K0|K=YpvpPxvH|matU^k;1v}(h>Y~Uk +k89MP{QCG}EaWD0TKz%ys4H)%W!v;VH1Edw0NkDuK44*G$wIoRJr76HAARZ|%8K9B^JwU7yz}yV|2nV +`&#u2{Jb|wwJ$TjhkW>pSfxh8dA8Q_9v}4+i|?Dg{oOzDS*G>&$4P1sT!&aI(C3+`J4FMwM +T1CFmN$4b3uETy3?1toSeig5CqVRf&ji01yW_-2D-8a9V3zeF0vsPm;@UcIi1)C&Y9Tmbd7pp7PERMQ +klz?*|*Mtn^gw;jEy%&sRN5KSg2colR`cTtNtX1ab`4oJZeyPqxgcF2|Ig!6Y5^J*nK7w>XyC)MC@E|MF3B=28ekJj$e~2~kcm~ +ZX1hl1AbzM5b_efv0Aab>OF*hAk<_F;$MoUm<9Cm@-#sqg-`;$De|!G`*7XO&%vs0DA8G0R?fbj?+nd +M5!{fWh|9ZHkwO1E!XYA_Y68~J`pWou2-~D*RpwCF5uEzk~3i29#!wip_ZtClc8GDACpicM^4o(f9Xv +M(6P{5XIT-Vd;YolSI3YwckCm|evKCm@s5Bf7{=||r>qWKGh+DTyfrWjA7KN{1k +rzVXZqr`yX7~xK&4=)zWidRppTft6?eNrm=mSQs6JY!hJ`7n7i^3a&c*-~*7a)WW$?`;>UZ9bN^%sF`2?w+qo{;h0j7^TD2h*6a9WD5;&jZvmc!d9YPrU5n+S9=R!40n|U@=IIk%(~ +=1L9e@{~PvBfvG|Zh_;+ulF5_KYkfd>1&&Gavd%$7&J=$YB57Y3gr?oYMImzCmlp(L01%bPQ|$zzoXO +bj*cpGIYdlSgYENNGhyDAi9HZMy!4V?zI{|VAuMcRa=zftX4z9b_Btng*I+Jw@4jmuKPIui_cwQ#(g_ +L|ZnUZxyMA2gt%1I5TTTe!_(RAv|VPqLG!lf;^h#)$KQBLNO^F6R1q85mwiUZ4twmmnN-`Y3l7rT(B% +Oh(iyCj+dxowdVJ!?t#x?Bl$boeal%o>&qk9)u;`Okpnj%BRbgwZR +=P8ULzv`GaH?eFzM`r5Hp?ksYW3zhX1;ASamAqTjGmUsr9D=(&^Fn4Vm;{1LRA3BA^F9E}zyOZ_BApE +LW*I|(Hcg_efLDBLE^V$b@WjUx(BN!2tj1nuYZsg2+X@X-1Z+Qvb0DiAwI=gbDeq2asbW~g%pd%1bhn +icqF<5-Y@*33@!=m_$lv8@5aRU_f5Sdt^o+?#)g>n;>K9xU66{=~3W&|F*hTWMBv*Ss8HgluP=a(Ww6 +*P9`R@2TbgWXIZo;6&J4;#=#i^t7afSASOheghS3nOKL-KDB9u@^g(BSdu`5sh|LHd((m9TF)m>ij-p +~on-v(vDUZ>y%HEX5fNgEIhI9UvbPdNW@x{a}^|F$zz6x8OKzNygEH@+}$@k*sITrM@DY#!o}Q-@tKu +(Iy3(E>}KfWrRL&c7#J4hoCE!kc|q`ae8dwF%?!F#ZJeU)6ccP;cq3q9sB2ia2GVYVvhs0E*aC&(nP{f(Td>E{PA*U*J=L7}1#)33*vHC_ +p&AFj_>UNrT_0Xrf@Q@tP|Qckzys6L21Il2lVNvuy9Xl9{-7#HiHBqsA7Vgxy$dszFjRj**xi&enM-A +7xv?&^V4EFkon{@#P8O{DKbM_lZez2S~8p6oAL<7{N`%)((_L~7cG +bW~i;S3bPD+0Y%BC94pC5)f~9#t0i}n7Y=!Vm!+v8X4Z@8eMH^juo^3HL&5x+vPGqZn;dn5X_WFfVhz9-&A|HZPJaYZi&` ++0Mdw9f`uSk?-7}yp3F||iZ!7KMamltb2UW9qQ=;G%b&o^3e-h_NeCh>c--5~;PBwyIk>)_)3rPr&~d +D6g;!g;qRNr2UwQhBTTztU)~eu60AYA6ZT3GzB;fcdJZk)NOeW>kUgEC~3O;*d8{ju{r}5eJgNz`OeBJy0lM8(42JFunOj`;ABL5VkdC +|D&lBa-u%loyJ%BlYU3bFJ{4T&mD--W8ugrg-K^IKS3s-rq?oQj5`}I!dxITbXAfN>L)m;;8FWE3?nE +Akb7BWPkp@Txht}2)_GkyJlla0P23VLlb#Ve9FOY3mkx0m@3!r!wki9d_5}Pt&&VLSVK^9^7 +h|m?DFF6C7U2p^Dn+wHS0Pt@RCZczmRp^h__!}{`>EyfWQfmrV)a61!BE4#$}8N!CYcEUZdf{VnWY8^ +g)8@QCobmWhMd#DAfAEO^(aDRXSRC-08(7n +g6a=VV6+f{tSz_LL1^Sl3X%rBu_$3R +EDgJ;(BvuX?Q(HnfsHjHQVkt10FQp0^yLWmo;6ysG^;a=7N~KnY3TNs}Ev94AMM;&X350M);d4y?o{w +5wI<@93qPg8*_o$@M?Qcy@&`@ttq=5bwP6gFAOD3{){Gh#|7iO#w*hk{em4py^4|-AU@l~LWQG!v&HJ +HS7_Wv%uU|Qy=_>4(23S6_h5+iq@OWaeVE{e26gHz$?}lfE=I@Wq&9Hu +Slvlc}+eWLIH(35%6_b*&=K>>Oxe!HFCca2pn%$uMW!wiOLPz6cFJ2KCH3ls1q(7KgB24SoWB28J +T09n@9hXq%+-{fIlJJ_lD^M@$1~B`(C`mkVWnMTu5S!`zv$U6K$RR5kGUqAiJ`uoiYHhLZzb?zKXO2j +(C}krB|Y2sDUy_Z!S`$eDQ4ffHw*B4B-6lK-%FLtm*Nh^0Heh$Sjw`*#m{el^8p^_P_yoQ-^sOZFh;rgjgzbG?2NM094}x&lQibv$(0d}J-I$S>H +S(MJ~IM-6PX#5g#;gC?1~wDJ32XK`^=W({kBh}A9^-?%^M6wgPHTD7=$IqI;+7;Q%905NiLTh`fKV=VNpgD-l&Ot9nOr|qCarbYtvaGUIgYM%(2OtqV}T?x{FFr +I8vXY&Od>3Evui;9m+0jr)Dw=EE3R!$uSisU0!VWAq5ysU*f^YtRB6

cIXnnOGvZNc=M>H&5PbvU* +N-%Ws>MH)EWHR7sjAXo4S1}#sO+<~tfdBMMFlALBTDtp_9jOYcycuB{CZj5WZ;LPoC27qE=V^vI{?0* +`ma6A(X3=a0%ppDLT$p`WT`7RN%h|zBl)nO*O3dfJ|7OtD(DELK`RTn3;W%a|nh43Tng& +$%t+C^R`x7k4?C>Czkt6b}Wz~8VB_#1{9)-NES&*i#-$O(TbWY%Ls#LfItJE`TpY~I2jK-f&Ftu>jS9 +}Q!;>S*6{nGnz8V;0Yf>7YqF9)6A|Hcu5 ++u`p)-mtsU%q6*TuAMD&v>h!7G*^}C72Y~m5^eoDuNqcX2t8lW8xT!l1>L3d1Lr7gZqy(7JJot{FSOi +W)I1l9wt4FDZWv +%-4EOBcImbOu^M!UC;(0v)_J2k6pTy}`5s8Tib})d@|Lg-i4e4hq;y;u2HhA`t4t-Huo_NLR!KXZY;7J{z`LZUf3FKgZ0}91uEljZr{Bh_kElh>t50CR%~Fk?xahh +0=`Fal&E{Iu9eFTHmD#ht&C*qYAZI?p2R>uQKp}TQ9Vb=XKedeFUTyOUqz1hkf^9r?KSRA9S?OkmdC} +yrx0Ews2K)%c&&h0q3;XLS>V72*4tF|f<6YVe4%)FGW*9XXnXkctVUdMtBUtcb8c>@4YO9KQH000080Pmr;MhK&u +&zA)N0Gkm20672v0B~t=FJE?LZe(wAFLGsZb!BsOb1!gVV{2h&Wpgiea%^mAVlyveZ*FvQX<{#KbZl* +KZ*OcaaCyyFQE%He5PtWs;8FyVI#sdP^~HcN1euoxOVgrp(FZ3GWa(_PkwuN9qGrSX`|e1|k}RhI(qW +ihERn~Lci-K8q>qk{MpyI8cPuXT26D}lSo3_%3L!F|B_h|7FG~$6TRt$5{4RkMq|!3ZN23d+N?757%cR&mqxVXh%@Eb(G*rJig?a-6uAnrmCs5A(q~2Gn@thhXD?&9R`~PsuA;Zv-LA{@)aHz%+YGBFMH) +YSykzJOI*)ZD(QSN8ONE$;1rMn&4m{sw^;>!_-mjXDct*5w_1ui-2}P!$;UK)1Q`cWdaS2C%xdKB9@qZI}<3Za +P2xbH;&IHdwU?qF>(=hmMzA&L0M1)d$yh3YRk!O-vZeRk+M!{;5wPRbYMVlFJ66ZaVaGe9_HhqwYpWyJ2&MgA0eIeMhp~Z}L=|cN>+k +)+h0~Usb4#82J3#U3G~@T+?2M6-$Sxp@Q`|yG{-=?Ju8}G_R#jEK>L>^}twR(5n(T>^OHqWKct`~8H@ +$TNdcm$CPgxFYp}7^OEhrVQVGv&HIR)qTcy&xl4BtkDgG2&48qsicH9LPlzc`)GqIa|F>(ld@+if7vJ +Cy5>ws4xwr!{u{>Gk3d>MC=c^V!_#C(mbBA_srCkV-qW%kcmp!m$Rx?HO!RqCe${cJYhsY8dx1r!5Lo +I@YCey7t?wx1&BGqsy@p`4cdE!CQ~My(EowZ1!CQL2z5IqTNz=G9G)q%zuQfxChhV5>_A~Pw-1vwKpA +(T#8!pHA`aZG1KNrCX`YB4w{9j-4M$!Sc%N7fK@Tx4G{GXo1p`3RHDaruqu#kN>{%;&9S34qRi5IgOp +WVZ}5~#HgT3gzJ@{3Qu^y^jqc;DG}*QUE;`+H+o-e89PjbPjbDucok5BYvEeq;USIGPQ;X>vY?!d_5o +bCOq(j@O#hYoX?g%q9!h?~V>f_0nBmFaT=OQ6+KIQPWum?3(h3uDBU0DYtvVGhRUH%~oy`h}!U3d1AV +{>}eBoBMEmLK>ni`SH?o1RNXQSiu9wV<56J-xh~U7fdrGGJ#fnOj9Sy@4{Fewx3XUCl4fy5h9&-8b3! +=CeDtzZb(^6TTM(?}X1s=%>hg;&kYq2TcP0pECd7$@k%NpBXu68tdat6W6qOBoLL24fWvZ@NZmSP0&yM#cF665b$gTs=eH?^=zPq(q{wgC&3&215ir?1QY-O00;o@p|(asQ +89&e3;+ObBme+90001RX>c!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D?FLiQkY-wUMFJo_RbaH88FK~Hp +aAj_Db8Iefd9_(>bKAHP{?1>4j^{>{PiEqz?M&6`gU^vC>e!NMImukp3{8=cgfm6(0MNF2bN%hz1way +fk(1tBHTFm(7rTqyXWziVV6a+UlP9KjWHq0KXR^q1E)>~tL6!%#;~9AqkSm_1{E4U?m6WhdDpACW@k| +o7AqQTNCtjq9m$C;+6eo{Vu+4!W=a>q`HY|=51>(%%Ip>OwkR?gzCMr@zQnnV6U_h8~?=<7;6n?lINW +7!*1IxC5)j~5$6BGwTQIarJC`v&U@t~E6QkK9Xub~306OyKz!1L~QOllrdYq8OL1m+}<;)iIf^_410Q +<{uD@08?+MNTu^ln*a}?tsIA#!*%4@vrrvl{Wbyd^KZQuaD{q6CXG*YjPzeZ +F_7ja&$TG!4OLb2+g73A7OFzdvq28JTny7Z!nr;CE`v^sm_jh+oBIwTr*g^(G`vdpC21xJ>fkq;7e=n +J$aUm7ovwze3dvDK^A_eFGLL)_@>_9l!M-avKl+?1|X`ZLJJHUkzEJ-0z@cn(M@%_kx7G#gDL6ta+^$ ++~8y$*+?cBlydCrkN5y^cP|G*@J%WlV+Oq86M-QhMGTqV8Z}Q9$gCVe{ikdlE?#2wd#JYX=jCBd|$Am +;&ekB+7t>==Pp=G}Bl@qcZ{cGq#i@60}A;#Kwie2pS7bW9dkgN=|l>37DLNXV@bpk|mVT%?5T!_=Y4* +M(Y%pLae;HyIy$!*j!L4(GgA#AikuO++W_#Zl>T$1z~p|4ng|NCY1<)3y};a-LP#TXe(PtEzWKbHWRZ +PaUcr-j2xAA^CVSzVdeE6AHADiU3|E{3qj-Xa<+Uwy$!EttGoMqNF##5b||QIV~p_8-jUu}>*IN2ASX +wdjRE1bM{R4RrurZ*2uLV1HYPfb$FE+|EO=rMET;*J0xq_%@aoly3dpzNJlfN6mL(SOdUY%?B#dRh#z +uP~1dqgpVCoRk=RD<1L0TFN2A)?1g${AZE`gI>0x)5iQ_w@mLp39Apw<>L141 +zyGar!Y!Yn8A)J9&i)jb&)FEC*uBxNYdtA&xX_Lkg4cdhZ7P~qqm3{#E%ndK83wm_BOEx@b77*Ou7s( +eZ@fnUa^F5$?+2S!dGZ78*9`duhcFw_BcZPLdA?A0T@Eb;|IW`r3p7IrCe`hq;nWARH+vxnDQr0fx9UCge-*%c_J*M=xUoApQ@g}oxSb<(L4w|TzuJdX>u4Ur(MF{kP6r6H)}CPY3@BFaM>mlG$ +bg4RRe5A}!imUQEu!41zI=-~{&8t*D7>n^SW^Vu2_vdR2q!yODv^Ko1>=+#z6_Z`mGfTY}{(X%hKD@8 +wK&^YfMZLwsp55)FY55iV_G#Vm8R&mX+P^f|xw&Gb#7n`7Z^ga1k70h)V3qE4vT>;T$b0`u)#4x?j*rTf8N3=uqO_-a`13f*H`%*>VFG +={|plX^IU*zj@5i1en7UMspcQ6xZG9BNdgG}A1Hy*!|k%W!(1Xid>_m*u@54of|M0U|WZVP`q$UU9&s +2AUcG$$Zu0`4@G^PZZIGtE6PvP}vK_t68zCOZ^#19M@R2%du>a7u<-FjnIQq-;#C2D-YX-9iqHw$v896x(lj0=X +(b5tM=rR+`D#dD{RjExw6Mt|CT-sYnpvBTllF8I-)Qp>@)9Pg_HgQi>~ZHIULo{A1er{T +e+KmydN`QVK^cJUba6H4Ng~!*Ye1@do2HWX5aW>ilK%gsg5PS6U)zFXB~zCQmGGwwLJgF6S>8@Br?Zd +Kcj4;&hr4%+PxJrx9zI2xx`ny5b>ODgCL{6$|6tCEowx(@<#*(KcJTgX1WkqcccTC{ZU=hEhkbQLBuD +fw4+8wboj$IEDH{epVcJl92G@le48O%5PIP_+ubuT}@&@$R5hUwfnK-gnFJ}a2RY~upP6_2Cggyu+06 +hA&j8U$`^=StIPcWXFT6Utft%5tQVBOMuo2KiB$tS@Yv$y*R0V;Ty2L+`A77d0DKEAzqA>`E~&GoetGH7FYM~4Ieb99UXc +Xl<{bjA7p0N-u#OgE<^%`hlOKa8 +tka5*22hE36}%g%H|K6eET-pyAaK%XCW;{iKB{RsQ??&xXu=`Q$EUH$4LHPc(R@O!kosn_ZL^f$uZU` +z+jZ$r2qx9zE7i0=aNtjdqGXX6g2jY5POH{S^)&E3d)I>Z^us%(94XtCnIwwzmsK|X$s$OAo~9+NpFi +IF}JX` +e!*jFJ5;nG@eSqU*^NhK{3#z=uj^8?={#>zuV%Wx4Eyw!tg;pHJq&!MW9w|4ko1|YZ9ue)ymwLcs-K( +jTxIv&YuZae0Xuc}F$ai8uz9Y3LE2kM^r77&Y%2HJrXLqv9@F(P*eo+b?4Zi$yUXdzJ_H4@(o(H-wM~ +Tm*grs!xw#+|^C7zmJE^d~$)75IWnB%zi{N^=$JXa5%8w+*lD_vIf_#4&ojik%bJPC1$f8?Cr@`lvW4 +JBIwePCy%<6%jwxht^dv(oWvQf@1to7A?XhEkaViqHCb#V(Y9LBhiwOjdFSxzK+RGhdk-!rn#@_vTIq +aQVB81&068QJ`~#^E<>qWu`%edi<bYEXCaCu +8B%Fk7Zk54NtDJ@Ekk5|adEyyn_QAkWG&d(_=NsWi_xwz6m>hxgJ#l<=Cxrrso8SxqU#U*)(xv5-S08 +mQ<1QY-O00;o@p|(aw!KP>M3IG7-A^-qB0001RX>c!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D?FLiQkY +-wUMFK}UFYhh<)b1!dlWMy(?WM5=yV{|TXd9_+?Z`(K${+?e!G$?E@6esE3w%FjjxZQ1v3wF0D+Fo%7 +BQR)*wt1FBEh*XcE%v|P%#f6*x3pQ{@*$DP;c(vg%nX%t_9Kt?h0-Nc8+NY~p+)jq#^rRz;*=Z1${jD +6u5!av&fcBM9sGGQ|7!%lzQtcJ@z*QH^MnaJis2ne;%vsQj1s?!d!m)>gCJt{&IO%>eI~`gP)C788Fj=gRB{uXDiB;OhjHXZrG}RI}@K{Q +IzbCsBX1ZI$)7hS$0}|9iz_fE542uSjMgTS)9x#DUK2Q#M4T+=ets5^f)R;0lqjpJF~tF{hPqAnWdTF +fK)lxC+BXFiEJ&j0Y@33agHfmJ0bdW_CpRcJE6g!2}4dSGC;m}xFYYmXiMW&*?72~zVlG^Yfn# +_k&?h*r#kNYhCTYns67^{*R0^H*lo^q3=BpLx-w>bL=166}M^iG+5>>6!6ODi^QfXRh#Zt$1+a4K%sM +Vz*V~8B2KFV?j3=M>i%tgxJAY||yvg^*VTpZw#fGrJ6U<}KU|T`GtoG!?h90d#=pwjdCOy0~F%`R@Jgr-;41{ny8c{e1iH2WPxQY{0wVx^lIeqUj>`4cA)(f4s}W@*35IpKFDp(%L-g5P1lPxt08YjY+aS;q9gEy7}!>5A{!04!ZQE}0Yiy +MYCdZb^U6@PNZmafC;-=MS!$H*EYzcZmSm_YYCL1#v+G7%5|c|{{_#`@I>6J3_*{q>y#!}6Q()-pM$m +|DLCWXJggtL~&T4)&nD`$Tr&_799(SPeLs@DG)(`=13@l>{=Kd@n*wD{;6LC4fZCf{3xx9J6#rPO8`} +?iR#lz5sc%ByQ_dm`$<2E}?+d&h?mhpJv!V5ecSwM=&|DIrhFY|yt3_X>EGgBF{(~SLXvG|^;WGNpOr +^cn{?1N25a2RrNWVnRI0Qi*JXo$|uaVOyjZ557|6sZtfcycK9(LoP*;<2*GSN71;K@5bOHAZ5w010t7 +Q23Jc1?-o49>yL_QEUSgp>b|{9s-jO#R>jE0`U>Byn5(OEw3M%*@g|caS6MU-;vDw9mi@Op<8-hYdIH +CtM6P|?qva8y4QBFoJG9J%mnujrd4j&Ec4UH}IK!TVZVzL@5CLMmk3Yo|Y!y26H(kEp-5Itxw +i*l#$#bN)Px_0K$n_7=uX)xSA?q*IAF&Yuf}kVj +W%6w*VfJqjOTv0dCG2AK#`bnKib5Bo5azlF +L1&#hhI`LXQCHqnJT#Jg(64U)6*@0>k=t5j+(oRGoE6U +Sk_B9dj#A|aW+#E?R9$y^RjLtV1s2?dEq^ctT3^6Xq^}t4mdtQ+1e#DMpW^28brX{F_W#Sr~Wjq_5JX ++7$48O2Ji6B0Z0$gM@vE&<=iwnv%8|W|9G3=reMea{TLB&b#st@1lKs?1%YhPS6!H-?e5U9{NMY``1s +2_r0Rmr3)Ba(Dal>?0d)*enm=5}m^{SukjLIhC?&Fw%cfJXwlq3!HMYq#D39o^Yd*89&M7eJ3$vz{X{ +peVrs4viR72Y2!Dh6O9Nh@Rd&(MCI_Ch?LAevtuqB4zijH&*-rhki4Xp||F6IVwqq_%b91u}yeA9^LIK +A=bFXZ?&-Svwvbl1*xGgk7w?aHXfegWy+NJ?%go3vPTedZyYyf>>N!sa=Obv&CLviQ#nP8MpzOa)&3Qym#TS_? +24w}AF6`Q8VSs(`0=b=~Vwz<%>zcGPP_kgzx0x#p&bSVtMg;1&`6z+}!uM;p1)*2!N%L9L7=UHZ4@5# +Sv{U3qf3RvsB3}cWLd19>nUHsEaZITUAwO0c!nja*g3^(;^AP{Yp| +)?@s47R~!}q3O-q@29S(hBc(v}GEG$!LEa*)0|$5Xdk0I>#2M`oOIc73>&Gay~N`ce=L`Dk@MR +0TRlji-z#-Pn-BFpG6kaj>BA7>sWP3`7aEGSFBkcWMKW;;kw{NE~!o4Av0*>m!1zRqgQtzQ%7zSAi64Z*yFoaU=>e6|vic{d=dNGl-KAm=;x#nll&R$crBBiDnjE +s)KBQ~{#7ldBDuy@|a)&$odh@`fAdpx +E}0GCik!B^^y-uptHF1RvZUD2-%x(YJ{lj{!nwm4B{FV@mmFz9e$={Q+rqIV1qu^kpv^qpWv-pYPvyS +Pq*BW>rzkD;a-}0_K1D1R_zCPMl@(k|gYCKkMQ!nQ{~B|K{UmBcjuq{p+236-wpZ5 +Q$ueFPbl>e6;HNIfVmvGME4$!O%myPHYe)*1#R4C#+VC(4UdLa}aZEBC3~eqTabyp@4dXumE$>+0bDO` +vy|0%OC?zLz1qQ^Aj|U)bG}_x5l8IbleG!7kqm5Ztmn!3wmhCr15$5l)K#0Z>Z=1QY-O00;o@p|(cTS +RS!l4gdgbEdT&D0001RX>c!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D?FLiQkY-wUMFK}UFYhh<)b1!pg +crI{xtr}}@iatr0{ +d=RF*bhNL{t`(R`&jTD;ARm!$0w37vk)J!n55eT@o)|F;*gO@2sX2?5JY9%@83l57Y)#ZmO% +0a`>cv5`^$svwCuRwJw3?eOPX%ekwN{bjz>v*Uv{{M7aDxKpG6ws6vlPr5I|{E&Qf7k3OeV-qunfkw5 +{%t|@j{zaM#v-ptSH{hP>T#4%awE@kepnhfotnzqrnJNHDD_>lXH9uvTVJX#!@c>Hj~JEx-l@QaWE1I +Qh_CZgqhGHj*$b-j5W8=kC0INH9FNeH=$&9yGq6@ENyHc^Yu` +Z)ZhLGzyqSFLj(V&=W)Gv`Fa7J@HS@Y-=z9VC*q_`EKTH^4jJku#XEwZH-N9$}bANChu->PKQExnE!% +^#`fB$gT@4;YyaCP_Lx<7c&E`e|`oUpt8eSZR6Cqsr39j|_GjNI;fqpMr!b}##P{mJKm-Sj5|VA?vl8 +ID+&J#S6-v{ivd*6MJ`iG$!rheKfT07zK(YSJGL(2}d+U^0S +k0EUhxIqk>(xEHYQs6R%Z+>D06A6*I*fYKkJVuL}?vO#~d%CrCu_CJh!g*Ml{?j0~2qtRt#m{YmJ31< +odhZ~hyFk~0Z+siBL-P8^JWlj01qteBnJs^7mI0TfXJMElx-g=Cku#tF@6s +JF&Mt}NYF6L(tn=J@3Hc2-St#h`8xQ0~&X^#?4k@?O$t%uL&zz($RWb9=!SHHgf!Y(e@IhZwPfbvs|! +4DUAvIxlzBr<70;}R0yLZmqW`W6tykiYU_eA;m%o(&CKE;Kfk2~T&~=yYe$R|vT8ej4}x-g8>6__LP3 +iI#}9Xw+)TwXj3Y%K4}ri&e5{H|Xe-l6I;(R|uLwv%RPFCXx6)Y0w<)v4ZEM@H*xOUPG%6B!<*z%(K4 +tl|ON>ZS}|B3Hz&^5gu>(PBX~0nw_5kYoj|kR^bV-!S_$uyLasTw9VeIQ>$U&6w9=4{s5UwK^mLJ0<+ +?hL()V4sku)sV86S_`VYHMV>2}ELL_;IeexA0){@5fn~6CK!&pE_`jFe_H8B2CVIWa6r)my1>8^?kO# +DxNyPXe;=SZv#8$wjhA&K|WRHapt6L8QQa8PCNMHlV6$@2Q~hgb3X@w~>%`XOeYV8xL?_-q!!tJm8|F)$GyWx9n +Z$bc^_$aRSlN|;S-aIGPW5V|UU5`MeH8vJWWrJ#@#IKp;mg-q~W4}Tn&8rv*lsA`~oVbI}EO3rkiHK{ +7#3nyoF1T#v8W>Z(o9?o&KaL>53tFG)CS9AWC-bA+KQQN=~oJ{hs9 +nZVX?#=~&v&T{LQLl&2yT?6`SWVnf|HJG7DYN-7QlIHSK3xA&rq +K6suU|{A%l}>f-UDF;z|dA?!Y?9jWktKGF^v>0w6-FBigxr%@`_*qLr%Tqe|(1&(VS;3bpw#voc4I{G +lIGfVk4%<*jF0JjxiA6LsE;Nt*`RG^#P)HWyvQ%^b(+F>TMP1Hn96#!{=fU-OrwV63U@tpEx(Il&Ec! +6Xa2YCG^U+|wpzz47>c(}J*1-YzFSzd+{J`~nAURl{bDSRWu=#UYe^bSz~lRx$N=kX!PRPL6VrN#U8>$^G3!-Xrq$VK-UjV+j&6 +jVqR0NE78H?5J)hlZUZLpRBC?5#ph3w~5Eq`+k*RZ{Q^kV_0HwO={EFOMIdS89mxHTxzautBK&B8?hm +rzfq$JB^B$`ITM?WI9f%I!stSG>W>dAY94XxO1Kl(Jc1U^B##xXg6q8HU>yfLMvmu+1&bT#?XxN29Ag +Fbmx=)s_se9d>rY%iV^_gD%8;hH(9TZ#zJ3+FV+@UaCb!y0MvkM$s30@Z;hwfrQt4(qiov6EmCP&;*U +0B7nZ2MvtkP(ylw0%W@d`(-vXQ-Nr=(Yj^0n#XFS9`@afk-JG_NHAflrpgp=fLhlgb;_enytXoN@5|6N +0qaW(?@Da#3_GuS)##4eT;*D-P6MKG`)gao;&F&Aoso;q4({CfK^P)#7_#q~*C7P&3l`6%g4eUdZFlN +{Cn`AN?JsqUEz?m!D`fYKtgNTVm&Aqyl?ZO!Zi0L=Y=xo~l)Ypvq}hb|z4fT5Jg2xmI +3X)eg4y4#v=#R$2%tK7!q)JAug%9K)Z*uHlR<wOuBO;AhvQsf`QxlCN|o_vtGdf%gslzBRD?2V)%*28wxDXwn`wJCxTGJE +1eTpO_3{VHdz87Y&IH_cMe%n8E7&kYd4xx^bVMmIJW}}Vi6@aDRJ?hhz4Wtbxxg5}yp|%vE~qMn +FU|hpi!>c%9&rbqFBiH4rXhskUYhs-e3hy&Y?mVBn@#ArXtFxn9eid`?OZgIL%wY|GJ=JMx(YM +KWmPbw@7NuKL#sb{XSaL|f9Ta7rq#mFomI{n#% +M=oa?u`{JpXRuZ;^D-%LxV$_1L!X +AK@Q2NWk*zH;Ki;93BX?LN+7z!tHZYIiRZt4P<)0(bTR9SThQkrjRyLnW_XgTi?>a2_CT%?I@J)LsYT +g2g*P>if0ZR!e_jkvsDc`#jba91w$w9=--3Xu$)zbr$Fx0vDBbe3Y$YN$QoVa}oLA0DR`oAr$LM7m0b +aA?~Zf$JBo8{11t2G_>ZLNV)F)Gdb*Fr4P1Y%(IcmAr2^z)N-jYLKPN1{-Sn;AcD)916smYltOS-SiCxg$mvrx&0q%y4q-iA +G4vV_~jaR-_dxb&m@vr&2mAw%#H%heO8jLE<{kU +|reKMz8aV-nhQ+oYZg#m6RYQpG$N)qd~YDOc; +^F)-$&Y@9k74>yWRQ^P)h>@6aWAK2mtS)wnh-JXyx4i007JZ002z@003}la4%nWWo~3|axZdaadl;Lb +aO9oVPk7yXJvCQb#iQMX<{=kaA9L>VP|D?FLQHjUu|J@V`yJ!Z*z2RVQpnEUtei%X>?y-E^v8`j=@UA +Fc60CeTpCUP{q=N-UKho9=xb;5VFbC29r!kC%g9T?WQVJ5H`oj%=dkg=lcfB+u?1Nkt6Q<+nYKWG6zh +PhYN|b;EA%h!5J;I&zWeu1>aO#&TwUu8Sd8Yjry7s-6j3Y(MnJf&ad0Ww|Mdc|_6kW3~H8(rFupkmyvKuG+uwwnMwcx7W=VP)h>@6aWAK2mtS)wnnYgoEroN006=c002|~003}la4%nWW +o~3|axZdaadl;LbaO9oVPk7yXJvCQb#iQMX<{=kaA9L>VP|D?FLQHjUu|J@V`yJ!Z*z2RVQpnEUukV{ +Y-Md_ZggREX>V>WaCxm){cjUT5dGbM#mG_QJL6mkX(_doN>P9oi6#*SiVDB@q=oSLd^$JIYq5|?O65}LUKvfLH4D04`#C73MFiHcTpscG +qyzM;wFW!CTad%Xj?G+vJB^;|hBRV4|(m%5OaJUm@bo>QfAshuR@!cuMu{%;{&^u}v-@Cakh7nPc2L^ +Sul9v>eUCU;rf&Wyb|K0R*CWplr%dOfwMjrC+@uQ#3EO6!otbV_G5IL*Gx9%hdQyJ3KU->Y@Bl6tXf@mAxi3D`TN`u=11OO>RJr$Wbg_{U1 +Ww3?oa%E{>OfUbd;EF$(1*wZ7o)?R!bHzz7t`USEb(a_3;P@$S+kq*bu=zTdfi7hEw +k!#wfcM@ +9divo!)LBc~SzEZSP|bD_y-x$#Fef-bGNS)d<4(Q|T3dn?y$PdYDVm2z`gbWGF+WL=Y3nAkD|wpNm_3 +$CamH#aNPLV4!N3@y^RY^88U!z#LEZV+s?Evr!Ir#(V%_5(*iDZr!G9lVsLe0zzWUQUP^J*GZAfWO*; +=xN###nlqAEo*L8WI(xq)77!r8tl^Uo+>o#134sEIG+nEa*tC;xwZh=!AvD)vLb_%Hj; +wxFh7q1zr%LcLb0ViBxpG3Qt~&JPpq**iVcyNg33Etl_Tash&{N~XnD?PO@;9lRJdbm!@|uPOF<^;TI +wPhy#FKn_@HSRS#_eyKvT5bO8I#*_^gkP1}Pc4t;zm&H-T@K=rrq`{!eA<*ukq~<(KLNDCJ@%ivqVfY +*ZHoIzMV^*0uAdT`c*CfJco +XCXOwT(g^uR;$(UpL)#Drj^Jgl=j1L00&%ah~uV@L{S8=qRz6ewPbN1*o}tB(T*yFd!>oe#_h3D=LZl}q|0I2OBR%xb^5rB=H$`MJj{F(|t+$v3kwS)EP+}I_)f+WIU4rgyK&~ +$9d&1aS$9xnik@$KgsooZrK~N5LdU6AUx~_O~s?tQPpPi&bStg?D3-e6T#S7ZliB`9*m@2blMZ+J1W; +?#YHi?T0@>BC{)CG*$4Sjj5`&V6V98^jCS2I!s+fHv)N-@u+_fYJ19o@c5}N2$K`B4{R4XU?%n>B$~= +zD2~QXXfSfB#7jXdCiEL|XvBX&nFH6ud+uQGyF3u65^7|qE+e&_=qV3PuD_cpOv?o%GlqYu^U~kUqx8 +cyCrT*^JRT$~?pn1nhsxUR+$vJep2M;OPexYC;j}o~Mb;5(#XcKgrraKRLH&}rBe@1&~zY=5X6?6Q(& +)%23gZ6;k8jMpsb8b1nGIA%J-6p`-Nm*fPUCAJ!_)-a-`5RD60|XQR000O8@1eFvys7kr0|5X4<^ccz +HUIzsaA|NaUv_0~WN&gWa%FLKWpi|MFK}UFYhh<)b1!vrY;0*_GcR>?X>2cFUukY>bYEXCaCudcK~BU +l3`O^I3QKGlX*730NC+gvg2FmVQ+FD*jf3rWnA?-kw9xGA_x=5?+`$tu)YkP^%Z-4eFmvolZ$16i&kvQU-d>i%iXf|LeYhY;_MwQnaT0+ +15ir?1QY-O00;o@p|(c)bvjfG1polu3;+N)0001RX>c!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D?FLiQ +kY-wUMFLiWjY%gPPZf<2`bZKvHE^v8`R#9);HV}UIuQ((RkqlP|x`zP*^5AvO7A#GI#svlhg+)u0&4n +ffl1l4;-#e0$EXOWpAdxK|zq|YH?jyyn(Z+$*p&}beEt`hszAFfH_%AtYHfDbyP_>{1Gh|C?qBploCzfS@)qa92 +qq^2nK#WsZG_@k?;(PB5lki(uR+*Vsg=S7q1CD~x@mZo(5uvYc#0`}unjLoElLk}adF|FU$|?HvamEQ +2T=oN4Fep4LqznX*sX451#7gC+VU!!c#yndhVA^mfsVYC%-X!zI@d_C&i-C5pFZ`-1?csE_%$LtXvcH +7)d!4&6t8?>VTPe$G~Wf5fXVM{Z^8K3p(s2ZMFCEGFv*?Iql1Di#x6&B8D8#7Dbxl_$dtwSxpHz3Xb! +E-Mif!QA?F+Jm~+N6JA*5Fdo>G{NWC4h=S?w6|MoQd`H)giRZL{)s{^P9tpd`(9p-O1tM;)7kl41|0< +*B*Lu5P6j=`zGlMY*xs|3C6~(f2E((Ks**9+DTz@7oMs;@@?4oxWUu>vzO)3B#UoKQE`?h +O{nWNe%MGjg6hV=FZ^^fzIQa1vDgGL2Xn>~e +34xaXIi)J6Q-@!VZ6=o{Lz&0|>?7?wMlnKW(m{%2|IE~aE@z`$hmX~*Dfud*-O#AaU>t&f8F|Nnjz +dHlOyjnxSGGtXu@L~q`h@%5xDs5Iyr(q-I0=_9`1rxK4JuAiBwKCWES?_5rA3kc+8@9Z%BEK)Tnkw+= +>evZttoiD<<#6>4{a2@xK15^04x+0wG2bM=Ged-P|5fXvB{0@8Vr5kkqjI-!ot$9NbDUF;DE7_dd(zY +X;~{>?-ir)fFU((6O^Nz$jS@U&S)Kti=adn#THxH`<;%f8GKXt4t6beARaml0NpUZ=!F{`y +eo>3K9>=TH{9S1x1+R;3;W*Dov0>URpS64KKUM{Y26r{9%$Kx}(!07$2nA~t~_%B0T +f-&~c5XG0p*IqN#Zj-b~En(GdR@L$=EV|SF9{@nOK&d +Iwr_w$nwNdOJlPdM-X~;^*-ouO(A0ZRpoTp{-%nuBvThved5iely +{1`0^{_ISEkcag?B^!eWCnj-I_>$G0YX^EU}QtLi{!7m~v8yo_9_dWC#Q@&MPD=go;WPf|e_l(5|s_-NXka2$QA@5)_~GrF +Z|TdEky#mCjqiZ%!E&kgXu+bxnG=OBiNr{a8Y1N#7sa}Cw&}jXazP(R*C|V= +=RWowpYhn*wdvUXs|3pv{fCgzpuawp#v{_BsRXYQU_7!flc_wrCv{U{l6a2mZdG~vTk&W|J5wv2ru!wu^=PVJWY@D6^C%H)0s_p-g7GYH}W?W^CaW%SVxT;Scez=hwk=6^3@% +KwU#9oL|*c!Jc4cm4 +Z*nhkWpQ<7b98eraA9L>VP|D?FLiQkY-wUMFLiWjY%g+Ub8v5Nb7d}Yd6kjDYQr!PMDPBJ#l6Ib=mT; +qrO;C;!R27M+AN*mf5eI!T{lALUyc!+A&?K}oN<=5huPdn1RkR8aJA(q(r!r{6K9|{JXHA2Dwr<9f&&FZ$jxn +1xo7Fi&kg3Upqu+1;@CCM{9G6&sFOwS>>ux5FT@ec&83c=DEK|0H*ZJLg9X+qY`le#ZDBLA=(h+`r&g +b56sO?X>2cYWpr|RE^v9ZT6=HX$PxeFpJI_95b4T{9QV*xI5l+=E=lJuhdUuqC~|jp<~Q%5v)x{nHLJ6oILXv?E;pO3*qofKOSxlFByJP2uQORxOs@z|7< +^vJq7X^FfUUBr=Vd9&F+F(4Z*N3h9-UhsN?FT9=FY7f!PEZU8&U1yB%yDGhKW5-KJksPEL7R;$;k<@% +4UY)Xd~*ka4E_ljtjmMaU8;$B{EE0vd=tkL^WoWBx?0mz%jgFE5Rzh7WolqHGYCRtg`~ +B@CpusAH2zHww5LQ+Dn;Fr)n2|O1*QYMNE`dX5WnA5l?5&@c%R`>0W5JZR>gudp-cQcf8;Tnx-_<|A) +>IN++-$w?(D+56D&rqwnU6(U^_!=Je@Pam#o6Tttc7JspLL!|RgmMR}%ou;8%G09N@~lx3Cz*MN&BAO +1!OLtn(NKYwh1nJHM#Ct)}Ybyo3J4p^^_Y!8+KhQyZ3*F3Mpa{2plK?F4iWZRW8C*a^v^8Fqd$O<+kW +1TMl*OYmltu7qji#)GdvZlyIRh_sdz{^&gF_KegCmfhYU=!Yuc$TPTq2yU>i_<+X`409&SdcZ(rxt<* +{$xe7TZxj%wLQ3&jOV#LL~Ox7!S6j-n@B~G2vRkZaC!+|))aLWwTONccmkmPUKRj0UYBAAJAm7)La(f +9;0*ZSMatG3d4({*fN`Q|32Dmgsve=kY@`GkuSj-#+INm&jZk`ss=Q(g>Y9$*i~j2#ep<#R=beYzLW{rynE8uqm6c}?BTcUo9QVu^Jfa%r7Qqh4Wsud3IaW$JWVcXgF_KY$h!qonjd^H^(IQl&2qTbFuqo73<#b62E +qXP7efj;{Mf`5Qcys+K{^8BlV*d8(vg>5Ni9p4HT{ICC*&`Cw4s%#4?+~C%!E9qv%gBuRW8IH`E`pC{M`8j@7XB}p0R(k;I7T +kl)z1%zGr9b+>}A276Ix{F>$U*mp<<(_ar(;5P-Ysx+#+BG9q@C4r`VgX3QU915~|}=ox+g8NQ<^`pL +?uIl)w|NE8BtJCq=~EH+L`2Xz&`mAt$BSN!7gQ`V}U{x=e+ti`!cu3)n=aX;ET4@2>R4HY|D +Au%Wi4nBW2QF}lmERHb?#4#u!Uyqd~&dw)eQ+LeJhjf!-E_DQ@pPsGLryDwF4`DFwg@}hp`W8O}?)ve +3Q8vI_ELW7G(^zHq*(990o|La6QR9lcwR+2Z=u^^`%c&L +T(#aPARY6Fi=$&s$?J#6jEn>FK9K*eZpB4N^|Cqz*ilD353@$2U*oC9e5sZ?PuhxQwSfpHk0l2DRbu> +G{u~?)^O-Um8&1_{%0a8&;&htLKM;i{RF94haFVpHQk-I&wvsIR7_0bMOq^|I=#l~`**Aa$)Ln3P%a0muSzZ(n +8WXMcdV28a_trqTL0s{*OVG1!X1Z5RkJBMCAup&}!3wx&_hI)-VHnHxADK{{`L#m?je7h8!C~lbshJr +q*cDvJ5Y@$@GnoaQNr7WPDz(&@Pq4s{to|NqD@9_PIJz*_T=e)3I49>&W%{QWsjY(q?RMz5a^)+a!$v +J5e_1e@pbD{Z5QBXiyP`utu?G5TUCwvlx^#8B$VP?P5Wt0MdIL;Nq-`+gXj$h)ynSf6X3|DZHv_f +lw(@QGOK?vLYwX;4ocj}_D5*si$J#9ks%j&NZGw8kA@ZW!gj?kG-rzr)Sqn27(s4Zi$ALyWPRk^nO)E +$x#A#8r0v)~2I5p3uGRQ19(={rOIp=i^q*wBU4&4|VnK}hBUt;*o~!NAn1I`!S*+7i!mFt7)87kYTwm +TV~4T!I(iSfr_)0rvB*R?B0oX3F5_fm5L|zZ!E2F|Ym#AEJf42J0*bdksv_(=G_T;Gz7oefkw(Vqo?N +vu~NxnPo*%iXFsK&)Reo)|9zz$5cD2f09?~>lokBm}^i*@~JL)B8G~b8`Jd;zb~`A2s6zhmW4M})h)Y +WXi9@a-770%)MG1tbl>hrxFPJ?M!fazDJEj)pxz4^y9Fmq=4Iuw%jw*{VIkCjVSU9!q2&X4)21|~fep +4!TZ12}&$LAC*Z`uNj@aNHO@d)+-Q>CZCSj_CM5qw>r5d6vmm06(cxL?G?=Z;=l^h;#kJ&5dWfSx__+ +FIq!kL3aeS?G$ +-PkKKN(?7mm6H=2%}CVfoXm&fw}-PIy9YMYrWZgK$Q$tJ=$%tknkW42x#}Ui8FDya +>^G~++f=uU=cNXQjNl?89LAbmQ9yhXWno;aYyK-*q3^Q?g*o|1fx5g+L%9fx(}2l?%L#d-%i`_+;j!^ +M?ISuk$UcI>biHdbm!%)`*0L~(X@cASvyTr)iDj~@DH*cD$B+eq_!NpwF4IIg+UfM&B+Jrlz^)S|!XguQG0&H2w*JVoL?(}& +P6ssOG|9!MoL#V+G!dP*m($tw<{GbWc&tPx%mmNHED}pz#Q7|&Q+MoIBFmE0y=)D8)#>EfZp7Fzdk`v +TSeayEOE82ms>ATJQcyj+RyScrY4A|ZM?ZfT(_T3B&pU;P_bKOp`{#& +jX9{veEa_Helne2-`*Tt;}8$%^7W^)*ZMcW^WNOqo#)K2L%JYpHot|#xlML4Bz +hoTqAk7|6r^H?6J3M61BAZQRBxYbxpS9fvP*uzqDhSi{=_X76A;MgpE^z86n~aCKgg~b#Gy2b7F-*)xtll1bY;T$T-dlrkUhS(!Q|3T_%UE<~PNPNd=_6tx*V*|E +#X^yHWEdo#}sjDH>7}lwQ!R;GlEK{-KqTl~P2OC7c=s?HU*El*+)rV6J#CU*(!(q40=pVjP +i_>LG^(E5=-K%n?Wh@gd;QDXQP=QuulfURbmactPcI#N`>6kFYI@K_-*DQcWA=^EZ{J{(-A?}nkM@uc +0P#MJM3&ItVT^E4wF6Sndl&;WJU+d2L3ZEQi07d8L~TSUmogl&yIsD5|DCgM*)TZMEa<0-4e?boB>=C ++wn^DNpu~@T_R|He7?Abj^k(GD>?hV64*D$3N+ySXpkwE)O!}R2GQfk)Fevlctfxf09Ke9nJPp%$W~c +N=wWWwCa5NCMNnRs9W*=0EQ0$q<1)&oi2PbQbJr(XR60St}G+U)APxxAtQE8733nOOE);LEH;hcjqTC +_0bvrs_gE{g3Dq&AWQY+Ghy>Qcty;Or-{d+~d9$R>vR=Mbkn(!$Nc6_<%U4!7ihS>A2u;mPG5Uy{u}w +JdLS8K(v@loi6gx2|1j)REO0d&cedq~B&5mm4hQk|k+wIJddSXwU95E@5L2yN%Ee+iP`G?}$Gv$?~iaKEN7aq-aH2=Fe +Ql6rKV^Z;T;WJ|jM<7Cm)~EJpS_G;o33b15GYrf@WrNb(JEXOl^&F5c;Aw&pt)atfF&yvRV|QhF*_B_ +cFVj)Pi4qJX_=$(TqZt=wGtVkHcKWD(+Ql!i*DP9iy_GgbMi3#~f!Y2kD%ZF;`3F~cf2=nnRX4`uR)Z +Q=>s9?2Sh+h5s2KzCHbhW%B$4o@6qiAOD@770pH`+k7yEEE4MX+02cAqS|t_~ItGxKpS8+ys-uK=Or9 +9sKxeA8G`um!$4O)_E+~3*Qe1?7Q#G8Pv~3AdG!+`5%7I>eV`(4mmlp6H@RJ_8~I3Ns{+S;{)c6Sl2! +}I?{i~6m1o$>`}reeMeQ!v%K}H$!| +O%Fj?gq007@8lq2~lVOwze1j)3n05a$?Q;=-|EJ$OW%ep=42V{GEWA+h?0H* +Bx~StlRAeNdHCFGiGL_nwbqE!bA~fNAelI)x%)Vw*g8K&0;usq67}s=4;pna{Ak=&d0=F*KO!^{qur; +pj??C>ywdHchK#-gZL;+tP@EHpYQc?q<~+lM>f0R`JdS~&0vnC`Q5n&_|0$_G}SUQ=5$fDPW;^kj<;R +Z?E&=ucK%k|@ZW8QPyS==q9WH`)DO&fuhJYTsW#(cU&^o28rf8&*=e5(*yIzSA%~uhetZ4-Xuuxv>FB +q!&qpm8f&B$0g7sQ7VkGJBBW&a6rh0qo_Z_%oLZ$Jun3Wjbg9}1zUM6!6Q|=9=aX8>pv8EzjyIF$gOo +kMVRn8MYlPPPhH&auF5}{P{q3Is%m0o$e7C_6$qzD?EP~^eP3nUnN;+3g9bf6zWKt7t+>Vvrow+94ss~K6yu8pavhylm^FLTR4072VFUj=Hou?z^~3f3 +0)nRk&@37JzOI;U)H4$H}^O>BkTf!j_@naa*=#OUAHy4y%~1d+^Oc1W%Kv+&O +#s2wz1ptJ#6iG=a&-2|?xDsywBl6qwzSvh?`()azzpxFWQXmyTS(n@Wd`vM%`)727n*{h +0UzbP~|D?8qMN!f4)FGD%#4zYX^``+{W71`{7{=cZRlN_!$mQ39Q?gA-$ei4J=DEUrZu6g?cdpejsF!f2%;cz#a|a%pE5$h7mekWV< +Dk9iKA#&N;AJz!Vep4n0lP-Bq$i)SE7SPXZ7FIq+a@)I&M;l0(o$u6=7dcJVGFho9?iEG>_2*@*HSk!{8~y +?X}c2L(+BIRVxe-G7rN}9&%K8Gd~Wg$VCsCXna}4I>`}BM%*QeT#4gfj(XXe#o~>4HL;dPVC?IQ8cFo +F`1cXEFYRlrSgekhNnT>(;YdF5eYfYU9WCm0YYw1?cpTgNf+ +f4%h=fXJTR+wE_0svO4Srk+9gDCRd?>I{6DPe2K$m&89c?!oRWZ8cG_S&R8TaP3<*f-+i%)F{RSIn>X +cgf#At9XM?%m1E=Yz)5oKOmq)`aw+@4Wvox#A<8m9vh$}V!@T9TqjGPC<%l+V34vR842>%70=eoBGz9bPT6 +!?s6FQYzVPq)8tV+HhQKL5>+34`C2(l1+*%3j;VT&rJ;oODYj_4*vRySczQ2AyVF=KiDtm%4=No6i>s +KD1oj^wcXM65MT!LUpktDSBVo=0BWQF+R^@-OMacld{W!L`1MjJO+{kp*Q8 +-sc#)+%)UDxzx>CD+x|w)V2Hzgt+N8sbS&(7#zk$L{7Ez%R({~9_J!UK=&*>W=<*~9ZCv! +{U?nh?&<4=OBI)nS)4G*SR>cb9jEdt!pp-NuU|^bTx-xyX=^>VPi)Boy<~2nzuO%&(mVaPp5xi;K643 +Llfc}?R=n!zpl0Qzgc#q^iEdYbk3!Mth;lzuZThKVBTc9;T8pF!{i_9i%WE7)L<7CPa1DV{R9B8xVYZ +oy*iBUYF9{<~)^t}f(s!Aoc@+TWu02PIUqW!JJN4-^&=5k<0HquyGn9xXbBpSGZ%^mG5Hc^lCZF@?t+ +2T#?J}0Ohv1SDlSLR;EZLMw^D<_@hdnGm7VX^t$wqBkPf|lKic)B@ANL|oHS5dejOQ|6?96yBWbNMmt +(sBJw<=-EoA8EoLHnJbV^GBccQ1acJ65E{uV`Qon7ihxSB~}WmscNx-)=ZG1d6=@qTHnUo3uzGv#d#X +k*{l$172=0#Hi>1QY-O00;o@p|(cs3UFXL3jhE}B>(_50001RX>c!Jc4cm4Z*nhkWpQ<7b98eraA +9L>VP|D?FLiQkY-wUMFLiWjY%g?aZDntDbS`jt)mm+n+qMz@u3v$<8_!8I3hx@%P0Qvwac#%Vj1zn6b +NW$&NJv6W5efjFtbXWk@9yG-fJmLsX*<*27fT|rSnNLg>``$n#qRZO|Jdr`@?blWV51`&F))@m1o%iUgS%NDQSy#4d@H;b3AzJLD +V&E4YehaX?P{ctz&k5THx?JElLsS9(z+9~Aw1(3bC~rC|Ck*~BE-vWbzY43RxECbTFQkJDu(mX8-L(~7hr#C^TB +T;Fl5APmN?0ij++tH?GPSUsZk-f&=43Ld8g5K5#?&d;>k=NYO0{db=`_bfiwQmV&kU=0%T@#duw2c+E +Ii_2tu%bwE7g>x+lGI^gtzfzIG}~2Z@(^X=AbFBZ@(#SW^n_;2UfoWIY082Z-kzD8Mpr5eytW}4~`bF +9=8=*{L+CvrdO|D-CfPu75-RWUyDzCw{JvIsonL}%<1-4v%Sz?`5kO}*ve|l)V-JL#~S;nv+U#8~Q_Uh@kl>DN%`2<4<9xneQvhs5AdB3a=ow#apdnqJkK#bUU+(VSMb9O?@ +jYzxls#wf$Rt;Wz5MAtE>;b4WUYXTK|`or#4&Oxnme*p6sKC}L}xzs7QX0s5n|8uHguDaY3Uxat(vax +5xA9`Eqn3q0|UDOC(>7Q;Cn}pfQb!(zH3`bf#45Vd4LB}X=#r@^!K8f_v&e;NTrq7@_Sfg5>o)<^SYJ +@^?46ZWN4>oOgyRu814i&ofdsg@qu(Ucrw$(p!eig0iCxl9rOX!>y6fb(DzPVZ^+<(B4zZfO+(s4fIP +obu-@-8^USx9hc%Z}x{HcKO`9mzyN5eu7?&JD7pXzw>S)oGZbvMSliF3fZM-?~qsiE!;sz4BT*t)0j0 +H>X(0;-R2A67x4!O3-TR>W>twDJ{$o^oUuW!Nv7qVnXEjJX5nA71<)d8qd1JX*%KlWBLcqUkWC)>^nO +0vPSDS+1Os5;Fy3YJQ@szX1)Z6Kb5c)mt5a~D-T$|RSlpcD-z~J%uso1hKNOw`x~)~1Gg1``2v)8 +Oq!g>48%d=bvn9l2I#|OnRYv_@Q0;)zzF@g$%@?o4C;z#|4G*ch2gn=Y~rb$Efz?Xi^bH4W<7U!_9bU +1Ktr?Si_q|ORwmwP*2N+e1-Je?=p}1t(n6sbDq1K_{imzhi3qaV+5PwwHse31J6#-}-ARvOEB!k-)mW +}=qJEzVoP_}J-ayHneMDb9F|ksAqP>amgR|rlJ-cF0*fee<7(pI#;)=zhgp8S{15rrmm@_;k(H{HA7h6$%bUA?c^{<6!Ty;nnhLOZ1o_t9|B1@`eG7KW#gA%8E@O-xgK +M_?X+xt@!5s{iQe +Lz8H=8Qz=wBfr{~mk)5L_IL_&bQ6KYVbo(i->Z8pKeAx63%tnTsCq|u}oP$PB9#1dsGN?T#l +u#p*${JmBh6D7JxUTn?Pl!qVTt!vbXE!Z$rq&T>HnawhR7VHN$imp4xYr1VG44>jljIXMi8aq5C?A5U +O_!8HoQ9K)R&OtkQPtot%{`6kKFWzi`BM)vf++lct +%qV}(F#$5P1@H7n;M8o&!IwRZ4zlNfh42qSQ<;rDt+Hx#jUwIMK`ws$?$o9YDeYh|S7xiPy90(Zinfb +pE17G0(7ep?be&~~H=Ja|*5ye~`W&5ei5ILbD&!ED-I**R;Jl!ArY~pbe+PZO=5FBC~h8%g=(lo}uj7 +q24`CJtLsD_9yGuU1kiGybc2x?+NKJJgn((bgyiA=1fC@-hO3ja!AcydJMi~OC!5S*YwEC)*L7-J$iZ +CRFss$dL5Ze}nJoiv0q_hcYEfgheactAfqrlsn28q~Bq>B!-9K9J1>2Dm{=dpv0Rp=JLH;1nQ`yrF4@ +J1JkZ67mBp`T61yXIQ-^MeT0yMs}y~8~7ftpd|!qbIhlBxxWC@^Wk=QP>a22YaD(0*>0TXWg|QqCAQ& +z2b{diDnfIAa*r6~t8}Ie^%h?>(robsA=KVLk>&EAk0H!u2)EwZG~FEwji1x79(UA#GFZNh_rYAF*(b +wzFy2vkmdC_}|3RX4ErhGt&T{@V2SCX88L;qgxNI!^#<#iQ<7cI3%f_Ui3^Fe9H3kmRM_-%{?2-Vg$m +D!U<|8zv6qdc}PM+@gr|HeS=ND%>pPfc)l-b!zbzr1)me34HH?{I3{WeOQ{tAy(Kh?=R#QJ2ie*sWS0 +|XQR000O8@1eFv+v4e2{|5j7%oYFuF#rGnaA|NaUv_0~WN&gWa%FLKWpi|MFK}UFYhh<)b1!vrY;0*_ +GcR>?X>2cba%?Ved8JrwkJ~m9{_bBvtPw~?9C_0KMb7AEH%*gXfuPvSCFqC6!b?k(O@tCvlG=^$*Wb* +Lk|@8#Eh=Ew5;gCfd1k26=!)f9DUmy=Ys+NSXyaJTD^a+%QDQPFktWN;w_G$MqK`V~xNysj74MDFW-^ +(yMytR|e^CPca=-p(E6fgWO2apms9kao(sISEWnYX+2aD1Ko`JI0G@ +C6a46cid3;O+qJ8qq6bJrTdN^O`CjS&`v%6h|i&HnxQ^DX=G>0`#eSWz%;83!65uh}D4EisX(W!cvG@ +}WTwSD^4A8)>piJ9IRiP3XB0C0ng(@w8f{xw3QS{lEHM*J92v1mPB=5N$q|DNxE&CERu*CFCxEU@Pa+3hyHDdhHV>RQi%7Qfj_hCh;!aA?~?b%J96m5iHlq +tyb7VbX^aNlZr2AE6<`*mR;V&^1UBOX?D3lCU!S-s?2BAiV1QgpCEbpp>zFIFhZ*}rB#;!f%mq{Ot6* +-+UDoYq>^UgOP~|Cei~z%}gRGE8EPA`PTD4C25X(AOZGp+>w!%BiAVXncq#8uQZjfeT1Fv9fCh-Q-OD +{lL+GR|F@vfqn=di2SxT^!hWZy-gJLOz0oYMIbzkV0)Nt>@sh1!o?!(dVFVGhJ@b!OxG*wSD~^2{!u6 +$yLB(mw3-foJx&_Xf86i0%FTJ6%5lJ;?zFoQCoTmLWi&w-8(`eR9!mb*l#wwLu%Z;(@<+jzV05J)MKQ~U$h`l?E5P6-TP`P~t$g$54f_Jw+Z& +c9Tj!ePVzJSBqeKQ(xv02Q078e18HPVzJ;{8?+o{6l(OO{;BbE*H4M^0YYdI(Z?q6SyVJXWpD6!K$Xm +--D15G!bn&s7y~98+kBRPiu@h<5oA~KKmy)D&)x&X7)yyBX>9{Nb5%-XT?!q(5K2~dZ@l_dK0@B +`kS>JyFj7e;3|}ii$kMan0uBi%kpYS#43S_Mt^hlOd4VuvpS(HHT>?vka|=mF&Wbz8t0Lm?4*phBph) +B#DPu(_0z*kFtqO?RbzU!^1GEUv5LMzpB&F7iH8%~=sVe}f8BZ?T~&PjXu!>fI1@oV^_G0 +&U#-yC4w!sJp5Zd4d<>b6=7(+A#WzyW?2f-9PS6*n7kNHyBjO4ch`d;>5+ZT%9F#)~MgfH(#r(eO#kH +Y;Uaq{XO?@YPT3a-7Jy#%a72qv@uz0`?3wVz>3o;l)_QU^Dzbc+;6)cn!y;cS|Gly2==$??rU$cgw(b +59xgu?w`M0!eg&^;_GSXhVXZyj#`|qgKX|O3bv$^4>WpcZx7LNEMq^z(D_1?r3W{X1j7$JRx~Mi0XUX +v%xg!Z1f;|VDOBN61;(XE$d1DIdYBi`#ZV4#mcw!6aF~Y5_JdBPi{(Q%Pd|LWivHFxfQ>wym%4sV$E0 +N7Ne+)oNsu$gUOqdeeGmcN`MA#LV0J_!3=Yxp?7O-aP{B~W=B%3I=Re|4Lg&9iREd4Vq0<7w+zNLqj;D}tt*sVC$>NR%yCQv@~X|ZL5PL3yppAaY{1git%2EJ6drhK(&crncZ8Ro<84t$9 +E-V9ySZ17G6Xgv?!ONd8ZgR2a_ypd1M*BaPF7q6LC_Q4-R|60*I8epn4VzmP>WOc9%qyN+QfhcNDT8v +gi$m?M9(xlM9(xA#Ls+89}Qdmns4h@5gJSZj8SuEI*mJsj3fKI`OXh&@IRwokP`Kry_|KzKFHAN5ZEQ +uIC~3jXoE-C&%yw(a2GyGOj#PL$!QI>ErlyHZ8nRotJK1j`Ky1u{&8ykC!H6svLAfv5YC{ltI*gHucO +99@9&ZYwK)7YP3~v?&JahuFP{Vel&IE}gJL`fg@}4B{>#Fua}?d`V|H^Gu_^n=!FzmF2*?LWB>|z)VS +dD(-qZT2d5EnE!Mz!U_P5)|A3Kdmi>VF2cbE6<3P!2BWKix0@Po~|_wr&Yn!@grPRFedW>F>_dbJux` +@KAfOpS^F$;aI;WbtY^_XhIAWAzlrq7AkeuMsQW(s2_GyJ7=#SvH~%I*~M!wvZbzZ0}1EUWQBPEQeqH +sJD%%gPWjjZ>ko`ihWyu?hl^;HgLqwA*lgaw9Z(1B$=~UM|BN_2}w7^u-okM7W*w2p$_Kg!3Z$m_Fq1 +s4F%l|=UrAzDJ#Z$yod;J{5LzF8q-l0|EE7Jps?$c!aAgiC0$37{*h}q(`WYA>Y=RmwiqbL6dP)h>@6aWAK2mtS)wnpHN12v2S007qq00 +0;O003}la4%zTZEaz0WOFZHUukY>bYEXCaCv=|O^e$w5Qgvm6(YUFkecmvA*ZEF3q2J2MG3)Zt#Kk&m +VzXcq^1A8qc7Wvoy}p_nmqGn=ADVMTCIw&w0WfmAdQlia>?a^P$9^PpD@&QR5DYnkZZN-NL{zR?KRXj +;oV7TOX!PHqPI|oa}hYqu2QypI0>*^$&~aoM4ke)kkx8{Kaet>{pmh^1aV62Cw#t73T|v7zu@zI(g4- +XF|ptL=?(g*&I60j_em~|brwhXb2#4TdwG-bBL(i~oR0tl|H~Z`TNDYZ8E-7vlD`GP*K8)0q#ZoY;~S +4>1BqxB3)o~95t>8-k{KJJEEciR(*%u?faFd_Dh~$m*1(9~h66lVlE_UW0ht;cnQ3TK{F~aYGy{#k?- +q()u5ZEeS#2|y7TldzJDbv`*ki2>T5hVzzv~`0#5V%WpUOwCgg3=+4uTnCa +PxqXb!?kBTQ=!RAwl?B65Hc;nabTTUVyhrHVC>`(=l$LGw50EWb0(*x|y!>pdKwQy#NRUi&9x`<)iB| +6wxZ3*IPG&8bi1o1V%}$I5UU1{<6F(yfLQuO7OnrvWH@bUY&7dz3{kfozUK +@_l?pTuv2HXZ_-^FjJK`eFX^Um!i`V{>WYLl>o_><8Kzbim+%y#JmA1-Yhe2Rhay-MArz1_Gjw!V|H_zzG^0|XQR000O8@1eFv6 +A${G_yPa`#|Hoa8UO$QaA|NaV{dJ3VQyq|FJo_QaBO9CX>V>WaCxm&ZEu?}5dQ98amrEwT|n#CNPNh$ +Ose*hD9JQcZDmm~2`gY^n^j4b|Gu+LLP*+4oyG^S@1A>m?rc)Q3!pTuRV^5$kQEgd3Ze(e^I9=#_k=W +ZxsfE*CRJ7i50PXsFN&y4_I6{tCFJ91F`?t>x7pXp@_PCmLg@8+dmoX$Tj!e0Nm-Q +8Z^?|N`|XKYR$gBojC*l*XbfM?e;I{LAk?rE8XSJ1x#4?MCXO@0h~4hc)6I#=L-hLhYiDZ2InINL*gX +-g&ah>cj~ +;D33IfgK?v&Lb)H$ThlV_}u2}4NYJKj{v8rVgmNlsyI9_s3l7v<*m346KG@nZFGF!95I|k|G^n_bdedy(2suP5fh4zqkH3`!SbLvktn&i-#6q!1{3} +T)z!?N+^y{Uk0lmGT#^WXlz^tUGaw!gY9RU{-6K~~~hHAT>s;C1DG7#u3}+R+hp*-VWEW9N1MkLCu)d +M2_GTd&saED@d>@hba`b7_j$9|Mz<7U-EdzjuR2wvn#ag*F*$i(6#df%jH!>b0v3!{Bd&CH9_|-u=Nv +mhOuPTC4#LJG|N-#>-i)m~uN#u-iv7qMu5$;hz4jF5ua*j`5DQ3pBND9d`5DwfHtvcIjpp@{YRoW8vW|ZhG(6El8UT#k2Ja2g$Rn8qJ* +&8!ZsHS1E9AZ3#^Guz75((s1Qlu};|hyOJ>1G+^0*={&Buxb)hAX!F&x0b+L$GVfC17B!Z{W +l}Hz@%I52t63obt=xU_mRRqS)FA!!kTp?0@fjxNqoh@Vw2I4eE4bX7Mb4a>E~y8~SlfauZ*cbVdV{g& +AK#V;b8=Uq#BJ-~4P~4na9-@lkqbfIkgKx9BDcyD8ebC@_q@a(=S2iwgesU=q-04mDmR-4OnTl5J-|FLJS<_-1u)F-CYK=>F)AhEYmh*m=A`xgW$`BP)h>@6aWAK2mtS)wniQn(4DFQ007nl000yK003} +la4%zTZEaz0WOFZQWo&RRaCvP~ON-ku5WeeI3@$+qq-M{h=_M>|&!MNV2*n=T>RJyZnXLc)%ChA|VRb +R`d@s#RYqbQ%+R={|83Q4WwjTJ^>0$K9mOCNsj5ESiSMIRZQgYQK@M*ao;Qa4&dOe@-VEnAnc%hYh!o +FIoEg_^HxO4D^gINpZ`rZE`5Kd7P=U(5S4+v2PQdpqB?7fZNWkG3T>AI?>aU)15V<_6O+DGbf}NxMitCHWhEDyX1U+01cus +9EF?kJt!TmK{)6GdB6s)Q*>rbDB&5a47UzL&~l$?)v{r0!)Arc%loYFdrTSOhM+JAre19HWs>k$HTW5 +am#4HC_D5|Cu+>C+H&xn$P@6aWAK2mtS)wnnR$Sn_)f004H@pj?IA!>1kLX4LoN_xiMG|qqDoRu{BpnjX80kI66KGy4<{5GOPm=E=X-|ghO<3M +l1(EUPLqTb`>62=_UPA+mfx*azXM!NZgi4M79G;9f6|C>8nM)PqXKAOMk(Kyo1rZbl(!GUE +Wnfre&!ZP@7*6!=Sml=k!ppMto|DGXGp~{dh8ONn3i^K4PPTh?p!r>OU)2Bnu9e-PX*C+q?|5^Yg8UZxw|W`KX)-}$qa5^YtS;VC`Kx*sB}tX;!CvP8 +mX)axR%%94(NMc{Z9~)P)Ri)+wQ>YO_HHI>ZAtEr_je>hYhiK+JScrqF(-`xMhNey6H(Kw*c6nD*dYJ +=_JP!#{Q=@44KLg0zk*ej?MiOsSh&3g;)IQ +KbE$1x7h31kr%O@*_&LZ>6!3ZB923wTr5dNfHTKZWiQy%C`dkynlW%rmks0h>m>cSP;aR$1MRDb<(0j +^hkhZ0em2QZ10BIWf%(nXXG3&F7b*xH`N7O+_mVV~BGSsa?ctwv@94{JWGO01Cgo)tm~ +sn&~B^-CN#MnI2NUnhlpgJ84tO73L{_Wk<_;HP9;f75LXrKei%f7mb#p-4AK&b;ZHpk%ph>Mc)miXJ|o<}j$)3zB;&l` +QSuEtR1APjpTSs?LJ_t;&n0pAFfN`c#CZu*NoSRE8X~Uy$igb{ML+DbGP^0&!k;shkN2?;MC6op?K)F +D{j-;}@+2GEA^nIF#VowXXC{>&BQcv!f0|4qG=Y?-H$#Zc1Q= +9mVv)&)&4w?oeYUSRR#YX~`O^#3jhvMcG5|spiJ^1jkE}-}-kL14}RO42DSYQqP?&JOa=Z{}MzWa}P4 +g43P^c`wL_99{uJy7bhm9wnDLPU2q$PI2h{`TNRd)f-uvZcd?J#FhhU&kf$R1i8WO7Y+DTH_2|0^UB3E}x_4ROZ8wIV +JgSkM1$)kdp12)!K4Qa7JC8#qwyMJnS+$}0%81Q`e`&3aXQ)n=#5Wybb3NN^goyJ=^4(||yxVPw1KuY +eZX^R31r_0cE~Hd-IE>BSXLe-9PAXd4^os;}9H=JqpFhL!zQrkx0mkyZ^!u88`OV%~_hE-L6YufSndd +33O@@|~JrojRO%6^|vRX|S+SY`0y;QIwpJD*S9fBIGTo9pJ*be`k +|M;@afSbw_lA1)=zS;rar_a>TNVc3cwJ$oaGC&Fn#+Qcb((9B%It^N#vySBj<CK$4Z#G?AV^JX5`1dvK*uF#}Ogt*4TwHnRz2fv_S?W3A^#X#R!L~mf-3PcP6W^dRaaU>{c|ZfoqMTn +d6BT!`z2~^*F98X4P#Nw4cOQW7+K_dRv7SPEi|J3lr%b6S$3p`+P(&Zuzqc7DZviF3_)ffqz8HW3{w< +)kiaHX*n_XBjST<8be&aQeT5&Ye{=3ID +2bT}fYw8mS6B`c@$bzf>BhqL{<(t+KRWpK64lzL(O=_@^@aD8vbBxZU0-HKD7o7)a)Iit|dGGe+7t=0 +R*=hMp3N$Mu?S@DR*47o%t|Yn!Ufr&?j79^w9U@-dcv5=LhVqy5$6(`jhGdOQgpmLXn05a)yt%ABT@H +&8=w(gJ%Dt!YzLouJWmG3qNVq$ThZ!Vmbl5uW_xkpGn2bqbHL3bVGVhUfvG#>@Ei`99yh`o?CMKCR43*{ClB|HQf-cQvj{OAp8aph_4gVMk-OM{t9U1#T$z1h;1Jc{{+saLp#l_*R(!3ChWXdb*}C0TXKjED* +h%O&-vGRTl9^5+#fpzM#(*$6lX`^a(SLL6JOwtkd(wP;2EzW+s0mlAApCsA2g+b0h+zkY-z9pDH*%{F +!>+It)kl0mt-Kz#O2vXfj6}&b;9%Ou^D3baeHu>=TCTwwV4CW{7-XEo3V%-K_K)&Qof +A`{py6LAR?kqPsTKyWlf5vMneRNge?enG;K1*PK8BzvSsB6CkqrtuwDlko*Jkvi=TGc$?oKJ0ndeI%# +3jLC!f^gQrEnM=z1T2-~K_M26-n0R(NC--FWh9bgFLdS&IO?2^~=tAM+^*0Mt^(TcmC(e{0n|i$04uS +m{pZz5G3?+RoMrwWdt_O=czqi`CfS;TS*i-)hq(^kz%hjm=FQ=IAC8uS-;4^{-%)S#{XxG4Gsok-NI&@>P)h>@6aWAK2mtS)wnlM}lMpZm002`Q000yK003}la +4%zTZEaz0WOFZUX>)WgaCyyH-D~7F5P#plLZk%SSFh=FVEfRNK;XERw$O(o2*uWJe9>AyNlvo=eP{Gx +TmINwxE$0ESzDSJ&5VBYA!V=Rkx;ttOs6=dq&~J%8N%+h6rJJJeQ!2?T*$+rZVsEx9{Jk3E$9<(Dyaf +v`*@&=YuTxi>k-*K)4Y_&BWtQadhI?38vau9*3`1mf#mmE8&%(TIQU7L8`+KN>!#u_f%HbIBQw{sF-n +S@?2m?)M$o+-);al;m5=PeZ;(ml*{A-YO+i1gt_=|t-YQ>MdF#{QBB6{r(+|b$)^NLm@U1 +2@^q_w8Jstvmre30?{z_|!A{>6`LRz8df%3~#CKOEU3r*4cMlVLDV4T0z4;==wS1?f#At@EA6RZG!TumA~m>0)D9yni)eiW33+z*jefkrH-( +3$l2lYg0dQqQN4VlnOSYh?Ye~!G;9c6FbsrkO@P9f{@Er$piW99ds8abO&~*6LPO8UnEY^ithpNbyFK +kQ_aObCm)zPfN>u_JU)9zIFT*5Z{)0;AbD2w++)5?&j;Iwd!<1aq%XqvoT6Y=<+nBMC-F(PGRfiZR(7 +Uh;H@N&=2?k6yF?oaQEODkCj?+5>x9|eFrj%o^}t2Db507-~7PDdb!Tcy(&iG*4X|86rX|qcfCcb~){%FJrW2NoPfVaUYa2PJTh4jX8GvBhC+g80h +&eDrpo23zAe5<(Nkbwyn-ikkQAzLhID^NZ +W&I(vMs$VXz7A;fY#*u{4Xn_SpnOMXx`Dl^sEo@E`vhMfe6b13bxLT|S)=`SMoi_#Q__N<9}m>5bZo{GA8)H|Y6Fku(cRrtKNsHB2?|G$ufX?kVC_C>gk8T;9?{tRL~VEVfqy*p_;8o +=_~P)7`?`Y@c?yv;2HaAurG4h$W_qt+wMCLDJm!C)MA>pE7-6IX`BiW1&w-0X6am<_r9kfzgpQYzf^( +mYL+%#Lk{_8FVop1KFKBYEZ3bzRnVIjV{6_C{KznvTo90fh=1|bg1gxP*|n`>! +zppLByOn;-$6)qgWXGj9`bB_wC$+?L#aGN9Gu`8x5@(J#xb!2w0j-O)1QaNwPT}XLOiT;rzFbF*H4_g +FFz#E32)d44>!PJh;H~71rm$KGF!ZmVPW&+gHq8#679cXDjo9G~0?ztw^T>BlWH4djRy^-|j3j7P7&& +LS-2Wb2@hr=R<~FY6mACuva0pbXO!`LUd&U0dLX_od-WLqrI@8C0z8tP2n|Gu41*A_$u-5EI(lw8bd~W6^Bco +1pQ}IFQ0jCG5&CY5tI)(R~`~$~<2|B~`6M@5sfKGyKR|Gd`(=8U_SM=yz7cbnVv2E!NmYf;wJh*% +o{d19j8QrMP>(#ml{AY3q_^O+?Sa8rjqsb^cN*x|l39+jBdEZY}U7gNS^Fj56O)eEc;cZclu%n8tw5C +kro2)AsTagt=SDWfbERlv^(;@p9{QUfpGV0AbSbQ2PfA+HBaT+`ctfT?ENiK%|&Ok~qCBCx%#Yr}Qg_s%(PY;c$Y&CZW@xoYx|!zq?*Mb-eGXb> +XZ^c000qYz?{d}QQ*ur{{c`-0|XQR000O8@1eFv+3V+&R|Wt8{1E^E761SMaA|NaV{dJ3V +Qyq|FLPyKa${&NaCxm*TW{Mo6n^)wAX)^HT1P0b?IoB8bZLea$kJeTumPSSFcNLEkw}%KVtYmZ`_7?A +>gH~Jm;=}ndCtdk{YYl3WJR)U+n7eNEF-+Cr80y*YFRdhW$pWH=Eh68+i|h;ull6@qhUvLP_&-Swg_4 +CI(?*?<+7@%C_L_U`#LAfhwJN`<+2klGZH)-BTomjW1W)(xyQ#+TQv0bLGnr +wk;)0f$=6|!1T^v$f(6OD57}>TSJ%JZEVExeJlwtOq_ +bxx3aPwc{j|#z)3Q-H(-Wyw^J7}c=MMO2Ba`JN2YY9;8T!E#S@`^<;Q6f`i?dA73No93SYA@C$&yi(@ +0}O1`%SK91U@fbylAJ%7Ocb2lA7jEbO&o6_EIx~XaweT1A6L2aw!bu5S<@CHB6m;N&&(`S-}N~w8e|; +Sfc?62E7a+7qyZ*vX*U#Hy*_c_*DSM*=21)CfwelNg?#|C;~;^b=n)l_Mwpt<1NIM=eBl1&}InGc;$x{ +#|zxM;f^&I!h@7jM2LLK-`IH85RK4p#TuDUN>QT4P5l_Nn2D6{yx!P~{|U3yIhQNz$mxiyeUy!4<-wj +nqdoHx$YS`K^z8{wjKa@=^F?6d(eQ-3LdIPn+oX@e*~>bX9hNJ&=Vn{p4iX0rzT4D +fj}0%2Of$$mw37!TR1-Hgil5&S0DHPm#9`^VS5F4&7!S}KkZ8JO>Y1r~C6A{*Kv-%B;i?6Zd|`c#kny +4`ACky%mmm28LsCV_xf~!I@H0ktRDibj0yo>=)t-@(YeU+70-fO+kZ4(+2yLf;2EZF_qfY){!F3zlO^?L=#$acCtUCecgcoqHeS{pG^V6B_5vd9Wown;qVLMwva2@-6Sco3u&1}GSXf{$FI23lN +Cw9_f9`KWE)YxD^2GjWQMTI}}>1 +>*{~EmH*Hf87HZIy2VpFrHcUEM5KS2%7VoTc5?X#Y__9 +t6k#0o(}tjhCA7eyROYZyawQYL_QRtpb`X=Fl=-gE?mR@^j1I!xFKVxvaOBcJ$qvoFub<08mQ<1QY-O +00;o@p|(a+iO@zN1^@tV6951d0001RX>c!NZ*6U1Ze(*Wb7*gOE^v9hSlw^iHV}XJUqQGiBo(&MXJg( +LRtKB(FHnZ_LWXu9RZCEvl{iDU?OmMV&q{#WQg@uqt;7&fA}zjM7Xuie@6`$_ +d^5b$)(%cQ+%Kx3|}~oh*IiRW7_S^?pkwSE7*_hixZl3YfZdHlO}!%3fL-z#b&Xhb!is2OusPpAri-f3l*Wpen;Ch-;pT=dc?nS>s;^iKiErM528trSfiznz6aNV>qwrm +``&37!#*VK3^%hEzhE)kR=_OXBp2$qFbON2UZ8zhRP%htAkh*6 +uc2WM@QSfk%Q6MJrz4Cg?Pky{%GE~78Fyz=&~V5fDv?|$nMRx@zOu6p@(#}&u#CH +W`pC21otl6BH>3bH{b)%(!GYpm9 +Du$#)9iR1!c-^|p(^7sZZSJb;03I`2hLpdxO7x?ugLA?`StCEB5)`*WlkQTmoRCXVv0Hq>AVdp0D}d_ +vmH~^NyJgBFgn@@KV?xF;usK|!5&1-n+`fa)=?l*l1Xf1BFWQd-_EbRUGC +tECB=z_4KpjbxAl;;2GDmkR?NPKM=N$m-lBEXZL5P0@tI!Aa;GE2XZ+5juU;2&G4y!!=k|hqo^Z=hl; +VaYcD^N;ZuFSx@1C-UFA9tpP$YA+tk-kl>(P +Kl)WJ$A-+B2GWWBNFuVAz3LD@2dkA?D;eDAdZ}>xjRE(g0-Xg(HQDJ(M}xryoNNPENj3W*?pUvn-u;o +i;Tl0d7J>3Vz2=78W@h5h~Y&Ld8}+4OrV)dJW@c>)~=g9Z&vld9om{)s(#U1$2T*$%v{?FiG^`t9Hy;kBFbxaOEeSG0-yhy?>%~lfg8I +O?c=zt6zxGCCblR`QuOxoez)H@0dRBzrDU5wUx<#P)h>@6aWAK2mtS)wnnRo89&ei002Y_000>P003} +la4%zTZEaz0WOFZdZfS0FbYX04E^v93R&9&pHW2>qUoiw0$A{PS^K!l~+ZIZplwM0I$Dt_pI2J2QK1t +qO{(VRCdz|cYf<)G6ULTESR2kg>V^!xmgN%V_T5TNgqt&u=$oh2@4fIyDQRPMGBRkiKa+LVjFP?c(tVsvK25_sf|FzZcj#p_RR|%02NHW3-8)s +F2)R_(zF;Z_u(I=Hw{?8oS*t%o7_qSG@2O+AIniWDkTToFszN&`o@ewho2`ma`cAuJl>K!bfiKsaN(0 +e-ipo3hO#2q@AP|iq68-a5%IVS8D|pUDsyqWn?%UQaIP5sDnNLiToAeh_xWRl!gW!FS+C1*Ag9?Mkpi ++?w}Hq44si2n5<=kTb~OfS_fyt+ZN5zo#W+(GbO&F)a~Jrtw2<~LC7JVK#BvovlJrHM>c?m*60&_(LF +$4;p2eAC&;qw4$q^3kIR$^@dSZUukGk$&Bc3g<2d8~2uiHz8VDsEV|$CTO5p=HCri_Zm-CPny*5H(f1 +N%lc$p-dR4j#OS>nlxrex&3&3G9;D2)BY;Ya*v;*|a$7h%Qeils#B@^~5c6$3B4-aPi_rpk?U#XITpF +JISmpCqr`FXo)hBAP^Yr0B36i{$Qc}vMb${O-g +wEl*P#vj$}(vM?$=`p?FHB>#8Tlxs0b($)pGu=%{c0X$sQ@yk=P-z2&R+TVKC^(?2MO`RSVo2F+mqcs +tL)|kOaiVd9`|M(@x5kDu1~11t90S~u|I8;UI7=b# +)7uR&5v!H&U|}ilG?>>2|v6e=?}y5PV_hVlMQtXi!Ul8G@~oaO0`9@_hp65kl`3TG4G=n)Z*ChrLH +Qu|TB;Z}kwbZs%WPz8p{NyCjAOdQcTE5b{t3!`3?qbRGFr!1ug!nho`RN^xo%N%TKZO9KQH000080Pm +r;M(_^B1}X>u0Nfk^02KfL0B~t=FJo_QZDDR?b1!#jWo2wGaCxO!-H+Qg5`Xt!LAWSv=PYd>gGIE!wb +{ij5FCPD4tWRyftDznU0GB~%3k-czZsH}NPRf#o*rzOoEgr?k26F1ClbAjNG5V#?e9sWi|9R$ED9-(B +u$G(H#PLY0ycPR9`?KMa9a*J+ +vok$8uX6U<5`L!H3*ECP9F#o`d(Bv_xu{f2=)^oqDdd)Xmh8kuqke68nSbQc4EOAk{W+n@f0*t`8qLd +2xcy3nOeN)tZAm5Mk(T@~mey1s23+wDS8aJ)6KTMQ+kb#;>7aj>NBt3f3@!H+0F;X%9i +vi{`ie%2T;kpo5egwwS?I*7uH{k#mC2|fByH=m-Oqu9v?rYAD@3G3B)f(L*hRKuhyY)YnaO#nRB_>l9 +gHh0G?&5&0?`Y7%&L}93J95)1S=PI!!Bj1SBC@R#K&$wl+@dF#4UG}hx=ah=P+j +Hx#Pf!hma26&hRwWS)Bz9{DJwJ7C=`)&p(W(!T8cgS<}mr4eDLB)RLwG8a3&u}9LF;pkqnps8oXrJ7` +{ae);VR0z{DT08%ZO}A2XC915;ZT+z{7zJ~*VJ?7NP*^Nnf%>3|k+kA=5&p>_NS*YV17<*b0r%qy7xcxn*h-q$Kz}$5=X%H8kSCAi~ +$e0vCx>#)kf*in{SX89r*(2{!xo36*@&$`%nZvwgngE +)57{|?xbsq7yxjDQZLT_{&$Kac+TFI^yqTvG>EC4A@d}`I1COZ6%Nw}{k&a9%i0tHKm<@sBR&$}Ao~9 +X&CM#NFLSIb;dHMLNC557}Z|v5`d!-62c0Y=#7F`g@`!be>Zw@43p#CTCEjSR`4=pxt&Y(TSC!HZ>KR6lJ1He!a9J +x6|nlTL;VyP*JN~5oPv4FCa{XH^46g&8h%Prqgc=k4Jo@FU-kE_fj-<=tqyzN-#8`YfKrdsZ>l(s_V^ +z5ct&Lg1>A%?KZctwT{^I#T)i@_L92%kf*MvQl^%B<$G|-7=XvNcRmV3i-QADh-JSUbXwSs&^2jomlu +;S0;2v3a~zrk*;Mz#ZDGz7w%4^1m!5aqxB6ud)+*>{GKQhOZdgG5e;VbrwGRn_*4UgF&}R{^3So9Xs1 +gsXny}k9G>V#fFKNy^`BQdtb8H|7s;Jg-9T*0^(MM3@8MMG}$#;#(j$ZunF%AmMUXS+Z-!px@*O#p~- +faGqj0uleuXOMSfv#u*Vyi@Xa*a~zx+d4mIGRa5yNI(awI$BhiJoncpP-dT +5Pu7E4vc;$|7b0W8CIOMXYeuMFaM%*5uV~o*y^}L6}H=ZgDA%mmd&kEb>?aCg_`vtr@K34VnVru= +c(+IU_uWe#{nSfjrwcL^6Mvy~!WEE*|FrcKGQz$oe6L4v6F+i~?)L`93cha;;#^O4>`S9iyxfjvrfyQUQz#ucs_T40AC0EHixaw2_OfJ1m9(1lLt_Woi;xsttfeS>mSA|y)`KnSU&mw+M{!Q^dO=pSmmUt!u +{9NR9C!OXF?K8f(>h*q{+88e9xOv6dyinPyA +PY-fDDGaKwi4c3JB!Q&m~Ig-od2in0A&5(IVwt3<%JtN1zMKysod^nZ}miqUdo&1Tpt3q5Iggy2J4jw +b4P-ro`_lvlJ^eFNfo~x*A9}h)|_kN8ya8avIccnC99N^z-h7G)^8#Eyugnv5P10vhJc)g6x&D+*!d* +v46HRuoRev8JgsT^n#L;dyDS7U5j-J!--W1(7JrWt;6*Sz)uZCd|byXoD(4byJ3%ZIL;C3HTVoe%Dlk +}x;4=X*$8-@ea_2(KJE8R76XA)D##VZ(FYS#8#vX}=n8yrH-EpXC$frM;=JL4lk=+P@cUfTj-cbK2Vf +%%=Yun^t;M8xn$fVj5{^+*Ch;-Q2Wz=epr4R~$Il1BSe*Q@r}ebHe`sP)h>@6aWAK2mtS)wnicAcvCe +6006WL000&M003}la4%zTZE#_9FJE72ZfSI1UoLQYl~!$U+cpsXu3vFbP{{5aIZf6y%a8%x(heDdxJX +)LLlH2vNZCYWQXnb20`}u~M@qKbF4(FMwkY1~bI%=_rss^algf9R-UZm_S#u$*bnd^scA0;xnIw$yszRVI;B(MPzjd8XAl<6aqH)r(x-EFIl(fc7uso7 +^!?2#|BpTA(tF??@AYDk$F!LpAl%TcqqEd5KKP`gE`>UJF+5H{rK44Ho2N>CsJMO(5VfYis!dFJQF=r +ZE$ZU)%s-$Y?9nYB3rGZ~AV01DWM=*peVL#B3>$d3GqT4@KA_X%DGmA +Wc?(u(9SgVvxJ&)LlyU$QgGp^tJ0+{jH(9^0jm7w>uH+1SZ^drNZ@~=xl{SRqz>S=i$&oaS!iRWfWt#*BBL10ootT{dGkv-h*>>)CxaU_mLcu*T)4mO3Clq1BAtUe0c=|AN2cs@L3+u~gV% +Sb(TqBE9{n6yw}^`nnavy`n|Lc;WUK^E2G5stS;FO-NCb)4pL+coB%UXDU{%)991Mjy +*up;)yS0xLkQW6yxz3S-#?JL@f-z3NKgGG%M-3;GV}CcAY>0%_Z8S*{!e+*lSs*CPkJ*>^$^;v^ +h^;{k@`YBirX>i_s&SKcv!{dZv!Cc!NZ*6d4bT4FSV{~J0Zf0p`E^vA6JZp2?$dTXmD<)E01Z^6zeINFsiY~>KD4Qvn(vh^iT +Qb7}fgy<%2yg*V67MSi{knS|7ytv3vb}q|Nl-3}1ZH}A`rSPZp0M#U%ozOhn4he-ESa->$=S^|UnVh& +lEos77p|Yg^Kjt?p`VM7Y?TC?hRRd);wK>Sr#U-%lbKjhUfQT0MC~^ZU){P=I#4#Bg@{FhVJP?y_G=d0olkpC1y@PuS=kV8y0~Ul?o`$nc&Ve4Vhb)=rfH9|sVUCCgiN +9I#I0xhb6e8}$TejY$>m(E7kRHhKrcA!{aw5DpOYS-0BlZ_3dFaFK^_qJr3 +uETNw%~EdGg<;C0-#v}lqVqdsWb}NQ0%)36(D4r^*Tv&;C6Xq9lZ?U7kev?LSm2_CIdV+<4DVZa14NV +d6*$EAj^6)i$Wi{3n=7X7~_2)y{0iN13;wcX-X^VWozz-^U&|GhcwJ{9!r5R1Px|?><_v>vQhVM{Tp` +CADv%y`|n4rdv(P=b%(?5VBGJG*r)#Z9UJ!Ec83>ie9gx1`Xe^Fz8u4lUWfGu=T{#t`h&Ls4kz~C-(2 +;37bbw~OZL7uJbwpYyWjV(`r{v2cW}Wj`{O}xGy;Jiu)#I!ee4a!Z1fI*R51I#$FBO_@2`67@_GnU;r +>nUyx+aT)i3(P-ualpgY)absQ2F=017-}7v1;Wx48Ha5raAE#;14P@#q>>8^WeWAFjrLJG&fSzh_t1B +SQAW2=;Z+9d{Ax&F~r!9d%${Z~U%@&;Z{q{5v1_uLn3D79J1bYljVbZ?F1qdxP^HPQAwQK(ZkW{4kOe +I;=bFk8sWF4`ToZ^I<4}1So@^fJqdG$%qNz&>OjJCP68(Bmz~ +Oitk59^1d=pOAyfrtcALta`h?O>YMp?&9fu1#2O65^q$87h>;o@J|4jy=8<>D|ML_i`e*OxsDFVhxa` +B;&j6~6wknLc)B5|Z_ws+H6a4?x%Rf&i&;Qu!;DCPn=;$cmb9V1VVK4>Vj&mn#pB^!|Rsf`c=&ronU& +2Fr7S2hDR$?SxsTYD7`RGL(-b>RYby@=$;0egeM$!VH96UW`&(aoq#w5Iy0|{d`PB;9BtRC6<`6l+sT +ES<)GK_`3N;SPvlO=~m!Kgj6#n5vTr=`*&CTo<~Rg(dX-&_2~)iK+Hqx7~`A> +|8E!j21=mi$Z{|Cxp>+Eq;g{jZSWqbNl*1{9>H8NDH0?*lLN{VVGP|RdKa5_r*wA!_AM(1D +Vv0OnCUo33Fv%bbHeViD`XS}jQT5}9yE0?^|XnQeIgfDoC_SIvp8p7t)5+Z}fHeNKKD&-};KO$M-;9_ +Gk;_>2#AAVqdqXS +H(n&RT8tF|3I!JhPA=FOVu-<{3!sC8#E@!oe0O+2+v`8QL4J4{_C>!&i+KILnedI(GY320ukuZX3CUZ%mm;-ivfRa`sNu +p)qe8`j^dJSc7!3Ka&AXD?qjF|su7Ur^unsS^QpaszZ#q3GFHX%s>D_A2!|&;)*DZqR +DFU-FuFWRSn`V-#FHgmk`K5zfA)fTWmT@NoB0e#M%JD(q3wBc_{@b}`ndD+iyeSCj#(fgr!#;q~q^Tb +%D|F*wlq2PtapCoOnj5p+5XY7A9$68>lTkMqnsxhrXkXrtHL66~Y +HKzny8Ye|^2O+d8<5D(Hy#*Q?1YEZbwCam92B@$XG`2RRwt5u{Fr-KZhrV|RNV_&cmVLU4UPk4odhOf +Qlh>CfjGh;Tm4-T$e%@jE3~9X0To?<2J5QYU?d#J?X&9Dq%=*u{7fb6;!t@Laa2Xa>oD3AET}JF4+>r +0V4yV%&eaTbL=XeS-odR4!!BYFVFGSl=aVg%yEtN$4LKsvX?4=|a82-U@Fp_xQkSBf;xu&p6su4Go21 +%c%mp4qvmn;v{cPyWwvm$u<=1K{@X~1R06epD2@d{lrra`v)nZdK;4>8r6j2hIl^cYxH@$i;XoWK$P+ +^$?62Tr>p9zi*TfKiJy*{m~=q*s&jP(1bt!L$Y)0$6$m&JqyB+jW)EG%>uCl_Vxkbz5JpXINX6Hj ++UM)u-`L1rL)GBXr`Fj9>x2s6|(6+Zf-N^=&;RNbK>A)IZ~#Mv}W6$+g94d2N(Yr&gCr+A5)7#WL%W) +;Lg&pmU&o_+ir3gr8C8X~vH#Lcbh-BFRGpKi9>-J~6lCgms)n+WqB7*VoO$M^^;WQ#xR6pQ4h%9rFF_ +?SI^r*3q7$lH^IdZNbcLdV<1LpfEXgqbV{(GHEUGxmCAIMWiCps^(i%78lby6k=GttRCMG=TcrOP!XR +ks8rEW!LClA#1p%BP@LAo9I;OAd{0DKrgbBR!L?PIYx#x +rUY)dhoFL1*I4pW|%({8n^#$@Sbv|+!)S{N-y(RA7p8mbrk}8LG_oYz;#9RbfzR|P>}^_PvIy@ucZ#C7cat_vy~9LJroUmiS>Ud1DNgy$^ +XCF+iEM;(HDgRE1MH|GRV+riSOSBnsxG0K6g06|$DCb19O2tTAbp4{{2-pz +k{fg@Ugk-*Ik#E2vf#_A7W$S_RjXR&s?@g%;a3e0qEg@)=c+F;d{df%-Az36AqB?%G2z(@>q=+13VvM +~iJFzvDp6H@1B9MkKrd$@CM8?a>9sOZ8)Iu@yytJT3{P6m`Ac1l98O{?tr1py3 +IHn28BBW@j~k#&WTra%xqJDynNd0VTflAOJ0<_1@o%f1F$(^xsOVdIVaoz<;jMMM&vsv@_iZ +zkAOMaHeIT{YX7bcyj^fYq8qH<8Mb>#ndXjU$(G~*)9XEK!D~2EFFFEsQ@G~mQaNlb*P`v&X6x)#9<5&7(9jkhtW +MvlDtB6ywxb^AlUf)>*j%B%Qi(+K*}OjJa~dC7n8m~+ +KS0SX{%@3e5yw{Pq%417W$P1`6)82QDq02h7&g6kD#6bNJkhER}T;hfCbS8PwT9eFe;KE?mk5<#EdVI +2{E%#An37E8ueS|CgEvk3dMmd+GW;TTNJEf}#Un_DYA2{V;v^k(t(V#p&x8^ie3TT;@H-2 +5Q{etN5u;|1PTNNNyrB=&;DYF(p4_ulp)#DN2`)T4-So&wVM7;^=gk_L~aw*^WGUZ;7v6UxJ6V?g7hL +Eau`;}_}pclcn=y)#ahwc6JF54kE&;dn;8(H8wX|h=?#oK87p{yt{#xft0Xnd;9UME +0mSTfo=JRrI)udNNeVlrJ5U}7uH}?ps*5u>wH}E0bhQU?>DSdejg^Atb+V(lQ&LBlx3Q1-Fcn#GQd^Q +5Pq$VF(Nc9tWj9%uDsZTt+--GbdX~~3wyq(>ow*)APJapX-(jdcw-Pa24>R6(fcF}WSof0`^zv2w4^8 +4@35wK2BWQIHmZ#t?Xpjz3@z6toI-l>lzUldu?S>-=b?BprMz^Vii$!mg0}>m*hAFccXF1HNO_DCOS_|&MqRg#7tNR!$>VK3$;bCHA4ohmYb`X8+hjI)ze*aa>OF=Q?I;dmXN;mgaEm`WyQ +?wcoJMz7u@~&vJ#HR7k9bV)kj0Lg*$g}0tju%ohjA|>%4=v-==u+J1tw-l2(yFlRrxg ++l3}MZiVU9GmnLu#YxY4?2NADcQ8`=-Pp(Y{@4q<@JhM{ksZ4Fb7fIDoPY*>~jYq3s{&}j+ +atGtl~(!1n=-}AI1qZL^tXf}-MjMrX-WkScB +iZg^%{)YdBXcl=Q4w>cjw76>1e72iN0KZ@h1okuF&LL}f6Z7kUfqSUD5#58K94J3zINvln|gAyANQDH +a8@F@%O&ihhwx6v+q>zrixz@3w#^$y`QA7td0#9bTr+z-UalWuPb{9n>{YWZB}?ar5l7dhCl00!?R>v +cEv{{1yjKP;^jjv45S^7O9UhwJj~Qvf2J7i0+K2Hl^cL?Xe?+WMMGu=vdaETE{Ai#~0Oe+iM(z42ps+ +DU?6IvG!8+1Me+z=KZ3(6Un#x;3^JKMJGbcs~g!lGi`-p&;nIrRD +f7~G4W0M(?fE{czUeQQ#w6-%l$Pa@`@DXI8cuGZ_>NK#u#*J@yb`se@*DQ?U*TqCEH?oz81Oz9A~y*( +JUGTwpOD2ixbrHWroTv_Nb>4mp|SgqDRQi;u$qsFE-l^~GB$s~2eHw-r9{W77tfv%`fsZNhq^ioM4E? +;h1p;s{)tF>0kqky}B=Vie|SL=nW6i;sF6RQC_#L4V(E}q`5SyY`H0ccs!R9){dNz*6tJ4LPV4mJY-_ +iGvi!l@q~LSYb?gu+M<))d#>mGvQCi1IeON)~&N24?`0pB;p=8rzJr9?_(ZgsXn`tvY9G(y +ikMxw569_K;|vB6*11xwkqXlCMYcqHGT9(huy3_@@-X1FRKEJFQWfyEl6Oc9Hw;s9lim7AdhJ=8GG`M +oRKD#Ba^?Z}#W%oprDPMu4n7l>i85DBsMtyb`DZ?e8{2bZjAc3Mwn+a|I1%48dVnFu-wa9IJ#OTu`Ha)hQ$gw#m$b{M|&n(f$gt +w-S8B}s(PeIK0M6iiijfBU@%09llY}koyzR5OI1R&9bJ|CMOd=uP!Sd;s-Z_2Es8!F)u$W!*A&g6T9P +Ui#oNz@zLKJ4Sy=XWFx2zqqTkt4DAjtYb*rXTmjR^?jS{7nAnMzX@J{w$Yf%v}U6EB-$QM*UD*oL +DfSjD!M_f^gIgmyDH~0JE^|CB7btU7^o^Q`X!b_-d`zxW2d~J0#?*_U`zi8P)h>@6aWAK2mtS)wnnNN +XS_iG002h-000&M003}la4&6dWMyn~FJE72ZfSI1UoLQYODoFHRVc_T(96wFNzEzN%gjqjtx(9!Eyyn +_QSbzDbQA(A13bC7xZ>jzb8_P26>JrvmB2DeItof4Ii*-G08mQ<1QY-O00;o@p|(b7PBLxb0002z0RR +9K0001RX>c!XZ)9a`b1!LbWMz0RaCv=DL5{*O47~Rhxiv_u=`pIDnT;t>f?af5ZugyS5M}WLx8h_C1GZjx=dbmq-xv!{hOxgLr0{Jaqu^d=h^qX+c&Dz;78>gL +}2GM`7r*7bOoiPCnoA3z_uMd2ka~IauYJ80IX%u%Gv6uY#Y3*Q=bNou?*lzw-s)8TT!|v_$m?bLjcLm +gz;aIEi5anqJ9PP&Z?Qn^DUI@`I6(u*)u}aPoGs(!av?y-E^v7R08mQ<1QY-O00; +o@p|(cSF>h651ONb#4*&od0001RX>c!ZaAk5~bZKvHb1!CcWo3G0E^v9ZS6h#xHWYs6S6DMz0czl(kC +F1a(n_mUwQXNIiYx~Xi4_MkwwWYT^}qMn+)M&YTJ7?JvA=V__)sW$B9s=jsTEL4_^Fc05Vq4&)COqt9 +R%&Zko!F^_uZ$0{-oknP*`TTNHck=nCX~llMBA1)p4%}h=SMd{7b0~6XH9()?C2}N;AM}!-ejEdoYwY +V906CwNZSB2w8fJ=^K=}R2>aUr3$pHRR%f;0&4*%vgu4ok?B{r7g1WW6FMOdf@e~(?8x?@iID^@nW%F +hPDY^s-hs&4RJB#qe$f`8k*{Yh`GvfM8cbaoDTNMKBt#AEtJfXEEh?2m(ejM~(mrZ%$L5j?_`92QcOc`wzi^At{kuLHY11oc{Pox@{$_ +_S@A$~-5FY~@m{U=P6ZRJVgxhq`GsxbMhAz|Xot~#m9cY7avKvOg{Htvbbj1MVzLxBWvNoplNBuKC^D +drKxaeN<3`!rSVJf+$&P2w_H8eZ0IGxs0Nh+9X83ApG^93+r)!*&90d+SH+rqT9sNxN~cmtWW0bjb|B +JMJ+~0t;uXZqGRt%_7`{(^4!0+BA{-VW{aK9pCw!v`psX>|f~KdY+)a=exx`)W7<@^)$h~2j+eJfL|= ++|N7+TnK+g7T^FQXSDvxi4WlV93psDs)9={cDx6fB6x>0^@LnR^gxbl;1ok{s+797{Jk9et%NonMy*1 +W&b3e`dz;Dfu#`bZGu!XZcCvHahtr@<*p_AEq+ +oYLbJIRZ|n?6k`nxva^>8Iq!c_*?1Uq|^TM{PizTO9KQH000080Pmr;MqFvq8Grx)02BcL022TJ0B~t +=FLGsZFJE72ZfSI1UoLQYWsX4##2^es_nsoSmfm0vFx$>@D8YdUg4Q;P_aBQ0mS*>p_w#??k^wPPtxS +jz^HEsA|D>do>6AjDZSqOOs4PpyxJzwxO(8 +k{XT6f#XrJoJ0>)vNTyKLqUP)h>@6aWAK2mtS)wnpJTuGR_)003qo000vJ003}la4&LYaW8UZabIR>Y +-KKRdBqxQZ`{W5`~8ZA)PQ7jVv|n=E;tmZEww6OOOX_~fUVGb2dP@o4` +NAAwd&dkpHd~$NKxM9C^T(CW>T1mFNWTc@&^6Fu60=tW?sP`nxwq4r^mSu$Rn_9GlZe(3{Ez9)#Vqw; +6X`ckMPjXkXX9v)oN4@dbc+YVv`lPiiKkgwyy- +EE`cRcMEiA$VYcte9me*Aa`sg7A`vw1Hypk;~ON(%+Up*D}DC{|BP0Q=b@e}*1zJPPCQIK;XYLWDKUC +T>{Qq^KlOa3d%D!T7ww%hr>sP!3(MV0|4a6xPGK2jRWgm+wYzgXP9`sewZ^X%pvU<6C^dfxyOv50<-c +Wv8z#y|2iDj-=!O9Z)07O$?}yg7e+H-Q!Z{P}}SzCBI<{HG`Z>OWmyU)|iDzs|0%?=G+2-XbRp0-v7C +lohUtIg`2Af(x=Pa +RSQid`X1{~GJ?t2pJa~SSmIr#2K=fDMOkr+#Ma6NnQ&;8D?SU1Y60<|vnrtvyNXZI(@$YbK4q!n)PML +&psm#2O&VMND4Rza^gLcPAR4~~_M79EA6?vj%$7W8=UZ3CI;n8)Rq=-efwIDU&6`6#GBNheQlCc-X=p +5*YOM(W*#QJSr!3#JAlNoxaSuot{Hzm=;M=~h^%AlxA%W|6Um|96z3J-%YeqZY#7${kXYg!fL$XQuTg +d?J~TjdZ_7mCaZgra+5FA^d0_vg%H90@U1Ur+R{XK11-rGXm^vs}+kZ{4 +0j_m4|wvF3Z>9RaZxGVj`+lgg&#ty+we0DwP0Qp3adT2{3lg8ZlERi<$#cI6{)KwS^)S?@Y;Gn}Av<3 +?6>`wbII^@7gMV1WtRGK=?p;@uHucZk+-KqG2!7^yf=pi56P0cGtBvkvY)z7B1iv&sxSKk4rRqyV0fZ +_C;$I7hoY?Ad7bm0Zt+uCXjZEc@L->sqq|5ew}Y!c-7eke?sO-40wOrzoN9N(@#c7mT)m@E0W>R-xu{ +`szT1s-{q2Didr?pi!U~=Jp{y?P#mak!l@!6c7vZTA#`gc1NEuni96%vb5izR)srpnkw1Tqe`lv5kOj!P1hoA9b%N{6w`thH57|~NM1!v%lv}8!2gS!tMm@sD{2 +!GIPT%rVaKqJ;#!vXU;?}WOR=dQDaEvGcXjsw391tyWUfkMlthVxjxCAo8Z3udk?0%23LU{!WG!$>U# +6CEWHPGH!3PD85n$8tve12oFyRYai~@rgfb@Eban!74y8IY`_T?!cp?BCsVREQ*wNvuZFto*bzg3Z0) +a6HV;2;WUQ`tL+Qgo`?u^pNv;7$zj;n+#K3***c8IVjok#s7;wOBQ6I*O}k0;;vAm^gcCLJ-vf*0VS( +ClczV#5Wb4;Jk=LDMtAi7yF>s2P1?z6XY97)ame$MC2P1PlmLf0EezrDQfL%1G|*%>w+Oy)(05$h2%n +YhYsEChOyQwM#lsK|HD8j{evPBC*+)q7z; +BoYGxXoEjtYu)Z7fujF0K=D}hCt^4?Q!%x-I}4f2vX2qK=uN*1bF9Nqio?=kB$1;&Dbd$RQ*g|>wM-E +vg*Rls*Vvr&7C}ipi#@G|yQ|k%EAno4RI+toKp#C@Mt}bF#rX55FG=)~K=G!AkOx+le{+Of$uQByO|t +EphL@Xyuk-}_duE%iuE5?)r7Q7rQvp^nz#fA_aj +PB7k2p@%GAT>ksb`HJus0%8X~2{nGjbB6WcBV!GLYsw#S@Pu`vgk~mZ0}5u(JHqxs5PWg-{k@($*=V5f$Ol572!BnbA)iBhXQmkN~RQz_Mp9Aq- +EFOvW{?6>$=N%A|TVq)^PGj~RaSKqhP=!)fjfYdcYa+D-mI%Q8)!e-pY(4lrH9u|K4xx-Y-h=g^|acC +2hnZM;^|(o{-%DcjP#g(5)B(#8XbZ>PHoH(3ja9E~#sWP8o(9ao)Nq`1E^(|01*8pbqHuD1L8(bkVnU +?Ptg$T-+(T{*2WoUF=}ykq1*L33c#2SFP{Ms-}sYX=e>pyand&ZV|vH>_kxIF_v3F3Da#B*P)@{7-l> +f_qn_SahwmqPs9dA$9k9-PnpZ@x)0V1vL#U=3f9IZLbZshBAXd(T9i}I8;Lz3mUnNbA(tu<>ynzW)nQO9KQH000080Pmr;Mvw=< +uQe(F0KBLG02TlM0B~t=FLGsZFLGsZUukZ0bYX04E^v9}eQS5)HkROb{|X*^+@!`5>#;MLJx;6BnN(G +#PAAoMs*=gh+7647Ad6#)WJt;`r?>z6+y?;SMM;&e-raMCr@JDPzy)w|adBU`Shw{y%ChyY-?bvkqGH +?BZ6D=}t}b`I$oTJ*6ZyWZZ*Pn0R{dFb>Q^h&uWqyJi&FpfsEhPs+pLRH7ktRu3SjB)zZU%YWQ~1V6< +v>jx)lFa{aSAF>Q-cJUH4A0XlQU*SL@=Izl&{NlxdT0Sd +Rjcy8xEER1x6|mS*Kc0@`KR|o(N+CWm36+-o$Rt*TTUbRC+q7Bz-*=w{)>On7buap%MF60Y0;p>$E9f +cqONp@lamOZ*Hzc&Wtrormu*`^H-3Z(4!rDk4b~H@pKw6algR+Qte1HJ_M)h==5ZRey9#M0+f^&kX7@ +$g@A6Vq_tWU@>$lm9m*2ho;br#y*YE!H@?G}o^>;7deEt2)Db?NqGOd;@s^L~(LYp#wl-OvueJjKiX7 +P^RWa1-CI1s}kU*7GSY*n;`B{jrFDd?R7)n~HVuIK@bdV_xfyyabfieisp2h+^S!ww?w5K-;OFq32w#1{&Smt5h7PzOGV&J|BN=* +`-s2<;1N?XX^W@|NhXIUXt{7W-EBf!~U6N&0z6F*zfnqDMj&NZW4G=-!=3RnQG`Xay*+TVJ02k<&o1~ +3@PST4>a(#96^YzWm#r4hPA7Wlv6DrO1p~{=O67;56M_Y!356yj5XS&=ry>07VlRTT~GTyi65_Z{%J& +^Fl34I1Wv}-G;#8kqC@h;1}>(qjNCw|!#t=Pf@C-ve##j=NiGm#@&fToK+%aTr%Yb48Groh0qqRVhTf +O8THMdF*|h@p{H(c@Z~zsjMzQ{7$t;A)U%^Dcw+AxlQPW|jA1{zJPnz+^S^BCg>>YaWqH0-eZuk|E0m +3fSfV=1Mhj02ouJLc?T2q2Uh)336tji28YAV#A#|Ko2bj8wp;idGwdRo`hR6%DA +uW3Yjs1P}um(E{7zDOacC5e_(=yPyECFsN{gTA~L6OWc5Y0=H1rh0Qj6mKWqRIo4Qc9 +wSz?KPr%yE^W%X8P)ZBDv+<|?PEl{UZjKw2mdI54*Q}H=En}Y(brMe*R7yI-v&u$aOaTs9r}}GH|9pO4cBWH+9z)IGn +aFOO&}L&M1u9PILUd6C{3-#04dY#oI;tyoC)vgjxDLuoca!*7_%Iw#bsK8hW=u2CjZPTubdaP(=OY5` +Uy^mnlK-ugHWmHM7aG?2N6?*=*&W2DS2C*=Ha@jqPLf?A`nJZFO4ELaFbg5~{vKW~s}d>_pmyk}5Kg+ +S(Qf+TXfKG=VK`7-o1Upy3*$v-VhM3ii~z?K|WVNsOZ5W$f&%*8XLvJ_-Cb#4AgT^6C+t=+D3talNI*b3AAX)Wh8tziCqesN7|D`Emt>RKfth*F{r +B&T-iBqW;`J$u0X*LE(QgXGsXsMjX&8UP!EQdbt8E`Wlnh0pgE|&EWiVo;EX(q59RvxijrsDwCn|OAu%^h)o4j-o=hgGwCIi_D>nHZpsTFwyAC>k2OQ4eRUieDKpT$(!ot +z27L0GQ%*A7ZPV~7jX=+z}41An4jWS{j9NF4{I-#_=#t@*5wX^8ofZ|cGl_ov{fb6+**9ulnJJ?N-cg +%U%F|HT1ICTQ2F=^xL^g4Y4+@4CKfZ)%PIjkTi%&{J1I@Ay??ukQSXS@Z{h=PLw;-eCN7rEk`t$EypB +8drUkg#p4<$0f%1zV3_$s%JEOi)v8aZdKGd)G9*XW5^3YO&{$t|Z3*8VqT|4NNa+GFx2Dqma0R>#^mG}3%f0bA1I>h&90CRfkkrZBTaXO$Te3M(KPx7C95gEL&=L+a0PUe +DOAuR7kV0W6-c{JKRUEVp*khu3M@xxn+FW(H2_Whku`Jew80=5}=olzrR=@uwwQi8_J<}!$<@nEFRh0 +idPS$oM>%UQq-Xk#|vL(h@2DG{qXzc+ZDvP6wQF=Z2aH|u~`shmMY&`~fK^l*Zl?h`~wn|44L%U<&Ch +DsvTxj#1Pvl*60UVTt-SaMnMWYL+CeIG2f7q&7)@q4K#*(ZeCSG#`a +bCK3F-*`-(Szn_d@Sp*1KRy`Ry($vikIRW|qr2k}%Dp-rYj@ve0Ir`&Ea^wNi&B@xD^RAB +jBB+QYH%4eUL#8~HrBL{lBIU3W-_*T?G7#}Le}q0W-zFN3X4uA$+z*68$}h_bMvHI^77y^v1dmZRlVcc3|7QqB&QXr-w%^f!k)-Q +GWm5nCH!a4_zF`>ufKBq+;!~2+WS_*4Sf_GggpY>G&x>BYtJFkozKs)kMY*5JU69!gWb9DO&*676)QL +GNM8Y<;vw1J%VK0)zO2Hei#6X-5nr1fc^~hf^jC=UB}WaxpUw(NY^4}E=itEyE627U3^5givt;P_5{| +i=bBQ%Qt9??g};+{MxQ~;i<_dE#R1>1bQhUm{5kp5xl{X=Z-`T5P1cyQegJl{&r0N0F}Ucf*Z=GLmzU +A&j@1g7p#`zvh=fu^s+>9`0o~QFqGWSR`_bap)__(CbmPGuXfX@Zn!$lQNoXD5Bdr-LvDn=vF&S;qt~ +wZ7K}<7OkyY7=zDWYbB>Giv{Md8jT-6A#w_VK|m~MZ+ykj_$4scfe3It2h_7)>m^@3%_7PM8y!OEZ-n?C9Jet^d~)hqGf!3)r +_*CA`^I?L9C=|;{RYrT!X)^w>PR))@6*q6Y0MBX9&W3(Cab7Vp_P;9jmzFE@I*{mKKwt17USTJH(y2x +TwpFr)9Y7Mpv;B-g>@g9%$Pwn>2S)5Gw^lgA-_|_?Ymm*RvKvQcnCx^(uEbNr^w<+KCZh2hyzzW9HjE +J?!oj!|HD&GwOw^}|;p;6Qvv;Fcl`U0}%(d~@6L=A^=bo!>2zGUPxBr~zq4@>IWJqSs*FexLVv9-Rg% +Z_%(`j^3($f3N^Ybr=f#g)(A50za8{@YgGsnMP7t|RZ}5XS-3u7X9SJ5-L_cbc4<5hM2Ji5YQ$s9tkK +#^8iG@d&^RO2B<2?sf~!*~vl^EbD4yJiCVXj<$GrT92}@1>3u_`*m|HD1{0GKOu$kxbBDHokedS`%PU +v$3q41Da%we64DMvBvr+-UfHHH(8b>V$8*BCrL%EISXrY`XH?bPkdC3d>Srn{Y$E9%JB;V0AmPWZM=1 +v0ql3!y-eS$=IVH@M?P8#%E*3IV0mUE{n=9TrB$B2|6;z&i +HI=Q$K**x2kvj*fEA>z1;%3vQpfOa;}b-ymfm7&F~s0owT{SEus4%;`-q@-R~8X#zIX8iTw}=kwDemXa##6gCbm9CBm&GU6#y)K#$C-ZFJ3U@8*%YXYwhmLB>xdX)9$!(eg>?oTY!Pw6B +5v7rzQRfhG4=oN(-sDUojL*~^(zWQ98;O2(r~~oIL1#A66}@OPLS9D5>k_>`rV +lNC?PAMABrRynCUE|6N91FyXi07b9{B^-Fw|i%80U(|A@fyYfv_wiT-07l{7#zs0fY?y^fo4Kag${vZ +PGXLw8MUxbbFv(<)pRTXl>uW3+ +<9{UMQN{VM7~6|apyNo8T5cb<&b-gHTU7=U`I`T6K6;biTHbhAV%Zi(NsR@XQBTN@V7&JMxWh*-}H{!m_urJT^974j(L$vU +N2Hin#ckMX!OCq2mW*{n5)_!~RpRqYodj{)Z1}8bEj57PO__RRsnp7%0)vo>-zS7eS)>N{`Dj0sJ9*odFXiswZ#8LJqYrSZqgq5-=h|jaw8&HefXA;%z-@k`P)xgI +b3QJ$;9*o%zhPwQC7_<2tG44IIg3nQF3ZJv+>$0n(l}TOw25A2l{wn}oqctghoK)R;6l2jik~FPebn$ +2Cq~>ZEL@26Naup_?!#HDb!@9%fZ~ST&8(mX{H5MPUx`{`8o(PeW}xHW?IE1&2^<*)t0)7h}vQX#$2+L`|{0V-IWHk +j{+XQ})t2(2!q?yemNMS+JLPi90f%f^7vWNhsmNJYqbnREFdcDHj?7!${R7#&7p|yCCNShS32vlT&Wj +HZ|x*sXNUuSS{dmljsl8vpxGW2nTH+p5i<4I0v0>vC5;5m(fSqQg)bXVL1CT841T7;_}NLkI0~&F9+dq9fd;R9spJPwF#qU +8&_vpzLTz(23AJgDC%Oc>3rEYn#yS8j=bZ#fc7)uXw03=G-3ILtw9iL +5;2*#OHO^kZCMtol0I{R$Sx%ccy;az%@cSaZ0v0`OsuyS=A%g=^+30Q-Jg9)R;VE&wjVmSWK27r2j+c +h1Dw`~C05aXZo*pHjjZ}JK&%lsFufPKB-ps}8!evCId;08EKAoyTc-BtBNbvowK9C7nc0t+Wd{W^0_= +;I!bbMU~R7u12;@{;2CI;jQR3Wb){5nYTg1{aSy6ElrY7x@ZLKVC-X?dj<88gl}<#l7Kg_e=8nQ!WYj +7>+#p4ZX3>d}FQCQfn()?%Ebu7AOGB${zLRZ!k0?)blNDxS*DUy0Av|gVay50JWfxtO~Brwy|ARDz^tdA3m7<{q +O045(`wAMxa$yDp$~8E{Y8O3MY}pC7JmMQ|HW7vO;6bPHd}Q&`T6bvSKZBCA#4m>XfaQ6><-+)>L5c +Ra5hzy;z-ULL`5Oy`l`QfrTsI@Q(q{d`81eH8l*FcqN{XmJy+IFQHL_u#J{bhpn4T<#$AXj+yH5K=I- +90Wk5uJpJonZ%FY(aqg&+wpa??R4NuVV@D+#d_t)vGWK=OGMsK2^-0H$W)&D9!JdLgfq-I26=#Es&dj +RiQAtVGbWj;{xXNclO=Z$!NfveJ2XK1It71yR1EavkVY#)a^sj2PE}$nZC!2+~6Tm8buKLuu(duWwQD +Ezo9i3uU6jC8*dG9QaG%%qREP9iDnoA>bk&H;Suo$)~1(RZs4jZmJNLZd<(%wZ`Wz`+d>0@M-#L})B`g4$&2KitK&(>C87tC7J97WR;RcdR}>y0m7C7R`)8^MHlLIj@ +Nk=bavF1}q-QHyp}>Ps1^nqu+zH?;_J8?r~5sS;WX1rCSeUxjAY{41_+MFR;e?w@~z<($Pf}V-)yrs< +n)*@M%eF_Acf`WXMG4WMc?OI(q*?DKrmnoV}mSN^4YUl^Y}d +d0s%(%o%6Z1z8|+q`=@^hRmKoydR*|DG~J?j*hTA2IL{MDris>(Ku{J-)*FhnqWp&wm4`0q8B +A( +!q&Mil3y2;0LLR*hI$XI_MC_keWZW4Hu-~vaT4AuEzK9-){7Ng9ZrP(>C>krKwR0ml-=tE=Nt={W$8* +DEo-9$MI2&PM!D|j3;5KQFf6QAb#-;=xyd*;=4UjcHL6o& +CJBMxX2~E1~SY`<7sLRBc&0sw8T9a`J^OKq&fo_rau|M7DEv!qC9XH2jJa9;-;0s+Sul{heOZq-vi*M ++K=iDAD5w~79KFO>5J`zu+&scg7^lBfMq|77KB92Y^kdxR!#F(1REcre!ccf!WNI-Gh?kE@rZjYr`e2 +$=5e8%b42NIxNe2yos!1*p?gnKD?tf9TT$(~*if$t4K8&~oE9{otSc~z`2YV7}m4$b6=JvwKzW2Q2@eP%mK0%6Yvz(5Wt<7=v5?oG%dw^T81e~)|JJ7saF=u@+)Qz?|0CgxE`FCGRd +`p-F1hWNLSli_@xQOe}Hd$KJZaOQHh8FHLwu~x;(|YQ7a(N{jiZqaWMfO6-uL|nB0OM0|QGQCIz~Llf{It;)>!xepM@S!Ri +-Oj0+6WeZYSf?!H*8jlKeYi$FxHH$(R268MnJZ2@`+0CJ*F;uq*aMCzj)L*rxc`DCrbYOR6?`m_l2X$ +2fwrA!#^I@<#_FpwZijsF#((b8&UYLlQqPJI}ky~E}800M>mo|_3z%$BADA}o@(=iWvitU^GVyvZ>A- +$nDPaIdq#$8Lt`P}iY*>|TBM^$#y!_`L^iR6hXNFaBw6@dSTl_IYHj|GSx--53Jrpb7_0OKivkAX76c +dN@hq=h2e*vQNUuAnZLyNz_+G&WBD-%T5wIJQlcbiM9tB7DLPfRoSu>d6mJmWzs6uD!ar;SUMEtNioR +dwF-G9mW^TwS(S!A_JK;3mnB1gDFA-@@!884(eHmBJ^KPRnWy!?{PRDL)#uZSn7f97O|3Xn6Sw*(nHd +j1D#8y3&*ppXWE_`&Rg$G(0pnC#c>2bp-|^Wue?#{9eG|x7GYW_2ZsIZp9j|M?mn@TZ=lFeoPZ5R(xV +{!L-2St$!JXpp5?|hM?@i!x&}TE&+%@c-(&)}xGU(BP5d^>nN(q3&y%MW&4P*Fa+<-a7x^H$cl(OEb4B#^EMqlD{bu*>& +Meb!X`ws@15vD^_<$<>Lh9(ZVMnc*9hq&CqBFIT-t&{>|0dGSk4jGTlZeUN+s@BBbTe8u&6@^eVKFb! +`FZi70s(mA$p(f*12W0LWTFF_gZZS!F@a<`LN@+^yDK$`*p=Bp84e|cPaIP3_+HY09PV@ +p^93D@*@^vzkb#bGnPV+st(aM`50cFk>axTm0K#gMh21PxK|61#KCIROgg3^KOU6UdUd +HaGt8~NhMr9G{9f;d0pCUdX=*)hfPOKp$PrFO`{sZ|omN_k>c$vNXPw0zNx)g9XA`_|oWMj^&XKS7kfrsB@-d^6*^gWOdl +04}0AtDE?Vai|ToN2zv4^#K@Gs`3B_wP@QbQk=aMeTi0FakMUGul!U1?Fj?)B7KB*z4QBU!Qz9CYfK; +HD!H?jtkmKqkZW=(I{pSq$@#7-q&k0(F?3H6g#~HPM^G44nB~*yJ5TSTOn)($}p|TG@KL%q2&N+ +uxWBU^WnJjoU55~^S)HRf4i9^YTeC`yuv?8b7&>LnWm!m$>Nwil;YDB1L1$T(h +Cu8BGFAMVX!$NeF>UH#iX4z@9wwC(SnYk;JK-)<-%#Lng%GkPrDW$o*GW2e1)1m=#(Jd(xAQo95l~La +qQRk4|>RF>@u%j~V#ndK)d{&tvd5J@=A<02V^!TtBqY8Mma}qmjEUTvM)lZvBu=H!(51UuRO$!6BXL| +DFx&fJWwu6_{KCbpS_yjVL!yU)Q#n@!vNa@kmlyJO6ihc$gDB_+_toEi&zEk!4K_-${M?Thn)rfcp%F +HhgXZ>5#%y9Wb!TCB+6dAo!JNx_A_#vz8}Q|BmtFlSEtBQtVT_HHUGJQ~TS`D^yU%bH4B;k2>84un~R +0*CTQ*C8Fcb;XXV@odXnZpf61YfE-hpD*dtuahQ}? +gX#&SdtgRo>m=x-#JY%nyjXl#@x(+_mtCo(x6D>7}LX<9|tb%Nq$GqeUC7dvisbwr&C(Zk#xWI$oZW7 +6YB*WgKL^{8HA5A{h*r>lFf{5~=bA3mo)q10}q9Z)CZ5Ji+K!91}wat2NVD>15)Y_vIh(wD#jD!%UST +xQwZcW<~oNINpo#`wr78TA~KedJT-)pL6XvW!VL^1k~;=^PO=A(eGSRWm&OA-Au*0DbWKI?i*ilFw9( +;10U>TLZL;;=IrOa2suF)`Wk;<5s29isIvtJP` +rdJ(yfQy>ZEP9A`FVjSkD1cVi{bbvNxYYW#Ec1E!gBl`i;@Tgq5 +Em{G<^=p>X(u!s7hMIN8Tp6EXT5Ifq|uZKI=zm2RW~7(#Ahi(!u1bOKjr*%&u4IKTiIE92RmHE@Z@xn +PiZ=Sg+TzV>8t=H-RA4OmEwI*Ca9rl)h;G7ljno;ot?`mz(X{GQkW^m%KLcKr)#!DtJ2{hv{y;X)Gs^H;`QOJnS-0`PXcd5P^nkd`E!aJ(dM +J*$9LbQR^zR>6(1WXd*$iX^;c)VyGg!!`+Hmuf4KVjck`Qz$sAwM!6WtNbTW`4$suWC>i+p9(X>&@> +>O@1!@^cla@u+l5^uVmD(8%?nEgOk&lXyb)TL$C}-XVL35reHu1uDZQo2)-i0ifc`2Juwf&HO6mwp=^ +0=5Fs*$y_h7|S64q@-`reW-w=D%De92Q2ZX@utg18Jv#rfLtzN5d&nJ=%nWCW!2y^_Y_G}l7Rnkx8=$ +P;<PAP +*o07n1*&3o!tAZNrv+!ky-CmxD?e+q&|5C3j%;UB2K__e(VofPxfwtD1pl1VL@$JseYQ7V-4s&*I%T(UwBLD1e{4m5Ad +7_bDbJw6jSs3vRV>4`xNTS0s*$qC3F+tQEsN8edqNar+E@?dZ5LD`6iQ-Z&FkAkC_T1wP +YU`3C!Yu8W5=gBw&%eOpc}NfOhit(2l2sqSy6h3leU7}ym_#Vz6iZ*?enhu0)7=b#WkrJ0Th{noQVg( +Dn;-C~wYLN@bfZ)*PL(tdDXgZ9suM9%hGFKtO8omTP)h>@6aWAK2mtS)wnl)?ebR;+006UR000sI003 +}la4&LYaW8UZabI&~bS`jt%{={&`hv7tw>W=9GklB7~jge>^qUF->+Wnuw7P{rO3LXu +B2(0iyiOFE-$j~m43DBtE{W*QkoYr++MJU302eOsnooi@BXtXW?*JbOyv-D>P2e#u1RP`7+n$&QyL$G2a$ZQZWfpJAZ?60L+cZ^~B +i{Hz;^eEo{eJYN*DYm04Byc8vdUaY7m2&9`jouylBNyRNd +GGMkq%T2&cS|P07!idid1=z_gc0M<>=yR1)VuFMzT3MgJCcJOwuQDm +N3r8NAEofD7^pmw-FFF^?|ek)#8k;}!5@c+m!^d%ykI?Or?Lau;4`7c4?9rwotE-N~tZGWuxJ-^A +WPIyFv4Kd@VS@n%d|xX}El35?3iH~zfbJb}9p5LsX<&IR;qO(1jf%hrHH?kSK161UwF4Zxe=C|coL9w +noYTdfyk~cE!S2`++b*A0Yes)ymyb`6tCiyWKqgJ`>e0tx;fUC;ck;It0$r@xBKfH +>}IcdL9DiP?-&5ijcS>1Q6I|z0<2vM?U30$u>>PG{pa#&=$q6B(iB@|hr$bSzVS_>tjf>-D6KnqRlpl +vA_^k*Eumt}o26S!d~!H&J`*cQHGv#th~g4R72l^}F1=nU7J;m8sOg3cMQ79FVfwgs}vGdu7qFI7*(z +i;*}&#{>lt7K--y{JUXJ9xoLU>U1-tnI5!R~!W(ghC~%tN=x>hd&kF0Xe2gL~4O-#`C;DK679isA;|j +erZfkbzkPD`++~xumZqVd)J|0(wbh?B5X<*pEU3Jbk%2_Dx +f7linU8gWux^UyRd_sTBZvp1jvE09hQPEX~JGKc?yMRmE5m~jGo_fCHIMTBeAOq3xY#2?s@$KEG}Oo_ +_KC?D|s#3=H5w2Z|w06jL?j@aDl(4(LcSUN6zf=x+|%(|D$&<*iuA17?J`uIQ`a6ebU%&Qy!ek$2faNC+D#a9dh}Zi2TzDC$wUwe-}LR6D|FxvAfY?ouqY1_ua +YNTnrZo2frc9ISq6PwwF>@D@ZQTrKtx{Ru;W$aO=o^2m4d3!EV(z3s!-bu|OWb_h&opd2Qo6?%+GR3J +E|05!!3)pVBNbiv%HVOevA#oT~9{qVl+qiATS&vYl{nc6IwB0#mwI7kgOaqaJ0{uv_J~d8Xj^X#IZjmkf9vj}Xn-I`KBeJ;h6t}Bf2h9S;Z1~%4qBRa$JN1`k*1r +G#`+HZ;aK6ID!NARLOWpv)Bd@w5Q+5y99{JgV2SNfXe+zafM`oVH0+&IdA{Y>13Jk}{dyp|uy%IyTeGPj|LoF9zlbwB&+7TWo*+zy`dg!bN>z$T8t-h-Q2v)zur@ +rIT;1g5+!IQZkB;L6m_6a)ZMYDt-yUw`wcuCQmGdc*rkxrmV%84ybsXhG{Ua3tlf2iX{;hj`}?;Iy=v +>^B5NB^vIm6ug26J8Yp0Abe1Nc=Xz)3g_DX?KT}vC$zJEz$8Ev$tZ=o*{Bb!rfjrFlU5uLMuoVa2a^a +5hQB?wn@q^VU>|MG6fs$@DGFEZgO@X2hHX4&Eea%j>17`+s@Mn_LH +2hKw4WI%hHY0(-hprFlCA2gffI9qq)F;iz-}_iOwmzPP3i|G;WyuhdBg*XJErm?X-aN+nkHt`V$DiX;rNm=(F(zp#XAhKoH10Ue-ynndT6LkF?2wn5pVNNo;$+K +CF4#;7c8C$IRX#V1FxJK{0o)6pBkowQY8ecQ_LVatf25S8T*6l0!j`&wv40Ug!NdlBdnC70rjJ8fRk@ +@og4wmN9AvaoFaCijAll@V2wGU6Z%519>IdD1kM!593!s(n +35St_Ext~;G>BM-DVHYF+tdPAwU0_OyEzMIVG8*J!sVU4>296Y~jCtCE=0HEcD4ymXy2kw|rV3*8zh4 +TPo!>~H1{P7W#hBLT7xrHR1!V#qmb5)ck`)ElPg0R!BX5HB!#_r^o9Y7d=Qt4foeZ{S)&r2fnV9Rmhx +EEUE+21K>htR!!f~bAzS9k?zCpTBh>%1d5&OzKuA+)^j7O=c27Er1oYV +U^~0P>!MBwtUOMty~4+Fk=lI*7sGNmq78j_BlJO{-5l4$b4H>aY+u54F8o;|&En8{%lfut6e_`zwPon +^x~4QQkh*L6p0=*-o|7J=*_O0WjPuu)=%Im|1=YBF%F#q)B-w-q=GJWejjcREq>(9L3yKB8zzv_p7j> +^Q(gRcW5S~X`IslX$5Ju@>xJJ^b1J6Ma^X69<&G?fR703(O +vuzxH|WFLcPYfxGhEcfAB4dukuffeVOc&HA_K{CT#PksPANX5bPfwBJw$ftchwq+8_{jM_HK%Y#7)(b +b_KXhfgSXirTjv;!_N8QF62m)KkA9HLBf|kUYy1c$k^+$e3T(WZaDnSzD$n?@6t9j#wr$1V3I_OCimc +#ht+00}+xC`sW|VK9AQb2t~x`r1_GsoV2E`k^iZ;4$#L`x}tKLxE+k-1RBS54a0K_?vzkQ6px|^)1SV +tODRu9Ht`G8S9h$wk~1x^ +t?cq3cXGvB8R}Y0~iIwjK{tMW4<{Zz+2xCCLOY7+wbKF7}hxrr4+Z9qSb +GP;@u=W@S<`x&uAZF1^|4{O9sRZs62dDzL?roJ37bX%H|O>#~N`x-_eo?^T0YEx`YebLkCPnhwjDD!z +8+$3wJC+15C))d)M +A1d;z#K}$!S=Q&r#i7_vu|LWtsb(2$evR9R5W8AKU(V*XZu_19#-vGdyWXY!Q92r?LGR&xTnN2(_3d$ +aLEl=tj$&y#VRLZVEX$#B*BC5cDRZDq^dh{^=4V!R~>0FHApF*IlMq;Mr#*arM7B20DITcg5(O~Uds*Kh^owLYDw*Y%IHTmm-1_&cWmnG~?HKyTIyhe*#A%F=qRRe?7UTv<+`dHStt;# +oA1+J8Hg1WievR%b|+Ey7Rs*B~3|3dJ@*bP~VCrA>a(rRI72_BxegTCl*Rl&7#B{A4K6;-C +pd@L#>?&pqgIKm7)RH#i-0WOoigk3QQgv0%Rn15X$W%{9xkSS~jrI6+n%h=Jabz51WcrVz_13#;UarR +Ff&lL`IwrXB_p!r4ek(^?mK68eNs4mWYvKz{emmO0AJI3RP+=I`qn3)M71msrIc`w(e=COJqDx9~Zl( +>47bVhHQz+=FL!)JfiC5NQ|P>Uqk)A6?6<@+!j=Rtl#XGeFX$lUEY>UFQttlVakw=NJJoXtq}Iq)4W@ +=j)J6Xli2N=$vOg~fYFpu1AW8K1TKuwbxLO$-7XHyD3ujPLLGd%_8k9!k1ipjYChZ7_qDM-17UcBk2- +ZTcdTX_3r|M+X4BQ19M)YtTZT_C=|MQ>Ar?EfGmQ}?S?uygSdVnhN7kfOe(t$EM1^F8Akh5>ErcsrYf +%afa;;KmqvbRQp%ojLJ>8s2d`QBEO`_?Z9}Z`oG6!rav9F>MbTz|Nn|V~#n*UadqRa6(>u&X+LvVnFx +VsV$?En@bwp2R*i)es8O%+RUQ?8gk4{ +Wc4ejDT2uHPVwg~29W~y&ppAxu0-ljnBkE%=HrEyTB?)%yYSEIr+M@7gfMWy2^D^=AyE5mvZC&=fReG +b3CDqNSYRZ$U2Gyu6`eGT!*D<7e&9U+Tu8#ArsR3+@hPE!nL{~MeXR9t>RzIkY~^nqDNm1CnP +bZj}+-&xwN<+d)ai)y4pUEZBHN*v}>2vfB#}yY)M$D6c^;kB#XNUE;|i9bPu +VwOTYX(>h~pNY;RvLuI;Z-MPzBtMr`L)~<&W3uAlh&a6YwiC<>E)W*ICxLQh +E4P6_vFG#2~!GyrA-0w7|#XOsdTucX|GR#12*7v5n++;9RM+7;e+6Fdq-FFJNU>C%vPMX9w6GJ*9-1; +5HW4R^aeTfS?O5k;SBJbhxu73k4Aj?Q8L3D#SL&q{q{G?sr{YKn~kU1sghpV7T3i1yyDdJ+=cj0x_PK +nglvc%zpGGb>QTWv4!JpJWiSs(~jyKCx=+G1)V-kn)6~R#!wMl^rDIB;cu|`UFFTlRmG%3;g<49+C*e +|Pt(n(3#)E0KfW<+^@Wrz@8l{``BwOE1`MY2z{fNLB2*&DnR}fM1VIt`46KAscEEUBq4tbqgJNjv+Ne +@a%Kk`+!fp;LJbkN}sXC2?qp& +xXdgwnH65`#pjHq_L#bPkRk2BelvSH=j)=6yISy!YXkxdQqu8ohpiDoDe&e1PWc-TdPo(n-U#pkL=-9 +C+w0;^TY!woW7vxWFF8f!w8J}M4ILU7CN2yS(+6xC{u~nTdMO~v^)X*c(Mw2npN*~=slCliyyNdj#FR +Aung6Jm$uAYI!WeKreHit^dqJahAlmMrE(E7fI!5lG>dfRbn-4X9WzHNUcjGeD)9{RRqRldd{8V=9Vi +U~+@QRH_G(6k?8SWY?bf>vV(NLJq~J3h1bLL$*Jdcxi6B&2=)9TnE`ah5PF_z$T)W^iUT-yR;3E@0V{ +WD^pWOq-5lpAMn$x`Y!KO$|s#JKZ@Ayjo^8Wod3V~uMXu`lSo)~StiA7YxX-i9B`Q4R9MtIo +wdhs_)3;fw*#W$ALB;!)R1Sl>8mkzdmj= +E-6YT>l~K45hr4&^?)-uC5S+tGnrt)t9lcuWHHb03&#~LUSC}YLCTwMI?`s_l&2_Rh=ov3d(4<1~yf**P*Bg{=@rY3e1c5$Sk)0-hDEBg1x +efJ@EOR8)}iRFWgkSF!;3#?9%3%dFDNii)nH5MAPG5;l#8?CkWBHiu-x977{+)*4qb}O3y~pz721sd& +St*$zHFSHWaSbCuMK;YV6i_O`&~siy)0hJeRWH;(>$6c2d8!4;zo!No%&^^NNRCHP~x5G~#WBJ5Zd%- +|@EgttY{e>#$3x9S3HaVo7zD%{v7fC)Q&X40nds%C9E}8F1G!CCdK$}jGqXc!-0D&bDvfui}fO!8r67R>p$yzQ&JsWP+Wxv)2DWKr3hwLkH|Lkk(7ykb;W +`~KgrzP0-jue&Mbe;;n!&<-Qn2}p-g?#*3afVv|{%U@coCyjAln-)&{8wj)vZ}x%cu#OttyO{&9xSS2 +9)UP2?#-){-Tc5$q;}*i-Dj<}r7LbjJp7ym7w9E)_AS(xh +1wELfu^LIwhE=KWm5Sqcyla3OpcOje-J`T;A)Q+^9VNG*esnWzlO&0ClK3ay?IQSC163E^)O3e2FG2G;rVCTqLrgP((l&Xl<<_O^xIG9~9M%|rV%a +&vOVIEHFqq$VTXb}JFJ0&`sws6L)Dv#S>YDQ*)jfG6;=NUNUYKi7iKex_j2ADeZER-h#epex=x_IQao+ATBjpH2Mp;zOf9 +@M4Q+Cb^ROhMk4RI(TzszVX;?pQT4YJ;9S0_VK8JD{&ZBL*t~I5FN$?ws$1=8qAd+TaguSK)Y;esB*F +*?#y7&b$r7S^a}kkTmkR0Nqn;rlUT~vDUYGn%@u0)tY_6+dX{wU&pOHpEHN_39=y1+O$!dNq&0>iao*)@MOjjHRQ@OCbKwbO@*czlJLQm@kpjO|_VQb +P6kw?!HyuLO`gB$NYsV3>uQL}7aCa)-xSXE+t8#V`# +-|#eNr&0*XV7+z{6;(B21dxQ$)wn2`u^8xiyUU2WyQS1hR^(sh1T`-{|!(}0|XQR000O8@1eFv5jjuu +UZFeIU4x!t}LE(S%h-2w{ +~*+sJ3JUD^Okth$>8d4=GkEccdd(YuTq9jh71l2>V5y^A?&W&l6Jd&zv2Qw&ERfHdVsSKfeExW<6%Kh +GK{CD^hUOV~t$i-v$DRp?$=ke9BW8d3Lt)^4L=o_zarqsz2AXKCmtM@Z;OR{q*7ew3)rstT +$W=9S-~|xX^}n9mUT-C?(ajeK5QmcjoG76a%VMKWz!uRVQoOZArtmsivQb33_CDyCLaENOhzg|2L~Z> +_f3&R(dN0rd%{k7@+;Q*=%r)DY6TuDj%8ohy9jU6>_br0=Cs1)p}CwXJGT5nOyFFW3?&ntYBAHSAQj% +ftg!^1|=wrCPtDy0~L<)nKi(im;)oj%tUyCS{jP|Yv8aK1T2A`{noG+yw3$URh4Vjwaz}CD?a$Kbli3 +*L0-(4D#cpxVtTPR2Uz&ef9GG31AN9m^940O^AKq6S8IYYq0upP8^{044+&lM^FUfsq4QF!V^kS^M@V8{VF`$d9Oz0eTA8mfef1XTjC>Hc*P1{yUh6H9gVDTUgo$Uaq(GR!_p5baj +GW6}NyMnd@_OGqawdUGQ~;q_Bxs*CP-QKDnXeVIU*4M5^h*IArhqF^dWV#-$Uu<9b{~Y%fpO0ph;N@@A-!Yn&;-y%^g*7 +;&=cAk$WfVx1Z!^WmeRbK45Oh|jDn!sh+YGc1Bu6FJRNHnETa348}?$HEcbu-M0PupmHjy*R5Y`spHK +#s0OF;S8S`zW<)CWj$Q3j1R=tN7c-R~&6n+a3HtHNZ+pi=X?pKP>Iw@?L3ky3(!iWb*zai<}rGo}m?! +ytVNtE-=;RleJGo6qqecYPKDf(6D7|D-Tv=zBFQJm;`?)=_uAk;+-mLc$eErp@J{@3fv|7F_oESt?D+hu7&a|!k#vUM5v&T;t19Mwj>i-Q7n~;%g0)Pn0bbsrHwRn8wl_EWBiea&JxRl?d^)YY%S< +4)2__!g-E2Q*UiA&$O_g07wU5~e}u`kJU%t}p6j6n$#>b!7#G>anep=D^xtJLK;FD!gU@(fuv6t5SZ5 +rUXVUG&&0AO#E+k^eQO;gzo2^LeRwaQX*a;p3r +@!!KDV#QeKrx|lf55mY)aapgFaz&Dny3OITxJ!^{FR3aY2$@x2N^fa?Zo@ZD7i$EHNUR{&`p@JINz8v=!?*TgV{v8ID6qsBugXv2uY`zf~80>c=1fd*)IfVq +R1m0Ecq4kkk^F3s~*Pw-nSi{TRy5+OoiCN~-RnNE~aow}JDVwII*=1ScQY$gSEv9&`asAS)rznTwk+^ +(JN011`kl9%jBqa9UP=KmWGxXOVn{_ZrBa<5l<9S>6YvVV+T)^#$MWKlm&U5sA?iYL7o^d{(jnCV#L^qW)f$d``>?> +<0lx?{)MWANrUCt$B)=~-DXA7o$-jDnr0$rT`2IFSY`mU&GZDQiLY&oWsf6fSOm$`K7*+g&Ms~=-oSq +AaC?_SvXAPc$Q+IS{KqF}X1_Eod{@5AGpR>pi*=kf_Gg~R6$=2{zp-0z*xq{?AdTX>1&w|2A9S&Fh~< +ap=Zl^5(p{F^ovS2^D4W?Vv^@?S6mZ!RFlPZ2o%BGY%QCkH4XB$wJm08<)^MLAJr`ZQ<_qVZy~8Dh`5gY +*2#p@6aWAK2mtS)wnl+4j%URl001Cn000#L003}l +a4&UqX>4;ZUtei%X>?y-E^vA6J!^B^Hj>}Z;AJ>!e%i5AAZ@<%N0clFmG@XLVDhvNes{8}ryD%{;d~f6 +i-q-J0X@>b#ERbt>yFugX>r@wf!&MUmjgqo%1ETRE*(fRnIe24cv#tKzn6rhrri|p9XQ?0y>bHzS0;EZ86P@%mn0i6Za$4QDwcF +L~pRiz%|LM9oq1A!93GHLx!UXxXFA!(>Ev&g`g(jN>{!E4e;9AS&~7P5;w*{t$1Da?rQBZ$|c*KA#aC +=rigrF98%=DZRJEsSZh<9GtqzW@1&(-NwOK?GxrW}lxR_^6w +G4klYaAHN;c0=iI*t7QQ-&Yr&;g|qm~VD#Ulfy%?7K!aW%k3|o)$HMPp3*?JMMTrQYEW`s*R=*|md5k +oFq#xFt;+T3NMakVVg`-T)){8K}-d9z&E~Lm?Kmtt2Ws;M4z=(ejKE3X@wlXv;T +};f!xT@&kyi3&H#Ml(M@h2)rTgg7#T7nH7;i&2`~fw!Zb~qKs)KkGG7n%AAqWm)<@X=2N +m=w}lJ%nRK1b`a%S<;fC3Bfi;FzU+>d*>6dDIgCqSggE^6^WFraI+#>vg$mwS7AQ*o7mCZFfmGCTZwZ*M}BV;dF11WiT0039u3iHNm_uM)6!3O +{yxqRo}PH%~KaMkuN5kU?<8Wm0B^Y&7SM6ovD3nN9`H-4qE6W^G +n4&$0xgqlrz(pZ@QW&OwUnhE@dTJ8huU4Gh>qGGp{%ANDTQ&!P+xS*rn)L4A%2nq{HSyZU%&xd$_70p +(^3IaJ&Hs#00PX!va02LT|fa^+Pqv#BSFBrz&)$h$j}31S{#k&fNMm$Zooix&=jEyguZ1t8@*5#E_g) +EAjQ9vYZ{%#$M24wzqCB|0Q&|$>X2y=)-L&MuDGU4fDkgpHISd)9iJUd94O!@62Yq`U!a{9I8Q_^f?G +?V4wcukA-~hK#fpw5u>8)lV;ro$gu5P8Pci+Fqko9qsY>E9DS)~t9*I~$X{k5}R1x`r=>M@}g7~IanW +iTA`)v+WVI~6GffdmD1AUkjbV#T_KpTix +soM(2YkZ`c_T2gR2!>42&!s80KJlR(cRJ>hl=fBf}5^IHpCG@Q=kP%#$z+!R@RdN)H~b(!vOU0MPMiLRlWezBTyo6Hc?TFY7TP%8q+#21EZsyp;3#bXU^1R^v7`y7@Nmn1!4iaO +x-v%{>q1Xs8P-+T%JL{XdSlQ^2?43r$82|-xiR3*|s4BnEf0(SB=e*WSNyc4uz0VoCZ;KPY$5FIGo!> +Fy}S}yv4=ny$Oh)swC^`EyFG-av=bPY~Ec5o?CJ0lM|Q>q0K`fY1~BU?RzJVpC`^FE-&o0ItX&D-~91 +2gWsLgBzx1#c>jGQnPgV{%;s>&Z-n|K>skd)rO^CVpGX7NH!7hixDp4q&Oldf#2e$72I_p$;|mMr-KD +2z|afoIpr_1qO2B(!o?m2Y1ul*5ERBBg6g&#NZY}_^_D}0T2`zZxlqF9zzc^F$W?T0wZ#WP*(y*#Q5U +ZDhG9;IAgMbD!vV1DiH5!V8Cu^0nU<$AxsXd*{^_*<+Edvti&v*@CvMS$$nF}1g-D|@(|TSc8z2C8#v +UhEat$jFt)}Q5iCICPer2$oi%HDH`?S!x!sm>W4Eda(i|&93P-Ny!YI1CU<|q~?(BBZWN~LNL;|n_*>I2!Z*AKOh1$-xKsdU^-!9Xy$c1XMH4aPBM%s5^(t%^2xU@t49{hiWd!s9n#(U$R05W=d>k!~JXg-D2;3}DhFh{ +d;E-WBrchhM%ufAmgX=H%~u%pM;AmlI|f?DX`YZT%KS0K{{4Bf@6~-zFb^d3yfn+0)6h)AdYw%nFW@J +0mRa5@m>Qj_i^10I^1C3ee-71rt;Q^Ljw(c^zT!14dN&-od(?@BB5;oekDJU9M10FuHa&j&Yswf-Q8g +3%-|r{`k={1Qeh`q9zy^hE(i*A~g?S*;`)hCOA&R0=334DLB{?!X6h7~^O}hJ1Gm;aG2T`=k{~zt~e*@(uwA;lU +yn7&dM{mCeT^C7@aBjza*zWR5Z07%PxK2CJu(}2a*Xm!>tp{*Lw>{yG?-xOhOd{oq%%^yJonPyUh)e~#*^4)@&H(>8I-a1GPo{{eU^I0vT^7lPat6SY +F5YCaYpytzKt#?Xa^;DYm^pGeD14kcX8}LK+V^_tcjN6-4k(U?kA*#5Z@_M1xN)zTS;F +KKDOhF@*d76NSf=hur27ER(c?m-KGSSw6-5qX&SQ;h^Mb=?s4&y!C1`BW+05~y)<>?Vi+^g@2z!(+H` +X<+Kydinr^}O)c`Gs97({-j|hO2j|^{e?@;Ep2DtkSUU7#>bohpKB#c$mCN(Q-oyG}5MOTL^3~^HjR4`Nyl +ezy;lo7Q@A?Y8n_=#%TmD;D{P5!Go9r74yQGJXQ#Zm!=R_BXOsi_~3>!YAF#bIplITksGrkTi(q={$jZf_b!QS8lX+~1Mu!7#~LgVA|eTz|?Cd3_ElpjK!j;38n{c}{66aShQ +G#1BP2)B376Gd;u&OOH^2%5G&~cWeV51|>oZe7!**w^YN74p)IyO+CzKRym)YygWG&^90>x+I-3+=O3 +X`(CtbIiX989xp>u7pJn+@{8plb=`>8>kr`KJpFSbUq0gjQtdRp~{Sx}XT`}ZS7zH^$ +JLr#Lh5)Htauf7sCnsI}O(<+>mCw!ow4*dc=Rq>jMOKwTM{9qWD66YPW9|ABGKAUO)=b&PW*$9}PDn* +;#x4nv!mj5=14C+O&Kgbr*70hLXXr+pV-zCWAk6w3h5h{sn#&&3`_S~~y8(`4bFcPjAcy*IVsP~5Y`g +<5yS1CKE^f#A9zZ=}8V0dd>615o)^=~`-88woPxavgXHJnR_tKA}tE#~Sk+_we2Py9{%3z5*i!S7ic3 +n`g2Q~UryRm{##X&W9xL(1z&fi-sVvHKC<1wx*_1Y@Y0$(C%xq~e^@d&vcB%6W=wV8L7qt?LXMb|5{UiDm>;L{?KqJGm$Qjp=t;dlJ$e_P9-kdiCRgcarc=Ww6NXn-JDhZWKgd3iFBOm* ++5Ryo4tf@6-7sX0T2$2qHdGyGk4K5s-eF~Kxd`aLaa#$A`ZqZa(M#~DVvqDNVMju8`5Ws$7>P9;~)DF22iXYJ)%)I!?_K{U6`_eSaHyxS<0~;FtIeRy)8vPiGd;^m&bYJ|7-vh4hyM*s$)*1Om)<+>_53X04@VcJxf((3E%6zfx;0vP(QTZ~#>?<&>I-{|c4BU8041#GO?Ttc#>!v{!O9lj=|jK)w-ts)C`okjeH=#iFU!^%R8yoc017Wy%oPrtEd`_<9>NUy2+P!REm1;9 +22GPlTn06@f^0k`Y16e5KD3IDMm%EYZrXTbz8I9PbQnr>a}Tj=gDG7lWueZGFGWIZ|VNK`g*?pfz&LN +b1VgK$3Bq5B1s6=;yqCh1^0gXd$|~f^UEMih0C_#41Ongk@1xjrcDppVd%v;58XOyG0eFj(4Yi{&^_)?+4 +Wew!{a{w`{U%`4srL5)G%XBYD=R`2fBI)-2y7q+HS(C2$i(bW2BTEg|rchIq`$M5$;vre +DjUi>Dx;2Pac=Dwu4D09c1QO8#H|wcf_C#Oc?DG|4Sx}0D%?zlPnm4OVobU|4|F}f5C*Qb82pWv%6Wp +_^h=% +xk0@W3PW8i0#)cLP^FJSZgzDqBQ=ML}15{?tvM;ws;8SkEx;X-I{R$~x0`U^ +o0z*l!7;C3X{11|)rmJ^#)mEMvR@`ep3#A^&D)-iFk9v%+cVx~9Pv?>9QPq_@&8!SL~2gSpfge%r!xF +cd81Cc`-k8s|3A0?qjQTtj%<(S$_~MyLuF$Gm9_u-q6C#bmR9u*4zHU18e&k&kbh^?z>PLW4!0CN(9= +Pl)Ge{VJ-mLa1Mhb1|0JjW!5{PDduR6ls1J`a-uK|m1v;Z^QtC8L+|g|&&PKyXLbu6OH79qp_ZYfh$l +8+M%bo1vH8%aTE}Pvq|FV|BAsM}NlDDyXwCFfC&RL2Z?bjDmLl3{MTCYPF(BSL1nS3peuI(JZxt$!>J +Bu-jXh#qRrXKCU?oYkmB|-hGcYG4v7Tj$b4Tf9p2RH32zy#o3Jopt1H@)4{ZyOGRx!66xdpdM-3mJkG +BRTeKJ>y~S3A==Vr!_~=%(Y(Ti)mp$g#qC77*o@c^`muDO!O8-pAxRceIQ;P|NY0K1C>4eY*?^L7I`Y +#d;vi&sPfiUQPwJj01z$Qc*Mat7%LTmA}NasyjGQN{IE5myMwcU=4$e{-XZQFwc$(J>9bPm$ZF5H-Ki +T!A{su0Ke*%Wt{BS419z_Ypt;#XvpwmY?%pL{A@D%G)|;C(N@;_Rc-REtvxAR6J;p^W}-a^SPwG4RyhQ&J?Q*2#A#4vYq*I%jrg8*KB`$g#QzKUlVtNv7aH6i?-Ts@$Xv; +(^WPFKcTu(SFCZmAYQ(5h?`^Mz7MfUT$M57gFCvnq#5GDHV`TZr!Hl2sBcz#dG!7JAEu@dtaN%ykL2d +YYQKr<*;Cmrh~Ysz7@$2CV*@xoJxJMZSf#gFIv0UZ$1U;V$wmYpOaFb_d)*GU_3O|Vp-NyewjZ|JC>8 +h~sf%Ai05rwJo!dRX&Y-Px7x2Ya@y2|J*mC@7n%PTl?A%(^_}x8C>1#t%ZaF1-d;FF&YLvQzKcP3ZQ? +dO{jce0&yjPf#C*IClZ(5o@BsDe26uqQ9NPhz^3Q#Q?^Q}guf< +;nXqD#@AErivbi{Kw}|loa@His&6;7Cn#fuITwzo3YIT4Q7JRm9ft{AS}iv9(6aWbb3R{Hww-s6REjY +_ci#!!`-83`)p0>_po=zX^0ez7#!^;VXbg7SO&pvuxKbLGiY@&))D@R8g<2rSHTWS3ko%POcLu?^{yV +oTHa2*1=QE-=K9I0_W{_3&h)~VaSqma_^fl|AD`YmSfoS(o&Bupifr2dYMoo+IOJ7#zxbl18( +q)N7liM3J*qgQrkmvP%P`=odV-*r+<70L&e@ByqMvqEd%#$3G*l +9~aD%+cpTL(q}T%SSnha&U{)}LQ8xQ?U@SA*_a5%CdRCfO)r!is8QKcUSk +Tntm!8$wI~j&CX33FomP3zhp*&Y43;xB)G}J2o#R0~HBfsv`J`P)3HEab{?V_arF3#N1Mx#7L-RuB!@ +kAc0HikR*Q7dc{HnDC(9KMs|@jGrU*C=9cv`=wFVX?${5 +4M-I9Qk@Op8mHsV-IeuFfTdc8bMgIHD`{0SwAP>EFTiQa!SlYT5MI+ecxxcmrHM!VL}((>@|_1I9Y-s`|K77io@W7vdc&4tb#N#v8RvXJ!^pJ0Qg +hr>vGusBbcdmelk+s>CVfrVl!-)>6ALE%10ilP}ZYI`U5P^j=uB|hIEZHU&790VSzoCI@Cy*6MVaV7g)uk+b%yRLE7YgY>x-j}74vR|mh0 +X(?nCk7~LsVEMVFedQevE!+5NwCGDIbJ&Tc`$O>%Yi=`iN9`g2`cgSZU;-7mkYIjz3T_Nim^{_iDs@d*dw7(yHtv&%!AH +3fG=4(U5O?C?}LLQi{IIB|n$0IaH^ZnO>DsbXVs*k1UCcz*75=Q6V#@Vk^)UE!39r!walN2tU<0*W~H +WEpS3l)0dm>go7Yo`B{9C9i$hJDOBVO{f`uVy~P>Nwmy1ynzn!9@BWKRCxl75x=?sefHG1KRp;P)h>@ +6aWAK2mtS)wnp=qrB?_F007k^000yK003}la4&UqX>4;ZVQ_F{X>xNeaCz-oTXWh<5`O1b%qm+2xUg` +XlN%L#i^6v7I=-!O;%o(%GDri=vC!yfMgewf&u`!E8C^kKoXu99ho$@gXy)t7bbsAF*s`qJ{e(;63Xh +Q)l|<1e7LZXSreva2C_C-;n5#)Vv|TZ6cU{H5v%aE=wP_f7Jd%V49+?V{k2v#cN)Q=y#fXR_62?&|B$ +IZ{0y!GfaYnId_R`b}1#F9mhO +Wg@`K(z*F7|1P)rU!pnhn@@c;l$sG@^Q0eTNIyn)uk730F0+VJTO5YWdpGjH;_oj0rSXkLB8qG!F3op-6w|=Fq^ZF +jncQA)pjfHk+`Bk-a$ZShS}#A47r!S{OdENgq~e95$!Z&}T9~V%xR{SK^=C_vzpaOdE;$;5HH?4yy(q +l6OUa7dLj@DI4_TkVT-Wc|Le)A0%gTdvSenbKNm+8pVOD&jNhG0#6c4FSpXbuXgr#>c`C1aB1f7QJQe +M5iiI`rZmiuN~RMkd#1DN2vXU`cXl8m%-u=D88hX~c;JkL4~}bC6$)6*X00Hk>v@_}@HlmXA?@@^DYQ +U)xLPOuH^GAjzH5;rV_T^sOhzyt>;tl~L!T;0`YAa&B9=!Z(A4@NgV{U;H8Hdr)^ZM8o6UQsDX9gLJy +%gU3Ko2CSU?a?uiHC6bmPsUAfg$gXi=GJqYmdP^$3vvYT}0 +#;$-daygQxB#c|&L99Va$01@Agp~~%yi~sV~4b+T_sJ>Ero$`Ql9fI?08acvDSs1wY~PcA^?s%%9#dK +NNRan#W8Lx%lpRau(e~*lAFzy`nOXBuaa1bql(g3-<;+3W~+pdma6Q_ssg=>9!YtwmkzYPwmKJ15^D5 +Toi>$S;OB}d>Um`rF#a4>_9u;Bmty?<;j4{aFbuBe1e2Y4uLY@9$zs*SZR9+IB(o=L>2f1q576dp+h; +Bn&F9742S$zZ6X!(@H5NP1i;ZicSchEHr?5rAWCqdVr4=elm +1D%m)$;^))j7}Ycu%D9{v0fqN!l<=Xd8>8gdQ%?Hf(v4d7`968jn9bPgJ7)f1X%3Pe^^eAF4Kbv +#ftibm1D1BQ?;ZYY&Uy1*Jl?WH#MAels25pn(okRCOoj^Mj-99e}J~CiEtw$6`Qky`Rm&=V>jNOtb#q +~ZsbM6HLMtl5gXIU!wiyKu>#RaT|1FpBv +tb042v7;-7{>jB%|0{niY}HmWC{#&#Uo*ikgFLh4>j +EvBMyzPahHh`E!>jD>8fTRIe}UPpgLl&7h)!{rJ`PGI-18W4iYZ5Xc`2xr2+C+=yY$Ngd7DT&*I>XAu +_ChwVvP=c>B_5dMc_LDynz3W7aptYJF8&`5st7 +qu>kigxml=T^nw5Z(O2{btH$IKxiG4pbeYqxmUoh_g7BUHr;$f`>no8?6^jg`~H5`CZ# +1dohu|fG~Mh{z&iK~sRK0tK%zy%mE7~4ioreo;f#_I_5C4rpNMXa`0v0^P_TzE8QFSH!hTT35yLZ$CB +{zL8KzQl5+BDjqA*u6Y$h~cyCOn&08_~sGrcj$BPOf%Gz@Admny&cSr_dBA;v>;0?tgW)Mem^{3|aM< +@=@%v62zgYAvr>%4JyE6VoZ=(b^s5E2|C;MObOd>;L^VcXkpaPiz57CRW%taO%IZMSi!FJ~;pN^dC;| +)7{BkP +|TrpmuqB?2;3VcwLrsa6`6D=ywJ+c03t!MO^5eWIort$R?U$JeD@q|B)f_KQeR|2WT_Ue{8#B{x|L&y +?cG|{{68@vI&(AqB;l(#_P$imQtsSL4RJaCxOv!EW0y488j+xb!dwaQy+pvcs^;E#l*s3v(8xDZ!yMf;dUXXtt!Pp3obU*{r03MyDmLha> +x{8mxcbyk-m#~}rFl|w)XmV?46@Vx}s%L69jGCo_S}xH&=e%*_Xu4xDA=NK(JgD&zv|l`%`Rn|raIr6}iato!FKtx +M-o(Q&uozP!zJZ#UcRRi6KDpewvp=)X15)B&IM%_qH+MyH-6N`Gs^IcQugN6(}4)95Wm%p<=H1~%Vc- +{AF&fBUhimG!-h*|8QPkG2rJO4)>{E)2Fyc)n%)82=oz3OOzw13b1B9HbujHHgguA&0gar5RkgNI4%} +C1hn6N~~oa->Y&_z+X^H0|XQR000O8@1eFvzN?04-vR&tXb1oR7ytkOaA|Nab#!TLb1!6NaB^j1VRUJ +4ZZ2?ny;V(X+dvS#>sJga0U2B$dTK*m2u%)wkOVi-Ln&fqjifEBU9q#W>wn+bmE>5mOnN9425Wa_-n{ +u#9LLcO)Fy8gf~$lBSvRUi?FgJPO6rpT0kz0j0R{rbX*oi) +rc+jdiR}Mzs#p?i@w^y)tFVc*AjkkD_R+1Q9&T=JwUc_fDMj|BLGg_-R=2Xt2TB>@dIAZ257}pG8^1G +wPgQ&P8tlfBHATw|CE*yRSDd_fL=CU=2U!xG!fN|77cT@O>!8=l5UWq01!PYlo!`PFX1(GMZ9l_Wgl< +JsOQH&ar?~Nm3(`C~*l)8%tvkODLq`4ygH#8v?cIZq^>5y9%#;WU>fSkObPe;HDGw!g)Tk+WwhUPev; +K`D@nQX*mK|gcB+nGnGVb7D}JIqR!TPG3Ly5L1+m<05!OkLa76IDtYL3w6L$_wt~G>3M!# +5P0(CNALzD!CvCzn7HPY>|*TYDyN^}q5E{VPJ>8QqwXyWIk;u`R;X>DT&nQ=>D{40bj@30omF?@xVi> +t|@$US3)&iVNrqj{^I#;{)cK)pnAhq4zHxU7z@GiK-0wx8x;FEno^=U0(v8Wa`;`3jM#kvj(5q2b&*5 +5ucVGQmDmz$@x3N$DV5LwquT*KkEKhuTYL^5X|BEJ?v0&bxrRf@TP|8(5Argu6p~n4oF=?fgCYvT_!E +eSFu1NZE$7z`-(9ZP=H|cG9%O@t)_#C(Jv!+iadT$DAwNq4I6kXZ+$mq6wT2ja=85J8nx}(7g5?d>Gj +J4+E42T28d`*oR=#hde=J!a-vzH2i8ACd1=~AJ^s5yuCSWubsa_YmH4#D!dqJjt6{VJ8YI&>vPNhvzE +H`?1zol!{9RQ7$4V4d2@7SZ7y(mZBoH*+b|5h`zzksLsK9#b{^oN`MM@(+2Esq*O$sZ{m7Qi97wyLU@I@q4< +zct9SC)q96`_C2h+~P-vnb5Moi|EZW!C*EgL|%D_J%PH8Y;>AbRdA<47cdE13SqxMd{LX}ZW!=4g$NT +u8cCDdoL11%S*vxTS}dnJQ(OnnOXXl+fNqt3Jj}uvE2A +$crgY!ppED+{Z6V8LB)r&qshS1{lL^7P-5wj+cHrSI;ribN=kXpvczFCO!t%aidB1OF2($r|@6aWAK2mtS)wnjMXdzPpK008d{000yK003}la4&UqX>4;ZY;R|0X>MmOaCwb +Z+iv4F5PjEI5Y9uTU6&}fZ$(|y&3an{UI(xP1jQl{Xo<4eQlvmqNxWa*;YAYVDBabI<>6e;%o)z8QnE +pLUUjBZG|v%hTB!^oCoOqrXzu?fNst#(82Vy3JM|JS&u1piSATI$M9Hbry}fL)1BG`OWDs$Aw5=gev~RBP~~5p9?~XF{_Q^bMZGeIup!D+D +N=#=xF^E{yWhbIAnZJUV*A(~sU$;)-ylCXWu&Py|Kcc8E7TfN8;r)@bWwz{e-48e$ApX@46A2{?2fZL +rD-Q%!lbgb;;PWj4a?3t*pH$V9vPLUd6QRR&}5xI`x?wxhv=LZECrw5Ovl^x*Au0g4nVI_3H|E(WJhl +;c?peZUgh=~Y^IE|*!;#RC5$nMl73r}jw~Xo23nE`NsJBhH}pV`bY(RtU&P*I2il87tQ5z3S)~{c(H^ +JPt;I_1s;w{8^DUedpeFAi|znaZAgTi8i7qxa!m4Oq(>A0_HEEyd3T?KAH=s_^>%{?(_9-7Z3#(!T-= +kx7Lb%rRCAU{cis9gLG)6iL`I08}w0%9}Kht<0a}^M36;f+rWcD3=*NJbXqleqT@_+bG91(k15{X?d} +do;B3m(4Z4Tnh6JUh9xgco!eJ)3*;li3P4%z}d{bFXE}ub;r_A?xZ4QUK!*asKP(SE1TfUE3wwyP9SR +eM={h$A5{`Y3LyL*T|Ji0f^HJ!`(alEKGG$k{69@<+w23B??M-4H{51uv6lEDfJANG`83o|6x$J%0V3 +dn}E)-W;eA?G?JfVPM8U_)1bB2d>Px-Nw0Lkj7e +=>^wJ!#aRbSI{`Ka3JfDOUEFUDp8?4V#_f84+%CR1H0)>B1-^ +=7%z^DV?rWmIz0?|gj@HNYs?4sCI7`oJ+|pMyb&J6cn`Mtycq4zSr^>;p4}_hWkm$FS_wZVGgzsa+dp +4_df~5XUuFC}K!-W5X+MRijcFV!n0^{_0$oF5*ct$Dygvez}#r4e|KW$TJ4EQ3hF}w@Xgv)dynp%HWl +D%4v-va?hafhrvlb4+>9q3Iyecay(=;=&!^^V{>jDBYXGNSJCzTfDskiiwDzeXOD{{T=+0|XQR000O8 +@1eFv){1HaItBm$QWO9H6#xJLaA|Nab#!TLb1!dobYx+4Wn?aJdDU23Z`(E$e)q57R2Y#5Tf1P`fS`E +@(sV1Dc14pF=(0edrQ?{1L~0~u$0+*WcMf%>gZM4lVZPsrBP +XFA+EkBlX^Yn7Ocpj`MxtsHt(6by%qAd`BWwOyQxSd9!=-qT51?xJ8ks+5YSD{B3-8diKY8{OrZsI +n$+-q`E{II^GCvOP+z;bRtSCvX&jBAqS^I4+tVUH#)~c-q0p%NbX~DUaYnf^kg!*JimC3s?T1=&rYw- +Xtk>zG&&UuDoy3`qy6fmicS^_*j~5jh_aEjgz>_bC$DJ~w1PaicM%o +j0p?J#d8W=nXV=3}ZcuQgRu2W9WR-i^zfDHGTGNVLkmwZOwdNi7h!N~J8Y&m8v2RtNDSQftc^IU7C=j +`YK;0lx-x4ManTN~E9q!;)X#o +9&ELp~GRZkpW1115N>F|UcDG4zep#lu!xS41`gVU&sP}`yoJK*GN;8fH3qYHd_jxT$4`M$)kGzPkaHw +W;1an`$hJfu%JS7v5k;S4g_TkjVQ(Tupi8qOY$u>(85tg+D3H5W%T@4@wF;koCpeLzjvOwd4KiCeIYT +LodA5SToVjc#EtXR3OAd_1b+?Z>(1+1nc$^KklUd|ky7eQD^c)*S>v1yw7Yj=5xIK_j>OqLHx*$c4y- +bx5(&@NWq+*)g@MYRpg#DwzN)a0uK2+(*orKv-hXX$U5Ofy7NAoivie6DtseI$tmv&MRCb$T>2D0hnQ +=P?B1$98HzDPMoS&M8Qm=1%iUB)aGVM(!yjxc2d3DhcHGb@B)h` +db)X>wj!p<}9+~P9D^5n2b!_0;?7{ijXr&&*9+41kW|1&4Vn%I;$A5FZ`02)PV^7@p*q^-+De>qzrU9 +=&bljdJH*$Vr*z9!lARhhvnAPq_j4X%-LFPu~F#W8l5f}i{TqCGQPwy^B+kf& +03XN$`GiGKv!Uwz12J=6&t}Fc~3 +RcvxDtkvi3^&WQDz$$hJhV|-(E(> +bvYzZdm+u}VHlE45lI;sfb~aauPvJ+Ma`7F)Shyh#hgubkc8{{8mTea|+@-ajZ$JI~@6UI`>(0r>rnj{=d+yd&{w8J;MWeS{skTXSD`>w;D90W7&`Yl$g{rg}Y<)U;SF}cN +jj*=Z@LupeH#xgir4f5l+Tiyy3wNSvh3W17Y=B*({w1H}sVT!M+e)QGzvW%{xmY-Je7j)yT=JsSjW&G +G7cbZ^+F7P+M6a%efvHRwqhU(P73B6JC~-S!b0$^UbQQsNceGCIKawazh@j}!tM*Tdg?K7O>)1#C2Y3 +c^(zfh|ebP!S77K)$t*vN8>DI}ub=h!hSFI5+$cQRuHE)^?FCVg?MyOJIBW@^c+&MD{7qx6e&X!4Lnf +tA>gSaIDn>|1BS1#7##h{_zTmB@T8EGe{I>*4K`g +g!yQu+9on!rt9|xV>dakisvPHB)-nI5yB%H(*RWPpm5^Jt=+K|t1Qc(UHa^zuX96wxM7X7ZgoymyW>_ +^==$w|i4j^uGAJnH1{1d?kbfChyZ^}xR-o`xs%D+M8Hi|}qGIKx6Z$vR}lL7N9V&WVr?ArXK*aV7 +>lDyz9FB`8WeQaZ%Aht(8hMo}i~eV7`Kq6dVA0QFp^&kVrgo0e)d_?i{o6|qVlWq~h&jQ#^VGXh?X?LrPl8!1CI8rgK*n>E3G&g`d?NNkWxu+;XOdl**dr*z$l_k|1F~~v(5l459HG)6-G!azY +IP%OQCqr;ojeHPnCo6OfR(8gsYGzQhLmwG$7rez6EBCVDrVn<+3dz19)z=o0Lf-rGDz|_q)PGVG`a{k +(9hD$T(MQA^g_XT7-sAz1Aj3cqufEpgCMm;4KzMK82BTgV?ACd(EOq1pn>yr@fA_|}tE4S~UeGhxvDTKvSi}ZkGB^ +rLjUxA)gVk;Ra3+e$~Bez>3K37RorwkU*!qdcHmU^6%_$Qjx2j(xp0ahPVX}~Atj7OO_M)2y`BSD=C1 +x7q^`d#!%?7#R@%^?F6go3oePY|&I-zI-^)w`?F=N`3m=k?-W4hGUY(rdc3pPx3AnjQM&rC1F;l +WXnB;vZ6O?Zq8y*L0n7Qr;!Y-4};q(&23&Ryv4``VK>s@TW?&D#cE=GZ_ZPPdX&1ey;}z$Or=sPP|g# +Z29c4zUytA@+@P`=YA=Z+a89F0NLK{gMPe-=72O^M1oN@Dfa?bu7p8r0BWgk#^$-yGDjl241>EO2 +r*K5PwE|CkD~#nDY1oMKNXr3ZOdlAQE`T|<_xXylnu5>|3O~o9`)f2|HYP+;>3kL*72< +XXI4wLWG~rjc92Ajeqe7h`ggn_82wj(3QOFvcOmr`QOyaKCbZ#1>m>@>>nZy^eQVo_Q=Ko^yGJc6_M0 +%eKfcHFUs0S^75<1b*A4rz_;FfCqHRm8Sw3g*Yxb&FM2IY3+2tk6(GMJs8#n^Ytxne9)p;}Uf?e4qyX +xiEuA195?#pyh5tBx`oT;1FqwT1@J`p3Nn{IcM0+e|=t*Dq&+)8B^D3G%HGa`pE^iL;q=rvIr23527y +r(widtEw|5{WUaidW$JA?EHgX*G)I+;r|b(y$#R$oUFVwJiO;~CY%}c +Cc95R7p8`E7m`YNOh-CjTUY7M`KQCUu)JDeGNUef!QFT +#{HI)g#_jP%b)GJupU2=kyd1S?>Zxmg`FCa<2uC{WFAGDvTn1UQ%+8dG_zouY|3guf$FhkNRk>@;n +X{GAo9$q?hu_lFZ1>(fp7Q^CI!rOiLpbDY?E5cYzIj7l!dXXTM!tvuG!@k*Z*+DoU;L88g*(t8{sGb~agRwP8uJtjbD +@Bw=!cZx~+~l~<)m?C;6MjSH;{<$vUAwUWik|5V05nRQjld}4ubGHJFsKLD(9J!cD^-d5WrlX}il;7nqw#a63S7& +D)+;g8;wT8KH|bxTkZaVJe_W|PSzNf1WDF4>3aE;Z9Ro32Ee7@a0s{8>pYHliq}A7LtTNobhq*cHRXA +89N~l7er5>j*K;xiRdw)LdKPL~8MeNXyxC!VaLWU~hc@IG;Y#kV)6Di6In>SrZDf#IN-V|1bX1_+^&m +mcDldqJt|lu>_IJLY7Gq8IdpDCir>8ex;oNy>iJfY-b%brf +z5%xKLA?z~ln2$(R8te<}zU9c^XY$L}xBM!$k!)Gla0Hgat&;qQnpoMWQ`M93#AiMe=l8(Xr;P#B&JW>re#-yXc9C>o?t@?Y5!edPL%3#QQ30mj8;FdMbo_hXV2fY^m9C0D$1c&l<_u?Eb}S7!h$P&DekSr +R350$H=P0fNi9=sw$_mLCh#9q) +B<$4#;yv3~gn*!VQ40xcuA@K=_Kz%`A@N>1dn|X>ka6chn46Jq;HjX`uhg#P}5dp=1$_0%|V>uKHy*C +y4O5LtCG|*8((TBMSi{19<>#7+BD-tU-+vI80<8G5k1J7EbEAIkdt-MRYnyfE#K^(JtvL&ea}ld-hNZ +9t>&DhzBhKv%18SJZ>6Z;Vv!co(9)TLWJF-aSTI_xXHaxVR<+K!+_0$ye&xPtW927lWZq+j-}J7CEf+ +kdf*ZJ5jcd#?Q(VSzdjP8S(Iy8!)I4P=GBDDPNLCddvnZfoKOCW>lFm8ufDq7<5L)Skq4QTG2S$7zd~otzU6zpT8fHoknLeea-W-kCw#;ZRi)T+6&}!_zU`eLIAF +?Qyw}Pe5fB$`{@=WMq-$rxitmHBeTm}>vvZPlLVc%5|9E@p4gF8k6k~548v~=PGel5U=jHv{B^yHg=J +tHyi*9R-=jerz5V|$Jf4tSnbsmPwYmFu$Hn&%f6kp8c$MVzY5#rCk}7f=&j5JYo<5NjcnninSLP~C~u +3JM_|L?8F7RS|p#n20;R+2+84*MIP0r7-7V3xEUaW_%0+j5q8I=w0OE;t8bccV}@g!LsmUU`@_bj4)W +7Bw<_>cVtH=MZ-5Vmv(Oy3S%9Pp!SxE9y4J|SrDWeWaANH5rcN*2Pi7`MXq>e$&pY+&q-Gx=wW~a-Xo +2)+6>~OxrEsNR+T>>x3F3e*&D5uZaX=^3=Ck`&2{^6-Vi3K(i&VxNaFine`HYn!q85V6IdLmipJ=POW +Lu%y>M_pfmkNsIt*W-BZ^wi@$4EXF^X@XrMxa`KjA{+DHV4H10!A)=I{at5eFRE-Nl(qf#`3`LLS@0GkEeA+f?ehv^3LlwVR7n% +2ogi49RZj*doug*q{#`bgM|=DrR$v8_QIc)K=xpXXdPxyJL=p5gNM*V>|i3rkXj9wZ2FSWMwsp3WOuQ +P$c1Q!;7dZVLq&K0s<5-8qsULEvz`Yd-odtQ^+hvyNVW<&oCie8Is>a(LruXJ3j8p~HbbdFbBArpi4^ +l}zZ;Mb3%2MzW-%6htkU66W)d +~N8l*bp_QA?FGGe>y_dm0iQiy&~^}q}kL(X5bZN2?{4yz$u&Vr!>lQkkE1ono*=svmYbD3cJl|L~6z^ +ofY@qJ)H$KsRhJxpI2gZ7^8#dIrunG*8(Hw;z +_s0f2ScClvY)02oOq%C1gvH^#;^%HZ#U+2yM`F_8rfGe(<(J?|~D;O!A8$g5cKmIK=GD7Dow67_T}-a +L0~1Fx#t#A+(Bd%lVd9A1JZCY9v7f_nw;&>aBonX;#axgRNq7O^{v+w^q)?1@ThWh^ut!9s1rxIW&_(%CY;KwhX|l$8xP=Y?Kq-oWM&j`<}8vkjQik}qWw&6@q0 +0&(>Zou2MplQQJchndphI_b5=riP&%hbX8PJEhbR^ocv|KQt{0O~Zq<9NAxSDUu4v;@xleL^9*6ur## +MMf!ZL7$7Rb>ycW>h<)^?yi6pkRKxy*NNW*XAeDX+BuSNcI>gs +IXS?&M<6t`Eo4n!%b@_g2j+fU8ud}lYmo~VoWKnFd>d$_)A|2M5;2x64I{W1KoH^Lg#>`m+)fzT?IZ{ +Girdo@uz9argOtwetxu9TUFM)`8&2YW_32D;MVo&e9v5Q8bXqUrDi`2zfVi}R6sl;t0py%ptvgHw8z) +plpmf>y@gQG@8b|e80O6kf40QlWqR{F}|G0q+##NgGy@G*TBfjpC$m{0NXDN#;Df!A=QX+l)c#yk}3U +UDy5i4%j7z{RIg%BAOx1|aM)o+1%e&+|~U}5UgAZ8SHr$fudmU_sZPmL@vh4}pPlW(7Vrf%LR@Va<5L +VoV^*Pq;BW@1|fODXi{8rl!bh7%ZlP|u*;hEM~t#5X`Yyki^gJgp_#Zuh0Np|2+%dP0kOSQ$a5uRT3` +k1v3ezN3asgeghf`?zQnYndB&ogEla +Rp*b*JK%VqUURf&axj0+k9brr86ieya2?VNGsbqlyse~FAn@b7!omUjoCzqLqDysR@U5)tS_mMbM$&~ +uBZMKq<@QGxQMcVffy~mw$JsoOhk~^z1z~BwlI}~BN5qTG8v0>qcP4Ij}HX?R?B7Yno9ecKs)^6Nq-x +_^LrJyvmlzqqj;ZMQuIGH!Cwxd;Z#?98_7Sgrc14wWc4K#f2Rn%f8F4AU2NOCnD&80=ce&JsC4AF+?m +!;vum6e9Z?Jvj6*l%C~u0nY01k@9OJ+jP#(En!1Zr$11?N`f;(s5%aXa?>rX<19Y~(r0dy0u_+OlBcY +q#prOgeC_EEb24^T@31QY-O00;o@p|(crnThqw1poj`5dZ)Y0001RX>c!gV{+WpR;2m84>)zkcUXqC{Pst$r~thv)j8i*h9^LTTQb +R&h#+s2ZsZVfR{=t>LuWZ#MmTDGvuxAKX@Iw=%qHa#3=(SA4U%Ab)=R<>M{+jl+E*G!eCtM2k~W$w#h +}R+Xi=Pa38)-x&3DyCLw)QKRn4X=5n})BQ2+Uhq@O8$;e(ns-V`)iLNF0qy#`jg`=dCTWc*wWC*+QJl +vl6S^tc6A+tXBz;T=LRiM+Z?3eE^;=mRCCia6lgGN0EE`of1vQd_2Aj}8jeG|$DidD+rR6=n8sggx +6!&7mib6ymlICcr8@zGtb#lToQYZ(N<+=dJjST(ewQ`){EDdqIQ8o4;fSl=NULevfO9%m#01|($-o8} +EZ+`KFUTKHrjRxHaYtS!KP2DBlVn%~Gb1R4G$t0EC`CFJ8PD*6&VT4JddIT8lg_j8spAbr+xo`URI6*GANq;lO#7FBTOF$O +fFc`jS)+8Lq=%+i8dpgv8qhqtU2y($)=2A410>@*^O1f_VwHLqK)7Vx5aP7AmW=qd^-g_P`;)YOpqCb +?+}C3`wO@JT>Lhgj-i$Mp>hguJBFNS8YvGSyjx&W-!$~zl%wF%y!PYc*0=u(}g@zZ8F)K-LI_Fe3YI; +Aj)#4L9grRy8#vYC`?-PsK7YdERG@Gk5o3O*(7Zzt*?1z_CS!(AMEq~=O_R;qq8YY$Ya^nrS*7_Nsi_F2s`q-$r1sB;-E5E#5g3DD#Szz!_B)R;S$I#_}gWiAdqvCB)pNn +6FEDNXcW8P#{gRjj~nZ{2{5{hH`wz_y~%9T%jKCKo4LEdKiR!LRnN-hgx +4sEy;HHUH0vP~e=!r+Mx=Kw^qo&5vDm1x3g;E~k{`GkSRJ0el$qznEnS%G5r3!quzKrj%_k1QGi!cygkwVFy%LpH~(rR?#|B6v@6xPbYa=k9|NR%Vz+M*R*2LB7ubhv~V2MLKTGjm{W#IbltMgCrpC(dA-{w{84Z#lJz8Lka(<6-ddV={dICh7Y<|;TnYzGJIJ_hAysM5WutJ=a@(2Yvn$%e+ +rML4E(W^0(*-4)9!+|zR{sUv8`#wX{5(bFgpD(dJ)JO9KQH000080Pmr;M$?G2k3R_j0Jt3h01f~E0B~t=FLq;dFK +20VE^v938C{R#w(;G+g1E&(@~tf26>T3}ERgh?^a=z`kxSbL#}H_VvY3@bg{16V6#4I+At{Oauy=1Cy +c9K@8P4~Naw#g3Bzdb_$&!Tdsu5BXdQ_rpHB0RCYUTDzaXRt()IDleH90R?_bgQ0P+hE6IihWN6DMa@ +XF|q`KgX3gGZnY8Ecvk`)KIAyp^Dh;#5}+KxMaVzOlc2++woXvH7`|nAmgej=}UraMnqOxGLPIj?Ezs +Kk^eBMxTrsgT1!!`Rx2O^=eZ`2BZlK{9|79>8i;!Xcu){u4Ne$a^YJAmR7#pDwt98}&@wk^c($qzILwtusPvLK~1Ft2K&(9NUuz3 +Wym&_IBGXm71p|i%%7;SuEsfYgehLK(|(co79RB<+J_x$3Oq+!-sW`j_1hXu74iH6p@~dXhepI_2Q`*EUly|3xi*NL8|}`eQsxG<~u;hO44~s7*3_{?l)7wdX9 +|dn#rUoTa=mBZmv@}*hf}-58`zE(q|$Gxwt;{EHXjjmpLN`O6L +2$kp~36eGsZCIbHD)AVELZ4y?giWyJs803uc@OgM{K*$QMHGE(${nv&_HyQI5SEd5~?LK#YJ` +kr#vC +`nl`+Fqn;DdAZg{44m*+2n^|@*$0qOz&l&{-2*=<^92_~aTu4T`o1-CM5M{NZn!ypY5qeTRHjo@SN?N +BFQ!4rb2G24gB!}d-#q3Opl~UXv`H4Zv0i=-rm(SmRBqBF!iw4dj1yp*DSs?Zq@7EpQ#=}vQkVZimxe +D>>o+nvOP)?Wx9bfkJUd+4rHcl5*X0NNX7tGG7iwyewN_C5)ro +8sl?P<6(Z9j6s9ttL$%J!B_jjPYzyEX@d9SK3J_i8{?Uq~h( +BKOI8?0|6LJcnM#MvKqiefzh0lVK|-Ds29B#_tc7B?aj91FVp0rm1nS=@`V%up=*zQ$(mG`uj*jguEEV^+AfZC +XO23`Y=3$x1Ca_f=2#&xc4b}zPg1PwP>Hex}9DJxeb?5j{)K&rK?U7`PoHh +^`ioaMi_3jyW)zu$+7A2=;}&9D-*>~unjO}~lnR5F%FmirMQKrwHv0jtHv%fkoDJq|8rhsMdo)xryO3P!W9q|zUGD-E=guOrc&I4sD@p5V$vSd`}i-t)c# +JOFN2JWo~AmCEO_YbcqTxeNzsf)91Y1;^CU*;-_Z_QaU~&O-<>aa?VLbL(`u0fFOET$l_;2?0layQ#1 +oW-|s1Ohj+QP-mP@Nh8ItEY+Pfk=q#e%|L10S?<6n}Qyh<|$4I`W +FUia(qb~TeAQIH;6i(F&zpCRep%~in(SL#FzDK+Ty@b18`(QVs6$GfW7^9u->!sb?R&CHOzP9A39Le1 +~gtxDFc}q0|S|{r{-;0CY}8)j!L1w-PrL!IJI9pi;Fezp-QY95J0tN@E+pNWE43(%`5IHBSwlS<4VbIa?UDTZrymrgnkPnrRx$ZaA(TeEJAB% +jh=Jb&2nGrgC{^sX+hEYt&jm$Iy5Nv?ZP8q^to;rgYYeG+0JDQR11)4`?=3GwxT- +&)8ie`B_1(qJ52s#h4#pd+;0#zVAP0Sa8-3)f2S{-Ultor(yy9vI-7aAlyHblSUoDPV=Hzs6;+N=Gt3#JF+^5KxJwvilVfXl};6o;e>}N8EGMI)y%gy!S!lX3rnM27~hV9$| +XZCg_8F;7SXVy<-#zmc1FAi@&KIc?{_)i=gaTMcv^?y)H0|XQR000O8@1eFv7@M0oj|Bh#ZW90i6aWA +KaA|Nac4KodZDn#}b#iH8Y%XwlwODP7+%^#YzQ01f^st?HP1BDD3x$xflBPv#TE)_o@M9yDA@seLb!%AKjW?TqzLsUlMd^l8yD!6zO~ +GsC#)@q=1?p~ileC7{+NsXDZfg2DZK$bYqK-x}Hj19IK@dJ;@)uK@OYueuqhvkGyfvY|>dwb^XYE2hZKxtEm8{ATCEG!^s+fr&sYtEtxHcc!vdaaxB{Y|-6@ +zz@YiQ&5$G9p_xRsl?4G*2vV&X0;Too7Y*zj(~DULfjvtmRFTAjrXbhZ>=l$WvJoV*2)1)Ym^m)J)*0 +jW_1yRV;KlZ(SyX_&CSi*$1ZmjBfpdumF7mO&xCf95KLmE{mhv*Tv#20GSDz+!~Cb2DcFuQ8lLa_g*E6#nNj-o=koB3Htm=b|F^Vy0Kx=kNWrN1G7jm2Tj(ZR%sS{*v@oz8e(LD6PL~BBtnJ_?rmT}-LZEH*+_&1e@5L84qO!z8c%Q=V$)xEkD +8F9BrS8waAxM86uIa*+k8EXs)|G0mvlvMH5`FHZ3Wf*3=XzjsWe +-|4hI^xYc*?7xXy>L-9nJ2O1c5g}M8nZE|Xmr@{79a3HUI(scAhQg~$RHcZI2&a)L`O{JGT~6N7jmh!z)C(f=2NayltQk%ViIBz +ol>9!>|JBRNugB?E@%R!21Aoz7+T_4(w8Fw5_&Bp`v6yh%T037<*TyBrl+Nliqu>%!i6=K0Jpfo86D1 +?#pU!!vDWUuHRv_iwL=wz`-k&G{*Y`Buc8P25{5Z^-6b!-$9@i~rc{C$kE)j41=jFBGDsw)0+NQWqqS +4ACi&x15=`D0-rSJyto+ibAE1Ob&=>O%I^)UZEyh(hh!z>nd1gYlf0pF;ii)hdlIKo{t>$`0e<%7?$@ +f59&cD)ED#M3gPiR*rsIRdvE#l$H24 +6eY13wG$P*5ggMhKjxW8#H|R&!w_=YmRE&tF)rJdX{Te^545AWX}E%-z==DZ(3!r@~Pzt-haY9+Mqj| +(Z?9yCOH=R`IBOHrwW&67TAf`TNF-edB#Tq0Hw;{g}1`T=3NlYFGW@{J}?8@kQ+H(p~^CCl>7i!Z}*H +vtO?HJ7`5ZMhnF7&^>wuW;jji}ZqNqm9b72ZlIc4+5Pa$BrSvZu^kiEb_6&XXS|J>E_(gg(6TVYjtF* +$?XuKf5nm`kZ%aeryF7l}hG$!a)Z{aowm)vlkmUz&;_iP^gXUYx7?+Z&3^vfG +V>WaCy~QZI9cy5&rI9!R}%q>DJa}uPE9W ++1#~ht_YA`i?qEK@VbI*(YDUA@g8=D*shx77qX5@`%4lK(yt!f3&GFBd +rjZiFK$);)*&-C}n#Ee(Xc3ak4`?Znwli-ud26-LJW15|KT{I$<<#T#yPF$v~sH$>hxgT>OIm;!}!x? +>d)|Yj`pDppnvflSottu;Nr^G=C&Zn#><*~|NfREY@NK+%RU4pD@mBDCFcv^QH;p3G3z=bTE`dw2i(N +vR3CQo(te5f)IHxryaz-iNUb2ye2k0Tg-xQZA5yjtESS5cy=1wVz9@ZnG@#fuqC!cL?dqg89s3$j<`V`F(gUjqWQk~?D1{wMyFtN^O=gGJJHFmGtsmM=W`@nZoJTxdM5Op!i%}U47yZL$zcvsAI~kR+A}v+Hp|ds!=UgID>5g%97bPi#lYA=Gj`mND9)R;>#{r+{cX@$I;%n82mpQwU5xeOacBG)6W2 +-FxZq?-$Aua +gQYIS#GU?`c*Fadz*<+2Hvf)Yb5#&|u`=$nrNn4;EGush+axkm>6jQ7SxTzF3;AQ&etAYjQ7Bb4QO6b-2w`dDzO%9@yT++3 +ir&|;$(fk{Wp$uT-YeRIUM2!2T8jCAnS(;Gz+!bMtKyfO#U-bj>^)JQD4({_9iqMRExPJ9mn-)dxv_D +%V7DV2;z6lR}m=YC*C!(|--IF@^kLXan+F&ShRg5@>-}W=WO=h|T+9Mv(Wo?jr&3^ +h~Cq#4Fc(G1WqS^|6G@gbG3PQKk{8@lQ@yGXbz}c!I_+n3u*kgWKvmCCv^*-NnwgWVqAve5GFj4#_;I!xDiL)sEv +4IG4w@tyArHWxLSf*XUDT?a$qx7FTS+gno%04@^RhJ +{cwJzBzxHe_GLSB<0^Hgwb0{FFy?@hp?V%O;niTieM5*o!%UN_ljj{t^!YO0+xIg@{Y5eE8>^d8Yb-`dF3dWgW +tt~uQ*1oMpH>Cc1RHTwWX7Z_NY76h55X)y&Z2}g1hv^qbYk{$D^skgE$xWk7aEIqzpgzU)i8rZPeLn3 +G|8oNJWf+{N{+(0D&JAgK;5mtRWLX_L?9%m0Byguy!_Qqn{LkhbL8#rc*C>iERxl|XoBBFlYZeXD2Ox +h1d?$v(Dytwp8exShCN~}`wLi?|q8*>BcLaW@U@}=}Y +`lK@;t6ub7_qdVi}7ll6@UOHOm-C@Z*mo8jQDtF4@r_>B)IjR!ExB_%!SEA7d8Re+4$)i#Qb^9O)_fw +#2;#i>8hd??}cbYFA^2O4dj;R{PWyxmS9JG<9iI0N;x}zUks_R$Z&H?x-bI`y!qz&Pz|x#YpM19aobTtCZn0jNKcLA&r +8Sye#onqlPAU4#;qv&V1u|1u)59~hubwC3O{cLO6K3$7Cn$6Hq7yBppe5PlOPY66(!DFvPtjS>{>3f62^;XZL5?xmQ +;N?wk1>7;<=f{Nxtq`d~v)I%ErPO`q#d6|84bBBEjXrUc$puHyl&=EF9?xe~zQwaj1Inla9P$%XZNM= +vSwt1R!kL{SZ}D@lMj(AY!@vE$E!oG`EFpy* +EfcRvF*Bx#x-v3C*2uuONbMv`Ts?6r%oL+T);F#3h1Q)YGUoN2`&hatjDOYZf>X;w?@jibs)BEykVL& +H2MP-9Eui>4APgm)Ekj}b(4P~hSx&W54Tva12lWW`(vu1@^bGZetX +bxQM=-o0T*!g<@60QmqY4#f@)H;Q~Lu=YuKUkz#1FxT2NVc%o;`PA#bi*268n>T2%#Y2We>#%lQv3s< +(flyF`=rc{*0bUUcOsnjaxu9Q3NNM`C8|`(0`q;W%aEN#CjpJ49Y%xa$jzp3X$w*Gu% +*I6_q+hQR;Bn;!})6-lr^c{vn<8xZan9?7Pys?3UrCEbmj>G!bl@Icc(-dz9Dpi9Ny-}TAe$GL2kevIp3MirWTg^nA +AHVBj*Z9LII-R_;fp|x{Pv$IirD#;msI5ycMLri9p>oC=WYj*ok>B3PYgq7L*3#bkruVkNAL2N +T^YE>hR`&3fnEy&`5zRzIPkG_XF%W3cfhj8`iO6RvH);gAM+}5|`7_-i7(~f>=8Cdog8CasI7e_PbJHmDeI +P+M`E>yR06hZ$03!eZ0B~t=EjKPOE-@}-X>)WfX>Mk3 +FGNLCLsCglR7p=xE^>2pm6E|u!!Qhn?|F(y+>n~wD+WSCpxr7o&Ma+B8j&VZ;uh`gaoUbDG=a!1vH#E +Z9|sfIX0u^z-vK{V$LgL(Xnfy;YoTQ~9b!nOl;Mb-cSTUmyVAz#Vn`4RJ(w0m1l3{(t#6X>QA=>rDuj +fx8Da#7qQl#+_;3wS_1KEBJ-IHNicTJ54$<8&`@Y?!UPeHK?&n?5lX2o$d&a~hX@b88E +6Rn1+ipqJLNQ3um39K;3Iu6@not5i>qf-IDokWoweE~NqZKGL9h?%x#BK<;O +~P55rO^)|3GKbMFcGGg({GI?;-DMt0BJl3(QjCu1KYfb+Bj6wdTDnq}u1j0wR_ +Pj;0hUl%KzZJZpZ!E4oO5W#82ms6sO8t_~p<_V{D%lE9kh)+N}2m+%TO)465QmFZloxZE1a!t3PZfOS +s`&p3~m&G*BCs0cR1QY-O00;o}p|(aD)Al7Q0000)0000a0001RX>ct!E-)@JE@WwQbS-IaW^XTLZgg +^aUvO_}Zgg`lba-@&PR`FO&d*7WFHSDXEGQ|Cct!E-)@JE@WwQbS-IaW^XTTWprU=VRT_GYIARHtyEoa6EP6{E +7m;~i8^Uhs1ylAp-4n3G$MIJ)ycKD7gL{Y{E_rj<-fCgzCwz4I0@c-yR$p9>+wBSA=^5@kE{d4YRSDJ)XoygIiK< +qN)!AKCI6XK8WE$u(@5TTyo4gXt9E>wB(juMV@FO2_=%K4=j1gr_{Fr3qd3oD0Ztf+ +H@k+uAWOptwZDSI~kjO!p7xEsZMoxY1q1(BjiZMaNt{w^~ +N!&T<;)Dn(`}E`sXqx9wqMynPMnhHTI|5kI_Mcw+zU%?LO!E@qBfTwD#1$@sSSTbNu1lt;e?p6izP?8 +u|K@ww1ebl}jdP6wj*}nK(N2((sb|k5IMZiE#%7`FAE$CM(-qZJS|lhaPkOkP%a5xMUl+^u;`$2@_$S +z76~3?UAXA;gAp4Um#G90SoKGf5&VA$GwA=;Z>w)W^IriligD94H`d8oVe*#cT0|XQR000O8^`W*#{4JOWF8}}lE&u=k8~^|SaA|NYH +!d(PF)n0jb960fZf0*UaAI;UYIARHt5!)WfX>Mk3FLZBkUu

@6aWAK2mtk=wnm3De{Wv^003?P000>P003}la4k13FfK7JWNCABEop9MZ!c +F!MMX>t&qz(p(G5#2D$dN$vr;hBGvIPh%}XsxEXgmjQbh-%y$1jQ8 +~^|SaA|NYH!d(PF)n0jb960fZf0*UO+{2eL_t(Rl~vnr(?Ae?->(>nhXRtO46!=gfU(FVTriI1znEW2LGSIOO|mBq~fmOU+i|W4_N1*u+p!W%@2Iya)K +LjNvAoqOt5z_-1mufwi*{;o6QxFh4JE1q}F;)r+m@unkVSm_c&gG88`MmJtCBF<%oHv0VA8IgcP>&OV +Z#$R3M886j%qEt)9zR1ct!E-)@JE@WwQbS- +IaW^XT2MMFEl2_;TIwa#_s!M+!jH=jMHRN+v%WL1tEjT~R% +T>I?1+q1l~n&@+ewjhw*8-K-n6j;q1gX93zh{1Fr?K1k6OB?xfmGCq&L6;-;llUV)xom)Z^t&Y(M}3k +^lGqseT~kPEveAGO2BRF3%fyypE$15240!xPT@a6Rr6)A +2gU?*C3faiSmq8{==i)%wUD3?S!r@LyD1V$r|UzZF#IoA%JUZlLWRo#0pTSdg^xC)`Zv +Tkyzl{N>iA@x*dyjLt@BJC@=TRs!PhEeS!k99nb8%yef`)XN}Tv-z>g*Ff0e1Dt1O745B(Bu02}ZfCv +Jj|6uv$SY)O1JV4pL?hoz^wgY{eS)qe{SiJJFW&x#unMA|0g@!hbU+3ut21ywE2Pv4m;LB4HaX25bd( +l}H?gV!>WjHB75}yM_k-H{_z|g&^>$EZe8xTVAf1r}W52hy+LDH-eWE^{!5fNR)D3tqKi$`O2xTuUi^ +dUk3={D`J+6KXY!DOZ9ygpEjo?v#qHm-Q&sMD6Cqj2o^BI{I5qO*|Do=|#*Y4^-PZUEkVX=?BkX9M&^D#@}&WK4^P +`DSQIg4z&nkM!W5{G%%{1jc8J3c^eS@Ipt#<1lbb^+&Qd+4}EctnC{>^;w282NE|Pw-$J?3*ykuF^Q) +Fp;|3ye;^!mTLs0l-^W6^Ygm#b8hii1qZf&t$PTn1zGo@;U%W~P1ND?$b3v7L|95)DnVV?n$%JKd6A3 +P5f!5|Q@GnU$mbjMC4IrE2Ml&XY-?l&$x_VRwj_{+Mri46_`1o;`V3AX=y_XMeW{tW?qpp2!~-{%z40 +aQR)u6jwpj%x>Mq|gJ4a{Ovj9EV>4yJk*`=m{@{!!Qd`TgripC+@E?ji2u@;?}#J8XHV{bth0BEQnLt +4N2nAXTUajUb@R+vUZ1ifbvxXV4`Trk#;1u1ivSnk?J!RUjwP|^grJ{Tj|0yijRb`xS|1#B +8jaM?o)WrN}dCh->|d5#yap0nthGW+hi87#N*qh_!MziWZYVp5#%Ci9SJ0okqrz$zX +5lAr|Ler)F4?bYdJ?9f +n)R?P0o#=vO_(%=@ym1ff9?Gi>4c#1b&BH=9SYuFS&bdx*C5OnVgtfn(K;Vw?_d}D;3IEqT?{2?tN;O +sFzls3;q`R$JgxBq{#CQBOM+pr8)~Hd=cy}iSIyj%&p~AM0a=?aek3jPh+ex3xts05QIqNuT*3Ee}x3r$V3%L^DG`e2Z6)PD%2ji75asn+jDZvFVqGhe>XKhKD6I$sopA#Zk7h&Y +9EcGbF>j#)IrXk)aZaNLb#vxg02y!SbY|Z{qFgHay-mzzwQ98W%>wqM}yMfGQHnJewi}Hp+hJf%~Js; +^g%iwvD3^O8yJOuw{w5eG=ZPAUwAI_SWoGRl+v9OW@qJUkN1WJpdvW<^GK7|F;i$)#jm5cAzwYZS7v4 +7UIHkv3s +f~4X#pMcAMO<`h?TZ7u@yM_yfVf>*jh!?aDDJVCV^)4)->`y*gOw=l4O$DiMYb#`y{zAk7j3E{`L$l; +_-Rr46}?yf@&FnRu-F_Ia9j`WW30{)vy1Ar5KrT+!q(Ypof1*m>UZ16P}KUQY*dRc9!PzrlWe2mscoX05VAo*=+&D&!LF`7e*(r1l0D${wcOgggx}bmtD3~^N+ico +-J&^H?}Z)DD-{Sv8x((Ce(OT(-UL#bhe#-P(GuFHewjyXDRXvqW(m$=PNA3}1 +Kxqe|XYNqrP=h1DB=K*iqy*(YPGfmuygQ<#AE#8mP8ZTC#g}lM_oz8h=56{o5D(AcEF*Y7Bip*cg!c@ +Z9pi)vcyS$)8%9xJF3w0`1K}>=q`91Qh&aMrZ*za@^UGt*bR?BBUDLsZo2_HEO!g9Eu>@(ogt(rv}2q +1Cnd)ObkyZodlOrb@5`XZgqq#9n&la`O?X1W0F?bJ3NODl!jqZNPE_v-@__-k1HKweX^Bn;Z;N#1iPy +K3s4q86-7`EIOziV>jK>`C72KyY&GQ5{S)LvH5}AdQDPw&$yx?usUwK1LV +(FJtyVS*FA&>5H=A^HctTwjkVRKiaN5UaRm7WxLe&sFa;l|+lKV-lYMT%u^b}AJzC<3HyJ$MLiMH(SU +!$iG-III02>m-kT<65FytAP*gMwhzQ~$J3ke#|!DYUYI;?AK%}Aes*QDe&EfkPq%iO87vO{%D +*Am0hOHqfM#%QY12=2OJtq}>vU$x%{@c4OZ16J1!%#JRe>1dz?^#Y~C^jW*NstBCiBVb=UFIs%*ONJiJ?V|7FON)_YcXR^W-U?{cy-ofH)ec@86h-M(;k*a-<~Jz_iOdLDr!TJ_2s6aI_d#xJXnG +7#>CxBROLjP6JzivR``%gfYOxES-ki5HRL5B9N0j21C +uapfSpIl%HL2)r;!c^?w?gh}-MxFa_BtKD@8^E?* +bnt04!|JmF_+7V^kL;6T2ZW;#Kqh!v68impWrfa!M2XNB*jGM%?xR)%KUs?`PkMsM9b`dmuB`@Y`IY4 +G7{e@@`I&*y(~Pe_or?8H7CZLLD4yOC62W2xJgPh00KIcsdXxC06R95ndFE8xZ@Vp8ka{s=jNxCUBl5 +U)#dty~`9=F-w!TxRzeJt6vpHtvkUo?}7Gw34Iqi&d8b=V;K4dy>%V}c=xWO?JBHv&?9KrKCQBURoCJ|XuH)qQjAjX^#&vm1y;PC@oYhtSASie6^T(p59?42FgEwgItZ!<{*XI +QPe69Rp5w)R=ftu4CW1-%yNX^zTLwYP3O9G`m5*u0yOU+^!wb=isrd84lPsx{j>H#9Lt&*K-32@E0(8ExDWA_$wkH5CNUip)Z(AXSsiFi7 +@~Ev6?%j6%pi7E-;C1#x(b-=7*kaE*bjq>;6!E^8VsE~kL-=@Z2N)P*D5ughKIZ4!gfC)T_18y$`P10 +4HTik2qX+vEI9(X;iU3O7%093QI~Yri%kGADTNub??qr0>v0yg{1Q35f|L6F?$zCejNVyzGI+Ao}3h< +s?6sYxriB3}SCt%Arqj$d`6Z!6;yc +j44+QaEQha|@?OJ(S@a!B&V_&9^&Du-yGrC8wHOE%I6n{Ep-CvwuH6yQ!^X3VEjEy`%#mcvpa6SfkL8 +nnHDKV5K>puF?(960?1XZ}goDTwQDMvtIiD+s6OI(K^q`C0vHcFgV6lq!JIWiYRc$y$K<4rJV3vL`Ko +xu`Ml#R!_b<@^@k4!Ql2u=D!)mWkD_&jWQIdZ&7~M9R#@p?S2e1%s1rO1!TG>w|IMijSakJ-G4>%;>I +o^z}-yG97XMfb!;2#{X04y+-vW-@~&{HwrF`IQ{-f|$XCt&J&9jF$G!WIcSFJIT{T@QVW6X=2DxgXj4 +MSgWtl1G$!5yS$g|>xKwb-a-!lY{PtT?D&Q-8k%Vrb78Y{b#`Dr$5O|hD&6rwe@g6F%zib3 +pKwXv9r$_VS(u)%ps}mSk|>O*P(*MTmSRcaWUznIj9ESZcT8&Rc`|#0Q@_q(aF*`w$Gt0;-D(xOLC^U +5GKiD9NjUp!txeOwtEH=RHng`b2x6+oadbn{>1WPda}55moDmE-#T#FVT#SgavBy8k^w#=<_@>5j_fm +Yp@9t!yp@2@6rT-$bTL@&7eeTwA?^F&lpE+#nT?cP#gTxvj;c}-I>|^wtW)({n|u(w+TB-d*eAfw=eq +m(tRvozmSQxeZCaLx+CSs`)a>XzE^^WaLErkWXNo8&+Bo^5-b9z?nk-7TD7jsY3obd}<2O!B3tC1zlt +pn>*fZ$_lkEnA@ONSBndz~zUI*mlSZD8r*ygGn1a_+sT^NVwTV_0~2UvAl{H)W#!nMe1canVP@Ska_K +FdBEhP1GRn61uOoY}%)jLsvbEj^aU=2m&M{(G%ON +HWpq)f(@IiBQJnH4-4f60)LPGvSuy*N}TwrTno`dF5TAe|qF`*GJkfik?e8Sx4`|< +ce0joNBSw7+)0^I(U3Sa#v4u~PZ!(jAlW(g?$%|_!P&T|w(j&8YZ{ZcZnxBBjORgQ8n;s(4Y{_#3Qx}m>%YmAb>I4rmx{JHV^es6ZB{7ujlwCQEUUYIz@DU$xI^7q&zn8TbfmE)AX$+-Q +)_2c8Jh!NC10_{N)5Os{*#YGG<+M+RN8R?dX!(S^diLJy`sP!5M +Z(u1YFHK$BCaAR|1tyBxYNzz7WADiDE7AM_xKs`)HPio0P-DrTLoScCZEgihDn|Q&`u9oNfGKPkVIHG +U+L4{Mh?do0OsS+WL|QEXJbtjf!7v2|T%oBODl?IfWq!~p-Z-Ccpgh(pKv~V0-8CEmwQ6Z)gkCK +P62waouhPi=Reb->oan-^2ekuvBNwd@aSFjHfF%`ga +VEzwJ-Ics{@3oy0ky6?mumyW*+1;%hg4IwGB(`1?Eot7CjUhICXRtEzr2AHAjfj%ptihx)c3Cooqy2` +&-}$A=6a;l(_Iw7jYzfw@bB3!~y1XID4$!qt?~qvhzk8MBIYVX)qC%D=LZ +z{VYGM#$#oxE;`4`kPQPS0EchnOIyqe$V0TRR{GOj=O2B?-``l+%s~@LLj38XT<)6$f6Y<^$9#`{Hva +i*fUc6eEO`R(AS*fl!N(a^boS28ia1ZF{v^eVd#@&0n(&^tFQY3pft4>hsoe)UqTH<`iEqTmVt^n3L9 +h8+GvUPSX1;xpl`KvV%NGTxa;pVa_k$wn~cP(-R+cbDAm%+_E=xzYn(awMi1eQqR|0;arWWb*GuLG*i +)5nGe67cQ!%Yzgz3@c`qD2Qoq@-w$rYO3N&Qa#>-I>{bLSB1u&YUTsyZsT3yX+^7sq+BQ<@lN3emfZr +kiqPfT(36J$U2I~JZH`J61LcsSapP=!|!7Ch2Y0tDVcSI;d07vfgL1k_@X4Rf^0rL_~vT7kF7af{Z(m +Opyg@o*4YSlpn$nlZnE_Fep}Ef}ct*R)T_wpUBj#B++?)YIYK>Zsk)lb*K0Rhqy82apYhzZ&irs^@q? +vxbQv|Ft4gytZqiTm)Yu!w|xaEej4ixj7~+r)wu^CYOEcS6U{m8-qaLx6mu_^X%#uQ~ZV)XQY=j!aCFzaLmw5ay>T6t!YkYSQ$~l!=VqOj^wNI2((DrI6S0qJ{QXiiEINKG;bxo +39v*Rb+GEF`?A0r2|3so700&G>x0MAPAUwY8HniraraXbVug_{zQ>elQF2g!E}?b~M9}KG6l;N3|KFFE&tt0xY-2!jzz73l6746 +n8|xbF?9#ck4GV{oqrj*&ZeuzQG!knznHDZd}bZY7K+ud@LI&xUv#JA{uFi0I-2b@bw7s7jV1!ikFE< +t+20LOSX-;-*N|)_3#;#=V8`l7QHufPoak6L)RHtT_ys(9%uav{e3SjV^T2OAx0OA$t_lqu8NND$F>xv`gXpq8PL(3CB|h$xCL9lvg?v(= +`|;W$al`~3zeHhXt@6R+0;aN_LnU$;roa-!_|VZ{J354YJZ|S55&kDaT9ZT-l<5%$|UuO6@N|k^K0Ne`?wH+NYc3RSa11o0ynk{D1O7 +;p_U@|oQNVSl`}_*%Png47O!1pe;|95Y97ZWpM|k!P`bu7V0k`Xg8h!s8b(hI6~_r`I7v%<+7&!u9(N +{6Y)A-tx8uL1Y=bUp%D(zCsX%r}ag#+sER3WP1j$YgLash4(;*aD(hB{w63-Z^9E=T&zxBB9NWbvi5T +b+*iE@WvPOjIL$<<3NpgCCkIoyZ@rP=hvv6Mk216jsC$XH;zN+d3M-vA(l1f<{Iv-sj=|WK+N~*mfqRY5ft +J?LhSxV#-%^Eo7Gx>J&P+>`&?7RlkCnOWFotqV`9%;RO2*ei7OQ)rekSaBf)T-+;j<>a)YmV#b5LE-u +>%NL&YjQv3JVFV>tGB$;bTEAOM8~fE^@bQ`$pB<6pT$?`>f0wO03AwzPS1%xAP+^Tk}u=M#_4k*0QSg +_Tf$=(Doljn^DvGiBz|eQi8y%>O0Xm!VlD?iV+dZAQDG5n-F7P9`PFr1X0u=Y?$CogBVqC+7C>%&*nL +-?DY%%g}gR1Zay)z!6a7ATUPpTAR3S0HoWCf?vnmQ5H<6&Tw(fg^AbuA%7tIGPJ%rK`O@gXLQZHr^|K +R>ieU2#wkQS_a%fMc;jFo#;p>y$I$-TDM#+=XrPy|Nl?W3rCn<_-Danb_2Ndg&|RalH`eiXKtD6b5h> +GcdR>J9;4F%v7jMRKOuXjU48NOr{zDwdR7LRQoT???9aw{&sfHo@1qBr3l&!q +&Wm_7S0ry&u?gFrF|0n#ICIF@gwspy1-8aQ)%2{(8gRllEmMZ{88n(I6EBSA|wN#5<`e(QR_5Z?_vo( +Mvog+g?wVs@)(s{5A#rN>zD9_k6HAhh1I)n!{oGUO`X$mJsoyfl?gOj4A{NZm`qV(Mq7Q4vK_d+bG{N +Wlj;feHJ-Q;uJsfgXi(hYD?iHCY{Xq>W5Y=?V^L_rF}&msNzst9t-a>IJjfwD)R8Z7efzLZ*Gz-OT1U +oF!g*?8Oq40wtOQq7Ijmj^xB^E9Rrnl*-`9J-?RL9U>}D9uMPaaCykmQNM9K>L7HK3C)j0&;l{4Z`)0 +=;>ca$CW9b~45xVZKSNZ@Q#~){;|JCIFvr1nn5$cqo!*bZGMT7|J)S1Ge)2}-KK37^56q#^dqsUDFn@ +4%_zYq&QDEs1jd!8<1Z!9rF+8!N9m$;2}!EfR$U4S!TS2xSFE5D`>GMD}+75}xLd9Ze|le`jcQ{2DDu ++JZgh~kS5UX#LdFXN8Kc$Sw7lv>_n$MEs`(WL?Xz0b~^E-An-dmn;{y`W42;pn};ze4hwwGC*CCx8~f +e4l2b0Sno6c86&5wJrEPUGBb9nq;Hw?u^;yC#k{$yoTDjc2Wqs<5}Yxw|E~*K>$Urc?2H4T7PZFm9hO +^OP>UNk=0|xTtaDoq=+is38n#9QSC;|PM#P|Dl`6K6zo=@hq!vN +{Xb^AlUjm26?kc7yr +c`KvFjyx_hJ9sR7NqN~#9GdY(hzGJ^xC@ro~$pD#|em&{gYsRx;PteS!lv8r`?jt_u0EzJirCWE(A}! +?}&>b_mHrw;!0Xo)0)oywGsO+B)$v~?|k{jH~TAozZo=x5HQb6X`%w>iQuZO#}AfJQf-n6(FVd^JHNh +?_01X~T=?5MzhCW+6MFCIQlc7Ka?SJVvS@}l4Tr7hllvCM)pN0`;dTQ7ug5RHq4FLVE4|mc-kS1Vgj` +0c0*=P5lbtZ4ZsA$6hcVa_0e3d?QMwG-q0%0&DM0^dyAQrK=_>xAd)9;X*qSg3Qn%U!03vj8rS&*>zI +B+dC*EDt8iN830GNy$@-GzHSF)-spB;6|XVo-%P^LQ*u*XBF<4o&*3BsM|i`IM;YJqVuCztWZsR<1JQ +8axpeqSVYwjMju^+X?(x;~s8(WE3_fbU?z=ykG{I={U8m4R5^27zBY_1}|)Ns#%^L;!Y)==*tKXY*=U +)b?&;OI(B(sq(ktbn}-pfmRj8h1WG65bz)U$-hKdP?ewVD4p3#vsFm}vQpJp{n#KZZhDa`g|R#;yQw3 +*-jAC#CkHkV^k_H?iB0Ko;R8{g2t)SFKUeG0!k}qd_v?a&ev&NLdE^cGD)41_L`Uw8xnavPJY +k!^EXdS^1V2kwRgCgWtXewDwuNur)r6#PXb`tc?NX~KOIg7UEH8J`q$%Xg0@;$#d86rL(~l0n;Ln)Uf +d?>0Z$82U+?u(HJw!Qnst%X!|0wchjn-TeIq|Mi1%jX_P|+kWz +?o@#22s>oq%O07%K7<`HFn=NpC48J@Iaet9GeC2C1J9j!Sw&T^^6i)tax09z>l30Lc6YWb1Mk}m3EsDKmJSt^ +XH<_$J0EHQ@$Jg($FByon^(arie9%+nQ4zh@Led%B;@dnaiybiZniCs15RZ-{22)-v(#(Jb9@awq3)S +luCuy0)$fMc4fm-E4DjkS3+hZ(rQ7Bzu)jmaM`9Qp6&^T&%=p8G01-G# +Lscw{8uI1v%eFg#b^VE@o!?$xV8>$ZovN|Cz9TUcIiZ~TGmv1*@l3nZ_$9JSp$UWeb{mR+Wx&@ggejM +)Nhc|5xBFGp}E`Hzba0Q}dk_Xk;*9VL_wI{dTG1ObjNg^bXR7M +3Mh)Z0m<-xu|-xovlxvYq4L3MUY$b{dyN#b?@8&GifQ=fd*&Sz&~WpPn-RG?bWyL8!rl^3fd@2XIivp +Zog0ExYk=Yz94bfp#;=JJg%J;M_d=(N0|DB_&Bo2f|q@R@6%%v!VCv!e07%`<1P#wkrsPc>~oK0pvck +(Nw2sWSo6t`RO=UJ*aX3+_j%Z(Q1rs}vO`Q@p^prH44F6*ZPz+t2jAO8%c7C)Wn@xg1Hmxxg7@f|c}@ +fo!Ae=b;8mMqX`v{HXs<%&0Jxkl`hhDi^`)#_<#v|K4f%2M@Cz(?oSbCOHc^m>1?Cge7=7v4qNggMPZ +Kqp(!#AF&IB-LlyFhi-Ml6YFp0emH%mTwfnuLU?ORyh;SaFFIHsDqkA~%s$Byy~>G*7H^gV`eW# +M8|YX6-Y>}4`^Ve<)^Fk3WFd!U*03$}GuTTq6fql)P4GF?+fiv3aq#Sh6@*Om$((C0RYyIo37=`q2jS0rt(lP*jIpcFYmp((U +!`-q0S6S;n^K*|isnl+y*FPMF2p>sEt*z5MC}@biVn;%3FFwv1;kaZX845<8+Vfw6Ln^tzM%axz*Ut~ +ZLZ@^{AMp3vs(z@zCZUO!1mHD>MMDBzk7 +w&RdfNE+SI#3Q1-R9j{;Suu~b?|9j+7(`V)T7(`BaHro=Tw!SeCh;bTA#fOVaoCH9+z`Qw@;P^sEcyB +`E$)If+=G-oF8j)_443HgZDpZKdwJLui!R6>P>js<(K@<7G@!FG1Sp)C3~l%9$gvH~OwXoUKwQeM+o6^*W#SYLc$AkL6aqdCw +tw!!jCx!U5%&hLK~_#NwcQ<|A`;DuBjfh=3@-kleC+)zFUYD49wv=uH!%!FPz&6h3KI`#yOJN@ugC96~(0Kjhy6JO^Sj8 +W!c2ZA^mQMQQ9YlGycfc6;0NJE-<4R&!sbNs`J#Uf +M0Pp+A?PrTW~hU5dG{`YeN6CJ^BmwnxrZMilNTbFDX9rA{O4%lP!7YNU+calX-wW=!%Gn)N%lfN|Fz23~1NsAb*wtzo7nlqtLx +Aix23m(+BGy?~rQ>>cBNXXQ52?0qhH{TL4#>kH!7S?Im_7Hy}d3fv()<6Y3~ts~doIlib&OX&n|70xk +^zhL)I@O)t6xBAsh#fcMho=Z*F+m^!;tbY`>p{#mj~{r{paWL022^J{V+iVID5p)v0h87CoV8HbRUW^O;5&GEy!~R`wf`4TO +928D0~7!N00;o@p|(cW#fnds4FCYHC;$Kt00000000000001_fdBvi0B~t=FJE72ZfSI1UoLQYP)h*< +6ay3h000O8@1eFvOG%_c!MVRL0;Z*6U1Ze%WSc~DCM0u% +!j000080Pmr;MwSuXLA(n90IMYc01*HH00000000000HlFI8vp=sX>c!MVRL10VRCb2axQRrP)h*<6a +y3h000O8@1eFv+%gCA+YbN$PdESo5dZ)H0000000000q=76a003}la4%zRWN&bEX>V?GE^v8JO928D0 +~7!N00;o@p|(Z>v(CiRA^-rud;kCs00000000000001_fi^b)0B~t=FJy0bZftL1WG--dP)h*<6ay3h +000O8@1eFv*=kMw)&T$j=>z}(5dZ)H0000000000q=7bC003}la4%(eV`Xr3X>V?GE^v8JO928D0~7! +N00;o@p|(bW6o0vVFaQ9VxBvhQ00000000000001_fje9P0B~t=FKKRMWq2-dc~DCM0u%!j000080Pm +r;Mm~Bv*`Nsk0Jj(b01yBG00000000000HlH8i~s;|X>c!WZ)0I}X>V?GE^v8JO928D0~7!N00;o@p| +(avS%Sp*1poj~5dZ)Y00000000000001_fv=VT0B~t=FK}gWG%_`GVP|tLaCuNm0Rj{Q6aWAK2mtS)w +np2mclLb%005i-000vJ0000000000005+c*PH+VaA|Nab97;Jb#q^1Z)9b2E^v8JO928D0~7!N00;o@ +p|(Z}OGa8lBme+abN~Ph00000000000001_frXs_0B~t=FL!8VWo#~Rc~DCM0u%!j000080Pmr;MqmV +C$-4yr0OAh-02crN00000000000HlHP!2keoX>c!Jc4cm4Z*nhRUukY>bYEXCaCuNm0Rj{Q6aWAK2mt +S)wnirIa}_Z*005a80RR{P0000000000005+c;>Q30aA|NaUv_0~WN&gWX>eg=WO8M5b1rasP)h*<6a +y3h000O8@1eFvU>*mJW&r>I1p@#87ytkO0000000000q=8BP003}la4%nWWo~3|axZdaEp}yYWN&gVa +CuNm0Rj{Q6aWAK2mtS)wnia)yb8|=008tR000*N0000000000005+c<^KQxaA|NaUv_0~WN&gWa%FUK +d1-EEE^v8JO928D0~7!N00;o@p|(b1X@*YW8~^~|a{vGm00000000000001_f$0eW0B~t=FJE?LZe(w +AFLP;lE^v8JO928D0~7!N00;o@p|(bM27<-{0RR9r0ssIa00000000000001_f%+x^0B~t=FJE?LZe( +wAFJEn8a%*LBY-wUIUtei%X>?y-E^v8JO928D0~7!N00;o@p|(aY6WpZ61pokx4*&om000000000000 +01_fjlSy0B~t=FJE?LZe(wAFJEn8a%*LBY-wUIZDDe2WpZ;aaCuNm0Rj{Q6aWAK2mtS)wnm)#sPC=-0 +01rl001Na0000000000005+cK`sFRaA|NaUv_0~WN&gWV_{=xWn*t{baHQOFJE72ZfSI1UoLQYP)h*< +6ay3h000O8@1eFv@sM;}`2+v}WDo!VBLDyZ0000000000q=7Ln0RV7ma4%nWWo~3|axY_HV`yb#Z*Fv +QZ)`7NWMOc0WpXZXc~DCM0u%!j000080Pmr;MiQ#V@GJoU02TuP03iSX00000000000HlFyGywo`X>c +!Jc4cm4Z*nhVVPj}zV{dMBa&K%eV_{=xWiD`eP)h*<6ay3h000O8@1eFv!o5Cvk^lezHvs?uA^-pY00 +00000000q=D8o0RV7ma4%nWWo~3|axY_HV`yb#Z*FvQZ)`7PZ*6d4bS`jtP)h*<6ay3h000O8@1eFv% +Rm<*LJR-^j3)p9CIA2c0000000000q=Be50RV7ma4%nWWo~3|axY_HV`yb#Z*FvQZ)`7PZ*FvQZ)|L3 +axQRrP)h*<6ay3h000O8@1eFvK>{Q7p#uN_cnAOhCjbBd0000000000q=7C&0RV7ma4%nWWo~3|axY_ +HV`yb#Z*FvQZ)`7SX>4V8a$#_AWpXZXc~DCM0u%!j000080Pmr;Mw=Z~oUjD|0M!ow044wc00000000 +000HlEwM*#qEX>c!Jc4cm4Z*nhVVPj}zV{dMBa&K%eXk~SBX>)XGV{c!Jc4cm4Z*nhVVPj}zV{dMBa&K%eb7gXAVQgu7W +iD`eP)h*<6ay3h000O8@1eFvi+jaFyZ`_I@&Nzc!Jc4cm4Z*nhVVPj}zV{dMBa&K%eV_{=xWpgiIUukY>bYEXCaCuNm0Rj{Q6aWAK2mtS)wno +9H2LD?H007Jl001oj0000000000005+cBUb?caA|NaUv_0~WN&gWV_{=xWn*t{baHQOFJob2Xk~LRW@ +&6?Ut?ioXk{*Nc~DCM0u%!j000080Pmr;M$?GKRHgv{0L=pc04@Lk00000000000HlG*Tmb-ZX>c!Jc +4cm4Z*nhVVPj}zV{dMBa&K%eV_{=xWpgibWn^h{Ut?ioXk{*Nc~DCM0u%!j000080Pmr;MlVOFqNe}= +0O0@t03ZMW00000000000HlGtUI74bX>c!Jc4cm4Z*nhVZ)|UJVQpbAUtei%X>?y-E^v8JO928D0~7! +N00;o@p|(bsqk`=;0{{R32><{b00000000000001_fuLUj0B~t=FJE?LZe(wAFJo_PZ*pO6VJ~5Bb7? +Mcc~DCM0u%!j000080Pmr;M*eZQEaM3P04^i|03!eZ00000000000HlEqV*vngX>c!Jc4cm4Z*nhVZ) +|UJVQpbAVQzD2bZ>WQZZk42aCuNm0Rj{Q6aWAK2mtS)wnpw^%f<=<002D(001HY0000000000005+cG +Hn3>aA|NaUv_0~WN&gWV{dG4a$#*@FKKRRbZKF1X>(;RaCuNm0Rj{Q6aWAK2mtS)wnnq5o^LM&0003L +0012T0000000000005+cd~X2&aA|NaUv_0~WN&gWV{dG4a$#*@FL!BfGcqo4c~DCM0u%!j000080Pmr +;MwGHAAu9y{0Av;b03QGV00000000000HlHDbO8WxX>c!Jc4cm4Z*nhVZ)|UJVQpbAcWG{PWpZsUaCu +Nm0Rj{Q6aWAK2mtS)wni{|<9}TN002b-0018V0000000000005+cPI>_VaA|NaUv_0~WN&gWWNCABY- +wUIUtei%X>?y-E^v8JO928D0~7!N00;o@p|(c6fOgNS001w*0018V0000000000 +005+cW~KoEaA|NaUv_0~WN&gWWNCABY-wUIWMOn+VqtS-E^v8JO928D0~7!N00;o@p|(ci2F_dw6#xM +6Q2+oO00000000000001_fd|zA0B~t=FJE?LZe(wAFJx(RbZlv2FKKRMWq2-dc~DCM0u%!j000080Pm +r;M!pK&ozXA=0Gz%603QGV00000000000HlFR>Hz?7X>c!Jc4cm4Z*nhWX>)XJX<{#IZ)0I}Z*p@kaC +uNm0Rj{Q6aWAK2mtS)wnm`~BzQm%0015}0018V0000000000005+cSQ`QWaA|NaUv_0~WN&gWWNCABY +-wUIZDDR{W@U49E^v8JO928D0~7!N00;o@p|(an5v~G_2LJ$y7ytks00000000000001_fz>Jk0B~t= +FJE?LZe(wAFJx(RbZlv2FKuCRYh`kCE^v8JO928D0~7!N00;o@p|(c&o$rflBLD!Zl>h)A000000000 +00001_fu1q~0B~t=FJE?LZe(wAFJx(RbZlv2FKuOXVPs)+VJ>iaP)h*<6ay3h000O8@1eFv?_5JroeB +T|z$E|xAOHXW0000000000q=80O0swGna4%nWWo~3|axY|Qb98KJVlQ%Kb8mHWV`XzLaCuNm0Rj{Q6a +WAK2mtS)wnkw4yCLBZ003Sx0015U0000000000005+cAz=alaA|NaUv_0~WN&gWWNCABY-wUIb7OL8a +CCDnaCuNm0Rj{Q6aWAK2mtS)wnidIhQ6D$0001H0RS5S0000000000005+cK5+s7aA|NaUv_0~WN&gW +WNCABY-wUIbTcw8Wq4&!O928D0~7!N00;o@p|(bE=}Lvjv;Y7AbO8Vx00000000000001_ff6PI0B~t +=FJE?LZe(wAFJx(RbZlv2FLX9EE@gOSP)h*<6ay3h000O8@1eFv@wwoE7C8U_{m1|S8vp2ZVc~DCM0u%!j000080Pmr;Mi~}vBCHtz0H0g{03 +HAU00000000000HlFp6a)ZpX>c!Jc4cm4Z*nhWX>)XJX<{#SWpZc!Jc4cm4Z*nhWX>)XJX<{#TGcqn^cx6ya0Rj{Q +6aWAK2mtS)wnnO9JS~E;0001J0RS5S0000000000005+cA>IT4aA|NaUv_0~WN&gWWNCABY-wUIcQ!O +GWq4&!O928D0~7!N00;o@p|(a-u4)MSBme+=m;eAA00000000000001_f!vP;0B~t=FJE?LZe(wAFJx +(RbZlv2FL!8VWo#~Rc~DCM0u%!j000080Pmr;MkDWM{KEhM01^QJ04V?f00000000000HlEswFLlhX> +c!Jc4cm4Z*nhWX>)XJX<{#5Vqs%zaBp&SFJE72ZfSI1UoLQYP)h*<6ay3h000O8@1eFvuZk~a&H(@b% +L4!aB>(^b0000000000q=6c?1pshqa4%nWWo~3|axY|Qb98KJVlQ7}VPk7>Z*p`mZE163E^v8JO928D +0~7!N00;o@p|(aesnNps00000000000001_fh)KL0B~t=FJE?LZe(wAFJx(RbZlv2FJEF +|V{344a&#|qXmxaHY%XwlP)h*<6ay3h000O8@1eFvZx#Tp_5lC@ISK#(D*ylh0000000000q=C591ps +hqa4%nWWo~3|axY|Qb98KJVlQ7}VPk7>Z*p`mb9r-PZ*FF3XD(xAXHZK40u%!j000080Pmr;MiDc!Jc4cm4Z*nhWX>)XJX<{#5Vqs%zaBp&SFLQZwV{dL|X +=g5Qc~DCM0u%!j000080Pmr;MxjGETVq)O0Mls!04M+e00000000000HlE@_5}cNX>c!Jc4cm4Z*nhW +X>)XJX<{#5Vqs%zaBp&SFLYsYW@&6?E^v8JO928D0~7!N00;o@p|(b*n)@t@0RRBX0ssIY000000000 +00001_fzVF|0B~t=FJE?LZe(wAFKBdaY&C3YVlQ7`X>MtBUtcb8c~DCM0u%!j000080Pmr;Mvsc!Jc4cm4Z*nhabZu-kY-wUIV{dMAbYX6Eb1rasP)h*<6a +y3h000O8@1eFv1#TRy|3m-)W6A*lBLDyZ0000000000q=BQG1^{qra4%nWWo~3|axZ9fZEQ7cX<{#Eb +Zu-kaA9(DWpXZXc~DCM0u%!j000080Pmr;Mmoc!J +c4cm4Z*nhabZu-kY-wUIX=q_|Wq56DE^v8JO928D0~7!N00;o@p|(byYKRHb9smHbdjJ3<000000000 +00001_fhP3^0B~t=FJE?LZe(wAFKBdaY&C3YVlQcKaCLNZbaG{3Z7y(mP)h*<6ay3h000O8@1eFv$tn +x`Mic-5{6qi%ApigX0000000000q=7mV2LNzsa4%nWWo~3|axZ9fZEQ7cX<{#PVQy)3X?kUHE^v8JO9 +28D0~7!N00;o@p|(a+Cv)rz9RL7c!Jc4cm4Z*nhabZu-kY-wUIW@&76WpZ;bUtei%X>?y-E^v8JO928D0~7!N00;o@p|( +aMfcwOi0000U0RR9c00000000000001_f$vKP0B~t=FJE?LZe(wAFKBdaY&C3YVlQTCY;c!Jc4cm4Z*nhabZu-kY-wUIW@&76WpZ;bZ*X*JZ*F01bYW+6E^v8JO928D0 +~7!N00;o@p|(aiujHYz0001B0RR9g00000000000001_fjL|U0B~t=FJE?LZe(wAFKBdaY&C3YVlQTC +Y;dS!AiUtei%X> +?y-E^v8JO928D0~7!N00;o@p|(c%@r_G%4FCW)G5`QE00000000000001_fudjs0B~t=FJE?LZe(wAF +KBdaY&C3YVlQ)La%o{~X?kUHFKBdaY;$FDX<=+>dS!AhaCuNm0Rj{Q6aWAK2mtS)wnhK|0006200000 +001oj0000000000005+cXKn`oaA|NaUv_0~WN&gWXmo9CHEd~OFLZKcWnpAtaCBvIb1z?CX>MtBUtcb +8c~DCM0u%!j000080Pmr;M&w*y5E=pi0DT4k04M+e00000000000HlGmZU+ExX>c!Jc4cm4Z*nhabZu +-kY-wUIbaG{7VPs)&bY*gLFLPmdE^v8JO928D0~7!N00;o@p|(b#Oo!#-1ONa{4FCWw000000000000 +01_ffR8E0B~t=FJE?LZe(wAFKBdaY&C3YVlQ-ZWo2S@X>4R=a&s?VUukY>bYEXCaCuNm0Rj{Q6aWAK2 +mtS)wnn=Qsj@>30056Q001fg0000000000005+cL3RfKaA|NaUv_0~WN&gWXmo9CHEd~OFLZKcWny({ +Y-D9}b1z?FVRL0JaCuNm0Rj{Q6aWAK2mtS)wnkwpF&vi%000#s001Ze0000000000005+c%!CI3aA|N +aUv_0~WN&gWXmo9CHEd~OFLZKcWny({Y-D9}b1!6XZ7y(mP)h*<6ay3h000O8@1eFvV9$Fe1PTBEO)& +rfDgXcg0000000000q=Bi72LNzsa4%nWWo~3|axZ9fZEQ7cX<{#Qa%E*=b!lv5WpZ;bWpr|7WiD`eP) +h*<6ay3h000O8@1eFvlbc!Jc4cm4Z*nhabZu-kY-wUIbaG{7cVTR6WpZ;bUtei%X>?y-E^v8JO928D0~7! +N00;o@p|(cN!!)k~1^@tN8vp<)00000000000001_fj6rM0B~t=FJE?LZe(wAFKBdaY&C3YVlQ-ZWo3 +6^Y-?q5b1z?FVRL0JaCuNm0Rj{Q6aWAK2mtS)wnm+=3FG+z004~z001Wd0000000000005+cfUySvaA +|NaUv_0~WN&gWXmo9CHEd~OFLZKcWp`n0Yh`kCFJy0RE^v8JO928D0~7!N00;o@p|(Z?@boC=1ONc;5 +dZ)w00000000000001_fxfc`0B~t=FJE?LZe(wAFKBdaY&C3YVlQ-ZWo36^Y-?q5b1!9da%E*MaCuNm +0Rj{Q6aWAK2mtS)wni-&u-Cx?008C)001xm0000000000005+c>$nF1aA|NaUv_0~WN&gWXmo9CHEd~ +OFLZKcWp`n0Yh`kCFK1(^b0000000000q=9qA +2LNzsa4%nWWo~3|axZ9fZEQ7cX<{#Qa%p8RUtei%X>?y-E^v8JO928D0~7!N00;o@p|(c!Vuh1^0RRA +>0{{Rb00000000000001_fjq_s0B~t=FJE?LZe(wAFKBdaY&C3YVlQ-ZX=N{8VqtS-E^v8JO928D0~7 +!N00;o@p|(aORh_A(0RRA+1ONad00000000000001_f%(S=0B~t=FJE?LZe(wAFKBdaY&C3YVlQ-ZX= +N{DVRUk7WiD`eP)h*<6ay3h000O8@1eFvOHXdj9RdIV?*;$>9{>OV0000000000q=Dec2LNzsa4%nWW +o~3|axZ9fZEQ7cX<{#Qa%p8RaCt6pc~DCM0u%!j000080Pmr;M)iNB^;il30Lmi(03ZMW0000000000 +0HlFB%m)B)X>c!Jc4cm4Z*nheZ)0m_X>4ULUtei%X>?y-E^v8JO928D0~7!N00;o@p|(as5E(Zg0{{S +73IG5k00000000000001_fzZ|m0B~t=FJE?LZe(wAFKlmPYi4O|WiM=LZfk6BV{2wc!Jc4cm4Z*nheZ)0m_X>4ULZE +Iv{a%^v7Yi4O|WiD`eP)h*<6ay3h000O8@1eFvq|G1_MhE}^O&9c!Jc4cm4Z*nheZ)0m_X>4ULb8&2GbY*OBV{2wjwaEX>c!Jc4cm4Z*nheZ)0m_X>4ULb9rrSX>M +z5Z)0m_X>4UKaCuNm0Rj{Q6aWAK2mtS)wnk$VR5C^a001!r001HY0000000000005+cKko+saA|NaUv +_0~WN&gWaA9L>VP|P>XD?r0VPbD}bYEXCaCuNm0Rj{Q6aWAK2mtS)wnkXh=eGO-004>u001EX000000 +0000005+c#qkFKaA|NaUv_0~WN&gWaA9L>VP|P>XD?r0X>MtBUtcb8c~DCM0u%!j000080Pmr;MrTL8 +o3H`^0ObS#03ZMW00000000000HlEc^alWNX>c!Jc4cm4Z*nhiVPk7yXK8L{FJEJCZE#_9E^v8JO928 +D0~7!N00;o@p|(b@k~y_i0ssIJ2LJ#h00000000000001_f$sJP0B~t=FJE?LZe(wAFK}UFYhh<;Zf7 +rFb98cbV{~ +c!Jc4cm4Z*nhiVPk7yXK8L{FLQ8ZV`*k-WpZ;aaCuNm0Rj{Q6aWAK2mtS)wniK9gx@_5003+*001BW0 +000000000005+c+Y$%>aA|NaUv_0~WN&gWaA9L>VP|P>XD@bTa&u{KZZ2?nP)h*<6ay3h000O8@1eFv +2sVE&J#PR2@0$StB>(^b0000000000q=8l;2mo+ta4%nWWo~3|axZXeXJ2w?y +-E^v8JO928D0~7!N00;o@p|(Z<00002000000000h00000000000001_f!2@+0B~t=FJE?LZe(wAFK} +yTUvg!0Z*_8GWpgidWpi|MFJE72ZfSI1UoLQYP)h*<6ay3h000O8@1eFv1I8G5zXSjPcMSjlH2?qr00 +00000000q=6xk2mo+ta4%nWWo~3|axZXeXJ2wFa%FRKFJE72ZfSI1UoLQYP)h*<6ay3h000O8@1e +Fv119ezMg#x=lL`O;8vp=lX>c!Jc4cm4Z*nhia&KpHWpi^cV +{dhCbY*fbaCuNm0Rj{Q6aWAK2mtS)wniM8qeln?002%40018V0000000000005+c-nj?>aA|NaUv_0~ +WN&gWaB^>Fa%FRKFKA_KaAk6HE^v8JO928D0~7!N00;o@p|(bfGuvMN0ssI#1poja00000000000001 +_fg`>M0B~t=FJE?LZe(wAFK}{iXL4n8b1!pnX>M+1axQRrP)h*<6ay3h000O8@1eFvMveu@rUL)~MF# +)?AOHXW0000000000q=8<+2mo+ta4%nWWo~3|axZdaadl;LbaO9XUukY>bYEXCaCuNm0Rj{Q6aWAK2m +tS)wnkCxZA^C&0062%001BW0000000000005+cLd6IGaA|NaUv_0~WN&gWa%FLKWpi|MFJWY1aCBvIb +1rasP)h*<6ay3h000O8@1eFv%AV%vI|Tp$Clvqy8vpc! +Jc4cm4Z*nhkWpQ<7b98erVRdw9E^v8JO928D0~7!N00;o@p|(cTP+ERWc>(~^v;+Vj0000000000000 +1_fg|Mz0B~t=FJE?LZe(wAFLGsZb!BsOb1!3IV`Xx5E^uXSP)h*<6ay3h000O8@1eFvtuZf-W&r>IWd +Z;I9RL6T0000000000q=Bqn3jlCwa4%nWWo~3|axZdaadl;LbaO9bWpZ?LE^v8JO928D0~7!N00;o@p +|(a;-o@N70ssKL1pojZ00000000000001_flXiw0B~t=FJE?LZe(wAFLGsZb!BsOb1!3WZE#_9E^v8J +O928D0~7!N00;o@p|(cMNfFH75&!@vLjV9D00000000000001_fw^J}0B~t=FJE?LZe(wAFLGsZb!Bs +Ob1!3WZ)<5~b1rasP)h*<6ay3h000O8@1eFv(jFW@WCH*I)d>IqA^-pY0000000000q=D6S3jlCwa4% +nWWo~3|axZdaadl;LbaO9dcw=R7bZKvHb1rasP)h*<6ay3h000O8@1eFv7k2%;iva)tGy?zt9RL6T00 +00000000q=9*P3jlCwa4%nWWo~3|axZdaadl;LbaO9gZ*OaJE^v8JO928D0~7!N00;o@p|(c#D((2@A +OHaPaR2}w00000000000001_fj@f-0B~t=FJE?LZe(wAFLGsZb!BsOb1!XgWMyn~E^v8JO928D0~7!N +00;o@p|(bSLH;O;8UO&gUH||f00000000000001_fnl5r0B~t=FJE?LZe(wAFLGsZb!BsOb1!pcb8~5 +LZgVbhc~DCM0u%!j000080Pmr;Mk<=g-sJ=U0Duet03-ka00000000000HlE_w+jGpX>c!Jc4cm4Z*n +hkWpQ<7b98erb97;Jb#q^1Z)9b2E^v8JO928D0~7!N00;o@p|(bBlL@131ONb`3jhEj000000000000 +01_fl#~)0B~t=FJE?LZe(wAFLGsZb!BsOb1!pra&=>Lb#i5ME^v8JO928D0~7!N00;o@p|(cjw73;r8 +vp=SQvd)R00000000000001_f&IV>0B~t=FJE?LZe(wAFLGsZb!BsOb1!vtX>4;YaCuNm0Rj{Q6aWAK +2mtS)wnmRB>g6*4002G!001cf0000000000005+cmD~#eaA|NaUv_0~WN&gWa%FLKWpi|MFK}UFYhh< +)b1z?CX>MtBUtcb8c~DCM0u%!j000080Pmr;MsaLP{EY$t01pKK05Jdn00000000000HlEr-3tJ4X>c +!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D?FJow7a%5$6FJE72ZfSI1UoLQYP)h*<6ay3h000O8@1eFvah +$&~caZ=9qCx=xF#rGn0000000000q=D<-3jlCwa4%nWWo~3|axZdaadl;LbaO9oVPk7yXJvCQV`yP=W +MyWppoMX=gQXa&KZ~axQRrP)h*<6ay3h000O8@1eF +vd9qhoGXwwt$O!-dGXMYp0000000000q=6lE3;=Lxa4%nWWo~3|axZdaadl;LbaO9oVPk7yXJvCQV`y +P=WMyX>c!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D?FJow7a%5$6FJow7a%5?9baH88b#!TOZZ2?nP)h*<6 +ay3h000O8@1eFvIfAWpXZXc~DCM0u%!j000080Pmr;M)(=%gIfat0B#2 +W05$*s00000000000HlG_hYSF4X>c!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D?FJow7a%5$6FJow7a&u +*LaB^>AWpXZXc~DCM0u%!j000080Pmr;M!?w+G~fdO01gQN06PEx00000000000HlF}iwpp8X>c!Jc4 +cm4Z*nhkWpQ<7b98eraA9L>VP|D?FJow7a%5$6FJo_HX>Mn8bYXO5ZDC_*X>MgMaCuNm0Rj{Q6aWAK2 +mtS)wniZP-8oSL004yq001ul0000000000005+cyN?V2aA|NaUv_0~WN&gWa%FLKWpi|MFK}UFYhh<) +b1!3PVRB?;bT4CXZE#_9E^v8JO928D0~7!N00;o@p|(c+Rlv`-0ssIv1pojt00000000000001_fmxC +a0B~t=FJE?LZe(wAFLGsZb!BsOb1!gVV{2h&WpgiMXkl_>WppoNZ*FsRVQzGDE^v8JO928D0~7!N00; +o@p|(b=1}4T#0{{T_1^@sw00000000000001_fnSvj0B~t=FJE?LZe(wAFLGsZb!BsOb1!gVV{2h&Wp +giMXkl_>WppoNa5*$NaB^>AWpXZXc~DCM0u%!j000080Pmr;My4&&IdKF40CNlg05Sjo00000000000 +HlHam<#}LX>c!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D?FJow7a%5$6FJ*IMaB^>AWpXZXc~DCM0u%!j +000080Pmr;M%GCE%*h1+0G}QJ04@Lk00000000000HlGwoeThQX>c!Jc4cm4Z*nhkWpQ<7b98eraA9L +>VP|D?FJow7a%5$6FJ*IMb8Rkgc~DCM0u%!j000080Pmr;My!0iMGFN00A3CN05kvq00000000000Hl +G_qYMCWX>c!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D?FJow7a%5$6FJ*OOYH)CJZ(?O~E^v8JO928D0~ +7!N00;o@p|(aUWppoPbz^ICW^!e5E^v8JO928D0~7!N00;o@p|(Z^v&Q5Z0{{Sv1^@sw0000000000 +0001_fiL|G0B~t=FJE?LZe(wAFLGsZb!BsOb1!gVV{2h&WpgiMXkl_>WppoPbz^ICaB^>AWpXZXc~DC +M0u%!j000080Pmr;MkP<96yHDq062&M05Sjo00000000000HlGM01W_eX>c!Jc4cm4Z*nhkWpQ<7b98 +eraA9L>VP|D?FJow7a%5$6FJ*OOba!TQWpOTWc~DCM0u%!j000080Pmr;MlGT^R2c&R0E`9z05kvq00 +000000000HlG*K@9+KX>c!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D?FJow7a%5$6FJ*OOba!xaZ(?O~E +^v8JO928D0~7!N00;o@p|(ajjr0xcLI41(i~s;L00000000000001_fiy)80B~t=FJE?LZe(wAFLGsZ +b!BsOb1!gVV{2h&WpgiMXkl_>WppoRVlp!^GG=mRaV~IqP)h*<6ay3h000O8@1eFvAGO=|8Up|Tkp=( +&H2?qr0000000000q=9gV4FGUya4%nWWo~3|axZdaadl;LbaO9oVPk7yXJvCQV`yP=WMyWppoSWnyw=cW`oVVr6nJaCuNm0Rj{Q6aWAK2mtS)wnmq)n +hw5J007gt001xm0000000000005+co1P5-aA|NaUv_0~WN&gWa%FLKWpi|MFK}UFYhh<)b1!3PVRB?; +bT4XYb7pd7aV~IqP)h*<6ay3h000O8@1eFv8-?V^OA`P9luG~rF8}}l0000000000q=BdP4FGUya4%n +WWo~3|axZdaadl;LbaO9oVPk7yXJvCQV`yP=WMyc!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D?FJow7a%5$6FK +l6MXJU11XJK+_VQy`2WMynFaCuNm0Rj{Q6aWAK2mtS)wnm(uw`2Va002Ej0024w0000000000005+cq +!bPSaA|NaUv_0~WN&gWa%FLKWpi|MFK}UFYhh<)b1!3PVRB?;bT4dSZf9e8a%pUAX=80~WMynFaCuNm +0Rj{Q6aWAK2mtS)wnh;lLmg!a002}m001`t0000000000005+c`5+DeaA|NaUv_0~WN&gWa%FLKWpi| +MFK}UFYhh<)b1!3PVRB?;bT4dSZf9q5Wo2t^Z)9a`E^v8JO928D0~7!N00;o@p|(aJqI(LS2><{#EC2 +vF00000000000001_fwL+O0B~t=FJE?LZe(wAFLGsZb!BsOb1!gVV{2h&WpgiMXkl_>WppoWVQyz=Wn +yw=cWrNEWo#~Rc~DCM0u%!j000080Pmr;Mo_n!e#Z&`0QfKf06PEx00000000000HlGZG!6i8X>c!Jc +4cm4Z*nhkWpQ<7b98eraA9L>VP|D?FJow7a%5$6FKl6MXJ~b9XJK+_VQy`2WMynFaCuNm0Rj{Q6aWAK +2mtS)wnj@me_iDY000Xt001@s0000000000005+c$3G4LaA|NaUv_0~WN&gWa%FLKWpi|MFK}UFYhh< +)b1!3PVRB?;bT4dSZfA68VQFn|WMynFaCuNm0Rj{Q6aWAK2mtS)wnpWes+oHR003|l001=r00000000 +00005+c080)4aA|NaUv_0~WN&gWa%FLKWpi|MFK}UFYhh<)b1!3PVRB?;bT4dSbZKreaB^>AWpXZXc~ +DCM0u%!j000080Pmr;Mx~r_bDabL0K^Oc05|{u00000000000HlG=Q4RobX>c!Jc4cm4Z*nhkWpQ<7b +98eraA9L>VP|D?FJow7a%5$6FKuFDXkl`5Wpr?IZ(?O~E^v8JO928D0~7!N00;o@p|(cOjE_560{{T8 +2LJ##00000000000001_fx%V|0B~t=FJE?LZe(wAFLGsZb!BsOb1!gVV{2h&WpgiMXkl_>WppoXVqa&L8TaB^>AWpXZXc~DCM0u%!j000080Pmr;M)BomnoJA;0ESEe051Rl00000000000HlF%S`GkkX>c +!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D?FJow7a%5$6FKuFDb8~GjaCuNm0Rj{Q6aWAK2mtS)wnq9I6} +Wl^006lX001}u0000000000005+c31@K*f<006WO001)p0000000000005+cQ*sUfaA|NaUv_0~WN&gWa%FLKWpi|MFK} +UFYhh<)b1!3PVRB?;bT4yiX>)LLZ(?O~E^v8JO928D0~7!N00;o@p|(b?oHjaF2LJ%L8UO$~0000000 +0000001_fuVN}0B~t=FJE?LZe(wAFLGsZb!BsOb1!gVV{2h&WpgiMXkl_>WppofZfSO9a&uv9WMy<^V +{~tFE^v8JO928D0~7!N00;o@p|(a}`ygu`1ONbB3IG5z00000000000001_flz-A0B~t=FJE?LZe(wA +FLGsZb!BsOb1!gVV{2h&WpgiMXkl_>WppofbY?hka&KZ~axQRrP)h*<6ay3h000O8@1eFvc()cWf&%~ +m2M7QFF#rGn0000000000q=CPK4ghdza4%nWWo~3|axZdaadl;LbaO9oVPk7yXJvCQb#iQMX<{=kUte +i%X>?y-E^v8JO928D0~7!N00;o@p|(aDLM(^P3;+PuC;$L800000000000001_fsls|0B~t=FJE?LZe +(wAFLGsZb!BsOb1!gVV{2h&Wpgiea%^mAVlyvaV{dG1Wn*+{Z*FrgaCuNm0Rj{Q6aWAK2mtS)wnkFaM +EI2p001*1001)p0000000000005+cu#^q}aA|NaUv_0~WN&gWa%FLKWpi|MFK}UFYhh<)b1!vrY;0*_ +GcRLrZf<2`bZKvHE^v8JO928D0~7!N00;o@p|(axyhb?lAOHYwb^ri300000000000001_ftH{S0B~t +=FJE?LZe(wAFLGsZb!BsOb1!gVV{2h&Wpgiea%^mAVlyveZ*Fd7V{~b6Zg6jJY%XwlP)h*<6ay3h000 +O8@1eFv9yTnblm!3)77+jdGXMYp0000000000q=DYS4ghdza4%nWWo~3|axZdaadl;LbaO9oVPk7yXJ +vCQb#iQMX<{=kWq4y{aCB*JZgVbhc~DCM0u%!j000080Pmr;M)O8x`2`060Lc~r051Rl00000000000 +HlG##|{8+X>c!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D?FLiQkY-wUMFJ@_FY-DpTaCuNm0Rj{Q6aWAK +2mtS)wnl6b5gc!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D?FLiQkY-wUMFK};fY;9p~VP|D>E^v8JO928D0~ +7!N00;o@p|(cm-NJu>2LJ$f761S+00000000000001_fhOJ#0B~t=FJE?LZe(wAFLGsZb!BsOb1!gVV +{2h&Wpgiea%^mAVlyvtWpQ<7b963nc~DCM0u%!j000080Pmr;MneJ_`VSHS082ms05Jdn0000000000 +0HlHRc!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D?FLiQkY-wUMFLGsbaBpsNWiD`eP)h*<6ay3 +h000O8@1eFv000000ssI200000IRF3v0000000000q=8cS4ghdza4%nWWo~3|axZdaadl;LbaO9oVPk +7yXJvCQb#iQMX<{=kV{dMBa%o~OUtei%X>?y-E^v8JO928D0~7!N00;o@p|(Z{qnpo{1pok>5dZ)=00 +000000000001_fvflq0B~t=FJE?LZe(wAFLGsZb!BsOb1!gVV{2h&Wpgiea%^mAVlyveZ*FvQX<{#Kb +Zl*KZ*OcaaCuNm0Rj{Q6aWAK2mtS)wnjoxF@<#u003?z0024w0000000000005+cnf?v{aA|NaUv_0~ +WN&gWa%FLKWpi|MFK}UFYhh<)b1!vrY;0*_GcRLrZgg^KVlQxcZ*XO9b8~DiaCuNm0Rj{Q6aWAK2mtS +)wno3y4In=N002q=0024w0000000000005+cW(yAhaA|NaUv_0~WN&gWa%FLKWpi|MFK}UFYhh<)b1! +vrY;0*_GcRyqV{2h&WpgiIUukY>bYEXCaCuNm0Rj{Q6aWAK2mtS)wnj$5rf2X9008GA002G!0000000 +000005+c{Rc!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D?FLiQkY-w +UMFK}UFYhh<)b1!pqY+r3*bYo~=Xm4|LZeeX@FJE72ZfSI1UoLQYP)h*<6ay3h000O8@1eFvt<;VP|D?FLQHjUu|J@V`yJ!Z*z2RVQpnEUukV{Y-Md_ZggREX>V>WaCuNm0Rj{Q6aWAK2mtS)wnn_E +^n?Qe008Cz001@s0000000000005+cwk;0;aA|NaUv_0~WN&gWa%FLKWpi|MFK}UFYhh<)b1!vrY;0* +_GcR>?X>2cFUukY>bYEXCaCuNm0Rj{Q6aWAK2mtS)wnqAOI#dh=007+#001}u0000000000005+c4KE +J>aA|NaUv_0~WN&gWa%FLKWpi|MFK}UFYhh<)b1!vrY;0*_GcR>?X>2cJZ*Fd7V{~b6ZZ2?nP)h*<6a +y3h000O8@1eFvt*Rrv#{vKVDF^@nH2?qr0000000000q=9cV4*+m!a4%nWWo~3|axZdaadl;LbaO9oV +Pk7yXJvCQb#iQMX<{=kb#!TLFLGsZb!BsOE^v8JO928D0~7!N00;o@p|(b6|KT(d0RR9t0ssIu00000 +000000001_fr&Q{0B~t=FJE?LZe(wAFLGsZb!BsOb1!gVV{2h&Wpgiea%^mAVlyvwbZKlaa%FRHZ*Fs +CE^v8JO928D0~7!N00;o@p|(cQ)Y~Lb3;+PcCIA3400000000000001_f$lgD0B~t=FJE?LZe(wAFLG +sZb!BsOb1!gVV{2h&Wpgiea%^mAVlyvwbZKlaa%FUKc`k5yP)h*<6ay3h000O8@1eFv-RBv$f(-xwH7 +5W7G5`Po0000000000q=An`4*+m!a4%nWWo~3|axZdaadl;LbaO9oVPk7yXJvCQb#iQMX<{=kb#!TLF +LQHjUoLQYP)h*<6ay3h000O8@1eFv>>aA|NaV{dJ3VQyq|FKKRbbYX04E^v8JO928D0~7!N00;o@p|(bGkCPBE2L +J$58~^|m00000000000001_fh2$r0B~t=FJo_QZDDR?b1!UZb963nc~DCM0u%!j000080Pmr;M%nAc!NZ*6U1Ze(*Wb7f(2V`wgLc~DCM0u%!j000080Pmr; +MpB8;Mj-|O0B#ci02BZK00000000000HlEtjt>BEX>c!NZ*6U1Ze(*Wb7*gOE^v8JO928D0~7!N00;o +@p|(b=i5Wl80{{R-3jhEa00000000000001_fn<~q0B~t=FJo_QZDDR?b1!vnX>N0LVQg$JaCuNm0Rj +{Q6aWAK2mtS)wnp#{#Re(}007(^000#L0000000000005+cYnTrJaA|NaV{dJ3VQyq|FL!8VWo#~Rc~ +DCM0u%!j000080Pmr;Mj`8XQ#Azu0JIAL02TlM00000000000HlG)pbr3WX>c!NZ*6d4bT40DX>MtBU +tcb8c~DCM0u%!j000080Pmr;MuMWHmrWG_061Cz02lxO00000000000HlF2rVjvcX>c!NZ*6d4bT4FS +V{~J0Zf0p`E^v8JO928D0~7!N00;o@p|(b<8fUyg0000-0000M00000000000001_fwa310B~t=FKus +RWo&aVUtei%X>?y-E^v8JO928D0~7!N00;o@p|(b7PBLxb0002z0RR9K00000000000001_fhoKX0B~ +t=FKusRWo&aVX>Md?crI{xP)h*<6ay3h000O8@1eFv000000ssI2000008UO$Q0000000000q=7rV4* ++m!a4&CgWpZJ3X>V?GFJE72ZfSI1UoLQYP)h*<6ay3h000O8@1eFv(lKvUWCQ>JkPiR=7ytkO000000 +0000q=9w44*+m!a4&CgWpZJ3X>V?GFJ^LOWqM^UaCuNm0Rj{Q6aWAK2mtS)wnkiO(iwmN000yL000vJ +0000000000005+c55f-saA|Naa%FKZUtei%X>?y-E^v8JO928D0~7!N00;o@p|(chKCadZ3IG6RApig +q00000000000001_fxyBK0B~t=FLGsZFLGsZUuJ1+WiD`eP)h*<6ay3h000O8@1eFvkO#o8H7WoAyr= +*G761SM0000000000q=Ea)4*+m!a4&LYaW8UZabIa}b97;BY%XwlP)h*<6ay3h000O8@1eFvfX;o=h8 +h3>vu6MR5&!@I0000000000q=97j4*+m!a4&LYaW8UZabI&~bS`jtP)h*<6ay3h000O8@1eFv5jjuuU +N0LVQg$JaCuNm0Rj{Q6aWAK2mtS) +wnl+4j%URl001Cn000#L0000000000005+cuo@5maA|Nab#!TLb1z?CX>MtBUtcb8c~DCM0u%!j0000 +80Pmr;M)R1ZR|pCK0M#P^02BZK00000000000HlGaIS>GFX>c!fbZKmJFJW+SWNC79E^v8JO928D0~7 +!N00;o@p|(cN3{5To0ssIY1pojN00000000000001_f#O3D0B~t=FLiWjY;!MSb!lv5E^v8JO928D0~ +7!N00;o@p|(c8tA=Rb0ssJL2mk;W00000000000001_ff7a#0B~t=FLiWjY;!MUWpHw3V_|e@Z*DGdc +~DCM0u%!j000080Pmr;M)E`Lz@z~H0D}Vn02crN00000000000HlE@Ne}>VX>c!fbZKmJFJ@_MWpjCR +bY*QWaCuNm0Rj{Q6aWAK2mtS)wnjMXdzPpK008d{000yK0000000000005+c080=6aA|Nab#!TLb1!U +fXJ=_{XD)DgP)h*<6ay3h000O8@1eFv){1HaItBm$QWO9H6#xJL0000000000q=DK`5CCv#a4&UqX>4 +;ZZ*_EJVRU6=E^v8JO928D0~7!N00;o@p|(b$F9q8h2><|g8UO$f00000000000001_fk##l0B~t=FL +iWjY;!MlX)bViP)h*<6ay3h000O8@1eFvKcj?HQ4Ih9@GSrU6951J0000000000q=AoL5CCv#a4&Xab +1z?CX>MtBUtcb8c~DCM0u%!j000080Pmr;M(df0^~(hS080@701*HH00000000000HlEtZ4dx(X>c!g +V{KM4Q;xE%lh4gdfE0000000000q=5@_5CCv#a4&X +ab1!FUbS`jtP)h*<6ay3h000O8@1eFv7@M0oj|Bh#ZW90i6aWAK0000000000q=9yP5CCv#a4&Xab1! +XWa$|LJX<=+GaCuNm0Rj{Q6aWAK2mtS)wnjs{dl5Yh0087D000#L0000000000005+cH-ZoVaA|Nac4 +Kodb9G{NWpZM`E>yR06hZ$03!eZ00000000000HlGZjt~HFX +>ct!E-)@JE@WwQbS-IaW^XSmkNl;WtPfjj!b97Kk0Rj{Q6aWAK2mtk=wniD#_9ZF+002Y)001Na +0000000000005+cU62p}aA|NYH!d(PF)n0jb960fZf0*UWo~qGd0%jEX>N3LE_8TwP)h*<6ay3h000O +8^`W*#!JyjmUIG9B(**zkApigX0000000000q=Cth5CCv#a4k13FfK7JWNCABEop9MZ!c|SbYWy+bYU +)Pb8l`?O928D0~7!N00;o}p|(c+Etm)|0000k0000S00000000000001_fo78s0B~t=EjKPOE-@}-X> +)WfX>Mk3FK}XVE^2dcZcs}B0u%!j000080QI4^M#mqQ!Ug~U00aO403iSX00000000000HlG>lMn!KX +>ct!E-)@JE@WwQbS-IaW^XTaZ*X61Wp-t3E_8TwP)h*<6ay3h000O8^`W*#hcka~UjP6AZU6uP82|tP +0000000000q=6Ka5CCv#a4k13FfK7JWNCABEop9MZ!cF!MMX?dO928D0~7!N00;o}p|(b%185ED0ssK +L2LJ#Z00000000000001_fvS`c0B~t=EjKPOE-@}-X>)WfX>Mk3FHJ>MK}11RK~PHp0u%!j000080QI +4^M#F)Cdul2G0FPJz02%-Q00000000000HlGct!E-)@JE@WwQbS-IaW^XT2MMF' % ( + self._start, self._end, self._fileobj) + + def tell(self): + return self._pos + + def _checkwindow(self, seekto, op): + if not (self._start <= seekto <= self._end): + raise IOError("%s to offset %d is outside window [%d, %d]" % ( + op, seekto, self._start, self._end)) + + def seek(self, offset, whence=0): + seekto = offset + if whence == os.SEEK_SET: + seekto += self._start + elif whence == os.SEEK_CUR: + seekto += self._start + self._pos + elif whence == os.SEEK_END: + seekto += self._end + else: + raise IOError("Invalid whence argument to seek: %r" % (whence,)) + self._checkwindow(seekto, 'seek') + self._fileobj.seek(seekto) + self._pos = seekto - self._start + + def write(self, bytes): + here = self._start + self._pos + self._checkwindow(here, 'write') + self._checkwindow(here + len(bytes), 'write') + self._fileobj.seek(here, os.SEEK_SET) + self._fileobj.write(bytes) + self._pos += len(bytes) + + def read(self, size=maxint): + assert size >= 0 + here = self._start + self._pos + self._checkwindow(here, 'read') + size = min(size, self._end - here) + self._fileobj.seek(here, os.SEEK_SET) + bytes = self._fileobj.read(size) + self._pos += len(bytes) + return bytes + + +def read_data(file, endian, num=1): + """ + Read a given number of 32-bits unsigned integers from the given file + with the given endianness. + """ + res = struct.unpack(endian + 'L' * num, file.read(num * 4)) + if len(res) == 1: + return res[0] + return res + + +def mach_o_change(path, what, value): + """ + Replace a given name (what) in any LC_LOAD_DYLIB command found in + the given binary with a new name (value), provided it's shorter. + """ + + def do_macho(file, bits, endian): + # Read Mach-O header (the magic number is assumed read by the caller) + cputype, cpusubtype, filetype, ncmds, sizeofcmds, flags = read_data(file, endian, 6) + # 64-bits header has one more field. + if bits == 64: + read_data(file, endian) + # The header is followed by ncmds commands + for n in range(ncmds): + where = file.tell() + # Read command header + cmd, cmdsize = read_data(file, endian, 2) + if cmd == LC_LOAD_DYLIB: + # The first data field in LC_LOAD_DYLIB commands is the + # offset of the name, starting from the beginning of the + # command. + name_offset = read_data(file, endian) + file.seek(where + name_offset, os.SEEK_SET) + # Read the NUL terminated string + load = file.read(cmdsize - name_offset).decode() + load = load[:load.index('\0')] + # If the string is what is being replaced, overwrite it. + if load == what: + file.seek(where + name_offset, os.SEEK_SET) + file.write(value.encode() + '\0'.encode()) + # Seek to the next command + file.seek(where + cmdsize, os.SEEK_SET) + + def do_file(file, offset=0, size=maxint): + file = fileview(file, offset, size) + # Read magic number + magic = read_data(file, BIG_ENDIAN) + if magic == FAT_MAGIC: + # Fat binaries contain nfat_arch Mach-O binaries + nfat_arch = read_data(file, BIG_ENDIAN) + for n in range(nfat_arch): + # Read arch header + cputype, cpusubtype, offset, size, align = read_data(file, BIG_ENDIAN, 5) + do_file(file, offset, size) + elif magic == MH_MAGIC: + do_macho(file, 32, BIG_ENDIAN) + elif magic == MH_CIGAM: + do_macho(file, 32, LITTLE_ENDIAN) + elif magic == MH_MAGIC_64: + do_macho(file, 64, BIG_ENDIAN) + elif magic == MH_CIGAM_64: + do_macho(file, 64, LITTLE_ENDIAN) + + assert(len(what) >= len(value)) + do_file(open(path, 'r+b')) + + +if __name__ == '__main__': + main() + +## TODO: +## Copy python.exe.manifest +## Monkeypatch distutils.sysconfig diff --git a/dragonpy/components/MC6809data/__init__.py b/bootstrap/__init__.py similarity index 100% rename from dragonpy/components/MC6809data/__init__.py rename to bootstrap/__init__.py diff --git a/bootstrap/create_DragonPy_bootstrap.py b/bootstrap/create_DragonPy_bootstrap.py new file mode 100755 index 00000000..e57eb832 --- /dev/null +++ b/bootstrap/create_DragonPy_bootstrap.py @@ -0,0 +1,37 @@ +#!/usr/bin/env python +# coding: utf-8 + +import os +from bootstrap_env import create_bootstrap +from bootstrap_env.pip_utils import requirements_definitions + + +REQ_FILENAMES=( + "normal_installation.txt", + "git_readonly_installation.txt", + "developer_installation.txt", +) + +BASE_PATH=os.path.abspath(os.path.join(os.path.dirname(__file__))) + +PREFIX_SCRIPT=os.path.abspath(os.path.join(BASE_PATH, "source_prefix_code.py")) + +REQ_BASE_PATH=os.path.abspath(os.path.join(BASE_PATH, "..", "requirements")) +print("requirement files path: %r" % REQ_BASE_PATH) + + +if __name__ == '__main__': + prefix_code = "\n".join([ + requirements_definitions(REQ_BASE_PATH, REQ_FILENAMES), + create_bootstrap.get_code(PREFIX_SCRIPT, create_bootstrap.INSTALL_PIP_MARK), + ]) + + create_bootstrap.generate_bootstrap( + out_filename=os.path.join("..", "boot_dragonpy.py"), + add_extend_parser="source_extend_parser.py", + add_adjust_options="source_adjust_options.py", + add_after_install="source_after_install.py", + cut_mark="# --- CUT here ---", + prefix=prefix_code, # Optional code that will be inserted before extend_parser() code part. + suffix=None, # Optional code that will be inserted after after_install() code part. + ) \ No newline at end of file diff --git a/bootstrap/source_adjust_options.py b/bootstrap/source_adjust_options.py new file mode 100755 index 00000000..fd33ce6e --- /dev/null +++ b/bootstrap/source_adjust_options.py @@ -0,0 +1,16 @@ +# coding: utf-8 + +# imports not really needed and just for the editor warning ;) +import sys +from boot_dragonpy import INST_TYPES + + +def adjust_options(options, args): + # Note: old optparse modul is used :( + # --- CUT here --- + if options.install_type == None: + sys.stderr.write("\n\nERROR:\nYou must add --install_type option (See README) !\n") + sys.stderr.write("Available types: %s\n\n" % ", ".join(INST_TYPES)) + sys.exit(-1) + + sys.stdout.write("\nInstall type: %r\n" % options.install_type) \ No newline at end of file diff --git a/bootstrap/source_after_install.py b/bootstrap/source_after_install.py new file mode 100755 index 00000000..a160538b --- /dev/null +++ b/bootstrap/source_after_install.py @@ -0,0 +1,37 @@ +# coding: utf-8 + +# imports not really needed and just for the editor warning ;) +import sys +import subprocess +import os +from bootstrap.source_prefix_code import ( + INST_PYPI, INST_GIT, INST_DEV, + NORMAL_INSTALLATION,GIT_READONLY_INSTALLATION,DEVELOPER_INSTALLATION +) +from bootstrap_env.bootstrap_install_pip import EnvSubprocess + + +def after_install(options, home_dir): + # --- CUT here --- + """ + called after virtualenv was created and pip/setuptools installed. + Now we installed requirement libs/packages. + """ + if options.install_type==INST_PYPI: + requirements=NORMAL_INSTALLATION + elif options.install_type==INST_GIT: + requirements=GIT_READONLY_INSTALLATION + elif options.install_type==INST_DEV: + requirements=DEVELOPER_INSTALLATION + else: + # Should never happen + raise RuntimeError("Install type %r unknown?!?" % options.install_type) + + env_subprocess = EnvSubprocess(home_dir) # from bootstrap_env.bootstrap_install_pip + + logfile = os.path.join(env_subprocess.abs_home_dir, "install.log") + + for requirement in requirements: + sys.stdout.write("\n\nInstall %r:\n" % requirement) + env_subprocess.call_env_pip(["install", "--log=%s" % logfile, requirement]) + sys.stdout.write("\n") diff --git a/bootstrap/source_extend_parser.py b/bootstrap/source_extend_parser.py new file mode 100755 index 00000000..c309b4dd --- /dev/null +++ b/bootstrap/source_extend_parser.py @@ -0,0 +1,12 @@ +# coding: utf-8 + +# imports not really needed and just for the editor warning ;) +import sys +from bootstrap_env.source_prefix_code import INST_PYPI, INST_TYPES + + +def extend_parser(parser): + # --- CUT here --- + parser.add_option("--install_type", dest="install_type", choices=INST_TYPES, + help="Install type: %s (See README!)" % ", ".join(INST_TYPES) + ) \ No newline at end of file diff --git a/bootstrap/source_prefix_code.py b/bootstrap/source_prefix_code.py new file mode 100644 index 00000000..3f897256 --- /dev/null +++ b/bootstrap/source_prefix_code.py @@ -0,0 +1,23 @@ +# coding: utf-8 + + +# imports not really needed and just for the editor warning ;) +import os +import sys +import subprocess + + +# Will be inserted in real bootstrap file ;) +NORMAL_INSTALLATION = None # requirements from normal_installation.txt +GIT_READONLY_INSTALLATION = None # requirements from git_readonly_installation.txt +DEVELOPER_INSTALLATION = None # requirements from developer_installation.txt + + +# --- CUT here --- + +# For choosing the installation type: +INST_PYPI="pypi" +INST_GIT="git_readonly" +INST_DEV="dev" + +INST_TYPES=(INST_PYPI, INST_GIT, INST_DEV) diff --git a/dragonpy/CoCo/config.py b/dragonpy/CoCo/config.py index a48e1444..ce241f24 100644 --- a/dragonpy/CoCo/config.py +++ b/dragonpy/CoCo/config.py @@ -16,9 +16,7 @@ import os from dragonlib.api import CoCoAPI -import logging -log=logging.getLogger(__name__) from dragonpy.CoCo.mem_info import get_coco_meminfo from dragonpy.Dragon32.config import Dragon32Cfg from dragonpy.Dragon32.keyboard_map import get_coco_keymatrix_pia_result @@ -26,6 +24,9 @@ from dragonpy.core.configs import COCO2B +log=logging.getLogger(__name__) + + class CoCo2bCfg(Dragon32Cfg): CONFIG_NAME = COCO2B MACHINE_NAME = "CoCo2b" diff --git a/dragonpy/CoCo/mem_info.py b/dragonpy/CoCo/mem_info.py index 71176685..9f833f9d 100644 --- a/dragonpy/CoCo/mem_info.py +++ b/dragonpy/CoCo/mem_info.py @@ -13,7 +13,7 @@ from __future__ import absolute_import, division, print_function -from dragonpy.core.memory_info import BaseMemoryInfo +from MC6809.core.memory_info import BaseMemoryInfo from dragonpy.utils.humanize import nice_hex import logging diff --git a/dragonpy/Dragon32/mem_info.py b/dragonpy/Dragon32/mem_info.py index 96be40ac..7461eb70 100644 --- a/dragonpy/Dragon32/mem_info.py +++ b/dragonpy/Dragon32/mem_info.py @@ -26,7 +26,7 @@ import logging log=logging.getLogger(__name__) -from dragonpy.core.memory_info import BaseMemoryInfo +from MC6809.core.memory_info import BaseMemoryInfo from dragonpy.utils.humanize import nice_hex diff --git a/dragonpy/Dragon64/mem_info.py b/dragonpy/Dragon64/mem_info.py index 7e5bafa1..d5b3f8bd 100644 --- a/dragonpy/Dragon64/mem_info.py +++ b/dragonpy/Dragon64/mem_info.py @@ -13,7 +13,7 @@ from __future__ import absolute_import, division, print_function -from dragonpy.core.memory_info import BaseMemoryInfo +from MC6809.core.memory_info import BaseMemoryInfo from dragonpy.utils.humanize import nice_hex import logging diff --git a/dragonpy/DragonPy_CLI.py b/dragonpy/DragonPy_CLI.py deleted file mode 100755 index 4fa12a52..00000000 --- a/dragonpy/DragonPy_CLI.py +++ /dev/null @@ -1,214 +0,0 @@ -#!/usr/bin/env python2 -# coding: utf-8 - -""" - DragonPy - CLI - ~~~~~~~~~~~~~~ - - :created: 2013 by Jens Diemer - www.jensdiemer.de - :copyleft: 2013-2014 by the DragonPy team, see AUTHORS for more details. - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - -from __future__ import absolute_import, division, print_function - - -import atexit -import locale -import logging -import sys - -from basic_editor.editor import run_basic_editor - -import dragonpy -from dragonpy.CoCo.config import CoCo2bCfg -from dragonpy.CoCo.machine import run_CoCo2b -from dragonpy.Dragon32.config import Dragon32Cfg -from dragonpy.Dragon32.machine import run_Dragon32 -from dragonpy.Dragon64.config import Dragon64Cfg -from dragonpy.Dragon64.machine import run_Dragon64 -from dragonpy.Multicomp6809.config import Multicomp6809Cfg -from dragonpy.Multicomp6809.machine import run_Multicomp6809 -from dragonpy.core import configs -from dragonpy.core.base_cli import Base_CLI -from dragonpy.core.bechmark import run_benchmark -from dragonpy.core.configs import machine_dict -from dragonpy.sbc09.config import SBC09Cfg -from dragonpy.sbc09.machine import run_sbc09 -from dragonpy.vectrex.config import VectrexCfg -from dragonpy.vectrex.machine import run_Vectrex - - -log = logging.getLogger(__name__) - -machine_dict.register(configs.DRAGON32, (run_Dragon32, Dragon32Cfg), default=True) -machine_dict.register(configs.DRAGON64, (run_Dragon64, Dragon64Cfg)) -machine_dict.register(configs.COCO2B, (run_CoCo2b, CoCo2bCfg)) -machine_dict.register(configs.SBC09, (run_sbc09,SBC09Cfg)) -# machine_dict.register(configs.SIMPLE6809, Simple6809Cfg) -machine_dict.register(configs.MULTICOMP6809, (run_Multicomp6809, Multicomp6809Cfg)) -machine_dict.register(configs.VECTREX, (run_Vectrex, VectrexCfg)) - - -# use user's preferred locale -# e.g.: for formating cycles/sec number -locale.setlocale(locale.LC_ALL, '') - - -@atexit.register -def goodbye(): - print("\n --- END --- \n") - - -class DragonPyCLI(Base_CLI): - LOG_NAME = "DragonPy" - DESCRIPTION = "DragonPy - Dragon 32 emulator in Python" - VERSION = dragonpy.__version__ - - def __init__(self, machine_dict): - super(DragonPyCLI, self).__init__() - self.machine_dict = machine_dict - log.debug("Existing machine_dict: %s" % repr(self.machine_dict)) - - self.parser.add_argument("--machine", - choices=sorted(self.machine_dict.keys()), - default=machine_dict.DEFAULT, - help="Used machine configuration (Default: %s)" % machine_dict.DEFAULT - ) - - self.subparsers = self.parser.add_subparsers(title="commands", - help="Help for commands, e.g.: '%s run --help'" % self.parser.prog - ) - - # The run Emulator command: - - self.parser_run_machine = self.subparsers.add_parser(name="run", - help="Start the Emulator", - epilog="e.g.: to run CoCo do: '%s --machine CoCo2b' run" % self.parser.prog - ) - self.parser_run_machine.set_defaults(func=self.run_machine) - - self.parser_run_machine.add_argument('--trace', action='store_true', - help="Create trace lines." - ) -# self.parser_run_machine.add_argument('--dont_open_webbrowser', action='store_true', -# help="Don't open the Webbrowser on CPU http control Server" -# ) - -# self.parser_run_machine.add_argument("--bus_socket_host", -# help="Host internal socket bus I/O (do not set manually!)" -# ) -# self.parser_run_machine.add_argument("--bus_socket_port", type=int, -# help="Port for internal socket bus I/O (do not set manually!)" -# ) - self.parser_run_machine.add_argument("--ram", - help="RAM file to load (default none)" - ) -# self.parser_run_machine.add_argument("--rom", -# help="ROM file to use (default set by machine configuration)" -# ) - self.parser_run_machine.add_argument("--max_ops", type=int, - help="If given: Stop CPU after given cycles else: run forever" - ) - - # The run BASIC Editor command: - - self.parser_editor = self.subparsers.add_parser(name="editor", - help="Start only the BASIC Editor", - epilog="e.g.: CoCo Editor do: '%s --machine CoCo2b' editor" % self.parser.prog - ) - self.parser_editor.set_defaults(func=self.run_editor) - - # The run only Benchmarks - - self.parser_benchmark = self.subparsers.add_parser(name="benchmark", - help="Start a benchmark", - ) - default_loops = 5 - self.parser_benchmark.add_argument("--loops", type=int, default=default_loops, - help="How many loops should be run? (default: %i)" % default_loops - ) - self.parser_benchmark.set_defaults(func=self.run_benchmark) - - def setup_cfg(self): - self.args = self.parse_args() - self.setup_logging(self.args) - - self.cfg_dict = { - "verbosity":self.args.verbosity, - "trace":None, - } - machine_name = self.args.machine - self.machine_run_func, self.machine_cfg = self.machine_dict[machine_name] - -# def open_webbrowser(self): -# url = "http://%s:%s" % (self.cfg.CPU_CONTROL_ADDR, self.cfg.CPU_CONTROL_PORT) -# webbrowser.open(url) - - def run(self): # Called from ../DragonPy_CLI.py - log.critical("run func: %s", self.args.func.__name__) - self.args.func() - - def run_machine(self): -# if not self.args.dont_open_webbrowser: -# threading.Timer(interval=1.0, function=self.open_webbrowser).start() - - log.critical("Use machine func: %s", self.machine_run_func.__name__) - self.cfg_dict.update({ - "trace":self.args.trace, -# "bus_socket_host":self.args.bus_socket_host, -# "bus_socket_port":self.args.bus_socket_port, - "ram":self.args.ram, -# "rom":self.args.rom, - "max_ops":self.args.max_ops, - }) - self.machine_run_func(self.cfg_dict) - - def run_editor(self): - log.critical("Use machine cfg: %s", self.machine_cfg.__name__) - cfg = self.machine_cfg(self.cfg_dict) - run_basic_editor(cfg) - - def run_benchmark(self): - log.critical("Run a benchmark only...") - run_benchmark(self.args.loops) - -def get_cli(): - cli = DragonPyCLI(machine_dict) - cli.setup_cfg() - return cli - - -#------------------------------------------------------------------------------ - - -def test_run(): - import os - import subprocess - cmd_args = [ - sys.executable, - os.path.join("..", "DragonPy_CLI.py"), -# "-h" -# "--log_list", - "--log", "DragonPy.cpu6809,50", "dragonpy.Dragon32.MC6821_PIA,10", - -# "--verbosity", " 1", # hardcode DEBUG ;) -# "--verbosity", "10", # DEBUG -# "--verbosity", "20", # INFO -# "--verbosity", "30", # WARNING -# "--verbosity", "40", # ERROR -# "--verbosity", "50", # CRITICAL/FATAL -# "--verbosity", "99", # nearly all off - "--machine", "Dragon32", "run", -# "--machine", "Vectrex", "run", -# "--max_ops", "1", -# "--trace", - ] - print("Startup CLI with: %s" % " ".join(cmd_args[1:])) - subprocess.Popen(cmd_args, cwd="..").wait() - - -if __name__ == "__main__": - print("ERROR: Use .../DragonPy/DragonPy_CLI.py instead of this file!") -# test_run() # Should be only enabled for developing! - diff --git a/dragonpy/Simple6809/mem_info.py b/dragonpy/Simple6809/mem_info.py index a7ed21cc..3d3dfdbe 100644 --- a/dragonpy/Simple6809/mem_info.py +++ b/dragonpy/Simple6809/mem_info.py @@ -14,7 +14,7 @@ import logging -from dragonpy.core.memory_info import BaseMemoryInfo +from MC6809.core.memory_info import BaseMemoryInfo log = logging.getLogger("DragonPy.Simple6809.mem_info") diff --git a/dragonpy/__init__.py b/dragonpy/__init__.py index f9aa3e11..6a9beea8 100644 --- a/dragonpy/__init__.py +++ b/dragonpy/__init__.py @@ -1 +1 @@ -__version__ = "0.3.2" +__version__ = "0.4.0" diff --git a/dragonpy/components/MC6809data/CPU6809_HTML_export.py b/dragonpy/components/MC6809data/CPU6809_HTML_export.py deleted file mode 100755 index ac7c62fd..00000000 --- a/dragonpy/components/MC6809data/CPU6809_HTML_export.py +++ /dev/null @@ -1,165 +0,0 @@ -""" - 6809 instruction set data - ~~~~~~~~~~~~~~~~~~~~~~~~~ - - data from: - * http://www.maddes.net/m6809pm/sections.htm#sec4_4 - * http://www.burgins.com/m6809.html - * http://www.maddes.net/m6809pm/appendix_a.htm#appA - - :copyleft: 2013-2014 by Jens Diemer - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - -from __future__ import absolute_import, division, print_function -from dragonlib.utils import six -xrange = six.moves.xrange - -import os - -from dragonpy.components.MC6809data.MC6809_op_data import OP_DATA, BYTE, WORD -from dragonpy.components.MC6809data.MC6809_op_docs import OP_DOC - - -OUTFILENAME = "CPU6809_opcodes.html" - -WIDTH_DICT = { - None: "no", - BYTE: "byte", - WORD: "word", -} - - -class Cell(object): - def __init__(self, txt): - self.txt = txt - self.rowspan = 0 - self.headline = None - def html(self): - if self.rowspan is None: - return "" - elif self.rowspan == 1: - return "%s" % self.txt - return '%s' % ( - self.rowspan, - self.headline, self.txt, - self.txt, - ) - - def __str__(self): - return "<'%s' rowspan=%s>" % (self.txt, self.rowspan) - __repr__ = __str__ - - -headlines = ( - "instruction", - "mnemonic", - "CC flags", - "example", - "op code", - "bytes", - "cycles", - "address mode", - "needs ea", - "read from memory", - "write to memory", - "register", -) - - -# Collect the data for the table from MC6809_data_raw2 -data = [] -for instruction, instr_data in sorted(OP_DATA.items()): - for mnemonic, memoric_data in sorted(instr_data["mnemonic"].items()): - instruction_doc = OP_DOC[instruction] - mnemonic_doc = instruction_doc["mnemonic"][mnemonic] - - for op_code, op_data in sorted(memoric_data["ops"].items()): - - addr_mode = op_data["addr_mode"] - if addr_mode: - addr_mode = addr_mode.replace("_", " ").lower() - - if op_code > 0xff: - op_code = "$%04x" % op_code - else: - op_code = "$%02x" % op_code - - - data.append([ - instruction, - mnemonic, - mnemonic_doc["HNZVC"] or "", - mnemonic_doc["desc"] or "", - op_code, - op_data["bytes"], - op_data["cycles"], - addr_mode, - - "yes" if memoric_data["needs_ea"] else "no", - WIDTH_DICT[memoric_data["read_from_memory"]], - WIDTH_DICT[memoric_data["write_to_memory"]], - memoric_data["register"] or "-", - - ]) - - -# add rowspan information -for colum_no in xrange(len(data[0])): - old_cell = None - same_count = 0 - for row in reversed(data): - cell = row[colum_no] = Cell(row[colum_no]) - if old_cell is None: - same_count = 1 - elif cell.txt == old_cell.txt: - old_cell.rowspan = None - same_count += 1 - else: - old_cell.rowspan = same_count - same_count = 1 - old_cell = cell - old_cell.rowspan = same_count - - -# add headline to cells (used for td title="") -for row in data: - for cell, headline in zip(row, headlines): - if cell.rowspan is not None: - cell.headline = headline - - -# generate html file -with open(OUTFILENAME, 'w') as htmlfile: - htmlfile.write(""" - - - - - -

6809 opcodes:

- - -""") - for headline in headlines: - htmlfile.write("\t\n" % headline) - htmlfile.write("\n") - - for row in data: - htmlfile.write("\t\n") - for cell in row: - if cell.rowspan is not None: - htmlfile.write("\t\t%s\n" % cell.html()) - htmlfile.write("\t\n") - htmlfile.write("
%s
") - htmlfile.write( - "This file was generated by %s" % os.path.split(__file__)[1] - ) - htmlfile.write("") - - -print("file %r written" % OUTFILENAME) -print(" -- END -- ") diff --git a/dragonpy/components/MC6809data/CPU6809_opcodes.csv b/dragonpy/components/MC6809data/CPU6809_opcodes.csv deleted file mode 100755 index b47bf918..00000000 --- a/dragonpy/components/MC6809data/CPU6809_opcodes.csv +++ /dev/null @@ -1,272 +0,0 @@ -addr_mode bytes category cycles desc instr_info_key instruction mem_access mem_read mem_write mnemonic opcode opcode_hex HNZVC instr_desc -DIRECT 2 0 6 M = !M + 1 NEG NEG byte True True NEG 0 0x0 uaaaa Negate accumulator or memory -DIRECT 2 0 6 M = complement(M) COM COM byte True True COM 3 0x3 -aa01 Complement accumulator or memory location -DIRECT 2 0 6 M = Logical shift M right LSR LSR byte True True LSR 4 0x4 -0a-s Logical shift right accumulator or memory location -DIRECT 2 0 6 M = Rotate M Right thru carry ROR ROR byte True True ROR 6 0x6 -aa-s Rotate accumulator or memory right -DIRECT 2 0 6 M = Arithmetic shift M right ASR ASR byte True True ASR 7 0x7 uaa-s Arithmetic shift of accumulator or memory right -DIRECT 2 0 6 M = Logical shift M left LSL LSL byte True True LSL/ASL 8 0x8 naaas Logical shift left accumulator or memory location -DIRECT 2 0 6 M = Rotate M left thru carry ROL ROL byte True True ROL 9 0x9 -aaas Rotate accumulator or memory left -DIRECT 2 0 6 M = M 1 DEC DEC byte True True DEC 10 0xa -aaa- Decrement accumulator or memory location -DIRECT 2 0 6 M = M + 1 INC INC byte True True INC 12 0xc -aaa- Increment accumulator or memory location -DIRECT 2 0 6 Test M TST TST byte True False TST 13 0xd -aa0- Test accumulator or memory location -DIRECT 2 0 6 M = 0 CLR CLR byte False True CLR 15 0xf -0100 Clear accumulator or memory location -INHERENT 1 0 2 Decimal Adjust A DAA DAA - False False DAA 25 0x19 -aa0a Decimal adjust A accumulator -IMMEDIATE 2 0 8 exchange R1,R2 EXG EXG byte True False EXG 30 0x1e ccccc Exchange Rl with R2 -IMMEDIATE 2 0 7 Transfer R1 to R2 TFR TFR byte True False TFR 31 0x1f ccccc Transfer R1 to R2 -INHERENT 1 0 11 D = A*B (Unsigned) MUL MUL - False False MUL 61 0x3d --a-a Unsigned multiply (A * B ? D) -INHERENT 1 0 2 A = !A + 1 NEG NEG - False False NEGA 64 0x40 uaaaa Negate accumulator or memory -INHERENT 1 0 2 A = complement(A) COM COM - False False COMA 67 0x43 -aa01 Complement accumulator or memory location -INHERENT 1 0 2 A = Logical shift A right LSR LSR - False False LSRA 68 0x44 -0a-s Logical shift right accumulator or memory location -INHERENT 1 0 2 A = Rotate A Right thru carry ROR ROR - False False RORA 70 0x46 -aa-s Rotate accumulator or memory right -INHERENT 1 0 2 A = Arithmetic shift A right ASR ASR - False False ASRA 71 0x47 uaa-s Arithmetic shift of accumulator or memory right -INHERENT 1 0 2 A = Logical shift A left LSL LSL - False False LSLA/ASLA 72 0x48 naaas Logical shift left accumulator or memory location -INHERENT 1 0 2 A = Rotate A left thru carry ROL ROL - False False ROLA 73 0x49 -aaas Rotate accumulator or memory left -INHERENT 1 0 2 A = A 1 DEC DEC - False False DECA 74 0x4a -aaa- Decrement accumulator or memory location -INHERENT 1 0 2 A = A + 1 INC INC - False False INCA 76 0x4c -aaa- Increment accumulator or memory location -INHERENT 1 0 2 Test A TST TST - False False TSTA 77 0x4d -aa0- Test accumulator or memory location -INHERENT 1 0 2 A = 0 CLR CLR - False False CLRA 79 0x4f -0100 Clear accumulator or memory location -INHERENT 1 0 2 B = !B + 1 NEG NEG - False False NEGB 80 0x50 uaaaa Negate accumulator or memory -INHERENT 1 0 2 B = complement(B) COM COM - False False COMB 83 0x53 -aa01 Complement accumulator or memory location -INHERENT 1 0 2 B = Logical shift B right LSR LSR - False False LSRB 84 0x54 -0a-s Logical shift right accumulator or memory location -INHERENT 1 0 2 B = Rotate B Right thru carry ROR ROR - False False RORB 86 0x56 -aa-s Rotate accumulator or memory right -INHERENT 1 0 2 B = Arithmetic shift B right ASR ASR - False False ASRB 87 0x57 uaa-s Arithmetic shift of accumulator or memory right -INHERENT 1 0 2 B = Logical shift B left LSL LSL - False False LSLB/ASLB 88 0x58 naaas Logical shift left accumulator or memory location -INHERENT 1 0 2 B = Rotate B left thru carry ROL ROL - False False ROLB 89 0x59 -aaas Rotate accumulator or memory left -INHERENT 1 0 2 B = B 1 DEC DEC - False False DECB 90 0x5a -aaa- Decrement accumulator or memory location -INHERENT 1 0 2 B = B + 1 INC INC - False False INCB 92 0x5c -aaa- Increment accumulator or memory location -INHERENT 1 0 2 Test B TST TST - False False TSTB 93 0x5d -aa0- Test accumulator or memory location -INHERENT 1 0 2 B = 0 CLR CLR - False False CLRB 95 0x5f -0100 Clear accumulator or memory location -INDEXED 2 0 6 M = !M + 1 NEG NEG byte True True NEG 96 0x60 uaaaa Negate accumulator or memory -INDEXED 2 0 6 M = complement(M) COM COM byte True True COM 99 0x63 -aa01 Complement accumulator or memory location -INDEXED 2 0 6 M = Logical shift M right LSR LSR byte True True LSR 100 0x64 -0a-s Logical shift right accumulator or memory location -INDEXED 2 0 6 M = Rotate M Right thru carry ROR ROR byte True True ROR 102 0x66 -aa-s Rotate accumulator or memory right -INDEXED 2 0 6 M = Arithmetic shift M right ASR ASR byte True True ASR 103 0x67 uaa-s Arithmetic shift of accumulator or memory right -INDEXED 2 0 6 M = Logical shift M left LSL LSL byte True True LSL/ASL 104 0x68 naaas Logical shift left accumulator or memory location -INDEXED 2 0 6 M = Rotate M left thru carry ROL ROL byte True True ROL 105 0x69 -aaas Rotate accumulator or memory left -INDEXED 2 0 6 M = M 1 DEC DEC byte True True DEC 106 0x6a -aaa- Decrement accumulator or memory location -INDEXED 2 0 6 M = M + 1 INC INC byte True True INC 108 0x6c -aaa- Increment accumulator or memory location -INDEXED 2 0 6 Test M TST TST byte True False TST 109 0x6d -aa0- Test accumulator or memory location -INDEXED 2 0 6 M = 0 CLR CLR byte False True CLR 111 0x6f -0100 Clear accumulator or memory location -EXTENDED 3 0 7 M = !M + 1 NEG NEG byte True True NEG 112 0x70 uaaaa Negate accumulator or memory -EXTENDED 3 0 7 M = complement(M) COM COM byte True True COM 115 0x73 -aa01 Complement accumulator or memory location -EXTENDED 3 0 7 M = Logical shift M right LSR LSR byte True True LSR 116 0x74 -0a-s Logical shift right accumulator or memory location -EXTENDED 3 0 7 M = Rotate M Right thru carry ROR ROR byte True True ROR 118 0x76 -aa-s Rotate accumulator or memory right -EXTENDED 3 0 7 M = Arithmetic shift M right ASR ASR byte True True ASR 119 0x77 uaa-s Arithmetic shift of accumulator or memory right -EXTENDED 3 0 7 M = Logical shift M left LSL LSL byte True True LSL/ASL 120 0x78 naaas Logical shift left accumulator or memory location -EXTENDED 3 0 7 M = Rotate M left thru carry ROL ROL byte True True ROL 121 0x79 -aaas Rotate accumulator or memory left -EXTENDED 3 0 7 M = M 1 DEC DEC byte True True DEC 122 0x7a -aaa- Decrement accumulator or memory location -EXTENDED 3 0 7 M = M + 1 INC INC byte True True INC 124 0x7c -aaa- Increment accumulator or memory location -EXTENDED 3 0 7 Test M TST TST byte True False TST 125 0x7d -aa0- Test accumulator or memory location -EXTENDED 3 0 7 M = 0 CLR CLR byte False True CLR 127 0x7f -0100 Clear accumulator or memory location -IMMEDIATE 2 0 2 A = A - M SUB8 SUB byte True False SUBA 128 0x80 uaaaa Subtract memory from accumulator -IMMEDIATE 2 0 2 Compare M from A CMP8 CMP byte True False CMPA 129 0x81 uaaaa Compare memory from accumulator -IMMEDIATE 2 0 2 A = A - M - C SBC SBC byte True False SBCA 130 0x82 uaaaa Subtract memory from accumulator with borrow -IMMEDIATE 2 0 2 A = A && M AND AND byte True False ANDA 132 0x84 -aa0- AND memory with accumulator -IMMEDIATE 2 0 2 Bit Test A (M&&A) BIT BIT byte True False BITA 133 0x85 -aa0- Bit test memory with accumulator -IMMEDIATE 2 0 2 A = M LD8 LD byte True False LDA 134 0x86 -aa0- Load accumulator from memory -IMMEDIATE 2 0 2 A = A XOR M EOR EOR byte True False EORA 136 0x88 -aa0- Exclusive OR memory with accumulator -IMMEDIATE 2 0 2 A = A+M+C ADC ADC byte True False ADCA 137 0x89 aaaaa Add memory to accumulator with carry -IMMEDIATE 2 0 2 |A = A |||| M| OR OR byte True False ORA 138 0x8a -aa0- OR memory with accumulator -IMMEDIATE 2 0 2 A = A+M ADD8 ADD byte True False ADDA 139 0x8b aaaaa Add memory to accumulator -DIRECT 2 0 4 A = A - M SUB8 SUB byte True False SUBA 144 0x90 uaaaa Subtract memory from accumulator -DIRECT 2 0 4 Compare M from A CMP8 CMP byte True False CMPA 145 0x91 uaaaa Compare memory from accumulator -DIRECT 2 0 4 A = A - M - C SBC SBC byte True False SBCA 146 0x92 uaaaa Subtract memory from accumulator with borrow -DIRECT 2 0 4 A = A && M AND AND byte True False ANDA 148 0x94 -aa0- AND memory with accumulator -DIRECT 2 0 4 Bit Test A (M&&A) BIT BIT byte True False BITA 149 0x95 -aa0- Bit test memory with accumulator -DIRECT 2 0 4 A = M LD8 LD byte True False LDA 150 0x96 -aa0- Load accumulator from memory -DIRECT 2 0 4 M = A ST8 ST byte False True STA 151 0x97 -aa0- Store accumulator to memroy -DIRECT 2 0 4 A = A XOR M EOR EOR byte True False EORA 152 0x98 -aa0- Exclusive OR memory with accumulator -DIRECT 2 0 4 A = A+M+C ADC ADC byte True False ADCA 153 0x99 aaaaa Add memory to accumulator with carry -DIRECT 2 0 4 |A = A |||| M| OR OR byte True False ORA 154 0x9a -aa0- OR memory with accumulator -DIRECT 2 0 4 A = A+M ADD8 ADD byte True False ADDA 155 0x9b aaaaa Add memory to accumulator -INDEXED 2 0 4 A = A - M SUB8 SUB byte True False SUBA 160 0xa0 uaaaa Subtract memory from accumulator -INDEXED 2 0 4 Compare M from A CMP8 CMP byte True False CMPA 161 0xa1 uaaaa Compare memory from accumulator -INDEXED 2 0 4 A = A - M - C SBC SBC byte True False SBCA 162 0xa2 uaaaa Subtract memory from accumulator with borrow -INDEXED 2 0 4 A = A && M AND AND byte True False ANDA 164 0xa4 -aa0- AND memory with accumulator -INDEXED 2 0 4 Bit Test A (M&&A) BIT BIT byte True False BITA 165 0xa5 -aa0- Bit test memory with accumulator -INDEXED 2 0 4 A = M LD8 LD byte True False LDA 166 0xa6 -aa0- Load accumulator from memory -INDEXED 2 0 4 M = A ST8 ST byte False True STA 167 0xa7 -aa0- Store accumulator to memroy -INDEXED 2 0 4 A = A XOR M EOR EOR byte True False EORA 168 0xa8 -aa0- Exclusive OR memory with accumulator -INDEXED 2 0 4 A = A+M+C ADC ADC byte True False ADCA 169 0xa9 aaaaa Add memory to accumulator with carry -INDEXED 2 0 4 |A = A |||| M| OR OR byte True False ORA 170 0xaa -aa0- OR memory with accumulator -INDEXED 2 0 4 A = A+M ADD8 ADD byte True False ADDA 171 0xab aaaaa Add memory to accumulator -EXTENDED 3 0 5 A = A - M SUB8 SUB byte True False SUBA 176 0xb0 uaaaa Subtract memory from accumulator -EXTENDED 3 0 5 Compare M from A CMP8 CMP byte True False CMPA 177 0xb1 uaaaa Compare memory from accumulator -EXTENDED 3 0 5 A = A - M - C SBC SBC byte True False SBCA 178 0xb2 uaaaa Subtract memory from accumulator with borrow -EXTENDED 3 0 5 A = A && M AND AND byte True False ANDA 180 0xb4 -aa0- AND memory with accumulator -EXTENDED 3 0 5 Bit Test A (M&&A) BIT BIT byte True False BITA 181 0xb5 -aa0- Bit test memory with accumulator -EXTENDED 3 0 5 A = M LD8 LD byte True False LDA 182 0xb6 -aa0- Load accumulator from memory -EXTENDED 3 0 5 M = A ST8 ST byte False True STA 183 0xb7 -aa0- Store accumulator to memroy -EXTENDED 3 0 5 A = A XOR M EOR EOR byte True False EORA 184 0xb8 -aa0- Exclusive OR memory with accumulator -EXTENDED 3 0 5 A = A+M+C ADC ADC byte True False ADCA 185 0xb9 aaaaa Add memory to accumulator with carry -EXTENDED 3 0 5 |A = A |||| M| OR OR byte True False ORA 186 0xba -aa0- OR memory with accumulator -EXTENDED 3 0 5 A = A+M ADD8 ADD byte True False ADDA 187 0xbb aaaaa Add memory to accumulator -IMMEDIATE 2 0 2 B = B - M SUB8 SUB byte True False SUBB 192 0xc0 uaaaa Subtract memory from accumulator -IMMEDIATE 2 0 2 Compare M from B CMP8 CMP byte True False CMPB 193 0xc1 uaaaa Compare memory from accumulator -IMMEDIATE 2 0 2 B = B - M - C SBC SBC byte True False SBCB 194 0xc2 uaaaa Subtract memory from accumulator with borrow -IMMEDIATE 2 0 2 B = B && M AND AND byte True False ANDB 196 0xc4 -aa0- AND memory with accumulator -IMMEDIATE 2 0 2 Bit Test B (M&&B) BIT BIT byte True False BITB 197 0xc5 -aa0- Bit test memory with accumulator -IMMEDIATE 2 0 2 B = M LD8 LD byte True False LDB 198 0xc6 -aa0- Load accumulator from memory -IMMEDIATE 2 0 2 B = M XOR B EOR EOR byte True False EORB 200 0xc8 -aa0- Exclusive OR memory with accumulator -IMMEDIATE 2 0 2 B = B+M+C ADC ADC byte True False ADCB 201 0xc9 aaaaa Add memory to accumulator with carry -IMMEDIATE 2 0 2 |B = B |||| M| OR OR byte True False ORB 202 0xca -aa0- OR memory with accumulator -IMMEDIATE 2 0 2 B = B+M ADD8 ADD byte True False ADDB 203 0xcb aaaaa Add memory to accumulator -DIRECT 2 0 4 B = B - M SUB8 SUB byte True False SUBB 208 0xd0 uaaaa Subtract memory from accumulator -DIRECT 2 0 4 Compare M from B CMP8 CMP byte True False CMPB 209 0xd1 uaaaa Compare memory from accumulator -DIRECT 2 0 4 B = B - M - C SBC SBC byte True False SBCB 210 0xd2 uaaaa Subtract memory from accumulator with borrow -DIRECT 2 0 4 B = B && M AND AND byte True False ANDB 212 0xd4 -aa0- AND memory with accumulator -DIRECT 2 0 4 Bit Test B (M&&B) BIT BIT byte True False BITB 213 0xd5 -aa0- Bit test memory with accumulator -DIRECT 2 0 4 B = M LD8 LD byte True False LDB 214 0xd6 -aa0- Load accumulator from memory -DIRECT 2 0 4 M = B ST8 ST byte False True STB 215 0xd7 -aa0- Store accumulator to memroy -DIRECT 2 0 4 B = M XOR B EOR EOR byte True False EORB 216 0xd8 -aa0- Exclusive OR memory with accumulator -DIRECT 2 0 4 B = B+M+C ADC ADC byte True False ADCB 217 0xd9 aaaaa Add memory to accumulator with carry -DIRECT 2 0 4 |B = B |||| M| OR OR byte True False ORB 218 0xda -aa0- OR memory with accumulator -DIRECT 2 0 4 B = B+M ADD8 ADD byte True False ADDB 219 0xdb aaaaa Add memory to accumulator -INDEXED 2 0 4 B = B - M SUB8 SUB byte True False SUBB 224 0xe0 uaaaa Subtract memory from accumulator -INDEXED 2 0 4 Compare M from B CMP8 CMP byte True False CMPB 225 0xe1 uaaaa Compare memory from accumulator -INDEXED 2 0 4 B = B - M - C SBC SBC byte True False SBCB 226 0xe2 uaaaa Subtract memory from accumulator with borrow -INDEXED 2 0 4 B = B && M AND AND byte True False ANDB 228 0xe4 -aa0- AND memory with accumulator -INDEXED 2 0 4 Bit Test B (M&&B) BIT BIT byte True False BITB 229 0xe5 -aa0- Bit test memory with accumulator -INDEXED 2 0 4 B = M LD8 LD byte True False LDB 230 0xe6 -aa0- Load accumulator from memory -INDEXED 2 0 4 M = B ST8 ST byte False True STB 231 0xe7 -aa0- Store accumulator to memroy -INDEXED 2 0 4 B = M XOR B EOR EOR byte True False EORB 232 0xe8 -aa0- Exclusive OR memory with accumulator -INDEXED 2 0 4 B = B+M+C ADC ADC byte True False ADCB 233 0xe9 aaaaa Add memory to accumulator with carry -INDEXED 2 0 4 |B = B |||| M| OR OR byte True False ORB 234 0xea -aa0- OR memory with accumulator -INDEXED 2 0 4 B = B+M ADD8 ADD byte True False ADDB 235 0xeb aaaaa Add memory to accumulator -EXTENDED 3 0 5 B = B - M SUB8 SUB byte True False SUBB 240 0xf0 uaaaa Subtract memory from accumulator -EXTENDED 3 0 5 Compare M from B CMP8 CMP byte True False CMPB 241 0xf1 uaaaa Compare memory from accumulator -EXTENDED 3 0 5 B = B - M - C SBC SBC byte True False SBCB 242 0xf2 uaaaa Subtract memory from accumulator with borrow -EXTENDED 3 0 5 B = B && M AND AND byte True False ANDB 244 0xf4 -aa0- AND memory with accumulator -EXTENDED 3 0 5 Bit Test B (M&&B) BIT BIT byte True False BITB 245 0xf5 -aa0- Bit test memory with accumulator -EXTENDED 3 0 5 B = M LD8 LD byte True False LDB 246 0xf6 -aa0- Load accumulator from memory -EXTENDED 3 0 5 M = B ST8 ST byte False True STB 247 0xf7 -aa0- Store accumulator to memroy -EXTENDED 3 0 5 B = M XOR B EOR EOR byte True False EORB 248 0xf8 -aa0- Exclusive OR memory with accumulator -EXTENDED 3 0 5 B = B+M+C ADC ADC byte True False ADCB 249 0xf9 aaaaa Add memory to accumulator with carry -EXTENDED 3 0 5 |B = B |||| M| OR OR byte True False ORB 250 0xfa -aa0- OR memory with accumulator -EXTENDED 3 0 5 B = B+M ADD8 ADD byte True False ADDB 251 0xfb aaaaa Add memory to accumulator -INHERENT 1 1 2 Sign extend B into A SEX SEX - False False SEX 29 0x1d -aa0- Sign Extend B accumulator into A accumulator -IMMEDIATE 3 1 4 D = D - M:M+1 SUB16 SUB word True False SUBD 131 0x83 -aaaa Subtract memory from D accumulator -DIRECT 2 1 6 D = D - M:M+1 SUB16 SUB word True False SUBD 147 0x93 -aaaa Subtract memory from D accumulator -INDEXED 2 1 6 D = D - M:M+1 SUB16 SUB word True False SUBD 163 0xa3 -aaaa Subtract memory from D accumulator -EXTENDED 3 1 7 D = D - M:M+1 SUB16 SUB word True False SUBD 179 0xb3 -aaaa Subtract memory from D accumulator -IMMEDIATE 3 1 4 D = D+M:M+1 ADD16 ADD word True False ADDD 195 0xc3 -aaaa Add memory to D accumulator -IMMEDIATE 3 1 3 D = M:M+1 LD16 LD word True False LDD 204 0xcc -aa0- Load stack pointer from memory -DIRECT 2 1 6 D = D+M:M+1 ADD16 ADD word True False ADDD 211 0xd3 -aaaa Add memory to D accumulator -DIRECT 2 1 5 D = M:M+1 LD16 LD word True False LDD 220 0xdc -aa0- Load stack pointer from memory -DIRECT 2 1 5 M:M+1 = D ST16 ST word False True STD 221 0xdd -aa0- Store stack pointer to memory -INDEXED 2 1 6 D = D+M:M+1 ADD16 ADD word True False ADDD 227 0xe3 -aaaa Add memory to D accumulator -INDEXED 2 1 5 D = M:M+1 LD16 LD word True False LDD 236 0xec -aa0- Load stack pointer from memory -INDEXED 2 1 5 M:M+1 = D ST16 ST word False True STD 237 0xed -aa0- Store stack pointer to memory -EXTENDED 3 1 7 D = D+M:M+1 ADD16 ADD word True False ADDD 243 0xf3 -aaaa Add memory to D accumulator -EXTENDED 3 1 6 D = M:M+1 LD16 LD word True False LDD 252 0xfc -aa0- Load stack pointer from memory -EXTENDED 3 1 6 M:M+1 = D ST16 ST word False True STD 253 0xfd -aa0- Store stack pointer to memory -IMMEDIATE 4 1 5 Compare M:M+1 from D CMP16 CMP word True False CMPD 4227 0x1083 -aaaa Compare memory from stack pointer -DIRECT 3 1 7 Compare M:M+1 from D CMP16 CMP word True False CMPD 4243 0x1093 -aaaa Compare memory from stack pointer -INDEXED 3 1 7 Compare M:M+1 from D CMP16 CMP word True False CMPD 4259 0x10a3 -aaaa Compare memory from stack pointer -EXTENDED 4 1 8 Compare M:M+1 from D CMP16 CMP word True False CMPD 4275 0x10b3 -aaaa Compare memory from stack pointer -INDEXED 2 2 4 X = EA LEA_register LEA - False False LEAX 48 0x30 ----- Load effective address into stack pointer -INDEXED 2 2 4 Y = EA LEA_register LEA - False False LEAY 49 0x31 ----- Load effective address into stack pointer -INDEXED 2 2 4 S = EA LEA_pointer LEA - False False LEAS 50 0x32 ----- Load effective address into stack pointer -INDEXED 2 2 4 U = EA LEA_pointer LEA - False False LEAU 51 0x33 ----- Load effective address into stack pointer -IMMEDIATE 2 2 5 S -= 1: MEM(S) = R; Push Register on S Stack PSHS PSH byte True False PSHS 52 0x34 ----- Push A, B, CC, DP, D, X, Y, U, or PC onto hardware stack -IMMEDIATE 2 2 5 R=MEM(S) : S += 1; Pull register from S Stack PULS PUL byte True False PULS 53 0x35 ccccc Pull A, B, CC, DP, D, X, Y, U, or PC from hardware stack -IMMEDIATE 2 2 5 U -= 1: MEM(U) = R; Push Register on U Stack PSHU PSH byte True False PSHU 54 0x36 ----- Push A, B, CC, DP, D, X, Y, S, or PC onto user stack -IMMEDIATE 2 2 5 R=MEM(U) : U += 1; Pull register from U Stack PULU PUL byte True False PULU 55 0x37 ccccc Pull A, B, CC, DP, D, X, Y, S, or PC from hardware stack -INHERENT 1 2 3 X = B+X (Unsigned) ABX ABX - False False ABX 58 0x3a ----- Add B accumulator to X (unsigned) -IMMEDIATE 3 2 4 Compare M:M+1 from X CMP16 CMP word True False CMPX 140 0x8c -aaaa Compare memory from stack pointer -IMMEDIATE 3 2 3 X = M:M+1 LD16 LD word True False LDX 142 0x8e -aa0- Load stack pointer from memory -DIRECT 2 2 6 Compare M:M+1 from X CMP16 CMP word True False CMPX 156 0x9c -aaaa Compare memory from stack pointer -DIRECT 2 2 5 X = M:M+1 LD16 LD word True False LDX 158 0x9e -aa0- Load stack pointer from memory -DIRECT 2 2 5 M:M+1 = X ST16 ST word False True STX 159 0x9f -aa0- Store stack pointer to memory -INDEXED 2 2 6 Compare M:M+1 from X CMP16 CMP word True False CMPX 172 0xac -aaaa Compare memory from stack pointer -INDEXED 2 2 5 X = M:M+1 LD16 LD word True False LDX 174 0xae -aa0- Load stack pointer from memory -INDEXED 2 2 5 M:M+1 = X ST16 ST word False True STX 175 0xaf -aa0- Store stack pointer to memory -EXTENDED 3 2 7 Compare M:M+1 from X CMP16 CMP word True False CMPX 188 0xbc -aaaa Compare memory from stack pointer -EXTENDED 3 2 6 X = M:M+1 LD16 LD word True False LDX 190 0xbe -aa0- Load stack pointer from memory -EXTENDED 3 2 6 M:M+1 = X ST16 ST word False True STX 191 0xbf -aa0- Store stack pointer to memory -IMMEDIATE 3 2 3 U = M:M+1 LD16 LD word True False LDU 206 0xce -aa0- Load stack pointer from memory -DIRECT 2 2 5 U = M:M+1 LD16 LD word True False LDU 222 0xde -aa0- Load stack pointer from memory -DIRECT 2 2 5 M:M+1 = U ST16 ST word False True STU 223 0xdf -aa0- Store stack pointer to memory -INDEXED 2 2 5 U = M:M+1 LD16 LD word True False LDU 238 0xee -aa0- Load stack pointer from memory -INDEXED 2 2 5 M:M+1 = U ST16 ST word False True STU 239 0xef -aa0- Store stack pointer to memory -EXTENDED 3 2 6 U = M:M+1 LD16 LD word True False LDU 254 0xfe -aa0- Load stack pointer from memory -EXTENDED 3 2 6 M:M+1 = U ST16 ST word False True STU 255 0xff -aa0- Store stack pointer to memory -IMMEDIATE 4 2 5 Compare M:M+1 from Y CMP16 CMP word True False CMPY 4236 0x108c -aaaa Compare memory from stack pointer -IMMEDIATE 4 2 4 Y = M:M+1 LD16 LD word True False LDY 4238 0x108e -aa0- Load stack pointer from memory -DIRECT 3 2 7 Compare M:M+1 from Y CMP16 CMP word True False CMPY 4252 0x109c -aaaa Compare memory from stack pointer -DIRECT 3 2 6 Y = M:M+1 LD16 LD word True False LDY 4254 0x109e -aa0- Load stack pointer from memory -DIRECT 3 2 6 M:M+1 = Y ST16 ST word False True STY 4255 0x109f -aa0- Store stack pointer to memory -INDEXED 3 2 7 Compare M:M+1 from Y CMP16 CMP word True False CMPY 4268 0x10ac -aaaa Compare memory from stack pointer -INDEXED 3 2 6 Y = M:M+1 LD16 LD word True False LDY 4270 0x10ae -aa0- Load stack pointer from memory -INDEXED 3 2 6 M:M+1 = Y ST16 ST word False True STY 4271 0x10af -aa0- Store stack pointer to memory -EXTENDED 4 2 8 Compare M:M+1 from Y CMP16 CMP word True False CMPY 4284 0x10bc -aaaa Compare memory from stack pointer -EXTENDED 4 2 7 Y = M:M+1 LD16 LD word True False LDY 4286 0x10be -aa0- Load stack pointer from memory -EXTENDED 4 2 7 M:M+1 = Y ST16 ST word False True STY 4287 0x10bf -aa0- Store stack pointer to memory -IMMEDIATE 4 2 4 S = M:M+1 LD16 LD word True False LDS 4302 0x10ce -aa0- Load stack pointer from memory -DIRECT 3 2 6 S = M:M+1 LD16 LD word True False LDS 4318 0x10de -aa0- Load stack pointer from memory -DIRECT 3 2 6 M:M+1 = S ST16 ST word False True STS 4319 0x10df -aa0- Store stack pointer to memory -INDEXED 3 2 6 S = M:M+1 LD16 LD word True False LDS 4334 0x10ee -aa0- Load stack pointer from memory -INDEXED 3 2 6 M:M+1 = S ST16 ST word False True STS 4335 0x10ef -aa0- Store stack pointer to memory -EXTENDED 4 2 7 S = M:M+1 LD16 LD word True False LDS 4350 0x10fe -aa0- Load stack pointer from memory -EXTENDED 4 2 7 M:M+1 = S ST16 ST word False True STS 4351 0x10ff -aa0- Store stack pointer to memory -IMMEDIATE 4 2 5 Compare M:M+1 from U CMP16 CMP word True False CMPU 4483 0x1183 -aaaa Compare memory from stack pointer -IMMEDIATE 4 2 5 Compare M:M+1 from S CMP16 CMP word True False CMPS 4492 0x118c -aaaa Compare memory from stack pointer -DIRECT 3 2 7 Compare M:M+1 from U CMP16 CMP word True False CMPU 4499 0x1193 -aaaa Compare memory from stack pointer -DIRECT 3 2 7 Compare M:M+1 from S CMP16 CMP word True False CMPS 4508 0x119c -aaaa Compare memory from stack pointer -INDEXED 3 2 7 Compare M:M+1 from U CMP16 CMP word True False CMPU 4515 0x11a3 -aaaa Compare memory from stack pointer -INDEXED 3 2 7 Compare M:M+1 from S CMP16 CMP word True False CMPS 4524 0x11ac -aaaa Compare memory from stack pointer -EXTENDED 4 2 8 Compare M:M+1 from U CMP16 CMP word True False CMPU 4531 0x11b3 -aaaa Compare memory from stack pointer -EXTENDED 4 2 8 Compare M:M+1 from S CMP16 CMP word True False CMPS 4540 0x11bc -aaaa Compare memory from stack pointer -RELATIVE 2 3 3 Branch if plus BPL BPL byte False False BPL 42 0x2a ----- Branch if plus -RELATIVE 2 3 3 Branch if minus BMI BMI byte False False BMI 43 0x2b ----- Branch if minus -RELATIVE 4 3 5 Branch if plus BPL LBPL byte False False LBPL 4138 0x102a ----- Branch if plus -RELATIVE 4 3 5 Branch if minus BMI LBMI byte False False LBMI 4139 0x102b ----- Branch if minus -RELATIVE 2 4 3 Branch if valid twos complement result BVC BVC byte False False BVC 40 0x28 ----- Branch if valid twos complement result -RELATIVE 2 4 3 Branch if invalid twos complement result BVS BVS byte False False BVS 41 0x29 ----- Branch if invalid twos complement result -RELATIVE 2 4 3 Branch if greater than or equal (signed) BGE BGE byte False False BGE 44 0x2c ----- Branch if greater than or equal (signed) -RELATIVE 2 4 3 Branch if less than (signed) BLT BLT byte False False BLT 45 0x2d ----- Branch if less than (signed) -RELATIVE 2 4 3 Branch if greater (signed) BGT BGT byte False False BGT 46 0x2e ----- Branch if greater (signed) -RELATIVE 2 4 3 Branch if less than or equal (signed) BLE BLE byte False False BLE 47 0x2f ----- Branch if less than or equal (signed) -RELATIVE 4 4 5 Branch if valid twos complement result BVC LBVC byte False False LBVC 4136 0x1028 ----- Branch if valid twos complement result -RELATIVE 4 4 5 Branch if invalid twos complement result BVS LBVS byte False False LBVS 4137 0x1029 ----- Branch if invalid twos complement result -RELATIVE 4 4 5 Branch if greater than or equal (signed) BGE LBGE byte False False LBGE 4140 0x102c ----- Branch if greater than or equal (signed) -RELATIVE 4 4 5 Branch if less than (signed) BLT LBLT byte False False LBLT 4141 0x102d ----- Branch if less than (signed) -RELATIVE 4 4 5 Branch if greater (signed) BGT LBGT byte False False LBGT 4142 0x102e ----- Branch if greater (signed) -RELATIVE 4 4 5 Branch if less than or equal (signed) BLE LBLE byte False False LBLE 4143 0x102f ----- Branch if less than or equal (signed) -RELATIVE 2 5 3 Branch if higher (unsigned) BHI BHI byte False False BHI 34 0x22 ----- Branch if higher (unsigned) -RELATIVE 2 5 3 Branch if lower or same (unsigned) BLS BLS byte False False BLS 35 0x23 ----- Branch if lower or same (unsigned) -RELATIVE 2 5 3 Branch if higher or same (unsigned) OTHER_INSTRUCTIONS BHS/BCC - False False BHS/BCC 36 0x24 ----- Branch if lower (unsigned) -RELATIVE 2 5 3 Branch if lower (unsigned) OTHER_INSTRUCTIONS BLO/BCS - False False BLO/BCS 37 0x25 ----- Branch if lower (unsigned) -RELATIVE 2 5 3 Branch if not equal BNE BNE byte False False BNE 38 0x26 ----- Branch if not equal -RELATIVE 2 5 3 Branch if equal BEQ BEQ byte False False BEQ 39 0x27 ----- Branch if equal -RELATIVE 4 5 5 Branch if higher (unsigned) BHI LBHI byte False False LBHI 4130 0x1022 ----- Branch if higher (unsigned) -RELATIVE 4 5 5 Branch if lower or same (unsigned) BLS LBLS byte False False LBLS 4131 0x1023 ----- Branch if lower or same (unsigned) -RELATIVE 4 5 5 Branch if higher or same (unsigned) OTHER_INSTRUCTIONS LBHS/LBCC - False False LBHS/LBCC 4132 0x1024 ----- Branch if lower (unsigned) -RELATIVE 4 5 5 Branch if lower (unsigned) OTHER_INSTRUCTIONS LBLO/LBCS - False False LBLO/LBCS 4133 0x1025 ----- Branch if lower (unsigned) -RELATIVE 4 5 5 Branch if not equal BNE LBNE byte False False LBNE 4134 0x1026 ----- Branch if not equal -RELATIVE 4 5 5 Branch if equal BEQ LBEQ byte False False LBEQ 4135 0x1027 ----- Branch if equal -RELATIVE 3 6 5 Branch always BRA LBRA byte False False LBRA 22 0x16 ----- Branch always -RELATIVE 3 6 9 Branch to subroutine BSR LBSR byte False False LBSR 23 0x17 ----- Branch to subroutine -RELATIVE 2 6 3 Branch always BRA BRA byte False False BRA 32 0x20 ----- Branch always -RELATIVE 2 6 3 Branch never BRN BRN byte False False BRN 33 0x21 ----- Branch never -RELATIVE 2 6 7 Branch to subroutine BSR BSR byte False False BSR 141 0x8d ----- Branch to subroutine -RELATIVE 4 6 5 Branch never BRN LBRN byte False False LBRN 4129 0x1021 ----- Branch never -DIRECT 2 7 3 pc = EA JMP JMP - False False JMP 14 0xe ----- Jump -INHERENT 1 7 2 No Operation NOP NOP - False False NOP 18 0x12 ----- No operation -INHERENT 1 7 2 Synchronize to Interrupt SYNC SYNC - False False SYNC 19 0x13 ----- Synchronize with interrupt line -IMMEDIATE 2 7 3 |C = CC |||| IMM| ORCC OR byte True False ORCC 26 0x1a ddddd OR condition code register -IMMEDIATE 2 7 3 C = CC && IMM ANDCC AND byte True False ANDCC 28 0x1c ddddd AND condition code register -INHERENT 1 7 5 Return from subroutine RTS RTS - False False RTS 57 0x39 ----- Return from subroutine -INHERENT 1 7 6 Return from Interrupt RTI RTI - False False RTI 59 0x3b ----- Return from interrupt -IMMEDIATE 2 7 21 CC = CC ^ IMM; (Wait for Interrupt) CWAI CWAI byte True False CWAI 60 0x3c ddddd AND condition code register, then wait for interrupt -INHERENT 1 7 19 Software interrupt 1 SWI SWI - False False SWI 63 0x3f ----- Software interrupt (absolute indirect) -INDEXED 2 7 3 pc = EA JMP JMP - False False JMP 110 0x6e ----- Jump -EXTENDED 3 7 3 pc = EA JMP JMP - False False JMP 126 0x7e ----- Jump -DIRECT 2 7 7 jump to subroutine JSR JSR - False False JSR 157 0x9d ----- Jump to subroutine -INDEXED 2 7 7 jump to subroutine JSR JSR - False False JSR 173 0xad ----- Jump to subroutine -EXTENDED 3 7 8 jump to subroutine JSR JSR - False False JSR 189 0xbd ----- Jump to subroutine -INHERENT 2 7 20 Software interrupt 2 SWI2 SWI - False False SWI2 4159 0x103f ----- Software interrupt (absolute indirect) -INHERENT 2 7 20 Software interrupt 3 SWI3 SWI - False False SWI3 4415 0x113f ----- Software interrupt (absolute indirect) -VARIANT 1 8 1 Page 1 Instructions prefix PAGE PAGE - False False PAGE1+ 16 0x10 +++++ Page 2 Instructions prefix -VARIANT 1 8 1 Page 2 Instructions prefix PAGE PAGE - False False PAGE2+ 17 0x11 +++++ Page 2 Instructions prefix -INHERENT 1 8 -1 RESET RESET - False False RESET 62 0x3e ***** diff --git a/dragonpy/components/MC6809data/CPU6809_opcodes.html b/dragonpy/components/MC6809data/CPU6809_opcodes.html deleted file mode 100644 index 264bc09a..00000000 --- a/dragonpy/components/MC6809data/CPU6809_opcodes.html +++ /dev/null @@ -1,1961 +0,0 @@ - - - - - - -

6809 opcodes:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
instructionmnemonicCC flagsexampleop codebytescyclesaddress modeneeds earead from memorywrite to memoryregister
ABXABX-----X = B+X (Unsigned)$3a13inherentnonono-
ADCADCAaaaaaA = A+M+C$8922immediatebyteA
$994direct
$a9indexed
$b935extended
ADCBB = B+M+C$c922immediateB
$d94direct
$e9indexed
$f935extended
ADDADDAA = A+M$8b22immediateA
$9b4direct
$abindexed
$bb35extended
ADDBB = B+M$cb22immediateB
$db4direct
$ebindexed
$fb35extended
ADDD-aaaaD = D+M:M+1$c34immediate wordwordD
$d326direct word
$e3indexed word
$f337extended word
ANDANDA-aa0-A = A && M$8422immediatebyteA
$944direct
$a4indexed
$b435extended
ANDBB = B && M$c422immediateB
$d44direct
$e4indexed
$f435extended
ANDCCdddddC = CC && IMM$1c23immediateCC
ASRASRuaa-sM = Arithmetic shift M right$076directyesbyte-
$67indexed
$7737extended
ASRAA = Arithmetic shift A right$4712inherentnononoA
ASRBB = Arithmetic shift B right$57B
BEQBEQ-----$2723relativeyes-
LBEQ$102745relative word
BGEBGE$2c23relative
LBGE$102c45relative word
BGTBGT$2e23relative
LBGT$102e45relative word
BHIBHI$2223relative
LBHI$102245relative word
BHSBCC$2423relative
LBCC$102445relative word
BITBITA-aa0-Bit Test A (M&&A)$8522immediatenobyteA
$954direct
$a5indexed
$b535extended
BITBBit Test B (M&&B)$c522immediateB
$d54direct
$e5indexed
$f535extended
BLEBLE-----$2f23relativeyesno-
LBLE$102f45relative word
BLOBLO$2523relative
LBCS$102545relative word
BLSBLS$2323relative
LBLS$102345relative word
BLTBLT$2d23relative
LBLT$102d45relative word
BMIBMI$2b23relative
LBMI$102b45relative word
BNEBNE$2623relative
LBNE$102645relative word
BPLBPL$2a23relative
LBPL$102a45relative word
BRABRA$2023relative
LBRA$1635relative word
BRNBRN$2123relative
LBRN$102145relative word
BSRBSR$8d27relative
LBSR$1739relative word
BVCBVC$2823relative
LBVC$102845relative word
BVSBVS$2923relative
LBVS$102945relative word
CLRCLR-0100M = 0$0f26directbyte
$6findexed
$7f37extended
CLRAA = 0$4f12inherentnonoA
CLRBB = 0$5fB
CMPCMPAuaaaaCompare M from A$812immediatebyteA
$914direct
$a1indexed
$b135extended
CMPBCompare M from B$c122immediateB
$d14direct
$e1indexed
$f135extended
CMPD-aaaaCompare M:M+1 from D$10834immediate wordwordD
$109337direct word
$10a3indexed word
$10b348extended word
CMPSCompare M:M+1 from S$118c5immediate wordS
$119c37direct word
$11acindexed word
$11bc48extended word
CMPUCompare M:M+1 from U$11835immediate wordU
$119337direct word
$11a3indexed word
$11b348extended word
CMPXCompare M:M+1 from X$8c34immediate wordX
$9c26direct word
$acindexed word
$bc37extended word
CMPYCompare M:M+1 from Y$108c45immediate wordY
$109c37direct word
$10acindexed word
$10bc48extended word
COMCOM-aa01M = complement(M)$0326directyesbytebyte-
$63indexed
$7337extended
COMAA = complement(A)$4312inherentnononoA
COMBB = complement(B)$53B
CWAICWAIdddddCC = CC ^ IMM; (Wait for Interrupt)$3c221immediatebyte-
DAADAA-aa0aDecimal Adjust A$1912inherentno
DECDEC-aaa-M = M - 1$0a26directyesbytebyte
$6aindexed
$7a37extended
DECAA = A - 1$4a12inherentnononoA
DECBB = B - 1$5aB
EOREORA-aa0-A = A XOR M$882immediatebyteA
$984direct
$a8indexed
$b835extended
EORBB = M XOR B$c822immediateB
$d84direct
$e8indexed
$f835extended
EXGEXGcccccexchange R1,R2$1e28immediate-
INCINC-aaa-M = M + 1$0c6directyesbyte
$6cindexed
$7c37extended
INCAA = A + 1$4c12inherentnononoA
INCBB = B + 1$5cB
JMPJMP-----pc = EA$0e23directyes-
$6eindexed
$7e3extended
JSRJSRjump to subroutine$9d27direct
$adindexed
$bd38extended
LDLDA-aa0-A = M$8622immediatenobyteA
$964direct
$a6indexed
$b635extended
LDBB = M$c622immediateB
$d64direct
$e6indexed
$f635extended
LDDD = M:M+1$cc3immediate wordwordD
$dc25direct word
$ecindexed word
$fc36extended word
LDSS = M:M+1$10ce44immediate wordS
$10de36direct word
$10eeindexed word
$10fe47extended word
LDUU = M:M+1$ce33immediate wordU
$de25direct word
$eeindexed word
$fe36extended word
LDXX = M:M+1$8e3immediate wordX
$9e25direct word
$aeindexed word
$be36extended word
LDYY = M:M+1$108e44immediate wordY
$109e36direct word
$10aeindexed word
$10be47extended word
LEALEAS-----S = EA$3224indexedyesnoS
LEAUU = EA$33U
LEAX--a--X = EA$30X
LEAYY = EA$31Y
LSLLSLnaaasM = Logical shift M left$086directbytebyte-
$68indexed
$7837extended
LSLAA = Logical shift A left$4812inherentnononoA
LSLBB = Logical shift B left$58B
LSRLSR-0a-sM = Logical shift M right$0426directyesbytebyte-
$64indexed
$7437extended
LSRAA = Logical shift A right$4412inherentnononoA
LSRBB = Logical shift B right$54B
MULMUL--a-aD = A*B (Unsigned)$3d11-
NEGNEGuaaaaM = !M + 1$0026directyesbytebyte
$60indexed
$7037extended
NEGAA = !A + 1$4012inherentnononoA
NEGBB = !B + 1$50B
NOPNOP-----No Operation$12-
ORORA-aa0-A = A || M$8a2immediatebyteA
$9a4direct
$aaindexed
$ba35extended
ORBB = B || M$ca22immediateB
$da4direct
$eaindexed
$fa35extended
ORCCdddddC = CC || IMM$1a23immediateCC
PAGEPAGE 1+++++Page 1 Instructions prefix$1011Noneno-
PAGE 2Page 2 Instructions prefix$11
PSHPSHS-----S -= 1: MEM(S) = R; Push Register on S Stack$3425immediatebyteS
PSHUU -= 1: MEM(U) = R; Push Register on U Stack$36U
PULPULScccccR=MEM(S) : S += 1; Pull register from S Stack$35S
PULUR=MEM(U) : U += 1; Pull register from U Stack$37U
RESETRESET*****Undocumented opcode$3e1-1Noneno-
ROLROL-aaasM = Rotate M left thru carry$0926directyesbytebyte
$69indexed
$7937extended
ROLAA = Rotate A left thru carry$4912inherentnononoA
ROLBB = Rotate B left thru carry$59B
RORROR-aa-sM = Rotate M Right thru carry$0626directyesbytebyte-
$66indexed
$7637extended
RORAA = Rotate A Right thru carry$4612inherentnononoA
RORBB = Rotate B Right thru carry$56B
RTIRTI-----Return from Interrupt$3b6-
RTSRTSReturn from subroutine$395
SBCSBCAuaaaaA = A - M - C$8222immediatebyteA
$924direct
$a2indexed
$b235extended
SBCBB = B - M - C$c222immediateB
$d24direct
$e2indexed
$f235extended
SEXSEX-aa0-Sign extend B into A$1d12inherentno-
STSTAM = A$9724directyesbyteA
$a7indexed
$b735extended
STBM = B$d724directB
$e7indexed
$f735extended
STDM:M+1 = D$dd2directwordD
$edindexed
$fd36extended
STSM:M+1 = S$10dfdirectS
$10efindexed
$10ff47extended
STUM:M+1 = U$df25directU
$efindexed
$ff36extended
STXM:M+1 = X$9f25directX
$afindexed
$bf36extended
STYM:M+1 = Y$109fdirectY
$10afindexed
$10bf47extended
SUBSUBAuaaaaA = A - M$8022immediatenobytenoA
$904direct
$a0indexed
$b035extended
SUBBB = B - M$c022immediateB
$d04direct
$e0indexed
$f035extended
SUBD-aaaaD = D - M:M+1$834immediate wordwordD
$9326direct word
$a3indexed word
$b337extended word
SWISWI-----Software interrupt 1$3f119inherentno-
SWI2Software interrupt 2$103f220
SWI3Software interrupt 3$113f
SYNCSYNCSynchronize to Interrupt$1312
TFRTFRccccc$1f27immediatebyte
TSTTST-aa0-Test M$0d6direct
$6dindexed
$7d37extended
TSTATest A$4d12inherentnoA
TSTBTest B$5dB
This file was generated by CPU6809_HTML_export.py \ No newline at end of file diff --git a/dragonpy/components/MC6809data/CPU6809csv_export.py b/dragonpy/components/MC6809data/CPU6809csv_export.py deleted file mode 100755 index a00349a1..00000000 --- a/dragonpy/components/MC6809data/CPU6809csv_export.py +++ /dev/null @@ -1,70 +0,0 @@ -""" - 6809 instruction set data - ~~~~~~~~~~~~~~~~~~~~~~~~~ - - data from: - * http://www.maddes.net/m6809pm/sections.htm#sec4_4 - * http://www.burgins.com/m6809.html - * http://www.maddes.net/m6809pm/appendix_a.htm#appA - - :copyleft: 2013 by Jens Diemer - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - -from __future__ import absolute_import, division, print_function - - -import pprint -import sys - -from .MC6809_data_raw import INSTRUCTION_INFO, OP_DATA -from MC6809data.MC6809_data_raw import MEM_ACCESS_BYTE, MEM_ACCESS_WORD - - -keys = list(OP_DATA[0].keys()) -keys.insert(3, "opcode_hex") -keys.sort() - -FROM_INSTRUCTION_INFO = ['HNZVC', 'instr_desc'] - - -MEM_ACCESS_MAP = { - MEM_ACCESS_BYTE: "byte", - MEM_ACCESS_WORD: "word", -} - - -import csv -with open('CPU6809_opcodes.csv', 'wb') as csvfile: - w = csv.writer(csvfile, - delimiter='\t', - quotechar='|', quoting=csv.QUOTE_MINIMAL - ) - - w.writerow(keys + FROM_INSTRUCTION_INFO) - - for op_data in OP_DATA: - row = [] - - op_data["opcode_hex"] = hex(op_data["opcode"]) - - for key in keys: - data = op_data.get(key, "-") - if key == "mem_access" and data != "-": - data = MEM_ACCESS_MAP[data] - - if isinstance(data, str): - data = data.replace("\t", " ") - row.append(data) - - instr_info_key = op_data["instr_info_key"] - instr_info = INSTRUCTION_INFO[instr_info_key] - for key in FROM_INSTRUCTION_INFO: - row.append( - instr_info.get(key, "").replace("\n", " ").replace("\t", " ") - ) - - print(row) - w.writerow(row) - -print(" -- END -- ") diff --git a/dragonpy/components/MC6809data/MC6809_data_utils.py b/dragonpy/components/MC6809data/MC6809_data_utils.py deleted file mode 100644 index 428857f8..00000000 --- a/dragonpy/components/MC6809data/MC6809_data_utils.py +++ /dev/null @@ -1,38 +0,0 @@ -#!/usr/bin/env python - -""" - 6809 instruction set data - ~~~~~~~~~~~~~~~~~~~~~~~~~ - - Generate a flat dict - - :copyleft: 2014 by Jens Diemer - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - -from __future__ import absolute_import, division, print_function - -from dragonpy.components.MC6809data.MC6809_op_data import OP_DATA - - -def get_flat_opdata(OP_DATA): - flat_opdata = {} - for instr_data in OP_DATA.values(): - for mnemonic, mnemonic_data in instr_data["mnemonic"].items(): - for op_code, op_data in mnemonic_data["ops"].items(): - op_data["mnemonic"] = mnemonic - op_data["needs_ea"] = mnemonic_data["needs_ea"] - for key in ("read_from_memory", "write_to_memory", "register"): - op_data[key] = mnemonic_data[key] - flat_opdata[op_code] = op_data - return flat_opdata - - -MC6809OP_DATA_DICT = get_flat_opdata(OP_DATA) - -del OP_DATA - -if __name__ == '__main__': - import pprint - - pprint.pprint(MC6809OP_DATA_DICT) \ No newline at end of file diff --git a/dragonpy/components/MC6809data/MC6809_op_data.py b/dragonpy/components/MC6809data/MC6809_op_data.py deleted file mode 100644 index c727f908..00000000 --- a/dragonpy/components/MC6809data/MC6809_op_data.py +++ /dev/null @@ -1,1411 +0,0 @@ -#!/usr/bin/env python - -""" - 6809 instruction set data - ~~~~~~~~~~~~~~~~~~~~~~~~~ - - merged data from: - * http://www.maddes.net/m6809pm/sections.htm#sec4_4 - * http://www.burgins.com/m6809.html - * http://www.maddes.net/m6809pm/appendix_a.htm#appA - - Note: - * read_from_memory: it's "excluded" the address modes routines. - So if the address mode will fetch the memory to get the - effective address, but the content of the memory is not needed in - the instruction them self, the read_from_memory must be set to False. - - Generated data is online here: - https://docs.google.com/spreadsheet/ccc?key=0Alhtym6D6yKjdFBtNmF0UVR5OW05S3psaURnUTNtSFE - - :copyleft: 2013-2014 by Jens Diemer - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - - - - -BYTE = "8" -WORD = "16" - - -# Address modes: -DIRECT = "DIRECT" -DIRECT_WORD = "DIRECT_WORD" -EXTENDED = "EXTENDED" -EXTENDED_WORD = "EXTENDED_WORD" -IMMEDIATE = "IMMEDIATE" -IMMEDIATE_WORD = "IMMEDIATE_WORD" -INDEXED = "INDEXED" -INDEXED_WORD = "INDEXED_WORD" -INHERENT = "INHERENT" -RELATIVE = "RELATIVE" -RELATIVE_WORD = "RELATIVE_WORD" - - -# Registers: -REG_A = "A" -REG_B = "B" -REG_CC = "CC" -REG_D = "D" -REG_DP = "DP" -REG_PC = "PC" -REG_S = "S" -REG_U = "U" -REG_X = "X" -REG_Y = "Y" - - -OP_DATA={'ABX': {'mnemonic': {'ABX': {'needs_ea': False, - 'ops': {0x3a: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 3}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'ADC': {'mnemonic': {'ADCA': {'needs_ea': False, - 'ops': {0x89: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 2}, - 0x99: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 4}, - 0xa9: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}, - 0xb9: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 5}}, - 'read_from_memory': BYTE, - 'register': REG_A, - 'write_to_memory': None}, - 'ADCB': {'needs_ea': False, - 'ops': {0xc9: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 2}, - 0xd9: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 4}, - 0xe9: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}, - 0xf9: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 5}}, - 'read_from_memory': BYTE, - 'register': REG_B, - 'write_to_memory': None}}}, -'ADD': {'mnemonic': {'ADDA': {'needs_ea': False, - 'ops': {0x8b: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 2}, - 0x9b: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 4}, - 0xab: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}, - 0xbb: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 5}}, - 'read_from_memory': BYTE, - 'register': REG_A, - 'write_to_memory': None}, - 'ADDB': {'needs_ea': False, - 'ops': {0xcb: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 2}, - 0xdb: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 4}, - 0xeb: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}, - 0xfb: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 5}}, - 'read_from_memory': BYTE, - 'register': REG_B, - 'write_to_memory': None}, - 'ADDD': {'needs_ea': False, - 'ops': {0xc3: {'addr_mode': IMMEDIATE_WORD, - 'bytes': 3, - 'cycles': 4}, - 0xd3: {'addr_mode': DIRECT_WORD, - 'bytes': 2, - 'cycles': 6}, - 0xe3: {'addr_mode': INDEXED_WORD, - 'bytes': 2, - 'cycles': 6}, - 0xf3: {'addr_mode': EXTENDED_WORD, - 'bytes': 3, - 'cycles': 7}}, - 'read_from_memory': WORD, - 'register': REG_D, - 'write_to_memory': None}}}, -'AND': {'mnemonic': {'ANDA': {'needs_ea': False, - 'ops': {0x84: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 2}, - 0x94: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 4}, - 0xa4: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}, - 0xb4: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 5}}, - 'read_from_memory': BYTE, - 'register': REG_A, - 'write_to_memory': None}, - 'ANDB': {'needs_ea': False, - 'ops': {0xc4: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 2}, - 0xd4: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 4}, - 0xe4: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}, - 0xf4: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 5}}, - 'read_from_memory': BYTE, - 'register': REG_B, - 'write_to_memory': None}, - 'ANDCC': {'needs_ea': False, - 'ops': {0x1c: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 3}}, - 'read_from_memory': BYTE, - 'register': REG_CC, - 'write_to_memory': None}}}, -'ASR': {'mnemonic': {'ASR': {'needs_ea': True, - 'ops': {0x07: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 6}, - 0x67: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 6}, - 0x77: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 7}}, - 'read_from_memory': BYTE, - 'register': None, - 'write_to_memory': BYTE}, - 'ASRA': {'needs_ea': False, - 'ops': {0x47: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': REG_A, - 'write_to_memory': None}, - 'ASRB': {'needs_ea': False, - 'ops': {0x57: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': REG_B, - 'write_to_memory': None}}}, -'BEQ': {'mnemonic': {'BEQ': {'needs_ea': True, - 'ops': {0x27: {'addr_mode': RELATIVE, - 'bytes': 2, - 'cycles': 3}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}, - 'LBEQ': {'needs_ea': True, - 'ops': {0x1027: {'addr_mode': RELATIVE_WORD, - 'bytes': 4, - 'cycles': 5}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'BGE': {'mnemonic': {'BGE': {'needs_ea': True, - 'ops': {0x2c: {'addr_mode': RELATIVE, - 'bytes': 2, - 'cycles': 3}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}, - 'LBGE': {'needs_ea': True, - 'ops': {0x102c: {'addr_mode': RELATIVE_WORD, - 'bytes': 4, - 'cycles': 5}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'BGT': {'mnemonic': {'BGT': {'needs_ea': True, - 'ops': {0x2e: {'addr_mode': RELATIVE, - 'bytes': 2, - 'cycles': 3}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}, - 'LBGT': {'needs_ea': True, - 'ops': {0x102e: {'addr_mode': RELATIVE_WORD, - 'bytes': 4, - 'cycles': 5}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'BHI': {'mnemonic': {'BHI': {'needs_ea': True, - 'ops': {0x22: {'addr_mode': RELATIVE, - 'bytes': 2, - 'cycles': 3}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}, - 'LBHI': {'needs_ea': True, - 'ops': {0x1022: {'addr_mode': RELATIVE_WORD, - 'bytes': 4, - 'cycles': 5}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'BHS': {'mnemonic': {'BCC': {'needs_ea': True, - 'ops': {0x24: {'addr_mode': RELATIVE, - 'bytes': 2, - 'cycles': 3}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}, - 'LBCC': {'needs_ea': True, - 'ops': {0x1024: {'addr_mode': RELATIVE_WORD, - 'bytes': 4, - 'cycles': 5}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'BIT': {'mnemonic': {'BITA': {'needs_ea': False, - 'ops': {0x85: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 2}, - 0x95: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 4}, - 0xa5: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}, - 0xb5: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 5}}, - 'read_from_memory': BYTE, - 'register': REG_A, - 'write_to_memory': None}, - 'BITB': {'needs_ea': False, - 'ops': {0xc5: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 2}, - 0xd5: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 4}, - 0xe5: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}, - 0xf5: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 5}}, - 'read_from_memory': BYTE, - 'register': REG_B, - 'write_to_memory': None}}}, -'BLE': {'mnemonic': {'BLE': {'needs_ea': True, - 'ops': {0x2f: {'addr_mode': RELATIVE, - 'bytes': 2, - 'cycles': 3}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}, - 'LBLE': {'needs_ea': True, - 'ops': {0x102f: {'addr_mode': RELATIVE_WORD, - 'bytes': 4, - 'cycles': 5}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'BLO': {'mnemonic': {'BLO': {'needs_ea': True, - 'ops': {0x25: {'addr_mode': RELATIVE, - 'bytes': 2, - 'cycles': 3}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}, - 'LBCS': {'needs_ea': True, - 'ops': {0x1025: {'addr_mode': RELATIVE_WORD, - 'bytes': 4, - 'cycles': 5}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'BLS': {'mnemonic': {'BLS': {'needs_ea': True, - 'ops': {0x23: {'addr_mode': RELATIVE, - 'bytes': 2, - 'cycles': 3}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}, - 'LBLS': {'needs_ea': True, - 'ops': {0x1023: {'addr_mode': RELATIVE_WORD, - 'bytes': 4, - 'cycles': 5}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'BLT': {'mnemonic': {'BLT': {'needs_ea': True, - 'ops': {0x2d: {'addr_mode': RELATIVE, - 'bytes': 2, - 'cycles': 3}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}, - 'LBLT': {'needs_ea': True, - 'ops': {0x102d: {'addr_mode': RELATIVE_WORD, - 'bytes': 4, - 'cycles': 5}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'BMI': {'mnemonic': {'BMI': {'needs_ea': True, - 'ops': {0x2b: {'addr_mode': RELATIVE, - 'bytes': 2, - 'cycles': 3}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}, - 'LBMI': {'needs_ea': True, - 'ops': {0x102b: {'addr_mode': RELATIVE_WORD, - 'bytes': 4, - 'cycles': 5}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'BNE': {'mnemonic': {'BNE': {'needs_ea': True, - 'ops': {0x26: {'addr_mode': RELATIVE, - 'bytes': 2, - 'cycles': 3}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}, - 'LBNE': {'needs_ea': True, - 'ops': {0x1026: {'addr_mode': RELATIVE_WORD, - 'bytes': 4, - 'cycles': 5}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'BPL': {'mnemonic': {'BPL': {'needs_ea': True, - 'ops': {0x2a: {'addr_mode': RELATIVE, - 'bytes': 2, - 'cycles': 3}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}, - 'LBPL': {'needs_ea': True, - 'ops': {0x102a: {'addr_mode': RELATIVE_WORD, - 'bytes': 4, - 'cycles': 5}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'BRA': {'mnemonic': {'BRA': {'needs_ea': True, - 'ops': {0x20: {'addr_mode': RELATIVE, - 'bytes': 2, - 'cycles': 3}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}, - 'LBRA': {'needs_ea': True, - 'ops': {0x16: {'addr_mode': RELATIVE_WORD, - 'bytes': 3, - 'cycles': 5}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'BRN': {'mnemonic': {'BRN': {'needs_ea': True, - 'ops': {0x21: {'addr_mode': RELATIVE, - 'bytes': 2, - 'cycles': 3}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}, - 'LBRN': {'needs_ea': True, - 'ops': {0x1021: {'addr_mode': RELATIVE_WORD, - 'bytes': 4, - 'cycles': 5}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'BSR': {'mnemonic': {'BSR': {'needs_ea': True, - 'ops': {0x8d: {'addr_mode': RELATIVE, - 'bytes': 2, - 'cycles': 7}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}, - 'LBSR': {'needs_ea': True, - 'ops': {0x17: {'addr_mode': RELATIVE_WORD, - 'bytes': 3, - 'cycles': 9}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'BVC': {'mnemonic': {'BVC': {'needs_ea': True, - 'ops': {0x28: {'addr_mode': RELATIVE, - 'bytes': 2, - 'cycles': 3}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}, - 'LBVC': {'needs_ea': True, - 'ops': {0x1028: {'addr_mode': RELATIVE_WORD, - 'bytes': 4, - 'cycles': 5}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'BVS': {'mnemonic': {'BVS': {'needs_ea': True, - 'ops': {0x29: {'addr_mode': RELATIVE, - 'bytes': 2, - 'cycles': 3}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}, - 'LBVS': {'needs_ea': True, - 'ops': {0x1029: {'addr_mode': RELATIVE_WORD, - 'bytes': 4, - 'cycles': 5}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'CLR': {'mnemonic': {'CLR': {'needs_ea': True, - 'ops': {0x0f: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 6}, - 0x6f: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 6}, - 0x7f: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 7}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': BYTE}, - 'CLRA': {'needs_ea': False, - 'ops': {0x4f: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': REG_A, - 'write_to_memory': None}, - 'CLRB': {'needs_ea': False, - 'ops': {0x5f: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': REG_B, - 'write_to_memory': None}}}, -'CMP': {'mnemonic': {'CMPA': {'needs_ea': False, - 'ops': {0x81: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 2}, - 0x91: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 4}, - 0xa1: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}, - 0xb1: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 5}}, - 'read_from_memory': BYTE, - 'register': REG_A, - 'write_to_memory': None}, - 'CMPB': {'needs_ea': False, - 'ops': {0xc1: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 2}, - 0xd1: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 4}, - 0xe1: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}, - 0xf1: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 5}}, - 'read_from_memory': BYTE, - 'register': REG_B, - 'write_to_memory': None}, - 'CMPD': {'needs_ea': False, - 'ops': {0x1083: {'addr_mode': IMMEDIATE_WORD, - 'bytes': 4, - 'cycles': 5}, - 0x1093: {'addr_mode': DIRECT_WORD, - 'bytes': 3, - 'cycles': 7}, - 0x10a3: {'addr_mode': INDEXED_WORD, - 'bytes': 3, - 'cycles': 7}, - 0x10b3: {'addr_mode': EXTENDED_WORD, - 'bytes': 4, - 'cycles': 8}}, - 'read_from_memory': WORD, - 'register': REG_D, - 'write_to_memory': None}, - 'CMPS': {'needs_ea': False, - 'ops': {0x118c: {'addr_mode': IMMEDIATE_WORD, - 'bytes': 4, - 'cycles': 5}, - 0x119c: {'addr_mode': DIRECT_WORD, - 'bytes': 3, - 'cycles': 7}, - 0x11ac: {'addr_mode': INDEXED_WORD, - 'bytes': 3, - 'cycles': 7}, - 0x11bc: {'addr_mode': EXTENDED_WORD, - 'bytes': 4, - 'cycles': 8}}, - 'read_from_memory': WORD, - 'register': REG_S, - 'write_to_memory': None}, - 'CMPU': {'needs_ea': False, - 'ops': {0x1183: {'addr_mode': IMMEDIATE_WORD, - 'bytes': 4, - 'cycles': 5}, - 0x1193: {'addr_mode': DIRECT_WORD, - 'bytes': 3, - 'cycles': 7}, - 0x11a3: {'addr_mode': INDEXED_WORD, - 'bytes': 3, - 'cycles': 7}, - 0x11b3: {'addr_mode': EXTENDED_WORD, - 'bytes': 4, - 'cycles': 8}}, - 'read_from_memory': WORD, - 'register': REG_U, - 'write_to_memory': None}, - 'CMPX': {'needs_ea': False, - 'ops': {0x8c: {'addr_mode': IMMEDIATE_WORD, - 'bytes': 3, - 'cycles': 4}, - 0x9c: {'addr_mode': DIRECT_WORD, - 'bytes': 2, - 'cycles': 6}, - 0xac: {'addr_mode': INDEXED_WORD, - 'bytes': 2, - 'cycles': 6}, - 0xbc: {'addr_mode': EXTENDED_WORD, - 'bytes': 3, - 'cycles': 7}}, - 'read_from_memory': WORD, - 'register': REG_X, - 'write_to_memory': None}, - 'CMPY': {'needs_ea': False, - 'ops': {0x108c: {'addr_mode': IMMEDIATE_WORD, - 'bytes': 4, - 'cycles': 5}, - 0x109c: {'addr_mode': DIRECT_WORD, - 'bytes': 3, - 'cycles': 7}, - 0x10ac: {'addr_mode': INDEXED_WORD, - 'bytes': 3, - 'cycles': 7}, - 0x10bc: {'addr_mode': EXTENDED_WORD, - 'bytes': 4, - 'cycles': 8}}, - 'read_from_memory': WORD, - 'register': REG_Y, - 'write_to_memory': None}}}, -'COM': {'mnemonic': {'COM': {'needs_ea': True, - 'ops': {0x03: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 6}, - 0x63: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 6}, - 0x73: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 7}}, - 'read_from_memory': BYTE, - 'register': None, - 'write_to_memory': BYTE}, - 'COMA': {'needs_ea': False, - 'ops': {0x43: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': REG_A, - 'write_to_memory': None}, - 'COMB': {'needs_ea': False, - 'ops': {0x53: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': REG_B, - 'write_to_memory': None}}}, -'CWAI': {'mnemonic': {'CWAI': {'needs_ea': False, - 'ops': {0x3c: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 21}}, - 'read_from_memory': BYTE, - 'register': None, - 'write_to_memory': None}}}, -'DAA': {'mnemonic': {'DAA': {'needs_ea': False, - 'ops': {0x19: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'DEC': {'mnemonic': {'DEC': {'needs_ea': True, - 'ops': {0x0a: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 6}, - 0x6a: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 6}, - 0x7a: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 7}}, - 'read_from_memory': BYTE, - 'register': None, - 'write_to_memory': BYTE}, - 'DECA': {'needs_ea': False, - 'ops': {0x4a: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': REG_A, - 'write_to_memory': None}, - 'DECB': {'needs_ea': False, - 'ops': {0x5a: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': REG_B, - 'write_to_memory': None}}}, -'EOR': {'mnemonic': {'EORA': {'needs_ea': False, - 'ops': {0x88: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 2}, - 0x98: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 4}, - 0xa8: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}, - 0xb8: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 5}}, - 'read_from_memory': BYTE, - 'register': REG_A, - 'write_to_memory': None}, - 'EORB': {'needs_ea': False, - 'ops': {0xc8: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 2}, - 0xd8: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 4}, - 0xe8: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}, - 0xf8: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 5}}, - 'read_from_memory': BYTE, - 'register': REG_B, - 'write_to_memory': None}}}, -'EXG': {'mnemonic': {'EXG': {'needs_ea': False, - 'ops': {0x1e: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 8}}, - 'read_from_memory': BYTE, - 'register': None, - 'write_to_memory': None}}}, -'INC': {'mnemonic': {'INC': {'needs_ea': True, - 'ops': {0x0c: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 6}, - 0x6c: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 6}, - 0x7c: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 7}}, - 'read_from_memory': BYTE, - 'register': None, - 'write_to_memory': BYTE}, - 'INCA': {'needs_ea': False, - 'ops': {0x4c: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': REG_A, - 'write_to_memory': None}, - 'INCB': {'needs_ea': False, - 'ops': {0x5c: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': REG_B, - 'write_to_memory': None}}}, -'JMP': {'mnemonic': {'JMP': {'needs_ea': True, - 'ops': {0x0e: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 3}, - 0x6e: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 3}, - 0x7e: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 3}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'JSR': {'mnemonic': {'JSR': {'needs_ea': True, - 'ops': {0x9d: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 7}, - 0xad: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 7}, - 0xbd: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 8}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'LD': {'mnemonic': {'LDA': {'needs_ea': False, - 'ops': {0x86: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 2}, - 0x96: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 4}, - 0xa6: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}, - 0xb6: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 5}}, - 'read_from_memory': BYTE, - 'register': REG_A, - 'write_to_memory': None}, - 'LDB': {'needs_ea': False, - 'ops': {0xc6: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 2}, - 0xd6: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 4}, - 0xe6: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}, - 0xf6: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 5}}, - 'read_from_memory': BYTE, - 'register': REG_B, - 'write_to_memory': None}, - 'LDD': {'needs_ea': False, - 'ops': {0xcc: {'addr_mode': IMMEDIATE_WORD, - 'bytes': 3, - 'cycles': 3}, - 0xdc: {'addr_mode': DIRECT_WORD, - 'bytes': 2, - 'cycles': 5}, - 0xec: {'addr_mode': INDEXED_WORD, - 'bytes': 2, - 'cycles': 5}, - 0xfc: {'addr_mode': EXTENDED_WORD, - 'bytes': 3, - 'cycles': 6}}, - 'read_from_memory': WORD, - 'register': REG_D, - 'write_to_memory': None}, - 'LDS': {'needs_ea': False, - 'ops': {0x10ce: {'addr_mode': IMMEDIATE_WORD, - 'bytes': 4, - 'cycles': 4}, - 0x10de: {'addr_mode': DIRECT_WORD, - 'bytes': 3, - 'cycles': 6}, - 0x10ee: {'addr_mode': INDEXED_WORD, - 'bytes': 3, - 'cycles': 6}, - 0x10fe: {'addr_mode': EXTENDED_WORD, - 'bytes': 4, - 'cycles': 7}}, - 'read_from_memory': WORD, - 'register': REG_S, - 'write_to_memory': None}, - 'LDU': {'needs_ea': False, - 'ops': {0xce: {'addr_mode': IMMEDIATE_WORD, - 'bytes': 3, - 'cycles': 3}, - 0xde: {'addr_mode': DIRECT_WORD, - 'bytes': 2, - 'cycles': 5}, - 0xee: {'addr_mode': INDEXED_WORD, - 'bytes': 2, - 'cycles': 5}, - 0xfe: {'addr_mode': EXTENDED_WORD, - 'bytes': 3, - 'cycles': 6}}, - 'read_from_memory': WORD, - 'register': REG_U, - 'write_to_memory': None}, - 'LDX': {'needs_ea': False, - 'ops': {0x8e: {'addr_mode': IMMEDIATE_WORD, - 'bytes': 3, - 'cycles': 3}, - 0x9e: {'addr_mode': DIRECT_WORD, - 'bytes': 2, - 'cycles': 5}, - 0xae: {'addr_mode': INDEXED_WORD, - 'bytes': 2, - 'cycles': 5}, - 0xbe: {'addr_mode': EXTENDED_WORD, - 'bytes': 3, - 'cycles': 6}}, - 'read_from_memory': WORD, - 'register': REG_X, - 'write_to_memory': None}, - 'LDY': {'needs_ea': False, - 'ops': {0x108e: {'addr_mode': IMMEDIATE_WORD, - 'bytes': 4, - 'cycles': 4}, - 0x109e: {'addr_mode': DIRECT_WORD, - 'bytes': 3, - 'cycles': 6}, - 0x10ae: {'addr_mode': INDEXED_WORD, - 'bytes': 3, - 'cycles': 6}, - 0x10be: {'addr_mode': EXTENDED_WORD, - 'bytes': 4, - 'cycles': 7}}, - 'read_from_memory': WORD, - 'register': REG_Y, - 'write_to_memory': None}}}, -'LEA': {'mnemonic': {'LEAS': {'needs_ea': True, - 'ops': {0x32: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}}, - 'read_from_memory': None, - 'register': REG_S, - 'write_to_memory': None}, - 'LEAU': {'needs_ea': True, - 'ops': {0x33: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}}, - 'read_from_memory': None, - 'register': REG_U, - 'write_to_memory': None}, - 'LEAX': {'needs_ea': True, - 'ops': {0x30: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}}, - 'read_from_memory': None, - 'register': REG_X, - 'write_to_memory': None}, - 'LEAY': {'needs_ea': True, - 'ops': {0x31: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}}, - 'read_from_memory': None, - 'register': REG_Y, - 'write_to_memory': None}}}, -'LSL': {'mnemonic': {'LSL': {'needs_ea': True, - 'ops': {0x08: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 6}, - 0x68: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 6}, - 0x78: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 7}}, - 'read_from_memory': BYTE, - 'register': None, - 'write_to_memory': BYTE}, - 'LSLA': {'needs_ea': False, - 'ops': {0x48: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': REG_A, - 'write_to_memory': None}, - 'LSLB': {'needs_ea': False, - 'ops': {0x58: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': REG_B, - 'write_to_memory': None}}}, -'LSR': {'mnemonic': {'LSR': {'needs_ea': True, - 'ops': {0x04: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 6}, - 0x64: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 6}, - 0x74: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 7}}, - 'read_from_memory': BYTE, - 'register': None, - 'write_to_memory': BYTE}, - 'LSRA': {'needs_ea': False, - 'ops': {0x44: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': REG_A, - 'write_to_memory': None}, - 'LSRB': {'needs_ea': False, - 'ops': {0x54: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': REG_B, - 'write_to_memory': None}}}, -'MUL': {'mnemonic': {'MUL': {'needs_ea': False, - 'ops': {0x3d: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 11}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'NEG': {'mnemonic': {'NEG': {'needs_ea': True, - 'ops': {0x00: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 6}, - 0x60: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 6}, - 0x70: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 7}}, - 'read_from_memory': BYTE, - 'register': None, - 'write_to_memory': BYTE}, - 'NEGA': {'needs_ea': False, - 'ops': {0x40: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': REG_A, - 'write_to_memory': None}, - 'NEGB': {'needs_ea': False, - 'ops': {0x50: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': REG_B, - 'write_to_memory': None}}}, -'NOP': {'mnemonic': {'NOP': {'needs_ea': False, - 'ops': {0x12: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'OR': {'mnemonic': {'ORA': {'needs_ea': False, - 'ops': {0x8a: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 2}, - 0x9a: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 4}, - 0xaa: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}, - 0xba: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 5}}, - 'read_from_memory': BYTE, - 'register': REG_A, - 'write_to_memory': None}, - 'ORB': {'needs_ea': False, - 'ops': {0xca: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 2}, - 0xda: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 4}, - 0xea: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}, - 0xfa: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 5}}, - 'read_from_memory': BYTE, - 'register': REG_B, - 'write_to_memory': None}, - 'ORCC': {'needs_ea': False, - 'ops': {0x1a: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 3}}, - 'read_from_memory': BYTE, - 'register': REG_CC, - 'write_to_memory': None}}}, -'PAGE': {'mnemonic': {'PAGE 1': {'needs_ea': False, - 'ops': {0x10: {'addr_mode': None, - 'bytes': 1, - 'cycles': 1}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}, - 'PAGE 2': {'needs_ea': False, - 'ops': {0x11: {'addr_mode': None, - 'bytes': 1, - 'cycles': 1}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'PSH': {'mnemonic': {'PSHS': {'needs_ea': False, - 'ops': {0x34: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 5}}, - 'read_from_memory': BYTE, - 'register': REG_S, - 'write_to_memory': None}, - 'PSHU': {'needs_ea': False, - 'ops': {0x36: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 5}}, - 'read_from_memory': BYTE, - 'register': REG_U, - 'write_to_memory': None}}}, -'PUL': {'mnemonic': {'PULS': {'needs_ea': False, - 'ops': {0x35: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 5}}, - 'read_from_memory': BYTE, - 'register': REG_S, - 'write_to_memory': None}, - 'PULU': {'needs_ea': False, - 'ops': {0x37: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 5}}, - 'read_from_memory': BYTE, - 'register': REG_U, - 'write_to_memory': None}}}, -'RESET': {'mnemonic': {'RESET': {'needs_ea': False, - 'ops': {0x3e: {'addr_mode': None, - 'bytes': 1, - 'cycles': -1}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'ROL': {'mnemonic': {'ROL': {'needs_ea': True, - 'ops': {0x09: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 6}, - 0x69: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 6}, - 0x79: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 7}}, - 'read_from_memory': BYTE, - 'register': None, - 'write_to_memory': BYTE}, - 'ROLA': {'needs_ea': False, - 'ops': {0x49: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': REG_A, - 'write_to_memory': None}, - 'ROLB': {'needs_ea': False, - 'ops': {0x59: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': REG_B, - 'write_to_memory': None}}}, -'ROR': {'mnemonic': {'ROR': {'needs_ea': True, - 'ops': {0x06: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 6}, - 0x66: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 6}, - 0x76: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 7}}, - 'read_from_memory': BYTE, - 'register': None, - 'write_to_memory': BYTE}, - 'RORA': {'needs_ea': False, - 'ops': {0x46: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': REG_A, - 'write_to_memory': None}, - 'RORB': {'needs_ea': False, - 'ops': {0x56: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': REG_B, - 'write_to_memory': None}}}, -'RTI': {'mnemonic': {'RTI': {'needs_ea': False, - 'ops': {0x3b: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 6}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'RTS': {'mnemonic': {'RTS': {'needs_ea': False, - 'ops': {0x39: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 5}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'SBC': {'mnemonic': {'SBCA': {'needs_ea': False, - 'ops': {0x82: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 2}, - 0x92: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 4}, - 0xa2: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}, - 0xb2: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 5}}, - 'read_from_memory': BYTE, - 'register': REG_A, - 'write_to_memory': None}, - 'SBCB': {'needs_ea': False, - 'ops': {0xc2: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 2}, - 0xd2: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 4}, - 0xe2: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}, - 0xf2: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 5}}, - 'read_from_memory': BYTE, - 'register': REG_B, - 'write_to_memory': None}}}, -'SEX': {'mnemonic': {'SEX': {'needs_ea': False, - 'ops': {0x1d: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'ST': {'mnemonic': {'STA': {'needs_ea': True, - 'ops': {0x97: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 4}, - 0xa7: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}, - 0xb7: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 5}}, - 'read_from_memory': None, - 'register': REG_A, - 'write_to_memory': BYTE}, - 'STB': {'needs_ea': True, - 'ops': {0xd7: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 4}, - 0xe7: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}, - 0xf7: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 5}}, - 'read_from_memory': None, - 'register': REG_B, - 'write_to_memory': BYTE}, - 'STD': {'needs_ea': True, - 'ops': {0xdd: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 5}, - 0xed: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 5}, - 0xfd: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 6}}, - 'read_from_memory': None, - 'register': REG_D, - 'write_to_memory': WORD}, - 'STS': {'needs_ea': True, - 'ops': {0x10df: {'addr_mode': DIRECT, - 'bytes': 3, - 'cycles': 6}, - 0x10ef: {'addr_mode': INDEXED, - 'bytes': 3, - 'cycles': 6}, - 0x10ff: {'addr_mode': EXTENDED, - 'bytes': 4, - 'cycles': 7}}, - 'read_from_memory': None, - 'register': REG_S, - 'write_to_memory': WORD}, - 'STU': {'needs_ea': True, - 'ops': {0xdf: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 5}, - 0xef: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 5}, - 0xff: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 6}}, - 'read_from_memory': None, - 'register': REG_U, - 'write_to_memory': WORD}, - 'STX': {'needs_ea': True, - 'ops': {0x9f: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 5}, - 0xaf: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 5}, - 0xbf: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 6}}, - 'read_from_memory': None, - 'register': REG_X, - 'write_to_memory': WORD}, - 'STY': {'needs_ea': True, - 'ops': {0x109f: {'addr_mode': DIRECT, - 'bytes': 3, - 'cycles': 6}, - 0x10af: {'addr_mode': INDEXED, - 'bytes': 3, - 'cycles': 6}, - 0x10bf: {'addr_mode': EXTENDED, - 'bytes': 4, - 'cycles': 7}}, - 'read_from_memory': None, - 'register': REG_Y, - 'write_to_memory': WORD}}}, -'SUB': {'mnemonic': {'SUBA': {'needs_ea': False, - 'ops': {0x80: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 2}, - 0x90: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 4}, - 0xa0: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}, - 0xb0: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 5}}, - 'read_from_memory': BYTE, - 'register': REG_A, - 'write_to_memory': None}, - 'SUBB': {'needs_ea': False, - 'ops': {0xc0: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 2}, - 0xd0: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 4}, - 0xe0: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 4}, - 0xf0: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 5}}, - 'read_from_memory': BYTE, - 'register': REG_B, - 'write_to_memory': None}, - 'SUBD': {'needs_ea': False, - 'ops': {0x83: {'addr_mode': IMMEDIATE_WORD, - 'bytes': 3, - 'cycles': 4}, - 0x93: {'addr_mode': DIRECT_WORD, - 'bytes': 2, - 'cycles': 6}, - 0xa3: {'addr_mode': INDEXED_WORD, - 'bytes': 2, - 'cycles': 6}, - 0xb3: {'addr_mode': EXTENDED_WORD, - 'bytes': 3, - 'cycles': 7}}, - 'read_from_memory': WORD, - 'register': REG_D, - 'write_to_memory': None}}}, -'SWI': {'mnemonic': {'SWI': {'needs_ea': False, - 'ops': {0x3f: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 19}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}, - 'SWI2': {'needs_ea': False, - 'ops': {0x103f: {'addr_mode': INHERENT, - 'bytes': 2, - 'cycles': 20}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}, - 'SWI3': {'needs_ea': False, - 'ops': {0x113f: {'addr_mode': INHERENT, - 'bytes': 2, - 'cycles': 20}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'SYNC': {'mnemonic': {'SYNC': {'needs_ea': False, - 'ops': {0x13: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': None, - 'write_to_memory': None}}}, -'TFR': {'mnemonic': {'TFR': {'needs_ea': False, - 'ops': {0x1f: {'addr_mode': IMMEDIATE, - 'bytes': 2, - 'cycles': 7}}, - 'read_from_memory': BYTE, - 'register': None, - 'write_to_memory': None}}}, -'TST': {'mnemonic': {'TST': {'needs_ea': False, - 'ops': {0x0d: {'addr_mode': DIRECT, - 'bytes': 2, - 'cycles': 6}, - 0x6d: {'addr_mode': INDEXED, - 'bytes': 2, - 'cycles': 6}, - 0x7d: {'addr_mode': EXTENDED, - 'bytes': 3, - 'cycles': 7}}, - 'read_from_memory': BYTE, - 'register': None, - 'write_to_memory': None}, - 'TSTA': {'needs_ea': False, - 'ops': {0x4d: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': REG_A, - 'write_to_memory': None}, - 'TSTB': {'needs_ea': False, - 'ops': {0x5d: {'addr_mode': INHERENT, - 'bytes': 1, - 'cycles': 2}}, - 'read_from_memory': None, - 'register': REG_B, - 'write_to_memory': None}}}} diff --git a/dragonpy/components/MC6809data/MC6809_op_docs.py b/dragonpy/components/MC6809data/MC6809_op_docs.py deleted file mode 100644 index aaa14f5c..00000000 --- a/dragonpy/components/MC6809data/MC6809_op_docs.py +++ /dev/null @@ -1,964 +0,0 @@ -#!/usr/bin/env python - -""" - 6809 instruction set data - ~~~~~~~~~~~~~~~~~~~~~~~~~ - - merged data from: - * http://www.maddes.net/m6809pm/sections.htm#sec4_4 - * http://www.burgins.com/m6809.html - * http://www.maddes.net/m6809pm/appendix_a.htm#appA - - Note: - * read_from_memory: it's "excluded" the address modes routines. - So if the address mode will fetch the memory to get the - effective address, but the content of the memory is not needed in - the instruction them self, the read_from_memory must be set to False. - - Generated data is online here: - https://docs.google.com/spreadsheet/ccc?key=0Alhtym6D6yKjdFBtNmF0UVR5OW05S3psaURnUTNtSFE - - :copyleft: 2013-2014 by Jens Diemer - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - -OP_DOC={'ABX': {'condition code': 'Not affected.', - 'description': 'Add the 8-bit unsigned value in accumulator B into index register X.', - 'instr_desc': 'Add B accumulator to X (unsigned)', - 'mnemonic': {'ABX': {'HNZVC': '-----', - 'desc': 'X = B+X (Unsigned)'}}, - 'operation': "IX' = IX + ACCB", - 'source form': 'ABX'}, -'ADC': {'condition code': ( - 'H - Set if a half-carry is generated; cleared otherwise.\n' - 'N - Set if the result is negative; cleared otherwise.\n' - 'Z - Set if the result is zero; cleared otherwise.\n' - 'V - Set if an overflow is generated; cleared otherwise.\n' - 'C - Set if a carry is generated; cleared otherwise.' - ), - 'description': 'Adds the contents of the C (carry) bit and the memory byte into an 8-bit accumulator.', - 'instr_desc': 'Add memory to accumulator with carry', - 'mnemonic': {'ADCA': {'HNZVC': 'aaaaa', - 'desc': 'A = A+M+C'}, - 'ADCB': {'HNZVC': 'aaaaa', - 'desc': 'B = B+M+C'}}, - 'operation': "R' = R + M + C", - 'source form': 'ADCA P; ADCB P'}, -'ADD': {'condition code': ( - 'H - Set if a half-carry is generated; cleared otherwise.\n' - 'N - Set if the result is negative; cleared otherwise.\n' - 'Z - Set if the result is zero; cleared otherwise.\n' - 'V - Set if an overflow is generated; cleared otherwise.\n' - 'C - Set if a carry is generated; cleared otherwise.' - ), - 'description': 'Adds the memory byte into an 8-bit accumulator.', - 'instr_desc': 'Add memory to accumulator', - 'mnemonic': {'ADDA': {'HNZVC': 'aaaaa', - 'desc': 'A = A+M'}, - 'ADDB': {'HNZVC': 'aaaaa', - 'desc': 'B = B+M'}, - 'ADDD': {'HNZVC': '-aaaa', - 'desc': 'D = D+M:M+1'}}, - 'operation': "R' = R + M", - 'source form': 'ADDA P; ADDB P'}, -'AND': {'condition code': ( - 'H - Not affected.\n' - 'N - Set if the result is negative; cleared otherwise.\n' - 'Z - Set if the result is zero; cleared otherwise.\n' - 'V - Always cleared.\n' - 'C - Not affected.' - ), - 'description': 'Performs the logical AND operation between the contents of an accumulator and the contents of memory location M and the result is stored in the accumulator.', - 'instr_desc': 'AND memory with accumulator', - 'mnemonic': {'ANDA': {'HNZVC': '-aa0-', - 'desc': 'A = A && M'}, - 'ANDB': {'HNZVC': '-aa0-', - 'desc': 'B = B && M'}, - 'ANDCC': {'HNZVC': 'ddddd', - 'desc': 'C = CC && IMM'}}, - 'operation': "R' = R AND M", - 'source form': 'ANDA P; ANDB P'}, -'ASR': {'condition code': ( - 'H - Undefined.\n' - 'N - Set if the result is negative; cleared otherwise.\n' - 'Z - Set if the result is zero; cleared otherwise.\n' - 'V - Not affected.\n' - 'C - Loaded with bit zero of the original operand.' - ), - 'description': 'Shifts all bits of the operand one place to the right. Bit seven is held constant. Bit zero is shifted into the C (carry) bit.', - 'instr_desc': 'Arithmetic shift of accumulator or memory right', - 'mnemonic': {'ASR': {'HNZVC': 'uaa-s', - 'desc': 'M = Arithmetic shift M right'}, - 'ASRA': {'HNZVC': 'uaa-s', - 'desc': 'A = Arithmetic shift A right'}, - 'ASRB': {'HNZVC': 'uaa-s', - 'desc': 'B = Arithmetic shift B right'}}, - 'operation': ( - 'b7 -> -> C\n' - 'b7 -> b0' - ), - 'source form': 'ASR Q; ASRA; ASRB'}, -'BEQ': {'condition code': 'Not affected.', - 'description': ( - 'Tests the state of the Z (zero) bit and causes a branch if it is set.\n' - 'When used after a subtract or compare operation, this instruction will branch if the compared values, signed or unsigned, were exactly the same.' - ), - 'instr_desc': 'Branch if equal', - 'mnemonic': {'BEQ': {'HNZVC': '-----', - 'desc': None}, - 'LBEQ': {'HNZVC': '-----', - 'desc': None}}, - 'operation': "TEMP = MI IFF Z = 1 then PC' = PC + TEMP", - 'source form': 'BEQ dd; LBEQ DDDD'}, -'BGE': {'condition code': 'Not affected.', - 'description': ( - 'Causes a branch if the N (negative) bit and the V (overflow) bit are either both set or both clear.\n' - 'That is, branch if the sign of a valid twos complement result is, or would be, positive.\n' - 'When used after a subtract or compare operation on twos complement values, this instruction will branch if the register was greater than or equal to the memory operand.' - ), - 'instr_desc': 'Branch if greater than or equal (signed)', - 'mnemonic': {'BGE': {'HNZVC': '-----', - 'desc': None}, - 'LBGE': {'HNZVC': '-----', - 'desc': None}}, - 'operation': "TEMP = MI IFF [N XOR V] = 0 then PC' = PC + TEMP", - 'source form': 'BGE dd; LBGE DDDD'}, -'BGT': {'condition code': 'Not affected.', - 'description': ( - 'Causes a branch if the N (negative) bit and V (overflow) bit are either both set or both clear and the Z (zero) bit is clear.\n' - 'In other words, branch if the sign of a valid twos complement result is, or would be, positive and not zero.\n' - 'When used after a subtract or compare operation on twos complement values, this instruction will branch if the register was greater than the memory operand.' - ), - 'instr_desc': 'Branch if greater (signed)', - 'mnemonic': {'BGT': {'HNZVC': '-----', - 'desc': None}, - 'LBGT': {'HNZVC': '-----', - 'desc': None}}, - 'operation': "TEMP = MI IFF Z AND [N XOR V] = 0 then PC' = PC + TEMP", - 'source form': 'BGT dd; LBGT DDDD'}, -'BHI': {'comment': 'Generally not useful after INC/DEC, LD/TST, and TST/CLR/COM instructions.', - 'condition code': 'Not affected.', - 'description': ( - 'Causes a branch if the previous operation caused neither a carry nor a zero result.\n' - 'When used after a subtract or compare operation on unsigned binary values, this instruction will branch if the register was higher than the memory operand.' - ), - 'instr_desc': 'Branch if higher (unsigned)', - 'mnemonic': {'BHI': {'HNZVC': '-----', - 'desc': None}, - 'LBHI': {'HNZVC': '-----', - 'desc': None}}, - 'operation': "TEMP = MI IFF [ C OR Z ] = 0 then PC' = PC + TEMP", - 'source form': 'BHI dd; LBHI DDDD'}, -'BHS': {'comment': ( - 'This is a duplicate assembly-language mnemonic for the single machine instruction BCC.\n' - 'Generally not useful after INC/DEC, LD/ST, and TST/CLR/COM instructions.' - ), - 'condition code': 'Not affected.', - 'description': ( - 'Tests the state of the C (carry) bit and causes a branch if it is clear.\n' - 'When used after a subtract or compare on unsigned binary values, this instruction will branch if the register was higher than or the same as the memory operand.' - ), - 'instr_desc': 'Branch if higher or same (unsigned)', - 'mnemonic': {'BCC': {'HNZVC': '-----', - 'desc': None}, - 'LBCC': {'HNZVC': '-----', - 'desc': None}}, - 'operation': "TEMP = MI IFF C = 0 then PC' = PC + MI", - 'source form': 'BHS dd; LBHS DDDD'}, -'BIT': {'condition code': ( - 'H - Not affected.\n' - 'N - Set if the result is negative; cleared otherwise.\n' - 'Z - Set if the result is zero; cleared otherwise.\n' - 'V - Always cleared.\n' - 'C - Not affected.' - ), - 'description': ( - 'Performs the logical AND of the contents of accumulator A or B and the contents of memory location M and modifies the condition codes accordingly.\n' - 'The contents of accumulator A or B and memory location M are not affected.' - ), - 'instr_desc': 'Bit test memory with accumulator', - 'mnemonic': {'BITA': {'HNZVC': '-aa0-', - 'desc': 'Bit Test A (M&&A)'}, - 'BITB': {'HNZVC': '-aa0-', - 'desc': 'Bit Test B (M&&B)'}}, - 'operation': 'TEMP = R AND M', - 'source form': 'BITA P; BITB P'}, -'BLE': {'condition code': 'Not affected.', - 'description': ( - 'Causes a branch if the exclusive OR of the N (negative) and V (overflow) bits is 1 or if the Z (zero) bit is set.\n' - 'That is, branch if the sign of a valid twos complement result is, or would be, negative.\n' - 'When used after a subtract or compare operation on twos complement values, this instruction will branch if the register was less than or equal to the memory operand.' - ), - 'instr_desc': 'Branch if less than or equal (signed)', - 'mnemonic': {'BLE': {'HNZVC': '-----', - 'desc': None}, - 'LBLE': {'HNZVC': '-----', - 'desc': None}}, - 'operation': "TEMP = MI IFF Z OR [ N XOR V ] = 1 then PC' = PC + TEMP", - 'source form': 'BLE dd; LBLE DDDD'}, -'BLO': {'comment': ( - 'This is a duplicate assembly-language mnemonic for the single machine instruction BCS.\n' - 'Generally not useful after INC/DEC, LD/ST, and TST/CLR/COM instructions.' - ), - 'condition code': 'Not affected.', - 'description': ( - 'Tests the state of the C (carry) bit and causes a branch if it is set.\n' - 'When used after a subtract or compare on unsigned binary values, this instruction will branch if the register was lower than the memory operand.' - ), - 'instr_desc': 'Branch if lower (unsigned)', - 'mnemonic': {'BLO': {'HNZVC': '-----', - 'desc': None}, - 'LBCS': {'HNZVC': '-----', - 'desc': None}}, - 'operation': "TEMP = MI IFF C = 1 then PC' = PC + TEMP", - 'source form': 'BLO dd; LBLO DDDD'}, -'BLS': {'comment': 'Generally not useful after INC/DEC, LD/ST, and TST/CLR/COM instructions.', - 'condition code': 'Not affected.', - 'description': ( - 'Causes a branch if the previous operation caused either a carry or a zero result.\n' - 'When used after a subtract or compare operation on unsigned binary values, this instruction will branch if the register was lower than or the same as the memory operand.' - ), - 'instr_desc': 'Branch if lower or same (unsigned)', - 'mnemonic': {'BLS': {'HNZVC': '-----', - 'desc': None}, - 'LBLS': {'HNZVC': '-----', - 'desc': None}}, - 'operation': "TEMP = MI IFF (C OR Z) = 1 then PC' = PC + TEMP", - 'source form': 'BLS dd; LBLS DDDD'}, -'BLT': {'condition code': 'Not affected.', - 'description': ( - 'Causes a branch if either, but not both, of the N (negative) or V (overflow) bits is set.\n' - 'That is, branch if the sign of a valid twos complement result is, or would be, negative.\n' - 'When used after a subtract or compare operation on twos complement binary values, this instruction will branch if the register was less than the memory operand.' - ), - 'instr_desc': 'Branch if less than (signed)', - 'mnemonic': {'BLT': {'HNZVC': '-----', - 'desc': None}, - 'LBLT': {'HNZVC': '-----', - 'desc': None}}, - 'operation': "TEMP = MI IFF [ N XOR V ] = 1 then PC' = PC + TEMP", - 'source form': 'BLT dd; LBLT DDDD'}, -'BMI': {'comment': ( - 'When used after an operation on signed binary values, this instruction will branch if the result is minus.\n' - 'It is generally preferred to use the LBLT instruction after signed operations.' - ), - 'condition code': 'Not affected.', - 'description': ( - 'Tests the state of the N (negative) bit and causes a branch if set.\n' - 'That is, branch if the sign of the twos complement result is negative.' - ), - 'instr_desc': 'Branch if minus', - 'mnemonic': {'BMI': {'HNZVC': '-----', - 'desc': None}, - 'LBMI': {'HNZVC': '-----', - 'desc': None}}, - 'operation': "TEMP = MI IFF N = 1 then PC' = PC + TEMP", - 'source form': 'BMI dd; LBMI DDDD'}, -'BNE': {'condition code': 'Not affected.', - 'description': ( - 'Tests the state of the Z (zero) bit and causes a branch if it is clear.\n' - 'When used after a subtract or compare operation on any binary values, this instruction will branch if the register is, or would be, not equal to the memory operand.' - ), - 'instr_desc': 'Branch if not equal', - 'mnemonic': {'BNE': {'HNZVC': '-----', - 'desc': None}, - 'LBNE': {'HNZVC': '-----', - 'desc': None}}, - 'operation': "TEMP = MI IFF Z = 0 then PC' = PC + TEMP", - 'source form': 'BNE dd; LBNE DDDD'}, -'BPL': {'comment': ( - 'When used after an operation on signed binary values, this instruction will branch if the result (possibly invalid) is positive.\n' - 'It is generally preferred to use the BGE instruction after signed operations.' - ), - 'condition code': 'Not affected.', - 'description': ( - 'Tests the state of the N (negative) bit and causes a branch if it is clear.\n' - 'That is, branch if the sign of the twos complement result is positive.' - ), - 'instr_desc': 'Branch if plus', - 'mnemonic': {'BPL': {'HNZVC': '-----', - 'desc': None}, - 'LBPL': {'HNZVC': '-----', - 'desc': None}}, - 'operation': "TEMP = MI IFF N = 0 then PC' = PC + TEMP", - 'source form': 'BPL dd; LBPL DDDD'}, -'BRA': {'condition code': 'Not affected.', - 'description': 'Causes an unconditional branch.', - 'instr_desc': 'Branch always', - 'mnemonic': {'BRA': {'HNZVC': '-----', - 'desc': None}, - 'LBRA': {'HNZVC': '-----', - 'desc': None}}, - 'operation': "TEMP = MI PC' = PC + TEMP", - 'source form': 'BRA dd; LBRA DDDD'}, -'BRN': {'condition code': 'Not affected.', - 'description': ( - 'Does not cause a branch.\n' - 'This instruction is essentially a no operation, but has a bit pattern logically related to branch always.' - ), - 'instr_desc': 'Branch never', - 'mnemonic': {'BRN': {'HNZVC': '-----', - 'desc': None}, - 'LBRN': {'HNZVC': '-----', - 'desc': None}}, - 'operation': 'TEMP = MI', - 'source form': 'BRN dd; LBRN DDDD'}, -'BSR': {'comment': 'A return from subroutine (RTS) instruction is used to reverse this process and must be the last instruction executed in a subroutine.', - 'condition code': 'Not affected.', - 'description': ( - 'The program counter is pushed onto the stack.\n' - 'The program counter is then loaded with the sum of the program counter and the offset.' - ), - 'instr_desc': 'Branch to subroutine', - 'mnemonic': {'BSR': {'HNZVC': '-----', - 'desc': None}, - 'LBSR': {'HNZVC': '-----', - 'desc': None}}, - 'operation': "TEMP = MI SP' = SP-1, (SP) = PCL SP' = SP-1, (SP) = PCH PC' = PC + TEMP", - 'source form': 'BSR dd; LBSR DDDD'}, -'BVC': {'condition code': 'Not affected.', - 'description': ( - 'Tests the state of the V (overflow) bit and causes a branch if it is clear.\n' - 'That is, branch if the twos complement result was valid.\n' - 'When used after an operation on twos complement binary values, this instruction will branch if there was no overflow.' - ), - 'instr_desc': 'Branch if valid twos complement result', - 'mnemonic': {'BVC': {'HNZVC': '-----', - 'desc': None}, - 'LBVC': {'HNZVC': '-----', - 'desc': None}}, - 'operation': "TEMP = MI IFF V = 0 then PC' = PC + TEMP", - 'source form': 'BVC dd; LBVC DDDD'}, -'BVS': {'condition code': 'Not affected.', - 'description': ( - 'Tests the state of the V (overflow) bit and causes a branch if it is set.\n' - 'That is, branch if the twos complement result was invalid.\n' - 'When used after an operation on twos complement binary values, this instruction will branch if there was an overflow.' - ), - 'instr_desc': 'Branch if invalid twos complement result', - 'mnemonic': {'BVS': {'HNZVC': '-----', - 'desc': None}, - 'LBVS': {'HNZVC': '-----', - 'desc': None}}, - 'operation': "TEMP' = MI IFF V = 1 then PC' = PC + TEMP", - 'source form': 'BVS dd; LBVS DDDD'}, -'CLR': {'condition code': ( - 'H - Not affected.\n' - 'N - Always cleared.\n' - 'Z - Always set.\n' - 'V - Always cleared.\n' - 'C - Always cleared.' - ), - 'description': ( - 'Accumulator A or B or memory location M is loaded with 00000000 2 .\n' - 'Note that the EA is read during this operation.' - ), - 'instr_desc': 'Clear accumulator or memory location', - 'mnemonic': {'CLR': {'HNZVC': '-0100', - 'desc': 'M = 0'}, - 'CLRA': {'HNZVC': '-0100', - 'desc': 'A = 0'}, - 'CLRB': {'HNZVC': '-0100', - 'desc': 'B = 0'}}, - 'operation': 'TEMP = M M = 00 16', - 'source form': 'CLR Q'}, -'CMP': {'condition code': ( - 'H - Undefined.\n' - 'N - Set if the result is negative; cleared otherwise.\n' - 'Z - Set if the result is zero; cleared otherwise.\n' - 'V - Set if an overflow is generated; cleared otherwise.\n' - 'C - Set if a borrow is generated; cleared otherwise.' - ), - 'description': ( - 'Compares the contents of memory location to the contents of the specified register and sets the appropriate condition codes.\n' - 'Neither memory location M nor the specified register is modified.\n' - 'The carry flag represents a borrow and is set to the inverse of the resulting binary carry.' - ), - 'instr_desc': 'Compare memory from accumulator', - 'mnemonic': {'CMPA': {'HNZVC': 'uaaaa', - 'desc': 'Compare M from A'}, - 'CMPB': {'HNZVC': 'uaaaa', - 'desc': 'Compare M from B'}, - 'CMPD': {'HNZVC': '-aaaa', - 'desc': 'Compare M:M+1 from D'}, - 'CMPS': {'HNZVC': '-aaaa', - 'desc': 'Compare M:M+1 from S'}, - 'CMPU': {'HNZVC': '-aaaa', - 'desc': 'Compare M:M+1 from U'}, - 'CMPX': {'HNZVC': '-aaaa', - 'desc': 'Compare M:M+1 from X'}, - 'CMPY': {'HNZVC': '-aaaa', - 'desc': 'Compare M:M+1 from Y'}}, - 'operation': 'TEMP = R - M', - 'source form': 'CMPA P; CMPB P'}, -'COM': {'condition code': ( - 'H - Not affected.\n' - 'N - Set if the result is negative; cleared otherwise.\n' - 'Z - Set if the result is zero; cleared otherwise.\n' - 'V - Always cleared.\n' - 'C - Always set.' - ), - 'description': ( - 'Replaces the contents of memory location M or accumulator A or B with its logical complement.\n' - 'When operating on unsigned values, only BEQ and BNE branches can be expected to behave properly following a COM instruction.\n' - 'When operating on twos complement values, all signed branches are available.' - ), - 'instr_desc': 'Complement accumulator or memory location', - 'mnemonic': {'COM': {'HNZVC': '-aa01', - 'desc': 'M = complement(M)'}, - 'COMA': {'HNZVC': '-aa01', - 'desc': 'A = complement(A)'}, - 'COMB': {'HNZVC': '-aa01', - 'desc': 'B = complement(B)'}}, - 'operation': "M' = 0 + M", - 'source form': 'COM Q; COMA; COMB'}, -'CWAI': {'comment': 'The following immediate values will have the following results: FF = enable neither EF = enable IRQ BF = enable FIRQ AF = enable both', - 'condition code': 'Affected according to the operation.', - 'description': ( - 'This instruction ANDs an immediate byte with the condition code register which may clear the interrupt mask bits I and F, stacks the entire machine state on the hardware stack and then looks for an interrupt.\n' - 'When a non-masked interrupt occurs, no further machine state information need be saved before vectoring to the interrupt handling routine.\n' - 'This instruction replaced the MC6800 CLI WAI sequence, but does not place the buses in a high-impedance state.\n' - 'A FIRQ (fast interrupt request) may enter its interrupt handler with its entire machine state saved.\n' - 'The RTI (return from interrupt) instruction will automatically return the entire machine state after testing the E (entire) bit of the recovered condition code register.' - ), - 'instr_desc': 'AND condition code register, then wait for interrupt', - 'mnemonic': {'CWAI': {'HNZVC': 'ddddd', - 'desc': 'CC = CC ^ IMM; (Wait for Interrupt)'}}, - 'operation': "CCR = CCR AND MI (Possibly clear masks) Set E (entire state saved) SP' = SP-1, (SP) = PCL SP' = SP-1, (SP) = PCH SP' = SP-1, (SP) = USL SP' = SP-1, (SP) = USH SP' = SP-1, (SP) = IYL SP' = SP-1, (SP) = IYH SP' = SP-1, (SP) = IXL SP' = SP-1, (SP) = IXH SP' = SP-1, (SP) = DPR SP' = SP-1, (SP) = ACCB SP' = SP-1, (SP) = ACCA SP' = SP-1, (SP) = CCR", - 'source form': 'CWAI #$XX E F H I N Z V C'}, -'DAA': {'condition code': ( - 'H - Not affected.\n' - 'N - Set if the result is negative; cleared otherwise.\n' - 'Z - Set if the result is zero; cleared otherwise.\n' - 'V - Undefined.\n' - 'C - Set if a carry is generated or if the carry bit was set before the operation; cleared otherwise.' - ), - 'description': ( - 'The sequence of a single-byte add instruction on accumulator A (either ADDA or ADCA) and a following decimal addition adjust instruction results in a BCD addition with an appropriate carry bit.\n' - 'Both values to be added must be in proper BCD form (each nibble such that: 0 <= nibble <= 9).\n' - 'Multiple-precision addition must add the carry generated by this decimal addition adjust into the next higher digit during the add operation (ADCA) immediately prior to the next decimal addition adjust.' - ), - 'instr_desc': 'Decimal adjust A accumulator', - 'mnemonic': {'DAA': {'HNZVC': '-aa0a', - 'desc': 'Decimal Adjust A'}}, - 'operation': 'Decimal Adjust A', - 'source form': 'DAA'}, -'DEC': {'condition code': ( - 'H - Not affected.\n' - 'N - Set if the result is negative; cleared otherwise.\n' - 'Z - Set if the result is zero; cleared otherwise.\n' - 'V - Set if the original operand was 10000000 2 ; cleared otherwise.\n' - 'C - Not affected.' - ), - 'description': ( - 'Subtract one from the operand.\n' - 'The carry bit is not affected, thus allowing this instruction to be used as a loop counter in multiple-precision computations.\n' - 'When operating on unsigned values, only BEQ and BNE branches can be expected to behave consistently.\n' - 'When operating on twos complement values, all signed branches are available.' - ), - 'instr_desc': 'Decrement accumulator or memory location', - 'mnemonic': {'DEC': {'HNZVC': '-aaa-', - 'desc': 'M = M - 1'}, - 'DECA': {'HNZVC': '-aaa-', - 'desc': 'A = A - 1'}, - 'DECB': {'HNZVC': '-aaa-', - 'desc': 'B = B - 1'}}, - 'operation': "M' = M - 1", - 'source form': 'DEC Q; DECA; DECB'}, -'EOR': {'condition code': ( - 'H - Not affected.\n' - 'N - Set if the result is negative; cleared otherwise.\n' - 'Z - Set if the result is zero; cleared otherwise.\n' - 'V - Always cleared.\n' - 'C - Not affected.' - ), - 'description': 'The contents of memory location M is exclusive ORed into an 8-bit register.', - 'instr_desc': 'Exclusive OR memory with accumulator', - 'mnemonic': {'EORA': {'HNZVC': '-aa0-', - 'desc': 'A = A XOR M'}, - 'EORB': {'HNZVC': '-aa0-', - 'desc': 'B = M XOR B'}}, - 'operation': "R' = R XOR M", - 'source form': 'EORA P; EORB P'}, -'EXG': {'condition code': ( - 'Not affected (unless one of the registers is the condition code\n' - 'register).' - ), - 'description': ( - '0000 = A:B 1000 = A\n' - '0001 = X 1001 = B\n' - '0010 = Y 1010 = CCR\n' - '0011 = US 1011 = DPR\n' - '0100 = SP 1100 = Undefined\n' - '0101 = PC 1101 = Undefined\n' - '0110 = Undefined 1110 = Undefined\n' - '0111 = Undefined 1111 = Undefined' - ), - 'instr_desc': 'Exchange Rl with R2', - 'mnemonic': {'EXG': {'HNZVC': 'ccccc', - 'desc': 'exchange R1,R2'}}, - 'operation': 'R1 <-> R2', - 'source form': 'EXG R1,R2'}, -'INC': {'condition code': ( - 'H - Not affected.\n' - 'N - Set if the result is negative; cleared otherwise.\n' - 'Z - Set if the result is zero; cleared otherwise.\n' - 'V - Set if the original operand was 01111111 2 ; cleared otherwise.\n' - 'C - Not affected.' - ), - 'description': ( - 'Adds to the operand.\n' - 'The carry bit is not affected, thus allowing this instruction to be used as a loop counter in multiple-precision computations.\n' - 'When operating on unsigned values, only the BEQ and BNE branches can be expected to behave consistently.\n' - 'When operating on twos complement values, all signed branches are correctly available.' - ), - 'instr_desc': 'Increment accumulator or memory location', - 'mnemonic': {'INC': {'HNZVC': '-aaa-', - 'desc': 'M = M + 1'}, - 'INCA': {'HNZVC': '-aaa-', - 'desc': 'A = A + 1'}, - 'INCB': {'HNZVC': '-aaa-', - 'desc': 'B = B + 1'}}, - 'operation': "M' = M + 1", - 'source form': 'INC Q; INCA; INCB'}, -'JMP': {'condition code': 'Not affected.', - 'description': 'Program control is transferred to the effective address.', - 'instr_desc': 'Jump', - 'mnemonic': {'JMP': {'HNZVC': '-----', - 'desc': 'pc = EA'}}, - 'operation': "PC' = EA", - 'source form': 'JMP EA'}, -'JSR': {'condition code': 'Not affected.', - 'description': ( - 'Program control is transferred to the effective address after storing the return address on the hardware stack.\n' - 'A RTS instruction should be the last executed instruction of the subroutine.' - ), - 'instr_desc': 'Jump to subroutine', - 'mnemonic': {'JSR': {'HNZVC': '-----', - 'desc': 'jump to subroutine'}}, - 'operation': "SP' = SP-1, (SP) = PCL SP' = SP-1, (SP) = PCH PC' =EA", - 'source form': 'JSR EA'}, -'LD': {'condition code': ( - 'H - Not affected.\n' - 'N - Set if the loaded data is negative; cleared otherwise.\n' - 'Z - Set if the loaded data is zero; cleared otherwise.\n' - 'V - Always cleared.\n' - 'C - Not affected.' - ), - 'description': 'Loads the contents of memory location M into the designated register.', - 'instr_desc': 'Load accumulator from memory', - 'mnemonic': {'LDA': {'HNZVC': '-aa0-', - 'desc': 'A = M'}, - 'LDB': {'HNZVC': '-aa0-', - 'desc': 'B = M'}, - 'LDD': {'HNZVC': '-aa0-', - 'desc': 'D = M:M+1'}, - 'LDS': {'HNZVC': '-aa0-', - 'desc': 'S = M:M+1'}, - 'LDU': {'HNZVC': '-aa0-', - 'desc': 'U = M:M+1'}, - 'LDX': {'HNZVC': '-aa0-', - 'desc': 'X = M:M+1'}, - 'LDY': {'HNZVC': '-aa0-', - 'desc': 'Y = M:M+1'}}, - 'operation': "R' = M", - 'source form': 'LDA P; LDB P'}, -'LEA': {'comment': ( - 'Instruction Operation Comment\n' - 'Instruction\n' - '\n' - 'Operation\n' - '\n' - 'Comment\n' - 'LEAX 10,X X+10 -> X Adds 5-bit constant 10 to X\n' - 'LEAX 500,X X+500 -> X Adds 16-bit constant 500 to X\n' - 'LEAY A,Y Y+A -> Y Adds 8-bit accumulator to Y\n' - 'LEAY D,Y Y+D -> Y Adds 16-bit D accumulator to Y\n' - 'LEAU -10,U U-10 -> U Subtracts 10 from U\n' - 'LEAS -10,S S-10 -> S Used to reserve area on stack\n' - "LEAS 10,S S+10 -> S Used to 'clean up' stack\n" - 'LEAX 5,S S+5 -> X Transfers as well as adds' - ), - 'condition code': ( - 'H - Not affected.\n' - 'N - Not affected.\n' - 'Z - LEAX, LEAY: Set if the result is zero; cleared otherwise. LEAS, LEAU: Not affected.\n' - 'V - Not affected.\n' - 'C - Not affected.' - ), - 'description': 'Calculates the effective address from the indexed addressing mode and places the address in an indexable register. LEAX and LEAY affect the Z (zero) bit to allow use of these registers as counters and for MC6800 INX/DEX compatibility. LEAU and LEAS do not affect the Z bit to allow cleaning up the stack while returning the Z bit as a parameter to a calling routine, and also for MC6800 INS/DES compatibility.', - 'instr_desc': 'Load effective address into stack pointer', - 'mnemonic': {'LEAS': {'HNZVC': '-----', - 'desc': 'S = EA'}, - 'LEAU': {'HNZVC': '-----', - 'desc': 'U = EA'}, - 'LEAX': {'HNZVC': '--a--', - 'desc': 'X = EA'}, - 'LEAY': {'HNZVC': '--a--', - 'desc': 'Y = EA'}}, - 'operation': "R' = EA", - 'source form': 'LEAX, LEAY, LEAS, LEAU'}, -'LSL': {'comment': 'This is a duplicate assembly-language mnemonic for the single machine instruction ASL.', - 'condition code': ( - 'H - Undefined.\n' - 'N - Set if the result is negative; cleared otherwise.\n' - 'Z - Set if the result is zero; cleared otherwise.\n' - 'V - Loaded with the result of the exclusive OR of bits six and seven of the original operand.\n' - 'C - Loaded with bit seven of the original operand.' - ), - 'description': ( - 'Shifts all bits of accumulator A or B or memory location M one place to the left.\n' - 'Bit zero is loaded with a zero.\n' - 'Bit seven of accumulator A or B or memory location M is shifted into the C (carry) bit.' - ), - 'instr_desc': 'Logical shift left accumulator or memory location', - 'mnemonic': {'LSL': {'HNZVC': 'naaas', - 'desc': 'M = Logical shift M left'}, - 'LSLA': {'HNZVC': 'naaas', - 'desc': 'A = Logical shift A left'}, - 'LSLB': {'HNZVC': 'naaas', - 'desc': 'B = Logical shift B left'}}, - 'operation': ( - 'C = = 0\n' - 'b7 = b0' - ), - 'source form': 'LSL Q; LSLA; LSLB'}, -'LSR': {'condition code': ( - 'H - Not affected.\n' - 'N - Always cleared.\n' - 'Z - Set if the result is zero; cleared otherwise.\n' - 'V - Not affected.\n' - 'C - Loaded with bit zero of the original operand.' - ), - 'description': ( - 'Performs a logical shift right on the operand.\n' - 'Shifts a zero into bit seven and bit zero into the C (carry) bit.' - ), - 'instr_desc': 'Logical shift right accumulator or memory location', - 'mnemonic': {'LSR': {'HNZVC': '-0a-s', - 'desc': 'M = Logical shift M right'}, - 'LSRA': {'HNZVC': '-0a-s', - 'desc': 'A = Logical shift A right'}, - 'LSRB': {'HNZVC': '-0a-s', - 'desc': 'B = Logical shift B right'}}, - 'operation': ( - '0 -> -> C\n' - 'b7 -> b0' - ), - 'source form': 'LSR Q; LSRA; LSRB'}, -'MUL': {'comment': 'The C (carry) bit allows rounding the most-significant byte through the sequence: MUL, ADCA #0.', - 'condition code': ( - 'H - Not affected.\n' - 'N - Not affected.\n' - 'Z - Set if the result is zero; cleared otherwise.\n' - 'V - Not affected.\n' - 'C - Set if ACCB bit 7 of result is set; cleared otherwise.' - ), - 'description': ( - 'Multiply the unsigned binary numbers in the accumulators and place the result in both accumulators (ACCA contains the most-significant byte of the result).\n' - 'Unsigned multiply allows multiple-precision operations.' - ), - 'instr_desc': 'Unsigned multiply (A * B ? D)', - 'mnemonic': {'MUL': {'HNZVC': '--a-a', - 'desc': 'D = A*B (Unsigned)'}}, - 'operation': "ACCA':ACCB' = ACCA * ACCB", - 'source form': 'MUL'}, -'NEG': {'condition code': ( - 'H - Undefined.\n' - 'N - Set if the result is negative; cleared otherwise.\n' - 'Z - Set if the result is zero; cleared otherwise.\n' - 'V - Set if the original operand was 10000000 2 .\n' - 'C - Set if a borrow is generated; cleared otherwise.' - ), - 'description': ( - 'Replaces the operand with its twos complement.\n' - 'The C (carry) bit represents a borrow and is set to the inverse of the resulting binary carry.\n' - 'Note that 80 16 is replaced by itself and only in this case is the V (overflow) bit set.\n' - 'The value 00 16 is also replaced by itself, and only in this case is the C (carry) bit cleared.' - ), - 'instr_desc': 'Negate accumulator or memory', - 'mnemonic': {'NEG': {'HNZVC': 'uaaaa', - 'desc': 'M = !M + 1'}, - 'NEGA': {'HNZVC': 'uaaaa', - 'desc': 'A = !A + 1'}, - 'NEGB': {'HNZVC': 'uaaaa', - 'desc': 'B = !B + 1'}}, - 'operation': "M' = 0 - M", - 'source form': 'NEG Q; NEGA; NEG B'}, -'NOP': {'condition code': ( - 'This instruction causes only the program counter to be incremented.\n' - 'No other registers or memory locations are affected.' - ), - 'description': '', - 'instr_desc': 'No operation', - 'mnemonic': {'NOP': {'HNZVC': '-----', - 'desc': 'No Operation'}}, - 'operation': 'Not affected.', - 'source form': 'NOP'}, -'OR': {'condition code': ( - 'H - Not affected.\n' - 'N - Set if the result is negative; cleared otherwise.\n' - 'Z - Set if the result is zero; cleared otherwise.\n' - 'V - Always cleared.\n' - 'C - Not affected.' - ), - 'description': 'Performs an inclusive OR operation between the contents of accumulator A or B and the contents of memory location M and the result is stored in accumulator A or B.', - 'instr_desc': 'OR memory with accumulator', - 'mnemonic': {'ORA': {'HNZVC': '-aa0-', - 'desc': 'A = A || M'}, - 'ORB': {'HNZVC': '-aa0-', - 'desc': 'B = B || M'}, - 'ORCC': {'HNZVC': 'ddddd', - 'desc': 'C = CC || IMM'}}, - 'operation': "R' = R OR M", - 'source form': 'ORA P; ORB P'}, -'PAGE': {'description': 'Page 1/2 instructions', - 'instr_desc': 'Page 2 Instructions prefix', - 'mnemonic': {'PAGE 1': {'HNZVC': '+++++', - 'desc': 'Page 1 Instructions prefix'}, - 'PAGE 2': {'HNZVC': '+++++', - 'desc': 'Page 2 Instructions prefix'}}}, -'PSH': {'comment': 'A single register may be placed on the stack with the condition codes set by doing an autodecrement store onto the stack (example: STX ,--S).', - 'condition code': 'Not affected.', - 'description': 'All, some, or none of the processor registers are pushed onto the hardware stack (with the exception of the hardware stack pointer itself).', - 'instr_desc': 'Push A, B, CC, DP, D, X, Y, U, or PC onto hardware stack', - 'mnemonic': {'PSHS': {'HNZVC': '-----', - 'desc': 'S -= 1: MEM(S) = R; Push Register on S Stack'}, - 'PSHU': {'HNZVC': '-----', - 'desc': 'U -= 1: MEM(U) = R; Push Register on U Stack'}}, - 'operation': 'Push Registers on S Stack: S -= 1: MEM(S) = Reg.', - 'source form': ( - 'b7 b6 b5 b4 b3 b2 b1 b0\n' - 'PC U Y X DP B A CC\n' - 'push order ->' - )}, -'PUL': {'comment': 'A single register may be pulled from the stack with condition codes set by doing an autoincrement load from the stack (example: LDX ,S++).', - 'condition code': 'May be pulled from stack; not affected otherwise.', - 'description': 'All, some, or none of the processor registers are pulled from the hardware stack (with the exception of the hardware stack pointer itself).', - 'instr_desc': 'Pull A, B, CC, DP, D, X, Y, U, or PC from hardware stack', - 'mnemonic': {'PULS': {'HNZVC': 'ccccc', - 'desc': 'R=MEM(S) : S += 1; Pull register from S Stack'}, - 'PULU': {'HNZVC': 'ccccc', - 'desc': 'R=MEM(U) : U += 1; Pull register from U Stack'}}, - 'operation': 'Pull Registers from S Stack: Reg. = MEM(S): S += 1', - 'source form': ( - 'b7 b6 b5 b4 b3 b2 b1 b0\n' - 'PC U Y X DP B A CC\n' - '= pull order' - )}, -'RESET': {'description': 'Build the ASSIST09 vector table and setup monitor defaults, then invoke the monitor startup routine.', - 'instr_desc': '', - 'mnemonic': {'RESET': {'HNZVC': '*****', - 'desc': 'Undocumented opcode'}}}, -'ROL': {'condition code': ( - 'H - Not affected.\n' - 'N - Set if the result is negative; cleared otherwise.\n' - 'Z - Set if the result is zero; cleared otherwise.\n' - 'V - Loaded with the result of the exclusive OR of bits six and seven of the original operand.\n' - 'C - Loaded with bit seven of the original operand.' - ), - 'description': ( - 'Rotates all bits of the operand one place left through the C (carry) bit.\n' - 'This is a 9-bit rotation.' - ), - 'instr_desc': 'Rotate accumulator or memory left', - 'mnemonic': {'ROL': {'HNZVC': '-aaas', - 'desc': 'M = Rotate M left thru carry'}, - 'ROLA': {'HNZVC': '-aaas', - 'desc': 'A = Rotate A left thru carry'}, - 'ROLB': {'HNZVC': '-aaas', - 'desc': 'B = Rotate B left thru carry'}}, - 'operation': ( - 'C = = C\n' - 'b7 = b0' - ), - 'source form': 'ROL Q; ROLA; ROLB'}, -'ROR': {'condition code': ( - 'H - Not affected.\n' - 'N - Set if the result is negative; cleared otherwise.\n' - 'Z - Set if the result is zero; cleared otherwise.\n' - 'V - Not affected.\n' - 'C - Loaded with bit zero of the previous operand.' - ), - 'description': ( - 'Rotates all bits of the operand one place right through the C (carry) bit.\n' - 'This is a 9-bit rotation.' - ), - 'instr_desc': 'Rotate accumulator or memory right', - 'mnemonic': {'ROR': {'HNZVC': '-aa-s', - 'desc': 'M = Rotate M Right thru carry'}, - 'RORA': {'HNZVC': '-aa-s', - 'desc': 'A = Rotate A Right thru carry'}, - 'RORB': {'HNZVC': '-aa-s', - 'desc': 'B = Rotate B Right thru carry'}}, - 'operation': ( - 'C -> -> C\n' - 'b7 -> b0' - ), - 'source form': 'ROR Q; RORA; RORB'}, -'RTI': {'condition code': 'Recovered from the stack.', - 'description': ( - 'The saved machine state is recovered from the hardware stack and control is returned to the interrupted program.\n' - 'If the recovered E (entire) bit is clear, it indicates that only a subset of the machine state was saved (return address and condition codes) and only that subset is recovered.' - ), - 'instr_desc': 'Return from interrupt', - 'mnemonic': {'RTI': {'HNZVC': '-----', - 'desc': 'Return from Interrupt'}}, - 'operation': ( - "IFF CCR bit E is set, then: ACCA' ACCB' DPR' IXH' IXL' IYH' IYL' USH' USL' PCH' PCL' = (SP), SP' = SP+1 = (SP), SP' = SP+1 = (SP), SP' = SP+1 = (SP), SP' = SP+1 = (SP), SP' = SP+1 = (SP), SP' = SP+1 = (SP), SP' = SP+1 = (SP), SP' = SP+1 = (SP), SP' = SP+1 = (SP), SP' = SP+1 = (SP), SP' = SP+1\n" - "IFF CCR bit E is clear, then: PCH' PCL' = (SP), SP' = SP+1 = (SP), SP' = SP+1" - ), - 'source form': 'RTI'}, -'RTS': {'condition code': 'Not affected.', - 'description': ( - 'Program control is returned from the subroutine to the calling program.\n' - 'The return address is pulled from the stack.' - ), - 'instr_desc': 'Return from subroutine', - 'mnemonic': {'RTS': {'HNZVC': '-----', - 'desc': 'Return from subroutine'}}, - 'operation': "PCH' = (SP), SP' = SP+1 PCL' = (SP), SP' = SP+1", - 'source form': 'RTS'}, -'SBC': {'condition code': ( - 'H - Undefined.\n' - 'N - Set if the result is negative; cleared otherwise.\n' - 'Z - Set if the result is zero; cleared otherwise.\n' - 'V - Set if an overflow is generated; cleared otherwise.\n' - 'C - Set if a borrow is generated; cleared otherwise.' - ), - 'description': ( - 'Subtracts the contents of memory location M and the borrow (in the C (carry) bit) from the contents of the designated 8-bit register, and places the result in that register.\n' - 'The C bit represents a borrow and is set to the inverse of the resulting binary carry.' - ), - 'instr_desc': 'Subtract memory from accumulator with borrow', - 'mnemonic': {'SBCA': {'HNZVC': 'uaaaa', - 'desc': 'A = A - M - C'}, - 'SBCB': {'HNZVC': 'uaaaa', - 'desc': 'B = B - M - C'}}, - 'operation': "R' = R - M - C", - 'source form': 'SBCA P; SBCB P'}, -'SEX': {'condition code': ( - 'H - Not affected.\n' - 'N - Set if the result is negative; cleared otherwise.\n' - 'Z - Set if the result is zero; cleared otherwise.\n' - 'V - Not affected.\n' - 'C - Not affected.' - ), - 'description': 'This instruction transforms a twos complement 8-bit value in accumulator B into a twos complement 16-bit value in the D accumulator.', - 'instr_desc': 'Sign Extend B accumulator into A accumulator', - 'mnemonic': {'SEX': {'HNZVC': '-aa0-', - 'desc': 'Sign extend B into A'}}, - 'operation': "If bit seven of ACCB is set then ACCA' = FF 16 else ACCA' = 00 16", - 'source form': 'SEX'}, -'ST': {'condition code': ( - 'H - Not affected.\n' - 'N - Set if the result is negative; cleared otherwise.\n' - 'Z - Set if the result is zero; cleared otherwise.\n' - 'V - Always cleared.\n' - 'C - Not affected.' - ), - 'description': 'Writes the contents of an 8-bit register into a memory location.', - 'instr_desc': 'Store accumulator to memroy', - 'mnemonic': {'STA': {'HNZVC': '-aa0-', - 'desc': 'M = A'}, - 'STB': {'HNZVC': '-aa0-', - 'desc': 'M = B'}, - 'STD': {'HNZVC': '-aa0-', - 'desc': 'M:M+1 = D'}, - 'STS': {'HNZVC': '-aa0-', - 'desc': 'M:M+1 = S'}, - 'STU': {'HNZVC': '-aa0-', - 'desc': 'M:M+1 = U'}, - 'STX': {'HNZVC': '-aa0-', - 'desc': 'M:M+1 = X'}, - 'STY': {'HNZVC': '-aa0-', - 'desc': 'M:M+1 = Y'}}, - 'operation': "M' = R", - 'source form': 'STA P; STB P'}, -'SUB': {'condition code': ( - 'H - Undefined.\n' - 'N - Set if the result is negative; cleared otherwise.\n' - 'Z - Set if the result is zero; cleared otherwise.\n' - 'V - Set if the overflow is generated; cleared otherwise.\n' - 'C - Set if a borrow is generated; cleared otherwise.' - ), - 'description': ( - 'Subtracts the value in memory location M from the contents of a designated 8-bit register.\n' - 'The C (carry) bit represents a borrow and is set to the inverse of the resulting binary carry.' - ), - 'instr_desc': 'Subtract memory from accumulator', - 'mnemonic': {'SUBA': {'HNZVC': 'uaaaa', - 'desc': 'A = A - M'}, - 'SUBB': {'HNZVC': 'uaaaa', - 'desc': 'B = B - M'}, - 'SUBD': {'HNZVC': '-aaaa', - 'desc': 'D = D - M:M+1'}}, - 'operation': "R' = R - M", - 'source form': 'SUBA P; SUBB P'}, -'SWI': {'condition code': 'Not affected.', - 'description': ( - 'All of the processor registers are pushed onto the hardware stack (with the exception of the hardware stack pointer itself), and control is transferred through the software interrupt vector.\n' - 'Both the normal and fast interrupts are masked (disabled).' - ), - 'instr_desc': 'Software interrupt (absolute indirect)', - 'mnemonic': {'SWI': {'HNZVC': '-----', - 'desc': 'Software interrupt 1'}, - 'SWI2': {'HNZVC': '-----', - 'desc': 'Software interrupt 2'}, - 'SWI3': {'HNZVC': '-----', - 'desc': 'Software interrupt 3'}}, - 'operation': "Set E (entire state will be saved) SP' = SP-1, (SP) = PCL SP' = SP-1, (SP) = PCH SP' = SP-1, (SP) = USL SP' = SP-1, (SP) = USH SP' = SP-1, (SP) = IYL SP' = SP-1, (SP) = IYH SP' = SP-1, (SP) = IXL SP' = SP-1, (SP) = IXH SP' = SP-1, (SP) = DPR SP' = SP-1, (SP) = ACCB SP' = SP-1, (SP) = ACCA SP' = SP-1, (SP) = CCR Set I, F (mask interrupts) PC' = (FFFA):(FFFB)", - 'source form': 'SWI'}, -'SYNC': {'condition code': 'Not affected.', - 'description': ( - 'FAST SYNC WAIT FOR DATA\n' - 'Interrupt!\n' - 'LDA DISC DATA FROM DISC AND CLEAR INTERRUPT\n' - 'STA ,X+ PUT IN BUFFER\n' - 'DECB COUNT IT, DONE?\n' - 'BNE FAST GO AGAIN IF NOT.' - ), - 'instr_desc': 'Synchronize with interrupt line', - 'mnemonic': {'SYNC': {'HNZVC': '-----', - 'desc': 'Synchronize to Interrupt'}}, - 'operation': 'Stop processing instructions', - 'source form': 'SYNC'}, -'TFR': {'condition code': 'Not affected unless R2 is the condition code register.', - 'description': ( - '0000 = A:B 1000 = A\n' - '0001 = X 1001 = B\n' - '0010 = Y 1010 = CCR\n' - '0011 = US 1011 = DPR\n' - '0100 = SP 1100 = Undefined\n' - '0101 = PC 1101 = Undefined\n' - '0110 = Undefined 1110 = Undefined\n' - '0111 = Undefined 1111 = Undefined' - ), - 'instr_desc': 'Transfer R1 to R2', - 'mnemonic': {'TFR': {'HNZVC': 'ccccc', - 'desc': None}}, - 'operation': 'R1 -> R2', - 'source form': 'TFR R1, R2'}, -'TST': {'comment': 'The MC6800 processor clears the C (carry) bit.', - 'condition code': ( - 'H - Not affected.\n' - 'N - Set if the result is negative; cleared otherwise.\n' - 'Z - Set if the result is zero; cleared otherwise.\n' - 'V - Always cleared.\n' - 'C - Not affected.' - ), - 'description': ( - 'Set the N (negative) and Z (zero) bits according to the contents of memory location M, and clear the V (overflow) bit.\n' - 'The TST instruction provides only minimum information when testing unsigned values; since no unsigned value is less than zero, BLO and BLS have no utility.\n' - 'While BHI could be used after TST, it provides exactly the same control as BNE, which is preferred.\n' - 'The signed branches are available.' - ), - 'instr_desc': 'Test accumulator or memory location', - 'mnemonic': {'TST': {'HNZVC': '-aa0-', - 'desc': 'Test M'}, - 'TSTA': {'HNZVC': '-aa0-', - 'desc': 'Test A'}, - 'TSTB': {'HNZVC': '-aa0-', - 'desc': 'Test B'}}, - 'operation': 'TEMP = M - 0', - 'source form': 'TST Q; TSTA; TSTB'}} diff --git a/dragonpy/components/cpu6809.py b/dragonpy/components/cpu6809.py deleted file mode 100755 index 2fb0bed0..00000000 --- a/dragonpy/components/cpu6809.py +++ /dev/null @@ -1,2739 +0,0 @@ -#!/usr/bin/env python -# coding: utf-8 - -""" - DragonPy - Dragon 32 emulator in Python - ======================================= - - 6809 is Big-Endian - - Links: - http://dragondata.worldofdragon.org/Publications/inside-dragon.htm - http://www.burgins.com/m6809.html - http://koti.mbnet.fi/~atjs/mc6809/ - - :copyleft: 2013-2014 by the DragonPy team, see AUTHORS for more details. - :license: GNU GPL v3 or above, see LICENSE for more details. - - Based on: - * ApplyPy by James Tauber (MIT license) - * XRoar emulator by Ciaran Anscomb (GPL license) - more info, see README -""" - -from __future__ import absolute_import, division, print_function -from dragonlib.utils import six -xrange = six.moves.xrange - -try: - # Python 3 - import queue - import _thread -except ImportError: - # Python 2 - import Queue as queue - import thread as _thread - -import inspect -import logging -import sys -import threading -import time -import warnings - - -from dragonpy.core.cpu_control_server import start_http_control_server -from dragonpy.components.cpu_utils.MC6809_registers import ( - ValueStorage8Bit, ConcatenatedAccumulator, - ValueStorage16Bit, ConditionCodeRegister, UndefinedRegister -) -from dragonpy.components.cpu_utils.instruction_caller import OpCollection -from dragonpy.utils.bits import is_bit_set, get_bit -from dragonlib.utils.byte_word_values import signed8, signed16, signed5 -from dragonpy.components.MC6809data.MC6809_op_data import ( - REG_A, REG_B, REG_CC, REG_D, REG_DP, REG_PC, - REG_S, REG_U, REG_X, REG_Y -) - - -log = logging.getLogger(__name__) - - -# HTML_TRACE = True -HTML_TRACE = False - - -def opcode(*opcodes): - """A decorator for opcodes""" - def decorator(func): - setattr(func, "_is_opcode", True) - setattr(func, "_opcodes", opcodes) - return func - return decorator - - - - -undefined_reg = UndefinedRegister() - - -class CPUStatusThread(threading.Thread): - """ - Send cycles/sec information via cpu_status_queue to the GUi main thread. - Just ignore if the cpu_status_queue is full. - """ - def __init__(self, cpu, cpu_status_queue): - super(CPUStatusThread, self).__init__(name="CPU-Status-Thread") - self.cpu = cpu - self.cpu_status_queue = cpu_status_queue - - self.last_cpu_cycles = None - self.last_cpu_cycle_update = time.time() - - def _run(self): - while self.cpu.running: - try: - self.cpu_status_queue.put(self.cpu.cycles, block=False) - except queue.Full: -# log.critical("Can't put CPU status: Queue is full.") - pass - time.sleep(0.5) - - def run(self): - try: - self._run() - except: - self.cpu.running = False - _thread.interrupt_main() - raise - - -class CPU(object): - - SWI3_VECTOR = 0xfff2 - SWI2_VECTOR = 0xfff4 - FIRQ_VECTOR = 0xfff6 - IRQ_VECTOR = 0xfff8 - SWI_VECTOR = 0xfffa - NMI_VECTOR = 0xfffc - RESET_VECTOR = 0xfffe - - STARTUP_BURST_COUNT = 100 - - def __init__(self, memory, cfg, cpu_status_queue=None): - self.memory = memory - self.cfg = cfg - - self.running = True - self.cycles = 0 - self.last_op_address = 0 # Store the current run opcode memory address - self.burst_op_count = self.STARTUP_BURST_COUNT - self.sync_op_count = 100 - self.max_burst_count = 10000 - - if cpu_status_queue is not None: - status_thread = CPUStatusThread(self, cpu_status_queue) - status_thread.deamon = True - status_thread.start() - - start_http_control_server(self, cfg) - - self.index_x = ValueStorage16Bit(REG_X, 0) # X - 16 bit index register - self.index_y = ValueStorage16Bit(REG_Y, 0) # Y - 16 bit index register - - self.user_stack_pointer = ValueStorage16Bit(REG_U, 0) # U - 16 bit user-stack pointer - self.user_stack_pointer.counter = 0 - - # S - 16 bit system-stack pointer: - # Position will be set by ROM code after detection of total installed RAM - self.system_stack_pointer = ValueStorage16Bit(REG_S, 0) - - # PC - 16 bit program counter register - self.program_counter = ValueStorage16Bit(REG_PC, 0) - - self.accu_a = ValueStorage8Bit(REG_A, 0) # A - 8 bit accumulator - self.accu_b = ValueStorage8Bit(REG_B, 0) # B - 8 bit accumulator - - # D - 16 bit concatenated reg. (A + B) - self.accu_d = ConcatenatedAccumulator(REG_D, self.accu_a, self.accu_b) - - # DP - 8 bit direct page register - self.direct_page = ValueStorage8Bit(REG_DP, 0) - - # 8 bit condition code register bits: E F H I N Z V C - self.cc = ConditionCodeRegister() - - self.register_str2object = { - REG_X: self.index_x, - REG_Y: self.index_y, - - REG_U: self.user_stack_pointer, - REG_S: self.system_stack_pointer, - - REG_PC: self.program_counter, - - REG_A: self.accu_a, - REG_B: self.accu_b, - REG_D: self.accu_d, - - REG_DP: self.direct_page, - REG_CC: self.cc, - - undefined_reg.name: undefined_reg, # for TFR, EXG - } - -# log.debug("Add opcode functions:") - self.opcode_dict = OpCollection(self).get_opcode_dict() - -# log.debug("illegal ops: %s" % ",".join(["$%x" % c for c in ILLEGAL_OPS])) - # add illegal instruction -# for opcode in ILLEGAL_OPS: -# self.opcode_dict[opcode] = IllegalInstruction(self, opcode) - - def get_state(self): - """ - used in unittests - """ - return { - REG_X: self.index_x.get(), - REG_Y: self.index_y.get(), - - REG_U: self.user_stack_pointer.get(), - REG_S: self.system_stack_pointer.get(), - - REG_PC: self.program_counter.get(), - - REG_A: self.accu_a.get(), - REG_B: self.accu_b.get(), - - REG_DP: self.direct_page.get(), - REG_CC: self.cc.get(), - - "cycles": self.cycles, - "RAM": tuple(self.memory._mem) # copy of array.array() values, - } - - def set_state(self, state): - """ - used in unittests - """ - self.index_x.set(state[REG_X]) - self.index_y.set(state[REG_Y]) - - self.user_stack_pointer.set(state[REG_U]) - self.system_stack_pointer.set(state[REG_S]) - - self.program_counter.set(state[REG_PC]) - - self.accu_a.set(state[REG_A]) - self.accu_b.set(state[REG_B]) - - self.direct_page.set(state[REG_DP]) - self.cc.set(state[REG_CC]) - - self.cycles = state["cycles"] - self.memory.load(address=0x0000, data=state["RAM"]) - - #### - - def reset(self): - log.info("%04x| CPU reset:", self.program_counter.get()) - - self.last_op_address = 0 - - if self.cfg.__class__.__name__ == "SBC09Cfg": - # first op is: - # E400: 1AFF reset orcc #$FF ;Disable interrupts. -# log.debug("\tset CC register to 0xff") -# self.cc.set(0xff) - log.info("\tset CC register to 0x00") - self.cc.set(0x00) - else: -# log.info("\tset cc.F=1: FIRQ interrupt masked") -# self.cc.F = 1 -# -# log.info("\tset cc.I=1: IRQ interrupt masked") -# self.cc.I = 1 - - log.info("\tset E - 0x80 - bit 7 - Entire register state stacked") - self.cc.E = 1 - -# log.debug("\tset PC to $%x" % self.cfg.RESET_VECTOR) -# self.program_counter = self.cfg.RESET_VECTOR - - log.info("\tread reset vector from $%04x", self.RESET_VECTOR) - ea = self.memory.read_word(self.RESET_VECTOR) - log.info("\tset PC to $%04x" % ea) - if ea == 0x0000: - log.critical("Reset vector is $%04x ??? ROM loading in the right place?!?", ea) - self.program_counter.set(ea) - - #### - - def get_and_call_next_op(self): - op_address, opcode = self.read_pc_byte() - try: - self.call_instruction_func(op_address, opcode) - except Exception as err: - try: - msg = "%s - op address: $%04x - opcode: $%02x" % (err, op_address, opcode) - except TypeError: # e.g: op_address or opcode is None - msg = "%s - op address: %r - opcode: %r" % (err, op_address, opcode) - exception = err.__class__ # Use origin Exception class, e.g.: KeyError - six.reraise(exception, exception(msg), sys.exc_info()[2]) - - def quit(self): - log.critical("CPU quit() called.") - self.running = False - - def call_instruction_func(self, op_address, opcode): - self.last_op_address = op_address - try: - cycles, instr_func = self.opcode_dict[opcode] - except KeyError: - msg = "$%x *** UNKNOWN OP $%x" % (op_address, opcode) - log.error(msg) - sys.exit(msg) - - instr_func(opcode) - self.cycles += cycles - - - #### - - quickest_sync_callback_cycles = None - sync_callbacks_cyles = {} - sync_callbacks = [] - def add_sync_callback(self, callback_cycles, callback): - """ Add a CPU cycle triggered callback """ - self.sync_callbacks_cyles[callback] = 0 - self.sync_callbacks.append([callback_cycles, callback]) - if self.quickest_sync_callback_cycles is None or \ - self.quickest_sync_callback_cycles > callback_cycles: - self.quickest_sync_callback_cycles = callback_cycles - - def call_sync_callbacks(self): - """ Call every sync callback with CPU cycles trigger """ - current_cycles = self.cycles - for callback_cycles, callback in self.sync_callbacks: - # get the CPU cycles count of the last call - last_call_cycles = self.sync_callbacks_cyles[callback] - - if current_cycles - last_call_cycles > callback_cycles: - # this callback should be called - - # Save the current cycles, to trigger the next call - self.sync_callbacks_cyles[callback] = self.cycles - - # Call the callback function - callback(current_cycles - last_call_cycles) - - def burst_run(self): - """ Run CPU as fast as Python can... """ - # https://wiki.python.org/moin/PythonSpeed/PerformanceTips#Avoiding_dots... - get_and_call_next_op = self.get_and_call_next_op - - for __ in xrange(self.burst_op_count): - for __ in xrange(self.sync_op_count): - get_and_call_next_op() - - self.call_sync_callbacks() - - delay = 0 - def delayed_burst_run(self, target_cycles_per_sec): - """ Run CPU not faster than given speedlimit """ - old_cycles = self.cycles - start_time = time.time() - - self.burst_run() - - is_duration = time.time() - start_time - new_cycles = self.cycles - old_cycles - try: - is_cycles_per_sec = new_cycles / is_duration - except ZeroDivisionError: - pass - else: - should_burst_duration = is_cycles_per_sec / target_cycles_per_sec - target_duration = should_burst_duration * is_duration - delay = target_duration - is_duration - if delay > 0: - if delay > 1: - self.delay = 1 - else: - self.delay = delay - time.sleep(self.delay) - - self.call_sync_callbacks() - - def calc_new_count(self, burst_count, current_value, target_value): - """ - >>> calc_new_count(burst_count=100, current_value=30, target_value=30) - 100 - >>> calc_new_count(burst_count=100, current_value=40, target_value=20) - 75 - >>> calc_new_count(burst_count=100, current_value=20, target_value=40) - 150 - """ - # log.critical( - # "%i op count current: %.4f target: %.4f", - # self.burst_op_count, current_value, target_value - # ) - try: - new_burst_count = float(burst_count) / float(current_value) * target_value - new_burst_count += 1 # At least we need one loop ;) - except ZeroDivisionError: - return burst_count * 2 - - if new_burst_count > self.max_burst_count: - return self.max_burst_count - - return int((burst_count + new_burst_count) / 2) - - def run(self, max_run_time=0.1, target_cycles_per_sec=None): - now = time.time - - start_time = now() - - if target_cycles_per_sec is not None: - # Run CPU not faster than given speedlimit - self.delayed_burst_run(target_cycles_per_sec) - else: - # Run CPU as fast as Python can... - self.delay = 0 - self.burst_run() - - # Calculate the burst_count new, to hit max_run_time - self.burst_op_count = self.calc_new_count(self.burst_op_count, - current_value=now() - start_time - self.delay, - target_value=max_run_time, - ) - - def test_run(self, start, end, max_ops=1000000): -# log.warning("CPU test_run(): from $%x to $%x" % (start, end)) - self.program_counter.set(start) -# log.debug("-"*79) - - # https://wiki.python.org/moin/PythonSpeed/PerformanceTips#Avoiding_dots... - get_and_call_next_op = self.get_and_call_next_op - program_counter = self.program_counter.get - - for __ in xrange(max_ops): - if program_counter() == end: - return - get_and_call_next_op() - raise RuntimeError("Max ops %i arrived!" % max_ops) - log.critical("Max ops %i arrived!", max_ops) - - def test_run2(self, start, count): -# log.warning("CPU test_run2(): from $%x count: %i" % (start, count)) - self.program_counter.set(start) -# log.debug("-"*79) - - _old_burst_count = self.burst_op_count - self.burst_op_count = count - - _old_sync_count = self.sync_op_count - self.sync_op_count = 1 - - self.burst_run() - - self.burst_op_count = _old_burst_count - self.sync_op_count = _old_sync_count - - - #### - - - @property - def get_info(self): - return "cc=%02x a=%02x b=%02x dp=%02x x=%04x y=%04x u=%04x s=%04x" % ( - self.cc.get(), - self.accu_a.get(), self.accu_b.get(), - self.direct_page.get(), - self.index_x.get(), self.index_y.get(), - self.user_stack_pointer.get(), self.system_stack_pointer.get() - ) - - #### - - def push_byte(self, stack_pointer, byte): - """ pushed a byte onto stack """ - # FIXME: self.system_stack_pointer -= 1 - stack_pointer.decrement(1) - addr = stack_pointer.get() - -# log.info( -# log.error( -# "%x|\tpush $%x to %s stack at $%x\t|%s", -# self.last_op_address, byte, stack_pointer.name, addr, -# self.cfg.mem_info.get_shortest(self.last_op_address) -# ) - self.memory.write_byte(addr, byte) - - def pull_byte(self, stack_pointer): - """ pulled a byte from stack """ - addr = stack_pointer.get() - byte = self.memory.read_byte(addr) -# log.info( -# log.error( -# "%x|\tpull $%x from %s stack at $%x\t|%s", -# self.last_op_address, byte, stack_pointer.name, addr, -# self.cfg.mem_info.get_shortest(self.last_op_address) -# ) - - # FIXME: self.system_stack_pointer += 1 - stack_pointer.increment(1) - - return byte - - def push_word(self, stack_pointer, word): - # FIXME: self.system_stack_pointer -= 2 - stack_pointer.decrement(2) - - addr = stack_pointer.get() -# log.info( -# log.error( -# "%x|\tpush word $%x to %s stack at $%x\t|%s", -# self.last_op_address, word, stack_pointer.name, addr, -# self.cfg.mem_info.get_shortest(self.last_op_address) -# ) - - self.memory.write_word(addr, word) - -# hi, lo = divmod(word, 0x100) -# self.push_byte(hi) -# self.push_byte(lo) - - def pull_word(self, stack_pointer): - addr = stack_pointer.get() - word = self.memory.read_word(addr) -# log.info( -# log.error( -# "%x|\tpull word $%x from %s stack at $%x\t|%s", -# self.last_op_address, word, stack_pointer.name, addr, -# self.cfg.mem_info.get_shortest(self.last_op_address) -# ) - # FIXME: self.system_stack_pointer += 2 - stack_pointer.increment(2) - return word - - #### - - def read_pc_byte(self): - op_addr = self.program_counter.get() - m = self.memory.read_byte(op_addr) - self.program_counter.increment(1) -# log.log(5, "read pc byte: $%02x from $%04x", m, op_addr) - return op_addr, m - - def read_pc_word(self): - op_addr = self.program_counter.get() - m = self.memory.read_word(op_addr) - self.program_counter.increment(2) -# log.log(5, "\tread pc word: $%04x from $%04x", m, op_addr) - return op_addr, m - - #### - - def get_m_immediate(self): - ea, m = self.read_pc_byte() -# log.debug("\tget_m_immediate(): $%x from $%x", m, ea) - return m - - def get_m_immediate_word(self): - ea, m = self.read_pc_word() -# log.debug("\tget_m_immediate_word(): $%x from $%x", m, ea) - return m - - def get_ea_direct(self): - op_addr, m = self.read_pc_byte() - dp = self.direct_page.get() - ea = dp << 8 | m -# log.debug("\tget_ea_direct(): ea = dp << 8 | m => $%x=$%x<<8|$%x", ea, dp, m) - return ea - - def get_ea_m_direct(self): - ea = self.get_ea_direct() - m = self.memory.read_byte(ea) -# log.debug("\tget_ea_m_direct(): ea=$%x m=$%x", ea, m) - return ea, m - - def get_m_direct(self): - ea = self.get_ea_direct() - m = self.memory.read_byte(ea) -# log.debug("\tget_m_direct(): $%x from $%x", m, ea) - return m - - def get_m_direct_word(self): - ea = self.get_ea_direct() - m = self.memory.read_word(ea) -# log.debug("\tget_m_direct(): $%x from $%x", m, ea) - return m - - INDEX_POSTBYTE2STR = { - 0x00: REG_X, # 16 bit index register - 0x01: REG_Y, # 16 bit index register - 0x02: REG_U, # 16 bit user-stack pointer - 0x03: REG_S, # 16 bit system-stack pointer - } - def get_ea_indexed(self): - """ - Calculate the address for all indexed addressing modes - """ - addr, postbyte = self.read_pc_byte() -# log.debug("\tget_ea_indexed(): postbyte: $%02x (%s) from $%04x", -# postbyte, byte2bit_string(postbyte), addr -# ) - - rr = (postbyte >> 5) & 3 - try: - register_str = self.INDEX_POSTBYTE2STR[rr] - except KeyError: - raise RuntimeError("Register $%x doesn't exists! (postbyte: $%x)" % (rr, postbyte)) - - register_obj = self.register_str2object[register_str] - register_value = register_obj.get() -# log.debug("\t%02x == register %s: value $%x", -# rr, register_obj.name, register_value -# ) - - if not is_bit_set(postbyte, bit=7): # bit 7 == 0 - # EA = n, R - use 5-bit offset from post-byte - offset = signed5(postbyte & 0x1f) - ea = register_value + offset -# log.debug( -# "\tget_ea_indexed(): bit 7 == 0: reg.value: $%04x -> ea=$%04x + $%02x = $%04x", -# register_value, register_value, offset, ea -# ) - return ea - - addr_mode = postbyte & 0x0f - self.cycles += 1 - offset = None - # TODO: Optimized this, maybe use a dict mapping... - if addr_mode == 0x0: -# log.debug("\t0000 0x0 | ,R+ | increment by 1") - ea = register_value - register_obj.increment(1) - elif addr_mode == 0x1: -# log.debug("\t0001 0x1 | ,R++ | increment by 2") - ea = register_value - register_obj.increment(2) - self.cycles += 1 - elif addr_mode == 0x2: -# log.debug("\t0010 0x2 | ,R- | decrement by 1") - ea = register_obj.decrement(1) - elif addr_mode == 0x3: -# log.debug("\t0011 0x3 | ,R-- | decrement by 2") - ea = register_obj.decrement(2) - self.cycles += 1 - elif addr_mode == 0x4: -# log.debug("\t0100 0x4 | ,R | No offset") - ea = register_value - elif addr_mode == 0x5: -# log.debug("\t0101 0x5 | B, R | B register offset") - offset = signed8(self.accu_b.get()) - elif addr_mode == 0x6: -# log.debug("\t0110 0x6 | A, R | A register offset") - offset = signed8(self.accu_a.get()) - elif addr_mode == 0x8: -# log.debug("\t1000 0x8 | n, R | 8 bit offset") - offset = signed8(self.read_pc_byte()[1]) - elif addr_mode == 0x9: -# log.debug("\t1001 0x9 | n, R | 16 bit offset") - offset = signed16(self.read_pc_word()[1]) - self.cycles += 1 - elif addr_mode == 0xa: -# log.debug("\t1010 0xa | illegal, set ea=0") - ea = 0 - elif addr_mode == 0xb: -# log.debug("\t1011 0xb | D, R | D register offset") - # D - 16 bit concatenated reg. (A + B) - offset = signed16(self.accu_d.get()) # FIXME: signed16() ok? - self.cycles += 1 - elif addr_mode == 0xc: -# log.debug("\t1100 0xc | n, PCR | 8 bit offset from program counter") - __, value = self.read_pc_byte() - value_signed = signed8(value) - ea = self.program_counter.get() + value_signed -# log.debug("\tea = pc($%x) + $%x = $%x (dez.: %i + %i = %i)", -# self.program_counter, value_signed, ea, -# self.program_counter, value_signed, ea, -# ) - elif addr_mode == 0xd: -# log.debug("\t1101 0xd | n, PCR | 16 bit offset from program counter") - __, value = self.read_pc_word() - value_signed = signed16(value) - ea = self.program_counter.get() + value_signed - self.cycles += 1 -# log.debug("\tea = pc($%x) + $%x = $%x (dez.: %i + %i = %i)", -# self.program_counter, value_signed, ea, -# self.program_counter, value_signed, ea, -# ) - elif addr_mode == 0xe: -# log.error("\tget_ea_indexed(): illegal address mode, use 0xffff") - ea = 0xffff # illegal - elif addr_mode == 0xf: -# log.debug("\t1111 0xf | [n] | 16 bit address - extended indirect") - __, ea = self.read_pc_word() - else: - raise RuntimeError("Illegal indexed addressing mode: $%x" % addr_mode) - - if offset is not None: - ea = register_value + offset -# log.debug("\t$%x + $%x = $%x (dez: %i + %i = %i)", -# register_value, offset, ea, -# register_value, offset, ea -# ) - - ea = ea & 0xffff - - if is_bit_set(postbyte, bit=4): # bit 4 is 1 -> Indirect -# log.debug("\tIndirect addressing: get new ea from $%x", ea) - ea = self.memory.read_word(ea) -# log.debug("\tIndirect addressing: new ea is $%x", ea) - -# log.debug("\tget_ea_indexed(): return ea=$%x", ea) - return ea - - def get_m_indexed(self): - ea = self.get_ea_indexed() - m = self.memory.read_byte(ea) -# log.debug("\tget_m_indexed(): $%x from $%x", m, ea) - return m - - def get_ea_m_indexed(self): - ea = self.get_ea_indexed() - m = self.memory.read_byte(ea) -# log.debug("\tget_ea_m_indexed(): ea = $%x m = $%x", ea, m) - return ea, m - - def get_m_indexed_word(self): - ea = self.get_ea_indexed() - m = self.memory.read_word(ea) -# log.debug("\tget_m_indexed_word(): $%x from $%x", m, ea) - return m - - def get_ea_extended(self): - """ - extended indirect addressing mode takes a 2-byte value from post-bytes - """ - attr, ea = self.read_pc_word() -# log.debug("\tget_ea_extended() ea=$%x from $%x", ea, attr) - return ea - - def get_m_extended(self): - ea = self.get_ea_extended() - m = self.memory.read_byte(ea) -# log.debug("\tget_m_extended(): $%x from $%x", m, ea) - return m - - def get_ea_m_extended(self): - ea = self.get_ea_extended() - m = self.memory.read_byte(ea) -# log.debug("\tget_m_extended(): ea = $%x m = $%x", ea, m) - return ea, m - - def get_m_extended_word(self): - ea = self.get_ea_extended() - m = self.memory.read_word(ea) -# log.debug("\tget_m_extended_word(): $%x from $%x", m, ea) - return m - - def get_ea_relative(self): - addr, x = self.read_pc_byte() - x = signed8(x) - ea = self.program_counter.get() + x -# log.debug("\tget_ea_relative(): ea = $%x + %i = $%x \t| %s", -# self.program_counter, x, ea, -# self.cfg.mem_info.get_shortest(ea) -# ) - return ea - - def get_ea_relative_word(self): - addr, x = self.read_pc_word() - ea = self.program_counter.get() + x -# log.debug("\tget_ea_relative_word(): ea = $%x + %i = $%x \t| %s", -# self.program_counter, x, ea, -# self.cfg.mem_info.get_shortest(ea) -# ) - return ea - - #### Op methods: - - @opcode( - 0x10, # PAGE 2 instructions - 0x11, # PAGE 3 instructions - ) - def instruction_PAGE(self, opcode): - """ call op from page 2 or 3 """ - op_address, opcode2 = self.read_pc_byte() - paged_opcode = opcode * 256 + opcode2 -# log.debug("$%x *** call paged opcode $%x" % ( -# self.program_counter, paged_opcode -# )) - self.call_instruction_func(op_address - 1, paged_opcode) - - @opcode(# Add B accumulator to X (unsigned) - 0x3a, # ABX (inherent) - ) - def instruction_ABX(self, opcode): - """ - Add the 8-bit unsigned value in accumulator B into index register X. - - source code forms: ABX - - CC bits "HNZVC": ----- - """ - old = self.index_x.get() - b = self.accu_b.get() - new = self.index_x.increment(b) -# log.debug("%x %02x ABX: X($%x) += B($%x) = $%x" % ( -# self.program_counter, opcode, -# old, b, new -# )) - - @opcode(# Add memory to accumulator with carry - 0x89, 0x99, 0xa9, 0xb9, # ADCA (immediate, direct, indexed, extended) - 0xc9, 0xd9, 0xe9, 0xf9, # ADCB (immediate, direct, indexed, extended) - ) - def instruction_ADC(self, opcode, m, register): - """ - Adds the contents of the C (carry) bit and the memory byte into an 8-bit - accumulator. - - source code forms: ADCA P; ADCB P - - CC bits "HNZVC": aaaaa - """ - a = register.get() - r = a + m + self.cc.C - register.set(r) -# log.debug("$%x %02x ADC %s: %i + %i + %i = %i (=$%x)" % ( -# self.program_counter, opcode, register.name, -# a, m, self.cc.C, r, r -# )) - self.cc.clear_HNZVC() - self.cc.update_HNZVC_8(a, m, r) - - @opcode(# Add memory to D accumulator - 0xc3, 0xd3, 0xe3, 0xf3, # ADDD (immediate, direct, indexed, extended) - ) - def instruction_ADD16(self, opcode, m, register): - """ - Adds the 16-bit memory value into the 16-bit accumulator - - source code forms: ADDD P - - CC bits "HNZVC": -aaaa - """ - assert register.WIDTH == 16 - old = register.get() - r = old + m - register.set(r) -# log.debug("$%x %02x %02x ADD16 %s: $%02x + $%02x = $%02x" % ( -# self.program_counter, opcode, m, -# register.name, -# old, m, r -# )) - self.cc.clear_NZVC() - self.cc.update_NZVC_16(old, m, r) - - @opcode(# Add memory to accumulator - 0x8b, 0x9b, 0xab, 0xbb, # ADDA (immediate, direct, indexed, extended) - 0xcb, 0xdb, 0xeb, 0xfb, # ADDB (immediate, direct, indexed, extended) - ) - def instruction_ADD8(self, opcode, m, register): - """ - Adds the memory byte into an 8-bit accumulator. - - source code forms: ADDA P; ADDB P - - CC bits "HNZVC": aaaaa - """ - assert register.WIDTH == 8 - old = register.get() - r = old + m - register.set(r) -# log.debug("$%x %02x %02x ADD8 %s: $%02x + $%02x = $%02x" % ( -# self.program_counter, opcode, m, -# register.name, -# old, m, r -# )) - self.cc.clear_HNZVC() - self.cc.update_HNZVC_8(old, m, r) - - @opcode(0xf, 0x6f, 0x7f) # CLR (direct, indexed, extended) - def instruction_CLR_memory(self, opcode, ea): - """ - Clear memory location - source code forms: CLR - CC bits "HNZVC": -0100 - """ - self.cc.update_0100() - return ea, 0x00 - - @opcode(0x4f, 0x5f) # CLRA / CLRB (inherent) - def instruction_CLR_register(self, opcode, register): - """ - Clear accumulator A or B - - source code forms: CLRA; CLRB - CC bits "HNZVC": -0100 - """ - register.set(0x00) - self.cc.update_0100() - - def COM(self, value): - """ - CC bits "HNZVC": -aa01 - """ - value = ~value # the bits of m inverted - self.cc.clear_NZ() - self.cc.update_NZ01_8(value) - return value - - @opcode(# Complement memory location - 0x3, 0x63, 0x73, # COM (direct, indexed, extended) - ) - def instruction_COM_memory(self, opcode, ea, m): - """ - Replaces the contents of memory location M with its logical complement. - source code forms: COM Q - """ - r = self.COM(value=m) -# log.debug("$%x COM memory $%x to $%x" % ( -# self.program_counter, m, r, -# )) - return ea, r & 0xff - - @opcode(# Complement accumulator - 0x43, # COMA (inherent) - 0x53, # COMB (inherent) - ) - def instruction_COM_register(self, opcode, register): - """ - Replaces the contents of accumulator A or B with its logical complement. - source code forms: COMA; COMB - """ - register.set(self.COM(value=register.get())) -# log.debug("$%x COM %s" % ( -# self.program_counter, register.name, -# )) - - @opcode(# Decimal adjust A accumulator - 0x19, # DAA (inherent) - ) - def instruction_DAA(self, opcode): - """ - The sequence of a single-byte add instruction on accumulator A (either - ADDA or ADCA) and a following decimal addition adjust instruction - results in a BCD addition with an appropriate carry bit. Both values to - be added must be in proper BCD form (each nibble such that: 0 <= nibble - <= 9). Multiple-precision addition must add the carry generated by this - decimal addition adjust into the next higher digit during the add - operation (ADCA) immediately prior to the next decimal addition adjust. - - source code forms: DAA - - CC bits "HNZVC": -aa0a - - Operation: - ACCA' ← ACCA + CF(MSN):CF(LSN) - - where CF is a Correction Factor, as follows: - the CF for each nibble (BCD) digit is determined separately, - and is either 6 or 0. - - Least Significant Nibble - CF(LSN) = 6 IFF 1) C = 1 - or 2) LSN > 9 - - Most Significant Nibble - CF(MSN) = 6 IFF 1) C = 1 - or 2) MSN > 9 - or 3) MSN > 8 and LSN > 9 - - Condition Codes: - H - Not affected. - N - Set if the result is negative; cleared otherwise. - Z - Set if the result is zero; cleared otherwise. - V - Undefined. - C - Set if a carry is generated or if the carry bit was set before the operation; cleared otherwise. - """ - a = self.accu_a.get() - - correction_factor = 0 - a_hi = a & 0xf0 # MSN - Most Significant Nibble - a_lo = a & 0x0f # LSN - Least Significant Nibble - - if a_lo > 0x09 or self.cc.H: # cc & 0x20: - correction_factor |= 0x06 - - if a_hi > 0x80 and a_lo > 0x09: - correction_factor |= 0x60 - - if a_hi > 0x90 or self.cc.C: # cc & 0x01: - correction_factor |= 0x60 - - new_value = correction_factor + a - self.accu_a.set(new_value) - - self.cc.clear_NZ() # V is undefined - self.cc.update_NZC_8(new_value) - - def DEC(self, a): - """ - Subtract one from the register. The carry bit is not affected, thus - allowing this instruction to be used as a loop counter in multiple- - precision computations. When operating on unsigned values, only BEQ and - BNE branches can be expected to behave consistently. When operating on - twos complement values, all signed branches are available. - - source code forms: DEC Q; DECA; DECB - - CC bits "HNZVC": -aaa- - """ - r = a - 1 - self.cc.clear_NZV() - self.cc.update_NZ_8(r) - if r == 0x7f: - self.cc.V = 1 - return r - - @opcode(0xa, 0x6a, 0x7a) # DEC (direct, indexed, extended) - def instruction_DEC_memory(self, opcode, ea, m): - """ Decrement memory location """ - r = self.DEC(m) -# log.debug("$%x DEC memory value $%x -1 = $%x and write it to $%x \t| %s" % ( -# self.program_counter, -# m, r, ea, -# self.cfg.mem_info.get_shortest(ea) -# )) - return ea, r & 0xff - - @opcode(0x4a, 0x5a) # DECA / DECB (inherent) - def instruction_DEC_register(self, opcode, register): - """ Decrement accumulator """ - a = register.get() - r = self.DEC(a) -# log.debug("$%x DEC %s value $%x -1 = $%x" % ( -# self.program_counter, -# register.name, a, r -# )) - register.set(r) - - def INC(self, a): - r = a + 1 - self.cc.clear_NZV() - self.cc.update_NZ_8(r) - if r == 0x80: - self.cc.V = 1 - return r - - @opcode(# Increment accumulator - 0x4c, # INCA (inherent) - 0x5c, # INCB (inherent) - ) - def instruction_INC_register(self, opcode, register): - """ - Adds to the register. The carry bit is not affected, thus allowing this - instruction to be used as a loop counter in multiple-precision - computations. When operating on unsigned values, only the BEQ and BNE - branches can be expected to behave consistently. When operating on twos - complement values, all signed branches are correctly available. - - source code forms: INC Q; INCA; INCB - - CC bits "HNZVC": -aaa- - """ - a = register.get() - r = self.INC(a) - r = register.set(r) - - @opcode(# Increment memory location - 0xc, 0x6c, 0x7c, # INC (direct, indexed, extended) - ) - def instruction_INC_memory(self, opcode, ea, m): - """ - Adds to the register. The carry bit is not affected, thus allowing this - instruction to be used as a loop counter in multiple-precision - computations. When operating on unsigned values, only the BEQ and BNE - branches can be expected to behave consistently. When operating on twos - complement values, all signed branches are correctly available. - - source code forms: INC Q; INCA; INCB - - CC bits "HNZVC": -aaa- - """ - r = self.INC(m) - return ea, r & 0xff - - @opcode(# Load effective address into an indexable register - 0x32, # LEAS (indexed) - 0x33, # LEAU (indexed) - ) - def instruction_LEA_pointer(self, opcode, ea, register): - """ - Calculates the effective address from the indexed addressing mode and - places the address in an indexable register. - - LEAU and LEAS do not affect the Z bit to allow cleaning up the stack - while returning the Z bit as a parameter to a calling routine, and also - for MC6800 INS/DES compatibility. - - LEAU -10,U U-10 -> U Subtracts 10 from U - LEAS -10,S S-10 -> S Used to reserve area on stack - LEAS 10,S S+10 -> S Used to 'clean up' stack - LEAX 5,S S+5 -> X Transfers as well as adds - - source code forms: LEAS, LEAU - - CC bits "HNZVC": ----- - """ -# log.debug( -# "$%04x LEA %s: Set %s to $%04x \t| %s" % ( -# self.program_counter, -# register.name, register.name, ea, -# self.cfg.mem_info.get_shortest(ea) -# )) - register.set(ea) - - @opcode(# Load effective address into an indexable register - 0x30, # LEAX (indexed) - 0x31, # LEAY (indexed) - ) - def instruction_LEA_register(self, opcode, ea, register): - """ see instruction_LEA_pointer - - LEAX and LEAY affect the Z (zero) bit to allow use of these registers - as counters and for MC6800 INX/DEX compatibility. - - LEAX 10,X X+10 -> X Adds 5-bit constant 10 to X - LEAX 500,X X+500 -> X Adds 16-bit constant 500 to X - LEAY A,Y Y+A -> Y Adds 8-bit accumulator to Y - LEAY D,Y Y+D -> Y Adds 16-bit D accumulator to Y - - source code forms: LEAX, LEAY - - CC bits "HNZVC": --a-- - """ -# log.debug("$%04x LEA %s: Set %s to $%04x \t| %s" % ( -# self.program_counter, -# register.name, register.name, ea, -# self.cfg.mem_info.get_shortest(ea) -# )) - register.set(ea) - self.cc.Z = 0 - self.cc.set_Z16(ea) - - @opcode(# Unsigned multiply (A * B ? D) - 0x3d, # MUL (inherent) - ) - def instruction_MUL(self, opcode): - """ - Multiply the unsigned binary numbers in the accumulators and place the - result in both accumulators (ACCA contains the most-significant byte of - the result). Unsigned multiply allows multiple-precision operations. - - The C (carry) bit allows rounding the most-significant byte through the - sequence: MUL, ADCA #0. - - source code forms: MUL - - CC bits "HNZVC": --a-a - """ - r = self.accu_a.get() * self.accu_b.get() - self.accu_d.set(r) - self.cc.Z = 1 if r == 0 else 0 - self.cc.C = 1 if r & 0x80 else 0 - - @opcode(# Negate accumulator - 0x40, # NEGA (inherent) - 0x50, # NEGB (inherent) - ) - def instruction_NEG_register(self, opcode, register): - """ - Replaces the register with its twos complement. The C (carry) bit - represents a borrow and is set to the inverse of the resulting binary - carry. Note that 80 16 is replaced by itself and only in this case is - the V (overflow) bit set. The value 00 16 is also replaced by itself, - and only in this case is the C (carry) bit cleared. - - source code forms: NEG Q; NEGA; NEG B - - CC bits "HNZVC": uaaaa - """ - x = register.get() - r = x * -1 # same as: r = ~x + 1 - register.set(r) -# log.debug("$%04x NEG %s $%02x to $%02x" % ( -# self.program_counter, register.name, x, r, -# )) - self.cc.clear_NZVC() - self.cc.update_NZVC_8(0, x, r) - - _wrong_NEG = 0 - @opcode(0x0, 0x60, 0x70) # NEG (direct, indexed, extended) - def instruction_NEG_memory(self, opcode, ea, m): - """ Negate memory """ - if opcode == 0x0 and ea == 0x0 and m == 0x0: - self._wrong_NEG += 1 - if self._wrong_NEG > 10: - raise RuntimeError("Wrong PC ???") - else: - self._wrong_NEG = 0 - - r = m * -1 # same as: r = ~m + 1 - -# log.debug("$%04x NEG $%02x from %04x to $%02x" % ( -# self.program_counter, m, ea, r, -# )) - self.cc.clear_NZVC() - self.cc.update_NZVC_8(0, m, r) - return ea, r & 0xff - - @opcode(0x12) # NOP (inherent) - def instruction_NOP(self, opcode): - """ - No operation - - source code forms: NOP - - CC bits "HNZVC": ----- - """ -# log.debug("\tNOP") - - - - @opcode(# Push A, B, CC, DP, D, X, Y, U, or PC onto stack - 0x36, # PSHU (immediate) - 0x34, # PSHS (immediate) - ) - def instruction_PSH(self, opcode, m, register): - """ - All, some, or none of the processor registers are pushed onto stack - (with the exception of stack pointer itself). - - A single register may be placed on the stack with the condition codes - set by doing an autodecrement store onto the stack (example: STX ,--S). - - source code forms: b7 b6 b5 b4 b3 b2 b1 b0 PC U Y X DP B A CC push order - -> - - CC bits "HNZVC": ----- - """ - assert register in (self.system_stack_pointer, self.user_stack_pointer) - - def push(register_str, stack_pointer): - register_obj = self.register_str2object[register_str] - data = register_obj.get() - -# log.debug("\tpush %s with data $%x", register_obj.name, data) - - if register_obj.WIDTH == 8: - self.push_byte(register, data) - else: - assert register_obj.WIDTH == 16 - self.push_word(register, data) - -# log.debug("$%x PSH%s post byte: $%x", self.program_counter, register.name, m) - - # m = postbyte - if m & 0x80: push(REG_PC, register) # 16 bit program counter register - if m & 0x40: push(REG_U, register) # 16 bit user-stack pointer - if m & 0x20: push(REG_Y, register) # 16 bit index register - if m & 0x10: push(REG_X, register) # 16 bit index register - if m & 0x08: push(REG_DP, register) # 8 bit direct page register - if m & 0x04: push(REG_B, register) # 8 bit accumulator - if m & 0x02: push(REG_A, register) # 8 bit accumulator - if m & 0x01: push(REG_CC, register) # 8 bit condition code register - - - @opcode(# Pull A, B, CC, DP, D, X, Y, U, or PC from stack - 0x37, # PULU (immediate) - 0x35, # PULS (immediate) - ) - def instruction_PUL(self, opcode, m, register): - """ - All, some, or none of the processor registers are pulled from stack - (with the exception of stack pointer itself). - - A single register may be pulled from the stack with condition codes set - by doing an autoincrement load from the stack (example: LDX ,S++). - - source code forms: b7 b6 b5 b4 b3 b2 b1 b0 PC U Y X DP B A CC = pull - order - - CC bits "HNZVC": ccccc - """ - assert register in (self.system_stack_pointer, self.user_stack_pointer) - - def pull(register_str, stack_pointer): - reg_obj = self.register_str2object[register_str] - - reg_width = reg_obj.WIDTH # 8 / 16 - if reg_width == 8: - data = self.pull_byte(stack_pointer) - else: - assert reg_width == 16 - data = self.pull_word(stack_pointer) - - reg_obj.set(data) - -# log.debug("$%x PUL%s:", self.program_counter, register.name) - - # m = postbyte - if m & 0x01: pull(REG_CC, register) # 8 bit condition code register - if m & 0x02: pull(REG_A, register) # 8 bit accumulator - if m & 0x04: pull(REG_B, register) # 8 bit accumulator - if m & 0x08: pull(REG_DP, register) # 8 bit direct page register - if m & 0x10: pull(REG_X, register) # 16 bit index register - if m & 0x20: pull(REG_Y, register) # 16 bit index register - if m & 0x40: pull(REG_U, register) # 16 bit user-stack pointer - if m & 0x80: pull(REG_PC, register) # 16 bit program counter register - - @opcode(# Subtract memory from accumulator with borrow - 0x82, 0x92, 0xa2, 0xb2, # SBCA (immediate, direct, indexed, extended) - 0xc2, 0xd2, 0xe2, 0xf2, # SBCB (immediate, direct, indexed, extended) - ) - def instruction_SBC(self, opcode, m, register): - """ - Subtracts the contents of memory location M and the borrow (in the C - (carry) bit) from the contents of the designated 8-bit register, and - places the result in that register. The C bit represents a borrow and is - set to the inverse of the resulting binary carry. - - source code forms: SBCA P; SBCB P - - CC bits "HNZVC": uaaaa - """ - a = register.get() - r = a - m - self.cc.C - register.set(r) -# log.debug("$%x %02x SBC %s: %i - %i - %i = %i (=$%x)" % ( -# self.program_counter, opcode, register.name, -# a, m, self.cc.C, r, r -# )) - self.cc.clear_NZVC() - self.cc.update_NZVC_8(a, m, r) - - @opcode(# Sign Extend B accumulator into A accumulator - 0x1d, # SEX (inherent) - ) - def instruction_SEX(self, opcode): - """ - This instruction transforms a twos complement 8-bit value in accumulator - B into a twos complement 16-bit value in the D accumulator. - - source code forms: SEX - - CC bits "HNZVC": -aa0- - - // 0x1d SEX inherent - case 0x1d: - WREG_A = (RREG_B & 0x80) ? 0xff : 0; - CLR_NZ; - SET_NZ16(REG_D); - peek_byte(cpu, REG_PC); - - #define SIGNED(b) ((Word)(b&0x80?b|0xff00:b)) - case 0x1D: /* SEX */ tw=SIGNED(ibreg); SETNZ16(tw) SETDREG(tw) break; - """ - b = self.accu_b.get() - if b & 0x80 == 0: - self.accu_a.set(0x00) - - d = self.accu_d.get() - -# log.debug("SEX: b=$%x ; $%x&0x80=$%x ; d=$%x", b, b, (b & 0x80), d) - - self.cc.clear_NZ() - self.cc.update_NZ_16(d) - - - - @opcode(# Subtract memory from accumulator - 0x80, 0x90, 0xa0, 0xb0, # SUBA (immediate, direct, indexed, extended) - 0xc0, 0xd0, 0xe0, 0xf0, # SUBB (immediate, direct, indexed, extended) - 0x83, 0x93, 0xa3, 0xb3, # SUBD (immediate, direct, indexed, extended) - ) - def instruction_SUB(self, opcode, m, register): - """ - Subtracts the value in memory location M from the contents of a - register. The C (carry) bit represents a borrow and is set to the - inverse of the resulting binary carry. - - source code forms: SUBA P; SUBB P; SUBD P - - CC bits "HNZVC": uaaaa - """ - r = register.get() - r_new = r - m - register.set(r_new) -# log.debug("$%x SUB8 %s: $%x - $%x = $%x (dez.: %i - %i = %i)" % ( -# self.program_counter, register.name, -# r, m, r_new, -# r, m, r_new, -# )) - self.cc.clear_NZVC() - if register.WIDTH == 8: - self.cc.update_NZVC_8(r, m, r_new) - else: - assert register.WIDTH == 16 - self.cc.update_NZVC_16(r, m, r_new) - - - # ---- Register Changes - FIXME: Better name for this section?!? ---- - - REGISTER_BIT2STR = { - 0x0: REG_D, # 0000 - 16 bit concatenated reg.(A B) - 0x1: REG_X, # 0001 - 16 bit index register - 0x2: REG_Y, # 0010 - 16 bit index register - 0x3: REG_U, # 0011 - 16 bit user-stack pointer - 0x4: REG_S, # 0100 - 16 bit system-stack pointer - 0x5: REG_PC, # 0101 - 16 bit program counter register - 0x6: undefined_reg.name, # undefined - 0x7: undefined_reg.name, # undefined - 0x8: REG_A, # 1000 - 8 bit accumulator - 0x9: REG_B, # 1001 - 8 bit accumulator - 0xa: REG_CC, # 1010 - 8 bit condition code register as flags - 0xb: REG_DP, # 1011 - 8 bit direct page register - 0xc: undefined_reg.name, # undefined - 0xd: undefined_reg.name, # undefined - 0xe: undefined_reg.name, # undefined - 0xf: undefined_reg.name, # undefined - } - - def _get_register_obj(self, addr): - addr_str = self.REGISTER_BIT2STR[addr] - reg_obj = self.register_str2object[addr_str] -# log.debug("get register obj: addr: $%x addr_str: %s -> register: %s" % ( -# addr, addr_str, reg_obj.name -# )) -# log.debug(repr(self.register_str2object)) - return reg_obj - - def _get_register_and_value(self, addr): - reg = self._get_register_obj(addr) - reg_value = reg.get() - return reg, reg_value - - def _convert_differend_width(self, src_reg, src_value, dst_reg): - """ - e.g.: - 8bit $cd TFR into 16bit, results in: $cd00 - 16bit $1234 TFR into 8bit, results in: $34 - - TODO: verify this behaviour on real hardware - see: http://archive.worldofdragon.org/phpBB3/viewtopic.php?f=8&t=4886 - """ - if src_reg.WIDTH == 8 and dst_reg.WIDTH == 16: - # e.g.: $cd -> $ffcd - src_value += 0xff00 - elif src_reg.WIDTH == 16 and dst_reg.WIDTH == 8: - # e.g.: $1234 -> $34 - src_value = src_value | 0xff00 - return src_value - - @opcode(0x1f) # TFR (immediate) - def instruction_TFR(self, opcode, m): - """ - source code forms: TFR R1, R2 - CC bits "HNZVC": ccccc - """ - high, low = divmod(m, 16) - src_reg, src_value = self._get_register_and_value(high) - dst_reg = self._get_register_obj(low) - src_value = self._convert_differend_width(src_reg, src_value, dst_reg) - dst_reg.set(src_value) -# log.debug("\tTFR: Set %s to $%x from %s", -# dst_reg, src_value, src_reg.name -# ) - - @opcode(# Exchange R1 with R2 - 0x1e, # EXG (immediate) - ) - def instruction_EXG(self, opcode, m): - """ - source code forms: EXG R1,R2 - CC bits "HNZVC": ccccc - """ - high, low = divmod(m, 0x10) - reg1, reg1_value = self._get_register_and_value(high) - reg2, reg2_value = self._get_register_and_value(low) - - new_reg1_value = self._convert_differend_width(reg2, reg2_value, reg1) - new_reg2_value = self._convert_differend_width(reg1, reg1_value, reg2) - - reg1.set(new_reg1_value) - reg2.set(new_reg2_value) - -# log.debug("\tEXG: %s($%x) <-> %s($%x)", -# reg1.name, reg1_value, reg2.name, reg2_value -# ) - - # ---- Store / Load ---- - - - @opcode(# Load register from memory - 0xcc, 0xdc, 0xec, 0xfc, # LDD (immediate, direct, indexed, extended) - 0x10ce, 0x10de, 0x10ee, 0x10fe, # LDS (immediate, direct, indexed, extended) - 0xce, 0xde, 0xee, 0xfe, # LDU (immediate, direct, indexed, extended) - 0x8e, 0x9e, 0xae, 0xbe, # LDX (immediate, direct, indexed, extended) - 0x108e, 0x109e, 0x10ae, 0x10be, # LDY (immediate, direct, indexed, extended) - ) - def instruction_LD16(self, opcode, m, register): - """ - Load the contents of the memory location M:M+1 into the designated - 16-bit register. - - source code forms: LDD P; LDX P; LDY P; LDS P; LDU P - - CC bits "HNZVC": -aa0- - """ -# log.debug("$%x LD16 set %s to $%x \t| %s" % ( -# self.program_counter, -# register.name, m, -# self.cfg.mem_info.get_shortest(m) -# )) - register.set(m) - self.cc.clear_NZV() - self.cc.update_NZ_16(m) - - @opcode(# Load accumulator from memory - 0x86, 0x96, 0xa6, 0xb6, # LDA (immediate, direct, indexed, extended) - 0xc6, 0xd6, 0xe6, 0xf6, # LDB (immediate, direct, indexed, extended) - ) - def instruction_LD8(self, opcode, m, register): - """ - Loads the contents of memory location M into the designated register. - - source code forms: LDA P; LDB P - - CC bits "HNZVC": -aa0- - """ -# log.debug("$%x LD8 %s = $%x" % ( -# self.program_counter, -# register.name, m, -# )) - register.set(m) - self.cc.clear_NZV() - self.cc.update_NZ_8(m) - - @opcode(# Store register to memory - 0xdd, 0xed, 0xfd, # STD (direct, indexed, extended) - 0x10df, 0x10ef, 0x10ff, # STS (direct, indexed, extended) - 0xdf, 0xef, 0xff, # STU (direct, indexed, extended) - 0x9f, 0xaf, 0xbf, # STX (direct, indexed, extended) - 0x109f, 0x10af, 0x10bf, # STY (direct, indexed, extended) - ) - def instruction_ST16(self, opcode, ea, register): - """ - Writes the contents of a 16-bit register into two consecutive memory - locations. - - source code forms: STD P; STX P; STY P; STS P; STU P - - CC bits "HNZVC": -aa0- - """ - value = register.get() -# log.debug("$%x ST16 store value $%x from %s at $%x \t| %s" % ( -# self.program_counter, -# value, register.name, ea, -# self.cfg.mem_info.get_shortest(ea) -# )) - self.cc.clear_NZV() - self.cc.update_NZ_16(value) - return ea, value # write word to Memory - - @opcode(# Store accumulator to memory - 0x97, 0xa7, 0xb7, # STA (direct, indexed, extended) - 0xd7, 0xe7, 0xf7, # STB (direct, indexed, extended) - ) - def instruction_ST8(self, opcode, ea, register): - """ - Writes the contents of an 8-bit register into a memory location. - - source code forms: STA P; STB P - - CC bits "HNZVC": -aa0- - """ - value = register.get() -# log.debug("$%x ST8 store value $%x from %s at $%x \t| %s" % ( -# self.program_counter, -# value, register.name, ea, -# self.cfg.mem_info.get_shortest(ea) -# )) - self.cc.clear_NZV() - self.cc.update_NZ_8(value) - return ea, value # write byte to Memory - - - # ---- Logical Operations ---- - - - @opcode(# AND memory with accumulator - 0x84, 0x94, 0xa4, 0xb4, # ANDA (immediate, direct, indexed, extended) - 0xc4, 0xd4, 0xe4, 0xf4, # ANDB (immediate, direct, indexed, extended) - ) - def instruction_AND(self, opcode, m, register): - """ - Performs the logical AND operation between the contents of an - accumulator and the contents of memory location M and the result is - stored in the accumulator. - - source code forms: ANDA P; ANDB P - - CC bits "HNZVC": -aa0- - """ - a = register.get() - r = a & m - register.set(r) - self.cc.clear_NZV() - self.cc.update_NZ_8(r) -# log.debug("\tAND %s: %i & %i = %i", -# register.name, a, m, r -# ) - - @opcode(# Exclusive OR memory with accumulator - 0x88, 0x98, 0xa8, 0xb8, # EORA (immediate, direct, indexed, extended) - 0xc8, 0xd8, 0xe8, 0xf8, # EORB (immediate, direct, indexed, extended) - ) - def instruction_EOR(self, opcode, m, register): - """ - The contents of memory location M is exclusive ORed into an 8-bit - register. - - source code forms: EORA P; EORB P - - CC bits "HNZVC": -aa0- - """ - a = register.get() - r = a ^ m - register.set(r) - self.cc.clear_NZV() - self.cc.update_NZ_8(r) -# log.debug("\tEOR %s: %i ^ %i = %i", -# register.name, a, m, r -# ) - - @opcode(# OR memory with accumulator - 0x8a, 0x9a, 0xaa, 0xba, # ORA (immediate, direct, indexed, extended) - 0xca, 0xda, 0xea, 0xfa, # ORB (immediate, direct, indexed, extended) - ) - def instruction_OR(self, opcode, m, register): - """ - Performs an inclusive OR operation between the contents of accumulator A - or B and the contents of memory location M and the result is stored in - accumulator A or B. - - source code forms: ORA P; ORB P - - CC bits "HNZVC": -aa0- - """ - a = register.get() - r = a | m - register.set(r) - self.cc.clear_NZV() - self.cc.update_NZ_8(r) -# log.debug("$%04x OR %s: %02x | %02x = %02x", -# self.program_counter, register.name, a, m, r -# ) - - - # ---- CC manipulation ---- - - - @opcode(# AND condition code register - 0x1c, # ANDCC (immediate) - ) - def instruction_ANDCC(self, opcode, m, register): - """ - Performs a logical AND between the condition code register and the - immediate byte specified in the instruction and places the result in the - condition code register. - - source code forms: ANDCC #xx - - CC bits "HNZVC": ddddd - """ - assert register == self.cc - - old_cc = self.cc.get() - new_cc = old_cc & m - self.cc.set(new_cc) -# log.debug("\tANDCC: $%x AND $%x = $%x | set CC to %s", -# old_cc, m, new_cc, self.cc.get_info -# ) - - @opcode(# OR condition code register - 0x1a, # ORCC (immediate) - ) - def instruction_ORCC(self, opcode, m, register): - """ - Performs an inclusive OR operation between the contents of the condition - code registers and the immediate value, and the result is placed in the - condition code register. This instruction may be used to set interrupt - masks (disable interrupts) or any other bit(s). - - source code forms: ORCC #XX - - CC bits "HNZVC": ddddd - """ - assert register == self.cc - - old_cc = self.cc.get() - new_cc = old_cc | m - self.cc.set(new_cc) -# log.debug("\tORCC: $%x OR $%x = $%x | set CC to %s", -# old_cc, m, new_cc, self.cc.get_info -# ) - - # ---- Test Instructions ---- - - - @opcode(# Compare memory from stack pointer - 0x1083, 0x1093, 0x10a3, 0x10b3, # CMPD (immediate, direct, indexed, extended) - 0x118c, 0x119c, 0x11ac, 0x11bc, # CMPS (immediate, direct, indexed, extended) - 0x1183, 0x1193, 0x11a3, 0x11b3, # CMPU (immediate, direct, indexed, extended) - 0x8c, 0x9c, 0xac, 0xbc, # CMPX (immediate, direct, indexed, extended) - 0x108c, 0x109c, 0x10ac, 0x10bc, # CMPY (immediate, direct, indexed, extended) - ) - def instruction_CMP16(self, opcode, m, register): - """ - Compares the 16-bit contents of the concatenated memory locations M:M+1 - to the contents of the specified register and sets the appropriate - condition codes. Neither the memory locations nor the specified register - is modified unless autoincrement or autodecrement are used. The carry - flag represents a borrow and is set to the inverse of the resulting - binary carry. - - source code forms: CMPD P; CMPX P; CMPY P; CMPU P; CMPS P - - CC bits "HNZVC": -aaaa - """ - r = register.get() - r_new = r - m -# log.warning("$%x CMP16 %s $%x - $%x = $%x" % ( -# self.program_counter, -# register.name, -# r, m, r_new, -# )) - self.cc.clear_NZVC() - self.cc.update_NZVC_16(r, m, r_new) - - @opcode(# Compare memory from accumulator - 0x81, 0x91, 0xa1, 0xb1, # CMPA (immediate, direct, indexed, extended) - 0xc1, 0xd1, 0xe1, 0xf1, # CMPB (immediate, direct, indexed, extended) - ) - def instruction_CMP8(self, opcode, m, register): - """ - Compares the contents of memory location to the contents of the - specified register and sets the appropriate condition codes. Neither - memory location M nor the specified register is modified. The carry flag - represents a borrow and is set to the inverse of the resulting binary - carry. - - source code forms: CMPA P; CMPB P - - CC bits "HNZVC": uaaaa - """ - r = register.get() - r_new = r - m -# log.warning("$%x CMP8 %s $%x - $%x = $%x" % ( -# self.program_counter, -# register.name, -# r, m, r_new, -# )) - self.cc.clear_NZVC() - self.cc.update_NZVC_8(r, m, r_new) - - - @opcode(# Bit test memory with accumulator - 0x85, 0x95, 0xa5, 0xb5, # BITA (immediate, direct, indexed, extended) - 0xc5, 0xd5, 0xe5, 0xf5, # BITB (immediate, direct, indexed, extended) - ) - def instruction_BIT(self, opcode, m, register): - """ - Performs the logical AND of the contents of accumulator A or B and the - contents of memory location M and modifies the condition codes - accordingly. The contents of accumulator A or B and memory location M - are not affected. - - source code forms: BITA P; BITB P - - CC bits "HNZVC": -aa0- - """ - x = register.get() - r = m & x -# log.debug("$%x BIT update CC with $%x (m:%i & %s:%i)" % ( -# self.program_counter, -# r, m, register.name, x -# )) - self.cc.clear_NZV() - self.cc.update_NZ_8(r) - - @opcode(# Test accumulator - 0x4d, # TSTA (inherent) - 0x5d, # TSTB (inherent) - ) - def instruction_TST_register(self, opcode, register): - """ - Set the N (negative) and Z (zero) bits according to the contents of - accumulator A or B, and clear the V (overflow) bit. The TST instruction - provides only minimum information when testing unsigned values; since no - unsigned value is less than zero, BLO and BLS have no utility. While BHI - could be used after TST, it provides exactly the same control as BNE, - which is preferred. The signed branches are available. - - The MC6800 processor clears the C (carry) bit. - - source code forms: TST Q; TSTA; TSTB - - CC bits "HNZVC": -aa0- - """ - x = register.get() - self.cc.clear_NZV() - self.cc.update_NZ_8(x) - - @opcode(0xd, 0x6d, 0x7d) # TST (direct, indexed, extended) - def instruction_TST_memory(self, opcode, m): - """ Test memory location """ -# log.debug("$%x TST m=$%02x" % ( -# self.program_counter, m -# )) - self.cc.clear_NZV() - self.cc.update_NZ_8(m) - - # ---- Programm Flow Instructions ---- - - - @opcode(# Jump - 0xe, 0x6e, 0x7e, # JMP (direct, indexed, extended) - ) - def instruction_JMP(self, opcode, ea): - """ - Program control is transferred to the effective address. - - source code forms: JMP EA - - CC bits "HNZVC": ----- - """ -# log.info("%x|\tJMP to $%x \t| %s" % ( -# self.last_op_address, -# ea, self.cfg.mem_info.get_shortest(ea) -# )) - self.program_counter.set(ea) - - @opcode(# Return from subroutine - 0x39, # RTS (inherent) - ) - def instruction_RTS(self, opcode): - """ - Program control is returned from the subroutine to the calling program. - The return address is pulled from the stack. - - source code forms: RTS - - CC bits "HNZVC": ----- - """ - ea = self.pull_word(self.system_stack_pointer) -# log.info("%x|\tRTS to $%x \t| %s" % ( -# self.last_op_address, -# ea, -# self.cfg.mem_info.get_shortest(ea) -# )) - self.program_counter.set(ea) - - @opcode( - # Branch to subroutine: - 0x8d, # BSR (relative) - 0x17, # LBSR (relative) - # Jump to subroutine: - 0x9d, 0xad, 0xbd, # JSR (direct, indexed, extended) - ) - def instruction_BSR_JSR(self, opcode, ea): - """ - Program control is transferred to the effective address after storing - the return address on the hardware stack. - - A return from subroutine (RTS) instruction is used to reverse this - process and must be the last instruction executed in a subroutine. - - source code forms: BSR dd; LBSR DDDD; JSR EA - - CC bits "HNZVC": ----- - """ -# log.info("%x|\tJSR/BSR to $%x \t| %s" % ( -# self.last_op_address, -# ea, self.cfg.mem_info.get_shortest(ea) -# )) - self.push_word(self.system_stack_pointer, self.program_counter.get()) - self.program_counter.set(ea) - - - # ---- Branch Instructions ---- - - - @opcode(# Branch if equal - 0x27, # BEQ (relative) - 0x1027, # LBEQ (relative) - ) - def instruction_BEQ(self, opcode, ea): - """ - Tests the state of the Z (zero) bit and causes a branch if it is set. - When used after a subtract or compare operation, this instruction will - branch if the compared values, signed or unsigned, were exactly the - same. - - source code forms: BEQ dd; LBEQ DDDD - - CC bits "HNZVC": ----- - """ - if self.cc.Z == 1: -# log.info("$%x BEQ branch to $%x, because Z==1 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - self.program_counter.set(ea) -# else: -# log.debug("$%x BEQ: don't branch to $%x, because Z==0 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - - @opcode(# Branch if greater than or equal (signed) - 0x2c, # BGE (relative) - 0x102c, # LBGE (relative) - ) - def instruction_BGE(self, opcode, ea): - """ - Causes a branch if the N (negative) bit and the V (overflow) bit are - either both set or both clear. That is, branch if the sign of a valid - twos complement result is, or would be, positive. When used after a - subtract or compare operation on twos complement values, this - instruction will branch if the register was greater than or equal to the - memory register. - - source code forms: BGE dd; LBGE DDDD - - CC bits "HNZVC": ----- - """ - # Note these variantes are the same: - # self.cc.N == self.cc.V - # (self.cc.N ^ self.cc.V) == 0 - # not operator.xor(self.cc.N, self.cc.V) - if self.cc.N == self.cc.V: -# log.info("$%x BGE branch to $%x, because N XOR V == 0 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - self.program_counter.set(ea) -# else: -# log.debug("$%x BGE: don't branch to $%x, because N XOR V != 0 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - - @opcode(# Branch if greater (signed) - 0x2e, # BGT (relative) - 0x102e, # LBGT (relative) - ) - def instruction_BGT(self, opcode, ea): - """ - Causes a branch if the N (negative) bit and V (overflow) bit are either - both set or both clear and the Z (zero) bit is clear. In other words, - branch if the sign of a valid twos complement result is, or would be, - positive and not zero. When used after a subtract or compare operation - on twos complement values, this instruction will branch if the register - was greater than the memory register. - - source code forms: BGT dd; LBGT DDDD - - CC bits "HNZVC": ----- - """ - # Note these variantes are the same: - # not ((self.cc.N ^ self.cc.V) == 1 or self.cc.Z == 1) - # not ((self.cc.N ^ self.cc.V) | self.cc.Z) - # self.cc.N == self.cc.V and self.cc.Z == 0 - # ;) - if not self.cc.Z and self.cc.N == self.cc.V: -# log.info("$%x BGT branch to $%x, because (N==V and Z==0) \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - self.program_counter.set(ea) -# else: -# log.debug("$%x BGT: don't branch to $%x, because (N==V and Z==0) is False \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - - @opcode(# Branch if higher (unsigned) - 0x22, # BHI (relative) - 0x1022, # LBHI (relative) - ) - def instruction_BHI(self, opcode, ea): - """ - Causes a branch if the previous operation caused neither a carry nor a - zero result. When used after a subtract or compare operation on unsigned - binary values, this instruction will branch if the register was higher - than the memory register. - - Generally not useful after INC/DEC, LD/TST, and TST/CLR/COM - instructions. - - source code forms: BHI dd; LBHI DDDD - - CC bits "HNZVC": ----- - """ - if self.cc.C == 0 and self.cc.Z == 0: -# log.info("$%x BHI branch to $%x, because C==0 and Z==0 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - self.program_counter.set(ea) -# else: -# log.debug("$%x BHI: don't branch to $%x, because C and Z not 0 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - - @opcode(# Branch if less than or equal (signed) - 0x2f, # BLE (relative) - 0x102f, # LBLE (relative) - ) - def instruction_BLE(self, opcode, ea): - """ - Causes a branch if the exclusive OR of the N (negative) and V (overflow) - bits is 1 or if the Z (zero) bit is set. That is, branch if the sign of - a valid twos complement result is, or would be, negative. When used - after a subtract or compare operation on twos complement values, this - instruction will branch if the register was less than or equal to the - memory register. - - source code forms: BLE dd; LBLE DDDD - - CC bits "HNZVC": ----- - """ - if (self.cc.N ^ self.cc.V) == 1 or self.cc.Z == 1: -# log.info("$%x BLE branch to $%x, because N^V==1 or Z==1 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - self.program_counter.set(ea) -# else: -# log.debug("$%x BLE: don't branch to $%x, because N^V!=1 and Z!=1 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - - @opcode(# Branch if lower or same (unsigned) - 0x23, # BLS (relative) - 0x1023, # LBLS (relative) - ) - def instruction_BLS(self, opcode, ea): - """ - Causes a branch if the previous operation caused either a carry or a - zero result. When used after a subtract or compare operation on unsigned - binary values, this instruction will branch if the register was lower - than or the same as the memory register. - - Generally not useful after INC/DEC, LD/ST, and TST/CLR/COM instructions. - - source code forms: BLS dd; LBLS DDDD - - CC bits "HNZVC": ----- - """ -# if (self.cc.C|self.cc.Z) == 0: - if self.cc.C == 1 or self.cc.Z == 1: -# log.info("$%x BLS branch to $%x, because C|Z==1 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - self.program_counter.set(ea) -# else: -# log.debug("$%x BLS: don't branch to $%x, because C|Z!=1 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - - @opcode(# Branch if less than (signed) - 0x2d, # BLT (relative) - 0x102d, # LBLT (relative) - ) - def instruction_BLT(self, opcode, ea): - """ - Causes a branch if either, but not both, of the N (negative) or V - (overflow) bits is set. That is, branch if the sign of a valid twos - complement result is, or would be, negative. When used after a subtract - or compare operation on twos complement binary values, this instruction - will branch if the register was less than the memory register. - - source code forms: BLT dd; LBLT DDDD - - CC bits "HNZVC": ----- - """ - if (self.cc.N ^ self.cc.V) == 1: # N xor V -# log.info("$%x BLT branch to $%x, because N XOR V == 1 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - self.program_counter.set(ea) -# else: -# log.debug("$%x BLT: don't branch to $%x, because N XOR V != 1 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - - @opcode(# Branch if minus - 0x2b, # BMI (relative) - 0x102b, # LBMI (relative) - ) - def instruction_BMI(self, opcode, ea): - """ - Tests the state of the N (negative) bit and causes a branch if set. That - is, branch if the sign of the twos complement result is negative. - - When used after an operation on signed binary values, this instruction - will branch if the result is minus. It is generally preferred to use the - LBLT instruction after signed operations. - - source code forms: BMI dd; LBMI DDDD - - CC bits "HNZVC": ----- - """ - if self.cc.N == 1: -# log.info("$%x BMI branch to $%x, because N==1 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - self.program_counter.set(ea) -# else: -# log.debug("$%x BMI: don't branch to $%x, because N==0 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - - @opcode(# Branch if not equal - 0x26, # BNE (relative) - 0x1026, # LBNE (relative) - ) - def instruction_BNE(self, opcode, ea): - """ - Tests the state of the Z (zero) bit and causes a branch if it is clear. - When used after a subtract or compare operation on any binary values, - this instruction will branch if the register is, or would be, not equal - to the memory register. - - source code forms: BNE dd; LBNE DDDD - - CC bits "HNZVC": ----- - """ - if self.cc.Z == 0: -# log.info("$%x BNE branch to $%x, because Z==0 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - self.program_counter.set(ea) -# else: -# log.debug("$%x BNE: don't branch to $%x, because Z==1 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - - @opcode(# Branch if plus - 0x2a, # BPL (relative) - 0x102a, # LBPL (relative) - ) - def instruction_BPL(self, opcode, ea): - """ - Tests the state of the N (negative) bit and causes a branch if it is - clear. That is, branch if the sign of the twos complement result is - positive. - - When used after an operation on signed binary values, this instruction - will branch if the result (possibly invalid) is positive. It is - generally preferred to use the BGE instruction after signed operations. - - source code forms: BPL dd; LBPL DDDD - - CC bits "HNZVC": ----- - """ - if self.cc.N == 0: -# log.info("$%x BPL branch to $%x, because N==0 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - self.program_counter.set(ea) -# else: -# log.debug("$%x BPL: don't branch to $%x, because N==1 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - - @opcode(# Branch always - 0x20, # BRA (relative) - 0x16, # LBRA (relative) - ) - def instruction_BRA(self, opcode, ea): - """ - Causes an unconditional branch. - - source code forms: BRA dd; LBRA DDDD - - CC bits "HNZVC": ----- - """ -# log.info("$%x BRA branch to $%x \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - self.program_counter.set(ea) - - @opcode(# Branch never - 0x21, # BRN (relative) - 0x1021, # LBRN (relative) - ) - def instruction_BRN(self, opcode, ea): - """ - Does not cause a branch. This instruction is essentially a no operation, - but has a bit pattern logically related to branch always. - - source code forms: BRN dd; LBRN DDDD - - CC bits "HNZVC": ----- - """ - pass - - @opcode(# Branch if valid twos complement result - 0x28, # BVC (relative) - 0x1028, # LBVC (relative) - ) - def instruction_BVC(self, opcode, ea): - """ - Tests the state of the V (overflow) bit and causes a branch if it is - clear. That is, branch if the twos complement result was valid. When - used after an operation on twos complement binary values, this - instruction will branch if there was no overflow. - - source code forms: BVC dd; LBVC DDDD - - CC bits "HNZVC": ----- - """ - if self.cc.V == 0: -# log.info("$%x BVC branch to $%x, because V==0 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - self.program_counter.set(ea) -# else: -# log.debug("$%x BVC: don't branch to $%x, because V==1 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - - @opcode(# Branch if invalid twos complement result - 0x29, # BVS (relative) - 0x1029, # LBVS (relative) - ) - def instruction_BVS(self, opcode, ea): - """ - Tests the state of the V (overflow) bit and causes a branch if it is - set. That is, branch if the twos complement result was invalid. When - used after an operation on twos complement binary values, this - instruction will branch if there was an overflow. - - source code forms: BVS dd; LBVS DDDD - - CC bits "HNZVC": ----- - """ - if self.cc.V == 1: -# log.info("$%x BVS branch to $%x, because V==1 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - self.program_counter.set(ea) -# else: -# log.debug("$%x BVS: don't branch to $%x, because V==0 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - - @opcode(# Branch if lower (unsigned) - 0x25, # BLO/BCS (relative) - 0x1025, # LBLO/LBCS (relative) - ) - def instruction_BLO(self, opcode, ea): - """ - CC bits "HNZVC": ----- - case 0x5: cond = REG_CC & CC_C; break; // BCS, BLO, LBCS, LBLO - """ - if self.cc.C == 1: -# log.info("$%x BLO/BCS/LBLO/LBCS branch to $%x, because C==1 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - self.program_counter.set(ea) -# else: -# log.debug("$%x BLO/BCS/LBLO/LBCS: don't branch to $%x, because C==0 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - - @opcode(# Branch if lower (unsigned) - 0x24, # BHS/BCC (relative) - 0x1024, # LBHS/LBCC (relative) - ) - def instruction_BHS(self, opcode, ea): - """ - CC bits "HNZVC": ----- - case 0x4: cond = !(REG_CC & CC_C); break; // BCC, BHS, LBCC, LBHS - """ - if self.cc.C == 0: -# log.info("$%x BHS/BCC/LBHS/LBCC branch to $%x, because C==0 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - self.program_counter.set(ea) -# else: -# log.debug("$%x BHS/BCC/LBHS/LBCC: don't branch to $%x, because C==1 \t| %s" % ( -# self.program_counter, ea, self.cfg.mem_info.get_shortest(ea) -# )) - - - # ---- Logical shift: LSL, LSR ---- - - - def LSL(self, a): - """ - Shifts all bits of accumulator A or B or memory location M one place to - the left. Bit zero is loaded with a zero. Bit seven of accumulator A or - B or memory location M is shifted into the C (carry) bit. - - This is a duplicate assembly-language mnemonic for the single machine - instruction ASL. - - source code forms: LSL Q; LSLA; LSLB - - CC bits "HNZVC": naaas - """ - r = a << 1 - self.cc.clear_NZVC() - self.cc.update_NZVC_8(a, a, r) - return r - - @opcode(0x8, 0x68, 0x78) # LSL/ASL (direct, indexed, extended) - def instruction_LSL_memory(self, opcode, ea, m): - """ - Logical shift left memory location / Arithmetic shift of memory left - """ - r = self.LSL(m) -# log.debug("$%x LSL memory value $%x << 1 = $%x and write it to $%x \t| %s" % ( -# self.program_counter, -# m, r, ea, -# self.cfg.mem_info.get_shortest(ea) -# )) - return ea, r & 0xff - - @opcode(0x48, 0x58) # LSLA/ASLA / LSLB/ASLB (inherent) - def instruction_LSL_register(self, opcode, register): - """ - Logical shift left accumulator / Arithmetic shift of accumulator - """ - a = register.get() - r = self.LSL(a) -# log.debug("$%x LSL %s value $%x << 1 = $%x" % ( -# self.program_counter, -# register.name, a, r -# )) - register.set(r) - - def LSR(self, a): - """ - Performs a logical shift right on the register. Shifts a zero into bit - seven and bit zero into the C (carry) bit. - - source code forms: LSR Q; LSRA; LSRB - - CC bits "HNZVC": -0a-s - """ - r = a >> 1 - self.cc.clear_NZC() - self.cc.C = get_bit(a, bit=0) # same as: self.cc.C |= (a & 1) - self.cc.set_Z8(r) - return r - - @opcode(0x4, 0x64, 0x74) # LSR (direct, indexed, extended) - def instruction_LSR_memory(self, opcode, ea, m): - """ Logical shift right memory location """ - r = self.LSR(m) -# log.debug("$%x LSR memory value $%x >> 1 = $%x and write it to $%x \t| %s" % ( -# self.program_counter, -# m, r, ea, -# self.cfg.mem_info.get_shortest(ea) -# )) - return ea, r & 0xff - - @opcode(0x44, 0x54) # LSRA / LSRB (inherent) - def instruction_LSR_register(self, opcode, register): - """ Logical shift right accumulator """ - a = register.get() - r = self.LSR(a) -# log.debug("$%x LSR %s value $%x >> 1 = $%x" % ( -# self.program_counter, -# register.name, a, r -# )) - register.set(r) - - def ASR(self, a): - """ - ASR (Arithmetic Shift Right) alias LSR (Logical Shift Right) - - Shifts all bits of the register one place to the right. Bit seven is held - constant. Bit zero is shifted into the C (carry) bit. - - source code forms: ASR Q; ASRA; ASRB - - CC bits "HNZVC": uaa-s - """ - r = (a >> 1) | (a & 0x80) - self.cc.clear_NZC() - self.cc.C = get_bit(a, bit=0) # same as: self.cc.C |= (a & 1) - self.cc.update_NZ_8(r) - return r - - @opcode(0x7, 0x67, 0x77) # ASR (direct, indexed, extended) - def instruction_ASR_memory(self, opcode, ea, m): - """ Arithmetic shift memory right """ - r = self.ASR(m) -# log.debug("$%x ASR memory value $%x >> 1 | Carry = $%x and write it to $%x \t| %s" % ( -# self.program_counter, -# m, r, ea, -# self.cfg.mem_info.get_shortest(ea) -# )) - return ea, r & 0xff - - @opcode(0x47, 0x57) # ASRA/ASRB (inherent) - def instruction_ASR_register(self, opcode, register): - """ Arithmetic shift accumulator right """ - a = register.get() - r = self.ASR(a) -# log.debug("$%x ASR %s value $%x >> 1 | Carry = $%x" % ( -# self.program_counter, -# register.name, a, r -# )) - register.set(r) - - - # ---- Rotate: ROL, ROR ---- - - - def ROL(self, a): - """ - Rotates all bits of the register one place left through the C (carry) - bit. This is a 9-bit rotation. - - source code forms: ROL Q; ROLA; ROLB - - CC bits "HNZVC": -aaas - """ - r = (a << 1) | self.cc.C - self.cc.clear_NZVC() - self.cc.update_NZVC_8(a, a, r) - return r - - @opcode(0x9, 0x69, 0x79) # ROL (direct, indexed, extended) - def instruction_ROL_memory(self, opcode, ea, m): - """ Rotate memory left """ - r = self.ROL(m) -# log.debug("$%x ROL memory value $%x << 1 | Carry = $%x and write it to $%x \t| %s" % ( -# self.program_counter, -# m, r, ea, -# self.cfg.mem_info.get_shortest(ea) -# )) - return ea, r & 0xff - - @opcode(0x49, 0x59) # ROLA / ROLB (inherent) - def instruction_ROL_register(self, opcode, register): - """ Rotate accumulator left """ - a = register.get() - r = self.ROL(a) -# log.debug("$%x ROL %s value $%x << 1 | Carry = $%x" % ( -# self.program_counter, -# register.name, a, r -# )) - register.set(r) - - def ROR(self, a): - """ - Rotates all bits of the register one place right through the C (carry) - bit. This is a 9-bit rotation. - - moved the carry flag into bit 8 - moved bit 7 into carry flag - - source code forms: ROR Q; RORA; RORB - - CC bits "HNZVC": -aa-s - """ - r = (a >> 1) | (self.cc.C << 7) - self.cc.clear_NZ() - self.cc.update_NZ_8(r) - self.cc.C = get_bit(a, bit=0) # same as: self.cc.C = (a & 1) - return r - - @opcode(0x6, 0x66, 0x76) # ROR (direct, indexed, extended) - def instruction_ROR_memory(self, opcode, ea, m): - """ Rotate memory right """ - r = self.ROR(m) -# log.debug("$%x ROR memory value $%x >> 1 | Carry = $%x and write it to $%x \t| %s" % ( -# self.program_counter, -# m, r, ea, -# self.cfg.mem_info.get_shortest(ea) -# )) - return ea, r & 0xff - - @opcode(0x46, 0x56) # RORA/RORB (inherent) - def instruction_ROR_register(self, opcode, register): - """ Rotate accumulator right """ - a = register.get() - r = self.ROR(a) -# log.debug("$%x ROR %s value $%x >> 1 | Carry = $%x" % ( -# self.program_counter, -# register.name, a, r -# )) - register.set(r) - - - # ---- Not Implemented, yet. ---- - - - @opcode(# AND condition code register, then wait for interrupt - 0x3c, # CWAI (immediate) - ) - def instruction_CWAI(self, opcode, m): - """ - This instruction ANDs an immediate byte with the condition code register - which may clear the interrupt mask bits I and F, stacks the entire - machine state on the hardware stack and then looks for an interrupt. - When a non-masked interrupt occurs, no further machine state information - need be saved before vectoring to the interrupt handling routine. This - instruction replaced the MC6800 CLI WAI sequence, but does not place the - buses in a high-impedance state. A FIRQ (fast interrupt request) may - enter its interrupt handler with its entire machine state saved. The RTI - (return from interrupt) instruction will automatically return the entire - machine state after testing the E (entire) bit of the recovered - condition code register. - - The following immediate values will have the following results: FF = - enable neither EF = enable IRQ BF = enable FIRQ AF = enable both - - source code forms: CWAI #$XX E F H I N Z V C - - CC bits "HNZVC": ddddd - """ -# log.error("$%x CWAI not implemented, yet!", opcode) - # Update CC bits: ddddd - - @opcode(# Undocumented opcode! - 0x3e, # RESET (inherent) - ) - def instruction_RESET(self, opcode): - """ - Build the ASSIST09 vector table and setup monitor defaults, then invoke - the monitor startup routine. - - source code forms: - - CC bits "HNZVC": ***** - """ - raise NotImplementedError("$%x RESET" % opcode) - # Update CC bits: ***** - - # ---- Interrupt handling ---- - - irq_enabled = False - def irq(self): - if not self.irq_enabled or self.cc.I == 1: - # log.critical("$%04x *** IRQ, ignore!\t%s" % ( - # self.program_counter.get(), self.cc.get_info - # )) - return - - if self.cc.E: - self.push_irq_registers() - else: - self.push_firq_registers() - - ea = self.memory.read_word(self.IRQ_VECTOR) - # log.critical("$%04x *** IRQ, set PC to $%04x\t%s" % ( - # self.program_counter.get(), ea, self.cc.get_info - # )) - self.program_counter.set(ea) - - def push_irq_registers(self): - """ - push PC, U, Y, X, DP, B, A, CC on System stack pointer - """ - self.cycles += 1 - self.push_word(self.system_stack_pointer, self.program_counter.get()) # PC - self.push_word(self.system_stack_pointer, self.user_stack_pointer.get()) # U - self.push_word(self.system_stack_pointer, self.index_y.get()) # Y - self.push_word(self.system_stack_pointer, self.index_x.get()) # X - self.push_byte(self.system_stack_pointer, self.direct_page.get()) # DP - self.push_byte(self.system_stack_pointer, self.accu_b.get()) # B - self.push_byte(self.system_stack_pointer, self.accu_a.get()) # A - self.push_byte(self.system_stack_pointer, self.cc.get()) # CC - - def push_firq_registers(self): - """ - FIRQ - Fast Interrupt Request - push PC and CC on System stack pointer - """ - self.cycles += 1 - self.push_word(self.system_stack_pointer, self.program_counter.get()) # PC - self.push_byte(self.system_stack_pointer, self.cc.get()) # CC - - @opcode(# Return from interrupt - 0x3b, # RTI (inherent) - ) - def instruction_RTI(self, opcode): - """ - The saved machine state is recovered from the hardware stack and control - is returned to the interrupted program. If the recovered E (entire) bit - is clear, it indicates that only a subset of the machine state was saved - (return address and condition codes) and only that subset is recovered. - - source code forms: RTI - - CC bits "HNZVC": ----- - """ - cc = self.pull_byte(self.system_stack_pointer) # CC - self.cc.set(cc) - if self.cc.E: - self.accu_a.set( - self.pull_byte(self.system_stack_pointer) # A - ) - self.accu_b.set( - self.pull_byte(self.system_stack_pointer) # B - ) - self.direct_page.set( - self.pull_byte(self.system_stack_pointer) # DP - ) - self.index_x.set( - self.pull_word(self.system_stack_pointer) # X - ) - self.index_y.set( - self.pull_word(self.system_stack_pointer) # Y - ) - self.user_stack_pointer.set( - self.pull_word(self.system_stack_pointer) # U - ) - - self.program_counter.set( - self.pull_word(self.system_stack_pointer) # PC - ) -# log.critical("RTI to $%04x", self.program_counter.get()) - - - @opcode(# Software interrupt (absolute indirect) - 0x3f, # SWI (inherent) - ) - def instruction_SWI(self, opcode): - """ - All of the processor registers are pushed onto the hardware stack (with - the exception of the hardware stack pointer itself), and control is - transferred through the software interrupt vector. Both the normal and - fast interrupts are masked (disabled). - - source code forms: SWI - - CC bits "HNZVC": ----- - """ - raise NotImplementedError("$%x SWI" % opcode) - - @opcode(# Software interrupt (absolute indirect) - 0x103f, # SWI2 (inherent) - ) - def instruction_SWI2(self, opcode, ea, m): - """ - All of the processor registers are pushed onto the hardware stack (with - the exception of the hardware stack pointer itself), and control is - transferred through the software interrupt 2 vector. This interrupt is - available to the end user and must not be used in packaged software. - This interrupt does not mask (disable) the normal and fast interrupts. - - source code forms: SWI2 - - CC bits "HNZVC": ----- - """ - raise NotImplementedError("$%x SWI2" % opcode) - - @opcode(# Software interrupt (absolute indirect) - 0x113f, # SWI3 (inherent) - ) - def instruction_SWI3(self, opcode, ea, m): - """ - All of the processor registers are pushed onto the hardware stack (with - the exception of the hardware stack pointer itself), and control is - transferred through the software interrupt 3 vector. This interrupt does - not mask (disable) the normal and fast interrupts. - - source code forms: SWI3 - - CC bits "HNZVC": ----- - """ - raise NotImplementedError("$%x SWI3" % opcode) - - @opcode(# Synchronize with interrupt line - 0x13, # SYNC (inherent) - ) - def instruction_SYNC(self, opcode): - """ - FAST SYNC WAIT FOR DATA Interrupt! LDA DISC DATA FROM DISC AND CLEAR - INTERRUPT STA ,X+ PUT IN BUFFER DECB COUNT IT, DONE? BNE FAST GO AGAIN - IF NOT. - - source code forms: SYNC - - CC bits "HNZVC": ----- - """ - raise NotImplementedError("$%x SYNC" % opcode) - - - -class TypeAssert(CPU): - """ - assert that all attributes of the CPU class will remain as the same. - - We use no property, because it's slower. But without it, it's hard to find - if somewhere not .set() or .incement() is used. - - With this helper a error will raise, if the type of a attribute will be - changed, e.g.: - cpu.index_x = ValueStorage16Bit(...) - cpu.index_x = 0x1234 # will raised a error - """ - __ATTR_DICT = {} - def __init__(self, *args, **kwargs): - super(TypeAssert, self).__init__(*args, **kwargs) - self.__set_attr_dict() - warnings.warn( - "CPU TypeAssert used! (Should be only activated for debugging!)" - ) - - def __set_attr_dict(self): - for name, obj in inspect.getmembers(self, lambda x:not(inspect.isroutine(x))): - if name.startswith("_") or name == "cfg": - continue - self.__ATTR_DICT[name] = type(obj) - - def __setattr__(self, attr, value): - if attr in self.__ATTR_DICT: - obj = self.__ATTR_DICT[attr] - assert isinstance(value, obj), \ - "Attribute %r is no more type %s (Is now: %s)!" % ( - attr, obj, type(obj) - ) - return object.__setattr__(self, attr, value) - -# CPU = TypeAssert # Should be only activated for debugging! - - -#------------------------------------------------------------------------------ - - -def test_run(): - import sys - import os - import subprocess - cmd_args = [ - sys.executable, - os.path.join("..", "DragonPy_CLI.py"), -# "--verbosity", "5", - "--log", "dragonpy.components.cpu6809,50", - - "--machine", "Dragon32", "run", -# "--machine", "Vectrex", "run", -# "--max_ops", "1", -# "--trace", - ] - print("Startup CLI with: %s" % " ".join(cmd_args[1:])) - subprocess.Popen(cmd_args, cwd="..").wait() - -if __name__ == "__main__": - test_run() diff --git a/dragonpy/components/cpu6809_html_debug.py b/dragonpy/components/cpu6809_html_debug.py deleted file mode 100644 index 4f1e4fdf..00000000 --- a/dragonpy/components/cpu6809_html_debug.py +++ /dev/null @@ -1,77 +0,0 @@ -#!/usr/bin/env python -# coding: utf-8 - -""" - DragonPy - Dragon 32 emulator in Python - ======================================= - - :copyleft: 2014 by the DragonPy team, see AUTHORS for more details. - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - -from __future__ import absolute_import, division, print_function - - - -import atexit -import os -import datetime - - -DEBUG_FILENAME = os.path.abspath(os.path.join( - os.path.dirname(__file__), - "../dragonpy_debug_%s.html" % datetime.datetime.today().strftime("%Y%m%d%H%M%S") -)) - - -HTML_OUT = file(DEBUG_FILENAME, "w") -HTML_OUT.write(""" - - -

DragonPy Debug:

-

created: %s

-""" % datetime.datetime.today().isoformat()) -print("Create debug file: %s" % DEBUG_FILENAME) - - -@atexit.register -def close_html_debug(): - HTML_OUT.write("\n
\n") - HTML_OUT.write( - "This file was generated by %s\n" % ( - os.path.split(__file__)[1] - ) - ) - HTML_OUT.write("") - HTML_OUT.close() - print("*** Debug file created:", DEBUG_FILENAME) - - -CALL_NO = 0 -class InstructionHTMLdebug(Instruction): - - def __init__(self, *args, **kwargs): - super(InstructionHTMLdebug, self).__init__(*args, **kwargs) - - def call_instr_func(self, *args, **kwargs): - super(InstructionHTMLdebug, self).call_instr_func(*args, **kwargs) - - global CALL_NO - CALL_NO += 1 - HTML_OUT.write("\n") - HTML_OUT.write("%i" % CALL_NO) - HTML_OUT.write("%x" % self.cpu.last_op_address) - HTML_OUT.write("%x" % self.opcode) - HTML_OUT.write("%s" % self.data["mnemonic"]) - HTML_OUT.write("%s" % hex_repr(self.op_kwargs)) - HTML_OUT.write("%s" % self.cpu.get_info) - HTML_OUT.write("%s" % self.cpu.cc.get_info) - HTML_OUT.write("%s" % self.cpu.cfg.mem_info.get_shortest(self.cpu.last_op_address)) - HTML_OUT.write("") diff --git a/dragonpy/components/cpu6809_trace.py b/dragonpy/components/cpu6809_trace.py deleted file mode 100644 index 359a6b90..00000000 --- a/dragonpy/components/cpu6809_trace.py +++ /dev/null @@ -1,118 +0,0 @@ -#!/usr/bin/env python -# coding: utf-8 - -""" - DragonPy - Dragon 32 emulator in Python - ======================================= - - Create trace lines for every OP call. - - :copyleft: 2014 by the DragonPy team, see AUTHORS for more details. - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - -from __future__ import absolute_import, division, print_function - -import sys -import logging - -from dragonpy.components.MC6809data.MC6809_data_utils import MC6809OP_DATA_DICT -from dragonpy.components.cpu_utils.instruction_call import PrepagedInstructions - - -log = logging.getLogger("DragonPy.cpu6809.trace") - - -class InstructionTrace(PrepagedInstructions): - def __init__(self, *args, **kwargs): - super(InstructionTrace, self).__init__(*args, **kwargs) - self.cfg = self.cpu.cfg - self.get_mem_info = self.cpu.cfg.mem_info.get_shortest - - self.__origin_instr_func = self.instr_func - self.instr_func = self.__call_instr_func - -# def __getattribute__(self, attr, *args, **kwargs): -# if attr not in ("__call", "cpu", "memory", "instr_func"): -# return InstructionTrace.__call -# print attr, args, kwargs -# return PrepagedInstructions.__getattribute__(self, attr, *args, **kwargs) -# -# def __call(self, func, *args, **kwargs): -# print func, args, kwargs -# raise - - def __call_instr_func(self, opcode, *args, **kwargs): - # call the op CPU code method - result = self.__origin_instr_func(opcode, *args, **kwargs) - - if opcode in (0x10, 0x11): - log.debug("Skip PAGE 2 and PAGE 3 instruction in trace") - return - - op_code_data = MC6809OP_DATA_DICT[opcode] - - op_address = self.cpu.last_op_address - - ob_bytes = op_code_data["bytes"] - - op_bytes = "".join([ - "%02x" % value - for __, value in self.cpu.memory.iter_bytes(op_address, op_address + ob_bytes) - ]) - - kwargs_info = [] - if "register" in kwargs: - kwargs_info.append(str(kwargs["register"])) - if "ea" in kwargs: - kwargs_info.append("ea:%04x" % kwargs["ea"]) - if "m" in kwargs: - kwargs_info.append("m:%x" % kwargs["m"]) - - msg = "%(op_address)04x| %(op_bytes)-11s %(mnemonic)-7s %(kwargs)-19s %(cpu)s | %(cc)s | %(mem)s\n" % { - "op_address": op_address, - "op_bytes": op_bytes, - "mnemonic": op_code_data["mnemonic"], - "kwargs": " ".join(kwargs_info), - "cpu": self.cpu.get_info, - "cc": self.cpu.cc.get_info, - "mem": self.get_mem_info(op_address) - } - sys.stdout.write(msg) - - if not op_bytes.startswith("%02x" % opcode): - self.cpu.memory.print_dump(op_address, op_address + ob_bytes) - self.cpu.memory.print_dump(op_address - 10, op_address + ob_bytes + 10) - assert op_bytes.startswith("%02x" % opcode), "%s doesn't start with %02x" % ( - op_bytes, self.opcode - ) - - return result - - -#------------------------------------------------------------------------------ - - -def test_run(): - import sys - import os - import subprocess - cmd_args = [ - sys.executable, - os.path.join("..", "DragonPy_CLI.py"), -# "--verbosity", " 1", # hardcode DEBUG ;) -# "--verbosity", "10", # DEBUG -# "--verbosity", "20", # INFO -# "--verbosity", "30", # WARNING -# "--verbosity", "40", # ERROR - "--verbosity", "50", # CRITICAL/FATAL - "--machine", "Dragon32", "run", -# "--machine", "Vectrex", "run", -# "--max_ops", "1", - "--trace", - ] - print("Startup CLI with: %s" % " ".join(cmd_args[1:])) - subprocess.Popen(cmd_args, cwd="..").wait() - -if __name__ == "__main__": - test_run() diff --git a/dragonpy/components/cpu_utils/Instruction_generator.py b/dragonpy/components/cpu_utils/Instruction_generator.py deleted file mode 100644 index 4b29c145..00000000 --- a/dragonpy/components/cpu_utils/Instruction_generator.py +++ /dev/null @@ -1,208 +0,0 @@ -#!/usr/bin/env python - -""" - DragonPy - Dragon 32 emulator in Python - ======================================= - - :copyleft: 2013-2014 by the DragonPy team, see AUTHORS for more details. - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - -from __future__ import absolute_import, division, print_function - -import os -import sys - -from dragonpy.components.MC6809data.MC6809_op_data import ( - OP_DATA, BYTE, WORD, REG_A, REG_B, REG_CC, REG_D , REG_DP, REG_PC, - REG_S, REG_U, REG_X, REG_Y -) -from dragonpy.components.MC6809data.MC6809_data_utils import MC6809OP_DATA_DICT - - -SPECIAL_FUNC_NAME = "special" - -REGISTER_DICT = { - REG_X:"index_x", - REG_Y:"index_y", - - REG_U:"user_stack_pointer", - REG_S:"system_stack_pointer", - - REG_PC:"program_counter", - - REG_A:"accu_a", - REG_B:"accu_b", - REG_D:"accu_d", - - REG_DP:"direct_page", - REG_CC:"cc", - - #undefined_reg.name:"undefined_reg", # for TFR", EXG -} - - -if __doc__: - DOC = __doc__.rsplit("=", 1)[1] -else: - DOC = "" # e.g.: run with --OO - -INIT_CODE = ''' -""" - This file was generated with: "%s" - Please doen't change it directly ;) - %s -""" - - -from dragonpy.components.cpu_utils.instruction_base import InstructionBase - -class PrepagedInstructions(InstructionBase): - -''' % (os.path.basename(__file__), DOC) - - - -def build_func_name(addr_mode, ea, register, read, write): -# print addr_mode, ea, register, read, write - - if addr_mode is None: - return SPECIAL_FUNC_NAME - - func_name = addr_mode.lower() - - if ea: - func_name += "_ea" - if register: - func_name += "_%s" % register - if read: - func_name += "_read%s" % read - if write: - func_name += "_write%s" % write - -# print func_name - return func_name - - -def func_name_from_op_code(op_code): - op_code_data = MC6809OP_DATA_DICT[op_code] - addr_mode = op_code_data["addr_mode"] - ea = op_code_data["needs_ea"] - register = op_code_data["register"] - read = op_code_data["read_from_memory"] - write = op_code_data["write_to_memory"] - return build_func_name(addr_mode, ea, register, read, write) - - -def generate_code(f): - variants = set() - for instr_data in list(OP_DATA.values()): - for mnemonic, mnemonic_data in list(instr_data["mnemonic"].items()): - read_from_memory = mnemonic_data["read_from_memory"] - write_to_memory = mnemonic_data["write_to_memory"] - needs_ea = mnemonic_data["needs_ea"] - register = mnemonic_data["register"] - for op_code, op_data in list(mnemonic_data["ops"].items()): - addr_mode = op_data["addr_mode"] -# print hex(op_code), - variants.add( - (addr_mode, needs_ea, register, read_from_memory, write_to_memory) - ) -# if (addr_mode and needs_ea and register and read_from_memory and write_to_memory) is None: - if addr_mode is None: - print(mnemonic, op_data) - -# for no, data in enumerate(sorted(variants)): -# print no, data -# print"+++++++++++++" - - for line in INIT_CODE.splitlines(): - f.write("%s\n" % line) - - for addr_mode, ea, register, read, write in sorted(variants): - if not addr_mode: - # special function (RESET/ PAGE1,2) defined in InstructionBase - continue - - func_name = build_func_name(addr_mode, ea, register, read, write) - - f.write(" def %s(self, opcode):\n" % func_name) - - code = [] - - if ea and read: - code.append("ea, m = self.cpu.get_ea_m_%s()" % addr_mode.lower()) - - if write: - code.append("ea, value = self.instr_func(") - else: - code.append("self.instr_func(") - code.append(" opcode = opcode,") - - if ea and read: - code.append(" ea = ea,") - code.append(" m = m,") - elif ea: - code.append(" ea = self.cpu.get_ea_%s()," % addr_mode.lower()) - elif read: - code.append(" m = self.cpu.get_m_%s()," % addr_mode.lower()) - - if register: - code.append( - " register = self.cpu.%s," % REGISTER_DICT[register] - ) - - code.append(")") - - if write == BYTE: - code.append("self.memory.write_byte(ea, value)") - elif write == WORD: - code.append("self.memory.write_word(ea, value)") - - for line in code: - f.write(" %s\n" % line) - - f.write("\n") - - -def generate(filename): - with open(filename, "w") as f: -# generate_code(sys.stdout) - generate_code(f) - sys.stderr.write("New %r generated.\n" % filename) - - - - - -def test_run(): - import subprocess - cmd_args = [ - sys.executable, -# "/usr/bin/pypy", - os.path.join("..", "DragonPy_CLI.py"), -# "--verbosity=5", -# "--verbosity=10", # DEBUG -# "--verbosity=20", # INFO -# "--verbosity=30", # WARNING -# "--verbosity=40", # ERROR - "--verbosity=50", # CRITICAL/FATAL - -# "--trace", - -# "--machine=Simple6809", - "--machine=sbc09", -# "--max=500000", -# "--max=20000", - "--max=1", - ] - print("Startup CLI with: %s" % " ".join(cmd_args[1:])) - subprocess.Popen(cmd_args, cwd="..").wait() - - -if __name__ == "__main__": - generate("instruction_call.py") - test_run() - - - diff --git a/dragonpy/components/cpu_utils/MC6809_registers.py b/dragonpy/components/cpu_utils/MC6809_registers.py deleted file mode 100644 index 2037ece4..00000000 --- a/dragonpy/components/cpu_utils/MC6809_registers.py +++ /dev/null @@ -1,375 +0,0 @@ -#!/usr/bin/env python - -""" - DragonPy - Dragon 32 emulator in Python - ======================================= - - some code is borrowed from: - XRoar emulator by Ciaran Anscomb (GPL license) more info, see README - - :copyleft: 2013-2014 by the DragonPy team, see AUTHORS for more details. - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - -from __future__ import absolute_import, division, print_function - - -from dragonpy.utils.humanize import cc_value2txt -import logging - -log=logging.getLogger(__name__) - - -class ValueStorage(object): - def __init__(self, name, initial_value): - self.name = name - self.value = initial_value - - def set(self, v): - self.value = v - return self.value # e.g.: r = operand.set(a + 1) - def get(self): - return self.value - - # FIXME: - def decrement(self, value=1): - return self.set(self.value - value) - def increment(self, value=1): - return self.set(self.value + value) - - def __str__(self): - return "<%s:$%x>" % (self.name, self.value) - __repr__ = __str__ - - -class UndefinedRegister(ValueStorage): - # used in TFR and EXG - WIDTH = 16 # 16 Bit - name = "undefined!" - value = 0xffff - def __init__(self): - pass - def set(self, v): - log.warning("Set value to 'undefined' register!") - pass - - def get(self): - return 0xffff - - -class ValueStorage8Bit(ValueStorage): - WIDTH = 8 # 8 Bit - - def set(self, v): - if v > 0xff: -# log.info(" **** Value $%x is to big for %s (8-bit)", v, self.name) - v = v & 0xff -# log.info(" ^^^^ Value %s (8-bit) wrap around to $%x", self.name, v) - elif v < 0: -# log.info(" **** %s value $%x is negative", self.name, v) - v = 0x100 + v -# log.info(" **** Value %s (8-bit) wrap around to $%x", self.name, v) - self.value = v - return self.value # e.g.: r = operand.set(a + 1) - def __str__(self): - return "%s=%02x" % (self.name, self.value) - - -class ValueStorage16Bit(ValueStorage): - WIDTH = 16 # 16 Bit - - def set(self, v): - if v > 0xffff: -# log.info(" **** Value $%x is to big for %s (16-bit)", v, self.name) - v = v & 0xffff -# log.info(" ^^^^ Value %s (16-bit) wrap around to $%x", self.name, v) - elif v < 0: -# log.info(" **** %s value $%x is negative", self.name, v) - v = 0x10000 + v -# log.info(" **** Value %s (16-bit) wrap around to $%x", self.name, v) - self.value = v - return self.value # e.g.: r = operand.set(a + 1) - def __str__(self): - return "%s=%04x" % (self.name, self.value) - - - -def _register_bit(key): - def set_flag(self, value): - assert value in (0, 1) - self._register[key] = value - def get_flag(self): - return self._register[key] - return property(get_flag, set_flag) - - -class ConditionCodeRegister(object): - """ CC - 8 bit condition code register bits """ - - WIDTH = 8 # 8 Bit - - def __init__(self, *cmd_args, **kwargs): - self.name = "CC" - self._register = {} - self.set(0x0) # create all keys in dict with value 0 - - E = _register_bit("E") # E - 0x80 - bit 7 - Entire register state stacked - F = _register_bit("F") # F - 0x40 - bit 6 - FIRQ interrupt masked - H = _register_bit("H") # H - 0x20 - bit 5 - Half-Carry - I = _register_bit("I") # I - 0x10 - bit 4 - IRQ interrupt masked - N = _register_bit("N") # N - 0x08 - bit 3 - Negative result (twos complement) - Z = _register_bit("Z") # Z - 0x04 - bit 2 - Zero result - V = _register_bit("V") # V - 0x02 - bit 1 - Overflow - C = _register_bit("C") # C - 0x01 - bit 0 - Carry (or borrow) - - #### - - def set(self, status): - self.E, self.F, self.H, self.I, self.N, self.Z, self.V, self.C = \ - [0 if status & x == 0 else 1 for x in (128, 64, 32, 16, 8, 4, 2, 1)] - - def get(self): - return self.C | \ - self.V << 1 | \ - self.Z << 2 | \ - self.N << 3 | \ - self.I << 4 | \ - self.H << 5 | \ - self.F << 6 | \ - self.E << 7 - - @property - def get_info(self): - """ - >>> cc=ConditionCodeRegister() - >>> cc.set(0xa1) - >>> cc.get_info - 'E.H....C' - """ - return cc_value2txt(self.get()) - - def __str__(self): - return "%s=%s" % (self.name, self.get_info) - - #### - - """ - #define SET_Z(r) ( REG_CC |= ((r) ? 0 : CC_Z) ) - #define SET_N8(r) ( REG_CC |= (r&0x80)>>4 ) - #define SET_N16(r) ( REG_CC |= (r&0x8000)>>12 ) - #define SET_H(a,b,r) ( REG_CC |= ((a^b^r)&0x10)<<1 ) - #define SET_C8(r) ( REG_CC |= (r&0x100)>>8 ) - #define SET_C16(r) ( REG_CC |= (r&0x10000)>>16 ) - #define SET_V8(a,b,r) ( REG_CC |= ((a^b^r^(r>>1))&0x80)>>6 ) - #define SET_V16(a,b,r) ( REG_CC |= ((a^b^r^(r>>1))&0x8000)>>14 ) - """ - - def set_H(self, a, b, r): - if self.H == 0: - r2 = (a ^ b ^ r) & 0x10 - self.H = 0 if r2 == 0 else 1 -# log.debug("\tset_H(): set half-carry flag to %i: ($%02x ^ $%02x ^ $%02x) & 0x10 = $%02x", -# self.H, a, b, r, r2 -# ) -# else: -# log.debug("\rset_H(): leave old value 1") - - def set_Z8(self, r): - if self.Z == 0: - r2 = r & 0xff - self.Z = 1 if r2 == 0 else 0 -# log.debug("\tset_Z8(): set zero flag to %i: $%02x & 0xff = $%02x", -# self.Z, r, r2 -# ) -# else: -# log.debug("\tset_Z8(): leave old value 1") - - def set_Z16(self, r): - if self.Z == 0: - r2 = r & 0xffff - self.Z = 1 if r2 == 0 else 0 -# log.debug("\tset_Z16(): set zero flag to %i: $%04x & 0xffff = $%04x", -# self.Z, r, r2 -# ) -# else: -# log.debug("\tset_Z16(): leave old value 1") - - def set_N8(self, r): - if self.N == 0: - r2 = r & 0x80 - self.N = 0 if r2 == 0 else 1 -# log.debug("\tset_N8(): set negative flag to %i: ($%02x & 0x80) = $%02x", -# self.N, r, r2 -# ) -# else: -# log.debug("\tset_N8(): leave old value 1") - - def set_N16(self, r): - if self.N == 0: - r2 = r & 0x8000 - self.N = 0 if r2 == 0 else 1 -# log.debug("\tset_N16(): set negative flag to %i: ($%04x & 0x8000) = $%04x", -# self.N, r, r2 -# ) -# else: -# log.debug("\tset_N16(): leave old value 1") - - def set_C8(self, r): - if self.C == 0: - r2 = r & 0x100 - self.C = 0 if r2 == 0 else 1 -# log.debug("\tset_C8(): carry flag to %i: ($%02x & 0x100) = $%02x", -# self.C, r, r2 -# ) -# else: -# log.debug("\tset_C8(): leave old value 1") - - def set_C16(self, r): - if self.C == 0: - r2 = r & 0x10000 - self.C = 0 if r2 == 0 else 1 -# log.debug("\tset_C16(): carry flag to %i: ($%04x & 0x10000) = $%04x", -# self.C, r, r2 -# ) -# else: -# log.debug("\tset_C16(): leave old value 1") - - def set_V8(self, a, b, r): - if self.V == 0: - r2 = (a ^ b ^ r ^ (r >> 1)) & 0x80 - self.V = 0 if r2 == 0 else 1 -# log.debug("\tset_V8(): overflow flag to %i: (($%02x ^ $%02x ^ $%02x ^ ($%02x >> 1)) & 0x80) = $%02x", -# self.V, a, b, r, r, r2 -# ) -# else: -# log.debug("\tset_V8(): leave old value 1") - - def set_V16(self, a, b, r): - if self.V == 0: - r2 = (a ^ b ^ r ^ (r >> 1)) & 0x8000 - self.V = 0 if r2 == 0 else 1 -# log.debug("\tset_V16(): overflow flag to %i: (($%04x ^ $%04x ^ $%04x ^ ($%04x >> 1)) & 0x8000) = $%04x", -# self.V, a, b, r, r, r2 -# ) -# else: -# log.debug("\tset_V16(): leave old value 1") - - #### - - def clear_NZ(self): -# log.debug("\tclear_NZ()") - self.N = 0 - self.Z = 0 - - def clear_NZC(self): -# log.debug("\tclear_NZC()") - self.N = 0 - self.Z = 0 - self.C = 0 - - def clear_NZV(self): -# log.debug("\tclear_NZV()") - self.N = 0 - self.Z = 0 - self.V = 0 - - def clear_NZVC(self): -# log.debug("\tclear_NZVC()") - self.N = 0 - self.Z = 0 - self.V = 0 - self.C = 0 - - def clear_HNZVC(self): -# log.debug("\tclear_HNZVC()") - self.H = 0 - self.N = 0 - self.Z = 0 - self.V = 0 - self.C = 0 - - #### - - def update_NZ_8(self, r): - self.set_N8(r) - self.set_Z8(r) - - def update_0100(self): - """ CC bits "HNZVC": -0100 """ - self.N = 0 - self.Z = 1 - self.V = 0 - self.C = 0 - - def update_NZ01_8(self, r): - self.set_N8(r) - self.set_Z8(r) - self.V = 0 - self.C = 1 - - def update_NZ_16(self, r): - self.set_N16(r) - self.set_Z16(r) - - def update_NZ0_8(self, r): - self.set_N8(r) - self.set_Z8(r) - self.V = 0 - - def update_NZ0_16(self, r): - self.set_N16(r) - self.set_Z16(r) - self.V = 0 - - def update_NZC_8(self, r): - self.set_N8(r) - self.set_Z8(r) - self.set_C8(r) - - def update_NZVC_8(self, a, b, r): - self.set_N8(r) - self.set_Z8(r) - self.set_V8(a, b, r) - self.set_C8(r) - - def update_NZVC_16(self, a, b, r): - self.set_N16(r) - self.set_Z16(r) - self.set_V16(a, b, r) - self.set_C16(r) - - def update_HNZVC_8(self, a, b, r): - self.set_H(a, b, r) - self.set_N8(r) - self.set_Z8(r) - self.set_V8(a, b, r) - self.set_C8(r) - - -class ConcatenatedAccumulator(object): - """ - 6809 has register D - 16 bit concatenated reg. (A + B) - """ - WIDTH = 16 # 16 Bit - - def __init__(self, name, a, b): - self.name = name - self._a = a - self._b = b - - def set(self, value): - self._a.set(value >> 8) - self._b.set(value & 0xff) - - def get(self): - a = self._a.get() - b = self._b.get() - return a * 256 + b - - def __str__(self): - return "%s=%04x" % (self.name, self.get()) - - -if __name__ == "__main__": - import doctest - print(doctest.testmod()) diff --git a/dragonpy/components/cpu_utils/__init__.py b/dragonpy/components/cpu_utils/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/dragonpy/components/cpu_utils/instruction_base.py b/dragonpy/components/cpu_utils/instruction_base.py deleted file mode 100644 index 007affe0..00000000 --- a/dragonpy/components/cpu_utils/instruction_base.py +++ /dev/null @@ -1,25 +0,0 @@ -#!/usr/bin/env python - -""" - DragonPy - Dragon 32 emulator in Python - ======================================= - - :copyleft: 2013-2014 by the DragonPy team, see AUTHORS for more details. - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - -from __future__ import absolute_import, division, print_function - - - -class InstructionBase(object): - def __init__(self, cpu, instr_func): - self.cpu = cpu - self.instr_func = instr_func - self.memory = cpu.memory - - def special(self, opcode): - # e.g: RESET and PAGE 1/2 - return self.instr_func(opcode) - - diff --git a/dragonpy/components/cpu_utils/instruction_call.py b/dragonpy/components/cpu_utils/instruction_call.py deleted file mode 100644 index ff29393e..00000000 --- a/dragonpy/components/cpu_utils/instruction_call.py +++ /dev/null @@ -1,548 +0,0 @@ - -""" - This file was generated with: "Instruction_generator.py" - Please doen't change it directly ;) - - - :copyleft: 2013-2014 by the DragonPy team, see AUTHORS for more details. - :license: GNU GPL v3 or above, see LICENSE for more details. - -""" - - -from dragonpy.components.cpu_utils.instruction_base import InstructionBase - -class PrepagedInstructions(InstructionBase): - - def direct_read8(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_direct(), - ) - - def direct_A_read8(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_direct(), - register = self.cpu.accu_a, - ) - - def direct_B_read8(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_direct(), - register = self.cpu.accu_b, - ) - - def direct_ea(self, opcode): - self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_direct(), - ) - - def direct_ea_write8(self, opcode): - ea, value = self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_direct(), - ) - self.memory.write_byte(ea, value) - - def direct_ea_read8_write8(self, opcode): - ea, m = self.cpu.get_ea_m_direct() - ea, value = self.instr_func( - opcode = opcode, - ea = ea, - m = m, - ) - self.memory.write_byte(ea, value) - - def direct_ea_A_write8(self, opcode): - ea, value = self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_direct(), - register = self.cpu.accu_a, - ) - self.memory.write_byte(ea, value) - - def direct_ea_B_write8(self, opcode): - ea, value = self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_direct(), - register = self.cpu.accu_b, - ) - self.memory.write_byte(ea, value) - - def direct_ea_D_write16(self, opcode): - ea, value = self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_direct(), - register = self.cpu.accu_d, - ) - self.memory.write_word(ea, value) - - def direct_ea_S_write16(self, opcode): - ea, value = self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_direct(), - register = self.cpu.system_stack_pointer, - ) - self.memory.write_word(ea, value) - - def direct_ea_U_write16(self, opcode): - ea, value = self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_direct(), - register = self.cpu.user_stack_pointer, - ) - self.memory.write_word(ea, value) - - def direct_ea_X_write16(self, opcode): - ea, value = self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_direct(), - register = self.cpu.index_x, - ) - self.memory.write_word(ea, value) - - def direct_ea_Y_write16(self, opcode): - ea, value = self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_direct(), - register = self.cpu.index_y, - ) - self.memory.write_word(ea, value) - - def direct_word_D_read16(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_direct_word(), - register = self.cpu.accu_d, - ) - - def direct_word_S_read16(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_direct_word(), - register = self.cpu.system_stack_pointer, - ) - - def direct_word_U_read16(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_direct_word(), - register = self.cpu.user_stack_pointer, - ) - - def direct_word_X_read16(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_direct_word(), - register = self.cpu.index_x, - ) - - def direct_word_Y_read16(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_direct_word(), - register = self.cpu.index_y, - ) - - def extended_read8(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_extended(), - ) - - def extended_A_read8(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_extended(), - register = self.cpu.accu_a, - ) - - def extended_B_read8(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_extended(), - register = self.cpu.accu_b, - ) - - def extended_ea(self, opcode): - self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_extended(), - ) - - def extended_ea_write8(self, opcode): - ea, value = self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_extended(), - ) - self.memory.write_byte(ea, value) - - def extended_ea_read8_write8(self, opcode): - ea, m = self.cpu.get_ea_m_extended() - ea, value = self.instr_func( - opcode = opcode, - ea = ea, - m = m, - ) - self.memory.write_byte(ea, value) - - def extended_ea_A_write8(self, opcode): - ea, value = self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_extended(), - register = self.cpu.accu_a, - ) - self.memory.write_byte(ea, value) - - def extended_ea_B_write8(self, opcode): - ea, value = self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_extended(), - register = self.cpu.accu_b, - ) - self.memory.write_byte(ea, value) - - def extended_ea_D_write16(self, opcode): - ea, value = self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_extended(), - register = self.cpu.accu_d, - ) - self.memory.write_word(ea, value) - - def extended_ea_S_write16(self, opcode): - ea, value = self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_extended(), - register = self.cpu.system_stack_pointer, - ) - self.memory.write_word(ea, value) - - def extended_ea_U_write16(self, opcode): - ea, value = self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_extended(), - register = self.cpu.user_stack_pointer, - ) - self.memory.write_word(ea, value) - - def extended_ea_X_write16(self, opcode): - ea, value = self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_extended(), - register = self.cpu.index_x, - ) - self.memory.write_word(ea, value) - - def extended_ea_Y_write16(self, opcode): - ea, value = self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_extended(), - register = self.cpu.index_y, - ) - self.memory.write_word(ea, value) - - def extended_word_D_read16(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_extended_word(), - register = self.cpu.accu_d, - ) - - def extended_word_S_read16(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_extended_word(), - register = self.cpu.system_stack_pointer, - ) - - def extended_word_U_read16(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_extended_word(), - register = self.cpu.user_stack_pointer, - ) - - def extended_word_X_read16(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_extended_word(), - register = self.cpu.index_x, - ) - - def extended_word_Y_read16(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_extended_word(), - register = self.cpu.index_y, - ) - - def immediate_read8(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_immediate(), - ) - - def immediate_A_read8(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_immediate(), - register = self.cpu.accu_a, - ) - - def immediate_B_read8(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_immediate(), - register = self.cpu.accu_b, - ) - - def immediate_CC_read8(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_immediate(), - register = self.cpu.cc, - ) - - def immediate_S_read8(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_immediate(), - register = self.cpu.system_stack_pointer, - ) - - def immediate_U_read8(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_immediate(), - register = self.cpu.user_stack_pointer, - ) - - def immediate_word_D_read16(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_immediate_word(), - register = self.cpu.accu_d, - ) - - def immediate_word_S_read16(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_immediate_word(), - register = self.cpu.system_stack_pointer, - ) - - def immediate_word_U_read16(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_immediate_word(), - register = self.cpu.user_stack_pointer, - ) - - def immediate_word_X_read16(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_immediate_word(), - register = self.cpu.index_x, - ) - - def immediate_word_Y_read16(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_immediate_word(), - register = self.cpu.index_y, - ) - - def indexed_read8(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_indexed(), - ) - - def indexed_A_read8(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_indexed(), - register = self.cpu.accu_a, - ) - - def indexed_B_read8(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_indexed(), - register = self.cpu.accu_b, - ) - - def indexed_ea(self, opcode): - self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_indexed(), - ) - - def indexed_ea_write8(self, opcode): - ea, value = self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_indexed(), - ) - self.memory.write_byte(ea, value) - - def indexed_ea_read8_write8(self, opcode): - ea, m = self.cpu.get_ea_m_indexed() - ea, value = self.instr_func( - opcode = opcode, - ea = ea, - m = m, - ) - self.memory.write_byte(ea, value) - - def indexed_ea_A_write8(self, opcode): - ea, value = self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_indexed(), - register = self.cpu.accu_a, - ) - self.memory.write_byte(ea, value) - - def indexed_ea_B_write8(self, opcode): - ea, value = self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_indexed(), - register = self.cpu.accu_b, - ) - self.memory.write_byte(ea, value) - - def indexed_ea_D_write16(self, opcode): - ea, value = self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_indexed(), - register = self.cpu.accu_d, - ) - self.memory.write_word(ea, value) - - def indexed_ea_S(self, opcode): - self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_indexed(), - register = self.cpu.system_stack_pointer, - ) - - def indexed_ea_S_write16(self, opcode): - ea, value = self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_indexed(), - register = self.cpu.system_stack_pointer, - ) - self.memory.write_word(ea, value) - - def indexed_ea_U(self, opcode): - self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_indexed(), - register = self.cpu.user_stack_pointer, - ) - - def indexed_ea_U_write16(self, opcode): - ea, value = self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_indexed(), - register = self.cpu.user_stack_pointer, - ) - self.memory.write_word(ea, value) - - def indexed_ea_X(self, opcode): - self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_indexed(), - register = self.cpu.index_x, - ) - - def indexed_ea_X_write16(self, opcode): - ea, value = self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_indexed(), - register = self.cpu.index_x, - ) - self.memory.write_word(ea, value) - - def indexed_ea_Y(self, opcode): - self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_indexed(), - register = self.cpu.index_y, - ) - - def indexed_ea_Y_write16(self, opcode): - ea, value = self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_indexed(), - register = self.cpu.index_y, - ) - self.memory.write_word(ea, value) - - def indexed_word_D_read16(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_indexed_word(), - register = self.cpu.accu_d, - ) - - def indexed_word_S_read16(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_indexed_word(), - register = self.cpu.system_stack_pointer, - ) - - def indexed_word_U_read16(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_indexed_word(), - register = self.cpu.user_stack_pointer, - ) - - def indexed_word_X_read16(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_indexed_word(), - register = self.cpu.index_x, - ) - - def indexed_word_Y_read16(self, opcode): - self.instr_func( - opcode = opcode, - m = self.cpu.get_m_indexed_word(), - register = self.cpu.index_y, - ) - - def inherent(self, opcode): - self.instr_func( - opcode = opcode, - ) - - def inherent_A(self, opcode): - self.instr_func( - opcode = opcode, - register = self.cpu.accu_a, - ) - - def inherent_B(self, opcode): - self.instr_func( - opcode = opcode, - register = self.cpu.accu_b, - ) - - def relative_ea(self, opcode): - self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_relative(), - ) - - def relative_word_ea(self, opcode): - self.instr_func( - opcode = opcode, - ea = self.cpu.get_ea_relative_word(), - ) - diff --git a/dragonpy/components/cpu_utils/instruction_caller.py b/dragonpy/components/cpu_utils/instruction_caller.py deleted file mode 100644 index e78e763f..00000000 --- a/dragonpy/components/cpu_utils/instruction_caller.py +++ /dev/null @@ -1,91 +0,0 @@ -#!/usr/bin/env python - -""" - DragonPy - Dragon 32 emulator in Python - ======================================= - - :copyleft: 2013-2014 by the DragonPy team, see AUTHORS for more details. - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - -from __future__ import absolute_import, division, print_function - -import inspect - -from dragonpy.components.MC6809data.MC6809_data_utils import MC6809OP_DATA_DICT -from dragonpy.components.cpu_utils.Instruction_generator import func_name_from_op_code -from dragonpy.components.cpu_utils.instruction_call import PrepagedInstructions -from dragonpy.components.cpu6809_trace import InstructionTrace - - -class OpCollection(object): - def __init__(self, cpu): - self.cpu = cpu - self.opcode_dict = {} - self.collect_ops() - - def get_opcode_dict(self): - return self.opcode_dict - - def collect_ops(self): - # Get the members not from class instance, so that's possible to - # exclude properties without "activate" them. - cls = type(self.cpu) - for name, cls_method in inspect.getmembers(cls): - if name.startswith("_") or isinstance(cls_method, property): - continue - - try: - opcodes = getattr(cls_method, "_opcodes") - except AttributeError: - continue - - instr_func = getattr(self.cpu, name) - self._add_ops(opcodes, instr_func) - - def _add_ops(self, opcodes, instr_func): -# log.debug("%20s: %s" % ( -# instr_func.__name__, ",".join(["$%x" % c for c in opcodes]) -# )) - for op_code in opcodes: - assert op_code not in self.opcode_dict, \ - "Opcode $%x (%s) defined more then one time!" % ( - op_code, instr_func.__name__ - ) - - op_code_data = MC6809OP_DATA_DICT[op_code] - - func_name = func_name_from_op_code(op_code) - - if self.cpu.cfg.trace: - InstructionClass = InstructionTrace - else: - InstructionClass = PrepagedInstructions - - instrution_class = InstructionClass(self.cpu, instr_func) - func = getattr(instrution_class, func_name) - - self.opcode_dict[op_code] = (op_code_data["cycles"], func) - - -if __name__ == "__main__": - from dragonpy.components.cpu6809 import CPU - from dragonpy.tests.test_base import BaseCPUTestCase - from dragonpy.Dragon32.config import Dragon32Cfg - from dragonpy.components.memory import Memory - - cmd_args = BaseCPUTestCase.UNITTEST_CFG_DICT - cfg = Dragon32Cfg(cmd_args) - memory = Memory(cfg) - cpu = CPU(memory, cfg) - - for op_code, data in sorted(cpu.opcode_dict.items()): - cycles, func = data - if op_code > 0xff: - op_code = "$%04x" % op_code - else: - op_code = " $%02x" % op_code - - print("Op %s - cycles: %2i - func: %s" % (op_code, cycles, func.__name__)) - - print(" --- END --- ") diff --git a/dragonpy/core/base_cli.py b/dragonpy/core/base_cli.py deleted file mode 100755 index 2f81c473..00000000 --- a/dragonpy/core/base_cli.py +++ /dev/null @@ -1,172 +0,0 @@ -#!/usr/bin/env python2 -# coding: utf-8 - -""" - base commandline interface - ========================== - - :created: 2013 by Jens Diemer - www.jensdiemer.de - :copyleft: 2013-2014 by the DragonPy team, see AUTHORS for more details. - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - -from __future__ import absolute_import, division, print_function - - -import argparse -import sys -import logging -from dragonlib.utils.logging_utils import setup_logging, LOG_LEVELS - -log = logging.getLogger(__name__) - - -class ActionLogList(argparse.Action): - def __call__(self, parser, namespace, values, option_string=None): - print("A list of all loggers:") - for log_name in sorted(logging.Logger.manager.loggerDict): - print("\t%s" % log_name) - parser.exit() - - -class Base_CLI(object): - DESCRIPTION = None - EPOLOG = None - VERSION = None -# DEFAULT_LOG_FORMATTER = "%(message)s" -# DEFAULT_LOG_FORMATTER = "%(processName)s/%(threadName)s %(message)s" -# DEFAULT_LOG_FORMATTER = "[%(processName)s %(threadName)s] %(message)s" -# DEFAULT_LOG_FORMATTER = "[%(levelname)s %(asctime)s %(module)s] %(message)s" -# DEFAULT_LOG_FORMATTER = "%(levelname)8s %(created)f %(module)-12s %(message)s" - DEFAULT_LOG_FORMATTER = "%(relativeCreated)-5d %(levelname)8s %(module)13s %(lineno)d %(message)s" - - def __init__(self): - self.logfilename = None - - arg_kwargs = {} - if self.DESCRIPTION is not None: - arg_kwargs["description"] = self.DESCRIPTION - if self.EPOLOG is not None: - arg_kwargs["epilog"] = self.EPOLOG - - self.parser = argparse.ArgumentParser(**arg_kwargs) - - if self.VERSION is not None: - self.parser.add_argument('--version', action='version', - version='%%(prog)s %s' % self.VERSION - ) - - self.parser.add_argument("--log", - nargs="*", - help="Setup loggers, e.g.: --log DragonPy.cpu6809,50 dragonpy.Dragon32.MC6821_PIA,10" - ) - - self.parser.register('action', "log_list", ActionLogList) - self.parser.add_argument("-l", "--log_list", - action="log_list", nargs=0, - help="List all exiting loggers and exit." - ) - - self.parser.add_argument("--verbosity", - type=int, choices=LOG_LEVELS, default=logging.CRITICAL, - help=( - "verbosity level to stdout (lower == more output!)" - " (default: %s)" % logging.INFO - ) - ) - self.parser.add_argument("--log_formatter", - default=self.DEFAULT_LOG_FORMATTER, - help=( - "see: http://docs.python.org/2/library/logging.html#logrecord-attributes" - ) - ) - - def parse_args(self, args=None): - if self.DESCRIPTION is not None: - print() - print(self.DESCRIPTION, self.VERSION) - print("-"*79) - print() - - args = self.parser.parse_args(args) - -# for arg, value in sorted(vars(args).items()): -# log.debug("argument %s: %r", arg, value) -# print "argument %s: %r" % (arg, value) - - return args - - def setup_logging(self, args): - handler = logging.StreamHandler() - - # Setup root logger - setup_logging( - level=args.verbosity, - logger_name=None, # Use root logger - handler=handler, - log_formatter=args.log_formatter - ) - - if args.log is None: - return - - # Setup given loggers - for logger_cfg in args.log: - logger_name, level = logger_cfg.rsplit(",", 1) - level = int(level) - - setup_logging( - level=level, - logger_name=logger_name, - handler=handler, - log_formatter=args.log_formatter - ) - - - -#------------------------------------------------------------------------------ - - -def test_run(): - import os - import subprocess - cmd_args = [ - sys.executable, - os.path.join("..", "DragonPy_CLI.py"), -# "--version", -# "-h" -# "--log_list", - "--verbosity", "50", - "--log", - "DragonPy.cpu6809,10", - "dragonpy.Dragon32.MC6821_PIA,99", - "dragonpy.Dragon32.MC6883_SAM,40", - -# "--verbosity", " 1", # hardcode DEBUG ;) -# "--verbosity", "10", # DEBUG -# "--verbosity", "20", # INFO -# "--verbosity", "30", # WARNING -# "--verbosity", "40", # ERROR -# "--verbosity", "50", # CRITICAL/FATAL -# "--verbosity", "99", # nearly all off - "--machine", "Dragon32", "run", -# "--machine", "Vectrex", "run", -# "--max_ops", "1", -# "--trace", - ] - print("Startup CLI with: %s" % " ".join(cmd_args[1:])) - subprocess.Popen(cmd_args, cwd="..").wait() - - -if __name__ == "__main__": - import doctest - print(doctest.testmod( - verbose=False - # verbose=True - )) - -# cli = Base_CLI() -# cli.parse_args(args=["--help"]) -# cli.parse_args(args=["--log_list"]) - - test_run() diff --git a/dragonpy/core/bechmark.py b/dragonpy/core/bechmark.py deleted file mode 100644 index d1f0db95..00000000 --- a/dragonpy/core/bechmark.py +++ /dev/null @@ -1,119 +0,0 @@ -#!/usr/bin/env python -# encoding:utf8 - -""" - DragonPy - Dragon 32 emulator in Python - ======================================= - - :created: 2014 by Jens Diemer - www.jensdiemer.de - :copyleft: 2014 by the DragonPy team, see AUTHORS for more details. - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - -from __future__ import absolute_import, division, print_function -from dragonlib.utils import six -xrange = six.moves.xrange - -import binascii -import io -import locale -import string -import time -import unittest -import logging - -from dragonlib.utils import six -from dragonpy.tests.test_6809_program import Test6809_Program, \ - Test6809_Program_Division2 -from dragonpy.utils.humanize import locale_format_number - - -log = logging.getLogger(__name__) - - -class Test6809_Program2(Test6809_Program): - def runTest(self): - pass - - def bench(self, loops, multiply, func, msg): - print("\n%s benchmark" % msg) - - self.setUp() - self.cpu.cycles = 0 - - txt = string.printable - - if six.PY3: - txt = bytes(txt, encoding="UTF-8") - - txt = txt * multiply - - print("\nStart %i %s loops with %i Bytes test string..." % ( - loops, msg, len(txt) - )) - - start_time = time.time() - for __ in xrange(loops): - self._crc32(txt) - duration = time.time() - start_time - - print("%s benchmark runs %s CPU cycles in %.2f sec" % ( - msg, locale_format_number(self.cpu.cycles), duration - )) - - return duration, self.cpu.cycles - - def crc32_benchmark(self, loops): - return self.bench(loops, 10, self._crc32, "CRC32") - - def crc16_benchmark(self, loops): - return self.bench(loops, 20, self._crc16, "CRC16") - - - -def run_benchmark(loops): - total_duration = 0 - total_cycles = 0 - bench_class = Test6809_Program2() - - #-------------------------------------------------------------------------- - - duration, cycles = bench_class.crc16_benchmark(loops) - total_duration += duration - total_cycles += cycles - - #-------------------------------------------------------------------------- - - duration, cycles = bench_class.crc32_benchmark(loops) - total_duration += duration - total_cycles += cycles - - #-------------------------------------------------------------------------- - print("-"*79) - print("\nTotal of %i benchmak loops run in %.2f sec %s CPU cycles." % ( - loops, total_duration, locale_format_number(total_cycles) - )) - print("\tavg.: %s CPU cycles/sec" % locale_format_number(total_cycles / total_duration)) - - -if __name__ == '__main__': - from dragonlib.utils.logging_utils import setup_logging - - setup_logging(log, -# level=1 # hardcore debug ;) -# level=10 # DEBUG -# level=20 # INFO -# level=30 # WARNING -# level=40 # ERROR - level=50 # CRITICAL/FATAL - ) - - # will be done in CLI: - locale.setlocale(locale.LC_ALL, '') # For Formating cycles/sec number - - run_benchmark( - loops=1 -# loops=2 -# loops=10 - ) - print(" --- END --- ") diff --git a/dragonpy/core/cli.py b/dragonpy/core/cli.py new file mode 100755 index 00000000..14a2f59e --- /dev/null +++ b/dragonpy/core/cli.py @@ -0,0 +1,196 @@ +#!/usr/bin/env python2 +# coding: utf-8 + +""" + DragonPy - CLI + ~~~~~~~~~~~~~~ + + :created: 2013 by Jens Diemer - www.jensdiemer.de + :copyleft: 2013-2015 by the DragonPy team, see AUTHORS for more details. + :license: GNU GPL v3 or above, see LICENSE for more details. +""" + +from __future__ import absolute_import, division, print_function + + +import atexit +import locale +import logging +import unittest +from dragonpy.tests import run_tests + +try: + # https://pypi.python.org/pypi/click/ + import click +except ImportError as err: + print("\nERROR: 'click' can't be imported!") + print("\tIs the virtual environment activated?!?") + print("\tIs 'click' installed?!?") + print("\nOrigin error is:\n") + raise + + +from dragonlib.utils.logging_utils import setup_logging, LOG_LEVELS + +from basic_editor.editor import run_basic_editor + +import dragonpy +from dragonpy.CoCo.config import CoCo2bCfg +from dragonpy.CoCo.machine import run_CoCo2b +from dragonpy.Dragon32.config import Dragon32Cfg +from dragonpy.Dragon32.machine import run_Dragon32 +from dragonpy.Dragon64.config import Dragon64Cfg +from dragonpy.Dragon64.machine import run_Dragon64 +from dragonpy.Multicomp6809.config import Multicomp6809Cfg +from dragonpy.Multicomp6809.machine import run_Multicomp6809 +from dragonpy.core import configs +from dragonpy.core.configs import machine_dict +from dragonpy.sbc09.config import SBC09Cfg +from dragonpy.sbc09.machine import run_sbc09 +from dragonpy.vectrex.config import VectrexCfg +from dragonpy.vectrex.machine import run_Vectrex + + +log = logging.getLogger(__name__) + + +# DEFAULT_LOG_FORMATTER = "%(message)s" +# DEFAULT_LOG_FORMATTER = "%(processName)s/%(threadName)s %(message)s" +# DEFAULT_LOG_FORMATTER = "[%(processName)s %(threadName)s] %(message)s" +# DEFAULT_LOG_FORMATTER = "[%(levelname)s %(asctime)s %(module)s] %(message)s" +# DEFAULT_LOG_FORMATTER = "%(levelname)8s %(created)f %(module)-12s %(message)s" +DEFAULT_LOG_FORMATTER = "%(relativeCreated)-5d %(levelname)8s %(module)13s %(lineno)d %(message)s" + + +machine_dict.register(configs.DRAGON32, (run_Dragon32, Dragon32Cfg), default=True) +machine_dict.register(configs.DRAGON64, (run_Dragon64, Dragon64Cfg)) +machine_dict.register(configs.COCO2B, (run_CoCo2b, CoCo2bCfg)) +machine_dict.register(configs.SBC09, (run_sbc09,SBC09Cfg)) +# machine_dict.register(configs.SIMPLE6809, Simple6809Cfg) +machine_dict.register(configs.MULTICOMP6809, (run_Multicomp6809, Multicomp6809Cfg)) +machine_dict.register(configs.VECTREX, (run_Vectrex, VectrexCfg)) + + +# use user's preferred locale +# e.g.: for formating cycles/sec number +locale.setlocale(locale.LC_ALL, '') + + +@atexit.register +def goodbye(): + print("\n --- END --- \n") + + + +class CliConfig(object): + def __init__(self, machine, log, verbosity, log_formatter): + self.machine = machine + self.log = log + self.verbosity=int(verbosity) + self.log_formatter=log_formatter + + self.setup_logging() + + self.cfg_dict = { + "verbosity":self.verbosity, + "trace":None, + } + machine_name = self.machine + self.machine_run_func, self.machine_cfg = machine_dict[machine] + + def setup_logging(self): + handler = logging.StreamHandler() + + # Setup root logger + setup_logging( + level=self.verbosity, + logger_name=None, # Use root logger + handler=handler, + log_formatter=self.log_formatter + ) + + if self.log is None: + return + + # Setup given loggers + for logger_cfg in self.log: + logger_name, level = logger_cfg.rsplit(",", 1) + level = int(level) + + setup_logging( + level=level, + logger_name=logger_name, + handler=handler, + log_formatter=self.log_formatter + ) + +cli_config = click.make_pass_decorator(CliConfig) + + +@click.group() +@click.version_option(dragonpy.__version__) +@click.option("--machine", + type=click.Choice(sorted(machine_dict.keys())), + default=machine_dict.DEFAULT, + help="Used machine configuration (Default: %s)" % machine_dict.DEFAULT) +@click.option("--log", default=False, multiple=True, + help="Setup loggers, e.g.: --log DragonPy.cpu6809,50 --log dragonpy.Dragon32.MC6821_PIA,10") +@click.option("--verbosity", + type=click.Choice(["%i" % level for level in LOG_LEVELS]), + default="%i" % logging.CRITICAL, + help="verbosity level to stdout (lower == more output! default: %s)" % logging.INFO) +@click.option("--log_formatter", default=DEFAULT_LOG_FORMATTER, + help="see: http://docs.python.org/2/library/logging.html#logrecord-attributes") +@click.pass_context +def cli(ctx, **kwargs): + """ + DragonPy is a Open source (GPL v3 or later) emulator + for the 30 years old homecomputer Dragon 32 + and Tandy TRS-80 Color Computer (CoCo)... + + Homepage: https://github.com/jedie/DragonPy + """ + log.critical("cli kwargs: %s", repr(kwargs)) + ctx.obj = CliConfig(**kwargs) + + +@cli.command(help="Run only the BASIC editor") +@cli_config +def editor(cli_config): + log.critical("Use machine cfg: %s", cli_config.machine_cfg.__name__) + cfg = cli_config.machine_cfg(cli_config.cfg_dict) + run_basic_editor(cfg) + + +@cli.command(help="Run a machine emulation") +@click.option("--trace", default=False, + help="Create trace lines." +) +@click.option("--ram", default=None, help="RAM file to load (default none)") +@click.option("--rom", default=None, help="ROM file to use (default set by machine configuration)") +@click.option("--max_ops", default=None, type=int, + help="If given: Stop CPU after given cycles else: run forever") +@cli_config +def run(cli_config, **kwargs): + log.critical("Use machine func: %s", cli_config.machine_run_func.__name__) + log.critical("cli run kwargs: %s", repr(kwargs)) + cli_config.cfg_dict.update(kwargs) + cli_config.machine_run_func(cli_config.cfg_dict) + + +@cli.command(help="List all exiting loggers and exit.") +def log_list(): + print("A list of all loggers:") + for log_name in sorted(logging.Logger.manager.loggerDict): + print("\t%s" % log_name) + + +@cli.command(help="Run unittests") +@click.option('--verbosity', default=2, help='Number for verbosity settings') +@click.option('--failfast', default=False, help='Number for verbosity settings', is_flag=True) +def tests(verbosity, failfast): + run_tests(verbosity, failfast) + + +if __name__ == "__main__": + cli() \ No newline at end of file diff --git a/dragonpy/core/cpu_control_server.py b/dragonpy/core/cpu_control_server.py deleted file mode 100644 index f164f5bd..00000000 --- a/dragonpy/core/cpu_control_server.py +++ /dev/null @@ -1,299 +0,0 @@ -#!/usr/bin/env python -# coding: utf-8 - -""" - DragonPy - CPU control http server - ================================== - - TODO: Use bottle! - - :copyleft: 2013-2014 by the DragonPy team, see AUTHORS for more details. - :license: GNU GPL v3 or above, see LICENSE for more details. - - Based on: - * ApplyPy by James Tauber (MIT license) - * XRoar emulator by Ciaran Anscomb (GPL license) - more info, see README -""" - -from __future__ import absolute_import, division, print_function -from dragonlib.utils import six -xrange = six.moves.xrange - -try: - from http.server import BaseHTTPRequestHandler # Python 3 -except ImportError: - from BaseHTTPServer import BaseHTTPRequestHandler # Python 2 - -import json -import logging -import os -import re -import select -import sys -import threading -import traceback - -import logging - -log=logging.getLogger(__name__) - - -class ControlHandler(BaseHTTPRequestHandler): - - def __init__(self, request, client_address, server, cpu): - log.error("ControlHandler %s %s %s", request, client_address, server) - self.cpu = cpu - - self.get_urls = { - r"/disassemble/(\s+)/$": self.get_disassemble, - r"/memory/(\s+)(-(\s+))?/$": self.get_memory, - r"/memory/(\s+)(-(\s+))?/raw/$": self.get_memory_raw, - r"/status/$": self.get_status, - r"/$": self.get_index, - } - - self.post_urls = { - r"/memory/(\s+)(-(\s+))?/$": self.post_memory, - r"/memory/(\s+)(-(\s+))?/raw/$": self.post_memory_raw, - r"/quit/$": self.post_quit, - r"/reset/$": self.post_reset, - r"/debug/$": self.post_debug, - } - - BaseHTTPRequestHandler.__init__(self, request, client_address, server) - - def log_message(self, format, *args): - msg = "%s - - [%s] %s\n" % ( - self.client_address[0], self.log_date_time_string(), format % args - ) - log.critical(msg) - - def dispatch(self, urls): - for r, f in list(urls.items()): - m = re.match(r, self.path) - if m is not None: - log.critical("call %s", f.__name__) - try: - f(m) - except Exception as err: - txt = traceback.format_exc() - self.response_500("Error call %r: %s" % (f.__name__, err), txt) - return - else: - self.response_404("url %r doesn't match any urls" % self.path) - - def response(self, s, status_code=200): - log.critical("send %s response", status_code) - self.send_response(status_code) - self.send_header("Content-Length", str(len(s))) - self.end_headers() - self.wfile.write(s) - - def response_html(self, headline, text=""): - html = ( - "" - "

%s

" - "%s" - "" - ) % (headline, text) - self.response(html) - - def response_404(self, txt): - log.error(txt) - html = ( - "" - "

DragonPy - 6809 CPU control server

" - "

404 - Error:

" - "

%s

" - "" - ) % txt - self.response(html, status_code=404) - - def response_500(self, err, tb_txt): - log.error(err, tb_txt) - html = ( - "" - "

DragonPy - 6809 CPU control server

" - "

500 - Error:

" - "

%s

" - "
%s
" - "" - ) % (err, tb_txt) - self.response(html, status_code=500) - - def do_GET(self): - log.critical("do_GET(): %r", self.path) - self.dispatch(self.get_urls) - - def do_POST(self): - log.critical("do_POST(): %r", self.path) - self.dispatch(self.post_urls) - - def get_index(self, m): - self.response_html( - headline="DragonPy - 6809 CPU control server", - text=( - "

Example urls:" - "

' - '
' - '' - '
' - )) - - def get_disassemble(self, m): - addr = int(m.group(1)) - r = [] - n = 20 - while n > 0: - dis, length = self.disassemble.disasm(addr) - r.append(dis) - addr += length - n -= 1 - self.response(json.dumps(r)) - - def get_memory_raw(self, m): - addr = int(m.group(1)) - e = m.group(3) - if e is not None: - end = int(e) - else: - end = addr - self.response("".join([chr(self.cpu.read_byte(x)) for x in xrange(addr, end + 1)])) - - def get_memory(self, m): - addr = int(m.group(1), 16) - e = m.group(3) - if e is not None: - end = int(e, 16) - else: - end = addr - self.response(json.dumps(list(map(self.cpu.read_byte, list(range(addr, end + 1)))))) - - def get_status(self, m): - data = { - "cpu": self.cpu.get_info, - "cc": self.cpu.cc.get_info, - "pc": self.cpu.program_counter.get(), - "cycle_count": self.cpu.cycles, - } - log.critical("status dict: %s", repr(data)) - json_string = json.dumps(data) - self.response(json_string) - - def post_memory(self, m): - addr = int(m.group(1)) - e = m.group(3) - if e is not None: - end = int(e) - else: - end = addr - data = json.loads(self.rfile.read(int(self.headers["Content-Length"]))) - for i, a in enumerate(range(addr, end + 1)): - self.cpu.write_byte(a, data[i]) - self.response("") - - def post_memory_raw(self, m): - addr = int(m.group(1)) - e = m.group(3) - if e is not None: - end = int(e) - else: - end = addr - data = self.rfile.read(int(self.headers["Content-Length"])) - for i, a in enumerate(range(addr, end + 1)): - self.cpu.write_byte(a, data[i]) - self.response("") - - def post_debug(self, m): - handler = logging.StreamHandler() - handler.level = 5 - log.handlers = (handler,) - log.critical("Activate full debug logging in %s!", __file__) - self.response("") - - def post_quit(self, m): - log.critical("Quit CPU from controller server.") - self.cpu.quit() - self.response_html(headline="CPU running") - - def post_reset(self, m): - self.cpu.reset() - self.response_html(headline="CPU reset") - - -class ControlHandlerFactory: - def __init__(self, cpu): - self.cpu = cpu - def __call__(self, request, client_address, server): - return ControlHandler(request, client_address, server, self.cpu) - - -def control_server_thread(cpu, cfg, control_server): - # FIXME: Refactor this! - timeout = 1 - - sockets = [control_server] - rs, _, _ = select.select(sockets, [], [], timeout) - for s in rs: - if s is control_server: - control_server._handle_request_noblock() - else: - pass - - if cpu.running: - threading.Timer(interval=0.5, - function=control_server_thread, - args=(cpu, cfg, control_server) - ).start() - else: - log.critical("Quit control server thread, because CPU doesn't run.") - -def start_http_control_server(cpu, cfg): - log.critical("TODO: What's with CPU control server???") - return - - if not cfg.cfg_dict["use_bus"]: - log.info("Don't init CPU control server, ok.") - return None - - control_handler = ControlHandlerFactory(cpu) - server_address = (cfg.CPU_CONTROL_ADDR, cfg.CPU_CONTROL_PORT) - try: - control_server = http.server.HTTPServer(server_address, control_handler) - except: - cpu.running = False - raise - url = "http://%s:%s" % server_address - log.error("Start http control server on: %s", url) - - control_server_thread(cpu, cfg, control_server) - - -def test_run(): - print("test run...") - import subprocess - cmd_args = [sys.executable, - os.path.join("..", "..", "DragonPy_CLI.py"), -# "--verbosity=5", -# "--verbosity=10", # DEBUG -# "--verbosity=20", # INFO -# "--verbosity=30", # WARNING -# "--verbosity=40", # ERROR - "--verbosity=50", # CRITICAL/FATAL -# "--machine=sbc09", - "--machine=Simple6809", -# "--machine=Dragon32", -# "--machine=Multicomp6809", -# "--max=100000", - "--display_cycle", - ] - print("Startup CLI with: %s" % " ".join(cmd_args[1:])) - subprocess.Popen(cmd_args).wait() - -if __name__ == "__main__": - test_run() diff --git a/dragonpy/core/machine.py b/dragonpy/core/machine.py index d5453570..c453b090 100644 --- a/dragonpy/core/machine.py +++ b/dragonpy/core/machine.py @@ -18,7 +18,7 @@ import logging log=logging.getLogger(__name__) -from dragonpy.components.cpu6809 import CPU +from MC6809.components.cpu6809 import CPU from dragonpy.components.memory import Memory from dragonpy.utils.simple_debugger import print_exc_plus diff --git a/dragonpy/core/memory_info.py b/dragonpy/core/memory_info.py deleted file mode 100644 index ecdbae5a..00000000 --- a/dragonpy/core/memory_info.py +++ /dev/null @@ -1,66 +0,0 @@ -#!/usr/bin/env python - -""" - DragonPy - base memory info - ~~~~~~~~~~~~~~~~~~~~~~~~~~~ - - :created: 2013 by Jens Diemer - www.jensdiemer.de - :copyleft: 2013 by the DragonPy team, see AUTHORS for more details. - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - -from __future__ import absolute_import, division, print_function - - -import sys - -class BaseMemoryInfo(object): - def __init__(self, out_func): - self.out_func = out_func - - def get_shortest(self, addr): - shortest = None - size = sys.maxsize - for start, end, txt in self.MEM_INFO: - if not start <= addr <= end: - continue - - current_size = abs(end - start) - if current_size < size: - size = current_size - shortest = start, end, txt - - if shortest is None: - return "$%x: UNKNOWN" % addr - - start, end, txt = shortest - if start == end: - return "$%x: %s" % (addr, txt) - else: - return "$%x: $%x-$%x - %s" % (addr, start, end, txt) - - def __call__(self, addr, info="", shortest=True): - if shortest: - mem_info = self.get_shortest(addr) - if info: - self.out_func("%s: %s" % (info, mem_info)) - else: - self.out_func(mem_info) - return - - mem_info = [] - for start, end, txt in self.MEM_INFO: - if start <= addr <= end: - mem_info.append( - (start, end, txt) - ) - - if not mem_info: - self.out_func("%s $%x: UNKNOWN" % (info, addr)) - else: - self.out_func("%s $%x:" % (info, addr)) - for start, end, txt in mem_info: - if start == end: - self.out_func(" * $%x - %s" % (start, txt)) - else: - self.out_func(" * $%x-$%x - %s" % (start, end, txt)) diff --git a/dragonpy/sbc09/create_trace.py b/dragonpy/sbc09/create_trace.py index 499c55f3..ce2cb4c8 100644 --- a/dragonpy/sbc09/create_trace.py +++ b/dragonpy/sbc09/create_trace.py @@ -22,7 +22,7 @@ import threading import time -from dragonpy.components.MC6809data.MC6809_data_utils import MC6809OP_DATA_DICT +from MC6809.components.MC6809data.MC6809_data_utils import MC6809OP_DATA_DICT from dragonpy.utils.humanize import cc_value2txt from dragonpy.sbc09.mem_info import SBC09MemInfo diff --git a/dragonpy/sbc09/mem_info.py b/dragonpy/sbc09/mem_info.py index 380f3425..4ec92e75 100644 --- a/dragonpy/sbc09/mem_info.py +++ b/dragonpy/sbc09/mem_info.py @@ -14,7 +14,7 @@ import logging -from dragonpy.core.memory_info import BaseMemoryInfo +from MC6809.core.memory_info import BaseMemoryInfo log = logging.getLogger("DragonPy.sbc09.mem_info") diff --git a/dragonpy/tests/LST2Unittest.py b/dragonpy/tests/LST2Unittest.py deleted file mode 100644 index 00c50f6c..00000000 --- a/dragonpy/tests/LST2Unittest.py +++ /dev/null @@ -1,152 +0,0 @@ -#!/usr/bin/env python -# coding: utf-8 - -# copy&paste .lst content from e.g.: http://www.asm80.com/ -lst = """ -0000 D6 4F LDB $4f -0002 F7 10 4F STB $104f -0005 D6 50 LDB $50 -0007 F7 10 50 STB $1050 -000A D6 51 LDB $51 -000C F7 10 51 STB $1051 -000F D6 52 LDB $52 -0011 F7 10 52 STB $1052 -0014 D6 53 LDB $53 -0016 F7 10 53 STB $1053 -0019 D6 54 LDB $54 -001B F7 10 54 STB $1054 -""" - -lines = [] -for line in lst.strip().splitlines(): - address = line[:4] - - hex_list = line[7:30] - lable = "" - if ":" in hex_list: - hex_list = hex_list.strip() - try: - hex_list, lable = hex_list.strip().rsplit(" ", 1) - except ValueError: - lable = hex_list - hex_list = "" - else: - lable = lable.strip() - - hex_list = hex_list.strip().split(" ") - hex_list = [int(i, 16) for i in hex_list if i] - - code1 = line[30:].strip() - doc = "" - if ";" in code1: - code1, doc = code1.split(";", 1) - code1 = code1.strip() - - code2 = "" - if " " in code1: - code1, code2 = code1.split(" ", 1) - code1 = code1.strip() - code2 = code2.strip() - - # for BASIC - lines.append({ - "hex_list":hex_list, - "address":address, - "lable":lable, - "code1":code1, - "code2":code2, - "doc":doc, - }) - - - - -def print_unittest1(lines): - print(" self.cpu_test_run(start=0x0100, end=None, mem=[") - for line in lines: - hex_list = line["hex_list"] - address = line["address"] - lable = line["lable"] - code1 = line["code1"] - code2 = line["code2"] - doc = line["doc"] - - hex_list = ", ".join(["0x%02x" % i for i in hex_list]) - if hex_list: - hex_list += ", #" - else: - hex_list += "#" - - line = " %-20s %s|%6s %-5s %-8s" % ( - hex_list, address, lable, code1, code2 - ) - if doc: - line = "%40s ; %s" % (line, doc) - print(line.rstrip()) - print(" ])") - - -def print_unittest2(lines): - print(" self.cpu_test_run(start=0x0100, end=None, mem=[") - for line in lines: - hex_list = line["hex_list"] - address = line["address"] - lable = line["lable"] - code1 = line["code1"] - code2 = line["code2"] - doc = line["doc"] - - hex_list = ", ".join(["0x%02x" % i for i in hex_list]) - if hex_list: - hex_list += ", #" - else: - hex_list += "#" - - line = " %-20s %6s %-5s %-8s" % ( - hex_list, lable, code1, code2 - ) - if doc: - line = "%40s ; %s" % (line, doc) - print(line.rstrip()) - print(" ])") - - -def print_bas(lines, line_no): - for line in lines: - hex_list = line["hex_list"] - address = line["address"] - lable = line["lable"] - code1 = line["code1"] - code2 = line["code2"] - doc = line["doc"] - - line = "%s ' %s %s" % ( - line_no, code1, code2 - ) - if doc: - line = "%-20s ; %s" % (line, doc) - print(line.upper()) - line_no += 10 - - line = "%s DATA %s" % ( - line_no, - ",".join(["%x" % i for i in hex_list]) - ) - print(line.upper()) - line_no += 10 - - -print("-"*79) - -print_unittest1(lines) # with address - -print("-"*79) - -print_unittest2(lines) # without address - -print("-"*79) - -# for a basic file: -print_bas(lines, - line_no=1050 -) diff --git a/dragonpy/tests/__init__.py b/dragonpy/tests/__init__.py index e69de29b..c9e34beb 100644 --- a/dragonpy/tests/__init__.py +++ b/dragonpy/tests/__init__.py @@ -0,0 +1,22 @@ +import unittest + + +def get_tests(): + loader = unittest.TestLoader() + tests = loader.discover('.') + return tests + + +def run_tests(verbosity=2, failfast=False): + tests = get_tests() + + # test_runner = TextTestRunner2( + test_runner = unittest.TextTestRunner( + verbosity=verbosity, + failfast=failfast, + ) + test_runner.run(tests) + + +if __name__ == '__main__': + run_tests() \ No newline at end of file diff --git a/dragonpy/tests/test_6809_StoreLoad.py b/dragonpy/tests/test_6809_StoreLoad.py deleted file mode 100644 index 32fc9e01..00000000 --- a/dragonpy/tests/test_6809_StoreLoad.py +++ /dev/null @@ -1,88 +0,0 @@ -#!/usr/bin/env python -# encoding:utf-8 - -""" - 6809 unittests - ~~~~~~~~~~~~~~ - - Test store and load ops - - :created: 2014 by Jens Diemer - www.jensdiemer.de - :copyleft: 2014 by the DragonPy team, see AUTHORS for more details. - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - -from __future__ import absolute_import, division, print_function - -import logging -import sys -import unittest - -from dragonlib.utils.unittest_utils import TextTestRunner2 -from dragonpy.tests.test_base import BaseStackTestCase - - -log = logging.getLogger("DragonPy") - - -class Test6809_Store(BaseStackTestCase): - def test_STA_direct(self): - self.cpu.direct_page.set(0x41) - self.cpu.accu_a.set(0xad) - self.cpu_test_run(start=0x4000, end=None, mem=[0x97, 0xfe]) # STA <$fe (Direct) - self.assertEqualHex(self.cpu.memory.read_byte(0x41fe), 0xad) - - def test_STB_extended(self): - self.cpu.accu_b.set(0x81) - self.cpu_test_run(start=0x4000, end=None, mem=[0xF7, 0x50, 0x10]) # STB $5010 (Extended) - self.assertEqualHex(self.cpu.memory.read_byte(0x5010), 0x81) - - def test_STD_extended(self): - self.cpu.accu_d.set(0x4321) - self.cpu_test_run(start=0x4000, end=None, mem=[0xFD, 0x50, 0x01]) # STD $5001 (Extended) - self.assertEqualHex(self.cpu.memory.read_word(0x5001), 0x4321) - - def test_STS_indexed(self): - self.cpu.system_stack_pointer.set(0x1234) - self.cpu.index_x.set(0x0218) - self.cpu_test_run(start=0x1b5c, end=None, mem=[0x10, 0xef, 0x83]) # STS ,R-- (indexed) - self.assertEqualHex(self.cpu.memory.read_word(0x0216), 0x1234) # 0x0218 -2 = 0x0216 - - - -class Test6809_Load(BaseStackTestCase): - def test_LDD_immediate(self): - self.cpu.accu_d.set(0) - self.cpu_test_run(start=0x4000, end=None, mem=[0xCC, 0xfe, 0x12]) # LDD $fe12 (Immediate) - self.assertEqualHex(self.cpu.accu_d.get(), 0xfe12) - - def test_LDD_extended(self): - self.cpu.memory.write_word(0x5020, 0x1234) - self.cpu_test_run(start=0x4000, end=None, mem=[0xFC, 0x50, 0x20]) # LDD $5020 (Extended) - self.assertEqualHex(self.cpu.accu_d.get(), 0x1234) - - -if __name__ == '__main__': - log.setLevel( - 1 -# 10 # DEBUG -# 20 # INFO -# 30 # WARNING -# 40 # ERROR -# 50 # CRITICAL/FATAL - ) - log.addHandler(logging.StreamHandler()) - - # XXX: Disable hacked XRoar trace - import cpu6809; cpu6809.trace_file = None - - unittest.main( - argv=( - sys.argv[0], - "Test6809_Store.test_STS_indexed", - ), - testRunner=TextTestRunner2, -# verbosity=1, - verbosity=2, -# failfast=True, - ) diff --git a/dragonpy/tests/test_6809_address_modes.py b/dragonpy/tests/test_6809_address_modes.py deleted file mode 100644 index ca1ad8c9..00000000 --- a/dragonpy/tests/test_6809_address_modes.py +++ /dev/null @@ -1,251 +0,0 @@ -#!/usr/bin/env python -# encoding:utf-8 - -""" - 6809 unittests - ~~~~~~~~~~~~~~ - - Test store and load ops - - :created: 2014 by Jens Diemer - www.jensdiemer.de - :copyleft: 2014 by the DragonPy team, see AUTHORS for more details. - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - -from __future__ import absolute_import, division, print_function - -import logging -import sys -import unittest - -from dragonlib.utils.unittest_utils import TextTestRunner2 -from dragonpy.tests.test_base import BaseCPUTestCase - - -log = logging.getLogger("DragonPy") - - -class Test6809_AddressModes_LowLevel(BaseCPUTestCase): - def test_base_page_direct01(self): - self.cpu.memory.load(0x1000, [0x12, 0x34, 0x0f]) - self.cpu.program_counter.set(0x1000) - self.cpu.direct_page.set(0xab) - - ea = self.cpu.get_ea_direct() - self.assertEqualHexWord(ea, 0xab12) - - ea = self.cpu.get_ea_direct() - self.assertEqualHexWord(ea, 0xab34) - - self.cpu.direct_page.set(0x0) - ea = self.cpu.get_ea_direct() - self.assertEqualHexByte(ea, 0xf) - -class Test6809_AddressModes_Indexed(BaseCPUTestCase): - def test_5bit_signed_offset_01(self): - self.cpu.index_x.set(0x0300) - self.cpu.index_y.set(0x1234) - self.cpu_test_run(start=0x1b5c, end=None, mem=[0x10, 0xAF, 0x04]) # STY 4,X - self.assertEqualHexWord(self.cpu.memory.read_word(0x0304), 0x1234) # $0300 + $04 = $0304 - - def test_5bit_signed_offset_02(self): - """ - LDX #$abcd - LDY #$50 - STX -16,Y - """ - self.cpu.index_x.set(0xabcd) - self.cpu.index_y.set(0x0050) - self.cpu_test_run(start=0x1b5c, end=None, mem=[0xAF, 0x30]) # STX -16,Y - self.assertEqualHexWord(self.cpu.memory.read_word(0x0040), 0xabcd) # $0050 + $-10 = $0040 - - def test_increment_by_1(self): - self.cpu_test_run(start=0x2000, end=None, mem=[ - 0x8E, 0xAB, 0xCD, # 0000| LDX #$abcd ;set X to $abcd - 0x10, 0x8E, 0x00, 0x50, # 0003| LDY #$50 ;set Y to $0050 - 0xAF, 0xA0, # 0007| STX ,Y+ ;store X at $50 and Y+1 - 0x10, 0x9F, 0x58, # 0009| STY $58 ;store Y at $58 - ]) - self.assertEqualHexWord(self.cpu.memory.read_word(0x0050), 0xabcd) - self.assertEqualHexWord(self.cpu.memory.read_word(0x0058), 0x0051) - - def test_increment_by_2(self): - self.cpu_test_run(start=0x2000, end=None, mem=[ - 0x8E, 0xAB, 0xCD, # 0000| LDX #$abcd ;set X to $abcd - 0x10, 0x8E, 0x00, 0x50, # 0003| LDY #$50 ;set Y to $0050 - 0xAF, 0xA1, # 0007| STX ,Y++ ;store X at $50 and Y+2 - 0x10, 0x9F, 0x58, # 0009| STY $58 ;store Y at $58 - ]) - self.assertEqualHexWord(self.cpu.memory.read_word(0x0050), 0xabcd) - self.assertEqualHexWord(self.cpu.memory.read_word(0x0058), 0x0052) - - def test_decrement_by_1(self): - self.cpu_test_run(start=0x2000, end=None, mem=[ - 0x8E, 0xAB, 0xCD, # 0000| LDX #$abcd ;set X to $abcd - 0x10, 0x8E, 0x00, 0x50, # 0003| LDY #$50 ;set Y to $0050 - 0xAF, 0xA2, # 0007| STX ,-Y ;Y-1 and store X at $50-1 - 0x10, 0x9F, 0x58, # 0009| STY $58 ;store Y at $58 - ]) - self.assertEqualHexWord(self.cpu.memory.read_word(0x004f), 0xabcd) # 50-1 - self.assertEqualHexWord(self.cpu.memory.read_word(0x0058), 0x004f) - - def test_decrement_by_2(self): - self.cpu_test_run(start=0x2000, end=None, mem=[ - 0x8E, 0xAB, 0xCD, # 0000| LDX #$abcd ;set X to $abcd - 0x10, 0x8E, 0x00, 0x50, # 0003| LDY #$50 ;set Y to $0050 - 0xAF, 0xA3, # 0007| STX ,--Y ;Y-2 and store X at $50-1 - 0x10, 0x9F, 0x58, # 0009| STY $58 ;store Y at $58 - ]) - self.assertEqualHexWord(self.cpu.memory.read_word(0x004e), 0xabcd) # 50-2 - self.assertEqualHexWord(self.cpu.memory.read_word(0x0058), 0x004e) - - def test_no_offset(self): - self.cpu_test_run(start=0x2000, end=None, mem=[ - 0x8E, 0xAB, 0xCD, # 0000| LDX #$abcd ;set X to $abcd - 0x10, 0x8E, 0x00, 0x50, # 0003| LDY #$50 ;set Y to $0050 - 0xAF, 0xA4, # 0007| STX ,Y ;store X at $50 - 0x10, 0x9F, 0x58, # 0009| STY $58 ;store Y at $58 - ]) - self.assertEqualHexWord(self.cpu.memory.read_word(0x0050), 0xabcd) # X - self.assertEqualHexWord(self.cpu.memory.read_word(0x0058), 0x0050) # Y - - def test_B_offset(self): - self.cpu_test_run(start=0x2000, end=None, mem=[ - 0xC6, 0x03, # LDB #$3 ; set B to $3 - 0x8E, 0xAB, 0xCD, # LDX #$abcd ; set X to $abcd - 0x10, 0x8E, 0x00, 0x50, # LDY #$50 ; set Y to $50 - 0xAF, 0xA5, # STX B,Y ; store X at Y and B - 0x10, 0x9F, 0x58, # STY $58 ; store Y - ]) - self.assertEqualHexWord(self.cpu.memory.read_word(0x0050 + 0x03), 0xabcd) # 53 - self.assertEqualHexWord(self.cpu.memory.read_word(0x0058), 0x0050) # Y - - def test_A_offset(self): - self.cpu_test_run(start=0x2000, end=None, mem=[ - 0x86, 0xFC, # LDA #$-4 ; set A to $-4 - 0x8E, 0xAB, 0xCD, # LDX #$abcd ; set X to $abcd - 0x10, 0x8E, 0x00, 0x50, # LDY #$50 ; set Y to $50 - 0xAF, 0xA6, # STX A,Y ; store X at Y and A - 0x10, 0x9F, 0x58, # STY $58 ; store Y - ]) - self.assertEqualHexWord(self.cpu.memory.read_word(0x0050 - 0x04), 0xabcd) # 4c - self.assertEqualHexWord(self.cpu.memory.read_word(0x0058), 0x0050) # Y - - def test_8bit_offset(self): - x = 0xabcd - y = 0x00d0 - offset = 0x80 # signed = $-80 - self.cpu.index_x.set(x) - self.cpu.index_y.set(y) - self.cpu_test_run(start=0x2000, end=None, mem=[ - 0xAF, 0xA8, offset, # STX $30,Y ; store X at Y -80 = $50 - ]) - self.assertEqualHexWord(self.cpu.index_y.get(), y) - self.assertEqualHexWord(self.cpu.memory.read_word(0x50), x) # $d0 + $-80 = $50 - - def test_16bit_offset(self): - """ - LDX #$abcd ; set X to $abcd - LDY #$804f ; set Y to $804f - STX $8001,Y ; store X at Y + $-7fff - STY $20 ; store Y at $20 - """ - x = 0xabcd - y = 0x804f - offset = 0x8001 # signed = $-7fff - offset_hi, offset_lo = divmod(offset, 0x100) - self.cpu.index_x.set(x) - self.cpu.index_y.set(y) - self.cpu_test_run(start=0x2000, end=None, mem=[ - 0xAF, 0xA9, offset_hi, offset_lo, # STX $8001,Y ; store X at Y + $-7fff - ]) - self.assertEqualHexWord(self.cpu.index_y.get(), y) - self.assertEqualHexWord(self.cpu.memory.read_word(0x50), x) # $804f + $-7fff = $50 - - def test_D_offset(self): - """ - LDX #$abcd ; set X to $abcd - LDY #$804f ; set Y to $804f - LDD #$8001 ; set D to $8001 signed = $-7fff - STX D,Y ; store X at $50 (Y + D) - STY $20 ; store Y at $20 - """ - x = 0xabcd - y = 0x804f - d = 0x8001 # signed = $-7fff - self.cpu.index_x.set(x) - self.cpu.index_y.set(y) - self.cpu.accu_d.set(d) - self.cpu_test_run(start=0x2000, end=None, mem=[ - 0xAF, 0xAB, # STX D,Y ; store X at Y + D - ]) - self.assertEqualHexWord(self.cpu.index_x.get(), x) - # $804f + $-7fff = $50 - self.assertEqualHexWord(self.cpu.memory.read_word(0x50), x) # $804f + $-7fff = $50 - - def test_pc_offset_8bit_positive(self): - x = 0xabcd - self.cpu.index_x.set(x) - self.cpu_test_run(start=0x2000, end=None, mem=[ - 0xAF, 0x8C, 0x12, # STX 12,PC - ]) - self.assertEqualHexWord(self.cpu.index_x.get(), x) - # ea = pc($2003) + $12 = $2015 - self.assertEqualHexWord(self.cpu.memory.read_word(0x2015), x) - - def test_pc_offset_8bit_negative(self): - a = 0x56 - self.cpu.accu_a.set(a) - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0xA7, 0x8C, 0x80, # STA 12,PC - ]) - self.assertEqualHexByte(self.cpu.accu_a.get(), a) - # ea = pc($1003) + $-80 = $f83 - self.assertEqualHexByte(self.cpu.memory.read_byte(0x0f83), a) - - def test_pc_offset_16bit_positive(self): - x = 0xabcd - self.cpu.index_x.set(x) - self.cpu_test_run(start=0x2000, end=None, mem=[ - 0xAF, 0x8D, 0x0a, 0xb0, # STX 1234,PC - ]) - self.assertEqualHexWord(self.cpu.index_x.get(), x) - # ea = pc($2004) + $ab0 = $2ab4 - self.assertEqualHexWord(self.cpu.memory.read_word(0x2ab4), x) - - def test_pc_offset_16bit_negative(self): - a = 0x56 - self.cpu.accu_a.set(a) - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0xA7, 0x8D, 0xf0, 0x10, # STA 12,PC - ]) - self.assertEqualHexByte(self.cpu.accu_a.get(), a) - # ea = pc($1004) + $-ff0 = $14 - self.assertEqualHexByte(self.cpu.memory.read_byte(0x0014), a) - - def test_indirect_addressing(self): - print("TODO!!!") - - -if __name__ == '__main__': - from dragonlib.utils.logging_utils import setup_logging - - setup_logging(log, -# level=1 # hardcore debug ;) -# level=10 # DEBUG -# level=20 # INFO -# level=30 # WARNING -# level=40 # ERROR - level=50 # CRITICAL/FATAL - ) - - unittest.main( - argv=( - sys.argv[0], -# "Test6809_AddressModes_Indexed.test_8bit_offset", - ), - testRunner=TextTestRunner2, -# verbosity=1, - verbosity=2, -# failfast=True, - ) diff --git a/dragonpy/tests/test_6809_arithmetic.py b/dragonpy/tests/test_6809_arithmetic.py deleted file mode 100644 index 425ea668..00000000 --- a/dragonpy/tests/test_6809_arithmetic.py +++ /dev/null @@ -1,719 +0,0 @@ -#!/usr/bin/env python -# encoding:utf-8 - -""" - :created: 2013-2014 by Jens Diemer - www.jensdiemer.de - :copyleft: 2013-2014 by the DragonPy team, see AUTHORS for more details. - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - -from __future__ import absolute_import, division, print_function -from dragonlib.utils.unittest_utils import TextTestRunner2 -from dragonlib.utils import six -xrange = six.moves.xrange - -import logging -import sys -import unittest - -from dragonpy.tests.test_base import BaseCPUTestCase - - -log = logging.getLogger("DragonPy") - - -class Test6809_Arithmetic(BaseCPUTestCase): - def test_ADDA_extended01(self): - self.cpu_test_run(start=0x1000, end=0x1003, mem=[ - 0xbb, # ADDA extended - 0x12, 0x34 # word to add on accu A - ]) - self.assertEqual(self.cpu.cc.Z, 1) - self.assertEqual(self.cpu.cc.get(), 0x04) - self.assertEqual(self.cpu.accu_a.get(), 0x00) - - def test_ADDA_immediate(self): - # expected values are: 1 up to 255 then wrap around to 0 and up to 4 - excpected_values = list(range(1, 256)) - excpected_values += list(range(0, 5)) - - self.cpu.accu_a.set(0x00) # start value - for i in xrange(260): - self.cpu.cc.set(0x00) # Clear all CC flags - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0x8B, 0x01, # ADDA #$1 Immediate - ]) - a = self.cpu.accu_a.get() - excpected_value = excpected_values[i] -# print i, a, excpected_value, self.cpu.cc.get_info - - # test ADDA result - self.assertEqual(a, excpected_value) - - # test half carry - if a % 16 == 0: - self.assertEqual(self.cpu.cc.H, 1) - else: - self.assertEqual(self.cpu.cc.H, 0) - - # test negative - if 128 <= a <= 255: - self.assertEqual(self.cpu.cc.N, 1) - else: - self.assertEqual(self.cpu.cc.N, 0) - - # test zero - if a == 0: - self.assertEqual(self.cpu.cc.Z, 1) - else: - self.assertEqual(self.cpu.cc.Z, 0) - - # test overflow - if a == 128: - self.assertEqual(self.cpu.cc.V, 1) - else: - self.assertEqual(self.cpu.cc.V, 0) - - # test carry - if a == 0: - self.assertEqual(self.cpu.cc.C, 1) - else: - self.assertEqual(self.cpu.cc.C, 0) - - def test_ADDA1(self): - for i in xrange(260): - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0x8B, 0x01, # ADDA #$01 - ]) - r = self.cpu.accu_a.get() -# print "$%02x > ADD 1 > $%02x | CC:%s" % ( -# i, r, self.cpu.cc.get_info -# ) - - # test INC value from RAM - self.assertEqualHex(i + 1 & 0xff, r) # expected values are: 1 up to 255 then wrap around to 0 and up to 4 - - # test negative - if 128 <= r <= 255: - self.assertEqual(self.cpu.cc.N, 1) - else: - self.assertEqual(self.cpu.cc.N, 0) - - # test zero - if r == 0: - self.assertEqual(self.cpu.cc.Z, 1) - else: - self.assertEqual(self.cpu.cc.Z, 0) - - # test overflow - if r == 0x80: - self.assertEqual(self.cpu.cc.V, 1) - else: - self.assertEqual(self.cpu.cc.V, 0) - - def test_ADDD1(self): - areas = list(range(0, 3)) + ["..."] + list(range(0x7ffd, 0x8002)) + ["..."] + list(range(0xfffd, 0x10002)) - for i in areas: - if i == "...": -# print "..." - continue - self.cpu.accu_d.set(i) - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0xc3, 0x00, 0x01, # ADDD #$01 - ]) - r = self.cpu.accu_d.get() -# print "%5s $%04x > ADDD 1 > $%04x | CC:%s" % ( -# i, i, r, self.cpu.cc.get_info -# ) - - # test INC value from RAM - self.assertEqualHex(i + 1 & 0xffff, r) - - # test negative - if 0x8000 <= r <= 0xffff: - self.assertEqual(self.cpu.cc.N, 1) - else: - self.assertEqual(self.cpu.cc.N, 0) - - # test zero - if r == 0: - self.assertEqual(self.cpu.cc.Z, 1) - else: - self.assertEqual(self.cpu.cc.Z, 0) - - # test overflow - if r == 0x8000: - self.assertEqual(self.cpu.cc.V, 1) - else: - self.assertEqual(self.cpu.cc.V, 0) - - def test_NEGA(self): - """ - Example assembler code to test NEGA - - CLRB ; B is always 0 - TFR B,U ; clear U -loop: - TFR U,A ; for next NEGA - TFR B,CC ; clear CC - NEGA - LEAU 1,U ; inc U - JMP loop - - -0000 5F CLRB ; B is always 0 -0001 1F 93 TFR B,U ; clear U -0003 LOOP: -0003 1F 38 TFR U,A ; for next NEGA -0005 1F 9A TFR B,CC ; clear CC -0007 40 NEGA -0008 33 41 LEAU 1,U ; inc U -000A 0E 03 JMP loop - - """ - excpected_values = [0] + list(range(255, 0, -1)) - - for a in xrange(256): - self.cpu.cc.set(0x00) - - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0x86, a, # LDA #$i - 0x40, # NEGA (inherent) - ]) - r = self.cpu.accu_a.get() -# print "%03s - a=%02x r=%02x -> %s" % ( -# a, a, r, self.cpu.cc.get_info -# ) - - excpected_value = excpected_values[a] - - """ - xroar NEG CC - input for NEG values: - H = uneffected - N = dez: 1-128 | hex: $01 - $80 - Z = dez: 0 | hex: $00 - V = dez: 128 | hex: $80 - C = dez: 1-255 | hex: $01 - $ff - """ - - # test NEG result - self.assertEqual(r, excpected_value) - - # test half carry is uneffected! - self.assertEqual(self.cpu.cc.H, 0) - - # test negative: 0x01 <= a <= 0x80 - if 1 <= a <= 128: - self.assertEqual(self.cpu.cc.N, 1) - else: - self.assertEqual(self.cpu.cc.N, 0) - - # test zero | a==0 and r==0 - if r == 0: - self.assertEqual(self.cpu.cc.Z, 1) - else: - self.assertEqual(self.cpu.cc.Z, 0) - - # test overflow | a==128 and r==128 - if r == 128: - self.assertEqual(self.cpu.cc.V, 1) - else: - self.assertEqual(self.cpu.cc.V, 0) - - # test carry is set if r=1-255 (hex: r=$01 - $ff) - if r >= 1: - self.assertEqual(self.cpu.cc.C, 1) - else: - self.assertEqual(self.cpu.cc.C, 0) - - def test_NEG_memory(self): - excpected_values = [0] + list(range(255, 0, -1)) - address = 0x10 - - for a in xrange(256): - self.cpu.cc.set(0x00) - - self.cpu.memory.write_byte(address, a) - self.cpu_test_run(start=0x0000, end=None, mem=[ - 0x00, address, # NEG address - ]) - r = self.cpu.memory.read_byte(address) -# print "%03s - a=%02x r=%02x -> %s" % ( -# a, a, r, self.cpu.cc.get_info -# ) - - excpected_value = excpected_values[a] - - # test NEG result - self.assertEqual(r, excpected_value) - - # test half carry is uneffected! - self.assertEqual(self.cpu.cc.H, 0) - - # test negative: 0x01 <= a <= 0x80 - if 1 <= a <= 128: - self.assertEqual(self.cpu.cc.N, 1) - else: - self.assertEqual(self.cpu.cc.N, 0) - - # test zero | a==0 and r==0 - if r == 0: - self.assertEqual(self.cpu.cc.Z, 1) - else: - self.assertEqual(self.cpu.cc.Z, 0) - - # test overflow | a==128 and r==128 - if r == 128: - self.assertEqual(self.cpu.cc.V, 1) - else: - self.assertEqual(self.cpu.cc.V, 0) - - # test carry is set if r=1-255 (hex: r=$01 - $ff) - if r >= 1: - self.assertEqual(self.cpu.cc.C, 1) - else: - self.assertEqual(self.cpu.cc.C, 0) - - def test_INC_memory(self): - # expected values are: 1 up to 255 then wrap around to 0 and up to 4 - excpected_values = list(range(1, 256)) - excpected_values += list(range(0, 5)) - - self.cpu.memory.write_byte(0x4500, 0x0) # start value - for i in xrange(260): - self.cpu.cc.set(0x00) # Clear all CC flags - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0x7c, 0x45, 0x00, # INC $4500 - ]) - r = self.cpu.memory.read_byte(0x4500) - excpected_value = excpected_values[i] -# print "%5s $%02x > INC > $%02x | CC:%s" % ( -# i, i, r, self.cpu.cc.get_info -# ) - - # test INC value from RAM - self.assertEqualHex(r, excpected_value) - self.assertEqualHex(i + 1 & 0xff, r) - - # test negative - if 128 <= r <= 255: - self.assertEqual(self.cpu.cc.N, 1) - else: - self.assertEqual(self.cpu.cc.N, 0) - - # test zero - if r == 0: - self.assertEqual(self.cpu.cc.Z, 1) - else: - self.assertEqual(self.cpu.cc.Z, 0) - - # test overflow - if r == 0x80: - self.assertEqual(self.cpu.cc.V, 1) - else: - self.assertEqual(self.cpu.cc.V, 0) - - def test_INCB(self): - # expected values are: 1 up to 255 then wrap around to 0 and up to 4 - excpected_values = list(range(1, 256)) - excpected_values += list(range(0, 5)) - - for i in xrange(260): - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0x5c, # INCB - ]) - r = self.cpu.accu_b.get() - excpected_value = excpected_values[i] -# print "%5s $%02x > INC > $%02x | CC:%s" % ( -# i, i, r, self.cpu.cc.get_info -# ) - - # test INC value from RAM - self.assertEqual(r, excpected_value) - self.assertEqualHex(i + 1 & 0xff, r) - - # test negative - if 128 <= r <= 255: - self.assertEqual(self.cpu.cc.N, 1) - else: - self.assertEqual(self.cpu.cc.N, 0) - - # test zero - if r == 0: - self.assertEqual(self.cpu.cc.Z, 1) - else: - self.assertEqual(self.cpu.cc.Z, 0) - - # test overflow - if r == 0x80: - self.assertEqual(self.cpu.cc.V, 1) - else: - self.assertEqual(self.cpu.cc.V, 0) - - def test_INC_not_affected_flags1(self): - self.cpu.memory.write_byte(0x0100, 0x00) # start value - - self.cpu.cc.set(0x00) # Clear all CC flags - self.cpu_test_run(start=0x0000, end=None, mem=[ - 0x7c, 0x01, 0x00, # INC $0100 - ]) - r = self.cpu.memory.read_byte(0x0100) - self.assertEqual(r, 0x01) - - # half carry bit is not affected in INC - self.assertEqual(self.cpu.cc.H, 0) - - # carry bit is not affected in INC - self.assertEqual(self.cpu.cc.C, 0) - - def test_INC_not_affected_flags2(self): - self.cpu.memory.write_byte(0x0100, 0x00) # start value - - self.cpu.cc.set(0xff) # Set all CC flags - self.cpu_test_run(start=0x0000, end=None, mem=[ - 0x7c, 0x01, 0x00, # INC $0100 - ]) - r = self.cpu.memory.read_byte(0x0100) - self.assertEqual(r, 0x01) - - # half carry bit is not affected in INC - self.assertEqual(self.cpu.cc.H, 1) - - # carry bit is not affected in INC - self.assertEqual(self.cpu.cc.C, 1) - - def test_SUBA_immediate(self): - # expected values are: 254 down to 0 than wrap around to 255 and down to 252 - excpected_values = list(range(254, -1, -1)) - excpected_values += list(range(255, 250, -1)) - - self.cpu.accu_a.set(0xff) # start value - for i in xrange(260): - self.cpu.cc.set(0x00) # Clear all CC flags - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0x80, 0x01, # SUBA #$01 - ]) - a = self.cpu.accu_a.get() - excpected_value = excpected_values[i] -# print i, a, excpected_value, self.cpu.cc.get_info - - # test SUBA result - self.assertEqual(a, excpected_value) - - # test half carry - # XXX: half carry is "undefined" in SUBA! - self.assertEqual(self.cpu.cc.H, 0) - - # test negative - if 128 <= a <= 255: - self.assertEqual(self.cpu.cc.N, 1) - else: - self.assertEqual(self.cpu.cc.N, 0) - - # test zero - if a == 0: - self.assertEqual(self.cpu.cc.Z, 1) - else: - self.assertEqual(self.cpu.cc.Z, 0) - - # test overflow - if a == 127: # V ist set if SUB $80 to $7f - self.assertEqual(self.cpu.cc.V, 1) - else: - self.assertEqual(self.cpu.cc.V, 0) - - # test carry - if a == 0xff: # C is set if SUB $00 to $ff - self.assertEqual(self.cpu.cc.C, 1) - else: - self.assertEqual(self.cpu.cc.C, 0) - - def test_SUBA_indexed(self): - self.cpu.memory.load(0x1234, [0x12, 0xff]) - self.cpu.system_stack_pointer.set(0x1234) - self.cpu.accu_a.set(0xff) # start value - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0xa0, 0xe0, # SUBA ,S+ - ]) - self.assertEqualHexByte(self.cpu.accu_a.get(), 0xed) # $ff - $12 = $ed - self.assertEqualHexWord(self.cpu.system_stack_pointer.get(), 0x1235) - - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0xa0, 0xe0, # SUBA ,S+ - ]) - self.assertEqualHexByte(self.cpu.accu_a.get(), 0xed - 0xff & 0xff) # $ee - self.assertEqualHexWord(self.cpu.system_stack_pointer.get(), 0x1236) - - def test_DEC_extended(self): - # expected values are: 254 down to 0 than wrap around to 255 and down to 252 - excpected_values = list(range(254, -1, -1)) - excpected_values += list(range(255, 250, -1)) - - self.cpu.memory.write_byte(0x4500, 0xff) # start value - self.cpu.accu_a.set(0xff) # start value - for i in xrange(260): - self.cpu.cc.set(0x00) # Clear all CC flags - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0x7A, 0x45, 0x00, # DEC $4500 - ]) - r = self.cpu.memory.read_byte(0x4500) - excpected_value = excpected_values[i] -# print i, r, excpected_value, self.cpu.cc.get_info - - # test DEC result - self.assertEqual(r, excpected_value) - - # half carry bit is not affected in DEC - self.assertEqual(self.cpu.cc.H, 0) - - # test negative - if 128 <= r <= 255: - self.assertEqual(self.cpu.cc.N, 1) - else: - self.assertEqual(self.cpu.cc.N, 0) - - # test zero - if r == 0: - self.assertEqual(self.cpu.cc.Z, 1) - else: - self.assertEqual(self.cpu.cc.Z, 0) - - # test overflow - if r == 127: # V is set if SUB $80 to $7f - self.assertEqual(self.cpu.cc.V, 1) - else: - self.assertEqual(self.cpu.cc.V, 0) - - # carry bit is not affected in DEC - self.assertEqual(self.cpu.cc.C, 0) - - def test_DECA(self): - for a in xrange(256): - self.cpu.cc.set(0x00) - self.cpu.accu_a.set(a) - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0x4a, # DECA - ]) - r = self.cpu.accu_a.get() -# print "%03s - %02x > DEC > %02x | CC:%s" % ( -# a, a, r, self.cpu.cc.get_info -# ) -# continue - - excpected_value = a - 1 & 0xff - - # test result - self.assertEqual(r, excpected_value) - - # test half carry and carry is uneffected! - self.assertEqual(self.cpu.cc.H, 0) - self.assertEqual(self.cpu.cc.C, 0) - - # test negative: - if r >= 0x80: - self.assertEqual(self.cpu.cc.N, 1) - else: - self.assertEqual(self.cpu.cc.N, 0) - - # test zero - if r == 0: - self.assertEqual(self.cpu.cc.Z, 1) - else: - self.assertEqual(self.cpu.cc.Z, 0) - - # test overflow - if a == 0x80: - self.assertEqual(self.cpu.cc.V, 1) - else: - self.assertEqual(self.cpu.cc.V, 0) - - def test_SBCA_immediate_01(self): - a = 0x80 - self.cpu.cc.set(0x00) # CC:........ - self.cpu.accu_a.set(a) - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0x82, 0x40, # SBC - ]) - r = self.cpu.accu_a.get() -# print "%02x > SBC > %02x | CC:%s" % ( -# a, r, self.cpu.cc.get_info -# ) - self.assertEqualHex(r, 0x80 - 0x40 - 0x00) - self.assertEqual(self.cpu.cc.get_info, "......V.") - - def test_SBCA_immediate_02(self): - a = 0x40 - self.cpu.cc.set(0xff) # CC:EFHINZVC - self.cpu.accu_a.set(a) - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0x82, 0x20, # SBC - ]) - r = self.cpu.accu_a.get() -# print "%02x > SBC > %02x | CC:%s" % ( -# a, r, self.cpu.cc.get_info -# ) - self.assertEqualHex(r, 0x40 - 0x20 - 0x01) - # half-carry is undefined - self.assertEqual(self.cpu.cc.get_info, "EFHI....") - - def test_ORCC(self): - a_areas = list(range(0, 3)) + ["..."] + list(range(0x7e, 0x83)) + ["..."] + list(range(0xfd, 0x100)) - b_areas = list(range(0, 3)) + ["..."] + list(range(0x7e, 0x83)) + ["..."] + list(range(0xfd, 0x100)) - for a in a_areas: - if a == "...": -# print "..." - continue - for b in b_areas: - if b == "...": -# print "..." - continue - self.cpu.cc.set(a) - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0x1a, b # ORCC $a - ]) - r = self.cpu.cc.get() - expected_value = a | b -# print "%02x OR %02x = %02x | CC:%s" % ( -# a, b, r, self.cpu.cc.get_info -# ) - self.assertEqualHex(r, expected_value) - - def test_ANDCC(self): - a_areas = list(range(0, 3)) + ["..."] + list(range(0x7e, 0x83)) + ["..."] + list(range(0xfd, 0x100)) - b_areas = list(range(0, 3)) + ["..."] + list(range(0x7e, 0x83)) + ["..."] + list(range(0xfd, 0x100)) - for a in a_areas: - if a == "...": -# print "..." - continue - for b in b_areas: - if b == "...": -# print "..." - continue - self.cpu.cc.set(a) - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0x1c, b # ANDCC $a - ]) - r = self.cpu.cc.get() - expected_value = a & b -# print "%02x AND %02x = %02x | CC:%s" % ( -# a, b, r, self.cpu.cc.get_info -# ) - self.assertEqualHex(r, expected_value) - - def test_ABX(self): - self.cpu.cc.set(0xff) - - x_areas = list(range(0, 3)) + ["..."] + list(range(0x7ffd, 0x8002)) + ["..."] + list(range(0xfffd, 0x10000)) - b_areas = list(range(0, 3)) + ["..."] + list(range(0x7e, 0x83)) + ["..."] + list(range(0xfd, 0x100)) - - for x in x_areas: - if x == "...": -# print "..." - continue - for b in b_areas: - if b == "...": -# print "..." - continue - self.cpu.index_x.set(x) - self.cpu.accu_b.set(b) - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0x3a, # ABX (inherent) - ]) - r = self.cpu.index_x.get() - expected_value = x + b & 0xffff -# print "%04x + %02x = %04x | CC:%s" % ( -# x, b, r, self.cpu.cc.get_info -# ) - self.assertEqualHex(r, expected_value) - - # CC complet uneffected: - self.assertEqualHex(self.cpu.cc.get(), 0xff) - - def test_XOR(self): - print("TODO!!!") - -# def setUp(self): -# cmd_args = UnittestCmdArgs -# cmd_args.trace = True # enable Trace output -# cfg = TestCfg(cmd_args) -# self.cpu = CPU(cfg) -# self.cpu.cc.set(0x00) - - def test_DAA(self): - self.cpu_test_run(start=0x0100, end=None, mem=[ - 0x86, 0x67, # LDA #$67 ; A=$67 - 0x8b, 0x75, # ADDA #$75 ; A=$67+$75 = $DC - 0x19, # DAA 19 ; A=67+75=142 -> $42 - ]) - self.assertEqualHexByte(self.cpu.accu_a.get(), 0x42) - self.assertEqual(self.cpu.cc.C, 1) - - def test_DAA2(self): - for add in xrange(0xff): - self.cpu.cc.set(0x00) - self.cpu.accu_a.set(0x01) - self.cpu_test_run(start=0x0100, end=None, mem=[ - 0x8b, add, # ADDA #$1 - 0x19, # DAA - ]) - r = self.cpu.accu_a.get() -# print "$01 + $%02x = $%02x > DAA > $%02x | CC:%s" % ( -# add, (1 + add), r, self.cpu.cc.get_info -# ) - - # test half carry - if add & 0x0f == 0x0f: - self.assertEqual(self.cpu.cc.H, 1) - else: - self.assertEqual(self.cpu.cc.H, 0) - - # test negative - if 128 <= r <= 255: - self.assertEqual(self.cpu.cc.N, 1) - else: - self.assertEqual(self.cpu.cc.N, 0) - - # test zero - if r == 0: - self.assertEqual(self.cpu.cc.Z, 1) - else: - self.assertEqual(self.cpu.cc.Z, 0) - - # is undefined? - # http://archive.worldofdragon.org/phpBB3/viewtopic.php?f=8&t=4896 -# # test overflow -# if r == 128: -# self.assertEqual(self.cpu.cc.V, 1) -# else: -# self.assertEqual(self.cpu.cc.V, 0) - - # test carry - if add >= 0x99: - self.assertEqual(self.cpu.cc.C, 1) - else: - self.assertEqual(self.cpu.cc.C, 0) - - -if __name__ == '__main__': - from dragonlib.utils.logging_utils import setup_logging - - setup_logging(log, -# level=1 # hardcore debug ;) -# level=10 # DEBUG -# level=20 # INFO -# level=30 # WARNING -# level=40 # ERROR - level=50 # CRITICAL/FATAL - ) - - unittest.main( - argv=( - sys.argv[0], -# "Test6809_Arithmetic", -# "Test6809_Arithmetic.test_DAA2", - ), - testRunner=TextTestRunner2, -# verbosity=1, - verbosity=2, -# failfast=True, - ) diff --git a/dragonpy/tests/test_6809_arithmetic_shift.py b/dragonpy/tests/test_6809_arithmetic_shift.py deleted file mode 100644 index 045974c5..00000000 --- a/dragonpy/tests/test_6809_arithmetic_shift.py +++ /dev/null @@ -1,394 +0,0 @@ -#!/usr/bin/env python -# encoding:utf-8 - -""" - 6809 unittests - ~~~~~~~~~~~~~~ - - Test shift / rotate - - :created: 2013-2014 by Jens Diemer - www.jensdiemer.de - :copyleft: 2013-2014 by the DragonPy team, see AUTHORS for more details. - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - -from __future__ import absolute_import, division, print_function -from dragonlib.utils.unittest_utils import TextTestRunner2 -from dragonlib.utils import six -xrange = six.moves.xrange - -import logging -import sys -import unittest - -from dragonpy.tests.test_base import BaseCPUTestCase -from dragonpy.utils.bits import is_bit_set, get_bit - - -log = logging.getLogger("DragonPy") - - -class Test6809_LogicalShift(BaseCPUTestCase): - """ - unittests for: - * LSL (Logical Shift Left) alias ASL (Arithmetic Shift Left) - * LSR (Logical Shift Right) alias ASR (Arithmetic Shift Right) - """ - def test_LSRA_inherent(self): - """ - Example assembler code to test LSRA/ASRA - - CLRB ; B is always 0 - TFR B,U ; clear U -loop: - TFR U,A ; for next test - TFR B,CC ; clear CC - LSRA - NOP - LEAU 1,U ; inc U - JMP loop - """ - for i in xrange(0x100): - self.cpu.accu_a.set(i) - self.cpu.cc.set(0x00) # Clear all CC flags - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0x44, # LSRA/ASRA Inherent - ]) - r = self.cpu.accu_a.get() -# print "%02x %s > ASRA > %02x %s -> %s" % ( -# i, '{0:08b}'.format(i), -# r, '{0:08b}'.format(r), -# self.cpu.cc.get_info -# ) - - # test LSL result - r2 = i >> 1 # shift right - r2 = r2 & 0xff # wrap around - self.assertEqualHex(r, r2) - - # test negative - if 128 <= r <= 255: - self.assertEqual(self.cpu.cc.N, 1) - else: - self.assertEqual(self.cpu.cc.N, 0) - - # test zero - if r == 0: - self.assertEqual(self.cpu.cc.Z, 1) - else: - self.assertEqual(self.cpu.cc.Z, 0) - - # test overflow - self.assertEqual(self.cpu.cc.V, 0) - - # test carry - source_bit0 = get_bit(i, bit=0) - self.assertEqual(self.cpu.cc.C, source_bit0) - - def test_LSLA_inherent(self): - for i in xrange(260): - self.cpu.accu_a.set(i) - self.cpu.cc.set(0x00) # Clear all CC flags - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0x48, # LSLA/ASLA Inherent - ]) - r = self.cpu.accu_a.get() -# print "%02x %s > LSLA > %02x %s -> %s" % ( -# i, '{0:08b}'.format(i), -# r, '{0:08b}'.format(r), -# self.cpu.cc.get_info -# ) - - # test LSL result - r2 = i << 1 # shift left - r2 = r2 & 0xff # wrap around - self.assertEqualHex(r, r2) - - # test negative - if 128 <= r <= 255: - self.assertEqual(self.cpu.cc.N, 1) - else: - self.assertEqual(self.cpu.cc.N, 0) - - # test zero - if r == 0: - self.assertEqual(self.cpu.cc.Z, 1) - else: - self.assertEqual(self.cpu.cc.Z, 0) - - # test overflow - if 64 <= i <= 191: - self.assertEqual(self.cpu.cc.V, 1) - else: - self.assertEqual(self.cpu.cc.V, 0) - - # test carry - if 128 <= i <= 255: - self.assertEqual(self.cpu.cc.C, 1) - else: - self.assertEqual(self.cpu.cc.C, 0) - - def test_ASR_inherent(self): - """ - Jedes Bit der Speicherzelle bzw. des Akkumulators A/B wird um eine Position nach rechts verschoben. - Bit 7 wird auf '0' gesetzt, und Bit 0 wird ins Carry Flag übertragen. - """ - for src in xrange(0x100): - self.cpu.accu_b.set(src) - self.cpu.cc.set(0x00) # Set all CC flags - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0x57, # ASRB/LSRB Inherent - ]) - dst = self.cpu.accu_b.get() - - src_bit_str = '{0:08b}'.format(src) - dst_bit_str = '{0:08b}'.format(dst) - -# print "%02x %s > ASRB > %02x %s -> %s" % ( -# src, src_bit_str, -# dst, dst_bit_str, -# self.cpu.cc.get_info -# ) - - # Bit seven is held constant. - if src_bit_str[0] == "1": - excpeted_bits = "1%s" % src_bit_str[:-1] - else: - excpeted_bits = "0%s" % src_bit_str[:-1] - - # test ASRB/LSRB result - self.assertEqual(dst_bit_str, excpeted_bits) - - # test negative - if 128 <= dst <= 255: - self.assertEqual(self.cpu.cc.N, 1) - else: - self.assertEqual(self.cpu.cc.N, 0) - - # test zero - if dst == 0: - self.assertEqual(self.cpu.cc.Z, 1) - else: - self.assertEqual(self.cpu.cc.Z, 0) - - # test overflow (is uneffected!) - self.assertEqual(self.cpu.cc.V, 0) - - # test carry - source_bit0 = is_bit_set(src, bit=0) - if source_bit0: - self.assertEqual(self.cpu.cc.C, 1) - else: - self.assertEqual(self.cpu.cc.C, 0) - - -class Test6809_Rotate(BaseCPUTestCase): - """ - unittests for: - * ROL (Rotate Left) alias - * ROR (Rotate Right) alias - """ - - def assertROL(self, src, dst, source_carry): - src_bit_str = '{0:08b}'.format(src) - dst_bit_str = '{0:08b}'.format(dst) -# print "%02x %s > ROLA > %02x %s -> %s" % ( -# src, src_bit_str, -# dst, dst_bit_str, -# self.cpu.cc.get_info -# ) - - # Carry was cleared and moved into bit 0 - excpeted_bits = "%s%s" % (src_bit_str[1:], source_carry) - self.assertEqual(dst_bit_str, excpeted_bits) - - # test negative - if dst >= 0x80: - self.assertEqual(self.cpu.cc.N, 1) - else: - self.assertEqual(self.cpu.cc.N, 0) - - # test zero - if dst == 0: - self.assertEqual(self.cpu.cc.Z, 1) - else: - self.assertEqual(self.cpu.cc.Z, 0) - - # test overflow - source_bit6 = is_bit_set(src, bit=6) - source_bit7 = is_bit_set(src, bit=7) - if source_bit6 == source_bit7: # V = bit 6 XOR bit 7 - self.assertEqual(self.cpu.cc.V, 0) - else: - self.assertEqual(self.cpu.cc.V, 1) - - # test carry - if 0x80 <= src <= 0xff: # if bit 7 was set - self.assertEqual(self.cpu.cc.C, 1) - else: - self.assertEqual(self.cpu.cc.C, 0) - - def test_ROLA_with_clear_carry(self): - for a in xrange(0x100): - self.cpu.cc.set(0x00) # clear all CC flags - a = self.cpu.accu_a.set(a) - self.cpu_test_run(start=0x0000, end=None, mem=[ - 0x49, # ROLA - ]) - r = self.cpu.accu_a.get() - self.assertROL(a, r, source_carry=0) - - # test half carry is uneffected! - self.assertEqual(self.cpu.cc.H, 0) - - def test_ROLA_with_set_carry(self): - for a in xrange(0x100): - self.cpu.cc.set(0xff) # set all CC flags - a = self.cpu.accu_a.set(a) - self.cpu_test_run(start=0x0000, end=None, mem=[ - 0x49, # ROLA - ]) - r = self.cpu.accu_a.get() - self.assertROL(a, r, source_carry=1) - - # test half carry is uneffected! - self.assertEqual(self.cpu.cc.H, 1) - - def test_ROL_memory_with_clear_carry(self): - for a in xrange(0x100): - self.cpu.cc.set(0x00) # clear all CC flags - self.cpu.memory.write_byte(0x0050, a) - self.cpu_test_run(start=0x0000, end=None, mem=[ - 0x09, 0x50, # ROL #$50 - ]) - r = self.cpu.memory.read_byte(0x0050) - self.assertROL(a, r, source_carry=0) - - # test half carry is uneffected! - self.assertEqual(self.cpu.cc.H, 0) - - def test_ROL_memory_with_set_carry(self): - for a in xrange(0x100): - self.cpu.cc.set(0xff) # set all CC flags - self.cpu.memory.write_byte(0x0050, a) - self.cpu_test_run(start=0x0000, end=None, mem=[ - 0x09, 0x50, # ROL #$50 - ]) - r = self.cpu.memory.read_byte(0x0050) - self.assertROL(a, r, source_carry=1) - - # test half carry is uneffected! - self.assertEqual(self.cpu.cc.H, 1) - - def assertROR(self, src, dst, source_carry): - src_bit_str = '{0:08b}'.format(src) - dst_bit_str = '{0:08b}'.format(dst) -# print "%02x %s > RORA > %02x %s -> %s" % ( -# src, src_bit_str, -# dst, dst_bit_str, -# self.cpu.cc.get_info -# ) - - # Carry was cleared and moved into bit 0 - excpeted_bits = "%s%s" % (source_carry, src_bit_str[:-1]) - self.assertEqual(dst_bit_str, excpeted_bits) - - # test negative - if dst >= 0x80: - self.assertEqual(self.cpu.cc.N, 1) - else: - self.assertEqual(self.cpu.cc.N, 0) - - # test zero - if dst == 0: - self.assertEqual(self.cpu.cc.Z, 1) - else: - self.assertEqual(self.cpu.cc.Z, 0) - - # test carry - source_bit0 = is_bit_set(src, bit=0) - if source_bit0: # if bit 0 was set - self.assertEqual(self.cpu.cc.C, 1) - else: - self.assertEqual(self.cpu.cc.C, 0) - - def test_RORA_with_clear_carry(self): - for a in xrange(0x100): - self.cpu.cc.set(0x00) # clear all CC flags - a = self.cpu.accu_a.set(a) - self.cpu_test_run(start=0x0000, end=None, mem=[ - 0x46, # RORA - ]) - r = self.cpu.accu_a.get() - self.assertROR(a, r, source_carry=0) - - # test half carry and overflow, they are uneffected! - self.assertEqual(self.cpu.cc.H, 0) - self.assertEqual(self.cpu.cc.V, 0) - - def test_RORA_with_set_carry(self): - for a in xrange(0x100): - self.cpu.cc.set(0xff) # set all CC flags - a = self.cpu.accu_a.set(a) - self.cpu_test_run(start=0x0000, end=None, mem=[ - 0x46, # RORA - ]) - r = self.cpu.accu_a.get() - self.assertROR(a, r, source_carry=1) - - # test half carry and overflow, they are uneffected! - self.assertEqual(self.cpu.cc.H, 1) - self.assertEqual(self.cpu.cc.V, 1) - - def test_ROR_memory_with_clear_carry(self): - for a in xrange(0x100): - self.cpu.cc.set(0x00) # clear all CC flags - self.cpu.memory.write_byte(0x0050, a) - self.cpu_test_run(start=0x0000, end=None, mem=[ - 0x06, 0x50,# ROR #$50 - ]) - r = self.cpu.memory.read_byte(0x0050) - self.assertROR(a, r, source_carry=0) - - # test half carry and overflow, they are uneffected! - self.assertEqual(self.cpu.cc.H, 0) - self.assertEqual(self.cpu.cc.V, 0) - - def test_ROR_memory_with_set_carry(self): - for a in xrange(0x100): - self.cpu.cc.set(0xff) # set all CC flags - self.cpu.memory.write_byte(0x0050, a) - self.cpu_test_run(start=0x0000, end=None, mem=[ - 0x06, 0x50,# ROR #$50 - ]) - r = self.cpu.memory.read_byte(0x0050) - self.assertROR(a, r, source_carry=1) - - # test half carry and overflow, they are uneffected! - self.assertEqual(self.cpu.cc.H, 1) - self.assertEqual(self.cpu.cc.V, 1) - - -if __name__ == '__main__': - from dragonlib.utils.logging_utils import setup_logging - - setup_logging(log, -# level=1 # hardcore debug ;) -# level=10 # DEBUG -# level=20 # INFO -# level=30 # WARNING -# level=40 # ERROR - level=50 # CRITICAL/FATAL - ) - - unittest.main( - argv=( - sys.argv[0], -# "Test6809_LogicalShift.test_ASR_inherent", -# "Test6809_Rotate", - ), - testRunner=TextTestRunner2, -# verbosity=1, - verbosity=2, -# failfast=True, - ) diff --git a/dragonpy/tests/test_6809_branch_instructions.py b/dragonpy/tests/test_6809_branch_instructions.py deleted file mode 100644 index 7a659765..00000000 --- a/dragonpy/tests/test_6809_branch_instructions.py +++ /dev/null @@ -1,278 +0,0 @@ -#!/usr/bin/env python - -""" - :created: 2013-2014 by Jens Diemer - www.jensdiemer.de - :copyleft: 2013-2014 by the DragonPy team, see AUTHORS for more details. - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - -from __future__ import absolute_import, division, print_function - -import itertools -import logging -import operator -import sys -import unittest - -from dragonlib.utils.unittest_utils import TextTestRunner2 -from dragonpy.tests.test_base import BaseCPUTestCase - - -log = logging.getLogger("DragonPy") - - -class Test6809_BranchInstructions(BaseCPUTestCase): - """ - Test branch instructions - """ - def test_BCC_no(self): - self.cpu.cc.C = 1 - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x24, 0xf4, # BCC -12 - ]) - self.assertEqualHex(self.cpu.program_counter.get(), 0x1002) - - def test_BCC_yes(self): - self.cpu.cc.C = 0 - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x24, 0xf4, # BCC -12 ; ea = $1002 + -12 = $ff6 - ]) - self.assertEqualHex(self.cpu.program_counter.get(), 0xff6) - - def test_LBCC_no(self): - self.cpu.cc.C = 1 - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x10, 0x24, 0x07, 0xe4, # LBCC +2020 ; ea = $1004 + 2020 = $17e8 - ]) - self.assertEqualHex(self.cpu.program_counter.get(), 0x1004) - - def test_LBCC_yes(self): - self.cpu.cc.C = 0 - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x10, 0x24, 0x07, 0xe4, # LBCC +2020 ; ea = $1004 + 2020 = $17e8 - ]) - self.assertEqualHex(self.cpu.program_counter.get(), 0x17e8) - - def test_BCS_no(self): - self.cpu.cc.C = 0 - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x25, 0xf4, # BCS -12 - ]) - self.assertEqualHex(self.cpu.program_counter.get(), 0x1002) - - def test_BCS_yes(self): - self.cpu.cc.C = 1 - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x25, 0xf4, # BCS -12 ; ea = $1002 + -12 = $ff6 - ]) - self.assertEqualHex(self.cpu.program_counter.get(), 0xff6) - - def test_LBCS_no(self): - self.cpu.cc.C = 0 - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x10, 0x25, 0x07, 0xe4, # LBCS +2020 ; ea = $1004 + 2020 = $17e8 - ]) - self.assertEqualHex(self.cpu.program_counter.get(), 0x1004) - - def test_LBCS_yes(self): - self.cpu.cc.C = 1 - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x10, 0x25, 0x07, 0xe4, # LBCS +2020 ; ea = $1004 + 2020 = $17e8 - ]) - self.assertEqualHex(self.cpu.program_counter.get(), 0x17e8) - - def test_BEQ_no(self): - self.cpu.cc.Z = 0 - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x27, 0xf4, # BEQ -12 - ]) - self.assertEqualHex(self.cpu.program_counter.get(), 0x1002) - - def test_BEQ_yes(self): - self.cpu.cc.Z = 1 - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x27, 0xf4, # BEQ -12 ; ea = $1002 + -12 = $ff6 - ]) - self.assertEqualHex(self.cpu.program_counter.get(), 0xff6) - - def test_LBEQ_no(self): - self.cpu.cc.Z = 0 - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x10, 0x27, 0x07, 0xe4, # LBEQ +2020 ; ea = $1004 + 2020 = $17e8 - ]) - self.assertEqualHex(self.cpu.program_counter.get(), 0x1004) - - def test_LBEQ_yes(self): - self.cpu.cc.Z = 1 - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x10, 0x27, 0x07, 0xe4, # LBEQ +2020 ; ea = $1004 + 2020 = $17e8 - ]) - self.assertEqualHex(self.cpu.program_counter.get(), 0x17e8) - - def test_BGE_LBGE(self): - for n, v in itertools.product(list(range(2)), repeat=2): # -> [(0, 0), (0, 1), (1, 0), (1, 1)] - # print n, v, (n ^ v) == 0, n == v - self.cpu.cc.N = n - self.cpu.cc.V = v - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x2c, 0xf4, # BGE -12 ; ea = $1002 + -12 = $ff6 - ]) -# print "%s - $%04x" % (self.cpu.cc.get_info, self.cpu.program_counter) - if not operator.xor(n, v): # same as: (n ^ v) == 0: - self.assertEqualHex(self.cpu.program_counter.get(), 0xff6) - else: - self.assertEqualHex(self.cpu.program_counter.get(), 0x1002) - - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x10, 0x2c, 0x07, 0xe4, # LBGE +2020 ; ea = $1004 + 2020 = $17e8 - ]) - if (n ^ v) == 0: - self.assertEqualHex(self.cpu.program_counter.get(), 0x17e8) - else: - self.assertEqualHex(self.cpu.program_counter.get(), 0x1004) - - def test_BGT_LBGT(self): - for n, v, z in itertools.product(list(range(2)), repeat=3): - # -> [(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1), ..., (1, 1, 1)] - # print n, v, (n ^ v) == 0, n == v - self.cpu.cc.N = n - self.cpu.cc.V = v - self.cpu.cc.Z = z - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x2e, 0xf4, # BGT -12 ; ea = $1002 + -12 = $ff6 - ]) - if n == v and z == 0: - self.assertEqualHex(self.cpu.program_counter.get(), 0xff6) - else: - self.assertEqualHex(self.cpu.program_counter.get(), 0x1002) - - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x10, 0x2e, 0x07, 0xe4, # LBGT +2020 ; ea = $1004 + 2020 = $17e8 - ]) - if n == v and z == 0: - self.assertEqualHex(self.cpu.program_counter.get(), 0x17e8) - else: - self.assertEqualHex(self.cpu.program_counter.get(), 0x1004) - - def test_BHI_LBHI(self): - for c, z in itertools.product(list(range(2)), repeat=2): # -> [(0, 0), (0, 1), (1, 0), (1, 1)] - self.cpu.cc.C = c - self.cpu.cc.Z = z - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x22, 0xf4, # BHI -12 ; ea = $1002 + -12 = $ff6 - ]) -# print "%s - $%04x" % (self.cpu.cc.get_info, self.cpu.program_counter) - if c == 0 and z == 0: - self.assertEqualHex(self.cpu.program_counter.get(), 0xff6) - else: - self.assertEqualHex(self.cpu.program_counter.get(), 0x1002) - - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x10, 0x22, 0x07, 0xe4, # LBHI +2020 ; ea = $1004 + 2020 = $17e8 - ]) - if c == 0 and z == 0: - self.assertEqualHex(self.cpu.program_counter.get(), 0x17e8) - else: - self.assertEqualHex(self.cpu.program_counter.get(), 0x1004) - - def test_BHS_no(self): - self.cpu.cc.Z = 0 - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x2f, 0xf4, # BHS -12 - ]) - self.assertEqualHex(self.cpu.program_counter.get(), 0x1002) - - def test_BHS_yes(self): - self.cpu.cc.Z = 1 - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x2f, 0xf4, # BHS -12 ; ea = $1002 + -12 = $ff6 - ]) - self.assertEqualHex(self.cpu.program_counter.get(), 0xff6) - - def test_LBHS_no(self): - self.cpu.cc.Z = 0 - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x10, 0x2f, 0x07, 0xe4, # LBHS +2020 ; ea = $1004 + 2020 = $17e8 - ]) - self.assertEqualHex(self.cpu.program_counter.get(), 0x1004) - - def test_LBHS_yes(self): - self.cpu.cc.Z = 1 - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x10, 0x2f, 0x07, 0xe4, # LBHS +2020 ; ea = $1004 + 2020 = $17e8 - ]) - self.assertEqualHex(self.cpu.program_counter.get(), 0x17e8) - - def test_BPL_no(self): - self.cpu.cc.N = 1 - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x2a, 0xf4, # BPL -12 - ]) - self.assertEqualHex(self.cpu.program_counter.get(), 0x1002) - - def test_BPL_yes(self): - self.cpu.cc.N = 0 - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x2a, 0xf4, # BPL -12 ; ea = $1002 + -12 = $ff6 - ]) - self.assertEqualHex(self.cpu.program_counter.get(), 0xff6) - - def test_LBPL_no(self): - self.cpu.cc.N = 1 - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x10, 0x2a, 0x07, 0xe4, # LBPL +2020 ; ea = $1004 + 2020 = $17e8 - ]) - self.assertEqualHex(self.cpu.program_counter.get(), 0x1004) - - def test_LBPL_yes(self): - self.cpu.cc.N = 0 - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x10, 0x2a, 0x07, 0xe4, # LBPL +2020 ; ea = $1004 + 2020 = $17e8 - ]) - self.assertEqualHex(self.cpu.program_counter.get(), 0x17e8) - - def test_BLT_LBLT(self): - for n, v in itertools.product(list(range(2)), repeat=2): # -> [(0, 0), (0, 1), (1, 0), (1, 1)] - self.cpu.cc.N = n - self.cpu.cc.V = v - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x2d, 0xf4, # BLT -12 ; ea = $1002 + -12 = $ff6 - ]) -# print "%s - $%04x" % (self.cpu.cc.get_info, self.cpu.program_counter) - if operator.xor(n, v): # same as: n ^ v == 1 - self.assertEqualHex(self.cpu.program_counter.get(), 0xff6) - else: - self.assertEqualHex(self.cpu.program_counter.get(), 0x1002) - - self.cpu_test_run2(start=0x1000, count=1, mem=[ - 0x10, 0x2d, 0x07, 0xe4, # LBLT +2020 ; ea = $1004 + 2020 = $17e8 - ]) - if operator.xor(n, v): - self.assertEqualHex(self.cpu.program_counter.get(), 0x17e8) - else: - self.assertEqualHex(self.cpu.program_counter.get(), 0x1004) - - -if __name__ == '__main__': - from dragonlib.utils.logging_utils import setup_logging - - setup_logging(log, -# level=1 # hardcore debug ;) -# level=10 # DEBUG -# level=20 # INFO -# level=30 # WARNING -# level=40 # ERROR - level=50 # CRITICAL/FATAL - ) - - unittest.main( - argv=( - sys.argv[0], -# "Test6809_BranchInstructions", -# "Test6809_BranchInstructions.test_BLT_LBLT", - ), - testRunner=TextTestRunner2, -# verbosity=1, - verbosity=2, -# failfast=True, - ) diff --git a/dragonpy/tests/test_6809_program.py b/dragonpy/tests/test_6809_program.py deleted file mode 100644 index 00a69d47..00000000 --- a/dragonpy/tests/test_6809_program.py +++ /dev/null @@ -1,413 +0,0 @@ -#!/usr/bin/env python -# encoding:utf-8 - -""" - 6809 unittests - ~~~~~~~~~~~~~~ - - Test CPU with some small Assembler programs - - :created: 2014 by Jens Diemer - www.jensdiemer.de - :copyleft: 2014 by the DragonPy team, see AUTHORS for more details. - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - -from __future__ import absolute_import, division, print_function - -from decimal import Decimal -import binascii -import logging -import sys -import unittest - -from dragonlib.utils.unittest_utils import TextTestRunner2 -from dragonlib.utils import six -from dragonpy.tests.test_base import BaseStackTestCase - - -log = logging.getLogger(__name__) - - -class Test6809_Program(BaseStackTestCase): -# def setUp(self): -# self.UNITTEST_CFG_DICT["trace"] = True -# super(Test6809_Program, self).setUp() - - def test_clear_loop(self): - self.cpu_test_run(start=0x0100, end=None, mem=[ - 0x8E, 0x00, 0x10, # L_B3BA ldx #$0010 ; clear 0 - 3ff - 0x6F, 0x83, # L_B3BD clr ,--x - 0x30, 0x01, # leax 1,x - 0x26, 0xFA, # bne L_B3BD - - ]) - print("TODO: Check result!") - - def _crc16(self, data): - """ - origin code by Johann E. Klasek, j AT klasek at - """ - data_address = 0x1000 # position of the test data - self.cpu.memory.load(data_address, data) # write test data into RAM - self.cpu.user_stack_pointer.set(data_address) # start address of data - self.cpu.index_x.set(len(data)) # number of bytes - - self.cpu_test_run(start=0x0100, end=None, mem=[ - # .ORG $100 - # CRCH: EQU $10 - # CRCL: EQU $21 - # CRC16: - # BL: - 0xA8, 0xC0, # EORA ,u+ ; fetch byte and XOR into CRC high byte - 0x10, 0x8E, 0x00, 0x08, # LDY #8 ; rotate loop counter - 0x58, # RL: ASLB ; shift CRC left, first low - 0x49, # ROLA ; and than high byte - 0x24, 0x04, # BCC cl ; Justify or ... - 0x88, 0x10, # EORA #CRCH ; CRC=CRC XOR polynomic, high - 0xC8, 0x21, # EORB #CRCL ; and low byte - 0x31, 0x3F, # CL: LEAY -1,y ; shift loop (8 bits) - 0x26, 0xF4, # BNE rl - 0x30, 0x1F, # LEAX -1,x ; byte loop - 0x26, 0xEA, # BNE bl - ]) - crc16 = self.cpu.accu_d.get() - return crc16 - - def test_crc16_01(self): - crc16 = self._crc16("Z") - self.assertEqualHex(crc16, 0xfbbf) - - def test_crc16_02(self): - crc16 = self._crc16("DragonPy works?!?") - self.assertEqualHex(crc16, 0xA30D) - - def _crc32(self, data): - """ - Calculate a ZIP 32-bit CRC from data in memory. - Origin code by Johann E. Klasek, j AT klasek at - """ - data_address = 0x1000 # position of the test data - self.cpu.memory.load(data_address, data) # write test data into RAM - self.cpu.index_x.set(data_address + len(data)) # end address - addr_hi, addr_lo = divmod(data_address, 0x100) # start address - - self.cpu_test_run(start=0x0100, end=None, mem=[ - # 0100| .ORG $100 - 0x10, 0xCE, 0x40, 0x00, # 0100| LDS #$4000 - # 0104| CRCHH: EQU $ED - # 0104| CRCHL: EQU $B8 - # 0104| CRCLH: EQU $83 - # 0104| CRCLL: EQU $20 - # 0104| CRCINITH: EQU $FFFF - # 0104| CRCINITL: EQU $FFFF - # 0104| ; CRC 32 bit in DP (4 bytes) - # 0104| CRC: EQU $80 - 0xCE, addr_hi, addr_lo, # 0104| LDU #.... ; start address in u - 0x34, 0x10, # 010C| PSHS x ; end address +1 to TOS - 0xCC, 0xFF, 0xFF, # 010E| LDD #CRCINITL - 0xDD, 0x82, # 0111| STD crc+2 - 0x8E, 0xFF, 0xFF, # 0113| LDX #CRCINITH - 0x9F, 0x80, # 0116| STX crc - # 0118| ; d/x contains the CRC - # 0118| BL: - 0xE8, 0xC0, # 0118| EORB ,u+ ; XOR with lowest byte - 0x10, 0x8E, 0x00, 0x08, # 011A| LDY #8 ; bit counter - # 011E| RL: - 0x1E, 0x01, # 011E| EXG d,x - # 0120| RL1: - 0x44, # 0120| LSRA ; shift CRC right, beginning with high word - 0x56, # 0121| RORB - 0x1E, 0x01, # 0122| EXG d,x - 0x46, # 0124| RORA ; low word - 0x56, # 0125| RORB - 0x24, 0x12, # 0126| BCC cl - # 0128| ; CRC=CRC XOR polynomic - 0x88, 0x83, # 0128| EORA #CRCLH ; apply CRC polynomic low word - 0xC8, 0x20, # 012A| EORB #CRCLL - 0x1E, 0x01, # 012C| EXG d,x - 0x88, 0xED, # 012E| EORA #CRCHH ; apply CRC polynomic high word - 0xC8, 0xB8, # 0130| EORB #CRCHL - 0x31, 0x3F, # 0132| LEAY -1,y ; bit count down - 0x26, 0xEA, # 0134| BNE rl1 - 0x1E, 0x01, # 0136| EXG d,x ; CRC: restore correct order - 0x27, 0x04, # 0138| BEQ el ; leave bit loop - # 013A| CL: - 0x31, 0x3F, # 013A| LEAY -1,y ; bit count down - 0x26, 0xE0, # 013C| BNE rl ; bit loop - # 013E| EL: - 0x11, 0xA3, 0xE4, # 013E| CMPU ,s ; end address reached? - 0x26, 0xD5, # 0141| BNE bl ; byte loop - 0xDD, 0x82, # 0143| STD crc+2 ; CRC low word - 0x9F, 0x80, # 0145| STX crc ; CRC high word - ]) - d = self.cpu.accu_d.get() - x = self.cpu.index_x.get() - crc32 = x * 0x10000 + d - return crc32 ^ 0xFFFFFFFF - - def _test_crc32(self, txt): - if six.PY3: - txt = bytes(txt, encoding="UTF-8") - crc32 = self._crc32(txt) - excpected_crc32 = binascii.crc32(txt) & 0xffffffff - hex1 = "$%08x" % crc32 - hex2 = "$%08x" % excpected_crc32 -# print -# print "Test String: %s" % repr(txt) -# print "\tpython..:", hex1 -# print "\tcrc32...:", hex2 - self.assertEqual(hex1, hex2) - - def test_crc32_01(self): - self._test_crc32("a09") # $3617c6fe - - def test_crc32_02(self): - self._test_crc32("DragonPy test!") # $570e3666 - - def test_crc32_03(self): - self._test_crc32("ZYXWVUTSRQPONMLKJIHGFEDBCA") # $99cdfdb2 - - # following tests works too but takes some time to run: -# def test_crc32_04(self): -# self._test_crc32("DragonPy Integration testing...") # $728b1186 -# def test_crc32_05(self): -# self._test_crc32("An Arbitrary String") # $6fbeaae7 -# def test_crc32_06(self): -# self._test_crc32("ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 0123456789") # $749f0b1a - - def _division(self, dividend, divisor): - assert isinstance(dividend, int) - assert isinstance(divisor, int) - assert 0x0 <= dividend <= 0x100000000 - assert 0x0 <= divisor <= 0x10000 - - a = [dividend >> (i << 3) & 0xff for i in (3, 2, 1, 0)] -# print "a:", [hex(i) for i in a] - - b = [divisor >> (i << 3) & 0xff for i in (1, 0)] -# print "b:", [hex(i) for i in b] - - """ - orgigin code from Talbot System FIG Forth and modifyed by J.E. Klasek j+forth@klasek.at - see: - https://github.com/6809/sbc09/blob/master/examples/uslash.asm - """ - self.cpu_test_run(start=0x0100, end=None, mem=[ - # 0100| .ORG $100 - # 0100| ; sample parameters on stack ... - 0xCC, a[2], a[3], # 0100| LDD #$.... ; dividend low word - 0x36, 0x06, # 0103| PSHU d - 0xCC, a[0], a[1], # 0105| LDD #$.... ; dividend high word - 0x36, 0x06, # 0108| PSHU d - 0xCC, b[0], b[1], # 010A| LDD #$.... ; divisor word - 0x36, 0x06, # 010D| PSHU d - 0xEC, 0x42, # 010F| USLASH: LDD 2,u - 0xAE, 0x44, # 0111| LDX 4,u - 0xAF, 0x42, # 0113| STX 2,u - 0xED, 0x44, # 0115| STD 4,u - 0x68, 0x43, # 0117| ASL 3,u ; initial shift of L word - 0x69, 0x42, # 0119| ROL 2,u - 0x8E, 0x00, 0x10, # 011B| LDX #$10 - 0x69, 0x45, # 011E| USL1: ROL 5,u ; shift H word - 0x69, 0x44, # 0120| ROL 4,u - 0xEC, 0x44, # 0122| LDD 4,u - 0xA3, 0xC4, # 0124| SUBD ,u ; does divisor fit? - 0x1C, 0xFE, # 0126| ANDCC #$FE ; clc - clear carry flag - 0x2B, 0x04, # 0128| BMI USL2 - 0xED, 0x44, # 012A| STD 4,u ; fits -> quotient = 1 - 0x1A, 0x01, # 012C| ORCC #$01 ; sec - Set Carry flag - 0x69, 0x43, # 012E| USL2: ROL 3,u ; L word/quotient - 0x69, 0x42, # 0130| ROL 2,u - 0x30, 0x1F, # 0132| LEAX -1,x - 0x26, 0xE8, # 0134| BNE USL1 - 0x33, 0x42, # 0136| LEAU 2,u - 0xAE, 0xC4, # 0138| LDX ,u ; quotient - 0xEC, 0x42, # 013A| LDD 2,u ; remainder - ]) - quotient = self.cpu.index_x.get() - remainder = self.cpu.accu_d.get() - return quotient, remainder - - def test_division(self): - def test(dividend, divisor): - """ - dividend / divisor = quotient - """ - quotient, remainder = self._division(dividend, divisor) -# print quotient, remainder - - a = Decimal(dividend) - b = Decimal(divisor) - expected_quotient = a // b - expected_remainder = a % b - - first = "%i/%i=%i remainder: %i" % (dividend, divisor, quotient, remainder) - second = "%i/%i=%i remainder: %i" % (dividend, divisor, expected_quotient, expected_remainder) -# print first - self.assertEqual(first, second) - - test(10, 5) - test(10, 3) - test(1000, 2000) - test(0xffff, 0x80) - test(0xfffff, 0x800) - test(0xffffff, 0x8000) - test(0xfffffff, 0x8000) - test(1, 0x8000) - -# test(1, 0x8001) # Error: '1/32769=65534 remainder: 3' != '1/32769=0 remainder: 1' -# test(1, 0x9000) # Error: '10/65535=65533 remainder: 7' != '10/65535=0 remainder: 10' -# test(10, 0xffff) # Error: '10/65535=65533 remainder: 7' != '10/65535=0 remainder: 10' -# test(0xfffffff, 0xffff) # Error: '268435455/65535=57342 remainder: 57341' != '268435455/65535=4096 remainder: 4095' - - -class Test6809_Program_Division2(BaseStackTestCase): - def _division(self, dividend, divisor): - assert isinstance(dividend, int) - assert isinstance(divisor, int) - assert 0x0 <= dividend <= 0xffffffff - assert 0x0 <= divisor <= 0xffff - - a = [dividend >> (i << 3) & 0xff for i in (3, 2, 1, 0)] -# print "a:", [hex(i) for i in a] - - b = [divisor >> (i << 3) & 0xff for i in (1, 0)] -# print "b:", [hex(i) for i in b] - - """ - code from https://github.com/6809/sbc09 - written by J.E. Klasek, replacing high-level variant in eFORTH. - - Special cases: - 1. overflow: quotient overflow if dividend is to great (remainder = divisor), - remainder is set to $FFFF -> special handling. - This is checked also right before the main loop. - 2. underflow: divisor does not fit into dividend -> remainder - get the value of the dividend -> automatically covered. - """ - self.cpu_test_run(start=0x0000, end=None, mem=[ - # 0000| EFORTH: - # 0000| ; sample parameters on forth parameter stack (S) ... - 0xCC, a[2], a[3], # 0000| LDD #$.... ; dividend low word - 0x34, 0x06, # 0003| PSHS d - 0xCC, a[0], a[1], # 0005| LDD #$.... ; dividend high word - 0x34, 0x06, # 0008| PSHS d - 0xCC, b[0], b[1], # 000A| LDD #$.... ; divisor - 0x34, 0x06, # 000D| PSHS d - # 000F| USLASH2: - 0x8E, 0x00, 0x10, # 000F| LDX #16 - 0xEC, 0x62, # 0012| LDD 2,s ; udh - 0x10, 0xA3, 0xE4, # 0014| CMPD ,s ; dividend to great? - 0x24, 0x24, # 0017| BHS UMMODOV ; quotient overflow! - 0x68, 0x65, # 0019| ASL 5,s ; udl low - 0x69, 0x64, # 001B| ROL 4,s ; udl high - 0x59, # 001D| UMMOD1: ROLB ; got one bit from udl - 0x49, # 001E| ROLA - 0x25, 0x09, # 001F| BCS UMMOD2 ; bit 16 means always greater as divisor - 0x10, 0xA3, 0xE4, # 0021| CMPD ,s ; divide by un - 0x24, 0x04, # 0024| BHS UMMOD2 ; higher or same as divisor? - 0x1C, 0xFE, # 0026| ANDCC #$fe ; clc - clear carry flag - 0x20, 0x04, # 0028| BRA UMMOD3 - 0xA3, 0xE4, # 002A| UMMOD2: SUBD ,s - 0x1A, 0x01, # 002C| ORCC #$01 ; sec - set carry flag - 0x69, 0x65, # 002E| UMMOD3: ROL 5,s ; udl, quotient shifted in - 0x69, 0x64, # 0030| ROL 4,s - 0x30, 0x1F, # 0032| LEAX -1,x - 0x26, 0xE7, # 0034| BNE UMMOD1 - 0xAE, 0x64, # 0036| LDX 4,s ; quotient - 0x10, 0xA3, 0xE4, # 0038| CMPD ,s ; remainder >= divisor -> overflow - 0x25, 0x05, # 003B| BLO UMMOD4 - # 003D| UMMODOV: - 0xEC, 0xE4, # 003D| LDD ,s ; remainder set to divisor - 0x8E, 0xFF, 0xFF, # 003F| LDX #$FFFF ; quotient = FFFF (-1) marks overflow - # 0042| ; (case 1) - # 0042| UMMOD4: - 0x32, 0x62, # 0042| LEAS 2,s ; un (divisor thrown away) - 0xAF, 0xE4, # 0044| STX ,s ; quotient to TOS - 0xED, 0x62, # 0046| STD 2,s ; remainder 2nd - 0x20, 0x02, # 0048| BRA $0 ;realexit - # 004A| ; not reached - 0x37, 0x80, # 004A| PULU pc ; eFORTH NEXT - # 0051| EXIT: - ]) - quotient = self.cpu.index_x.get() - remainder = self.cpu.accu_d.get() - return quotient, remainder - - def test_division(self): - def test(dividend, divisor): - """ - dividend / divisor = quotient - """ - quotient, remainder = self._division(dividend, divisor) - a = Decimal(dividend) - b = Decimal(divisor) - expected_quotient = a // b - expected_remainder = a % b -# print "$%x / $%x" % (dividend, divisor) - first = "%i/%i=%i remainder: %i (hex: q:$%x r:=$%x)" % ( - dividend, divisor, quotient, remainder, - quotient, remainder, - ) - second = "%i/%i=%i remainder: %i (hex: q:$%x r:=$%x)" % ( - dividend, divisor, expected_quotient, expected_remainder, - expected_quotient, expected_remainder - ) -# if first != second: -# print "ERROR: %r should be: %r\n" % (first, second) -# else: -# print "OK: %s\n" % first - self.assertEqual(first, second) - - test(10, 10) # OK: 10/10=1 remainder: 0 - test(10, 5) # OK: 10/5=2 remainder: 0 - test(10, 3) # OK: 10/3=3 remainder: 1 - test(0xffff, 0x80) # OK: 65535/128=511 remainder: 127 - test(0xffff, 0xff) # OK: 65535/255=257 remainder: 0 - test(0xfffff, 0x800) # OK: 1048575/2048=511 remainder: 2047 - test(0xffffff, 0x8000) # OK: 16777215/32768=511 remainder: 32767 - test(0xfffffff, 0x8000) # OK: 268435455/32768=8191 remainder: 32767 - test(0xfffffff, 0xffff) # OK: 268435455/65535=4096 remainder: 4095 - test(1, 0xffff) # OK: 1/65535=0 remainder: 1 - test(1, 0x8000) # OK: 1/32768=0 remainder: 1 - - def test_overflow(self): - """ - overflow (quotient is > $FFFF) - quotient = $FFFF, remainder = divisor - """ - quotient, remainder = self._division(0x10000, 0x1) - self.assertEqualHexWord(quotient, 0xffff) - self.assertEqualHexWord(remainder, 0x1) - - def test_division_by_zero(self): - quotient, remainder = self._division(0x1, 0x0) - self.assertEqualHexWord(quotient, 0xffff) - self.assertEqualHexWord(remainder, 0) - - - -if __name__ == '__main__': - setup_logging(log, -# level=1 # hardcore debug ;) -# level=10 # DEBUG -# level=20 # INFO -# level=30 # WARNING -# level=40 # ERROR - level=50 # CRITICAL/FATAL - ) - - unittest.main( - argv=( - sys.argv[0], -# "Test6809_Program.test_clear_loop", -# "Test6809_Program.test_crc16_01", -# "Test6809_Program.test_crc32_01", -# "Test6809_Program.test_division", -# "Test6809_Program_Division2", - ), - testRunner=TextTestRunner2, -# verbosity=1, - verbosity=2, - failfast=True, - ) diff --git a/dragonpy/tests/test_6809_register_changes.py b/dragonpy/tests/test_6809_register_changes.py deleted file mode 100644 index 4a9b723e..00000000 --- a/dragonpy/tests/test_6809_register_changes.py +++ /dev/null @@ -1,206 +0,0 @@ -#!/usr/bin/env python -# encoding:utf-8 - -""" - 6809 unittests - ~~~~~~~~~~~~~~ - - Register changed Ops: TFR, EXG - - :created: 2014 by Jens Diemer - www.jensdiemer.de - :copyleft: 2014 by the DragonPy team, see AUTHORS for more details. - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - -from __future__ import absolute_import, division, print_function - -import logging -import sys -import unittest - -from dragonlib.utils.unittest_utils import TextTestRunner2 -from dragonpy.tests.test_base import BaseCPUTestCase - - -log = logging.getLogger("DragonPy") - - -class Test6809_TFR(BaseCPUTestCase): - def test_TFR_A_B(self): - self.cpu.accu_a.set(0x12) - self.cpu.accu_b.set(0x34) - self.cpu_test_run(start=0x2000, end=None, mem=[ - 0x1F, 0x89, # TFR A,B - ]) - self.assertEqualHexByte(self.cpu.accu_a.get(), 0x12) - self.assertEqualHexByte(self.cpu.accu_b.get(), 0x12) - - def test_TFR_B_A(self): - self.cpu.accu_a.set(0x12) - self.cpu.accu_b.set(0x34) - self.cpu_test_run(start=0x2000, end=None, mem=[ - 0x1F, 0x98, # TFR B,A - ]) - self.assertEqualHexByte(self.cpu.accu_a.get(), 0x34) - self.assertEqualHexByte(self.cpu.accu_b.get(), 0x34) - - def test_TFR_X_U(self): - """ - LDX #$1234 - LDU #$abcd - TFR X,U - STX $20 - STU $30 - """ - self.cpu.index_x.set(0x1234) - self.cpu.user_stack_pointer.set(0xabcd) - self.cpu_test_run(start=0x2000, end=None, mem=[ - 0x1F, 0x13, # TFR X,U - ]) - self.assertEqualHexWord(self.cpu.index_x.get(), 0x1234) - self.assertEqualHexWord(self.cpu.user_stack_pointer.get(), 0x1234) - - def test_TFR_CC_X(self): - """ - transfer 8 bit register in a 16 bit register - TODO: verify this behaviour on real hardware! - """ - self.cpu.cc.set(0x34) - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0x1F, 0xA1, # TFR CC,X - ]) - self.assertEqualHexByte(self.cpu.cc.get(), 0x34) - self.assertEqualHexWord(self.cpu.index_x.get(), 0xff34) - - def test_TFR_CC_A(self): - """ - transfer 8 bit register in a 16 bit register - TODO: verify this behaviour on real hardware! - """ - self.cpu.accu_a.set(0xab) - self.cpu.cc.set(0x89) - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0x1F, 0xA8, # TFR CC,A - ]) - self.assertEqualHexByte(self.cpu.cc.get(), 0x89) - self.assertEqualHexByte(self.cpu.accu_a.get(), 0x89) - - def test_TFR_Y_B(self): - """ - transfer 16 bit register in a 8 bit register - TODO: verify this behaviour on real hardware! - """ - self.cpu.index_y.set(0x1234) - self.cpu.accu_b.set(0xab) - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0x1F, 0x29, # TFR Y,B - ]) - self.assertEqualHexWord(self.cpu.index_y.get(), 0x1234) - self.assertEqualHexByte(self.cpu.accu_b.get(), 0x34) - - def test_TFR_undefined_A(self): - """ - transfer undefined register in a 8 bit register - TODO: verify this behaviour on real hardware! - """ - self.cpu.accu_a.set(0x12) - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0x1F, 0x68, # TFR undefined,A - ]) - self.assertEqualHexByte(self.cpu.accu_a.get(), 0xff) - - -class Test6809_EXG(BaseCPUTestCase): - def test_EXG_A_B(self): - self.cpu.accu_a.set(0xab) - self.cpu.accu_b.set(0x12) - self.cpu_test_run(start=0x2000, end=None, mem=[ - 0x1E, 0x89, # EXG A,B - ]) - self.assertEqualHexByte(self.cpu.accu_a.get(), 0x12) - self.assertEqualHexByte(self.cpu.accu_b.get(), 0xab) - - def test_EXG_X_Y(self): - self.cpu_test_run(start=0x2000, end=None, mem=[ - 0x8E, 0xAB, 0xCD, # LDX #$abcd ; set X to $abcd - 0x10, 0x8E, 0x80, 0x4F, # LDY #$804f ; set Y to $804f - 0x1E, 0x12, # EXG X,Y ; y,x=x,y - 0x9F, 0x20, # STX $20 ; store X to $20 - 0x10, 0x9F, 0x40, # STY $40 ; store Y to $40 - ]) - self.assertEqualHexWord(self.cpu.memory.read_word(0x20), 0x804f) # X - self.assertEqualHexWord(self.cpu.memory.read_word(0x40), 0xabcd) # Y - - def test_EXG_A_X(self): - """ - exange 8 bit register with a 16 bit register - TODO: verify this behaviour on real hardware! - """ - self.cpu_test_run(start=0x2000, end=None, mem=[ - 0x86, 0x56, # LDA #$56 - 0x8E, 0x12, 0x34, # LDX #$1234 - 0x1E, 0x81, # EXG A,X - ]) - self.assertEqualHexByte(self.cpu.accu_a.get(), 0x34) - self.assertEqualHexWord(self.cpu.index_x.get(), 0xff56) - - def test_EXG_A_CC(self): - """ - TODO: verify this behaviour on real hardware! - """ - self.cpu.accu_a.set(0x1f) - self.cpu.cc.set(0xe2) - self.cpu_test_run(start=0x2000, end=None, mem=[ - 0x1E, 0x8A, # EXG A,CC - ]) - self.assertEqualHexByte(self.cpu.accu_a.get(), 0xe2) - self.assertEqualHexByte(self.cpu.cc.get(), 0x1f) - - def test_EXG_X_CC(self): - """ - TODO: verify this behaviour on real hardware! - """ - self.cpu.index_x.set(0x1234) - self.cpu.cc.set(0x56) - self.cpu_test_run(start=0x2000, end=None, mem=[ - 0x1E, 0x1A, # EXG X,CC - ]) - self.assertEqualHexWord(self.cpu.index_x.get(), 0xff56) - self.assertEqualHexByte(self.cpu.cc.get(), 0x34) - - def test_EXG_undefined_to_X(self): - """ - TODO: verify this behaviour on real hardware! - """ - self.cpu.index_x.set(0x1234) - self.cpu_test_run(start=0x2000, end=None, mem=[ - 0x1E, 0xd1, # EXG undefined,X - ]) - self.assertEqualHexWord(self.cpu.index_x.get(), 0xffff) - - - -if __name__ == '__main__': - from dragonlib.utils.logging_utils import setup_logging - - setup_logging(log, - level=1 # hardcore debug ;) -# level=10 # DEBUG -# level=20 # INFO -# level=30 # WARNING -# level=40 # ERROR -# level=50 # CRITICAL/FATAL - ) - - unittest.main( - argv=( - sys.argv[0], -# "Test6809_TFR", -# "Test6809_TFR.test_TFR_CC_A", -# "Test6809_EXG", - ), - testRunner=TextTestRunner2, -# verbosity=1, - verbosity=2, -# failfast=True, - ) diff --git a/dragonpy/tests/test_accumulators.py b/dragonpy/tests/test_accumulators.py deleted file mode 100644 index 486517c3..00000000 --- a/dragonpy/tests/test_accumulators.py +++ /dev/null @@ -1,53 +0,0 @@ -#!/usr/bin/env python - -""" - DragonPy - Dragon 32 emulator in Python - ======================================= - - :copyleft: 2013-2014 by the DragonPy team, see AUTHORS for more details. - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - -from __future__ import absolute_import, division, print_function - - -import unittest -from dragonpy.tests.test_base import BaseCPUTestCase - - -class CC_AccumulatorTestCase(BaseCPUTestCase): - def test_A_01(self): - self.cpu.accu_a.set(0xff) - self.assertEqualHex(self.cpu.accu_a.get(), 0xff) - - def test_A_02(self): - self.cpu.accu_a.set(0xff + 1) - self.assertEqualHex(self.cpu.accu_a.get(), 0x00) - - def test_B_01(self): - self.cpu.accu_b.set(0x5a) - self.assertEqualHex(self.cpu.accu_b.get(), 0x5a) - self.assertEqual(self.cpu.cc.V, 0) - - def test_B_02(self): - self.cpu.accu_b.set(0xff + 10) - self.assertEqualHex(self.cpu.accu_b.get(), 0x09) - - def test_D_01(self): - self.cpu.accu_a.set(0x12) - self.cpu.accu_b.set(0xab) - self.assertEqualHex(self.cpu.accu_d.get(), 0x12ab) - - def test_D_02(self): - self.cpu.accu_d.set(0xfd89) - self.assertEqualHex(self.cpu.accu_a.get(), 0xfd) - self.assertEqualHex(self.cpu.accu_b.get(), 0x89) - - def test_D_03(self): - self.cpu.accu_d.set(0xffff + 1) - self.assertEqualHex(self.cpu.accu_a.get(), 0x00) - self.assertEqualHex(self.cpu.accu_b.get(), 0x00) - - -if __name__ == '__main__': - unittest.main(verbosity=2) diff --git a/dragonpy/tests/test_base.py b/dragonpy/tests/test_base.py index de4679c5..a181a32b 100644 --- a/dragonpy/tests/test_base.py +++ b/dragonpy/tests/test_base.py @@ -33,10 +33,10 @@ from dragonpy.Dragon32.periphery_dragon import Dragon32PeripheryUnittest from dragonpy.Simple6809.config import Simple6809Cfg from dragonpy.Simple6809.periphery_simple6809 import Simple6809PeripheryUnittest -from dragonpy.components.cpu6809 import CPU +from MC6809.components.cpu6809 import CPU from dragonpy.components.memory import Memory from dragonpy.core.machine import Machine -from dragonpy.components.cpu_utils.MC6809_registers import ConditionCodeRegister, ValueStorage8Bit +from MC6809.components.cpu_utils.MC6809_registers import ConditionCodeRegister, ValueStorage8Bit from dragonpy.sbc09.config import SBC09Cfg from dragonpy.sbc09.periphery import SBC09PeripheryUnittest from dragonpy.tests.test_config import TestCfg diff --git a/dragonpy/tests/test_cli.py b/dragonpy/tests/test_cli.py index 2e7a751f..d60e1200 100644 --- a/dragonpy/tests/test_cli.py +++ b/dragonpy/tests/test_cli.py @@ -4,7 +4,7 @@ DragonPy - Dragon 32 emulator in Python ======================================= - :copyleft: 2013-2014 by the DragonPy team, see AUTHORS for more details. + :copyleft: 2013-2015 by the DragonPy team, see AUTHORS for more details. :license: GNU GPL v3 or above, see LICENSE for more details. """ @@ -15,22 +15,28 @@ import sys import unittest -CLI = os.path.normpath(os.path.join(os.path.abspath(os.path.dirname(__file__)), - "..", "..", "DragonPy_CLI.py" -)) + +CLI = "DragonPy" # entry_points in setup.py ! class CLITestCase(unittest.TestCase): """ TODO: Do more than this simple tests """ + def _get(self, *args): - cmd_args = [ - sys.executable, - CLI - ] - cmd_args += args - # print("Startup CLI with: %s" % " ".join(cmd_args[1:])) + try: + VIRTUAL_ENV = os.environ["VIRTUAL_ENV"] + except KeyError as err: + # e.g.: started by PyCharm + cli = os.path.join(os.path.dirname(sys.executable), CLI) + else: + cli = os.path.join(VIRTUAL_ENV, "bin", CLI) + + self.assertTrue(os.path.isfile(cli), "CLI file %r not found!" % cli) + + cmd_args = [cli] + list(args) + # print("\nStartup CLI with: %r" % " ".join(cmd_args)) p = subprocess.Popen( cmd_args, @@ -39,12 +45,23 @@ def _get(self, *args): universal_newlines=True, ) retcode = p.wait() - self.assertEqual(retcode, 0) cli_out = p.stdout.read() p.stdout.close() cli_err = p.stderr.read() p.stderr.close() + + if retcode != 0: + msg = ( + "subprocess returned %s.\n" + " *** stdout: ***\n" + "%s\n" + " *** stderr: ***\n" + "%s\n" + "****************\n" + ) % (retcode, cli_out, cli_err) + self.assertEqual(retcode, 0, msg=msg) + return cli_out, cli_err def assertInMultiline(self, members, container): @@ -59,19 +76,18 @@ def assertNotInMultiline(self, members, container): if member in container: self.fail("%r found in:\n%s" % (member, container)) - def test_exists(self): - self.assertTrue( - os.path.isfile(CLI), "CLI file not found here: %s" % CLI - ) - def test_main_help(self): cli_out, cli_err = self._get("--help") -# print(cli_out) -# print(cli_err) + # print(cli_out) + # print(cli_err) self.assertInMultiline([ - "usage: DragonPy_CLI.py [-h]", - "--machine {CoCo2b,Dragon32,Dragon64,Multicomp6809,Vectrex,sbc09}", - "{run,editor,benchmark}", + "Usage: DragonPy [OPTIONS] COMMAND [ARGS]...", + "--machine [CoCo2b|Dragon32|Dragon64|Multicomp6809|Vectrex|sbc09]", + "Commands:", + "editor Run only the BASIC editor", + "log_list List all exiting loggers and exit.", + "run Run a machine emulation", + "tests Run unittests", ], cli_out) errors = ["Error", "Traceback"] @@ -79,9 +95,9 @@ def test_main_help(self): self.assertNotInMultiline(errors, cli_err) def test_log_list(self): - cli_out, cli_err = self._get("--log_list") -# print(cli_out) -# print(cli_err) + cli_out, cli_err = self._get("log_list") + # print(cli_out) + # print(cli_err) self.assertInMultiline([ "A list of all loggers:", "DragonPy.cpu6809", @@ -94,10 +110,10 @@ def test_log_list(self): def test_run_help(self): cli_out, cli_err = self._get("run", "--help") -# print(cli_out) -# print(cli_err) + # print(cli_out) + # print(cli_err) self.assertInMultiline([ - "usage: DragonPy_CLI.py run [-h] [--trace]", + "Usage: DragonPy run [OPTIONS]", ], cli_out) errors = ["Error", "Traceback"] @@ -106,27 +122,16 @@ def test_run_help(self): def test_editor_help(self): cli_out, cli_err = self._get("editor", "--help") -# print(cli_out) -# print(cli_err) + # print(cli_out) + # print(cli_err) self.assertInMultiline([ - "usage: DragonPy_CLI.py editor [-h]", + "Usage: DragonPy editor [OPTIONS]", ], cli_out) errors = ["Error", "Traceback"] self.assertNotInMultiline(errors, cli_out) self.assertNotInMultiline(errors, cli_err) - def test_benchmark_help(self): - cli_out, cli_err = self._get("benchmark", "--help") -# print(cli_out) -# print(cli_err) - self.assertInMultiline([ - "usage: DragonPy_CLI.py benchmark [-h]", - ], cli_out) - - errors = ["Error", "Traceback"] - self.assertNotInMultiline(errors, cli_out) - self.assertNotInMultiline(errors, cli_err) if __name__ == '__main__': diff --git a/dragonpy/tests/test_condition_code_register.py b/dragonpy/tests/test_condition_code_register.py deleted file mode 100644 index d899e9b7..00000000 --- a/dragonpy/tests/test_condition_code_register.py +++ /dev/null @@ -1,128 +0,0 @@ -#!/usr/bin/env python - -""" - DragonPy - Dragon 32 emulator in Python - ======================================= - - :copyleft: 2013-2014 by the DragonPy team, see AUTHORS for more details. - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - -from __future__ import absolute_import, division, print_function -from dragonlib.utils import six -xrange = six.moves.xrange - -import unittest - -from dragonpy.tests.test_base import BaseCPUTestCase -from dragonlib.utils.byte_word_values import signed8 - - -class CCTestCase(BaseCPUTestCase): - def test_set_get(self): - for i in xrange(256): - self.cpu.cc.set(i) - status_byte = self.cpu.cc.get() - self.assertEqual(status_byte, i) - - def test_HNZVC_8(self): - for i in xrange(280): - self.cpu.cc.set(0x00) - r = i + 1 # e.g. ADDA 1 loop - self.cpu.cc.update_HNZVC_8(a=i, b=1, r=r) - # print r, self.cpu.cc.get_info - - # test half carry - if r % 16 == 0: - self.assertEqual(self.cpu.cc.H, 1) - else: - self.assertEqual(self.cpu.cc.H, 0) - - # test negative - if 128 <= r <= 255: - self.assertEqual(self.cpu.cc.N, 1) - else: - self.assertEqual(self.cpu.cc.N, 0) - - # test zero - if signed8(r) == 0: - self.assertEqual(self.cpu.cc.Z, 1) - else: - self.assertEqual(self.cpu.cc.Z, 0) - - # test overflow - if r == 128 or r > 256: - self.assertEqual(self.cpu.cc.V, 1) - else: - self.assertEqual(self.cpu.cc.V, 0) - - # test carry - if r > 255: - self.assertEqual(self.cpu.cc.C, 1) - else: - self.assertEqual(self.cpu.cc.C, 0) - - # Test that CC registers doesn't reset automaticly - self.cpu.cc.set(0xff) - r = i + 1 # e.g. ADDA 1 loop - self.cpu.cc.update_HNZVC_8(a=i, b=1, r=r) - # print "+++", r, self.cpu.cc.get_info - self.assertEqualHex(self.cpu.cc.get(), 0xff) - - - def test_update_NZ_8_A(self): - self.cpu.cc.update_NZ_8(r=0x12) - self.assertEqual(self.cpu.cc.N, 0) - self.assertEqual(self.cpu.cc.Z, 0) - - def test_update_NZ_8_B(self): - self.cpu.cc.update_NZ_8(r=0x0) - self.assertEqual(self.cpu.cc.N, 0) - self.assertEqual(self.cpu.cc.Z, 1) - - def test_update_NZ_8_C(self): - self.cpu.cc.update_NZ_8(r=0x80) - self.assertEqual(self.cpu.cc.N, 1) - self.assertEqual(self.cpu.cc.Z, 0) - - def test_update_NZ0_16_A(self): - self.cpu.cc.update_NZ0_16(r=0x7fff) # 0x7fff == 32767 - self.assertEqual(self.cpu.cc.N, 0) - self.assertEqual(self.cpu.cc.Z, 0) - self.assertEqual(self.cpu.cc.V, 0) - - def test_update_NZ0_16_B(self): - self.cpu.cc.update_NZ0_16(r=0x00) - self.assertEqual(self.cpu.cc.N, 0) - self.assertEqual(self.cpu.cc.Z, 1) - self.assertEqual(self.cpu.cc.V, 0) - - def test_update_NZ0_16_C(self): - self.cpu.cc.update_NZ0_16(r=0x8000) # signed 0x8000 == -32768 - self.assertEqual(self.cpu.cc.N, 1) - self.assertEqual(self.cpu.cc.Z, 0) - self.assertEqual(self.cpu.cc.V, 0) - - def test_update_NZ0_8_A(self): - self.cpu.cc.update_NZ0_8(0x7f) - self.assertEqual(self.cpu.cc.N, 0) - self.assertEqual(self.cpu.cc.Z, 0) - self.assertEqual(self.cpu.cc.V, 0) - - def test_update_NZ0_8_B(self): - self.cpu.cc.update_NZ0_8(0x100) - self.assertEqual(self.cpu.cc.N, 0) - self.assertEqual(self.cpu.cc.Z, 1) - self.assertEqual(self.cpu.cc.V, 0) - - def test_update_NZV_8_B(self): - self.cpu.cc.update_NZ0_8(0x100) - self.assertEqual(self.cpu.cc.N, 0) - self.assertEqual(self.cpu.cc.Z, 1) - self.assertEqual(self.cpu.cc.V, 0) - - -if __name__ == '__main__': - unittest.main(verbosity=2) - - diff --git a/dragonpy/tests/test_cpu6809.py b/dragonpy/tests/test_cpu6809.py deleted file mode 100644 index de003340..00000000 --- a/dragonpy/tests/test_cpu6809.py +++ /dev/null @@ -1,737 +0,0 @@ -#!/usr/bin/env python -# encoding:utf-8 - -""" - :created: 2013-2014 by Jens Diemer - www.jensdiemer.de - :copyleft: 2013-2014 by the DragonPy team, see AUTHORS for more details. - :license: GNU GPL v3 or above, see LICENSE for more details. -""" - -from __future__ import absolute_import, division, print_function -from dragonlib.utils.unittest_utils import TextTestRunner2 -from dragonlib.utils import six -xrange = six.moves.xrange - -import logging -import sys -import unittest - -from dragonpy.components.cpu6809 import CPU -from dragonpy.Dragon32.config import Dragon32Cfg -from dragonpy.Dragon32.mem_info import DragonMemInfo -from dragonpy.tests.test_base import BaseCPUTestCase, BaseStackTestCase - - -log = logging.getLogger("DragonPy") - - -class BaseDragon32TestCase(BaseCPUTestCase): - # http://archive.worldofdragon.org/phpBB3/viewtopic.php?f=8&t=4462 - INITIAL_SYSTEM_STACK_ADDR = 0x7f36 - INITIAL_USER_STACK_ADDR = 0x82ec - - def setUp(self): - cmd_args = UnittestCmdArgs - cfg = Dragon32Cfg(cmd_args) - self.assertFalse(cfg.bus is None) - cfg.mem_info = DragonMemInfo(log.debug) - try: - self.cpu = CPU(cfg) - except IOError as err: - log.error("Missing ROM? %s", err) - else: - self.cpu.system_stack_pointer.set(self.INITIAL_SYSTEM_STACK_ADDR) - self.cpu.user_stack_pointer.set(self.INITIAL_USER_STACK_ADDR) - - -class Test6809_Register(BaseCPUTestCase): - def test_registerA(self): - for i in xrange(255): - self.cpu.accu_a.set(i) - t = self.cpu.accu_a.get() - self.assertEqual(i, t) - - def test_register_8bit_overflow(self): - self.cpu.accu_a.set(0xff) - a = self.cpu.accu_a.get() - self.assertEqualHex(a, 0xff) - - self.cpu.accu_a.set(0x100) - a = self.cpu.accu_a.get() - self.assertEqualHex(a, 0) - - self.cpu.accu_a.set(0x101) - a = self.cpu.accu_a.get() - self.assertEqualHex(a, 0x1) - - def test_register_8bit_negative(self): - self.cpu.accu_a.set(0) - t = self.cpu.accu_a.get() - self.assertEqualHex(t, 0) - - self.cpu.accu_a.set(-1) - t = self.cpu.accu_a.get() - self.assertEqualHex(t, 0xff) - - self.cpu.accu_a.set(-2) - t = self.cpu.accu_a.get() - self.assertEqualHex(t, 0xfe) - - def test_register_16bit_overflow(self): - self.cpu.index_x.set(0xffff) - x = self.cpu.index_x.get() - self.assertEqual(x, 0xffff) - - self.cpu.index_x.set(0x10000) - x = self.cpu.index_x.get() - self.assertEqual(x, 0) - - self.cpu.index_x.set(0x10001) - x = self.cpu.index_x.get() - self.assertEqual(x, 1) - - def test_register_16bit_negative1(self): - self.cpu.index_x.set(-1) - x = self.cpu.index_x.get() - self.assertEqualHex(x, 0xffff) - - self.cpu.index_x.set(-2) - x = self.cpu.index_x.get() - self.assertEqualHex(x, 0xfffe) - - def test_register_16bit_negative2(self): - self.cpu.index_x.set(0) - x = self.cpu.index_x.decrement() - self.assertEqualHex(x, 0x10000 - 1) - - self.cpu.index_x.set(0) - x = self.cpu.index_x.decrement(2) - self.assertEqualHex(x, 0x10000 - 2) - - -class Test6809_ZeroFlag(BaseCPUTestCase): - def test_DECA(self): - self.assertEqual(self.cpu.cc.Z, 0) - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0x86, 0x1, # LDA $01 - 0x4A, # DECA - ]) - self.assertEqual(self.cpu.cc.Z, 1) - - def test_DECB(self): - self.assertEqual(self.cpu.cc.Z, 0) - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0xC6, 0x1, # LDB $01 - 0x5A, # DECB - ]) - self.assertEqual(self.cpu.cc.Z, 1) - - def test_ADDA(self): - self.assertEqual(self.cpu.cc.Z, 0) - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0x86, 0xff, # LDA $FF - 0x8B, 0x01, # ADDA #1 - ]) - self.assertEqual(self.cpu.cc.Z, 1) - - def test_CMPA(self): - self.assertEqual(self.cpu.cc.Z, 0) - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0x86, 0x00, # LDA $00 - 0x81, 0x00, # CMPA %00 - ]) - self.assertEqual(self.cpu.cc.Z, 1) - - def test_COMA(self): - self.assertEqual(self.cpu.cc.Z, 0) - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0x86, 0xFF, # LDA $FF - 0x43, # COMA - ]) - self.assertEqual(self.cpu.cc.Z, 1) - - def test_NEGA(self): - self.assertEqual(self.cpu.cc.Z, 0) - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0x86, 0xFF, # LDA $FF - 0x40, # NEGA - ]) - self.assertEqual(self.cpu.cc.Z, 0) - - def test_ANDA(self): - self.assertEqual(self.cpu.cc.Z, 0) - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0x86, 0xF0, # LDA $F0 - 0x84, 0x0F, # ANDA $0F - ]) - self.assertEqual(self.cpu.cc.Z, 1) - - def test_TFR(self): - self.assertEqual(self.cpu.cc.Z, 0) - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0x86, 0x04, # LDA $04 - 0x1F, 0x8a, # TFR A,CCR - ]) - self.assertEqual(self.cpu.cc.Z, 1) - - def test_CLRA(self): - self.assertEqual(self.cpu.cc.Z, 0) - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0x4F, # CLRA - ]) - self.assertEqual(self.cpu.cc.Z, 1) - - - - -class Test6809_CC(BaseCPUTestCase): - """ - condition code register tests - """ - def test_defaults(self): - status_byte = self.cpu.cc.get() - self.assertEqual(status_byte, 0) - - def test_from_to(self): - for i in xrange(256): - self.cpu.cc.set(i) - status_byte = self.cpu.cc.get() - self.assertEqual(status_byte, i) - - def test_AND(self): - excpected_values = list(range(0, 128)) - excpected_values += list(range(0, 128)) - excpected_values += list(range(0, 4)) - - for i in xrange(260): - self.cpu.accu_a.set(i) - self.cpu.cc.set(0x0e) # Set affected flags: ....NZV. - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0x84, 0x7f, # ANDA #$7F - ]) - r = self.cpu.accu_a.get() - excpected_value = excpected_values[i] -# print i, r, excpected_value, self.cpu.cc.get_info, self.cpu.cc.get() - - # test AND result - self.assertEqual(r, excpected_value) - - # test all CC flags - if r == 0: - self.assertEqual(self.cpu.cc.get(), 4) - else: - self.assertEqual(self.cpu.cc.get(), 0) - - -class Test6809_Ops(BaseCPUTestCase): - def test_TFR01(self): - self.cpu.index_x.set(512) # source - self.assertEqual(self.cpu.index_y.get(), 0) # destination - - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0x1f, # TFR - 0x12, # from index register X (0x01) to Y (0x02) - ]) - self.assertEqual(self.cpu.index_y.get(), 512) - - def test_TFR02(self): - self.cpu.accu_b.set(0x55) # source - self.assertEqual(self.cpu.cc.get(), 0) # destination - - self.cpu_test_run(start=0x1000, end=0x1002, mem=[ - 0x1f, # TFR - 0x9a, # from accumulator B (0x9) to condition code register CC (0xa) - ]) - self.assertEqual(self.cpu.cc.get(), 0x55) # destination - - def test_TFR03(self): - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0x10, 0x8e, 0x12, 0x34, # LDY Y=$1234 - 0x1f, 0x20, # TFR Y,D - ]) - self.assertEqualHex(self.cpu.accu_d.get(), 0x1234) # destination - - def test_CMPU_immediate(self): - u = 0x80 - self.cpu.user_stack_pointer.set(u) - for m in xrange(0x7e, 0x83): - self.cpu_test_run(start=0x0000, end=None, mem=[ - 0x11, 0x83, # CMPU (immediate word) - 0x00, m # the word that CMP reads - ]) - r = u - m - """ - 80 - 7e = 02 -> ........ - 80 - 7f = 01 -> ........ - 80 - 80 = 00 -> .....Z.. - 80 - 81 = -1 -> ....N..C - 80 - 82 = -2 -> ....N..C - """ -# print "%02x - %02x = %02x -> %s" % ( -# u, m, r, self.cpu.cc.get_info -# ) - - # test negative: 0x01 <= a <= 0x80 - if r < 0: - self.assertEqual(self.cpu.cc.N, 1) - else: - self.assertEqual(self.cpu.cc.N, 0) - - # test zero - if r == 0: - self.assertEqual(self.cpu.cc.Z, 1) - else: - self.assertEqual(self.cpu.cc.Z, 0) - - # test overflow - self.assertEqual(self.cpu.cc.V, 0) - - # test carry is set if r=1-255 (hex: r=$01 - $ff) - if r < 0: - self.assertEqual(self.cpu.cc.C, 1) - else: - self.assertEqual(self.cpu.cc.C, 0) - - def test_CMPA_immediate_byte(self): - a = 0x80 - self.cpu.accu_a.set(a) - for m in xrange(0x7e, 0x83): - self.cpu_test_run(start=0x0000, end=None, mem=[ - 0x81, m # CMPA (immediate byte) - ]) - r = a - m - """ - 80 - 7e = 02 -> ......V. - 80 - 7f = 01 -> ......V. - 80 - 80 = 00 -> .....Z.. - 80 - 81 = -1 -> ....N..C - 80 - 82 = -2 -> ....N..C - """ -# print "%02x - %02x = %02x -> %s" % ( -# a, m, r, self.cpu.cc.get_info -# ) - - # test negative: 0x01 <= a <= 0x80 - if r < 0: - self.assertEqual(self.cpu.cc.N, 1) - else: - self.assertEqual(self.cpu.cc.N, 0) - - # test zero - if r == 0: - self.assertEqual(self.cpu.cc.Z, 1) - else: - self.assertEqual(self.cpu.cc.Z, 0) - - # test overflow - if r > 0: - self.assertEqual(self.cpu.cc.V, 1) - else: - self.assertEqual(self.cpu.cc.V, 0) - - # test carry is set if r=1-255 (hex: r=$01 - $ff) - if r < 0: - self.assertEqual(self.cpu.cc.C, 1) - else: - self.assertEqual(self.cpu.cc.C, 0) - - def test_CMPX_immediate_word(self): - x = 0x80 - self.cpu.index_x.set(x) - for m in xrange(0x7e, 0x83): - self.cpu_test_run(start=0x0000, end=None, mem=[ - 0x8c, 0x00, m # CMPX (immediate word) - ]) - r = x - m - """ - 80 - 7e = 02 -> ........ - 80 - 7f = 01 -> ........ - 80 - 80 = 00 -> .....Z.. - 80 - 81 = -1 -> ....N..C - 80 - 82 = -2 -> ....N..C - """ -# print "%02x - %02x = %02x -> %s" % ( -# x, m, r, self.cpu.cc.get_info -# ) - - # test negative: 0x01 <= a <= 0x80 - if r < 0: - self.assertEqual(self.cpu.cc.N, 1) - else: - self.assertEqual(self.cpu.cc.N, 0) - - # test zero - if r == 0: - self.assertEqual(self.cpu.cc.Z, 1) - else: - self.assertEqual(self.cpu.cc.Z, 0) - - # test overflow - self.assertEqual(self.cpu.cc.V, 0) - - # test carry is set if r=1-255 (hex: r=$01 - $ff) - if r < 0: - self.assertEqual(self.cpu.cc.C, 1) - else: - self.assertEqual(self.cpu.cc.C, 0) - - def test_ABX_01(self): - self.cpu.cc.set(0xff) - self.cpu.accu_b.set(0x0f) - self.cpu.index_x.set(0x00f0) - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0x3A, # ABX - ]) - self.assertEqualHex(self.cpu.index_x.get(), 0x00ff) - self.assertEqualHex(self.cpu.cc.get(), 0xff) - - self.cpu.cc.set(0x00) - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0x3A, # ABX - ]) - self.assertEqualHex(self.cpu.index_x.get(), 0x010E) - self.assertEqualHex(self.cpu.cc.get(), 0x00) - - -class Test6809_TestInstructions(BaseCPUTestCase): - def assertTST(self, i): - if 128 <= i <= 255: # test negative - self.assertEqual(self.cpu.cc.N, 1) - else: - self.assertEqual(self.cpu.cc.N, 0) - - if i == 0: # test zero - self.assertEqual(self.cpu.cc.Z, 1) - else: - self.assertEqual(self.cpu.cc.Z, 0) - - # test overflow - self.assertEqual(self.cpu.cc.V, 0) - - # test not affected flags: - self.assertEqual(self.cpu.cc.E, 1) - self.assertEqual(self.cpu.cc.F, 1) - self.assertEqual(self.cpu.cc.H, 1) - self.assertEqual(self.cpu.cc.I, 1) - self.assertEqual(self.cpu.cc.C, 1) - - def test_TST_direct(self): - for i in xrange(255): - self.cpu.accu_a.set(i) - self.cpu.cc.set(0xff) # Set all CC flags - - self.cpu.memory.write_byte(address=0x00, value=i) - - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0x0D, 0x00 # TST $00 - ]) - self.assertTST(i) - - def test_TST_extended(self): - for i in xrange(255): - self.cpu.accu_a.set(i) - self.cpu.cc.set(0xff) # Set all CC flags - - self.cpu.memory.write_byte(address=0x1234, value=i) - - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0x7D, 0x12, 0x34 # TST $1234 - ]) - self.assertTST(i) - - def test_TSTA(self): - for i in xrange(255): - self.cpu.accu_a.set(i) - self.cpu.cc.set(0xff) # Set all CC flags - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0x4D # TSTA - ]) - self.assertTST(i) - - def test_TSTB(self): - for i in xrange(255): - self.cpu.accu_b.set(i) - self.cpu.cc.set(0xff) # Set all CC flags - self.cpu_test_run(start=0x1000, end=None, mem=[ - 0x5D # TSTB - ]) - self.assertTST(i) - - - - - - - - -# TODO: -# self.cpu_test_run(start=0x4000, end=None, mem=[0x4F]) # CLRA -# self.assertEqualHex(self.cpu.accu_d.get(), 0x34) -# -# self.cpu_test_run(start=0x4000, end=None, mem=[0x5F]) # CLRB -# self.assertEqualHex(self.cpu.accu_d.get(), 0x0) - - -class Test6809_Stack(BaseStackTestCase): - def test_PushPullSytemStack_01(self): - self.assertEqualHex( - self.cpu.system_stack_pointer.get(), - self.INITIAL_SYSTEM_STACK_ADDR - ) - - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0x86, 0x1a, # LDA A=$1a - 0x34, 0x02, # PSHS A - ]) - - self.assertEqualHex( - self.cpu.system_stack_pointer.get(), - self.INITIAL_SYSTEM_STACK_ADDR - 1 # Byte added - ) - - self.assertEqualHex(self.cpu.accu_a.get(), 0x1a) - - self.cpu.accu_a.set(0xee) - - self.assertEqualHex(self.cpu.accu_b.get(), 0x00) - - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0x35, 0x04, # PULS B ; B gets the value from A = 1a - ]) - - self.assertEqualHex( - self.cpu.system_stack_pointer.get(), - self.INITIAL_SYSTEM_STACK_ADDR # Byte removed - ) - - self.assertEqualHex(self.cpu.accu_a.get(), 0xee) - self.assertEqualHex(self.cpu.accu_b.get(), 0x1a) - - def test_PushPullSystemStack_02(self): - self.assertEqualHex( - self.cpu.system_stack_pointer.get(), - self.INITIAL_SYSTEM_STACK_ADDR - ) - - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0x86, 0xab, # LDA A=$ab - 0x34, 0x02, # PSHS A - 0x86, 0x02, # LDA A=$02 - 0x34, 0x02, # PSHS A - 0x86, 0xef, # LDA A=$ef - ]) - self.assertEqualHex(self.cpu.accu_a.get(), 0xef) - - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0x35, 0x04, # PULS B - ]) - self.assertEqualHex(self.cpu.accu_a.get(), 0xef) - self.assertEqualHex(self.cpu.accu_b.get(), 0x02) - - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0x35, 0x02, # PULS A - ]) - self.assertEqualHex(self.cpu.accu_a.get(), 0xab) - self.assertEqualHex(self.cpu.accu_b.get(), 0x02) - - self.assertEqualHex( - self.cpu.system_stack_pointer.get(), - self.INITIAL_SYSTEM_STACK_ADDR - ) - - def test_PushPullSystemStack_03(self): - self.assertEqualHex( - self.cpu.system_stack_pointer.get(), - self.INITIAL_SYSTEM_STACK_ADDR - ) - - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0xcc, 0x12, 0x34, # LDD D=$1234 - 0x34, 0x06, # PSHS B,A - 0xcc, 0xab, 0xcd, # LDD D=$abcd - 0x34, 0x06, # PSHS B,A - 0xcc, 0x54, 0x32, # LDD D=$5432 - ]) - self.assertEqualHex(self.cpu.accu_d.get(), 0x5432) - - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0x35, 0x06, # PULS B,A - ]) - self.assertEqualHex(self.cpu.accu_d.get(), 0xabcd) - self.assertEqualHex(self.cpu.accu_a.get(), 0xab) - self.assertEqualHex(self.cpu.accu_b.get(), 0xcd) - - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0x35, 0x06, # PULS B,A - ]) - self.assertEqualHex(self.cpu.accu_d.get(), 0x1234) - - def test_PushPullUserStack_01(self): - self.assertEqualHex( - self.cpu.user_stack_pointer.get(), - self.INITIAL_USER_STACK_ADDR - ) - - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0xcc, 0x12, 0x34, # LDD D=$1234 - 0x36, 0x06, # PSHU B,A - 0xcc, 0xab, 0xcd, # LDD D=$abcd - 0x36, 0x06, # PSHU B,A - 0xcc, 0x54, 0x32, # LDD D=$5432 - ]) - self.assertEqualHex(self.cpu.accu_d.get(), 0x5432) - - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0x37, 0x06, # PULU B,A - ]) - self.assertEqualHex(self.cpu.accu_d.get(), 0xabcd) - self.assertEqualHex(self.cpu.accu_a.get(), 0xab) - self.assertEqualHex(self.cpu.accu_b.get(), 0xcd) - - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0x37, 0x06, # PULU B,A - ]) - self.assertEqualHex(self.cpu.accu_d.get(), 0x1234) - - -class Test6809_Code(BaseCPUTestCase): - """ - Test with some small test codes - """ - def test_code01(self): - self.cpu.memory.load( - 0x2220, [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF] - ) - - self.cpu_test_run(start=0x4000, end=None, mem=[ - 0x86, 0x22, # LDA $22 ; Immediate - 0x8E, 0x22, 0x22, # LDX $2222 ; Immediate - 0x1F, 0x89, # TFR A,B ; Inherent (Register) - 0x5A, # DECB ; Inherent (Implied) - 0xED, 0x84, # STD ,X ; Indexed (non indirect) - 0x4A, # DECA ; Inherent (Implied) - 0xA7, 0x94, # STA [,X] ; Indexed (indirect) - ]) - self.assertEqualHex(self.cpu.accu_a.get(), 0x21) - self.assertEqualHex(self.cpu.accu_b.get(), 0x21) - self.assertEqualHex(self.cpu.accu_d.get(), 0x2121) - self.assertEqualHex(self.cpu.index_x.get(), 0x2222) - self.assertEqualHex(self.cpu.index_y.get(), 0x0000) - self.assertEqualHex(self.cpu.direct_page.get(), 0x00) - - self.assertMemory( - start=0x2220, - mem=[0xFF, 0x21, 0x22, 0x21, 0xFF, 0xFF] - ) - - def test_code02(self): - self.cpu_test_run(start=0x2000, end=None, mem=[ - 0x10, 0x8e, 0x30, 0x00, # 2000| LDY $3000 - 0xcc, 0x10, 0x00, # 2004| LDD $1000 - 0xed, 0xa4, # 2007| STD ,Y - 0x86, 0x55, # 2009| LDA $55 - 0xA7, 0xb4, # 200B| STA ,[Y] - ]) - self.assertEqualHex(self.cpu.cc.get(), 0x00) - self.assertMemory( - start=0x1000, - mem=[0x55] - ) - - def test_code_LEAU_01(self): - self.cpu.user_stack_pointer.set(0xff) - self.cpu_test_run(start=0x0000, end=None, mem=[ - 0x33, 0x41, # 0000| LEAU 1,U - ]) - self.assertEqualHex(self.cpu.user_stack_pointer.get(), 0x100) - - def test_code_LEAU_02(self): - self.cpu.user_stack_pointer.set(0xff) - self.cpu_test_run(start=0x0000, end=None, mem=[ - 0xCE, 0x00, 0x00, # LDU #$0000 - 0x33, 0xC9, 0x1A, 0xBC, # LEAU $1abc,U - ]) - self.assertEqualHex(self.cpu.user_stack_pointer.get(), 0x1abc) - - def test_code_LDU_01(self): - self.cpu.user_stack_pointer.set(0xff) - self.cpu_test_run(start=0x0000, end=None, mem=[ - 0xCE, 0x12, 0x34, # LDU #$0000 - ]) - self.assertEqualHex(self.cpu.user_stack_pointer.get(), 0x1234) - - def test_code_ORA_01(self): - self.cpu.cc.set(0xff) - self.cpu.accu_a.set(0x12) - self.cpu_test_run(start=0x0000, end=None, mem=[ - 0x8A, 0x21, # ORA $21 - ]) - self.assertEqualHex(self.cpu.accu_a.get(), 0x33) - self.assertEqual(self.cpu.cc.N, 0) - self.assertEqual(self.cpu.cc.Z, 0) - self.assertEqual(self.cpu.cc.V, 0) - - def test_code_ORCC_01(self): - self.cpu.cc.set(0x12) - self.cpu_test_run(start=0x0000, end=None, mem=[ - 0x1A, 0x21, # ORCC $21 - ]) - self.assertEqualHex(self.cpu.cc.get(), 0x33) - - - -class TestSimple6809ROM(BaseCPUTestCase): - """ - use routines from Simple 6809 ROM code - """ - def _is_carriage_return(self, a, pc): - self.cpu.accu_a.set(a) - self.cpu_test_run2(start=0x4000, count=3, mem=[ - # origin start address in ROM: $db16 - 0x34, 0x02, # PSHS A - 0x81, 0x0d, # CMPA #000d(CR) ; IS IT CARRIAGE RETURN? - 0x27, 0x0b, # BEQ NEWLINE ; YES - ]) - self.assertEqualHex(self.cpu.program_counter.get(), pc) - - def test_is_not_carriage_return(self): - self._is_carriage_return(a=0x00, pc=0x4006) - - def test_is_carriage_return(self): - self._is_carriage_return(a=0x0d, pc=0x4011) - - -if __name__ == '__main__': - from dragonlib.utils.logging_utils import setup_logging - - setup_logging(log, -# level=1 # hardcore debug ;) -# level=10 # DEBUG -# level=20 # INFO -# level=30 # WARNING -# level=40 # ERROR - level=50 # CRITICAL/FATAL - ) - - unittest.main( - argv=( - sys.argv[0], -# "Test6809_Register" -# "Test6809_ZeroFlag", -# "Test6809_Ops", -# "Test6809_Ops.test_CMPA_immediate_byte", -# "Test6809_Ops.test_CMPX_immediate_word", -# "Test6809_TestInstructions", -# "Test6809_AddressModes", -# "Test6809_Ops2", -# "Test6809_Ops2.test_TFR_CC_B", -# "Test6809_Stack", -# "Test6809_Stack.test_PushPullSystemStack_03", -# "TestSimple6809ROM", -# "Test6809_Code", - ), - testRunner=TextTestRunner2, -# verbosity=1, - verbosity=2, - failfast=True, - ) diff --git a/dragonpy/vectrex/mem_info.py b/dragonpy/vectrex/mem_info.py index 246f953a..eeff9bcf 100644 --- a/dragonpy/vectrex/mem_info.py +++ b/dragonpy/vectrex/mem_info.py @@ -10,7 +10,7 @@ from __future__ import absolute_import, division, print_function -from dragonpy.core.memory_info import BaseMemoryInfo +from MC6809.core.memory_info import BaseMemoryInfo from dragonpy.utils.humanize import nice_hex import logging diff --git a/requirements/basic_requirements.txt b/requirements/basic_requirements.txt new file mode 100644 index 00000000..f1567f40 --- /dev/null +++ b/requirements/basic_requirements.txt @@ -0,0 +1,6 @@ +# external Python packages +#------------------------- + +# http://click.pocoo.org +# https://pypi.python.org/pypi/click/ +click \ No newline at end of file diff --git a/requirements/developer_installation.txt b/requirements/developer_installation.txt new file mode 100644 index 00000000..20d6d798 --- /dev/null +++ b/requirements/developer_installation.txt @@ -0,0 +1,34 @@ +# +# This is only for developer, which has git write access! +# + +# include the basic requirements +-r basic_requirements.txt + +# For rest2html from python-creole in setup.py +docutils + +wheel + +virtualenv + +# clone own projects with git push access +#---------------------------------------- + +# https://github.com/6809/dragonlib +# https://pypi.python.org/pypi/dragonlib +-e git+git@github.com:6809/dragonlib.git#egg=dragonlib + +# https://pypi.python.org/pypi/MC6809/ +# https://github.com/6809/MC6809 +-e git+git@github.com:6809/MC6809.git#egg=MC6809 + +# https://github.com/jedie/bootstrap_env +# https://pypi.python.org/pypi/bootstrap_env/ +-e git+git@github.com:jedie/bootstrap_env.git#egg=bootstrap_env + +# https://github.com/jedie/DragonPy +# https://pypi.python.org/pypi/DragonPy +-e git+git@github.com:jedie/DragonPy.git#egg=DragonPy + + diff --git a/requirements/git_readonly_installation.txt b/requirements/git_readonly_installation.txt new file mode 100644 index 00000000..e8f283a8 --- /dev/null +++ b/requirements/git_readonly_installation.txt @@ -0,0 +1,30 @@ +# +# This is only for developer, which has no git write access! +# + +# include the basic requirements +-r basic_requirements.txt + +# For rest2html from python-creole in setup.py +docutils + +virtualenv + +# clone own projects read-only +#----------------------------- + +# https://github.com/6809/dragonlib +# https://pypi.python.org/pypi/dragonlib +-e git+https://github.com/6809/dragonlib.git#egg=dragonlib + +# https://pypi.python.org/pypi/MC6809/ +# https://github.com/6809/MC6809 +-e git+https://github.com/6809/MC6809.git#egg=MC6809 + +# https://github.com/jedie/bootstrap_env +# https://pypi.python.org/pypi/bootstrap_env/ +-e git+https://github.com/jedie/bootstrap_env.git#egg=bootstrap_env + +# https://github.com/jedie/DragonPy +# https://pypi.python.org/pypi/DragonPy +-e git+https://github.com:jedie/DragonPy.git#egg=DragonPy \ No newline at end of file diff --git a/requirements/normal_installation.txt b/requirements/normal_installation.txt new file mode 100644 index 00000000..6204ca50 --- /dev/null +++ b/requirements/normal_installation.txt @@ -0,0 +1,18 @@ +# +# Normal installation requirements, using all packages from pypi. +# + +# include the basic requirements +-r basic_requirements.txt + +# https://pypi.python.org/pypi/dragonlib/ +# https://github.com/6809/dragonlib +dragonlib + +# https://pypi.python.org/pypi/MC6809/ +# https://github.com/6809/MC6809 +MC6809 + +# https://github.com/jedie/DragonPy +# https://pypi.python.org/pypi/DragonPy +DragonPy \ No newline at end of file diff --git a/run_BASIC_Editor_only.sh b/run_BASIC_Editor_only.sh index c073e333..a0032229 100755 --- a/run_BASIC_Editor_only.sh +++ b/run_BASIC_Editor_only.sh @@ -1,10 +1,12 @@ #!/bin/bash -# https://github.com/jedie/PyDragon32/tree/master/misc#readme +# https://github.com/jedie/DragonPy + +source ../../bin/activate ( set -x - python2 DragonPy_CLI.py editor + ./DragonPy_CLI.py editor ) echo read -n1 -p "Start bash? [y,n]" doit diff --git a/run_CoCo2b.sh b/run_CoCo2b.sh index 5e3f7abc..34dae163 100755 --- a/run_CoCo2b.sh +++ b/run_CoCo2b.sh @@ -1,10 +1,12 @@ #!/bin/bash -# https://github.com/jedie/PyDragon32/tree/master/misc#readme +# https://github.com/jedie/DragonPy + +source ../../bin/activate ( set -x - python2 DragonPy_CLI.py --verbosity 99 --machine=CoCo2b run + python -OO DragonPy_CLI.py --verbosity 99 --machine=CoCo2b run ) echo read -n1 -p "Start bash? [y,n]" doit @@ -20,4 +22,4 @@ case $doit in *) echo "input, don't know, bye." ;; -esac \ No newline at end of file +esac diff --git a/run_Dragon64.sh b/run_Dragon64.sh index 9d6aaf96..2883d451 100755 --- a/run_Dragon64.sh +++ b/run_Dragon64.sh @@ -1,10 +1,12 @@ #!/bin/bash -# https://github.com/jedie/PyDragon32/tree/master/misc#readme +# https://github.com/jedie/DragonPy + +source ../../bin/activate ( set -x - python2 -OO DragonPy_CLI.py --verbosity 99 --machine=Dragon64 run + python -OO DragonPy_CLI.py --verbosity 99 --machine=Dragon64 run ) echo read -n1 -p "Start bash? [y,n]" doit diff --git a/run_Dragon64_pypy.sh b/run_Dragon64_pypy.sh deleted file mode 100755 index 67396572..00000000 --- a/run_Dragon64_pypy.sh +++ /dev/null @@ -1,44 +0,0 @@ -#!/bin/bash - -# https://github.com/jedie/PyDragon32/tree/master/misc#readme -# - -#PYPY=~/pypy-2.3.1-linux_i686-portable/bin/pypy -PYPY=~/pypy2/bin/pypy - -if [ ! -x ${PYPY} ]; then - ( - echo - echo ERROR: PyPy executable not found here: - echo - echo ${PYPY} - echo - echo You can download PyPy here: - echo - echo http://pypy.org/download.html - echo or - echo https://github.com/squeaky-pl/portable-pypy - echo - ) -else -( - set -x - ${PYPY} -OO DragonPy_CLI.py --verbosity 99 --machine=Dragon64 run -) -fi - -echo -read -n1 -p "Start bash? [y,n]" doit -echo -case $doit in - y|Y) - bash -i - exit 0 - ;; - n|N) - echo "bye bye" - ;; - *) - echo "input, don't know, bye." - ;; -esac diff --git a/run_Multicomp6809.sh b/run_Multicomp6809.sh index 05491ab2..54484545 100755 --- a/run_Multicomp6809.sh +++ b/run_Multicomp6809.sh @@ -1,10 +1,12 @@ #!/bin/bash -# https://github.com/jedie/PyDragon32/tree/master/misc#readme +# https://github.com/jedie/DragonPy + +source ../../bin/activate ( set -x - python2 -OO DragonPy_CLI.py --verbosity 99 --machine=Multicomp6809 run + ./DragonPy_CLI.py --verbosity 99 --machine=Multicomp6809 run ) echo read -n1 -p "Start bash? [y,n]" doit diff --git a/run_all_tests.sh b/run_all_tests.sh index a52d26fe..00429d1e 100755 --- a/run_all_tests.sh +++ b/run_all_tests.sh @@ -1,4 +1,8 @@ #!/bin/bash +# https://github.com/jedie/DragonPy + +source ../../bin/activate + set -x -python2 -m unittest discover --verbose +python -m unittest discover --verbose diff --git a/setup.py b/setup.py index de0fea51..84bc6be6 100755 --- a/setup.py +++ b/setup.py @@ -21,6 +21,18 @@ PACKAGE_ROOT = os.path.dirname(os.path.abspath(__file__)) +if "publish" in sys.argv: + import subprocess + args = [sys.executable or "python", "setup.py", "sdist", "bdist_wheel", "upload"] + print("\nCall: %r\n" % " ".join(args)) + subprocess.call(args) + + print("\nDon't forget to tag this version, e.g.:") + print("\tgit tag v%s" % dragonpy.__version__) + print("\tgit push --tags") + sys.exit() + + # convert creole to ReSt on-the-fly, see also: # https://code.google.com/p/python-creole/wiki/UseInSetup try: @@ -40,6 +52,7 @@ provides=["DragonPy"], install_requires=[ "dragonlib", + "MC6809", "pygments", ], author="Jens Diemer", @@ -48,10 +61,9 @@ keywords="Emulator 6809 Dragon CoCo Vectrex tkinter pypy", long_description=long_description, url="https://github.com/jedie/DragonPy", - # TODO: -# entry_points={ -# "console_scripts": ["DragonPy_CLI = mod:func"], -# }, + entry_points={ + "console_scripts": ["DragonPy = dragonpy.core.cli:cli"], + }, license="GPL v3+", classifiers=[ # https://pypi.python.org/pypi?%3Aaction=list_classifiers @@ -77,5 +89,5 @@ packages=find_packages(), include_package_data=True, zip_safe=False, - test_suite="dragonpy.tests", # or: .../dragonpy $ python3 -m unittest discover + test_suite="dragonpy.tests.get_tests", )

6rB*fTLvU +(R8V=zc=&U>64|#^@t+Cj;9|+iFq(P@6Pv|5W`-{6I#^Tsv8W7C&l*;49ZQbvcHCR< +;JH7$u{+zjj_gX>91RE&7{gC3zqjZ70?dQ<~YFW;@s%EwTXC&6(CQ=)1CP&w^`IP +E%pzuhD~lSPf(r`LCjc4*wr0Avl3=sf7fLwzux1h6E^9NQbpTa@5d%h*P!ep=bQt21NuvZ_-5d&%d84 +dX<_`zDsbENpaE|enn12UT1S%LJ#={HU;Q3p1e7wBIRVrNd>3!g>E#|D`zysy@o%C>TXpR_tD-07M)S +=r@bBhT*ZL5cTfEjc8K@B@;=d;E)3&a_TdAr*xB=06;07MCY<2Zy6duP65?FCaH^hn1331i6W~4WYoy +$ZX&bLyw<^evi+?=Vw^??Dd3?N3V*_(_)R@DnZggNx^-`o8i`coDRwW^-TLATN|J4av0YNCKGAm5$g< +H@=QE*(}ieKDkz$dJ-~AnxDrkO;%nh%eF3n%_;qKK#_wFn>`rtrmpY7Y~JI`^_$^?p$z?tF4?h@BPp>>BN5j#evO`4$QN^^r{kJH>~HX>|7Viq~r^8_#G92&3D+ +{=J$G`+-ciL!$Hut(%{RRg6eH;G-%=wJTAQKBzjmB{lTVCmU+)ylB#DiyTU))mCJxxqA$V4qW*7Y9r% +QaVxIFCBF3<~LAV?IRdZn154mQ}-M7MnX;Gx~OIx<3PORJjA5xuCe=sBn149CV)kDGYf^G0tE~eOe1@ +Pny!=d$0gM;&K4DE378;v&@9H)gnmcaf@Y%)R28`Fq79rd(M{hamod*{I(aMVqIABp8mbGCmz2%ZEku +J~|Z^U^-f_nXQEYG(50A2=y+nMi5jB|^_OG;N{O$w9m17pLz8XmQ&F%Zl>bYq|Z17wcRD+5;-P`hVO;}w9|7Pjj +R*Gi)j6FFa_$A-NDc`SD9xpX|f<7)S6MSQ +d3by4mXLuh{*{*TU`RH<4-#yrtn0%`7Y}x5(rAEOe{Tw}pM=8^+%Cc>xTo^BY}}8VRO9e0L;A*$^flp +2{{!b<-ondHeQ8LsQ03V19AJV5CUbyYBR8xmUlV!g&)o?UQxqv5j~f>UeElVqKF1_?=>FK$33Y%_2-hd#}u3(5rped2iDv1zn~CG1thjoSCC`ozc)Xz(L&5y?jz3SeG{vSxu)*S9Ab(p8$Rs?JBEABr2-d +(!E`*@Q&BdmY@DIzjH&$X_c|)24k5C%(Axk7yVxW15W=jckSEygbJ&0|OQTDx(KzR#NJXz%@YV7t%d! +cd7p14cKJD29E=_A69qwvnp5G;0vLtc;+pe{F%;Y9E`lH)!E~mns`SPnwC=TbTNBu8Z4QS0vw7()dU= +-EaPaIsN6K*3NWGMg#Gahgx7ws9NNo~NIgs?*jI(Q+U)d^t$Po(^i=z;`q{l}sTyRmOewc(yH2?RKVA +n(mR<1x8J1{BEd5^rk~P<)V{2ryHtwBF8R-;BUCXEd$L(cA_ccGZ&1G>;_Astm6v4VAYEGV;_}Eq7*h +i_<2b^&hIkl%;`SCPZRcYF>?B|SnAj9U!a +XKGj(7(|UZ@aAeJ5>2#_}ADxV8P82GJn6=?o%GjyMN_fZre3_S!5g=?XFEq%I(nRkbKGMMHtv0@T_7J +&|=RQ<=S4bt4%hB`dWqTt#mie@W{P-g!Jl_K#w>I>Rb|z{Wj`xH{FF(HjClM2p-nm?@zr +a>Abz(6ON(pRC(35)Jw(MJnl&7U5nne#Nih7+%N${p@5%ZJ7&tr)B@2h0hI(tCtn9@o~2VKV@$8sXWp +iN+2T>zFsH|3&DdkL22PEJhU40K4gYrzvO}L2@D!dpzT4usihAP?BHN2d#(8DGnvs%`L#pN=A{tVg{$ +Y+;lBGboHvb0+cp+8Njju=b^~n&vAt6zWA7Etpydg`4 +pTLj#g}s$l@ODWXfndD^Tq6^(LYmqXa3;s_J<8H2%xR`#5eBt6UnMt9}^uX8FQA=wtCr<$?My>sYjaq +pc#l$nc=RH+m}_J)=A7Sm=kh9BGS%ZISjrh@ +IHJO2kzO9KQH000080Pmr;MjP;i-#rch0BkM*03ZMW0B~t=FJE?LZe(wAFK}UFYhh<;Zf7rcWpZoTk%pd@4ji5^9QILCUgI_rKq>c%cYVa+EgTP +LqixVzJmaES_C(hrLk6t(MbS#UAhNKVdIb&a*K)uNIR@)!XUquvan_c`3$hk&lID)l9IXf~WZ7Mh5Ji +(4|y4dz|dCJ`qH2D2o3D4!3H-=KPlBs$z>$fQ2mCL}r4Cn^Y7PlQ~P(yvQWaQ^A(9nwe!BlLRb&b}ZD +W;-KcBFYs&9q+{F)JgchW;L)Sya+z==XrlD=QD%wCN3Tv^9G{*a??PBZ{$rkrvSeEPwvZZXj&2z*AWO +JD1mb{2E=uX^D>3EiZR5d7e$6vEZajH+{N@}+AD$h(eS7@oH0oUvb06u4O_`IN&&9 +Y}6q)GTHHS4L^ZOzag-U0{R*Ot0WxEV>-@Vyrh76K3S^Ut5Opfn6Yq%-=H_Gf +tVxYmqZY#VFL^QFsw{gQapGEu0;s886F&Uz~)$U`zc9Jq$b5BnWKe$=FyFA|DfTEF&jt)|RE=#hI}vJ +3BsOPoC`6!)A@l@b=G=K&MLIS|#b@q<2!(Rxsl(d4#U(ObygnG3fP-nyuOWcRX8&W382LS^5ZyS<+gQ +B}W!h*cSuJYPw|QOf539_=I+f@~W@Y^NS9@LkRdKtzog8AtR3uhcjNzhQod-vPs<0hz8A2GQ1MEadTc +)xmg3I$lu+`b{=J0e$^|18 +3O(Gu2EHy97tTvRhPZY+S^OD8f?b6!?-@_O#g@NCdGggRB#2@V@E7dg(eUR!3n)G9`u3_f1nE(mvKYt +e>{D6`jAy6%W&SGleeGjd;;CsssQ9t1<1eTM10z=M7;KX48>ZQO*xtmY&wip{g4r=iln@BI-!ixQm9b +6)jnYM;b6lVc~#w}nXW@qV-}9`zmjMpU +tvK|&!<{l_dq6lK5iJl8S|s#D`qNuS{rBUC?2cXV-4B=a<$ZF;c4M5*AO$Y??)CYxIiK5%;lPZiW>*a +7ya4at9R|S}f54*Do%h#LEbHI9^bPQZXS)UXuK0s|GPwAtNfNSY#HM;#CaDS*GS +TTHyhBs<5kL!|=o2&!{~woupbjNr&#!roHlwS-NWm`n)0UJEcO7L^6|&D=C_?3ObLaR6{iLj!$y3TAX +-j3G5vkW*3?eB|m#pem}wE-Va&_q+g@oW(%jR;si($*O+{?Y$?A&?V})xhbS7eg(8?N`c~PiV!W;LZ_ +lkg00b5ovIEhf0W}Vs|P4>#;T|c9<>-2h2j;T60XhUNOOH_r7;_fYKhD44qLYsJ)+IjQs{mhp0*|=VK +@*{joU}i#qAi^Vvd50vO;Ytwn~*yei}@0Tmjj9%!Lf;0}p1xX+jl&`F633{YE?VOP6}O^J@K*LKXeSW +)CE-G?y9K?Ss&&w0;q&y5RsV5j3!`->-&Qz~z3?_S|QUY-{DR4^h0MLh0KC)%2k)(9AD4$=5~{aswwG +%HEd(F(5Q{QD&PK07o;WZT)YmX!4;E7%TY*vNhL$Xyyn}gc(@DX%c&p;^r%D^}A(er-MujY^z?Y(4+& +&7aiBn&7c1Bl>zX*|NQK!5&7B0-tIS-592T5=j(h|duo*(EQhnFE}R?#@O+;*USG!RIQZ}@#gz7Uzzf +m&?4IR2yg_dOYDp= +$PG{Xp%OOECrByp}i6vSM7vFjF!W^&%D2g7`HIe7vNb@`Fyi!`YV_Q>eS^>dWnSD0)4)c@RRif|E^#c +)2raXiR`bPd_s@0eEQ3i +z%r-#XhmU~RHz)MB=lDsNM@B|xV5b0U}w^>G<&j)XN~qctOsKO!HJz@HM&mVtiMA +_Tl_i?`|FAi94Lxd9(Qe$=qA0NjA~ksu&$i=a|zx`bHY;c%5kAYHHn5{r56A#gEy9|@x7-eI`yzHylJ +zF}jfj)}HvvV2N=<(^hg1N=AKa~z;4WP~+_rHW4e%@EnMBF2O6Eqz8=Go +wDAla>Yq-GK8cf#F4DP1-i?TcQcJ5PeD@nkwB?SUz3o!_6Z7GK#hOIZ4nno}7FGDF_3KYevAVYUBOGg ++2HrvVq+RdV1up`NJoc}NT`jhOxww3Ff8}2^waOH@mq2LXYCnR2bZxE8SoVmZzncK9BM@nVgJw;fen|1zDS9#4sG${@{v +@Hl?e-5Y>GOBNRU^@G}iO_!%)FdsXyKUE|Q!p}}L36*K0;BIS^A1F#l6F_ICPO!vndXJP|xHC67bfkQ@TEh)Xen3Sjz1y2=jWbB?LeF#rMm48w^pZxnN7 +B$ECMMhFLj*q_Pkh^`8v#H`h##kX~U}af89CnSvN3OUagC$C2Q{ZKZ*GLBg@akXmRm@=U_P +(XA&X3lqSdvkHI8^x4~Q(BNL`JM^G56EL9>hcW}$h(aJh+*PNPne@BvD7iVIR7qZCALGF6Ipv=y=lt; +O6#;nH@-?K=V7Q4iP%6`C6&ety{UZSaB*a{Gc1{w+$%I^>o*^qZ{~R^H|nzhQlmOcS=B?CtKy-3YU9R +&1p(-RLx7`>+%RL2;$au$0%)#rtHqdl|KNeE|CH@ff~G@Rna8{J4KZBa>G!$|z0tlWHk4YUablBw$$= +XBwyRFx}!bxN~mQ$o=SJ{${R{d1}39p+r*v;j5Yl4+yvZpt-+270hX}9$h`yCV^wu>R{Wx_BdhZ3Tz&Ln%- +HXHHf>-5}7oj;ruY{=uxhgjvquBuh=c}N@h-4lglZWA;3Y91Jx1Hz(qZEjfs^OW#xF83~$$k{3D)T*_ +a@*R3R;;bl*01ThsNOA*^w>dA2BPJ?ScooJMKQm5)?m+F0@?JZuMwTYuaqrNj8CU(!m*6sDQqMV9Veg +_{GQ7Ua0SZlPVT;4w_A%3g&{+-!N-^T)lG7hyl8SCP%(PB)%Sm4?gbL_n8ZND%}I_WacfeslMF4lyHN +kCn|n^cLV~m4B%AaVV|MWkb4w8`g2=W;$+-^Vprj#KOG%WKx)8mar3(GR-|6cCC#}Wy3759p}&4S~b1 +MguBU`!ONL@snQ&@E-o_XSh^yza!^{Z%|2H`)ekn7F@?Dy->u)TvjVyLx-=V#dT${X>AN?xxZw!@@DX +-Y?B9tt=TD|eNS)_)YgSDOa*DXtnHjL9)m7X>&v3cEbqkvquyitAA>d +q74;`Fesax>?L)N6&Zw4Z1Vvwh9Pb_|5~=&cny%h^pz>Bm2DeOr2;)?XTjAfOfLIAYF@&+3=yEZHtQB +A`{@FFNLBpjUfv>-m|uk*S($Ud&`l_uIkD)3tLPrw;Y`45M(mzv>Po%v3&Yjx8+&GD&A5Z$wjM--{PF +oOXD}OKT4Kz65TF%=zAU)k_-W(^baA|NaUv_0~WN&gWaBF8@a%FRGb#h~6b1z?CX>MtBUtcb8dF8!*e;c=zDEz-Z#e~ +{C9NN_QCF!>7EYo#urPVgJb!{hUudGXs$dNQFYKEC1B{OaAXMfHcfCCJMlGAjb{rw)cvB(+V05~`}I5 +=+@3rFE+lIO=qdk2xv-rjRpsBDuwS=JZjJYOc~<+4cTb+yjRs#qkq<@&O$;Qfk0k +CVD_rT5y+*`jQU`MPel$@;QriuycDlJ}Q|so?b`DL$^CaO)mc`E}9mt?T46zbOzx*+9+pCH&Jsxwe46 +`C2-X%w~^fvvKmEs@D&a+e>(HQ#4o$I)vS!noxZmvsWglTBMBb(>L%dR0JyvaZ?$TE5P!aQ-`Al+^|Fq-~)CWd&uiDHun#x7RyFz~-W8%L~LF)VQsiEAD(%H`jvTcH6FtYg4}+?`6fs1-} +_5d9_G36}|%q?gb3xXr0V+n2cpBaA{_i<#kCI%D2?eUiMSD;yMJ28lP|4b$y*2A08)PJbnu3$`?fg!v +`ED?Pj&An>7t?HoGX+(?!0{)6s0UcU`P6>qWLV0OHy^Zvet{dcIk2nqoRl%4@2YpSAUJvo5Cmdv8yk! +ywJq+I}l*^KD&T7v_6ozri2#6-I%BP(P&sd2pLI70izX-L7-{?tD`LP1Z~Ma&>jFS(i)Oczsn=uA|py +wSC3JQ8%_GP{uh-o%ublmrI~wq#jqKY}d>3%=|8{^KuEK*0hBM1M}?-XI*?;-!}P*u`1m&D8)J8uK-~ +0_^)3i6GUeQ)ZRkF)3Q3RldqHXi}48FK83eP;!qBde~y2j?IrLb(3@rnUE|&u`0$K=kMSGQ8hn?kPyM +R*ttKtD>jtJ|y56pU_$K&syjLvSqW5i5+~mu2xT(r{y(oqw00(1+|E{q_y3DW77I{)WOUjHMrlV294J +HUT2?{h)Xm4*HmdXkV70DV3!csij;!;jpSQKaVN9YOTzHaUKh$h#~R^hx&$_bU0UKS5c^mZ%Y2J +WP*73KFM(^e*KLN=-zCin(q{6-h!_yQhKc|UU=!cX5QWKPk__gnEpV7>z_@Wt0RAA=PS5Ik4Rn&PaD? +``d#tD{@)mIRx~>3ac23QT<+a&2M@T1@kFCm8HoYmTMcrh~v4M2Vcy||SVYe&KODMW$A3~p^h4=RM=1 +Zhc;L%@x`S=IsZt2@ig;Xg&N8CST$N2X<+?Z}JVg70FrJcNje_NPMnzuZWe&V)mdqdn}Uc;1Zu|u?JA +UNC|py|xEVY)PZSFATHVyNFUyjLYGptL^wFJOhxDXOt3&S87F%-hT9G;NFJx%3u44FG5=r1+vqd%yvG +Vx`Q&7-_i6wLk?C1V^iY0|}OGS-}QS&5M-YjuU8MS*Sv)7xapInEX3Kv&9@e{j#o8H@Sme?~8vImr)xI>j#^vcD$>qan&3+4qNU|M2GB;Y +jrWB-A;=_?tKQ;i@Ty&ywMMIPN^ZDT~|ay90cBURL??Abi!#qcs-A4L<)5_59}yaJFZE5*BE~of;v54 +tHrAOfpE>bnL@pjYdyKVoRqueyI4w;2_1HV|qC16a`wtZI5c0hJgPJvtbu3PY`Up6$o+>Kv?G1KBr(b;en}7Z7@BXa^(ms@5(CDhoHHfHl8eQI$EyxeC3fr<+E~t_0Cpa@K)8BQ6)1`L5_VB^*Awt; +m%Iqga)v{0w2fuu|y38M)73=&FoGTaQ0?)uXyge(Rw?#sPuor_(Z-)LH*UN=J&7B$JGyNnvIqjYIIH6 +?A`WBY(C_(`;8yWBrD2k#?3PX<+;iqZ;53uf%`2Jmxxi7FHxD~ +iAL?c@Nc17PHH0-PDW +CoU~0agJ!=9;r%XqoFzw9a$UEm5o%Fu1T7d~aE{9vq1cyARTVIbHgC3B@(uJd0OoiRB0^vQz}BdQWVc +MrKHVm)@>>GDqYmn}2Hkl@dnrvE_7SlCm;Y0ea3Z|jD4^?=(r_H7SP9oeH_9O)b}GkHJKXVVVcZ;2M~g +1(dKB$2i~uznAa=lck`kplL#jUQRyT@2hXBakzAx9OwmCSR5dDZT@sKXd@Qw>L#)Aao46hl0`1+}r7* +0JJp)zfIvSs-nipg9lf)()EjFeU>lVbd+sYxE-eOhF&O$=GCH{uQTMhAn~~i05aU`vLcv9(?vr)PhREokaU_GsE54=J5b{{sUOpu;0;Uf()CtwXc+G!3odax`@5$J3Y*096w?a4_=dugVLCS +?ILk`)hc4ozH8-$KO$t*>%32U#3`=i-E*^jnjo^E+lZP3ATMj_ +3t8YZcC&6?Q9*YJ40&n3;#e=A_!RdGeMA2-M6?A@$FXkw +a^1>Jj$-!BF2y{C|`DV4oU$kPI`lehI4gBT@8mb(?hiKZHQVUaR!Bpl)*ZInSfckn5@Pos)gyqcNMa{>JU*yty-K3MAP&S##&3&JR65X6-W=r^bOMJsUS@nm11%rHRbXnLO+d`_j#v-AQqZ?G|bu6J(O=fqJTf2?TXgKw@(t83slT6b2dVS}g@wUM$ +eU8f>m;5f9P$xj~`9JTiz-P6ENOS${LNUKa?4x9{?&Lg>^$(Gv%UTBuPh3OK-uW5LPrYe+R>|Goufa(v15M2BeNv*!*2j*rm&fhW59=d1_Qmg@P1ye)>{puzz2%YGL+Yw +nav&3`UqUeRWo9Y;qAtGK+!^h^N;$ +EM`uv@Hg6VzY*klFvkAe@bDfv8exBdt_n(OMpx7jN~q0{sX9gRlqsc&H+N%g?~ix$>Y<$>Hz=F+E0|lgwG&5C)|uQL++ff(+3a8{|miC +92~^&6r}~=$6~uNL!F*!8;+T7{2ZO@LM*^m2gDY}rVqK6=n*iVH&7*L;k@8>H~BIkxh&eO7$;QIaZ46 +7W}hSC(2K?(F?pDz3cz?2;;y$(=>vb2^cM_%hwCL=Ut(sMBSS!iDV$0g(u~0>U6ZYk6?<|t5)s?&=v? +0&EqfQsj-?Rd-@SX74BiK`ZdFwkbo;>^Fbk7K!@al^_C2_*);!tf4riZ={iE3%AWu@+_QCflwMRKo`sx30}=yxOJUkJ$4RY@P2)cHqyqN<&Wa*;y2oSX`-h1K$7 +H&P=zO{~^311Jb0wV1^Z9D-q=$FmAi!>fFLTx$b%dG0_>lHo8^8^UTvz2T#Gbc}xVZF$z@&GylYx+&f +j%}oghQh6s5LPm9l9vEmuJZUr5Q>9cW?uT%hw}f=#4o+vdd~r-*dpr`TEK8}?nsCB(Gh0(yjMj!mhsU +H_U&|nds228s_FL`sOsEPcA;?o_5ar1<)_ilyVgHMTKd%*Tj-H^UD;zUzSzjn_&JnJVrl{;} +_^rv|7z^hovV|n0<`DXfMqh@-Z?{#)$#vcu%OizRQ9lN+z=S%F_dJn4Nnfh>3!E7|OTwrl7`4RtSp=6Q?xwyZWEX)7>lX`efL9B4l|CSU60Y4%&>UtdqY$e!A_ +GLhgW(P0OgI-j*hjUio=P~g>QaEH!~qYoMVIY +_eyBS1BGcxP=c;?)j-?9-YIlv{h60HbCtvAo9AzNu`43#U17eB?!rI-o^iWfdc>EoROh2Xm81H;d!o`|32ohM3Y^=b^zD8n@)F#$k!46@wvS}v1jzX^bByUVF%w_CM;6tPt%!?GResz8dnsCB#Erg4$gFCAsnvX6+jk_QzNf*Ma5|QWYiURsK2h>;PW;U{>w9MtBw=z!P +5vV=-xufj=!a);5G0ywD9C{_Qe2c`$Mk;rJ?+;7s{7|xD2M(fIm?f^jXqTT&4+nARV(L8^nN-=-7HLQc0Lt%FfKy@drpE_Uil@k3VhXyT{kQ|?qz +Dcs*7WQLqVKzTh*SiP@$Ay0XX4bqlDV)Y8|Y1j)y*0oUj9qRv%FK9Pz!l+5v%#z4%r|QVTwcYRe6osk +vvp(Bj$)0p_V!JUF-=bzo^VpH_wBC2R@rp}%ap8yr%6eqn6xUMEQQ(11Wtb}b7j;{%?D&<{m=LQ8I(_ +>?S@GGpr0?lJXwGNUT2ry}y6kq|;%SLYNnG18GZ8DyPa>HatZvd%KP*Avp4bPtk+*JG%}UFB|DiS2v? +n>H7OBKPa9-xUJb=_ESv+yl4R1?Li?30*q+kg-qwHR9%{_LBPIV^p-!9W%a)8NJNg>9xF0Rp(^@FYAJ +L0+D!zt-od^S%uaY3b5Z>BZ)!Tj%MC>sw+n>l>glNkAh^^kO<(vk~{bg(4?xuKn*y)oh|d~ioOBEBhE +u$?Jo3fkuT`5hsI$O`*C|&uGtX)H%;v4Y6XqCV2~v#Nw5w>6JU~4V}CZoZV-`{4fMrzWPX{W-5$0z6e +jBHa=k_udyNA-e)8IijQ^;OOby`Ey0H8{Nz!F`g~=z3vW;PlX0uVeEpa4^wDzqa(>BDZJcK@6vJ%yz0 +oG}*cW*L&7k<-+AB*{BU8vD=Ez>wU_Abj};p!*o(F`=4H(MQU-O-1qo#msCBAG5t#LlYp#C6D +N!y{}j^|!_&Aw)1TWQ)wwcSeT;OgZy0lFgA;?V{ZvS_uuA} +zmw6#yJcY+vMhLA!+6f~YmAo}{7-oS1%$w95)volQ|MrqjOJPBAjZ1-sanXY?lWVlE~hfvAsjrYTW6` +6o8l57Spah>PVem_{k+*JiJRg$RZz{c9W?Xfinsl0!FZ5U+DI7^m}P>m%8IKW;D;6>kV!SYtl!33Q8t +m@l>3x})fpL`--9a%q^R#uv7oPD534RGp8XeM;3uCn?xCF5v7(P5^X>Aez811nrR%J15_^`q*v*j0>+ +K2@rtC{!!hw#)l%+W9jO}eTSat(H#(&$t)qVJU8J0dU(D!quDj{U6{}yDW3RX8z+Z9U|m?poz<6XOp( +?ggM%042x=`s$H`?sA;RXc(t5Kt3jEf1E^0oaYMpHpGOw8YFStLDms{c$wA6TVs@=(c#K&C+?9?K_JF +a43n%uTt-r&aaBj8GTyr)V{Ho +JOk1qO8MpD#AQuf+(J;UTsO4fdW~lL*~KBvs1>EwADwONQ$mW$MgfQ#^;C?=II!^hfU9B1~wWK(Cp8r +iEVfHDOK)(*{mBT!9yLBLJT%PiZyOI01OKUMpFZ6UN=AptC|}YtCQV!wqxV=x+R7IgM{-2v`;Uw4GSn +=-sZ5muqm3G^#@m=ml7&g*fmp@!wOorzO(pAO+5EmG0#y$KAV~8fI-c3|A0wqRP@>hW>#|^1*eRyt9f +Au;PuA1PI<7MgkW@oJSNBR(5&Ot$wpBw5bU@aa2DYMW|H*!)jPK_)dag> +>xE{x3^^L*zA(zpx{Wcg-i&TxOgBn*a{kkp+3EVXL{cuyk++Q{XlU6nMl0z`Zi0S+G +(Zt`Av#8tANpj%aoY)y_^_=ORjDenm9h`XwDfAXu6lYcasW>wlEGI#>f;!!XrW8@EhLi%ZiBPmC$}1y +?ZKQ{?TR^2y&O%cG?oz}xP*3KIEu_s1y{&l-HQEo%Q?nY9?ZoW~{VGjdpBjoQ`H_bf +PL!UT!JRz&hKXFfn)yVP*${A9JbB=9KHq`&V7n^hu`WR1E-1Yw8@+Id>rD+}hVMqQRPLe7)iH{3<2TR +iZCUbwyfaFU5)<@ai7+vz##sH*(>1 +dE@>bzVAVqKz4$1ZOcrlqgiVuCqn$vP0qLKDH<-*K3brD4tDU>DDR9-DzgcTOdWAvgds^RZCNCoRO@-E5@oZz>@#aCLnoWc$^&DR9q +ge|C;|jcj6y(aW!aURb=2_&*vrRKj<4i&0+Y5TD}!prqp|`mmY}N;wCkcNrt#KHH&(_Q_0Fl0_mZ)K$nJL2woOuEawMbnW(;3UDw@j#ljspZi +e{)6|jSAEzCQA2!AM)TkD+oxR5JPScNKHN!(;meyrnSVY2(Hb+v7>9-_G{X!%T6NF0-TY$;rzeMeY +Lev-7FvvHkwzT_LVpWHcV}Lxu- +#(P6AB>i)+qj=$ +xNJK+77f!H73Luh52|afjYQ%kmCv2PhFL`6mB7}RS6*nDZd^a}Ua&6|p5uD5ikVk!HHA<%WAWM**D&% +UC!9+m|gf*pc#Qkow;*APZ+-c3N!_9;={HcC6I(hc&;K^wKswQthv?h}+E@BLDuRSSopJc0puYC@AR? +tCPm0Q;)K}!+Xeb6g-wL;>r&wc8xP1pQY<_8Ry>#r23O +W54gJEbIpo~ZqkvuSEPg^_0=IrBIuo4HxUxh#W)vpzqwjt~dNm|hq79D+674T&J&9BYC+rT0`zmjG`h<8$0|k! +cCh2gdp7Z#vk$a+VNv68#N5Q>ur9TL9;u%u3U>A=Vqk6rmgUx3jZx(PSp~5x6H_GsagbNV2I=oBb4sg +hr&o>P@$VL)pDD>U|NYlnAB1emju@B9lvfB5RS44jz1cp)|G??MDsSQXN14t!9^@i}>Z^mtWx#I=MmJ +FTisLp70(lACd5m0Rvz8+Rp>{-j3@m1cZ0maXL@}^$3ob_RVxEdsFot)<#n#fgtnC@DaSLj{yqmK-nk +JC@?VVNnkgMCgM{RYv0*{)yy;J=LCLf2(r^r8_yo? +tcc%dBrbJSC;@Ps&#=AjiTxqqDeHj=&0>mq)g+gA}2QDK%s18l1e+m_3b; +;)pBzI3sa6i{A&s;cua1()BBx(OnmYru!C7c5r}`%KFR$ZP4~<-tWG(HA9D=8;~bUGp7~hvV2mYU655 +P|Xm&fo&OB+BDD5xGrW<2C3J3}}VFCJZS)R2~LpFX;1FpLR6~}(RL(uRNw%M(WCZGy*(jLB`a|U^()c +Im)20rqYqZ*(0JJHE0NQ{vd7^#vXf@My&8*Kv{w#k57b>3kEee5w$QKQeDG!zyb-*$G`f-_wu;+mWI; +{$iN^m?7K;?K4yMk}Wzu#HPB>74w-fOI$O8ul@~;}0+)T0YcJx&0Ba=ouziTSY+lv{+YTQAyK5XuVwt +xa%V4)D>u=Z??*Ao9C7*?}t<68gjT`-l)5Dq +Bld7}ie3|3%VL=-F7Sq;}cyn9GOuAF)8k4+`tR!GDnYha*D@j3wjMxrK8E4zImwcDz-yYZn)FRVs00u +1cVAFmiPY)>9`m-dRc{rP)t`?UOx$VzJI9u9A5R{gb_riVI9nv>y;4wSoY6h5Oi}d5tXWCU`fg?%3*M(yWi{f~;gv22IV;w5N?fRWb^_R0D|v^! +;qyIk-YMTlDyIlC?||qHlj>7D-~X(GWgkw|uI{?lIr%VL+xA0U%dyGJd{N)xW@gTqHszpqNA-}$fw+dv83O!zX9sddo*3u@86UEG%Xh9@M;q?7SGIqXXZvAoXGj +-9LA;x>__g*nXUEO&~-={2GsO76oE)(PWa#a+oMXsJYHUQ|1)~r75{dW`BROoWkoB+@sj7Uc$95TSV~~*s1|Nc%*l{1h7PgC&Xg> +vDKkzNroG~Y=U*w-?QqHWbhA7sc{6Z8|B4thUi5U6S0OUcEk{D1ct3MupO?KU8)ob%95b7H8T+!nK+2UA)7@qn>(==DWzlGN*Qb9dyR>*h@^msMu +BzOO5VmeYfa)YKYq6Zdqs^F%62)5qps7IDIXd`m6X)iVkQj(hSbW7N1AvHR`lnop5M%zOq +Xs^+OHgQ>6h71F<-W8aViB1A-m9O9&7cnu_6q`pS$(*<=5{rvbT6R$=ne-5ozN=pR$>ZyhCnlAqzc}B +SKK5Cf!>&4}@Vw*kZ_T7L)#;h@!gqc=7JrV>`E`^gBQVXYGd=mJv4SG5lJHCOL0zBo4a#QXv0T&XEMJ +-(E!dz)c9xCBOL>ML4xQbd_s#B^>XIEiy!u`Ncez%Xv=cV@A&!J5S;pa%P{DX$0Cux2TC#5{SyOVqrA +2m;0qTZdWM2$tvyroZ?&yo3tsFmiY2Gzz9L>_GI%=5xooYj +^pl=Tv#b0o{8kw9(`!isGs!DfJ39G?$&)TC%rK!Pf}lX~~o@IP!PKqu6WmLBbhFm)VSrq3*P5j^r20O +Ghrl`foVdrFp~rAsph< +Th93Mx%>A@X!ZQP-mYp*#=7lhKdI>nB)T{ScYM=ZYHE=;~mo|cBgV1x(bPOqTP^nNZzv{sC66q +1PE2-X;7<4H9Hc8a5z$y{;KvTJ?T0kIrdmzh9Vl={eF!g2JN`GI^NLDn_U1Mfv+O>ph_${K4%b)tqhl +x#%XK_2hE5;e$QpCC$}+ra##Olc9r$7wQ_Q`RH^Y4iaDM +JE<)=qy!`QtA0|%1pAS)PTi@~9hrnKsP_ti>}1CGA`m0-kI@tip3i5fm$8mhoq!=zD(XNK11(DUI$6} +WWXO9Yh=_9HIKmtkkoO(8_}z>D4ZHL9MFwl#>r9SlH)U>ntdw;=q*{m(0Tr$8PYeoDq)*m#-B#%PKx& +Y&7q!D@FIh8c;oC85r6gr8H?c21JsY1HvHN=&e_xw))k1=VP~Z%iZ?`5z@MT?JiR~A!YsH0frteF{5A +Nk+SZB*Ir30wV6mmxFfFWaQU9#)o+cWK^Wdfhnc=G0AL$Yl*z((8%?pgwI^nF6uAa-d}l^{0<_E}-GJ +#HUi7^@D3v3oSxUPhhuN2{~DGV#MPZt%_<0p_7Fq9jd3s6alD(42+2*nNiB>~SLn8zSj7X22kjb$MMaE}HG(~_d%hskwYzl^bH2!Frvv%#^9G4k;|r4@^MFQC@l#L +N9kWFlLn?1O41-d{8zMem=x7)*kt?;QXhB)6>AS3QT9z9_s^b{ev4Mx=Y#WXg-t6tglfav-vGKbMeZK +;yC-!eLP2X;+b$MNcmvzadh1Sy}F}KDN|1o*QcnVNab6z7yqql4BL&0GxZY`4n!H}vmX<7#qvE56GH% +|>@^Ong=iHD%n3IP-bLNT^e&xa4;(8l5XvN&WyK)Y*k8ARQb7iE<%r-TR(OvGnK!j8!6%0VK-9gN?gb +x&U|sS?&%yz}o^r&!A+$4-DgqoWC^w?^Tk&$s$?Y(5qUP48bu;xui2J0} +3o_mj+}}sEXI=u}c!Q&CM?$~eqdlzEBMzKE%x*u8m-Au`HP23QM_UH(a36dKG6 +T@0yka$v?Z?iJncpi$@-5aUv9|THVD(`W^d#@Am!^;Z{bMSY3s6W;-_9NfZxwWqYK|S@Ac?J#cjBK)k +d}lTM#tZximg-qeRIhkV5$4nc>>>(R7ex!ix)TcW=*^Gy(~Q0~F!ZEE(7$pm1u%s0L8?G{_Hm`-m9&qLlBno$|P^xT_CeUi`_rh74)<%9cd!@czn9y3ymo=w}1oBN;SA +lv@@vINM1zh=`$`u0rOgU*dzbDK0wAfX^Fi5M5ujP-3wUa*G}Hl2ZtFhiYK;U#FvV1t*&54b-U7 +sFOdyk?quLII>L3TmN|`i%Y1>Qiyiu#yyqB?a-m+)G4BcXNfy`;-U=dp +4g=F8pH8R|qlRql~EfXZ!jitLQBwZ4JjbM6+TKNE{gCrwN!;+DH3)OG_49Z2sHOc^=n)T;swhbwj;LR +YL!W$xv|EntnIoOp_^)%Z=O8Ph9_M=Fh{3Ry++4IrT@f5L=>`4)AvS@J_JmvF$z*Bz44j*`$l&9>i)> +2`dc-W4i@w@CKC`0a0~ujB*0C}5Q?+g@umP&8*vn>IFaY1O(FV=9u~9Y13x#8k9x7tJ??2 +@(;BW;Z`l%sr}haZ`^Hp4F|pm2uE3l6Ox5w5Zkkf7{)#rP!RkB;2O|=JmIK +l}iC7dIE!-RK_8#rbIPqWAeLj6YQ+NWnZ$_Z{BkY$TKTjMj2yFoSu==#JuY?BieJ*BG#lZG>(WVzNzt +^=8-3XAs8{Bnz{8dyIP6OW!-^J^4Sza1-5cZAghhKDN)Q{!RFTX1l0vR6eyaJrzxmAw_{`(_xA5^GK*jkb6iglEQ#Iv0)?K((2N3SP?<8X{iOwvT6O +r4=wwQJM-nu5SmO~5F3?GsEC(tgja7UZQ+$fefT#2rGFpY>i+Fr-L#}D=yMJ4FW*;AQ*S*~Ks_>7N +QN3;2_$Nde4|B899uwpr$1P(7S!EW7x*W#bF+|8Sp1>qvA!OX3+`2dG)t&PAR%`NSKpG(aK@>2Xi5zb +?sFu8zlyJ2umW5oPfkeSn;_Y%i>h9h>EQx#rrdp=X3W8RDIXmlN`1CP#PabT@N^Xr5%~!L +Y|NPwtp53IZt=S$ovbC98Z#JzrSQ!@@LjEW$7&WY}wT_7N)|R;!=B=sEx?0wY3Lc$ +|GU2RA8JwcghS(qFxU6&2*x9jJQ;GTRH@Pcx!Lkq~dDCufAuYIl)LBOg1V~L(C7GE4*V8aUJ${C| +3AP0k8gClX7tj%uo>APO#FMs)qx>wZSU92_oB~TiA9T(oIl{IEIN9vxPckP_^3A+!iVR5xqc?fHD6f3 +P451?ScO4@_Ni;H%kH;S#+hz*{vI14o*_GP}#2TI>bnSLptoy1rc<)|G@eDZ%EiNF0pflc_AhkFVT*{ +t=^G90#~@0P&tKNs8Jx+1!Eo_;ww?6V1;WMj?Hp%zFC)+(MC)1lwjq3|Jg7g!s|$1|R;WnuU7&!||wT +21LPK@j^wbPa8Z%lewH!cyczPM{pgqm_Q9mHgao4QV=jeti7$`TOU?@kr8njrH5_-W|R@e*5N|qi+wX +gz1%E>Q8T89lm^f^gWcJ@5j&I|7p0hG?my5FxI2}k&GCe@Wx-lZn9m_MuLDp@mP~6dO-!5C87cH98ca~hO+$NP(QslT+i=BK;( +Xfp<44puIG1%w|VW%;&1eWW8k7~A@W|Y?ZjhEj$g{{w50AMGqryg?F;tAC*4|eR<22Ml<+p*XH2dh&* +g}$eFOtzQ<@FO`C|rsN>WmRG~JZ*N13~>lm%tc)h$d?IoZXA2ScA#2}YYD1AM2$lmGMl;D6@_KRrJ9x +9s%caEuk)eYSRd#v@+-x>3^K`w!K)PV>ut9=Z=B2GM<4{>0l%H-w8#(raT~MFp4%iTgh2>_{`)Zt_W=-`kp`0Pr9Nv>??n^S$Au};^xs$kQlYcuop4wQ +F#V69%6tkJpU~LEqBV%1VZ;zg3WL*?%mv@Bt$+{+Ul&ODEwDWw$LeI5B3QR#berLJ$F#+9-j*HZbmIh +!-p`g3<`BmOr70n@@(P_i<1Frdk6ZELEL^G^g;v2(f$uhq_TjbBoR`2$mAxI%MgijTu@G29^=SuUgKc +y5uf+MJ8!*Auayy@0+RZKfQRnyVQvoB6H04W!1HPW0ZeVwDzc%e(nqi*L)OcZEU36Wv>1sK53JMK3u+ +iA&5ANqlF#}^x7V$7an*7sN#6E|ZSc78cNJWjrR`mdf8%h0|uWTW$G=`*S{Zi7nQ-9K^pyklj!?84k69$&!Ea8rRmU(h +-J@Xa^k#)1h{fJX!E4-N6OgtVcbNMXp{2$x068vF{Qz!Eg<7mJ;hf7Xus3 +-zZ9*xbr4mF{FNB<%PoKDwpuHdy<)r(^3M+)vIufBWtp0xIG +*GIj>k`j=-nj-pxHizj->jh1sp-W@8Hmgj;z|KMs5MHTj1xehEe@xIr>^{IhzC0G*Yy%F4_$1~Z{NoD +0S?C8vt2j!{{J0Kb#osqLDB18EMY{L?e>$?lgF-kOpS!5kac}kRN1%3&);?qKDOpltmz8B?G&c*(BVW +ey>xIWm(t4OE!si!G}MFUrwYxy2nXK+f;Z&ySLExBSeb1i7QQ$w+_zfg%-HE7E#Q9Sx|rr(6a${T*-p +MrzKq$D2QMyj3RZV8#We~g$GiK!qyLs%0kWQOm^SUzSg+_BgzJ@lTJj*h`F;KT)nSJi^dNC+u=p3zJG +rPK^i!zU!)^iBl_3WY4?9KrQ`t#HR$97>T}gt+x+Io8tyd{L=tvP=H5Gn%wm>Rws8aGU86;*&{@N2}= +pQ?%WS>+mS>PV=S6`ftc2TYwH&QJO!;P_Cb$91>dwo_fGi12Ws5$&LjukQ67Z)?X;zfZmNip~qE#j5} +7gQ+({QX}j#mMo=$8oZKmV7kf=i8uotZ1azWCF!3yDfeUUVrAj)*}4Rdih-DEk*;SJSI340^dfY3Ue}TS}Y?jpFx^Ca`q9I^8kDp`>hueL0dwLS5~5In@@ApYU}4itC&L`3R^a2%EQ0b5hX9$XO0fq_2v0(_c1W`KZObxSShEOs3!&)|l~1I+x%LE +aBl51<>1?Jli(aoC;R?smS*c}zeVvPvI(A0yY>Y*gHy16)ArUPkwr|Zxc8v@3m)m7i?{M%9+Px^{Bg_ +d};tz0dA*1p%LI}CBOa=@@K@=WhBR$oW`i$5^lwFa#^fnfkeKIDWmOU|ZGI{#U7WJk4{+SG=B3nsgeW +!F35%OO+c^0O6Szn;>7%jx;l!jptPqSW_@_idE>+BC(I1U}X;bvpOv^}tP^ +uq-Uf7;+t-Ft5|sP?_c{YbcPUwcsR7q@5DfwZ@y8B6XQdJ}Kh6cR`yD}AA%P7GiS<=-bs`o&naWoBS^ +j|3cXVclSF-l)MK%I$k5s?&d3=$>Bbe`G)5I53AjHyv!&=Lf$V1VnARIz?+myK|~3-;XMnc|#2;D4Is +%UNq|}d@9x2!RR(Wjc#L&$0>J5ME$*nsjK|rf%@$R%^4@(IDy@xGf|RPb(0d=nh +zCjnDB2e6!%Nl>#L>AihVO8z3`3~gy9pniJ!Wb4MdGq=NHMzYW$L6DlK-Do=}ivr)-8^-l;D=&pDz6P +sx-?fB=lc4vo=6rw-x;jCqnSLhfhv|-XO-hhl!;dF)6^t$>Xs% +rR{22u2Y)I&Hz1V{wSqnh$siRi>+Q{DOi0tb26vdojZX)yn0^O>m#SwjClpJ>;FnZ=tvdEYHbt3vZ;& +pU|T)Maut#KAoFHlo-g8{;Me4_uNGp-UF|eq3K7%F5k!Us$WJ1>EK +D5GTbo+Ry;Y+qqB6#yw#q>g)>t$^@BrywJDI}966}qt?#yP>1gOpgPAFF;KF$l2ez?y&UF56hZh&-Vd +|BzM^W>{g`nlhP1&qB`BDW-?z&Q>b70gBW%0uP5fKx+ZdTJ(Q=FF{Q%!K*iy(E*KIWUIq})Y9@mGAo; +ihrtXK|tDyQ46m9lC^Z2r$;GVy&YpY7l8K2MFGCi~jgu5wszOdEreGz&4IT>Ss)x9{_&3oN3Xw +mGu%MBmKi6A| +a8W7VumIGc;(N0l@;ueAUgM8wDMynZ2XYe*?txt!y&gMh#a+7oz*}WscRA7%J!+1?HPO&oEUPFgK?QW +HLi@4Vrr=#$muA{+YTQ1?MDQMnYT+(Zvg$utM5b@ZB$sCC5%-uH>yv!G_7jJj6JJ{qJ)1DzD0O94cMb +7{oUGRIZSYsX%hJDVOGYSc{ja4Tegx0cJ<)mp@=B|H9t3ye^k{V=O=Y94$^QqI5>d?wIRz3U+rXlM@QrJ%hksbj +Rkd`{r$?_xU>2{)@;K@B%m_5*KDrT-TUw$D>>QBcNYX-sJPL#N7HZ4(2gtW1#cea#={UC@B@#xnih`; +Q`++jcbgt(p(vP-6N&>HmarQVn1Xcm`8+VzQY$@t?G&2sq@bY1B +nzGvF^~XL^260Lpl`*8xCJZugk~19_(T%x7S5k7|tdOVhothtGZlinerS6WDwS?1MU_ud@{0<1`9p2Z +#CL}4q+4MOP!-^FT4AVyXpS%0Xo@W2*vq|RJc$SG|f$z!Sjj_;HzQ^rx%z-pxN~cx?S9o&JKYF=)fy(PtqBOC1vfe3M0rN7!>z3@W5y?> +p#2@2j-aO>&7GWeO4A_P1NSwP|?FoZ}or$Jm@mvC!67h&0gZ^T!klPA$Vh(`Jl&jqZQ`Q(e5*@ekXFB +c54Ja_p8<)kEF`RO`6g0>_^!``>vRaIbwA?&zIniSefxdc~XqvwY*KLVpzu+B5vO-JE#`l6`YYj=B9W +w&$yilz0l|jC4tOI>d{-+c3qM#zUOUxX#Ja2;sJ{a=s^x#Pha=aa+B!uZ-Z-U*z*+#)zWG=Pe}>Z!Mh~AnJC(zz)c+^Vf^9LJhW|j022E`3q{zD1!L>7gsb_Zg57ykTWpxj2j1gVn{gh~gwQe^?oL +Ykzjja=tT@GUHLX~hw3q9^k*@d{de>^&@QR%n0FmorKoY +T{akqcb6PoR=r${tyj3aJ+`0=0YTV#1TxcqcSG2R_|8e#vHFdpFETaP{wnjHq2t3%LeFJyB+yghnB;h@IAIP4Yq!zK88Q!UHtYGBihI;Pf*C32r(EpF&G{579 +-%yS+W~K}|Y5{U=H>}Dh8m#KS+7JuiZjO^wQJwu705cP#^NE`JuJ1lFqTaboVRzOQ#T2HQiM!}3JAK( +wN`40_9?|y8=iGeuU2?OtVvelJWaQ*+xs*GfFN^sV-j#b+-xP5z5ktc?WrR$vi0C3LAhuD3+JD_ +MAay^HO{(vckaN^5tBP?J8|OH>cutxDm+LRR*UWJ6c>O7qSc!b|V)5APZVl585m%CcRHpGW+A%~5VqS +}|8wH$uWqyQWTkHla?VN=%-Tit4k89o9Ws-RD)ub_wqW7P=MElaKAI$sPRE)^f%mHO1B4WEr7IB# +J`;*Zf5R0zkq&QRtl06Za8tFv9L`8pjr4}s7lL77`L0I06)D6`NdCzlmD_talgkxR)_Hzf#o)9dnu!| +hN$zqZy({gy4Hy@kZBX%XUz(O`M5u1gvnM3Bd#cWKvjDy^_KW`!@x6dBR0c&E3-sycafpy2f_%=? +_N_T0=6XmMExhblN2lJ9AL94B{~Cy`zh$A-$uw>l~^*WuFv}E$`TbC#(dGpNM)a^PL`r>XS}yc0u-S_ +I%GXD%(v! +Yw8)Coj%Ciisg9yJzfS!p5{sMAeB>TVxFR4 +6inK#pPHmRLg{mhKX<^hyfUiwm8e_^m_KO@(~>E8h(b3@=lxYz(z(bRJW7YsF@46j_;!6o$f- +PNAp#?(Atsf4dsrNfG~M`*wt;bSNVt67sRm9Vj-(eWalE((~!rXU4>kq*&!2aZ`&oyr%;uUhc==5IesvS2G>@H;zZ0Nip|*GT>06A$?=qOg_4|#zC}EtGp}KLHx2$k(U!@Ra?6{@;K7k0iX`CTW;$x +IMj_Qx^V2oPYlHiS3U2BcaDx?=iVjn;6RK;B*gh3AuT=E2`Q8d40_g8IrFfc%|)%%lh7Jn%&3>*S_wzmrJb;*~iNyfNex9CgP-l7h3Stx;k`|6SmZKjV>NF!Nj8=N-q +}c9#$QYmF>&Lj(9bpQ_?;#RpAR`kv-L#Y>N|aTXVxz~vR9YI1O`8!l+19RMb;6W|({s2CTi44-+_dkx +giPj)QKxAW+@pc&cFYx8_g<=Z@G6S_u^UI{?raMj`H{;X%vbnm&Sgok6Vbp0_=eUt)Pg+d>Y9&rYtUV#&BI$aho}!2Y0OFn!Y(YJn8a^zASvB!hFh$fKI7(BzTksmmQQpT@lIX8@2eY6~^(t9?IyB&R+8-?r)j +eXAx(Byw$_dvw*oU9K^ONef?aD7u()Q_>cEjvj07k77CujVG*dD7r6NK)0vB0~cCod1bKm7L1@$}`yQw9PAicv7=>8c{yT&gY(g9j}`^M$;QFjc36npq}+Ks{R +`b1?&3uKlt)ga{+D~I|~LiyJzqm%`*!+yYH$5I*2$13zd3O^`hmDQ%$Nqjq&Keg0IQ~mak9i+0`Zcf> +-MHIS&DDcCCVGmxh51VGf4Ihp?(4S=n=eQ$Z(vYqGmqf042LL~44H?Hb^t#hb-|5+g^H1eG*-r4}e0O +mPxa8u&NxK6yJal&o#E#sZLUiDkjyVt}^z*;xm>ubqf5={zbU|y`Y85Hn(9nw%k@E~2CMC)1T<%--o$ +>Kweduyk4^e}ztrQe?i6L%2T3%apnR%v@7V$H=%}@L(>`|7*RZ27~9+Ctpzi7zO7Ek#lrEn9Fa&gVFx +XCM}02mw9g1vJX8`Yw+bDNefNb1@t5$|;B?k_Z+n&uQI_xKe*Zpxc{Ne)E}DT5=dr&3V#A_zdIFy>HQ +-Ndq(R;``knSZd2teLJ#qEm*Ki2Rxoi?V84CFr|_aLBg~5}rB7jEQkBtNC(6;m_LN+==t4y)$=Y)rt3 +1P^d$D*Be5ntDAw&p7V+6@a*aFS=dtJPRK$46FR-{55C$W2Gk@v4uQsioG1XN-17`Wbo%=2;AEB>Jx> +r+Q%>2q9!#o9=q0TzNmjJ`A>5EJ0seuH<%FSiG>WEK%Q*~kyBv&xEbCrja3FoH;QG +I^sWT7ctQpQ5;nLJxhqlG|yzi>4QGQp0Xwqfea>PYAsK-e_kAvyN}j@CysCJuo;k2;ghnU3MCAZzD&Y +jxqRd^?DC4wXD?YcNbA@ueSl~<8kj!33Ji~LsK`IxW@eXat@5XE^I%c%-Sk6$eae~B4{o7<9&T@+X*+ +|9VgJ9v$!|Oqg?=c4F>^;Pe0N3oeXy!?!!ijW-Gje@|V-Bmcn;o!q_o_=4>x4Rgg6!$o~j5{o39q$P3 +^RI{T16j!kL8$@*8DW>vTBbD=t@^Go2Bs8*wf!3KVtvY5M+>e5B>6I5e7>vB73k;|Oetd2~>ecABC(s +WsqTu{-6oUlc6qlC$u)^o;qCYBuI`5a>cy#CqUN%{U789wlWj)`edKnMA+AQiw +r<+cqJ_8UQZ}JS_zehxJj+Xo$khg(kl3;TL^!tAqj53Z8*=J?4=zPiQu=nE4>-R^mzdMXn|L`FSLz^%X6T7 +{KR)@E5Vx34o-2VOKAUhpB94RO_aAr)%-|PFsx9^VLypC1<_sQ@7{x$qJnZQ4vP5%CWCnE*%!Su6-0a +Qdv4)XB&7VlePm!21IUcGuAfj+kN-u&V1^A~?Ud>_NXi7oYFN2ya=>eZW<-+kM~=Iz7uLk9nj9ynCuP +3m~zhhLc4r&%QF?~nf-SL)X%|L5TJ;YcNLI>1+e#qJw=yV~M=axjdSurM%!_3P|mVEX+1Uhq}^K*z?y +;WL=IKfHN&nEV}o9R2b2o41EAp1(UB@0k%=S3cBx9s`G3`}aNrus5u_#4GZOwy4O!hgW+qFpEWr?oYf +mlE#)R@AB)b)LtpBoX7&(Njj37%=jzX62d#pME%1vm?{|2Jk#G}svSA~$tCGVk3|8-UN3^gE5hQv2x{ +$iC-2oSzZeY(qunX(6#WWX;Gsg1w*?&%=$b6LjwnqBA5T7SPch{MUewMmq*Qz~8c9VTn7EL#mxe<;uz +_x_B5V`$Y)nj64Ljg*XNZ2hoE=!m(;vbP_iUIvbo-nu+XcY`h`~s3*h4*RRiT?&K@Szlvo|l(z>&A0` +158&ImRXXZ9MN+!!t9%2+8~AUXs~#2Sgh^>H086$(zKIdWm;Cuj3iOgxaMS30-({(c)k3LExjGHx=HZ +li`<0j*#QLfeEF{<0-EP<}CxL3tZN7)J$Ya@&b?gndukB-**9JrbCiouUKxgK{vwqr2vLK=m+jvw+w9 +F^Q$E~yicC`Z#}A!1|v?e^5*W$Qe2qErNfZSqkwGu31w_hk_EC3t#A(6-MGZqPG%{HEh6~%WLgEf(vg +L$ZA?JX;bek|;_(qCipTqf5k-%8UfLGFU05!W8LP$HO*Iu&sc}rqJesY62Ed#ZR}kKf?je;Yg%?p#-4 +Gievy1Bz4mT0Du34fL?hI#(^+B$}I>aieWRf-wk8Hx|+;iv}Fd8&<{AdGkv7n)+HqLiU*2deqxk4crq +<2eH2#N-)#;H{B7{_*yr<+8Auyp +foCYVK`A5>Q)cx02pC4o*B?$Y5UZ%fzi^RVm%1_Ar6hK3GmmfYnA;VL;h_YOw2Uk`Ijqb8#>{Cm4^=U +_`TM*^k0iENWA=|{LBbE&z}p(L(GXsq(RUnuazaCVBJ#-7Q+*w&=@bE=xHBhGh&q&L2<8^3j@qBip3% +yi&Ai*VW;1T5J%ty1>?AYtigKwg<7_11YvqJeSc*#l8=dg^AUm+!i{>_=aT}ufWBNN@3*>3Nf1(5=VDtyYM{AY7hy&Tx``^Ud3_O`#U4t=yYYTZT%;PGGxg9~U%Ul*+L>`UT);C_? +?v+ts8yalaVbi0QRyKz^q3H&DK~QKBB-{s;=msIiEA^$QrZLjg+~!N?7A5QhEX7t&e&t>ZdsZM`c1cC +dBdNu5}``Ng+{1Od}DiFj1jw+^VO7#oypYH&n=K3fRl^ud?5x@(26RO>{7n*!d<;_X}#EJ5aPeOAM)r +=dTB3x`0zJLIJEONX*Wd467?=_GJ3AQ2fu&_tOV>5KG-N=7_XJ_$Djgr(kizyM31;~`Xre@Xv~e*r=_ +ouS`Fm|9dIglIZZcsvc+8_K*M5Jwt1MnQ3i=x`@ysQ%)2%p!)3iTT2s8C$hCPw!>kUe2#qJzBi9yXu) +^Potd+R$%1iRk8J-M)xUisgGi9IA(%OY#1wI=p!iLr4Gl@_o^`QWomL;A(FhROSc!)Xw~n@EhANvf9F +!>w+E^CG)R+vP#2%psjqiH`m|1cy`xjbkG-Ho0#TAIl`xq-r^I`w(~bxEk@c(a1OjpuW0xlh!-eCVI@ +YV+`)TB2Lz?UuQgtVGj5f`J;p+RS&S)ut4X(oyq-BcyUDqU^=09zD2>BY5J*&`Qt3a-{0?2aV4G1{PN +1JMicS(`Q3Clmrt+-KVNs^XXk&Q|B;s;zBVELB1jKTn7(0DY!;xP-&DEP1&s1PzTQZH+Pwf<>I*Pw#Z +SKR4yXe$AS=6^e~Pc$%4+Qim+dhYYMNY*{=5zS;UnEI6lp%vbws#Rs!p`k6jhB7NYMX56Yp@l*KPCe6EZ6Wm(OMl=D +P-W8Q1M-o8s=&l(C0j`{M-$4+$Mb+LrSg&9q+iY11esQPxv%yEgZ;uF4Mel65EnwyeJ99MFUcO)4om- +$-vV@(iR0f9+C$U1PLwazc2D6NBqB7tf>3meu3ih={@1BiSKw#(H@!4}PSU>#^q)uMEq+#D +r{uJWMhTg5e{-*35Hh>bLsgdiwcZdvqueI-VgZ1Gg_aagvw&G`)-Ysr&-bbyRiqFu=Nr6B3sd?^KC+h +6I6#Mp!2;&1mgH6bnW?MiEJD^Y=|LgLip{c1YHJaNKQ_>c~gykcW7*cCN(Y8#?WQ@8F8sL{#RqRHX?ob8qEl~ +vAboQT=?AF?eQu%U_6L+*uS ++HwkhEcSd5O!wS4(3o}lCYKQJ>g>Yk5DE(l!9Ln9`h4ARl;#x;!FupOYLy``&(A79oPfNDsQB+J^TzA +auCcU9`o$~eg-=b$weXeautw`d|HHDMi;9Sla%#6+~8`%5wzNywsxZ>b_rkfqmOeaglN~mij#fKl2jJM#HhhXficO%L3VY$ +Dq5_Ys}SU3*iEK&6{IXs5KYAZW4&=Np6;iE<<-?ikH9dDg!1&~EH`kRt9P7PMPm1^E|en3Tt*V{XOd+ +9x15^Zta+KKVJj(on}y5HNE@C+nV%JUhU{B%Bs_rsueRb#=&#<|zZc6p4TA{Sd2ddecPiP8X(Cjl2|h +iYTR7Fycl0+rKx?{JI9#Nr_}#9CrrE9mOMycsl78Nf6tn0dv96Tn?spDd7JD2$JIvF`m=`AQfVyBr)F +B6=b{xZ;OxFj`+x*;PHDiO54YOGD@N^L38j+)2QlpCKk*^n|VOaGS{_x5EWr4@GH3u6qqxi7V;2tDdt3xgVEYTqJkBVvE45L7 +gwM$3?6Nt1)jMlZ@W91%|Fp5RTI}iPS$Q&>De+}CV}%15T5#GzZiZsJ{BO2(LsPRsS+x^2FBf6`id3b_!#67=N_8#s9-1}{3rxz%;1?4#R +NgmIFake>5^402t~Y0bV8PGPo~TyKK+~<1%TGjz$2bU*%3Nol8qu9k!hGNy~^G!T34I6{oc+2_JIxxJ +X@FyDOx5rN%nrv`_ZxTgOt=fYN8%8mD7C9X4v7`OwW>5KKNw9el#=&re)hxC!0Dkn(Xwld-^>+qSAqv +fkf$pFm{eA-;xe;AP%-`6KLqArL^$45&Tzf{LVVw3eNdvw{o>&SltZ*p1a99izl3~yh0TnB$AVKMVin +^(o8y5!@neHo6##@TzWpX(bYw@xh_!2nO2b$h7|vd={YAfh^~Cyy%2^J3Z@c`iBz_sV+VT{pyNvy=)R +4+&MUco^`fMZ59JP$)R;^cr!$_BQo6tU2xC6fJ-UXoYnpnK>lD&(~Wg +Lr`rVh>jT!zWQSMW3YI#c&+U_`$pPsKt|Nb;^tezeQ;CGXJbg5!ByMrf__$XLfoHLu3hsgO)Qr1u9Zl +AQx5LaCl8w6*na-3zV%20Uelz+9Y|F?wstZT~Q?5d`%)Q^dPEY?LDCDyh-zJka^E>4S5k9-Hnns*5JB +cO(~EkrU(FprKY}Q+)>(q#D@+;jIMpZR79T<(LO}ISUC}x0hA8Cly0c=R`ZF!fJw$Q8&TNj-uY7nw@Z +savcoAIZ>H1EfmAwoP6pQ`4HE!Vp5+DkLK57z=yjxX^SPbZdn2lCH^o$JUXh@?R~#Gic}sV4n!Fp5N@ +Brg+0R>!6ydAS+3rZ0gd(wbct$nslLT8q8k_*DP?Zn{)Y&DB`osI$)wEjXzG?vPU#j;dz#-(gAt8MpONLkL?b-CV<;hRz(Zh@iY)dkE2FpAr{Sx}6n7WQZr +p&PE}t!gwIN-br5ysW_Hw)mmPC@99LKBMh=yDVZ3)~^oVKY#iB{d1 +nB!~b>ozrySQ>B)z5d`hVeJ}j~a6m6HDj6aM{M}vN2rX19fd)nhkJUV8PkkFfiZs5^1>3iS^@J~4ts` +S_$`#@mo?lJ@0A{q;?^K!}O$0nn(pz)i2qngsccVTz;`*8T*W)SY!g89Lm6HiUq$_s0`?Bs%uH?7E^D +LO_zKf=5vpWcv%RhVEQ8GcjOXL*yPPexxQXZcS<+yhecbTWB@J1{bRf5ag8Loi1@EnV1iomqlCl#5$W4I^O7vP5CRbDZ?IcG93C>fZgzALwtG +XlrXT`0!*h`SA3^7lW}a8Lex+IyaXTQ9M+BFC%^s^1jqmWqZ0-RY% +Dvrty@5Q5%h}oOuQrlp|K<3LQSGMcrg#`d*f2B5WkW%g}R3zDgN~g1bB-)Np?cjJ^BGk#!QIO|`BTrR +ZWYZAfdqJE^;*M)Gaiy`QMJQo^ylY@go__G +00RiuHS{7QYYtG^PX!#536Hv`fe^B|=J*g}qh|m?@<}$I-%SB>sa$(NrujGt^!a7P9i^aq^cKU~C@#N +uTs#A#QFcC+-eSWS{?zlx9-5);IGNy8ZS=$UP*f>M1Xl9I%k^UNtVNhZEZtgYs$%Ujr-3Oz#xpyu)9KC-j +3hJQ?>0o#BxfT{be^Q<#;^mvq-uoP$wscDE1IG{_mivdCv$UMA{1Y(s3cWc*9~W~Ep*QL4+lE&7-P%a +iGkJ9POdq%#o=W;bn{hu^#1VGIC+2g_SMnr=kGCokRzv8qMC16XKNBSIi-=L*Emr+UM36Fh&Xr>h#f| +V1M4%X(t1jCNZq3(^q7&2fP=xK#c)r2+<7B(_ikOUjtIXU2LSWwcuDrDCz8R34@?N;N)G!5h??#x&r(thJ_y!35OG8Q552ka!14i;Y<#Rk1J01izj(Ilkj~2vz^I@lFDcp?EkRQY>h-IH=DLmVEinu +Y_ZRlSs!DN4G-dukteXE~XV4nevg!gagv%)rvUld|yCNXM!Fa%_{Z0nv%g1rDJ>}WOuWo8xtC9AJ> +hQ1s$}R#-#As +`x1Dsra;9}M4a|Ml5Q|yzNVWb+nG_CpO1hnrPpW&pv&gu3eR336dHWPiOz)}2SKA&$Smt;50E{(8N8t!rwRTgNkq{s-RiR?efz?^>@9q(Y+&Gj_5ZdF!{U>%oAtqT)yqq|qn6)PhA$9 +{cA1NQNRKaMC4a7-*{cgLxB`_|~cXy4I!T26L_?`G3g5(A4Ox>JH3*EY@hyf#-68gLki7Ip@DB8F>($ +PoA$>N8y#XbWD0dZ%s}fcluYDq2zPet?BgS$uq`K_mzymyAX==`J-CAKGV1DvAZhfMy7Jfc~0Iu>|0i +!%~(-8Gu5qA87W1`W^WK>Y<=|^nZv~{H{|ic)6vN1H)~c2GTf+T#JoINpUSKh6tXe3PDiP7n+h&Nao4 +{%A0=}9ms8u9$MtW2^BaTRFh)@!l#EOI+JI0A1*C{3Dycjs&k5SOS2@fh^T|V0h0SJCW+oRu +lD>8Yh*NV!URzwuM53mH6M1qf=LJMc!62nI19BNg +OmczifqPS!#ohkQ^pmDD$>GO6-2|{r}a_YBS%4<~Mx)QHbU!P~tpyDlLw9XpSm*24U`Gwp+Yu#T4Ct; +2VQ^;P+J2(xCNHNnbx^INKv&*&+l0~Pe8zt#1o;*8<*!s+;Gk)`l`^NQWk<=sxWYN(Dbm2+U)(eq}Q; +GcqGY=%26)Wo6f)WYs?Z5$ZwCgLpylBv^g&tFBt%IJ`op|u}wgOc?{s#+_aL1 +1~$m#5?g}f;u@ee(1rRMM*d%{JD=xx$foo=_{G1JH2DDy5I{D-r+E7KzSYgL08pm#trRNqW{F4LP0Lr +N0CIri88ZUHSi>IGapI#ocib`zkZu|p(irRvkGeQ9*Z +3F_$3QdTA6^fPnQDYXKPHfT3!$5X~opx_-W^odvFa=?vzK`&#Cr*wZW(lXKd$?8V$eS>mc<23Iz5ub4BXH5-mXd~6G=I7tI=0Q> +cvSZLwTteb`Hv`Ssa?lfyrwe={5945X&fhLc +eilonuLj>vRk-s?;0ZmyoTvCX5s{})h80|XQR000O8@1eFv000000ssI200000D*ylhaA|NaUv_0~WN +&gWaBF8@a%FRGb#h~6b1!sdb98erUtei%X>?y-E^v7R08mQ<1QY-O00;o@p|(Z?#u#|N1ONbc4FCW&0 +001RX>c!Jc4cm4Z*nhiYiD0_Wpi(Ja${w4FLY&dbaO9sWpi|2aBF8@a%FRGb#h~6b1raswO31T+%^!t +>sPSqK@zG8iH%-TEZQ6rz=sxrkzU#c0xgbq8B3%}Qv2|)?+o>#v-7T0jKn3OdJr=Pi6NMw` +_w+cE1*6bY!k9_x79rNU(cRUF6u_Yqug6ypmGtF^)JMpwMand0&Yv*AoCq)`YN4sKMZc^WouH4D+@j;|uw2rbP7C8@5Bwp!9`E5St+QMCw2)%OJlgviD`;R_c{A1XK(ND54U%?e>0dGzb9TWfLZjR9P>@@l(ky +OT2|ait>Qt^uiioo@j;6@gq9*+`kS3c}4;Ef2(g|EgHqivj5ZG12hf(p0sJicgZzR)o2^a3eV=lx +w3fIffAImf}B{`$i}4*Cc2=`XO`@hck2*Rgg&X8PnYUoRzWDR*10a^`FwI?5O3X#*yWT7JQ)I4YE*pS +Y7bjzn1GblLyg7L88}MaTSibtb+d;XlG%Y0o(0wDA(hhYo$_n}IP%BdLMbvD<>)sVN!!!2AcFZcRmMg +x;lR9`q29xv?xxU&5=9%h9SLj?HsAH*|xyj{eO9$Bmv2hso023YORAfxJw7+FzKbV +Pl+f9G$zZUY@~?)P;l7qzvc17UO9KQH000080Pmr;Miw-$AFCDs07hH@05Jdn0B~t=FJE?LZe(wAFK}yTUvg!0Z*_8GWpgid +Wpi|MFLY&dbYF61b8mHWV`XzLaCyBvYm?iyuHW}puuf-Wx3+3))9KCLICI;c^f9+dGfmE;$LsNMEqbl +9vZRQzy-uh9{Q{sKBt^^KO?o|(jU<8~00JNgLW(w7ninjU7m>P>hx)P*n`{-uqHbDmizu$|iabhgFRI +(@PzYHxw|BRTT*!2rFNM5V<>|(J#7ek+#&ap)`TK2@i;YMMIb{D3xs1}}`!rd_(Xtpa1+-I-hZhWfe~ +XZS8=wfDu$M`ZAKs)<0>HmDxQ0yfRnt-3C43_kj(?{49q{m06oZS4j4$u_E!?uHNvdDBTwGj)Vx_R;B +Fp>f&3^#t8W@@Wz+))}SA@6M>#=2;MIvOx`I|$rPLsg@1{w$eh*gmIgMqej0i#wZ2h=3)mm(|JOZpF} +cXR+)u`K)r5wln{eWMji(n3+j(wxO2>8oA?_T1ub@#@=uEq;0V`p0)a=|dFTJSj)IXg!%-9mO$cUowx +)ihP?ac_G5N@B1DIZW(ha*(*`-kQcmf_J6s_io=^c-9@3u8zH_*mv<$TtVk;oHYELCB@gUCy3VE?gTBe~}p|60zVPM~C#@~TgAgJ`Jp&MPr_ +h}r%#6m|JU8D916Q~bh^~D->cpHZ-%hPbX6rk3|1k1V;4_m~&Ompjx_-9>f0D!pHet#uicZOSt2E6Bg@!}d8ObENsG9>TeYA +~khTQpOBZJwa=||Fa3e_xlATMtSe=kQ9`aduS{!MJa!+?Y5h7N&uKH +_XLZz;{AXtikkHVL5vq9a1XP~seI5J{SYb3AkMpS5)5Q6xSi5*>u@C0JXte1ds3L&2O+0`i}y_0s6{^ +mr$S9ca$&{Sa-x6-ZS5Ura$IdZr1an<(KiTXHF`YNwJ)P;PQN!^-cFlLU>38P75ZM)*zKQhAt)8*pfg +4KJ4KK9RGRgIdZUOA@6v{Ld@UK?28FR%4?@@;DbfJfH>?Fs2A=I!X^twpXlqq0I#80m-j5-Dgqu)VnZ +A1BGKNSoR7RiQ7bOqXNY+WKrP(&6Vjw$fM%5v$RB`J8(YLxYVEl*^}&9ry6#DM^mM|S{dr1Zev{4ABl!~vHb7CIKj_s`%0!8@f9jZZ)mjWVw_eo9F}xUOFD)P=Tl;PSO+9Fi_P>?V5ZMysHt&_T%E#}3fZEE +onAF*v#ZNikYi2)MoBI?zCnq*#CR+MQhL$h&RrZo9`PtjR_O`s4z^zDq50z!{?G@yFMRb_eQsooG@qb?!`Q;Y5^s?P}Xm+!yU#hozz5K!E3pt7* ++s-wQ=1l2H19#Z$Nj1IwXV;~@zIIfU(Uk#jli587^yLQ)ER@~XRn9#E7@&5r1S2yiLK-xQs1qfHjKbR +T1?9R^grcYA;qAx0lx1INbwb@Fdqx*~{80)N~ySFc9u2D`o?@ZDg@b{2WR!PY0gZA!!yfGm|J7pX@Es6!YKa=`eA%b{?P3Mj$2D_cEj`eb@Cnmpj2w +$vgdNs00Xt2b&!ipj>gTN!ZA}cOMN+@*pzVytoV*cF@}jaOE~kW7#!wp#|vRtON29<^W;|aFD>C0Jii +qM>ZGkZ-E(1jwo?6SWT0&TIyYbl|AuFM6@?8;;K4@(p{J>xPC=@b`ZV2ICJ2HCOrmf}9>Q00W=ir)z6 +HYY;WjA;51G;wh*=LL?;hw#@Bi6GNIPv#fsRMn3G^EUzRIMWvyv#q=&%PsXlV7fN=+#@fSQ}6d(hEky +bVFN4zZqcbY}!AK16RZle$|zTzkP;T_1GuQY$=h4o-NAV(%Z8Xfnba^Wh(`)F +9xX}Q>cvd1`fQ4V0cvf5%%iG9Aw1Ou*%Mg45B)KB6n&fb3h8CT`CRJungM5?Zo-eaF0&x%7tfx5d%^e +2x&=Czj^)X7Re3C(qvvp*AbAl>C}qxsEcE+EceTn|&rC9)(`Dq$f3fK|^X0znC^smJ`@b +8>dtXpi@>C^<~#xV>iS8(UuU`KNK3i_*W>QzsY5$s)_6G`Hta_mkf;;Hv-$ZFy`lTBR#*1S3g=Y`+$X +ISn-)YbH3Ok&PL{RS&cEtCh&{zC3jBope26->X?KC8k#JJsokNJj +RUOu@7)zgMYd%krz)(oG*v&i?QKm-lC52hqyf?Z5dwFbPyc!C&+cF<*jsDlDKD5>=aS=Yw_{@wju*){ +3ScLu$vq3d0JIRH_V)$lCcDk@%fqwB1H|$^p;<>wor +?qUTBiDJ8{6s1Ep;`V-Qge|2EQv!YVOP15?fB221DqfK{Dk(6idl8c3?L!iF4}%xx|vQ*DLws)rDxdw +2$-#0_^dx?OD(I{$$1Y-l42T!;ch#PNVeWM&x8#nna*8ej7y3&V`b$J#tRvarE>GhWy +>vL>m3yUuE)-BS)GI3o_XOuXN<=lNN`BtNd`*AM#91jSRO4DwSGts3;8>ny%Hyh*1)C{343!k-uKt(M +Ut^ffYBm+PQFmI$1ixTf*p3V8G*YSJwzVv7^K_d*ym>&+sjDRj@5J%Mxt^^agDHodrc+qVd!HCNMPLf +|2Yr~iD}Ji1T|>Tc_>u)4+5F*waJ(x^Hh;Qub)}FuGwRYV;Zw&zSnPs+OqIbA$LQ0&<^KtKa`W?Oh6lsoOKD<9>ml8dV +_Xv?5B0BsX}G%doQMC>Er+$Y`UK`@hpnJa%ZS@8$X9S`(`LubfvCYiP)?S +On|HG3OK3C5mau&T`@nh8^7HK_{A~-_XQ)gwY9w1A$XFC!}+98Mw7KFw~dM%9fL1sm5))!K5sY+6Q0x +nJig6sC3z>gn*;Ay~cpLTude>5R}va26zA9?Ed!AKq*VJC{XcAB?l(~VPdPwlNK=HIo2}qj`pj?dJLe +FT6cS(+DzL}2cO?2;ZIzy&oC0(@PM`~;=9a1+#>45f4bv{iBR5Va)@rI>Ci8I{6s;mqH~(#QiKhy^Qj +G1sp!pv}Lg`seT5}81sB|zCq|9Bve7^-56^C=xW2GupF8Mh+vBGiy1b(Uk+hvpXt3uX1goI{9Sd>lI) +-dUSojd^6#v61IQ972BNOicDwrg;gXTp7Lz!_8d7IV5qn#S^tDl>h3BJc2SEmR_yI#tD~)p;G2GL~ng +CYsu4Yv6ko6m7E5`-!bp(Sd6IjFUf}KmMm~)FiW+eGw^Jz@7;St*!*~OGn>ul!}2 +-1zfRbJ5*YyE9X#6+_MzcAxlUB08*c8*>L?zMzAXu4D_((i%Pg^Y!&L(zIa-(_*-`!Oolj@K&z;XdTs +R+dHtq=R4<9T?9^5cZi>=Vir;r{z8aL;J&q-|- +}{~N6qKRhM?h`}WO<~O0&92Ed+NArbv(0_=ja~%w7`0^l`4WX)s?S=YvHJNA=T^h{T>e!IZ|)T_SCjS +f6~$MpKpKsnf)E>o63IpV5Ah_3!uV8i$pMU=OD}E>PvL`(osV5y>Gr{lty|{s1pW%@*+>Y?JEwVC +>>XMrF4pM;cAeFC01xH?sYV~0}&emM(r|!G^1^%V~lm+AQ*W<5)YEXLU*AKffJW70ZZ%u;JQi8rif)s +4%S)e0=bU6jbx`Vrr(YrE7GlEsNGh(0VTj9DdEHTYicvNrbU3U3!;$S1dh`1rU2A_-X9bPBTDKYavQV +WYx%0oOivpi?h>2N-=6Kf~-hIA6wmy@9kEacf_$g+UhFJH>ZU}!xFOns`dE|eX}z&I58At1~G?L2%* +Ih#?wr1LPi#H)ecJjPel8UBZ6V72&Tc-YZ8s#-^OE4gabSYBK0C?gMWx48)TdlQ%mDhn&tsQFHq41j0K6NN9@~<>b&4n#=e-etFYU5*1o5 +3Q@@#K?D_2_-<|JN8Kds$rs)x`vNqt9Rsc=qf|dW6RCbTrX=wweRN<9HnCy}rTqSzS!3i?N0n$g4`|8 +{%=VnGJUn+-QnqyAe4rM89OoG6Z^olhUhY`z-r%a%JrkmAG~R;B*_{ciSiqVSCt>lBr-Yi^w>u4yV`X<;q0>Z?a@1isxGLEGeT&hCtB;C76sf}`mU +4eQ~9S({IxQ`095{A0JmZB7p>?kWyS1jLLWx)zVHT=jiRSj22rQnF=+KG--)KLg|&dn#&`MFY%8C4Gu +q0^nG)A`7h}hlVUUfE9(>Z;JeGR%a}tVsEF0=lb*!$aa*mSiu_8ZA>1|;=r;rdo-wFHc4ZGf8HpX(y6 +gqg?>%^5VMmVxUA~3-suoinSn)U+i98>L1nw+OTN;)tu?O?|0H|aS!f47Bw%v-F1KAUq@1%&pS;yV&l +uZ7k{riJLhAaC&yuXu=szfDyyB`5r95SaCz=Lrf&BsfaQ0 +JQ^VXCrXP)BdIW`A&n=)!Lh<4wh$u093?B-`XAeSw_G&|RCTBDd;`IR#6%dGiLUEck +&=!bqLPPGAvZy1iYaKJL&SZ)k1N4&~^ZR_H@PS5Y_7NJv4KX-F1<0G;~iIIHWPfBd;l@49=LDRaz~Q4 +OVDxN>%R{UVWz?Cw^!YQQN0MR*tGd5iRyX?D;{FbP4i$-)TF^Q%vD`kT8Dulo=vt)lyBkIKnMP0oL$Z +5dPPqtOEf*-!Damc`ot4|w6ejvU|r0LM8(LUlnX7~Ik<MJPn8g3dS(#8DDK$*Ec@)p1 +`F2A0*vZHTH=d6i;8Gp)if3(WeG2~BU=V>I~+1WbQ|4yeEZ^*z?iK|GAL&bg?DcFiVM*OFr)Hw92&E( +@Bf#iB+B!d#|#F0{Agb^#}TM%#;Q;4N~kYfC5POI;`!fpw_MbO(@`OA7-e~(4peI=0%|Y{J=2i`ZqNH69@364C>l4`gp&O$QyEM21^+Dcd`d#DuhIKztHU6D +8?WCB{Jdo@v0z1`VrevZ%g{h4;cavSZ7?cSWx!`w-R5_kc!Jc4cm4Z*nhia&KpHWpi^cUt +ei%X>?y-E^v9RR$FtTNECkeSDczWh*{#8JZ^2KhA1jk2wA{P%@akSHN63v?QV_!`#s$tqKVm^s`Vklx +qRn4S91kpR_!@mzeq6B0o;vl?_fq5Uo!zu1Qp3E74XNle*C^J5}FTFR($JS^{(KN@PZ0KSqYNCMi3KH +#518_8C~IbQf81*Avt~CNCNT&!30~$w}cZ|F^&d%#HlvCVuHXMl`nu&_02XCR)he0ybw;F_ps(kDM@B +R#o3l-BtyJJ;vWLZGusjbO51EoCTU7E0UfnEQaz}uiXogF!wPJ0LU;`PCud +?$;ENUF`xmghi8iv9(cBMU;)G+@auy+2t_$cDSYG7VAwvCdqB#Wi%nH!MM<;|kLVII(IdQz1_H!1Gu7 +g32{@_m$Vqpj4ISQ-?$91BgI{4IyJUa}B2mziC_LJ>J5Y81$hu4D*u46s8Hcb5hku2{ggpc;vv0M{L2 +lhBJ5#jKJ9%J7N?LU`@hBh#<7S>GB2()YSs1iW|z21tm0^)eJksD6p7-&&3E^&6ZRLx9dkg_}{sYHQjEy&*+QfsqB5=jekP^ssPf0$A%#J%7p8LuLXWxzrLxb22UfPeuxNUhX|unv5*Ouu@tCLoQ=V$y +4IXno*85k4Rl3~BH87nysxcW)<;BjJYET&m~E1)9j=KEu?B@OI(%zznMlc-+zwuYZuV>J9J;mzK%))_ +T`57$TBze>^yB_n5KeG(O7K`odS|lr`}oSNA@Ci~8D1y3Z|Nl4wYKd5L?TSt= +PJsn+&K=Py#B)brWmeQyj2sfwwx=6VJjO8WFb{SBgvN98OYa72#FE*9hqjQuBr~GK6>3nXY_CdUSZc~ +z-Y?@Nu-=6lngl{l9?Qp5L=4`SxmKs|_sc+gzSKTSkrm$|!Q2p?fnSmYqK(BWMp?V*0T<7Jt4!#yQmF +v_JNBS^zRCe-H%d=BkL*;3TdrI;QcJF!VQl0H{Q{q8;g&sLub0UOsI7dy$Upp`xoGjx2W$I9aVe5YGc +uEPc1{SHg1-N!bA0>SgPu=M9=<1ogvJ=4+|st{`@DUoi=rYX=j(oE+v(OXkQVVbH+~{j~7UN{^v#f2T)4`1QY-O00;o@p|(Z?ChsIh1ON +b&3IG5b0001RX>c!Jc4cm4Z*nhia&KpHWpi^cVqtPFaCx;=+iu%N5PjEI3}P6T1WI+>mm+9_t|>|)K# +?j**$4tdpv9%MEk&|R(zbwnfYU450tx!sen9^zU((rKlDgDxQxp+k4|jIXnKQ$kEeR)~(sVv_}$WPN +tTLNw#=!hDb3nTz!lVa&B6t|57F&n!as#ULPsIcEGqWY#+R_pxM!NZh&QybIX9C<02EWUxGI^bdy*bi +gpd%*N~xpLWJ(vp7G@j*)RqMWI{$lhAW}fQdBi2zUN?87i;romM>};y3PbF#}l$)<{6lR_(XuQe<;|~ +5NDt~SEweo5TyI2V~co9?7Kv$u#J&rjtpBj1k{o7zT;xx%&Pzz5ZClXPG{z;COMK6S!_db%EpUcpc1L +UaIpy!B6)}VFQVUSMLb=@d>)lW$?1F!Y@MaNfHGk?HFO@cg7P5FTUBJg4w&+E$!VTf?iG#kpyl=MB}Z +JGOxPVu5W0wiJcsjuw|6(RhNSbX1^ByVA&$Xw`1DLJ*SHfbDLPJ0q$4k*h~0_xahoL}z3YUZ9Jkj2S` +}~|@Oj2*6$G!h-YxVsC@)=S#bzEc903ulob~cZEmt^f^F_&X9L?w8^OCltKco?qSr`7fkBqLD$8y<3Vexf@EUtS%w8pS*@f#qHApTV^Z1+6 +j>0QvI=!D0|51yrmj?#lC>HYn0`)BF>+xwG7$Pk^V!~3Sh4?!;E>`1F*9q_&V{gCgEzwzmeFX9j6d-v +x7-@7+kJ~LTxy2eHX@qVweRglvh@6aWAK +2mtS)wni>UwrnK>008*~0018V003}la4%nWWo~3|axZXlZ)b94b8|0aZ*^{TWpXZXd9754KFaz%OjK7*OkW~(h+N=)Q$l!cc!{p+{eeXgqUM(@7~&J +etmX0NPOx(27AwK7DJ<}QRiN|hM%x`0AiXVi7;B)A=tSzWr@+(;<3!Gb&FXNjvV^5_1YX +or)`xQD7XFS$fGPbOMhE$L~i#l1W!YR$`uJFkw8330rU=aSVvcNFo^JNOi@;95Om186r{yA>D~OiQ?6 +SC9@947R#8S$O#YW6e$)oi{`jME?CUO>rQ;iL_#?qBLyTW&`X*K;B!y&nXd~9F(Vf-g=v~06G>hJU($ +$?I7HJKjYNnH$2UYoX~OAuD`dkOn2-gTc^g>=J$(AE=0xxmRWt03uVUeQm}cn$;*@*au;LUYh#($}^F +zZtL>xtXnRiVRZzvKhO?*8Hi;Q>|37y4kMw5toXxi0_G{eFbKLA1?8RK3vU5S23X-A4I3GF$%!TVXDl +gLnnp4tsi(fHgq8SI?_hs1ybWJ^qD+&`R2|4NjJOPN{gz)0Sr +PIeER#xKK#^&pZoBx5AXZ%p%1_G;n%_F3%jWA)hk)|P4p|H`x1r8y{d=D(sOtk;zk3Rg>hu^X1e*jQR0|XQR000O8@1eFv9GRm>2m}BCP74449 +{>OVaA|NaUv_0~WN&gWaB^>Fa%FRKFKA_KaAk6HE^v9hR?%+aI23))S6sCZKsQ32O8YWeX4eG+(T1cG +hgPE<35DQ*XF`H(r?h{+*Cs$ZL%USF+B`sF-*e8r*FH`zpsw9^jUTz|NMktpS|RB+F6BKa; +9{PwuJ{bRXKMBYuy^(W`jxr93|*Fq^#7NAS06n7y-J{Q*ILS*=#6bo1grKOlxnuA^;nJP2AO(ch`lo; +@gJex{xO2uI-^a^m){Fjx6jB`N5ic3C!hNVmj%@;0gWcer-e1Uw4#vcyJynN(Hlpd-nN-a`u6R@hAW2 +*b9&4wouL;*>j8>HZ>Ys-qq6j(TnA4o*OV{jLR_uhaG;DRuGz5o&oY!I2o<1m7O$NE0;CJc!01EL}l# +2#fx_29*0i0Ft!hzJpcbVur-?@tF_FtRvra_4&}a>PS8M2ZQG`ePg*x1R6CU#$4hiv!A77bzeJf!@;~ +1~xV{jl6Ct_#V0SDGb91nMm*j*d6VA#CI|2i1uR_8TNOG=!XHLpQp%%F)$z#GBRmI7Fs`=s>UQ{A*x1 +L8=LyEsbLs}6YxW3(uOIcC_!Rkz}P=bn7N3fm|kSECV@$)AA4b7;!!w`h{+nVj}G9q!aYArE2+>SJs6@8ckIN1XPA{Jgr3dXisu;`kSmoec`qmnH09ORcXZrR)kNk}6*{7QlyboU +JKY1%0ds_4KzFtk3p8mDt`FlP+shs45ApR30_r=biL)V@$az<&MC<2v=Ox8Hq*40I0CU+zYBxIW0xuT +5R?7uL-8+bMoS$LMB+tVgbI$Tgt=gUAB5X}N>lJ7=`;1EGb~DUdaMkSdi;xsUR5$-tsXFal%&Ds8@C& +5xDCe-M>*T4)?Ly9rw(6YSfed#Kj@Z5Q5B1x#`R&!+71MCc>m|J~PhR|w_Nm3rFwlQ$l(XA+mN5>ENO +OEC=EYencuKAHRoWx%&(;}Y+g<dxaHl!ko+9hggc=QL641;CI$e4}q`R?8^A# +4SzMV`Pp7SV2@CnT6?GN*5?}znm2i!Z)0(PnAsoR$Wg7azcN`j_hj8_yC05M+1axQRrjZ@8z+cprs>nR +3V6kZovx6P>tnxI^nwh73RBhtGFlEBbfluc9?1yb700)2*{O%8dHBn6t}W%48$Qnq(GpX*$zrE8#}9TfnS~x@)17 +5)iSKMqb^*#^iM?ix3*4uT>!nC-EWKc3I)(>?899$BOwtUQNb(H$f< +}zQA)3x;Btm33ydfe=6HcElkqvubOy*?jY-Ap~-@2)0MDP?5az`5PQL#TqaY}a-oa{Bc5P?mY6WW7XwyPhE4(#wRjF2*yt4bo(V@=jQq@@7r?;}g|I8k$mj+9 +7^-9%25Ui`*THuYUYiUmJO5u@Y_$UB;cGB8>BjGU&20qbjb1N`VCM^0 +|XQR000O8@1eFvMveu@rUL)~MF#)?AOHXWaA|NaUv_0~WN&gWa%FLKWpi|MFJE72ZfSI1UoLQYbyVAK +<2Dd|=T{7r2TQF?Uy34y&;-~9Za3I88^rFjmX^jgyOOAqR2;Y1e)|q7N_G~lA(-S0XXc!_@Cv5iO`%Y +wZ1x#+b~pXWNf^5VfIN50EYB0#`w#m69P*i4NIip?cJUPAng6EXZj&}oypQmkF&0G;)A(11#u|9P**r +ldw_4~E`}eXWU{Hx>- +w~dPL$7(E8e(Fd*+zHB80Q>_%hSj8<_x(Nr%H*E5SFsA@n<|OZYD3H>ToehfsV^?Twb8N2oWE* +Y^5hNa|&`%3M+0xl+i=0Wn*K_ExuYW{D=8^62yKJQP%4y8{{N#P)HE;ZLO@fsIS-P5Bg7s)o7bTlhK9?n^iw&4~UjXDlmJd(v +`$uo=WfLPcEs2-_2Uz^0+_@Ql*_%~@8-0vm%FylX{4FqeFudLR$?cdN(s%C}&x2x*B{$jb1(?OC2%X) +DZgD#&DrJ|Xc7YC|x4#gbq1xsz@?S(RQkf1NMq*VI#aE;_=l`N01&FL9Sk`>mZezbfhQ@B&q0flqn1uSt*utrO?cA~2+RBFF>&(=XSWk +q92jUir?EFpSSqj0CXri|bybmQM%7QhB$-yi^2;jyOPy#D^&FGGZ2^GIX-zW4jTwJ$0v{^iX$IN{-(W +W&Sbhyd2o#s;fhN<}S{E-&=wUK)H*xgTgtUh}*WHO*DRMOhA^F2g1X`wCD?0|XQR000O8@1eFvQS5C@ +cM$*pszCq%AOHXWaA|NaUv_0~WN&gWa%FLKWpi|MFJWY1aCBvIb1ras7bk3)$4T +}uV@Sy!z$dGDl2xo;3s#prtBSm=nH~<0dC +hJVSJqSl9_1_+t0WU6p2chfqmcu0%EYox@~jF;mQk`HURAz)6!mDdD)S8sVP26|Ouf4iFke;)^|Ij0N +B$tHuqo3tS$rK9d7f@~2G2@8k@WV5h5F-sNn7SH>d9}@1nEQ=*|19x0mP9yVJX +Gr|d!0k;tSuNJXp#k74VkBj))Or6@!eN7ZsIHX=$^Q6@wzV#$a%_1b82io(H8m;3>rPn1|7W3#Lq(5a +T~3?#n*Rc2LECr{#SvaE+xBR(xfK{jFrOS4gWJul0=JbW;2Bn`o>iOjdd8GOe-(cV0B*gG`4cH;Kyvs +l#mGEbj5>;^XX*Xio^_Og{&e|gTt(qHUh%RGNfT00P*06>;?q#j3g9{tEQZJ%RsW)OpzPCK?RwHG@z^ +84+YKJ7kCS-Y*;aM6hM+!1(NvXu4?20a>S_j-4Iefj3{`s~ka&c5L(;Di0<_Tq2n@Z!st=IPD(-Oa`M +Ej)ZV8jY4IuPXKi{NYprXpk>{gcVI@Bs8Gn9l$KUXLkl`6)8a`Qi02{C`z)Vj-sFv=}L{pPt_E_)S6( +*h$1utCM^^2$hga(#Yr)2p@wbeFzplC(a7Xo1vvwCqc$pD>^lo&1ZC%|g8>KTLrzF`>jA +}gHE7^*I7HVYV-ue7SHh)YA{>Nx;=*yFb0pQ_|1AvwX9WYcUcj@D$zq~cGgYFZBtcld#3kVAw44!nGb +rFzW-2xReZEqR?cY0P+Ci%n67Xj%{iYt%I_iWG9S@9$V1;4$zWhp>QQ&dx(RA_GY0x&DFR8va +;fianQLe1w)XGv_k7NuY@uQ^-u%5d920A)#yq^N>QlrS)4Z+7S(yh#a~6pJ_qNwd6WGT=*DeR75DV#R +iO!!Y2o2e7y%jKp-QPZEJe_h?0EKN&krB`wBwJY&KGpzJC2$3##>Ry{P~}P4cQ-2C%Fp;5LCyP +eU7YETf!%Z4a#=>1?t(7_aNPn0@iZc*^)hqZ0i;iog!bDvDr|4`YiFkd9$xtK_O0!y?8;)AGf@Gs4O)AieJD42~S}>ZkA4vtX4tTYD2a^AhhMN4r3Ub +#N>KwdtG%pVKfR@OkEqj2Ffwkx;FR^pCsukUW9K5Rd->Kc#g@$D%)F#X(x&gL>$DgQd~WyMqiQO{u(r +rtP`IOiBUl?Ag8E0!bd~TFQ?Bs29!LC?sF0&Ldc_MXw$P^lj3KU0tpp=-Wq3bezs^(6eo6dj7|H&bjl +gPu%*|KrHNy&@OjKjPysvK3&IqT6HPznn{*#es@{|3|bKRs4j?RqHuM$ul +2g6Nj%v)%0&Q6`}Su|LJgh!K(YQgqGniDJtVR3wReuH)LU*2EboWC7=htCnhM*n%rz% +|ddxNxCFKF!1XB-yr=tr;bHGB~AnLuuVwIo#7`P_s>gQZgi{#!t^hnYYxK}U0YR|nEAgKa2VI#aeLf}MQuDPcJnu-8>b0g;PaTA@fCLOKq|9Wot3}m;5yJ;4WXl)-3S)tL5{&7-!+2l +2(9ghD+i47rDYi@>Uy@r|jee_m@EvHjDpSvGfU)QKQz8paW4)}(H}c8_aQ1AN@?0r(|FxCM$PBxeDr( +Xe4{_t$aS9Jf`ItjuW0;KDQ?l8O6l-R;X2X2Q19)vxcrft&o>`(v>_B`~J>l};Pj4AUr(8i!i2+Y1?9 +`n8oK*D=f)F-C@m;yY-iaC_F%l1;P(4aUKhWtBbMqJI!s->uGR(XUVN(NraU`%3Kgj&(TF1okJXw$S% +Qa%?zYP+o!k)6n@uWZ2>S^}N6KW86$~{!Gsq7T3Wz=o42mkH!@MCt3h9iYGCsBft76^V_fl*B{Ol+&n +l}ti~Bt-3^5MJ54jhbQcyRM0ZpE+X(lX#m{=nWOx5zlt=7#fUDb%0y0XH8j(tWJ08%=E_waD%v3rXgl +-Ny%QddW+HzoKSj=v%ln200>&$A!XaNc9U?)lSyTdt?+yiVPqk248&0I;B}cd4{LxfI{sH?OzfI8C4XOYY-t*HU^nQfA-l%RVVmGpthRz9ghJ`4^U0xF!~ +;w!CZ!lu5V|d^Uz_@A1T@@!2P9Mjo}K@-Dj!D7(+)05f2Dr1#2?VzfX#gl5S8m&F0JhZeNUm_UicgYO +4=F4{||Gf>gSmUE}YwOjsSbG%OoX4j20C+*-2^IrLBMQI5z28$G={@@bz3V!9n!UX{H2qeM6=7_>i3v +(mZ_?zLYS6w;2p4u;4Xr^TN9KuxPL*WT{xyWUqK_p-f^$h6b+gjB2|z-0aISztU*`Z`=!91UB95pC>Q +TjbUWmZws4@7S$uqKeITP3^*I^k})>7X=}ClhjK*M$#K$FY+42W4~$VKw+I@RQE0rD-G8~ou$sq8Hs^ +E(y5SGW5?Mi|B-`8^(O&HEP{|5r5EYj-CI=J^a}ZB8NM%P?bzP6%82RQUH#d!MZe9p1+azcsI!c3KxJr>#Ae>VmaH>Nr}?Qyn +u|_2*acoS;-Z_;CZJ@N +H@Gyy~^oP+UtSBQ2+G%e0bWZi}9V+g+nRZqTiu22meLDV#o7|2bJ}hnnaRU4XOwej)*=*TZ#3R6dV1xKJC&WkDN;+C<+{lps +XoOpVq{OmdVMjxlf22o~CKUu=z)pp7Pr{OV4~IpLXO7D2%@tz|UUVzvD3nXmn>LyBI7t<>N(*3#`)Z +EQY?6ap`kQ4-Jp<8)Y0_{#XK4^W)O{Irro0eY|NI_5@_>1+%~*c*$6MetN5}NOL|>WPj^iiOw*oqD<0 +po|m0&KZLa&zwj0aH!H!oV})n3}76ks25q~g{-QrYW1gi>Gb?Ou`fQ|s(u$eBB*mw3Ja>690V@#8wfGdIfEUSR^5Lu +5M|pWEC^7(E*Y=9T!tC +Szgz+2_A`>@4|KhxLGk(0dd!^}?|{rt?1%R_*Hy~e5fOZGyp6!J7pF<;z@G@a@av-8Ux-4AhY@Y)}Vs +(=g0saY4O9KQH000080Pmr;M#`S%=sN`f04Egy02=@R0B~t=FJE +?LZe(wAFLGsZb!BsOb1z|VX)bVi?N?E6+eQq2*RLSj2it)ocX=9w#(7;>C+V<8KujYeG@V;IExm5 +KNcSK(5j%Ly&oyVUC40V3!DQycLXYF2W#)5>;-rTr6z_-J}Ocuf92g*#>^ZqCmT(}bg6U9Crc<;*LlimC~& +_sZc&1WvZ2mmouSOLuKK{aa@vkA5C{ol)I1W0A92%j|=;=flnGDY4f&vsmbbqVIvEj%l8RF!Q(o~t!viueg|Eu`I6sX={*dYeM +72#3Y58P2&uEaYA7c^?E{<2glOU3m)V#)+b?!y?qIed-Y+Z9Z+GUROjk5b2#L5=_IT&9j&Oj2Xu7dUd +!y47(}uJ_<+2Z0<-aaapF;?=+@TvpTJSPn60~6d_E|706Uq)K}+lb3K_3Zf>W8v+?D4I)=uY62fR4DD +`27jOngF56EW3(CQvqy??A^eP!jMEE%1SS(T`aonisFQTgk}2%DCaB#oSJT9A?}l%t8`zO$N4E+Ijxv +9-)H?o7@|lJ_uz)6u(=+pDw7F*P?TszekNh;a>!*zRPC?OLQBh9ZAR_#Iho88w=cIy}-XEiAXehFRu0 +DGt^Mp59)c{m(4^RY45`GvlM<9noLWOlwEPubU{wPiFI@Sm +A1LZugj1=>!}BWxXnpO0R>`eoRR)SBCmW5RC+b2zCVx;4O7n(c|OJ+qH@M)z@hd^>=baIyh>U()g*Ey +MpcMFP5RXV|+gf84oE66gZIueEl9 +`6bnHFt0mPtg3Q1!cn|D-TBoiagOK+)YQwPU1ELEd4eSesQ4`cU`pgj6c3o1wOX9O#G@sVl@)BcazUy +xp;f<)&~~BwPyqRST!pp_0u@^;n7U9Vuj|D-<($A*6xG`EvX@BEOtA44VCT&ceOnc{oUak;};o9!SXyXL73*?Xn +3rb5#tXI2Rl55FV^nUxz49R_!9QVWFst?JU91iF8nHj!d)0a~=FH)H=PgrFZ(|5Qs8jZ)}krKaGLK_| +P%B)8JY5zu}yOq>zU8Gee;Cybl%r!GB!H`(wM$WmBMb1_{Pcxx3TNH}jc#gz>B-dr33@fz%Qo?^3xvs +xgT(2@Y8;usKShE?|;`l9dd$Z%WA_w_}+l}YNy5z=hS1K#H(qh82Q8h(zFNO9bVrvwio5U?ArbvF{p0 ++YFt0{?7l1d<637!fyVL+UNo)01c{$N9QOdD=0ouFLxY5HR{I{$cmcX@r6-2Lm*W%A?4n-9q^H$Puqp +MSi#ykMs+;ANRP+r8dSH=E5A47Z+wB392d=(70m%g=XL$)~fMJ3PIvG9y7w^O{bj-0)yD8l_^v5-^;c +C+Hp&HmtNzIbVZmO0M;$P-%2BV(aoRR2T* +a`s6?d?11f(B8nYdkO8OsFn|?gR)!HVi|qA^Wb{&ilJg8Wkf*;S!i%7v{?I66vKJ{K~ +#(V{_gG*SrO?&uS6sLnK6965|*&#l~$&ig7R+(!skBIn6&~qtC*5%K!?Q@i+3#R{5l`rHH +M0{2-S<=6EG<66-Nt5J7K1Uuw(A}hUK;9}hu=}RFIbZP%R{!|3cVnSp^}5J=lH}DodHd#&e2Nr@O;pb ++nWaz*&~&aEI18)=xHX+%=>gSSUgFsrc+_%y31}(!T9bH{S|qg8BKf^2+XV4am@t6Fpa}<_Eg`DRYCR +;Zw_4;y$-%cnTDu-ZjRtbj;tjFwq1ZO|1KUA|7gOQ1t~7jC2Orn^9DXn_m|hlN|}H ++GQWZwvZv>l#NrSIZwwyiiuV-Y163;a-4{t<^v5ojN<%iGJ(F@u{ +=TF!@*-&A6!qSt5J{(iOF~)uax1w%PH+**nwUd(2p%s;%KYxaVHBI*b;rA#^WAxmB7JXPL6KWz6+k9& +pB2YApPXP3=DbdWe-_ZI=bdJp7m;@~T@thqUA0D&KO3tAxTNPE7k|@wxh;?Zmo7<4nX?7K@~XNOU1@2I8d*@A+HeiYo884Y)8py$n*IF&j?$CgE#NCs9B%BsW%wZzT~$EqPh_>Q1J9IXOK38nq4nJYem+v>QaQJFz-WoEW{_#d^3WYjtV!@23mPrUe3y +BZN#8wVdntp|se7QF(A*kaw^ZYnaWTHco;b?h(V8ME8%q0w>LV1LSi8xB&6GP26oH+2Bm{4gI_f(G%f +nVatx>H2h3uZsKpl-LUPV|ND68un0>q&Y%*SEgK)2u*uG^P@RkKo2d||GBCJDic_%P*ujPSrmNgHV4? +d8*spyP1!xqQ;4JYIDCDe-=rZw^?8L5Ze!8|JNf8MrZo9t4{<*VH+RLJ*sJYZDZAP|=?B!yuTeGm#z5 +LjF81_!b7zAkJ`RRf7aoCuz7obtQoux1d-0Y#;T- +KLvBP$&iyiD#qh`NJuxVyWv(cH#5>Hr`1HyWbM-j^7L28i{L1!BRtW}*g4YhEjo`UU^f$v+b2SWj;g5Jy#ShEraTQ+f4Y;Z;((|2Y12Rm +xbTzev*Q`7N>4~8I`pvOZncc|Q@m?n#iFZC&GUj6g>+x?D|3A? +(K&L-^5Oe1TXIO<)soOdDe%}yeJ=gG`k;JLp&P$#Yw|rVs9PZ6XQQH^7%7e4n2F)-V-lO!vDj(_2$AqrZH}7wH|3m;VJ&O9KQH000080 +Pmr;M$=GQeoT1+0MfJs03QGV0B~t=FJE?LZe(wAFLGsZb!BsOb1!3IV`Xx5E^uXS?7dl&qe`|W`p&Ni +>wYMAi0GCL2CV$zI2{QB!o3_CJ2a%b+UI;X4c-ffYwBOGuX5A=QOTWk69|M_Ac%G=B +S)LoP8MLeb1i*mZQFQDz##Z{KvU+$-u`yqR|XV>=ja>}P)^wU^2P4u$s;-*ZH|M{{hlk9lQ{`bq{?=S +e@(Z9cF`AhVYoX*dWOLm)=KDxaePxqI!yxp&5+}*SEr7!OXa6)+lz2s#Bx(H6)OA;MlPVqe|!T*lgOL +TuZ-0$bbeBQp^`R}J|F$Z1F!OiA>N5Hk(?bc=2#fxbCr)tYD;xo>!_O-j+U)1IlN6m|M0(aiN9z0#or +)zXCPsf+7^ZohzQ`5mixBva39h1L>|pxh$K;Rz(UAg~1ij%JITTrlKoe>g>d+hat*^Kfc`u?sd`;Mf8~7f}TJCF2E(FA`=EGmC +^?q!An{7&gW%P^R!QfiUWaFi%GpGN)${}W_YGhRg5vNc5$d0U=Z5naq}=4M}8#~hAZ%a%{Q*CTSc!FfrPlGxt4ow>B>%F;@mS)xo6;8= +NKo4)yOxm7v1b-ojTTDkTP%8B#rezAu+ag(QhSr)FuA8wfWuyZTfp#rDIcDC1ARF>qRq=z{pj(U%7}g%7HE +f(;dZwzI(glBRL9>q*bQT>HDN#yk=t-B2{{_yRB?f9nmd!w) +ygGFNIraHf%|T!kNz7o^@t2v0fTQ&a8c>&vIwp+`W~(N3JAxFV&2vI{eur+*403&2qV>eSUKc<;`&x) +i_##Ue6tQ3c`X!5mg#ZSA1qeiwizJ2+i=|(pDNaBL13(78C~Uz2I +Kvktwjfyub1@0A4D^xWi->?jTdb46Ep?afa_5JilA#80$~;{0PvFx1V}JiJYTT+A|e+kwqPTO +%mf&4x&V(uCXfdr7D6|GcamOU8GJMV=_ELsE;8;{XbQjvpy}~h@VzGR1^8$4hEUX(LtUy|kAly#sld< +iAjun@uP4+I4!Y>o@_;BdZ@;2NVM|KdB!tx@EeViS=|fxI>)^98T`=gYsckPfF_CtIBJMLbx{oOI`RBs$i5)y7-25gPxnX`vk|@$TJQQx{$aOYyfIFXlRnBAV+?9PH=!}l^p6q@(#PbVy8$~dv#fG81l?&Eyx`;wuMfyYLRv~d~m- +TZOD{SG00n;m_0h97JW&XUzO`R4j%iYU@$R}SC;4_n^|VY34b!rN8grrSwD9UvAfUx#0bbls&TjLJL8 +FF9E)#nYb-3aJ$3?*P=LP`uU3dW@|MoCaN<(AmxXz6Dmo7i=07~M44=6OWL}t`^~fEWCK*(OIeC)3m; +35=4KFIUQoA^EGNVY;ryN-7LA@QcUDHUpGjn&5y1Dm&s+MQ0yyKc((-~qK-D#9oXy>uU&}~PHe}rW_i +`HQms$#*QnZd7D=V)hm81>}ilD*Uyk~ll*v9!e@L@w!tx*eUEt2a-E&7bP7T|L&jd0FaRA}9a(SD9pY +&DyeS|LYj#Uweb^nB|Agf5|W?z2Nc%%|UA#qoH-nq0k`4ApXNIz&r`DK$!)dFNo+%hN1BVlS8{2kP{A +01bjj)I1W+@lfpxwO91x?x5%?a3>b!35E-NaF8Z0h9z)&(c0Kq4`T-c<6bbEh92ovM`~qX9QpiFa28T +_=@H-Apz@e27Xa@trV=~j}6b>HP?h!EYlLZEJ1O7{fSwV(5i@#);vHHJ_VGg>$z5`|O2T%&n(8JEDhZ +YX#41s_M>~lfi7yYXE3r&C{_AA@y$_cb-;CF3={ +|vjvw(hAf67oCoa~2TYa(eldH8i;&{16!O;E_5oszahWgIw|E>jjA|I#XNWsvH3xG1Y~eio8h;=i?cH ++=!0`7B7KvYLgl8Me}9q!o9=vbELW2W1@>Wxjb5)hs&EhvOEv8Y6gWwekpb3+a~n{8D5FC$9_&71O1Zhee +5BjDAomjd6I-awo69-SDm@Qb=+h%3AD=ex%!SFfd$ITWrlM&fM5XoR;$!BVz2~b;6*9jiiQu^+j3fP2 +SQG7XM?((zxZ>? +7YCiO6)3m2ic}iq+r}kk-Y0t#W`$NOr9WiUAD5z%fV{~qJlrDfsNr?qU!XI#K!H|m#sE1ebNEd)$z)hfAh=$Zc{ERkG7BU0_ln4sNNE$=-0u;ic( +7{7su!YXx4-5^}6VNPxvVaiEutf~0DFt0aU4u^ECqNjGIk*L$Kvx#S{*pE{3DCx=eWwlCNEvke;REad +>JYYH`AAG1X!SSXT3Wt>MP7KwB>Aq3w|BI!KiWkA@}7YuEo2A?+8-1E8hjT3GWU#pi+aOi5@7LDuVmb +iWK4G<7R%qXA)v9hzhgAl)dyLEA3lh7CtE<>A@!Oz@QYz%^VfIyT*>Z$yd8kBS*898V(w>51-~m8K)6 +TJHfZ(*xFKJmTkqn7rzTp^(M4OLxv1inqLzVpU}kt>J!H}v4!MBN +yV`CM3nVS**A7J1U6Tc;E$VH{U&a$-tzpxm`(X#v{q9c3n#MSaaq_*IbN5JsD*z)YpTxth&dVi@N}In +IUa*$JkU3&(h^Kn=3n_7?@f_UeRqU0;=qbLRR$U#P;d3x6Znn^kF1aCsnQeQAodk2jDA!{4?(Wd- +i?6=`*wtwtzXWzHDqCzx5*y&Vh9yzmLn$yW!K?r0;uG(l$u=P#`{d@EF5QaVx#kRbW&UG5>?h%XD~T@_8xMcAZ^Wj-#=$SW^n)DQJAG$d#|JY#9iPXdfSEc- +?L@XXRUMJFn%Gstz6u!HJYG^G8S}11ovCC=AbFS_&_h{PU(nu$ +}&A5*yD5w%dC*{%Q3;mOR`fP&2wdcer1_wbGk(9WtMRigU)UOk&wSj6)u41eOVk|-S(48XrkNgg?NjB +01Z&K(e?TAt$6qecl--_dnXgv)eUs@^4EI!Mxl@#OA;K;kp#tJEY0C82{;HPXo|sTmckemCu!m1~Gl0xr2&3s8nfOP=W19sphrxpNzKth1pvUu`MaZrTd@kACe^ks +oN(63yD|Ade-2F5`s8pbU$AVCs1HZEEu*@7eB4|EKNM*+D5?g37S;b|lekAg-Dg#-rl6u2;^Amh>~R9 +IkGWCj${FXIk7NJx<*%1e=^1k}X$HF~eAb=L3n?)rns7lFv{{qdCnkk1sLjJ*3!0a63(+P1MHFYPv>u +!>voVYHLpcz51EDJfQ!5lNo>2&4rTw8J@gLhHD>2mXrsjuxOr{S{&1h%U)foZ*vtAYT>5AL`+KxL=JH +`76WyYP8624fjvN3CJJu1Zm|fZN?tDHE-=v*3nXuAtf{G~KF?DAAjt)UErb{uz>J{;Wvt&R^H-Slb7u4_HoYU(VI=H(61Fs@(QQT+_!<1IWDPi) +&9vV?ma@n~LJip~wVlA*iPQK@a9-wN-boclk*3CK6kRlLO$Hg{bvAG?hh@b+NZL=-b~{$w4raa;?-u` +W6Ge)DN!E}f7j?$ZkIZx>~$CtO+g%C5KXLEA3_!6ntbUoHnUUd}0wKX^KJR%V90T=k(PwJYCvCJ4`SU +S+OBCR&@8GuGW8*1Md4@;x(*kLvVvRh??rIdz`%d7M6vdW~<}F1G=QhdfsQcVX+x-(FOF{vXNzdcio3 +efh4tzrl$1OZ0m3n58e>Eqgf~o9F!f#Fy8ItC8LN)3yHBBK5y~Z2u(gPviLp{AmVfDWExU5+^W@CRvi +gFp4A@mPJ{>0W6ErDE$@qLo1(v+Jj6W90Qx40eXU5(8&TIaDqV=U{i>nR00DGUx7ah@SK6M=7@&z5&* +qGjSwk>YJ7^606_udOqxv^VTxeq;66Yjfs +hJL@%1$+Lk$;lJZ?Nh(y-!OWVProodgpzOI4I`C`|csR7+>PHjm?)-}B9# +08KYz!$SC*K@W_!PwkCOkm#{PhkPyj4WPNH=ta{VaT*O&tNjLZZ-;2U-G*6JR?q`xC$`Q&2yhh#-IME +`od!)032#h5|_~gQNziEzKd#ferx!!c3`OhtE?R@Ir&Xd#N@8Km8{t&OPcW^GjZEzZV5&?F_2T`|qMa +mebpmW1|@75E#huF}NqV{Ks9m3XEL +m&i{Z7%bg{B}ygdqZ^ORo;08Nm39v)xwCotKj6iHnaB2_|HBsyE?kH=7wdK1mg+Hx*mZkyJX%{|AeJB +w`7b{xiZ9PZkBMjK^718b_~!{~8Fh9|mz(znE3^2?Kru5}%CD`!p;>0WmLFf*70Y-EO*Z<{@PRya~6T +*DT(er=3wy*wkBcdc%xns%$2jQfBs)h1rogmT9AWUL+ac3!j3&gaV9+3!{>vbo1es?xTlF0BgugxrqK +_Rtk!d3W!z;gZVPE9sPJrF>MjvX<6Zz8h{wvA;gdHgg#6>R(RQeiJw1dOIS|3Om@Tp^C9S>uIS908Oyh>*H!44<=KSr +&;hQ%Yb2M!E_%-ReYf2n3$VHQJsb=WQ1UiyfGa2X<5Qix6;%zT`A{Wefw0aIcqS_Cl#PEetC@fLp^ev +!%7QR*P_YAmU*^2gpXzSZuaRJXs3-@*O@?%=V2Ivj#)of*-gRlb^kal4=s5alwfF5;aCRFb>=-=--%L +0T3KI!jGtBQ+QmyxCJwS18`QHtrd`mmu&<#v~{gILW_F~~b=dIuG;OERWo$*upqFJ0}DVkz2ocfBsI1*|QAT +gK>QUp)~c?uJ&2o#1YNI*;|%!37N026G{uYFq7B155H3GfF7sD+x;$Ru=75-J#=L(+7THSEMj4D@*6; +8xjB=nE!#;qV%A@_oVUQJB~Z_$uaL>Hv@|Fk-^NG_p8{!F#}%5eCN$1QevT1m>dAIdpN6kg_1Ff=j?r +F8d{Ybx_t^)<4jfLwCUmzBA8|elW~;1XFDG!X8`mL?e#a0@OJPmu>ajLFkgG^V_u +NYSxkVMc06eK +J@DtNI{esItpu#C?{K<;^)AnEfSQ@1rogtTWv^s4SA5HrK~#Jm2W2w=y$-f37dWbA~RD*}N=f7=P^J= +2|J8eY!o2VBcl;FwZuoa0+w3ZZ62(Zn9FcZ;xf6i>p$O*Ojqn_C;6*hX=0u7X^^#GqARrznT|yf3_O(93kU +ncE$4SB1Y%pk&dCyanFm#+kU|dPv=VSX!|1c`hh>u;xmz0&lblRD=L|i;cmN(%d+^O)sI^7Ab4-X~T8^zQ?E{JRoBXr>Tixn9((b7T_>Gas(#xoYFBl7mPjg +w=vrJ7Xap73+9@wMls1t&?bNe;`sE~^sn72sn+7O5W&eb%cd6(O1yZA&62gjU^DUxYc|xUmfs`!Ecrh +Kwv`E37-&++0ZYhOE%J*T+R-66GkZt}I>lY~0GR?cB~>$STWyEOgse;?~KM +!8vR&gsb2hXLUD|?Dge-cf}31Z8wId&ggY;^oelUq1dzBU6k0&{habFX_Fn@ZS>e9r~8a3If*ZXI}7WXmpor!d-^94r +T^mleE1x{zs&u0rW*~EAPbogNVO=1*xmVLc4C8MC;0<1?QkWhi*OGxN< +Ilui*%(I2=bC5I_<7z0NLB9ch=Q4J4G%x3UpoZj+pv=O@;%o|#ll0ZHj_6B(Uj?z`aLRQw=S +CE+%pMBbI*M){*xK*P7dH%1L`wxe>l$TO(#Z}c91L8kc2UVaTpPd +e>zN|#o@E!js(q{QYpU0A`6VNO-NX9rE-qdZp+~|z2ifih)+g@{Q< +8QS87Pi3uo7m!4_xTB1;J?Eb5eHMzfO>)%Z4m@$AZuQ8#{kZzG4##B=spdPvR~&Dz&x`EItqb6Vse-| +KoFCPqo5p02pGf%&<&Uf5C#xl>9k}rhasq+umvD6xX_1z3XYq+e(99-0Qdk1vKWKT!H9-#L_h<8-iT@ +O5D7#jhvp--a!=+v9 +RgMGwsjS1v|B0wm=bin$+g*Ga?BNw$LPCp1;yJ7uu_RPV>Jx;-3q#q3>C+*?<%p~u|7_8VtxF(c#K6m{--Z54lE_IY-%so`V^~^Z!=VJn-sv&hVj +)_a^%=N!u3+X-w6aPS*)jr&N8o3p?&1~&!yGte(d2k(Ol`?h(Eo+;N%8Oe&#!udIcF0T->t?NSMVFy8 ++8v?=a(I$ftM$&7t0s1xYR5T-J8QjOqVz_e>-XCQkH&qe>QwCLdPSPI+i*Lj�Aq5%K1`Z5Pr_Qc&y +r$gBN(&+Jds +Cm>3PacVV@W-LHTka4F{cMKtRAKQv!oPz?9FY1@rhM1Gp(?8NfA=7eEhW30xFIzy<0*TdJ8r8p~mHYg +#FvKp!2R!YET5L#iPnC?kMK0osDbpa3E`$aX+LfWc?jbToq=JU~sLhm3=a$PiFoaMAzOgrWaC5=NzsI +`%zbyf*$HC5&HB*1rv5RIQ?V%WdV}%t(luTml_<_Jy5g=f^lI&Bog}cy2iR)26Tt0d3b?@rb2ke!SE7 +lo-Q7S+zStU+>v0E$VZALvXoD9;_^CdQhLiEb7V`k7FfaIU+kAgy9raOOLt>adPQ9jdYm{I<8r6DJTP +$n3n)qt%~y*ZNhU(kayH5gM4R`cfsBLiZGOj;hR!M!oIi>!#vK=dgM~$c+B^xco4^D;@rsd>XP`ykv) +o%dDmwn-8kHC8PtbJM@@UPryncihlyPR)JdGwP?ak<&!B6(v@wo5uIn)-T}AN)&)UHi#yN*z|>6}M)hc;1@-nN64a1X|el&}JPxObLMT~EhZRSACg+l29vRrc4D#)vPI;l55&d(U^{emmdoJ +Hq*Q9_POx0gw1hYdA{NEJ<@T&Tu4y6Bvq9B+f7_gJLYo(KKiyu`eT4Fs*t@QHU7mwgQ?X$ri7nCoF}D +%|PS45)21d{Cr7%a2ZhwQ?_Bs1_4_dbl;E+0^F40kpCEZ(lAp(U-C1xl*KT{mE=%!#ZwX +>7eOWl7vqy01C2Nel^l>wNxXU!R`;6Qv;Pipv%eNQ-#Bikv0cyVGJZs8(85F8Xm+2#EZ^ +O3Y$@i1>{h?a#`C$ua2w?k1t~BzVEDd8~R?9s#^&{bo4n4B~oi>`vb@8$uEL)J?Lt?wPPG0jQKGW^eE +g=EG<))E`9g<^Re6h%1_{iW(mo=MQ*i2xfWy{8hL2S91-dr0&>+Ly@TXWy6%`2v`WfLT +_XUYUqwyH__LD5^XngbMyFEJ)N>ULJ*cVyiv;aN>u+mKEVWfdnPFMEbUKO^h>&~!gsqe{t)rl-?Jwez +p6yjqDA?yvCV8Fy-j)Ps{Go4&C3Y(SjX8m&GRcaS66XR6gfaZa`8xxsF&YsV8|lohkT@H>K|LN}Qyd! +a={apu;{>|#ARW^*+;#^X+-+(IIq$V@oSWvfN%$R@FR_&R2-vk3Df);p1gaM +2`(^Mp3B`_KNb)6-rU1!Ffs;l3S|L>r}XBOKW9&Y;vPWW3?T;4k_D`a;dk)uRp9N|07l=TYImMy1lqd +<{P$s&O0kQ;&z7MPi1#F*JujtCnDwD4eQ+>kYS0@ne~Ac6UGVURlnI`<(0!dg^GAh|B}Bubz#16G+ZTPh@ +Zig8hYP?~QUJE?i0XOLJM;v+Ts~)x+x4?e1-BnU3W?JBp^xh(gL&ugX_`c}0hAeejiid~QsBoJ&KWWP +vW67~>GfC!D#=BmCLluMfUX?D8fJw^6+#_Anl7>iLlRXUY+Uf$vPrJxS3WNBxRIv%<3v^P8)57wp=ZX +WFj0&0$MzSTJL<`4?hk-_bt#??n55VxIh4jq@kw$zK}dXY+)>NQ%HX24^sgLpc&77?MC43Ros6!4V9w +#VP9R)yhDLCoJT7oPk0b5PKFu35`!qUbtc`n-*zh&_SE#Uz#VNgKR2@!7|W@0k#RS7=V!y#gkRSP4zF +bDXcif>M#Cem)V!=*sWnlB5`LtSjDvy!kaP5vWG?4=|7aBE|6}Hf`Tv_I|D1X9*C+5FGf&pU=4>hFp= +qydFvAelm8m&;D6`qBO_Yza-dt&mx(c9-26F +76Z8_c#lyc;EIL^a4bCz8cPVjjfk=QFR`{^C&C9vRrec3F^4zvG#m^T%LO)#!04 +RhwWBv>iebG^vrs{4DX|`oBILM<@T+(#rs|8q*Nm84*D@Xq2@_wuf7$HeS}{hb~7jCK+CqOj)slo?9R +qGt0XDB5Obt{;y%;szcf#(`KgIeE~eJjc7=IY?cjzx{emIl-CE=HBR#pCJw$@PO*UKW+0C}MgZE%J;c +DRNo9VFqG8ww@Y774T-X8kC(xgpI=@+D+Z;BHDh!T`zG~a50ljc0NbG@D@*mQr;D^Iyq*Z8KbuV`{xK +jfM2vF?VKZu$DOZjro-6k>`1+ai)vdFTp>)diMSj)xmQY?Z-2wdA2!zze)4406gD +7-pmVWc*nR;B|B1CTqx{lui8@u|4uv`8G7D!@vBe*E-36E}r^d@`R(c}>ymXsU3VPKE`QPt|ofXp}@8 +3>QZUGvL3@~QgZpRV0|U*ux*7@}9s089qTcr_me*!bF}Pi??_ki +MuI;^=}ljR*ne!{)o858IKaKCFRbN~BM!iI1;V!&~B~X;zTTSdm-Sa+X(6%K&KKQ{0UJM>dL +z*uWK>I&V8?Pm{zl7~6X4uRgD=#6GZTRf*I9cRsR-Jv-q2+17L(9{_ANm%Ry-Cb%%DH7q5I_;0lb4=1 +LuiD%)Ja)RVulAjJ%~!@H!5V=o{BwkkIf3-`HCTsQ8yd^HRePG(u9&g9H?u8K$-6n%$xT44rL3r$YZ1 +$y>Zz2wiCYtXZs@Iu@M+Q)#d1pO7Clkj^Qt0F$*t1i^;0rD$DG_&(ks^9lRgeNn6GU_!gYCr3 +)JNfA+%s?0rFg_l5b{`-1%L3-h!01^L|<=4bB<^1}=BRS_JR9ZmDip)|gY?6q!(d`6!QYV2*1nR47W7%tcF{-Eo8OwilKe~MFC)G3#;|>ou;lRZMkZ~k}TH1j*7 +hoO`ZaPe5Kr!^{}$}>Z7El_=o2K(d2KfIZb}OIP}axANk?kyRfdmKkpUQk)N3Xnpiw_$t2ewc9i_oD| +0YL2Vk!9x>nfc31n)7weRc|u%lE|x6EEH-YYcRzvUN6;dSY)5ZhqF86ptK3ExqI>0s=1_usKOk*|!-- +?TYLU3y#l1&q$i_b2|!%d(cV-jIqje31n0how65o4#jxcw8*jlh(gF*ydub)mwL|G(K^a*1RBV^kF^v +``Qked$Ej~kV#2X7e@1TIQ7QeUUOL1Eu+8)w;T10vGRD@F0qbS-sa6pFf-&9sOQSZ$x*#;__-`f#`Ai +1_?lmGXtP#RQEbPOe_#h9OWlO1dxG(!c7Husd$n;pAJH4(u}exiEXHcS!O4B1;H6WC^F%y7g0>2ubM? +p!gX)RoCaZ7HP{4t)=8zYT#9G%ze0%hco6T-*?x+oInYX*8jfL}cgDZDyEnVvNfk60i&dn%Maf^e^pJ +)DEJFBfqj?Nrep29Rcp4>;q^3}m9T_NFXF|r>#wTf2id?x4iF?7Y=qznRQ+mY1+&0Do5A$eHBFA?%Bs +r-a$y(#_mbzsQ*LNFItU8tquk-n@(ygS)fhKh^Qejc7Z&SPV2Re&Vqv4Veyk?AW +n6GtWPy=%2g{4iK!tJnPuWfSNJ?%L;v^fD@*5QOWY{VCbZ7{n=cf3J4HlaH1;8=~O=}a|quY-D(xa2_ +`SgFF2+w#^j?cppp*)6c?AV)?Y^JQ@s3w#qDHg1OtC{3nOhI#|#AL~TX{R)+z_7-E>+3;6?Zx*7gePrH#jemzl=Z%b0nO+`3$fbK%jWoHSS?YZn|D7q352S(J0adnnNDo=`)Xx#8Dj?qF>+<5nx%U2{<=qT-)u-09+7#%Bg<=;0rg +s8cf?Fp7${bR44x7~aGI0nl+eH{MICiusCc&F{3Uj0qXg`g;s#+WY?9;YQx90}7VxCCY=0#-~JSjmWb +Ed)E2H$tb3^z0`kU`e?07)N1NJC(s~`aFTjA8^rA1fw7<3l|16ER2reEbKUm;CiZ`?(~C!+fC^v5eIA +SF*KxTxabR?5=JPPFbUH^B6#C`D&r9o3k+Le9888M$%(fqm~}$NFy9iU`V;U>I)bahepy^&N_d=oury +!reD{?@6^i+9b=eBBK2-+?w7oK01s46j0~l{~OYh}(??-?BW``SnuK`W?8c+bA&PEKp0R=khG1Ucq+e +7EATF>haI8)joj8ZsoRWfNv!BpJ{k)TMK8mIC`un~xrZyhyz=X3e(lPx-{!&Ft<E_YH`q8X(eNi3{j*_gr6*R>FK*44>`Qr7-bWl3D2%8?`5~Zo7WAQE1E#eujgY +cklSK=*D(k1`iqq0&q`{)fLe~f;aa!!8vwX%IQhPW^@;nSX3O3$*i!nHl +*T~|T2M%r_bT)d3j^`pzpo4x#;iz?^#$xht$!e%Ypx`<4V0BFwy_NZ=MuAD4+rODie?=Slf@mpzjzXZ +yBW2XXEiujQV?hSi4uy +rdci9proM-tG?Hti18`PvXxr8C$`m6m;`VfbVI%#f-#uTRbXo9n09g+l7US5W3kVSbTn>XGZ`Lzoi8*C(Wo#{&cj%h}5@DNe+?GR+@Mr$$ +-deQ_iTF5q0KuB>QH0HT4lchUOfbYjhUexTPibf*;?~yS>>X7N?P$yEH4({uvzrkXNHS-)6!RkmyR@T +!OJZ|Gq^2wp#exzHph)-O6Kjy8(swH|$e6^0(8z*tzbX>gXr6%fIO4mnr+~w21^WaTGpfEpjYOk*6l$ +XQsq`Kxoiy9xsyQ>-rkmR6;z0vJOZ>b}HAJBvXz(2EzhCHj)gKt0W4!E9KytT@3Da^s_ZyIV?dABxM# +sxtkG?5MjOo1uLV2?||Zf+RUet9^eo)mCqoFsZ3!6hXM|zaPjZk;9+T8aL((Z;9u%Yv4)_Ux4+o?;s^ +GEUd04?t0@iH%l@iJ^;_k;k7CyRcg3uc_Y*(%pHp2ig}W}a?g(_IWbV=7bJDzS^XTWzC6MnLe_$^dWm +rml^ijC#kAmit>mGS6T>ct#|D(dWK2SLBLlXth_?z1|bY0@t{HnRxmb;UWB +I2Zee&%GN;+Dt4Hw32@<6|WIt7CZ|nB{48HlO#D94q_uz~}2IYtDegjD*g+bu!!&gkrbzLLH4uZhLE1 +B4%NG3F!4;_1X^GTGsZUv9WfJT+QlncB#}l_q3AkxZR8X1iAC((`aUB)-<;@;eo +@x@tm$WEE&3usveZEZ}x?5XphU`Pr^Q-#a-Um$Cqo+KkXW@!ao%8C}h9Sb9Ywwf~lAHuUMVw4RQ7m+x +#{;k)iMXAD2W54W#2y?dq#mH$HpZ9@-YW$bry!&AM^_Q6T>35%`~j-p^NmyHM)OqI~qUwkgYDCKfrxH4_?EH3GIh +I#n{FrYI_CN#X_Z^`3U=w8aB9ZBqyI28>t|FhrSU(7^|e0^tEP1U~H^kyF#++G#5~@@L*Xm?cibKqpD +VntKrj_nLs^8&U|_0Cib%LgNg6hjm;r=*uH2HYf+gP~P0tawV~0+$1wfxW5_;+LpfK<{4GeW0 +%JgJ*9-UHhLw-Dv}~H`GnPMBUH<#y8${AIlSK)9r9wU+YId-g9r9Yu?iG2p-VAgh;uZN!>WyaMSnU}NllPX +1o9cO)%g@7imG9O_Cav~zdJmN<%m`L?j9R!@#Gs$PvH_+Yc?8U(%a|XQE$xOnGUn~s)_J3S?DWt(wkt +o@y*T$=T~Eiby{RdV9#X&9_n^XTcH)^`KLc=Ae?(3R4t=7r|}hrb+~_rB#y@x?Qq(+CzbuwjljkE-ahCunNjeg$*J&5}5G +HOb|-H)lW#LwY6|n5j)jdodB7ecJ~3G4Q_xTMn1pJg@s0M|7RP%O)i_}JAAV(TXv +Aokrval>US50>1e~!=HrjFOfv33h|)b?TLDdx+0)=-<-vOmPdvrvvo^1tsueNe9q+r@#*GCfVXD;`bvFlz5l(C`81xajt6Ox= +sL8c@K2j$1hS+Y>yf79EbSY_xQ7~<@@7m*zT#;Z~SeQ9FU!F9yHuR*UX*tqMb+j0o7itRdpKBD^Az#Wf! +(U()+8fRP_PV$o-6-tqh$|x9UR@k(r*Prwb}I&ygITzRF#TT91{=4_EVG&Nok2@0JYru>)uUXrf5i4@ +(=FOzo97+;^gLzY@|E%Ma*Vf@EG{~=B)nC1-$ +gf`2U%jcw>#Mr|*_!p&Ac{ELL*bT>CXsgLl5ScZ)$7Bujc6ZXa_p&G!qLL6D9sUPE{z#0>CdHOr4KZq +c3IUuWXw4n$TZ&S{tDe4N;kM(Jnm`N^@xzfid~o6=pixlwRpXs=4_%dXUXlGqwU;Fp(MyT{!9ab36}D +myW8>uPX*S`t1Ke*0PuL~Z)U|P;Ca5hrPuY@#jhvMKg}i7x$e(SU+qYFZfDJQGmmeHTgA`$b&XSg#9; +eXgPh0t4E3VB$PCvuh#xzG7*%Pr&e*uR;Fj9tMH{7!TM)NfQ{;1RKgcIGZs_QkoV+cMc%_nQ31_=Ik& +ek@d|6-Ik$hB1(r4;ZkVRdf@3q7YTN5KK)LR-NyCxYgN$Y=rqUGV9U5`=o8?^dy>Ti(sKi};SwEc13? +~!#1t2+RuLrGY=m0_XQAf_FH;8zNh5AZ1m6^%gqmt+liK7XwifkUlC60kp-h2ap;A6&1(!JdFh%1G$? +g8NiZP+QUL&oUucNXOB%ojAe5bt#}DAf0j)rZvPEBw{w5D&oBo@l&Y)2dCzD@`gk|pX7-pHi$}2$ +ebUNjl{&II#*_bjR=wFfb<1dr-s^aU9&Y&es_rvxl^gOSuDk|c-eNDGaYf0NaO+nJ`iCTQ{~C +KiJ_TQ3R38TB$L;&xsNc5r@pnnG4(bfZw@I>}hpCAAKIm8PJ3tKBm!m#?D=Nas#N5i18q==^SI +r)M>pgW^o*eqA(r>%emBH;@SffB!7#HXbvOqF7@K_5lqDol!0m6##9m`O$f`ZMdgSyVh7QwjIa0JYu5 +g<2AQ2dV`6Kx9wa2aq>o+~Q7iwD+suTawG4f;2mqS8ZgRZjQ?TBJ1-=*73Zzl5gY6|8j`7Z+b|FbvHR +V?%KLMKG4_~K(H-k*GA|FA!QBz5E)R^Ny*sX0x54=S>ldBS;}nqisXfkhQ*oq2<~)W)!>7%51Z?q+(! +5(zZJy6u2@nB^>22KGSm-Z|!?xt8y;WxLYCYiaYz`cQc+d#9|ySbKMFnAsiG&#j(9=)M;n%e+@t)Fbs +}ZXNyOYE9fYd5s=IqnFi;KAHixKUDUbxay9xK4k6AqORRx*gr(XxRSP%MO;8oR7NK&$q`{z#;&~WaPH +JcX5m_x>|;kdEj6!jHCbodEM*^iJGg|hk0fLTxrS8v~6~)@FQTUu+ai1Hp>AO2(AJB^m0wM@!^ +ok%LJ->c4$)>VdnORlu^Thjo5tSLM5T>|N=D4~sMv$-qGZF0ho|*pw)jtzO|3~uff4SCA`2BgEf0lCt +#XStrOV>;}B0-Y~@IoWtDn+s&&jzl7Ea*fL>)#*4I2cr*K#vD_M{P}~bel{FVxZ4NZ^}|@>boZMaSFu +!)^r;CWES$PMia8lYD57jyRPpWZuQso-hu$6+R@hg3S&^_Tvv?P?Tr}_k1z!IEI^cl2Jf^65^LffB>? +b)5XcTvAdmkejLX1>WWfFe6gw_y3zgXs(A#o{(z2+E%*m{)`}(VTSqlNZUCgI|tmiu +uR=5Blca!2Y+{mVe&=uHSy7ANRaZnn|0xp=Qh9;{RXngbO(pSS7@TRIZ&KvdVJmm=(6v);4f>r{osz`SVk=0&CF6VdK`YU^rGsL}Pg@RDY*Z5h4Z +d(MycGW@zhiZG6;NmBb#O{V9-!8h~~v%0i@q?mzpQcFh!WA5ZTUApZfY;(RSR<6?aK;QJD_mDAJN43UjZ)RiH-QMfy|C^1M<}izFAdb#?{i{9^eG{x +a}KtckL^KYv?zU32aWZ{(@>d~<0`vQc;JmZncJUEzk^2SkA%Cj+5Rqk$_lXP=vEs-mp!o@idrUa-#en^rT$Iu%d2IPE;6vUGPgFD?u{_RauLB6BH +h^9G9)z4%LNwU`xo_b@b_UZRbcJQs#jad{TzhSJUnd`y{B$l@?pL5h@*(|a+8<-!&1;n=#^c_Mikf3U +B&bd@Un9XbB#U}2%BRLh?Br*qkJm!5VSTea^HaZ&aA$Uos~V!ga5>Yf$4iYug2;v2!VBaX8U1x)FVC| +|Tuv3A)D+Y9;)v&-sgmeB2SYM(6*n{_RzE*edVwtgyhFZJp9hT;@&$*@@X{~#5-oHR*v +k!_#`bgsc8F2ph%l(AU-z@c)eB81}Hqlo9YB$Mvx#5AP5i>0OjBqWY`e~?mXF +mm`pbzs{mj$DEY5>eFBIH>82VC5^m(b=$~aG_M1#Z@F$pl{cpmwHmYBZxax0V+KOEu66n`Ju;3%8hCa +hG@&QyMpP)MWEmT8aa+QAt)eCorzNRP7Z$G1qdhP_cYK1TS9dxx;;pF9(x5E7}Pw)kOu@jG*nE&-ws7hJjSaxgCsP4She!FYr(ED_kE|xK^^?ElkO8s8*h%|3N|M@4 +_|o1+RYr*SRKqwGaxvgX^0Elsii(aGmGxvgz+2n=jvS@+Kabb1$qj6`1w_-P_8pw4|{yGc=|gYXqcqJ +Vx#ou`$ak9tFob1qm#kjE)}fa41fS(pR3zve;s*cW|%AHZX3r3};h28*47|tkaP1fO2JMG~M`Kq9)`3F3M&-A<>C5?ZfzVMe4)Q +9>D?Ptzl^$P^lYA_caQ9_biF5=8XJ(BTO(eEjP +usbsmG>HLDS*oq&?LFC-^%g!cVzq0SXiXs7C-&dmg{(BlD^c_?E_7_`y{c{Hd^RHCK(wY7BHQ$!f&xs +iTcK5R!1SraT-%#_$kB3;lzW&ur4hR?jM!n!u7XZ_2Y1RQnJl7Dd*t!5;k3qV<9UQZe`@mt^8)fcGJp +uiTzW7-e3vkXM{Y$2{@IUEgd?S~!e5Eh0cjp1dq40^(5BV+-dvewnuir~hJvMG92&b@bsGaSPle5t0( +b+F2eD!wyy(Gq8?S-EQyMF2~1WxzVg{mp^d4{Fy5e(6B96v_OOjuno=Bp+ +rNC}OYYm{(R(rvk*Df5};~C!WRMkr8@ZcVgDFG3uf{W}_o{{KW%yl&iN5{M0LW_N&h%ms}b2z+hIU5{#hO&_ +a@C&aV-b2xjDP}kIr*e1wGH!t3LX6rX`Bs*b|F%;*Pkm;SXJp;IMvF>QY__aeps^CzHk}6YeEwa1k)* +@V)c_&yC`}Rh>LqAD9X`<($Z67xN?SJLoeN#YRP8L`N+mv&Lck`PI#KcbPC&aCfK`D3?( +ajAR~Ew|d>!4mzX9<=71`RJ~{(>>2ay@lS_uS(&*KwT_JZInl)0Bxoy}tYuW67d^Tr?aaRql-~ysr*J +lm^Sj$5>ldqEWamK7jvWjn=De{!zz%fHB$k*bs%41{{H8I{eCd}5)zJ0)G9cD9BjJf#!?9^!^V@`R7R +Fw9()M5mu4z12$MzQ=sz89$p|+wBGzN_tAZG_jc(!s{kA*HgjBr9EBDMASRQFu3cPd +Z|W~V;s$(4btuV9?N?3yuS^Zg_aO9#J5NcmH}QmE2qXmX&wQ*Og>9bWECQB^(v9}Pf@B{^6VRZK59Z*AO&oIbX~hx1Yhi&l)h_~uAO) +p}HL##CFao_s0@&8yXVA?Yf(5Y+836%qHUVW3Y9r1tTVVq<0}{~CM?MW?lUsWO0ldj@>r4DOU=Tg9@j +t%?45k3~ca!6|*9bgbkDJr$M^2L>M?pWBeP6Di9Po*#v60{bZ2wTb{O+7h&+)V1f%{q05lqp|TCT2Jm +qu#2zLgO4{QF~?SZ!YD&{s~0e6ZJy{`27Sif5M%lE1Hb{B#aCLz|L->@ELA ++-xX^7rSmsJd2kKd`__Vz&lFcz3_RbL^y3V9Ut(7M-?~qM9ReDlGBH|$RL>A8M!zdE`E>J2m8z=)vj} +OI-NsSiE&O1F$uY#hSln4T+i^c-Bxd=kJlva{hpNq8ZX+TKV_kNKkpsFuoyvnQ4*7zZ;q>P*nvuldqi +Hm=n^m|_nol_J~E-#oJEBfFRweqX|g3E(`Cn5LGwaqgnsOg?=F`(t!XLQ5S==)-VrMf4niNwbY~;a%z +Ko$%U`L(6@!e(J3PrImnx2P{HJfxxLMy8u^-x$g|Ei$IFns!;w7(nc;$rMI16VY9tykgG`;Sj6>x6q8 +Vd-Y%^5088`qfYr+Mpb&g}!Iafts3zs&uJN@IO|*H%EF2jdMNgmFPmN}P+|!xzu!7Ni|74Rv*U{bEz_ +Y_=LJOfPTzb*?QlyZg)Ud-2NHxfenESLqEf?nrl;yk>N-c_oA2;5GR395s0yImgt`LwD_CKSxhWQ#`S +U`NXf+X?K!z5{CSc%%nM<9!F~-2rEYd%OM=WChzSziTT$ch3c>{w>6F{r<$+vK0!__<)krpF&1P8r3e +DcN{&j7=#1&btj#ReToLxvF?YCTfE&4=VwpOYcVd|+L3jwrp2CZJcxZyXbB5lRD_*GXZV2{Q>K$p9Ws +WIcd^W}*THs_aCjNo_cv5|;LVso>3LJ0||8nqybog&w@YP=Yr<1>fB7z|3 +4|CIW8=4M6AgTk*gf=l@FiE|QSEnhcD&w0CHv_!sJ|^5G014KlF(5WIKyvdDN&)RA+BW(a1wRw)=2Xg +pzB3kpW-|IKs99HGHXkEwo7Y}5<0uAn{}>0T0=PH?Ko7v%r$Oy{1-SJi1RHOE&5mgnKqY8$$6#(P#z2 +uh4uP)WdI$I)ory#Tq!9W11!_btx7-gEk0te|)C>9{_uBg|`=zM%DfhBkptAM3Vtx4b_08lP`aDhbd5 +T*F;$T0JYkoME^TM|UcIY#?#?^T9OMzXtFlYEuviqE)h8q9;lA~U}eI5Eru#|NEpTG^)j-I!OEX49rt +`z>xWf>+E^Jf&s#52AyReaZW$Gg~NMr~iDy`biSE3oDHQnLK*aeCQ##fNbNr7z`4wpLcZ#UVRi4o7a6 +9OAIc;B!~k`+cbuf+Ak8uK@F`TJ3G-J>3z5muu&Ca>N08Tre&vl8))gG+D^ +hNt-a|6>~r1Z!jakU1E$?qY<5mglwN4|Iku9+V+f5PyAJm0t#Dd(&8&$G+QmpDq8}sdt{kHzsa!}ita +KEHDsqSC?n~7f)yC_u;O0BVj?F&zc8S;7jJswii{p)-h;xU**B5jj2`SWXFdpzR?ZuaFZdZsR$hx +c%Dt=2OJ?T16)i()QZlroR5%=G?d!-56DO#00s8XvE`#nevK~w!T#7WMYg>-*sQeIeHq!r^w)F%(9bvDYrwjU0U)d=1RwkU1 +e;L;5rt9D;;t{d?{fpX|JtBjLd +rV|0C=$dn_ScqfbZ)D5JR%nS+P_5k@i@+VMkjaKCX#Ejde9$p{{&7B8`hYCC?g+o%(7(1G*A4yp?dxC +mb78K?&MdTpPwl|;$TQ92N{-_p3yb5cGF#@ithCt5em@aSGwM3@YQja +X_jnp8;LkY{h?<-ormsGC@bs+uT%KSB1~3FmO#r>;WQ@}hl~?#kmRY5h_y$MWdyMj@8a0uGmMZhEQ|i +IC*oedFVdrjx-5BFm?1O?%;hKE;;uv+*Hw&d_8Nj!@FhXdNb5(1wa1o``cv)UvhrULy(eq`x>)^=arr +j9OG3kGm<=Ic21zWghQpe3D;P-9F)PADbrz^Y9_gF^BGw!@eO5wI_GA8YtBzfw29>Xzm?+8|~&$Sn=7#Y?q*_QTb +In-PE`j#%*-zWLf5Oev*AXZP!x`R50m3a-T-{EOhszcy(T0=jANmA4rp$xZp2CEB+;Uwb4s4>YqZtrQ +erWEh45`fNOwz5ytqG|`ot~5M99+b?J)C`SoV$x)FnisiQr)fhmm=^Gr;+!>f~xP`d#Q{CA|7h}eqo| +{d{80xZ!qWjdJM_C{YMGSAFlZcb-q3SkFdjTDl6nh{|_+Go5HsZo5n%ai;MujBp|`)3m9!>K7^fw+Uj +mNfB^yr`NWDgY_R#xF4TeJL@)gl;RX~F +AHO20sGpih8E7J{zpJC?Ku#d!Q_rRO0l8oGlph{l*aerQii_DjA)JEDuopeA`>QK7j2CCRx8jHpog21 +07!L-DOeNt5hq+BOFBZ3BM%KP|B>Z{d)gnP2I)NjXx}N=<>WWCru)uWR7}9@N@%l9O8@QrSl!H6ZsCwbW&1jmXvX~goAmk9&$@}O|$NNPKY41ZRd*^-p_&DlpmQiIg?+50J>$97>c5; +s~v88d+S$qM#B2`m|om*eY$v8T@`4*;D0`U)4exUhPoq`L=`~6YTeNAUg&Y$v!)uh;zT(cL4kMkudpQ +-D%^|?{XLv-I+q2BGF*S+tiiCyr^WGL>9O-Y@T1p3095$5$EDx-Xs8spHv!gT0Ypf2kTeQKIfJU!GyA +tN^h5fMi8a{TRni|Nn?>c2br510;p2kM!`X}7$b=v&$!EN;H-rAEB9)*Tn_skTOU!6?A=Jx*^-s%D+XJ0 +A~;+x2cuCUGRK$Gg!X;}t&osCqHQE~PQj7tPQ+PRSE_P46CMuFCUaD9`29B2kn-C;2#w{Y8ggxLKZ+V +;(@Jid_zO+4gRFOwssjl8{=*_V2g&?EIN<(c#KvgnM81?E1Xn&kpHIdemi4DKSw#y3n(-lDavgwMe|N +Xz>&zX_%)S*zi-N4DLEF@RG5#IXZUU?XsheU?)|6iW*7Z?d6w&@>U)e%)ZL&G#U? +ds(rI6XP!Vt6txmIsb5@h*E`&K_!kCC%nlM|;t+C=TYA*k^kBdSC0%P~hu)GQ#HK}xyPevHsLcD<@I6 +dQ@SKOs**L#5_>%TR35AEr$lRLpk27s_x7Un&{S>TUb7wY1W>5|IU246eE7~yT&_f* +aEth6bNA`b_=K?Ang>SV2qmh#83WB$b@a9N%-c_M`B +9o;_E`c8BTUcHzCt^ag{w&@v*=jpmW(8na1M&w$Naca@gO}vcI&(T{G_e$I$qQs +z(yQn8FF+vKjaXo1ow+GWN@~togv%)R6kj#;r$jE;5^5Jz6l5D~%g#}uhUBzD&NS1eNw1Uz(dcW)X*a +*h6A4jEBpJrrpi9i;^8Ifv+*EK(y)3K@V@TpFDWFs%=Od@wq#vlH>k|eq{cb@SaWqDnI+2P3!-1(CE-Xyv=OJ$5d}6MF?3C2#L?Ni3OHSA;>Og8 +1n#FECH}V}qmEK2HqjrNutB%ACg-R?fS|&k`WKQ@%RPA7)a(GqV28Lw8&8Bf^hW&!YmZ?ZH;k+E&EH5 +aRMuvyg!&PWkFuv1soe>$AKf7xNK~Wkk3B6cm@`CwR2i-aDYW#qC`FIg3>K$WG>cKt4JH<)R&^^13DnrQZmdK}y{&k`X;^X!!J`$MGJwn)oNM +~LY2DV$0qnF;9Bq5iuo?>fz1^>|ve=T77K^`p1NinI4yD&^{PZvuEaCdFfUAX~##V6jBb?Fhq2mr>9L!Y +fUeetH#kc2DUDz(-BjlNque5^Oa_1yjQ#kt>j!;?JO9R!)InnBopTqiSQX`f(9nUQK-h|fZsGoQ%!28 +T6Y+6~4W=+nN)MVb6?EPyrKRnmYGmb+a2y$Rmf7cs!qoHYyi&plAtz$|^6y<4)` +Ij_EOtLtM4MOdd1>Yw)%SD7iq&_UM;gU}H;<-nrR_lZyPMCFi^B9QqmK{@DhEd;db>{7?SR$lfY7XG&kH4rS@1>h5Nps55$fOtp~JjO8Lk;wE_dFzS*iA#{8)=lf`hjo<2 +U(phTM9<|hq)#HLF?9riH^ms|K$1c0qMEukXT*LUFooMxC9u5w479RT5rDIu%?Qkzghsx4pr@_*acbh +BL?Z`GMU`@y3iw +zYd){yw9uT!WS<_|N%OJYLD~$HIXy^jWULWpr1|!znT)?#?5IQ^x7lpzj&} +&494492)LL?Hcie==0Dy9;?|H645LS&$-hQjpsT`eB5d0X0UK@~ZIdHT{wRGZ)*uM0=062t`5&b(O&0 +~mw7GZTjj){R@Gt30Y>lnHgg@Q4=Rsdi{9AL$7w)t8Fc^Hk&S#OspuY-S8m`&Wbhd%linbNFyyZ{g!* +U0$@3_93l-U^B0s-MKg)TkkkS~R<(^c+%I`5ODS_b{e{YA5Xuhs&6ucMz0)X}QfcixY?XHy!CU%iB2D +ug+0ZfPJPVan~W0=u)PAUGAf;tAc`GN&m)88E(hN!|6K9n@)!0EfxWUFTLPp@qyRQ$9PRTPH_{Pq@pw +C{IJu{QkteYhZ_YKLTf5%2V|pM$7BuNMkO&GQkf +F>{5o@8HVbU&kBRlRZOSm1h*estHH;2Zz4t?F%x49i@%O&iNeP)=(oqxo!%@sYy@A_TJ +&67zreqsaeqGz#vO6Lf_;)LNu;?ki{VK(6j=<7C4SOUhJJVQ&wBfc@?(S#{iV0hGmlP66)_Qr(_^f5s +9Qw$hv%x7YcVQ(a1;2mrk>Y-g;QSd=ZSu<-$=)WExBS=OylHpL*tx^k-0(e$H`1P{CpTDMt(4fKBJkf#!7V +BRgX7RnR_*ax$B!f`irC3X^-@0En%0ZZyL8#o?P6xB(k?8h;bce^NYZLAw%&+WZRv5*%E({rLg9pSm6HNhNT<thK9@eK~k! +nv@SvhvYO2VMSbT{ZjTaDcXLGe*Dvhj^Gm4q_EnJVt*=6ER-erhfMk(;s9A#L2{)@yp-N<6c7EW}sp> +tyjBA36jdJ_l@^-p>QSljSGTljc)eGoqJerwDP-tu+lfJL)X%&QklTMW&z==(aF1o}6ce67I)`CWa4! +m%TWuUk*Bv@qOqh1=lSVqmgDnY6t7@?A7Rzj8BN-#PE=jyo3I=WUdn3dMD2ws;~Ii97|H{X&r~A`)Bh +!9s-G%ay>wXB?Nv<4963G4oR!bkgUeeb&(%;HnyhZjuVvw2A}jr@u3P6== +~8p=;GngOWK`(saoYsoz>o`W5kSj^@<{ASbz1=4o5|_=c3}!yG)l74EH|c(C$R8F+*e(2Oi4C`Rn>uP;p^=L6gB>i>!MxwCvd^X~C!CEt%tD>~BYMM6|= +Ldk}Dwc4~rK*I>vf_jXa|Vn`+TNOl->+E=Kjj8=9?wZ=bO$j49y30Ch!uRHA%*t_PIH}<59o;u~ki{| +54wzs6m%a^=FQ3L@;$2~97%83Xf9p|6Ves^@5*jU^hc|)z8e9I2EYkr@|2tPG(dz_abZf_a$!trcoAV +Ht4SCgCQbj2g;iuT5|o30kex5j%X9J!m6p1EGLUWg6Del;(9^m#Suw=?_Lxz`d%%@?80!&pgnFPJ|qh +nDv>&(U6bZs3%yEkbF-q}8pz6=>_RH#_^C#zA7PU0iy0Nc(6uCqoIeVn3n9h&csO1Y>`oVRb@XRUhPXU4Nlw3`dR6Fcq`CrjuTf>txca~betjRK&XRmAf2=`%KHQY +!iFt{cxo94ZystOtT*B=8;j--Q;QJ>TIp+6Nk(LyYGu=GA4)e}`opZl`D-M|*PHG^BXe1jsMb@EXgb? +SS(Hl>AxN8OTJ*$jTlcW@ha+5Q9F-?7-%7FnweM~3NT=#A(Gv$uPhiAZm)|1j5q3r5KDnDQAM&v5e(1Z$l~8~i5`s&WmTqU4Lzj +iX*TKt|hMRbQJxEQp_i;)~AQf4H`-qQ`dhhnVhvXvr@@-3QBk8@gd6OJXR4&@_cHB!g23!5|pHuPp*S&a0ez +fQ!vkoV}N&-AfN(5{fdPEI#vN_C9S8DB%nti0g%39VqmQlh9JHpBT%)8Nnk3%GGO%>0Yn7As6fE{5s7 +Y$K+jqld?PBy<0?2j`$VgGU{`Y_aWhpfBz_z4T3)Xvp_e9`6TCA*r +qKFn(&p>UOHv5cz}-fvI+=@!EQkj7}k`5&n}4Vu9S&`p}%oPUG6hyG7)f0MHPKe>Hy_t3Yu|Mv$~g~4G-cVAL>2rGrD5Ym&( +wtIsRWSe}?#gJ(|JN)6WbQyAylda28_O58a*#DyJA@2lAU0tuC~e$>m&+7;g3B-Gdplp{~L*zY*J5A4=bf?-E +uqrC?wqQ5Xkyg|poiN8SyDvFvP-5#S7!+cpCE6wf2T7{p)t~$1gk`y*Wa5 +ld~I%rs!qak0j^JQ!~r9g^n!>FfYog`Q9;VTu+PdZI^JALe8I4_HbeAGB)X_fuN4{30M;#)#_2TUSiq +WcoBnECn-_KR@k$8rX=N!WhZu`!*qsu{*S!jY&Y%Qf8b#F!C!Dt14aa$Q$U`#gMlgJnLwO_6YVz6ssE +SaAKi9k2E{YWH&Pw8u3x+$(;78;9#kL&tAYRk)D_EyATm5UY&>f>)JRtSZLq<|maV*EJo`2}2VG*)#A +QRhPpFeLl&wf52&|9PeEe8aQ;~Q!^HvnuW=?ak%X4Yscpj{fJmGe+q}iWblRF)ywj9kL}Svz{teDZi+ +hXz4$4&F+>lz#_nj=JGxVH_b0>(&6HP}P$_R1MW$!J9#7+yQLdg;UN{U<_}()ET7Dk2$cRR0w-ZCZ(K +s%|%ah(%H;Pvt2->_vgvCuqfnNb!aTP;yVtJrb_%7f{|4?7Wou8=r)Im7QEH4et-vM<-Rl2m-pg^uq+ +0F3w;y>X#fI327ewrPT23Hf?i1Za*jL=ZQb3wu6L1hGz)A=OhCuuyEE=joL5Rm+$R +cAWa$FM_8;Ah;L=IiaY~^%Qr-Q#~+j;$$PrUueDw;G7Y0^6|n_iN5%$BzT4(!DB5))l%&U`g+5{o+xf +X-9zV)em-Z|wNI1kB0Wn7h_rtcn<$chvb($1E^Q=GrfzheG +B)kbh(5llQf#66gC*4-qH)YPlWr<%S>*8LlN_DYj_ +#-t~hOQv6sB8?lYLD&h}KtkTw64}zSpxGWd!iX2WlEl%jYoh-4oLI^G3B74%tsC>8kWbdB-RCjii_Zx +WXL5qhaH?AH8YoS-S#l_GUr)@np;@l0E{$Bg6uoC69Sd9c)nyuWFr|AV=C|X~^&HhVTZmG)rX-xBY3T +3A!*2Pz*GB(juje@KTd~f+w6)Lw@0y2HaRqkv)1!QJN&I6$`=4F<6$d`O2Cn{k#ry9lgaUbP7Sy1DH_}g_7goj)tD +?l$R}HfIw=e1e}aunlb-SHyE5Y6)Xa9}-ox%igs&elm(0)QF$v`BjOF;y0-XB3xR(h-oC=`N# +IfwZfpYNE0-MF@8AURrS$GO^EcJJ|eaWg6I^O7#`mdn@-tx$7)7MRk`_Br_ +$3i`ccV%g#c7-yt+zPHgg@^Cph#RQzcz87}b3j=c@V>Q4|H}t*ervk$B1^f*y~-mB#1BU4x^N7Eo-Ss&SVLyRIV9aDES`{J3P4;3;T8+-}1I? +~JLzp|&(0tgE(JXEmH8n~YtGFY;FFb>M~BKfvbC7Qg=zp8xsPKOpqy1^yXG$D5~A7y}pHHE~+kROdx%rP*Q3Z_tem!sKn=ljNk2;PVs!PZnJB!FOwxzQP_#2&a7cSHKgjbl +jm>;s|}(M;e)sxYo``9`~vN3i$3{g+`MkLmdsD@)AYO|0+Um7tG8YB4u_aHm^WINBjf}R_4=8fnmfLY +HZ)n5f&>}Ed*i?u=PNBUmm(=UO*zEl +S&G(Bm8>plF?YGRq`6o=l|kSE?-BXoW+19)Kt; +URR{XE=XSgZ=W<{V4)~eyKyIMtpeD;a7}I{gBe +Bwv!nOwr`4<>~6R;zokTe&&%EljZTHK;}E^XgitN(B;F*JR<$MU11(Ga*vig~*(_DrGpp +LfJL=C2`o8kf0SZJ4Jrrr*^#X>6&pO)|Y)%A9NWvg4p*C82<#d|Hb7$!1k9F{uyqsc(}qHo +^C!Co2yl@_1_R0R65ZVB(p&03kO=1*vAyL71vkDUojF%fH(j{Y`wt*z$Cj3dx1eR3=COEyz(fm-P_FW$kN#xF-ML8plM|Dso9iq~ll$`TE&zWh`^~)x>*>Grqi` +GCMT)SLH^^3K&$WNaH+?34#;k)hjyO89c_;=vAJm|&Ub_W%6$L?lf*cok4cg>5Nd^xtgT#Jx4b)@af#pn7Pt|T~4quJSL5P5gB{Nn^5Wt? +GGo$D82)lZu)f1H7<5|w;at(mOvj!i$cLZ05b8$!ZbBFU>%szJ +Ve#sk+r}DnYgHAHaHoUNEOUaz&Lg*PI7KKK4JGFIBC~RZxo5i@NE7<2l&md3x?GVJ?YzI!_x;X3>>hf +0F%VT&w`H-Wb=e3C1zO$*}ky=F959Ey-xgbS~E|IJOnMM;m#s}wiwmWM4>fdqD)V=b9e}^q6=!2!>st +Do}m>{Xz<-{d(9J1oC6|SM5OUnYEeND8-G08cm5}WL-de}#aHuP<#{q;eS{)FA@f=3R!=T-#)@ctEc| +D6S)ZN(4zG@pjPMfFKY^dr0sy=q=;6~8cgH}*xM$hK+r7Z!&0YgqPhh5MsD;G)bQ%TYLC>VTNZ$;^oQ +xaUo!J?a&ITOaLXY?mWlUmD&E-01wSaSW<26F)4Y66`F0Q4o{y{bA3->ppgTzL4u~)^kdK`qEY02?Z& +oN4@nVZ)`}#6`e`FKsg`5g&6K`p~&(3$nFi(L2ZUu4kqQq!kYQI6eq*k{a*5kz*OU&wiih~vH@vUy0n +9)MxJPKm#OMho~shcJKJloNMY@W;h{ZH!gS>EL|mhoq+pMv(<`DD&Giz&TsP;@3yOL5WotcF>|XvmyL +WD0aJcF0W48{}@SH0eduC_y){*z|*5*=j;vat-yUo6Gg80$?$syzGd7nXe6SMx!B|l*N|Ki(xi3NUmi +|^X4EJGp~MX~HJY`EeCG$L2jUr{rpL0c2Sx8~+%T#+IGU#SQb;<1mtG{6EW=(mEoo=x_8&DPmZ=9CBk +=r{oNaAZ@uMo_Re!vblz=$BM=0%*gXNRi#o;N&xp +vfA-sCx4;B=c5R}k^dDJLGO{Lp{OR%4OXK|Z&BsU0t)F870kUn$*ZAnmXpMQjIfGNmPhgAj5tIv)7JW +PP4gK1wLFzT(t29vY?ZSU^fv-B-Yrg&j6GMx(eA3zebS&DALEzxevA{w9LG{~;UDowntB&UHp&U}b%6 +?B@9Xft%&~YKg(-&Xw*|DH+R{nbn{16L3zmruRFa<4~Gv&Yw#gx(Me1E5s$3KhEwgwHQ7TBwy;z2wei +F=-nD7eRyx9&pE19H3}hn@In4d7iKa!1G7zc?vApLkSk-YA98{FKT0fQiuiT$h-Yg@O7;ovHEq;nu}D +%3v{d4f5_JGkYhe(c&yN4kDtC{-o2yiKgS7_FUIFK&~KoY15@?4cF)sZ!`Q-PuSwokK%a0RElgASF$q +#e+2|@i7qHBw&Qx5dA;Ox)Mt>qlP5nSVn5&GaVGim9ueJB;9M-MlpbLW_Tas3E;GW!3Rd$T +Q9kz`x+ov+Bpdx!4cqHk)9^FSvW2_z7W;Ei5LAdo;p@b$-?XjVjIL}soUyY4wPYGs57I!BJ%G_z^bp8 +3PiF8n^(HeKr?&v->wHuhA{Owoe65Uj{R6rkRPbqYI3IPrPs}SF^XAOwf!27o6bl37FnUI?r$O5!T@Zzw7YDr2mk92I$>xUKrE- +9{es32=J86`MZZ+G`tI5S@=9J0I0%%f38pzH=%%Dbt3X7QFuPD!gHlpu~I>JTOpbPULw_Q0I0VAW>!{ +nmm6hu&-TI)fHx8RJR%8UVzKW{;14GNTZdGE0WY_R@t^>2W;LJOCyU@946sjU;OiZ@*aY_rmDPv3`%ZV?4T5pDUm1 +HSH$zyq2{+*Qx`RHZ*J1Z0Nwlw|j%2X5<-B%*aT>e?bN%#w8#KNJ5T89^YGR4B%J(>HqRS)#O#-D{o>fW +tRlv-LG67`VvgPoa@e@GMpi_j6NErTw*r>g_&Qye-+s}$O<$K#!1XhC`E`enaEFT2|$i6wP!L#@flYU +ys5+08g#EgyNVw16(vZI`R{QB$k?wN}i<7aWC{iA7;R1zZi|AlPD(f91?iEmSGUj!5US`jnYj+q0bSi}pRZPgw0 +v&JE6HjG4@TBIoWW`OME?n3Vy6T}7pcZe~O%$y2cdZ;g=^?@#g>^=s2<$ +BKtFg$(74lb(;a4KVaOCR4J}oR|MxA<8SV$t=>?7U!xo6wLGTF$cdH|1%OXG)y5(?SC3?QuezJ6 +HrUXIm*usuU9Ioe3V&m`v>4dTd1xqp&due*>};9cCn*sN$nBPhQM012t}l_rp}u>uP)XTtudYtoeK-K +b-r7<-yt607bJPkZ-9*-NHwmn +GsR1MLn^jVfqvjBQ+~HnnVTS4j<~(UzCZvMUs8)1>Pp@4Lzm9|ESQ&&yy@$3QD5WY;Ura=nYxShBml= +@O`o#~CKzhB9im&{0hmQ`7O7j?I%235?1P@wkrVB@ +bKqpu@nTHiNdHorTyeFHB3mEPxV;=GS4EmJv6*9FWz2K6KaZneuEE!K;G~thb(Kal^4i9WaTl%toSUv +2P2%n+KjF50yvV(~hKwG=Op2P6lS!bcHJVmc3cBWl!Dl*}Guu%;Ew)|izr#*t0H~t>G5aIFpvK*Mn&> +l$Jvu6Db}tW;ZaFT~OE|)_R%rK%8%@GHRtYDeD!$qIeP4Q|w{kKsFv!;x=64qus234Oax&s~g?Ex{@NMUU@ij>HX@P8h_Bt>4Fr?(p>Txi +C3Jtsk8C8BSL%kBwS6c^NpiRRzJGSBQ6Z7U{isyScszDn%-$gmMWOHNWNNL^xKXwS}|}%Y-lMh9joiLM)d&&LMeCYZ>lE4w=`cgJL&0M@VcW%#Cu95W9h+iOxZsqbcRN`6bZ9IoM(& +8|=4;KAAjeHt#+*b_MnKWlUfUU4n#Mdj4#ZI3c^#iW$chnNfAQeJT|85~Fiqb&-8M(Bv354%xLQc;j+ +pO7r$uzsv%Gvrx3k@-BN5$E6x{@Ma4MqXFp=~Qy`z+{6e#(srs3kC`4UpcJSj@c_V74k!otymnmXikY +E^kgkNTrNT{YpEhV_G}j_fofWL%4f6SmLzb5$J;U$?2JR75=IOpq%tJzB!|ttZX;N+2cutc2G2*l^m3*Z;x;;-qkuxUC__5gTS8BQiQ +Dl2yo0td5X8FU~ZQTx0WQ^XglNh@OatF?$0|#Ft$ydS1IN3!62r$!=`aKF^Y!=^6-z+s*3dWDLtNZyu +O_oetg11P=)Nm9r$)s0PNR +>8k}oE-n7Z>mQp?-6BoE?l!{4gO#~L?#M7zOTmJ>jq*z>lmI36L(jn;4Mv%^Jn?iP!yayBsLt|Un{-6 +fW}?7a>C;P_veK~1P&5l<-poZKT{!bXLlsiC2%KKSPd#TmxtWIm<>o(Jzs;toYq3hyHJ +y*rYM{4y8FNWgtf3sHUdP^)lgyx7PSJ?!)chlk#EG*E=OCoS +HYaeosfJe4c}I2jffFIx;N+%YTbWuR&0?ed_7kqU=%bW)yYwYlJ=WtaP`MpCRHF=o*nAJZMm76@Hzr+ +BxE_ts-iv|T%7{&?TY7aG^fCw^NsSR5X~67bk>3UiYpi;a#C%Yl^X#vsmmyT+Mmx4rW^_rTh-WnQq>^ +R0&`dAjxluM1l)_-EFPuH^2kkpZi6zI}Z(<)t+;4zaidx=LZyvbd%D<+$bc@j1Q-Vtm?lMo2NpnN`oDe~xyEaC1t%XRd +wVB(Y^B@{K;T`yyvj?*T-)M6VQb+YJ(g%>E! +B0p?3fd-kkP*It-{U{u}QSF+>tSQLi`a!EqxOP&$F3uSo=_P^|2MuHM6fww#VsC9krbaHd<$ +>83**Y&2e%V!4cf?gHXYB)_;bEzVYi^AE#}+yAwf#jWwe<@)bS*2C2AdoN@t5OKe}rGFt76?yD)yXAl9@HdqE7dw8 +*B!A!W5`)QI0CDLE;zIx6;xZUKB$Ju+l|a%LnnS +@%YA)Y`(&PyYQ2rQ&%;tWZFjJgDt{6BBoi)zEJ;WpoXQHzTXGFr(bwWTSjLp$afOw(mCk`Psior@PZW +f~;BbZzU$eV_V?Y}MB_2;%^>t9T=Z^|!tNwB^ws%ux0VLyoAZBgC1s3$onTD(e(-{aatjeRoc)>|Hf` +q=sy632QZ^{EdQ2%0ZjvYfXLn8vVmjKPqs5&WZGBqKg=L;TbCxAsr(4EgESe!8=-Y7od@$U#iql3JoT +{$!pZ>(Q@Z-7e6ELipMl6*dKUSo<-w6Gw%5($>|hwx +4L-JF%tBr~6y#hH1)7@I<>S7naeVn4yxs@aQQe6I-q-TT#w$hMYG%W|sy(@f|xpyVAj%4j@)#K1j&0@+f(cZAUadDv#VOZ>4xn2{FayYP;)}$ +N8_x(d9ZS;;}7u#A7o^IU-1@&y5^>xEWdU`f_`DtEuk?tb8Ep1rmHsbj$-g^<#KIn_(93)aZ9>?IM5> +sGl?J=Zp!g_%PeuC4TlP6{4E_(IQ^oYIBE5lf2Y~MKJ=!tIVfob&YwB(6ecg$H%+s$d+VlbEjiz9d}Fe5L@&#)Ak`CEIU&B}=Hj3h +z*mYK{`Ulwg;@5nm@F08Msw&Ftaz(GHL2xLg|Q*dIOs*+kREc|&)2xI)vUhIj$W*O#*Cydh>eJ%QVe% +S`>$CsL)^Z6;wZ~PoSX&j*f&R6Y?!3VbixCGYQ9f2!$!NHu2^0l4Vhq4^xFGU}8{;)s!>G>59`3RU%)rv4@JD3yb-J~j(r9w~cw#+^(OV4nsZ{J9i#sbb9YQ#@=QPmWPIb# +Tt@v1X{W?f@`9#squ)Z`3ne2F>Tv#VhowVDdwA4cMliqeGTs|R>?TxuuYY&YhDskFYl-OOrU5QWfgzc +!ZX_+P=)zy>1j)%e%=!4Ruc0q$#agt8g;~ily!5EjBG+cHQA)K0C-(6GJz6lCnBwnUo^6jG0`O_|F&S +csgan^X#e3&429Qi@?!G0^O6$?w-U&X7hInLoU{3+jp{LF_HqN&NL)kX6>v`g{uacRn6V080Ba6ylr_ +783WakBA)Y!xZ8icb}B!<;ra|d+D#9_J(c1ik?0gQ=;|75+Nj6OJXrS +r2%SBYwKCNXO0%uId4y=sd}u)=h(;CW>jxvM((7wOebR2UUrOr5rl_?tjrrpq382C<My;xLxS5>s&zJu`iu +ym&?DmJ5f&W&~CC%O)0l3D0_xG=+;om&RyV>}w<3EMpQTRXXTc3nRVKoX^_5qqtGAKQaCa{_$iD4OMH +q#2wS%5#{{*`<$9RU`1Y;GGs%!E>~&?hq)m5ZT+1Fis03H=2MIuXF0;Kx)~v#Ynl$`V^!M8Tcj%K`-+dC9*Gs? +rUhmHPVn?=!BmL@23G9gH6814TSVcIOf>0Iw8PAM0?{4gaL4RX&J~1a%R!1Zih4WnRS$p88-UU8&hP1 +c$Ake$ekUSbr0_=%4nbIsY^fVoLL<}c@Mg}vcV`Qw{FBCA!Fl=&A`M1!#H(&MRMUf9zed;Iv{FW_HJr +fQ56{;z7!Ok}Hq2Ar|7}s_cm%l>x$ae)NKXFWJbB($7iY}tSt<_ck=%x!IKOeq6P;`ekfw~Ege(xQ{c +$uArof~ciId=ddgOp?6lq|`QD)lM~t+E)|5%k +#iOkFz`tMv%+5~>3f_;-`cQ&AHR3x(n8yglx#*m?-X(6ZNZ +-zu`XT=$8%>TP-K&7o|My$5f3yJX2Fi+oLTH&qCT +`%bk;N;=%BeMsD|5B(%qRa39=xhkFlp$Sb`3BqEMcxkw-y}~DAvrDF%E{G3TxYnxJ+8>*Qc?nM*xRge86?%YAAQ*!&;Qsf+Ws#`5?@taUjl2NK +EE2K&(XMlc*L8@`|i)53pi+!LoxQ-Y%_;J%LBX;V2B{s4ugINP5cX=^UuJFL<#gq=vgA4{l3i&J|~9b +SziyhFLVO4zra($VwmEM2`Hfle6omz;XHcQ;{!Gb_-E`-ZEk>f#<9@8LhfJ!?N**c)uxnyu|QxglL&f +7P&to;TcE0I4t+LY%z$A7mJb-Vl!Zcouq$&8DTTl>#8_z2v%hth?h +eX1mn%r8J=uQPzxVcJa-?3cJ&5=hQy6Oeb<)MzmjU@9~x=FQ*8yWm|EGP&R<5g`inQXHOFLU#IL(GZy)$Q})-4{Ur+wd~+GGFx>!C^ +)`EWHZMbgje=)KV=gDQ27t_PFsYv=b`_*agXrz0>o`Dg#v~JnfBGg(`K6gotXRTxiLc^l((snDM9tND +=jmTp{D6GQX)4b%4*<^5$Gg$IW-ec@#Er{(*Q50v3{Zb{`U^P$1qM~%2kF>p-pRciQiEo5G +$En=~gP1vZV4B@h;9UA2-b1`mn4YOma=^lbuZu))Nmyz1l$|a#lv@QmZO1C3=kG2P7a9n?l!%^t+yl2;yfAo>;l1g+uOB_;iYSOdFxfdOxCy^tWEKP`N +9syHFw_mKB;%csnts)3ZxM;CvsKhkD+Ecgu9xXUBR4Ve~P!LyssJ5v`2Hf10L&*6(8K4jeGkb)8tMTJ +q|6ov%O$-zjG!sF&Y#(xh5}@6IWZNndO*8Z_qL}+D?*&ps69B8|H2Y8G9(A>_@+#dVB{nv6 +i48wolyX@A_S+S(4zj&(uV<&yHSd`_<$;2V4Zxy4j}h*| +hBtFn<|oJ4o9QE-V|%*mR-WUDz@t3aL`>*611$LJ`!am|Rb-w5$76HxCP*Kdr4QyZcJvFW&2ycS?={& +LJb5L76Ap;BGF9t^)J8$#+Dl!5OBkos>^Z-0gFh!B0uGb&(Rv`SV({W;9H}yov1% +2-0l7gjrMWKZ)!Rm1-EB8g+`{wBm0Q_+@Y97sfmBT&N!@+WPwX5;`Rr{W>0u`6jNm6a7uq|YDI=a|Z# +5AuY~T +g5{6_G0XA(T?6+B$B8Z#ye}?rKA#O++|vPUZrIcA`-gv2WmtgtrZ5#buC-Bn~Rpoqr|V(Wzu^HHr4Qr;_#jBT-Vdf&UZO~_^SllQ69kwKTcrAbY3apAqLI~nCF6;aX{4#Q@ +{b31a}jpr*;9UcLDO}7$evyFxG-EfwMoJ$Cgj&`^4{*beEbfuo-aq(Q=jyW*-8%7QW^q_6Vd*vf>es~ +Z>xd`Ix*hZx6Y{urMoV|)69yGHz9@BxujGevasbt%7gCZG4%I?eCE2cq!JAMPRt9gYFsq|Xn_B_4x{Q +aAjzYb#b$}|y6V1kt55O~{jzs_tMAiIg@UQWQuuoaadtqWt#-;d?9`6$wWeDeZ5;N;o3zg`$PabD#Ru +P=mtSJo!}2+Kf`*E&#ed%^m(R#Y^HM&gH$7|jxXLJJ6Z5EnB{__FDmM-o8Mw061O5LkF}txaEyx5W+k +x4L=Zti@SPZf!t|rLiczi{1=*k0?{tFV%4YR*r}`HEWMAd^=f(U67k6Sk;kehgg +w?pzPNK8oWBIdQB=ZH4Fdp`aSEF0O@|6I8KSt;E9EM*vn-ks*fI;?NhWMog2(*Rf??>VD}-uBRevzw4 ++=9A5VoXY_<_o<{C=Iy~i&Oz#xGl+Wq*)Tavx*C*A}>a8#Y`y3ro{U%d;?SbHiXfol726k|lT(}hP(Y +Qpt8^vL5MW0sQdDuz2D9>7%;Mz!qdr4qEsxXv0_Kt +?U0wjc(}>-Ln4~#PC0N;*Y4|{iJ`qpY(6B1A~$%j^i|g5*&_W7)w$FhH=cdQpyQrzyNfRQBagAjv?13 +VDF0l|D{td@broAh4oPqmgK>~@pJUS1 +?(cr*Ned{y?uCh%5e3_3++&8!>vE2!rE7z=QZhFR#p;vo1r(E#cG;zb;O|Uu42^Yd7p&zP$zapn^#V_ +F5~mnvlGkP7$K|Qa5i40{Wa|u3*ouK?`65`cw$LLh;c}ax>(VjvpKB?S=}m()OzIUA^UNLNy6xeJAC2 +ZvfhjrlgX=B$*YBoEy-LeQ!_;xjUKPp8-A*5P3R7ExmPDq$J$MCp6c;z+QkC6@@KSDD*KV2mB}yr@I1 +1+>+|@qt{NhBr+k-DtRRo6SW&lg8sDD_v^hn+c_ga|Rp>J+kbe1ej_KKwa(vrS2Bu#Of6uME5oz3G{K +h>h;`30%!I#{z`X~M6kInRu_W;3qH6F$wUh7Ax@=(>}{8iOr8?-Z5hHSk`KU$n2b;CB|iAM4j13#k3N +A1Ty0n$C^c{170==L18$pvh8kKnzriQu4D5KkZgP(0rN#rniIA9N)kp7@n;7~EgV7lWa^?T5e}g}-1( ++0XNixHw83W{>3>Z4MWIOOM!vIaAD?z>Y^thjOY5nBMd{t8zGwp!w;$pRpPo!!Ssd`^GHQ6J?A@;Y9D6;E&;y +$$Nljiipg;AreFBZx1sxQx%QoMQoO7zqv�@6$!&`Y%6l}1`#rM08l|*b==ufAwXs*Rr<-2=Yvx+$) +eUK3ky^~*!te7ZKVAfyx#Y+C%KuKUoMTkS*{%Dd$^ZD;2aXs25F@Z9FK>19$DaQ~)K-7+EY6Sw&N5%% +K=OK`vbg+rb1S}f+4;|1=3PGW*ExQ?+TW6YV-$M&*(~gsaxiUxb93Jw66!m#+1y!ygOCA_-W&gZ?bws +StodsmoqJ2GCy=Jal5>+{6lU-ld=_HHU@JQsgPKtBPx8;;6gUO*3m6U&20gQPUu2$h90nf%n0N_oWOG +yD2!+gUf;9?KFn6>A3u=uWwG~uy +Hg&rc1O%!jn36GWrR4eIoxR2mzGP~H_uDqx5GU^dD_o4dHXzzN`=F8{Wz`3@H@-^c%rs>1EKcG6B|kF +95u_hwB+-{R0{;?6=%>)5A}>`Wslc1cJ?E45#5UvxlR}1BVF~W3x!uRe{c>0>*NUd^ng^3K+Wu6z&(( +_V)3%^b1zW_M4I4kg^WIqQ`PGm{=hga(=1IQOJqb+_p>Fxz%`lD`l_Q{&ME8nUiYvkdCN0sL+ox99k>ar9pONdIdtWGbOju`Z#FSMQ<2HTrC4MpZt5ZDS0 +dZ;XwkH_`g0@x?olp9huPglO8rm{BN$oIt9`(Fv*2)c=ewl^a^~sKiuH{WUF+6eQrChTHU)}+^HBwSZ +;hK|}tqG>HyV!TmsaY}R{hqV~S#mtJCC}^KB?k*Lcu#2Xz+KoHa0QIJ_LBd2wfCCA2hiSwZ(#sKc~yd +xTsR}2jkqW_L2&!31c|(V_jq-QOX`u-$>YPM8R7T;8V>l>9fG7BtaFJL!D+emv25cU0wukxU{P#-NcY +Q%=!?ppSCoYevEm&4;1OWbFE7yxSq8H#E9~d#{jP|a0MCCrjm6|u!=SJLGNJ`l`Slvl1O!<)eKWkl=U +=H0D|v7x0fxuAmnynIQ8z^cBh(8+8a|*9O<0|T53v+s`nYBw?~4Y+N2>A713aR!Kl~s?AcL0)K%{O}{@L +(uN&rkz~)RyPt&jx>*c-@i!`<-e$x~sf~BXOYVTB5J{_>Zzf5eZUQQir8YS;=mU~|grn}4 +OZt)Zk^d*gx6PhL*GaR(Kv*ZLhh!dBcX_QagmB(BzyLGd|gHtP@p)lP!p@^t}Ah*DWza7%&^1@4F8k5 +Y~D9)*KC{QGmEVk0SnsK@3^H|Z3Jzwrux5b`7rGAkHk1iOUiu|nmDT7jXgjF{{i6gAG^pmu;qtq{VixoC}`Q47&7h9nQuVmGsPi=DnrcNj +e?y;kswL?`)CO9qHq~Q;6tIX;|2H#Fbp%NK3E3A6?Vo%84A-Q2?6D_VQ;CQG%sP>iv%*vF=h^DWbpRr +9M&Fz)6sJ!6u>0OEc%pYP~j3_n>>SkF*t0Fp0^kjk!b}R32*4p8V*$uX{}!}7XV8NG9cbbHkAfD +k5|VGA-oz(RWsSd__nV_neo-GAmPt`fVIwqqT(KK9S;qwKS6S6J(F(-+?3iXuk2(41&hh`T)@x^ +%JMb2`@V@=KUT7YeL{+hOUaH8CmCre0}{Xl?T6egPKM>mg;99b)Ndm0a)GZdwNmCL@;WTBaOdU3dq&d +9vGhBpbr73*6PL=cB}IV`EvwGJb6L}>(d?OOSe9K +>KB_21VePLYr;aF157m?}t>qb6J4q$UXS^3L62VUf=KW9*+ixlOZP7a8Z#M=XnTGxduwfVJO{h+k{6Z +ZtX&MzvOvSpnNQ4v)9^Gy6J{IM=x;xT(c1n)s0=bzCHHA4nV`R+Xs;+F^tFC#O{WyLGv2tkS^6hU$q! +7UoHJnV+g{7o3Zd5_ +F#u-U$Kcm56yH4nwu#j_CfZA}GTuiE;6R-?25lUX%$N1OHlXgMa4AX#D!m&JX1U-=kD9+RivoOkiY5i +HYw7Wrcm>@k(Fd(x4?T6?Y=HLt{dzp~}5>+y7n@IkZk+wG!B)a7EEY(v^s_lGb|Lq6j6(T@F{*o&F1g9Y8Kxcv`>Jl7u%CKKM;Lh2NqnP^kF@Zfkq|cxMacU2B6tL`!f)@DCM^>-Upswgt;qD2(x9aw8dN@Bmo8M9sSNDd*^adv-+12t +zd>bEQRk~&y?~Xc0S&B*tnJQwB^}g^-?G1(9-9(JzErnejWkV#ndB$p)*=7CIOnEphuEzQFFu5U5!pr +`^$!>`dxt)+3u4fslG8UG%y)ENf7rd?E^ljyxL`EQmopXvid3ky~?MztgFU?L|_VsX0Y8LSeX?cyxAl +*IijYN7|3&(|(-$-pyShwv{kFZ5ubE(Tf9n9%Q?o7I)%V~+mctCFgWZNE@{yMIf3|~2feWIR*+FIA0k +mr1;aEo@#_^M~zO%oPR9QeT(lUXe?dxu*FE_Wqjiuc%f=$c9`j$&ieWVi0C3EyIgN_kh)qLT<+v}MV( +hk9LX4dR2E_+^4>;%)a$@P$`ktmyktk@X4VAfE`fnkEMPCjev$V4G`4B7eq|y_<%%`&>DDxv&o{tOP= +lPm^UY9A}b~4B$H66?;5HH>DuNs(pl&P%&W?F3~<>B|XAzDVTH!nA1w=KhY5C04ZJzpvYZQo)z#YP)+ +f=s9uf1!2~8;fF~KiXYlvFN{AMVRq!rovRp(8lstP@@J_;mQG_+uWj??)2OCyAeRo&0fOzQlH3AQe6> +ds!@3QgrHoMplcp`Asqo#&csGRTcBB4@Uq5~XC1!a=Dz^}la83jB+9pmXS1mgkE;|OlG{xu}G2o6mFK +0n@u1cnI_7#$wW7Jf!v#%L6=?_E;Gn}-4)TviI;1nn`YSJUe=IVQOLx*xoQX9I@#Kr}@zKEB^@k@!f^ +*OcQUuAgAhX^-G*J8CoKOqkxhFl26;s>}~)maW*}Hh|zp5#Uu1Ytq2idjVhX4Lr1F?p3d>=#N7I5Z&b +Af$@9?b5oci1TQ#vNKl5og%VF-NV?+*JGZh0r?QUPY8H`ip&mS(NH75XOOE}ka+UH`xe9DkO)RL}Dj= +)^Nfq|xzz^TGg$WM0RUF>MtBO3F55JW4!PwLJZtV_7BN-HV3@g +b6bY&%Br9jrf%$I6T7(1@ppi%ZKruucvci`o~LHD-<0aWAG>xJFp9uTy_(G>= +Z+HO97{;z8M3wPtJ$RxH$;GaSOE#FlaN&k0a(K+>J6tbd2B!haYf|L3mu6(9>>k4pwF^6Oe(Au@(i-) +eJmkW>`CK*?y%_hB%EM{`hRf}0!N5Ob~(VCDFG5;e;})Jwj!%cJJwSjbt1tzik6Bur_T@XY4^cSH_Db +YKSt`&X3z)b?(^Iuk>5i^uR6nERY5)8H^_?t7ceCBbYuUx0;qOgw{<7U0w{+L*%T@?c!aETcrtNm%d; +RI9-MRx*7*!FD(M_t4*;3Dee0daA!jJnUEQ6Oo-4ekUXfi?WUZvoOG(a9Nf%D1t@+c?uw-B?Rr|K{lqJL5!#WepA<4<-8Y#lly)~V6dCVy7 +vXI1!XVk3F;)+Ez3w+-!vG|}`(IDsRZC&B@?N-`C&N}Ozx4e}Hq+BmFo;>I6PLp?Cp^A%`>P9e8j+Sm +8opreLH^s&)ujcWFT@+^%Z&(Q?rUI9_!1UF=C~ODb6o82AS3b}X8a +wU21)putOIi|72Y`s+Nv9lU +h^YKw(E}?(dt<M1M-bzT&Xy{~jD>4My>f!} +i$x&w^kN)hMOka3{|H3sgojJ^JUrqBDkm3@_wVDrDPP>eRR!fvN%L(bj$bV#a(nkpmR0V=VzM8?&CcP99)nLO?N +i8bUpY8m;q-?H`1I&U**HL0Ee+dQLN*?3e~-Z_K?r9z3+)t0t9z8|LJd%wHNtH_K~8{P5WG_z6<7siv +o1x(X)~M^yJS)uophe*m>F)7QiJ4m>9s$a+9_)=@@@rVD$ooN(sQ}cI|a<7$ov_2=clR03BfY-mwUHn +Ysd=V0B8aG1auJGyoiv8k65jaz=WbuQVHG_^7Xc6pyGSC5L_KXCGcWZ;fT$zZcM-v +0cf=s@X)tgco6`j02F{A&40GZOEj^4fl1&5H3xNRzMZvRj#j9{d0~VtWfEeK#z|M&K?_*eh#v?B<3Si +P>NSq5K!o4v9AEdFRBGB(iF;qu^)!Xi7nAC8DVp^2sq|?02%q2Ro|Uch1<4O_*PHd)LGUIOb6%S@(x_Ngy +hMn}_g>Y#%gNZI!}?9%b+iM-g=ZE8^|g^iVZj5Gs*Zf~2!1|*l@ii}-2h +(|p751CXFUxE02?QHBBsQnFYGyYm^Vu9WKJ>#O9KDN@Q}Y6-#-~1@>k>gC&NQNj_)_B{sLW~xmCQU5r +WN(cAw!}zHeD3++M}uuGv^(o9yv$AW!Lz%JQ4N?&+vkX{G>Xx2&;82+ZH@5QsZu9pZ|@)rk}y`}D{+{ +?@KKm0Qrm(DaZ#N+OB+ix8c{Ug +>RMorTNYo*ld>rG*V^r5BBJOsnq4#!xyq`s(=9vC9$MRs#IbvcJ^FdBpO+i +Qv$CjNJN}u3;m(c_eZMwMaU8k2NadPv$|LFG-G0~JwbL>6Xeq|7b>eO1o$u3463B~eT +SU95u@WEHl*OKBoMZw9@aG9He#me{s%@`J=`-D&PZW;Q?p01mp0T7Urqt&q~J~f=zhF)S9oFB$=}lAk +r&-!+1px%px`;PKTecb3vrXSW`%DkePvuQQa?K_e;?3uyryo+a(yJj>F`u@-bNmAs*z6#mr{0#b~S#j +{PTX(h&Tt#=h2I|6zb=0elQnp?i_->dFyhFRs=x~ie`NF$TcK|{KU3XAv(m8(9f5xUi$lt8Xsp>mpk- +!+2#rLFv5#N-I%@FN`q+I)Ir?doOBZ*n$4N@p-#z!y|*T5fLL`u(dQFysu#qvZt`(kjcwT)8>HMyoQ=sv1V_Ou5}t!0r`%!z?zA= +?EbJ3FV-iKjSRY_@0`eT*$hkN+tx{-tzZY5tI+G#&p?Zq2>@|DXk)Lm=#>|Ndvr_-5z-e +8}JTrW_u27DwH3hVSzsE^2@-F +3_A19=e}}T_OI+Gt)OHs=z|U9@VSbAR$>SEf+nG85P$)Y6-GnZUM&0H+`Y+?qiCBoxaTTz*=@2eF%N0 +h3q~q#lGYAk!Vi3BPwys;~+V}4N{`+cP+&$7G(&LNFud3SGIxW*vfdhI)AkH(K=N!=QB36-Je3i +ouFG);e42C04`p3BXT*yoMAp!%qYIVU_Dw())26nvpZ@Q3J5> ++B?}g_c}nUCR4Pg +wB3Z>RNM16)%GPJMmC+l6Pv=@jJ^+-JMvB?+l@1xpRXksEnhCS%l&IgQRiMIeV&C5ZV&`hF`}bxzyh; +n>tpG1Lhxwi(A+|&SyLdY4``#}h@uoO>Qts~vZ688b;f^KhYi_+~Evd1{OR(eM=V`YjvPu*@PF +aM|;qi|1C(m2H*+u|`;}d7e+RSi4*xdSXt4VBUv}b7~=XuYh@q`Ttg@(+v2}WI%&!plC37UJxSxl#P0 +|jM~4V5ULkjp{zaXc}6d`r1qrEJ7xfAe=FD5vZ%dAtNM5&S(Gnz{%*OwB^X$%-Shm|tkI?a?;uor|&L +&mShYd2m|tM~wvs{J1~#aX{;()!F&_3-iyuFVJ84!u+%E3-r|&X1S@@uS5WUj=zGc)0D0qI++$9VZq_ +^J|Wo`S6Fey;Q=$1&EeRdH$lpZ9?=nM;2Q@Tt~_&w_It{Zm%v3nAKOll(ez=RkZn{OZZ5Qs*FNZnljZ +M`5%yJ8_uV|#dIhVyOH`sxOdTM{XkW@Ek4x>Al&~~Nk18jECVe?$7$1^NV+Xk;9qSuPyoxl8lryYFin +6~QF1&DPkC5EV9)-u|lVysM#D;tx+>Juog{%9c8 +8;xiBuNzUitQzv^N}mn +^;sN2jwPk>Q-RTGuz???n-%%Qf=q`AfW&m%22t5W6aRFXnN`e7mcZz}hcR|O9__;nWpu7-Z03KMuVqn +H>$=4|oYzaxwlnEIiu|ubz_p#*LDZct|t?sd52rzj`vtxAqL=J}U$k2lk^0W7>6v?Usv=}1vIiAtFj^}UK2J}ilu&sl>JLuhYL=lv~ni5Ztc~OWZCw?suj +J~DBzzgNmw#(N`|5!QnuP*)L80haV{l}TH@BOvDpBcl9$7MtMyM|M|Uf`q(qY0Cub77~%+cq4jgBE5G +ZR`uQcY>(wo$BzYI)M~vm1_OXt5#tL(X?QjGE}aOf^tWU@%m^b_H3jVG>G@WxNx&P+T!V0pNAgHHp%% +}-Oj3Ioya+oX^cK24mVxM&19AL?LB>TRFY=5+?HF$A>zOwg2b(qkRmm7W%0*35fjv4LgFuo%%6>GPiZAv)%if +Tgh&sSA$Q}}A#SqSlP$F$89Bl_%+ZaoHzc=AG0DGSHPCb@Iw1xNaBEVruIvb+1+%$O`0ip>A$ueJ55% +zE{3R*Y8UhOZcT3cPS@6yn8mRsOD+tL(G|rse#7f9T5tNa@k-+9?$N92BY!d-=vnl1z9(Qgyj$+{c;c +PD^^*Mh)|b&;$tGKL9}@nDI|+qlcpbvxGm65um>s&;AUap`VS7v#ggK@G^npDs;o$Bg_sjFS$i*5Qh$ +ucCBBjT0dftPATcjNYdrWEfnO=r{D@XT;tu*Ey@umf`RR>ht2%LY^jmy`n0*~#^Lm2QDrwK1Svr2eJG +#X6D;A>Sv(2wmY;5p;!w|GZkiCt)b_PkX?AAPx!gV+_aj1p751gkni8%fZORxp> +dcJM`Ng?~&E_$E*+c)dU^f#f*%l^9(c>0@N=GO&?{%jia-}5G)q5Ge`!FPr8uV5TSR~Phb9So0wR_&6 +4E&#ZoI=Ox4`9)VI1Wtk67XBG=G^T +)L-h$OYX%7Wj`Y^TX{F6XZ2SZk@X4br%27H7F1?6~#29d+^t_y|(7|%djk04+Keu)Aw5>(V-=Jz!G6^ +zR>n5~L-f57;cey+dsv7oO$*WdYA&{v=9YyAJ(Y99K+ +Yo063hdS<_yG$;#+8+>u5azhiy~zod(^%b+cr87> +D8J7FpR>NT6#@{n3?$=(X$_~K&o<(UwVd!e?E(7c{wHtAuB_cv7Jx7~rU%K0L5A~j~S*2|x^l-O&^l%n&-z*{dHHzbnbKKH>oQ_xQb +{n-3iE><>NQHbPFk6#(h6`O>c+W@=+edf;FEPb-O! +kY36V@qfTzks@Xuhs_05u^Bk+SA5G;?$J-GZJ3^_-?Qre8jV#EUYm1>~Zo=2|!QF0-{bp~$JvL4ak3r +|xJ=xxFF>Ts9XMeTClJTJTc?#8FftoB89iziVNru|E7ggGrY9E6hQu$_ac-g-I~)P +8@1nFmSVpHYIcBVQxs5EjMp7LU=zz@G_!dN>$07zt{qM8f7!IJS=><2NI&&-07obv$HmG7?O;IIV1ECK% +H5)$8)<9IG~jzE4^J1u##Vewu;1!(XPG#dN&|%Kp*UlZ{&?PO{(Q2$02_ED4>1xCQN{R9865--5dEF` +jUMvTj`!tn0r;HFi3lz_w~HGWtlWVd{#T{ipD0Z(QM%O3XNcJahI#Ohg-bB}@Cro{UlJE8>&la4 +6XHCjIYm2IVzG6^!HuTHeZ$_K7XiFPYW~*pLR`k@*wGwYkr-f!6PBr+;2vXMCgu!Z+0VWbmfGjcw4}ZP;vKkuT}J2G|jW+9GhSKQ~y<&&oe%@rkM# +sXeEU;T6Miw?87s{f$BETxd?gg6H%3ygZ2vo3R)r +rQkSg2JCtkVC6Clo5OU2=JCd#Zo+tnd$-z*T%WOJNlvg+1|_HMWL<3tcQHy?)hsIorkLPGYXv=%oGl#8IpN_Z2*xg=?lE +*oV(Q$ika|Hj(6~|pWruS=;UO&vX{z^UZuOIZy)hjHg@cP@%`o2hrqcDoW6ima^@`FNggkTs3L2#HLN +CKr`lBB7xD~S{kbHH&>ume>^Vr3h{pjx*i5exx1&OodI2Z22PwbNIIgA`?n^`mU{23zZp3=Vo|%bBQE +{t{oChvfPzdYvM};oqa5$yQOT*f+|o%;^l|8N}M!Th^9|#!;g(SDSjFPJG|Fu3>8ksqyaN3NF81OFlzdEwnIPd!< +EWU`f$pdd2$ZSlYwV}+SbGVWwckXO}E+JLmF*KC3a$7oGA4*6L5r<2a_g4KXb$w?YIXg%XI4EH*=zW3 +sTZUs0xgtZHG+1?M}oz#TB#L?xvl5BCh*xd(ssDjBUvVdtUb^2aYgNtgy|kINL6AgYskI(e0h!dI5`h +b$J9O+~8>VBjcYFF>T`m;$Xqi?H*x!tm4|mM=7_G%U;ah +p3VsT3BI30Br>Cd+ig)W}8>22IxxUFfQN$e0)^cImCW=9>dVu-d954pQrK(lCHZ))2gu +5NhM({PNVfOFt3wb9s1Z}R3|ImCB*DGvJ^8O8&08#O(h+Tw#Z6oN|oyABrgR!Mb?*M4 +hg9$)RLo!wtvq|s=HJAZQbFV=XsBKgCHM5uO4+;rn6R)h?P1w5c731-1_L0T@lz!oidSjb%NUbWm{S& +%jpbS~%VvL#~H>rXkC +rB{L<>4@;UZp8B9W@uN1Y<4&7?2#;PFvTI!noxtz;_~G!O1Wa~>{x4ip-FF4Ugj;ix=w?J26QyLFddj?`)Se$ojol!sDw +*$vu@O@Kz8dnl#qF26WmH{7R4W^%9BE4_JxyC&o8j{ZC?o~zg*>2Af%fm*Y>QoBu2R$oHH*0L#bltJp +n~&ju>7A|k`Y>0{<%#2NbbUdO$8ly=6nAm0)6Z?6SO*{-|O&sG#cEGO}#o6A)lPMyzU<_;xbwTjR4oC +YhSBjS)Xo-Q6F!?P>|A>!b5FbfEud}LC2F>2iB78>vk;ztXJt(BY>endG^iD1S0^QDp_gCIQdRLj@Gl1D~E}We +^%#3R?2b&h|(|v_Fm4FVqkzSqCoFBT&2vHkdO#}N3m7?lLpJi*WtD0BP@#mMP3ZFo0$Xzl2if$KMeaF +CVttjbwRuKwfRMzm*=iO2n1NJ@r0BMn|}=M +q+kta=Y!!%$pCqjuLdUF$*ptqv1xI|_OY+RISiO{AucNF9MZI}Q5UW32Rmlm!|kUK{60^ZllzP4X|%@ +G5{cR2Ulv=eO43Fc&NLllJDALy9b9?PC^FNjQd!#(YNL8L;b-;#zIuy$ +baoo{d1jfttH&BP)Hf$jA9t?KFqtTmLpVd+ktd5#U}UElX5>Z{_xW^Q0{MKNGKI$QS(TnIHPtB+KVW< +%>}ZxCF<}Xl@IAVVb*Ky*+Dx6Xzu0gWMWP;h8`#*NRPhpFMC7o#+w9uD;f~wn@Y?DJvP+xlj`!kyter +T5e&kDQZ;fH=O>8sBzEzvv#-!eqYJF~w&@-6*AEBs`9&e<3*8XhE#sikY5)ZLJWRriha1+^MW$+ri8o +R#V{?NC3y%i5YAj1GT)8z=nGM4RJXt4OZ|JzE+UOnKr%OCRU5YSgQrXfG~@(q1ZY0w#>CTWNy(|D-IK +a~+@#pJbZ;Va}G1O$=OSjB4JrDE3|UNS0`7<<%VV}m*;rA#w1e2xx%inhC#1(*6ojd#eV+qB4Zg9aEL +t&NWFkCA!>ldk!aSm+b}EH&MD$$y!Kr9zywMzVZucN!Za#f7JbQkUL5tkTr(+yiHRdpXo2N{$bB#@bS1?Y({jrZ94P +)HHSnO_XsuIv`*jIODN~~<=i2gnM +S}L5#Kr=Rr!LSrCKE=U!It{cdLEo6dSM8q^AasZVK6AzZ8Wt7)PW;T@1Vunq1(3c_(5@xnmC~Jp8VZp +8fk6v7L;#CArPhw}DrvqfHHyIu*Afv#1n_EE-j$-kAk`8qEbqOcib?54BiKEUtn0(?@r)tdc%+x)T3*d4zcH;359Y(J@7YT{Hl30l8mbRA~;M)TsIMr?h^=>1ri7mZzVt!5`M#_VOD=;eT#QWlUjR`HXkn%eHJFO%(}%Pg5 +fQP`2lUYUT5UB--JA{)YMRr<{BG~TsltH-yjNt#o%%-eGBM+ +Hg?tX53UI_|L2{OHvwkQ_{5@ +^WLT!0)Fg4VR4c*dEj?hux8Tih0d#C?2P=cnL|i^|z)IlDJGfg^k?>?#Yy(QH{))rRX^|o1r4jJud5# +XHmo1X?@4E3tt=@oGiIQvgY)lw;ulFcSmFD6`FCP7D5r_P&oOo>Uszd0|g8l6yKc8NO ++yoYxoZB3Vhmmo7cZsEw*UKbwHu~U5Tsjy4wG*H~`xZDMs-C-kF22q3|8o=W5ff?y&9?1C$d)7v~A_; +#f^H!-F)q|po6QM_qFl7J2nfmoYYm<0lwY%v)*=E7hh)SNN85k#3(0zw^c4SlL+irW`2t;N2kgDHD>t +f%Kr^4;`-xLG50*n>Dz7Q@Cf{(6k!EwO^NdkyulDzPb+-YLD&#!+jHxPewp@%+f=-K%+V$EiG)^)LNP +WRSpkTYW&@b(81J!{lDLySvMLi+qGhBQ*@dM`U&%meciZ&*-LLPTSHbotQ~j$3mwhx_fIDfRTqplW8! +OyoSnzu!BS$zT5cH9m~%B{w#m3ELEgrwJR-hnGCd@?aVE4yH}+Q8P|gQ%VK71>sFEk15&H!F#gdc`wW +PMIekDnx6RAHD&#y5lLaAbcoY&aabI0xTMN?BQ$b<yP +2Y)jC`{IA-Cp+p~D9x|1S@2ExE8gmujG$sfl2X~yk*bRD~954*c~OG>P(>{`g2{OZT)QD&R1c|V(jMG +*RFJF0y>-X9iJKeo}c%!z$|*;`2Ocn|NqtXLIO(F1CwDpj*el~5^oRJWdZzCnkP(%vw<>ow0Ns2CfAjF!4 +AxF`6Cl*2HLn^dw+hpid+%fw0mG^;&Kd$@!+J}frRgVn1Ygfxl_Pj2^4QzVt$FR)%cv9tAZqJTo9gSlW`1!Q +GLjdBH+`AolfW$$w|W9z<&(Qu~cvw%ya@H%0gsk?sHZ?WY0vWZ4!k+rF5h|4*OnBRKpgC;Bc*q!0q95 +Q@QY1ceEjqDd4XDT=`v1cxaEM+unzvSvh6t3vuJ+=zyNdXF=!11aA8K-~5=H4sK1m|LREB~%2V+Zwb*Dk66{))3qW+1BJ_FZA&DWhM*FJe8h= +>!5@MG6}DE9Xa?+)A>b`Z2G|ELyI~2aA7M+(8~-Xu6#7+t?_162DD1PGu(H4!$phgD^lr;e`>*+e^^Z +X!AkVu7_l@>%tWnizB~-jkgIm=keKUyVFbK$GtO~~78|wlDfQEgXl>EaOt`|cu>DEA!=Qtp+7B_CCh_ +wg;MF>QSOQ86{2YiANC6M-hEB(C0@3&pJ`tz!xe`VR9R}K9u%l=q3DAquKak{-13V%Aw@tWmfKhcn94!M4l~4>A>y$ATR +OSD5F(+ty87V&@*&?n--t@7t-L(T>Prg*=+^8Hd~;&f9ofN5{Kj`_r=#%!e{GGAyWJdvBe*ko&!rCXL +h0Z5olCd3B|igxp(~QEvDaVo%|YDGOrO<&cnK|0(0KaOdIbcJ>|=I@cTY)@^z08RpyCijG@y=aEy9?d +0SDiZu|Z)&wuE_^K{aT;4RhK8i5kno^&fU6$~~l1Ne;8CBQwi`bun;o8l+ghnw%c)iVdf|0$Qz`xSrw}&1n4@;n8l>SS^W*eZBAbetR?I9x3UFIG(BGF=mG+B%=?*%wsQmCG^ +eh`*aj-tKkJ?j>WMW_cgU3_uRE&vSEp7dY$jIBUsizV{{fg*%aEeaHM+3<3f5^aNIrNo6)ou_q>K!Ic +={(XPt0FO#Qk%S=u?8R%}B1KmoOAL?*{hG}JaPW;U|5o5w|BdmL=1u|n37LQ< +$lHV+nt^T(69d)>_A`wce072i7wl#L(`I>hU~LkCiFaaEd!|=+6?*+`v@-UWr7p`}06R*+Zpk`aPi0^ +q30aUr%qEs)M~2G_jUc?Al?=X_PoD37alup6 +XCh5SeL-ci>)WcbY@vaR9_D~%BgMka{8w==-&AeOAjo#N-aY{*MfAjl*DY!P|!Xc(|jVh#@*UAoQ+(D +-zaL(%mmJ`4sYB>3U|cv*irQnrdW`OLO8~6lP3?_^=OfRrxX_$w;I`*zSZ6d884F?qqeV&SSf)ro_y* +^7W$^RRh^MJU^E$F9!X8+_A9ln{ZtYSwwJiuK75RuS7e;dTqb*SlN$H!OpSMkhxOBqN;so$4P?K?p*- +=Zi<@tIYiw=1EMv2Mawdj7ifDG&ZqJdI-o7Ad?{6-Zu^-hBrw`PamOEh&eUZZa;#Fkq$HB?&xr3yBr7XE`uoWM7X +aW3wNPKxaI-HDL^kIj_>D9S5`~r-Te~C4|c%5dYIq!|i7s}g2$78qew&=kn*d&Kwa=*R050y^5J&qjU +OLHI(WES9KFQd$$=z$#ObWxpIS3Jn&9>lp|9Oeq6gRf!) +pa1y5cb1}AhM9V-YJ<54`y@DwAB2v6Ly!@Xfe`yQ9dv&&&0hqZ$db;#LsqvWqrI6vc?T;|1FVi#WH^f +%G{FTl+Ifb#rbrxtmqe677z)KH45ly~qiAIL75$}HTk_UJNWmN$5d(8j0Dsu3x +VE1IGPKRg$dA$Sx}H!Wnhxkl>iBW~ +*12>*U`PS!0gTB}05g|#c{xkEioh)xO|Sk5pa%kjL^FZG4k5X!*HEiCa0=djL2zUNwK?*I{7Ld7P!ZM7mz+C?f4;BrhbMtWqI8yqV$R}cLp-wK&nM@%TF-%#wkTt5Pi +=$-?d<#KWv*KLDZoi=YA!Jbw1{P1@SW`)MP>u=fUn= +&S3xxpX3i&YrrXM|MojgWe5-*jP&$RPYf18o?aB5b%fZc#=A;&zVV+K$do?Qw8x!Me6fV)u}kuB-UxQ +%~m$!v~#KbDnc|FxBy(gW1D-&C*^XT<2q=b*^FW_ta}iH=mVHT>9J4`1HOi4#gp;cbkpjKhRfc<5N`g +s%St@zTn(!)V;QHv#Z>i5o5-A#f+C0KS@1iScCbXVHKRO^t4s5J{@KuSf_L6CAsmv2& +cRkSoF}ln=+{f;he=Jz=Dy-K0;?dl7?*7w2*NlhyOfV{?>kBKbKTE1XUuvr9;$}iCVW +TrLo7jO`vgmoq;K@47FEG93eh3t8x&?)-JJd|3<|@AA;c%ru6suUR?gf#S|`q?|HbYtq~J%;%(Hk +1oB_XzYF#J#TMjw{$Cd$hEHx<22w^S_ryAzM#~gA{;S^IEiZIeB{vDlbh12n6_(PCK;PF+M2r5HS_OgdNiK@TP+rZ?42uC0*0SVd)AGwqh&va5Ommo +sx6;^TI{kCIs|hPKyf7mJ$Qly{yhi|%Ek!+fHpyZusjlh{Bqf0StrnA3Bj)j8dP(W)nE%?|>Qf# +^zXZez%t>6o%}H3S;xYF25TJwEF`eTt55n5w|748`;@$~5{K#pmmFFLN^R2_b%|uL*?7j@^G3`EZ?y0 +W&P0%V3A#ro)Aw_(xzExKDPBob?7Bid}wBp}Mb?Y|NxGc$pb0WM8`=?3k-Rbf@YhXoEnR_HZ5&)_bi>j;{K`=ahby;qk$m2Q2u;~Zd^x`Y$!6I~=^ +R`8Vr3JZ##xooC&X~gx*rX~d$UV|;FZPbP=EGIY`B2hQi=8fpFAlmDi0DR#MGM~szIvQ>sEXOB@rSdU +qa)R8w1s4s^i)%(Qe9QWNgvB9JdxTsJrj=AuD`PvX~$9{TpxzW9>;>%YRx)*uHCuO6*C!Z~cS$!LBp!#;$Cl6IbA9^O@Vx-XA?I5`^fMz(GuX#F#s3RN8A$wa%;+)tvD +esFibeZszBc&fKDLHZ{mcSV+!;drA^!=+e!iONT}$%8A2-+VHXsX|w!<@*Rr}9nO2ArP%|~Uzy>EnHe1Pp&m=vl{i|;%`0eV&Lo~jpWCP3 +(XzW!hF)2+*CfG8#BzGWIq$BOJ{%l^c&JSn<@I^o@A_mrUS9jt-LN1j77r2)3j;CLQgkbm_DXZ37{IE +j3)h+NNgrnF?S?w>%{5p+Kf1D9tTxwZ({!PnJC@#jp9~kWzDph==-@cULQN8x*m4U`KZjeLUg#~oZwtPT27qnJy%t1SAdP?lR3NKp7f|6$0j`i4;DX1*m)Mqsz&!a)S(8{x +nAs}%!Qh}jNvvg33InxFj9%qA!&T=q{vG*Qs}Wu?Y&l?A8xS3#z}(;RI$;1?Jwrg@bV(nXPr}<^xGw> +_EpM4+Yl(K%DIwR6WE6wy?UE?M)RNHt65DKmZ5QoZvS(?VDL2E5O5IdLXmGw7_Ur(ctVb!sA61Ty#6}AEsvzlNS>1;ub6&sJ +j-(y9`oTPFY)HxFuI5`uR<0l>}2JqawD_`c2>2)*ea*Sxr_K7y1xizM*U%H8ij!Rw$@kk1%K5HmQLbz +KTyS46s6;WD2zr(`?KYE4tYH%WZ0kz4=BMA^ZZF3(l+CEenxz?rkYH=g}wJD; +QpqPX*n*wJGzorohN&|9mBkB6O4GG5r=a5D65J;YIf(W1*eiRFk8 +e&)Lu@Cu{vb4&ys-e+PimMe$qD+d;CT#wkg>L}kIJH-3$XotBRpS>K21$t+gyS(_1Q9&jo^?BR8~WtaNE78XmP@|N!H~d7C#)DGIDEgTV(vAv(S&i!QT)g +mODL)vBC|B#b%@j{|>REY_aX*JQGLKuP)+_BZ8evr)+(ngv0I$Dqvm^>e0|xOb}_Cd)*jhclKzi?4IW +rWYLfNOKm0-z8rAmtTQov5M*U8=xDO^-iaGTVC=Kf)atcI%KNrS(Ad93La2HYXAqDo?40FP;aJ{`_>Y==O|)7TQO&d$wK*b4|T4znRH2F4y=WUh*u`qC +lfMlsBEz@oymy%Zv7k1LQw}55RYR-}egy`WH^|8HxTl{Kqs4L2!&gD3qc|6r(A0`N1q$gpn{q;Uq6HB@UEFU6} +bS-HSfq`U)Sr9Mz`84_hRLsg?q1I7$bZsCmc@#;5#ViMhYw;3ZC!@$1C}Wcm;83Fkc&BvryI2k+SJBO +g1SM1?1NkHl|8h`@2U*4V2Qyl5$ur-FNsnC~C<_Ytfs1}kdWpU&JLU_JeBgrr3taeY0rqgf@)lI$jAk}MR +lSxXmzN@(x$La$o;Nl(9rHrK)2Th(kDMBNuFO6+hk_TAc+2h1(&e=&+bSrDBcf4Iu1jtiJf54L$C5k2 +9UMOFc%_!GLn{xubLVf2_sR>z?sNok8T{3`W0LgYr266JEJGQ4QS$pe?eLgsJrp;jh<{8P=g$~|ckQ& +}OZ?m)boP86$+nZ+B+9QDbJdH%ti!2>7=JHKbm`yxE5CVnUadLtP53OEZ +?$auP4wuSIg@XU@s4?fo=NENdMEZ!=n>V~&xcU9`bhXb+vI&^=M;q?Y<%x!n78sJQK_mN9xqLNg|C=5DOjB +|M-u`KmKEZ-2Wy1Uw=bknE36}8Mv~}%isR-e*xq3|M~A_^V^t$ZEvr4|KtB2(`#M+J{ +>|NK9H%rO5yv#4+4HK&iWeKmRY+u`1hWs=_C@>}GWQ`JifxMYz)8IuONC&2U!Gz3ANbJf0%C_uC!R=d +ye>$G(V0l+Xd_B%|2>=92^L(Vm^j8V`tLi#8e4FP^@y +-gG98v7VJRsHF-K<@&OQnYjL%ae1An)<#V?uR_hJ+L_?^t&Ed4WCe1yrRz{jqPVZ+fOK7eteEN1Xewr +F5&@X6KkD!ns&z%p&wn9Gu&Wu->fjTC39_qxym6h@M$iXJ`qpbMl9QP0gkI(v`ae0u&33AJ@&HDgY#q +wQ;tBE?fuUdy{Dn1affJkU6xgW79tsWz}C*4L!0CDhnMP?Z!=oR`=m8yILTX7;;=6;iu!G%q3o9b)6? +NS&Jl$34=V${i9H-Q%n*8ycSEUlgsd+VvFOqU0nUR?5ZhU_lZdA-U6%h|PyIWdlEK!NZ5&ryfi>Qd1@ +_E2RnMI&@#$W;(}#4AV;2|AW`TY;qDYQ#l~mo8maq;)U(2-sp6}38=T^V==b7muVBctSeCRzt{wz<_6 +Fqyxa^dVO{Px#rEyt*xB8mg_JmbT!f}+nc(OfGM(ij5DJu@s(Dag+hBiKn%`08N|%gyZMG0N3x0X6km +h_}O%oZZg$G!Q#~-qmzrcyQ%CA0l7^hiC;AY3XKngIzK_p0h4UtiotXQaZs6Tt@7b4cfT_hDz0gBt3N +-84r)~Q@XTEhT||og@S0mqeQYfdZakAhX><4;+fm>)a^2mg{oaF=Ri;Q{3KinUhr|zZF*wXZ#LbYxSr +sl;jW$O899|4yCVlNJY0~gydC!&Z01Q$O6mkr+Fs=fg(6brw{A-=aT1NzEGO^d9%}n7}wvLM +96yfuG(s%>+k}KNZXK|9r{JEA;XJWGvMUIyN}ei$l=q3o~u(rqXD0=76nxozQytm6*e0;x?@YU7lcAM +tF|;6`77d?(|O6fRj)VwjY2tr%RR*#ZC?q?*&jryfHLvWyyE5d3m(-5Io3!Kwsroza_HuD60?iUA6v} +61>H{Gpqthx<@!PQs8gG2>Mc_rqb@Rb4&bF83n8)XyiUwLPspB)Zy{on{ +D5wP1^;BrFu_{+7}*8-C@%)ijyV#ir-&l&aitv9`~SLoZiCy}{IRQxtg2zuL^UMXDGNTb=eb8?tssK~ +3+ehmzTxsr$Q$$^ZR>7mFC;(`wR|FtRaeANDIRTx4 +mXP304i??yj10;QI(F4$Ms3;H`3?5pbq{hbT;)%Ak@&ISAGdO<(CV1HHB1!9kUXI?3xI+@1wYy#f6$e +!FEq;{@fRmI7evA@eFryFmn&I>83F2P4Hb#R$cw`-a~Dx%c*qfbz?6i!^ily{FmO!j^Oq{$AGs(<2xK +lAZPb`ST>4mny5+^CxJ-1zlbObW=tuFNFK&*^-!$&#k{unCmWLl7Cf}>R#>^Y +pv-36?jo3NROmRO`SETir7O8wOh>Uki>`)o;&T%)Jb?yEpB#u=Kj-tdL(b6!OL62(5cXNw;)k6NsdD# +dp79|{8K+UjJHc)?o?pqSKKOOE1ZasB6w|H4=^6F7CR5AZ^C>mvqmqzGLptcyO)P&<(Cv$w+9Ms_Ifv +;Q_VA(Va(r>z=h+{QbIvAZ?zs#*zX;lfq#KEr_V%tiH)RPt58v^mkA}ca0sAvoOi-ABzN9qEYF^(n6* +KeBFZYs9X)oQ6sM3u6?X~Z%=zphWP +P(Gpcu0RH{Q#ZvNsRjcsnKJ6l;QAWYW^w!0%=O~s8<5AXHRJTw2d_i|o+sn`(iRxwFF|VMQA1M2 +JWUOZG=>v1Du#!LS_1z=i-*i&URMtE{#c*d(cflM3YI+P?-G*lD%w)kOkmFpEJ(8}qy1B^7^SQlQo07 +4vLq(kK(UlXGzp1MN>iNIzT3|87{`SB9wnIPkP}X0tyRY<9{=zZe>7@K=|L<@a!xtsjo0RXj9j&TBn0od9iU +{>xiN`XO|ub~=@%_e|3oH78R7tn=6kh5bc;1w_HNmq_EOn}t_lgSXUrqd9#0)Ukjy}D}QpoainBfwN6 +UWMBhAZLE5lO_$I5lwz;M60acv$A+V{Ax3O75*FI>053It;O`pRDPI&c~cfaKph>=kEi%4zt23Z<1O# +{Ccq;Cib_t7(A5`;Q}_iKUdkWitAc_ULjE!Y19`Wz_AJ$adL>DrT>D?UH|zE`i>)OKuzQSzhjE;ix^Y0sD~7Hg)c`>~%ZlM@{3!*OiWgg0}_Ypc#mLd +imD}x}_nC)a{X@c}=`{&4sSTO>_xazINzL?s2=`QBS5hJ+?vi(#Iexg;r|>24;dwKciP-1EuMeQxt-) +c@{x^(>(64B8sSYdc?bYeB6df9J20I>W^we94jn5^{-9dpU&DYcpWzxM5YG4qlcMwtZjJTau2(&h8#u +O(D9x-KD?vblhzeZZE+`&-IXT0IU}(;`#HI()2j#-ElVelXSv(V1y+gM^o%vWn(B|;_Th+v^lGjK`cQ +A>u6_>JwBfH8tIui4zvaR7(sIaXuZLz~Iw;+xg%?vtuis6@>;F23yi)X<32|cb +2A?_(RR7V9EJ_k%y^#{`KCv;==SpA-dB`;I-0(55!jJd!{a8%u;XbUnHMCC|>7c3>Qj2|9_aeJhiL82%>c!ZfphPB^x}a$+Jiv!!a;TTf-mZPvpj+a0z>>(@MEU$ +`&S{j@e450Gs->B73M`9wohJjTR0b{+YJX+AY7BHaOwXbV9M%v22OF4 +w%3ltF24T0WKBrrp&`+*jvZ29Hv(xR08TgPV&eT8>^}2Y_=djS~#U3J#oL^$UM`BX~e{;c*Ai^Bu+b} +?y!ogc5#$e1*2ED6Sq7^hB}?+Q)na!0a=K#9bc{&G>`uLoTV|ntb&UMh9DHdFa-H!VtfIE`Y +w?Ez<_$|tOPHBE?o`^#0V1f@dOpvG^l1qzUFL9x@yf5fQ&6i6a~-?$x=|{4Ae>rz}6THgm)4Oq$J`n; +D$&JQq;fZY|AlZ2EsYX+D&btZ6J8VfXoZf)?jT;x{xu90_plVxmJ_GfWm=v`f{xxFM&q}UIR%*4hFH% +$Awca{4M`IXB$Au1{uC{Hr1O3Uq@U@hwon|!#kf8`yr4FZ^PA(Avy%~hW>FAGkVuu +d$xfe`(nqlu`=&)VtFYOu#a=&e8zJYX1_J+fG|&&E?yJ%KhPOeVHRq6NfW&bVHU>zV;qqk=7txUL+wm;yCV|wIR$!hdBGH?Gt{kzSJ7UYax-!To&n=1Q@F +X9b@FY^{4T?O#34~KEN*tn9CuH+K37zPk#I%cMy9K$Oo2$&+fnFcIx-&n7+OC&Ji1sv +p=ZD63)Fua^2K0c;n@`FYmW3gnn*ippS;{nARUYN0Tr4d>ivsPy`-N6>8#+1z`t&=Y4`XmIPC3|Q%H| +5+mtw7*+hK0NAfV&u}q%vyJ~Ksj8+5-uC7%@A6u$6uEIe$a!=ttlbc=(de*yYtWt?+*1@gQ-hz%uPk2 +N~v3wT!QG<*NSKWy{ySqgZPavDx?_Q$VZ#Q`$>r?Aq7AmJ*UsNs3t#F$Zj+th^l*X8+)lKRskm7N7$G +Y?;9=eH~(A8XTiuwG65n)uek0R2Oz8@}~UCODf=r1O6VE5j1ljJ^K*(;&il%97EJ90R!Dt((}MPs151 +LjO>nVXW+UDA2Hsy>fXH3qV79}PwG%e*UIDS1$5_aG%QnB3KV%o#| +P~2l#(y01?U6CXG!P_7}-2NNh21%q~j)lWL>OQsTht#ETHug1nY^uNUwy*Yu-go{7-X{DLZ-d^%fB)y +a4PuqOTor5wpWr>N`6J%4ef@U3WcLtjHTZ~N1iy8>$;%eOeAo9_4XK(QUqe5;kQCau|wcHDGgehoDD%aT_Yn7>rqMs +`9wpB(=1OQvuVa~I~C`%A5cExKRhZw*I^wAakA%F65))!Da&|h-_Q_2Qspc)4?K6!!(s#?@zuTV3x*P +o_}Om#W-g4183GZ>`CC9Ah+ckODT{)er`9L?gLXX2i9%I#=;gKp+V4 +ztmORT;A4$F8pAoDkLtfYi=Q&Q&h9k#5(!?!f8T~#k@Ybs7Nk5r%8c#KyAsVX%VAl?T +r1^B;x)i*^(8LwFQqB><%u8bwKhKo%m!kQj#I7=qC-iDM)~Bg>o1@2|+;!jRCFJiTeb!8Gu<0aCT*tmN=FM!0M +#$p55YH#Wf5Qc45?iL}Vt$u_0ehVLkdjTLJFBmx5_mXm;zG3yl;7RdZcZ)bTsC)Q&~;0r|1wKy{c1eC +;ANjd~10n-^MuUtmH5WZ!%k_I|^1p~&hP*I>*kOFFmFknD=u`2Vx3$6TZ3Qh@PYwbsD&6amBBpHzYar +DUueGTYv6E9!q>qcMY>;BOF)j@;dy=LQEGxy2hKd9FQ`n<#E+Qi>9?)#9~fs8u)L1V|PLD(yL8M9BAU +XvJ7_4iy|CmN-1xjc|KB1#-G@5L=ZW9JD}?ey_osNnedeR~o +9oa8hqmV_yY?8mDX&VTdXiIV-pud##YHeI8mgtzOea9GEKM7A$o}z3oEbWcC?{(KvE`Y&J2SKXT+u)d +UtoXD;*yQH4cABsQto?K>(wbqDEw-Gnfy7wyK4h7LQDk^FeHTN)Xu1Q*;NPc?pfcA~RW6FcvY-=v4H`$vpc(Bj0N{mG-Lc~eZ6P-ho>G2rkR#K(ZqA$Q^XBhfXL(y~dC4?GV?Oy^*uvCqT1*k%7BKW)4sE!Lb1DhchTK +7y-2gw8Q}n8J`7UMi_QwBOVF?tD{0KiENgTpyIDsZQ+i$t1F1NpuH?W$E +{IBP|`0LU&ub%+(|HEOt1Mb&D_zbTkL!b<@z$k;l82BMb5(UzB7)4VQf-*SFz+b}af>2qqR%Nao;Ije +*pV9(|2LPb~1VpZoHAy6=7nu9nw}Py7kgHb(D}VRQMC#~tt;6}P3XiA)cp +Xn4@M?-w5WIwdDkhELx0cD=Z|N`6S)l7rq62@Eu~D2$bjab@9pB;gV(`&>T}cUj(G&f<;{J;hlSABto ++xQ8;)d{X;INa89^^+r%f@QK-D8e9js6WC*T7oKyj1xElS$BdI6s(;Dl^Z8#D7HSpfyC-y$|yfe14K@ +{Uk7p{U|USjgUEupL7s_ar*D>3H0+#`M383`uV2(+j|22d{h49o_x+qfqo-jd%x@js**atGm7&}pvUl +FXrkyFf;&Bvy>y2{_;_)HGqz>#vz%#INsqQ3`>ILf^a~5=Gr+S8 +ZAI89Z~0y3u}c*Kfq>MY>eaS;y0n!EY}!w?=C{zUZqicZhZ{C@uh2Yu~;@}@4gsZgUqXgp~_S7MK9R5c%PJa!gZs9PeQhU*$26)x?|RDq7vB<-Rq#_ +Vg8YoQgbZy%dC>WRrrYVk0~q;6~c!-bfYP~7~tuA?5~f(lu0C4ec{)Nw1uOvE@e57VIIk_^dTW6q@g) +n&Wvuc^Y($B!chrIU8#HYBF=YTNiVUY8vU-Dp6U=Hm&J&m^~PRKlr!xNMH+UKnS+y_9r2n(93=%O|wTNL44lxe1(9z=c_M3XX(vg$QvCETJHA3uw3V~j3kXUlCL8gbcHR +2jj;Otgh`CG{d=im_LSv&n%`NjXA$N5e`{+luW;03^ +7j3RLyAt{2SVS;8T7$JcUFTQM`NCZZ3;>)z1ECo5J#VXDR`VSSrWCt1z#o9cOTICopzyQjHuVi0W?XF +d^K!k_}`Ls+5GHgM5YzfL>kOHU%5+oo$SPtG@u7l$svA6h@SRj*t;}^4^Dps}Jl_Y`wiZI|G=-N7(Sv +3w9W>l=gyW|@Gp&8)OSaw^uSGnr!Cu{x=(3`*k@HE$~$0wN}SOlaf(Aw&hafm^KNTf@xj4TOuHH0Wwh9D>VmVlrg5&dHz#gA +4thKA8womrs7*X%C+?UZoXc{8z5oL8N-!^IJEZMI7`{K+?*{%nh0v#~uX0VK9T(O+MjoGy*&{@T1?Obe$Lwqv*D2PPQ +m*$Zq*>lm`X^z2pj5ZL{)Vk*d7UYyD)Gi?djj@=~bGk-JFhH8(oQNqJ;;YC~V??A&G%QQ9)ZSsVLV*eqef(EqA!qiuwgE0l)%JWug65Q%?&#`H)%QlA3D^#;5nE5FfyBUG +Ekf|2o=}CAb?*|{v7E^Vs68az2JKn=Z(0jZnwIg*mMj+2mVeL_jJg&S1Xcf*}Y)IJ{IFSbA&|=gdVzg +-uez65+R)M(6zX_GW%a!fdn}a7`l6xHyw~^kk$-_})exhU-A2lbcKiWN_({d8}30lQ357L@}x7JVVSU +jgP)1@z>OTwQtMU<@betm_T5WyDiut)VIR-)X=+6HERkH;?4VF&s#izyNpRA-uGmbmEbwoIAVnUnouHet=&dJt@J+F!TpRvX!0n7>VW6N-1 +Lw)GR&a8a{||K%3C9OEO2fp-nKO2TxTE((xb1YMV&&%RXNvOLBz+qg?d;?k?uZg$m8Q= +I}{lpi)+ZvEx9l8B$vPyYO{kNlG#4*98J4#Q9szR(W@B~Xf@Xc{9?ide`9j*=uzqA>PlSH(O75>N|rC +lqizpeysp)-;cWi!eFxG@$vnj)*z(B@3a~qMht5q_NigV5_`TzPd9Q6ucl9z;LJ>@Q-|z<1fqqAir{! +ECeD$)^0g#f=jZdlq^I9#(*{>NR=UhFcr`>K>@YNF+gon;@kK^$_fq=jFDB@xXeI+qNG3sgvkFxVZV( +#{8=_d +T7Knx(908$~=sz9s~hPSN!t3HUpB0$p075>hNzN_+IJPG;R1qLYVxFKubA|5{}mUwZv_PO~G;rdFw5& +ETkd87LsXt|PIPQ%%+rC#pWC|Va +hdGTwcJf8GhE1iK|{Q;;9h>X76eyD&Tg285N27xWb!S$sZ5DmH#BNo)(v?Ct)ItK;Ki-u43&S_>*}GB +CHG0&g6*>1dZIYloeVv@Ch2^kxfThkiKZM#k(n>Vjwd)efeYUfi{3^?az)b&Dz4Q&-A1ooF?%Z-jI +@J&~-x^<;mU&MhPm=O?cV!#3>pt#i@p!s@!$pqaHpX}XDfnt$los8w$9*{|a=lFPU=d?{y#E`IG@h~K +|dG9mSHBaV!aZ?;+VLQiPnEL1+Va0Pp)@Yd9~_CD4bIhMJ`ZRuLwMXzW~h{1s{^`ShUGJ%A;eYpy7JO +=nKG?H}m!i^Cd7vegZlxq_1QCDL8KHiR(!Gd|J7XL-j%!*F$4Ql>168_Dn>zF%-4-@umnIHwdPfeO4cf4Vd#!|hdiUtjyL1M|E89t^ +*?nORUx`i52R_l7q=`t3o?{R|tmimx_qeFlMfpv!+oKnvlp=63&fM9|Me`jZj;8?X6bx>R(Nry#N8iE +zxzvMB6PV>~+BdWwXT2A%AEKNNl8G=_#rGZH>)%yBO~IZH?6b)G$gQcCuMmDPqc`ueEE#Zc2__VP|4& +D;}cD=Ck}NbU6M(3&Yf?fWV8W#ftO31r)!x&wTEHibbLsB0-#r#zclx7YP}dzOhH$uy|$R7trExub@> +{ou5bLn_)754v`^G1mikzV4;*nyC?sR2;{LMU020mGqC{(l}nHLP~oe&fD-x2YS{5{h}yJ1i_y-%Y`{ +M3KT(RDe@8}w6<{Bo3-(b3MoS-sf|ZvdlYn+X209*PX`XGufB#Hy1~ykG!f`GjXzeY*f*MvAN9rFJi& +*3S7W{KVKm0@2vzX~)N*}5i#gf+a^-?!Ie`_$k$(fg{lAmn-!UR*Xk2+d2`G#c>~p>!m0LUC+p{6q?~ +=w3gTIf^E@8V1AId8Fp=k^N@0opj;@%Xu-o&_F&MBs}-x;Y=Jh-NAws +xVGZKrfoiPTX{^WlOqdUG5gm;+Q+gp&!v}cvW^#eOLl0oM~<09GsGSr&OKwakV?RiN^?2-uCziVo3ttXm!BL;uj-XS=-j&*3owiB38% +xJhauqu|A)SSPF4=DxmSFuuHro3R>|gq+Jw1y2XC43l$q7Eh{r~ac9~;Nv7_q=4M&dMzGYeEQ_+n1d1 +WYgg(HM@CI6-|`#z15s7QTRFxt0V_t13T10uM2{sy$>G&|_FELK^-L^|hE3Ndgb}f~gCJm1{p5X7y?> +R$fkkzB6#P>L{-z4GYMDRJR=H_EW#q_s@XTWKIIOF5f!Vlt8VDVF08Tt7VHIz@H6l#T4YQQL6*HTzm5 +%G?2Aej-oRF*)RdjPGk+W1DE#iRU#B%5se>Z47PU>m%FbuID20x6^^jywAueE)L#9p?+>e=RP>j3&-p +73fl!`Wc_C=5XT!OSGW)I>EeRfs>>)>_0Ss53+&q?*rCIJlXYl@ex?l0>9{jTx{olwr!6L7p +FuguI0|xn-mJk)VE=ki|ApF@!xb1ZTOjN$gIqXt +lm>hhGgb{uk9b=oAM8GHBI8KT@`vZIQ5+!=p4XtQot!db+nv&>xjA_Uw?m +y|4mQtwQK34DsbkWn0WKzWW=$h%G0TQ*@rmRS?Yj4tdn*b|v-O&n$_M0AP88 +!UPmVL{z4P;dIZWj-`6Wovne^dE!TwjNrcKAp$FBpvqZ@x7W7irMrb^s`6!p9=^$?JX&f7D1TZ5XcJJ +?^yC!A206`mH>{|wEd7dr>J@SCSkcgb&kmV?YjbfPQ+Yxex?5qX5aUxqTNO*nP#~j7?CE)w(u<}>?bEDq%cQRf1G}@4Z6RmMjmuq?o2m=ZExz50F^3`bDX3`LqQ&eyA7V?|-K +l$h*K5vdgb>y^Mla+pp(_=KW-V~fTW;anZKlelNDZwXpbC8MVrGxKW{{Q_BAEla^yACd9;C9vI83C7`%?+JN`Ewt+7mPN!qMlCTWvDsHa44nFi74_;cWbfQq1gTxVfJs~ +<-goZ^8~1Q|3OjdGyeX4PyPSs|A+rMLH+-c6Taj6AD-+7fJey1=w*<_5=I%&6?XZzU_M0P(gpw8J$(AgBL1iXT<|&a+5pZMlQVg7UW!i0n +i|#_mB$l?em0&E&`r|c+rYl^kJzdzEo+eytm{tp6K*f|Dfb>ig>vQm-DIxW>4&iJVluB5^G8^iJN-Oj +=-&?c=Mh8ycF17F|H7me&Vxd_hK$Lmir;u@Ay7}YYaUdwDK9QOk291}hNx51R9j*BIBC_sVe+}^wpBH +zZ6n$8DbcVzI3AoX6D#_`Up3+2l(wm<71{0gkj0O(RyAZcl%y}{_}K5gBvI@6EKjrL1A5eSm-qs8EBy!y;Q`JHCkH|RflFI0^tv&Z8f(s3eQ!M8y8ph(#H6ot(SB|!lQ +gMZGyiT{^=&JNC4HM}eve&&!B{RR*;fTN7L_>WF-glEa117coqczNncrMT`Me5cUJK +w2U6Zj^742r9OW3^IAZ7Lgq6_{SvqliD3D@dnzierxN<${bDEn(yORn_;CG;^o1jRQ +w`j`>rqx6lz`vuXiOT-dP#$?6VW3r4Yt<9Ww=Q+6!usXv%RVeWAL;igyLWVW*G-(RIxOj(Bz(2pvDY6%a#%FY{hQ18TcXxm%J?sEblv|iDY;dbzdj#p`9HkHCEfWill=*<|6jk@JCy& +c3;kBHaRJ2z{}N(NO-BJXFGg*e0ehD!fjgL_)>aPaT3beb3Dp3baS&W(^0g&w2C$i2`_EFvyKW;4vbj +JXKYWenf|e5hDSidj%K^yh7yxbll9dIl2P|8bQ7!)f7brmsh~-7TwyDKY;9dt8UNC;`Hd~Nuf_wo~9h +VCeG^jJnmTUhuk}LisDez0h#^V>++|Z{usj=9+O}Z@Ysu&-$HXl^!?eBMYvEhuP{DyJ5z?p|QobJ$qX +>xSXy7a~Ii!pmsMS?TD=q*+Tl#zL4-7!Nx+{ktwYWE~G)(%1t2(bPWD89jXw!pPGuZ{a=AAW;z6>Nhc +fa~kV`s+FVZi>+F=J>lQLcg2i@1_X-c>)<-%eePAfJyD4Ztme4QTM1LG&2kQ&xNPK$9 +JZ1!cXpSt|A@L#eP(N|Loy>u}z*F$~jr-VH#gjM^HaNgp`>0$I-N>H#B)s$8E59V?9+P$SC*a9`uS6JlJ&a$~unFgPuQ!m} +9`!4GzwirX+sQw9z2!%*cW+Nz+)6KyGxe4xmCu=?)zPlDH39mQFU&uEU!Xtv!u-?s1^WFLrd_q9eibT*Sp6K_eb- +rNow|b&4BwuT;+2{6VMn#Luq)*#_Kh@XE%Y{wW5M{K9#k#Xs8TXzRv>V2IfFHcF+w8yI%AXJ8@vOLf +ihgFU=K7{$W3C(}e`Qn>%UgY`zK0NU6Px4cU;2%!#nRMU?LD49U(If@aBnjG5(V*}hMb@Nuios}@`7+ +ZTNI0%4loSq#1-5pNA_|aW26{rQ+3O28Knf5AKz|{2v>uHYfGjMgJ)Q&ezgRmjVryq90$$7CNf245i` +6x;dK`Y4V}`65_6t*@65xtJa8OalP-}~-98?X0TD@}3R9g$@)3q`WTrUBQDi$V_(qJ6u%9D__W7RUIg +%5$lsoyaZ{sfpwwfS%&C~z@cTb0cu&i7ckXi+QP)$ER|s)eo8)*b}?=C@S|`fnlxZ)!>Zg9ri0>iKB3 +sD6(SNH%O#UsSVw!Bncz0PTd|q6F`W=*vb=#6KsZ|Ge^kHAU!mbNt;Dq2JB%cTBE(6vub6Y*af*9>^|gK%S+LL$_v+lq=$Qp`VQGQs?OaBj#V}X+`gRm9L#YR&cGK~YsR_C3y<7j#cn +tFLL}bN(-hUx71p4vbao7Xv>$s?Rb+gd^7Oz5P1*-{-5|QtIHL=OU+xs8d)%{K>&HH0C&Y0Mk|o)KAu +Zj-*wyySa=|S%CpxeA1Nj~3Q}XqXkLqY%Sb=NUT4brwOpEIaE7<<^!0U2L1+v7RcbluwLZw~Hi{;A5y +W>2#=`Lbl`P{eVjEsB3k~fl|T-loS8O@;GB%6z#lO4*eOUFvRTRuRtP_X`%%2kU++B$WnQ6`AToYPx6 +*M&y0T!do&0#$RexH4|6#ZH6?Wa_^CF7k1OlTpg;Ug*>9}wPY@$2|;ZBf +>lmHR7j0WX2>6+-Xm|@9kj}h5_FzV}oDhy(u%QChsnCWT`f(o6rhB2D}_6oH5$+aSx{0~}y1(00jUP9iQf>jNgFq_)6j-L90DA2Qh@ +rnV;#lBseSS1dmn=t;M9uzE6RwK9iyD|o%jhLS6iI%~R?}0_hUA|U2EKcgo9^cJO2-umtErycZbPHi)Gc-S^Ct^%pqD!#= +)!X=8Xzm5N(;D-_gX;6kK-Qez5qNw-@4vT=&E;=%{M{6x-_7xNQ-ppu$KOp6TIcvLf~oi8)`4YRGUkE +h)I^2u%#5G*C4<5Hvbdm$8_cM8y%~z$9?4gs(dV?c;C@0J)Y7wUdrKa*Z{$9Y;_fSEQD}Np1KP{i#0X +y7W45~=^G%WZuahF|GJ_A@3v~`MIM)bwJ9p}pl4c@%37etJo~N+Dp(mWr;!rwfcqZxUO56rUw$I6FAZ +1A&+AXnXv}0M+nHs$m2`!_2(chB8c4kC)b3jr^qSFki@JmALIbHg5q9N8+&1v(fhZkJ9*dr1|v3HGyT +p_!12kTnIWoBO9=(-yZqSF=UUw~AQm-75 +ZA;Ff{lc{$??NP4Hs;>1gh=k+oV9O`TBm-?NQV@c6~Pl_uos!C +>~O;F_X^@~eX`Xq_q~n@54y<<- +k0`B6)BTVj{7?IShUKqy^;ahXc*cQMcimgR03=HgyG6&6QK#DN2%HIE~t!}c83M +53W1-{H$)k3ZY54NH$g#x4pXHV9W-?az_DDb}>1+RrOYrM8xra-N_`m5e-nF2=fTbV9kwzQuds$a)Bt +Dk~~J6{kR$lyN|>@yz@1P_KkTB-Y30}_26AP(rg@cZ(Bi+U|y4ZeDp%s4{dJS%{0gH+*1dI+AMEDk9+ +y)}Qg7kv5#shA-|qq%m?1*I`>;;lby1dtm2R3_s#?4)^Y{az-cNT#$J4XX65PDU~bU~!~}#V~;Br!G# +u!{gIpvR&RA|Ej^83ui4S6+za>VvVMsa*doIdh>yTs-7?EXuc|=f!2}-ecDn|k!qH(>GYm2l2$zpR~F +y<%Ff?k>*@lV7dYEo3&c9q+Xg#e`o_H`qbov=ac%MTWNm}Mj;hT$vnh+4tA~9F?3?!rQ+x<66}89Ct+ +vnOvtHMY(!P)YzZMi+SR4kAKF6tL@j>A3(~#MY1)HzL;^vOO2ybJitF`Z!s3c=v +{j(U&Kx=pI`ogdU-boo*H`(+g~nQ+pB>i`>s=bRyOM33ons=NHpiE=pWHV*J5Y_ReTX2RZKh-YsJ2N+ +74>K6XZT*3{_`?eyZNITqqPWtko5wl-Y#d_=Y_T7xgrn#3)wdJCz>%vxfUFwpQ_f;02pAtn(*xkV54P>8)-LY()Q+N`W``5I@b%W2P6zm?MH7!qM +VjCM#PuoPOvUWoq3NiE$V;Aomi_sYi3UmZd)%rRRqo*0#m?YX(pey=j*VvX|GbJE{9ezSz=#Z2wv +6!g>D+Rkzp`ulEv@H8Ll&Z}lnf?*WahOaHo^s^jCY_Xe=rx8tSDv&+AMPM2S9_rE#t{@=XLI}HBj8lO +RsCMkrbDT<~L1j7)5ff*R4VS*qS1ffxkz-bKmGD~Pd6o81x+I5uz#g?ETlLUfU1ip5PLxG8jBEa4Diw +-md1H`%#1XzfmbmpyD46zDN(xBb!f^LgZyx6PDzZ3>VHp?ktpgR7mx|vm79bJ=pK=v@c%7T$VhyuuBt +ck%i0-}iv90JvHYPDm@wRC1}3I|-4^x7O3TR{|C?N#bO`GT6iRWlc8u%JKM4+o#^A+Krc+!S0A%2IK6 +l2^9BlCn6}f7cQhg*Sf;z#|UHwFM0I_;CK@8M}Mp*&H&Zc|l2-Uvi%PuCU;VCxd6-p)~g3#tTFrh(#f +3>wF;S@_NWRvw>payIj>`_Lc7k1k3N(e>BCXl9z8`3B`6nJ?OU%_9jUG^+Z79XH#(AR59m|ZG`DbASL ++cf*jE5=6fdd!W5K`D|(-Dg(t&Z2*6k@WFSV5u*!e$@VYEpqsqRugk4~{*}H-1J1!?LmgqB<-?Ny(Yv +z@q!P#)DQG3r%nwaJU1ia2{<>(%wTVi*z87e8FwDG742*li5xFZ%!tji}eAJjB-oB>bq{$V8i?nj*kKw|l(gt>|Q;t +;8R?F%{iLh^&GJ)H#q7UW6(_QYdrSIgMn}kbM%Xxj?D4GP-rNV(|C6xpJyJ`(*?2)-z +-{09KHGPrLEAP=!M@G)9+R%^j+y3Otag^QQoMj)*pL&gg%#~{!vA$_&jdMr;^_G#OPZS#S{nM3>6YdXI`9+G&JlV=AGvrHub0srSA-6mfBpwb+2)=?bEpSS#wbInCHl +wSI>3j$t6ps)VRm{lXOU+qZ!yNm7b0}t2M6|$EuX0EDoU~pXPnpc)9A%PA|z##bebnJiIV${P8>yuhX +85;}ay+IEzoO#=MBp6b4sST>)BYxpHge)Nkxzx$6Wx>t!;dHv9`LxiS$uGKZmSwY~7`49XnTNPV_Ys>MA(F+uy*1FRK1~IiFT}7jC5PCz`PH-vmpJeT1w-~dFt(vR>xCMt +n&8*7R8TEr(adzX9xI&fm8|V56a^KlzG}f#Ha6L7cUg=E&!vbId@UjqsytHuOFeFcMF37 +E4g{4NiSWVEyyxfXTgJVf7w8lYOLzB1{`Vd7~=(4deA*c?6X|bF#n@@3c +rCwKDTi})0$IHk5Y>Ga)xouQF-76;(QPC&#w6>m@zc}JfQ_W=#)9E1R7Qz;FCCAA!v@lg`%wBva(_4w*DKpSF_2TTJUSiGE+(aUx#s3F!fkbZNz+r@pT#0>*nY}-d)^c2h0w$klU9+<7bN|C0^BoS}eSmBdYER@5;bJ9Aqovn7llrZ4D`h+<6o}yqVsvjwn?C(gd!F +Xqn)TpF*?%vw?eoeL~ra!)971l~h?27iX?5iv|VFcR#8gA-qKS3lqlZi0xmEXT6v@*vIM9;D~;aSZQH5l}Ld3+x{H(u`inRW^QW&au2sK$s|umWN6@an<-u`a-_Q?AkOJJZ+K +<+(|rtmjTn}mUTfoP9N1h`7)NjO=0;q`^aTjshnDU5|XM^@c8=5@^p&qLJ4@5%~|fq$~e2JxS6$J@Hf +g@BAZqm0f8Mzn|rZ}&Biu&XJr`tCRyvuW~0!va`pE2+kP|n{kC7krX$xutSquID;(M77UDK{VP%>vDz +*aKRd%^6$_4DW9FT$c@8CiUvx3>ZvAz%ea))Jz*~sAsoD=udm!3KR~2Uf}0eB>~e$CneZ4=}Z2J#hvO9KiO3U+O^}js_uxaf-FKL>mj-S@ +Q#;D(H1F(Hr+U_3WGe5mA*zUB4z*#<@WL;QKld<=|1Bxyh%mO&u=*PTuH$KDz^j=)%$<4B4KTb(V9JB +8Hwf?Irhi~^uT<`}UtLVu=qTD>=mSKPV)`jPM<`(107}albKLXdUQ1%VUK2Qr9DdQ6weFBYfG(YBiw` +Ns5dSU$|r~piX-a*AhV|W1-=UcHo$k|ZsE?7PZuE{X_@5rUf_iuqHL#z^etP**7B#O#C_+b=zso_6Gc +n~pL69(@wW0ym6&IRuElaZ-Hf%ogHN;T_$NFILrv{Z3|V;-L*fpwvGi*Tl&U21n +wSYxYNbdV}=UFCNuK9$z!-K(qfqMXJVspe)}l=7O0c1Ld29y=60QVun;%fv|waegC-%l%gDnVsxbX&~ +y+HJa(C*hbpP(WQ}f_eyN6h_Dj)w;Q|?n)5g`jn?Ba|*TzM3WWX&A!YV_^C-L6D +ePtkRgbKnaFDxw8Kqo!e;v@AJ*Mz5rYwS%7bS`T%Pc|QaaGlkM;hz!}8*|dj;_wA$GT}3^dEs_Ws5U& +YY6AS}MDxx?war#rK7Z@xkf;=I%|F9aXce!8uQH=lU~6-^7d_BmtsFSWM_d50a3C;8}jFw0eLttF$t! +QO+Xry^4?H$D4DH-zFlneyh56-A&G+)dBX}d#}A#>pG`|qPLKC)HHpj+_5a#gc7+sfkaJVayD68o!wj +ycP`Bn;W(6>@EVV~4ihPVe}yXV{t3Pxpx5PHv?L5dQMOZmFNcq8zRy?r%GLYw;~&NVXfU!5qYQTnu)du9*c+gPdRi{!8AFtXT`F;!&Vx2c`~jK-0rl$$K1LDI{mmf +E*i41dyeTz+~d@mghinz9ppZx58(xOzz#2n5HK%P8^|-{bFS +&!K06}zp=7h7<&`_{x<%`kNO90<2Hc|x-EKC&dBYN6}I~Z(XSqHk2aBTV$LmocGTMwHt7P2J+g7zqai-4=l*_qk~5G>J1EmUY}ED{oo +r%@C@O%FNwe5X8e`F?WcSJ#q^D<*Xlskev|>adhkvpOCy(8}!(WHaS9f +*lb5WW^af)cGc6<%Rc0eR-!z&$HU>gg^#FWa*8L~24!n(agEIWaE86jfiw17bA09>Ho8T>*#FA@D`0B$NtvZl`U@Ym*)3{*Nwa +Sp@}&IR|JD5>lzDkye)2EB-ob~^_uqS@_XxTk<*zRu`|FDp-jDU=-^kYue$aNO8JGs{GZco@rpV_-bZ?0|`I1?}=7_CfB3~1q`D3EARVDLB4&WXUTm)%h-jbyfx5FSqsxOm&wpI>+Xj_gDvV{Ci=WP +>byQZh=W8v&E?v$@11_`esh-*mPFGOb*a~r=Y3lJ5QnxrORrAdK-I7#dqJ)^? +ea`ew$gJsjIw0Alig9Bww8MO4$Y`?>E9i6<)ZH+k(_WdE-*nxR`vUWf8GG`PR&0bisFz2kKD)%-=?l* +}GH5!ySjtw=ov@wn5W5Yioo^vRk%YpDW~DYIvRa@IUag>^K(^N2(R|FKwZNaMtj)Ec!QVK`vz(tqP`m^k|I%S^A +6$gbUzKyQ6iX+fdVB2k^$CT*d?b+04Hd3B%v|)t#uaDC^-Eh41Mp6$K(#0gv^r$FdF>&U~cGu1HF*Szb89at55}irV8R+6fDmxMba2Irldfu{pjGo#zwF%F<6&8D<48l6REGl=uucX&Y^!-7TZk8}Z!EO^_Zg$?LIL8B0{W>2QyuP(HU-%?T=<)X2Ho;4rSps%%F0M&Q-R!ZDqF8mR50N8YcG%5yU|kuLH+ +Eu8Ez(qX9D=^Ha8uyQlWXsRBM6K2gKzg%;uDkVR6ydEZGBPP^XXCde7)KT6CWF>6Hi;*!KDB$xc5&Qw +YRch+TbPJD!h2wEd+;z4wOKrmxj|+Y&492jRlyC_%*9jxeTgz{|dM7|W8b)QG>&z=6j)>Ik(ePR_BJN +%fOH5YC?XFMK9l0Rgfp<_xX8g*rCv1BWlB}FJTgW;Pg>{w1qnUS(D&{F(t7Mz9K|89hN5g(U`H_YN4B +qjIu1)Nou_s2){i!D{jJQFXU=*ja+1j_RIAn>dj<_K&@89e^dfxI%*z(@%gt@cAYquLRhm@OQCl;rK7 +iEw7tA@B!M`z3Tbl^kb`e($V9R7{3%rBuWyM1vJLP2j>RTuR7;m2|tE1*gI)2%)roi3A85h&_^kVNI{#8m0ioU7#(!${{1~mRorhpVAfr0g@x0W{c7Y6xDjQ{Qw(-pL*i2XYPHV$pivL?$bOlqt4Xa&OXX(u}U=* +nY>?n@Ea=)FWOB9`z@OJ0!Q1IQ(+VtPN-`PYst1WMJi_t}d2a0>KU71Xtb`;GLhIg0dceds3}pM@IaitJP(J~YTm337*s1 +6_=GUkYCMI|Q-JD405`k$CS!-bH5sAzw&a`SvsHb$8y^cmdzvuLEO#ns7`~ZoEV)_S0Yy}I(!M-=5NI +4~Zwol^d3g#4XGUCeT9$oy#KF(O17!2Bqvs$KXgonH+EcW_5;f+-S***JGx@ap_*L2Rt^3H7%jq=7`R +A&Zm3}^-A9$Q|{G4xtSj;Xrn=EZe);o-wJLGV{J{;4v*cId7d5-EWNS>E8{cz@ +coCR#D$?=Zc9d7H4mF`TJJm_Wc-eep5}yo7w+}wK*QetM4g#zyca=S+@HfS@v+XPPI1%M=qBha8j2pU +Z*a`kSEWdP3{%OY6FoOrzGt#~DgCxH@eW?$yHr-|$3{PwAa|C0Wdjc;v +bPfAXJ6$R|N1T`{yX`#C(<&wm=HVE+)3!2Tdk`KR{&n>YpgHBLbYm?Th)KoA_EC8V)rejvlb7IrCIP(+$U2aqLPxGrSj(F9=kk`zrho~zT1PAxXMqpEG!b9jo>y~38ecsf; +Z>O;0>FWcK-25|GY>`pMc{R_bz+Q3{*tX4mgp*1$;6;71{14#1q~{H=V--7G??ki5O8<|16Q#?7nla! +v$ZY==r0#jB3d|X)}IZNz9-2_oAN|;dS7r!+92(wxO0xyPh +?cSkiI+q;;C^R}Zw=n9u@nbVWpBU+iu|E*-;TKOEKOg!1$Qzi~Zjt5kaGe2cp@bnysw1>DEc+&{fK-A +@h*A-ySteO|Llk<;h$w$1lbv>nRL9JJD1zAst4O&oh9dbr`k!(!uwM;qq2l`K<5+2#s8YCn~fCO=0ET +juFJ5QYz9CR{l^woi$KItGtJrSPggZD^O-s>mVqH@g}Qrz2xP^W1q%vyMeOr6JqV|k73g>%?8|O{ +G_ORL`1!U<{!4+1+drrCKp#&mqX$sHW;M*)-FQ@4MELImD)WCcP?`R}095o=sFPzNtKu}$L^5~GPQ +paL;NhQR*dP%x(EK|rpnc@9VGd5WY5t-syVd3i=-jJ+bHcZ&nBT9j)zH%kj;J*jKZ)})UAcUPf%-4f%hNXb>R*ey(%je0>hIR`PsJ*)IcFKRs8+{WZNxW(m^Wf_m7=-9k^Oocb{yu47mD +QKbwX3*2-?zG&~8Sf=mLH4GZmR#1&4X9;$LxI{aocnm-z@gFH7x=;wxtN{o^a +f5zncL%?^t@|oR+H)E(jjwQa|?6j^I!~7nKnMm~OBwiT0CirSmWh=?1E~L>TSfyH=T+4zO2IVSvU;4Y@?7aEwz&$+B&)d;lLDtk{0v +mLFy=33>}PeA7-(-NFlZdotA19D0EP}wen9}wh#|nZ0Eqz>54!d$m;EjfC0U!1Li7KgDO|~ZC8YHy;L1*5%WrVyvlS)p5d~qBbUJ9;ff(Ovy +!jsE)AtY$eIMgJpSS?u*aVe^H)X2tAj_;Ski|uG;oaQo4YEK0vwVRp#6JRAp!Jn2h_%LlW%kFPt@!cm +H2XB}zRcMP;tRafKL!HMi`xbbgWdea87uz`w)}=&q=l(ODBcJG)}q8@_(33~cXGxQr)UZqL`P5pgeJuovU15APX9{agsQdG4+oFU%fLWvNF=IF_y=2=*y)o|2LwL~i>Jn#^az<~ +sjSccUFC_c6*hNK1v74;NvVIZywJ&CnQ9E&_YT)SO^79ybzlf2QM0WnJwu=)_~)n +5#fzj65B~2O*o#Ih)&NG_#r>OFPYi;&yWQ>LsXHx}o*Coo(}M;6|(qS3x)4`(ApbEq97Cf?p$`5pnq_ +^{iW8E#$Dbvu7`fB-YX8;Cq*BFw;Q$srNGUE3vTC2bbgBzE16_?rtP!8Fyl<-lQf9ZldDNzcCZf_V9z +3ku1iuEgxX~?q(3K>*chi?fuA^ucPr`8dB~94av;vcCiFVo?x$G9^1|K8ee +Y{}H9%7uDoIxyMDgTS4Q<>uvvME@6QSZ){FvlnIP^leo3Z@?7Ut{rWNT&_zEo2tM)q)YphuO8J|~fEd +sS&6foZP0-1OyP+J=`(wq2uZrG3o$`*GrrW0btMu(>Dj`}XSy90~}lAAiWoYsmZ;@NYXyzDT;f1;r2H_`h_=?_v1 +oJN=R0^Ql_p>JEWNYgPX(gI=R5V5d?*b@~hgfi`4Sv4rW*YXStI$AV2^kiH|U`7yD^!(~rPU|e>ygv2 +EVVlarjbOI*hFzPSy`DYSrB-jfQfu=|b17S;sS{1ZcZ)PS2dyH0dNHPM20&1P0iy06@7i^GFfFTPsE8 +%s*ZymO$R+nW8@P>Xj$aeGcR_?Q}vM;+&2iLjRX8{QMJ_1>?hop*LMY5ZFvNweO{TbUFXU*dIOD+Tgk +niz`8~U#XD876XU3m{I-_vtmTJ)2h+V2#5NEOsIkQz=s>N88MGHcEk0m}Dfs{rM)torq3Kpz9?pS_G# +x#pj_3~0pzg8I87bKf~j-gr_&aCNvy2hoL!h^9ruB;wgi?JJd%t*ke02gj&g$t~Aj_6@7{PKfM-CfjL +7#LD-FizLQCIgfq8L#Dnx_SBX4{i`jLW76Jxbw9b?#;+@DtK{VLBHOL&uy<~wD>L6!BkM;`1kGnetHv +92lY|Hvj#*AP`zt$zT8^u>6vol>8R1@WV%_GP)FLgJC$4JH`}I~jcMZ)*^4v!yVnez4!p`!N?Du%I#4f_&PITz#LFOxM47Ys(nb)U;MCW6~ZhXR!igwAHr=3J2U^e+8n +Z-s<`A2kb7&U!W7iOa7h@Bm;Y6gz+dj-0`A~dcq+jk=GM?uXcY`sRTjvvn@fqk9xGU)FTI_`(*k!tg| +K{k;WSQ!LRHW#IzXvch-sRFFTHnJ7ooTetG?j~-DXv7D{qjPb0w#z*LlGn +!--Zix-z~YSb9c$P4lE3hs{BbSvlMEkJ0$Kju{u8Z3!?8R_-6EYr_#5O+U8PMx3CX0)nlBUI&6hQ1Cgav)Q0&|PdGfBlc(-pB~ib1Wt +9}qrm67bUMdC2K_t^H0*+vKTu!GHIlMM_`Rq2(E54odhb>S>+T1Co@}IhV!(~@zEUwZ|6;e<~#?NC*H +cJ1tWUF3V5CJQ-BVKt#>q2~sl7_GK#pN)|s&m>f%8~QJ+8h5ws>=7RUFO{{Zx#;e+d%l2g&(IoetXrg +Qy#xs?T7hra!Cvc0>)?pWQ!DzBM61T42|G8!vN<-8pr8R3*AeGxCAwH^#P_=&0-t_kpj+E2Im^3G75Z +NQn~c=`S3FXg3Pi7FjtH~7ahe{InguFCS9W9@_!VAp^ha_1)X*Z)V+bcbM%v-w!|{fxnCzd@YVYXumW +%pl4ue{s3koFlFvXS6pXL{IaC6;L@a;DtHm+B8Z|CQMb-iG<(!rf8_{5I>F?@_3Re)+F2;BB;Yn|e?f +j5mQpI89?&zYvKE#-vBYYX_7T8&<%q2c)m +{z@8DK5*L(+iAz>rNPH!uW!|>Aq;I?n~_Hmk`DCclr77E$#d&hzzt;zMkdBTD|R#eAk6SH`)4}NsCB6WYmBErD4QCiL*)YHfMhv{gi&cIMT&_cP_C>}AO$mH>vjdW +w0d5P-XU`1M +mLt3k<%_T)$c5pqGSXkj>6l7hx46Lq4+-fdURL{(u6kG$tAU|^sg1*aJl=UKwTXblJ%}6s(2zUF~7Pm +Jip!tjov`3&46zS<_F7#Z*^)}{^IwQs-t<*xQLZB=|BZM%FF}}vBJPsbg~g@|Ex6F@S&*9*&AfMKaEuy8E$nLEB!vq_>H?JqM6gau6_( +mo>_c77OldGq*w|wcS5`X#Z)=xqkR!$W8}hDcNI+zKD95h>ZI5>zN(Y&LoTzLA2gK=hFO9jDr!FP0!n +m8!5j~pp-g563sklgIM-#$xV<#cIq~tG6IQj>up0~h?SZWWq?Ww!y3f^sQH`HZ!?N*F}1Xnsq%I^%@i +YeI#1Y3AV0=e#-!g}I!dVq>^z#U~J->h34>{utS-<$=a#y^a=?L6P4Tjxy45etCU`QIJDGH}?jQrenV4Z5f*P3Lu&R~G<=h{dGB(wx9JmWyxowda>9Gs3e%_;N$C6n=#XwUJSySt58~pyeUPJfl +S?NIBf|Q4A04+1uSZLN4zdTt%YB4%B07WXFemZ)uDX*#pz=Ec1q0K*lojkIR!2QRNZ3FE8keQ{Axo93 +vh~Y}K-(ndF)tmEOOqREO~7rGH6!vNOXlNKW|SiNy@&gs*b)^%;`x>_vdvi+$wh>n$B#OQbSfF1-y-8 +Q7siYj~oLMR8rWf8{uu#H=!4!g$}5AO4bz~Clk8QyY$orI +!bV1KX1DLL(hz|2gq>^G1-%s|@k6&%D~a)o%g+6+%V@s25xq4`s}%fER^gh}FA(}wJUpD#Y(&U;Kjw} +a`dULBuP7-U0xtNBAP>FOHaVXf`vp5$MiZWQ8?}q9L~;9(Z5WPru2fbPUU3;K{*H3~{*WDa^GS*}idI +4XbxHNkM@Fp%12$t3okJ}dZG(u}lF)+ra1BCrW8hBR=NA;`cRRW~$thL7kcm&+7Zex`(c#k@@Q4&S-wSPl4N#Lb?PPTk}dB#;G4VN(wb7=?P +8+f|ZFF!pcCKte!5BUeg*Q}i(CV7D$G^_T5_`Z)+LnFLDDq_tSk1j99Xe|~deftaF|Lgzwrss9ss~>I +oe(=coQNsG4-`RUO{M~hbNDXO*AYqzbf+B?x2+fcnPlT5=5hj)eC`H0JMSW@;xK7_M(P#-}C<*dIV8@ +$+_8_2FpI1sXy$X6Rx!vbn?IlhvVQWd&&ImB5pfm6{5rfgeCFVx>%HCexeu4QP3UzyaB6Nd?I@MxyH=;}Yya0hIs&9$S^e&IAbU#Hv7+twIOOI-vD<2Knvpgh^=tO +(>%Ls@*9iB@?=7a-+(Cm8hD#@9FMSD?u*%nAo}A{H@H#=VN4|1roPupQ7TIG9NH5<%D>`2Ou#5g+J;@ +YpU;=He7#dm-nV+DIux6gzUC~Gl$Kfw=`0mfbi!Vttowz-~6yllkguURvIe+0x*#JK3vINgh=roAzEN +3n_Ekn;I#h<@Y=-&?*ejkgW&jt)}+dWb}7MFsKgfx0rFqm +{&G=(SHrBNN8MzM&h^Rf^RR1Nm;GL2g>HBTSRO +*R?@iHx{SMny?9udKDn(?P1JSwP)-=xYh9z&UVmwPOh6E#b?C1`*4)@IBV4IkwcpMSvp+LmmaPymLo2mz+9+m5&lFU6V +B1*xQE-`3kZT9phy_(=z5Ne;%9u*f9fBkjK*%ZBERvyS(Vqti>!Q+Wql-wJz!#6P>fmjpAM$F8bS|qBByM+$iO5jj}7aHl>SVQ+iz6?+5gvKxrGG#;`e_iX_a&zMrj|oxkwnH +BH;+lPRJ@+R4-%cTSiQZi0F|k(i3cWfyXYzAG<~UOx5<)*-rV*2dFV@{^{UDFkL^$n*BC17=!b0Y@*nC2wEv}@3{aX0qYkUTZeaS +ShBcNEHY!6Z}5d6+3rm-)Ikay*<)H#+r^BkDUFAxx_t)lHsPLauZ?!Bv6UdO(|v)40bX +f|$M<<>NMn$>yFG4)=z!M=xQIKU0*(J372Pn;N>_WX_CLiy#4krhU69^?ILm#%@tDcp#U+rTqC=W8jV +!p%L3Z@QLNt$5UfM|`WA3y2RpAw8#!N->7?uxY6=$$-*8k2lc +3isqRaB?e11!W$q(!d^J;S>u@tYdN=pNUGOB4fl +D1Nu_VRNM>22QKhjydH))4NvEn_$$svn%-49pNjVH#*rXxEPLqf@Jo$|H=LR|8&^>FRr*}#b5S+`@d^|r2x#TqhFM +AZnOI@cJ%juYoh7z|DOE)--o~d`!E0Ui~YC%xc%)v+Fvlh6I(vl<&^!xl}*_WS@X*i^qcFhZ~CgNe_? +OYfBxJ3@Be;lqhI!q+oOFfJNS0s1r55*15m@nCadqazFW3g_OQQ|m;1VlANC-2!@a!!?LUUU{l~JK^{ +lu1XxZo2vmT}e9BSFE&gSwX +}L5GBY%C7*!$<<{R8-FzU+vL*p+E}@3@#$+Uznd2rGWYe1I^M=(J2Oa^LYpa`~hb-)Eizl*jd(1+Q6wZi1Y&rP~{)*e2>RU6 +W*e3ah$D~iA}O6c#%&}J8idIucfCYI}$HFMItVAip5gr~B*MM2Z3;_d>)a&u2mZ%~!6Q6;O1P~sWO%r +)|d1*-0fSIEGxgEYmynA?~)Es+WVA{(A&B<5g`kS9t9&CN&a-Rf6hyjby8%A2(S<_NQ<7$q*z#G#?h9 +Tu2ArZO|c=;g9N_X#>B{yEj`SJEN{(4|i>>yl~)ozMoo9?A6%rt5yE-Z5x$eJ|p`1hhX^ +wzFg_Je2E9)DZ{xozh@jXi+^og3F*5Y@v=<(x(w9T_VWiHa!Gwbzzpn*w6Z3^X>;l>4Y+n2WvY|!4Uz +MsK8gpvpZ0#qd^b1SW`H6enZxB9PurC|af{oxZ+N*hE@>61!<^;xclRZYIi$f30bkx>Non4{6KMHTUb +eu=@89qd@rE>5*_%?l>~Jmrw9Re3PsIC@zHo4izMfHAulEV`{f%Pz#Jv1g;E{UGBee?6c$RzTEa$sia +2z8WmF}ti_T@uw-@Y_wYfcAbZ0=3g)-Su_)OXbu({qGQJcxs2arX3Or^_XcRCt4yU)OuKbz81eje^TP +49w*wQN#{?6n=A~G8lAhvorY3K!3C>TDHhx`{Gq&IHKo^(~~7vCwshr@)#$xd5&o +dvCl|H($h|BBHnz8g&{^y>Q4E3)@yymhcYUXo~foqNBdcPk`)h~_K-nYEjhf{tzlf_!{NZD!}Mehw<6 +gTf)@z>Tm;FXKwe#ENrG^fks^*ZG(um+!WjYsI`5iud}wj?qMH{Q(GvN(iE?i%65~yI+%^`Cix+=0)D +uDPiA|PShD93JY^n;RYWE}5gxZxzx0m3OK2(W07s^F6tcFz%7jM5E#-Uf9g>g)%U5*>3A@TdhWk>fyY +wfYz^arSD-B3)A7v4T*(M}U4=ai`a0*~bQ)jGlnp^k!bF1f?CWb*vpZu`Rl&)6s*bT&6t0b0wVusWK; +j{+mlQ>jd+EqY=5!}al$wimJLqWiwA)E|0w(AVLTFOw+08btY-S}2Fmo4P$hy3u00i|V(z2NUqqjGbl +}mzUUl%U@5;IY0Rut`p)3V;wcz)i+s2Sr+Mbw`XyJ1?moslW~rmNjA7CqnN(SbXn9fdB40qh#4a!?tZ +$X%dcoj82npua3ucQjqXtorz%r+_9ZwaO-LyP5uFKQ%R8%8huFB%Luq%%n>$cf1X-|@guV +U-jxM&Z>sW@=Pawi^knIQH~R|=<7&EIO{QrqQb5KPg|T)#iyNf>EWStQ9gbOB)qn`zt`aI{ecOCvg{* +Ec)lifZXqb4J1{_UJQ=HBsS9RVn;Q+KJKSS#1uPYV+sP)Vedu=^L%N8Zhcy+yR=x$wVL1#jK|LJy-uY +Jmr>+z?|cEstm{i!QL0M_P;PRhL9MBQXi1spWE^sG<~+!4_M|?(;pg?-xervhJirX67qo`Pr6bN6VSA +x)(J#vwX^$~$iu3y01RYTTH-kYvkO!VCM6LR;G2wId5$R<(@ZhYVp|rb;AlUAGVnUCupp{51>k4_N(& +AG2DC8XjZkX`kX#2L0SD#`8gMwicI+6yjYQ9&GD)q3NdyKbv>f=Y*G6Q2!RX)ZuekuqRF7}=c%K&u4< +BlThBJ#Pq;bQ0d~?mtBN8y3wS+Hsf|uJo$vVdDh1EC+q4A|GVJ{t>MWk;=YM +`KkQ6+bQ;?fC;E#Hs1;j@18fB-7LGhLZzM%B;;QrdjYPk6%Us1kU2qpc&WU%MWT1zvprX{XqX$2bzO} +6La6TFZxPW?oqOEbo2)iM~S_t>}dyKnWtW#@)u8ONx;HTUpbCGQ76o~Ub?Xx0*Z~morY(;Il&8$D +WHrn`OR4Jy8Hqz1V4R4*}F5^sBdN48Bp1=e50G#VJ$$P%y}nrpLB2bT8a#3U6W2tCS|*poZ +HecY=z|j&tg9kaFf955686X_xCelR_UX4u|l3ECRTm4-%_ik-dL1j4nT_-tNpkd^?*0r!MfP6rvnN>` +;R=HoLj7G>?Om+}i2MzTAkc8=Q-+^^j7JN>Iuj_M_5OyyJxZgq+&ZJ8;h+#vot!rgOoF>1|+33-&utL +?{^Jy$5r{)sYgiA6@P~GWwyLc2+?$ayk~eULVjvrn%);a^b>or?&r0tO#-KXgy +}Hn_JNNZ1!9WgnE=a<8V(=bb7DB|OI14nvYX%SbQpRR-56szVubU&#a8BY78wwGks-bl5*2F1hOjLZ3 +Z6_SD_jZ&2DXjsYr$2lN~^nKI7(6*lXAuw#!-Xy5SHsaB30C5uBADFakc?iQ`FP&L^Ry9kkR*CKmgZw +hm8OMIfukhn4c_>wiWt$-pYl1@C%->^Ha%A9 +fzTavDrFm(f@-%2K$GD%No3h@#C +`p_8_DE13_kQ8wlovd*8`|*G9>A%GIg5R!%~Z#|4ik8Hd9M`M6_5YoxgwS`8%J8t~;+32n4G@uqn^2BiDseWx(Wh}~Tz&fNw1(K6b_VlbS_GU +3Ow?>T2m6f;sa_y#XMO>-QMVNlgE6B2E{bAn9@}76ss1QAXTy1sjR1+_Ws~@&Z$b{k{$P_%Gq4tVgt3 +YIFYF$I7L+-o4u3w#7@X5iNB(kQkFZnWWsf{3+sAmZp^g8+1$7C>$y!zo>oS&O|>S?;q3v1TDv(DWY5j}a +lUfn{y``rOLEV9S5VIYFUu_7kE7TePSo_HwR;@6i{QqFeDwx-_5Wp9k6n@bn# +mPJu1-fT*~npM_p$6IgK#8JC#@V@S+>=dT`2&F+x%c0Vvn@4<{_giz9D7)KDqX}EGyS}UGjcML(+zTo@2HD_bp0+g8l^WVz$TYb4%f&?fRziqbui~ZOC{NFw*N&mlaxc6}O`-l3Y)#U +GkAVHu6MIsCXOjltPA*j!-$rB(Yz2rAc3Su9!vJhbyXxag4JOvz7qYRXhVFZ|Ze>$Ud+VrIQQhL(|2BlW&ryz0edCrpV_?;>yOvnr7Qn``6s!m0G`j_NMOi&t!#soF$QztXMCMjN +5AA-bOsW#<&aCDM42z=v|L)WZ2r4+eu)5Kk^WjnR-HXFo5f_L?5{$>%4^I|>zRYoJ+5z@>Yx+>_ +`-3Gl2-MUxCmHp3>I6?nW}U3X$tdy9kq`e+ms}1qMfO?|UUv$Gfi;A|?xKp~;}znMk2Dgu`Z6C-u{b! +8Ca5n>Xx_@K%Q8rF%w?grF4R<+)tr3Pzu1}zJhPt7hkEo6MPKMQtGAOlBQ%Mh +gf(KZ2AhUd?8UE|hjW0^MzQugw2+@Kv9B>L>!Mz8(5(d1Whn{F?G_KU#O-}z@RJ#GwSH3psCZrc2{kLjp&1ln +yON06rz(Gxcg`Zyt#Has#{&XaggI|!P7sb%eHny;wfCjJ5&(4mW%;Hg{X>Cqn%Z+vhAwI^N2fF#vqm9TxVeHlCc{mzjpXBfROO&LwQo6uW^*2y}@|31bKfjR +!)TKV%T@bd25Jx*QReKL?4f!LW48digy%@S4vyUU#`fc^Uf5pIL})xecDrK~Dbj=;*-NMAuByex6J@1- +|KRWnbFzmd*Offx$LK%}jJewePd?vYotSS=kQ$Yg^fWGF!@&1bcA_tCi_OlnYz(WE;HcSa+cST_5xgW +X{p4Q-#Mb5gndJ!Ab9Wu|su8)O2G?@neN#k+xR--A4IE7kH0)+gcWT-%H^U`5Vo72yrz!+2LjK +%XxCse)_>v1w+jib&`yv9vJ?xQ<==EOc`PS3wN!mh1O1Rk1XMNbR)Dro89P^WMa-5#ILi=^y+c(qzn|<3!3AZuFH@*&ZU}ORiZa7g@`A`(pA!^&MDW_Uv`Kl|+ +DisF$ToF9A*mAFsoFd-<<7p@SIi14#wRzYy@EqjR{6C^N3X%p_o>mTQHA)`a!bH%sfL$*cy?gi;dIzoD0wS2O*p0ex#;7A4(=1CX`HOKMqmN*QMp_gCXxnz|+Nm9r1pF496A1sZU-SIn*+ +r2mzt9HH%H;Pkdw6y_vIzL=N?y&5PAr<4^DWvIrXM;Z)#YW@+J4s!YxFUjvABa&f9ZK^w(PhD;0b +b_R99TnVw{JR+QVBH6eGh%@U1wSGBy|kZZ*n?dDO(4;xUA9Jb!JZI?9({Vnc@TYr) +$-{R;jc=H4XBQEl56tka59{C_B3h&;Jt`~o>hLK2BUP$Neml#q*FL=&O`QHokr--v$2-k6&mPt1?|Iq +&@!--o-KnS@|VChfWAT64`+HXCehwW64GK}2kwFpDQM3H8HnrL_&}rCI%?cC?Oc60F#~jJR`TO^`xVe +Tdv$vnCLac7x!Q5*hYv*sdm;-^|;+j;2x+98$ZBS3_LwN93};Nrf~z&l_#mSmIRc$2dOZgOSxyfDw;t +S)^xXKRfr_4LCYY3gM#fC^rmTiI=W>gzM?itEi2oSpFH^O26OyxZmsI+qQmq`{DaG$IlM_3FPAuMe14{4|Z%Wzl*Mwf0#IF^xITxOVMd=&u?z~cp*qQ$|MTb +ei`*t-GXg5zL@ApEt(n+p@VCH{^Evh5iB=ap6d`$?}70`}a)7dbWTUQ|q!I@l*;l4ss}Z=V+{Xbp3P^ +N@}XW_~eUi(wN5j=*nV68p_{?d`^o+sYrW`27Wu-?`#n_1+`jHQzh?EMCV%+R;ikE9}mSR+u}e%#+?) +R9nx|eYGxbjLg{j8LO{jf#?O_PX6wI_lGblv!Zy-aS!-be=l5OjX&{;o#&V%PUQEh4!@JA +uY9WmzJC(?ijHi!5Fr5f}2m$NaH<>4!SEHz&6G5%YCrP%Fz*q#>R5E_VStCj=H4~nL1LCf$DA;Ztw@H +TDVvzW8rzjuf!{t;rOHc@_6nhXW66Z!lRPBbR^$D9PsTrJubHffzJP&m}oB +3`chNp#<>Qm(L(HK^?9~Rwq-_!N#R6ex;&G*Q_*f}nSD;?wJJ;B!0LznNw`lxSHf}NY~i@NRJd+*~}n +7*G~h+8 +oHqO2xy-;_odw)yNHBsGk=f)G&xuJ6Ix*s&8&!t+F_{+F<)%>2|A$Xp6UE{jZ;exz2{Q9Z;#`;+A&iC`q!MdGaDB5&#S;6LnHXzN=>Vs=9xM|iMibqXe_fPepKA +rn2+aXbZ&ghHcUV@3s&MTiY#SPOR0KmVzE_PMAit@tsaFwlWtkw3jFU@=|voH0wvra{c;2Xze^wZ&hl +2(w}V!8FX=0aYs{7pX}?riR&-Znp+mFsDPlMg`6sJfoy-<0nh{>LVKgtxR!|4{Ek+T7~&)IlQ6OZWJauMOWczvNDEw}}3Mk$D1)FL +hhXc8_Re}M0#8LY&{G1Mtj87$x?9Bdwht~VKkH#C88`OEfr7+T*y`u+stbNP<+-Il*SN#EI=*|jqI9( +9F7v@D#17MOkHxqTviH4S|-_U2g_BlWE}4vBC|`k)>&bSPh1;Q`GMzKChRz0Ht~?`OF_Ov4&S_1$k~+ +Hd`{P(-ym2ezO^L~xC3s)LT6hUJgSn>KhSkC+f^0u<3g1Lf-wReRy@w8=kkB2Q#mLrVIj67}VRlVM=v +=048&tq}BwXRjH%Zu2~_3f*mzqV%7u>G6z(##T?MNk}(~%&w~~l2LYrp|QSph0yJ-dm|R}T^kk=cvK=qyH6e6Ej}N>Pa3)Xo?;`_YZMi`ty;QdI~_+};O|wNT}FF3rm|I%QiAOYL +F5j~hyGFQT?STuqCMM?^VLajAH;=i}O1Jf;=L%jJ<6qKGilw!R+f$ID=Ytz@3g+Y8ul!_3D9am7hsue +%f-VtR6!+)Aley^6)2JzzIaJWYI}3061X?QgI9HlkQ*>xk#AfU_OTowg^+GP3H{UGf@PKQ|>+fhb!#_ +}2K*CZ8I*8hzXOZk@cgt&fCeTxA~+o#Qh^OB1Qql$bc5a1+xXy*F-R35q_Rw${Or$8Y&7cn^Ios^3cd +y1vrq`nH{~HAB?b-TK-;#&6Z={Xx9<2kE*xNKf!R(xwM#I2^Q~%J}oUE4pP( +J@kEu@^-g$}O!(lZ`Np((r*1N>X?FRGtDW7g6&-I}ud()?Zx9gTlCrNF0T3eYE(77zu9aan@b%wub=g!10+&mr_jgo`Ym3%-v3+t-~Yf-l>Ot|d;aYY<=*@ezCC< +SlRtU@VfWkh^&Q9h|Ks}aQ2V#8{cS@&i$adaz%gkoMUwVk4J)F~fN)?}A5y7$S`!Y-1FZ%7!5f9l$r>xd5ETXxR53C-8gdJcq%AAss_aE+CD`uO&}wI +FqCg|7^$)r~WF`uk_Rj+$9CuQGV2ZF!yg^+mL|N(s$)X*O-)&KfN1$OQ+--Vef7+*WQ1T)4}11FT0zA +7-CUwZNT&-K*!`C4u;(wYDDO{|Iyk0fbMG;M1KJ4Es{dPt@Ppk-C4LhyxD7;`AOS6;6%^V{&{CVvb6R +uT}|=)MQ}xe6OKza|A%{yK^Sn{f}_uSr^2ABHxKe-G5a%0#`%gn$k_GY7BFRadz_(kfV_o2o0M+|Zigy +d}9BVzMNG_V5jDr?64*V3+Ua-;kCa;`VN=IqZ0@R}g2e%KY{>xRiqBHYVopp#R*J&~0_`+%>M+qIw$v +i-V*8o%YIO)RSJ4R=7iZPMfthF{NL^FqSUr +EAiRF#vl0&p~k|9B^rHMJ7Mxt>FgY5e$v{o6CAQr>3uDp@?BT>_!KDwlbIVceU5~v+r@Y}u03Q^Pp!| +JSLf=kvUIh+%4OP3L=x+$at0ixUhhPvZ!7?#onPjOn@0+dCYCPT*mUA|h*WR;UF0JCpQvpKQ +;KQL|2Ji8yeevpA8YmFWC?f4t0}tJi2#*NpBbKMw4xwW&_@>PUrmkc&w5>)L$Hk?6jvzpXH|5vYz7{6 +85^^I|4GFXo2Nfc@ph;zlqex^F9)IQN&zEm3ME$j8uBHi|zK39%Y^EGd%(!E)z;xa+NA`k5mJ}wUdvp +3VE;j<3S*=&#fB~@!%v%FcEt%I6py{j_ZtI8t1b-1z`+mcxY;J+Ncu3dj(gX)Z!|X!p5Ch_DD|cVP`W4PLxpYCbwxm2lCot1LX^6dP4Uz3OM}la(HL)wbbfZ3puAk_V2OFgFdWvUBNuY +s@M21nazbY%v;@k7{8H%`yw2$gS#&R=JGs$ABdtU4s)snm44hy;>9J}-b7~dVX0T4px?zemYx9>5S`Q +w{Aem4a8pM9-&xc`gmd=2gl1^}GEQJTS7oFXweVT`6R8pj~MQ_!ZBL_eM20Z28MK(#Soq|iN;g!xb$h +p0@XOWW+5mkqZ7W%hZ~%rZSJiWkE<0@|;}i)DF;!Cv4f`WL}M1y)AFFA!Yw!oHG)tMt^xahGbm<;`Ysmc5#Z2Q48|WY82Dv+SG>SYJO4= +Un)__5&-+?-*oxbf*tw>evs(fpndbo9%frz$C4Lr#Li$ckya2nyJ0HNVS$F@Opn?5n6Spg6fSUe0`yR +Hc@mRdU4Jpn6cohj@U3Y&2*x(qD4`5S?_p1pYl)rZVc|+;S;u*Hck{A3cKj{4g#nBMEkuUsyK1d)oaP +pTipQydFh`8kMG7au&mR&nmGQmU&T^{G6BXofqe~-o0gto$A@@QiN+nNTcjNZjO?f +sl1|s?Qmo7>}_S1H+g+uKVPxB!enB7Bc3VQC~W=2Z$*Bc3r@S${hmf1;iF$M&p9@P+hwa`*!B>%8QzU +OJFT7)%T9<&{+|X8S>2v|-px!!ID98xo5T;k@2%P> +WC;>$%i)AYHHa0tfd=xAOoIQ(SnGX)q#+E+L1d2ppO)-X+YvBJkH#Ts2_Dyn3L12PF#=wIU@O0u|j-} +i}3OId?r8IqBJ$Gn$qZ=EoyI{9lr{?Ns6tMYTar$edxEtaJQe?;{>;#Huaq#msehG4T4jwTMZvO;gAi +{u6KL5uM^R7_-J&2j#AO@fbYAo3HmMumW2RN8QhAwb_Ld^F<<4++5t{VA(7&{*~?+`O_KeEul@EV#OPueH=+1c7?Q0Z|yPd2h)PBt(elTBRM!#GwMN*Zu+!fq8;_r$l?(}^%(%JT +G&15)Swu#Iado(^9Tk~3pE1^Aw=q^JdY(7)IW4x +ba@kt18A!>a15KxlP2b)ghRkDnJRg2D*bMExaE8nbq-KWoAq_k~F}4rZiXBy8gmYY{&D +s|*z4eD=^tp-}R5l)Ow>Y`f!`zgXWn*X1ZR>uD#t;_ruq?P}(uK!Qc% +HJ?g7KOIwG~k{D!D1*)F)WUOC<0{}3S&5u#yFfLK8q;;L8O+>S7_s!Kx0=Tfu&Ty8Ugpqmc(v~LM;#j +Cxd)0EJ|R!z>=_a7O+APFQ9Lg+IR^CQrKq;gANSZLU0_^e`1THRP-~SSGc4ITC@TRODu-5A-afzm@n= +R@WClmLNOfF5M_%21h&k*0(Wr{RLWwD8#^3bNiWl{Fvxeoy)^wx=GnlQqWqX0X@Y$kwfQ?w4otI=KpZ +YHQaJy}JnK)H=if*v!;CWWC8bRKlaw;dC?o%olrqdHBk4P3drK)3h9i$})#Z&v4!wR({#gpW5E1u`GiJeSd~QXS-JGW9JPCvCUQA5$Kusiy67eLP&lp}t +uyH}n!I9UW0w6*prO-O$ME+TIfC!$s&pU_xSA*J_UZY{cSvP!4|m;Px^D{?q9iQgB +|_-5r2}#k8`~3&ik|*?@je5SN!e~zY8`0i!JRPh5qKUzQG|_#-tcHs~BZTip4m9LNvipI8Bl$fiXDEe +(pC8Atzb<1u;kf$z<_$AfY@6rYkWh`@zU%Bo*~Dfh(~nPXS{kD5y08V8P(9V-=hX{2x*&{g9#d +*kASN~>W@ZWMg|DN#vgzs{n@ZB?F2&Z?#dvI&_6}}DAdZ(k4_Qj|Gg17S33;I6O5z%GpnrI1FQac?=p +8P<1`>Wcq^5bvf9qf?5Lc8}isE)(ZQ7WVt@f=ynu#)_~MjS{QH +LzSdvt?y~-ng<7cRuHatt0DrVDjT{Xx`p!z +i46m|rAPAJWljY_7qo6?7IyGu^Kj>e6>rOxKO?kQ94s!~bz$XYP0)OWh`)xq~0R_8Or+?f8^?wUzEKk +ASw^5E$N45#<`ppDFUds;^2hP^ID<S!+jL%d=db0T^G{yjT +{*m~qmUouQ9n%Ml2t=RRZ(nJs7Dk=*$}`R`AjRxU1>+ebA+>@oIKIHcD|QfcX;v$O1>}zb`(Zm*^Z>d +7k63F*H?6Us*R2xLiTvf)#hXid5fe|)f?i;)A0gLG@jnQV9R~70DZ(iQMH5^*N;W0i90nYXTey!i +NX~_FnmSp{S*m9bkrky+Xcg?u@8XCl!`q@_YW$c$dlqAyf$9ktG47ITcpPhQ=c;%#=h+n%3>%sfNU*D +@${gO&KO%C{Ru7@jbJUpvCr);x%u8=l0Cp`{@s~dz;qlwr~t-Wxbe6}YY0ShV_?5cu)*RW?VAA8{>zonBH^NP;pFHWPayN$90(}O5CU$T<8q*jz8@4<196efUgi?( +nc&963U-P%-N3lDmat()p~fU&tXQBE-^{EOUJYHIELlwII004(9Hu6O^?$x3%Oe6A&YT$zrWcfAS9i5uNsDr4QpvVVxFF(!yp8@8fROw-W&*oF>uk(WRj{@=URM(rTI59{~y7@yI<3>kFJ; +acNi=A4+0qGKO9^AFSyPh0C;n!rc`PCO%7j3OwMrfG`6Fpi}t6a!HhO`<6EsaYct!ci#c;-H +nivHx(Hik2-|{|rVy*g~dp{9okf6$NllvJ6rIArPBE=PCk&0UMjZ&LS>>F;=`N!tn%pKE~X?hzyFnh@ +Z{>q`Ac^WEsc?!=?x(5aMN6Hb%hu2Z*kqmW+l425@b1QM1vDH3`ANGzJ{aO)iRZ3T7VgWrht{1e}chY +qfU)>(1lzBkJ0b(n=@CgPwDGFzNToPuunr_W$~Rc;?@YxM0AA{F8_au;q_P4f$IU*XcBxN@byF9U%;f~O(BoJywh|6PW8x5lh^b8h3D;?dwZ~_?orhv*`4=A+H7=gooh +9sp6;B&?{}-3zv=s0x_CF*HNsF;D0f>ssW60lyX-qzny$w{1i{}eH&k_QuBh-Jh7`$mTUZq@cs=a#JI +A1U-8mK()Rj67a>^4M>N2kDGLQ5z580nOd3~z)icDYMjy`N{)p&E1eMiXdE}na{5Ex24x|Y9z=G{erp +N1uh5akg>+uEN~P0UldIy>q;Y)hYNMs~%Aou#Yd#HcnoZY;k6Cne@|yih#|?*%J7DyLpHx)+Pua%z(M|OLO(MK5P5wb<5P(qeu +zOB8DSRnJ8^P@7;sDsM`+hW&UqKI)Jj>JzhpN++KhDw>L0S@7LtN|DpW9|3??z{{8=H|NZ~!hJXJ*Z! +ib(e)u-)7GQL~IiR|P$-n>K6*$eOh4%mc9ZdgMU;7<;|IT&4O|(-aiNo=t7>#`@<%%hoI|rDTWiVw9f +o!omfXZzgYN!BA0$?IynD1cO&vn`~RA&K{q!z5imQ$kSk_6}A;52BuuvG376y_Pg)i?%DX5fBiO$p!@ +IwXg%`8HgJqGc$=X$pnsN>QjPPw)j&Q|N+>aZp|WHP{#|2*4TNEYz0MG+Yyh!!|GgvLp?Y{M;}7k7Wf +WGKLQ+mujEnmg0HyGchM%J-4s9IAA^--F0N^3l)-uan#M5Tlr_<8WZN%1$)5h0o|6T!N=R&#shR$$^` +OZP&JOdt1A7-Jm!(c(4;*S(e2uVo>Gm>zR|_v)1o!i{Nq3K;Li}0;#$gU$@aeqe%8}0%4i)S=o8JvV +cVE5waP|Rsn)&vN3n!w>$q=dLLzg3^I{$dpU)A7|Z}JbKmBtLUi!4XFXHI#ggdQygMJwk%;I0)ZJi*3 +$A7A%lsT*3!NsWVC6*kP2t{Z0IScn;Zo4Czjgn{^wUeelKo1{tjn7T`!?zq+-{_N8c6YteXx5jhQ%m^ +RwVgCVStN8v{SCl!vr#cO{3>AfDJ*lE_4^7lx_Z@s&mhRKv9t;_}!vNh;S2OrgP;mb +(+vn#QX2MGP@)Zq`pf6IHvs5P{oRB(qidzIdJQ&nKHrwWT8ZE*Z0VPVIf~otT(PR%S@Hu~%r}*?X-R) +$){;S}R;o-=3L{KIj^Md8 +s1riM^rEalplhJ}H9!|S;hh-vrw{gA7eSODy+N7y8={seUXOGL>=|aCdoPyXXs2UfMmB?P>onCBO<#n +=F#?Cm%m9Y;?ra5xkCOFJa-`!xVC#8Mlbj(oR! +!!Q;aZ%cd$A+>)x&bjdt$rAT21@xuwiFhLHb=84UI=_vs<_ad!8MbQXxCH0X3$X@OGO-Lm#z+RYTYaY +0J^!X}7O;;milw{@&xrxm3yR(52i>%PcWWr-Q$*BC}5dk3V^jov{r^|EW4`F!*z8m5IXz7W2E^$^e<| +E)2UrlC%L-7yN$>Z%KOlUSj>}LEl0Af9OQ-c>U{>e50{L;UDZ%>u6|JNx=d@#zLVRoLQ7CmPP2|Qc1# +|V!(h&9O5MVdBGb%V7T}@GZ1p2cr9k2z8OyIW}uHnyqGEh)(QbKg3z5TJQ(}gs3lmgh!-;r60Qf}FcH +D(1sOqrg)Pq{3>g4oLl;bXX}(66AxkOjeU6Al%(obE0J_X9X3}6~5e*9#boNV+%oi+pGan*4ncrNz@` +p))u&^M6-`htcjwGjsFur?0x+lUa{Ii({s{4ZJZ}=5Zp&oqg4Z9t;=DYdi#sR=sK$UP6ob?>QDfqf+e +UGXFkNjSy_4>2J$$0G-)Xb+nc0VH$Y;S@$I#51sOmINB_noxQsm4hw`S`<9+TEkRr=YrO0f4^%j_6r{ +Tuwz)Ti2+R8$+z#f&TJWPYDX`kZ;A@(4^{T%}DxNGg1zlk-&>>xB-QOxb0a|yW7qqn+>_6jQL?@}H<*?mRx)p^%@OZq)tuDeS(sP(iC$=4=uFmrApPN#T~6I?@D!a{6E>-eIu%vEFP2jB>bq7-pL> +p~Jo}-#D{I$hIg#y8I7LcAHylq$K=mGNFy|?MIH=lfuEU`eN0+dV@s&D@ts$8CCf%zo)nmBz}F;||=$kkVjtQFLfTg-}*>B +Q}CdjO+Wsz=QouIi9oACBhp;E`nUa&ac1=>&Gm@24zz7eYx1(!_B!!Z{Zq1iz<0Cnb?eHWRd4`V{!5m +qbai5e3aVGSBgC+qSq~J1J0^h&EybCyM5@QgZAKA?-8{=2V3$I*3sx^k9D7U0efulQ?F}>ImpMBWM^z9Dgko-K2dC)Wab+?0*KsNhk905=@6buxpk# +X3-Q_1&dj5dWPq1-aBl@o-A2>e6muh{yrgesSARLQSuuj8NCd<<0Et2l3?R +@ptT5=9LEE-rXT8l)DH4MQ#z1p%K$vqcLT#NSW{#EfI0}58^Qo%x|ba@}~wtcncqFUbbgpW5}^8D5pf{`SCdOoRH^@ki*9ASmZ5#dME41 +j!1~)MU5a19Tvu}x{pAl`bgx)2%kVGeg&Z?_kvZe-B}o*Q$lKEu#4jGMF;p7qKA!gH}0{k`L|1#sqOx +fqovug{=ID8=?L;&a~U{^csEav+xD>)@~hC3N#?h6#jvC9imqTWFPz(Gy4VfxTd0tk?@tV($8;L@V;d|n8zQw&F>RiDjsfPK^@6}_pfC7cOP61_Ex{4q6_w^n@f&Y +#YMIhNVlc9>ucPZ5(?Cv{!fHmZ^H`Ehi-?NjPy&i3Uo(O0*pr^{Z|F&S-7hpQ*`e +h4QlsT?0)U1RjzX|qN0TM5WdbPb*7ygO~Jvv`|!$gr8F`1MduR;|o +B!&!8KUM=t@47r2CD347G{ehBbI^j1eAQgpjw(WJ5+ty{jKU6gm$$9#$FSd}XVvIc_f=?n*#W)Z>?Dg +cvDx&xtt8;c-#e93!s&UAb{#=EnJ@k12G;qVmjXbu{!fygUf27pA^zX$@BFJcnLV$joOF)n8oUv- +*+=OsyKv93|lZNH1a9D9}>1o~1fvCd>{&D#cY^%;aHxb +Mi$`+Z_zY%LX5YUA9usd-oanN>mf$2>E_Ve|JU5_e=VIM +So?62EEXbKh4lYn=3UT^GmJ|ulRhPj5wMTFQQL&p%$Bj-0!A#y_*!z&udj~WMn_B3cIp7l8|NY +WS+@#&Du&aoHrCLMh|QM(#xPSidLGc`%pX;lLYi#E8OiZ5gxZQQkT=|GFQ@ZTq|=MH94V+Pl21*7eOX +w8Tr+GU$qQH;rFboTP$yyOF4yhW`a+!>`TZwmbx%vX~5ocT4#d(bh;N~*>=X=9qzlNJK4Kkh^vxXTq5 +7~*ynii=SD??y4`DqhuG{2Z=98J>0+5m_oQ?5)aT$GS0&cQq0znStO>QQH|Wa9FMu4Y_rerTxg-Wr&T +b!wQk?mXzDc%I2o65t2``QWdX!~V@B)0Vd|-dZj(Ilz-T;p>+HArN_7X*p8pRAdZT6lm2h+;`QOWQ&z +~il1CXr2ZFhpFC@qG~y0*KHRG$J;9@b;eQW4u?D`a_TaB8Rv~{=Bmtd|V!bw<~0V!j5N$@9tusZ+-vv +Q66{;II5*I@SIb!fCPD`w4vlHdw#%?UTP3m*Adg)_AzE@FM-!7e&Ag13Y*KmVL%8*aLL +i)%#Z@@!@++1bzSDTV1kyL3^kUmEU>r2PVBn{_v3MmhyuVmOxUI~T^=vugAh3{=bO%S#qpIn0 +D6qt;`u{Fk?J6By%YHLP71%Z>b}~&QUQ@Kv2&ipB57%GlI%Io*Mg@!|IjDxMLg+i?RuB|g!6|BdR`9- +4neY6r6T86YAGs4G2Zr6nEyUlZu-9YH+u_kkhkB +5d~|IJAg{i(RoYg4`yF)t-Xq?D^vls-<0!{*7>f}o`x%~w;o^Umz!ve0UD~@t*pL@7unvzeVn}*15GA +O8QJ=fRkSMIylMy@z#z16)7A_1-B5=zj={SOD43z-nGSM-CC5MRp7t8(3A2f#bhLnTt +B=nd!kd+#Sc<_<#1Ml>mA(pEcwm$0b^7iQ}oW2^Jfh5}g3d_Nf2lfTrokPN%4U2!5k<_a2wdcWZw|{uVHWl_|qm;>UwWGy1jHVKi$ZjnW8QnzSnc!`b>u6Wp+{yrSVc+ed|ak-Ts +lO)#=4BIohx7f>-x+ZVqVP%FFc&bODhiY;N?@_HMk?LtcfnwKzBSpQ~Bm{Y}!n~J*SAOu-)C{)reZ$a +Q0T#pdmZ4CsajSk=lSi<;xIB-Ep^CljtcKBF89Kj-5JR +W5R#sYth8BsH2X#e%Je9aPM3FK#flKNMBOuJf@C}nte$;+Lo^_7}@R+e41VF5=2rgJtB_q^D@L|#rAS6< +}#cm!WHoljunoa*zTDKxw)^S&vd@cw8NdiXWTr3&HIkq>jB;57q20DLw1#1txc0Jylrizqz741YfTcw +!WR4_vMc?f^G*yjsB(fGeKfzH0C*pTiYI@B%8z@8F5$mWS4?$Z}u~mIfXectV1!u<#XKomjjZf~DJfc#_pV#n=Uc$6W6XpVZx=XZh5HQf)t3qI!X +MO_1%doFtd4nhTy{U&jNC_LbVRa#PdJ*X|aHMg;U#Mc9T##e^$_Pf_d6YLEk|Jkv~$HAYJZm7?O1%A< +9rmXB=mBR%Q0aM=8X?Qv~l3=sV{(P|wt`S} +F0Z0R{<5=g^A6a)x9x|pBGC@lEIG*o7w_@YmwVWkF8_>_U=lnlfq7!0KV<);_t8mMh#VVWW$VH0EgI} +^wx143f)VIM2wL>G +7u(kC9gg2YAd@lY<9Is}fr{~u*+fdWDcpE(7ESd4q^!h4X$no_4lbbR7tDLi-RbK37tdnv#Kh)D55Md +ivb^t3UrtPwHfyag@Dd(>}+BS3A|)TyJ;9yOr$AA2-sE7 +5^^=Wj5pBKE1wu^ifKw7o53m +FSOTA)l4&X_T1?N!aOebE93WF9pA8RuvuF#5O0U6d0EGL{R*A+CRChyij%lGrA4Q0N*=cx^zLsMEWQf +J{bC4-RJfOMMeXYJqVpz!KgJz8#RaLa&Z%P!g`A7vGaFH*CEqAzWN4t}3Gp=wmErZj;{&aah4oGIG(~8c#&W?vG-SwnETu^IlHPpGRce +Hg6W(K=lotO->6IV#mmGFFWGiknnzJ}<6@bwUQe+M?~H13;p5t_rjT;wtA-CX>S&y{j-8ust&`2YMgA +65JxPw~r4F`Qbt$jwq5>dwHn%c3y5n&FU7rX<7?Xcw~#YsNp%6ay|9lmFr}s1yerGb5lfFMOMokwU%r +n-(BiW>e4e|>5kK=i&7g!JO_%x1DOAk^6v9H7jfP;uE$!=zfer+`#kxFMdel)CvTAYx5;B8 +G2}nDGLscDYd&Hq7D)wtciD2}8^?sEp_CGNsZ;{1>Yk2X@}&<6b)9dntjPcQ1Gw^7V~|lK)^d{gp~!E59~xX62VZ`~8s5EM@)_gnu}lOE +N&Tz}sVS?S5&DgQhqZ9OWecHvGW7Y<*6j59RM)EJdMH(zg>X +MX&bw+P*HYLU9f*VkCg9tarWts8xSnt%<;R=5&GgmXUQVbujPVQSakk9k#9*=}LF94hb#iLwI{R`GZ4 +FTLKeIOmWa)THE>Rv~FcwB+h|_ZPj&iJTUxJmu?TJxQdRV#Xd|uIK8Gl@AK*Xc0pJpmb@4|yZ&-Bnqy +tdqB_OsO}-CC%F=}FOcx*U^W&xCqle9l9*(y-M?~{UKOF%e6zpkr`PTI1o2;?7F7^(yy%wEGqk~e`Pj +Mw?!MWqeC5?jo&;a*0yu{xU6kD-42tmDjCZ6_EV_~=_OjKPaC$DjtIx^e+I!!254^=H8SxwwLUk}3@q +YKC>Cv}*MK-BRtK`Ex6gVeE6XPoUu0L%DH{|_1#IAL^T2Y(VdeXfHF{8~X;>PQoVkCJdjnces2yf4 +Lb?xyN^**?pfIg$xi!JQeZ6&O`YlE(1i?Pqy>X1>$LX +{|F6f@pQmH~|?3$;$t#F7+q242=oovhllTw$xd`Mn}-i0*3)_)(Ocu|&g@nF1>jl=)=^3&n;KaN}dI~ +@Aeu^;0wzCP|7n@$wxNRHqbIDU`8Fpm5bc)(uFzR9g{=pzEy07WgnB`N#{?Cg-xEHz9V|5=GLMIm4Tc +7ZQUC8MGCjAmg<6)MdLXqo~r31i_TJ!(;5vkO?TKkG<`7T$||4V;$?;VH0eX^dKwXdDT76}O1YLk{Ly +0VsmYL%Wm^J_|r@xM=C0TAJ;d6efGgW$ZFEj|+b(6zd@HP#;2W-S-KtC|e=VPoGnouLfHn{5bB-(_XR +UtK^{Q8yApd12$89(Pv91x!V}#@`?Q-U=H4opOEkJug+JN*V6%xUn*7zbBww&Ze4{cs026BKf{<5D8nb;Vh5j0F-W37=csc7z^&(kwnGtUyA0RthT-5G7g@>J1dA +l2fpj_VF81%Jg*jDlIRhO9sS{y9gOgr8@dn|(y^OX~Gv!TNNAo1J0*cf#@okDH2bA^hbY^E!h^S3j)46RoC2IAqA|Cy8G<n-Xgi$NN0aYHAu1f*OUmN|-yVXSdE%c1SO}?b5rIF88t;^|<4oJl^c>6+lBMyh7gj8mDT +l#h&wP11OAl8(v@w6|tJj(vE@5_a6I_Sku06KBjGc7^w=(h0hh!fFKSuk8uoT;b@ +*U#s%s>TQRTE)E0tWI*6A^|_1+A)cycr!;wSv$+8N|C%iUn@_?ztXGb=;Y`|XV@J_Brq$>5coHaLe|5H#`6;0+zLStYnq#qjb(^kB=6m=&ai(^Qao1=Renc#ONss +1&1cJ?(r-a;sNp9YdyFixc|J7bCA)jMt(@I09gpd0JImWhlLBJb4fploHa`claMXDwkbJl+d*@i}! +{R(1GOj$a>uTN{Q`MJ}G4bi(tY;--rlx4HMQ0gQ&t4A|o#K?ebG9j>)0VOVoLFYWox0PKxjQ8fbhCCN +hVhtA!;WJ$n|6QAPcHVH561Dh6_hxq*wSiOwQld!P*q?M3#1L$IUgb>pB#wD>Dhl +?lZ!g9T5E8zbSNO@JU$3;=Y1^&36{&7-U#6~b*iBqcH?q6M0@E}g_zQXO=v7L0RB)fm#x_9i)V`Dz{d +t>A&pYhmM`jnwy**TZFT5UIuzYZMZGcKK0FIJKVp+$da +jkg#W8HxOTgL)?Gag)Om{w2Ilucc0E-$PbdM}Lkh^kc}KsEjI^|;+DT4$L}UAC#X2ci2xJvwi +bi+JNzEGbcKZtu*`TOWboey< +-8rwFzX~`A|Q0h@s2j_6?aU5MqRbu5?)vmU4uDL;xK7P9=@U!;!zt^Jv?HsfJgtL9!GT;9Fmig~m_)v +y|!5_}jILT5JMiD4Y;v7e!G=~u=hm)VS_N5ujU1y6JEL}3gak6x$V=#N1rqC-7BVh#{1cfpAxl20+Qv +>ueHIswVd{}CSqmx+}Ribaf*fL2uX5d-DkI~YZK>utcb4bE)GFqI9!0F;;9vZsbk|nT`4x(7->_;qh_ +GRE2h%~{K;uvNiLIQfqgGYfMvnANgLfA|I&6Wr_Naj~wc}JMs4o@K3epyD`W*p#p(&I^@vb~lY^3$mB +{C#Tqw;H{j7zAzaF0s_oU5)(H_UgCDv4UQCGR#SQWo-vT$9y!(KdtS~^Us}>kiWCs&sK~4)^c?<`&{{ +^?h)wrbTPL=Zc3Z8Qm1UuZ+Xi`c&CVfFH(TN~W-7k0Q7Y0M2bJX +~Ka#o#7fNzvo|rc{o4>T|D99$(VV@M$4G;;bt0g77*$D@75imnduFp*j!Mp1pS-{q@cR~>sq-`5Ah>oKF>Z79CG3V( +g`0TQy2@N#M3aYJ*W$HdHZSR-+P8ZfPggxWQB9_LYiT`=^ZjD}HrF*SadU6e_>c78>=|rj_m2u2j-nj +cE4goAWSyZynBy<@%3`awTFvSbgs06eVWuQMBtO#<82^_i@ld|bgc0(eD+FY>ZfiptKw-5@H@O +TjtWlLc%gu31^gL`+%LW;~VaD`x_#8K!97cV~K1Z>t?TAvA6W(0dS%o_i?(OHC&qv4~GYQr0wl{s1mY +i5I=G&_s$Nm}GfmiDiko&PMr8PW-R_{3%a@o=fj6N&^PIc?_ukGeNob`xx9{&y-X8Ez@9$6E9`H}^?@! +(y5ZV92OX^%>`9aUy=p`YiBsIqI0u&KZDdWRyTzzW2VOVmVNnFGYUc%WtlbL`cj!~Zc@#cyVw>!u7T4+h!&T&tqqx7GSLm&*s07|m +B=3rH^!bDr@EfJ&dv^LZD2x!D*MyoZ9Y0)JS&`3IioCuY<7h;5&i3LuJx6 +e|s<3!dT0H|}(HBA%JyV59ZBLqzX;~KJ?U%B)q*0&(rU5C +7ZOUHCS1-CcaQEdJL<{#nJlM+C}yBTxBBsT#Vpz<$Php-6(ViKiCZCLanwcYBjO$h7P6w3p=`NUGnwC3DD#^3mVNy8Y|f1R +GiUqTrdefz8*#pjaT!vE{|SgW}I%ktCGUmoGcH})*^*E88inLhq{4^lq1pP2t`{Rq?lZ{6cFnhXDa{O +?MMVVJ^5iY5shrzskSAe@Ft6oR0Q4xt2!y_wKY`*xz8MeKwj*tbr7f8Qk~-$o>RMj3h=Lnr$WZy%AL* +Y~_VoOiVmdPno!s5yT7MUlIz7lrN2Wjjd5JCh3FoyBa_=3ONGt2$$1=QGe-gPg#3ffV>%eguVYYm;!d +8iB(-$-SFX5qs8rw}F0BpuL9Z-FChI@D?wRi2Z)_J7pf>f1qx{_dDn}U+RnvQ>pZe#_$S>gi+(-L_c) +>&v$5H;0JVcoNp~gGA%LPx%5$U2@t&T7nbwgx%RhjVRZA#VB--R;1#K1;kKF!l*T_l7woQ{1%I6MVAT +NW(jNx;TBz(JLTX7R5x7@K7WK?S<}7y0eD8+%q5#edlgoQ613y*tlZBo1Em$N@CZj$!je +IP;w&$}A`0@lJuzOL{f4b-IKC2PZeM4=sFgIYBN@>`{A^&4an}S7It{Kt1GqejwJv1&N-6o+JU;b0C` +%NZn~5de4*2vhEtQ+=pAv_vLLXiSvCFP9Oun*dd!>p5blU(!t +PXWF^l-#T1Wfawg=ND@StT029hp{m(_;iF{|OcGt=2t_vbi_;`dV+gVPGrx7hf2Q~qy_LPOxA-`Ozf~&nJt4R;;(g!sExU!rJ1inUSNw|JJvJXg<9m@3 +wByxAOt-Nye220S-XRVl_FLh>e<=LTus3k~l{51O(0i%u$KEfwCo7S+ITzvYpu5d*BfQ%{+i?4~@Vl6 +GgW-*AZ!r3yZ?bzh`~M-|w46lV9Y6GbaGMhv{1y{$dz(n{rI%G@nfHIJe9dg`^tV-bSO1x8exqwF_K_ +CkX6-_T7uyYoB^si%DArOtZgHrOZE$0b +dU0?1lu)bo}CL6&(YKe%#&pn}VV*+8>tosqYo|(%ky(TgbmQzHSKp!)xE86Y!6;Q=7`DVR5!jAL4jpQ +qmWe$0I%%S40Ti{&7?(z)Tf>CQql@FcU@V1`8C^ve7BBY#)M4*j26puV~B5gmpis^Gzb*L4{H?U5cs#P8Y8^9|CpZ9wzP +~r~5TT+oR#2M>{gTa=DaitPDykCP4Ns4vQSg4!(1(0;51k8fLr^xkpztPh~>vEolNFstPqvt-8H>Rh5IrtelS#gfr`jnRb +rZb?_do4lwSS`I?0F0Lcu4X7EaL?umM(Q|3Q-v)EuZ^Sr~8Vq#F9jIHwj|n02Ia&jC!QBFmIf41d`^n +7(vk!gZ;}DpD(g;gF$WTANOeGmpIvArhTZDiUHePg?}JIDDUJdM0+_r_4(r;EkX6gf`?()bRSHYHX^h~cxTQbtKio* +`jW{Nm3H!Can^LbgMSSvGiwg|HCuK^7TWa=n(06meTdWI0i@JzBTnwZz3YVE`32)I0*{CPFf&_CNpAxN0JAr5jBM}lqXcE~?CQ*v|s +Rsv%zI}$VT_Yh5_nj>t-M6xQV&5N%-zB&q^)4WSHbndR{?=QMYNJ_bvY)#Vz2I#`9OL_D)4rob?x;fh +d-4^6-q7@JF-?A@1`T2RhS<&$seLRs*?%Cg9kZxpA87j_qV_7Mjl`jEtEb&@gWAz_L*Z>6=zBK{h4!E +K4pMB_f!=L2q5s6c6=jgbece4QUn-s)a3aZZSS<0UWrdUT4G98v7Gz$v*~nSubJp_g?1m2X;=5+%?aE +i*yD{Y-MiyQZR&WM{M`iS?>)R)BcfK&7QrZ|2qUHBh=NaV8e@Vu|?@TAJZGd)tn_TQ$TN^hMz8us<;q +Qe@jyxI6CqXX0+Ba%l3w|Cx7C#AszvuWIGJoXmL +;c|Dudpc;+v!xy!6PMJRRtp$n7#a}z9qrt(3ro{EdtI9mH^<4UxJk8rC*awOI`lf!gv%(ZdWsb<^1x@ +ugno%U)WwMesI=U>cbMP`!u78*_sab{d07cj)--)SC`BF}U`*)ojox8A1|6ydx>SJ)9ZY70@duzY^u* +>^Dv9lxM&&?p7dv7t`-z@s{`EQvobKHgMwFbS_ct&Vx+Xg4_qJV$7%2WJWBwM&22cA*zMIf +;tf6sn^8%R>;q=ziELLE(*5*-odzwjYb@VEAfl3Aujn@1>qiYg +PyVHTw7CxmL3dNVDiRh`qN&>hQNVLT#g|Be{cgw>+Fu8S<$864qr-yuW-T7aLQRJ07|_Rq4V+|ZcCVw +o7^kWi)l<+Uq(M2dQh_I09qD>`y!hxUQnN-JqnwFln)TKxE+uP-r%?n5y#FbK^m +RZ8P`&W6`bv#pnG)BZb4VqExek21w+|?pj1J2gvC_z>(#!d(-@-%#IoxzTyCLcSEmA{P)WNqVmTV +$|TkpH4y`I9xqN21y+*LY}k6Jstld5ttC?2r19&zeGAIkx#UK)T%|)?_Kz{@lM*Jjv2UGo +vD@A0Q;))!=mz`guS<`u59?7C|AxJ#{y#<=A(1hGuRQ>TXa3Bn)M +VbD*nXM5-FePYXZFYvoLSQ40B3Tz8+8I56Ph7W&Hr@bw_Y(zgV6@-Sj?bk@as-n6X^BSY(o}IdszFJF +v%lWa?A{3l?b;jYoDD(RwotILplN$zE$ixb-R4r)0uW+iO&;3EWxKGe4PPf&>>@-dv<3T~(5uESWnZx +Jo?81k`t1wBp(Ap7E?$$$rR2Yy|o)c!q+`c~7p*R_*UJ)?wUJqvKJet0B_-Xa6)i-=buyF2-ka7(5 +FBMJNTV-b`>3e#Xdc5lzxMzlxrSvQ{}QH&-x^?X|d5mRN4j<*ZBG)3_Yh%gN?X+*vz3!WA$eE*00cCG +uekUw%F~je5&GnO0BKA}`kLAxV3bk&(9;T^gDPt}+9g^yJaAY0F@NT-6?g&{NmYkHDAa42UZR6@C$F> +~v9(>mP@l@*3Ao{J+Cz_1F3T$ey5Igukr+&HT8p@DHbb4j8|l@_oji#0eB4aEyjfibgOPr*Rx52#TO- +7=yOB@TW!aTj&=+dv>3~_Yf@d_ig&UP#xQ2LzLd*DJ0qBEQ0(G`SXx)d!3~At#kz6Te)Cr-(|=AJyXA +T3B&I^#alOv4)<&ajPG?!G5y8n?eDg1_#VxL;jVc?zeB(68VGqO?B7LDTZjt36}sTyEsOrn#31heYk6UI<`xPtTOE84EAH0!N0!q=Nkk2o +%hi04rA6D7~%FBzKqV)A92xi&iQq$ +6@@u*rGEzID6Pu#(X-A%f9ap6ut)OBy!okrI?~5}Q0iE5PpC^w%VOM`HK@=at}~V}9=j4IZ9mGv7D(zpeaAHRyyOY!&5C0MKTK*;!BSMP+g(%^2!3XjIG|5pP+~zoz7LubZ{B=WbnxoIUq +Io;PL3f>zWSIiHYA75IAZXdVmL?C*y&2f|Bx6mlWbc{2JLITV%Ix@zwNs^FQ@BX5+gokCX%8RW!4k@C +G$ozRk~ki!E%9&2#an3C`y)7x=@MYfl#PmUG|u)h_$9YUsx3CiSXpJV43S(rZ2_qR^X&xJJ^oi65-9o +9O5kD{UMrb=Gt?R+a@mzM_S8E=0tWgk7U}BV+Jh*A8uiEq50$gM}6M0q+~L^IRd-Y-5`NGi?LTfX1<| +|3UjQ)rqnYHB0~Y{H3q#k9ID=-+g7F&@+f9^|+F~a=hTGG~+FNjigEZS?&w?D640&CY@ZXp|uC!GRs7 +iVvQt&lO>W&>Gy5HTg|d*f2qH0=Ridd^SHrfSr5~O}1ENz +iqj-(^AYkIhM$?H)JVjB230r*q(njiJx3uUdzOcCdTd%pG{WljU?PD-1|^K@6vLoniFOT9Atz!)cuaF +f}y*69f-`T&VHci`_2Lai^%czqmkM_mY*9F95jsKO3~LL&<{nlM&Sg=cGFJh<2-xh{pv2~hc)+pc%0* +B}z)Pfrrmu}3oKrnUODnt=v8XZT7yipQ){9ZFQ{y*V5%OH34r`r>Thx{PsVTyWn`)Vj`IY+#Gp?V*sz +SDnQY9VdwXae3QQekSD} +}WQQz-JvHpIiy>!zj%F64c?%EzR99CJ4aHKY+x>H>Rid-fKo>;PlAv%0IN*L%UA>)U-OTJL%}4Cs@;t +C4`gSFGpojJ{NBaNzvyL-B7URx`f};zIRSiyW$GEJFx#WO58$3;+=f +-->R*C@F`EX#f01OE!^9p&MlzZZsJpWZOASY>+hnkX!xtdA+g_X3pA6rkNg(wMah36bPpHz3i)>;a|> +%RWREp5VxMh9?RELPoIt#16R~*T7TcoL?cjFHU4bCl6QbKcL+E!=;?Z6?j7}!eU1`OHdBAzW|IZ|xt;UaeR=^|qO0w|7`!ji +%gL=IRug#lpC%8q+3;3(K{6^2dIk@31_G9YusyW(Ze9Z7Dtc`wm%?&Y)^t21_S!@nO8~SZQE3`e +3!aFMEZp*W)_97z^4q64{SsXRzYnjukI@29@??IBk=km+T%8?izSjMbU7QL@Sn-xs&;%CL=dy@Gh}Xloyw8Ipgtc^9+L|h(rv4A5PxW93;Mf`CQwn_bVeg +qZB7-&@I!!IHu^OvKjiQnW7**I=H_)Ves~v4dEEko(bToe%N5IwA~CI;)<#Z%nK7|vGBRSvxN#$OB6- +RLFtf7fu?wT(__UTPq%ZA3TdJOo**8>=G;2krR8p3q3bfu$$oOok +I8>9tWoxDQwn*m&uvU9{Z+CJvAB<(!vikd5$^N5)d>y8{La*<#f!6?ey4lmo^w&C9VXVahH6r!*tQNK +WE|!`j$n$@(cDnsQ7D-(*_0)644%M^U&Of>Rp#H_EekB1Wdp?JVCUIsk-`X7=)?7yEnMV)U~xh&x<6+ +;WR02&8dCiq}YPV2`>m^NpK@Wtg=W`li$#Z4z6{Wjc8w{Uw;qRK4)NfZM3+!6{}R>zYk7(CVtSaGsM*`95jVsS +2}G}b=#pIR)kax5YeZxHA~6l0v82@T*Qz4A>oHBA`{FO1}@qKeK^Fen=ef$!KyzMP?;XlmwNH< +W~zay!JFqsra2M7?>N~s7#(K%q8;2<5_H%JE5?B$@vydPJTV=q +8>n?`4TWg0{UF$X7M!0y&858k(2s{p}1NhnWuI;tH#jHGPH)Lm6cDAy4pTW`oVWbNat9(TkRK+7kxq7 +B;74~EgFz8T$p|`O7o&BotSW?Ovik5woA3Ew=ZqP&970aTi$TjM_Ivq3?$j(-a8IS*A+xuLO-5-9;7) +HX~*MeK3Yzqs8s5i%UpOv<(}|ujlby{0)sT;Jj@h0OQE2}%Z0*J32ngw-Xz;F!4VVERQc>9~8F# +4yJZ}dCvPu}@m2;R%Bk$A6ELy5PjR{V~Yp}n#i+EurHt~%}S=f?5dND|+x%usv}`YC$vdJW&|Up~Aii +1A=g;U>ghpzUug<5zJ%jP6xx+bGz(%XUvylY6z?HdUC|1zk1{fMC0h3yJKt1Y493y^X5LV80picATb? +eOh}h1hrqa%`b>|{t^CGBIRh=d)zO5(*joO5LjOm>vH}@+~58GFz)}R5z9V)F0bQQ9`L0tMya;xeOt8 +0K_87+pUV~Y_}0Zb_~_ly`22h!EYbTzj-de&mPRbc`m@u9?ZXaF2K(o%s)Su?=8cCfA$ +RHlWTt|&P|V)fng(u1KVenszbuPyedaxjw9f7f1Gu9lC%eYypOuVsvC;({v3u2?WW}lN0n$^K=ZoXl3 +VVdLtP9*M~jfC9dEiy0ul)keK_<_Y8ILa8D!Hr47VmI>f60xW$a;Aryk=iELX;BvzYKRH8@g-JVk--m +kR={b9T9_at>)BxmKcD-47hEvrO0IA@67BCs~}@ic4GPYTe1E8r?hv1I&NP5_v2{42Yr&dq~-9Cr1v! +#fEOennobEgAxvvY#mgs%12tdZ(qXxe#lRioZUsd?oH!-OY%hmj?afSjwdsd=~CBI#y%q3uQBpZx93U +XjOn??aQrIR#0p%{AkJ=bq^0!?pX}~-h9m@#Bh;Dr?e~RKi2?J6W$oR +xe7gF$qVTj-Z{yII;E3ha?G`Xk&skDioFW9uENZar3h5nccdQ{-D=BG(~o{_uU``u*Uf+xY02lNC-85 +#pYTy)-JwlbX+iw+C%*jbO!baY@Ve?4Wg%EJ-Wk<>fa6&fJJL9)c7z0`{l#My;z0Yd8hi{?H$NF^Ur0 +p6y}nh{lind>}KW`SQGSqi40&fs&-4>|($8}v&`JhOoxS>1DX?4s{)DHg|?w&av1>n3}Wl(bMFkoBnV<@ZAM3iS1q%+iv8b<-hM&F|W=$rT)oO*FG0;wngg=;Bm||M6R +VQ>2O#pWl$UG#s#*O=emXqn{A8D+j!(B@$R^v2Yj4Z%);BueIMPiIY+>>JcP7W#`IMPH1>-uqh&aIIR +AAp;BK+DS_p$?g_B}@7B|E{)gn*d#QyIB=N}RZ4-ViAURk3{1K*&0{TK26=WrkRZ{z(Rm$a|(zRbx9% +E!ec_gK%A4mf*zCBlf#Pu)K>6ratCax7{@@L$1FdcbakBMfbHN!-AJ%@K3C$BU_O^4xogc895Gx)X_5 +<3323F{7YeBk+`bBq5HG@B%K4-NN{zcGmYY$gv`9A1k6>s9(qSMVf=LO78PkJh|p=b^aJ{P23cjxKU}7NF9;b +PEgXtd&3r$Hk4!60ald&}V?Tke=UAlx9#*CKc)G{HVK=Qq*;gSr_^G3fF28>~^DL9#!}AC12<2l!y{5 +AMmz&0vee)Ofx|-mb1XQr>+de#%%ha&uTC0|T$()lDfeuUC0>NLOQ=ojtm*cAQ!;g_Ee^#rPDc^JQ)3 +rJ@-svv2xG<hGct2(pL!F|il?Qg3O&-L~aj-LV&CyzO@*^z-u}4Q-cl32O>NM(`AkB-D~6HxK0v%v6x`ow +L;Thn-pIg468vy)QHANf%q044+|SQ@RmcnZs>%CP|6Gnuf1)M>2>i#Ayj^Ltkhu7_W(+Ffn;MMJ=1M& +eP!kFfGYceVmU8C)IY|TvPBfbDG*t1C%l;xm^Oi#U0E{I&1`8|fkQ7^A+G*a(Gr%Y5nNk+^^5ksa4Tj +?Hjd$^P%glFTIU1_%((&6L;Impzde^?sq?K3u8{ZpQm?Cx?oCpv+(@bp=K4sVdVQTDc>Km%)#oe7t&3 +sPM7k3@;7(nJ8s^cGF`xi~(d9Qo?>|pma5i0%k9KLAHe^Xrzc^13ZI6nhaX`=0%FNVFA{I}H9&wFoFd +cLRm43-5%&!ZxpE@�cfvaHfItMIENJW*vuFHyRq7>q(N80=UmS#>+vCV5*i +q^s9rPv!_5wpcB?Gq`gbOVDv +?87{=(F)Ws9Nj_$wxS^xgnpT0{S^{@};*13=_oerAM*w>%K?;M1%l4zeaWNP38W-Fw4%2n^$JQr!U84 +f%T_g6HWzM;4OFGJf&yF+>x7IO=($(tO|!?=T_UOrwBA&*f;k!*)5RD=eA1azBhRYQTQW!)EV+7m(Np`kP6ZI?8&= +Q{zb^2N~6NU!MI;_N(ylPl#_P;1Q5wy)g$H{81+?C=z&Gj8?u~?GY1oSBs!E^=ePB8igTFchRZ2|DIA +Ztx6oY?iNBly^}>wy2}Qd&Iom`oR8Zrv-Sv<}j?9B{c&M@4_MT$8H{7n!6kb4)1{t90Zk9{^k^yW`gt +1&vB3t2qV>{m_kL{!O2Uz#@Tssc4`dL2H$FIce|L2DN#*+TehWss@MsFKb3f`SacCGt&-i)AkRifl=K +}rz2^$3LTD);oym4-K9+Z7IoyP_$x9@xyyk!&K +9xS^g(_89}ruSBw4Zab07r)!)9HP6vaTL7`P=h_Uw#|m1-bzaFd!zj=cee{U1@E4p-|EWo=nkiy`&&5 +8|EJ(ov6=h}oE}9Ty6;TJy>=eQI-aXPgNp6~Bx<~y*2zLS+!t)#lQ*A}J*Vr}Yc|UGJ-+^1cm;mM*RS +wO{SmwZKjQ1(;MH;_dHM{mvmHs|zFAcUl967eYYzAlK5qQ7-rmnwaeaH^lg#IEqWtcnAK@1G9p3&9Zh +;THMf=IPQ1tUa?H-gaPRob~>8FKCnf1Eyw>gUkshNBsx1}o +`ioU`7roHY%9_rzbgK_paMiW@>!1V2sn3V?6@iBtXOt|9G^$DqHm68s@v}m&!q(yIo2DNI^%08RHi5& +9)DzFCMXRr>$;kiXPeJK&)um+`m6WAoE`#>Uf? +LbA+us_R19{;dy<;KDJd?(_eu=EfLq{qcq<+!P0PR@+|F1A4 +{bms|@5ayLO_~b#8<3ED-o{GivU6${nCPIv8b}uR6Ap$Maq}@x6n>dml7TYBe%Ts*jV0b~9FmL#{Zy^ +1%7pdCqi7z`Q!30G3AwxqULv2`8PgZ-;dhAha~?4l!scJW63one|g=Zm8&kHw_;Ji>+GRG@XAIVG79%ptzwy5WD0vh#Tl+*Pzo}c#Y(UWnMZUYoJvA7L+bhGZ?SFRL +XTc{pco4gD8z``NVR|1I48pBw-00Q{$8{}zd1a^E-Fi_nsNH;91W%KyO|HtF4vJbvrEVsCjuANeT~Zz +#J_Nh*08uZFwl8HDXJgBytB$u6xx`1_XGuFOEa87H+jM(mbp$uE!?C-$+nfMAON{C5j3Mee-Se@i88c +)VdS4ecR9nCyQC@UC98cUVCC&0us7EH)%Y=pFDkL`VFcNbj|H8;k!v5|g`>Lm&SZi7Wp9OCR#WiS0DDg*z-djABKfp1~?=cwFG=g(Q;Rrwy3k?R6P+xy%e*1u-Nf2KyEJKDK +3UZ6uh=m7Id7(743^L$(n>WWjTfItm!?$S$Quc(jSu{&KL_tPV|l@pVy^61_UNOmYn0}E>3?5(QdvoO +BgRRcZ;hd{QX3IV9Oaofj$M6BJehpxir7jg9NgP-^JQZA3zkt&~xJ~`OM&yI#OA#uz~DS=`*<7V&)us +fPB?6JP~cP7+&i>!OP&D(n9kGPox++Cw=*O1#(+wEUL9BtS#Fw~2xNL4c=F_4*=l1Se9xiG;Zl8XwPb7M(D1 +*i^(E?rK+RGC4n}QT&&TSXAbO(ZLtMMB#K=AM&%!daGF%!ISuZQlrpcz7QdGbe^lkTQnI6COlgbL_o# +EU4I^RgzZ_?qf;~teSd?b;2C5O?sD0)J;}&TCdyPr-DlNQ=l*8qy+RJQ6c^0wD^jc!s%rmp5h=7fBS@&h^=hKR0Q+} +xkeO68$UqQ^@#1@Xcb5%3WBOXA$4!%QBrkUYrrD1lG-YQG8&heFfLN$3#3<$YjQ8PCZhN7qxDXQ#LZszUCdMx}ry4zO1ZOayrmi58}_&D3ZOJ +!)}MJ|6H)W0oY#b@%4otg(v>(k}nz)KRx|B&2$2yP#mX8k|r>C*N^yV9XR!2(dO@^8u43Um-2UH^WRF +k_}d$e!akL71V66>-%i=MZ1DEv#PA(5>G16t9_~JByS6X%pD5f*wuyMh*O1(q=k7I1{@OCGt5TrEj?exZ`{{R%d)GFG-bzTxJ{zC>EqvPhQkh#{1SBFfl(yKv>2 +A|cRgg^n2LXw<-1sMB#$6VdgT(4x2Y5A?=%z!O`AK_bmvCS`*88YPaKie!0{dzoAn?8|m;0{ReW02!e +dwMGkhbsjy)AQg!QLIzz8rhc1o)fq`M;bA@OdhKo5{a%|D?12;!R=uG;c8bP}SokEf}hcY+)*@+AE4_ +yK8qwU(0-%i;bCz2_d|qfFDj5;5ZYKbGK1gD$-1$(56CwI|?0D0{&oI$SywRDQ^&qoM4AX$oJtTW<#bfOEhJ;YdUmFg +APVm!1Q0}jQNV3RXlA;q<=;j=7V1pRg=*hy9N19~(;@=4w9Q8?e0lCWT4IW{=roHou&hldWUY(lS6+Z +|1{agNzEX_Xt{`C{Kn_8jj$j1s9yfc7g0gj4fsWiNEPh|nNnP{h6eTeoNNMcx~6brM)QlV-|xo}L3^uwwT+=Wq1=Y}EYYb%P} +32G!35A4ye<6@9~S*zp;@gL{7TU>KSXcfo!nTcGtAd%&Zt^WvPBo77z&#)-O*^Ok9kPK5w>(k6q)8e9@Uc{LPgd&<;->&b`|+gg6|}4m$%!v8N6fEc6=jNAA69yW%REY8szWk+a03(9RWA?MZP8Xw#&Bb_ZB2{#|}K&yO_4 +&w%cqVx63KvJ5vnbW^5?D6TEFgP`vjdZI>i(`#AXbVtYSAOd?Ri*<78L%eJP?;o#$D=Od!^JP-MbR*rpkom8pSt7{70ovyuYwZ`BHwUYZ-VU +}=wpbKzUpvmqQA&cd1or(C6`>lqCu&JkTnLTNJ$OyjAuO=bB{QKw~)Q)KD(uWh<4THf43QljUHkKnf) +Q%;H*AJ90Aigbiigv2r46W`D&s1}BELP-lRjOEG{``x2kUXjnKpm +9z9NM^3r4V@SH}xhN79B-C_*bIRv*zozlcjRYMR(0koXS}!_Ef_$5(%+5 +juGu>}mG<*bbW)fahYJJGu~kD^%zz_>#*0)`M#78z`a1dLdi$JhE2BO~c_ymgAx%8(dTa&!HKm#&jt( +qfdoM7$m2s|Tp*^APB{Nym=TOY=s>+EjFqW8@;Jt9U-@q84-Fp$d9{(;62;9;AsJi{<>hK6`8cp5;Kd +bB-4xuZLodDab~^s5oWUhK8&;3fO}1+ADqV#4&9pkW(&!C?xYUPmZRCQNWDGqj!4P=)r4JOi8I?<1A; +`XGBXpvUj9N=Ma4P{YZEJ9mHJPxOxoLALGlf&i@&>d^-0#zfX!r$sJQ562(v)*--tbGOpOZK0|N!k`L +8zgxZTm_VVy|vCEzTd>4c7LghavFA??TI_OSJVrZAU+gL&X?`@_V>Deuql3ikT*I*@f97EnTXS)ybEA +m3V`%lqiZ-qt4{}92>J|J@MTHWTkgA2YF%WU_6v0e9WL%rRbI(`?t$8V1(dWW73+Yo$5r9GSZ?s!G_> +YU$7otS$fX!#;-E(iC?FLO@5V +M@>0sPYhSY`#sCzFj!v@5mT+>nxWeuS2`n5m$&A^SlxM7*luLf#9+@$!G*=#=mw6{2p1%06XN3uTMOu@OXe$!0v?~twI`vgck +Mv3DNy&MqSL-6_K%hG{fZo3_ouG)j7Ml%+KeD1*hp~`Wyp@qlHyy~-% +b={#pB>o@)SMW^0&np&@4Nnx=f$krmj6m^73rHYlAr%vabTxe1xLDB;WVs4a9j(h2sLJ3Gw1C&qlWIX +JFE1mWjF5MWdp{`2+SBfGwT|P^&l;m7q^LNxMjoC96iHC}@WhHCtD3X`e1I@wnAl@J%h#gVegPB8D1^ +*+?25T`MckC5#$yIZj%I)eSm{&!L=2%Bj?n=-tj|VNb$0|9v^t4llK`*gN=2%oZ +5_|FVm#SKsU3eqUCjpxbZuuE~8-( +T>|TTi_vVQIP4+`JdRcd?WAvea4YzK09l2>lK2Gdw~)7X?+dsGHQ>D+(D)9cryZ=WEg*yktEVL*cpA) +Jg2g$Quj=k)l@@8VT72gam_O581|MGUo`u^T>7bg&{+A@HvZM)6ps}4<8+1fCY75mNLr1|UEN17JwZ@ +l2O0X~ktSE{vK+2WvU<tiTcL*6)bsev5| +%71B;xWoi!a?-T<`IMj;vV@e1u;k8q*{q4QZJEEU(M#;?MFh-hJk!8y(3?uyq0EXYb+SBl$PCr=6iC@ +)t|OybJ$As2@Xb~tj(>46=EC&y*mV(1)CAU47B4dKq0Q*%`WPxsDF;68~tPz_+fDyaY;!D3KEgTAn5! +eZvwQu=ZzA5VKl514@X;`7N-1(sGPL@)> +Wh2Srb!YJVbVL}5%)0#W6jOO_j==rtmMdF8sRXVq+vfFwC9M;BWumg~U*%GO&)#d@WjGu3MODXbb$=0 +4e0Z(y_R04tKsx#GOC+EanOooC?V4Wa2`Sql7JDwS=U2%hT;0%d7H3z_<0@NFP?s@t!inX6%kA^iEwj0uG~lT6K$fw!kUgX +n6GV(j;m(CEp^KH-p}@uzL*kc465V{4O0A?y~njwg))7`&zK?kM0#kzpC`zJM-SYFncE1-|2RY?b9RP +yq$Op7)Nitx!wB`+Cwgq-o@_|>Mc1J@3eYXIQIAC@`vdRMeX4eyc?+hE+}FTdr)+Dzh-omuzYmkAuf% +HOYia?6sYhGZc(cd&FYq9o5LUXw8zCfN1mcbQIr_z#rO2qt%!=Gqbx!}?Jw}em2 ++U%E(E8@*=5#o%v}%rXEK?>D`HYAVqRXU}q|{-*r(TtxuA#AZ!a3zvybTVI1|4RXdOCgt*R~Q5Pvg>D +d%hBLeRV9xW}#s~2J%wW%5-if5t$6Ukv#T^h}7}s$-yfo{miQ>p^X~TT3<)vKDPSn+5jHrpVYzJxPP_ +O%uA@{o{uIcit&@=(3lPnB6s*wmRslCBh{z$&7XHdDMmSIEKlGnhi=%PSlx4Jz7{?POMncfM*Q(O +ljSWEjHJ`EWmxry(aW8y-)pmCU-CJO6~HDDTH@#dxnDdG;Bv13DS@|MI(f&Bxmhl^O3ww0XS+U5stKHl~d +d$XNyr*7UH%7UeEa{@QtFUCMs2p)rt@kdQ2^>6l9Wto6~lL2#JJ~C<~aPx@wqDB+%I#LYOY9{Z1C5ix +77OaVHMN1+Et0aSi%Vci`Pasf2gF?;C``vDn$^SCcIDul2hyA(siM-@-Uv@RCKk;d_ya}1EHfz6E^tV +BBZK-o~d~SYbd%~(I!ItM4YeAXD&)sf@w2&eM>K3vPDZeKr-~I=rI_Drt>(C+v~q*-nYsrCXjj@D}8-vmM4P0F9!ps?ZLpPG^#Pn2p?;6A(e&Ou1t^J{=4uRoQml ++ZWkj?NUmkpnK2D1VD-1$lh?BnxEoc +)(SM9Wt#{|j;HVA9z}O7I*bF_tB@bS{aw_rr&Eq4C9EI~w>h3o6bE^wh;0^MkK|Iy=U$u_x2YJU^j!D +V+%%b?dCD*$FFGU)MIIJ33BpGn){l1>*@k$>T^P*a&vWvYLEx{o|x0w3b}XXL +EcF>o81s2((HikH5r_9nAn)tMoI+;8{Pw!JD**v?q&!Xbi(u%o3BNqQ5y_n8^a +7(HZiOtxFbiM%ixxQ0S`&=$8RdJ-+p>VRIgKz3tc!|;}*F<>>I?Ub5YDlCm8CX7h)%PT~k~15w$QNjRmG~2@P1jiw=H +%^h{L-;+cPhw;k!@h~C3Qe?YG;Dpy+HI%OASoc3gi?sUzs476vDYLncoW3}Mx;$BqadNETs)m2Bd4$P +{!aZ5QUGOkp#bjfW`#?5)etNyv?L*{XUf}6FbwyP+kwm8Y{`K%Ey?9NYbs_fDscHwN+H(rO&ZFzKuL0 +k;yq1RX_!yFkHiv}V1sp~cukAEb4TI}2hI~CV*=(xte555qPyYAM>p{8v9)3|zQF%aZ+ybw&F;@)fiX +GXQ|Zr6JF?Z1BeQ1ux9umAJ6W1QAqzL~u5_HQ;0K@jXW0>@dFVUeHJul|QaeQzFrIm{1qAYY1w6d*WC +Ga&7T;6ST+gYGE{Vx=Ij#R7-mLm?87|HWS?;&K4Ev$xs^_Ex~|ev%^~J$lD1cprf4qvhP +!;SPMGS4#k+5IXY&+HP|^3P>w(M^=!*j?BV_vr1K;L3tbm)kDM2;kwo&_i8C!6W2^n7zh$-1c +UN8Hl?y(04xZS6^2yB)5Y5&0E`;rItLdKR{ipH>kG^dgv`y=|xfClP#sHS@ZO~2ouE~3#J~ExXABi%4 +=E;D5Aj;Tdaz`W{LG9GxI!-1mSkIchB?$9$ou0=Qc>f#aPM}m7vSw9#X?xM@Rv1XGHTwPT4dtW#pdlBEx@;1Sg +7|JQ-CN3w6kA{*m;PKT!ftD(dO_v+m1w{m&cwwlh|XWLR~DcHH%q|DPr7_eBM3DwN)&bJ9UES$el +b9C1Act0kgNAg|bSEq*G?xOLV%RYqH++b_gDJZCQJ)!N5+wFA_BIm%&?4d2p7S-4SVUsl{t({dG@Ud3 +0PNE%hs$bMIll%2xx4Ml=P}iaE4TD3YYGL(YCCd`q6UMU{c2)yTK?TcTtaMZ +kyt)WIkG_&Vhj-r%Ry;?Hs^I7Jr|mP){R!}?8)v8S&1DH2b_;!bg{BZ5ceY-W&4MOE_s_Vx>F5EQl$&aY@pJJ6U^0@o{$-6@Q}7CSBK1Z2Mnu)W^>z5@JV`5&YeTf1pa_1l$8Tmp^=RL6cN4Dmm{}(sU@HK9dUAw65 +WSYh4R}9-PGA(FTk}vb&m$R;U;dKcvkAmHA6UJKHPKDGG61uUeJdgw1krQ6MFX!8z_+vNgxkm5*&*mX +`XuneL~%$iVNlm;;X8w@SH2%^crD!veL`hq-tW%4r`FGHzEqOqnyxdW@!_W@9oEOXHTL6kK4m$NIskIGC8QRN<(;JD1}*fwI9c>}^%y4niYN%9vb49HRsTk>W|twzvC&pm3%cOjT +gLk_3BWe?X3}^Q_Qlv8~zA<}#69l;C=#Y|4)qfiP--0SU>1}umpiq1o>r|E +{I;Fpu~vGK}44%0La>K5BkB6K!GZzECG-x-SE@bT`uv4{czA!0@xKYK($7pfV_>NKs6TjRu~0UQ6z{~ +kTgg{v*|lXO#K47f%2{VP0{=o4+ko!IOvjL-}sEqLHkPlRvO=+7|>Zo-csHq0C{NoCTaT!_EI1@zCp| +F^z9cQd5VKB*S~;nN)70mqu&D?l8r=d{HIQrH+;MO%t{9Nt5kejegS+7k618mc&18}76F8y!Brm4Aqn +bUr;{fgK*Z!5oKrT3YY!dKGyfB}&mU^1Qr0Hd;B^X@dj_b?b}Hc$tm!Eq +L+XwwRv(v90;@)IVnq{dcGSIdka0Gxg0s{ar-_`ibY5|KK^60M9Wnaf<#JBgspj+O5|)+{s=OGTzFGG +0{D@zvM6!Uawah*Dx7bZ#Z4k2A))obVkmO?)YVm?5NtDb5X5>lVf{_XKWmch`o;*rR<|xZy>i!=KYS3 +rlPrf%^nvTmOmd3{W&MGUF$xIBU1LyLzJ1C9_@Thmo;sbgA6Hm8=O;GXrh#LK6_SRbFa)(j>=Vk;aya +(2)xJ6iX$RYGRk*7qtUK}1&>6jPPB6#*&W?pwqFp(WYYdQl4Lp{Cz*5d<(b56ran-XiOu`e`I0EvWPg +pud>=Q$1NJxueWe6V+or!pLN^?ddyLQ*dUj{DT9^}mQJmJ=CbbJrRF4<*QX?uyxUvm0#AcN94A5^`ZyFvN^P ++Eh6Jpt0@ZA}MP;gntAfPS;>;L6+%P;WoVlWp6xTfS`%Hz31h4vzr!F(@thJEu56j_mTiT$wX(|En68 +abW+6iygiJDrBd5`+Iw_H=9y&vc^FtM;tlz#%bI(fZ~JyhYz_jUIl+A<;OtV1-9)MFkr>04%i=p3zb-GfF=$0B(r`|DVAA30wdS@TuuGf_prJ9os!7^LH~-zTJxY9;N@Q=5DL{hcZubOs}CBY!+)a~oM)!7Xhc6AlJCy&rN3u8e?N*cSgMCoo(#Z~N7hgN%}&I +c3;R+J*u}!+2^kWP4fFg+Ks%m*Y +Pb?w{O?tS%FDU0c#@t}Q2V6I|?-MeYrw8||6TtDe@O6p5E%ne>YyCf2>Y=aJ`hT+2Lmz9sBJkoUlVSP +mIHho`yl05MBu&tJE6rkDPSU=ES`lvJeW=ZW$4SbymTKm7cm>WwU36+V?XlvBE*CNGQ6W3TemG&svJB +ZOTpCzYjS)(i^;Tk1c)V|~oIkS7{q73x4ojBxa*NbMBiv&dx5XoZ9IWRcd478&DsO*QR2t>I5@PohZf +T6Z@3AO497+3fo0ar6dX#XgduM51eVt+`oEr^MYwclh_2XH3qP|6l7#zt^Hl^OV3*d7x@EvKZ^&TgWZ +N_+^@Vu&~r%_IMIjIz~Evb`=AA9!vRIf8j9aZ*GT(>px7N1RAj;X4R4rkSRq(YOFsdpc`5mxG^8>~1j +uc~gTQpy}xMP{Ascv?ETxD}@P59$;C>zyzAug;m`_P-Du6d8PM+FiG`h6iD{p3H#ubIcoEPu3A8zRs1#sHR@5g+^OHq( +0v{vo)9Z!q&!^XE_$qD&MP(b!gznqVs)fOWAz6b=a0v6BoMU>~7D1EGLVr9DpCAep*wdULYbBMN@(vF +)Y*jDHfNw?#U+akNI))+{N_UEvAZG()bOSvfCM|g+l22+xx@msmZn6xr_3g;2Ti~l&rG@)M{^aDEoPv +9Kl9AP|cMuXegj?M7AK)BqR&yO34_7g@6&dtO9qgUPZa`a>C$c#k8h(~Ehdi~1z4b=Jq$>VjqFHZW?4 +;9L~vNPw}m4B>g9PVC4&+pThY$)cA5Bb$~qVlxicu9Ju@KHWPYbWoV{iHu?uMiNU#?Y8?N4*vI6Yi{Z +Rw!SM6Eh9g?A`)!R7XK$JKZ#$3w8#BpVTjRc0Ha7=&7TYH$ZnIKC$i-az52G??ai>ce=mb4xrm1BB +&xkWMc+m{pq(!U7-VvgWr}=o>n>8V>nYI8bsvw1I7&yGh&E^wEY{kRRm(NYH&zs`6*Ama{*)V1n%EBS +EW0hV51HV|RM(E~QBzxAj;bp2>;6=9;;EN0RyJ^SjZ`oSkQk2To=R1=8(V**?~bSW<12z~)fdVVbS}S +`wCUEnkVz^5*f{4^BpV=f;Z+@yO_za5EyQdF)__@pcG}unMOpJ@Mj8hg`G!x{#u7EtT;0Jnp<) +Q%c{T@lii#`$#;VhxP`$#1WE}W(oGC)(f#KvedrYZ1jL%dgNh|sQof}E%Rb&Z~B3ZsMXLJ(*adqE#l? +alZ6!*x}MbAv*}eC6|s>?m@6&lF&k?fsT}w&r7FkBu2vxC;!ZL7aJXVmBcSuWe;O!id&eNrnigN+bmj +7(;_AWD{8L*_ZoK}J5}XYea6hw|{7~kySxAr5LeBaxP%z_vhM9h{tN(*xJ}u>64)K?nLcrC}fHt?y{u +C_etp)^O7zjOW1_#YSV>O`vdcie33HdVlUmV;h&^3C!>CSZP` +kZ~J|_)D{y1G9Ox|0+{h{A4oyV3l0xle~X3nfpMJ_W>f?hHvrT@qig3m;H{-P4}(W@?qQr*@psT1MJ` +Qxc;J+=Cd^Btu1Sc=?moWpbwE*?ptk)kJ_G3hRxU0{c5(*Kbh`VvxR;&-G5@V=AzSyJ7@dkqsRrXKDw +36RaC}=q2uSYf0Qg7ezFlap-El25n@H!0hSMrlgkpsr8=UT=HgUmwerk5>oq-@ckMpl57jA#pJX{nN} +4|_Nv_J!S>(*bJiak7ynUZO1*4)`exYd};^P@9I6LF}X`=E3U1J#p0ZbK?nciaD`Y +89}u$Rp@j%;#Vo`UKwmgncXTDtv+Wc~kQUuF9_ip`O}nD-t)^+a32jrm@;<8SI|#cMMGLR;Z6K_f+l^ +Ju}f8X~zzBEThDr%qK(hI%_#fPcHD`sqN7I1^b73EiJn2nOzB=y6xkK@NjX@#nmViq9%^ZiK8D!g}A7 +nM(bU0`LzxDJ7qA(hb<4+CZmk-xj*EsD=NpP5ybF1eKTUv&sGc=v4a)hhpaE^$QSi`~ou{%l%MEDA=;Mmj@;^&8w`|2^U1nZQ{P- +)=m-pwV#C3^>g6-be(mRZ*A2EwiZq>R{^iK1{ogKixBr( +b3AXuBefgXFcG-sC1p8nAhvA9uI!-rFr?(9PoFh~BX;^@*5jgC7OZNZ3Sih5o{l^3Uk|2yq-v#6u$V6 +;Lf&6f}Fi_H&QNV(LMm!93d1v{*iLYHivH-nzObTq^W@JE(CjKr_XFyqc`ldQT-@MZ)4w5XOy^jSR8c +qDFCKP@1Zl~{>_V#T2HT~>gEPWtBQq!3{KK5Q{geXAJ7P>^;ZVsLl#TgP*=fCcrJw +k!j-tcCxAAdJs`G7h>gN-bmx=4U`E-H@l~A)n=pPU(Mh_0ktFdM{$|L{Iy9;~f1|w(qvw542>eY{?G7TAKXn!O0d0Dln7CEFFZI3~BL?!uK* +cgQvDu3j}IFDd#t3Of?Xo&iy^xyzP8m_xouPQPoY_Sfc|;{kNaJjC+Uzlcrmt_s|Zy3|a&)1_mEXm@*E*THZx=4I_vmEm3;pUB9%nSbo;P5Wf2u>26E(CtzdiU->l__@GUF| +9t`@cceNr|5zg1I$Njtp>Dmr(cnWl@yy_CgEaZJ({JbYsEn04r}V0TlR_$>+@B$4*Y{lrbG`;8*1S2^ +<@o=Pd&!&s7Tk>k#4+z-an2c;=&hEenF^z5!ljbS$@|S)-?>`Zbxf9dG(8(72JeJ=^1r9si}KCK4TZj +ON_lfgGie>RXe6T$ZfhK?_Z2NeZtE)$Qu2&MmOnJ=o!0*2d=*%_}_NK)Vyu;%}o5pZSO;V-F}I??6+e ++s~or3naure8aTMGoSg6bYQj?QG;d49ft?I0^+eZL^J74t%mK2BioH3rrk_{obthXU8xF29 +zlNjgr6)GRd1Ln+1+u{8o#O-<6};+bVA+l`25B=r#$AeoI)qwJbLO6UzWLAc@Txe0QS7fO(rn|H_z3C +a7>+uK&T9`fs+)_9qKn +jb>+lxLLwa-3LB5AIeXb$xJ(k3rH8;Pp@r71j42vdWW_@s^kjDpo8@s%C8ev0-=V@jJHVkHgn|q;maL +G=dA=SE#F%E-%S>f)kv!)UQqLclv6U@-Jh`yU&WJg_F-64{%pj%13T3CO<>#JgvASMMD5>_Ti~APg-X1PFW*X|i7 +rSmHD=Ag>T4q6t5Pl(;dr^^l;;@H`yv2JMiE|Q(;Ka^snLFIuJ9#+?Pm7|i$g0w#d)jy264R(E>nt2b +`S4OpBTl7mfRb|6u1#*SI|(~U!`0CA98sH9blB!DOEXbi`u(D*nEhZCML!MlW?vF|VqW~wX&)j)lQtC +}qvdqRimP`OZb^n1x2L~2BW>(NO&D)%?mXhl@@jQ;zg~PhzO%Abom}z}xd%v=L>0HF!3mGU$X^rgYK? +ovJsb_Kr3Ny~xTP`MmsP=^ESol8djenm(lzCVZ)W{>ll}vj&HXM5yQ5XPwVeyPbBD;R^mySgIj%n+Ke +%jiemnK>;24t&1@1+5X~W57X-?LF|NTS^Ejm}oe4_teYYLR|9+tJd7$*ifsQkM9QWs(3-pa?y +P)xQ`;Lv%f!58c$prU8q}D=N=YBKzX?u`LrkXiBs_I~jGPBm>YPgjcAO%8{?X{*BW)-i^arc<%&9_`D +c=FQK!Qki11FuIvm$=5?NxKQ9+x^9l{7~V(yKdWmYWnc## +3arLO_9y2tL;Srkj``0@OxWJ5ogBxBJpBRzMM^z{9RZxH6yx45P4bZTIBrbjomZF8<0X;4dt+4bI9gS +ZlIDI{kLD{TLH+_O3H_w%ah7`OHCHn4d&e(!jG^gMnZ;Qs6WFYaGEWW(qTi6JaS|C}uSAC2^T2J}CU^ +1bb*FdAhDf~GM7+kPS>!hGo(v!G1^$$;rZ-Z5D;0Um7e5k!5{U?=ZR?}GYw{I!Zj@pgDOcNh>{zv~b& +=G~kfznx|L-NBf@yC)Oi#e%eD4ic{Muf$+C51qw;x68aczF7)1T2gP@4fsPpdE~Z1kp#4SQ187(0;Zk +3*+t{{9bA4lfo!7zU%dd0B7j``FI{8#-7ZP}9_H18`F3m(Ln4^3$v@-uC;l8aa5hBGncujwP2NZE$!5 +V#*POL)a-<@E=TA7`&TdyALz)UCZ`8~TnX8G~n`di^7tC7!@SC}L&Ns`2fLe{sD81vSK*#)Nw;6gzV? +V94czKyXZmHP}@+V{HkK2Bj{=3`#e=>bAd+2{MeK33IpD^~^nMAs~*Nb8ATEz@!U$>r+?@fi!_WSu#6 +2hRRH@@0kl2Dy|ZigSyn>yDby7?isE)oqIACmJ$xZJrA4Hzxax(FiT7o(Z_LTJ{pz5=17%@uy_xT8un +;^ZFJpqcQ)Q&lg4in}=}a7uBnrHu8Z(Lh!f(sjJ7A4omQ=eD_>{f4weJtN3tS2w0$Q)|Jq5?XLkri(F +BnTtLZrF>899^c%r$DNMpEfQBy=acff|C4;d^K+v*nUQx(v^h$jU1NKd;!1t}F`=@4>U*yHYn%%q%?)?)^X<1+_N) +pzN079A{p8-`2yg@&4gzRUrZ-MP`!+3Q +O=glLES9;9eYMfx#FAseS!?6nTBuJox}p?t08*1QN@lQ_RhC9Cr{HC4Wx$0pyy4rx7z)^=jm +)S~{v!C0PHu*v7r110RmsqCh!|^EBmxT-XM>&#fRFJ%-aep;WDdG4LFAlxf$#Q`{hW)T`w8ZH3G!zhP ++1YYT)dlHoz@Vu5(QA}B&O^nCWHUHxh>^%PGM_Oc~7fh$xysh2D9Jg|>Uh$&S#xKSUH38IVRFfs(Tqh +R|273ouLBlU(oEM`d!BHL?{Ld3&e*n5r<54+2Pt-HxL2M+D<(=M4pCwU0h{X-`VgFZq!5wUly(WX-Bh +j2mEq*~j&m_{aT8ICtOV-JtzWT=M&=kJMj$~g^h&ez?Vw@5Pj&{Y8NkYNzswI+wXnIcn!z>%g1wRImW%Xu5y*h2l?Uh(QYntY&ao@rd^z4Z?ex +>IeGN{97ri_soS-J*n^Dj@Hp2Mu^tisNeKtzMG?l0e#u&IQc1wT*eetDsA|i%f8u$NH7PGw|`gTA#XrPzA1qz24w#~WKA~c2vkv0P}YWEU^@`>q~7o{f2*^+&!V%xOm3V3 +g1h{l+;Efy9>-cF_m+vpyFz77uQL2Pc`rjhWjs`;kxnLm`b>BnzVS8y6l2CAdI!`L-*FKdkhEAI1#ti +yNoU9ZL%`%4Fynv@2_X7;nV$2F%3b>)|Jgv>1_4j#n`rmva1o*{in#ff-=ak#`cdx&`h`8E9pmWOo<% +8zO#b$nYw^CDuHwso$cZ?=2xNdb2K1*uh8Z|HNzhg%7K^r8&HXvv7!JD@M}c~zaH*Mx`y)G7%+)#i77 +TIrL&@En`1BC`dTOsD9O}U>_By39V$L-$q$wO4(Y4lFeL7vz$|u=|4WIcMVMSf3Q0=Ly*tHjx?A(y<; +Q|wOeg5nYVtJ42U3+oHUqQ3m$1`pVslI_!9suE-}8@U}VpK%WbJ$Ddn#7L$X|zvN +vC?xZ$9jgjN}RaK4)Mei@-ZK%%c9{~;sL^!7Bec4A>BS559JDrR)pI&EGco_0F~g*G^tDi +WLz!o)PU+26fhC3eY@8HRZyW@M^6YT?d=y|Pe~G+ZwXQ(M6cJK%m7&DRiGV-bE{I5Xn+0lc?`SKZyC? +Sl@8fv}#LtX$^XdM5eFMng|?FOFFggYNfn#7XgRARv_2Ua&)pLpHxE$r%!6R7CiGbsYA<1a*5a5lh6> +{C+00A`GhoUvv*SuxUzE>GUi?1?r(USU5215@h!lCQYPWoX1+^uHXD +!uS8Q-GBVVh`2vTjf;D!NT1+QWg&mzZ5)wxaZg6Zel)^h8z+g9l>f%TbX2XWtSe2n&KI#fR$HI|0FdFx$tVLlcOF(jaRezdIj+&@~Gp6*LLvzgbrr0|AQk +-QWqb7293>Wzs>dK=WhxM+V>clR8Zzy(MY{1Ts|#G{ViG +FYSQt3-o75Ea4w-AE6{vU0o^6nb~>-p-4xQ#zYPU=Cyi;>QOEJ*LHeU6?~h4zk9f;WyNu)%Tj3su6KaN4sNcovLajz +{y$}07iU$P58eyvVDOy|e>|T06HnOW{9L5gwGUQ4PL}2o7_?iz=ZSq~SCPMKC`Jmzy2~|>qzMO|AsDkC4` +q%6Coi11nSrS9R1$syJ(D_B-XUW7tD)C3p2^U9K>sT&jD`=%IJKxx@7m&CbI?p +LbHb)Vrx0@31PWaCgHotF(~rd;t8^BWxd$5r58C0f)|OpY0xxl(Af+z_ofE;-aM!q9-1uq&H`HX_T=K +Qonia$LjJ(XGs@ldzG%@E3aW5!YFIny-stx3l03#M&kov2a4&JB*VC;(4zGeSC#WfpGjj9OD6b(htrd +p@s{h(nh3qQvbNV*dULtV|5ykd`aJ+55eB_HE{;64GImu>^M=II!Es{xW%3{K4{dffNFHEh@cPL1Ws~=OIe?Z_i90E%watv%_CcIi&PMrTSD^Msx9mq#;K!n}rr124Fm^O>{+TFkle +^>$ot4vUaX${AD}ONn)=rxT@k+wr0>vSa_9JI7P?<7{APfrdOZZt6OidNG6)4m`v=xzW#Yk;>weDc$( +zopp*a7OPbeA_X#hJ|a6PDugeE!{6(WGTNVSfi5gt@z2=NeRJfk)zPxdUm?=3@!t9-b0(VB~MEMfEMu +{LmEks;S4@+2!A=g&CNM%YTvqeJB)y-06=Bjl7d!+m-Q4d5X?e94^)Ay0jW-JN)h$L4Wm>!LyMz+VJuEH#ZrNUP*7Y>QD8~iyd0;O>-PI;D%<_G+e7rcpEMOeXAJ$3L;k{`z9Y~Q*W7j;zCV +)1L6HlR-6z;nkBZ6Mm7WaEp>ZsHU4P0p-g4H}6yb%OADu7o!9HTKymBmRc5KH!!I)O}{3{n9QFyiRgS +zvdF66~Xw_l>3ir3 +HCv%d-Ks)UScmytX{2tfZ^+Ft@ETdP3cygj4-U9uWWEc1jo*bl|uL9{(0$juQhW`o+)qa$hs!^-2rX9CUiFk>T6f>{ +zSgOZvVBv7ao-L{9feamxRt#7p+gtu{+hNDX%~3KReExnn^Or)~4`c>;U(A$yLuJpAj2(xFs{?q_W2D +j{)M4(ldFEyT);y);WxPQ4e0z8neKpiv<+4bO2`&5Rn>?`RDmd|j`t;|QZaQRQTp_)3mYML!W?wH=dq +32{Wt`FiSIt^47$M{R{_0%V`i3F*I}ghb_Su$cJ?af=M!_UO`%aarfLykx-zwO8I%Q@|$X>GckGt9XH +QQOd5MYFiBDP3g9rRMf$$XBV6VsIvnxJbJFcSLhwOg +C!0XIc8W<7t;FsM6|b;mE*nJD9Ug1`fxOgTdIi6${{HS5{8PW;%Mt#r)9{lrFv)&dti*s=)rQL19ApR +?>>C?h!hi}U>YbegnL`Yqc#8NsIEDhhp~!$kupxB{e``yZls|1A%m*(m3!-`So9S-z8#c$}W7l?M`lgHBd|aU)%O +?;VL#E&T27CR|Z}9#*e#2l2w@-}Rd8r-|GyEsHXymU?cDJHm(%+@v +xENA^#0TAK2bdMMVHD?C|-T3S6OOz?&yI6KH6jD16+J+wc!`jYXXbIKjhmCHNtsy2hOLqj3w +*?Q2qbZ{BrSVg={NP3Rfmj>k|>&ElsWDO$pEbP0%stUpFjP7>xg}!Fl_FOY*@ERMf#S&wEhLJ3~%Y>d +ccS0LD=jaLv!j=2&1W4TZdGRXn){yW+QmB`rsJVP)Tdk{Bh4!rRq$|;NLRVKf7cArS6NWp})zVqxbRc +(-gItuFSj0(AURcCzD`oMxBXz(<0ZP?V>yXhyKDn8oA=ji0lLx!HcBUVxy!76F5ZhYL?HTC`@1JUQJ +cU#+)M&}f^xd}G6(`Q8{xC7>b2DmDx>!&*;}xzyXd)zHTH96QWwG*TpUJCls9C`u*+;myMJIh!afF>l +$(o;fWl#Gjp{smnLWoEhomuXUXPdO$UG40aV&=ff_QBdU+g!+8h^F{pJ7vCkT$|0*yxlCMEKNOpbGJF +5eiKa!{DdVEHp$wR6^+Wm!y(`GdD%?&Y3=I8Kn9MZHJO?{8bR7-tk;VG-?6%7AvI6XC4^{Z3J*TG8RP2CcV;Ep`eo({PSD(jyUdkdm`X(@{=G$8;$a+s#ELx +nI2X4C@d!Ae1ncR9Iei(ds$Id~nYd5IX#?IxZI-mv35r&c;dJV0G +Lr3GU(}t7t70`0+ZL9zN_Cx7hxlrOl(wIn3!;`05$`B7?oOm0lP#nzdLRf|+A?IqPlQSI+jkXlJ$5XK +qvKa}?v9T|$2jUJ7&R^l-c3AXSLr&*=Zm&2X;l_vnV}xVn&12iyB!q!N=M@csDr@Nz3Do7SK?MYujb` +dR?=PTXHID3+;DbWGqpW5+?a_Uo8u)d6zO?1cODnbj2heWvw7tG^_JX88b6%I){2ZGafmF_{x+WCr`J +6mhTnu1{KUSi{QBI(x&Os7I7;C-_H*^vKR)>rMg8K$AGq|tWX+)7bo1E1KT5SX1hv5=G6uy~0AnEU%5 +4T9knI=j>nd;J%_~fkfZ{%T_W^Hz67;*ai~$I$pg^e>_2vrR&=it@E-YdjoBaiFVq;K=wjF_yAke$PE +HVK_VPy7imH-gwL$Er1Q`>>Uat2&4p#bL`==VxN{t`6%zFWa!1T;$(@0#)L1_|abfl~+q2#E4WmG_@2 +l-|I}{t21b-YR7qa2h@vYJH~*$W)P6PzU9|5YiUS#cIseY|>?0gY!?42N~I;dBj&KZi0a8^8UrFf6gX +K05H9*h9k_ioK5soU+sr&GvqZtW)r;&v#1`Ie2SXL(jQlI0&}#zay7lvYOWd%1Wusu6i$RJYUfjAf#U +1o{lBRFm|6US@Aq@9Km5S=YZYqrEO?$h;xJ-X?7>6h+?&i&O>V@gAmxiSO&MCEMh{WdQptWzt4^UeIy +K|_IHLxuyxd|zSM4+?lbwrsvnbqfH;LMHUKsi*>l1Fy=i(4R24Q2xbm-VK)t?TX$DA=Y)B20LkB5*D? +_=RC6=fZFW(MCv*!JuFg^BZ~OhRm<;pC +xGjH*E&lZ~F*H>d$ZR>s>vl+WKMa*++fQlQMVxH&E1t^Q!xtXjBi#*#pO+rLG?e(1dL(dy!dokrcFvG +<&FZKt%3B)^wwJ894TQ2bSE0 +?%hn%P={eX&mlGX5xH23+Ta$F!2=&fY;bGMY*dX#Tyx-FFcfJ?{QE**=*DZtH~Iy)q9>^!__@=-nv@$ +pp`gL@$PaqbJfhKnaIUys-L%tSDA*v;|Bo{|5ccCkKk4#h`SU=fUbAWpufp3Njm$kDVpwCNT7Y2Bteoo^Pz +xR#QpAly$iGMU@kj8~@-4ie`sxEZ!%1F6DRH4=(>}-ZfsA=4WXp?f+#t9Z>NIQFVMUcE? +Mgk#r6RE*kH_vwS0vS!d%dpGK6_F_pj|G8#O%gi@4VaVb~zU`q^D;(5-{?G#n?zyiPS3c=(O;utLELK +eVmL_CUzHdm-dgn#=mAV-7#I>J1|?!Aui+{px0m +5S8a(-7cfaEfymRDyh|$);V*5;lG~75cxqq1fe%G^nd(`2S8Lr63iha_PJU$SXPDA9#GD)onb6ApI;+ +{g~T(8o@iH6Oen%yNo2FNvi!M!Wy`zx1H==pem93G@@?(RFbg7AYJd*S@jki*pL%|u^ruHY?Mn(A;~^ +g@M|nXp6CIGq(_e`kaJHL1=-YO{v{aTgl4 +5p`ggNrq#0l{jXxQo=)nU(^ptJFc*=HZ*S?!!Ib8WB$ambSLVP8_i8VM=C+OaGJ=}@dDQCw~^Vnj9{@ +vqy=rnm%IczW}W^^xp%f&WAoBjR9^Nu+u@%sTf(vU^?CL>3Iq&D$9%ykB!$o9vtS>YpcLV4-pSznOcJ +Wk<1XTd>bpL^IQ5?}X;P=#t@Tap0xf*5ly;wV%Dj@)yak_8J#5hsuX$%w)2iQ{E9j +|tgc6XzJDbzxdQu%0I{RL^&bEKQ*hQ0K;v49cT|zP$8vCPnH612fzYxB|~|8RhtU2Q#fW=Thh@qY0>x +ts9f=+~CVW*nC>!PF&bZU%V%w_)Xj3C$@#jN}{V4aSKmp=nDb~#Kpcu5!XWPTQFho-o4Sy!YeZih_f27b6L_C>6<)Ezp*%{1UjvNN2o+d6r_n(pPbDD>TbK^Y4bk2@w1bl} +u&PlWOF%H1ShRvn3wrRQ|#dZw2G;eo$!@-#yy1|NvK-)3m(93BN3T|3$EOyDd$`y+Fvukt|{&Q$V_wDc?eQ8YF<}HATAZlGbxkn2dEJ +H08mjA5nZNv-PY#nR-W4pR#M87FlnCO=T!H25;xVjLMU%hL6#K)7I~n#fh&eq)OiFz1PM(3_)T@cs3N8J76!G6%2wcQA$2S9O)blIvhl)mGI}{YDyTb<$(eq>%*% +oU9V%DkLd+QRfHCYHX6I>zODaS$JX0HNDgB>-oY5zww5AGfH4&2YLGdtvh&rJ%H0O!v}I!AlO>$5U(G +PSAbdKKtJbooRxy%%-U#uO?pehRUTw%RN%uLw-}D6851_~3>>0SORQHK` +&XxZ9hTn$|8>5OEdI>ybFR9o*@1+#Z`pIf4u2c+s(wg$$ANpS8bA_kXgUUEk*#*i}LnJt%O)3cWZKY#%b6fJ_v=0JAoewhBG3L71q{s4{c>?l>2 +Nz3^!Vh_Mlm?6PCvwj1sJQUY6b`Eieo#GQ?U_2h(7;=YxS}{8W?|~q3qPR1Eunfx&NC49J?$XM4y&xC +e#W|n#N&Hih-d(-R}5M%3Mk$%^rbpkW0EeIuurdg$pF_-a>(h~V-|gqZeXyRP34ecul_u%;M3+W^=qD +=kmnpR8qW#VIJ()4ePwe6{uO}vb9E;Z0;ppQtFXWX`Sl_2+LKxYdpzRm@+$zdv%B7rar6C2xKS6tm9U +|_!u|zK4^${jcE+5nL=VrN9;Q7zcy;->1Y`u|NB}m?g+Qb3bPhx$Gj8mWzX6b7@+Ml37hO*lJLoDBWB +U9xHRuXI5pG7jp6|@n8lp}l`{zOq$!oB)<46a{1wpB20VJd!GHZhp?jz_AgsvswGbF|HxlE;1CTRI4-2_!G#;i<)I~w$Z@nm@e +OKn9R&UFPOWKw9iKv=bNtuWA|?BGCnQPZh{R9d3bVxbQ)!I70O8AjLQnpm7dOw?J|EE4+E0amB69k1K +&-w}c5xF2d!cFXllzU|>RcjL5=c=gF(*$n~dHk*Y7;P5tSHTVBE&m<{Z_%N5^$vl))r9bO!s*S|PJYNWlY1s8dehl%fMC~PM +&GslZv#xC`(?KCY!G2@atrql_@6QaaMW&4hpz@zcg`%@irPz?XnAQH|AdIO`7_35mWF<;Tjvey8ztgw +y6KLb*`M_&p0VCsXW45vBluNqe<2`RxmITU&$jy1*u2r76tKK4PgL9Agc?2?*}gR<7s~K2yV8X&Do?3 +)Dw#R^?0WuEgCl?a-_0{kzEkVoqz1@Vw8*QCDpnQ9;*Z=u4*#uYG)q^sz0lTYsbwr~CVl&%+a)7|&6o +y=v&v>RUA{(4NZv4iR-36*n?+u3CT#*=gE~ew@!7Yblal7MY6{?rir{{@x%N-lWr1G^7M;&B+n;1ddQ +9=DN)-+tdx_OZ@Lmge?@Es|Sv*_UUVvm6R31FIFxBB@aJh$aB3lfKj#$Ybg(|9is5op^4UZHfjTsBA* +Qd;l`6$9iyBk#?Y+e;{FXribUU2xj1S*}|1P52?v9F{Ses)vTt!EAO7I3af@aXkEcAY(3_cL?*4FN7c +l523U+jO4BGiFBQ;C0B9Kko=l+JzW03E3%SBYmP12UH~?ZCczGrYG^5vBZ7H7YM%h7Rm~#=}9CjzHQzR +)>F9y8yRj|n4dG@1sfjIDYD#X7=2WV+=@A$*Xmm{$1K~JPywQPPGM4LC6d(%zCn|V9P?DS0qwak2@L& +Q>F)L(#io%SSuJCOT!AoFcK_f-C&We)hgXKsX1nNl8kCB8t&YmeA#!1>2!?GpH4+-D!lZ9cH7XLj1Y| +HbV&Tf87Rz(}&ACgJ`>z?FV{&$kn;i8p}Jz4_yE_RM^&k +kTO`(0Z(T_csb$7-{f9<5p;k9N+4zY*-A3-P^t2-0Myx~FFN8kFvo|*UNdx6Vl06y +>KeErZ|0Vy%B|{(c}`R9W%cKmYG4c@_Wj--`OTG1<3$d=~!4|1%~{R +s8eciZ3UtHY@uZ_22*J|MlO0``@Df{Wt0vRR8?<^0&><{+OEh|J~%i`rP*C>A!2``}EzlXFC>g^8COS +`>}uOh;NSR=B>iu&Lc!%d+BWe?m3c(_z+szYdv7%J!bQ3f38=!8EE{?)fZyB_ZvsMP2WI6fb6H)c5N> +G=1y`hMeK|LSt03--@GysD8-VHr$$Yyi!@i*!H=9=#%BiLJ)@I8 +3LK(c +QMszDb`0uY27*eZvqU*T8e0MCR-h<_tvJKR +@&A_kHpRK=DQw=S>ww`dm15Gg)VqmPP_4g|nZAo! +$>tm^JHa4@eCd=&_D*@l;!fL=GXoz&*W7!feE-5PDe)`u+Ww8x^ksSWw*pQwX?py_kv23^ +j?SgO6NC0!$=d88|na>w;bG{p{cQvl}w!c5L-~$eSp4oTB^cQlZk{<$?Uwn&CWPbXB;$~<6m3{LYV*+ +<>0+Z!{UYM&`X!r)MUT5)EeLT!BKXWNNZrj3o?zWk9XD;uO8rsIsRa9@!$i#V|DNfl{khh)NRo!))YQ +HlRPRjb%2#A3XX2Jo{vWL7}9iLBvE51ae`LxtHkT@?{yi<$mZX +Xv35c(O{9b!HR94f*Bdnj4fqJsmJ|AOF(v{azLwyc+XDH}CQ@ZZUNMZ6IDjw=j|S>{H4@M8HJ%$ +&m&r~)<`!pK_;aw@>uIns4LGlHvRN$%g;D?9%@s#If;;YAQq5m!cG4LaC;1}LNeK +XJ}b(mUk`?6+F&Xjl_(@h(;F2`P*4_xCqws*~3fGSxm%v&T^$))lAt8;_g>vgUrg~FUp2I<9pF%qLK6 +mfB*M_kiuHFhTBuDw~(R7bv_%RFHUcu74gqC-&NhAl!AzkT-h_@@|YL-bZg9HWco$Yna@F;c2>G2 +TgaooBpcL{`3wU1gCdr{ATXKJ$8@5?~2m5#YRtWB7F4C5s2;863M#@pG@{clD95#jO`X4A@&_GS~eW2F +2TqApauk@-#CHw^LE%BRgZci#JLyDCL+qUJ$ZNSf_^>=0k{A^l3pVi-C##PkC>`BZxkWjs7m|7fNn{z +LU^%MefJirs(K2(b3jO|smsUo%PuB}*iwMoJDu_$vM$HeyT{q>HlCYS44_Dqe+l`b&CavZ3X&V_}~Y3 +A7{7bXWW~uQVg-k0&T|xJ@m^t)GQn1}gsHR7$7Uqj>DhS1kwDMZL1AXdF(A +iLc!uZ|uk5hzDBGUPU<(T`*e$g>gmDphgEA^CpHxg~+0Zi?sNwU(fu_*Fkg$NoQst4+)MEzODYzS7uy +>GTJ@1;qD=8;7^n88WQlbnaav3-)tzOrpwb`l*>sIxZO4Ze>6@E4SsZar}SBr-$V-z9=x(=1T&-5SXQ^+VZ7_MNE+;XOfeq0D>r8Bc;!HKh)WjIXo#I%4PJ>fbj7JQ+T6kS24LHfl}O?TUzM?Ybu3!044L +plN|`O$k9e{#-|?h7{GmhF^#2lz2V|KEA%ck#Ov@h)8|?WKNQ_M`4` +TKEr>oYaw*fw#0M^IK0$|vv050q^o$->Pr+-93WC-{dpQ5~Xu+?ICg=R8Z +1pb>|8sNw< +`O-TH&f7tb-=Z@+M-93A+naa2Q~mEWJO3blD4!{|K@UU_LjhQ6TKa|%?%`X2RnJ!7=mx +jw(T+-U`Ubuyt~@XX^-OX1azm}+V35>$PO4zyB6x7T5Nr{*voeo8~mxo=BdALv9EWk{j`l|`!85*!|{ +J%we3k^Z$DUVdjj^2KbzWLof+_}sr`Cp-&=0rUuxG}nmK2UX($eed}Y+po46H6i}BKsS(lng)-^zN&n +{$6tCe|KYkxB=CeqO9bc>cNa_=%~WGC`@<@*D9LofF5BILP*+w5=+GmVL55I`&q@?T=U8cm1ixn}Xja +LRF)<$K3{W!NC={*A`(GJb^$FIHLUc&mios$jxwkJtw6bxY=xISbhE#fSq!h6f9G{W&|WLS&hum8XyA +X)x}_?CQa(P@oe+$Akm%-{=ww=b)@F`a`+4`28EgN<;PV>dh#WOI5&B*4D0+@?P5etPzo%HhD-kKJv|E?BRQW@G#>=26w +JFvID@x=h_cK;XjxVyUz;@&IJuBKh6M8J8rDB;>c)7r!~!)Jc5tr=t`* +hK!4%*MH&~Xz1SO6x!({)%}WHj&Ri6)Ne`kx(_deAk;{pydp=2muqt=#TchI7H5wEBLk@ARg%K?T3tK +L4BZ>%edkr|jibNt)cz`hnA@GTD(T4IbHxg* +O2(cZmR=B^Ko_uj7*~Zrn+|3^AoJ0mPgej}er+%EXX(*B;^H9ye&E#T-l*J}n`)hX-7pX&hUg9{lx)H +Bd%(xB{(+B|T(kyx!}};EWTwoTx>7G;=shyb1kvn*QO{K8rYre~Xjf1K81<8b2u3ZEN)#*S~_e{mn_5 +WNoXUX?O04VlPAsepB9KgX)imbJb?*_b7c7ylL--F4-+y(!@y<6~TVMN07W|`+s@#55Pe)8SU9d+vxw +uH1=?OlEm%vyOHrW12;LL=L9!d*_+2(fpgXFFlD9;_Ta4}(jSM +)rbM9|WJ$~Ae1pL-62ZOgq9`BtCIJy(@Z>J~IJ)FNs3E~~7{8A_niFU%j?O*7$)A6P6?ufl@6MvW8ML +YV5-fS4#Y(em?5`e#T1CX~c>{}LKXWff-fuZf%8&uju8Soy?5C1e~f64C*L&MnDm_74Tx{S>}8mC#iQ +^Xf+U@7*SN{Czn*Vy@$%G>uj?fW~Y&0q4sYqOi+^k;6TjOEL4q1~H{R!L3vfbXK?4>5b!usHq8vd+=7 +Eb4ps*;VproOYNgb>(N>dW8RY9nXw|wF=i(FU*Nht;0NLcxGwKq?FCehkMvi>@#x^<<=i +A+xkE=UYeZ=J&z$$LIw(PBI?Fyr?9UNm3_?PWX;kFbJkEC$EIUox$MD19|*-&dLe`W6p6h-4T%~^S*o +3bo}N!H35nLSY;)sLbj)>~$(&>0o9#9&I97wtAfCtYOcy|XMFN*dqL0_E$rGs`Up%2{j}db5qYa8SX` +N4fa!F^cRymar9{TliJjim`r5S=E;W=hOK+EzjRPHv)hNlb<7NtEz_}U_T10UPE@l@!wfY-xAgXX%#r +t7&DVDQ1*7T&bHpnw4|gkq*bk?MMWP3NmR$}M}nn?rOI?U%lgW1WPKI_8H59pG$!(0WmB`mQ8EMx5XEvYxh06;de=r7JHq88m26CQhv?GRu7V+r8eES6RyUzzULAXR*su8 +T;_n3=yWxFarm#ep$Nj2ZVRs^U7>*EewoVMy=xc~_14nogR0AV+>CS6$s$J&BRyRxS<^z9TCb~Y(c@y +Z*BRn2ER=A_&u|UuFMva`fJvs%dTT$KMz;%1S3-wrcJYKhR{BXHcifqDWApA^aS>5(y_k@S55Tz2&ht +Mg0KybPoqxBvfl4JzJhmM@GsQFrwlF8m)C(W&t`E9y|VJTrxw@{ngBeT&55YIMbE;AUzA_^3J1ehwRj +z_;h;ajkGh&fqaZFl{kOqQli)AnD+0`5?EbN8rKDZuRn-zz55>|CB6U3Jv6p@f#icdlp8Vj#oWzhn;e +h4j#5C_CEu3t1qe&DXG;<9T3BD!7wzMVsXT_9q)2Kup*ih@gDeJ)O_Ac<0`=Fkimr(5?@+%T#q6#xLK +iGxtrL?7gV$vZj2O?5mSIWrnxwwix4?-&2zg7VgkKtcmYE)au56BM!c;i!r-rlDE}pm5p-ZKRnknH`C +mX+JT*7Z?kpVAbPV)+7R>cm&*I0Ee^hdRqhtLx8a029_J>x|>*id%y_TDaHX(c-; +_Y4E{O3Q^2m|jTVeaEy;5LITb0)(!n|=7f;Iy5PBYo%Woi5YwRai152m<^ySUY +YWnlk-#%GSp_Aet1X?#-R7FVOY=5aqoc_00yhmwf?WC^k26f&P`}P)36MU1S&dq6GCpWW>B~*mAuMC- +Y&Em_EM*Au`p(oK(X=7<{^1GF)YC6h;K_05usBn*fwbRgCQgi;6wIYMkkM1BXR$?#i`J-H~EzCBqN(X +gLRopJqiMd-$l7)U9|_%uEA_;R;LLcUB%!X1aPAxFHZo;N)#38BV@8!~Iwk%xl&MEn-iPVSdebye?Y} +@i&Kh1l*9QuIRn>IzR{M>1aBI3?m;SC|Sc0dvGpmn?Z>?Jm3jx2q6bVr-|~jI9Pg +Gm{O3K=w^^YF~=12AWe1>sMv8p=}PVI1NP*6WuA)?Gc!4v=kOxdKquB0H#Zxer+DkCQ_f2DQ|RQ?YdV +OnIjXj#p)u9>rb!?m%i?#dD+O?7!MbG3#x>!KnUv;#SK-)>1=T^iA{ZV#z +R4bS4;k%P~$=G96k!}7gPHW#er|U3l-ob}fS#|G-pU4vDGe;5dM>;R#4T)$$;>0g1qij4iVt=l|SAzjL`^h(K@>$MK)J-n%G${MJSR|3Tt=w?7u_AJR8VWDtJgvBZ*n421riaOv$(?{ +#eNg!`_x2koo_Ft$6s+pZ5GzP)Y^+%xCtTh(Q|ER_7h^@gIi&K|ZW)8lY&{NG&Z%^8Q`cOC!x8k_5lz +;Cs{bdUJ&4E@2IS0CB;;^FT3?~(oV%^a2PN%_rZ-`m*mKkZv1_c;FRE5ki!UI^+}C3D3Oyy-T;pIZmqlQ`OD1O?l*?XC0Mqp*SGDSq3=2c_7*i`rTNd?hE^&q@OK{A=kwa!PW +O9^=56=?g@|FtqrX)4)8EQ|^jq0a=cpP%R{(#4cyjGZ9TXv3IoL#jEqD8&8kJ?94e6{}7ls~c7P^rpo +;VG)zU;|gZrgI&P1NxSuyM_C;q?SYuMnYeG+_DibQ`f)eYJzhI3(d~cRT6bER6kNEO4br`2~)a`vg^x +GXtxw^1U6oq&Zue7;4}|m!r+xHpkJ22{VOqCDnaZI_R)iRz4Wgt2~lg92n+Rn$B@ +IyWSWqq5wG*Ho^i*`^XrsI@Z^O?c;>2qC+GA!S!k_e5n5E^-1*z%hQJ3e-M{3h^Xw*nP5Zz;b=A1`h +aq|7E7x#uJzY=A%CQWd@IqU;zd%Ul!D=FWue1EU`?~_A8c0rv8?`Uo}78IGbkg#orGVVbe8egWQRV{c +9;CJOw0BJwbvQGL22Y!XE#PcPvc*@in!NFc9^5!w?M`Z(Yn3#7>`cg&`0|VDJRO7 +)<^&r;diZ>@7y_G2~z~bI8svxSL&KFa0L4Jy)H)S);LC*7oONaD1+lZZZQ~A-p +783ga65VYk5$u97$*)9l(>LkjUNs->E#lC-!Yz1jjNdu(?PA+mHZvcidvjfQ+NZbE_`DeriT5GkyYMc +0SLH+7eL?$xofPO#bLu?2=ZJ}~d_KC^omz~$FKBXPQ?5O?k(|)G7Io?X_gPqeKVu8uu`|rz&lqdNZ={!E*$WoTCZ=${6oI|!_Hb1EZ_CLMD8S8M({SX?` +`&GWi#)@Y9vZ`YI=`BPaYGK8vm$J)P97y#ZD-+Wh|!`m%X(aMD~U +4BMo%x|8-?;U$4wR~#f0)Isex3Vv4et``1C0{V{5}e^COhiWINA3ySCy-q`O_nn1oM8QW*Q`!geb2fM +$-qUn+(ZkqIb=wlOCA!W2e!nI9Cm@lmA@ShPXK(Dpa=ID0qgMEU#E3e+NHls815CCdCHMP+e0dgMwgp +>ggd{MA`hisChDC;iiT1E9{j`RZ6Sf5p{>nl7nheRt7`pxnVHGGOl-jL40n9KhWr@LqbM-Kt5R(kcwk+8um$VuZ;T6g-oZeKb4KeGYY#!ZxZ1*UmWzdl>?-V8^3r-ib_w4q{2E(1i5@=u#Ar&H6N=RIp*L&ELt>W#O2{0=U{vYMguvd^`s; +qh?c3k7EOMXEVE)G54lc!V+s?`r$e|LG=cT&1$UAv2TDvP$&mL7khu4kv8s +f2L{4j3Ib7#oIq8}hk>eD|LtAcm;V2e`tsuB)xtewC5!3;Py7G(GRMTnH(24jgd!X~3q~T{Rfd1DOz? +`Q23EQ)8}tXCeAYD?W!qU_zha|yx%cM{`>D#QE +qwv+-d;KD=`UBJ_XdQtgOy5!h=G#+Gn)Fmr_qj<^d%;X%LOr-j?suJl{l_iG6#1lHLu4Kvdo``!6@{v-lS7%-yX+l-b$%x(tyXLli^K7vvQT`u +){lzBN;Rd6&*gxB>}e4)J2u>BM7PHfvg){I6GnN9^a>H}~bfk4P4{h;=fd%oaU7~fnWd!7u(yzr(d`& +DT^^~pTneWxA`L*PZ7E0yz6>yLyN6_f=`E%P{=^Q`K)euq{XBn9={Tm*}T-DgS8eZukA+wDe5LlRqv# +#)i$zxw(vsNI<)8-Tvg#O4Tq`oPyO&gYOmaBGT`OtCHH#x)vjMFO>a431N+6_kTZJi%;wXz+S$8Po+{ +m{QpZh(BiYXz?72@rNsY8;7FCA{-~%Lw^sLgTgE^y*pW&U&TiD%uQ +4Yw`JUdU&G|cNvJGm4Ab*46&H!c!{Pwe3f^M(;6i!q!|WCX4N+5hy?LG0dJhism;#ZR-H)iRhx%H?DN +t^t9YZcE?1Mc8s^47a@j-GR7un`3QT5iHjf|?2(M;eO0k47$ +$K9CQ$^(A(%vn?ZXKJi48iQ@NFx)K}4ARDJ=pX?ywFy?GcSQeluH#d$l9-7PUp7y+;Bj_TWm8{Hj!9Z +)$+{QiP9Qh#j`Udz0e^(!e)xB;kGg2JLn|-1sfTo9qk>SojN!7?XQ1#dZMlR!B^e{dC)9PCJ#t4hL~` +58q(%oBjaXq2w+ilJ3{r85*K@!{htDLTHcFZ1WG{9ZiDU9sN1y<7v-U5ydA)G$>8NZt4Z}NmV%-n>R? +4@KR-esEXd4y$QIj-v@AfIGedI?&dCb%kaO$x-X>xA9V-w%mr@T0ecSVyX=i;d`H?N8>dP9$S<+n?EH +@2%#Y9n@Fj4umqvb(BH4AG|{EZIH}nAKUJ9^NDVO|0uluM7O}N;H`M4qEC3sJAZ_?dm +-nJZ~^)Lb2iDJChcVl5lzy=s<0|XG*@hoD0cu}*OE&bFwq_blw?mWib +W}NPrR2a_s!^HD2Ma(;l*;<)&Of7SnHO;Ism045ad{M5O`!S?LcPr?H@xT6JK1o8)q|8hbz+du<%8Bl +pk+8%KsxVg7LD{I=gW;ukh#nYESUGuO;u>5m;D6%PS|T~JNOry2K4AgD8W1khA!Z$;)_Vp^)!qCsWi0$L%<;CP^dhJO +$7xyh=hHp<%_4&pq_NuvegEdbYRq>n%m*XTl&Y?HqFiWfYN9t37?L+$7@X*1fh!Txpfp-1>6CZP^`k3!tEZtPrZ9xVGV&(MJFIwR4Mhaj^Wg)!!#xk)a4x{ZdD89}>Yc8YE +cwwTvUjIyqpqyWE|O~7}Uw3+A}z!PV7PAa5{LV5xZ$27<21{A#Cc_jQP^W~rLE(vemrFXx|S=V<_poz +Ws>+J(R=OiibEP9l!) +Cx^JQO;iBk9Lwa{%r8Gvn?>F5R&Xzu#*RcJ6S3aS-zm;$n>NXflwhFWD!geT5`p0h;tYq*dTEN5yUkh +_mVwak5U%IQeyxSW_v5_SBswDL;-g^5kqeeI#V3FGyQ269WS7V}Q!}Ko!2uRX(hwQ*Di;**;X`9>!IP +N?GS-#nDy;j)ffDo3cVUx@2vfY_i9<6VMFPPc11#+h%Nd)bV|hL!?rLFmfqR#9cX%vWJ(R6YGj!ucxE +f3#tRXidsa;MFNBd17W$biahR9v*O0~@gThuCe_(o;?)E0o*8^7hi?1!h}8CCW_PsF`25lp)(d&n0Dj +>U#Nm!GB5P0G@R=CosBJmXUJ8t0zAm;DiOFzzQ@C|TCGk|E+-YhqR)2}}>0|=Ulh793){*9M@2z#wF! +ymm>X+<+=`o#dLFC1QMG|WifYY5y(i$@%gv{gWp<$?_03*#0XK%hKXrt556{Tx%;UC^D2<|z;E|gf)2 +BO6F*}$)U6KjW8q4i6Tv0lC`ZcYPk8DFP|_7q;x^|4Ni6J=NKwx+QXPMgycFH)_&tdM^mvtp3jm>>gK +&=0BaIuER|&OmxTvK9nYS$@2+eiOu=gyTnEyv^#mDBP`JqPp%XG@bEMVo4ky#l-Rlw<0u0L#7ZoAK8$d%w3pha864a3Z%|ck0E{jABKtsO2DG=wynhb?;T{7-u^k|8P;Ntf5%#NyAGvd1z{q}lgzPwujCS%2JlJWh_P&~UXBto6ow*>k3t|W08@`b{Z +{<2xI6L1=^h%&nC1g~-8T%FD8+vLblSd+-*;}{v)p%7%~{}vXgSS-MR{N2jXPxIzU==3$hM +2^{Tn}*eg27F++#xS2y!Xz9n>Z9Tr7xglmH8BWR3clO!2lw&np@xu+^csMW-c3$TZE4%EJB5)%Dl{>KPB~gF_6&qF{)#o=i(YAJI!NaUW{CC$IKrKYRMf_GGL`zNb970YrJ>Uh9j!A +{3D7hbk$ho7=Fr5lcPFSm7EQ)ED>=k}H)scVWO!=WE7^h(OfCV?EapGe2<;dZOwj0nS;+FDHGrg7pBC +yf}y$5I^1-^3~FHZ}K?BfL@&jJE#SKzpat*eI_qqrQuEoS=mJm!G8)WU0>>$`f3F*2Pzq)%|z!T7 +9-JQ?d`Z0zcxp00P`8I|rU!eg(iPHEnv=~JTUz@oB;dpA%_#;OG#g)~HqP60D3YB7{2@kMIrrGZ{H3n +0{8lJfBCany_DsrD-c7)QB0Tu>MGmLBkJ!oXdb5`&*?%hN)RP^5LhiH7g +W2+d7tGxL|?9w?Jv>Z6ns# +^vQKEsa30H+MbXz)7bfd#PGVk+Z;e2|ar^6F6B!tD#+^Yf#FjJ3^H8-?ol9uL$15b^3dbLbEfR`0s>4 +9EYkq)s+hR9aVe6TO#aCFHaHeQ5r^S*QCUnH|(3A{+z9fNof$Jr}4>>_LAf8Cm=>V0@9UQCbqGh}){YRk^{5PP|AIAOyDt#9VgFqCA +5ft38HbNo@Lcl-o5rVNj7L4fey90>7d2u1cWNcayB`6*Ni(H##Z;U1|9-r{h{X-`w +`AvAJ7!7hf2?gSmDx8%v*%#826T==gDwi9^oB02@z75C^C{w5zw$Tv1Z_gK~m-Vqs2?wWStTV6L#{}G +0J>??d@u?;z4?|z}+orxvmy@NS@la+0E@wcJU<$5ZVVJdq5{`1D;|6-`L`~fOi_WIEl^DR{R*!W)!mC +k<)DitlEQ%oH2o(a8pEo3G{O#mgj%#MfA2ka%-DodwabwVF6)MeM;h)hvK79Q1PhXCX_%ofNolY1le$ +D3k4y+9EG%{4>JErPk9LJfZ$`nCtD0`ncCA@0KA;gOxZmLPi$G#|X1meYljMNJfcpHrbn&cF;W^)r^| +4qsa|;cMt6;S_Grx2V*g*@^dwfC}nzI>ypas)TYOH_zPDz?10(Asr@wZe<|Wjs%!w94~M$-NX7BiPZ( +-?E{3F0^M_NeHWIK>A!r4-YJ)>AW>Vy~@Jsy(I58DV486vXEi$p}z7X% +-TK0gT_k=c2^gAs +`=W)9>_#GzD{aFE^`w%F0)MaEqgsV4)2>ff7ZdRWLk6SoV+~iKvxj=3pTAi5bF8LfMO*szwhqlB{Y*QuKG-gc@vla5WBkZL3RI!RN;mWuuhyG`ys`O2^J +hs$~M@*lQY6%Ai>g@O(IogG?~z&$!p?Y~#4`HonaCNGJzi^xx*dZK`T+g`Dt%Lt?h9 +VSHaANUA2+Ro};1rA$|(;FiH(ACws4`_ao3$MXxGQXI`q3v(@dQi$08swwVg +SDxWa>sUM2vlR75A4WY@!Khs^m}+@Nf5szv2nOnLD7@1XFgjzejs_FC$Gc}Hws5;FC?r^C3X#fLsFSi +`^vb-NRTe=;xio;gdXUxg>_+FU2vCx$|Ie!^Kdtm*8v%yvcg7IaO9ydr~r$9%}bKaub_jTRliU-rd5IR#dU_F$`zN>N& +XQS-^-=6=K137AA*~8H9${83D32w^Y{0H*DD*++GE>p2Ij2fnb|X&f8b~|E=u0mK{Zw?K{7sxPf;QaU +KefFajj(8{P;BB!Mtre?hx@PtV+*bIyI)AXHYnfR$O9Yc)g_z9l%sMPrFr5u?g`clQrTCmv8nctSE+T +B$T4ukL9~svA<6pV69rXs4E!hWJ#v +vu=1{RxyM;iegl~UAr0$mCX$Ha1;Vc0qNpBJynw4(YVy7RqP>Z?Z|qT!` +5Lj>b%!VReNu-bD~^u3w>_fQG&yypNl+FeBZ`6oqMQ}@%q0i}Om@+VCCF7+1*76xNTWWz-SO)wNoF$n +TIc$6VKlGyd%@;$_Q!xjj;hmT?CzSl=*AJq?R-|=IxKak(kp0fB}mHuq|q2!0(rPu?vw~tt{yOCIQcj +b^@1gf8HI}+dBJ?KBtrEmC*%6BIgiv5wJA8FqY#7XiUTcPYO3b#S64fpKsE@Y4OMn9Y{8_wGR5c(PRK +4$bo>XPqXC4~429Qywu;Vt1>`kvf9}Y8nt|O)Fr>m;xh9#(s*}9ykys);_7xWdjPeH^ +;}Cbu)v8s^@!GanGnZwkOVh7Kl$h&yu-J+n3^WvJ1VEZm1vRkW29q3P@mNkQUNn*(%CBx!nl_G?Vd?M +_lf#RBJpIq5psh8)5Ang8@&AdWJ>xE&VuF! +RB6tY0KW^B=WT)rjBpmanKa;rvU8zE@yKZeUfQteZST~}VvbYjhS=BkMNT|nkzUogq)|=L~E+F)V=J} +$T#lU8mpdmsNTMnt8OV}dtR9mGEgZ37z^f>FWj%BrB%r8WkDFen%`k0cY1fwS}yx}W_TE+>w;l4xa{a +LTt15yO0U)`CpOt1s0b!YM_;zdIa>R@*WS=R-x9Ic07zhvbwxPx}?V<-*!YdmZ(Y1uHh2ilPhk>aXe7 +YVLbn{Lj2f0Dy2sWSWd$o&YbMRukpyG6@B&U>qcM)wui;4lx*JBnZ7l+aJF)4W+9s-xK$6{!a3Q~L>` +pNMB$&dZ+0@k*z{4pr!zOWhX5^uoOj@fVWz75s+8MQTDk9HYQ^N4NF`MZR=R{C3n4X$i5a&u;9h|4Q_ +>r`0d)C&w`K%_eKaJr@z#Bf9>~_FDm0Rpxh331+S-zvr2nn11utzi$0q&J}%W@HM?((Ex+I@xhUo#Ar +AIe*aTI{NLlpOidY1R$(sr1@el>r#huIUyGqM2X;?-NWYl$N^U!k_g#EH+%tV^u5|VU#!q5|FMN2KWa +v+_dX?Y5kT{A54gj{zp+K=gGI0x#uOQlH31l0nfV%?O-H*b4gwm2jJ_Smy2eJV|dqbMrXJ+C?zysixT +g4Ls@)DGL1ChNSr>)#}6h#2p)7Fv{ZY_dtzYtAa3uFR>)83%?Yme@J4EKg*1|)!c133i{ZErnnJ>{Pk +jje}m$lK6ko4f5J*(y}~$YNVq_lCEIq4n1LVy(*_t +2U7*?EGsS%hHjs?H<@QGp-QIErxCsay&?oQ)N(!=x!vRnH_>ByZm0JU!A93BYi@uXpxBozRjTHy^kRE +PJH(UN(P&ziZ5!SAW{Kd@>V4LB-6&?)fORzwhoYQtMOy>uuc490$@?Yr)KTEkL+ihvz;yoYPcLpf-iM +Jgbn^d8x?o6EK``u>xtcL^|5gqn+z-YI}`ginv+#)nH7~^Q6+q^m$ +#HM3iG^zI(gPrS|D)9qfg!~yvXr^?bV3m)*cq`MW=7QC}0?~QpIU=TRu;5S~d*W%OC+~Vap^ed^onza#s +T3>ZfhH8g+V)&?ukpAywC43(I&?Edsrs)DyADI8MpS%D1ary6(5C5Nv-*OE9x6)tZ7O +CF~Q5Wp)|D^Lh{W7Qa_&q$`X%xS-pZ85-dUvoE#l8#8{sS3gy1PXQW;ZDcYIo0We=~fyHui`@=9BFCN +&lpfJ%ywoKiUYz9~Aiy#s|snJJVmi7xb>ZM1BQ0erTT+m +cCRt=@eWg;T1fr}n*2xK>_=dEx&1UgctIzA8-VEkjp^T$(iz(E|F>h)b2bAc<1RJ2ODX*c|7Sz_MPey +6xbA0C$M&k1vfUs1L*Q@vMT_Z&A=2!5C+QwjNEoa6t06L*7ng)S5=)Z!H>wS1dtRxN_>(PTYTeB!32c +`bY()HphUj&HIP}ZUx__YvApZ8nqE4{K3_95S4tHt|>AT!tj1%ZTSSJ&gy;X`>#iZ*hnjp=)B5DeHoM +<28@5e%dP-H$i?p?P<4HX;bC8tNE7o?)HwSeB~wOi|aSC`X3S0uK)z4)!2qSs~ACQ-Q#=M_SLUbt4|J ++bh#95^N9nWxcQQMc*360T_J6^5g%`_AG!>l;Mk6&pf0xLCMXXa!$E1~)yrV||kne1x4V#+)?ACSYnA +Li>oc2F>Ce6MEB)c|IOeFTgS;C%Dy{h~IC|eFa+83RRxNi+dlEcqIZ_mLF-b%1W%`=ltpom(}ll1r>` +_N@koD6M9=81+OLBW4}&Ph@iCY>UYJ|OHwVZ?M<)d-f^QPm{BpEr%Ysq+l)DmwR7+bhmnXLi`Az*+NA +S!z@SBY)mUIyec{BQyTTWesLPS6Gs$>Zo^g*I^wl)#D+1saVj^~VnDVf)>}$bZNyOJs8|$Z)eemRzB6 +5`UBQHO+fV!P@>ZG|{72U7Ji#egZU*zauE6&?^U}IRDn4p(QXh9u-`{n4tZ`60V;AvS-01}osZs18kS +36lnzGd_}iC90pUdDT+)ZX#o#Jp8LGkrsBoUj%ncRo?(p>O>8er=3w(u*^F)YW%+gLVEYCDZYF9}moX +c`!c1*$pC1X_zmUBo(1Ycy5fxVWe-bpr*AMzOB_&UDU@hQ`c8zF0di5=r+fzHY*j0>jYJjy?Wx_lcWy +n4I(a*Q(W{^_?iE@7?XPWz2ube1<3y*PX)ohBY*o5y%(%!E*lTNk_GLMUHOo({VAr(RFdy3GAm|U>JY +k=Y#k`kqcJ(EvXg}0u$MgZazGWa_bTn-P$R=rERLDpBto~X^Rf4@;>~`X`^W1J=~Zu*$w5RFkU!nx0K +1ROI0(y_Iug%|8g^^@6j#l6b2+r?I7~BvqLe1k2bY*BUxF0sZJDPD)-1wcyj;G#T92Jq7t=hJyZ3K2V +{Dv|PO9(E!zc!M`a}2Wf};CQ@|79{Z+#GC86xP8jl3ar{4l^kWTrpEf(;Px7rEm`D;%~Yn3Dq +~#f%0Is@m~&ZT`RzyRk+UAXMmEqCqih8XMpSB9#_!E+Sqpb`%V&M!XWgKHtifaxUI{O!=9#jy%quL?t +29QW*W6#BSXOMOj(gQR_Imyr=fi-nkB}N{W4+*sL!z?_JY3JM%Tdr_OYDe1Kbu{9%AfG#wrqxYVspm7 +mDc)SP)h>@6aWAK2mtS)wnnWnFOFsb003nI0012T003}la4%nWWo~3|axZdaadl;LbaO9bWpZ?LE^v8 +mkUwwSFbu_aehT((xVzxaw-y016h(#ror3Iw&Z2C#Hsw-M5-<7ek^coKP;R35$lrVWZ`U04dSkhgyy7 +sXHVEwTa(BTxIF{xfbMlw(QwLzT+d)m5Vl|BLu@=Bf%MttFa!06?vP#6%5)Mk9RLP+uZ*!OM=MS9p?7 +6my@Rr4OQ~^AB979H{MP%zgwkenKnf_*qDV~w4raGe!iWYyddPUr~Ndu4Y#Q)$hP^+#ZfqY)?m +HJa=Tw>5PZkPN%DZ`ojr;JsLC37=sTFcrd27EXEub2ZOSt<7(;zpHNE!1QY-O00;o@p|(a;-o@N70ss +KL1pojZ0001RX>c!Jc4cm4Z*nhkWpQ<7b98erV{dJ6VRSBVd7V_jj@mE~z56Rha9FkqQ3aO@3H8wSu! +m|Zp`NNLGL93>8ry4+Tk`jvI0=DWsJhL?GvhZelX(xOFn>1(VM}G|6-2D&AKD6IlgWg+26xs7dvF|6f +mPlfAa`6m@mdB@2WLHk*l}MP%J8?W-F&sTaN0YCDiUM~gCpX!;->h0`&dibLkLH0@Lw)DoSyMG86lkXoMhx;KP5 +ht(b-5ATUV9E1dmPM%q4g`-~?K72FBH2czQJErOayNFGZyO}HjCpq(JJmY`4>F`_=weLLorwqOl_;=r +iDjk?ZBAQLXHaR&kz7t&=(S(I(mwxhX$Awl$u-yY%)NY$^i?-x{TGw9;7jTE+_yjCD?Vtkc~=j&+@S1 +j9|)_p6i9zd;f-2fS3aGum7Yc +!Jc4cm4Z*nhkWpQ<7b98erV{dP3X=QURaCzNZ>yO*Wk^eq_MPrNsC7*_ym-&2o%l9Xng+W?0XV2{M^uI{R?$FHiJFU0lBYf-k9YVOx!=y%t@#wQmSmzS3pU +$^_N=+&L7Re!`zQuM93lcKn*>FZ#m*p_YksAR3~@~`RJ9}B$|2h~3aE&n=5)0_O_!haolRU4u9U8{Q| +cDmh*2dU*s7@}MjTJDCL$J<^xE#`uM!7{p|``)X)4A1LYmc42lb3tVDl9n%gyItl=47%Zz0|v+r2eh0q{d0gR%_@}ABp6?Xo`DjcSCe-tx6@$N +~m1sD^W?Huvd)~hX>h%V!+~T*Rp6(L5%EI;$D4}4a_NtWYz8q)ff~wJaSqmil(C9JU-&6)#_d~MeTdC +&;)RRqP=dL`j|8CwUUi(Fdb-?LdD;;+H0HD3Y@2r2TvY>`RrC^P{;3^^C_KCaOFN1~0gE7V%!{SCMR|d`frj15x;^A>)0tIh6Ppcc<7Tq}&EBmX!&W`;gU| +Dg7B{YK)Do>9`uy$hX>)(N~|Lkn6xKVp8`M)q}Erb +KwhH^AaKdPK(0xlBobQ>r&G!FcQo@ja-EBfW9Kuld@LX6ni-xgiq0rj>HV!Yt$5(=*V=&laRkChPuD`u5D +(foKrO(H<>AFvox2HSc< +6Ng$+`#c5C*C#^<2&s49&ChqrrQ^Xjx!Exy8r)$(M0P0=*c}pM~T*0otLKwex^emcRxw@bG&nce%R%n +hCdH|-ywAQ=Jxi7*U}ikAae*Phh0_8u7zI?1Lb*scqsb+6kioal|@~HCWBvULBY^jSuclly;2eU#76M +>AWa_;JXAOo#|TeFD5`}aM0fvmFt@X%CiNOXDX6oD#1I3!JH}53P4*t7eVL2vTS-vnC|9=mYL#u=))_-d67-r9 +s2|Z*zx=z9cf1+Pw`m#9Y*5M>9~}o94)P>7K>!IRZLY2~qNpdIG+0jtpU+x8>`$ ++10A#%E{u*&|pP~egs{(#rl#c;9q}ez0d9;rUS0DnOLb6B;}B_8wkXJeq`m$+io8&iU__1--4P;+L9a +lMKxtTRMKsW(x-KfnqN1fLV +Y`V^D)#DrEzJFX;H{308U7`-Z4>K>0~@Gm&-S&bwel@&M8XmrRnkbsI{CNfJjvrffivAe?sZYA=BO0V +~-&(7R5zi7wDs+WtA>sG;Ku8t@_zWfm+jX2eMv)*uZ9x545$>K_-f;9G;J55(6)O8;Rn#2njvB4u)-; +K*r!s~utaEEiwab&v*C)NJB$X!RqJ!sufQSaHtq3$~c|X*!pOIcr_QlExUpiGjf?M +*tv{U>>h%FrXib|V53H=~`RG5KClvX-(a-?ZL{EbO +A<)}K0R^qcr4~Q^pltZD?f{u5fnelmev^JCVY@Bmor;=5w8dYX1&V7ZXln9j0%h;0GmBEV6w!Eb;=2a!l-i*h)i!wA>HH@me7`7kfaZ({k)XjIYI>%%%d{9%-L#%=w!*!8cwR`G``TP!1fcUd +yio^iYBmjW$p_hBawXp)F2oQUXSBjq_r8N`PjG&+6$@Aigd7j4nOn9-KFgAKzyCZZgBYFbcEh4AIw9sR58zmb+vQc$ii0;@w05D)!OYXtej +vcwKP})4L9+vS)JFtCYgW!zJ-u8@gxfYLHkdQEeCfsb3Xqz^nRN^(bW}g~Af44)9Y(W8HA^2lSPE%JG +$ZgJ=44%Xi+j%4gDg%7J5NOyb5pd)GN&p0fEc--m$~+e^Qr1(TXBnrCfo%ta&S=0JYaV!x;j4BZNaJjkh+)1|B+vb!&Op2iMapkpfsJirCumX50i@o&)(g|v< +jAP>CKI0m!0q;u6xbax6XY6byqGUE1K~(p09UNM8Y$@BqoitBaDjAcR&NsFZ&~&(YZzvx#HeSE5%7QA +}K=LK4^$VqlAyL%*2+lJOz8(#90#&!`0;CRl_@97Dk2xb5}m0(ee{!oT|6Uw{@17W2DDUpOy5EC3rT; +UB*&1Gg6(N&5nfY2mMT<#oAkq$8N_^m8N0TvP$lc9)K1p +2mr+5TZ(tQxC%96+oxLKq&4OIE+xZL^pw0-foX>-oNd>|sirmgWAhE=(a<&wq=ne**WW^@B5*Z}Hx;M +DJe2SHra2{G0+2vdZ2nwNjlm$oqMy?^(68tda-q~ONa+$#@vPmp40~p5?A@aS9Ws)qP;64a!=qfN1D= +dn_BZx!o_C_C8OIX|E9HnSzTvP(aGQTsPcq7x|0*!JzlxWFFT4_w6VN=IDsS~u_F~|R`5SHhv5>H6f3 +W>!NnF_j_xq8gmAnl9IgK={8=IRT)03{LVTdp~Q0Ka16yC+9=F!C3ueW${F?!i`(s+xGU3)MsK@=JS) +!UZ(i=oRw{&3CHTd>CCmv~)m#2ZNaLcuF%~*j>+|tBVjzf=BGpRi-f~__^sq{)zPPIfrVt-?Jgb`~lg +_;o1ynm>-KDSI?RxuhdAFm|Q(}ks%W|SK8|wekF~&(wVptbH&}U>W(7i=PL47EuIo@33+TdV)(NKcm& +@|&V=wr^w1E(S@W?;BjcJY-HJw|JaBAm{DDkR`KMJq$*fMRJjZ4)$ehO +l(w6k3Z24Ch;B^J0OMz+W<3Y`hj%8Ul~@U?sd!e`x|#g?Y&`At9NtEp3k_(f0YkG!-rVjOA8f8$iW>X +@=@Qj&JmNFVo2FvET&X=v*CyyUl(R@$d{^{KuWy%wk;py>r0+y-nHE#^EbU}=r@D0u;(akhn@fCNH@~M&!xzz5+`HGskr;zZ3mwd_(Fx~Vz!*bLqkHF +|;L%55*7qr0zxP-vo)3Zwj`5;W49H?0``g38X51gO`5(<&nb?LhK{lMeE9BLb-X;I97JMt2>Fo~1D&xnktHKaG?lxl>(=1pl0)JAdoM-afS}; +RDzPZ+rP$HFO0LU-EH>-(UGFBP&}%Rdl+r#i=Z~p!v4!K=~CQdo|pb(z1+*@jVkfe{Imy>Z5j`^Cru +pUg(swFQO+#mV=fzR8|a6<)==;8pi~cDGOcQU^nHi#xMXXxrN2 +iVcIB^r`HTOsYqH+tuBZsP-B4x1YKXX|Uo6d~vqsxB=&IDH^I58MOL33)a~l6T%A-6UT3z{qr&)_DlZ +|5D?XlyFU<)LA#it*3LKo9`InD{i=g{2pF2l{*c==H&(-c)T*B +gcc1GDMz@)(dKLcD;BZ;Js%*%05CmzIgf4?Gw9z$(jE?z8yf9&G4mxp6;Dvi+`amz6FhNrUwq(opFSY +k6(NwgAes8tIsh8R&E9FvVHOCy119w`}NoWFuH+N=lCCJ%)d>CF!?&7W{1YqaQFrio33Ukl3f)5{;KP +%yX&i;#ML+JtJmwRKZ`%SzRgapVE;&KNTM+{m|l0(G?{;u&bvf&@!b56lY`r?#5g9#?TFjoKz!EHNh> +COms1xq@;BC1xsgsOrw+;f9r;Hdm*eX|sjG7YSwYWw%c)y(gYhCb9f1Lij5#DlGcEH_{WF3O=_{DKpXaJrDbco5CF7 +QYQg$Y0pY2w<*&L(r7TbOXMd5}|h(7B012iZ8=+B!h2i#ji;8Z9>Cym(X~%<5RO0hk8W0wl+Gs`{8Qo +p=xf^HF-eKV$vwCq79e=#n3d5SyK`lz9AYVu8E2p-e9H{p9r1044$5I`s>lrPL1>Syho%M8Z#xCW&Bm>J6Gm2csf1N1dm&&pu`oa93 +9KEG741;6$HD;-R!X;rLW}o6*UCqrKUj{HJ!Hm)q%hnAjd!UlvqwGNW0Mu`lPfdCu!3I^l@~_Y-jvd= +Q!CGKA2%b)4sWa#uB|qQzfMQ=(8pH&VZZgiYNIy_~t18f*%16B(Viotbm}dF_vfpHlLF08mQ<1QY-O0 +0;o@p|(cS9vnbq0{{Tk2><{h0001RX>c!Jc4cm4Z*nhkWpQ<7b98erWq4y{aCB*JZgVbhd6ia8bJ{Qv +z57?}q=!I;_|i*Nir>jfl6^#B4J6(gfw6a1cMe-4wDw>61GTb!;x!ML0YqH#g= +GNr^`|--tI7hsA{Dxe3?!kZ?#q$n1PSXV0VxtNmeprBF$~|9o&5j2E%az^dY)wff`{=2uuR27Gmj?Gh +0<8nvvoxb6O*Zbs;FCf=OOdeqf`V4oGccQXfD#;F!Z~CZw>l*}!0#kKl^wrJ=8@)!IL`8d@FQ^BuVeR +*K(vpdQx37BFwQ=A@YWU#6y{;2hNACuUTeqp;Bo-a|v5)~X&{#^cKod{q*MoxPWw?l{HAeS;w705qH) +V2T_D9VGRKR5nUv$CLMO3@l!CvtkoUL2s*OiPCk$5>%|k#x52m?^1VytL2MH +`$b0GV)nWr0Ov%-&@^_!)kS&OoS%>MxkWs6`prpX=8Uym%RwAJ3~n0F0!!exStclLp_9j_x*i}CHHXc +PlK6KA_xtloqum0z14$3NQOP$}#8r+!A=CM9msW=T;MxyuM`Cq;~wn_)S66paLaD1Rr$!BMFVC2$dkl +%|!*4RB@|2pQC|vQ*X*H>;GBVa5B%dJXV>a_*sMv~_`nxtZmr@U;X@Z=L +X$hX{GUbs-zmCQ|qz7RPRp2QruwqA6!VgwDJiJ7LUK5;Pfax-Y!rB_B1peC$eJoW2-J`pcA>99>dqVX +03v(rDuQ!krOOv!lfH}rM`u-6fVmQ=L&w~3~kFH0fDlF8R3LfCn{sc1Xrg?wf-bD_7m2f*z$nKih*C1^FWiU^IPnf)8nbW=!mLh{ZMCY;o08mQ<1QY-O00;o@p|(aBcKy7I0RR9r0 +{{RW0001RX>c!Jc4cm4Z*nhkWpQ<7b98erXm4+8b1rasZIMxH!Y~lW-}5OBeP|W!^ALO(_%Iku*nAVI +vAwpznsiC(kg +?=++q%eRwv*+ISHm2ds?rb-(U&bsMkb03g=h=J-n@L>Py9wKo5qN@cHF`onbtqv>+sSRycM&y7k$etF +ZGKjkeV?BpDmSX1!W3ZiYpeijwt(Uf5d^rr|cLyqEZhmstRWEzP;*Gnh_~A6%EFb4vZKIvGut`;!F9t +Wc6`N2g#Z$R0ETGpb2-2$cB2-1i!G>eQ*@Nl1zU$cJmYyNW^Ey(%fuI=`K$6IR@CYjxc95T$9x>pD%N +$qjRl+WL>(jp4@b`}temt@JvT&PV*;m2efB;C!&d$x62}jY#j +48k@^U8HW_|nwOAZbW4-XG&`S(_;MkSjnlZ86?FaL9JaDJ650hMhb0Y=%Rd8tHmCB?SRH)(w0f5!>oU*5aK3N<$pvn{8D$(7Pz0WnPua6lG~6n|vb=4%T(G5qTwa#SgcQRA+Cd;zOz0Ef&e_%~sYa +cIU>)RaIRp(;<`Vv@Mzi73v16soPc4*3!0mo+^1(Dp{($$#?QazH0Q)N!m77rrD3@=Wl;VRla%#g}Qz +Pfb$L#fBiMB7g)W>0Mb-k%4We8iz}ICvYra~zP&Yt&|E{?rmO4pQmUk_iz2^xoUC(MWEQ$c;43T~?@` +EYr5e*mmaxTgu>maP+q7;L>#E)Wg3~boZIc(KGjvdL0X1Wd<>!^$(%zXa@qvKP3yGt?tm_IE`wkX;4% +=C^jV^gxS4{;QufP6Ot!M||;&4V%2T{jyp3%Q!uGZ*c`RM4Jgx%^l +`r1Av}4NIR`Lf&lC#$OQACv5ao!0g+S#-`uZw#Xa$jp=KO3z>=wJfDO%fDGr9XQme0+taC7U8Qv4Gl@2S+n;4xC2GMpSDe1;MSk0kfREgu@4XM5LvFO{g}o=v7)2x7 +dAKSAZv#UI6#1WtP{l>&d~pmoLuVy?lPYcz^!v{7lR(762$P!kx^f!uuSF$0v`RHtVV_huWMvZ7N`r^ ++21)PMb#JdVz~B%;cuj=8sMr*w9T{0u2Xko*YaLUc7wu?88sz3%j77&VD{ShXp-8Ie7l&_4&)!=Zoh* +et7-2#rw1WcnRf?PQ(NF@AR94v-6kl{JK9pIz2cbQp(!RRzV4VN$AVL!NICXl`@>koV1_w&v_ZM2$;- +h)_(?^!f3hP*AL7vDU5d1H$14ppA^h2{aOLn1OCZt7Jlw!?c9XFrAN|x{@t?H{?lhkyA +~adIUEY+XR2HrTJQvRYR5CG@Rzq!^j&nNw-^BW-(SfzySpy_z*h%=7OgJAGQN0`cpI+tD~OIAhiV1Rf +;G|eysq<-SYm7XCPl~WOG$z7Rd|E|KaGS8x(aHq#jyDfm6#T(!aHSh{tASe^iHRr*x%yzULfPFL~ +tuOKh&xwm_XCi4Wk@W#FxHC!Ic_Nm5e=ta2@`Qk6DMtsz9f-m~b +R?7LVHS6}q|D-h>Q`ffRhc5yuwJKDoQa)etyyzHIwcrk7oo(wZDtR9_}`RtHKeB7x|y;_{#4(GO0!(C +xAJKS#^^L16q;Z_|A%pn{hXfr;H6z;-UM-DEPf@m6fcyo{;HDk +c9uKd)OkaVSE`ak{z3nMX}T#q|GF^iO`rWG|}hmNq99R!@A0dg3u1Ky3`%hYQeP|Nj|)#{rzKF%llFA +v|$u4%_+fY0-X{&910mrTJ*UdbCt9h)A)VJ1Y{nQT!x4SPz=C9)sqJ8WIQY)NwfpI|`cB3dQ@e +!iiZNcL_mHQ>9E*#_S>PA5KaXgT)$S%tFhE#7CXR%*>8Yvw45xOL^KnFb%HMO8ez=`}>D5qaZ-Oy#kS +Vd0P^{|?FeL1Pn9s%O@OG`if?1=sx$9Nax$gix-UndHD;WY3GXH+ZDKFUXJlt_zLPOs^#p$8G&~MAj+ +Ji$JK6VX0{E^mmdOL*9H8Gqyz`f5zZQ}$rr#LtX^&0A2H%N?2nP0Pfn^W&Q1h^%rIbxCxX*FM81(JH5 +Y|?ATZxXNAWw2;&x6rlmoA*y_OK0(L4~2(XM%&rIAw>nr|!P@xg_Bl@}qEHG3JYIzAn4;&U9Vq_p +qh1>xozyy@|3c_2m*g&|OULb(5RTApW1cCWoDah&~f7>1MEpnWA8id-)RSqi$rgW2o>7@a~W{JbE)L| +sP5;2vzjK!x-9C_+G6_e+{uhG&ENVA*gM*{iD>>MFtSTASbqf)95Qhsg-B(bzBL=RSnQy!VGUL)=s(C +C-!+zaV!*|wIuylR!Rk$`a8NZaQf5tkCEf#U2?E2Npq&)5O><5h|royFRS1=WNmZXX}DL_bP^Vu!kM{ +0{Zx{BuZVP#dO+g=Zk{odt~`nD8@nB-F<%;4esdGwL{7>K@{I{mav(_F-#v@dIkJO@-*(qF$NWo^QD% +vk-!Ur%NE`t9*5ZdWb@b1~3hIu<&5eX9lvX35ujMsB|xB7sSgo3*{m}!pgA0&6p)}7Z>$P&w$^&N9vF~h)aj`pD@1Cy5-< +f&y&B-lVq2suA0z0Mn$iDs*zO!y#EyM|yvs75i3gWGCn0JO^^T!|gAn&HgFw9p1^vJ?fq?^HCS_K@$w +Yk!DRD}s(nOF};&sx&1%K>XJg4HnrZrB)1R#QCk{zYZHkUGpF9&NurS~FTU2`qr95@xMs|1a^Rq3U)M +*x1G&CH2^`t+&s%$j(SQv*dHbFbyHmr!6++;n@-& +0p6#l2j*~hM(`pp^JcMNR%sarpQt%1iCrNarl7>A1%4?Jeo#hwhhM}L6BHr=1Vwu5!l7{!f-=;TELW5@FK%n~wssYwDNegh4MM7%GHNwlE~ir?n0?M96?51$LiOJgh9gN +*?;f6^AAA=aqcY>&SSRHb*>+fAw<#>l>VzryZAfNiRz@aLR}*RL>aXKtwYz&UwvL~DKW9P}B__4oGZe +x*J=C7sSel%w>Rv)_*oU__3hxay0x +<(^V@8QB`t0+?XWFUO0X)4evtGeKb!WZ6nfrP-aX$ZLibveC=*ft23WYyYsXe$VKYw_CE-tI!q~XX3*?W5Ys>bw`w#Y=9W!jN8f_0*4`hW5TT2 ++rN-=SS$23iR0E}h5nP6wn@%{f%JP9Y-;#E_mGuCVw8=Mg$}BIq*DBDz;VuDK`?D3f +>%7Fzt8^!I&{81%O4O86_H(*@e~}Szy_Qcc9K(wuFJZqZ9H(>P9s(FRl%-A;bvmbt9UdeJ^Kw$GHkSF~nqsl#F{jcolLS-v8Z +?njnioyAoI0SE$i|8(;741gp;jF>h2O|v7n?u;{kQRup3N?cdwp{$N%=^Ti6FwbsYpovj}Z+T +rk>cNcM=S0+Wg331$e^jY0_-lRi7>jqe-S_~B#i;^(~+depcDY{BYF3O^{C0p@!-bldlL6Y5wyKvjV9 +H390BdQLeD4CG&(UT)B0n0E=bu_x!W=ewU5i?kjlg-~3jOM8tU$Rw>Vl^-D?2PaK$sJE9x8y{+5L?^$ +U{7e1&4EPOqPi;O$A`U%BL!ZO9vc5{UO59d0@U;}ytSyhVS?V>wAr7&W3e41uJWPM=Vj7gEu# +MpOnD3as-{(9H@n6|5TD^mdIMxCZc;Y*QfPN8&R)EJW|U#4y!b=UJIXlQ3K#(!&QP%% +NCFxU>kDbcHD|C7dB%WszRUB8j}!JO}2^nobR4Yp)6|1lSy%?Lrfw?F1E2roBRFr$&*7d#d)Qr@MST7 +tx=i5YX3*3l|0+no$VA6}~1OhpoKD{D5&8KDCtlgDlT(uu4J-xnI7gWv=_OTg=JF+=qTpn`==j(=TBP +#U8l4>@m1@C-|2yfXn=77^=yUg&$u4QS-K8kR~&hetrQ^!zst$I-Jz}+JoL5qH?vc&Q8`7{p8rt7Q)E +3?bF-+fs|f%snJ*JU%yhMe{0lqu>2(tCqfuFU9T|j*||#)cj@`@M?;H-c6hJZJPjn!r%7Odb>gz8EE; +2w6-Hwc-b-0D`hJ)YZHw@PYK>HA?G4qRKa`%{LN8cF|G<+ZYt`wgi%04yS#z|5V(c8|KJ(3U +|BbL8KF81(z*jQdbfK~)s- +M_&eyC0hGln;?ZxCxv%ejGRL@6*{2|om&oReR8JL(*i7-?A;vB&<FtI^&};~?U5>HSWguw}KdgKJ{hVz84aisYU8y+Y3sf>gu({TvIeLYndeb)K;KsEUt%6hFX(xJAy@b +6vobH+Z80p(x$3Ice=o75Rxos3P!22*^AM80sj@Gh1HjxN|9Ig14S+s|x9EqPXRpOX(C2;*ZVL~PML~ +-0t`i ++s`yoS+PhX^XZipyVU*EX&NG$22HnrU6?*p`vOMUdidGv&lp1@TQDg7Dq0?$j`y+iD+-;z0-n>hA7%k +F7!HS0w4!kPXq=yU|~p@n7NF{Y&Mg0q@=u#CbXKMrjbPvk^xpF*d;!hiqlDdL+;B22oR1C2X{2Q5l(_ +cKwAGOCn`L4&NLA0;6R4@m+`J(LauYy?7ofi{rK|P3$TruQasP=rEKDGsEIlIgISGx<`#GDaMoHio(-64F#U~0zm-mX=w0G5@d|h>GTMCAA+^_BPusiN9zUP~dhDwxsvGWrx +qq02mp2Np^_F-g-1kRl_W%bNLP#IBc*CCv3qjR#jmfXHQv`kxBnut7QomRvErEz@Thbfkoy056pezZW +Wbe(xEyEko_D#%-3EYGm?nT?&IJ{R$p(Nwo=EPoBjkJ=F8k1P+!0>Wug1?5sEgT-m1V~!+>UGz+6Y-) +Y_qr{K6f8^Smv}M!%7m0HFmkBtyGOOWw7Co{x6%UT^ev|dt10>SI8(w|N@p^pC3$!e7RR39>q^>OO<- +np-_%{q7iVoG;#qkMEcilUMalPhx>y0Me7Ov^5O7J$q(}wu7GNEKcp=wox>DVipic1~9y0PfuczJvO0 +}fx;jlJXjzrIP&(?L$w8@llHpT}0hj{OzpKN97N37Rg5AQ{aE>i0lbk6e>n(KLGeqe1X_*^^d^C9eyQ +aQo|J87lE=|A9oprEMsJy2-$uEWMzd|r%7=L{k#;+;KvL6IVj+J9@(yR}G7O`1dQhK+S#O`KCYI9*a; +3moYmD52Kw7L{+%Kin#MhJe#F(PDH!xtWZV%6{C1CQV?Hf5Jg=ulL~{DIQs`^?r$p8htt;f8r$0a|Vu +oXGAAcb?HhvO~)qebO}>B#oayz!}*7t8xr9W(OuDNu34d%p==M#Vu4DaS}ZUD)vhTr>^bU8^vHQ6!Y$ +VHX}G9-I<=0KASxx&=b=`_aO5(Wkq!m`H1k4N~>-N^I*er_|sAFvQm%25 +a#rJzQd&b#ylqXVB(SVm5h3jF&eER4Cq?_k>zdr;^J=d~@;*lHcjcNsy1@Y(US)0Arx<>^Se7XX1sI{ +$t7M$1q0<`o5w|fa!)jE6b(j8OGqT`}N7Na2>37B?!P_7hts}`DxWxYr;ckOPV~!Xr|U4PoSAI7~jVf +IMrEve$2Z=GYl5fh3jmGA|c~sr-_Gv4~nL}T-NCg&GPSUUYpFr<&vE@bY~oDFZ6pTrFXZ&;WOvvN&vt +hmwARaSdmF{42uGvc*94hUlo+*)jiqd;RI$hwB4_A%-cd`+XRi=T^>)Mb77c`!O=M!#z|0gr#z(_=af +tUw%g|>0BP@u48VP6Z;;=EnQ{Eu?M~VeGYze!7~HVVVIEWFtWSO~O+ASsMC6wkz6T&M&dDS_vYf`QNd?7 +J8q#19F}H#RL5CH+RwG4N1s`OZ*xv9OU^Cb9_NJ;qEvheDinav@Q18XuKH-*FOvWeut^8sIpE6EJ&+s +*}89x$H53?GBQkQU98iSsTB1{hC6$}0B7iwAcZG*e;ox^|-F$RCB@ynA{?B^HO(rbz#`3s~66Le3rUR +-)uh!3cDx=HVjFdZGQd5lw}7s<%Mru{NhMjjvEmqC&VDy=Kgs${mAmzk)1EKcb;F4v7T5RjuLCL9;8& +7Gyw&kOc%^VKz3k(y&?m3~hG)C?3*2gBf^9%7@Z@E=|YIsmLlqv?w-xtNT0KM&K8zeS$4qh~^cR@d%OWmWz|*46*gXdGD^7>fK!oEpRzT%7|fbmoc)YmN;?!1ad +4k4~SMx3GGTjp;kn&J2ccD^n~BZ{ja_$#E|rXP+M2a~nA*q+87+6U&u-z-<6W-F@u5GtrpW-N>S#2!# +>mRs|sik#mjlG+21VcXa3%4PWr!;|tAuEz1}RW^VykSCpzqY7s;HA6iuGJQ>){yPyEx@Y{Wp(UpUCj+so&!YH>xt44iBw +-ct_)cV9x10Wg14={q>d4X>x4J=l-NZ_BruMsknkDZ0=7_{C2)ZS2xhb~n94>^A{)jGU+&~i@a!=L?G +qaB>&IPnw|a*_)13+n!ky~FqDjkV(}g2eokcR$@#d8SCh_T@GE9>LbBKyllk@(d@*0xCeg>1F|n7AY& +VE`jUPs+K6*&4na|m+yq-AiJ;d+&NQ9Gk2IodwR8htd#T&Wt|tiLpszA043h!M(G%A5j(6h{cb6_vfT +Udw)NRMz&s9#xU)fIdvS={W!hOxdDE`WobJ+`-lMRTMbX==vo%AV%OxzN5#u-x<$R9=EOL=JCLnwKAbZ#^gwMa`(bnq+ +<8^^ZqNfS-0lG#zR`Oh`0iV|A!rTO&sZ7U?FP6ga2?8gaD6BJ?FPjks1WyPcw)Tc^KQfG1)*-cN7EDV +C{nZWt-kAec7s +}JSmb3F8SG?X@Um`CGIGQKOyzuoUC3K$zGsTkYEkJy3mq@98DZE(|b#vjP5B_oWR@PiFMJnP`RynZ{oau?8Yez0rLTL +_p{e!;T5RWo(<@C#h=y02Advave3L!~*>7 +rsp}zq3k$j!C2{?|2y}K`{`z53b?D>_Fkc2_nGfPoZ?JLA?yW#{osv>_=UNGD2rVt93(;vYCWS&a-R% +;*Otg6SVWA9zUbUhojF{eJMp|5G}Uz~fOV-1JYZ>N=!J~t;$(P&VVG+$$8S8pFYHd+5l{Hd>^_6&KZ- +t~yhPp2U(7vKo52+v4A%CP1JmkAWOQ$@l>7)lEenZSu_g|!fPF_6f219Ye6Nm-KCL)=vL9LY4L)UYmA +3e@8^Pja6w}Ogu$U>1oeqq`eBsg14AwVRY>>zr89Fg*D*V^Kz+j9>!*H36GKHUNv>HACN)HPI;6*QA%yegD{AySy%| +8`!o>X_Ko`j2+;ea#}CS+s0YUlz<23Cd%{WvbIQEF3~RldsgS5I8gEpMF(6rwiD49k-A4fl(*y?K=>4 +)iJv+P&w4YBs~Tkl9)eMINhED#(#l}_?W +S=2{)X6(jUIZw>x|(?QKr165VaHME0WQQ7y^F@81fHf2ykMcB}6M*y{q5P^>%?PD9FCLLrcu=N`Lbma +@F0zh+^xI$Sbic->#v5cr(ZRsyrZLsp}Ok%JnD#Yp+S_&VxM%TC#3=5!Maw`wn>_Z4zBKr>$-H?NZC; +Tz3+@!rFBPv>_TBCYCJyo&f?jmn0l^1@ictJ7_SR;n*(ei5r2LE<~8xcZ@xYKBNTBa<6{o=DBKx +lR+zO5l>xX9=dX^ROvN#GHWz&4Vzff+E8 +#U@c~A1qiN5mX1xKllpJErh9}7wv+)1sj*q}l>vqX{+>{t~Z)r;GcG?@w+#)uEOdPr#bN}d@#g2n%c; +qAT3%+@d+eN#b`M6tp%Y^Gb$3i14EaL18%SU-=0_AL`V&t30&(<5 +aB4+QJ5g>W^%&5sm}_`P+~#xklm8KlFG?{Thps8<#3oZy(36V;7dL~;4>>zj`hTEGzaKOiwCk?5T^Hs +r;^$i4vMG7Za|ZP{BE7sT!o0pdRTm$j>nGi}$HAS;t-WyHz(!ybWuDhE84ETFxFpO|glV;E>skh>zxd +w4f~3k~qmWNT{@wC#PEN%4^S){Hz4*gPU>o&8eWk?nB1aLzXIAJN$04+-o4?~;iN-4=e;A#?xA&UCdp +>Rd+zgPIJfK4!O^fWB#p7_^Q=Ryl44Hfg!r53(VA5eqGjlcj+a0;4W>@d}A*-tr;yje1-47 +0Z>Z=1QY-O00;o@p|(bSLH;O;8UO&gUH||f0001RX>c!Jc4cm4Z*nhkWpQ<7b98erb7gaLX>V?GE^vA +6JneGZIFkSM6xd0nB;{n5OKK!10mfd}H?(SbfL@YPpe4J!FlBUP;;C6&s`V(?$VXE3;0WlF5ew8 +^E|ROM}!N+n`($sI(w_)#Xcs7tYqi}+fKxJboDRw`4qP_nLJSZJSArBZe{F-pqvCX;F+;-+3r5b#I%I +gWT**?Ln}wJ6nKS(R&;e4fJ~Fq{(l)vI{30m%G5jcZwFYiVAZ-vfRf;TY!KY!Rz0nc<_Esw>?hDc760 +Hf?xvdA68{H&rStnLf{wdLo)C|FO&p`m%{DC2en7jOjia2>9^BALD9~7CpW-~DgrtI6~BpQJsfl)6 +X>6B-zk|QusAEEVF#FalhjSs()2V|^1M*8P#G=_`N48m8gFV?xoP_1>gw$YKO6L6ke7|3P}XwRRM|va +%X%h@+pH>!nHB|pSjf6!W}OJNDw{l=Ew-CjDcg*IVN>F0Vl`OxU_7u(iR(rI0@8Ld^kXo1AeLnXY?g1 +4h_L)rtbo}kFgN*eQ!4!%TZsjr^e(Pa!IF|KvOKG|{ak5y?(*v7>U=P;zfVt2U!2V@&;RpG9E-j?83*3FuxeSo4gOLD-%u_K=2DWL+@2mXI90sm`Q6eyn!AZt@)pcRZpqBX_h8c11)%1 +BKe-{8Bf0Bsg0N!b*@?<-0003&&pWLBpM(0%m^bcXGXiVs@b23eth()1&7z7#QmvJFs=;$q-+Tx}=Vd +@Jsd`Fy#fQqvA +mL^6rx{k!Htg_{HY=*;DBMX}z!Ww~Li$sn(RM#4RjCkJFslz*_6LlEh4-t%bi-co`-$sG<3uieV_dtl +64H~3Q-(Ya)tMPat*X6Ag&{#2xfoeylK_iRwh^QTM@aSeDZpX-J0k9~m_ct +H*pkky)^(PRlS&wgrMOx#~dXXCcekV^IkUg?E($>kK+ZwBTD1x^j`=sLtt`dt9oB`{IpwMclf}ln`LG +pTV-e4t^LKa@gByN-xcdJ%q@I=J%vG`>O#$p5JMGmLp{fAEzt2k&_v8ZGWEic`n1lS+2dHFW-ChQ2Zw +$w~D0r>V_M4%Z)?YLu{$NLXEnVkA`WW6(l_u`&Ic+=`qxTD)YM^5090evwDGv2|g>|<7p*yq%AMwWpI +mN_^am2o0KF!LoEGPS|KKfzcvP+)!heVi+>aOfSDO?`}uo_NyWe^_H3UsVlsN@S&b7=Km&dh|&905i0 +a*UAw)ASyZvg1yRLf*~vx=DHB_iig%sF}gB?c^__uD0FzQ_qBbN?Z+igsOpvLY2u4XkJwcF#Snfpk)S;mEaEgR +*2nOF}lCE3SK`r7{G|^yY84%72id`x#=jyz8DY?BxdAZ@*E3f{%9S4Y~`T`c$|SU3!U%L@C?==Q*b;U +Du-f2@vsMKFg#i=!VLL6FwuftZgL*ktHKwXvdn!JVC3iEafS>Bt}L-5l9l6&_rttQVgx(<;5A)?n^dN +ndHF{;y%)fgBn~`(oZ4Lm4I3aZ1{+d<-jGvq@%^cI{N(5fXdiC%?Ks3UOblJ?s#XYLG(0>U_E3<5L=Y +@qhKU-9#W6PNGB7tBK2+0(3UNMiAVfSziatA-zd}!w*T8WCGHPDlf#a9}MWV>ZID>WP)R_)Xg&U$7fZ +ri?9*FPb1OovSe2@x?`b0}0VPnD=G+mCT918UC02Zo|; +i|4T)5F8GTtmnf)p^=&KMnw&LeP?DF^D!&3&;QFpP&4GBJL!nDliTNTa4mG42rl8>5cx2#s$P=u);2} +Es-%tU}-#YBR#^hKRF1T2BQea);Ukq=Q}tO;Ol9T$K +*s}M-(qxj)Wes|nE!|qyX5CdYC;MCr0ARk0OkdO^EOVprQRFuhj8I{%b;i_Keht)DcR(qgWln;I%eH( +onE{Un-gv#jWP?Q{jLYS2lfQ4~~`Dn!h>m9y0J9*xx2dr)y{&03R3}^qm1Uns5s0n^zd8aU$kd~NQQJ +V~dR)}s=2)^`Ox% +(4K+FxSU=*1&ZfaO14Q<&hh{$bOD12!R%I72jqc;RqDt@tATJ5PX~~)kyL94@cjA!KyLH@>UIRhB)Uh +Ty=**ZR36`gv_ddTdx5V%>q-8hc^;zWxc9oR{wlxVw1xRSEUXgA3flE9%g@mVCkGXbd_g4JC&Xo +bN-f_Q-Ip21gxjR2NSST)*HE5Td9;E!?*U=l&fWHGG8mQoH4=;JgBP|=sg9(Axkvsr!$!HhpU-Y-6;m +&u!ueXx1(yQj&>h5rBc}Y{RKurM>>1`Of-onFg=j9p +LK8pI=R;XKEO;rU>9O07vJRKpaNf&NV7W|s4?a-2n8$QL;9cp4p5>8^d;QL|EwF;8P15DMU4Z|*N*p& +kg($_2ct!}oFay}^LNJ~F#E2@$M6iUk6FhVcpxI$0u$@(dR3EU66+GUg7h?Ipc{p@6s?}YZHpYt|4_r +@U^9)D#)(!C-nwcO?Y~hl#tw$FVhhDdWAD$PSvy2ynf?wgIXT*ua$`Pr3A!;N{c`S#T_q3XZJak?Kow +_Q$ew|BzRa$hin(b)4;0uD3=};<*SnEx^i^)-DvLn^Rirr^_aj2ies}Q_fZbve9^hIyuiwnxUcC8_KQ +qG_!_SNc$QWj02BA789L#0+ohpgT~r$z9B|bV&tG43TW>)8 +ua21^jHavAjU{E0^j1;2Og(t24+R&aGl;V_**I_(?sWd0;$!hB2N%nk41me8D3;@^UmRLmW5wFc`7gv +7u4R^zISJuCgRIUu*I##GI-jX=|Hj{hy7`Df>+wrQ`D!cb{tHAr&H_Vg^@|E1tYxY=O4ztA?RU+-R8h +kbbUP?b=L_^z(uc6fles8xGSqvBhB0GA33XPr);slFL3D{fOj?gKnru8x-I+1y15T-|3U$DP<}J&j^9 +y}F3rMyp;6!dP`d$mVhd~RHatUrYYLgzaWe%=vPf{B$7Ze%Fjq|*$+%=+T`{2Va5>_gim&B#YG(fI*) +vlNVS;(*jnbJts=G4l7`qL4*G(t2@ZTaUD5C|>ZEo}Hqa(9S9(Oj2>$+028SV{P91b-}h7&Q=UMhY?0 +^om*SNux5aP%y$;x&C^&wSYW%|mp@xu0ChIw2UQ00zHvEP&svnsB>&+Xwo^ht>|xW?7Ndvl$t{@zn7H +rs9M&{6W?h;kX3`xcQ|OE108&v{AN!nRd)KvP%&e7oNwg869g#}{QBzs1~|OC(TX)@4%WCKZ8p6|mY`Ys${MKz< +<>9Ztn?S(ecvuBP8S{`$%A(^!+BL4Wd#ND$1vwG*x#0tjcfm^)hGb`DNmZ`}Ko;GKEDzAdDJ$3HNKYR +frutRRd%?0?B3Xfwv)P4vTH6&P*drc8$F2;3JJ8kl%+)sYim@HNagqfRMLN{~ciK~uO&7S%3-E=dgA^ +pe@x)Yu51u+Rb&ijsXmmoLSiPzx9q?T5gM0wCZ{c?SS04Td0h^v4!`eEKT>n5~<&D4O*`R^BeM*-#>< +lyhlJ2}wJcsw2dCw$89j%aShK{G1D0qey9M+#yYaiFyhQX1t@&(!&6UdEnBLN~F0u?)AU;1GL^%4>C` +LEf6J=#-J{NVE_{%X{w52Y=|Uj!+^qan{(7DM;|4&HtoBuAq?f?m9A9l=k>NqRXnwZ%p~nPZJy01V$s +wtJS_>B6y>dz`P`P=Mz-U8Zi@|3DUwDE*+wt#xUbrF^vfq#+^x=aHl~f`3bm%G=sb4oe@Ekh6|g>#%` +~R-!R9%YpQG{a*1e6LiM}a-ide%SsY=q{l*32{C7H_sGw?_X+#*`bH5Pt&L;8Dau$bPG*HKS>=GZmK& +_!0QO*TW=(w}_kwf<-g_(VJks$rOD?nXa$GSRZ;C0n~gzx-Gi%QC1oS2=PVR6mQS!2>YuuDY$OxKI>X +A_q_cifeJQnpO7>xO1_Jl`Uzv;B=j)NtNw$Fif4IE)@kdXbWqB1&+qtiB6}a>kV2uLg_$fF2SkuZks3 +dOa_8JY**7Cs6Zj72hI%-clbcP=I^Bw`Z-PNFI-8 +hCmp8FGJUf!_H!$8A8Ivnk|G5N0$kC<6G_IF96X0t&B=%?mkv}0#v|K&2vrLwQ-m)`)LH~Suc_^*FdW +no|A5C64x*pGWF7b9EI;=21@C2G$}fnas)wCxyxUrt>2F6fSQ2|DWo0*0_b2hEPhKGO%QM)&x*r}Q?m +wVKAMcA&R3*Ve$>xp1{PQ=4j++U^<=ei0^7&wpe{;y*RZ@}Dwy_|FJq{-gc^&~Vp?>OQ^fV|PHtoc~O +3jQJ1sZdb4fTT^Nu5r0yx^yf`q*T~qkG1c>Md2^AHakJ1&@o5W1hY3&3H!xPl;R+29Q*vq&rJRT5t?7 +_W8VHw^7{Z2ib&&G@rXG!&TBij|xusA9;>mb=z(H;UW`HT!|ZQSYfkmbCZp}@vdf+sRjE{W`XP6?fPS4`Lzc| +&I?9EiI4oDQ$p%#A&fMxC;-80bWtp3J^`_xkzEGl7M;R3%T_XA65^xGO6NI2`_x)bWI&AhW7mBzcA^o +aTYjDn`*puE+iq&X?i}d1WF-HbH$Ox5F`j$|^s$aY6uHrPnE#v(FTC!0zBZYtzx4FgK?3=kd!w{I_Y#*v&Sa1Oh)#>CKnn8 +#@ZXI+!hOsz7`2Da%|QrqYMs!_xXnSFhr@EkwmpKYE1R^q@ChJi@?LaTq;3|{%_tSAt}enntvBRQD?K +npy+u;PKvzM#;7Qy5Q{RYf4IQu8b=ZTFFI+wzWpa9Vx8nTbB-(!^_ny%9=uzMCr%Q4_sk*nVUEJk??s +hwWmCyK>M}N_Cn~FDD&7%DKckm9nq9o{8HRZG_r(u?d+NRGBVHfH@Mf65j%Fu +Ur!W3NwcnI#h*Cqh&k!z^xzr~q?q%qnpS?W0I{SZN>Uwd<>)T_v$RqalA@`xo-Xs(3iA3&Z8t(w5Has +^c{x~$kpc!uo%6``QA=Om6oHfqx;;o|EX9pOc7OLpjWm_JCeX*9LOq)dN)B{((b_0_hC%{&3Ib|W^eH +~1Jm|F$1w}TGPZPCZx#%*z$TMp#KUFW!w)*cZ+q&9SZk_*P;B+2ls0C+cBmgU$)>K*2LAbx1@hNJj8# +(hc#rZzIc(iO3cvm8l6r>Sk9?#`xVmw*?7T}?iI|0gW+p{mT$@XuvKTu>HfssRKQ4V|SYE1BHL6w5z3 +(sg&>%(V~gx!}x-fLjv~?6f){qc~0d%|Ev#R%CM8q6a8dFYfHB3+nZp+#$Qgx^!uZk2de9vj!CIvNoH +xWF6YjZ3aua*(A6ngtkY_jc0VH(~`x}0t~!j7*n(9rrdl!D6w@_x)YUkY8h)=ncRrC;pVRC2g#bky~j +$IsGz(zPAbqm)`X!-VO?Vq?5X&6-4lud5cEb$=t~7yY*9SzRXME!hDWUy3NHbw`mA?AZS3MySmD8SU02u&sJ&3;Jz>v9BaHvSc5)O +2ot}8_on*RPHOnO#DZUc3qEq)7k+zax#`HLzb?GG%Fa+>g#adyBHvqK9vc^^>w12@Y?shlhWCUb%1Xv +0$h%hP#{54y{4kD5In+_-l1{f;D;AEL|6Hn)2B5gSJ7D&)fZ)S9}kFA5YC#marxqB12!S*^@qOdko-w +uG~M47%jM3rlM#h(fsydPrPyh*6s*A|3RK}F}12VH)gDc<{o;o2wN<9hh91(J{mZNCSd&~`ogP;7rOVZzkPpLOl0t&AGaXexFcDCg*5O4In{Z9`Zu#|nRV2O9^lp&Nyp+Ced}jaW +IPLw0keoMZ)0zhoaLrpws6*S4V83QowXc)1YW%QPCh7f3P0-b=s;hq1X(w&kSPC0P%T-@-X8h#}nI=4(Aj=5+zC;>*biO;DPzXgbLjFqxYvT|=g4Y7FJ#TuWK2 +=&cvw`7>BsqHaYj~D^rukl*emW5-D!3_lHIo)C6-`MA^ +>phR~q4j#(s8?>uHKH3o!NFiqb^MZCCjQeDXfR-Fycs1Z +4VtCt(?3RJkV|z0woU%-T0c;) +Otu{<^4I4_vVMBvE+7wx=6;$B)9b?vpCss}aHZyfN>uPNSlr`BEogf%5au+CkR?7NYRe}15f34K+oGN +%{qiOcq0%dnK4W<#Fc$NGTpiYGV7ij5{+dm{3G0Z>Z=1QY-O00;o@p|(aUn#tbf1ONbl3;+Nm0001RX +>c!Jc4cm4Z*nhkWpQ<7b98erb97;Jb#q^1Z)9b2E^v8uSIurCHw?b}DFp1nc9CQg|74Q@dun?q&{NxE +070IiZ6Pz#tfWce7JZ5ydg;^kNlK9#NlwySGNL|_6n{R^pTy;Nm!h$)Hiri>hW+JTl+0#(XM1twgBzP +LI`BgGgLOgtZ0*xH{GgjKn@K!}J72{gvzfrZPvR%Dx2{(~Tcf%w65d>2KZwP=u_kCU!u(=+k>oc~?q7 +6hj%ZyD&Ia4q&R39Cgy2R4-Xo^kS(DNuG*5%oCX}5Oof(~$!CKkbcuLG2d>g?Bc_vRsR_vjDia`6MPV +v9$I>{3LD$;|sZTxh35g9R{mC +Ne8jK>fo%%FWt-0CvhsWU!c_vnivBvu{9?!+i8wgW5r}uYfejVpP`ilVEhbTv7?NVFs1Wyo)1vM_I5O +FrG>KP0i+E_a8xbykpU?YLH5{CdkytrN(Eje*7@tH+PE!k@NSPH9w4@!axqAJ^JuzA^A)nFctkPISFR +M$KL5pf82eaTjqNdh0aB5mF#3Wa|Luq+BUU0;|NObTtp`s#X0%lDl|6XHkbtmC|FI4?WZ%G7^RF) +kV~y@<2%n|1AFyhb=N$0~QI4R2~(CgL|BZWH6jf%!o8Sh7ln(?C`EZijl +fK(e0O${1puG6$d>dyKK)YtEf`3n9^m*sPh-46g&WkvfY{M%*RhLZ3hlHnr>YrKPI2rbFr3GU>64CQ~ +f=+LgSVp~!c(d8*B?D9-GZY+(R{J<*VwYL(F`;MTQ(g@F9ub5G>?AA5yLXjz-U +lDl(uxW>)&&yQX<`j}R3>4@uBniZ_xvTdce3f^W_mD@;|6Oyq_?(0+;jN^q*r9-BUef&% +(~e!wQ=y}F2YP}U%bRu6Z4i{Qb*$qJ*97iS0A43=e= +sgL&5d|AKHqzwoJi0W!e|rBC~e7*T{yi4M58tGFL +6w_PAuZ;LLgUk;Fs}L?z9gJ23={K3jAWZd?1?@6aWAK2mtS)wnl7|38QTU005y2001HY003}la4%nWWo~3| +axZdaadl;LbaO9rbaHiLbairNb1rasl~&ts<2Dd|*H;h;7Lo&7Mc;~`DG+40=mNWoqDaw)Y+%vS*ye^ +76_Sc;EZT4H%upA~j<>BJ;#fR$J9B2JOR>0Gh|*N5-du~;uNObilO(ygxJWEKx8S_Xowsf2TMI7v`}C +6}Z>5)F1PQ;DUNmM8R{Ylc2rd(~YmD_6QEMo@GPO&Rq}0+maVH(TuN~A*dG!KsRq3+`mw#-%Txs|yn+ +CI;T_*xRyeyT6okK{-=N9ds;D8xe5b$S%!Jrb}h!qg87|7+~ +ehVYX!eair6WTsb+YD*)vMym(6!We|3ZK#MfZ4@A?07gj89?k{udsy +D)LyDOv|?-oS?A&xtosG*T%aKA0ZU?Eorz;79+g4|%7tR0ZeCvprnpd5iJMpDGK(<}>1|m;>6+jm2h4(i#!D1zBOg9#X0qwYPve3| +{((GGYQPU~lW8qc2jo+)|0=>0M{`t~Wy~oVEs42_iV3YMPQT +QV3&Klna6{mJVF-uGU#tEB!9DFX6j_v3oc-oB`zY;Br04uTeE%5xsz86k7oMJV6nmkC)44d!BxB}!;` +$$RvBNorDh!dDB%Jd@++LHiHPmNg;8_+qi0q<$er$`1{Xln5v@SzG_sVbi<{26vmSivSxVVWRGdAGr@ +DEmjY|kbLqTmEIg&c9wWi~)2oWS$YIfLS|QFS;u%Jnx%#;0>Jxhf|&b^l@Dnf)C?3~aL4;-a&zdzF{Qi#n1Q%=Gv4LZkjBwrAcZ0{2U-^Na-?h*oVcPp|BQHEEA?O1XrVbTd0freSVo` +YtbdjIz{`W<5Ndo^qDR;pX%F3k>EDa^1b*9PXEaOx0Z>Z=1QY-O00;o@p|(cjw73;r8vp=SQvd)R0001RX>c!Jc4cm4Z*nhkW +pQ<7b98erb#!TLb1ras)ja)o+cuKF>#xAdnv@NH(REg4c9jA3SjkAf}?w#vpC=!xrQ>2z4ZL59l +-+uD}kf204?zVUDtzT0~ATSsV<_j|e?ufzTfe5oGPG=)g7Sq8qZ0U5m-EJqB|0<;_lvfsUqB_4e{yLq +rd91`Di^@cbWuD!{kyHY^#>GlZ%QP(FELEbI2Zac7DM}?HaT^!&I2G?T=uY)CNK}Shrez|gSuW&VA@e +jy0J&6^izNc{7_UyeSY~-4!dYB>%_149`d5-jp58RYnfaDgZObGmV5)`rolEmgt*TBc3$JBS{VMV@tb +W}Fc?yJ6oz67R7Qz#{-S=-~u3&oKUwabD92U)OVYXPp;teuEuB1ONilv{#3TUE)&u#eApUWVUdFx2`U +u9Ovz9{pA2K2>bRY=uGWc%VYhjB7`6^8|MNp;^?`ODR?-w|zplQK?She-i30 +>?5F#lq&GnlN9XU~bUOaLRC8GWGzqQ&+E}=oi1a$0x5sDikNnpsZ;n4;AID2&k%vxSI6i-aKCg~nAD+ +KC^N$Ywug>4TdUNc*J3RXay3u$Re-YpkdDM(}U{g+0iAZCm%B9TxM5b=0$5}8lTrEEIe +H*FiNeXLXTG$O(=)K#p5Ys4VUF{ +IvY5Ldcbj}u%w;7`q9~W3ld&_Y(m>2WJW>=`LGnSsY94A(y6#{^hko?MTl{#3;(naxS>CBeFlwNX=CC +(!vsBiPaP}!Mw6J8UN$rhY#=j&BahsKgKtY(7K^lQ+$X(~x-Jkb=-2`Y72|CgM>JM>;)9d|)%R$3cT&z^npH6ela=MO-B_to4 +)^w-J`sOufrO(J44Z*%EGMYlcdum%WS!?SE`HiIc9`L)-Th}zo^F6)9_lpOflKT4f)!CNP`0;8mc|Z3 +myHgSTn5)2i?t6Y$Qd%olNHWVpq>Mwr4HEFRC-lUcxC|ysv>{1$y*IPj{yl|%ZSuX|=tXV;vlusHySV%XUT-BQOEJshJ$hcFr4(up0B8XP2FbbSaQl~hSI*d_0 +uz8qVfq}qA@Enl)d&Ypc)Dx5oP%KWt)}Tv(ZGGEwq7K-KyZ@)La9%hY3W**M_WAkCHoL2}0K%n};{S| +!AxG<4u6!^%%edH+n~wmS%P4}yr)+?REPJ+sr!A8RAa*f+zcyOWF +Rtdz)8ivAd(`*&}9y +7tA(p_)S3W=hxq`b>4p>pS8|yg$caxg5?s`Z9Ok9Ys{amCn$>}fn9gRYji{waiPk2e4Xvy%KZ8#S|qnZWB6hs`FKrA*j5g;`nzF^Uk)OnuWV9d +LhP_XmT1qhTvNF2K|TVi8ACB4Om;`4Mh!E*IGi%5Yg^a0mc*ECDApn8KmicqWDl1sYP_0sO3M1?vHYF +~Z=~=p&O}NkjRM?2Ql~(RMQmuz27NaCOC^Oo|v!RzK63GnGfj*zPsJm-j(N4rZ*uXQMoWc4v(f{dDTH#7@S5$Fv9c)^Md&yu(;$RC +@Lv4+?fiHF`7BXEnxWBxwaAJGq|>oi?lf;%?hF%8n^V>pf6AAx(-vveEc<{@9C5%uWVih&>hPMtu}qE +G7tuuP!m`2Us3~ptT8 +0I8{v|3`s3%Q@7dc>7^DXR{Of;Mgytq9Wt`;Mt- +`PiC2hi@MC(d$N(u@f+vq{9tctL0boop~*lqDF(a!R|>^1gxb9;9HdaPLTitEI6DcK`85#$3!OCt;kYq7L2&FqdJ}9X^+lilz? +k602oFcdWy1g0yI^i@#e<1;oMc5UU6!T2XVXeV_C<9dL$Yc*hCK!)Ks3suwTq3$vf4xKG!w-Xs$`lQUbUo}&>-&eCRrIKGE;%5QejOg4 +zEV_BXjNs%F4R}c}18EA3~|+S-Tqei0ms{naa%Y6O=CiUs1;Df5G29qk{EMy=sdN))-BVAc}mGc(duz +xBIpcr(UI|NE@~8BMwjnPMk8YiGn=nH3rluj08qMv^&T1C<_F!ueB#l%3cjCqBK&cuDwRx)#DT*kYLz +gq43H|H__P|Pk4rrK-;AVjy^ZZRrP0LabQ&U*1pLasrcE5kN)huSZvgU*E9?!>+azf*RA-)IYCpbQ(y +<)UjLqzR8F8iO?u)r@S#(~qS#%Wa-s?L8V=E*R_L(D_A!c8Sdtk>EyXeKo#F85Q%|^PQ7u>oW1;4B*v +-?b~J +sLyICpX$iSZS?B3Fg|k&J1WZ6pAY2wZ_du%iEr4)L7{GPzJ@ijb#4piw`)*B*vF$3kXS>)jIrzJX9Ij +@MZM4**~9LM&)MB5W)v*2I3k?Io-R&d&)@D>Pvq$Ra!`%);ElPs`J(E2iA5dp((O7wcDoj+0*FCy?#0 +|W`EWXT_U!X72K$bwWhlVm1Jx%nG6-9(mKmr|zf5Cnz=L{@$-BPD>#h7iV+4;u#cz5wiY#)k+L(<sHj4x($=xz<_qXI!oHt1FsP&H^laRCXekWMTdXe($GLfXg@!gya1=C +lXcC09SsF}JRpcY_UPH88Etu7GufVXf&@q)*Mmnmo?-{GX`pH%j)M4m}X@Hgx(Li_DIO5n?O;Vi$I={ +mZw-V|<(GC|#;M%X?2qit)0phPdLGenBjPJ2Gxo0d+rGQMwdkUnqUIexV0D9tnHE<*Uf6g1yQYy2yLK +Ek#A?ek=Hmo!1Y#?+$GJVmmz%*)SK&>^rOsvJgqHqg_*2~ny+r|0&6Z_EW;yM1{i)T-Jo%6Tvk3Ss0| +Ni)u|Ka!yXb>#Wggd>;XEBk6$VQ@dap1p6e6eSCUX*|d`Lh +`t1D?MfR$s&OZGUJ0}^tBri?=u)Uhu>(Bv#gxSk+O2ZtYyPEOeU)~U3p>1SgGNl`6MY$9)uEISh;VtJ +6xq`TiIHA@5R)ZLsz#)Z0wFE94s0BoBX95L@<42Po8V(!H%NYZlQ_SU(vr9=!%bi#S=!nw$u_r?Cx_E +In_$GHK56N`0WsN2=ww{68pIFFRm6_3Q+s!7tz36UI4Hrt%i5Cf41#;IsC99=fC->6Dl8x1>Qjqhw9c +mEjUNjctC7Ml&!+>08VxHpfRZ2Mkv3ePHm0q(4lUBG`PR!yZgQZ+lmuRJSf7=1Akvdi$oRfx&8OzTNi +a`^;i;{-vaL|;nAQ^g9k05ov6tI4`5m`aMy`+6&3`Q1P5{Q1#e9JlxQv;OYr`S{DfUR?gV)*XZS%@OS +b8Z5aZbR?DyO3~Cwmhr3yoME`k8e?SBR$fs?&O7(2#MllGrnPXR(R}3e*0m)KcDLxEKCOGaL92!)uEo +P%@DGynwip)E(3_jw$H-~|F1|uqnSd~CB!ys`@jBRLOtMa-0Ttm|Odgnc3n!$K8gPFWSo5KIL$1JnG= +r|Nh>9sVyen5i(=rS&y3JLTBrBBs_O?(hkJl+=u}7~CFXdQ67N=Nfhao~YUiPt?trnOT!2s2q-72xlN +?cMnm*@pf(Std8N3l? +3>ZoxV**vI023*Q3ZzAnabRF)5MufeS~_`@yLW +ej-C<;qySqEj`q$(S*h(4)oHu+@GoRV-;pd-w=HFgpTD=Qa@5r47Wsy?C2mX^ +{o4CMuKk<%z?aTSZ%95Sr!96JJY^KBPfguf?0(*o?Zjt*vx7+3GqHd)pXO_PIia^qe2YQEq_ieXForb_3;YyVipE-X`Mho7uXdO~2;>`^_gneU-`A7o3_mE9lc4-oa2%2Jcpy!y^w +BdMMHgEKJi2!SfyS!B`~0ViE=7dW5yOGQElOETzC52oe@iuQhrl9JzA30)mj>s1?JpLo=O0reZV9-|} +4rQ^gpozV2+&n*y&sF|1n&Rui#fn@q_qZEP!$nCj=%R88Z0L9Sz3Yvs(BHX4Qdy7=A-M)IIFSHf8K=I +U)1{rJL(`i8$1yTu$KO +!<}SsOhaPT(w@IWCQife=7^#(var<{P-prUL;-nEY_cCiUj|qMZB1bWnAxz5IY=uiW{UH84vDIQ!xqBX5>DZ_XghZ>M|0~6HE4aMtHtP{Ya-^hZ8!1OM0k; +HAVQdEVV%NrRa8XlaF;v!xkv9Pitkqcdj+%P(t1mgxpTxP6>qu^E%rpnQq1+iSaDN=#63>|PVH*eURd +fS`ku}&?Kf^WAr?@hURq_e=fH)a3~1A4X_@d*QFp`q)!T5V)~ySKijDyKo26h7XK^Me_teX0DY%VmKB +6WQ&yAg>d-RjIwX0Hk3Gx^G7?tF`##PEn$RxOQA!%hosO);hR#NOWW9SU5+_zE*+7S}$`oyJaH%L|-e +F$(AYJt=_F31mAh2Jo?WOkAw><047?ls=MJB)%F&_74YCz-Mj5?3$Qr-BY}l^)<_Js_sb;(7a;p|^$KtubrV>2D*~1 +3;N2^=tg`T2E7Rnk92h}(@MAhhw+H|mmoO2i=!3W1WnSxh?z&B-Lxz6mTc!|FO +2<(@1dYeOW#N*w^j`iRuOH-~6$A{NaE(hRV-bmf&7qdva6u<||eXZ83(>F{R4Z-^+>9wg@s7#tx<{o( +XZ{Ybzyx=?3p6BgOL4*qLYAI(gp92+>F*Q7=O7d|RoPn9##i!lA9z>%sA7u~1-_JLO)R|2BLJP4ndD` +puDVK+#V1XqHb;TMinbIFpyQ|&4c>JQP%a!kYi2+z>tF{8V8vxI{jiTmH9Nss;;Mt@;j}WQr8avZ;(S +>o{OFpKV+KU%2g;joG7RU+cs+6O~@*&9?>q5eq0hsaQ?r%=htld4Y)&i60B{VjxSCweDK5Y`DN^Rng^ +~+uGn39ZdOU!a&p6of^C@`ncTA9GZ_nXE4meZ>DvV=? +lzf#KhQXYh!+p@+_yGgJGCzj&SPZ%8z-l^ZTx&LSyHQXCdfRryw;xX5f>TdkHdXrSx?(sI>S^mF1RVe +(Fg(?PA}|L9(0nT_J*N1Taq|!jz87WgI>b4?Pk^l=XKqS;=Gq~^`2w$V^Rbx{Mm@$GDUR#{1`IuMdX)o8!Ky8=>K=<4tGT!FM1X3?0EZLPvA;Eo#njF* +=|E^yW0r+5tWrsCeeA1MG|MKENKV0AUx)7_u@4{S@`qCmLS1ENK7f+JbcB)GABH0i~Z>(4JOiQfxN!~dPfXXdXtBEf?=Qs +Ku#>kJK|LwQ3^@(9AYosYsH@kN@kMYzBA=D$4SIkU>lZz#2_W(%2R4O$0q5Tw4BQmUPB~L-M?D*>HDMsr!C +bjWjVoKm;&R* +1J-6sGVQVGOe*>93tzjA7uC_K34~G3*A&RoJ}t>{YW-D2&@^Wes!4Z{w7*CYIX5tAzU{F@S5Qi!(8~v +BM$u5FK*-o-Q)CKd1UK+iz#Rj+0 +mNDAn7X%i(}^gYfizmFm?BX@DmYpQAQa9cERcZM>6aO2m*>$9lLf5#N_E3-XBG?Sa +vEsv$Os#-NS}G5IMzAFv~!;g|#jp=25vOywCNuTsq^U3Dbhgfk0FNjEVN7-iW55(uT;nUY^PQe;^1hY +WoitF^0Um<nR{VtB80_44LH9?X;z97b36Ka{uYb!@pmbpDp94iS+3I!f2BL67u7|%e^*g~ +!1X%+3s6e~1QY-O00;o@p|(bkDeC1j0000!0000f0001RX>c!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D +?FJE72ZfSI1UoLQYODoFHRfvyID=jH4N{x?K$jmLsFDg+;Oe)ULDJ@Bjhw!<$(m?9;VA7>UIXRh0##{ +hUO9KQH000080Pmr;MsaLP{EY$t01pKK05Jdn0B~t=FJE?LZe(wAFLGsZb!BsOb1!gVV{2h&WpgiMXk +l_>WppoJUukY>bYEXCaCwze!ET#C5WVviqxcXbQEDgZrEV%=2PdeGZ5g|fPu2oM*>=5a?Jjot`wkeAR +7s?EPB1g?@#f9Y>%AQ?4)3Bl%%Vv+k3$&G7L#xAPH)fY!MflE1Wz>670_d@5y7b3o|wiFRH}rONzj;a +V>M4oi@+@~nSE56@OzcO*&={)Sp+wCDEXzdjl)y8dqBIE1z@g5W0y9X +e1~;vR#H|pRDxznWD>(w>RIk5%L~SSoSN^d3TFdBx($HtN)~`VwYM@J^D-ev-bx7ZN%Yx@gGvKnJE!2 +U=Du|Edf_oz-!C?62` +Wj>}v*j+0?tJB+FAvvHZbpBXTAnebu+AS)O9KQH000080Pmr;Msb|KF?W#w0HQ(x0 +5Jdn0B~t=FJE?LZe(wAFLGsZb!BsOb1!gVV{2h&WpgiMXkl_>WppoMX=gQNa%FKYaCwxyU9V-gkzo0L +f5ice!MK35eD)?85xZ-u0oi3&3*)j4Sw^GgrI41=Qt%>_phH=i#w+VXg4t9hxFCGhuqv`Fg{i +Ud4BYxzx}_*&wlYwU;O&Nh|CKOg^#&;ID;M~|=m^ycxK4{!hN?Yr0CK7RiGn>U +ZQ-#`BO{r`CT?YFP{zyJK_AKtzF`t`^6A0A(S`}WPdkB_hWGoQVDYWl^yw;$hj%YS_H?{B_+|J|DpkN +1CkeEb`I_UC{7=HvHYzy9vc|Et@#@85mj|M}s&_aFR^?)dTB_aFA}zy9#%^~X2gJpS-kd;Fgt_4)&Se +fQUX)So^+e*E*ldmPtQ-NoPh_-BvLzy0>{C7=EN@#UNE-+cJ@H{a|x`T6^IA3wbP!w>zMKmPvj{!{Hy{4|{iiwnr(gg6@vA +rA_edZA^yb~05B)a3{oxPazWurz|LX16Z{B_X=JERb$9Meh`#=51O#PC9{O%seJR{ +i1(qv3mUB&Etpf-~921Z(nr}{n^KV{ofBE?B@4x)*Z+`cS&mNE8y?OI#ikZy6HOc?a6#uci{PX*s$#33#eEs&@@As?!OE2&DJ-~0jdHm`1zrX +2a{`$?^mZ-<;-Xh=q_5arze*6C2zxlr1$ +|BpX?{P^8}`sq*q@|VAS_U4-(KKuBW|5V3M|J+SJ{PaIN|HoO6$4`FppC8Z9=6S}^zdBcZ`qj!>{AwN +Nr(fmVzdD}hynj{Ks7b@;tov72t{Ohzi*MebK0Zk_wiO}_MqOs>uvh|M>f-+fB5=Ok3Y3iQ- +QR)`SKsXe0llV7yq>W^{apR?H51){8#__k6--mt1rL!+3&yl;y1tk*DpWs|J$#ydZB*)r`I14tQM;O{ ++kbKA(v`*@cGYv^^1S~-53AYFBtmB=#G0`Y4g?l|7h_Kj~~CZ!aQCb_3VGvGhX#@*Q;ZW<5jEVdewiu +`ky-aDPFDTvwwGF_UE4Gs}a@BdhuSJb<*N^zIvd7k9Zk%%x*Nst8r%k)C=AJnf-*voUdAX`Rmawui5_ +`m9LJ2zs9;=jVt-^8L!4%$E!2e*!_<4(v$LdBAJ)+qoul~rRw>C4^i*cNT;ha3{o`-tA^lS9YJQuI~WIgzaXZ5Fg(8oNxH +)iBGnf<3Tovg@YygjvhMwp=BC;GkOrJMI)7V>cQI`==UI6`spelZvS^k3tNJRGi3KY9#0PZneUf&Z*6 +5B&-+J-z)O=O`Y$5Vi}U=oh+1FU9jZS?3-{_SlZu^U%MWblxAC6Df?IudC;)*Z0`{p1p2I_OG8;i;lB +;F#Kmv=uy-6d$R0LTJj?O_C2b8LUnJC?EmZ!`wmRnr}57D^0=_Lw$XUT^d{^{tJ{hrTWw`6S75ix}5VfAeB&b^Gs(ev9YlQiNZ(+$SV +RrgW7zP)Kt9KGBv;j#NY=S#mh{hmFmdG{rLl#?qz4t^cL=@-pBpdg8{be^^ZMh7HaUCb-3xboSpO +e((lru%TDdj59X~G>gYA<0V?W)73X(7wLMg}FyjrjU&}bnkiCA^QD|2BUGdV&V$g37D=$Ph`oV0q-gC +W{i+#L&@sr2Qfu`u6ilH8C9p|uG&L^^GzuEh3vLO@gbg`yKAeX&7{Vas|;{94s29w@uz(tx=%DkKNS;=DDXCU_j^8DpPg)%p1c$LGFYvCp&pis*)D4$BmI~bcGt3cm-Vu= +0Qz3Va--ajz2C-&mmZd)i&;QB&3?aLSPg{xo}EW;n6`d?G1C}S_2i?Ue_fc5Q**cX+gN9hckpWraPQJ +q1Eji|$ga-VdWex!d|(|w_ZY2kU^`?%ki`E|v60V;dSRzIOdp$C1m&S=%U7&-kSrU&+Q^^C +Ma!f5ph_J0ok@mY7j?SnDP{WykIr^*L~$Af2~3j)iG5l_@b7SCd@v?wzp7iL^_)dS1g{m$pJ^}70+5z +U^}o)P_xK>zVkOnk9WyiyAg;(t1GjuPQP1ND^lyPjLGPyCYTVf72?;Gk=f^X#r(yh|XfQ7*1N3m&H=i<{R~8$4YSZ5N#{qPb$bx4kTmvN&K7>ji3hgOT?Z?kVdwp7(RQeHEt;?wuY1E<_d +*RN-7PF^nGT!bDr>h0_U=Di_?)-ba6 +Fuo}n2r)p35Rns$q2;=9E)HDM?dvIu-mEZLCW3O}op057gZ~G+&4rgy+d}vGs8velX?j=S=73MtL +I#>y8uV$Y?_mW|rr~V5s{M>eP;g{e#JTBD+7OWqSYlb_4>3%MZMlqqdd_1~e1phmo5nq#`vSC{mcfak +Ioc6{GwGi<_L)F0B_fY!@fg19~yCt@)-w<=xQ`K%Y^6>O`?3&xJ4*ZgSEnIs>xm;ab0zR+fUj!v5BHl +~Gi=!V-XAbq2nsJ=8)A`!++dja{WViQ15f7;W3|=&Hn3lSxMI%)MZZ4bSU{$X}>vyq;!;3xf(oeMh)N<{2IGj0*@@+R;JGOp6 +3KCC0ab)9k`>6?WX@?Fk&LZZV4bua}`tke=waIWEcrB0fj$`wQeY;oy=GUlcr4w}_Y(2o~PF0JcN(oQ +;<&26^r6=>i&NDuax&4Q1zvO|AIk9+Wx@Q$Oo{sqU_FKdT7|Jl@W*XTSl`0=z4yzUjWjybG@k`hP{dp +yS5{>az#!m+hEDq%0m57;pLD4bVCfuLZ&3d^9?|`NnTOLxsB=|LvR~rmIuN`8S;RrnlD2k^>dsIECEC +%MIo~TzW0SX@<9gDR0TkG0hw_e17TRhOA3;%cMXsxHZi@5M)u^B4%;w0=^7}N)zWoy=xCBq(nnuqpFj +=gbu2t5yKCpP5920Xz?IasYr!JepZLZ)&zVB(qh);0XJ<*e{amPV$9cp4te%RRvR9jX!(o#E$`CulrR +9WsK9#1|w?&54UK_C9Wd((!Ri!J)UMAC;*%u~4o(N>GcNm*QdUg9g;hU_%JcS|RmF;`aM$ux>a4h;IM +HTO}bcO4w+dAi13^BO{_$La~dt$)!iv&xiT6BZGTT+kdF`OS%#Ip_TiI1#PW|$=vVkHc>8#=?1$OVZS +CJ)>FYE#8NA$f0m?=uZ_MssZ;h_TKUxlC_5nF)bIsfv38cs*f+N-Qf`lI#JA-(6J{gQba;IZ2auWU`a95{9Qq}%outEJxIofDrpSmcRdh +fh73r5zvl=6h*Dn)qFcf;LC6bRnw(2P`vG2fKYd?L!NSfg-dxau~+o*Pna57rX>tY=|lzINnV6DFDI) +?000S1GGdG)}8PUSW97-!9VtO8Slo{4;Q>7wm!jLpkpS>xDDmPpDSj+kV5>eR2?%wHsTQ9pg2xcNUNs +pKV0}F2<*V@o=jdh$0e9{$@1`~Clh}yRD;gZrG;UXL%D&llvaJqS%*d8tgJPCYu8Sdf*&%m&nw`MwrZqbU;U186_;inze_aK4S;AKi +T6Q_-==K9sjpg&P8O6Q5NIim_|B$WEE>Yhk9Mgr%*B@*K_yVen}68J$s>;F1C;%ERCMZ$fK8?h~QKW4 +Y3H~fwp-N>9js|%?)kV?zjDtZiFQr%qk%np~azJf{y8b4*C^^p=|&ILv)9T9Zy4rxy$vx3G0zbifz3-=#7@QwBE5XN4=(<}^~LaP*B4m8qaO@#2%HN +=j$8LY@APD#q~^8zZNH?2t``$$|IQZk+fA!ZO(YYwwE=?Ay+t_=%YA# +IwvDP_U1+KEz&^{DEK+rP^zRUxLCVm>$>moiPl#eM;{ci2e?jeQpe2N2b00>k%cwz?8&X_S01t;Y3VVVXXVch->;X&I?#AKY +lGmgN1Q{Wu#1hK?}RLg*pFO3nW(c4CKqLvO@x{(`Rm~|AKLYe8bYScOPXDStlSFSjH032QBG_ej-isCOF2)oTKeb4dG{;dKdb$;1m08zvRSETpg((l0;2If6mTvuu$Zzc)zY&ShGNQPw;dE^NYd +RM&Q;D6JB!ge#2ynfuow(jHD@sQ%Pb~HTGD`*t-$xfrt;C_DdYH_eDSWWia;(kLGZ@;-3vn=7D3n+~w +yECh2mjA`!*Ft|Z!gr;~ZZbzkABQ;@l!S7Qr(}kj2 +P +-X5A8+H~|Jpy~jh42b_=Uk`rVTQKY7f*AlE>t?_1l2~Ksr=$8nUiB`4UeXhf!P- +cf~f7c*l!DKN$g{71gY2_yMhy#p@gEH$;Y0DfEE%Qi6A +hheD(krEt7v(+RHx>2)fIKVuetcOO371(malYjHmOGCmQo4#W2_dlXsr?i15!+Ooq>IafgCpeF^$3cH +XJq{`u0I#Oeg>Hv+JvHF$BubmtVRI-zI^9SeL?N^BN}a-Di=m%HHZH{p|qAJE^xn}wL3M(j^^$VFVpi +-V;n6*>bxI;~wuR)lTZFNa0C?ta@ZS-kVIZspRP%VbeBcq4s4_Z`y-AojRGT;!>)bvjENRz? +^~UZvU@$X>I$vVS3kj@dk7!v{5~jaHilEyl_dI!Vyk1EpVQ_1|De&l0cM*1>`bxB +OsU7jf!lXOCD_-oxD@@mS*MYRcB9F5pRSGnO3#VD6V$e+TbnSgKF`Z0SR~^ui4En(aKVp~IV1h8p6ITHJyFTfMtNoG_`_h|38+F0seFEOzl<;C?a03ysLE>}3YZlw& +B+q*qqnS&H+rC}!65_1!)brRyYX?t9y`aDpk7>oB1fLwF8(#v77_J +pfAB8NG-X`PtP@`2I9R6ru8B$$5NFPSKd1tMLiUQTItks3;)NI)E9g_dZ4nfEeRtUgV&jXBI+yKwhw- +Ro&}EJ`Buz!;?#lt{J8P0EI$OC0&3F1jpp+oH?FQ*AbPTuAYB#~0#e5Wm&D;!XU%K`q}yXz`HXpxkr6 +h^cnx2J3_0iHMKqr+I*v06Dr5{yjmIl4KGAr(=>WIG4^0#_Q1bBZXv?rloR;qo4yYHV3D)r27?y7%;K +b$lZ@=TJUKl4{AQm+_`@&>-2#r%ct89XBl2{&U+s4OI+u$K8i5OEFn64k}#QU@E!+4J++~N;EJN0PT7gIrTZ=*_4;KQ8Cu4|)Kk$TT!Sh!rwLlGfT^L +L;urRxec9?7d&9l%bVRO8Ikyt^xCArfh7p}B8gx(Cu1>SmJ_!UJ4}#)y&qQeQ&ld4HZIBUf?ieq8c+b1-Z_b|Xx9EaQ2U1P;zJ=CC~H+-85T8+EV +qG(&448%_k&>}1e~JC&H@pb~5miuK5q7QhyzI1-Mbg0blSmNV*JC;r*Nwj!KE5TRCNLsF*)x18MTfl? +cQjAep_Xk}6;xK8WI@R}sd^h@0&F(I-yn(U{DVf^T4f{7}^;C-GP7K<2vpJ+W^?jm5j5N|yRMZI0vSwuVk14^!6hR6D1iV}5sA#B+0 +6D(!l|VP8xbQzLy4fJ}-mCzX^-=Kv>Zz_ok$?1AMwn+?&KB1vz2F}6LX?zKH77r;h#$@`)3&iy-Ll%) +{+7+zc@j6o~SxY`cci}UWc{gS0J9%S=SWs|hS0~Ix?5IWpoQxbrhHIALKnZt;H95MN8RoS`oL#K7G#7 +`$$Z&C}o&|(As>=Yzhz?EivJ=6fkH&JVJM?uQ~sSJYub#5L-s+sXZT@l#Fp=4Mnt(`>)D!P;{I2cMFP +HG86Wm1)j{wPTuA$EzhqLI@t79a^Ww=fi>%P4j!{oCRFW>I(P&wxX2!!hH4@PH>*w>92kKrQ!`!P$1Z) +&V9)o2cXvZ;>WETZufC@RmWal9hKCS)nuQ&y_Uoy?(V26M#la|Lmt+H!{@QJZyAoxj3Tp0`xTj%m0eK +1v|&~eW%b+6~}2nvG8V)vqeXpQ9XRoD${?6N~onwVH7AlIttaqN07>k00DseAS80DN+dts;$zS%qS24 +*y{4g7Z$LUm_vI9~f?7$Rq2En`FQ85~jckD4mX{$!Q`2Yw&B&n+sKp5?sjG95f=chM7yE{cH0x5EF7n +U8d!XNRsM>O}EUX5gtgmz1kMs1cl2DVun-S{z} +YWRef7jCQ5TDR0DmzvY3t*Morg#6>)TLJxgoh=03?h{98(K_QZ7wuY6TcJ6`#2iW6*c4V +mnfeG$`*k@tA4Uga1Uss$3ZnwL&M>Zyc5YE*(PRH$zR~>*e$BeiwX_Ww%PrWQt;{{f3*5v +_?<^A#*2tV?7Mf%0awv;$g2L*SOb>y4SS>mCI2gVnkA;j>iy|sz4Ec-hosr`83bT!8N7FSam*c|AD&K$woK@sCeH8+hh=AP@P6gtlzY +A(6cqJR0>#C_#i1kiflZ6*Uit!yZ1h(fXhl)ihhO)`njKuUrk(QNjy^Upt|QgtneW9$GOl6X70cPs +$IHEmbg$eJdyJB7y=TCu^(o6ps0gwiY*^oJcrs~`+d~Co=@{L%C9QVnfUqo_LgLP)4q&w``hR{JFL@l)_kuA#%-v +!3x;elP>kV%64fmI5?btJ2Ww8)H*R^L?)4E{xoUXunFz00fQjEV)v&coGL;ebn;tfsjtO0|mNeMg{Oq +Leb&W07$b*>SWRfROU{`u}m%|`SHB0sCi4A#ZUp+N?$?A+RHU|f{w4KLaN6{=)*8p{thP)7Px162=3{Q +LVK{ZYsl9TBa2tYwl#YnQ}?=tTa#c1aT<8SkLAJ2En>KmL~?12$!JC4& +hHr(1>&?qN9B^B(Wzy5R}xYNYjQ5*cU_F)L{YKqe)478R%yt%X&sSjd5qbqP{AgD18=OEvEk>=913nS(0q<5rBUn`iaGNLKJYLL-1vNfd;5_ +NsU;^||}SFTrP7VBsb9f8aBPkbT#FTR(~W5suu@oXFFac2A);EnB;}=dkXzEIm*p4RlF$%MLsqNuYm* +yWx;i2#Wk1&(b{@CLEFYUC%YBdp(JQCi>wa#1bhG0396f9jP`aD`aIN@bf{f2{HUc;=n)Ksq&!)e?C2qXN|b!82i48LEYj&yyPigKp?1mPX;R*OJ6;qa7sxR}QqhnX(G074|&VP8W!?Y6pa!%L^TTdoJyw1bQz;bL(GSSCrBVr +_vdr#}LSk>}G7lj#6fwA+kgSyuPz_zRjvpi1_XB2(zZOu$;L-6t7RwpjTR1|Q?4$oS{G1uJr*g@UviE +=wEy)`rqPZffXk@7`3rvCJokk=4#u1=Q4;~<_6m`oX{o>GzNl&RK%+3o+Ffke9OvCH=W(umY!)qo3sY +N>@`TgQeN#-(Vcyj8TG%bnWFJlivrI*NpC^Mu!=o@yhs$FjBoPGpB+@zy`ra*F0zFZLjVO%F#F5S+t| +83-xX(#2QN1sWaVc(in%pxLFco@dutk^HXW-!umVFZYtZ8OodM?Tvh6t4Qd67Zg>oAB}ra!b+I>Eyw_ +WeAG<~&e&zZ@W`2wYAG^O~x3bp71tyN7kJ!_zXBzbo5Nbq?{IgcgVDo6_Im4N8;<53jr_sZv?t=5+=5 +O7}ci_iE8)nF>Wr_KHvc6aO9?0<%1bfX}CT&QsA`M0cJn$`7QRF7bO +{OlUwHOz&PAsBy%X080Aq@_c7Yh%1>0t;soxR#&4>t9d~0RTklw$?y0EZnHq|9!&B1A6jh!^ACxFqac +-C>;r6B&PM@4T&595^s7~Y?>h^Jla(vc)}bYn-=H^Rm1qgVqx4xMTUf`{SMd7!N9klc +4SP2H-L4YI{9t{(|p91OD=aBg|QAe!5$sG_Wdw}y4OkAJUre?ox;+6ri%9A#9teRP;LhgqZILR=|iiZ +tZnir85SvTf1SG5HBGd8EaNbl;*m_;XOrod_bK4$S+O-e_>EaYk66^@4OPpiX2-{r9d;b+(L#0)fMTR +O)p{T6sZtMxRH0hb>qJ6}sWQ!|r~=`%5^V^;EhrGPzL@l6?9sPVS*3mKN6yM()>yJf*3F*m` +<0a&3Nw?R`0{L0{f6Al@{xK3q5Fft^S370_aC{()ce@T9=5lJ*U;F#A0EuJ^HjcxhR??Ef8?L}O +(kukw{dTjxV8s&!00dpxb;obiy*|8l&Rc>m;T(mSWWo*xI6{jM&Y;qQKEvVWxYmgWdMy9Z9Nhg<_qsT +k@G!I}ivocV1R1?Xy1A}1B9^xFr{FQz?ZY_M5_2v7)|1q|F3WQjn9bREzai-H}3Lo`$95*M}b+4ZPMRRWAPk +c-qaHc*cPUzE%#tdeMd3eD1o;LEY<#p<3QGMl^WBP7m+V+EfR=f;Td$pgvUJvgv6Aw +cpjn&|A3Yf%+252BxR%w;gi4EPJW6^^WQHaF*PI{wMoQ9}Gc#?gYq|2kKrQR&kXb5m`@zSrK?@zX=As +@@B_bXa)UbY?+tsIX8!TZ`T_Q>t6S51D_C+l0ch4S~{k;7s>RyLu2_e#h;=MI31Hf0XN*Fi$9F`H{A-I{%E)VPb@E`CQm&Ld1jq$y@lssr(;)ge~ysib&C7DBvzpz8oySU6+> +=H3D-_#E+qTG4hO1`Xbwxpm+$38O;jSEex&$k?+fZ)&-8qY7d`;z +EN+*QeVP@2gjEW>%1+3So@YVj$oU7@ +&*`~PpQS=1l+Qb1Mq; +U^`4wgR*0d#nsE-)oH|T*9SF`Pc2mjIuVxA~Hxe?y@ +aEgS8PB9(y#(GM!TIkk-MfEjIJ8pe3w!-P7lFZ1^R&{95-)L^p?Lv9!IXr_)I9W9Pkeg%Y)cs;oJ5=F +EoEQJC^V;sMh$H$R)yy`GeFucd;X$`t$43H3%-b`8w(IQC=wu#&0rVO71h$2|VF7n8cz#pMdidp^jfE +eohjMC0X5$-Ko1LJJ-FWB=nq;e#3D6Nu){n@;b0U7ks!K!TuT?qkO3v)U{3BAwo*1T5*0l +55^{Lz$@N(dnkSXG$q@;&c_L_YT4rjCEH{B5EilJ~#x26nWyu#w0sE!C#M&*(o2+TEEF(>h9R8=%h!&k`2qIaG#c9;VLDZSI-m&f#&GNunElzn(X${175=zAo +DB@8qPeL#63-U^1Z(zWNUHhCR*qt~_a-m>N`ZZyIz=8v?rKjapg2T%&!dsQ7+g>|fU?komvGXm!8}1c +W>tbvz$2~3hBL7BUx0QBz*&W)$bHBo6f?iMQtu5?0^2a?7buP52-X&L_5b5GEDS?p-$#U;a~CWz8~_5i%Z*w7+8nvnYX+ip_#x}-pq3!Ma*=V +`Em#_~=lQ`l1{6b-O%kC6*9K-2}Nf_XHSYu9B?>s~<`GcCF_)HE}i-n{L_kp7j&aBRU_w#bzbqxEZQh +xS#zTp4of2kKrI(|+n!P-S!&;O+ZByix-1SRU{FxZvYSzH)h~LwfrrUbi4}?R&o_b+6~9lGb@c2c`;4 +S;dLKkW3SrX?PEW2s1yb5VgX747r_Mw=$`FJt;$a#J-iq4`7F+FYs6KDo24%_}$v)4o;_~rIu!oFf~M +yGj@J+Qulh09G(`|@cBh?`bnkrvUEJX7Z966T5wt4jYCGwEWhJ46t)Iu>dfO_H_izkx^mLPX>E^nL|( +tmw%(VDIT(P)rkw~D*Z`}xJk9qsf3nYCOzK_-^>xDwIJl?g0a;xZIa_Z@7IxmhbG&U=Lf3`smMuE+g+ +Z<>Zh4^Yb&y+`@X6B~va!{Rw8KcRqC>i#mX<)*(nJ9#uJ)Tb{?c6a`P2dKo=Z;~7v6<$y?6==dwsBzwav<=KdL+Lx)d4*JtPz)O(OWxrngLDFTAyd2)8B$)? +>pBAN@X1O(O-Wh|BD|7ee%)5@CGsG{8m}-d-0f!69H%$s4tINW2-`-Oq7|PS*aPZuj9_BK!!Elb9FXY +_b%k=vOa;E^1A1|^jFBk+MU?B8x!?I+zj>-}>@13~>ou{|guAT4ZtV55Nc*y8cA@W|TwSRK4c|XHBEG +RO4KHVm`hN2SB*AUB4Z?*e{mzd(kF`PivlceDw*LQkly{F0v>QAAj>WvU!dQXr3uNS`UqtA2eb?ROp! +U#sR@YI$i6`Zb_o~gIYZD~QhhCo0ua_I$V{woZ!6<5W>EL*s9@=Ai;m_q|p!*=I;hA=YvR%Ty`~EY~>&x( +BMo%;mp3L+vIsB4oj^BGYaZX$wO2&uZ;ZdFxxEvFC5pRjx{DClub#pM@4}&k}vB2=F85|%ki6F%rKa5 +$~7sq}tm(f}<+?iXSQTKXqQfYbSgOFu66`0`r_U?TKO-Rtluq&J+gy{Gqs +PtA?r)NpulEC|!{WXMaJR?YSHtq))L-tWTR?CbUW+i(ZGui5-uFs=mDpC +N%kqNz{+&tP>#^-D?uyq}dI|6FhCcF;xH^L}mU(!iphfq>pm5}b;S%m)=i6SCyaea+Qtzn9Evl6r5ON +>hbGk2I#2XPnnISh_KmGC&$khHij&0wpdyW0}>;V%(&Q@AU?v+p;jC0AD^YpLmOG2R#kQ0$0$>aRAZr +rOzCBh25jA<1hAVc%)1Iw=@z%}!GJ;>Sn?Kz=B(sxyXGx3@CJn;QE)G(~rpQq|;Uml98K2;@b@Zl*HM +A38OeqTp=P*V9NMsqjb_JX?Ca~DkNYZA$kq#u{|kbFRz6!4ZquS6L>5Di3f+C;eL6TD(I_I-Ghy4NAr +^RV!gr(U|xzO!FwqKx3+IA4HzYZttdaBa5feJ|cafAhq&>)HuDJCBb+3cuz~MI!SR6DxQb% +r*SYnu!vI5q^J13u8vJ9AL;;XY!k3zv~q!6m9`?TfI=w* +I4jSk}GfmhFpQBLHMbI3PE@UvA&>4LMPW@IjVW!<4riLPfon{;-1OQ@`*M3TRL7de~nM1JM&HdozD%5 +530I*QGpgdvDkwHw+YPqSse$z0S8;yqrpx#0N)q`7K3$RmbI>JhE}$#tR07E5if1Y{~NZ_!O5nFx=yX +m!#MEUw(k?>Vb9lu_wF25&0~32>Eu2MM`!(bjoBL+iu?DC69wDJAh-;Gbf(^wS>rG4C)t;`zwOf|5#N +MSkvAx)Iw+#*SN>qe#sI(u03ynQ4c7GGl=B7*w#>Z1(Nr85fXZF%hU&AH+p;G*x#$cCAcpKcHrUlbQb +GcEMT#iM@T(jD!KOCF}xCx*mA+tmMF}7{w}{h>AL&nUNw&Z8qAVhTe-8r&=13Q&oXi#02FoN4;*l|Wk +D)V+OlA1d8yc^e!aiMSv6+$UNg^XdSHnBo9aRUmHW%jc=Yg29{k_SuU{a@@$Qj*kN4X5y}C)YLl$U&6 +qfuIfZ%zJ@}ee5C29clvC`RBj5KW?wAg+WSJw4-6;7&r(tGyN{^??S?f~^-knD}+-umwG#LJiS)R5%1vbL_hAg6Ruj2A4gZ9@23FpWXqlPR4w)L9A6OIt$37g4X|i`b{5>oEIm~BC +uMi>a`98o3IaKL)UWOyU5J~Z8w>`Qg;~O5en6=*0wkAVZ(Tqz46qr58PXpw!Em6>Yls)fdlI=v-}O-0 +MvI<-ZlM_1dkL`yEPBpVVIU)jt-6&zL(`Ank8bz+?kl`wcPEFV=EefMUbR@aB4-u*W+*Crk#B^Xt>gIF-i +B6L~7N@(F&?q@DXVOg#QWd3y}8xVq)J{RfUqwSD6^I@ff*wkjd8@)`{stfdcx%XfNs$1fWU1zQd1mK2 +ii^P3!^c{xw7z_fCWu+lOtD~}*DbM9Gk#Z3!pvYlVY>riM!);v!*}n$f5VsIAjnv86Km-aZewl>N +656ZODFbb`DLFH1n(@R!f2Lp0iMO3%;XpWUsmY!QpAAT_3({yjgFd7)n%EmHzgs;%VI+0Zn<2n)bjOf +JN*=JzbqcNc5|FJ;_*cwxrq7}?$%Obyb7JG$d+HpfjwVbq_wyrYH`|r)h;%pLb&_ItWa0EtX))zo3kV +#u#Aeh4sdae&7$IBaf8|7YMaH)49n|VP*tmL<4f`E;-u^H-YyPVE$<}pEDmL~i#ppydE>HBmV%f?M7# +`IRc(Hk5Ha_v+n9N2tcCO*me&HJ5f(UXL9rH0VX@~I6|Bpztl$vT;t0axOw#g13nA^QovffZtoua;Ao +YubE6aPAIO?%DeXzW%#~UK3-d+}DgS?hyLlo64cF}^?t~>ckZBqBk2En{8H11N}2tA1E7xDNa`d&l|3 +omqGTb5TFs0!H~i=64YZl}~sW66Ro(q7ACmq(2Kst-JoB{_s1EiZcZUTuKMvSJ++u?+W#>eqc}b$Mwl +Ve}&0T^=U1tiwRk$cj*75f?1IU|n3i+oeN^gSgOs3(sv``w%GU?(P>^LH8|{jQ1FOtD;+os@eq!TNH; +ZE}mJG-Y@SS_G(=V!mU)f_Ls7egzbKj6>c(HUcY7qt*J1a=!I2WT<5Sn)5a;v#d*KQ;e|yR?V^NxS+a +KRBEeV^xQvSmktK4w>RvaJL3)N7B))87aSy=qI~2Ul+p +h@lR(uZpFHU1GN_+#*6kO{O6wd~AA@SUYddOkC1eYxYC-H+z%z}%>f=h9Ndbfbi1rQ-PFc+kBf|`{8L +* +X*p>*X*p>*dDf)Gq{XDgqQ#=c?L1OE8=Q#`>b`@btl-Rea1c80EB{?vY;L;D47b1b%GL>pr#@~%t53Q_}PK~9Ml&C#Q<^aWChW0_l +vBMV+}H;0k92#b&%Bxl2-x43m`_|x(8lpfVu+|93YthqQrgaJn>Zbi>!cd1A-Y4!2sU{)Gfel0X7S;S +-__P{1Qa#L69E=`9aVcH>4*>=zftEg1aE}3Zk7LJ_)@1z;zG2)xd)ce7?ZR3p}jAV+kC9z*@&~JG&Im +24~`ftZz`<8JztMj${PIUO|dD$bhtae_!8@V){ +x6=0}<6b0ZWh~R?|JP1dFurY8p;<)a0yI415g$rsncRB=|AvmlV9McZ4b8r+ms2mLr*u=RnJHuz`ei0a=>YxNP$lwQw;UK{n;Lf0CJ +1CA0>Mw&j!XS$q6q^OrUqM+`ocmH7e3tGPfguGSxhx21TPmF=$W>8dTl|sqY|h8c?+0`2H-{0coLXIRGF*aeth<_z<6^`$cLfbA+w)6MY~ +$R6GQDKfss)4+uQ@;69$RJI8hj!#tTm41*hAB!!N-(mY^Iyfb>BLUl3{pXg+|`0XL1Y4^82-bi +W7@>D3^^GRr3*Nu&q@WEzmT02BmKY7m_Tp+Zpb6qG6j_0}=wJ>K?9g1mN6p%zqH1$8|^vLdLz3Fu>h6 +oYsws9X(-^McZppmZasm<-AaW5hkb?Uw}gc|k#5kh}_N%7Ox^Ab}f{6b0o#LH$oqz!Ox~1Z5=w(+=uL +f=Y@Q`!Ym)mhKlxqSPWNgb2zWf|7xtJRnHz2kG4)X&m7WSmmn<@q+5dIO2ASB{2f5&fFB1qH(;~@dkt +u5Ktu!3Hi=;ad>Qk+$BSPAMhsY60LudO6`-$xngl>9Ku!TY3Q#~0$Ob`c>@FQI(lWQ+!Ds1yks6MS1@ ++{?8L{9zSa94cD7Xv?D}vI*pujII#wv%8$Z!lOI0h8=m;BBsXX$G_zkEG2#$OPzfKvkvZqRZuljf +3keQ*1PSVZumx4oL0xcA*BO+51eF&-;xs&cP_7^f3C0!Bf>_(%!Do31jt2x8`JkXbD9{fI^n*J5psqe +(oaf-!Y-)p4GJBD`n8|{EvPOFim` +&sd93a4;InkUh!ZLJAWI!2#ey7FkmL!nG(nmrNR|W$Js_6>hYXlez*K_dS*-2v;InkUh!eCwU~NI6YJ +j1F0@0vAG)zFgry0~~#{DG^_$=KoGDVeUP*)k0R0buLK^0}JO^;}fU{U-Sew9i&H +%J#HO+h_Gti0zJzl0oikUj~3c#ts;asdGV4!@J2oLa|Q{siUr%IE!`bbu_a{bdaJEZr|MMde*kCKr^t +1%+)vjZ2WO3}}B)Efy4o1*Kp?0a(C6gCeh>QYK>CH{6w%p!O=LstU@ef-Y0db-*8t*w(< +Gl5NL#)L9&8+mY{GYC|n7uQX;Gcw0ME(rdA}V5D6+o!h=5ai(eA!@ylT$dtNJF4iEvPMj +|fGa^vCGkm%CGZ38kJq`8N_GwGv<9lzm?^mvg$lG{OYJ4iwY8QUNi8swFO6mgK~4RW_ZLN-Xg +hUZV=Y!P<8ldpIqFF|HC$gBqW)F6Qxq)UTbXpjaCGN3^QG{|=b3CkBhvjMgJc< +lv|^A03^IQ~Ixk2^1j)7_M;7GBf_zwz4+|1sLAonQZN*(ojU&?iB7P*V!b?c7eL{bZWR- +%XQIIqW@x#S +!U#F_feg#2|+3$NFhY-%dPN1x?hBdj6skh2-Cp^holH%G +k)Kh4WSRl_yD;F$UQ*r0VEF~c>u`+kR71s09prZI)KmtgbvVi)IKzY +`|%Rc=YT#3^f{o&jEU#`Y*;81PxP92A4i`>2H4>&!hWAru1Gk-5ME11ue2=_t +SKa{ojh2o`KQVABDc4%l?Sqyr`$FzKkx3GgktUjz#_9kA(uO$Tf`VABDc4%l?SrUNz|u<3wJ$G(Zm1x +2cAU*?H#(fuM_0P6619Q{csbwH^DN*z$@fKmsPI-t}6r4A@{K&b;d9d~jY-=h0Prl8aTr4A@{K&b;t9 +Z>3kQU{beOz{akK-B@N4p4P~s^faz=zftTQ1w(E;MD=I4tRCIs{>vg@alk92fRA2o&2S(%_tA6U6g>s(ETD)5bS_lPhEBJb%3t}d>!E +HxU86*ewdE-=lD+q3R@c2=94%K-7n$<%MMs}z_J5|9Wd;GVFwI5VAuh}4j6X8umgr2FzkR~$F=z+ZbJ +8qOkFMoG6l;H7H;qwtAKz0DK<1#V5i|#Q0-EYfOLbVgBolxz8@0y_P1Z^isJ3-nB(oT?eg0vH)ognQ5Y3Kc=OBnr^1 +Z^j1J3-qC+D_1Rg0>U1ognQ5X(vcKLD~t@PLOtjv=gMA&+{H{`y~n5p6Hl_Zzp^^;oAw{PWX1hw-c_N +o}@z;C2%{RHuFCx&F;96;@JdpCy+aV+zI4PAa_2Uj77^u%SFq@0~ak8Efy^nEfy_qKZ@en1ac>kJAvE +@n{E{H>1c4_AJVD?I0#6Wlg1{35o*?i9fhY7kq2CGpPUv?+z4N^F4# +l$x{Z8n2LcbIGozU-uekb%hq2CGpPUv?+zZ3eM(C>tPC)7L7U9^t@?tYOP=yyWD6Z)Od?}UCQ^gE&73 +H?s!cS64t`km14gnlQ~JI~v%rg%1?-wFLr=yyWD6Z)Od?}UCQ^gE&73H?ssQ9{2H`km14gnH+B`_&ZB +CiFX@-wFLr=yyWD6Z)Od?}UCQ;5z}|3HVOHcLKf>;GF>PJolIBVQ0HvWCiA(evv>qQ79U~cLKf>@ST9 +~1bippI|1Jb_)dU#0=#qV{5*E{B>~?F_)frgg1Zyko#5^ScjwTDUjCKlNDG)d!Q2VvPB3@gmlk4YyI- +UR+@0X=1a~L6JHg!v?oM!bg1Zyko#5^Sb0?TP!Q2Vq&btU6!`l5KHIVLvbSI=cA>9e-PCTWAbSI=cA> +9e#&f)NpmVJo@%LwMS-}Xz=Yl6!@kROc`q{USg3%c)^i{9)edq4xVH$|0Zrl|GOgz;^<^6X2Zy@4PR!!hUwY$PeH<0pAJuPQ +Z5pz7z1BfbRr+C*V7$6OY^gz9(^ELcMctK8eZfevQGL2P6sboq+EId?&a&!QBb&PH=ZZxD&#i5blI=nJ)?HPDpn`x)ai!knV(Z +C!{+e-3jSVNOwZG6T+Pk?u2kBgquSw_Dk_>g1Zyko#5^ScPF?z!QBb&PH=aEyA#}<;O+!-Czw0I+zIB ++wJ-I@P=AG +c~1a~L6JHg!v?oKdwg1HmSonY=oE&~}2f6QrFW?F4BjNIOB=3DQoGcHUo-ilOX&5hBobg0>U1ouKUmZ6|0uL +D~t@PLOtjv=gMAAngQcCp0@_A8x`>z9dvT{WdztNkX;Li$lvNAW0zY1ZgKoJ3-nB(oT?eLbDT^ow4f? +v60;`LIl-LsCGiNCs-yy+X>oEXm$d!6Of&N>;z;dAUgrs3CPaaaTeyW`$dw#*a^l?@O6T(6MUWFJNOv +n240=;>V#J(ygK3439rtZS7RQ#U*rc~o$%@eRVS!ALDdPWPEd7%suNV5pz1k&0&=7N2TbRE=`lvJ`$c +{L)CrqT*mT0C6D*xz=>$tBL^>hT35iZfbV8yN5}lCfjGgz#D0aWd4@5d4(g~4Hh;%}v)8jzuaENq5q! +SXIkmyVg$uKS8=)5nL#vZ;TSUSPd36@TZ&>4Z%uY&z4MLL4e;2r!+w^CFnS?iV3~O($$RVbcklPS|w9rV}=uu<3+NCu};w +(Fu-DaCCyBGxsGZn8KG~SO=Ri3QC<&>hx+nLncsl=FY!i0DHU$7N|Nw)d{L +jP<4W;6I7j`>I7A1I={$N+8eS2s!mXK=Dws31K9l{Q=sYuRVS1>q0|YWP5^ZRs1rb)0O|x#CxAKu)Cr +SLm~`fK&o6!nY&v1n37byXbi$?+Hl1khR8zpF6E>Z&=?QX80CfVU6EL0krA}D9mjqBJfI4B*37byXbb +_T5ES(VPgh(euIw8>siB3p#LZTBAowYe47Vl+3coQt0VCe))Cs;bc(g~JMuylf@6D*xz=>#b!jfzb(!&hkrDeFE|Wkxqzo +LZlNCosj5+L?o%bauSheo=&+99P$z&o0n`bg&Pz{;C4f>Vlsci*38hZxbY8o@1Y6eqo_>_(2o +``k0n`bgP5^ZRs1rb)u<3+NCpbF6(Fu-DNOWGeeWUI*A<_wvPKa~@qZ1gNz~}@7>{U~~eb6BwPq=mbV5Fgk(J35-r)bONCh2%SLa1VSeeI)Tu6f0;BEtoucrfYAwzPGEEb +qZ1fC6=#TaLZlNSouWxdbV8yN5}lCfyl(qO-D^Um6C#}u>4ZopFgh>A$+tn0E=8s#sesT0gf1X-!JiB +MT+huBv0E<%hb}mD!J!KdU2y1vLl+#n;LrtsF8Fi7pSgI9pJ;Z_?4a4^h?uPI_oVqrbFTDb;}%4^Akq +bqE{JqNqzfWlkmv$J7ZAFD&;^99`^!PGR^9LLbv4-ZG3aB^$Dj{RpraZJEL~vf0!tS-y1>x|jxKO?J? +}Vxy4M0r7g)N$(gl_-uylc?3oKnvAGm0_c;KQ%(88AsTKMRlC&Myzzd_5OWzaHc8MI7VCM}beNz3F}N +ekyUX_2%@TGTzi7wcBEELs*Vi!}kuHezgr^oby1>x|jxKO +?9k+d>?zO?zLdk1)DC|bit+zHeImkf=w4}x?t0Fc<)F05t<=EfawBE*K +yl7>Rtt?x>wK%wYTDdD5U8~5F;pcL8t4uxe;}*1*I-1bwQ~MHeImkf=w4}x?s}I@*mS|B3pQP_>4HrcY`S361)DC|bit+zCS5S;f=L%l+J4(F +DcE$urVBP*u<3$L7i_v<(*>I@*mS|B3pQP_>4HfYOuAswb$_WKrltEueqhrDn=aUN!KMo~U9jnbO&4s +sVABPgF4%OzqzfipFzGsXejd}({USB6>4HrcY`S361)HwZn^WwAg#u6)fVu$G1)#2T>q7nz_jubcDJX +S8sS8S7Q0jtG7nHi7)CHxkUE*k$$PK8vK-C4R9?Q{fUX4NNei0&gb-}9(US06&f>#&3y5Q9XuP%6X!K +({iJ*R`d{D)@yJQ)V1`$dR=)&;aKpmo8k3tnCD>Vj7nyt?4k1+Ol6b-}9(US06&S#giI{gMJ+7tp$Z) +&;aKZ#RRg6y&-f*9EyQ$aMj&3us+H>jGLA(7MKXkGK7j0$vx;x`5W@mptNn7Ua4h*9EyQ$aO)k3vykM +>w;VtfJAlC)CF35F3t_yNqP_u$u7v#Di*EM`EWNGX#A;4~QzsMBOy5Q9 +XuP%6X!K({iUGVCHSC?P$h7UdG{vBV@O6Q&3w&MR>jG +aF_`1N?H8wZGN_4-76BxU|*af~W@O6Q&3vykM>w;Vtw +;Vtw;X@{pCFvh?jz37X-T?*9EyQ$aO)k3vykM>+jGb&c#H+ZE*N&funUG=FzkY17Yw^#*agF`yKWnc(ETDwY8F^_!Lkd6 +T`=r|VHXU$AlC)eDF8_kWR#wlmP5TWw_lAh=zftTrDne*whVGzkn4h67v#Di*9EyQ$aPJp7LkEm7v#F +;_Ny@l-7lg8w65tTp=BeQ`xEj5v@W1^0j&#YUDH`YZh+PWw66QIYK%emi~Ins3us+H>jGLA(7J%u1+* +@pbpfplXk9?-f>#&3y5QAy^J#&3y5Q9XuP%6X!K({iUGVCHR~Njx;ME1Mu664j>R +t;}U7+d$RTrqbK-C4RE>LxWstZ(Ipy~ou7pS^G)di|9P<5?c7laAuei0Z@b%Cl2R9&Fz0#z5NxIZhx}ekrr7kFSL8%K$T~O+RPS@IXL1_B!7pZ|#7nHi7)CHw3D0M-p3rby3>Vi@ +il)9kQ1*I-x_JU4V>^vDt{-vPQ1*I-1bwQ~MN#&3y5Q9XuP%6X-Mku=-u)s;@alqB7reSa)di|9P<4T-3sha8>J#s{;M +E1ME_ijptLx^~X!GtDae`MDyt?4k1+Ol6b-}9(US06&f>#&3y5QBd?=1^|N3(ri1a02^a)kvzX99Ezd +|lw{0$*3y2sIRrGW-aAAXwn*0$&&8x?-P~Mv-^F$P@&-AlDUkj!Z$W3vykM>k7STpMYS2uM2!#;Ohck +m*2@nzxX9!>;hvK7`wpN1->rub%C!7d|lw{0$&&8x**pDxh}|cL9Xk*gbMZjQo!p1S{Kl|fYt@HE}-? +P#|XJD$aO)k3vyjR>jGLA(7J%ubzhQ?`tE)aC!lo!tqW*fKw;I8w*V +dcd={F!`$e39)&;aKpmhPQ3us+H>jGLA(7J%u1+*@pbpfplXk9?-%I#O9xw~H^30__B>H<|4sJcMa1* +I-1bwQ~MN?lOuN+$@BNqrzz`o0VX&E5SXKTzs|QWuoEpwtDWE+}fJ>b%E`Ujo4 +{2zCLj3us+H>jGLA(7J%u1+*@pbpfplXk9?-0$LZ)y6(D6^mX@(Bmu1pXk9?-0$LZ)x`5UNw4MOp0$L +Z)x`5UNv@W1^0j;ZU`$pYs0j~?1TjlE_PEfuA$(7g(T2(?RXiBLkr3eHnWzc}HT{o{rH+R2ClBQ6rhT +<>OTdCfZOGQB`aM||?I(#GuUOkMmYsd4b4HrcY`S361(Pmtbb+Jm+VMPkxcfzFz|sYlF0gb#qzfWl +US6(e36?Ifbb+M{99`h(0!J4(y6!IpLiN5(=Lj}ku<3$L7i_v<(*>I@*mS|B3pQP_>4Ht4@&~|l0jBH +P=Z8?eJzmrifVu$G1)wefbpfagKwSXp0#KJm*=+)#E&z1_rVB7#*Uponb-Q2W2S8ny6sr7*<_Hm#x}e +krr7kFSL8%K$T~O+RQWtc(t~;Km?zN!Q1*I-1bwQ~MKwXy;I*=90 +jMw7^aY!~VAB_D`hrPMVAlnhzMi+m^aY8& +Ako+J);rX_UJ&UE7<~bwFJSZqjJ|-;7clw)Mqj|_3kZDyp)Vlx1%$qU&=(N;dTx%0O6`6ZEf*~pEf+0 +=mO;y)r53FCT+lptVECUj3z`w**X@^3_j-Y)FR=6lmcGE!7g+iNOJ88=3oLzsr7y7b1(v?R(bv+^cv|k8kv^RnQz|d=U&q?IxVBqGCD1z(=s|Oqth}vEu+&iIxV5o5;`rR(-Jx@q +0(JE^l#ior#*C9L8ldTT0y53bXq~D)pJ@sr`2;>J!d!*fBBJKt&y4MyS=B+Tcgu=@#* +Pc_^oUOomS9k1)WyUY4x1p-Y{At)9N{`p3~|%-5F1oJ)getrT +uf-Kd1e3+CQiLbF@C+N%LRYL#I7-+C!&3box4w_Rwh$o%Yaa|D5*EY5$z|&(U^1{gH-8`fl&vc}ZGEr +)6|nMyF+TT1Ka3bXrEIWpr9brzLb+LZ>BkT0*BKbXr13>+_v2|Hkc<(=s|Oqth}v0x`lr^y&>!8|k!> +PMheoiB6m7w24le=xFDiPLY4(Hb3kX)pLckkxm=ww2@BVUmU)owdW6MH=WkfX&s%`(GibBW29Z@(<$< +A+{UT3bXrTNwRGA@pTmzfQ>~@bS~_i{(4+ +5YuyB`}DRJ|gr8d!N6CLHdy-%OFW~z;J+DNC3blOO#jda>br;T*lNT(%qT0*BKbXr2EC3M<9$NTxSPK +^K39y;xz(;hnQq0=5Z?V-~iI&2ExQ?s;$PD|*tgicH7w0}W+{URrblO9wJ#^Ybr#*DqL +#I7-+CQiLbJ{PRr=DgicH7w1iGe=(L1R +OXzsN53dvB-?*KQT1Ka3bXq~D6?9rbrxkR}0h^mv&uQzNw$5P_+Mc$?e5>#MJq~~8C20?x_Rwh$o%Ya +S3$UKyre$Bk&hLACdtS1e1w8y{zqt6~=igrR8^qaIsE=<8>a?3qyXmx>PCMzelTJJ7oPB-kO!zl$gVk<2?W +S}1xJPeW3+l9+PP^%}n@+pww3|-5>9AR1Pgc`nI^XB3I|=@c+jO;{PP^%}n@+pw(}p)KsMCTvEvVCiI +xVQvf;ugz(_%U;rgQeZy7S-PxSgz8P^SfT*aMod9Uc)Lf<~+@b=p#=Ep^&br!933x3`nj_xb8heShON +V(paD@+N&R5vFS99WvegWS;`=18eYk20Np)s!prwe4nrGT=zF_znVTg#f@02>a?m(tLn6>POIv)s!pr +ww5m?4>aZ0uzeMe;^Yzu8=KjWQ#M)Pa?%U*H?Fj`$JH}o9kS=o~)DG-?&Xu8|<{XPMhnrxlWtww7E{3>$JH}o9nc>PMhnrxlWtww7Jf=> +0Kwczi}I)HrQ!%oi^8LbDcKVX>*-6*J*Q|HrHu$oi^8LX`PnVX=$D7dwuKYUeoeAEv?hiIxVf!(mL&{ +)4n?GtJA(Z?W@ziI_;~|zB=uz)4n=iU)@>kpI@HImy2G#`DtmLmey%$otD;VX`PnVX=$C7)@f;-mey% +$oohdT)(PxiT3)B6by`}VzO&E07pE6jFYaEDbN=q_#otleT&K--+Fa+`bg9$U-?&|GAFe)Jbc`mcrFB +|br=@jTTBm(=+E=H2b=p^_eRbMb=j*FGPyLPC{Isu5`|9xd>Tm-aqL$WaX`PnVX=$C7)@fgz_SI=$o% +YrF`s&V3|4!?Rw6so3>$J2^OY5|>PD|^wv`$Oww6so3>$J2^OY5|>PW$S7eRU_MzuVg+wWUs5>a?X!T +k5o>PFw1a?X!Tk7ytAe=Gx#D;NuUeZ^Dw5m?4>fAdG_39579iy3|uMW>vgLN}d=c4x2 +XPCM+hzRttHHeIc+)A~B!_knaK`Wv^wYK@)N*lB&8*4Jr$oz~ZBeVx|VX?>m6*J*v7*4J +r$oz~a+z7M4H&)>M6m|A0}&2`#bch`>oU$5R^wZ2a4>$JW;;RZHc?Xc4hJMFOZeCJX9+-urpr(Jg1Wv +5+s+F^%R{C3!Bhn;rVX@{M5*lC9y_K^w?K~wd8Nq*;_zj2$c7TRf{op#x2hn;rVX@{M5*lCBIcGzi$o +p#u1hn;rVX@{NXdwuKYUehi+?XuG@JMFU54m<6zPs_Zt$WDvww8&12?6k;Ei|n++PV4J@-v`nu=WpD` +iErl*&tT)!`Z}$z)A~BCuhaTEt*_JiI&H4g<~nVz!>ssyA4unze`$lAHrQ!%oi^8LbDcKVX>*-6*J*Q +|mey%$otD;VX`PnVX=$BzJ+^bq-?$A?OY5|>PD|^wv`$Oww6so3>$J2^OY5|>PD|^wv`$Oww6xCmJq? +{%{>E*7T3V;2by`}drFB|br=@jTTBoIT+E=H2b=p^_eRbMbr+sz4zPdBZ-?)uV`|7l>PW$S#uTJ~ww6 +9M4>a?#;`|7l>PW$S#uTJ~w6CRuIyt$J2^OY5|>PD|^wv`$Oww6so3>$H$fY +t4K;VkeNlahsYpRH4$KQs8Yn?_>KO^c)V@mp0yX^3I5}|DMvjDF|n_-{-44ZTt(TW}L2YBEst%FJrtm +@yfx}&)ms8$&|;e#P2)5*5TD`ovhQw-?+^W(d}b&+FYkUko~`gC|g7JSe=GiWT!=T+F_?1cG_Vl-|Jg +H_nLOuX_uXL*=d)Z*4Jr$oz~ZBeVx|VX?>m6*J*v7*4Jr$oz~aMeh*RSiNA51B);rpZ(HNk`Z}$z)A~ +BCuhaTEt*_JiI&4cuOVbWJ?XZ*Y^{tAHr-r|A`GE$jg?3tKr-k-8`**$NO;_9Ow9QW2?6l2Jc+9!cO;x_vw|?$5ZMD-@J8iYoRy%FA(;_=9v +eP0vEwa-hJ1w%)B71&qvU@pPipzaX?q^^7r^DY}T(bXp_j&lW+3qD{umL#R&HdVH_tIQ)-Ql{!b%*N? +*WEQmohf=8F-G$hcD`=Uec0mc_xmmxO^hZ+6QhaI*we0McQ3gm?3DU#tI&C)M=@it3Ej`Tn>%BeG0Yf +;F%DxK#yA}RaNWao57#|hxBC%(U)bImq=z{SbTQDyKoF9Q+OA*e%8hoH7P?Fh0J>R$y;zkft_J;ip+5A4;-3h0MA)`Y^hm7vNi$g|-jLz=n +YsMg(Y!>+2-S>uU4%r;C*^=EoAK);5CrPJG^9jEcLuBXd2EhzTWasR^G9-0ZC!My_{WF7;*CDU$S^1m +qjb%TO+duKy2Y!_Be!HR)-XXkm?Y}Y*;bjlK?1MmphXl`VO-XXw%m2rJG70r4BzQ>hkl-P~LxS1F^fx +5TG@B_C(MfQpxRCYc_Gpt8UFPt39+qavfbeX7W)m|aCSMK(n?MK(n +?MK-tdXX0dL`PaP*`+)3^GbE7}krk2EhGL(6A}b;*CR@F`M?Kdisv@d-_qplkg8L`NAhIH|BC=w>6=@ +Y|6=@Y|Ee!OM>ylD4#hQScfSPjwCX#>s)8X$fF4-THjGBy^jGBy^a{-f0lTDLNlTDLNlTDLNb1uNl(c +_R&lTnjVlTnjVlTnjV6E-#g{h7zvWYc8RWYc8RWYgc1^E3k{quz~9$*9Sw$*9Sw$!HbfWXB|+CZHyuC +ZHyuCZPMR<4hSn3_&$PH9<8&H9;*YcwaERUjoc%MAp~-H8+Qa$nX9yL*4s((~lVUPYg+J*^umKa%*yH +a%*yHa%*yHa%<*P6VMvN$v$qR)XyeOoDG_^nzWj7#EyC*H9kz147Lv9bbJ>>Q>R~+e2>IkM{7i9>U9>+`mJ3&+O +knTrvO?>mju4KlwZQo*T{vD-tKW@i7TL+W%)D63lL;ze9ox6DOqd5V^zC!4`49!vk@4Fz>6UI2Sx5_> +ka3g4q)6cS!Kzte{G9vOh?I4+;M6DyIhT{xqX7&z@_4XUv)4A;yOoA7acNj=#fvdzfzz;XQ=+5Z=Q)d +&uo!o;~FCkk>>R~+e2;-xjp3eklRCU_r!D08V?iezS{1~>LIG%ef!P@%(>tpvWLhX +B72DJA+m?a9wK{)>>;v;iS>}uLrM=5>mi_rfS&B@jX4=S1oa}Q7eT!U>P1j5f_l*%@&sO_^TdVV*7LuM++BPB2&wDGa6~V_C68Ri=bZ2vljvV9w +GvI5zvc(UIer#!cjOKya?(=P%nad5!8#IUIg_bs24%Km{`js=G&?_LKjiJi0VaDuV>HG4rhZ^6YuZUM +Q$&0dy(6V++O7NdiG}+h}>S}_S#2d4@O=u@_N1ddviD)yvXfEZZC3sk=u*hUgY*7w->p+$n8aLFLHY^ +v0mi$Ca*Vny?>ju!|C8nZf|nSX5GJ=$lgTuCbIW$x0z=Q(t2}3aFf!Tl-{KDW=_2cC>tC9C%>~j4ne& +M>P=8@f_f9wo1oqV^(Ls*m9xLjHz~b$uX|E@lhXB-v$NXaZ15(sH<7)G>`i2EB6}0rn+V=S_9n77k-a +$~xS39G0(ukBn}FVD?@d2|-9Iq~LA?p;O;FjU{&y49o1n5@AbS|5Q#KO+m0t8cH$?R&s`qy;aB(_#6W +N={vRCPk4M+F=_|3$6lh&KGvT6J8W@5dWSZ@M)6VRK0-URgi&IK;c25*9T6I8Y+&psZc^?vvN8EBsl( +t0zy-lX&Z8pN$X8o`KI=rvTq`L^RPTbmi@1P4^!+zRI4*5XaARv)O`1a +Q^AMuK7{unybs}h2rqk5|4KI9HJtxtoZ0`sxMTnl{4m8nB=^zg?BZ1LA;D~}{Ci07LxS1(`1g?DhZBN +_cMfO&nt@30LxLaX*@w_Rg!bWk2KdG6VF>R-cpt+15Z;IIKBVg5$$Ity**mpIBfJmceVDEuLi-Tf=h` +{#=4|jGybs}h2=7C9+5PtSklTmcKFqEUk$va|_ApGb4|#pa>qB0j?_A*KY_QUE+U}n04Z8P|Aqnq8cp +t*c9<#rP@IHi>O=W)%v+F}>A42;+&<*?A-C+$`g@pNAM*N;S +2mvhJ^AhpXM+#3EPEOM9wPe^SvEBNy+rmUvM;mi%k26RP`23pu_5m7C7>?>eF^CMoeSKY558pdC8IAH +eaYxcMqe`elF^sh^(C7x*<|DJ9~+PVUb6X;&6jNMW~KZ}^*F@yC7v(we7*aDGY0W|nNwe4`4Y>QSiZ# +aC6+I-e2L{tEO+x#eusJ-;`x%Bmw3LU;U%6g@qC$6Ut;+Z%a>Tb#PTJUFR^@ywFN#@Io|H~xGM#jIF9KPi6C5JCLe97TU4qtM(o15}$)8mlGn$p=*&X-WWyyU-x@g;nKjWK#1p7pIb9-^%P$Bw{;1z+;{Hbb^qGGU;whY +Z_M(&mwGuR+_y-3D!!+lA*1_(ysvZnTC%SPJ5leP7P7fBRiCM|Zz8?}fAi8sKVxs{yXsyK;HBytwSXMECyS!{y5*0} +OvZ3@{8Z`|hKkcJH4UXc(wL9rTJl>wC!tjhZ}LY?l*t-!|?qRV;siVxB7c!20Hxz#X$WKKGB@tcgbiMx8!1!i%~9a$=9p) +qwy!-k22am?l(8?F7$b}k#t37CF~adlDQY#S)u2{`TJ;g%Kv)A|&5%~CYOt!oss^hXtZJ~Tsa5ro>k`n}E~<&|ariwMGCBkgoEmUyz^MVJ2 +AmpjYQU*koZ25Do8Z)dQ#1E>cY0ztbMH?v5E%uh2AmpjYQU)hrv{uFaB9G*0jCC>8gOcc_e)ztG}}E4 +867f;Pz^#g2-Pg}?cE@#Fx5~94=)S@Q_T=iglZ6~nSA%=B?AO?2r5D~2-Q@m%v-uas0N`Lglfc`3QkR +N>g=%)szIn`SDX;+e~nmgk%%lpH3-!pRD)0rLNy50AXI};4MH^t)gV-ZPz^#g(%zeXg1>)a4AP2F4MH +^t)gV-ZPz^#gVmbw<2AmpjYQU)hrv{uF@r_!~MQv*&7I5patbpL_@NGU=!2- +S#<(@Aj;Lt4etti2v-MW_a$8iZ;PszIm*p&Ep05UN3_2B8{+YP9ob1Ki^fR7h$dsez;hk{WFa2r48sk +kmj@14#`eHIURmQX^uioj;r19*1~BQlpIw@r0xXk{U>AAgO_*29g>`Y9OhBqy~~2lSuFU+1UQ;pDzCH +=JMh4<&rT7BP2DD)Id^Gk~00p;8KH24K6ioce@{7C#pRP@dT#^oEmUyz^MVJ2AmpjYQU)hrv{uFaB9G +*0jCC>n%(}EsP;I-6PFrXYH+E+r3RN8Txv`#A*q3+29g>`YFOH`XFs^qd@j|b_Aq1=ml|AZaH+wi#>C +UikZ9DPQG-T}cT{3&VhKPE05$&R&#orupBRI90#O4*4G=Xz)BsTfL=6x%CYBh~nC(uPvG<4s)X#TsUL +rtH(WpVA28|jtYS5@bqXvx{G-}YOL8AtZ8WT_eY5=J5H-Cz=LJVqZP-ng$WgyZDL=6x%K-2(H14IoFH +9*uHQVKu~05xYeYv!b|5Op}cpEG;OK+K;&)BsTfL=6x%K-2(H14PXspof5BPjkNc)0`AyP=i4Y1~nMe +9D)iz4g56l)4)#yKg}Vau+zX!13L}uH0PT?yE37FVhn2@0O#?PfvFT)gkbqX4&h8UH9(xqh3O^0}GzT`_fr%^zH5k +-jP=i4Y1~tgW00%=^JrtR9w##n_dl-Vs+sE0Hbqs1Ss5!9d-V4$SL=6x%K-2(Ha|kE^H2~CHzr8nyvq +B(hfT#hY<|3#V)L>A9K@A2q7t<;HG#A-~od$Lq*l8}ZdCfjIhtopjX^^Kuo(6du30@CFP~oS6p9X#!_-Wv$fu9C`8u)48r@08|ML@x(0huDw^}?z;EYpo=0-&*aXY$iYtoKg~sCL8k$o26UQ>>GUF?IMd) +vgEI}zG&s{-&v$P)EySA!ZyLO5@TS3=25%a?X)Y#FoM~{T!I=hUnmW^I{c!kT)Lh%;H&{IiLB00geE- +g91QmH2bYqaGL7wI&por5{oV;(yV5fnd=3dutuKx8;FMr2C{q{Q=kinn^gBlEKFsQ+x27?+5YHp&6Jq +`9W*wftl?hPk}7}Q`;gFy`jH8+ukp9X#!_-Wv$xtUH8r$L+saT>&F5U07l&&|bIA@VfH(;!cSJPqJ;xvfUAWnlg4dOKSwMn};D@2~=Cas{;fKGFhR=jEOrnyNg&NMjF;7oIq&3hkhvI#NG +{p@So#aSWLG*Ht(O;c(**((rKylHNNx^GJMJnbf+5Ys?R12GN6H21r&Z8s-{P}4w712qlQH20>5N%ZC +=oFzc-#)WL+OoKDcO*SE>ftY3&0g;%0{nPMw;?i6mE-x-`E*~ymE*XPK6j+*vL}E&VDGjDH&+Mzg%~> +I~G_@t~6az5LLp*_{0hR_>8enOFr2&=(Sel1eVoLMyNt1g|qi#+L0j2?%24EV1X&y2PEDf+Uz|sIq!( +t&m6fx-1pi6@;4Z1YDVu-l(Fa#B48kA{Jra_tJA*gKDKvOx--eKlch-o0EftUtj8i;9j0TDszVMr^=G +$_-cOoKAbLs}owiYX1IG|wKBlwwMQDGjDHn9}TmA~MqB5L9ewu%&qjDyB4;(qKx1DGjDHn9^WMgDDNB +G!LuP_VC|%$HPhCvyU*7D8MuT(>w&VuynGwm$afwgDwraH0aWxOM@;Ax-`4oh;aPtpC111<&rU&M0pU +Prg@1h#554oKuiNM4a77M(?CoEG0m&*-f&I`H4W4>P}4w712qlQG%sm|m-u;a9u)1VGrvaS?bQ;iUK&Jtn26P(GX~J|0 +HVxP`VAFt212zrVG`n*IPw~J0i7}>U={zFH(;!cSJWU8H=rmzE1)BzJ8n9`=rU9D1?%$GY!r(`T84{mki!CeBal1EHVl@4d^u4A+rCO8QX+J^b~}KsPtyW`LUkZU(p+fG;!PN$g>626`Ci;l@0S@i4~27!PASjPWqW9_` +_}FV}s!?#p#wuFIDj@Fey)FJrun@iNBC7%yXlF~S&Oj4(zxez$@Kl_giL?SUIVM?kg9r!`Ol +E&Y?>4~8LCIL(Wn8dOuVM@Z3geeJA5~d_fNtlu_C1Fa!l!Pg1&UbHmW+-e)*pjd%vHD4vk}xGz~pxyc7lp730)Gpq~Xi!NdUy8*#?TABdWusWlF%igOG1~VJ^$=;@$c}mC8$YIlb|L+O@f-lIw(O*f|vv`iSIn)6;C*ma3WZN_dm-CgDxOo5YGJ;Y`Argfj_e;yadm$#u!Awu|a>(8Dl97eG@j3V9OpB;-lRlaMDN +PhxG95GNr{LY#y+32~CPixP`Wgggm(lJ*JOM{ysDy{~&yNNeTkZ1Um_K((W?N!`{OXS@=o +iC!M{Gd(X%%1|;3t`R7IqTsB-lx?lXi=09@QR)w8BqB*35XI9B_K*Bt?-jr1SQx>u#;dX!A|mbF2E`i!B2vp3rt`tTGYuB;-lRlaMDNPePuAJgM?@I8_$>B-THP^-n^agg6Ot((Z4~W7xwGROCs>laMD +NPePuAJPCOc@+4M032_qQB*aOGlMpBE_p$Nt^*GF}$diyKAx}b{ggmM8WZHJYPlBJsswcrtf}I3A33k +%?&IJx}T1R?^p{K-laAx}b{gggm(67nSENyw9sCm~N_nUioP;Y`Argfj +_e(zRW_SZgA@NqCd+CgDxOn}jzBZ&JO<`~DJa64)fLNnn$TP0k+on?G4HT@tz^bV=xv&?Vj9dnuNi2 +xSt=B$P=glTaqH!b#|o&?TWuLYIUt30)GpBy>sWlJ2!ovED=|lTaq1OhTE2GKqCfLYIUt30)GpBy>sW +lF%hpm(Kn+mza7O)|&`w64WH9Nl=rZCP7VNag!h>K}>>}1ThI>62v5kNf49ndw)k+Zz8BkP?Ml0K}~| +11T~4(OoEsMF$rQ4tC@r@30)GpBy>slewIWmI1$Pulu0O)P$r>FVj+{zC80|~mxL|}T@tz^bV)2=60o +FuKT9H(oCshNz@!4x$#;bg#6l*aOG1}~E(u){x+HW-=#tPSp-X!9vm|20iBKk?OhTE2G6`i8E0=^WiI +qzNmIN#bSQ4-#U`fD|fF%`{I1cBA0FwYF0Zd}ik}xGD7t;dvvDG5^&rX);Bn36ChzCPgWYwfe&5h0eF2w)PxBo-} ++MN7hzgeeJA5~d_fNi0?poFq6&aFXC8!AW}eJ0iq_6TwP?mBgYY!AXLX1Sbin(Y7F4Rv<}2l7u7)NfM +GIBuVdnmRT$~5uzj(EeS~yk|ZQaNRlc^rwxSZr-dmAQxc{mOi7rMFeSbFMFe8KiCDfQmM@9rO9GJuA_ ++tih$Ik6Ad)~Nfk*<81R@DU5{RVtd;iXY6R~_rAd)~Nfk*<81R@DU5{M)aNg$FyBo&d)_AE$}kR-j|` +*#+cu+LR58E798(uyPrNfMGIBuPk;kR%~VLXw0e2}u%?q<7cSi4`Y8l*IBSAxUESl0YPZNGc+oJs(7p +gd_<`5|Sh&Nl22AB)#AK$$}FhN@DqvkR%~VLXw0e2}u%?BqT{ll8_`JNkWo@Bne4U_B(dOf)j<6pWFb +}FbPf)YnX&22}u%?BqT{ll8_`JNkWo@Bne4UzWI{{Cqk6O@+BcjLXw0e2}u%?BqT{ll8_`JNkWo@Bne +3plB9g|Cksx5D2bIze937q8H0EtNn(weKqP@k0+9qF2}BZzBoJvQx9ilKlJT&n`JRydCoIyS%u(xqP^Mxn!VWpkbh4 +pk~u>lHnx7NrsdB+jaF~#ff1h!%AlPlHnx7NrsaQCmBvMoMbr3-N`{rpQYFJlhLa2@8BQ{sWH`xilHnx7NrsaQCmBxi%$I|n8X8tIt +YlUx8BTIJ$^5drrgZo%GO%P|$-t6Xr({gYn36Fi&wejSZ)1OV_8%Bc+$`dWDH&5TrsQ3;6i$^GhJd0= +Mwg5(xw>@nJz}glG1O$J$xxG_CPPhzn#}SgLrjL43^5sEGQ?zv$qC)t_kJ+D!bygc3?~^*vi7qiX0?gSO4q)yVoPQO@@;UCmBvMoMi7vL>5jmoMbr3aFSWTWF*Pn&ytwsCPtLZLM9_gMv{yq8A);_>0EnLNG +qIVILWMLGLmE@$w-pD>*~#N6C+AyHItDfBT23#UB7)4NGqIVILUC5;UvRJY@RagGSanD3~+t-re}nPl +?*GH)l7zy3?~^*GMr>qGZ{%Tl4K;wNRp8xBS}V*y!*#4BpFFE +l4K;wNRp8x?{@P1Z0`;kWg(N1BqK>il8hu7NivdTB*{pUkt8EYMv{yq8AkqjakL^6nE5Xm5t&o_ +Uv;KVFnauMlVdn1V_lH^L#(cVjDQaH&hWHORuB*{pUkt8EYKIgkPoDw2R`)z^yMQi&lU*8GxPGd-tkt +8EYMv{yq8A);_>Dp6%ILW&=J^$RpkWpC4tY$KtWL7g7NivdTB*{pUktA1=&b7}F*@Tk}C;2?zz2SrqR +x+$))-V}PGMr@AFd0cQl4K;wNRp8xBS}V*j3k-0Oa9hUn)N1T4U<76gGdIE3?dmsGKgdl$<)rK*fOPo +d4FZzT6y0!?fKts4aDF5>*d4Wy<9Q|83mCHA{j(7h-47SAd*2OgGdIE3?dms@@{R<-}N|T6htzJWDv< +9l0hVcNCuG%A{j(7h-47SAd*2OgGk=3?)keOhh&0C29XRR8ALLOWDv<9l0hVcNCuG%BAFFSY`-v!89Fj_Wa!AON%FnlC1%#07&1eltjJiAu_9wd#){0UBV$Cyh>Q{W-OqfO)hEV^j1`$xM@EQ@5E&sdLS +%%<2$5NJWMs(5kdYxHLq>-D?q@#C>JuYGMu?0M86h%4WQ52Fkr5&zL}r%^Eg^UXs7cwi1j0YJHG9F|+$as+PAmc&KcJ5~ViE$z0LdJ!R3mF$ +OE@WKDtS~Ywj0^=C3NjRAD9BKdp&)0?(kwtRBxFd)kdPrELqdjx%;F+LL56}11sMu56l5sKP>`V@XFq +dnR-hOXG9+Y3$dHgBAwxoDagm`QLqUdu3hZsS|M?&PZ=1QY-O00;o@p|(c;fEffE0{{S&1^@sv0001RX>c!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D? +FJow7a%5$6FJftDHE?ooVr6nJaCwzfO>f&c5WV|X4C;#mxZ1dj0^1FGkQF;M*0K%BMv;?2OCy^oMH(c +PK>hW7^jETt1MKQ#4(C12do!MH_xeY}(Zgg$(@8R#|G)D{EAi@?QpbvV-E)q)56$eys#`hm$ +YdQjBlS3HgN4*Jhk)GOKxcJ<;!27xSAeOtQ2J-*HOlf?Gu+rC5h4A%1r~AJ$LgrB1EaMKWHJ<*2TSpYnh1#8D79PLBQ?OvQ3heGmGAv89iKe&5GEO8&+eq!qop-<7^{Mw1JPv~_ +|_)tH(xeve_6y1_SH|!Z1UA5pvX-QHaXm{`)KR^hf&loG(Fg1>=M)kpfT>3s)ew(kB6we;%dz@wQZ25 +SHTsVze^zXpe!WB&f1N`xb?RART4NHz4BSWI9&#XKKHL^ +<=>;$Y@AlP?xmpsWp?EZGaG+)?@?+UroDDrqO47;P?CVxmakFS2j{R}YoZ+k;*}UJSh>S&=rrPtR6jb +})T!x(k+<{`N8SMbxLy10)IkL!kvZ;A2^VdaR7GeHt3)LuwiWd;4iHxcxZz^L9YA$`N_*qtWdCKQ5JS +r&C!|Q&ew?ov@Dm-kJ^cqkrK~ls3xCVe2`;ZO(pixIJO8U8LSRk5Q{dv6Gt5u;g%)hnw_xbB2KCGIwF +7Pk^D^e!hPdkFkwfhfQ>;&bj(^a-OExRjSkJ6iPUEh#iaTU9TCN0*eA;QPFxWv2WJvo?}&=;^DgvjQ* +W|$quJzU7w_;^!1AB-m6mIAm8Zy3E#iIYenxj0*kHa5xmISvR|K?xYnZP-{o2Mjn(uaJn*6O3s6e~1Q +Y-O00;o@p|(bOvR7F%1ONcY2><{y0001RX>c!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D?FJow7a%5$6F +Jow7a%5$6Wn*+MaCwzh+m72d5PjEIOdSNYTU&bp@*+SFMYm}J1VNB)9)it6OG_i0Scw!!%8s$vfA0(_ +`O>|h^@A;OhKDm}W)A)4m$Tm4v!&8!s5j8<{MzVbGMOZQmsWKiwrf?c!OMGeU^IfU&>D+Ss|KNye(gZ +&3M_WUdUgT7MrENwkEO>dL0y_k>6J^8KYz-$YcR`_1nBb?%C)r75u9l;VDf_@49jo9Z!~4FRk|`;x45 +``cS$dP4W-ews^|=a^Yq=`eGiaHoG;SzB>7l_He(W$Q)kVF?A08UA5vD7lhR%9p|++4=P8vm2? +Ql!r6}s&_ZEu+RLdNITsqVA9*g)sCs?IDx#`j?qvz0TMU-ICD34Y)M9jF;t~zNQj_+>g;vve6;HE=8o +IH>>T8d(W*3kh)abi#DIJU?pGED^>c6=KRSA!u*k_u}ooeQ;REK^S#rP0kn%NBDH2oSR@FwHFR?^h%S +G)SU{Qe6!IOMav}Fs)0uq|%P90H!AAP;EMt5gO$@uSNiu#s42 +w-13nL=939}x%23bVL71;KGQdwhiIrrng&Cmcs1Z0;l@1_+oxq?91c4zy1wxQ-KX&}tg3o2+=wxEaeKhDu@vIr{4s-vi^nI8|8V&zQVOb-e#+U*pMjh2;r`cW1U +j51ZeuFgID8>S8o;>kB&ylaimg<7N@KCfKa=#$U{!fFt<@vH@(l|H436omtw!`&SXZ_4O57uoII9ViFABOIljM_C;= +YmDJ&1WvMi1AkGkKc8c82$Er`Pe%Dje;@2$f@Qi7^JuX1$@PDg^iw^DAI~?(UgjrE4gdhyC10jVgVy4wbgKpjI)>2F2_s^Hf$kl+<`Nb3ntlpSYu|V-}C*sHvld2*MA?;KD4I-O +V{>VGy6yX1;|diP04Mr*`@G>s_tL{zde)Q%y&RLmE_&WssOG3Vx%17<{JBme+80001RX>c!Jc4cm4Z*nhkWpQ<7b98 +eraA9L>VP|D?FJow7a%5$6FJow7a%5?9baH88b#!TOZZ2?n?O1JZ8c7oV&abG8bvn4k7#!y|cGi&qV~ +51X7B7l?s|XD<4RkV0lb$Ao{q_4)4=*#!*qCIc^+|^;!}L^FRaZUr)&~dKAF4I3nk~9+)*G!(gKF2e^ +$+v_?LqEDVK0;0x-^7R5$PETKhMJ9QPs=iNcrVXh +rLZQD2FFHwG1xCxk49Coeg)^)W-8lLS-AR9><%A9i8X7W+?iOaOg5~*PDqjw?qZe$op%#KdH8gW5_J$ +T}My?Z(7M=_v_ArDYC-9Dx#{P-&s@0=w5kgbC5`oY-&E0I^OBb83r7MC^kQ +36B*TV6}QkSeqXQ>EXDzLZKeM3UxJ%|2mK=)&U*{de`oo)3-dKRr3-aL&z1msIG{NSi9 +?8J69mDqc0fso}9I&E+pjjw}GrtH9prwz^?z`Jwm#VFM`dDqZtF7++8_>eicnkkUoaAH*2zrE5X(uoX +C=LcUjduMVc2sN4>t^?!wZCk3Ta8YKE^pgZrMqgo+pPDlt8KdLweM~_jS^8uh?R-im{~?%n|KJ869r3 +p!Z^|oqod!$y&)9zJsLaT1l;Tj2}F^D5ScFa@}aMSkv%WAYz+E_DdF!TQoyN*Af7Lc^ptRqQPvS1RSh%FA+vsMo>DLmz6iE}ocF4syAnRud|TnQP_qfuR{BNU}qX#}q%KN)!y?WihXm+~oX06w4-nRPfD!vLE$ +zSxg$Z3Gu76SOR{Py|?MCO_?eztnQ>A=-lI!%^jsAV3gXeP +T^fY>I-P*@;C3n+oHE()1>CG>5xt!}eA<7iabg{~Bh_))K+ai?VnLUgrhScv%6rFxQ9}0h1I9neQNy? +c{C1Tt-1K$SnNEogcUuPn4kt^6pWKZWp%JMlM5vfUx(UmaPqWMB$y~@%`{mGWip?gaOVwq#+DGIoXP}VCtd22}HpkaU(t{a9l$K-UV`HXgM@RGdyfleAl9JM+qp4P(g=@ki85sYl7f3Eij?d>0g}D$0FS$aE&BTv!<1{{; +X)b`vOkPSEXE8-r;>W$*=FFODON|!79-0ZZpzF_UIUhS=jMqS*a!wpC1%eCSdQO*)AEp7K%+i(|8x{b(Vu9(n=m0 +{3vru#JQ+NrS2nuGCLDU1r$me6lRdfsOT<1_1xitt-v5vR(U?8v6*cf>zglBDBB&Rmx|4ei(f~3uvj1 +jxiBC4)m0yPgHHW-<4-0Y~cD>ig~PRD17{B%Hbgh${nfLn9{h!S)q$A^Q30q!>vfNSoUycl?vPM2YVp +IU~eJt$(lZx`}>oJ~**xaKT#+hHZHceMHzHcC>bz4;3=;numTkr`cPrh`}-p@G9`2G$qf;S0_&Xpfv^m_cJW)stTEFSBahY)Gd3$w?24qxpo +;RwYx~QhXprAh0~bIXdi^WzwGbjROnWD0Ota$Sy=l(=BB#OIYr4VgEQ!$=TutOyyIm98o@>W_Fn3RY* +Ja-@DRjp|A}#hS{n@r(v=@ug=Bn9wOgp3k#S6}xoKWeRx{vqq&{{wIYqEjCi)286^I+LY;wK+ +Q(uK4T_b$eV`41x-0T?jn8h+ygOd1Yx}4jlAY*XCBMVr5Kk>9;c&nwaMuy3__zUA!|%Hy>b?{yd-B_) +@fV+w13`GW)qYQrzqWQa%kd!AK8NTfXK@pnw3~0Uk4VCA!;??b2acd%Gk@nC>|U<+`$5<&nBvBTeNH@ +XIV6ggu*PiHSk#o>ling?LzQQ%|n{Zd?TmOZN<(`%ub^H2*;eOxz4Q%PmG)GaZ20vL}pzzdv?;u>h|& +vwSk4*ec(e|OUVtp8@sGI>aj*|d&1hI@7XnS?Ex)rz%ZE|c0aBiSL7_rj*_;W2u-4+AR0;?8X_*WQR+ +RT@^|-y4iE7?6baf;0BYVAty9UM4OCR{qLdz>RRH1`eI<;`=*ZABxnl|Fpq+}^EWW>3Gq6haZKHm^9z +SgP{=NLE5YNUjO0Lk~>nE9s{PYAlGan;9w6q2KWs7~~Q^CHgZVGw2PsjxGhxT&@b80l-0p`Tez8{z$o +#KB0%pcl62j)Tfe-+HN^3%awEB|F+j_yL9Et)fLdme*x>KCU~?-g~O_s!0;jk@%$`(r_uypP`_<{r +PI-!tUG&#{^CheGc4GHy9vhEhhvgV7q~PIzQprnQy=O=7*`*%OB_s9!66bkNSh@VgSAIWB( +ge_||K6SZ)v=6@TG^1<;os0@pB+|L`DS^uFCjg1gK}1#ZAm7;wqQp};J5B)H)e`UPJxkRd9NK9~|v@} +Hv7E(`GhmrJ4PRfSR|FBW+wRcdz?GJ_th;{>sI6;l=~jOnV4fkwXxo!i?#38K{9fo>4M-1=&mqek_LU +Y1H<3ZwWsqC^|I`H3t56Q+K`j0Z1@Z{Y@rq5&ge7MqO}wNyM3E8uIzRBUzg6(VTqn>S*12eFL6Wdam> +T&M7)gaIbJ-=w1Wt@OAbTT>)F%E!_+sJ411;=}X_#;A!ZJfJ{D>CB>az+DO+a~Fk1U>ZVe)0-1d?N21Ag6PC_bVz*7Wn9NcDH4SEud;Qn6dn+oS_YD66qKMDu>!d?wjCPgFICaxJYm}q(1#1M9T +DyIt$hakw!lXT7*Ep@O`xW`uMbj?(`YHcjxo&boqQoz9coBQUy~az744hJ)pD{6DB6+1TY!Q`(G)d+Z +&BX%V$e}I9g5zivbolg6v^Lx7k@U$RH)dPd+mopbjy;k#;+=62(X6MGGc{WrrUCRtQ)|rdDVM?P +3m0XiR*>RtY3pBIDSgY0CfN8z6J}4Q5=~3gzkp`FMmWt%VYQ<^(SF47`z|ZXVIr4Xoz4lJ_%~@@`uAy +p9qb=M+`}8nH&~)_U@6)p$YV#0L#ZxEpnM#4RJvl|o$NZYvfy;TcY>VzR6elF}OYB1(l{y}q?Gqke-m +E%i2?4r&sUj>m6G3xQ&E9-oLAzL;7Q?g4~2^-sa*hOAB84TA|+g}$iA50a +YcT#^QOu0$|IeE63tvCAJI#cX#wj+hx%O94L13zjv&zt7bj&tipkpH%usDei!3mqpAauChdG~(MZM3L +jDyKS9F-tc)+gmuRqTBe(FNwTe=sPcFqLLfqRQzE4OyVi7^0iQAv(J&S-s@iUwzaLEBr4|O9KQH000080Pmr;M)(=%g +Ifat0B#2W05$*s0B~t=FJE?LZe(wAFLGsZb!BsOb1!gVV{2h&WpgiMXkl_>WppoNXkl`5Wpr?IZ(?O~ +E^v9BRPS#ZIS~EMUolcX1azIWc@q9cGm +QNr3|i7?T9ea(o4AA@e?bvWlN?Ye+C-<6ZS3>TZU<~DYeXmmqt4r?bg`c0l+jfc5lxt3(q;F)eiA(Dq +#cGwnD14r+U9ZH|=%@5NF*Z>MBL^;Ol74j_niY`%3yodn?lt_0?VDBP>J@!hWZjR4Xet)FLqS=pYazRWh~0RzcmuGLtife+Khgs!U0l&}2E6Zl51Yc@jGR-B`qLOfHKmm`a_a +-cXijyKzU6?MzILIn +9>y*)$$RXfE?n;vnWZkzXV(0J$+x5Trn^8n^|y(s$f72F=)g(n?+Pu55k8a!pohvB+oYaxKDa(~5!=4$blR=XAMFm&GKS^S +M}x`TJD1N@tyWkJO%xgy#wx?Kdo;||4hGP!)iNaq +FG*l)?BW=V3+@)~m3B62%^7_ulN?)>qN``TtYDFE7^A^lo|<^j}a*0|XQR000O8@1eFvz}XNq-~#{v4 +haANI{*LxaA|NaUv_0~WN&gWa%FLKWpi|MFK}UFYhh<)b1!3PVRB?;bT4CXWNB_^b97;JWo=<&XlZU` +E^v93RojjlIS_s4D@x*FU_;m;(Mp>c8=JVZX4NVSoZ7pxVyPzhDox1qU&;e>Qt2 +}m#-gcbsl;{>i626;j}}o{;2(hUWqN2$~4|G?b3{#r!w2Xw8Mmv1kt+Ck$fN5-OZjUSr&oQkI8RE;Ugbi5R1FqV5sW4H+uB@|Yy)K&+9mR1rS#M>n@2u?o@$Qs{;~X4bDtaIQ2 +asWaFOw8swsqR>6Yh*nHH$H`9BfPh%~+M9hI&1cjcF6e7>GHDKHi+jXEX?W4U97(2IB>{}8tkC`d;s6 ++QChgD2XtsL&-fR)rcYCv8XF8?sXhKaIHz%`Rd){wOXgr^cN7GK7Xv%z)IEZ;om^R{x(dLLHCW-`BWPA8uJyb@ovwD$o7WAHELfZHm?XAS@VESHk7bxfc)-d!@y+(gE5G3?>g +%(Va-jxZUyUG|_qn2?#gbtd>y?xhc+`etRziklBr?9+ss5AWZn~zAjR7$K#sUBg8JsRag=fe8%)C=oR +-gFy=B6sbr*e;EYOQlkzgbR;CEcF@*o(Ce@NX>U8Y$bY-&~hoU+{(rWGtCz$HXbbwb!(MR~ +6d)hl|S^L((^Vm3q+`bag-U!>r=)H)rcsqQhS~~H`4Z-)4NCB1=0;ocQQ>x~F{L%$yQA~6JQO-t>Q9d +>s>3gO%hdsjE7(}`V#H3)o!XqTD^I3Q;#0%w2mXrY~)@#4HNE}RlDp&=wR+UAw(dMHx-vxu9f-6HNCnb!XMDh;}12R&zqy#)nClmkI-k@DE7?k@fUmX<|8#u +A(s8l>TB1XCmDJyqujF$5@Xh$uf$cDqD{|$vhB~AF4KJfe~wmEt3`@BOaB2-O9KQH000080Pmr;Mj-p +$IZ*-t0EGkq051Rl0B~t=FJE?LZe(wAFLGsZb!BsOb1!gVV{2h&WpgiMXkl_>WppoNZ*6d4bS`jtl~Y +Y`+CUJ!`&T@P3rG%yM7@;uV5mu~5tUvqGcwydZTfcbg)KlN6x&T9Y_4&GMjHpGv2I +e9UkLld-mkDN&i71EyQ3DQBR;*&Ov-|0e@ZD-o6f(%?maAbBCx;$R)mm4g|TK3(OA|q<7_gO7-1}|hz +$`XV{)7flA1+w;tn|DHzvk=TR(+elHnt&wxySEQyEL(6p9A92LGy2d5ec?L&2D<5h0~Xz)7Od`q9KKt +EYo-OHI?`6U;j}6yYr=bla()N9i(563kaI0<42Ljb@ug5M#ZG*Q+EP0twNj#9cApEAnfJOQzguu4F+@$l +9J#-*S5`3#_--@?HVIokItZ8F|8bvsp2wZ)*2T8g<4f8749|1(ELExT +75zIOBVIM$G-SfkGY<~Fq0b+m_d({mpn*rVrMEFz>&W`x+kp8CD!D+SdFEy9i!c!Jc4cm4Z*n +hkWpQ<7b98eraA9L>VP|D?FJow7a%5$6FJo_Rb97;DbaO6nd6iVbZsITyz4H|#acL#W0;?W&(H>G7+G +ru5B&gz4nPdQ~#zwYjmHqmC4$vM-rQJx8;_;g|Gw<1Hw=X|*7e6E^O_EWZ<}uw(W~1Nq1-9L4Q?X^5S +-Fu~C>oiHNjjREKT;_{3oT#SI_#8NVI6y_*mLQPr4rC?>&%d7=_O$I{L0Gg*^*h4zd#Lq%HEY?&j{^y +2Q5qCrO^&cyEnF3fSBgS9^<8D;klw!-7tPGC2Zi@*C@61bTzuBL9f>b#YK3RBBdw`SVtK2-<7-mi3rhD*cX~hwXt$XH-rv7c|-HsZ;fsc`L@O@lnMLhecnc)lR%JE$(0qh4(hHgGdZ*NZ|H +nTwK-5JG+C~sJJyF%o`kNx8H@a#spPs2p@Xh4Zy3w7-MO>K59xv?>@W&Fux5+$^TSHX63G);vUW_u(L +Ti7_Cv~XXe2*1LSqB^M*bnO#D1t9>_>zK-Tt}SiLrxO=}P#}KkVLz#A`HNlY(9LoEfaVpuxwe6-nLjZ +s86-z=%oTaQrs16u_rKhBLoGl89(j`4bSr(WCq)|PIgMu-MKq7HA{i|vQAYDcHlO8j7w$5jH4bWCQu$ruH7IumQsR~fsoZJyB@A}xP*t= +QuMDG0#=WXY;Ee3+|8h|oy=ewU%7>yul55h&cj(PZoE{v|PyT}C!{H9@McM7pZ66?^UlcsZkv^7dP>+ +={wnKNu`2d|p$n6dK{oYOgd#_Kl$PxMKp*X$&$KOx8)q1XYb=c4^>a|*Y-~3#pKCZcGH}P2XTbvp{Wq +b~R%e}Dvh>5L*=nW$A?u^JEXIU{?6wk$D7Gp8F59scX+ty!DO9KQH000080Pmr;Mym!U#!LeM0QLp|0 +5kvq0B~t=FJE?LZe(wAFLGsZb!BsOb1!gVV{2h&WpgiMXkl_>WppoNa5*$NaB^>AWpXZXd6iV#ZreBz +efL)k>K6xa)VR9~Y#Q`IR_xS>Z;)&hc`|5eWD})GgQOCuU%y9|FKOZcTRus1IXrV_IPLc3L;b>W^p9BYhCtZnbH#Wtv&JkyG}__U?u_040GQ^+HuluA@SM@Q+9STdO4u4}SK+Fyr%rT5z1!P=0dX-rpin7_>sUuIJG +Rf9HI+n0dn?zaH@4%hzQRH@5%wp|rP^3o&^3XfCvRw8`K{51`XP;yYb$J3tCU-2awhjLAa+NUDJd12E +N9X+@DRe2(Aj5Wkzbfh=2dMfb%t_k)}C$Qjv78pmo#Pvru4v?EvlK9Yb8@8k7df*F$qVz+UB-rrG_<; +Ih%+M>ltM;uT0&q|gm}%nU9{aIQ2XsrRs3Xpav7qR<<8Zooxq#(9idA=0hXd`ye>o}~6n8qYBWFsHezXZnyZSVoWW{VPX^byPX5q7yymiWB_&_V3$dGQqY|tyU{ +l!nwxS@atTrjb(vdfyu~ewUSslt5wIb$`AJXTuuyr4?jiMf5ECaR6C(>7YgsZCVNiBhMg@2UmMo-YZT +;4EIxFgo<`_#{TO$#q4s0+n`DPUUh^xk=3xF1n&)g;``|6jck=#1pTB)9edkS~7HinUcoK2Les!3dl@ +c!Jc4cm4Z*nhkWpQ<7b +98eraA9L>VP|D?FJow7a%5$6FJ*IMaB^>AWpXZXd6iaOZ|XP@edkw<)EAIw7J9YPZM%J-6k4_r5TUy2 +u2#q-6R>V#N49A%`|Ed{F9?KgnZ{|sla7mW*8Y!If3ueo3 +m^ksm+HN^5?9!1QNY7IWwoJIj132rzcAMgz$nVNiG??h1xcc2$VFt=C@bJVEbFvv3LOJNjWZH-h--MS$Qz=WxvFy +ql$@fa?FA~awm%ywoYMV>!N6Y-T|YG+jn6(VREns*B97ItzAJ`pI&YHF&p +mc21234#J4IkYX7^9|0;SmKY%4W7*McgOnG51ku1g0UeHoe&^HMD_vc_1*9M4zgA3&`o*-u;G3lLfAv +ZgE@A*aoSf$&8Jks+m~F76rY7h^nCqPp4LbeWn3$kB8uLdUUjan`tGsi&skw_mYsb;BYVVh>FQ3{tCK2+@hQX=dy`-NUKA4d}2R07WCuf*S+bRV_0;bM!8sxgB*%r~?Vs45F}4p +O9bRMB4QnN~DH(L4(B1pa^qecHMGtl`PamDH)FR%EF3#ds{6LbFxk4BHWn6d?~#_$MSJRy{#gw +*0P+bA4UfG17Pj)#>c-4-td();6&F?cv>NRc$$~y~;#?C|sNds3A%&fxpZ$U3JZ3Yc>5=t1gBL!`*(5J2+5Es&nxicmI% +4d26x9-F|ro-CE$jw@U0EchISi;DC9beHpqd&7?jW`y5V!ZTC#5Q*|)}lQZ=?A6fb#ADNH5P6x +e|I~z{>k_ElYzhuppodH4r!jkW`)aO#J-42I<{{T=+0|XQR000O8@1eFv)=2%#$pruapB?}JE&u=kaA +|NaUv_0~WN&gWa%FLKWpi|MFK}UFYhh<)b1!3PVRB?;bT4IdV{>gTaCz;RZExa65Xay1DMptUmq?gmo +5zd#f^d+KBLo4_DfgyY>~*lt*mP}jqE)|pXZ!$|3sA;6TL0K>vY +^LQ5K27ZVi)gn;w2Mi3uKqcdrk|L5eOjmKlms1Hvu@)$sFC)8IMy55s==b!;*7(o=ka23r0KV3g=jpt64P%GLcM@b1`;6 +&dru}fG5OR$6wO4@FigvX7DK=}4gfkJ*B*simpp`~x*awzLas(G00;q~AF`ZB~!;ad7q;cAA|x&eldclQ#ci*}m(S*j36z$oe2Y-z+I1PabYMET=sE(pB9q*vhKX{d}W +v0JcNsSU0lhn?Zx;~y9h7y1ovBbZ89hSFJjMT~&H@VPg+xqp~IYw!r4Tcc5HFnPR0U)*W5;`t?!-1)+ +DF)*%52|rq4;uzqrGiu);(YosOdy_}XzT2A&I^!{P??=#rVQVz$wIBMe5ey$j!~1ck1TdB|+hW>GZj; +wr>|n@wfIDf+NVr~@Ed3FWH^c-z8)o8J;xSv ZFmdIjt(iwVz{}itmk)QW2^;Itl-)het3*yz4p`y6XjjD#BF|M&x?eLbhz^dRf!WvJUVt#*uw5=nOs{*+k9?1 +xE#QC|Ov<5gt@XCr9NY$B|H&kL)N#smNXw-pNAY=F2aZ7sAhQUeJr>+#3LsEMxtZ>xD9BYmm)hZ8~v! +#_4$*aXQZ##2Ng225|<@nZ%hqXA)=fT!pv_&sB)4@LZL+D$iAktMXipxEjyZh^z5jow$0&Rq(f3G%_1 +;bqCKc|0Y|5xJI3~5!c|kCUH%kYZBMwIYFG@IYFG@xhZi|o|_Uk#c +X#-2mWTG=-&>vt!`S`(2S{3LF-awRB`#fI;r~16Q`D|p2?fObH +Ox<|*N1@Og-y3DaXb;xC-}s?=zxfaK{>uNL_wU%!-ftB1@9o~t+S1<7*|Ofx+S1<7*|Ofx+S1<7*|Of +x+S1<7*|Ofx+S1<7*|Ofx+S1<7*|Ofx+S1<7*|Ofx+BUs^QfNjgFVceHFjQQMt3_vx^fy}lcVwd^P@jJ51!5nP{trL19J+rFoc*20_| +-VR@r!$d-kl0&_Gf*!_IaFQP8*LbWR-VV3)@YCo&f3`EXY@27h%8Qua=h?2Bv%Njrz3JhPr-xXSr|aR +r|MlKMJxcZP!2E|q?x<(G!(Y$Edbqu(M|?}S_I*tQlD2u22JC)ycSr)_gFi_E^2<6_0zQpM0`S)J#8= +t)0DkbRDEtXfO9KQH000080Pmr;My!0iMGFN00A3CN05kvq0B~t=FJE?LZe(wAFLGsZb!BsOb1!gVV{ +2h&WpgiMXkl_>WppoPbz^F9aB^>AWpXZXd8JluZ`w!@{?4x$H6Lnp)Ca99T@&RbLP$dk1o5IO>P2X=$ +FNs>7wxW-xWE2p{lbfF+Vr}gU|yb?d1iLjXJ_>XuKFJbV;By4{qd|1SHrvBXE%n{TPk**cM3?MX}%>Gh7Nyf7Mp1^bY~UM5;{ +gDP#tHSS2Z9H55}8YnxE0jRB|EgwBT#e-T8jxeMJegsHXFFhz~(5&f)^o)kv$Rcxekbn~1f03)Wp!Gw +ov#UpqFl%WA5VUn1Q6nXtbO~_Y@sl>7rC`8aQFi(`&1tc;Cj|oudbDhBx5eAs>|CEaSBkA)Xv7%V`RF +2Kspo(9jkZ-(Qd|F-=fZs+n2MDAN=!1hX4WJNCIlf6@Cixjs;IX=5dt7wP@G^@MpovbL)NpH0b->d-nm +GMtS@wE4nDqv3^2>r9vx;?&nii--0OO<4fTC8zbZTsj)VAeY-y@8}+z@2u@VcNyihjNr0{A?GmJife_ +N@6@Er)4Vw~!S{R}IG1QF`zcz_hJ-spGQrE(II#UmHq|(5G|PM>mx4uD4yn+@O28{B;?1YYtG#1@=%> +alU{~>>3mek@x`YsglWKMfyH~hflXO?t=(Jm@>4B#`^d8>7`+S~)+6~KS$dD==x%Ym+Lz@`qGMgD +vR3)6U54j-b4K^C_RwaJYhaS*Ewj$swCZ-n5I30512J*~Pw6QXMD0^C^s$KCa?*)hKOGqFrt15mauv> +ry7&N;8_Z&Xw~AyoP+CZ0ONJn;g&slrs04)HJvbe>vDc;&s(H=dYmifQ+#;Bdpl3=xgTNkrcxpayl@2 +gjKpu$4wuCf%*N&BvYmu*|s8^N3wGr +Vp#|Ic+RzYXPrOOMMwozl}n8uM&=!QuTXRbDD*=bC@p9QxLd#z}xY^@u$?MH;O=YP0blP)h>@6aWAK2 +mtS)wni%CE|ITO005e^001%o003}la4%nWWo~3|axZdaadl;LbaO9oVPk7yXJvCQV`yP=WMy=z_({)Z}#NIn%#oH5c@_z4o|MCAGfAgdN^7&65KmPoOKl;hffAsj9AOG}+|LyU=`0V%Ieedy$-@b +qR^wWob`tZ${Uq62M@z?JkAHIG3{m1|N!`EMbdH?*o-~Hj64_|%x-N#RlufG29{+sU}U)`Vi{<}XX{r +sB`-+j1K{_XpJe*g8y-@pI#`1qU0cmF}2_ve4|{=09#`ttYh|6kdD`1sAY_m7``|MAoOaA*AZ*~d?>- ++%S#{g>ap|MlZnf1Diu{iVMAB(LB9@xIh=zkB?}5C8IUJ)h^!;y?WO_a8s_`s>FRKKt$Ci}&BY|MbuA +fBkxrAAbDiyH6i}^@sa0|Ki)f{NL{1JRX1l<){Dg_}PcA|LN0*-#z~7ao^#0kMBM{e)h-je*5v8KRy3 +lR9}Di)u%5%{ZXm?=F|K4k8eNz=DUBnZ|tuhfBg7|$5&r|^Z4}s*B`!pWq%jMcaJZ>`SpML_~}mnyN| +#A@S8vS)gQk3_5C>R`n&g^e)sL4%kaPa;eOw>|M~r=Z|~nc*7vVJU+qshe)hQQ`Y*ox&i&uD` +Fjcf^1kUmKEA$d0>(iIteD}xu&hHHV{zqT +@@W0+Ee(*P+|M>G?{Da&7yU%~|lOO&3=a0Yp=@*Y5Jbw0rFMjd)4}baNAAIrn*)PBN*-wA|qwhZ+KY# +!J&tFRs7((+_`n|GxM4m+Zc{Z})z{f1mc7`$O*MPPlfy{nh>7e>wTBe*U@j{P +Fj9FZlI;bm7OlcR%{&5C7X2|M-i4_}S+_{K1d^@ozu>`7gfs{BM5wi_d@hlYji;2lxNGGpp~v{p;s`@ +HapH(LetD^Z(;V_wVluF6H&Z-+uW?)Z7vCfBp2+bTVK5>g)H9&mON--v7nNe|z^oKmOwJf4+M>uKn5l +e{c88di(6!&-&~U=lbmG>v_N2zkBR;K6}*L^Rvggmfu~UJ^HQh&%NF6uIGGiefD^q{_NeIL;G2-Z*hm +`uFtOPx_`Icwm0JbueuZ0N&j_coo~k*>7~3(2FJ~u$#5><<-X1P<-YtC_e;5vEy-Kn8SawJzHemmk8@ +}JSd(JA(qs^yy?Z?4zLa~vf6n_eaew;x=DvD<=N|U`yYBlTR!pwP)7~Yp6;~gH^tz+xo#A!eKR@rMf1 +La6J8L(0?hiiNGb)D5H9O=V3O5vF_=vQ}E!33CU6AkY(sj`YFOyFGRj%woC&RhCba&OO>oqxT4H=mP3%AwqKx$C;qp8Ip}9(!)Ce7fep?b9P4p*!_>Kl~j +c6AmKT%bMptLaC?v?`%~6{b2Wfou?En*CVj6SB7`#?$<9vBzWXIi0=%aE)r_~{&Y^E36a`z753{*fvd +c}-rRamhWCv;h2Xj7Zlrs@`Lquz&D0Fq-Sl&LV}4W?Pbr>m;VJ8<3}af@b3XIb^tR`Iy05vp`_tE5d- +s1SG>dC%NA4lDdwzyp_~>o0mHd@7L`=!;9N|y;EM=%TZfT|MishJl?yjwT>VY(&bN4$B+1$@PebIbm +-cZav%~mbHE%%@cTG!<2=Crk=^Eul^wvTN2YctdLO@Um}zSVs0zFbYE92NXjy7?*~7uCnaM1n3ME#U{ci)2`Sb{ +}^I9ldI%pJY#zANPs1_-fvcQ(tFJe~&krhSACBRp8#b#yd?$(aHaX<2esj9!cylGcQpLxnXOb#`_OCd6Ect-u<(H|=H>*)W^o%OrB +r_%8}Cpe|^p!qfrpnwGIy5@}#Ub5+V!!0dcT2G~D{cFO;Xu0N6^UlP1&yTJ=y`=_y#K7HC3K6+Z8J@Y +E{O7@r9{XBTnI7dR@o7V%=qSF27O?d(I-f_yydm(ET&3nH&c){ahR)&f&?UU`ni0-D2%u$zd%jI?=?< +rl^u{!ytzVcPTmNy-I%Ig)?_DWc#SDrM!E)8~I}_|4MI4ssd+OI#Pd4*%-~V+@zdS!47nxett(IJ;K| +ckHImP|lnyfmSYKF=SpwrEBWe!(Vf`$DX!4WvG3hx +w-q1pO;#GY9ygg)AinUW=Iz7Prb%d-@1Bw7P)H16VnFzyO7L={CJ(2E@*l)Z+fcwr@Ss5;9JcwXN*^^ +Z*MaJnF|X%-JHU`L)HDiuH-iFDszYWCe7t(2&m(2v8nIA|4W0O8(#Ag?#t&~)70QDS1rSs``oWFMQfc +dPMf(j7v0`HF)}JiH?zqw?mwrf*2I|p9nHH+MVo(`a9+mv%XoVkeD2P4f-&@58pLznog5_AAf7ROo% +%a^ovGC`RJC-Mo-wcauwvF8p1REE%nzRi{-^%&sZ)IB1gxr_>M=izd8oNa&dgy_D0)%!H0-?T;oeFuu +QhM0E>HIMHUo<`Grg>47J7*1Oc$RMPhwN9mp<~TAa#OwT2qlVUC@Mx4)&=nKWl!}zI8O)1Z}Me=b5=H +Yfti2*3&cARMgy|`ShLZbToP?pNZ#GtMO^ir`^{?T1=-dio6^8I!|)HSQ(hk-7QCFB!{ILq_BL2R!=R +vFAq9NR!pUsf6nxMW}Tk)n%JBUwuHl*G4j$&U6QP6?~}ybAZvOJm#bM8%?;1ZsawOzv!_3IhnGpjnib +xjS-Ny@Gf`C)&-t_>oyVJYq?fIUC*9+WDbFdxnPWfA9G^OiHPP(>;`Lv0cug+vD_x%Z%;Z}O&TATgDi +c)Kw5@sMGwpF6VET@UKE*ChuGbyv>7Qnb&!^5brqCqQf@i5T^N;6qn%;9(3R5W)Uxp@CareynIsLhMn +}=F+rB`gauyNp_GuV2@rKLQKa1UMR{mA-!^O3ctm-V|d{itqeqQjNe^zrw|v0fdeA>hp9ds&U9ZeyFt +Szugm0_Zw3^i4(0-Av$_(oa?2*{o?%+V{iYxipgdb +Nu99$?Q9;6`e4u$Z5S*)tI~ub)2hIh~d(?a9W4r^;fU^Od1=ORnJoytDLpmxj8Y^E<6)Vn-0yjE>XDd +j^e3JDs4g8J@YUSoM^TsV-4_$CF~86{@}>G|_9!WY!kr1j4e~GtJcB9X@6y^)|B?5qiy3!7zF~XSF-M +`1CfDPFYW(P4&n0{_|hn)l%+P#hEHecl>bq=V;S4zcVY`^Iv*YFV|~5FaJDkzT?&9cw^k7re~Dl+{k1o1}=-{*VwkEV<{QxU}qT<69oE`>7uXK@>3^2aX#@o> +zSi&pKjsl7M@dPCedL`iTgg+HS1+P@ulQ+C6|%?enXMwJg91&b&!a>^cB}w%Osmwd9L9;Ek(5g$@|63 +bgt*VW`ZF4?l<&6&-t(RGMAIJzV5nP;<~0SYZ~{9ye^-Y;utw%4@${U+-fXO48!Pph6>Gb@ +~T^>q`LJ)@AOC#|K}U4}LHFx|#{dY)&lH!Z~&yytTB;%>HgXWI07Wc}f+k4@Saz+I**_lpd*{D;nN_b +iS)qe1slJOlYGf+4S*HX;?xT-k%w9Rw9FD+o&9-c(M=0P7Z!7)?k+LNJ~o$2F#n|BnIKJ1!;)O}s^c&{6t-^oz_bj{Vv +g{RB8AMwu6kfV!R#({NBZ(|x;uitsbxuupv%b}+X=f4!v7}*TBW?%O&4ax4XCzfXNs-aGAU{ScPnUU} +LQPyXi%Y95_nS$+!%`mWZJ;%v)Uo#e!UeJpB{?Q +ohHnrAAOl8g#OfRJb?vYTJHj6atpq}}N8S9>fkKz7q22&|&d8Xh!SDpoc;ZX;EO))$th*iJ@Ud_$jPq +)m-%=6yeuUd+l0lyD()MW=?t=Ei9A2Xx2nY;F}*zjUlYnFpGizp+sxws5nKo_*eO$Tp`Ga(yTw4m4`U +JD5=P_wN3uXw#HYrT>M<(;99$NFqpPA&7|H8V7${hAR+Cx0g<&U=28SV-v7mVRMrlS`w!Gu#r->}U#O +l9-CTie>grgxeO3OTRFypV`P^un%;xOd!t8R$X3~U?^W}Is&~E9K457A6D}^p9clIo8$C +KlWg{+X4L3unG@4$;hNcndG{1w2-UgfETYC+Uv16WXx8Hv1=`3xNcG%^NPC%sd23AdnB~la>OZzoY3V +g|<;!eht+`<>)+WULqUkMz!^4!=`1g3l#7sbDL1_q>-g4!vpJv@SK+BD_O+`(2Jawdpd(5;?Ct|#K=%*jAP^zgE^QIoaorj+=)#>gb8-w67i#ih>Gl7b^NXyWJPNPu%{ +aVorjBB<(VtRw&UP*c^M-qb+q`VhtTF;9T=E3AO?c1!=B=OzDj9?kB)(Z!9rfU{aau`F2sp^623EEdS +uBmfy|7$vjjA_fJQQ%>%xtlX@tEg#u!^zXa%%?0Km*v5lDtoM1UeEGS1{xhp|zZ?)O^b{3a@o#FS@o;nhcRWg=2GF>1-ui>tH<*U6~@w83u`3H7T&!8_jvov<=v(bf1sp+j +TzpHK8%jf)_9C_hzrZ2wO_jvD&fBReTO<&UCGik?iU}_!5SIw&nOVR?4Ci&9OaR-kE`an*4xCuH1gT; +neOtjC&T%)vYBBzCV!8jf+wCzAFyBB;5xi?C6n(h;*IVQV?Hx?JPlQkgaf9Llf*SUr+a=JVjRty%|l3 +Hw*8oHx{P}FFXtWp*aO=?b+~H)XAGIa2Xv)%QEp2|yG{Cm2qZ1-te>gjlIPQMYkY-LaFsEmkk!m +J!`?aejXlKf831_Z(-6NArn>mV3q%C~*JW +5S7p0+R$WH6XqmE4SxduC*_v>bt)E`f>1tU<=fUzK7&n$rjIy1aL;k;M6NUfioaoOsTE&GObo3@0}H) +}EE-%wUbT57>DJrzg`h?rEMTIJ;+XGZmR|ehzcqw}h9jw`r5Q$Jz1Tv$>$9tXE5!(o`6;1O5uZX%J^} +a7z>CbL-0RIb|Vsa(a?8ZJB#){o$VN?Rk``89k6lSbNIiwGJ9*o)qp&|Kt?Ma@yd|RV_~kVi$hdQCzm +3)-1WW#KVDzW%GLtecJ!Ki)Ly*JmVzuqXJ3C5|&NjHQP*Umh0CHC#IP-qpCNqdF1jUPG)v`P4y4V%s! +YUC``K$(KRPtj0=~}=pshf;JhAb*$%#Po@8!G<;{+(iRnG`$p1NKMaBzN=}cUckVD; +pPn<<(w}m*Hsz@>+A6W7{ZPwg=bCI%j`K%uV-b-hIv7e>SF>{zA!!@X)=haHV`yVVbHR+Tr;<^I9=A3kHLsP?O@EZ!ZK{8U^Q1CKQcR=_F((tF|!bBtZQh`WMf +&{Tsh@j^P?&8jGF^4F^MN=-G{-srdE4udA8!^wdc^7yP5xTu;?1{pIvwZIyVOQ!~3A9iNRA(>?$yU^q{;$<{jubMa5DHV#;DZJe6Q+He{N!Ows{9hlMQ#oI+bO^C@HLoGh3*N{;bfvuQIYg606#M7%q +EJm-#Qqx<;uB$*t_OM96&WWgy9dSHJJLG_%Ae4EwiY*xkScuiFo9dPdJv0oXA&^_A+bBb$*T2qmnyEaDJhgl?Xjn3HtxaJs@1^yb==10qjaA!C(p_v +-aR>#Z_4fJ~gZ|?9+-ReI^eqzp@Og5rn_D0`kZ#w6AjNxUDF+OH#<3@~;xcUL9A7`*&j)|<9OisI<&# +7ud%ycXUVr5*P0`EF$Y+4m +aTwQG^{zRHDxi1Hz$TCnO>az-(~omx91skrgO^1tjY<%HT|L4%4Iuk%|@rQdCQvQE~A+-%?8$-RhFUC +YmXU5%lyzHVcE!AHZ#^lyp_~L5U-imIQP69g}Ixp=T=cBuglilouN((NUk{s0mRlcy+54~oHI*;Y8+d +fXfA7x;^u7E#r)_>bISB>uBQ)kym{61nX{mI&XDPYit0IcxF*IX#r!yHVRxil9dy0#Pz$zWxoU1?&2q +%ls-}^<;VHD)6__5|qTtM#32kc*2b9f8JCyhAYYyo?C&PK$1L*c@K*z99v)lRFIvbsnI45h*q*JWde~ +G~F{b?6H>)rQ$^v~}<{qeis`eTA$z5n{-zxYFwkNz;?@!^~A-hX=k?RWDh8oz%3-TSZR2>tK>@agv-z +kPo{r%uGoa5=BAYRXlI(^5TsAn*9dHq}J@g*970wOx+2 +y+}}&8%inWQLTU#G=8mkY(3onT4-e2+qm)<#70N_I5cmwE7jLlH|NdCnk*2%Q3k%y +Uq55)@%S^v^5h4!}6V>IrX&aIqW`1Ei9kbOlTb8T_$^L+NpEx%bvs%C4CfQ{iQQW^usfr1x?x!nWY~aimIkdH$s#$aR!|vcRe_GC$-WduE$AXsQH*5A6sq>mK%1PtpJn?c4Yu +PDZ_MjHxU6^1w4!9WNn!kUz^7TRK1cqaOYmWcsBo-ZW@;4_NA)-TF)1f*dx@?)RnL|7Id*7kJnB5$cs +-@ptPO4njxWGKO5OIucIgqfp_?iXqv}y2Vi-Q}e2a-?=SCApj)TytK?Okp`RyBwNb&dV;x +WtW4S%lW)z>AhyAK4@l`<*e#**m5}{vmAn14u7m!gj;Xl8Hx$ +3nB^?ca<*c@#zixhY1lF=Sca_SMCWpxVA%yM+87vv#r0v|-cJ6CC_O%`R+Kzo~C%(25U)vd +_ZI^o6`Q2}m&6Z+Iv8C8j+#zvixFy+=gd`zJND`8SBq2#i5-t)_gcLb#-n%K86DQm9>B?b`^yzt?*Jt +GL`kfq74&|C9ak*x>W=T;}+;MSdI3vjCY=>&LLp9r>jypqf;>gT)WMfI=B+vVM0ciRWq4ufnn?(G=Jwp+CA;BH4B?hM6*(;wS9XwT`7J&z|QY+7&o)!Y +8!wn4JV_qMd(7HZo%dULWp+l`xW?H3!&eTfMtHm*J8B`_@EwqqI_=Wd#@Ex@+J6B~eR#{%}8me`h{+d ++xVRyIr9_P)3C5Zif(Z8^Jb^=&(1+gXPVRX2CvHmJAF=k1uoouNp;W7{!@4WPGOneCXvcFbYhJlc*qY +{wk7!wuWk;+8~-HC0JU<2*Vs5gJ!z< +IOg%|tgu*!XZ0vrS{}3o(KcrW1PxpJ^@=-F8m5J=1M#bldFQ_I0++&TYqK+w9ynJMRqDzm3jqq +jTHn+%`J5jm~YObKBzFHZiwN%#CF?ZQmefgV$|aa@&!-GgSY4YV)dXe{nPR>vdl>FVcwtTZG&0;3nAH +#^AOwxNQk;8-aI*g23L-wyCo1^=*57+XmmpJ=+G~wyn2q>uo!F+m7D0qj$Z^LJZ7i-nN;ydH1%Nx9#I +?`*_HgVjxdA6;rZ7XZr#M<+RHq%b+WZfBx4!Z!?M1uXSZ9 +i+r+>H>iC3WG+ZC`5R&~0C8+n3t*r8Y*}i0sZ#oY<4vHlnuer)~Rb+iKc&nRdJ+Ns`x#tOW}i+-&Otp +_hL7&T!TwcJFZLwr{lU8|~S#prhNq(T*vGxlI8SlcMLtlFjFOG89I0`YK=lC9zPlbF=N)Y8o5!)ujo}DdHyk} +<%7jJtI+aAQW2eIuzY}*fahHKuISbQP)4W&0t-pqKz-wkXxo891b^TN#nH}czAN$w`O8{KYdyMgT +nwwu*%R=ZK{r7SkD-Msdi0;%b32<@h^8@z7ty20xPuba7Uw7SviMys2NZYH{!=w_muiSC-I2o&8=bVJ +b%MK=`PP;^7lU9*Zg^M-Wd0*r1jy20oMqZ^Fg843(Cy2=7dn~ZKUy20oMqZ^EFFuH4|B4l)v(M?7-8Qnben#n5^-B5Hx(cSZ1L#xk?uJkHjxZUHz?hpbc52(NjE2bw?XL!r5luPM!Fg4 +W~7^uZbrHp>1L!Gk8V7=>FB1Tn~v_DQ4f!9Ji77d#-kgLZali@3r67%}6&Q-H3D}(mO- +Zfk*diYyZrDNhdlO>1L#xk#0u18R=%Eo00Apk*YjIdS@s^@aV>)8;@>0y7B17qZ^NIJi77dp6~gX=@l +d0h;$>;jY#hd#Ys87QdmTp?QY3Zh=o0jhRE9>d-km;U3P1f}p^?Xp+z +|##+H$2_&bi>m<-(WF)BthNtH5SubV$_XMH%8qU^}a(9#8Ed#-5hme)QwR$M%`zQO~t$`od7!X$a6FE +h5%xzcZMPerf!(JVd{pd8>4QFdQG>@Qa4N87YTc-Hqt*>suUX}j)@z1Q+`8v)-8XODymj-|&09Bb-Mn@4*3Db@cs3>x1}W&eq3edO +8@g`jx}ocat{b{;=(?fnp1*>gH5+)nGZaDOb(7akUN?E&Ag@z$#PAg@7QgS-ZL4e}b~ +HOOnM8B^vqV_qZ^4fr+iYtYv_L*am51HT4-4XhJfCCvC^%^iw{X(aeH@N3}Lz^{Q{gTCGw3J3fe_%-l +rtk*di)4<6_V1U>Fu>oQO#0H2B5E~3O#$bcN27?U-8w@rWY%thhurWuqYU)FDfY<=B0b&Eh28az1duJ +#*Kx}~60I>mL1H=Z14GiJUfFQ8}Vgtkmhz$@MAT~g3fY<=B0b&Eh28az18z +447Y=GE1Ln8@@4G{N@E3e97+m0_KtOkfVgl5J^-WkVgo%BamWK&*n7oE5S +eSi#_Rdf^Fxg8 +29gaV8%Q>gY#`Y{vVmj+$p(@QBpXQf&QK)a*r2gNV}r&9jSU(bG&X2#(Ac1{L1Tl)28|6G8#MM^;Ml; +iL1Tl)28|6G8#Fd(Y|z-Cu|Z=4#K!!^0R;&f8#MOLaDEmJAT~g3;Mc&ffnTo~ff#Hs*kG{1U}L`Vs3x +tr7=sN48w@t^Yv9+wuYq3!zXo{?@*3pzn!kITw#;CI!3KkkG1y?R!C-^I27?U-8w@rWY%tisuh&EagA +E273^rnZr^CRlcZQ;aw+3pBnCO^?7ahDccx#~6K&^pVgR}-|4agdhHRex`g0co>4aypnH7ILP)}X9GS +%b0$WevU>d^Py$Wr`G#HRe=zP}Tsf0aydD24D@q8h|y}YEadnszFtQss>dJsv1-^sOr1Gs)1Dls|HpL +q8dasfNB8M0IGpeWBx#Zkp)W)j2Z;>LS}b{^Nu*-sKHSKqXtF|j2ajA)7ET*rQR6 +|5ttea24WJr8HGpaW)c~piRPPK$2T={88bmdSY7o@`ssU6Z=N?2KPz|6OKsA +7B0M(eU2MwYcL^X(N5Y?;Z;ROa(4XPSBw`u-aQ!0W3o(9YeoEQ-C&QNqvtC+LNHN_`HP)yK{KpcT30x +|?z2x1VNAS};gzOIZ}-WduJ%i^%m4J+HQvJH#Eu(%6rxUkrYnc>gmdnVd5IiBgRsbS1%+L%ei%m`)_H +@ID7G^Wp={&u?6=~Sj8n07Q_BTize!nlXi_22l;78btM);iO(K(uoeL8dNo?YEadnszFt +Qss>fPGZYwDHLz-6)xfHORRgOARSl{dRP}lljkrLofmQ>pM$H#GzY0xY0M-DkQS%Ki^H8FLvc`Nb;x( +10{~)bFT7$F(X^r^AWwFYVp)EcNYP-~#p0Ibndx8ek +?23ifY8fZ1nOhwpgu+y21gB!8W +=S&YGBmBsDV)fqXtF|f*J%h2x<`2AgFhSq647@LJfi%1T_e1z|(-I0Z#*-1~(0E8r(F_Je{88%sK^}1 +~(0E8uLZ5(`Uldn6G=D-jkpPJPmjn@HF6Qz|(-IG2hu5^fc&caMR$X!A*mf1}F_i8jLjXXyDPnqd`Z5 +js_i#=hzn>jrpE7J$NwEV5IS!V*?5Vlm;jbP#T~#Kxu%|0Hwi6<2h3iP#TOh7-=xlV5GrFgOSD<=?oQ +&H1KHP(V(M2M}v+A9lbLY6L>W6XgudOC$X3yqd`W4j0PDECK^mMm}oH3V4}f9?+nER6b&dEP&A-uK+% +Ar0Yw9f#&b$QNZ`=Gp@BmKhXxM4GZYg%G@=U;O$NlY-BU^Kz#eTRE~DV^vbqe(^+iY63ID4I|-p=dJEWTJ^f6Ne@aO&oe>_ +?n|iobz}-m^15?*F5dq$m0UnlfQ`Jrn#oa2 +B*nQlba?t&H0<=n#+qAc$)Au;c0TyTN;C}Oy2a?|9d$xV}+CO5sT*%F>6JWY6-@HF9R +!qbGO2~Xc8JxzL=@HF9R!qbGO2~QKACOl1en(#E?Y0lRsu)!p#Ie*@t2sIIEBGe?PNl=rZCP7Vtnglg +p-?i-iF=`UjB&bPHb52MmLQRC42sH_6?osucAEgr~7&S3!V${T_iBS`yCPqz+dS@swIBIg#B9=R8MwT;J&WJW0>U3B7r#nM2G3{@f-ZZmmToZGz0umGOG~sE&(}br9PZORdJWY6dXDA%#X~ +NTlrwLCJo+dm^c$)Au;c3Ftgr^BluZdxTngsP-BGg2viBOZECP7VtnglfoY7*2Ws7X+B{#g%;{=}$>Q +4^!y8IGgY{8D0pfl(8qCPqz+niw@PYGTwRs7X+hpe8|0f_i5tCg^Fx(}br9PZORdJk9yaY4DH)H3@1G +)Fi0MO_Q4@H@!0y4%{@kX>!x#rpZl{n);N|TW$BTYt{j5HZ(=G>Rg0gomgO+1=( +H0fy4(ah-_$Y_$$B%?`2lZ+-AO)`2-M}tQbk0u^XFq&XA!Dxcftmz!cXp+$+qe(`Sj3yaPGMZ#G$!L< +%B%=vN6O3lfspyFylLr|mU(GycV{RjX5IDT(fLAFl|D<4SqjV?d#1lL9i16jy*?tXxR^oQaQp6}pg +9B5beGdJPFFSU_D}ChH|+KLFVkzmLQ9jDCM``^df%ZCp`}Snla^+^I*j?9D^D?q6J(mSG-+wl(xjzHO +Oun{8Hy87nxHfpX)@Aeq=`opk0u_?nn`F)iu;9;CL&Elnmy|jMw&fK*`Bw{OM5w9q?^TxC!?haN)wc3 +PsE)0F}fDJo=|^KbJhv}?)?o+doKGZaDeG~sE&(}br9PxIxbJ^$s +x0*IR?H%)Gu+%&mqa?`t(RRuRqZkpUQxoL9KM5a0au-lC1+%&mqa??bniA)oj=8$P3(?q6;OcR+VGEH +Qf$TX2@BGY`4Y0rO2Hl;p=J7pnkE+LXV!x#rrC2%v2$il+Vfx9GCj@tN8Bt{uUV{O)WoQXQInu1K}~|1@HF9R!qbGO2~YD(Z +*wLGu>((&nUapG|%)l;54~uBGW{siA)ojCNfQAn#eSfX(H1^rin}w +nI_;*nTt%WuQ%qx62D$tSeRhcoPRefIcjp$+132GA5B&bPHlb|L%O?aB{H0PgDnmwsRsEJS$p(a61f|>+132GA5B&bPHlb|L+O@f*PH3@1G) +H_38z^n7VrthAA1!+uxs3uTNpqfB6focNP1gbe-tv9_rRZXgTXQ)%bs)jNvxVg^|Efs`O?l=yRg+{tNDDrF~5^oh&<kQ7xc +aK(&Bs0o4Mk1yqZr7Dg?MT64;@IBId!;;2PXi=Y-kErMDEwFqhv)FP-wP>Y}zK`nw>1oh5vNizQyW65 +DjH&XVLWJ|o~za-ugZ;7`LZ)vy7ZOQiBVMr2^gd`zJND`8SBq2#i67DdiNGVc^lp>|bxxrryro~N*n-(`MWLn6ykZB>)LZ*dGYyQzebB*Gr#ZB)Fk90@6B +i&QFDZcsOQ@W=sJtcX%(o>436as;p7B?+!`mVrfans_a#Z8Nw7B?+!THLgdX(7`>re$hgMxina6*8?M +)1swCON*8kEiGDFw6thx(bA%&MN5m87AURx=jhC=ik22Ey)zU9w6w07c0A`tiA4f3Eo55rh3zI|#Z8N +w7B?+!THLg_>7Ai);HHI4i4XC|D* +a(G(qg2=NDGe^9xXgtc(lN1G0|e8#YEo~6fGWFJhV_~q0mC1g+dF3*6T2-YvRztp@l;WhZYX4HJt+wE +go7tw0LOo(Bh%RLyLzN4=o&8IJ9tR;n2dNg+mL6-Wdu49$GxKcxds^;-Q5?3xyU5EfQM%v*urMGKVh+ +S`f4#=$)ZR0H6gx3xE~?EdW~l^Lmx0XqX-jf))fV2wD)dAZX1O;Xl6TUs1jD6%{bFU}(Y6f}sUN3x*a +8Ef!iVv{-1d(88dFK?{Qx2E8*B5FE5PXmQZupv6H8gBAuY3|edIW}a6(V9+9S6cHT+4KpBVodS@sc5NILLLZF +2}i+~mZEdp8uv8R5NHw5f}aIH3w{>-EcjXQv*2fO&*GlNJ?{)f0{ATOS=_U@XK~Nsp2a-Ebdv{v*v8*HFDGQv?2k476L5-S_HH +RXc5pNphZB7fEEEQ0$K#L2A_0LG0xbku2(;j5!Ow!91wRXZ7W^#uS@5&qXTi^!v!O*li+&dUEc# +jSv*2gJ&w`%?KMQ^q{4DNS+_Si6anItOcZMPXd=~gD?pfTkxMy+C;-1Ali+dLLEbdv{v$$t*&*Gl%3V +asxEaX|pvyf*Y&qAJsJPUai@+{<8$g_}VADF*EU*Z_l) +P=AAQ_oB5HsLCu6<#@FfNr`w)hcE0DnrjblR&V!Q8BAW#@3u+eBET~yLvv_9V%)*(4GYey&#dvx8Qgeg@yw!_MKKFv7Q`%wSrD@zWOJp{@ulvyaVP-dab>vh+ngJ%}WERuQ6fQ +mBzD~nYYt1MPon6e0E5y~QzMJNkS7M +v_NS@W-y7o99PS#Yx8WSuD>Jp`OAI9YJA;AFwcf|CU&YyJ*?+B~6rSBSC@Wf96Elm#aXPS*U>?$bFC% +6d+^*N>731VUMavYtZ^h_Vo65y~QzMJS6<7NIOcS%k6(Wf96Eltn0uP!^%A`Rn&Wlm#aXP8OUjI9YJA +;AFwcf|CU&3r-fCEI3(kvfyORKg?cqvfyMP$)b@(Ba22BjVu~jG_q)9(Z~Xk1tN<>7Kg0o%)UTmfye@ +p1tJSX7KkhmS@SP{PX|jQi$)fWEE-ufvS4IAXXXGRi$NBHECyK&vKVB|Ki)lS1`t^wvOr{k$O4h|oOe +Y7hrBZs4j{5XWP`{{Pv11MX=KyLrjbn}n?^Q`Y#P}#vSDPy$ahU6n?^Q`?6=A5lH`))lH`(PNwQpINw +K6@QY9%xRx-H%Ix$R2Zm9`WiMM&W&XM@NFkqsgnL^gpUY!2BRvN`0PVMpU +Y!KNDvKeF}$VQNjAR9s689pU>O7fKCDalikrzB5Fo|1?G2H6a<8Dt~KMv#pl8$rHn2H6a<8DulaW{}M +wn?W{%YzEm3vKeGE$VQNjAR9q8g1j?S{|vGjWHZQSkj)^QK{kVI2HE(r@nh4+rjJb@8$336yfakw8EQj?EmKIW}{=GgS4^v7uu_$A*p#9UD3}bZqF@%(0ncGsk9*%^aIK_W +VP04ILXgHgs(0*wC?|V?)P=jtw1~IW}`_=Ge@!nPW4@#*KG|s-8DCZ*1P!ys>#>^Ty_ljT;*`Hg0U(* +toF)S(~=D`NzBFjm;aIH#TqV*FntZ{CK=br}~*=Gsm7Ym?nu09veJ1c)T-w{ZcwX0391THgs(0*wC?| +V>8EQj?EmKIW}`_=Ge^f&QK6Q$A*p#9UD3}bZqF@(6OOoGsk9*%^aIKHgjy|*z<*<4ILXgHgs(0*wC? +gWAn!5jg1={H#Tl;+}OCWabx4go-Yh-)Y#VIjT##@Hfn6t*r>4)V0;Bxo-Yh-yx4fL@nYk}#*2*?n=Uq8Y`WNVvFT#d# +RiKF78@+~d|_yl#fFLv6&orxQ*5T#OtG0_GsR|#%@ms{HdAb-*i5nK3qu<8 +DK=AVrr1oenPM}=W{S-e?+n#HRBWi&P_da}GsR|#%@ms{HdAb-*i5mlq1&>nEuY#F=+036n=!WuLQe~ +3ip><8DK=AVrr1oenPM}=W{S-en<+L^eAiI1p<+YDhKkJ;n<+L0SgsOlkNL&S!N4G|k6HbiWQ*buQHVnf7+hz$`NA~ +r;9hLFr7#D<6s5gQ^lL~MxI5V0X*L&S!N4G|k6Hbm_Ce$S?e4G|k6HbiWQ*buQHVnf7+hz$`NA +~r;9h}aOZA!0+sJ400u5gQ^lL~MxI5V0X*L&S!N4G|k6HbiWQ*buQHVnf7t%@3O&Ha~2B*!-~hVe`Z0 +hs_V0A2vU1e%So5`C;?J9zSe;*!-~hVe`Z0hs_V0A2vU1e%So5`C;?J=7-G>n;-W0Ve`Z0hs_V0A2vU +1e%So5`C;?J=7-G>n;$kmY<}4Mu*VOZ8a6d-YS`4UsbN#YriM)on;JGXY--rlu&H5F!-j@Ee_P(vu&H +5F!={E!4VxM^HEe3w)Uc^xQ^Tf)O%0nGHZ<({8pNiCO%0nGHZ^Q&*wnD8VN=7VhD{Bd8a6d-YS`4Up< +zSAcTEkO8a6d-YS`4UsbN#YriM)on;JGXY--rlu&H4~!=8hZO%0nGHZ^Q&*wnD8VN=7VhD{Bd8a6d-Y +S`4UsbNFIo`aH24VxM^HEe3w)Uc^x1H%S}4GbF?HZW{p*ubz+VWYxEg?EOko)tDLY*yH;uvuZV!e)id +3Y!%+D{NNSsIXCCqr#rA<7`aWn6NQnW5ULSjR_kQHYRLL*qE>}VFSVjgbfHA5cYf>XA{CEgiQ#W5H=x +fLfC|`31Jh$CWH+L8xS@iY(Ut6u;=SIn-Df3Y(m(CunA!k!X|`G2%8W#A#6a{fUp5!gSbX*JrLBipdm +n8!1k;gXQeiiznK9L!X|`G2pbSKAZ$R`fUwzM_YCxKu;F0C!G?nk2OADH9Beq)aIlGB6Tv2eO$3_=HW +BQefu0674Qv|NAh1DTbHL_+%>kPOHV14D*c`AqU~|AmfZa3DGr(qm%>bJLHUew}*a)x@U?adrfQ0i^orhiTUn*MdqK#%_#|26(=`q%WY>0i^orhiTU +n*KHYYx>vpujyaYzdke2_-pXj;IF}7gTDrU4gQ+>HS_B;13mO>=GV-xnO`%%W`525n)x;JYv$L?ubE#nzh-{T{QAs55B-|?HS= +rc*UYb(Uo*dEe$D)v`8D%v=GV-xnO`%%J~Plmzh-{T{F?bS^K0hU%&(bWGrwkj&HS4AHS=rc*UYca4D +`^inO`%%W`525n)x;JYv$L?ubE#nzh-{T{F?bS^XuWh#(j1)#0q +_0U|KWCsPeNFnB^fl>g($}P~Nnew`CVfr%n)Eg4Ytq-GuSs7&XP_s2P5PSjHR)^8*QBpWUz5HjeNFnB +^fl>g($}P~Nng(~#3p@B`kM4L>1)#0q_0U|lfEW>P5PSjHR)^8*QBpWUq5G{Cw)!&n)Eg4Ytq-GuSs7 ++zJ`1a`5N*y;@-^gZ$k%+Y`CjwA=6lWen(sB=YrfZbukl{bUv3}1chKHJdk5 +_uw0F?nL3;=79kh4Q-a&f@?H#gr$lf7)hwR-MUXomrT#{UpEJ>CmOOhqYl4QBal441*q*zjHDGc<7>K +&?gsNSJ^hw2@wcc|W>dWY&As&}Z~fqDn(9jJGp-hp~|h9OBvl9Hq(DM?C_lB6UlNxDc%ky4ZtB}GYLp +g&aaP`yL-4%ItU?@+x%^$yiLRPRu|L-h{SJ5cXHy#w_Q)Vni0k{n5nBuA1X$&utpawIvD92a>?@s#2z +#Z!u>6wj%YrzB5Fo|4>Ef2iJ}dWY&As&}Z~p?Zhv9jJGp-hp}t>K&-}?oho$^$yiLRPRu|L-h{TJ5=v +by+id5)jLq{K)nO?4%9nP@6J%wQ@um=4%ItU?@+x%^$yiLRPRu|L-h{SJ5cXHy#w_Q)VniO^;GXry+i +d5)jL%0P`yL-4%ItU?@+x1^$yfKQ13v!1NH6dWY&As&}Z~p +?U}E9jJGp-hp}t>b*Na?*P36^bXKFK<@y(!}1QxJ1p;@yo2%%$~!3UpuB_f4$8YTRP`+Hu)M?a4$C_% +@36eX@(#;8DDR-WgYpi_J1Fm;vI^2DBhuXhvFTIcPQSWcz1@X9^)O1cQD?;cn9MhjCU~Jp?HVl9g24--l2Gh;vI^2 +DBhi+s>gT-;~k85Fy6s<2jd-#cPQSWc!%O0igzg9p?HVl9g25nsOmA^!FUJb9gKG{-obbW;~k23DBhu +XhvFTIcPQSWcxTT*kMR!1I~ea^yo2!$#yc4AV7x=|4#hhZ?@+u$@eaj16z|O6MIVfJFy6s<2jd-#cQD +?;cn9Mhigzg9p?HVl9g24--l2GB{z2@6@eam281G=bgYgc=I~ea^yhHI0#XA)5P`pF&4#hhZ@5BuB81 +G=bgYgc=I~ea^yo2!$#yb@6P`pF&4#hhZ?@+u$@lMP@kMR!1I~ea^yo2!$#yc4AV7x=|4#hhZ?@+u$@ +eaj16z{|g^ce48yo2!$#yc4AV7!Cz4#qna?@+u$@eaj16z@>HL-9_`K#%bb#yc4AV7!Cz4#qne?_j(` +@eaj16z@>HL-7v9I~4Ea4D=Z9V7!Cz4#qne?_j)x@eam26z@>HL-7v9I~4CwyhHI$&Ondx4#qne?_j) +x@eam281G=bL-7v9I~4CwyhHI0#XA)5 +A&@eam281G=bgYgc=I~ea^yhHI0#XA)5P`pF&4#hhZ@8k^h81G=bgYgc=I~ea^yo2!$#yb@6P`pF&4# +hhZ?@+u$@y`5f69?lRjCU~J!FUJb9gKG{-obc>;vI^2DBhuXhvFTIcPQSe8R#+I!FUJb9gKG{-obbW; +~k85DBhuXhvFTIcPQSWc!%Ph`NGhH@eam281G=bgYgc=I~ea^yhHI0#XA)5P`pF&4#hhZ@6-(R81G=b +gYgc=I~ea^yo2!$#yb@6P`pF&4#hhZ?@+u$@lMS^kMR!1I~ea^yo2!$#yc4AV7x=|4#hhZ?@+u$@eaj +16z|jw^ce48yo2!$#yc4AV7!Cz4#qna?@+u$@eaj16z@>HL-Ef1mEFO32jl%e9ow-9!$1H8!ThTbD01 +jXgSt^*Cl(U!Ke6|dYhhvF#CT#nF`gJtj3>sE;z{wOcv3tmo)k}tXWp2_cw#&;o)}MzC&m-wiSeX(Qa +mZ16iquWppoPbz^ICaB^>AWpXZXd6iU6Z`(Q$y!%%y>Wc$7YTSnhv@hsER_xS>zaZHtax!RXWfP@ +HgQOBDzrI6%rEMJGRVQh=JDizaZM%K>q5j~0G^Oz<8BDVQ^~ba1f!@h&x7xJWGR>^qNG%j4reKneD)S +UYncl#jdu97J7f1B0H(RIhj?yTcrIw&>= +EByC2YXjHMnZ)sgqn$@5`6ZfVh|*QLGfDA=gpLj_nf{2PKKo-pY0DjqSLr{}3UX2>XNPQf;iP=$gRLl +Q%SP{MP8BepsXA+6vnQmrBb_&XoQc#BQlEHRVE+v{5=)$iyPw!PMCeo0JKc6f?2@t65kBx +oH+P}%3ZxrS=!QL2Mi(u3Ra%hLd)O_!#|r=<^ciDBYo^+9S*tD(kW1f3i*K{#g5v2TeUH;Lo-Q75kqf +7BivAstWVKTgz))p{_6>*wU@}OPZ>Wg-qw#3*7}yU-i|HWCXgEtLrg@w$M#*v4DrhU77;Vm3Vxmak7uhv`)k9_UX0I0|uZG@|EJ+*RrDrQKJD9#V- +37{Pf4dm^JnGWFJtPVJL!kv3%7?N9^iUaNyVN(%htx@o+M7?k-pzIIpPL@hGDGCOhX&KT|G7lktyXDG +MNzfRx57I1J8Ra^kN$<9Xi_UL`;F%Wry2YC{`6Rb?IQKYd5l^m@~zZ-Doge!SvZ*-PEI9&InP~~>0`l +QnLMO-zZ}F^M~%ZOI@5Em`Yk(~Ot7s~tJTVtaPAO1@atTrjb(vdfypRowUSslt5wIbDv$B-TrP}$Pd{ +geuV_^r)lTT^1>v1v$-XIlBl!j1e|_JM&L0RCtI;EP7Peu(I(BlUMa6##wCroE=>u-Ken>yGegaTS0| +XQR000O8@1eFvB~POi-#`EWIEVlMG5`PoaA|NaUv_0~WN&gWa%FLKWpi|MFK}UFYhh<)b1!3PVRB?;b +T4IfV{~_Ba%FKYaCw!TZ?7fAk>=muPf?P!T3c%4%0E>ZWv@rV7|)=!F#@cS_l?!S#k8jBW^Ok|?5E%O +{i1rj(s-m@UL5+Kb1EwsN2`&!_KRKlw*CynXWesowwc>GAp7$F +H_8eze8^e5>bAwDsMOd8=>UZa@9tXIs0j$R_^b*WcUTfBACzl<&UTK7D-i`1H5Ouj)xYc>U__(~B>@& +&T}fo1gtM-`Tc5Jb(JP?UNTT|N8Xe+wJFD_VDfY_VxD3k8i(u{px=H9IBTuzIb~6^dqD8_0!|y_U851 +Z-2;+{c8L1_4nJC&tGj%k6*obQ_bfmPaR`&VD(^o +KO7?Tg3l`!|nYfB*7XwvgZ5{`I5J|K*Q=`h0u;<3Dfz`u?Y%zW?#(fBsc|H%B@@&H1aAUVQsqn&4MkK +GoCnS8spJj%NdZ`0&#Y{w1$?|2H4~{-e+TOz(g9(dQq3_}ORM@BaAd_Wt(C`=5UP(FcF}{rjJ8pZw|5 +PyYDXhwp9MXOEBXhM2+pM}zzyL;Q6%`R(f*$*&&YK7aA@O+EUbb9&!o2VZ`*ee?Wpk2%d>KE6nc+Mee +U`R>R6uQ`1A`qf{3-n``R1Ny7&#n;=b*KeO~KRmri+ez#DPqUk?{C$3(rO|)+-m~p!`K9Nt{_SN>!Do +5-?_PYJP5(@`uw%@#d^Ompv;r+aJ@2%}WZ)0!U_NUMCo&V~;?Zc0M`~T=ve)5nFfB2^lKL1x%#J +_+4`0C3v%jaLbe5{q0284Nh{q*|V?TZ(GJ+>cSKm8k)@ZMSB)|2VXUi+Uf +A!^ym-)s2@y*+}-~I9@Km72+dyijz|K8glei`i--{uuhzxXHa-Fj@>&wu_;+y36{{cQPGKhAe=9V-sr +I$D4C)|&NJ+xxuVifhE=!hOd5*0qipPW?w;JwD%l`_9zq+^3BH_Um_T{o<$X=l4H +>pRaqB7iMpM@zZ1O?dSQgpZ$7&ukA;zuphrmNBQy}-R}7pERTNtH*AeQz1&{E%Juu^EvxL?@4x(J`zF +1eo+bUzr@#I5;lX+N%jbXoZl`?GfJ=do?mW!nlrOze;8{VdC?fpMxWVQ&UXH}@($aa&(gR@{;TDcSKh0) +n9o|{)AP8VjX1e=Kc9`c=a8^O6^hww|@KanZ^L={?(R*|)r5_IKv@+Kinq&u8Pv;Tt=h?tL;CSG9ZX57` +Z#dGm4eTd{Ja=VCDW^^9BRgXd87I66JbD`VxCbLBH~`CjXG$BrGg8~gc?kFlQh{m6!no%zViw=?`!-m +r1yMfY3wD4*VuW*Ue6ZO`%n>C>5?o{SCc_WrPV@IJ5X)|K;-FN+7ydA=Cca~{0p;GMg}7|c<=H^yS9@ +(!~;&~C~eV#GrZZ~oCoaN~)wT^L1nfoE>})tTq)$4YZ*bMCx1X*{21PFl-3&$+vp-+jkhwkw;=hxF;Q3r9X*Pv65JM?PQ2#PT6 +?p7Pd>=WO$f0FjJSL +Tr6+0v%-4#7BhYaV>J4Lk~wYtJx4pvDwE?3s)Vg|Dd`9S&S$%EKrOl%}?la|12AufLLur6{YyPzyIh@aQT?`^j8qZ$qc%&m`e4X)y>&rPhxG}yUP1+E9&~sNb>n-~>j4Rh +}&|3VdQC!^1IK*nmxQS2FcVG_4f4d@8A28qkk+teAz=wT#~jNe1Fh527^yLaZF7xBSIMWt{033AU_c<_ekmbR8Tlw^@5f+*A1{xdlUdJ6=lF>dbgk=SENQ4?Ro^yHP*%D%4P7J)k9^+ +ZVb#Va$9S0Zv1(F%nZsL;smNNr5NhgsDAqN8#ImOT`Cn_&z%7~>a@EMI@l#V8W8@5EJ&n4`r^_FWW*R +iW1ao;qiPl6Y|e$f3vxar{E0Ss)y%PXyA(A5z+K-1Xd6OOa&p(ieB0M1;(tX@JzA56+Yj3l5%;L?pI; +mg2hfQtx*dk~(x_yuQOaVTdeaS702yL9d#kJ(8#uvI*KLJ|N&a3zqBTjzshyTTdfe7b}OUrAf6b`zI$ +7xhIy28)^1o~~iXy&T*DOv-FA$muIDU^d|{hnob2oF{lsz*O@#z$N_z>IA(!a0qyKURu`)Hxn9`Njl4 +XaE!e>a{7@IuK-Bv+Rfc=;*!aV%8Ak;U>QOOLja&-PVok)ER85T2r%9?wu@Vno*hI24Evn-I3zAfkim +2U9oE#jrh%{NJm=(zlrlxj*06jWQfCd!A&xunN{3fydw07*9&p%8yb~ZFw3pTe=%Ith#0eiRQamgJ&o +DN8%m4%@g4)5vM5IxEeO%1j#j;8lne(RiXBYwFSKctE2OA+*WHsdSJ9wnU(_qP%IDkL@Bq*WuL0 +|;z^^cM~noI1f9q@y5b0WTg4H!vpyPlnh)S(s;j%J;Z+uRJ#0D)9~EA*4Mf0Z?3Wio;C=wHBN!;~T^` +;9bM(=D@R7@v&H3=1t{yaqHGq3*x)MB=K5l14u?D;GHQVT9zRTorO(4dox +S1e7^W${d2_PMe1JA9S#k!n(AjzJil-3W|F=!1xd6k{xhNcdQ3B7UOaWHTA-{WA4MIHjku5$;&=Y<0n^0FWmi2T+&Fn*AQUv*}|qy^Sz}92<&n&7#Z_+CW`Rb$q*+gVLql%fCTrt+f7` +Ow#r%rD;(Xgk`EE=Pwo{)KjJ(Qp#$X8Mi_Y44{jTj)ucm?v+VawTr$enx>EJmjtJpn=Uy6ikWtdrG;D +j$6N*Nd^M<$ME8DyNCMrw6Ze+p+15|e8OGXM;4~wZ|9vzAcdz`pKn21~h*>hG%Iv?<1U{FzZmKoARu2 +dX9fC#*keZd{#W1QWkVZrJ&ErZ3m4-txP2=6>hW5D%Map;6E=}b@S(jsJ;Q@}t7!b}eaStziZ-z>+0) +Mh#G4w@?(Fn1RIJ>g4E{mB4_lWYl^1!Q>GyvXUH4eWgBj_DxAGYD0=0L*O}r5pF1;1V2v+6tu9#6Mgh +pW(llP|U6~@Ruk{IGQj0GGq?z=E8LK(=`t1Czv;Y6Iq-5%4IwTlkNvg7*Ht!9P%~B9L&Sqw#YUTn&ZT +G7jKjfBj;_Fy|XGwPfob1>LuZ3T{g)uUZ7Z$z50`Qd@)KF(?}9`-hL-xWa7!GV+8Us><1YEHj%-?W*WKB)>Be?s{sDeLRlgl{`t(bp>) +{BM+0=Qn{aXLSc#5;RPT(STz>6~)O6B!paxMl%f(&dxIkDpx4ywrH51C{U~EMggiO!zI^O-z{h7Y73R +Zjdoslg1%*x7CX4zc6Fz(F2>{B2gq>?|E2Xmk(j%8^hZtUfo(9L6gPKoBMC^c#{1dwAj`IO7*~o>L(e< +z%AUP*@%gc^0%7r^&eK)-MMu=~qx6C(r5!Vl5!i^_0qsus7=o@r81i>a0_;oCqLC&WEWzi%Q?T|Yqjh +STe`CMiM7k;|zArhBNll99bVTgqeUQl>U@e)%&2j?;Y^XF3Qz|l2DPfgn!xMT9S;(yb1?GH507cfc29 +@1h$2V{S-k=+4e%@Q=g-aR@5GcEKf0-pF_e2}^q2>Dy*q;tUr!Ltu)BDQ*xi;dour089bUjPPZ<2lar0o{~3A8TNCsq7Rr +=2#*{G&F-Xc{)@3Z88kTw!jd(OsCqzpviZ;nc6mD)Ud;(JwFbgGU(3}%GTWs=iOf6M5-^_>dJeO@CM{ +q7_exxnZGiilzE(B^0~c?Ql7;214W9@?AWO(jIMQ~15j21p(4f8iLpt3P|6psREUb$~2!d$LVR2G|xr +8Dn$0li5V8M*wFfxFiNv2L3zGl_4(uMbj-fBMlf@4W%${k~&lm`xssFh98x3X!%j8K5Y!?gA+elo*Au +D2;ZgWO&ERd~5&(XdIUNqiH;yXYT3g0WF@nxn3;s|?Fn)o$XFbXGi?!0BLt4ZaGPY6jq@OV_io)PfP| +aR0y`a@%EOrh3%dyKz{|Tdu9?6yrWS(RI{l!KHT`GyG1oTF_kEp#NEgE>hz|?4d#3{SD&V^qycLd9m< +MhTDfcjCrO7xPikZA*(|s$-1n$w1C(250gr5zGIXShQT3YwLL7y*={a`!ZuPhuxq6Ey}3*<$`uwvxuW +86hO)#Zqi)AyzC`~))SYE%etB%6awg=$-@;*MoTXTb%{aF+U3^|7&n3GYPv{R5BR +9LMzu>FXIkYreVYKmsw{$}NjT#l4o6j5gee0dT_Ik_H5oxe%JptHaY=ezCR^0W(27%K#P8O~AnH@nPo +TFLeo04T`}BM>A)giB(%Um{Jl|z422_t&pp$ZUiWr+76Xs-`l~6$7c9OVm*_nAWw{7N+WxpN11bc6Qj +!AK3&03l`VM~Biu`ZVhBhrbM7k-ZkT@Y1GHW0uxZ@mVL^uweCIV?XPf>kq0I9cjAvl)?!AYmN3H>8Br +iLZg#g=KyJJgVKqCH<6_bE0Ss_};L_97`;px|1d80B;=zYLiIT+ZERFU8dr*vfunijxT7o1Oy?haWL> +_P@bf#8*95^{u^oKW)X#=VS{OEq@?Yr@v8A1)N$k*)L~rYc7WA>I$PQ*?zo9n0N0j|uTULmE&N&0j>`c{b^h|B?|^)PMT1GjQPkZTnE?k~8co4Cd3XruIyq76Fyd&?!=W1{{=a?%wT9Yamm7CWT!FCQ)4rWCZ +n9Bt2_vhs9}2(hG8fzfumZ7W#_I44NqMBSz;vDn@SqEbY}stiW4cF~t +aH;rI5beq)P={X+0cgOtT1K3Lq+du*uvV;T=w5sAzb^pY4i6;#x67^SeKCnyjX$HB=*y7KI9N;1M1c1 +fjhk`c(`fN3FWxpqN9PPbT**@bjGq_mjOE3qA +6MxH6G^6@+~qY0lpO%qlv;wwL97dJ-Yk|~R6g*|87csY3cU<+L+eKDc>9MFeF^wzJFBpZ6CB1(dRb*b +>seNE36D5Xojb0#BM9h1m!@*BSAQ4!l4W|!6Eur!#h+m{B#bKJPJku}#fH#e44>XIpQRynq(hSbZZ~n +s09ke1Ve4XUV1mk&^RjP<)=uvLh?v&;5DAEwo3Sal7f!8oAXDAz)vzw2Fl(mahBEg0Cr$#Ej|%+a@`m +k=R*_E81}?`MCQxz}e>O|^+EvFwZcJB{eY;pk_#H--+QUFQFeoSFs4|VhaiA=O^PpNh=FLB#d(DfinJ +|p78Pc1YsSBaoeHol7Sj8x&Dje=FX1knj%=xM~gzj~rT+54~cC6Y;dr@gTmP_L-)EUSd1=qY-%tE52WnIx(J|ssP%RIP*622(M!nXG+hj^6A9+sZsL+wf(P|c06jC+L+)U> +?wxG)lP)j@1E~gN#c1UxNzeFlyYo$SuN`&RKrA+R@P%jTc>nAIsitm#b-d*2c8tepvRvChqTNgfaps+ +8p?hr@_#DNZl0~1aJWPz#e-dOU9OUD|l_3Z2RUSy^Gfm*92=p*`-{X+DB)?A{pv2JxQ^f+%Oj!~9Ya& +USR2|0RPobnGp20i|#d)WKM}Cj0lso*q~27EbNBfgOV-ffx^0!6ps>N;G~L%t#;A94p +_4RitBRTM~PRw9G_??R@2BzrIOK(D4erGdNFHre|gH}1gZi*#S$l4wdxP$szlVVfkC$6VB-hf);D*gI_ +?zN#n8kg9DO3@`wWkCWzh5~!&)f_5s!_$QGhFY6^zU%EUsJniApnF~FHHLl_k)0JbB$-oO62*}Lly +_$QpefJC}r;yk;^3+0s%dJ8LIFx{Zft3YIK0AE^?rIZHQx9H`wwoj5Bc*a)_yJ&p9HDx#z?s3~P6oGF +iXw>d}K6p4BdO91t-}8t>>mi3lO?W8BoVtCc5zlOYS~9;Qr~0#UWO{9DE21KsNsZFQ5lT@FF^Lsf~Gl +)>O$d}SSCHh07zPI9O=JHc1hxaW=iI1~eM@tCd=i4`qNtXv5{X;~1`xXb-Rw+yVSiFz+kOII~t`pE;` +E7d2Et2+P;o{&8FYYH1QANm@cQTOt;;`j>o|w+KrS4P188lnjR|VP8%>b!2L +%fWEPueBth<;L&1jeG4vO9b<)jc4;p0n91~XMVM-(Vmra_c46=NMQ4FHQHA}uwxH*bHSdtIkY{@pAbi +4mjO5K_^H*htP1>M#>)0z0OwE8>A(C| +Fq5<3W+;cQhI|KLOnXHP&1aBs=|C^zM}E)!1wr~du>?Pto>Pv|4nvi2z=IU^UYPjte-D?}}oL~r)?qH!P{24b +^l)l!dk!P#-m|7vxVcKOelCC7M;G_?>K6E(;vNoR3ZKz?Hi|Ao<=zEYWixAU7Q&4VmA@ +V6UI+Z|QY7W}wYm~d43D?ra$2|38XHj<{IE_lxr?VwH+ruF)0nFU<;RX@aZv=aa4JdINI<4MKTtS5t8^-0X7Lr4EjY_xg#nT?>U +MG7#mfKY=JRWM*rwI^iHncdFF!4>Hj1d$83`{RchCBS!mfqvQew?$MtAPjKHQdEu_i-G68S;_Fj-Nr0 +8yAH+Q*%=OC9l13Z&&TBJJ7u@Mg5oarsBKXecJ_eOzA1c96rGkV8^9Yx=T0{WGnAJ(7kqQ{G%I +>!E>a`6L`0ZC#}tkpgr}TdUIr&rwUvbCoYHj#kQ)Rb)b74=D53F%n~}Jrb*OPL#*DNeoPCs_$L8~q*xBS1s(cYG9%&z3g4mBNoloY#bH1@TqYPcIAhj6_ +XFMQa!>G~b?L8{WFmO7De6L|15}@;Q%iS@!^L1NukHG2f&3lk(Y-d1b0@(YCZw#l<=()h-%;gnF~^F7 +6wvYml3BOrV!yR1vg$Yoy4N`^{24}0RVB>0H7;^iQykqasrlB6*C3};7Mr{rProaz2%S&B`&b|7z-iT@t`YLmxyra +1nfV+6l1KsOj7wHSz?C8Ruos`r~r(FcP?(s$UN=>1Mu9vt8HeTrV2G +y}e(Yc@MOH}>Ldv115?*pk!A3F6rp;QjNQOHlCb+fR5!?mD!3cbN%%{)t<%l)I%25P;bd!3R1%hEXfj{A=ZwvBE5gUn<) +Wh$je4m-k#uBI`Zmat=frR)LSD +SfvOTDV4CvMQALD@Tbt*-)_gCb(mhGMq6cY*s4l(j9?h^x1+{g4N`*P%*{NZQpxmEU3ExMSGeovJobE>GlWo36L1g#`fM8 +ipHAuA6^A_u4^Vo$ZMemD-X%vA;!hlDyF0F_q{t=57Wg63j{!tVo*lR(<}s+$YT3Lxv3eLvQkqtU)Ag +bDCR{Fsf)$dB2PP1uTLSx4j$2SNU~xuMN1JJ@N&vweG;&*RmD}$xg8USpZ4m+FbsuclTO@6xX`_I=a^ +m2iJC~3YkAiEO-KTDKB<)FZVDbkXy^;r^JyPQX}Zoy|qqb@#`nL*TJ9+g24hgHw$i6i^5Pyz&1#uP`cI3XSQ7pf*s@=pT9VoZt3{OiUI9$OAJj{Y&SftRyt*-JKLplu~r +>qo_)X)iE<$q6guO_5>9k@f2BsS(gp8A0Desl#xhuM{Q%X?9P1-}?>kp#_FI)!srUsBs|*-bB=Ie*8Y|g-D^h#&^?Jp(HdcNpw3+ga~Dd8!H(S_$603Q5hGUFHG48 +HdBl64#EI^;k!=rZM>#!2E0R>mkg1?rnItvZQG$7yG)`>L;hygB1H{}LIBFcwy^gN7opk~F?!6m6;~XyXPPW^tS&1^(pm19`5i7{0C(*RJ<+`m%8eV2sdNk|14TfU?H +JS+5$t)w4ybghQv?k{zm?&=|#TxJCN9ni~?k#R-g&kncG=|`-r4VOQQnOxP4)KU2NMEBY) +W16U7t41CE( +NR#?NT=}V7Ndc+gmYcC8dFcceW59VdAi>cef4X`~2+uJVTnrVrW3irU8^p-yLME5#83gogHefemp8|7 +Ch11*aP!+*gq(Km`N&27u>AyIf}%)4&?fbMlFNCo#b6(sKAINd2_pmx{uK6$jPgwId#3k5|^eqL=wS*2Zx^;XqSAh4i}QN_Jh0Ki}j|LmV9IauG* +(S5w22yr_6_hLGlnby_nRmrx!p?F8$8!AJDxn^%6|%LJ83h_XU{?v%p~Ho3iBPStXKE9z&xtQIsVxch +le<-_X5oo=Kw;;c~yzG{wSWO~(c+(1*KQlByde|7CUgbkBlhxRIms!V}%=f<>J&(&~-eZ}0fxPe!P{A +;gmquO<92KnXd`TbAh#`Fzz)&sn&H;ZZ&Bu~zb)*ku3=x^4D +_iDH=jPj$#=vM~M=h#IU18Q4Q9v?Zwlc=w7#@4g$owTp>F5dIm#0l&6Yww{aWYEtYxo83Aotx>o8`db +tzb>qdNQp7|!*SjV4S-a&+*abgdb(o~{l-aj+tF3cL^fckag)K{D5585 +{EKPH@+yZb(?e7f+`-Pd*$#trpI%?Kp85c)qcaQhILlD?>P;o!QD-5R>11?Hy6ElviyU(SK}eO1vk=; +VHJyy;)Z#a3W@kRH#!fl!gr;=AQ0$@Vf1N)_&C@`BFnbB@-2(8A@+jVbaro*({cwOBqpp +~6Z%&tT-bMNUbq!G()uW8~< +zy-^qEM!xYpfT(^RB+SXXXe%-9|ZdyN_pJpt(@pyyYK_9Vb$g!y063>HSY@5t2!%46N~BWW*#KzQ*1@ +umaPVa#qtm6Ub|b*)Hp>Qg62VsAnZCS4ItkgDz~M0G$LNCI&Hf^0d^lA``s@35(}#oy&D0oxyv6Q-C^ +20WY<)-;Mom_#vT^k*{VW%WE=z{_j%)Abg!F&MdcP!uWm1ZEN!Awv`~w>={&0EI3&eaRcHdGcV$%!TA +e3$qI=y~nhT15!9Fj~jsZ1v^WNH-BRX}ngi1dcdAEI%-uIz?=Tz-b_7K)_0509*Id{Re?g9}49-t{T3 +U3VuH+(q#Y48lJUM21-H|{(Z-RodxnoAzuvF&bD@kGu`XGxQKLW+jUZpuc=E9tH%Be=1%&Urf3y;9to +-EA2zNEPRvKX%yALAR_aJ4X!0;c+JN#J)%HUap_J-6hY(s7@aUqi3`{_iK8hD--2jEU5COC=s3T2#E> +ES9Oaq1s(vZtslg +luBVFGi@ngjI+zy`0vsK*TC&S%^7=BRWaH%iRBq?Q~6C27?hWm<#$0m5lCuooFS;O;SNI65Y*WuAHrS +Rx?yYMB4!iyRxdgMkr83s>Y;lY8(Lt0USF+6D*z{1>glsQe#H0pf06W!}}8Ek#h;`uF>?X<>Nn){#)a +i6ezOWlftUV3zkIqn08`Z$ieUH0Qxy4^MK+MjB1*oe5ns*i|!X(UF>4xDO3*`Dx(?bg#?WhGjYY&a|?%DuQC_s+3irPS0J$D2=_ +avy_erXRLg#s61<-d+lzl3^%{};Jzr{!}7bIhJAzk5=6N1PZm{+4`1-V6*rfHO~XAPj^JrQQyvkp93p(D))jKLYWL(EL( +fTY_cc(%Q?WciVQ5_jara0L`)dG(B7jZt%nwK3>dNhR7P{AtJv2&5&6yWifp0;h&pJ?}&IdrqR!96XXazA?A@1C!lvdkMi??6uUPDA9Jw%GmjBm=1q#l4vi*paA8>gribd^U +|95};xx!YDa6Sco(p?h6!=C=sPF0O_>Oi$wN0?l2JBsh_g!ICMmqQ)F*dM+Iu26*jvyWkSVIdHN=)`8 +S`x$(McZNu?pAwr8&{%)sfjKR}g=wXw(&AVOp3HLhI&r@0af`^0?H)|SEv+W+aF!>ap*fkIDFSp4vu= +(rO?<{n$4WZubb(~(~Gx#0bz!!NEIuhsso4w#0H%b>BP&syY!m$IvLlSNs$U^rzJ;S#|%TsL+vvqm=H +et;3g_gI0@}%hAOq3ACu)A`3sN=2?*Lf=o-Rtn^Y68{pQ~)T?b-9CuEjA=OlbZRuocrd#SmhLqtz=v^ +EEoT}+Xa`nZ{`rT;nIoK%TVZ!en4eMTRIuvzUp51C$dIXP4l1|cMM;pV_N85r)S)Hbct0VWPIHXg-~J +(&S$cnX99$JcPlS8qGkyOX&%)b5X!9ehVFIl?i=)ITC)X@yp>H*5$$n_9xidHrtknA7Y7iILH4LavxH +f^=j!gqsq^zZtJK5jdFDzPSct=61n?qj>W-4z|M8*}?z_~PzuvG{99rsLm#fEJ{)b1eBUbQi%=&;d5& +K0-yFvUkLh%IVw_0U2EPnZJmwm!lUCv|=Z_H#P%%x_uE>A?(#M~OTBuPmqhO?!&ajS~!r`8*~*C}h}; +neE1x@lSn^5qV!O?p%j)TjpQ0i9*t9&xRc09KW*f-`)xzu;O=IdPMr^#i#7&OX3-zwjXB;%wwwrP^Fx +;Rh}(5a7FZPv^~vVlWQ->j`Jf8xtBzKvdV%p>3Acbvd9-Lbj(ec2{}f)TQp#qr^QI1;%utBU6-asM)tm5$?%Of=pkEznwNpN +dF4rim~x*#lg?g42}S34^w49~UTxw;h~@b4sdAK_8DwHp;>_^!YT%vSsLI7un<05`lTF|WEbt)1cm8x +k0MtN^CKpJFy;&S7N$ymNVIeY@KQmo)hY%KP2pa8BJD`ChqRatXL}rB3zJ42J{HJe)QuobWuTyIsyNA +?a#}oYy5zg^EA?nSeUMh_LJNZSK{i{^r4u&9F$mtHkH32JUv@OW=1FRq^J@ATWjfG73xJ67vkUYM!C9 +nrCGr$sbE+Y4~FDM%AS`$RXnZp>r8-^ME0n#%(RxLp$rh*4@UdU39M<6xnN +_ma~A%arsFw`a36}mczXZYG2&6XIWGkE`@l{aJx!Z!6xhU5AMVE$1SKFDwkr{+eA{aJYvah=N>ZWDa9 +UsfTX#hIPdJPUld5!t$$!^Z2AY!vJexx@8Q7^T->+hNA}Iu +VE^toX^3Ha($F4(`;>h(mQ=9OaCrDfphlLKxT0*M28xdZEx&GoQIf2D)su!=2X&fz|6m +a8YaxSPX;g(|k~?H&houT+$mwO8`#K3!J+)XbroLiZ2?!_ev+!4n_i0bH4zP9f|@FMT!pOCDMQflK?* +xf^!zwZ=n%v_Ed)QI2(2o21(1esmF)sI>Az +V+l8c*gOgbf+CR_Peh5~(UYyd0_e%v3Lr@{dksm-IwkaO*E-JbxqKk7!!{gl??8O>46Lb06@Fb>1};? +nJk(Nn3KX7r_TuHJ!e)OxBZE*eJPy*vhcArzX+F(uJkC^d1-~<$C}Fk-fqRcx4EKv +6d0XImW#?6Dl^Mn$7CxyA#-LWRsr;~D{;s!tPA+q1`_N3N;y@(7n#C5B!}chB{8dNiy$mkQT#**G((7 +wi6V6E(!r*?n(7% +;pyR?oxb$unse|B9$3=+GCsrjR(T7dIQ`jTXn_d?_IXH05HHj&0Kw<(p&X3|H~QFydT`2zm(!?W*Lov +@LK0#@I0#+NGAxErI1z;R5Gb5i1M^g=DlN3}rTZDhLYM0-~A=~BzXH*^V3T_wV3y%Wf}Ty?uOoeDl_yx&7+#?cfkIBg#GsCRGbul{fOIjJpcnreoEzg?h-{f%R1JZrGB3nM$h<#LU>^72ZIspjEASB0q<~ +N;Zc=<%3xDuuqh^>(SyUOg59gZwx4Ll%m<2DUU-Mg2Ynk{Ik*zkiI6O)I|Yn?fLVeHX0X>Hkn0C(;(( +`!Ry$P##VjxR4sNSCi3eALXds}13Rh6Yism>R-0S2DLUBCFYpgRP! +5REfV>ZM|ABZfki7(8JgA^Xs}uJF#Vjwp!+94k(W +_jVAyb>i=z^w(Ep+H>|&^Q4~55yqhvcjB$2pWXKpjsQ0t)f??2^6!u@D5jEQ^)~=ihWRW56a+y?+S{o +L3K4K5C&OWP~8Y>1OZ_dy-w~46tleKJJ<>wQNXzbWJtgX1duC0ML{eHVoBim0}eaje}fb+K?eL<2Y&Ai)qWfp-G*5}=m=SOl0NKn(!^h<@Gkb}?_*iv +9-$U!boGBvOG&BPc5eCCdOH2Us@%s{y$XPzpg>8>CnT7S4FFD +{0u0n_0XY}wm;$*{z)}Y#vKXa^3ly`w@D5jED^!+(szt!e2V`)-^#&wi!0iR3Tfnjfgi^r61nf(Uxaa +L+-mn$&`Y=x?I}cM{veF=H3sWZ&n;;_yQ4v8rjGF|?K!_Q$lxu-vmKWYxyaX>?iH(pA2I}Kr`$Ry`2W +QL#$G`*%o!~r>Kra^@cM-D`P=R8W7vAAYY{i5E;b@Sy2jYUDI2}|Cf^u9?(Fp)yz@Y>wR|F+;Vn?f1v@l@J%_=r!az$B)QkevMW~geU6>Y9vY@~lsD}cTO;FDXYG?t0 +8DwYy6%_J2a2R0*Ogs)$$AP>xW+{>b#VjxR4z_}hGN2R!Ib)zb3>0*M{3np)glP;#=Kx^`CE=jX8q^% +)KAAaC%<{rJT#2oi9+23Cqzn)yfC3@8LEamrEMf8h&Y1Y61;FFHUh +&CLTUl8pblUY;+LZs^guDo3-53xwn9ZaC^`pK>hvOg%Z#c|^j6tleW4p +(9;F#Z8q8L;I6nHO+n0TC8tTmkS8NZ^3z47kXEhK%FJB`9Wj$#<|72%`W#hg=S9O~9%ItV+Oe1Z+mY7 +=#o7S$vSO2ibERH!eXj%M0&tCALDU7o>VYHWp-KVb(L2WP3S|9p-nazCEHAvnmDmcUnPAUfP_Yja5KdhP&Ql0>C< +TWf1d@t?3=j4i2Rmisym1MNSzdUDE3p-X41qQxr~wD{q@czVq;5fS79>$Yl`z<(8i=X_+91vwm!O#Cg +?G3TTR~GEXc$7;34SHmzZ2}P3HH6G3F%fKKhpqS-_ceoN;p#l?7et}FUP-FxOgP6kZ?^3re=JZd`(5mX~}7TR}Sz$OZzYIUpQ@8gx*t3<{M&eKDxq1(myyxqx2}sP$MkEc!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D?FJow7a% +5$6FJ*OOba!xaZ(?O~E^v93R9$b{N)UbLSB%OFk%${wU8!x<2jf7BE?>f+C{Jjy$FS;p*Vudfm|U{y7 +)+Ii|ESJeCb`4b>6rbiSjMT?N@Xu*!{6X!=IiP7H5&E6Z^aaUguA({yLo#s+)tt{!9z|fO7G_U>6=te +)RQF3F2t%FO2WhQ3|{|sWcRGU3zLX+iOx+6S{@FaBp-dNO^CYMDWLVKMKA+#Srv3lO378FNG%roH20uev}$EaU!c5nxQn +sRqAvZ{Lz2+n6?%}Od?*V*50x>tOMT;fNS(x}z4_4V-CXxR-t>r8DI#w@G??D~j3G +3Kb)@-034Gh20WUsvJ*PaucrtIg3)20UdMe42d7`9SmJE{3pmK;vfa56cboJs(59=tHsO~GK5EFbQEI +f${4YKLWXrsrJwTXs5`U|*?LD^tR`W9&$;bD1@^1(pRSqoDO#V&|;a9mlF@;^Dbm82z4p&JJJEx@^Qw +=<5aDonN`WDt)E+2dw}4wi}&45G;11NAN6c%YNN7a;-(le+snh_g2$8+;F{oc-Q&~P)h>@6aWAK2mtS +)wnjOP^bPAm0066u001)p003}la4%nWWo~3|axZdaadl;LbaO9oVPk7yXJvCQV`yP=WMykB_~c)=|K`0P+&tI|NW0|9$vn9_xQBEeEo3$=H2$P-t*z@=Z`*n^YHGWKKa}Gzuv!o +{Nes-d;E5L_Ya;~@BjS%-P@Nhez^a?9{ce4=577+>4(QB|4|R#zI=RIKY#gj|Ki>KtL>YgeByuosuxc +@>xZA}tG;`;{o<2fZtc3xdc;3``-j^{uU~J^dGFip`Tg7br@!96S~L0N@y)xZhi`tYY5wBvFaN22vTc +8O@$~Q8mk+Q1^7Qci_N%Q%_-=dmxPAH4yYC*~yq|w9)$50Eo?blt#HxM!bbr6Sef;*_-)dmL*?xNbae +MjV&GvNv>f!Brd@aPg?Zul{zkYnG&wu~;>fzg;_|cDVUe$CM^}GA0@8ABshQI&(kK1SWZ)>F6@9*E-K +h*#;Z|f&p|FHf1 +ZSS9Wx7A+%;>A10U%UAOAN*wv`ls!6?Z(s3pZxG2F2Ubt`f7W4<72<8wXeU_18bsxE3?|Zx!-<#d;jf +^ukY#!_1^8@o_+lBXCOKh?nN0e| +@P`6vHUpZMtGXP-U$`cI7hchA25{L`<#+J5)N^X;SU%a5La{p^!Je)iGx?aMzt|MH8kKK*dpzPi8vd5 +Kxff3(Q|XNkY9M}GfUEBWgF-HV6UZ`aiSRNMQu2Kf5b_T7uW-q$w2yniT*+Fq24{P5HN*B-upeDfFQT +OaxRg8pWE_;!2q`0j4|+tWkYPFdf7+1+}|-}m>fjQ-_^cU!i4(~CF%{<^l{tNQrw9=@$d|L*nUJiT~{Exmj3&FlN+f%P*cSd;sYFP>ig{MvR`pMLy)`|dyIF$WLMdg}J8U;WQ*|M0l@n}4Yn+TP>+3s- +;tLL2o$-{buGh4cLj`>Yr0k?V!_;lBU;LU%aNUfmNqezs;jZ9*sr_W)`K_l%2BVh^QcMf^`-4Nf{)b9&N +lA08qQs-_wcM5>t0W7S>uY6@9a^}pEa0T!!c`St!8$fHQRp98fMlLvc}a%ulYFJUXK|qYAq(uZ)et!j +{4#;Yhq{Cs|@p2>s8AV{bVtEJz=jA9;4QIuMhW{I4_(vu3EWqF^N%g+D6T3>{oqkXOBjGXU(BDWoy~* ++C1y4a?~4-Q8UY|zir8Y>(Tw{^_{h_^*NS?MXI^iV`i;u?a^KXPBy*1^H!71dSg8`ItGNrM7@bIB)dH +CB6$92%)6GVGreuA^&0ipnohrJaD&A?G@Bas==>4&;l}sXXljXjtL4Kc$_4_9snP6beO>Ie7DsJf?F> +&X3rXf#3pws?W3R!M(Ko)H!7=s|o4~|dTs6HcJ1objC$uuWG1C>mfUwfF3C+!GwT4-b*#=u(;if)UA8 +7|Gu-61?ziWCO`>n6Ki`qywn0>2dC==*>cCbk0R<-t+&B +egL|)`Fav1 +?Z#a*Zc+D2_a)MM{*$HZB_L2#(JS>u|MAz1qhjSwyr~AaZN$i(rJ7|EZ7 +=UEU&1GAG!;{@HUjL1MPB&KUe;E=jDy#P;PeM0tUm&;PE2bMOxxkk*D?%4X2XhnK7s5c+OWbs4PVh%U +3T=U$(Mzf2anU3Uw>R>Uu6!=kpbiBjYwZHj3=CKO2vP?pw6QuVWFMh)W?%UnxUi&Rf-Z2Dv&FLM@lSnk0XE-a0 +~G4Ds`ulMYD0MUlDbJa(-hV7h*F|rIyr +&3!d4g>+VzAw%)twAvAr2Ky9w**SxxYw4IIn`QE!rb7S>WA3LB=7S+GG+scjDrw5lMP_c$S&o@k|h=s%Hidj4ts*g514HNKPMi*4Q^7RM@*?XIAm1s?^WO4HYJg%iXL;>L40`WjiKcCIM6kHxt8N``9o`jPVrP5OnK{+l6IyQc=Ywe3@WJq^$Q~THSb6 +Q@KpPHIPOOE2k6MVqQjw=9U5b%H+z#*tZ)0ZDY0#5386WQZbPc$QVt#Ttn={xMn=u#czNyKNd!fNn)% +AmKp8DCUzNIHV7&QnRk+~JCS7@_+-brS(T{+;12-D(Sf6<#)x4TDrDm-z6T~=Da}~1lf}u51gKums(? +y_NZ;If!XUNcwvDwu!8`S8*&()+WeK$%2L%TcV4|eHq0OEzL)+tF~OX74V4z2CM9e2D*1TbrtHy+r{5>qq`qzKowHa)sbvt&?IGwC+iwH=Uf5&_oKmsML1S2WC=v8N&m +@lp`G&c5U!EFlSP^k^T~!9Tty_l_ZtPyg|C=@7-c(H`-904i;9l-PnMu!dK-#66H>WsI4flM|s$(DAG +~@ud7c~UItO7p@WERxSU~)NInNFi`p(WYIg(p19PsOp#rW?#AJ>QaDTF-r2IjQtnk&$b<~?gkp_+#mV +Ot73BE=FQ%+d_G^pqm!i*g|JPsf2*EI?smYs0lsRBA5*$$!ZjyVHIS31E;cWZQ3xDo;N6DGkhw<(yc5 +e7)EqDBYDP@f$Ha1yF4h8cSMiXFdyu)t3VTUmg8iP +DmS6+dKJhhBdIvC}ifz+1UMR1t4w`CX9MO0U?12s`BnGk)Dp@Bn<_32cQjf9$fac2 +i>ij7UFwHe0IVJQnj>p1TQ>;M;6HpHlSzBuy0h)>=;4k9}N@8rz^&9Zf!9zG^TM~f8!DV`=9))1>5F7 +qWa8PG(;cpMstRP&^k3~D_#DM;@lBpyOKLk@-LOysH!XIuGV3cl?!>AQW4O+#uc +$5NPENGEKO4~u02gnD|Q^trVc3eSrgL-^Y-cavXaDYJ|_SJ^+9+o97n(K1|G}$omP3q;W!3DXf5kZ^K +Gq4y6&vHNV@??LqyO7jyh8OZv1L6bu#%?+x-3BFm&4LR90wm(HxjWD6b53PZeJXze!LWJ?-1%RsCcA3 +(;Ye+V3!e-1ARHc>fW&|iec);N@Q=dg6Cqi>=r=3Nh!-y@I>>v2j;tYL^ciEBx|xG +pPas$y!~<0OrORtGH7CJyU_m&3^A%2De9Pvaz%UjsLWmSWK=Ul4rs4B>-`9z-y35v{aEMoJx0)tH2TY=2Xu*u~l(;0$v_9}*FxyEk63AbWT{|{?5T|Fw=`x@R(1ur;a!eo-LRus#;A*<3 +AP5hT*dp3=tD03K@K2w>(%|Hq7IO|!IdOpy0D%YK+$rg>cCFS$Tl-BsgcP;p#a+6T?+Q6A{lU8S#qnZ +5|bGHlAcL3xO4Y}kEY#2oD3eo98U0tZ +2hWPn%Xz_*yZ#@Gbk1cweuy^%l0A%>Ky0%8y=s`L(Epc#h+85RIm9;3bvU^lJQAZ(9-6*+Kqh^Gx+qC +Q8>ehGpofy43~I427hOmuN;)_Ma&z+OYwqoT)_f)cw^fo-ty4XE2Gz;kp9YnWaA_7V`B#6!Lb+5>brs8+G5W{!%(L1Tm>#H +Q~Bpg2H+7;4rD|*KHlF%4ssAvoNuL0nS`%NwNg%1wJ4q{Ljbb0zQBdRi~J2my2{%F-bSXZLEacUXkiPCD3hQsBzV?~4j(qU~1UqalWc(~PGyC3DU@cA7}u3ccMs1z(2f%pSx)k +Hp|rV&OBG8zGVBasA#e5+t2*vH6-*mKcFAZ8@*8K!IDb(6p^i +xh_*(VA!^JWRZwFHF?uCk)Gr;c_XIUVL%F?*%hI$d*aV;%B3QXqMu?fV)AY+&FZ}x?P6uF&L^;580bm~R97FKhG3-&J&Sr3+8tr6=E-5p* +IGn(V=O+(5AWkUe$F5JxKpEz2)zD7E0Xh-l)-j$ADrpp7mDgyNOi5~Hizy}CIn{MVOX@fvB(-YAHc1i +y?XV=JK|`)+G$1Nw{(4sI${vuXJC>>Frvt?%F~8u!&|`kUs=tH +JUqZP1zAjCG3|0($ElLQSFArt +0(luvtr1(>cAEawf7?Nk;Rs$xcY=2b&$v{ZXmpNWDwG_8UNG2p<)2#>*2RzEKiQP>$G!D`R)1Xda81%B}9yOxiU^Oc=0WK#E6ZRuW5P+Tr?>oSsw=Njiolg_x(uW~v(LCVoj&w#@UP{JSpb^vVwOmYJwa>@Z6RB3{lu~flgP +{()M+hfRA(Ih`iF-ijPf`j-$P&_HNh%TE%Q1fMaAWZ;5ZCRn62n0KzjzXjrWE`l;9*YyV{IvMBMj$Th +%VW3wVTnQrJs6?H9|_OSW?27|9ig3Lv9T~v=sOxfqDH{q_LTxK>_hOUv;eO=l`*{gu#>GuChP~ +{1*Sf#UDu4t9OOXb5Cpp#>C=)(FheqM9|={Y)(z;^&r@?2$g_OXEVN-Lh6*gn(C_w|AnaEx$8XtrN~| +_)2QxELN64PQYliG)z!j|??M!)W)eWRf1E)?&r9)km^g%2507WR~cL`is=&5VtGd$4NdnH&l#Wu240E +pjRrtTW-X!*B1a4qg3gCm)8o1S?0|46NsBFJ#j@}F +drU*&SPV+ttmc&ISE~M^;7J^&v_o8Xu+wHiN&B(tI0{{xbSLrffV#4E+6ao +Rn# +QPNgSwO|wXg}O2=R91}|cN`1J0 +}^+sF{1_)IlL1>fQI@m5ma@+ao_D{nUpStV`=zOEroAaE={|uv`9AEo1@t(1+}Gx3H*qGl1i}PiL)!S +f!-Tr`@)Bs$g)~C(YNEmm(jPwDz~`NfBNyRgGE}5qs?$A(_%_*yyTxyC@lQT6&G8Lg*4VWq@-`SxApVLj?WL%B(9fnVLz?J_hdb5PMvr2HRA_F>F1^Gg6mea4ZzXDUgC!MNpJ7yDYbCoa_mPy%44y4YJK@i!L_E)WHiBoe%??)jPeDu89K(n?S;*O~S!;OB;M> +kh#KUC4U?6FPyUhR6|Bkj}Mt}Nf^j-$qq=QaY;L0YDH*hT{gOR=?&2~*_e5sY7#@W_JzZN{iulIvbTH +G&s5NKD|4IvqC(3za9OJ5AXlf+Ku=+-?JXH?gc&wy00|xPtPKnNDYlt5)kL8HDoS%ojVdrKxy*2E3b- +<)LtSBnEEY}XVQSif@1)U7tCAfj4&_2^Vl^5shb<~4?m+1!=Q4TPmS*Kb*{!MDroS3z)^KQ%=uXHVop +`%R^@PPQ%?0Z5j{ap#TbZm%+Jm%PZ-eGqA(U359!9@l^XoBK68MJBXjt2)eM16X2Wzl{V<_guR^Sl;wf|&}_nlcpo5u^!>xEu=uB_UDeheZuZ +aFek!Dgi6;nW|H?iS8Q#Gp;=WL(sDh9{`c4`Zn2Q`n_9MX2zyBNhL@g@nMru9g2ZAy4Es;UD*S9N2sG +(-(Cj(K^CfIKs3~)B?uzZv^iAjI!B-h=DhDxT=L{NgxVn2Lequn?lv7EQ*6}ZiJb<`2L8Nt%PR#7`zi +nouvqOWw}Z1c1t{Q>?eO@5Ep?@6%0K90I{sZ+!bXCKjIu&qS+|SD=A +o+UAi#ckumP_&ZDTtff_1wT_DS`m%2s*^hA-7cOF_z8s2EADm847^N-)XTm-0|4AzO7UwlWKuuol;+iF&ZObI$8!;3ZHVP#I&dbb9#w@U%8iKv;7P=JDpL$T-T +z>(4pxfVOF7UhN}(H;2-?}t&@K+U)A2HVZM>|#Uz;If@5ceu^~Tx{2>U5IOZ=fyDTuEo*>H&y*jC5DF +`2=~O+ZcbU6SJNC3Tb`Uu2-OxS*_&bw%C!M1Y^Ny_?yFHMr^GBVZG)+9Hf;_&+t{IyLOxdtFpyI++mV +VdjnHg@M{*kKfC6k(1-lFz=75PG3dm2%az>*xB5n1nhtbejYl#OL#}l&&nT@o!2zlBq98~kF7gP2p83 ++x6-ex)^hK_`ATkREQ$JwTOpdIS;{DouzXnXbEsfZ7j-IfJ;0Dh;RdI2F}gEr?_OQ=Pm_`MC~`6#uAs +tclSBeOSB(?&bB*|CHiifOw}ogA@M>X!5|?5nO#F``1n3`~AQ1F$i|L9=qK^E?p5mSJk0Fx7U5yGalv +vu=xOVeBvzuG2DDs9KT3wkv^iH#!56JY=KA@ST0>x2zM%j^NZL`a-0%sZEImA6P?=v=HJjk#??z88%1 +0F#jo*6MTE#V%dQBP=)WMYoKby+%pRkzN4R8|{yttN!=sg>op8o8a%zXLJbFkhUZV{QQv~@oE&0v1 +B7MI+6f<={g}I0Fn5U&IgoODA1+`qjb6sg-37-d{=xp#7RKn4H&gu^321-agsiYPCd=SmmCtw1QC@UL +w%LRkFb?^*cZOC^2Cx?^OzyAhHBst%4~4f-GhT_JyYEq!$KG&6?Go7tVd&pxiDJ!ZJP!wD)!LES1LRJ&W`kW+{iO8n@}45;p|f4hbj1?ZSkTuh +ZwX0w{KaIl04`nZD}*}C!S)a(U+q*298O8iJo5Nyo?2AyrEt8r^h`!%yuj%5(j!?TR-SgB-Us +3|r&;seQkxH9k7gnNK8jGudF6(ZJEnJH7mbfj}?;l)o@Z_v%)n(L!7j;nm%iW)$YO)WZFHrvXq;^j6-?09z|TUVF{sg?7K+{c +zUXqqK@#;sU=sJl(7d1__Ot%(#Hf(`#K70I-1(*Jn +k8W4d^LeL2GLK0f%2J3Bf-@m2L`sS?hJK{XTD${2isPRKGDAL45S&-&Yk>$wE4(sPZUR}&B-2A&wq=Z +?!LTm>U&RX +MWFiX4i$J>w;BLq3PM+1HUf3tiG7`!+rBqAoH#F9Hj;+G$NFBF9JwHL-Z|d$qw$O%e#$IfrL}RoR->%3%#kXwRJ6SG9MMYS!1|`Nk!I+ymh^Zwrn`A6^AbR9cmWB|ix| +`$*e*X5`^kL)dWU4{RKYRT{TY90!JuS-8*X!*|7E{DYQGz0q39N`mYg{;7G|W#OLM9hUm-FU +bf<;5!Ce2qqj0VJX|L4s8CcPi_4%+98@kvF2i|Q%dlP``AxL#>0{fLo(?`8-1Gp4!-UhfR+U>L0pWig +nNFnun?ypBr8E$#d(8#;&-NWnG&`cP#CXHzVteg`iRqla +kSoKpnbhj63`-b9itlHT4?&&4kydGCEvaIVW8~fhLAARc3+hy|t)_A+k5SHv)EIhyqcPcRN!xu1&w37_lzieyONxGr> ++yfS#ag|(Y^hF3?NlC5v#7df0+SWWgJe6s&0_Zk8wLEM>i5Z30d@+$X*1<9DmC_QpSa6P{PVZzR4sAr +Y%?9S>X#=^IE!t8&lXnbDYWx9g3CA#+Dm` +zUAUkhek-^IBiilW4+PrrD5A{!yr%lqzlS3XDXK>PEr-JC+BZ^jwD9DALk`pSF*9lcl>Jl|n$^$byDY +;!s`#?L}yJg_+;54WLY-pjGuqUNz#5*1cX;hWteGDUjI|<_9QalWS5VKpkfwE#<@?ejR2}pZ2)oN}J( +nhpS<5*`^DHPQ|;pDqO8y8)Y&dbi@iYIoEy+cF=qfH4fuVFrBUhpA&cjvftw;9@9L(g|}+Dc7(Q#vFG +zPh)}7GX|!YRglZr#E?=;t@}PSt?=Tp8c{NXt!dR0#rbF?F3s79k8ip*(kObPfjyt-Ie1>N@D!3phN0 +*DaJC(nkG*MlooP81;s)5_nbwJEDS?O~&C<$;Fed +N=NpP+A#FiH2@_kruKu9Oo(bPNeWt1`SbefT>f?ut-W^U0|*)GJ;_*uD(vL>PU_%izTjKv(^t}-=u4C0Fi3y5VCREGGW*&nKg_Q1gwsKEp&C1}#zlGei{X9bBdI6RT`-jZaWRI;I7mKrC~@Fj)EV5~vYFK7x3HYI +5C-cs(L6r3E>nE3o838vaYXpexYO7LvL5@sx&DDuFADVK$$r{2M!x1fDGrBKMj39pqNsf9}mIy_-d0? +EXH90y9IDMINuhq4+*a|F^3^Tfb--!2geft9HFBVY4fy0j1>`Sr?-;?Eu=|za +DpQf{F$gxCr28B;1;k38S2$JvI1}jP}5`$ClNWB{Lq1e0$`GRCS8FEzziVvBx=NTKD84In$Hmum}OOke6nI(u$s4k^v^ndQkRGu-~L~88*L=4JU9URRyW*gOa&TLTw_iO9Ww|dJK$ +`6!ZfQD_~j!?mTRmka!ctOhDEo`lhK8$pSAts{3gO}yScPxg3O58sJT^z)~Jb{^*yY8v&`oF0Jig9aO9U@S>CTO{JP|yI3accNRK7LX2bz&8?GT0_MiY85 +c_Elm=bs5ILQtUd!~qgk^(#63X(2Nf|_m#=FMGn$CS~H29t`^&6pl%hLTQ4;H^n<6}ikFPf1+?PD$Y= +acDv>C5ScCueXicUG`ur{5o8lxR&xE%_-~sgd8{p4+8`zW|Go%n%gLTCuw1t5m?-$@Jw`^Q;jiXW?bt +G8iQfCKmnr*{f)^~dEtd&Iz4<#!f;JhFP!gH-rOUlNi&6Afv(Y_S_gv1RHUealtP}UQiJwc<1R3uo^+a!%9);*gk)2jlf8G$TLgYR5xfAV1x9yYf-G +4u(pltId-asoY*Zfe3$Wtcb9-V&Jvi7;+9%vt`-D;~_7d`V8v5;ivhPnqk1U=Mbb!x=$|mDrq7jU +E)y3ibHzILt!v_9N!{vj$^_HlntJ*lSJ!dqEpbqHqShUkcX^qb%EqSjasV@exrS!MpTOHJOx#PmvXB~lAWOBr0bJNCJNh}sQP)gi4s~R+4*SR?y+XekhGoVm)OUnZj;Z!JLy +*sJFIEO7F9vD&0LWZAH~C_f&aozaB>luV2NgW#G2FORl_g4tkpJ!AB0-!pa~zAq=~?i6RbZ#7>Up-S& +O;6v$^RQayKZFq!9Q{gk!;uCLQTK9L;Wz6N}e-7z1*&N#Q(bkR=E+hbcziMaVwP6;um@u3~t&k8GS=Z +<8pVgA#fUol9^D<_aS=&!XQxA<+}6wnpd|44(jON~Z$JO2Wo|6F539=g8XQ1T%U`VuOHQ^CLaW{9!`VN9>T@M?& +aYzPS)4o+z7372x4LgLHIMfg4!l8#=|+Y4H+(=HqpX*5r5umMBor7{qjpKIQyYY0p`J+aSxPMVZo77n^TEyO4ajkbVi*9W}2n`%=uzW!%?0zSJbfb}$XiWhG}%$a6N5(wJXXSq<>7%|2N(SFB +F})ss5{H`F5`rdlFV*k){?mh^AK>-oj~&)O6Fl+!ls6mtArgV)+U;?iZ&!9=#oSrl$?Y}?zovEInZjb +KneYsXj~IoC6VSOM9Dt|~eHZBN0)4M-nMM@? +GEDzi)cfgamDo8-p&(7j6#UreLTWoTmi$;)ZY(+$TfSi9f4Iv)|9P(2LwXK;@ph{n#1bjxaxYm;&OfBRMC35Jo9Mw@oPQXIy%K6Qh_?wy3~02ZG)toYl!Mv5HBqtX@cxv;=mthLw+>@Dn +aUH%-c5|1Ko$h4A~kWe^t1mT24?LMsZS4eD>{TJo@&v_2+cS1BHWeCe^|)$R``>W;DtD^p=g)4`E|8m}H6p +QKC$-y(;Yu-dmoffj6*ovh-970r5~~!$4M&3JV%tgb4C+|X9|q7Y%|uBHdf5^3h7Wi(l(utP%O9^|!Tmt)!_wV0rxBx;s0B&U +R8(R9twOiz3}PY<3#-n`e3m<&ir2l&$f1?i^LVo1NOjwYqXRmo*Yj{VYDriQPfDXJx>OSZMeGOR--!fkdK%H=hZc|G?!K0tLVb(e|O<+S_y>(=N+5Z=n}vYH3S*B1{7&`xZ=OHw>+4L+qxagEUT}UeFAI#PE0$QP ++!Hi4b1$EaLBiztG8nO@P;99r87Wc?J|`l2xUWnx2vGmPty@z=wW$c8jh!zwix(Hzhoddnz>un +dqI_u)o1CfmX<7o3@T^#DoNofDc+?5+a*#wm)}HySS@~K1xEEgp-|FLC~Yn?rXU@-e&ZK{@TJ5K#w9u +e(F|0$;iZkIY|!DIa>f`i%DScvXh0gp-4hz89w@XTs7yH;0)JYBP{5G)XR1X2#BsI4OnF~C(Oj3J4v* +p~m_vUSQ~^PwA`gjQA_PTx^3*`Hl8ECbg~D{U9&;9tOt0D5MWWL+B#}vt0g<4qgOHZiLB!EmCc>txKj +N~ZK_CkR0?ARA^pcj-gWm+ew3~{Cc0%jq<(((C@x$5zL*T +UE@;zy2}mSCin#(yX>_I(ko9I#aBF$mp0HY!<+gr0OlJ5pj29=jroowVYT_;xv8n6Wk4Yzf(kV}vl1a +&!+=~(2+erP*BSc0zgOk*h(DKuB!7_WCwX9v1E<@C@_{u3P_f#Q)MmJ^+vGa+ZYI2S`W4!l2z +X1>qeBD^$zO9~E6ok;!;fN!m#wA4w=Hkts6<{Tebjr)?6IRnUFjbL?%#C+SeL>8kXWtFwj +jlc)F%Sb#6f1kgB|yOCErly;U>vSN`F1$|B1Eyz%k3NO5=fLA6-eF`{@5U8%xtC4pz4s+!AT&kC(u{N +h?jL-FZf>bDbc>?H#5Zb-qkm3&2L+;jfBqR$rY+!0*B#5*I@hZ1Oix9-t$=Rj>x(|4|IpxVc!sjilaB +J%xJ{UC`&q)(1alHgIB=x{;$SU}IT`E`Jo7^O*>fxeO>gTr5Af +zM2iZBP1Qd3laoPz6Yf=w +%OCZ@32It9W;to{+8{B=ME(OrTYKJ-p!T0Vr5x%?=Z!y9?fm+Y{SZvmbHr?c7)h|`Df~omW?!aG{WT< +kO9%(0MVK%20iHXw*p7behgS8nb9RofzhDK(!WoqqS1>?PJgguESYZo!8y)yh8;x!o&hK;dEp&75dme +ZaKQN%U|wd>f8y!ano{TLDy-Fp1QGcMjt*1Oi);O~HqOPJaG5>}3|O%GuXDZ0~QTX&?Z#WH*K^=h%95 +lj<5U7?WKoyHD9wGBD1#30Igy$uxOq&kW47ClppeFQix7`2Kv!*78|>0&x8a=K@@zaS3Bfg?*A-ErEi +GSFKkgR$*NTnZ=Hlxbdoyc^b=r|=PKVKVM|>>L}+f_a>yRxA27mcSIbrkO^*RknUGs^sO6xnm*yOcKMFfO>|Q9CV|t +-M`P*%%7Q+>0aHp@bJ@$X`nZsqc94p%hXb*oE8D~PL+!VY}!eoqQk&Ydj-dEwH4Ny7(btY8tlv!B663 +B}F@cLG)eX$CZjNYtBz!DFWo5~f+3cPwyw9OSy#Dcpi+42)l@4m|Bfg?|eURDJNT${44Lc>nX5ENFlq_d0e +EXt`U{5o&jpaKhbi_9`EvRTshpIEoSI~9umiRQqukr+dC{#WKzQmYCo_BI;m<#1nVJplVO?Itk(2$8P8qDkm!4`k^;NGwbT#-m0!^;Sk>t3OO4$nDHU1gLJUhrOl%%0 +_4EDNb3-rAz*XvUmYdBahJO99ewmnYA1ff$2#3ars6MPtC=H%O(~{Ss+NstkWmnoVEh6Wz$$+->ox`Qg!s +b@Gz5vMs7P%i3QCYx{`J!b!OD*hs~hgXO&2Bh%G-7*tKaC +EOxbKfu}yW*JA@JJUD$bglig@o5ZEFWeK#kP8#Q5;s}R5aFnfl#}?7y+Q7A@U3-W~Rs?G&c(0yo9ktD +JYLbppagq>m8n2y!{|EEyuhjjn2vC){`r4gMt{|#&Hq3n5aXtNaHZv40$0tQNm;>Evr8J#B;5`YX;L} +MNfL4YBNvM`z1PJ(|Li!l6Xo|1en>4A+@mXb5zpLYf +dY6Ma?U%c-b<>SPe2^D?U*7D%K~)R5_XRD;_HQ+$coYyv4m-XEA8r>=@O1&;{4u?3CfvX-lQyu5zerFl_Fq+ +cdyKn^;~P1UOGdJA)$KH(DGKJfj8PKko9+{NK4`FT?vzmWJo4Cd&(sYy@xb9)?s56olZ`BE_ST66H*^ +>ClLuw?{R_mo&FY_%i9A%uroXoHzh6I1$~He$L5%AMR;s)g5VG+cYa_-4EZeY_l$ +{HUds~?-L26LeE=#mB9hYQ08yu>Bm8?;{0VFt(kVNC@oeL?lR;_`YD2ciuS+KM_Z0l)4!Yh=HgeU?3v +u>Bdlri^LG);5G?#*RtC&Srduq2yvEgu6W%3ihshV2M{VHSK&l_^&V6i9UBomRx+@*zgmsE6zjj`$;Fq?KcmbO&TNDMP +)(R`bSjS669D(Dv#8mtK~rxA$3AdMcprRrsc`WRmLvKHyVo82#Ul~fCRp$vGWIX&j&5dcXm(TdbPm?( +&XvzzA9rV4ffDqKoqf}51ACl`bweaYo58Ax!e|G)#oZo2-yq7=Aq4TO|w`J5_Uab9LC-DmUOHea)mLm +jkxJ_X=1k0s*6I29-u-MkS80{qHeI4@!6nbJ!Iy4=5!dI3F@g>&#F3`w0A&gI5$5`2wNC +@I}30({x|IXaP5NFYUnD1Lg=^0vggGp^Hs2_EZ(Yq2k$1vi^F@OUL14nEOUS872rhcWFD77#=}D0yIv +4!azgE#r47T}J@Jsn1%ERxZJ+LE{dV2s@_~MfU4C}ig$rSd@UI+J-jj2d +>p?QeSF>lCYr&=f)0*56%HMni-k;)TZ^ruo9-RrZL)MKl-UQbVsffEm}F+#zew8=X+!(}uusN1dZbo!ogMsC5eIJPFD3P>FHqW-HprL(v|zB*p6#6WS@VA +uv5@!-A+c^}wYthMxKCUR{(5Ob>tgx3>j(bc=!T#&yH_I(SOngiW#O@BP$itN;ZX;kbUS;^FXzES0{j +4tCuZ%ccm%8Jt46DVCLv^G2=9U++Yp%4032Q5*2ciU)x+n`-^jRU(~Cr_2I{2axRJ;`pK!Q!vGY0!E0 +R$|=+P^+*ouWpWW<{IDA3`Opn>F;J7hny#ilW4V+Vb>)eCc*#mF94`OB@YH>QE2xO3S4dz=L31y?Dh{qC)u6sN8?A~oXJF>&= +Tt6ltHv4*N_HNLks{lhM*XdldMu#iu=TJMK{RsLFH2W=;88UFTO@S2nuIh`zB(Ovn<)-c6Xj>gpy97E +n7gHcr>ZDIm%>{4mlQ0m`}L?lSlHd)^gDE8m6aMElR$il2hUI~s&Z^ +S8sui>;TfMx_-K26MK?HQ#ATr##;bBqW$AvzBV>djQowF0!<)U44=h_yWEp|4uzT`ChnNe)HpTd>23b +C@QCk$9HzayI+8dP>;Va@6aWAK2mtS)wniVd+x8j*005B&001=r003}la4%nWWo~3|axZdaadl;LbaO9oV +Pk7yXJvCQV`yP=WMye +v^27bQlvpr3DjS|kGAY=8h5d)lQf)peDBR@y4~v!4M&fYIZY?YXr7H|I9()v(Jykloi45RObaV_QVT_ +iDVU_A%KVT@iOAR;<%mU{bLvD(FOm7c&#cUWEt!)16%6Fh*}GgE7@?}FwakT=Mmv1kgR#dC0MpXgQ#` +jUJQuWWj)?EC5;kBR8eFya)Jtw?@cHu}fVi3-QLGfDA=gpLj_orSCnbr|-pXz5jqSOcKM^6C3HzOvQt +hm)=p%ulCvRxk_`T7sepsXA)(YDMmrBb_&XoQI#O|pvHRVE+JdE%pbn%<9sIN>R%O-?sT|iD?? +b%lD?BU~lO;dJYN{_7BLd~+?Dw(5rDs$G3NjN%$nA^WPH4a3wmI#dv;E(R!6HA0qKSmx?#_ip;K2pc$Hd^)JNPs%*P85q4WiFL|dlXaapTA5RgmXCabTD^@`&86Mc) +*G@h@X?vV?taf$|>kYsgG62OpUh4u}Y17J2vldq_Vhm+}K^%UrjC#(4=%V@kvDW+wdt|rNP8mF{er^` +h)iik4iv&X^BYc5|rE&*8?SXrDg?CjioxBTnXpe;E7@HI&mxv>Nt=zt+SzP+j#b& +l!*jhbdYgX94qwrxYW2?O%N6OpH*DY4z7zce_J8>oM|wX&SS(17;6>Vw{if~aMvIDnmT1}6R?~;m6(2 +f(15ir?1QY-O00;o@p|(cjlC36d5&!@%GyniK0001RX>c!Jc4cm4Z*nhkWpQ<7b98eraA9L>VP|D?FJ +ow7a%5$6FKA_Aa%FdLa&KZ~axQRry<2T_+r|<8u3vGLKZu-?tmM>f>eS6pvSf22${Iz^q_Mv +Fxm|AXk4}pWPp^xzN{Za7s5H7Vv6^j|z%FH78cZUzIFp(gRa-N!(*Y=8t@<#zd;9MFof=<#R3FASH{+|jk3V58G>x~gpHND&Rhob>q$+h@ZNNA +POwVu5-eSl2baFYl`$*hhOzy7EZ*SGbyBjrD*W;VJ$=UnM@r}BEe{=or_Iw17Gsdf!l(|pIjf&?WnHA +6^TwW)s712M!ycP_mv0Ca!12abkF%m0{h*)jD%Z6!@FIZk|X%+gDO6Dprs)1UU3490Mw_{yUY3)0J(? +_F$dU1k9I)6xEf?I6ANai4YkrqWcP^X2hXz6r}y~oc_PL78sKOCPZ_5K!5p88SeSFgV@l{`B*n3qMSM +lMsV%3=oTVLb|=Gd#RC)ipo#3lZ%VENcBCb5&GRc%pgDNhZk`&B|;=o+QiGrC!|^Wqja0(H#{R#^y(e +w5Y0enr_H8#UfAs169L|^F^%}h8#uvYzC96Nkty4)zYMtTpTSjK4~2u>rMLB%u2JS@HMGhW)DbpjfIo +gXuGxC=S{~8*-LTa6%)e6G|c5zS!KQ;lqiN|JLROq$?d!0k3YWn+wjLjWTby47Sg%*^m?7-aj~|;ljk +p9(1Ocikwl#pErH==|B5feOh>~d|4l1?{&{N=o-oU&1zd^<9=1G_j>!8Fr?4CJ4n5=*Zzjp152_VNr3 +q{euSP0@o_1MBhTP_a5?Qq_kYMI>?8+-rJekSX_&1-<*#HU$6TvYf71Bls&y(E1%yG;na0LyX0xCXbA +$ArNS;t>~JRTl@`P&6$SzBaAWr>ZDZ*y`iwqS-TVd?eSAhY>pqN<@?nJAfasK<$p5X4DjS-Rl(qmK#x +u*)Na{X$nY1cml?*a0&UF%$oVd^J=~Ba=$cs=O1PuZ>GG%V!0diT2n5n78G=4$GYh8g!l!lbU6}4lmsnI#Ok%Hl3kC|*D0Vk}MdSxo-IqUdx{z$D9T# +1b@HtueMe2Hr>RSn9Q{L4mVxaOmqcXwVo#zX}YocSQ{ZaJfynyW7=vb$=P=}Asi)i +y6gR#>dx-|WyukE_oVRH^hM-d)#tL4$lN3%Cvs`q+STi2(uqbA$N3fXMeX4p+_S1 +nDBHLmkc8?IsB=Mhlz@Aa95pFIx|ed0FiK2K2Cf|Hr4B(zNr>(tL#cfm$qaWPQ(lyrP6t5*`e122X$w +U$X0-LpA)F4{AnkcDnj7)znNy($2a-#lZGFlvPm?dAu=vQ^_t+>jy0=W}W|$eI9~bMg_2_+=sq;&CyheS%Ha6M?E3?`GDBZmmmis5}cc#t&3B7s_w^R!8dO{M +_|-6$he1wBJ^fvndcx1k_6W#L7fPFxdh+!LQZ_ew}5rYzz*qOL{QL#bRtD~=IyQJkel$c>z&4z|rDNg0i8-gl)6k}A}KbP+i9irN*Ic|d51$QBtq*}aPIbz0{>5(l?;9>6yp +IxnNz^&!bA%}wcVPgxM$7Hz@~f>7iL$>#*5L^XvQe{FB0Bt2k6)l3S){5n82hAkujxdaLMHFvMGI!PU +DcF=H}JfWr{WzA;#K}22Yq#PD==fNODuo%j9>h3BbgxH)*v1&y&O<-p81;0Q>^nW$Y=-5L%s_YCaB*P +N<-^iVP~U{%>jsvz +5nv28@zFF4N0NM4p=9M%Q;TSTZGjg2Tr8)voKn4n0h&=0dF9STVk!y05Tt1&?1(bh5sr>>$dt~YVz^& +LVRUt?4QYDE>;p%mDM`NcguPHpZ0M&luCmZbf)JIfv@{QsnSNjuSt_YPN{dtw@}PD?PJqIzFi>ZU-vf +mXd}M4vS6Cwi^rHi=g+Yw}Nwu##V<8;Ieup4DxR_jxFYkXDU#M5=_>0j8SMP47;ggwLGCiNlgV--=o* +1{}>iv~GnENIE$^6(YxjvV_fAA~(gFm|kcei6Shy3V;UlTn03rRTz9LUfwx&G#{>83if9Wg~P&Ebi!= +sXzlz&bO7Ld;2ifGkGHy`)j5EmHcAYYBHr^Nf$C*hG3dxw;n#&fbo1?q5%C@5WbWB;1Ryvn=lOzw!#a +#*i@&Vrf5<(|51WFGK#2)lLo${yDjQ59Z&VpWd8*xW5`t=~d`o2bb^OOwM+fbe!_w;2=tovpP}N>r}@ +6%L9Viv6-v;duXM)zwc3MbkFIhvwqZF)hyz4dY?Hpx_t0TT_LM)uMwqxWeFm|RK5N|!wGxx)v|-uqo`Ts9kWmVpXDY7PWPFZ4hkFuJMj@QFdyOQ;hsgvsbwa1*+ld!MKkIN~ +26q9C8S#Y3ZfmI!Tt0m%AolW`J)QfV+%EUB|YteDW)Gq>i@V1e|r>v-sAu1&yYh>%6_x458}qrAwU#QniN@*M?*E7d_|s1k$&gyWm{>DPKUCrAFBERGki*8M+b;gL +SWoMsA45qxPfgVs$i7N9d(=wmRZNkEZnuY33meLjrc_C}_k6G7IjWND=Pps6FGFuTa4^aB{IGyeo*RB +{eg-nJ1OY6tYMY^E)Y5!R;M(%1I--DD(;NBDXv^Q`MViWdj$Bl +<7cEWnVB%1slfD{@ztcwv9F~ZL6DQ+n^Dd>MD +&i_8hR*mnX0{Qhz)NO(4)GRLAr0l5sbxCV7`Hmo@zWOuREBf*={Fsmb7Abv|&B!%23~rQ|*+p%`ysuA +8aaW`XV?97E?{BEui*Z0Vl+7wS0b)OWWzEu)@=E)*y(5)0x?yVq|_2&;7|eUk};A%!!6>(;w6G7@bc{ +qP&s0A4MtCw-1N?;g-JYOONcw7!F3B)k9rBo7>MD?(lP3i_w?+;L#JtBRsppc<;*vZM;cw>_Om@%OyE +gSCY?aiOmC0woyuk|%sJ0EZL2F_pvFG&_JJ1mvy?*~~*%NY=SB_oXgN;yC5bRlJ`D-ZWC-NbXckx{Kf +%>CihNfI-$P~XGsTA_evwTi#RHi>y4J0j9L41W5A;_a?K +fkWL0k5XOF}yoM@NBl&BZt=WO5InhyrEV2<yiUEB0RbvinG +Wi141GJ%sQU9(jCpQ!C?DQ(@v+`;-4pbD+F@SzuJKHE5Wb_{ +-_NFyX0Pv|zJ3}$e@Q$rf1f`MPhN&0_4yN&`%>OLN$soM=O16Glf669%eBmRn}Kf^;Q2lQwrk|)PhX* +jj%M0wMX?N^D)jtLxG)CQ?*gR8HKOOdH{H42e+^ID`2fN(lZSOQuW@%FG+y`SOr>Z=VNgPd;gPO%OY&~l=y ++4A7U$bObVH$$}c%_~gI=eKcy1RqJ&`~D7ob4#9LS^OKw|2xDj4cUe@I^_hNq#Gu +?Cl%kaM^9IW_ta-@iN>u)7jbD4^`6~{13G|K>a$2*&{RFws|JQ-cu<1J{`NoRABP;q8-MUWc&rbL3zM1+4b$4 +=vfU%wAaAWu*Q@T@qa2%JaTvQUhO;NxBaxum;VJ&O9 +KQH000080Pmr;MwhRe4!%|Z0Mobt05AXm0B~t=FJE?LZe(wAFLGsZb!BsOb1!gVV{2h&WpgiMXkl_>W +ppoUX>(?BWpOTWd6m6guO+vYrg?vUMF7G8HY%;&{923bLN_3*?HjWvVh$uGake +;qx#w9-!Pnw=P0?_TFSL$d`+2z3V08qmTaff7dTR`^V3Jd;R+JPe1$Zm!Dm~{PpiX{lBmO#cw})`sn) +V&(GKI-o5&lS8ravzCL~X&GYr@{q>u-|Ie$}uV3!Jzx(coH?O{a`Qh!m>+9FAp5J`9zTUt2`01yjpTB +wa;ngnr56^#je*O0Q=XclJZ?6x3qt5;N-#&kM|Mko7pZ|Z=zIyxS{r>aa_ix|%$FBJL{o8lv^RM4Mzx +?q0&Gn}rt?@tJ>g7A?`u@j#t3Q9Ze)j3lud>$MRs7ALe|&xN`t|h%zkPpw@%;Yz-Cv%+IZyKG+czKHz +53G+`!Rp^{^$RBe{x;FdHL>Nuiw9V{V(rceRuuh+AaKWeRzBQ{>Kl0e*5Nr{@qotU;XLb%XdH0Yu~*bqo{?prcyZm==zj^iTk9_pQn{W2x(CQD*@4kE +gQy>20Z~t)p`uY8C>GhA#Z=T=nr}_O4e|r7u>s|QQufBeM^ZxmI`TqKz&))y}uRZlE8uI1ckn2}(clG +w}-(SzK_V?WTFVFAZ?@zA!arxS|EdJzqb(fByD|*DrPr`?uGB|NN`}_PalPb$#;NKVJX+lP|vbBqzI*%K_3}>)WPSW*Q5i78f{SUQTtCH7Re|j4}FYelYjGV9>7r@>6Bkf4Y8FesTZt^Zj|L9}leA7yB`GC;rE>Z}yL9(k@t6jK7 +QeceDN7j9=^ze{RKPox6Yap;`3kr;j +7Po_uGH|;*y5>K``tT@7vpffI5m9o%U^%?&tHE2KR(+fdW&hrl= +t|2b)gLdmu`OKU#Z_kAm%(N3FX|dEYN@&ZHOGsq&GMr0S#OX2qCH~1=<$dbt;BfIM%g8>+$Em&ALYfa +tiGtZOYUFgi&9p5QEQDCe_Skn_>qW^2&2Rg6wa#7n>Rcud(z)!GJo;U4pHKUb`l3Aco%UrH+MjV*TsoKi^u0AMyQ0VLv|@ +2ue&tM_VLxFV_RTo;Mt`d1VIS=l#lCTgUGHvwDFKWM@TA_1UGJdepyVE?J!BLg6dx +2H6dx2H6dx2H+%PB>6k}qQphWaj@7m+W%-$DD1|@@%LCK_KQZgwCrVE%ZDGK)(4dz=gqv!6!-H!)n^) +a7z7lFau$})Fj3OL)^w7m&Yy&4p*!h~Mj2 +;dg7>$zA1snA5-ebL`Gy9yx^;R;*$0tc~9X#&!2#!*=aq+r_D^VT(rDlc<5wJ$3^NbnHXT`m}$q0ok= +Bbp-YyceD0qw33-u?CxbnefJk;_S$f6bjCIZ6_bMntjDg`IiDK#VVlEk6_}9MHMkTl_nz(7?!jFJw$n +vpkHh}4OUmH0&cCpy)JuO+?_Nuuu)_OeD=+>FBfRl@wPn2xqfKKjE{z)k)1YlvrP!W7dxdZzJ2-3g@r +0G2Ng5t>mHS_#vJQd_rc=SZU0`oN(Oqxbc5>L%J?s~AeB*tv810g+v2NLKg=e;S* +j4tWox#0!j}*-O)ylzd8};eJV(ow0gEX~LN3oOn!r8E_x3C^F8|c;D6pArTu$@I4cjJNefB&&dR%~d+ +hSqIE_oZ>^Tm~0<+D>)}OzPbeY|j#UgjQmtF79BxbB|kPnbs0r3@7XSh3UI8Xl1ubdYZ8e`fGo)JBZ4 +$=KBF@xjixu&iaFKV^wPmF{XE0H|p4Zx#8nLv62He4CBVS3pG8md%8Wq-j#G(aKm=i`TZF9JB&R;fhV +!YpC3?s05K-QE<~gEyx32)|D_oy2aoiFy+or&96am=c=vu7#Nr`D(a`^0V3fusq +0VeR0uGmM?CZ4(!cN!p9E2CI+T(HX5>B@JWst>fTq;Fr|FPg#H~3owr102KSeqp<*2M}`HMu^)Q271L +jX5-hxxg}27tUi=b_>%LHu1-SZXEWnioxUv9ar}l-CETffWv|>2G=)O>5QevKQ8~7!-#RCU&Unt4qRd +Ls_x&!xeUnps>vS{E^4}yV#8#)+*QSIM#{E~rR(l9v27XDyV{72Dfy)Li8@OZ%*cVFTsWtG}z+(fC4LmmR*uY~0kL|V(J098fg3AUj8@O!Xvf-&U +AldNL8c=LNu>r*f6dO=%cxnw#t>LM)8)vcolKlrIJ0-zN!&7Tuq=AtJMj9AtV5EVO21Xhf!Km#ECBR6 +FGj6f{l7Wfb7fOPahLhI7NCP7cj5ILPz(@ll4UFLP54`!oV!tnx$TMy+7&ov&ymxuK=tgpTmd*Xs{Vy +-u2Vxu=lesb&jqqqMFqpF4rfp7fBHFQMfnTziYODD%jhQ;DGr*f6dO>)sO<}nw9 +dM@qmbQRAlZOq1Cn?R`$9<|*_fmqD0ZOOfno=W_=5W~xCEEva_mlSzhwVGNg&yQBp&O&P!dRXYzE8Yz +EBb?BlHSx&4y;2PJ`I2a+8~b|Be-WXEiEpxA+82Z|j +icA(gSVh4%@r=#Egdg7OKAlZQ=F4VqI5=eF+*)dxkD0a+N$82?c?G8pd80lc7gONV(ahr@ASm|H|hkj +ou2}U{?>0qRTkq$;W7{R3<1B?tXGQh|HBjfhh=k`nXAA?VVOLCc9C<#VjJqAp~z>y!WWv(j&j0`X`z{ +mh2KFoNr{FO&cyqn&Y^+b`LFP!g;Rure@P1B?tXG +Qh|HBLj>KFoJ`%FO&cy1B?tXGR7IVx&4y;2PMJE04oEtHNeOKBLj>KFhaDlFWd`^3^0P@v@etZBO}hZ +P5hDpRt8uZU}a#o1{fJ&WPp(YMg|xeU}S(1XpViM1Q;1$WZdz^#4j0OWq=iesC}U%7#Uy$Z+>4W2}TA +O8DM09kpV_@9bD|=agQ5*Nr06AD*;vldlFy-UTokF4|uKt1vDgdU{i+iIpNtb9@ERhb)nt`UxHsUa6g +9DQNtKuB)~|3kpLq^e*40`z(|0R03!iL0*pjE+DMgoik7zr?f)!!FNfRO+r0Y +(Chz-3u4eo26p04o7j0(%l*B)|x6?!HhGj06}7FcM${f^T0a0Y>8H9~OQ|fRz9%0agNg5@002NPv+5B +LPMNj06}7FcM%Sz(|0RxZ{h3UlL#?zzRXhfSlVGN`etNIM}U0Xg-LZ2a)g4sSGd@U?jju-0{%DFA1;` +U?so`G~~V%E|p8;(zy&S!6ms&E|dTx2}bh7g*#%{;|AZhFO&o;i9Ja$l3*mkNP>|BBMC+lj3gLIFp^* +-!AKq+5#oH;3sw@WBv?u8NrI6CBMC+lj3gLIFamqHCnF`mNP>|BBiZ|@7r!LIN`jRHD~UaUFWEDgl3* +mkNP>|BBMC+lj3gLIFp^*-<8kW6FG;YHU?ssyVowM)2QjfJhm5Ljy->;0SFiLmE1!5(ub$p(I#I>`8)=1S1JXCK#DuWP*_iM +&O9{WpD{D$>oe&!7rI$WrCFnRwnjjf{_VECK#DuWP*_iMkW}6h}#!RfRPDC=J88*fWOBLs(4>0305Zd +1U6$^R7!%82}ULunP6mskqJg77@1&Xf{}Url2Y(XCRmwZWrCH7J(*yH7<*qR2}ULunP6mskqJg77@1& +Xf{}Url2Y(XCRl+&+!sn>PbL_dU}S=k2}a=W_Jwf?q%?dTg5L~U}b@o1y&aJ1QvB)C<#W$OAMI8f +u}$4@CP3L(8FI~1ZH)tPz{mn43ydr3pmaoixyaq60=^=29>y>62M=?NW{A@n4J688#k5k^D +=L0hQw$acdZbrSnu{rF8tI=Fj;VV3S3zsl55UNQfh?&;bNsLGEPKhg?Nx|e)S +k#M!r$D`45Nw5cbYYb)eC>)y1=F-!x$A8(Zq*F=MQR@Itujrlcl#v;KdP`~Hu9SV%iVBk8J9Bhaap^#04(2U{9MVJ>t@fwB$u3cVTj^x2aPA3cHR<1YY2B8g} +X;V7zEYVL>Zc%!2hOENz8QA<98AxjU)y!-MbJ)!h#)&cmD^^};AtX#Wbt3c1%p^jtB54L|N8=BSv#>c +Z}-7Uoh9|GV)vpBe;EP-TS&FU;|RJ6geIA)YU+(H9F(!6B@$?-#CYC3q>gE*Bv{SvStM&qZF(C!o=t? +}qbukgWu4lN{|JH;9S=o}#ckUkvEAOnZ=Dh4rX7j?^3EaR|Aq*;P2Z!eUfdC<~!!kWsJjM&)7lh+E^9 +cOu$q60Z3)0d8))voZBl$q-kpX@M@hh(am};{v-?$VL}?wVH5yn1gZlnx|u~GLr~8Yd?9i-6HZhi4kkPEBlaGDaPX+G@{0sOc^#y5CO$ie)7M9Thy;+6{SO$ ++Erx3&yc~|l$7xZH-_q^C~^0p6{IhfEkoMlccjY`G5RA*EHg`jqjT^23JTwy)1nQCGI*Q^jX)po}LJ5I)~Gi0P|U`Gr7dLiFZ`VqhYEW8%7r2zm6@g{wUAi&8i>?REN8Mi%2o~oH# +v;8O$t~lVtKG1TK2(`NU?WOo4&(O$ckz?DPR_LXNiy;JgKlt5o@>7M+#1m$ElLKa2k<_~2P76*%EfVi +cm=x@bgj91`0%CjqR0x5KWQX-`zoY`hf;U?TgD-AV5g`eGuNtcV1NMYq@ZFCmmJ5K9GJPzk-Fqt}@9FSdR-adGdu%ejIJt=;xBT(1ra^Q;#;PTqE%&W42OO?# +qbk3=xbGxy#IW$e*VRL2dbvOu{O7ZNzug11}8(f94~=;#Kq4@97FN|k(UfhwuTS9v&b8PEr=z#jJ2T) +`3BxF{1mRp{#rCe3=cUs4D#E7`vm$Jex17qh`BvA@8#DRDeC=1=Nu?0Zcory{B5oVx2pU!sNqKB|DE3 +renFEH82j#c7SDxO5`aYCxm0S4g +#Vvdfit_iEZ{Mr0nH!uC&y15kMy51~@)*yj3hZPNMj^1!n3xB{^2&nC{Nu|bMG+>Z4)^`d(vsnhT%no +&hlgoYD=um?#JEn-pBSp~_YKPvIf1!Z)x`qeP(JNa%@(ofYn>)N2&Nzt4OuwExzb0Ia~ST~ExF2G($f +wp>l8XDa-s_oQ^?v+@yVYDm6K;fQ+oKYq6tS~*LtKID^8VLGG*H`j-p`r>0_JWeDE$;r^eo4K5kD(D_ +JToC=A!fed`3tmD;|>*vtigp|y0XYAD-^}WdR6P=?%(Z~v}vG1L&Iu7W-4MfcjEUePA_6YtFDlBlirl2Yja=4CtXeRo7aD_Wp7o-ldu`0#%ZSc3l6zKkhNUUBboPSPq51BZG6 +s(X<+Z%9Zl~(0dDk1*$yDmeJf5yJ54w@5S@73Skb#8-U2!5KTqx%3h2#K5N}+72XT7NCUN5-bVweP9Q +u0JM9VZF%!UY*X5mRK{DhiJa$`wHZJ{W5wtBI;G>fL@xZOW^7T;mJWAGI3s*o_2d?Jxlg)Ux^jCsy}@ +s<4s@zH}7w@XA%)D=DYSVpLJ>)FEktUoZ{b9(s0x5hNHOJVAxi!~5eDAX_Mk)pVt)cl#xXZGaOUYUk- +(BPT~lah3Bl_{0x`0c2wvEv-1gu$YLyNIlZ$2fyfE+wnh*Be5c3$b#;Pe_gI`{a9Vr5RH!=4+>zS3vS +BgT8i?>dbeNFA(09zX+bGfLGlHgP+9gX#=XWNW3VyUC*w`>NY`-B03JSR+{)r&z1uITS}alr1&Km+-N +KK71;fm0w%pG^-^e9R2N|Uwgc&Bfl3uIz_>&9({ux8oT`y=k22W++IA3040;!RYN=|!Z-ox6xH{K7zW$lV=w2)HqH0LnQQ|@|F_LJK$VWKkhO)3?`0FISH8rkV!0T(WZ_D(9wU+}Zc|biOrU)k^g?fzhx3QpL^3+2i&VSyF4i|(4gL +F~u2>^Th6MMrR%2T(O{zw^MF&SRNYW4a|2!<%Y413E2`=J8SFTeB;gnMo5)0zJ9I{l_19$XroI51 +c7h=EsQxD!SKF)vwc`=xl1yOLm760T?`ORSJ&rK{~>a!R2@Pl0|LaMwjULJLq03TJ;N^Zc%1HRvsk>& +qtR{Su@=*17fK@I;gKrjDpnsSsSJxB-iRs56GAjxC>E}M@}?EtYniTZnm%>jZaAx0J%sR>`R2| +pwpo>tdB^hSk)&{gMlzN +}VU^;!X%17ors&t)C4S*n%a*V22-)bAWwm&7Bg0_}~oPYh6OD$x^tX46qStv>?my+g@wA0HW +OS}>HQsSiDel@z+t4hb7UgcSImx>-EEy6xbx3&;j4|!S)z8fe=gjD407jbu~x1B`yS|I@%5l*1@g=@xfJI-umZ%Hh{>Np{yZW=%Q +~SvmR&=jLh5?J*(ln;LoaXxh9U*CAWP$-T#nJWq*!o8Dt4s~jfaJM(4Ro(nx&uXAH^77>EXvN&VH9*L +6%M65oQ=}FQfy}d1}M6>kW%f&!*rjp>%}lt$D_gM6(`sM8&4w(MPrDw;N4g#@t)4=1H=X8+1F9gyK38x>63`4-wDMm(B(@P0AMmw>{Tv~6i|Lw%0_$7G%vWE``%4j<@kO1N +6e7|3uFJ>T&gy4MzlILG-S1b|DKZpKz`-z9wUlrTtVpo}v0wP`Bix&rrB9yf1q4l)0o^^n +tKD?xCa4Ns)Dz1sKrcY?w+8Akq)#bH}mhUP(q`ryLo6dT1xMYk@djJ~8qz=5Ui3kxrUYbn(U=#}T{g* +^ge)y%w`b<}%s8Q!uX8kOfy6&WeQxI+iN6uw!4s +}wKz#Do*k4v8_e1s*$2N4YHQdf#42AS#_yJVVG!cUQ2nN5RW@E=36TtwJFosNu>`$I;iH}n+diMCm-ff&1In<)d54OOc|z3?T(jKv{7TY2q=p&S8IZ8pSYAQJ({zu|^8o +U}5fL+t5cEOob+JPty=Yn&W}4@B20V|kd6l8IoIfc*&*^3!}8&Zlt}5A3sMx$DI*A%)W5ZJ=#gC>a^k +`|R!s)irjv+ZdY)7PFdQTH+mN!>vPO-u1$lEVHomWjzub;EZF4j{kBF!i)8C(v4^$Ovqzdm&q?@G^WY +e_9Fs1;{et-Gw`@ZX4K^;@j)(BEmb`gf)lb3^G+;e%}vPEOCATKU68{T7Bpfc)-AY(;ZhMGi76bKH&PsWUdoghRfJOo{-HZ1sT +aN^&xsT)@xyFCbc@4-A=lPxa$KNJM!iT5atXZ){1-Xwqemnw^VB6eT@=l~nL%}->Sm4M2dj)s(?untB +iZ&)>B2Ll8EV4Mb+;G3goN!yTClSHva4Cbhi{rU#25v8(md{h6~Eyt6f19%Vn)wX*}~~xbgxApnv)HJ +ONB$IMMfOd+*u*goz=j~No2hkKh{BXx2>9a>36;6aY8N-ZbAmK$#kpQf%lxc`z&`n1KHAQ&PIM|N}8X +3V68cEA-m)@9<-Cj>BkS(;OYsRtCnstnd3%r7Cw*h2xkauzau#1^iKbxd#&NLf_jjYSF@Rp46(R{Bm% +2=lvjqiez<(#Z1f`_t2hyNd+|%yBY5cxA?>T=bPLa1*l19SzJgn-yPiHCc6#oDBZ!L{3RE2FcIw@JNt +nN76>MnfE=HybXN@*&YhzDZWf`qbYkaX%rC_>!<@s*W*`n8VYf@+=QIcqL3r5t<@972p?usaT|idq +mgm(rsL0N1U@GYAh_Rg_cX_^Q|ash>ec0(4a71|lJ~>JqarlCCzl{_MrRa5F%>t|i@t=N8?~9k@$Kot*DSPutMFHnNpf-cdi1kgQ>jgL<1t8hQxCmgXL&+83W?Ke#yJ;-LuF{MOtWjB9F3kDrkZ +|$=kMjvL$J7^+RIg#5-zvu$%fY8?g#i165^NXGs3^CTd0_R(FM0834p4z>SDl6K5*+i?i|*Alaq0wj2_XK3eK7JHCb;1>n!G)hV!EB)1DJ@Er3fVb^7c#6y|#Hg +3IJ~8xg@A@dKe=@r!owus>C7m1?%g>@iiZSX+YXt^Pb1(UN7@+?7J;Xr^kpLtb+IE5kyECE>vfwyCvV +e4C|FGVOK&arX6m(j_$RZJVcmK70a5XWB1*qO4xqmEQF%8kevd}T-3wp6{{f8V4k<1IIF39JuGTsBve +(0lho5a#L#Px8kw^A*Cml7$FZ>dwP;-28xit= +RSEia5`COu*!+7Ehx}M;yn6dP65kOdb3JPE0zf)wYy;L2P;U6I@;O6sow_H*~M%EbK{a34;S2(a`LdJ +kA%MuqR!xUMSRt<_JYZX5Hi@kfyfBi3=OL*Fvt~QmTw@`chIHIvo@4z{Fg4(QuVe6Jf@8_tKP}3g;>T +%I&A3do6HfS8CTWU`iC2q%EBdSlF)oX9{8ha+LRK(qwU~5?x_;<3Zi4#J8@!G^D%@YPRN)9kRace5%8 +PdBXnUk&gVy;9q8yr0hN4(7hJ6h16+)Y4*k}VQ6r%^+#Z@@)93jd4cET43m3Gu9yJTl=xjQd7R}$Px} +byNB}jH|BM^Zfjnwhg=TOHr`47;H`_5h$c-I=W!&=^-D_DY_%ts%yaqNdcNkn&>kggPa4#=7*}^(l&p +62bXuDN^KkokBeo33h^>wtEvo39}FO##0s-y*$FjdsUCIj~L#Hp^G_DCu@;e#`EuT=_9ACD7Nz*4MU!rI=X*qrL}1PTQ2^%&jjHJrydPCDp_1?o78Xcu+~4^0zurCA$%UzNhd^qU*C`|kKc +-RqLZ!EC`ER)Z+SL}Uwqf_ZldY9yI#!VuHspgTA(%63iYu9JUj>R!8N01j;d$dFKMhcO8LK+-N-sdmJ>Ss1Udq02Nf5N@@zGAA-~h_en|C`vM&H&y1v+aTnBrar-9xq%H$shH@E`RM3Z5RvIWQC%;PCvGL_Qm=+V +?=T3fIYdto2&SgWiZ0en5$fu&V&N)o8)i631>L-$%As%ZJnywgdAn$w*MVlh6$L2-?CkAa>r05IROj9 +WYb^33CCZzpi9ZIZZX!N +7Uvf2=nO8qvA}HK*pd&@SrAz8Io<(t6y@KCn!07rEE4239Psb_DAy_4jGOGfE}hMn7t@@O3F6e_6*%C +(JYUqen%%*nT5h!qiwfH$a|_n#2_6Slpqcuaij%vnJZ3K +=$J1i=F6RPCQe6a8+hrm)aBGexCIi3XZ<~7z`@AgZoo5-8iT&0I=x>9@BJW-&h4|Bo>r&=YKg`J8#BQ +q+vbv9kyD_CuwEqGYphbsq1gb|XFk1a=Pq&IIu%4yO~Be-2lJv#6>{!T~tTI_oyqz&y~cgvT;3ljI$E +p28{mDg4?v(^hqT1@s5AEQQU?eGL0-D^RTQ;4ZTb(q;}NaM@BH&yOSF8?9&@mi*?uQZ2REFq?wy-vLg +URgGwnw3$Xs*2Vvi~3R6`lag32eE;Ss=zjGQZ3H>x$|U5`?md6m>_lL1`$cvqiSY(G?C{T;+DQJjmny +ylE7*Ka9v=L$I->pm+WtGrxc5_ekyA(tXY-rR-3$zYo_P!QG?>lJUWvI_7GB`-TTRUF^_YSKUje3!tU +{vf)kRkdqb85wdb(eUEZGL?NAk9y#-(J#NGYqUKwYn+B|a>!yl$cF%qtza_(;VGBya+Q^Xgc$`hb^@a +Q@JtQYkq%BEcBi3Z!Tf9_7e7O;CtUHY{gEsYxfw^6QA1{zjmD*N4D_!3X}J%WRDVU;4qJ5?JJx{Y!(5 +P_;kVP|ne%TOqD7z0?Bqkrh=UYltv&g&_z!lotNIR_Wo4MpIgt4$RTYP8*6p14d9!<|`yFx`1M}x~?85GGmHR +tN77u{=7duWallT(g6!PDzPo=4Nc0~mvL|m0>Bw8r|s@><=u;*mQEi8bhtLurM)Iv!I;Mpngt +PUdy7PCCnP9yj~`gw_e2mav9^Ip+p70A-60+ztF=?&zD68c*NyLpZ(?e-H#vs%*z1&^!)n +mzw@4mx4hWkdiCbR^SkH$JKnJH&GU!nuRWLk`ybwY|Mva!Q&q?guh!CygJc~D9Ez$-&t53n7mgr+CA1tD7A=L)B~@3kQAwK1Oc8v;Iaic4Fns31q<@!oi!*3NP>)Cka7rmBOoz?H9nX{QEwxIcs59=2T +@lr_<=q<$j}9ZP?#*n=?^jnK_DCK>J3DrfebOE5!hB3_oly&cs5w4gVboiu?LP%0Qg|Y12IRiQZ*1B2 +<(DDps_nYSVV#hVL*w8Mb*F`qN=0_?ut9D86C>H)$-vV*a&||hVUF-(-F`1!()fF!MHY?PvDJPc6K#z8V0h|hR&= +tH%$Rn2#`P&7S#&QVHzFrY;yy|IuxtV?A>{0PT8o^m@ewztQzT0JHwxNYn%{Kb&@t6@oXDXq2y4ou0c +koGfSds@8P(nh(j%4T64HXR%lv4tTEuwl{KgWwytF +!`(olP^FsX+w-m>+m+{A!NIR7z*hk&M;o(kjNeJY@o>r7L(S56Y~=>Qjo##O +#m*93_S?h;PK%Isv7h};7JGjpQ1hPdV?U4enavSz7K-Mq2bL$a|)BRfm;a@Ye5#Q)gzPkGfX#Gs^PZW +dtM-(4T$rOASIw!10FD%il{v$f+!>Kq&xC}mM3mcJ{w$cAg0*kHb)%S5zj_*cSHAMDmVB5Q&4KH%ka@ +vx`1rs3Rz0ekU8RWM#P<4>jbU5#A4Tr?SL)`*B1Q2AS~{lsDW=5cyJvZRwo}9&0fNoI3mpjmie~sU=8 +tXG$#ThvjmnccO&4mHaf!xZ~lu`0tGn4&TQz?e1$qb(;v4;>cn+lB1t>0 +3U0kZ!%)by)e`-ody@=ceCPzQgl&TQ$&?)FQpm$?|N}=um$ym_@`HCv@f>64C%~6byv(lg97a^fq{eHAgMaKm*z