pax_global_header00006660000000000000000000000064126143761220014516gustar00rootroot0000000000000052 comment=5bde8a08fb0ef6346e2e67c8203b84011a124315 aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/000077500000000000000000000000001261437612200215665ustar00rootroot00000000000000aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/.coveragerc000066400000000000000000000003621261437612200237100ustar00rootroot00000000000000[run] omit = aiomeasures/_version.py [report] exclude_lines = pragma: no cover def __repr__ if self.debug: if settings.DEBUG raise AssertionError raise NotImplementedError if 0: if __name__ == .__main__.: aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/.gitattributes000066400000000000000000000000451261437612200244600ustar00rootroot00000000000000aiomeasures/_version.py export-subst aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/.gitignore000066400000000000000000000014171261437612200235610ustar00rootroot00000000000000# Created by https://www.gitignore.io/api/python ### Python ### # Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class # C extensions *.so # Distribution / packaging .Python env/ build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ *.egg-info/ .installed.cfg *.egg # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .coverage .coverage.* .cache nosetests.xml coverage.xml *,cover # Translations *.mo *.pot # Django stuff: *.log # Sphinx documentation docs/_build/ # PyBuilder target/ .env aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/.gitlab-ci.yml000066400000000000000000000012771261437612200242310ustar00rootroot00000000000000before_script: - python -m pip install -e . - python -m pip install -r requirements-test.txt python3.3 tests: script: - py.test --cov aiomeasures --cov-report term-missing tests/ tags: - python3.3 python3.4 tests: script: - py.test --cov aiomeasures --cov-report term-missing tests/ tags: - python3.4 python3.5 tests: script: - py.test --cov aiomeasures --cov-report term-missing tests/ tags: - python3.5 publish to pypi: type: deploy script: - python -m pip install twine wheel - python setup.py sdist bdist_wheel - twine upload -u $PYPI_USER -p $PYPI_PASSWORD dist/* tags: - python3.4 only: - /^v[\d\.]+.*$/ allow_failure: trueaiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/LICENSE000066400000000000000000000020241261437612200225710ustar00rootroot00000000000000Copyright © 2015, Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/MANIFEST.in000066400000000000000000000000661261437612200233260ustar00rootroot00000000000000include versioneer.py include aiomeasures/_version.py aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/README.rst000066400000000000000000000007461261437612200232640ustar00rootroot00000000000000AIO Measures ============ This library allows you to send metrics to your Datadog or Statsd server. This works on Python >= 3.3 and relies on asyncio. Installation:: python -m pip install aiomeasures Usage:: from aiomeasures import Datadog client = Datadog('udp://127.0.0.1:6789') client.incr('foo') client.decr('bar', tags={'one': 'two'}) with client.timer('baz'): # long process pass The client will send metrics to agent as possible.aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/aiomeasures/000077500000000000000000000000001261437612200241035ustar00rootroot00000000000000aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/aiomeasures/__init__.py000066400000000000000000000005251261437612200262160ustar00rootroot00000000000000""" AIO Measures ~~~~~~~~~~~~ """ from ._version import get_versions from .checks import * from .clients import * from .events import * from .metrics import * __all__ = (checks.__all__ + clients.__all__ + events.__all__ + metrics.__all__) __version__ = get_versions()['version'] del get_versions aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/aiomeasures/_version.py000066400000000000000000000366741261437612200263210ustar00rootroot00000000000000 # This file helps to compute a version number in source trees obtained from # git-archive tarball (such as those provided by githubs download-from-tag # feature). Distribution tarballs (built by setup.py sdist) and build # directories (produced by setup.py build) will contain a much shorter file # that just contains the computed version number. # This file is released into the public domain. Generated by # versioneer-0.15 (https://github.com/warner/python-versioneer) import errno import os import re import subprocess import sys def get_keywords(): # these strings will be replaced by git during git-archive. # setup.py/versioneer.py will grep for the variable names, so they must # each be defined on a line of their own. _version.py will just call # get_keywords(). git_refnames = " (HEAD -> master, tag: v0.5.14)" git_full = "5bde8a08fb0ef6346e2e67c8203b84011a124315" keywords = {"refnames": git_refnames, "full": git_full} return keywords class VersioneerConfig: pass def get_config(): # these strings are filled in when 'setup.py versioneer' creates # _version.py cfg = VersioneerConfig() cfg.VCS = "git" cfg.style = "pep440" cfg.tag_prefix = "v" cfg.parentdir_prefix = "None" cfg.versionfile_source = "/_version.py" cfg.verbose = False return cfg class NotThisMethod(Exception): pass LONG_VERSION_PY = {} HANDLERS = {} def register_vcs_handler(vcs, method): # decorator def decorate(f): if vcs not in HANDLERS: HANDLERS[vcs] = {} HANDLERS[vcs][method] = f return f return decorate def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False): assert isinstance(commands, list) p = None for c in commands: try: dispcmd = str([c] + args) # remember shell=False, so use git.cmd on windows, not just git p = subprocess.Popen([c] + args, cwd=cwd, stdout=subprocess.PIPE, stderr=(subprocess.PIPE if hide_stderr else None)) break except EnvironmentError: e = sys.exc_info()[1] if e.errno == errno.ENOENT: continue if verbose: print("unable to run %s" % dispcmd) print(e) return None else: if verbose: print("unable to find command, tried %s" % (commands,)) return None stdout = p.communicate()[0].strip() if sys.version_info[0] >= 3: stdout = stdout.decode() if p.returncode != 0: if verbose: print("unable to run %s (error)" % dispcmd) return None return stdout def versions_from_parentdir(parentdir_prefix, root, verbose): # Source tarballs conventionally unpack into a directory that includes # both the project name and a version string. dirname = os.path.basename(root) if not dirname.startswith(parentdir_prefix): if verbose: print("guessing rootdir is '%s', but '%s' doesn't start with " "prefix '%s'" % (root, dirname, parentdir_prefix)) raise NotThisMethod("rootdir doesn't start with parentdir_prefix") return {"version": dirname[len(parentdir_prefix):], "full-revisionid": None, "dirty": False, "error": None} @register_vcs_handler("git", "get_keywords") def git_get_keywords(versionfile_abs): # the code embedded in _version.py can just fetch the value of these # keywords. When used from setup.py, we don't want to import _version.py, # so we do it with a regexp instead. This function is not used from # _version.py. keywords = {} try: f = open(versionfile_abs, "r") for line in f.readlines(): if line.strip().startswith("git_refnames ="): mo = re.search(r'=\s*"(.*)"', line) if mo: keywords["refnames"] = mo.group(1) if line.strip().startswith("git_full ="): mo = re.search(r'=\s*"(.*)"', line) if mo: keywords["full"] = mo.group(1) f.close() except EnvironmentError: pass return keywords @register_vcs_handler("git", "keywords") def git_versions_from_keywords(keywords, tag_prefix, verbose): if not keywords: raise NotThisMethod("no keywords at all, weird") refnames = keywords["refnames"].strip() if refnames.startswith("$Format"): if verbose: print("keywords are unexpanded, not using") raise NotThisMethod("unexpanded keywords, not a git-archive tarball") refs = set([r.strip() for r in refnames.strip("()").split(",")]) # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of # just "foo-1.0". If we see a "tag: " prefix, prefer those. TAG = "tag: " tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)]) if not tags: # Either we're using git < 1.8.3, or there really are no tags. We use # a heuristic: assume all version tags have a digit. The old git %d # expansion behaves like git log --decorate=short and strips out the # refs/heads/ and refs/tags/ prefixes that would let us distinguish # between branches and tags. By ignoring refnames without digits, we # filter out many common branch names like "release" and # "stabilization", as well as "HEAD" and "master". tags = set([r for r in refs if re.search(r'\d', r)]) if verbose: print("discarding '%s', no digits" % ",".join(refs-tags)) if verbose: print("likely tags: %s" % ",".join(sorted(tags))) for ref in sorted(tags): # sorting will prefer e.g. "2.0" over "2.0rc1" if ref.startswith(tag_prefix): r = ref[len(tag_prefix):] if verbose: print("picking %s" % r) return {"version": r, "full-revisionid": keywords["full"].strip(), "dirty": False, "error": None } # no suitable tags, so version is "0+unknown", but full hex is still there if verbose: print("no suitable tags, using unknown + full revision id") return {"version": "0+unknown", "full-revisionid": keywords["full"].strip(), "dirty": False, "error": "no suitable tags"} @register_vcs_handler("git", "pieces_from_vcs") def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): # this runs 'git' from the root of the source tree. This only gets called # if the git-archive 'subst' keywords were *not* expanded, and # _version.py hasn't already been rewritten with a short version string, # meaning we're inside a checked out source tree. if not os.path.exists(os.path.join(root, ".git")): if verbose: print("no .git in %s" % root) raise NotThisMethod("no .git directory") GITS = ["git"] if sys.platform == "win32": GITS = ["git.cmd", "git.exe"] # if there is a tag, this yields TAG-NUM-gHEX[-dirty] # if there are no tags, this yields HEX[-dirty] (no NUM) describe_out = run_command(GITS, ["describe", "--tags", "--dirty", "--always", "--long"], cwd=root) # --long was added in git-1.5.5 if describe_out is None: raise NotThisMethod("'git describe' failed") describe_out = describe_out.strip() full_out = run_command(GITS, ["rev-parse", "HEAD"], cwd=root) if full_out is None: raise NotThisMethod("'git rev-parse' failed") full_out = full_out.strip() pieces = {} pieces["long"] = full_out pieces["short"] = full_out[:7] # maybe improved later pieces["error"] = None # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] # TAG might have hyphens. git_describe = describe_out # look for -dirty suffix dirty = git_describe.endswith("-dirty") pieces["dirty"] = dirty if dirty: git_describe = git_describe[:git_describe.rindex("-dirty")] # now we have TAG-NUM-gHEX or HEX if "-" in git_describe: # TAG-NUM-gHEX mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) if not mo: # unparseable. Maybe git-describe is misbehaving? pieces["error"] = ("unable to parse git-describe output: '%s'" % describe_out) return pieces # tag full_tag = mo.group(1) if not full_tag.startswith(tag_prefix): if verbose: fmt = "tag '%s' doesn't start with prefix '%s'" print(fmt % (full_tag, tag_prefix)) pieces["error"] = ("tag '%s' doesn't start with prefix '%s'" % (full_tag, tag_prefix)) return pieces pieces["closest-tag"] = full_tag[len(tag_prefix):] # distance: number of commits since tag pieces["distance"] = int(mo.group(2)) # commit: short hex revision ID pieces["short"] = mo.group(3) else: # HEX: no tags pieces["closest-tag"] = None count_out = run_command(GITS, ["rev-list", "HEAD", "--count"], cwd=root) pieces["distance"] = int(count_out) # total number of commits return pieces def plus_or_dot(pieces): if "+" in pieces.get("closest-tag", ""): return "." return "+" def render_pep440(pieces): # now build up version string, with post-release "local version # identifier". Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you # get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty # exceptions: # 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"] or pieces["dirty"]: rendered += plus_or_dot(pieces) rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) if pieces["dirty"]: rendered += ".dirty" else: # exception #1 rendered = "0+untagged.%d.g%s" % (pieces["distance"], pieces["short"]) if pieces["dirty"]: rendered += ".dirty" return rendered def render_pep440_pre(pieces): # TAG[.post.devDISTANCE] . No -dirty # exceptions: # 1: no tags. 0.post.devDISTANCE if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"]: rendered += ".post.dev%d" % pieces["distance"] else: # exception #1 rendered = "0.post.dev%d" % pieces["distance"] return rendered def render_pep440_post(pieces): # TAG[.postDISTANCE[.dev0]+gHEX] . The ".dev0" means dirty. Note that # .dev0 sorts backwards (a dirty tree will appear "older" than the # corresponding clean one), but you shouldn't be releasing software with # -dirty anyways. # exceptions: # 1: no tags. 0.postDISTANCE[.dev0] if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"] or pieces["dirty"]: rendered += ".post%d" % pieces["distance"] if pieces["dirty"]: rendered += ".dev0" rendered += plus_or_dot(pieces) rendered += "g%s" % pieces["short"] else: # exception #1 rendered = "0.post%d" % pieces["distance"] if pieces["dirty"]: rendered += ".dev0" rendered += "+g%s" % pieces["short"] return rendered def render_pep440_old(pieces): # TAG[.postDISTANCE[.dev0]] . The ".dev0" means dirty. # exceptions: # 1: no tags. 0.postDISTANCE[.dev0] if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"] or pieces["dirty"]: rendered += ".post%d" % pieces["distance"] if pieces["dirty"]: rendered += ".dev0" else: # exception #1 rendered = "0.post%d" % pieces["distance"] if pieces["dirty"]: rendered += ".dev0" return rendered def render_git_describe(pieces): # TAG[-DISTANCE-gHEX][-dirty], like 'git describe --tags --dirty # --always' # exceptions: # 1: no tags. HEX[-dirty] (note: no 'g' prefix) if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"]: rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) else: # exception #1 rendered = pieces["short"] if pieces["dirty"]: rendered += "-dirty" return rendered def render_git_describe_long(pieces): # TAG-DISTANCE-gHEX[-dirty], like 'git describe --tags --dirty # --always -long'. The distance/hash is unconditional. # exceptions: # 1: no tags. HEX[-dirty] (note: no 'g' prefix) if pieces["closest-tag"]: rendered = pieces["closest-tag"] rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) else: # exception #1 rendered = pieces["short"] if pieces["dirty"]: rendered += "-dirty" return rendered def render(pieces, style): if pieces["error"]: return {"version": "unknown", "full-revisionid": pieces.get("long"), "dirty": None, "error": pieces["error"]} if not style or style == "default": style = "pep440" # the default if style == "pep440": rendered = render_pep440(pieces) elif style == "pep440-pre": rendered = render_pep440_pre(pieces) elif style == "pep440-post": rendered = render_pep440_post(pieces) elif style == "pep440-old": rendered = render_pep440_old(pieces) elif style == "git-describe": rendered = render_git_describe(pieces) elif style == "git-describe-long": rendered = render_git_describe_long(pieces) else: raise ValueError("unknown style '%s'" % style) return {"version": rendered, "full-revisionid": pieces["long"], "dirty": pieces["dirty"], "error": None} def get_versions(): # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have # __file__, we can work backwards from there to the root. Some # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which # case we can only use expanded keywords. cfg = get_config() verbose = cfg.verbose try: return git_versions_from_keywords(get_keywords(), cfg.tag_prefix, verbose) except NotThisMethod: pass try: root = os.path.realpath(__file__) # versionfile_source is the relative path from the top of the source # tree (where the .git directory might live) to this file. Invert # this to find the root from __file__. for i in cfg.versionfile_source.split('/'): root = os.path.dirname(root) except NameError: return {"version": "0+unknown", "full-revisionid": None, "dirty": None, "error": "unable to find root of source tree"} try: pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose) return render(pieces, cfg.style) except NotThisMethod: pass try: if cfg.parentdir_prefix: return versions_from_parentdir(cfg.parentdir_prefix, root, verbose) except NotThisMethod: pass return {"version": "0+unknown", "full-revisionid": None, "dirty": None, "error": "unable to compute version"} aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/aiomeasures/checks.py000066400000000000000000000013501261437612200257140ustar00rootroot00000000000000__all__ = ['Check'] class Check: __slots__ = ('name', 'status', 'timestamp', 'hostname', 'tags', 'message') def __init__(self, name, status, timestamp=None, hostname=None, tags=None, message=None): self.name = name self.status = status self.timestamp = timestamp self.hostname = hostname self.tags = tags self.message = message def __repr__(self): args = ['%s=%s' for attr in ()] attrs = ('name', 'status', 'tags') for attr in attrs: value = getattr(self, attr, None) if value is not None: args.append('%s=%r' % (attr, value)) return '<%s(%s)>' % (self.__class__.__name__, ', '.join(args)) aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/aiomeasures/clients/000077500000000000000000000000001261437612200255445ustar00rootroot00000000000000aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/aiomeasures/clients/__init__.py000066400000000000000000000001311261437612200276500ustar00rootroot00000000000000from .datadog import Datadog from .statsd import StatsD __all__ = ['Datadog', 'StatsD'] aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/aiomeasures/clients/bases.py000066400000000000000000000060041261437612200272130ustar00rootroot00000000000000import asyncio from abc import ABCMeta, abstractmethod from aiomeasures.checks import Check from aiomeasures.events import Event from aiomeasures.metrics import CountingMetric, GaugeMetric from aiomeasures.metrics import HistogramMetric, SetMetric, TimingMetric from time import perf_counter class Client(metaclass=ABCMeta): def incr(self, name, value=None, rate=None, tags=None): value = abs(value or 1) metric = CountingMetric(name, value, rate=rate, tags=tags) return self.register(metric) def decr(self, name, value=None, rate=None, tags=None): value = -abs(value or 1) metric = CountingMetric(name, value, rate=rate, tags=tags) return self.register(metric) def counter(self, name, value, rate=None, tags=None): metric = CountingMetric(name, value, rate=rate, tags=tags) return self.register(metric) def timing(self, name, value=None, rate=None, tags=None): metric = TimingMetric(name, value, rate=rate, tags=tags) return self.register(metric) def timer(self, name, rate=None, tags=None): return Timer(client=self, name=name, rate=rate, tags=tags) def gauge(self, name, value, rate=None, delta=False): metric = GaugeMetric(name, value, rate=rate, delta=delta) return self.register(metric) def histogram(self, name, value, rate=None, delta=False): metric = HistogramMetric(name, value, rate=rate, delta=delta) return self.register(metric) def set(self, name, value, rate=None, tags=None): metric = SetMetric(name, value, rate=rate, tags=tags) return self.register(metric) def event(self, title, text, **kwargs): event = Event(title, text, **kwargs) return self.register(event) def check(self, name, status, **kwargs): check = Check(name, status, **kwargs) return self.register(check) @abstractmethod def format(self, metric, prefix=None): raise NotImplementedError() @asyncio.coroutine @abstractmethod def send(self): """Sends key/value pairs via UDP or TCP. """ raise NotImplementedError() @abstractmethod def register(self, metric): raise NotImplementedError() @abstractmethod def close(self): raise NotImplementedError() class Timer: def __init__(self, client, name, rate=None, tags=None): self.client = client self.name = name self.rate = rate self.tags = tags def __call__(self, func): def wrapper(*args, **kwargs): try: self.start() return func(*args, **kwargs) finally: self.stop() return wrapper def __enter__(self): self.start() def __exit__(self, type, value, tb): self.stop() def start(self): self._started = perf_counter() def stop(self): value = int((perf_counter() - self._started) * 1000) self.client.timing(self.name, value, rate=self.rate, tags=self.tags) aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/aiomeasures/clients/datadog/000077500000000000000000000000001261437612200271475ustar00rootroot00000000000000aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/aiomeasures/clients/datadog/__init__.py000066400000000000000000000000261261437612200312560ustar00rootroot00000000000000from .client import * aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/aiomeasures/clients/datadog/client.py000066400000000000000000000027601261437612200310040ustar00rootroot00000000000000import asyncio import logging from . import formatting from aiomeasures.clients.bases import Client from aiomeasures.collectors import Collector from aiomeasures.reporters import StatsDReporter from random import random class Datadog(Client): def __init__(self, addr, *, prefix=None, tags=None, loop=None): """Sends statistics to the stats daemon over UDP Parameters: addr (str): the address in the form udp://host:port loop (EventLoop): the event loop prefix (str): prefix for all keys tags (dict): default tags for everything """ self.loop = loop or asyncio.get_event_loop() self.log = logging.getLogger(__name__) self.prefix = prefix self.tags = tags self.collector = Collector([], 5000) self.reporter = StatsDReporter(addr, loop=self.loop) def register(self, metric): self.collector.append(metric) asyncio.Task(self.send(), loop=self.loop) # self.loop.async(self.send()) return metric def format(self, obj): return formatting.format(obj, self.prefix, self.tags) @asyncio.coroutine def send(self): """Sends key/value pairs to Datadog agent. """ yield from self.reporter.connect() rate = random() formatter = self.format metrics = self.collector.flush(rate=rate, formatter=formatter) yield from self.reporter.send(metrics) def close(self): self.reporter.close() formatting.py000066400000000000000000000110701261437612200316130ustar00rootroot00000000000000aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/aiomeasures/clients/datadogfrom aiomeasures.checks import Check from aiomeasures.events import Event from aiomeasures.metrics import CountingMetric, GaugeMetric from aiomeasures.metrics import HistogramMetric, SetMetric, TimingMetric from collections.abc import Mapping from datetime import datetime, timedelta from decimal import Decimal try: from functools import singledispatch except: from singledispatch import singledispatch @singledispatch def format(obj, prefix=None, tags=None): raise ValueError('Cannot consume %r' % obj) @format.register(Check) def format_check(check, prefix=None, tags=None): response = '_sc|%s' % check.name if check.status in (0, 'ok', 'OK'): response += '|0' if check.status in (1, 'warn', 'warning', 'WARNING'): response += '|1' if check.status in (2, 'crit', 'critical', 'CRITICAL'): response += '|2' if check.status in (3, 'unknown', 'UNKNOWN'): response += '|3' if check.timestamp: response += '|d:%s' % format_timestamp(check.timestamp) if check.hostname: response += '|h:%s' % check.hostname if check.tags or tags: tags = format_tags(check.tags, tags) response += '|#%s' % ','.join(tags) if check.message: response += '|m:%s' % check.message return response @format.register(Event) def format_event(event, prefix=None, tags=None): a, b = len(event.title), len(event.text) response = '_e{%s,%s}%s|%s' % (a, b, event.title, event.text) if event.date_happened: response += '|d:%s' % format_timestamp(event.date_happened) if event.hostname: response += '|h:%s' % event.hostname if event.aggregation_key: response += '|k:%s' % event.aggregation_key if event.priority: response += '|p:%s' % event.priority if event.source_type_name: response += '|s:%s' % event.source_type_name if event.alert_type: response += '|t:%s' % event.alert_type if event.tags or tags: tags = format_tags(event.tags, tags) response += '|#%s' % ','.join(tags) return response @format.register(CountingMetric) def format_counting(metric, prefix=None, tags=None): name, value, suffix = format_metric(metric, prefix, tags) return '%s:%s|c%s' % (name, value, suffix) @format.register(HistogramMetric) def format_histogram(metric, prefix=None, tags=None): name, value, suffix = format_metric(metric, prefix, tags) return '%s:%s|h%s' % (name, value, suffix) @format.register(GaugeMetric) def format_gauge(metric, prefix=None, tags=None): name, value, suffix = format_metric(metric, prefix, tags) return '%s:%s|g%s' % (name, value, suffix) @format.register(SetMetric) def format_set(metric, prefix=None, tags=None): name, value, suffix = format_metric(metric, prefix, tags) return '%s:%s|s%s' % (name, value, suffix) @format.register(TimingMetric) def format_timing(metric, prefix=None, tags=None): name, value, suffix = format_metric(metric, prefix, tags) return '%s:%s|ms%s' % (name, value, suffix) def format_metric(metric, prefix=None, tags=None): name = format_name(metric.name, prefix) value = format_value(metric.value, metric.delta) suffix = '' if metric.rate is not None: suffix += '|%s' % format_rate(metric.rate) if metric.tags or tags: tags = format_tags(metric.tags, tags) suffix += '|#%s' % ','.join(tags) return name, value, suffix def format_rate(obj): if isinstance(obj, (float, int, Decimal)): return '@%s' % obj if isinstance(obj, timedelta): interval = float(obj.seconds) if obj.microseconds: interval += obj.microseconds / 1000000 if obj.days: interval += obj.days * 24 * 3600 data = '@%.3f' % interval data = data.rstrip('0') data = data.rstrip('.') return data def format_tags(obj, defaults=None): result = set() for src in (obj, defaults): if isinstance(src, Mapping): result.update(['%s:%s' % (k, v) for k, v in src.items()]) elif isinstance(src, list): result.update(src) elif isinstance(src, str): result.add(src) return sorted(result) def format_name(name, prefix=None): if prefix: return '%s.%s' % (prefix, name) return '%s' % name def format_value(value, delta=None): if delta and value > 0: return '+%s' % value return '%s' % value def format_timestamp(value): if isinstance(value, datetime): return int(value.timestamp()) if isinstance(value, float): return int(value) return value aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/aiomeasures/clients/statsd/000077500000000000000000000000001261437612200270465ustar00rootroot00000000000000aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/aiomeasures/clients/statsd/__init__.py000066400000000000000000000000261261437612200311550ustar00rootroot00000000000000from .client import * aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/aiomeasures/clients/statsd/client.py000066400000000000000000000027571261437612200307110ustar00rootroot00000000000000import asyncio import logging from . import formatting from aiomeasures.clients.bases import Client from aiomeasures.collectors import Collector from aiomeasures.reporters import StatsDReporter from random import random class StatsD(Client): def __init__(self, addr, *, prefix=None, tags=None, loop=None): """Sends statistics to the stats daemon over UDP Parameters: addr (str): the address in the form udp://host:port loop (EventLoop): the event loop prefix (str): prefix for all keys tags (dict): default tags for everything """ self.loop = loop or asyncio.get_event_loop() self.log = logging.getLogger(__name__) self.prefix = prefix self.tags = tags self.collector = Collector([], 5000) self.reporter = StatsDReporter(addr, loop=self.loop) def register(self, metric): self.collector.append(metric) asyncio.Task(self.send(), loop=self.loop) # self.loop.async(self.send()) return metric def format(self, obj): return formatting.format(obj, self.prefix, self.tags) @asyncio.coroutine def send(self): """Sends key/value pairs to StatsD Server. """ yield from self.reporter.connect() rate = random() formatter = self.format metrics = self.collector.flush(rate=rate, formatter=formatter) yield from self.reporter.send(metrics) def close(self): self.reporter.close() formatting.py000066400000000000000000000110701261437612200315120ustar00rootroot00000000000000aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/aiomeasures/clients/statsdfrom aiomeasures.checks import Check from aiomeasures.events import Event from aiomeasures.metrics import CountingMetric, GaugeMetric from aiomeasures.metrics import HistogramMetric, SetMetric, TimingMetric from collections.abc import Mapping from datetime import datetime, timedelta from decimal import Decimal try: from functools import singledispatch except: from singledispatch import singledispatch @singledispatch def format(obj, prefix=None, tags=None): raise ValueError('Cannot consume %r' % obj) @format.register(Check) def format_check(check, prefix=None, tags=None): response = '_sc|%s' % check.name if check.status in (0, 'ok', 'OK'): response += '|0' if check.status in (1, 'warn', 'warning', 'WARNING'): response += '|1' if check.status in (2, 'crit', 'critical', 'CRITICAL'): response += '|2' if check.status in (3, 'unknown', 'UNKNOWN'): response += '|3' if check.timestamp: response += '|d:%s' % format_timestamp(check.timestamp) if check.hostname: response += '|h:%s' % check.hostname if check.tags or tags: tags = format_tags(check.tags, tags) response += '|#%s' % ','.join(tags) if check.message: response += '|m:%s' % check.message return response @format.register(Event) def format_event(event, prefix=None, tags=None): a, b = len(event.title), len(event.text) response = '_e{%s,%s}%s|%s' % (a, b, event.title, event.text) if event.date_happened: response += '|d:%s' % format_timestamp(event.date_happened) if event.hostname: response += '|h:%s' % event.hostname if event.aggregation_key: response += '|k:%s' % event.aggregation_key if event.priority: response += '|p:%s' % event.priority if event.source_type_name: response += '|s:%s' % event.source_type_name if event.alert_type: response += '|t:%s' % event.alert_type if event.tags or tags: tags = format_tags(event.tags, tags) response += '|#%s' % ','.join(tags) return response @format.register(CountingMetric) def format_counting(metric, prefix=None, tags=None): name, value, suffix = format_metric(metric, prefix, tags) return '%s:%s|c%s' % (name, value, suffix) @format.register(HistogramMetric) def format_histogram(metric, prefix=None, tags=None): name, value, suffix = format_metric(metric, prefix, tags) return '%s:%s|h%s' % (name, value, suffix) @format.register(GaugeMetric) def format_gauge(metric, prefix=None, tags=None): name, value, suffix = format_metric(metric, prefix, tags) return '%s:%s|g%s' % (name, value, suffix) @format.register(SetMetric) def format_set(metric, prefix=None, tags=None): name, value, suffix = format_metric(metric, prefix, tags) return '%s:%s|s%s' % (name, value, suffix) @format.register(TimingMetric) def format_timing(metric, prefix=None, tags=None): name, value, suffix = format_metric(metric, prefix, tags) return '%s:%s|ms%s' % (name, value, suffix) def format_metric(metric, prefix=None, tags=None): name = format_name(metric.name, prefix) value = format_value(metric.value, metric.delta) suffix = '' if metric.rate is not None: suffix += '|%s' % format_rate(metric.rate) if metric.tags or tags: tags = format_tags(metric.tags, tags) suffix += '|#%s' % ','.join(tags) return name, value, suffix def format_rate(obj): if isinstance(obj, (float, int, Decimal)): return '@%s' % obj if isinstance(obj, timedelta): interval = float(obj.seconds) if obj.microseconds: interval += obj.microseconds / 1000000 if obj.days: interval += obj.days * 24 * 3600 data = '@%.3f' % interval data = data.rstrip('0') data = data.rstrip('.') return data def format_tags(obj, defaults=None): result = set() for src in (obj, defaults): if isinstance(src, Mapping): result.update(['%s:%s' % (k, v) for k, v in src.items()]) elif isinstance(src, list): result.update(src) elif isinstance(src, str): result.add(src) return sorted(result) def format_name(name, prefix=None): if prefix: return '%s.%s' % (prefix, name) return '%s' % name def format_value(value, delta=None): if delta and value > 0: return '+%s' % value return '%s' % value def format_timestamp(value): if isinstance(value, datetime): return int(value.timestamp()) if isinstance(value, float): return int(value) return value aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/aiomeasures/collectors.py000066400000000000000000000015031261437612200266250ustar00rootroot00000000000000from collections import deque from aiomeasures.events import Event class Collector(deque): """Caped list of metrics """ def flush(self, rate=None, formatter=None): while True: try: metric = self.popleft() if isinstance(metric, Event): yield formatter(metric) continue if metric.value is None: continue if rate and metric.rate and rate < metric.rate: continue if formatter: try: yield formatter(metric) except ValueError: continue else: yield metric except IndexError: raise StopIteration aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/aiomeasures/events.py000066400000000000000000000040431261437612200257620ustar00rootroot00000000000000 __all__ = ['Event'] class Event: """ You can post events to your Datadog event stream. You can tag them, set priority and even aggregate them with other events. Parameters: title (str): Event title text (str): Event text. Supports line breaks date_happened (datetime): Assign a timestamp to the event. Default is now when none. hostname (str): Assign a hostname to the event. aggregation_key (str): Assign an aggregation key to the event, to group it with some others. priority (str): Can be `normal` or `low`. Default to `normal` source_type_name (str): Assign a source type to the event. alert_type (str): Can be `error`, `warning`, `info` or `success`. default to `info` tags (list): An array of tags """ __slots__ = ('title', 'text', 'date_happened', 'hostname', 'alert_type', 'aggregation_key', 'priority', 'source_type_name', 'tags') def __init__(self, title, text, date_happened=None, hostname=None, alert_type=None, aggregation_key=None, priority=None, source_type_name=None, tags=None): self.title = title self.text = text self.date_happened = date_happened self.hostname = hostname self.alert_type = alert_type self.aggregation_key = aggregation_key self.priority = priority self.source_type_name = source_type_name self.tags = tags def __repr__(self): args = ['%s=%s' for attr in ()] attrs = ('title', 'text', 'alert_type', 'aggregation_key', 'priority', 'tags') for attr in attrs: value = getattr(self, attr, None) if value is not None: args.append('%s=%r' % (attr, value)) return '<%s(%s)>' % (self.__class__.__name__, ', '.join(args)) aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/aiomeasures/metrics.py000066400000000000000000000050431261437612200261250ustar00rootroot00000000000000""" We’ll walk through the types of metrics supported by DogStatsD in Python, but the principles are easily translated into other languages. """ __all__ = [ 'Metric', 'CountingMetric', 'GaugeMetric', 'HistogramMetric', 'SetMetric', 'TimingMetric' ] class Metric: __slots__ = ('name', 'value', 'rate', 'delta', 'tags') def __init__(self, name, value, rate=None, delta=False, tags=None): """ Parameters: name (str): name of the metric value (obj): value of the metric rate (float): sample of metric (optional) """ self.name = name self.value = value self.rate = rate self.delta = delta self.tags = tags def __eq__(self, other): if isinstance(other, Metric): other = other.__str__() return self.__str__() == other def __repr__(self): args = ['%s=%s' for attr in ()] for attr in ('name', 'value', 'rate', 'delta', 'tags'): value = getattr(self, attr, None) if value is not None: args.append('%s=%r' % (attr, value)) return '<%s(%s)>' % (self.__class__.__name__, ', '.join(args)) class CountingMetric(Metric): """Count things. Counters track how many times something happened per second, like the number of database requests or page views. """ class GaugeMetric(Metric): """Measure the value of a particular thing over time. Gauges measure the value of a particular thing at a particular time, like the amount of fuel in a car’s gas tank or the number of users connected to a system. """ class HistogramMetric(Metric): """Measure the statistical distribution of a set of values. Histograms track the statistical distribution of a set of values, like the duration of a number of database queries or the size of files uploaded by users. """ class SetMetric(Metric): """Count the number of unique elements in a group. Sets are used to count the number of unique elements in a group. If you want to track the number of unique visitor to your site, sets are a great way to do that. """ class TimingMetric(Metric): """Measure the statistical distribution of a set of values. StatsD only supports histograms for timing, not generic values (like the size of uploaded files or the number of rows returned from a query). Timers are essentially a special case of histograms, so they are treated in the same manner by DogStatsD for backwards compatibility. """ aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/aiomeasures/reporters/000077500000000000000000000000001261437612200261305ustar00rootroot00000000000000aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/aiomeasures/reporters/__init__.py000066400000000000000000000001121261437612200302330ustar00rootroot00000000000000from .statsd_reporter import StatsDReporter __all__ = ['StatsDReporter'] statsd_reporter.py000066400000000000000000000047331261437612200316560ustar00rootroot00000000000000aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/aiomeasures/reportersimport asyncio import logging from aiomeasures.util import parse_addr class StatsDReporter: def __init__(self, addr, *, loop=None): """Sends statistics to the stats daemon over UDP Parameters: addr (str): the address in the form udp://host:port loop (EventLoop): the event loop """ self.addr = parse_addr(addr, proto='udp') self.loop = loop or asyncio.get_event_loop() self.log = logging.getLogger(__name__) self.protocol = None self._connecting = asyncio.Lock(loop=self.loop) self.protocol = None @asyncio.coroutine def send(self, metrics): """Sends key/value pairs via UDP or TCP. """ msg = bytearray() for i, metric in enumerate(metrics, start=1): msg += bytes('%s\n' % metric, encoding='utf-8') if i % 20 == 0: # small packets self.protocol.send(msg) msg[:] = [] if msg: self.protocol.send(msg) msg[:] = [] @asyncio.coroutine def connect(self): if self.protocol: return with (yield from self._connecting): if not self.protocol: transport, protocol = yield from connect(self.addr, self.loop) self.protocol = protocol def close(self): self.protocol.close() class UDPProtocol(asyncio.Protocol): def __init__(self): self.log = logging.getLogger(__name__) def send(self, msg): self.log.debug('send %s', msg) self.transport.sendto(msg) def connection_made(self, transport): addr = '%s:%s' % transport.get_extra_info('peername') self.log.info('connected to %s', addr) self.transport = transport def datagram_received(self, data, addr): self.log.debug('received %s', data.decode()) def error_received(self, exc): addr = '%s:%s' % self.transport.get_extra_info('peername') self.log.warning('error received %s %s', addr, exc) def connection_lost(self, exc): self.log.warning("socket closed") def close(self): if self.transport: self.transport.close() @asyncio.coroutine def connect(addr, loop): if addr.proto == 'udp': transport, protocol = yield from loop.create_datagram_endpoint( lambda: UDPProtocol(), remote_addr=addr ) else: raise NotImplementedError() return transport, protocol aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/aiomeasures/util.py000066400000000000000000000026731261437612200254420ustar00rootroot00000000000000__all__ = ['parse_addr'] class Address(tuple): """Defines what is a net address. """ def __new__(cls, proto, host, port): return super().__new__(cls, (host, port)) def __init__(self, proto, host, port): self.proto = proto self.host = host self.port = port def __hash__(self): return id((self.proto, self.host, self.port)) def __eq__(self, other): return other == (self.proto, self.host, self.port) def __str__(self): return '%s://%s:%s' % (self.proto, self.host, self.port) def parse_addr(addr, *, proto=None, host=None): """Parses an address; Returns: Address: the parsed address """ port = None if isinstance(addr, Address): return addr elif isinstance(addr, str): if addr.startswith('udp://'): proto, addr = 'udp', addr[6:] elif addr.startswith('tcp://'): proto, addr = 'tcp', addr[6:] elif addr.startswith('unix://'): proto, addr = 'unix', addr[7:] a, _, b = addr.partition(':') host = a or host port = b or port elif isinstance(addr, (tuple, list)): # list is not good a, b = addr host = a or host port = b or port elif isinstance(addr, int): port = addr else: raise ValueError('bad value') if port is not None: port = int(port) return Address(proto, host, port) aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/docs/000077500000000000000000000000001261437612200225165ustar00rootroot00000000000000aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/docs/Makefile000066400000000000000000000163611261437612200241650ustar00rootroot00000000000000# Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = BUILDDIR = _build # User-friendly check for sphinx-build ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1) $(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from http://sphinx-doc.org/) endif # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . # the i18n builder cannot share the environment and doctrees with the others I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . .PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest coverage gettext help: @echo "Please use \`make ' where is one of" @echo " html to make standalone HTML files" @echo " dirhtml to make HTML files named index.html in directories" @echo " singlehtml to make a single large HTML file" @echo " pickle to make pickle files" @echo " json to make JSON files" @echo " htmlhelp to make HTML files and a HTML help project" @echo " qthelp to make HTML files and a qthelp project" @echo " applehelp to make an Apple Help Book" @echo " devhelp to make HTML files and a Devhelp project" @echo " epub to make an epub" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " latexpdf to make LaTeX files and run them through pdflatex" @echo " latexpdfja to make LaTeX files and run them through platex/dvipdfmx" @echo " text to make text files" @echo " man to make manual pages" @echo " texinfo to make Texinfo files" @echo " info to make Texinfo files and run them through makeinfo" @echo " gettext to make PO message catalogs" @echo " changes to make an overview of all changed/added/deprecated items" @echo " xml to make Docutils-native XML files" @echo " pseudoxml to make pseudoxml-XML files for display purposes" @echo " linkcheck to check all external links for integrity" @echo " doctest to run all doctests embedded in the documentation (if enabled)" @echo " coverage to run coverage check of the documentation (if enabled)" clean: rm -rf $(BUILDDIR)/* html: $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." dirhtml: $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." singlehtml: $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml @echo @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." pickle: $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle @echo @echo "Build finished; now you can process the pickle files." json: $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json @echo @echo "Build finished; now you can process the JSON files." htmlhelp: $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp @echo @echo "Build finished; now you can run HTML Help Workshop with the" \ ".hhp project file in $(BUILDDIR)/htmlhelp." qthelp: $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp @echo @echo "Build finished; now you can run "qcollectiongenerator" with the" \ ".qhcp project file in $(BUILDDIR)/qthelp, like this:" @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/Humble.qhcp" @echo "To view the help file:" @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/Humble.qhc" applehelp: $(SPHINXBUILD) -b applehelp $(ALLSPHINXOPTS) $(BUILDDIR)/applehelp @echo @echo "Build finished. The help book is in $(BUILDDIR)/applehelp." @echo "N.B. You won't be able to view it unless you put it in" \ "~/Library/Documentation/Help or install it in your application" \ "bundle." devhelp: $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp @echo @echo "Build finished." @echo "To view the help file:" @echo "# mkdir -p $$HOME/.local/share/devhelp/Humble" @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/Humble" @echo "# devhelp" epub: $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub @echo @echo "Build finished. The epub file is in $(BUILDDIR)/epub." latex: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." @echo "Run \`make' in that directory to run these through (pdf)latex" \ "(use \`make latexpdf' here to do that automatically)." latexpdf: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through pdflatex..." $(MAKE) -C $(BUILDDIR)/latex all-pdf @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." latexpdfja: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through platex and dvipdfmx..." $(MAKE) -C $(BUILDDIR)/latex all-pdf-ja @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." text: $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text @echo @echo "Build finished. The text files are in $(BUILDDIR)/text." man: $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man @echo @echo "Build finished. The manual pages are in $(BUILDDIR)/man." texinfo: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo." @echo "Run \`make' in that directory to run these through makeinfo" \ "(use \`make info' here to do that automatically)." info: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo "Running Texinfo files through makeinfo..." make -C $(BUILDDIR)/texinfo info @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo." gettext: $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale @echo @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale." changes: $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes @echo @echo "The overview file is in $(BUILDDIR)/changes." linkcheck: $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck @echo @echo "Link check complete; look for any errors in the above output " \ "or in $(BUILDDIR)/linkcheck/output.txt." doctest: $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest @echo "Testing of doctests in the sources finished, look at the " \ "results in $(BUILDDIR)/doctest/output.txt." coverage: $(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage @echo "Testing of coverage in the sources finished, look at the " \ "results in $(BUILDDIR)/coverage/python.txt." xml: $(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml @echo @echo "Build finished. The XML files are in $(BUILDDIR)/xml." pseudoxml: $(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml @echo @echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml." aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/docs/conf.py000077500000000000000000000223001261437612200240150ustar00rootroot00000000000000#!/usr/bin/env python3 # -*- coding: utf-8 -*- # # Humble documentation build configuration file, created by # sphinx-quickstart on Fri Jul 31 13:30:39 2015. # # This file is execfile()d with the current directory set to its # containing dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. import sys import os # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. #sys.path.insert(0, os.path.abspath('.')) # -- General configuration ------------------------------------------------ # If your documentation needs a minimal Sphinx version, state it here. #needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ 'sphinx.ext.autodoc', 'sphinx.ext.intersphinx', 'sphinx.ext.napoleon', ] autodoc_member_order = 'groupwise' autodoc_default_flags = ['undoc-members'] autoclass_content = 'both' intersphinx_mapping = {} # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix(es) of source filenames. # You can specify multiple suffix as a list of string: # source_suffix = ['.rst', '.md'] source_suffix = '.rst' # The encoding of source files. #source_encoding = 'utf-8-sig' # The master toctree document. master_doc = 'index' # General information about the project. project = 'aiomeasures' copyright = '2015, ' author = '' # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. version = '0.1' # The full version, including alpha/beta/rc tags. release = '0.1' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. # # This is also used if you do content translation via gettext catalogs. # Usually you set "language" from the command line for these cases. language = 'python' # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. #today_fmt = '%B %d, %Y' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. exclude_patterns = ['_build'] # The reST default role (used for this markup: `text`) to use for all # documents. #default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. #add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). #add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. #show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # A list of ignored prefixes for module index sorting. #modindex_common_prefix = [] # If true, keep warnings as "system message" paragraphs in the built documents. #keep_warnings = False # If true, `todo` and `todoList` produce output, else they produce nothing. todo_include_todos = False # -- Options for HTML output ---------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. html_theme = 'alabaster' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. #html_theme_options = {} # Add any paths that contain custom themes here, relative to this directory. #html_theme_path = [] # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". #html_title = None # A shorter title for the navigation bar. Default is the same as html_title. #html_short_title = None # The name of an image file (relative to this directory) to place at the top # of the sidebar. #html_logo = None # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. #html_favicon = None # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['_static'] # Add any extra paths that contain custom files (such as robots.txt or # .htaccess) here, relative to this directory. These files are copied # directly to the root of the documentation. #html_extra_path = [] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. #html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. #html_use_smartypants = True # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. #html_additional_pages = {} # If false, no module index is generated. #html_domain_indices = True # If false, no index is generated. #html_use_index = True # If true, the index is split into individual pages for each letter. #html_split_index = False # If true, links to the reST sources are added to the pages. #html_show_sourcelink = True # If true, "Created using Sphinx" is shown in the HTML footer. Default is True. #html_show_sphinx = True # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. #html_show_copyright = True # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. #html_use_opensearch = '' # This is the file name suffix for HTML files (e.g. ".xhtml"). #html_file_suffix = None # Language to be used for generating the HTML full-text search index. # Sphinx supports the following languages: # 'da', 'de', 'en', 'es', 'fi', 'fr', 'h', 'it', 'ja' # 'nl', 'no', 'pt', 'ro', 'r', 'sv', 'tr' #html_search_language = 'en' # A dictionary with options for the search language support, empty by default. # Now only 'ja' uses this config value #html_search_options = {'type': 'default'} # The name of a javascript file (relative to the configuration directory) that # implements a search results scorer. If empty, the default will be used. #html_search_scorer = 'scorer.js' # Output file base name for HTML help builder. htmlhelp_basename = 'doc' # -- Options for LaTeX output --------------------------------------------- latex_elements = { # The paper size ('letterpaper' or 'a4paper'). #'papersize': 'letterpaper', # The font size ('10pt', '11pt' or '12pt'). #'pointsize': '10pt', # Additional stuff for the LaTeX preamble. #'preamble': '', # Latex figure (float) alignment #'figure_align': 'htbp', } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, # author, documentclass [howto, manual, or own class]). latex_documents = [ (master_doc, '.tex', 'aiomeasures Documentation', '', 'manual'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. #latex_logo = None # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. #latex_use_parts = False # If true, show page references after internal links. #latex_show_pagerefs = False # If true, show URL addresses after external links. #latex_show_urls = False # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. #latex_domain_indices = True # -- Options for manual page output --------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ (master_doc, '', 'aiomeasures Documentation', [author], 1) ] # If true, show URL addresses after external links. #man_show_urls = False # -- Options for Texinfo output ------------------------------------------- # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ (master_doc, 'aiomeasures', 'aiomeasures Documentation', author, 'aiomeasures', 'Metrics metrics metrics', 'Miscellaneous'), ] # Documents to append as an appendix to all manuals. #texinfo_appendices = [] # If false, no module index is generated. #texinfo_domain_indices = True # How to display URL addresses: 'footnote', 'no', or 'inline'. #texinfo_show_urls = 'footnote' # If true, do not generate a @detailmenu in the "Top" node's menu. #texinfo_no_detailmenu = False if __name__ == '__main__': sys.path.append(os.path.abspath('..')) aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/docs/index.rst000066400000000000000000000004031261437612200243540ustar00rootroot00000000000000Welcome to aiomeasures's documentation! ================================== aiomeasures requires a nice documentation. This documentation has been generated |today|. Indices and tables ================== * :ref:`genindex` * :ref:`modindex` * :ref:`search` aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/docs/make.bat000066400000000000000000000155051261437612200241310ustar00rootroot00000000000000@ECHO OFF REM Command file for Sphinx documentation if "%SPHINXBUILD%" == "" ( set SPHINXBUILD=sphinx-build ) set BUILDDIR=_build set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% . set I18NSPHINXOPTS=%SPHINXOPTS% . if NOT "%PAPER%" == "" ( set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS% set I18NSPHINXOPTS=-D latex_paper_size=%PAPER% %I18NSPHINXOPTS% ) if "%1" == "" goto help if "%1" == "help" ( :help echo.Please use `make ^` where ^ is one of echo. html to make standalone HTML files echo. dirhtml to make HTML files named index.html in directories echo. singlehtml to make a single large HTML file echo. pickle to make pickle files echo. json to make JSON files echo. htmlhelp to make HTML files and a HTML help project echo. qthelp to make HTML files and a qthelp project echo. devhelp to make HTML files and a Devhelp project echo. epub to make an epub echo. latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter echo. text to make text files echo. man to make manual pages echo. texinfo to make Texinfo files echo. gettext to make PO message catalogs echo. changes to make an overview over all changed/added/deprecated items echo. xml to make Docutils-native XML files echo. pseudoxml to make pseudoxml-XML files for display purposes echo. linkcheck to check all external links for integrity echo. doctest to run all doctests embedded in the documentation if enabled echo. coverage to run coverage check of the documentation if enabled goto end ) if "%1" == "clean" ( for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i del /q /s %BUILDDIR%\* goto end ) REM Check if sphinx-build is available and fallback to Python version if any %SPHINXBUILD% 2> nul if errorlevel 9009 goto sphinx_python goto sphinx_ok :sphinx_python set SPHINXBUILD=python -m sphinx.__init__ %SPHINXBUILD% 2> nul if errorlevel 9009 ( echo. echo.The 'sphinx-build' command was not found. Make sure you have Sphinx echo.installed, then set the SPHINXBUILD environment variable to point echo.to the full path of the 'sphinx-build' executable. Alternatively you echo.may add the Sphinx directory to PATH. echo. echo.If you don't have Sphinx installed, grab it from echo.http://sphinx-doc.org/ exit /b 1 ) :sphinx_ok if "%1" == "html" ( %SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/html. goto end ) if "%1" == "dirhtml" ( %SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml. goto end ) if "%1" == "singlehtml" ( %SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml. goto end ) if "%1" == "pickle" ( %SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can process the pickle files. goto end ) if "%1" == "json" ( %SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can process the JSON files. goto end ) if "%1" == "htmlhelp" ( %SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can run HTML Help Workshop with the ^ .hhp project file in %BUILDDIR%/htmlhelp. goto end ) if "%1" == "qthelp" ( %SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can run "qcollectiongenerator" with the ^ .qhcp project file in %BUILDDIR%/qthelp, like this: echo.^> qcollectiongenerator %BUILDDIR%\qthelp\Humble.qhcp echo.To view the help file: echo.^> assistant -collectionFile %BUILDDIR%\qthelp\Humble.ghc goto end ) if "%1" == "devhelp" ( %SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp if errorlevel 1 exit /b 1 echo. echo.Build finished. goto end ) if "%1" == "epub" ( %SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub if errorlevel 1 exit /b 1 echo. echo.Build finished. The epub file is in %BUILDDIR%/epub. goto end ) if "%1" == "latex" ( %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex if errorlevel 1 exit /b 1 echo. echo.Build finished; the LaTeX files are in %BUILDDIR%/latex. goto end ) if "%1" == "latexpdf" ( %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex cd %BUILDDIR%/latex make all-pdf cd %~dp0 echo. echo.Build finished; the PDF files are in %BUILDDIR%/latex. goto end ) if "%1" == "latexpdfja" ( %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex cd %BUILDDIR%/latex make all-pdf-ja cd %~dp0 echo. echo.Build finished; the PDF files are in %BUILDDIR%/latex. goto end ) if "%1" == "text" ( %SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text if errorlevel 1 exit /b 1 echo. echo.Build finished. The text files are in %BUILDDIR%/text. goto end ) if "%1" == "man" ( %SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man if errorlevel 1 exit /b 1 echo. echo.Build finished. The manual pages are in %BUILDDIR%/man. goto end ) if "%1" == "texinfo" ( %SPHINXBUILD% -b texinfo %ALLSPHINXOPTS% %BUILDDIR%/texinfo if errorlevel 1 exit /b 1 echo. echo.Build finished. The Texinfo files are in %BUILDDIR%/texinfo. goto end ) if "%1" == "gettext" ( %SPHINXBUILD% -b gettext %I18NSPHINXOPTS% %BUILDDIR%/locale if errorlevel 1 exit /b 1 echo. echo.Build finished. The message catalogs are in %BUILDDIR%/locale. goto end ) if "%1" == "changes" ( %SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes if errorlevel 1 exit /b 1 echo. echo.The overview file is in %BUILDDIR%/changes. goto end ) if "%1" == "linkcheck" ( %SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck if errorlevel 1 exit /b 1 echo. echo.Link check complete; look for any errors in the above output ^ or in %BUILDDIR%/linkcheck/output.txt. goto end ) if "%1" == "doctest" ( %SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest if errorlevel 1 exit /b 1 echo. echo.Testing of doctests in the sources finished, look at the ^ results in %BUILDDIR%/doctest/output.txt. goto end ) if "%1" == "coverage" ( %SPHINXBUILD% -b coverage %ALLSPHINXOPTS% %BUILDDIR%/coverage if errorlevel 1 exit /b 1 echo. echo.Testing of coverage in the sources finished, look at the ^ results in %BUILDDIR%/coverage/python.txt. goto end ) if "%1" == "xml" ( %SPHINXBUILD% -b xml %ALLSPHINXOPTS% %BUILDDIR%/xml if errorlevel 1 exit /b 1 echo. echo.Build finished. The XML files are in %BUILDDIR%/xml. goto end ) if "%1" == "pseudoxml" ( %SPHINXBUILD% -b pseudoxml %ALLSPHINXOPTS% %BUILDDIR%/pseudoxml if errorlevel 1 exit /b 1 echo. echo.Build finished. The pseudo-XML files are in %BUILDDIR%/pseudoxml. goto end ) :end aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/docs/requirements.txt000066400000000000000000000000721261437612200260010ustar00rootroot00000000000000sphinx sphinxcontrib-domaintools sphinxcontrib-httpdomain aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/requirements-test.txt000066400000000000000000000000611261437612200260240ustar00rootroot00000000000000pytest pytest-asyncio pytest-cover pytest-flake8 aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/runtests.py000066400000000000000000007167661261437612200240560ustar00rootroot00000000000000#! /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 base64 encoding of a zip file, this zip file contains # a fully functional basic pytest script. # # Pytest is a thing that tests packages, pytest itself is a package that some- # one might want to install, especially if they're looking to run tests inside # some package they want to install. Pytest has a lot of code to collect and # execute tests, and other such sort of "tribal knowledge" that has been en- # coded in its code base. Because of this we basically include a basic copy # of pytest inside this blob. We do this because it let's you as a maintainer # or application developer who wants people who don't deal with python much to # easily run tests without installing the complete pytest package. # # If you're wondering how this is created: you can create it yourself if you # have a complete pytest installation by using this command on the command- # line: ``py.test --genscript=runtests.py``. sources = """ eNrsvWuXG0eyICavH+uLtXf30/r4i11C395CkUCxm5RGM7AgXQ7Z1HCHInlI6orXzb5wNVDoLnUB BVYB3Y3RaI7/jz/69/kcxyuzMrOy0GiSmtlrr84Mu1CVj8jMyIjIyHj8n//ql/ef9d7+h88++2y5 iceTYprG46Sq0nKVFYtFevX+v3r7fxx89lm32+08yRbTIFus0nKeTrNklQbpZZKvVwkWDcq0Wuer CgoEXD+o4Es6TxfwcnVeFuuz8+B0neUrKPHw9Zu48+Y8q4LqvFjnU6i9zJNJGtR9F/k0Xm6gC2hg neT5Ju4gEJ1sviyw8U2lHpNqpV8vN51ZWcwDPRjdXiAlxrOinCercXoNPS4I9n7we4broSp8VJZF 2YFWZ9hRDCVXWC2GIZWr6ipbnfe6PyWXSTcKEpgULHOZlhXUHGeLWRF8HfTu94Mv+8H9aNgJ4L+9 4HWaBuer1XJ4797p+qyKf9qszotFXJRn97KqWqeHX/zuKyqKkJVVMAp63d8XRf5i2e0H3d9nC374 YZGUG358lsxPpwk+PZ0dXdOrx9lk1e1TM/V/3WdZtXpUzKnEd+kiLZNVUUqNf8rSfIoPWCApU3qE 6W628ipdlvj1+XqOf16v6NfD1arMTtcrqvh6fVpNymy5onLJPPXDgl/frJd52o14xNVqvuIRP1kv JrgAj9MZQZLD+snzq3S1Lhc0yjRPuUNYsOxs0ezl4fpMfQq6L0tAWnx4UhDIP55necrTRj9hNan9 JKs8AL8pN0fXk5THBD9gFyA2Su+ALtQS4Vb99ARwsNnU0XU6oTXIi9MkxydYBALpJQyTlrlMkwte jQXg41rPEOLEeAEIjdNUpaveWQq7a1X2APn7wQKmOgoAQ+kJtyAjkTG9t6pM68GVp+ksGGcV7Eva MmUP2xGkxv9KWpVgQYRjPMH1Go81BNxroyFsf/eGavA7aV6lw9vAlVXZAjbtYpJSgT4SixjLR7cB ytsKlo+ARhCowZMky9dl2mNcAQyWVoBmETGBCV4DpbhC3GMiuoTGs8UZ0UKibBogoCHZajzuVWk+ 6wcGoRp1uwZw+DmeJOsqxWUFEpReT4j89CK7jNEClDR+AfTYoQanVxXrcgLjm5WACn0hzuMZjG30 JIG5l97nxRQawkkAklGlUo17vYTJAvIC3x+nQOieqrbTsketcqlVuakHIlVi+tuDxrlMSlOpZrYu PuMXjUEfH564CweILqV78pebRrpej62x3r1ur+YbWCKd9oF3rWD5UsAG+JtUUHZQrhe0cbrOTodl XyLRweW1GCbyy7TqYxPTbArIvqLm4yB4vT47SyvssBr62psAeQYqq3gronBaIcMJTlMAIQUWqz8C RIgUg8GiGPCrCOgILTVA3Ctms3QxBdjGebZQiz16XizU8sLs0DvA+wBfG1NPr0fIXom7PsHfPVyG MU41/TqMeI7V3tHI5e1X4PIs1FCQwMRdD/NW5U0sF0zEyYZKqgBtFYUkiAFAAamMsacQssreJHG1 zLMVfTA2FtTH1aPXQ2u56FWcLJcw2F63G9ltHx+cBHdHQTf4+utgv+oG+wHD0K/L2UPuvlt045+K bNGj+rJ90usVftsHZJFW7FEenAARRXo+HlsURKM/tmCJM7bsM1S4ZBIc6RX/HB/+ZnhiLjO+BHJS LFm6GM+TJRT9mYogofh9tnpRBoDafxa+KC/fFvT2n+23D4FUwtv/aLx99vo8m63w7ddfG69f6dff fGO8fjilBu4ar0A4wVcD49X3ILHiuzvGu8fZJb66Z7x6khdFqd6bH74vqJd949XRe3wzGhmvnhcr fvu5+fYZj8V6c0SvzFLf8dCsN1TqG7PUy+KKhmGO42mFr7LKegWg8FtEXvPLgl4vbKj5LaI5fOn8 0umsUfhsLK00iuX2re4Wl4hB8Okv1vsf1ErYb9WSwVvsS/hqg4lwj9P0H5lp1GxWF0KOGrC4syqC szxN5kgPZ+sc2Cu0dsZkmUkJbvBgG/tlKuVwXUUH6W9d9QyF62wyZkbG9R2JYg/4WZ6fJpMLZiZX aTAtFuEqOE8ugYAH1TKdZEmOp5WcDk8Mokl3tok9Nnc+0lyCy1nFJgVJgzCaMTIXYHI169U73mTT NZPEk56qTFMQ40mwNyns2sLAtUjkaQplbi07ubVNMmj0BWfFssdA2DWEFFknOy5X09Y82y7x2RMI G3wN83KMhU52mT4Q3VOU8neYRnP2oMr4E0+fTAby7z79a8xBldptcTs2B+h1Jwnj5WIKIitxGZZ+ gb/Xm0WNnZFdyY8wE+moi0jRbUrTuooU7n5tHNLVJqblA7pHTRkd0tYaI2LX4nHZ7IMml7chFoiZ z7vNyPJyQ4j8hqQDfAnxA08g8CU+LabOGhpdyFHAbvw5iUZMA2wS4kFQhUs2BVloebnWISDvBlFv IfJZXkySvCYPPKckGpQIOn0GuSVgkg/UEI+e8IJkBmwkzqaG7OHBalO49yIz9XEDOdiOy3tM/YBa AyascWAw7xVgn7cfOok0BDH8OPTtADVIlxRsoRbOSopqRBYT58WUGNMZrh6+jfHZ+mBrmeiNvd68 zvghslCvWALWgEg1Lpa4jH/Klj3qoVhWDEE8IaBQ1qoc8kX1rI7pja9j6cKmHMVyXG3mpwXOtSnP HRfL+mR+soVWg1ga0P8IyZrzoDvoNyha23/umGyIa6wfE1dE5j6mhQEwjFdldna+IqBqEG6k6i7+ fwhf7AcOYCMDF3afhcZYRsbKfhzzaJ1b71Bl03HHQy/8p6jK8oH0x3RzWiTllOS1cr1ctYDmqdss 2ezlpm23dXd0auqAy2+cdMcodfCes2gPvXPpDp4g6YOBZyYYVp/2dGOT7omyucNKUardjo6xOlnI 2Cn8KExCBkIRqW0MZReXiZEYoTT0ovQeUnG0xycO+QKyQbcF0g8zYGdcW/ggkydpplUu1MfsVuzl 6aSGRzzCm3BowZI9zwaOoYv6FPmHfrcd1Hvd4C5zGzqum3BG8KUbdT9gzUTfL4tGBzBjzZbJCjYR 9q6PZsf0FPtptUyoS475pW8FVGPOOtgjV1AQXW12sFW6MOqaxDslxXi0RerYldriw8ge4q5iyQ4U 8habD29w1N7LFoUrQ+woKlDV2BYYiBXY9flVewP03VATe/k9F/Vjkov7iuVHLTz/dgy/MaKo8+G8 vsHoP0TI/ZWZe4Oxmwv4N8FXvARUEi88mkej9WJiLy6+sbEMq8T4uu46Kc/G7VyDfv9srinW7gZD avwXs5U13yk3mA58QoZDXcOzw2yc7vv0wrdB4H3UqClcwYRPi7eLHhB4R45cVMeq2gnqEnRfbss8 GMXHVJ1oG+hWae8q42xcpJuropzqGZHfHzorUl0dpP868yOdjo1TbTXal4YVRL71smfVaQbqqr5N DrNtpv0tWEzOuhqgGUft+kfgodXGTjOOhbufAg27d2SObztPVsUbpufi6mMnh1vYaWourqbVJ5qa D5+bHSYHB8TfskWKWkg0BmB50m239cJov+opPtwk1XYHdsdudzzyG1gvdqH7w1Z+TUZ754497o/k hrX4DJP2bvHzPk4BPv1iiurLHdTPrQIxlEYOu/Tcwu3Kj1FdLYZThHB+paI5ljLgS5ta3Ucnl/q9 Ugt2m2trwK41Z/LwsQtba2Y/SEsoDbD6z5FWtBmSTA6at5hnW9ZXGEdbLBBPVtd8sn1WJNOoHVxb K0ttOxPnCLv8zitdYL8OE23s31gIha9tasAHgrMvSe2tCI6q81cSgunMZU3CJ9y0jdmqN27Me5em zr9hb6Frcy9pPqqZ3RZyL3h0nk4ulI4fP6LiniwaE7wcYeRtV/crwy5nLfpBOB5Ps8lqPA77wc+/ +Pa9Idp8ImxBsMcK5l8TadyO3pRrS0dnfXcxernj5eIuvOLX5gRC6+i2TBG6qipXlo1G5Zy86Y2X FGHVGD9bwpnbgmUlQsQXRk9/g5HYv75rbIdGIyABSRPvFl2H1LqFycbEfnV8+OVwcL9V/SDGKkLu GnPQMNsx5mS4g2KfiJLfRviT69x9eGCA60GG7GxRIwP8MGaXGI2NDvyqBR+g9g3MKY5jwvvacqll pkUIJ3MNFFqa2j3NeXtb6CkaPS2KkQlbzO/a60yKfFzMZlW6suvV7w0w06sxFxJgZUKlIqA+0NSK RaC+A81NcLTD44PEY3WgYTvZSom9dgcNTPbYGzTpr4kdv7Layeyq8/5fvf234oMAJPM8ri4XV5P3 //Xbb/8v9j2A34NHxXyO1OY0qeBo9NQykAmKWZAEr9enYoYf/FiUF9ni7FGx3AQvsUXcOK8vFz8+ kmbwJV56EKedJ6gmQR0nlDPdDIoKVZfwzyrD9S9T0oYBMUtKw+VA+SSsT5dlMUmrqnZCwNEo1wNY rzka3e4NPvy/DsgIyeQcTZjyBOkCspSCTKE28Ig7GUaP04TvB9h9BXXQ5JvMUWG0cxx1lRdXARJk Gv9kXZYwlY7VERy19qDu27dvYYIuYJZWgyqZpR8Hv9h1TWAQwothzpZ5ViE1+pkVfeRDoX8BOGVG d2ryAivwL2nsFQz1aKEx3mPFtS5zXL1LXkjgaNYdPm0NKIL3KGVuv4ZKdOF2ab/WzSCzUs+mEVm1 KqX3pnVKF9cGLTf/N5AixLRGwdDX3fadniJzuI/q+QN8Dd7AIuJrmlZYrUVyBjM2zapJATsinZpY wjhBh35AE1j+rNSYU8VB8BQtwqtsiuZo2HmxXjGSYNtU7yrLc/LM0daf8FkjX8HSa1kUq1gByFar 0tgouH8Asm6VTgqQCoJkBiISWsZPztEcblYgyYUmkhX+vFgAomJ7MPSV7qTFXM9dUxo1a4p1hUme JuXOpZfrVTsKmUbT+rbxsmk2XS+9JWhpFPJWcDGMEKEXdSwtL+6NDUr+9QCG7gUoIfaIiyKGeS6X 6ZMfpf1lm7tCn2HI8j3oAm8jpAM+T1VuuHZtGqXx0Eb15u75NnGTxdEk6IthrGgXUgByCdkaGkrD ltNYeGONER3tBfmA9TBlar0uUYudxVXwdWOF7ta0AXaU3wJDDZQxj4xe58oR4WhVLjatS2OybAVd v175zs1lB4cuzVOvO5oSMU3XxAxRG7gNcHpgpEthmNO003n47NmLH48ejx/94eGr16TlCAb33r0b /X38l7v73WAvmU6DyXlSJhOgI0BOKhDqkAknsBJkY4tsMp26zny4J7pX2eLB/S7Pn90PGukPu3bn 4z+8eP0GIHBKBuE/DEP2Y0A3CBiBSCE9+Ds6PpGFtSQymRUocHxwYrq7PAWcvGYb/FqMZ0MUES7i yXyKElyvi3M1eB8MBtKfIf5dAoqV2dJAT2wkjEPW7l6yV0MPXkTHw/uGfAlNqc1z2RDgLmWUaTVJ lun4PM2XadlD2381RnYRQNcKeqvcDQD6ajWNrfn/HOCh+Q8bLga6fiyOob3w78N+EL579/dh1HQ7 YEtUVJ2gg8j4NJmOESEqagPOGTkIO6m8G1mLJ2Dj1p3Qtl1Zw1H3FXFWJfliPe85e3QibnpWYXKB Nbu8oY4MRWstbD0nsSwcGoyKB1WTCpDrzpcXER1p368z2NcVOkYlp4plp9ewKYCHlbDlQHQ9W2fT IriKv1Vi1KpA8pax3CMo0R2ij0NwWK8dlsPV6s7QcbIezXmB/oNQn4RcbCNTaHUv1C0woMUi3/A4 aLJhMLRnyV+Y7FmLxYA6gqMRSChAHM057XlXl/tv7tDIUUhAf976ArnTRBT5jjf/iKcVMYxWwCPs +yWdhIm6RUTBxh/3nxLy4KyCR5Tfw2GnxweHWP2ufR4C/OlI7TS/UtsV6GMti1Wk+IJ1MiSpM0S8 vEVmJX4D2wNnjL6xvIyyeFquNj2p3TcszuFQioVIHsQjB5zh6HDXjW4UlHFs0nGCmxK5F6rm0koP s5ctJvl6yl8uB7A7T9My0gNsA93o+TypzltldPzYM2saQMPBXGSDO3curhywJyDXoKMeHuizWQYC hjqTqomgSQgeBiHAHeorRltMWEyzCZ7voB3oTcu9sS0inqO4jKQGZ0Hd+NcmEgTBBk7aZVasuV/e W8Nhx2Hi4pqOWwpNi+8hl76HFe7hpo+RzNoV/txywPtzXWSalag22VlX/mfVAp7wb1uT+wVSl966 tm7BHKWJR8XpT2gbdfpTOlmhX116JWhTW0ZFZmERjy+uYpQiaZnrY51dMlkT6VRF8acqi891YZnM vp6cvjVY1CprfR7uxdMNuhL17EnoqlZ0NasNaKJr6UpD9SlEWndx1ZBlQ7O+FEJ6G0JT3jp+ipot LpM8m7L30wwxH/cL01bYYFtOCctTnj04bsDOTNY5TKIFkz1NrinpqlkbIafZbFiSYnE8MiO7ddwn UY7yGe2uWOgCGdHdQRdXx/XsogUCjIRLdeoiFmCydgCcPEVtJYG4KySCR2tF7W5tkBEfhdjRNUdP 9VOhemKJf/Q8Vrw0W1amvTWnqhBcKG/zIsFg8SyCR4fQopZAEAaILNE1pXtgChuEQApDPF0rHmIB SNovZK0JckP0paBmFI2MSanCzSZlKmDCOcKm0yxjgXCD/QL5TUsFhIXMsU1wN8U6mCcbKbNxKDnT aLvGLQn0JyfPH0qcP5Y0byXMbGpv2AHyco0sli8yaXM7mDEvcCGU8Np397LcZZAZhHusUsd0KgKb Xe1Sr3+IOlkpWPgwRkAfDweHJ44pEXkr6pb1tt3aNDeGbTlNufuTdDDSJN1USr2mEgK+qoJxOQPR hMidT1mRIaCDQ78+wseu6t9h2CSfXphvaup4mJ3UXPI4G5541SpqVi1mMWxRhdSz28pLmuuFjOTG Bht8ZvvAmXXihZpwzsfkPExKUlxB4Zk2eEJg0WnEkH7T91o7XgD5Kf3S9wpOpXQIRLrI1wqXZJhA 1jZVkCaTc6BkK/jXI3n38DxN8jXOCP7grrAld3y9Wt0+YojoB/ph+j5YXqggkrUORgeWWVFDupG6 Om1CkefJorDlHIKCOJ2qevripMLFVsJ5JEpsYDh4NQdHbnuQii8gFNQOU3zgOqcb4lVVyPNMtRdk dugle3KL3bSfNA48Hde0b4URl3po9Cg0TBNE03oaC59EDXpqnYTgpAuiCpY0r1GF0dtisY/SRY0r DlvSVQvGTRqqeDhq1lpZx/zNRFm8qygWK7zQkik/y/CyQp1VY2syVZgQBlx14t1BVNQGCC+ufIdX utBK8lx3SgBXdtcKSrNzajBq+kxTybrvKvtT6uv3VT0HWERNAMoI7qTQtWjreZlj6sTYSN3rnFTe 27ulexo++4ocj5VMQG7slLrpiIqrOk/wAgt1jcE8XZ0XU5OMsSZSOSrMp82N7ygrsUxH2ha9YZZP 58k1oKM5sj0Hq6BENl/P62suVjjguKiFKuiZpIq2qHyplRJ7DNelWnGlTN8zxZE+33+qS4QxYgRI FWT7yRNkQFg3CAD2aEthmZi1EOjxJAfOPYsTXJozAPjOd8lqbNvmwbh1Hui5QNAN1YY1XNYTNdRH e2JU5aEZWo0kkNfl9/BGcJECOiRBXoCkfJXkF+g3jlKJvnUcIHCKWfF1oW6BA3AdOjOoVfN7NjW1 5pXGZqFLFDUrLbFP1LaQ8de5pwCPmVqDZcW/PacduQroPX1BXL4fOJr/mF5HHpDrS7W9tgvJPVuW 0H10JxSJERnLFCOtzLMFzvWVWu3AWm22ACJG04pdrMgkk8a0rJQWU/02dipiIUyFS1i2eFrXJIPm UejGBWKBCOGhzzRruYlTHG3sXLD4Glb77qooLyrz3pX2jPVxV7hrgKV6L9oO5fMXR8/ftIJpB0Jo FxzNCwZrFDMVueOTTDq2Fn78eCwI02uYqOpjYfwYoPy4QOwfY9+Nk2U5Jq7Il7NqV2b6Er10z0y+ c1JTJVbvRupHNpzqpFNbCJR1T3j06YjYBsIn8V25q0bSa4IJ+33/nwb788H+9M3+H4b73w/3X3ft qzWsNr+gSnV72gjlJcgqGMwTQ4720LbYuJVIAnwLpIKvYFEmnqVwRIDzAvuBA2mDhXl9uVA2Xco6 F3hlnvwpyzeKhXhseVgEvUg3JFGZZCQj9axV+Lh3LbyEyNY16SSl6okTJ9GgzObZAthjtkrnukmo 7ppYQi3p3FfYlNu5uNfgwxJECXuVMGo1Yoy0anYmdnVtoivv+mvy/0h7dby/Gy9mpZnw2aPxw2fP Ro+C0MQVOLzj1X0xx8A01Qpv+taLC5KNiikFdqmK/DKtT5EoFIA4qm5G8NX7dcEBEzEabtV5+uzZ 0XcPn+lb//BO8OfgXXAvGAZfB98E3wbvVsG7RfDu+uAU/5kE78pQKXAC2GkwqKLCkweuuNUYD8p6 BYLYvLhMe1wj6jx9/ePT549f/PhagkyaNgMyNR0Qrc7GdM87nmbVBZnDxMokswz/GY5agz+dvBu+ exd9e/zPw5O7eIMNRZ5G5n01sX+6XpK1yPP0jMLcWAAeixajWirRwZSlYKwaYuPimptSYwuHYcMO 2hlDTAf5XrW86Qo0pIVEBSa2gucKNKBM0NIVb+aGkXRF9+pyU1ot7Tt1fC3uSKycjcleJTnNUY+q q8kobgJIzZs2BAnYIwIBDfGGFj9Q6Com3avz8aoYzyo9//0gmU6T1Qi5pAy/sUTbl4DqEyrTVxS8 PrepPFUN96t/2K8IpmrZ12Ul5mmuGvLU+sPRw8eqnkWqqyUPC3bVmJwdXKzicQrcjYFzaFcqiJtQ AnyivQY0mGenMb3dgmms/xm1oBP3ZahdFTD8UJt4vHuHNh73bDSlNuKzslgve4cOXuqWwnv7lcyp Xd7T+M322jRcAfsY/ZftNqOhqadtilwaKrMdtbxm4S0FRePmQ6J60DUi8bsmMnl7s1BJalroRJLc 8N49u/HIsEx4uAbk4ftQg+0LHUhLVijhzaYRZpHtEmoL7S0cfl2lctm5hA7xUrvP1qdjbJS2aJ9D xcFWzy5Tc9PW9rzSCBqmyKPL7rlt2hb86MZWVl1igC/9wy5kgIFhY+pfhtYkuUjh5FaQ7XxDmF0L kBbQNd522e6pG5pKOYB2WksKDPvWKhgW07ooQTtE7KihP1SK6XAwUMCMuiB8EiqsXYdnwlOEZls7 CsK6Ha7jNKQ0tMa8b2sVgxtDkQGVDv0tGcuxvanFwCgaNqQnkChYgVmmq2hnK++vZado/BvtV0Ec x9/U9t4K0SO0i7wen+aMC5Yk8a6603s3vRvR39d3o6AX30EGW29Hy6lhi7XQsmkSFGBUZjKvSSao Yrhna+4Ksse8YmcK2ODLLDV00k8xPGSltHJBlc2zHLg21CJVn8TyJxsvkKy08GeXM7ShNAZ9iYs9 T/IMILXNyNl0iUU1+w4AzTImedUPribY2YiNkIhmOJbafBPgmnRAXQuPDH9hbhHIUO6G24Ny/NEI Ww9iIhRsPVNyefsyeiLUWdoiCd0qlbXYOOKtCle6lVuqzwxyN5M3AVV8wNTERM5hSg9AbFf1oBSw dnGhshZ9bdxm1OYE2uwspyQYwfWQbpeu624jxxJNjMjwkz7nXvpbuma1AWxOoi2jg4jvKqz2lDbM Nmbbcqlm6hOMyRlpp12qAJRbfwyVFvQmE71sphvhvsMxlFLV/adN8bEx1O5NU/ox625JoYyPe2JW 2FNvRNlsWTWJL6axd3RbfcQECWUQj/EelVcl8k4S1uh8mKnhj48CPBhba/OBNwVaP7meq/BdQDWc 649lNrnAYwuRExQCCqa1uJRIAtvuO/RSx9Q8Nmxc8VwuPGttqOKV15Yy9tRa+B8fDXD49j3LlgWX 9tQ2lY7VIlsIjkaY7RyP3PZ6+2VU++Ar68lgL+jX67ozE1UXyMbGNqqiZIUko0W0QsWGJi5bvHJM 4wNzebBe7EhvZvf4HYZc4xTHV3GZjVzA0h/kf3TFRxfNeNA1hDJ8Z5mINAYYtWwVhIL65wtsA0YH PveCGzfWcYislqV9KHTiAn7MfcgGQsxiZRo+6TvjukW0RZLwVAY7zbW8paRAq1ULV0zDcfSnmWXX 4rvIkUvS4DTlxCdX6JaGFhBEPK+QbZGusmYuTPZHptYLgzGqMDf5Fo9Zr4r5IkWnJNSDfX/0+vXD 745eNw1Xzot8yiJKurjMShDGvFo8sgnQZY7hO9oBho+aDbLXnMcFxKWfdNDjDEVebyKEzG9Z0gQE y97CNGWa5m4jnabO3XuT5Th+bc3sIoualqj3TlGHH6MNRdk0yeJSMSvfKdUKpuAJI/dAbUs9zr0A k5SmVZbZePfo/gH897th96PbRl8HC266uOdbEAV54IQdqGfErJPkZZpMN7ete3X4JQzl/nDXChIl Xozep1kJDLAoN2omopun4ujt09e+qbCDACsj0bVpA3GVkbrS46WHXJI/Uw4IMv/44dUzmyMyAVJE POTyIDUdQ1snBg0lqbswHUHlZAFyj0vrSQ8i5TlwC8olAANHLxfp3gJDUVn7cA61vBzLuE43fZXt m17kK2Iw5WIjYth2byyfcRYHqbSd28imKzyMH/hMnxFMdKEjTVN3i7Ysm7W3u6XZ/SmKGK4zop86 mWw1HJRojY1iBRuR+QqRgNKCJZMiZC5vIMh6OU106ClEipD0a1t1VIgoXM88Xm+YqWqc1X4fQY/W dfBNgE1HNgaBdEAYhIMjAE4aka/aFCFYVUeoa2hCuq3TsEYLc6xsTMNVma3qKPlkaySpIMKr0Bk6 ldUWSSQx8w5B4gWIibNwNfHs11pk5u6sjkx5XUwrbrTrQ6lC0y22yxMFhJKvtxtKObZuhkgvEHDf oocw7N2Mo8kC/fagfEOCxXDjtYGYbS6i9W9YJCaigzb2cFx1XCS4gNlL1BCR26vT5/mFba3QOJrT ZT11YM44O0h55p6LspN/whLkAOUxZYHPXCvonW4C8WqAc6UdZpEwBTYCjACt6ZUlfdLwgyJzEF5e 2oSh60O10D4DFG2rKCcABu7BU3TjqnGDVtVrkKmDSJFMeceWfHGNZH6bqiP1RYhfOrUS7VnLGCfT qT/Jy9L28CBSRu5EaAfTDw78oe2WLSihcW7pQbityLSUPWlmPXPB1iDX6vELZfvj36ciW/xH/4YV rCGLXBq4aym71UrWXLAGkje5SX3YCqlwGG03v8Xh4fA9Z3j0Wi/WJSkiRc3alE2oJygZGtRCrnMV s5mMDvuMs6PDBoHDkrJTUCQwkRlkuDRGF8RJCFDg7UVmb7DsbFGg4SWeWIHIYkAQ+plfJZuK7cJ7 6hhWzGwZZQFl8w3yNHLnT+fJYpVNWqyZRWEEkPRJg4AnOs4uQeAjS4JvDGS+6fqvDJxN5DBbPkqS zfQUQz7IhPeSxWYOg/wWqPNP60p1aVNPS3dJC6lu1KNtAT5meeIR62ihnOtCLGhcRlCRMPJhAvcL O/oOVTJFVBAdBCU4ZJW7h1C0IAqHSncqEVsErCW6ANVTuVxqa/4+O8pzT5GFnEaEUi8kXKK2FjUA CnaBiHBCZuk2kMH6Xfj2IcYpSehr0IMTZ75GNIuCQgW1kbiIlri1rk22tUCELYRRwz1IkLQRpGMv ADJNQTkwaghbYPLJKFVRtm5Qya8X6PWx4MpkRXG54HHIRYqp/Vwv2sa/XvAMKLvVfENTQg3dOGhu 1j9sqGB5SEKFYRh9ilnQcch60MfxF0PrrJanyWK99GtNmRwuNjQ6iavZusoc+Eryk5+i5fo1Siek hM43n3/++Q2h1mTK3ShqrmxWGdbsmDF9XaljJh0OqtEBU/kD8nPC68K8smQ0Q5QFYTjPU5Lco+A1 NaZ00lo33DTA31O+hbBCp0VxAeRtOjiFaSQ/Q3pzvprne+i/PzkfPBhU0ODgi/hBfGi0Yf53//7B IT8c/u6+evnTei6xHu0p7tgetjzCm+6jcGmETcBy0AFWJi/yZM+1faCLhe6HTltVsElNv+cm2987 jO+roDTVsIYStXWDATPKgX7r2sAahUP7vD5x5ZKJVcaTqC+dcJ8WUww7DtJOi5TTveHJEkkZOqJU temF/K35/Z6QKc/87zUG4RuxpbpgxHXUFvyS6q+3DdEoaDTb2GLAE7AIL3owuASWcD3POecxgxeo lCRkceDFCemrz7KHHo6TDs1D+Ohq6IOUmx64//oQEyoVxUqgGAU/Pnpdk54oRsLImmWksHxts21/ WG29/f7ZrZpTXgO6DfMMP5sZWhWPqk375mFR99zOBgdnCV5E1t4LqBfryaHSdQkXywVyYcLOWgRW n8JOtG+4i5pKO1O51B2UgdZeRdv5K45Kq5u2qULJcGRrEBVySMMJQjdAsbGAIwCsJhmDONu1p6aL sg3OgUyWHP008gfIMIAnwAkey45G4s0ak0ZlVMJtkhZ8ibbh8JerQs4FpVKCokCeTN2KdEPVhzOK 6kYGQD77i/UcEx2lzV2GqRZryPp1/25coDnZ6YjNjpg66opN/3DAi/kuoTBgIpZrTiyOJqwF3QPz XNV0XRxubzb36KbXS+DWILiwHR6nZKHJiNzjy6WKcjtGryc2d6wahxxcR4XKvWyxIjWqGR838jke 68jFY5wyRinXzim+84jer9LacStgy6dYbKcfv3jz8NmzyDj2YAWVwLU6G4WhnIkb5x/qkbQEKroc +duZfFRKVR4xMAvO1kDZA7qtpHOtlgunqJc9TTHOd3AOR+RvP/+241B76X0wx9jhXXV6GeTFGZus Vmc+471m2OqGxIDt34UOgsHzsLMz+W8wU7y6I1MXMgyg697G3d0f042HnZH8agv9zV3CoNQLL5sF ynrVJ4hU89ra1va3rSwHYPF28OuN8Bhjed8ieWcnCzrdNdwVqR/XXAm1QiAkmoebxvyh+m/KqqSQ OnD0Qkov5kmeZNBMGV6ohoa6AHSp4iPtMtKX+1sveqe1dmJ3z+mzxlS1zxDH3HDgPtNw+3Y/xbZA V148JcL0JVmOe2iRXiHBsOEEXGyHEz6mq/TjQIU2PhGo2vdbTmhtrHcO5JLOuDPHGxwRUr9hz6i4 85ROBihLsJ0zKagNOUc7VqlmQbDnOM+k1lpTPAb6Ao05ulDPkcMzQyQqDF75lZtokTLWJJNc1hEm PQ/VVkGxrTunL8XwMVCG+PS8W7SUOb5W2ofaw4u+HR8OT058Q7Bc1xhu5vCmHuuyzrHgX1wsUJuk oHXk4kwJVhobM2cxp+gJ1THUmQ11tW+JjFD9ShFIvVtr5J3tlprhVh79/40Qd/8lwt0tAinRvZEn rbvpoF/fbCJyEFpsQb726jfcoupyW25M3YgtrfeM/0Jjt+ywBvXFlTH4TzC1ZHGl3XDYAPqwZVYX AbrxIq9cT1Z4n8vy9SWFcr3M8KbFcADymqOqPviaScugsRJXoqYlw6zYwUxPjlEW7cOqYZsz+A66 m92M05QqM66Nql7K1TItvG3uoS/k2u3SttuP9bmnlmBUBhRdAYAu5zTBRvOJssi7n7r3Zgp3Pki9 /sfnwWH8gPxGZI0KtPKdokEfKmrgJE+H3tUUzzE9jtcBhyc8+zrtCRoefI63PgXM7CmUI//jfnC6 puwBgPdrdEouVGeZ6tZpC0UnAiKO44a9FNfQYgaaJ4U+w7ga8ZRNomF9mAT6elJfOIS7m8mZc859 RD57fvGr1x5BPVXWGe8jMtsrAUmSU4zMzJntcS1+BIiLq4r2Mi4B+wXhBJF5GBx/GzYMOwb3Nj1r cI8TYfvcpWy3R8Fu2/QOu8HdrTyyi/rWz3U+Iw1V34HJ0ZW4Z2Xxkeg0DrLwrr6AlJAfDDPIHGJE WBXlaqtqs0rfr1PMbFYw66mMWJLSKGfkUGH4M7SFxuQdqOrje3+l/atzfzBYqMaho8nC9QubnBfZ JG1nYoZ/B4yFzqiud26Glorijfbk+fd46Ic9Aa8jR7uyXpDljrLXAdEGYSJm8gyX4KURMsUKDwIL j5Td8HR2zUywpo5yiEiJykPjYoEPTo1c0jXjzRquGmohufOoqQrYnes2lYQ0HM6q1iObZZhEgAf+ wGufVRAhhIpO2LAaANyiUyoVY1xrmuIQTmg8heOokq3Ydq8MW9k/lkXdItJoLVex5SLW9RrN6fbr cHKO6d5NwV/9HjRmLSzvjUFkq3ZaQhF54o34bOLI2cWMGeIN9aOCBTTFX0ripmjW7jGEdDAt1f2W IDc9h2D2Xbvr6DbBhf4qspJXTAqjz0etwkkbvFbjt+PHH9BTU+DZMRgTG6ec1fdclMd7VZuYj2Fr o5EXgHsK55KGgaD3mudZcXYkuWgkso4TpK2je1JJ0OiHhNMX5Xt9TaaderNS340JbKq+laDJrctW yxiVRYbhKLiwAQ/MMNSCo5tKGCG0DhZdy9RWb4kZmWEOFhGDodRlIBhWxOBKmQaQJbKl6V6gJmMU WBNDVtdIjbtkyC6G9fzdqo0TMQqMKWmpmRrG9XxtqDoeqZISuY6bHAU+dxL4WiwR2G53qwJIF8NL x2ooco7uVOOXlf8Fl0fqqcWicQwuaRRGl+xRBQ1c2h5WBn+noECnIBaiTKJF/XrVgA9KXy0eb3Vb yHYxuzIdDfrq0MCOVktkKw96BkB3W4xT/P+FbD11JnYE6iY+0CELbtWamvm+OZ19Pdj+7Rpr8Y3j yyVzxLcYxQ5ABp7sFyRy4FTjeul0h/FLYuroYOglnLxiI7PC05dHrWVhVXcse57mOYcD0d8NEcjG kxEDjrq/OQicqHrsuYX58kd7KK8KzAXU0w1tyKxaCBuI5AXKzqZPJsit2bSY94+uYc6IK+LRgLI/ wnr0tvoapsgupYGYnBhfs80Ed+/Jxqn6uCk20kKuBRRtvuFenuXfM53KDGjuCngn8yMyGyYm8AgD YcYUDvM5yG+esAiqkXgB399slhQWW788enb0PYgk4+cvHh95I5obF82KM/RU7ehGBfb/XwLk7prK xhG57TOKGYcZo+Oy1KzMeLhBDC/At1ajoBcqzX/YD8mkGm+tYfpmeTbBm8BwvRAmjT+UnVLY3MYh X+lRMbwMGtcNYyNk4kqPZPg0Ti6TLMcQYb6msgWqMbA5rIFxKedZRXfN+Fvs2UOOsHDBT3LtPm26 3EadtuhEKuKFMkmi80v9g5hX6Qs4EjtBPnZKNMptI2mgh2bUDKIx/NDxpzagkmr13IOMGTaC752P TXvaJM8NNyrSVbDU5lwLTev0rLfpX8XLl0BwnDzm4uoYX540qQI2q07lZw3QoxbH5GOsgkqaQ8vt fRpfpBvXFwoG6NxjxPiu6cCSq/jUqMBg1WM1wWtZEHZF64giTxpWymXiPpxjExRqT9PVVQosVEeo Ug6XexLb8hwOK5eYExWP1KRF44RydNvLbWRcXd0jY0+kIl2EKxU3O2VHwlO+qIPvVYE5doCklgVG 7R/2aoscbb3nRB66i/Y3fx5E9PT6Lv2N734Lf3++3/9FBSJSyGIY+sFuTfpk1PdB26Vxd6NokbZn Rttt7ARkntCfG8Rr4OhApIBRcNTLLASH9x5CZ/NHNM+CNUAIzBvqoc/uCwsr5XETRRv5AGn5JHen yEC48JzZgawQGu4jdPGObBw/Hw9/e8I32se/dZJf7Mn5bVLk67ltWj856E8O+5P7/cmD/uSL/uTL /vVv+pOvUK7HHuxmMPPTnVDdtLs2/SgjMvhUtdun1G099lmh0DnVSr3EZ0c5jcEhD7Dt8Nu3Tz3q 49lCBioTz3h02KZcgLZQYf9tSy4OTZNrzOC7tRkcNZLTanQY+ZUBGr1iYVNKWHHjG1kXMgLN21tA U2sSW3XZRmnnhrAeRXtwKNJKGk00dZOeQSuefptRP/311kC4uwtN+26zcVZBiVj3l89DCkD6BcH8 OvSgt6RhKVY6C306FfvNMp2k2SUqRQHdZdNODhxI5gZJig0CLJZxvCl2syBFuL8iSO+0zC7tF2zS m7voU+4DR0a7CTVaqZ86P+AetxV3rjX3cJtm0CLhbKparRS1hppAMNSUfBLghNsY/iVhFHzTqk5k 0YFcGOnuHH2hgV9PCzIjjeMYXVvOk2WFF5lXyQK/tjRUrZi/z0mLt0rNm1RybJSRAB/pY4LkMjs7 X7W0hcq2bEVqM9brrYrlIAd5JK/dZtBeUDwpr7JJ2tJSr8BbK+hO1esH6g2cScs5zE+gzwnkihO1 tFT7mRJEIE7RRbLkA60cf57breVecJGmaOq3cb0B/AbabmB2sdRWzDnaSQfcEDz6vE1bzK5vuzn3 RBkqRUUd2vFzxu89dMNXH0+myEcwi+QUb4/ZttzyKuacerKi6jiN6Ny0VTcIhzrzbSMYJh95yAT6 Af24GwbDbY0Tnu7a8uNwa1tyWN21tUfbW1Pn5V2b+8v25swD765Nfr69yfpEvWuDr7Y3qM7bNzZH ccUP2qVmS/xS9wFbG/VuxI/k4zjuw9ZNZMBoqTa2wakc+CiyWYGHQPTd4zCo2m+P/QwakNwnSJ7x 5viSfvxxO1isCNkGz3bx4hbM3x8zFVuuadoNqOPqR/yUxKst8dEFR3fi4fG1ADHcUfbhzusfN5/2 mu5vJLPpkzQq2tEkY8JRdnv1Fx0B2PS4Uw+yZT79qZyZXogthUEPulYh9rRB14qNIinywyri2D5J UOnju/e0zniPR2vt1Ni3wrJU5+jsTuLGkMQIoypxnVoGqE0O+3RxRUIHlZmtc/6O0GYzM8zgecqh l64SMkgm8YTcg/RBBwQy07sQhZDCbGKaJrm2W6GLVkplgcDDdNABhfJbrIIBfyZ3LpSzjEZqT1vc P0lpik/irZygQAjjMMQo80KplqiKBSuK5HLX0J5UhQIwmEEfpEzJEP5fX3uirkiC29+RTItJyxUJ YuPOFyQ3myU0hD50wDEd29ZoRk/e0AAT3gkdiRfl7zdvkjNMz6mPKnZkcqnY5j7rkBEujElZsY+H KusmWfG7Nzm0dfBqJM1JMdUKFxUKGzGiSLyUBpzeKBax47ZE4Ka5XcfT29VkwGXhuHVgzzJhs0Ix 1aDTNZYJm8zDrDrCewJtyuFhUq3Cs9hk+c+2t9fveE8YJMw44OrT4W6w3qD/adf9mOPza3920/x8 gNZn57lQtzK/wrK1qIQ+HNT6eunXgHYnUbtdhSVZJf3byEMv/DuJ7/ICCe5rfABO6E88jb2GB837 My2Jhd82P2rZy/eRYiKO3ITQnhXpqtNE12cXWVU7HABEz65o2KqwWVA95eQDfzO544JNWqdEaWnH L07qKVPFdlvF5qSGW76PmW+ZXfiYF5Vt6QiDqum2hq1qZUr+RPGhdWGYFsNiYLjVNluGcxdgJQMC Ysf+Cz4vwjTAuGHI2Aot3LutYO0EP0HkQN65PbnoeFQyxhZAc2Z9XY571q+u6Xku3bPpu1sqcBpc GOBQl7p499vsRGTToWUM0CxmMW/jzr9ZUulLuGBtbeDrGqmVImd2gV/It6iexr4xpe6Uryi7orpp rql13xp+1Ki09fBLft43CT5UqEmuzbpyZ97j0fb1hEcfron4F3dIN3VzTAXwj+vsAsg3zVPKYluJ OKrinqAx5LwgjfmscBye1dJUN5J9s+XmotUNeebOkKTrcj72UVrycrldYPaQbLM+oY2229E0JBp+ 7BWP6wJ6scvscQy5hvVYuuhJC9EHKLE+pYLFdaoatpkGibOVGT0LjciGbtizH149GyqHZMyQWcFR /yJepCuMwXYPnanIMXlVAjW8N82qlfHObukVYl5GpPuHH54+Hgaz6cH0q9PZ/cF0dvqbwcGDw4PB b6cPDgenX6WTWfq73yTJNLHqy0VacP/wSzOeG3K44I8ZDLbmDsbn18Bkpus8HYqqxPj0DO3bHgkL eUj7Fga7vGgrAiBg7wcHbQUeA8pBiYODBwMYzf2v4HH4xYPh4RfB3QOoFvS+R00PvH8BzAyLmfbH Lzm+QpZW3OgPhMFT1d4hTFFw+MXwi6+GX/zWag/ePy8upb1tdk7KFkR5CX56a5A6r6tt+RAOQzR8 cMtCIfhXX07q0DIBbnZno6lW6a/3gniq8kFcWgJYS9BDik4/PQ4x/9COMWRY22LdsT1v8c/oOspy V1HTD1qrigq/aXfH+asRZpTV8Fd4opKIi2suaREpmDJKWVbJG+ajvnuGWlp+P4l2mxmjCdKh+dMV WwFqoRtS17i5jcnW1cwtTPaxlm4qRMNUEdQobAOqkTwAcfSH6dgam1P3pLVlOVm0NY4lx5rr2w1L 1ZO2pkmCb2t4LtmwOWv31QT5PRnr2n1QGyeeGD1S3WjrTnB4QP99QAKw8RiDpnCmOCqn35i5xQ0o 7ezitUVxBe0BzaDse6jmBnYwgQPED28e1UbEqFVOULfwAUSUo5wpu5QQzQEH8v8A/j+U/0dB7/ju 4ISe4jtAZ6xE5U3rlea1ulRgSzcn0llb5nPu5k/oaNO4Ot/DSzRsQYQ/XZICxWPcpL6VG9uI6AWT d/ss6oE/izo6ZyymSUn4cza3M6mr5KC+eDpXE5RYtmf0Y46zvUyZXttmnV2DIxaLICQjzmE3aqCW HW1InIcH35jRc+pIQxrZ6rA8dTieJmdElLiWXPXYSc1V2eGfWjGyVGULxfrI1ad3YPhccBw+QVHb BMNvNnWzTYeEtBqQdaPXuEOIb410pshu2HnjIm5RBGJHyqjecMEwJkEyhmE8o4MTK6AynHNdLb60 5kyVl63rnrXzsLxoZPLTJQHb52hMdJ5cppxMSUWvAlz63AjdjSt6zJOAgoMVb0ldH+lWre1CVTu8 M+o7IY5CcnxS56unNw3SSm+1eB9A1XiKN1vUkLo4sr/Tepeo2AawVMn65qhTu/tLVrNjzwXWibPl EQo5OijPldYjg/ZoGXZaJAftMdOmDbQvgfIluS46fju6ka0OO1jV9tahN9tddayKzwn9UJPMzNp/ orSdF7i24VTUru4jLbCnt3l11tKVLl+33663Y+5end0OqHb1sqddj5aybVAki7TYDhIjP/hqcP93 b4CRH3w5PDyMv/zdb3/z4Kv/3VtBGNbtB8aJZ1i3wlJJsizHlkyy84Ao0sA2lBD3JIcaNjxA/BhO /bWit6tIa6D6cgdUbwVYEVE87bOnGjUXRbumzgy/fqZc7tAKA+QJMcHYr0ilBX+/aXpwKkrRN3dU v14z9OV6/9+8/Q+fffbZeLlB1UHMRB3DMa1XWf7+v327P/jsM2DeP8CvjIQCSt6uSgHsp+uzM+Dx yOCFPi7p1qSjf246msIRYVVh6Cn3M5d5LUFMOnLgeUqvjTOPKkC8q4LGf89emA8VJMpUwHDQlL9V bBfqrL1+nJ3OXvDmPA1oIVTAm0QRVJXxAWcFFZPrnCw31hVbs+An9EPREwONUaKsZZmqiCmoMUFu XU9emVLgT0p1PU1XqGxnD/x8fYaZlJMKmsmLZCp5VtBYQ6TGnLo8L4qLCvGHktyQl09SUYA7sYWF +o9xhZ4qWOAo0bFGqM6OxFPZMmYM3C5PFgR2z3iuRcA355wJCQqjBBIYhfi085y0PvmGzNPS+WlK 1sASJhOqQMec2XNauzOxlxJ8Yhmew0+rXA7VMHi3+LkP//xCU/Fu8Zc4oPVil5XVVUGt4qQvphKd jS3koEO0OTJgxFAnaZ2BnFdFr7RZsKNtJ/iIVAW9GPnqavwIRtaL+gH/qhlvFAlcKkq4SpyDrVxh LAN8Z/QB8KVTDs65hKmcY1CEpRLvMIDWWUz1mFRkICUnlDoHg39Xdupzs9VRMMZ9liyBJM8wJIS1 kpYsPibJu3XVO5Yn8FhwhONpS2BMg1KtWYJnoZZrRYJd2wDSqPVIyuBgkgXbMwIuc1QNJgVinURi K1mVUdKOrsijVBJw5YrQiX4B2HEcA+rwNJ1Sfg976rj0KDgwThnoyWiIXRL/QZU0oJcIaqpn1We3 z4WtA4dUb4YROS3TpFaCskW9gocl8vRyPLE7PiagTtyg5hM7iHmjwvDEk2mMm78LlfHuHIbhuTZn qO6arpKaoTca+KW1gYHbgKn/xBJ+1mrPkDUnk21hLug8Z/MAzI9zmuQYRQTod4k+k+ogZ05X3xCe OYIHY8HdIDMOY4IPduQOc9Kx6iA4ZL0h7A7H4MzatdZqDXl9ob/GGt49/HII7WI44q1BzBw47h4O HfUVw49L8pW5jy2Sztt3O5nQO/iVG2wGQ7leZtN1kgvJEaPDBtcgtmLGKqvb4IoEAaklAD8pEvri F1G/AkMIeUs/BGJASrOa31Cbp5rnMMFnA0qBhVQICXm0CG3ELJc5LRdeeGPGSzwIWkSjTK7Gioia c4FqYKCDcPRqhCfW+g9dF87tJ5pBkHFe/QkWy0pXnvNxH6pgueOQ5uAX/Ocv+M83oeMUzcd8ET7z rfFYqT/CJsRRHPXdIDcRgkooVPAwAb3+T+gbm8w6K99cZrp7oLJqMLycfzFnHRGgWJd0RFdThdfr yAZhzs/WyZkRYIyVDkHIiA2EH9vFRvGRW5ctQy9Q9sNkZBxNiqIcEsrqUHdJXkh28atkI8H1Gjgu EKWijHHwRDFPnuWh2JPCPp5cIC4cGL8nlFtRvTIvkFpQgu+Lar3Pz56LJdUyLrA/ZhigK84MKo12 sIuSGjzDTdvPyYXGuVQLAZ5SAlGToaivqpmDbWkmAJDgbohp29es9bpD3VIb0eAQP1SIzOjxbFE/ Poe68/eLO388INSV+Yfg+cQAHlMJHCENUQGwZReKCEMl1R5XO7vZt3/uGHUR2fQkePHkLzBlCIFZ buC01ZxonF7pwZ1SBXzd3EjB5gRh6dC9K0YApkjXoteH0cIh9LxYPKjPi8bnkfFDHRNRdWAcEq3S 8CDUigGj87WcejAt8Cw7wxTFfQB4hpGu0OexwcTkNiCrnAMEbUxyqERak6yKsrpHT4tppUXKbEpa 3t8e4Lx+Cf/g1BRLnOb7eAMB75DGVSa16QeHHMMBTjOkQi04eysCSec2PrtmRVwls5R85Bn+eXKN d3YjVAlSz/fuy5ajkbXUpW91Zao4INMK1Z80Uq3nc9Tz077XiagiyhejivJ01t3JvXhWVcbhPZmf TpPgehj0jBCh131MO1MhHcagpH193G/xvNX7ZcFqebupGg2kOrQMRN7qvbWGVJBbh7YK+DnSo9tW sgef+6j3+FOKqRTNhCV4cgSUOc3TXnH6k0F1GpfFWI7K+IKY8gRQKCqriOwRVGD5rtXNaIX0RQVz Q+tP3B2oUOYwa71QvgmptyVW7b9hgY3ZXpYk8I5GYYMhCbyIOhzNVF6Yu7BdRh7j2XesWxCc04HK duFgBIPCSwsO/bINFu9Jm8gKXu9abW6HrLZbRhxygFh9cP+r23VN14lm3/TiwzrXbd3ce2bhv9m/ fnkTDE7nVmM3A9A8p7UnaGsZvbr0wVfRB+j97YnEX7ZsIhuILTk/+SaCZrPFTbtIO0uJHm7Y8bd2 bGdp7IU9ViiPa20nazWHFNiFHPPlrDRD3WeS5ehsluXpNAYhw4E9BHHhlCKRY1RhdlI7J088irW3 0erzOAodX5Y1BrlF3Wusx/CUvLqik45pfWAMp6F9r61r5MWxsEPnZK5OR9vJkxWhtRY1nBOxDkRK qQtVTCjiY/DhFCeXQfphkWMA9sHAiJxKaumVPmZVF9kSJIiEYnkjoqjERawlrc9ZHEWV9KgokWSY uWZVSAQEBQuewuZJLiehpzM56WH4fKxJoOG7jT52o7hBUeTRlnvFCbZxJPYpiWM2QQ95dqruBRb4 28Nz5PrHDjTOk21eACAoxkbAAiTBaLkpAvEVpOjaCq7EozopFsLI04Ws5JY+qETdCe/FXXpBJJQl NLgoqgBRVqQwHeilkJDEPiMs4L5wI/wpLQsUL88M8zVSBrI+YXGW9mDZekqyi/okizJwkeemF8oc ZyfoQkBl4LlJTmx1HM5T8E3wxX2nMdIsHXiCdqgTAEnR5ErgpNhxVhxoymvAY8ppBdJnjaAKscPt +W5CA8/RCAwQi3KYYJZVVL6fF1ckz2b2SUtwhmfEiZel1lrmaGiZnum5potyPdtOEHx7jXSdyH+P jkAMzHUZ+BbGryttWSB3kXZYGHdx7m5bHZ0jLdwhHdEHrpG7TsNB5jOQNxdLF3EHYtjfNpOK+ex6 iUTRqlkZSvs7Zl8icKya0ckNethdZR6L0bRRGMXRYAF/0BONAXwo2ig6xFOWWQFqL5huMP/CRBFo urZK0+l6GTDD5874oxDzTvN0QGdGQ4s3kkvjeMkveRe0pHylA+a2yrzT/LWbVOWJGuRQjbJd6EFn kcnFEPZIulptXpZ0x6v7jWodBpzwZyTT0JWfASw76a8wmtOEkqwgfyyQK+JtYgZn3wlllD2zgmTz d8rVzSrHKzJJo6uNGE7LqQQT2Pvq8LexUfNhJaHyWZvQt1cVRYWzdEG3RHSNvaZQgpzzHphXpII3 gIyWYkxICoGgfiBpSGB2y3jLsgro1Ny1mYIP13fbkrZV5LXdZTmD3gxm8hR1rIClMqs0MIrBpcYT GcvekOxNa3w7siOjdlzvfgP8fmNAUbT7nt56grT2tFcm+hC2vwvL91D8hytSXV0jxacNhLa5mC+n zTVU/YfJdPqqy77uMDppuRG12Ok3Xm7qAe8ZsgTB0opjnNLu64vNAKxxmdCrISmzOu3gelRuxzUU J32FQbkF6dc7QeqenF4Ro7oF3MG+fSnqUfEda6A0rE1cRIJx1zy9+GhyO19zgtV7aXLkxffVB6I6 QWow/mBghK6jjxbTJw3sbKUwStf2Lo2h9D7S862vLqk3AHzomlcShRT64DTe0oGzXESSIgtGAv4D gORB3wil0/ytwdyJqLVqhm5eZU4RRc4VSi4gtluxDVmv1pWJqppNnKnH3oWQmYsTpt8XytUb1T0z 9Y1cWGmfXJzoua8k9rJfbvLQmxeYnbwhAMvWbUqxrRuJblDQ1NogKvh7a+ePZEzYm+ZonrLOtqR+ mpIS8U+e8Ytt8/a5Z96IE2wD9TEUSEstDFnQ6r7sVnwtORj5M4hlAtYveOcXkgP8DRnePG2o8fyi pQLYWIrK1HraQVDjXUfrElXRm3ZrG2uydqpHHnFWz/bEa0f4GrDIXuzIGKKilfW4ZJC1rKbHuBNJ amVkn2SUGu/cYQot8IyznVIZulCgLPO+WAV4D1Ik8YxYgUWGX1iDOzjHoKr86XhIBRmHUL2p3tPr u7jHqd5QEbkS3QnHclFFDd2leuZ+NHizWcEBl2FZpFdS65iv7Ch3LYvsbCs6pLO0swV4+OpC8Iv7 UdMQwd6anrtlQxkQuqqMhgerv/4g+NCad5s1ZSqce2x1gX3ftglwFfZO5drPR12/8ffO+//u7b83 DKl/Wi8y9E55/6/f/j//K5lQU4ABPDKnFKEYr8KJVf+nH6DkAEPlMb73abKRX5BJyx/W00psVFHn OCUT17OS6WCVlpdkltT5fVJRTLcA3UcyzDiO9sakU31VoKdJcpWnG86JVRtmy1NRqacyVU/VRr/k dCJ7wUs52sZvCZwH8JdY/Co7RevwDebvwtBp4l5L4dPQjuHr4IFl/j1NJ9ryG5PudOpZx9Q753hR Df/qFzgSvtDnuAF0QCQTc/ai+U841yihoMsO2gTQDbogAYX6Qeh/TMnU1tRvVOtTvL0tlA77MsEU CKrLklO2JxPYa1NOVAbN4EIdxgeGrpxrkdCFxts8SbRWcRD8gS6+MVxnkk/WOYaf2JP4fqxJITNp IyDzeVJOOXUQEEuxJUYzBAYHS1B/0IoYD1RDdIUvg+FwFOxd/y74M/z7kP59DP8e713fPxjA81dP npzw76ODA3zz5MmTxycdb4opKkbuqwP8CyWfnHSAf5wl+Zh7HQW9g+uD3/UD+Pch/TuNVAmZt5F4 I0DB+wdY5KsjOT3Am9/SGwSqfodw4VsErH5LYOBrhgM+6I5gucdke3ksS9br7leD/apLdgmMSr28 uIJzr/w4B97gtSnALYdF+wEVwdW0RtPxuw4VV4DciPJAMAWGEz9057Yaw5xMvEWy6nSy3GnCcNBU Qw2P/3m/OtkqSBr7B60R2Sbb6gnmYprmFjTmCxm78UYAJK55CiwTf7NVZS8pz4ywonjV0SOnS9u2 AW80YDvpT+whaYZYJ0X11yNCBK/Ngh7S3vX+wf23rBHemueuWe0Ls5ryLmQCUiZXPXsBYqATqInK +6qMMeRIPHXVfed0KkYT7DsoQ6dRKh+pEk0reNxd5LcZRu9k7oCeNFFdI66bCwcDxVPw6kh+Dfhn QkehUZcivXetM/oUoBp1oRh6InWBtaer5DIpR135LfnKOLKrWfE8zZejLrvzB7ozIMMbCZZTrjgv VrKSpK4UOeAG8JdlOsuuzRHoN1sGoYEGJnAzzNAi8uqAWybtH/IJ9qSFzVcPhl2Pu/YSsvnLWpuJ yRLKFNb2MTyyWN6rFD0YlXPBfA1pOHzFjHvIq3N0jEWfsiroXWPYFi1Uq6bVafM8qSiklDJTC6ku 3bGa1okCB2IpQPWsOAPe1JO2+g6UxuRHbgN8Mz8HmfgMcLNMz9CQQPVOzdsTtF60T5EREEtDP2Yk pXDBxpDNtLq5OZjt8K0XGkKGTBzlF2d5Okb4aJ177D3MfWgf6mt9BduNlxvApG7XIMqCIAAcnR17 kVhd0nsUZEb6sW7nHrQSxqEtE2Ipw8cX14XNFqJtnr64m/qCtea1NX+RTJa4x8g3ZooZnnr2K9gj VU/KR06Mj2YzGJuH0nepF8lpRb9bWpD9NBIQ7Y84845npoQTqVAyVWmJ8VxAPw/sYmz7oYpREuKK StXzhVsKe8E7cJ0PF8mQMVdqpRvowCXJpTObill+d4iBDWpsq4mEWmi8trcSgNXT4BxOdN0YZLm0 XPUO+mbpyDNZ6khB4musR+Zvd9SNu8zA664cZSwVc5gyDwOND+yyKNKPdOQ6mhtA4+mazxWwWQ2T a9NmcUwei2NoGxA9nY6ZgLatBgVXTJYq1VsvhOKU8a8sXStrEINVPEErba1qhpPPqSJ4vcELCmMY iyaw6nUfCVyYsJOy2e54C+tEWWKQPZfwBpR3Rwoa95q9LtRsYJWcGRSSVh7J+wbI2XwQ3lU9d/wu 8Ywv0EbPlb10l5G5WlJBAs5YcliNhhRAWkqSAalTfYw7uG2FzS1umaJzHBs/tkgrjY6QBiBPaelr j13kK42xMR4FUWuB1LhcoRsXXvfFpAdqhPpQTFVhe/cqqa6xy64vfbtMSGMheLMKGevB5qqAKYF8 hQ0N5kl5gSdMPOHTpFQgdXIYzXSab7qRJ3KQoojW7DWF2MYA9OApZdqynJRJdd714KzASKeI5qxR tVjKeELqGrZPbrfqKII5dMvoNj3vYKBb1/Wstz2NdVFnV8gHu/SMdXG8jgrj1Dq21lD44PTgwhW1 IhI24vkqbO+jt4741I9TDkj/6TeQORaeO+7qhgm52QxGb6E6LEAgy9J1BRARC2i22mZAbc2/yhyo zj56FvzzIM035sGiGe5EbEWBX38ZifhVIAcvP2gZb1i+D6XjuyyXamdn2y09ZkXimfJ7ht2kcShf s0yDOLYo+rTYcNiuisUNBBPlUF3W1H53X/P4hoGPD1jtOzNQfzv+3fAk+lB22N2vhvvoSV2RJ/W2 Md44yavNEmZWtOlYr3tTDbUcdSfNtM3bNtIH0V85EpdrOpqM4eTERbYgsKwtS00NLq+QEe3G0JEe FcTdYbDHKWJS3lr3VmlSTourhV9QtI9KCuYtMiXLeG5BkgAEHmZUng12c1/OoD7Xg9oKEdMlX3st PqlGXcXWtw1Ilv6DRmT2pXC/DTOEnN+IFaj32YIZt55r34K5sNtSw4fNtct32+aBbDYWSW6yp/R6 Quxl2M4ftIoIkzk36JZqYMvputMkV/6jtl2GweSMWJrOqzEE9LXbQsOMMzuPvYVycRHVZjdqzlmF yZ2LBZF4NzIU0681Ein6PjYjUVIArtb2Ztkiq87dBqeZitav1EHypqEeMtVJUSOcoiqNnmQwg9yG w48KvDGBo1JWVrqET9+1RFMYozc4K1+FgDcLviEbhevVbPBbw3RPTUix9M2HXQpfjqdpTojlVhz4 J7hWNK3nSuNlnYFNsb7jDikmptILv/4WNaVyTTrqHsYH3XpMXRpT99tvwqilfo3FBJ4n6Bd982iH /AjJ+21k7L1+4wAE5FRK8NjsErj55bPQAUfdhPCM1Jx5VFHd/fjBDIUGd2nqslGsbnDYX3p0EDUn aJIXlQ/z1TXLWDy3hACp10y0rHi87ieee9hCy153gJrj2nIaFxN714KPs0He//dv/xdvjLUin+oo Ye//7u2fvvvsM3Xlrs4h+g4exKGqeXNfbTDbxAIviFcduV6ne8JSXbDTjROm9SW/JZw/AJyL+oO+ qYrNYGD9wBt1rdNB5F+dl8X67JxsY8zoagBheq104U8Yk1qV4KiebXCD64moUikSrzyvTht52uxq C7YawD+q93/M0itbD9/tdvElOYAz3a7d2h6hxUyCNgJcu5hRA2RDvwge4XUuX45hqWVZXG+UayIb 20sYs1S9vZbL/GSywoAoulGJWQLVxf/0Eao3GbtyRv9T9K0L7ihQ7mC1RxQyDnG0DkFXrjFE2Wma F1fYWREkl0VGiVpmayQ1HJcg5QBylzhwhoISFzbh6dmjf9THzIAyDRLzASMU8PA8LV3LZOroaByu ljMp8Fg5TqwYrHKvFHdvvSowRyNbR5RkGrHA9rC5FxTchwMvUDCGPLsguZiMLxOjM2gJSiEis22M 7gT3g+CgOYcZ0PN6WmS91PIROqjMFmzKotuTABjUwHgMNcbjGpBYhb1JzTkHJJVTPtqCNJZyPMay 0AxFROCJU8GJ+EoPcIgLXaQbKMezCjD/fqPuR9ndgzuClo3OszrS0bzA8zrGuZhlE3u9g6tzdCjV oGBmDppwd5VlxywKqD85rxuhKIHa76SCMwt8hQmbUMi7OmJPUio1uolMKa7Akzr4Xh82HcZki9ix lI3h86JgC9UaV7khgh970OCPgl4cx/3gtCjyPgb/iST/JxrgYPYwiiuOPjlo1odB5cTeSHrAwH3+ FoGIc4N9tU6LgD7wcPrwrOYIQx1uVueIqewgVM/lI0QfIF1iqVdl07Rke6VTDpEky6p2VU6C4yq7 TDFa+aoNvSbJAhuYlnRHf4o+1BweK2GuIbNlUqq+aZBkL3YfW8C4imVGNkoGCsYSqVNiH8qqBRIL Ci/kqbWskgCatfsvPVBDFB25DvdtzrR5CzVe4FtKuUSg0Uz3gztJeQbPd+5cXE0rh4+gOEnDixu1 Hc6hNvDISkcrn3QlKqB/dewEG1JYT822vKVStm6UX+jZoAQbt8gI0WyKcUFtjx60F/nSDpjzKzdU mjHjDytxjUFmG3Rc0uOeZ0ChYcdvaJqYAiPrMFsBCo37Cz6ul6o6L1NYId0XPumCqy7Q9IrKC4JI Ax3KSoaRDMAcYb02/pC7JirUc2q2QCZMdRN9TsSiptnyCkfywkIaHIvqVRi6uVkqMmzkgjCkeVnY q9U8jkslG0nIIjpFs0L6PvQEdcI6j6ggiRs11Air1H0Uq/130lQyYCO+jI9mpCfXyfTEmD4HKfUM mtu2BorD/vYwqGX9ttfck46jizM2b8Yd44qrHrBEIvKoUesySJSMGoYhwXmRTdKqpgMGprg44p6e pa7Xgq05XCeWGZyWpT4H3/K2IiXMjARNtNrDc8QpGnzjjtRBaaWur1k8oPTCb0OZOQ1IH2i5tfG2 B7rer3r7ZRTqU5Q1XCTdcIzF5TG3p7IBcrBjolODUbQu/EDmX/AHatYFkTzbNgtoF6xlmIXbLrfk oMYmS/OpWbFTv4XSnTpZmIoKjW7bJEnro8hDyS+xwtDHdH4hcSMJZsDW2etPZOfYH/K3DlTC8aXG cgqT3TUrbU1MMwYUzSIcs1oq7AXoUjsgn1oyUudsjAhFyaoltm9rZ3ZYEvP1wanzSFfq2Yvplo/V PQLGx/8awfsm9LE9JtU3FZ4UdECVg7ABxSN48x2f6YsSY/qUEdJgfO0N7wfN0PzENGGTohF5yzoV e2LSOuV9UWufGBYRkZsBQoBwaK2cmU20aLwqSgGdXD6M5oyNWq4Xt8QCzJPHWRN3R4LvSRKUGP34 4vVqvuodmyt6Et2EEgDq9kXmXnZfYFnX63Qy/qssrJ70BZBMK8Kun0p64rS7axxpikNZFC2yIw0a fAxnHstZxINThvlxQLKmwezvUwxdKlthBASWB8/y4pReICVnfUwy35IeTg2MJh76XsE5r2dsL+4v +sRL4aV/0DtDv+PQ/2UPdTuHsMYqGWX1UuNRt35tTYNHJc0Xwfox+hcxQVt4YbVeYnIRPaqIgeNi rlRHw9Zbym1qG9kmXJKd/Eiil+6wmaXoTiMRcmxLJgqe0vLULL2DJOWIUsf1qdx9EryxjWJZtVqy yTGNeY8vv+weekuXq8lagqeg9MoOjLXIUbWFkrcRyORyu8ZM4pG4U0NvmzzpvnduWta2q2Kodhu7 pZ5qU/Puzm/cSNHQ2LPdMXKIEpXj7L+8j8pJ/Yr8ZLF73bR9LeNuy6bk0diT/d3NbR3YRjRibvnD WqHhjHhulDBjT+lNRKJJKNqIxU0CmrGrCCC1gR8uprtsXii268atIxJblvecsmRZ6l24aGak9257 e8dv3fUuBOrC3cXdqNOOQcaqd27cwUbh6KZwdJ4tF2Kc8EAiwLMpvQk+xQyIQrVUL8pdVupF+V8W 6ldZJJiWbWvU2UP9xg+cerK+CBqNOhirMsmzy5TnmbNVKSUxPC0xSn+JbtLBz3JrA6Iv4Br8N+RY qwZRwYewr8s9pQCWWK73F6dUJMV+iSnEAWoUOtoYhCF9WKKRng+rmpjFKgTDQaqJX+ZwRvVjtAPy eJj7jRjkWay60zqLtH/ybvffdsS8HWOqYfwwtoIPJnP66zOVDqt5Ba3V5q0xKpLd8PvMsx12w/+H 06ngf8+VGe42eGxkbIjX69O2ioOtFb9f520V72yt+Di7bKt4b3uPResY97dWfImJ0ltAbYfVTwd4 jf4mhEAi2HgIgR2LT5VtJQQqToynJSc4Xx3f8hZExdixN25YL9lB4MO+DLidjOzcHo0g7KuRGO39 LekSCc20Th8vNPPI/vOib8ZOqVVZmHTvyXox2ekELGVtbUdR3KzWMS6EjKkS4yNsIQo/VnlxO67o QjEyz7J/YzWImFl5iAHZclnlvGSgXTa+5EAjP5ubcbYIh9wWD/8Xz/pZxXuhJWsnWtBGUwFPSH29 9Anro/+Ybq6KcuqRZS/4C6KbrfHTzqL0CWHZwaS6bk3n0zDbsec3sXdp0kpfYZBKS27Myv4UdXR4 W4hTbNfAN8dS7YQG4Jf6FbxZ1ZIvQdbj7kgDAbJ7P9wWSVqfTJJ2st1ikK47C/er0X7VJyWkwNhX EEQ7dc4tOA200H3lEo4GwuMmRunX/h2iP0f+WrdcVqwXbl3MumXPohpzeAcPYe3L5p01qmOA7ltA NV3Tlvma3jBh05YZm37olKGd0PYpm+48Zx80aVRpesO0+fWHvf0qamoPmc6amkN0uPccpe1VoXHE AJNkB+s3sqAp8soPdmQEYxq28cabtIcgT9sE6de+SBU1E82ZcRfC6IM6CFN3T7KDT3Vf6sE0r1Nv EHaB1rxb/LyP6I5PvxDVKUHW7AeeCz0Wgr4T26cdZCAp+te5BfAyYCrN1JS5LoCz/Xrsg/TOtz6x a5NkjxUdXzx8n2zE7LJODU1bW+drhs8cZmT6re8KoqeRRw3a8tUcj7uIYu3Z7nUtvSupTsvlRVMG t+8ClMWcuzbaso3M5di6BilGGHU7XsemsZDRj1kEsjvmqRsjVHRZ0cXcwXUPd4MWjNl6zyH4RnTR 7KEf/Uo49Vex9WgQDdlSveY9kTVnkWGzkc0cZJ4UGOlG27ErwbfPVvB4zkDhjvxT0mplZiTQM98L 1U2eM1d9XBQM1UpYThp3D9bKBXoTJblmg2hsuTPGYYzVEPRyqvNXo+9brvanXW4XVrRp71gKdeP7 34jVkEbxVTrQ7kk6WRdlj9CmPqRkVLdb5BW00wUXldzF1ogc6r1cCb9EVjkvV8KIbDAISWpBmz2p APUkW+nXxrANGyKbNlDjN5tZqTZRpGN4jEDDW2+2jA6iHbgh0wu/L9ZfXXuj1z47W+y49lByl7X/ eInkxiss3yrGcRxQ5PDGPYTPAm4A8Cvk0pFkExrj3IwNhZNkTkCtI2G9PJlfNa9PDNIzL6bbjeag ixO7/DYzuR1M5KAFn4Wch/ia5nJ/Y8YpCPk4qyZJudN1uxT9zxclG3goY6Rl32GAWG6X0ZHpM5Td dhlN3xszAC+jRrEYe5Lxs4E2+9Lq8Az+tA8pdRs3TCGNEPSeVI3O8Rg9mIZB18nP2FQgOdVY5kW3 0mo1LdYrcbjuclAT5JskWSKyTwxj9FS5ptpaIhrz5DydXPQqmW0KWVqn5KJ3TR0av2b/VnRtod+9 w6hRQOW2fEIFDFwTRCV7cuw8RGQMrUTdhq6TRTbbKFuiyPvUu4SPtXrXogdePe/2vV7vcylneQnT +4av77GhfWhglWedvWzX0CO72g7GgLQsFQbUeUwlsEagsKEFWxHn9z78P5DAHr58GtwLjhYwv8Gy ACGmgpcf3iBho5bntNwrV4jVOWYUo0m00h2wq14DBQSxpI0QaX8YGTixx1JX9wwmnZvA0MP04Emr KTCQjzvjMmatjoa747uFg+JeaJCfj0Eu5XDm4tetcNpM7q0ijNEUAdJMatJmrELD6LvX7blI2CfP cIqqk8HfBF3mSCBBSt48v3epRzakRH/jdJphbGeiXRhGADP2cQBiCnkXBK/XZ2d49isWQP887WGs ATxKCkUx3EBO0xkGKxJhCD9KToPBgH+PYKtki6jr26xW2l3EWnSFq84w2gsuUE0+LRJG35p+W/LB QB47EbBqlNFWMJFSXVCcztUpPvdWp2aBbZi4J9DXOw0bUMxWciGeElenjmONEMdKpVrrWuFkvTqN 9WkrUrnoONoyZ0Fw9jOU92xp8pvu+L3erjmAo4O8deL4Xlf3IkuTIpYsBpIdcL8kpnjdt9OsXOu1 +0h+j7MgHNaMioyZXSRttsofw2F97bydVA6DN98F/h4EX3+tjG4V025LJojNsN6cmhA6w/lZukaU s4Yw4KrwUfOCyWIM7V9on9qGapOE1tH3eqWSxhz+ZmhlbaOcrB0tzf2VhYvtPMHHDn5F8uzy/g5m IVGrQfnT0f8yW4zHkkF9T3mm11FIZr2mj82XtcR85vn8oP583rv2ODIu0NM/FOMfkgG70E1wB1tD sL4U0iffiOr2oubL3kxcLbAeENEDp8yMmzvTdTHDwhdmiQy/N9rG6194SZUP7E8Gbbh/98HdLwC9 8iJZYQOMhLByXaI+dr1rNa66lOC1jA5QoyiWVSjVuAQwsX4wgdYO+8F9/xcG3uxqnlz3jrFFGPcJ jeELG5bwPM3zIjzG74QF51av4dn6gq/Bz2kW4Nv7ztt/89lnnwHWYxQ/DN/z/t+8/df/E+Xu6Zwm VTbBKENnFLlhvZhwCI5staHgMVPOzbosAbcnaXkP4zes5ymcpwCeOYYAefv2LUbWydlDjsIggIA3 RDU1XjRg+vQMT16YIQ77wbyym28jK4YUR/mHT/7IZbg9RgA/gv/6zeMXP7zx25lM09P12S4FMeEb oN6ojtwvgMS0E7s0xxgL6aoo82nXLiKVPaX8QyLo5RlzT1OQjBFF1fBby+w8DGccVgqkPiU6kgP1 9xzo7cZY/WIXUJFlgRtoIlZfYWjq0Ym/yhfc+KemIhK/u8XjrxtI9Pd5soTjtlLaUvdmtCsKNt/W xvF+dRIQz+oOpTkLYCvQ+7halduDI0hnkQp6pkZQ22u9lO3QCLoU9KYpVJ9g+KwIEUDvHDr1cG6l Ci++VPA9deNGW2NaM8kCdl2odluoAq5ICxSIhYReirMyp/SLdLCvEYWPeX0K4AULmq4mcfBDRR5G MJqKoqtgzJOXm5ebwWF86EQt+V4Hn1ZPwGAQqhyTA2G+pzKYrKtVMc/+VCsh1Izf13SCQp7cjG/y NEcDgpLzn1C4E3+I3LpeSKJR2Iw4oTCVnfbVC5Gk3HCp422oXRsFMXR+0yC7yEjFtBlb7/296jp2 2V1DC3S/FlKhsBIEuG9wN9ibQY8x2hYPxYlpCGMPx6HKIeJTUtoXzj37Oksj/8gJ4eKABDuNavat hVkZvnTsZanaa4R5UR/MoWGMLT2uOw5Bw71KGpAg0XHWAbvpXLeE1mBzJXSXyGjcq6Kga2RvQEap B2UtG+qV61rOxJuXYdiCOBU3sQm/cm1Fuu2mhEBrrbBY831PILSQ9zZy3rZXYSB0QNtGKhttALFc blSy1RTNooxG+ny/diMg8SRPk9INfNcstl5OqWlq1ALcWoGazjgIICNJ9DIHFNBE5Yrn5E+adHSc C6yMaTfF1KJgIhRwbJ3RoaFuEkjsVZJfUPp0OimRoFUWc7s5aADPyhzvCmPC4J1LvdyU354CgzVh TXyECHFLH2opYzwWVVnjhWIIkYrMWbETKtcJ11Gu1vPYDw76weBwp0u9behyrN4cD7OTE98lnz8g FAs/Tt7M7YgJWNELZcChTrU1Vt8N/Kla8aevZ9/BJMy2aKCRxG1LrUWMrdndk2hS2Z+Y8FA0vI7f ZLfu3tZneFkd8HtMIcUstMH3nJjRHoaqacwWpqqbHTe4JTXrKGIMNPYEH2poZTBK036piGMSiDoG 5pSqdw0L1qpv2/vpFTAoq84+ZkTvRN5AZ3vPehrKJCNfGZXCML3INHwu3e4wvBJ7F8bF6iuU+XiN FCwUvQSEtQGGfaRB6m4djwyDYD/JzEHcQDD1bjvhZG/0ktUt7nbozaszQ6w1ovQF9WTUEqjJQ1kQ DXrrClctpEJhzT4bVxCoBsPe7nbfLSRjXVNyAoAtHteTWyhzr7buUm+L8Q1VdfvCvwzO1dqeWbRj 8VCpKSTK30BduNPBe5JHAkoFv1ScWVzuxqEDj5saJ67KhDIUY3glLE3oFKkQiGoVPMK4yeNFvaHw f1Yjfk3AmtdtMz5taAtTszqGvA5dsVvCYc9axbYaC28Q2nAKTPJat+9gGYiajGctYRu4EgA8y9fV eeiLZsHN0veelsBeUr65rSuzOk84fyJHPSW4Kj7pYe2ta6MzTrCFNV9lebQC0zRPNul0zBF8pVhw upbM9NYVWD0gbhSP7vTgmUUxtsBZVD/dxdSdYDh79exeVNrwtaUCIMSNnBR59NKRReeSQtkcBVnl JexqfWV4yVhx18f1jM4tf55fGzEdzsKtdalDb54Xcz4+CLm1tW69QDfjNI6YNU8OI7CRuUbh2rTA JfS1tYGH0GMnR69e3a4TYB27cxOxKNmg7vHmHiicL5UNpkk6Lxa1QsSzK4G1FSVqStm5yT43649e dYFRleb/2Yvvxk+fP3nhJqbUpdTjp8dIEItgBmMetvzpWd2T3EmzChOKsu0Yv+DRoHv0/dGr74KH z45evQkevXr6JoDVDH58+Or50+ffBc9fvHn66CjAcQWPj37/w3ddJYeKOQ81Mwq6OHq0aaEXzYsV pQrgVexzsb4OlmoNQL5G1uVLm1U85VB//z+8/XeiH8+KuEpgj6TL8v3/+Pb//jsdtt4KTN/piBhJ ehlOagRiFP6bZ6dOmHgYCNfshVggpLBAVDCssRP6fIV2r/IlflUnD6HThRG8mjJ64XdG3TybZyKC scEH0t8KDxVS1iAbCUWyneTrKaUL5mBrZP26kIkiX0USZKfBdF2qgzDiWa0e1PZWylK3H1y3hZnF mpi7OLXHFnOiPVW5Y7U5VukQ5HM/yNPLNLcC9b2G9Zys8g0G+E7wbA3IXiwoHfEigTW+4jz1leVf TgCvm5J+N+yqYF/r1vOrtaYF3lP2uuE+XvmApL5uJhgMu+EHNRp296tu6GvU5x+4E3B1Tt+w2w/K 7rvQ4BCV4G/v+nhIazZPrvnAdWKxETz+V1HwTWAXciaTMtReY47Ynl1u8CC6d88JLvVTXdotPMgc szsDygzzyl8fI0DX0eCnRlovJKlSCm1eyX3vmMHH0g1EdbBPS7Ot6NeG4SZVsNHaLMXN4gtq3FVM NnQoe8GbkkPnXyaLDI6KBCYnHEgwP8Ca7FESyxScMzysLAlMTQ523dM9N+xW3RQXt7VdneR429AP tiWykLrK5UYn1s4rx1tHQnCGO0QkUN2IlJr6Hf63j+52ZuNGjxpQn9N5+PXxfoW2lrAdhbhynt8S 73D3K51eYxUcXO9ffxO2hE7j+errfgF/ao26YaiRTWFjRNtzrja3M/CM5hC9GxpK+rZz25am4u6G vtVOtXcrHcuFS/coPL70Mrr/xYHBNbV2lyAgRokJlKEmzb2y8kF5ptb2SuB1agRNNjgVAN+/6Otx YsSYpVw7F1WcuuGUm04rzGbGxyiJdEzh/mouS+yXTypqKKFKjQJcbQUbm3nXBCPJg+BGVheiYzJ4 NSdWoIQemJNC4OPtT4oAuXPizC00TuS/95SsYl/4i5U/DmmalNPgfvybAFm2xfr3YIiUj6EezDmU zxWpqUQo0kJNVL+uSTzjCa6M8xVFl5ZvnN1hFBz+5sBUplQ6ySmneX7/b9/+z96sRGVKEvH7f/f2 734h64dXqYjI2vzw4es3pB7n6yQKW8tZpPR1LZ0HRBZMqpV6hEKLQv2ANstVUeQ6rxH8UY/zpKzO k1z9LHSZMtUi5qpcT1amwGnlSjKSJfmzHalER5j0iEKKcYGAsi7grQCOeoU3yJtJxY5q8IQfMdeF oQ+Bdigf1Gq8Ss7U6fTlP705ev1m/Obhd2goM1/G8p3uy7sD/tzt1FTHVLBgVqfucrPcjCVJGBEy 8+CLpiR4JMBCEgocxSlkJCDErFBopfSRPyWXSbdZ7afN6rxYdH2W0lJisjSKXPLdJDRuwtMcJxDv AdrJq+EhhcYG+9jC8cEJ/z08URdflAStT312Oi//6dH46O0bbCaGQeFl53hMRh6YTQe2ZXfSRW1F FyaCCr95+PQZlcayBhz4g5rqdF4d/QinraPx86Mfnz19fvTaM4rj4f0TTErZu98PvmJTK7dI8HXQ e9APgJA/fP3o6dPx09fjx0dPHv7w7M346PmjF4/xEOdp+OAEKj6w3ePgI28n2Nx/KIqLhi7s5dHL Bwf3g6eMm+eYfIaNGWRbVrINOQb8bleYkvfPDS7CrIes8ao650qt6yjTs6yCPTpG4jxeXpzBGzYz rXr2PZDKLKiuL8WFwAFjtlgmkjGPvqPFyCw7w50BwPe6jHGkYqm6UdsQ5KnuH28WxzwM+xY8WZ2P mgoHqzmv0sG0P66BqHRCBwWBEbBjlQpkakxjWSX8ZBdkg99e1wCbZE1gujM0BWWzUltziL+we/IH L1k5AGjfDwyzTUy6I4IiFT82IzQsgbs6q4+6F1Sntl6u4/FR7mGJO7+k5QkexA/6umYSjNFxrVrC kEi1G4ntjZtNIlljGg9gGKd5Oq90touCIipyliO8zY1t7U9CYFPqD3yOfOIZffCku6iHjSXMdBc4 cga/OWivzDyb9oPZAi9Dq4lQcxPp1MzztHgFat7OLTe0PnxT5g/T9vVhyHTKQ2sUSzKtqSbH9xup W/Abj+HlP40fvfj+5dNnR4+HvggGNn/jnT8m72Tigt2WUASzhcxRo0Zv5gnC5j+x64ZmCzvWiGZ1 MI7P9Thev/jh1aMjXxyHxwVm9MJTByBmIpaXWRXvtAqevN0LI0EqWQ0BKvVlYy5xu5DxOmzOCOYe WT3yMsO4egFChOA1nLKoGYkKvjC9lp9WDGkiOcWBJn7bVFcDvcF7pWxFeVlnbsy/veDHFFbxMhXj Ocw9RqLybJ0HICSm8JJ2pohCFadgovxjU6RKC6c5kEnRPhPv8DcTlcFrF1bTvrWAoQPw2uWQeYQf H3A/qOmDgmTYgdu/BQ8bFJcq6CzteHUhrguwt6P26IDNuODb0bZtO88wnWjeFt3EZnBbMPCGIfXQ DUjy+bFZ8mSOpw7ggjzc1nE607BHGQvL9P0a2oaWhFVhui5JuWjgJqWGFAkF5PqYD1pZZbSmbX/m yRkmdkTnxJWRcBKkimoIzSd8/lL+LKpRla+QGxPuyvn2dJ1aZJeARoj/SQ6gcV45q4zRmuLCiPQZ HYVx/hDEzYTamK8BbthAyRWeMxXMBazYaSZHQqM54GqTdYk5DdWRQoanTxV07yyQ4zOeMGKdsLNj bbjJxSbAxcZmp0RdYNhXGHsmW6wSyZk2K9DelF27LpMySxarIa6fCVVCmAJdEePOr5JNRcY4aJS+ gpm+hNPtlIf8og4iW5BvmUyAlQCumGdQ9OWL10/fhpX8hvGRDMLBRTI+825qOsFrOWLyBfLytFis xpxZ9xSmCleg9lCno9Y0K12KWxMByR1N4Ub02cy+16PGd+DxmJL6AjNW6269jPzF6xYm7vVTifm8 6yFkKTJh+hofHb19+vqNn5bsBUcZHec5J6geI2brhmNDAfQcUxQn0w0AmGE+6p65URwhrJjPKSFk xbYHGSbZOwXuc8F5RxPy6sIJJ4+s4OkiaG8sp+il1BiiY5jnQXa2QKc/cmMIZFURnbwtLM20fhZj pz14LHPz/MXR8zf9QP968/jpq5O2uXqxqDcnsljEbaDCaHyDVJHNpPTM9YmK5ZuWxhRrhLGVQhb+ lC2J2vlHpHCbg2fePLSHjx4dvdZDe/XiyeuWgVkUX5Lh5pt6IELYg8a+iD4Izla+Zml8GRFVMCjd MzrD4EsQ2h6cyEkcz+nGNerE3c96x/WNVk1G9LxYoYaJtPcpqh9xX9fLglMysKekHzwN58FZYSr2 yS6f3IPE8LCmiMKv5smGkAQoPebYnSe5ytyqI2aMsTPE6poKUV7tvrlKjq2d/6ThrKpiC60iiUjT WK2vYeFNhjyGzan69VI0DkttgPDcvISjWXKaIxV4vQHGck10TuXkJM3ZbQ4uHrJLV9l4FzPWPJgm UgC3xkczaqXe2i4Hcf5RWVBLc0dr7Z1UU/1xrOI9YvwSqLU9Pyqy7abGwbp5fUpkqCT/y2TBxBmX V0QNucrAatMgxJhK+IgeBEYbyE4EPrF3hn7RohmZMZIm3hB203HQowTZV5lp+LQnsg+20IsCudxh bTxi/FVRXsDYS9w++Sa2LWPIjXRhguNPT1l/5+nsGFunLxvfnPR4WSx77l5/CkBV5/BnQuafP61J I5tTWvqYJl4y3E/pBMMu8GNSGgFbhCMr7PKOScXJvhhdFdISRoZMTSsy7t/tyykL2r9S5qakpk+n 9XSYzW0CC4bYCc/TmAM5CmPGYUGYGyKZYdgePRzEx3hSaCss5zj2nEyjOfszjkLHdoMfOLrY0zLv EWrbxPO6ACOZTh9sK2Tqe8E63A9X45ht0dY7T1T4NrGknce0I5YV1XuZTC6U70djKzajFW1X5iyc 6NTb1TdWvOwd9TYenY1XX6N8vWt9zR+/G4P4c/TozYtX/8Qz8A+kW+asoLUueJvi1k5daho4HS3o jlxmM9BVVAZxQoypihgIw2NMiTFUJn5nJWa9IVTSWGCkHOSKszurowVFF5ymMLPoNRh7QWosnrrT MYfkbIpkgkctJLrGfmCpF6W/dAYCF14tU0tsAi9XkTaq/7/Mvet6G0mWIFb+4x+wvfba3rXXl3U2 ZA0SEpgiVTVd1dxC9agkqkpulahPlLrUy+JgQCBJZhNEQpmASHZPz+cn8Gv4gfwAfgc/gD+fW0Sc iIwEQFW1Z/qbKYGZESfjcuLEuR/9CWs1viNidLQvToHp/kQgxP/UVP5aBDHUAS1zW0KbRHnA+2V+ NQhE3+QZe0XDhf0RS8TTDeNisdxC+jOwOCHnm+r1kieB3y6AblI3OXbe3Nd49MM7u29C7N/mk4s5 SvlInEBYnZIWzqii+F8U8vFqkUv6aoyWQumfPu0zlYZv0LpBa9i/LgrKXRMawMZeovBc2V5ok8Dg Hc6S78vrnMxMdCH3UHmxXM4Qwcd1iU7mHwuaEArkL5ILQFABQFHIgLyiPaPgA/gp+rLgMkIFtugh ruAOPsoNFPIMA8kL1QFUPtHyDgCx/JhnkRQJZwvjhUuMUPf6tOs56r04DFAOfT03y58ey8T2WsN2 0iYg0o2xTtw+SyVDskXwGOCBpxyCTRV5bzy/TSQBA66CVdeI0gWh+nwI9qkoee6tbAJiYV5dFaQC 25nm8wKT22h59zT3Q7ju8WgxXLfTSoyDNRXXV2OMJT2UjnG9os2mpCqpwuyMniu+kW3vugU9+ptk 9+a5/K/5VbZWZ0hd0+7XsxnmQ0K4A4KnR8GW72y6ulrQ/Xq24JcN/SHA1heJTJ/SiXbevELL6E/V T/Nuls/JT7C7Wp7tfAWIxK8iLzqTsrwskD8nP7JMkDutun9/nPy0/Ons5MG97AH0gb043h+e4MOT B8c7P11nJw+h/7eHP4zevX3+FWVPucnPfro5PYX/P+sJDYnLK872SR5cJclzdBqN7u/B2fyBPOAr 8UKUdeKGYq4M3xsW4JNoSvlz0kii6jP0dQB+uFsFx+tg/rGoSkrgGJwzJfEMnNwDF36rYVgLBdQI 6bWOE6JNkOqWwpk+zpIf4eZGL3FU0E19KXaaw6VvikGaHszKkzIPdYJAWbDzHEPXl3mtrxUFCdrU QOTpFY+NYhiz5Gg8tVzlaQ7kugBSMS1zZmkoMn7q89kGVUixhJnkOBuMMQdSZgJUY5UuZREHc96y SbvjaZaK+c4eENEny2QG9IFa3loeXhh0SrRTTIqlrFDCyFtn/eRt6eV/hZujogsHZsNUz8yJ7iYW NOAGmuR65IbU08J4qmcauN02uHeKOZn2KZjIG0yWvEP/4eVqDrjOKzpeasUzK4VXC844NV9dneYV aoIvVqzkNTcmqy0AcYHH/ZiT/RQ2l1Jk6BzPdduWGgQgLmheKqSr7Tp6gg4jGQg4yXP06kE6T/kd bpZo3kcJo17lyb3Hv/5NlvwB+D+Uso1cFViA71F4Fy8/lxpy19Z8umdJKbHhqR+YAQ0eRxoMuOdD bf+2Kde5rcq2ZMgSOXcEEYJC7zI2Jklxg919BH/SN/qSbfuZQWH3x657v70ALtPALtzYU1J+d6NF cM1u1YZrnQJmJuNzOOlkeGHuSqjlWjXNoKmsYabAjiBMSN2qMI8+dPQ1Y3CYAmhSFN1Y7RWite/Y i/0ZtW7RrfMqvMwpRQ6yGuwYOp4ZHm+THW5wB2scCan+mnSMetmguLj51ELckJtB1HucfclmHRRA 4KjPkRjmH1YwUDjDn2d7jpe/x7k5qfonXGF18mBe3ABHe03JxjJzrYT+S5F6VbLcxnn9zSuYLPqY vWpeicsqzyUnrE7g6N19Svmnr66XuZjOF+UC6RUhn6Eq0a3w9XNjwyTTh/fjGrn4jhmuQWx+Kc4i wjOTStRcQ9hmwHd/xTraLiosuttM9QWaRdi4N7Mu4/bqKCRnPgoHIHCcyxo0bJMo4VqtLmupXshB JWeE8gwjT/FyA/mPYo5yEz2yZvVkfndcP9aiiOJYeLE7KmJDHg25U6VoJcoBjx9A+weWHwscEr36 F9fFvOtpTH+E01Ze18k5XFhLvJUmsxWm3zECPUBHiYgT9dAxQ4bEipVsf1TwKolbBPpISkSxTc8l vIvOf2DN2VLIjXhNwvAx1xASgRLVqjQV1Hlg+Jwxiha1tZo+w+UL2Fh9kc8p3JW1AGzLn3BcGmkr StFwTAUeOUMLAUDru04sMxmx4hX/+1B8JdHxv6xRCFoU09RPDbDNGgjU4K4qUcmAE01NA1kuw/yL 4cRY9qkBYfhwNr46nY6Tm319X6IzJJ/CWxEJrDkd5oLcCJAg5GF8NJQEJG8Y6wMURYxcET6hCwwc Z7re2Z/G999eK49Xm+Tx0DJCDnRnizVqyabwyXJnGpqBtPRJgmfg+zUdL7FiHAiHJNzsPW5oM0Px Blnahomcy2DaTbtf9/ebHaUMidnRPBhrzD50L3lqTXDoq4A+B/ATxRUgiZioxuoiMo+3Q18/nFsf 3b72HmMn/PN4/4sT4wimpPpYaR0RwVdzLYQTjC/2Twhs6onk2yxJ+xSofIm6X9ctSgMb6DIzmgAy 2hgtgN5HG1mw7QZqiHKffcIWNjOXIIng7M1YKyBI3tw+HDbIKxJ4lzWTZ3ihSXJ5n03A6gWWkLxx XkQmaYOqYQJXOBoxzNEPPLUxiwZlK0WIRh2qI2vcZ76j/DY2doYueRMsw0Znyxv44RJCtN5e6CgL VoqSXJlikELGD4I84+SiVVSiBzccpOgs83oyXmA4j1Gi3rLS2Xo4TS7GsDVLScZj7g5jWHKDyVoH wHoBVhWsZJYck0Np73ghCoq1c0xVaeh3UjqfDTMmHjQHtaD7GQYOAWbKaxhV76f5n3scFkSVbHBK 7Msh0xaFvjGn/m9Hh69oHGadzU5LDM7iNlMhzRweYxyFVSQc6s9vlhShqw1MfiQzpeZtMghBK1J7 aO7MBOcQD79kKRjOFPzAX4h28SAW2hdjFmluD1KGUeQxplX6MBZclvcMExNtezj9nFXzxKzwjjoM NSHzFBQma/ucqkhUJK4SVtQY3mH5k9qhKF2KsIP/1EMmzapG2jGNdFxKn5NfUWQZecScMdoYhYiV pHhAHBPFB7EO95sE9RXGG1LqsABH7iUmCgzjxLAmrbFgjIn/ZxHwKh/PaxYWUDejg0rvGVxHdzsZ Fx4I0orIAR0kF2ylYM2OIRlozh4LkMzmN+zLNy1Yu6KYwt1o6QC8gZ4JiO/NN4D8sFsZ6YOu4f/G mJS29BbXgM3WnAXEFLz7/FeE3QqLTBQjPHGXSG3SAjh9vX9k6jUn04dgFRbxQda/3GmlGJD4OZ3/ E5xT/eq+vLl/v9vvu5T1NGh/lj7EAGSnGdY5ktTuhA/ns/J0PCP7pFpy6aBzqFAMaNdYMqUuW1vC L1ppjzxg/cty4RURHeB0yiqa1r2bUgQXNeDoLYrd4v/Q3/1IVVIUUfrdNXups6v/0jRYp5J3G9K7 36Pt6N2/3zNFXTilCC4/CuRw/aTloh5IVHnNOeDxn/HkYuT2hG5YasUt8Bz+qVikLnEgQOn3Qzjr nBmm5dy401bKEh4yiNFOYd25acNTwXm+w2siy3rOcQ8HuSOGzfY4u+PixC1L8AdqTv1kCgKr1ZPC sIDULNxJuDJXWEMeJAKU3v4stW+W2atyuZ9QbvX7dXdgH7+gUCR480/e43dHq1N4uOM/fDKdwsOH 8LDzl07ntJiXi8Z3vi2WhxW0+kfVEZ69xyCv7t/7D5/MEd7fqIcvjy6KMxzO11+rp2/M02++UU9l NOqJDFo9+QEwCh49UI+eFR/hySP15PmsLCt5rJ//UOIHgJANUBstPOWZvegVp2q7HHyAHsOhAgLr Tg9/pR++pCl6Dw7wiW7zHU3Ye4BtvtFtXpfXODs9vRdYtKTwtrjmvWeE8vYen879wdJDzk1Cu3zP OY598ZA0cUAq2P9fRwNDbyCzGBWHielAPloaPddIPxQ9rH6kgoGJyOh36aSZWcOWjUN9zqTPFZxe koefkVMwNpNcS5CBQq9urm0yL1GtMxuVZ2fQwvF6RzlXQ05MHy//TZVPVhVnxM68JGyYBnwDcJND hht0KVUyKmtG1kkncCqkt9yaQgDxhwfJfWJbaK4HaYrNH14m18lFMSMvHFxLlP1G9GREpdBokoFk S5OnNtHZd2yb1gXy7+tp3mmJGM4JtwAzp/nvQfZelir30ZOmztlVG+AbzUmYGDmS5FhXispKkUG6 ZCdLknP7ko1hrqoNuvqwrB1Dxp7YccqxTsl9x/xXRL5m0/2OFcGvjO14wV5GsXpErN4E/Fqy8juQ nLE6kbjYXCyXi/1Hjxa3pxgenZ3OyvN6US6z0/zR4929vUe7Xz46zS9ghDv1JAcueac822Exqt4B FnfHyVIXy6uZvamRC4cbgXI4gHQB/LnMuqwutbyeuwJdifH4NctIbDotE24fTg5BmpXqWEW/VUP4 a45LgEPBO1IVTnV9AKxxDZnWsoMfETfMHmIoFo5yLs9HUqS1z7kzZDhi3aRUyLB0cxbS6Thg/kFE JlgoHIEeLnlqsM7ZTKasinPSq4c4sI+iiUGB2rqUi4LE7kBHcvpvwgun67aoSoWC5GuscuWoeXQo rb2PiOpFMo5YBNPsq+gNSDoiY7+rbIX2HxRYlLRLaBGuL8U7UzoiPqsYkQKTmeP06JGHBZhQg0iM KyFqdjuTILscKQxhAnen3WayYe/duQVEy8QGhoo3lcz9epJ8dwN+PDMpzCRej+PZYU6XyERSZOZH zLhiaUCiySx12Xd4sZ88EUKAY1H4ok6DwhvZl462e12RQygDpmi2U/Q5NzGFaIJczchb8vQW1l0a GJTnJZKHBixJ96e3Jm+LGZKoHVgxhm6uY85Og1cE7BPb/u3Y2O1jqvK/CJxwrKNJuULM3U+e8g+i r5TKkw7Sal58WOV2kDXVlHeuszBOBTtJfm/bIdfNcNADADdNT195KVgPS0oEAgPu/t3iVjQ8u10z Xky2IPWWiJS1bxiqEm/g+icX1TNt8HTHivEU4NUm0Y54OpGCVwHDrJKcu0UtrPEgNColOuZ8eAmX vIJZZgIKnUcm5rVCDEzQHR2NCDPBEt0ShJHxlbOaENbc31HaVkLOi3I2BWDmIBWVf5Q6rmiYkIba OoeyVZxS61FGbp/ImSla84ZZK4OkGBdhpG5xumF3JILoMlVm7uxNLnHS9MOgZ3xtaGFqGzxKHzTj yBar+qL5YVyA+JDE+wFDT63s6YY5Z6WbXVlUQ7O4AP3wdpPARbdO89zeq6g3NGQIdVJkV80pgJ2v ouAiJJqYs9sgrmNHDhK5nNM4hA5rFXCkJq6zGhj1p2FtomaDB9D+geerSP6/kUy2aGA4LaeNrHUg aHAlBXTjyWI+5MozYc5DQNcDoyw3kfuiol2WC4MA4mSMSvnx2ZLuec/Dq5wYNS2OfzQ6W8Hn0NdW QLrBjGfFuKYEJMd4L9Gfqdak8L+1Sq5G9MY878ZLODlY3dYsVF0GhS9H46rbP9HV+vLJcmSnEWo0 FiUOeNcrBEiyxK5fumFJWuSW/UHDY+NDlCDUGb8KctI31XObTmZOX+l1MTWDuUJz1Y94fsEn0SJs G2d1LJS4K6mPnh2+ejsShyESiaB7my/VW4cfqGOeFjXeIdOY78o656rGK1nkh0NKzQID6Cc7yV7E 96uxd81oVIqYTQNLo1tsDr14XpVXEswMq0QpKJNvkt2Y+TfhNjLtXw1RF2pwPuZ3ZxGGQfsSaHty CMQ7mP9ex49ZsaeHx50eE+afGIlw2BQMh7vR+F2STbAvyQt8Mk+8qu+IxscwjH34fwlAwwFoE3wJ FyOmUpRUUl75ZhopwHFAmV5HqoFLeWh6Q9F8/ohxqOyEQ+yrJ1bTk6hE3SzsIcwv5gFqyfWBdwKM +iSeR4b1rla0z+eY0xorCBDgNelD/GGIlO9Y8zU9TUrS8bwmFoxXOlvbHiaRsW81J5FkSY6+uiY9 SXvAtobLSd8F2NrW7XM+erthwhaDtvicSVbNahHGEhhoPx44nzaxwQypld667D+suBLnL82wsS83 sf69pbGntQJrnJZw5sskPkz8ZL8Nc/V6MT46vsQy90FWN+tqgHhvGmV+3Zx3FO/m7PvGU6XAsGjS Y4KEPV8KW7iU3CMJqp4uPLIvMf5KgjA+ZHOyrhGqBpJPGGZtRR0zUz/M0mi/MMTVTh6+VZwbvoyW 0F8A9A18gM8f4EJgAia9AKYSg/56WBtASVkyLDnb+N1jq16VihJ0T5cVemSdyID6rSpZ18cqZM28 4LIFzvy2dWJPkdv0DZ/I/Pp6CG+uOtOypE/umq5d+YSqV6sTLPM4I2XfaBRjaWzzQkmMuZ8X32SB sJPXHJu/CJb1g6MvPWzS+VQgoZESMay5hJHFxmGmCI2vh5QmMoCbYKDcYNXkhSWNxwqTo5CNMDJB 8pKc7wE2fuBN3WSyjs3fMb8b5+BWQAMcJGtwqCnOtmHTG5PeF0kF5xtok3VZ1wgQVA03ksRY5YDu Cxu7hu7QJhGS6mbjSPLsPEv+4R8wwHC3X//DP7CqUoP1cvITeNSAUAMbKut/wUC3qp1iqVKWUBzz Ssr1sovDjWjSgABGhVy1Fl7hHCNRcxLWu1PEuHh+bH+ecG3zqlHG8j4Z1t330WJeK1k2JsQ3r4+n rI1itGhujocBebi21l0G1aioXB57xnPyJvHyMIi7jFkTVuUmTi8gW9lUkSQg8zrrN+Gi0ckyDHF+ m5rNHU+nRjdm+8WUP+gXxBEgLboNmaOuNGuClG2ltTNPuWH007UMwilW4iNoQax25IjkaCWNj7m8 1nTVNYKbs7W0YzZqEhDl/xVT5aDyLH4EAxyy4FVlNzF3gPjrdMtWOyi5BtT24wg83ZzRhbZo+Iwe ErWOjpRMTbI4gzkSuyCjr8eFnR0SBack9ThNFYpq6L6bg2hgwtVq2XKzfEO9p740ZfPWkqqvmXax FWFcLy8f7GV+awXSIy5s2KfjjEUF8c7jIWFtvDpVShdBHNKuDsWJYLLE7rVcwKYnnwavlCInpRaX h/kh+xIRSgyM1QsDRtU3+lEmlBvcneS6nbw7u4ff/DR2j9LVF5MRS3PCd/hSLyDD9zam1QonftoE 8YUhZIXBeHxIs8QcS1VW9lDjtkgh7PXcK+tlvVHrQROxHKORGR4WGuq5ejYwniqPbdTKZQU2B9+o qI2eZm4hc7LZqqgsiu5AfZplMQht/VTrIt1iHmFrtzBGLwi1Yp7awxe21rwzZ4TVW5yGP6NnESFp chmBpOhi82XUkqCEU7+kgIl3Ol3NJxe4e9q05i7gxcimwBwE3oZKXyIIR2ZT/UnheAI7k4OPWjMD yc3NEaD83HyMPMDQtQxImPgKId3yBriVpPniLDVgB/R9FFz8cCwzm6s6qCFkvbXNmEWs64Xe3L2B BhImtfRcNn+afyMbgsRVvVyThk2Pw9wm3e7az2z4BiwURgzm3lVhPzMwHm9p3+rOPa9QlUnDLU6E 6TGfUffT1TJYzG7TDb3LJeR05pWm/OdbK1skwPxmIp1IiDWAAAdgICdNGVbzApFSA98Mk88jRYhG 8o03+Acs1CQE19zSdf3C3oi1BqW5n3fmsEA5bWhZwXlRFm+0cecscohDEAHOGhyPs/97Y/Ro3Jqr u11faZTTNvW0BXkSFGrCOQwTxSvYloPASY/Wph/Jit04/gRVL9Xz4sZPAuFZqerllcuRrXwtgk8p Zz/s4U6+sS6Yv0P3s1CL5D4RXu7scBhPeviMuQJhrzn+iaRsWuYzTjg7JufCmRMGlanmXrtrex/F v/llLUAm6NlMWk9n4CsntT5QNBGj7+nSR9ESSeeq9WzNNRTxWzZUhnSMxRRBsNNoipzhMfZQfsvT UqISfHVcfFrdQVDpgfgXIXxwJ8sNc1ghtTvm0Q3kEyealCwMir44O7hZpAhGODjDqtF3HMk0k4kq YVuZv0CVyCghA2Wk4DABz1m1Hn0cV2t0sSQGoPAQsKZENFGmwN1SFFSpEReLhhbRQhvATUOHrYX+ cmgCR9wq1pknkJUL7nWoxQjDIyBDPmycFHtggXUY6TYRdoIslYhoaCeVTzIb6ltMt+KmXktEOLk+ UYK9+XTAtbR2JkU1WbE/6Jn4GfmkpRgkH32rmD+chkG8iGTxxxkX8znxkxErHIVAUUpE9OSgpL1U NBWzyS/ENxKZg9N8Vl7H8+PHhTfgoBDyQI2AeSgT4bYBFgZK255Nur1+4QW7JZjDY0I/+q30LRmV OeWQNMROlq9CXkqGtIa50YxRAIC0nYpMwrBgyRTYNeRxw26g/0OK8PuN5MNF8rXgfBN7CDeGXgCL Z4wcteWEkY4t/Di+bd7/a7B0PafOeKZQbFN/rO/N9MLHrmYzpBWdDRjqtaHdUnxyjGflU9wdJIog 0uqsrjgqq+9T4DXY5H2uXQniIbFQ23U3yaxxk5hd5KuEwnf6ugwxe9AOExvYc0y/gFi7Co9uX4US juiMmj+aZ9WAoPfrVCUaz0yngf5KP65IMeO+n6R6FIPmRUqijtyjGFOk4ydvr05LHLkNNjqmXy1z n+VnS1GtmZ/BtLk3vlSjxvRc0s3+jvajtz4C6di/+3VC/9enLDV2BAOZhoa+acV5UdR8zLQVkKpl 5bV4Gay1ZRG5yKxaaczVjAUfB1T2MbICVOcZ3ylGpDqnhoHKBUGhRbL59PI6/hxT5KBHjWkSFtIh 75/qPBG7ZIZQ9re5kaChT7HM2Kz0ltd+Azsn08LfLdEWX5fV1I5G/t5uRNKY+Yzm2HiFNBGWDrYj vI/dkI1xq/ZoLRsaxYMfa4jjx9VvrqjZl9gkvG4bxtF90P5lnu1+fBVaP8y9Nn428l0B2L1fp+aU WmwfJFhTmKNzLTS1yDiukItwh8bg1UDt4mCTf5Ksr+2xVmMtn/faeMd0K6W1vSVW6I7m1uOn+Z/v 4yfx119oYQz4QeJ+hZTL0RwHr6EXtzKKqMbhbz88LnAhwgbZZHnjbtR+PPM+zs63MxDsjtOWkKsp /RMhaPSd4BjGibGbgvFexa7sfxGV0H7W1iyIx/X2JONtCfEYW7bslJu0Gm37ddG4J0QJIFcF/BWW tVwvJNDFRdBb7mEEGV7DzEg5BVcgObPcRkkQbeg4gaH4ccUEYK5pUzvSCRsfvb0iYB85o6L6rFLo ozjSDsZIKxvhFLiZfry7GzQvbUZh9PSLg8bH6LHvU63QqnF7FTyR6Hl8aBb/JJR4kXtAw+FIGDIc drEMye+N7Bz9au6cBtCQCnEI1tlNIAWC1O2Vx87FGTkzR30RHlGN4KuIZMjHhXmvCOulptLs2/hE RHiUY1UFGjKH5DALlB/NjE+2UoZqkVhh23FxcmJPchWMJH6uInsWuERGE+gEeQ3OyHUI1YwfQfTy tYwkC8nt54ldYUqI7mCjryzO++1qgf6dsMO+3HSHzu6YfzIISVjxib1tvoroFSB1Wu1ZT74JS7Xy XRPoPJ/MycTjJrfWZEEQXFtd7nVbm3ab4CsKjQ//1fv/9LPPPmP8+fCv3/8//8lnn93DstPfH74a PXnzHZZSfXnw9mB0+LsO2mu54T4G+y05ktcWkSctb1BXN6NOoxFiEdpejnsYo9U76WBuARNXg5VA eqMRvhmNevuYKZKCl8jpKKknVbFYYjDE6W3SEyffnStB+V7HJu43ZTzJyxFVbkkXl7TrSgya0ClV V5CCCDq6CAeB7ViLUXJE9SoOboA0yinDgZIzxD3aM/w2HTDJYhwkteLSyYmtAI/Zjd+hkZasaANo xwWMFrPVeYHZZ6SypQfFdB/Z0umjTifomfa5GJgJJDVE4QFXTsZixug/iCdbZtLnsO9O58N//b5D WJCNxoticXn+4b95/3//288+w83jB/vk/1SVM2PX54TNDjJlfpXdkWIrWaeDSbVtJPuiyLhBVlbn 9PcjBt7ppJN+clHOcPsuq/wyB8L+eHf3N8lO8sOLt8msmOTzOidckoUoa/Orvq15qShVn1kojjXH nH2wTm7RMIf/XvZ5Ns0/mvT96P99WlOpWSowtu/lyTIBaQKBpsmtJWPAeMnhn7McVeP4QlLpcjH6 5I+YW2s8M9KuSiJLpeJU8tgeVYbAmxLfwEno73fC424/7BMLeWvqz3nz4WlSOd3L8xT+n00hvIXw qmYGcoieSWnfTZ+6wNQxMydlQrM1dKRWjkEDZCupbTmvMzvBcjZtFI/CVJZmBEz3ps777wx+nkv4 BHceIFXgmlE9rbPFSkQqiynWjFObeCaQj11n9Do96wRZytU3LHr0FBdMANwbhMFdMn0I24GailMN mPaFB9I8XQPRoYUHTx4jtGMPm5l5XSAXaD/DjU/MV6D7tJxAbxbS5gotiLpHNoTbD8Ic8DQUfufN ix7xjmSrBaYRVVJcZJ5dU3RLB685aPTKABL+lPHsyaLgQx/HccwbguUaipuhfc94z0B0OS5pgPOA R3KAiK6Up3/EhJmcfBu7K2uxhOABNo648Wjk2jq7A/CRbqXsMlDSUIHXONcMuWNSqoDsxyNbSSoA I8UYABmInXBdYblum/jjhtLJYEMPPMMy28wPBslN38/iiE9t/ha7zo7G9lV+H5wanvPAO7uR5EtL +dQpzPNlpfJI/nwPdQsLBQSO0ai1FL1tdJnTbC2Evj/6Ojdufqw9CCRjagOLRi85Ew7DQYmdqnks b1OzDAMLUunFAUGAXgJ66GgViWeE+8ZDVkYZwtTgxMlgDA+VeKX05KXlu24cErgP4TLeYMworARy KRV6xaHNFVEzBEVrG3HWJmyX0VID92ciziie6xfMZL8lnvIjZeNgfQaGpwJLEyscsagwK01XPG26 A38lBg5Ypy08T687tPPVv+F2+GsWH5gfXqi3khx+I9XRV6fiX9Uj9Q+nK27Oo2mPA5YpJHgCrA2H IjY9ReykMxI7Br3VqnHTQNyOxmxiQfTaxeviEjJ56u33miMTgknKL4xKRIfxSMSwoXSmHV1W9Aud xjAbYzdmdRXo2AZljqwXt8C6QShcfmged2KQ4/T7l9lxf9cxNjrcdxlZS0zqnTbbUNfMsgTtU7oL cqwP6tU0xpYYjdy0moZK3tjgnpn5ajNdloZG2MbuUV9rXJAmZFShHK0yQNvV1wQ0PiGMZxv8HrHQ vQA4dwp0DNFLs/e1PfzJfcx2/k0Mm7pJl80ds6Yh0YcQ6+6ttb0z2yIMZ+M/FbNbUnKulioUir3k 4F8Wpv07nRJwzrFwyDwI8xUSbz4bp/GOtxhX55T+LkzoHrnX1nMLFpJuQkQoAqofKeKJDOIDhtJP 1xfE9VE7+GZQRVZYot/lt3FmSMatcopyHlwEHL/fYxcr4AYWGfeaJldojuZoDXRzwvHWbRzWeYMY 9Js+uAEShLVpY1owrCg3XMuCdzbRJIbS31wBiiolte/Ext3gOw8WjiqeUCF3STC5YzQWxXIlecyT abk6neU7+FGM9bsgAhE78jz+jvCbstDEb7nTqU8sS0ohdbxnKsJJMjNSCc6XQXIdTjcvlXEpFNLA 48RFY3dt4GMs8Yu6cycPWEmNRB36pRhKibOyXTOajxmsl7wXW7Ymyg2oLiYQ6sVTdahDTxzxXep+ BUJD/IreQmTRuBFSY5ynkSR4nX1RQqpQsySqOQDYMI8DcCdCSwvMORyf6PCt5RXGpe1HEjr5w76J H7ymB53w9qYmUHzLDERDKG7ajjCK+3JZ3vQj8jCqwjmbIQulak08sdQh3RqewYzKMHgt04pN5eFQ qg+ZRi3XtRsfXtiIl+bWtVt40w9HK6tEGOVJi406JLf7m0iy2fEYWd5U9jksVhIMszbEKJSrVuFA 6+hgTNsQLhDFBtx+o/Z6dHZafeFxzNBWFhyNH//t+/9C1N6jK4xpm5+VH/7N+y/hmbUGdBa300LK aZBylVzuU+ojDFsGDUjjBhD/7ft/Db2N7v88n7P54sN/9/7//FekT+fISY5Sx3huIP5cEAumuCO5 WjDs2umbxQLQqvx21cPR6NfpuKGbnzKcjhAQKgy/LBfkuZqqVaWYjFvSHhLFvGV9slvyUwxTD5dC eijngOIUTcDQ9lEo/cOrjKp+prBmw7244wc00pmfBBazsl2QnTAxwf0AjVm4E9i4oG3AjczDrMjL srxcLTQfQiskCsDULBKwD2W5ZMqnjARGtKXFoD/S/jFaBU1r87C/f6IxEoQrns2x+cAJUJDjm2yx qnKcKxFRq7AhICduaLB3yJpgVRC9ewYWKrubO2wVhY/rauLUOMg7Srtg8bCQq1Mx6t521N54UWKz L6hIlyopR5UhyXrgqVoWt4T7mCjB9GQnhN4D2OVQfIKp42LL3jDlcDvEsAKPOzNi6HRCiEsVuNTo VHgINuQ1RikG41btKsu/Mh45VTjxX38BHy4mlzMYyp8M3kqtMn5OFa9rA2GQSOEyafMnOhDyOSoE Nkh+47Xgr0hRaw6454JhuhH+Y0qT9qg0ac+bHr7vBHOT/ahTNkMLp8DDVFYZxUEF2mNpa5TxMcT0 BtG6qjwwQxdHTDFTykA9MGhjBigTbs7CtuOzcMUOVB6hihBsPoY91NtNyUhn/MEJ/aQACJI8BOhh NT2F/9qaGr2/Ozp89+bpwdHf9bj+WnvDg1dv3/wBm9Ec+36Nh1w2yiQbmk5LqnaRcmlVWYfzqlwt WPsFD9GwRk/S7jQ/XZ2zzVm0//Qic3C6Ozv2XsIgIjLfD7vkooKl47iCNyue1Y1cL4dd3Q8vzI/j atjFlVRuIWhfHnYlL7BbWHONiTl/vBSjokiutE3dvjd1MYSTY0DKUzKzN+MgVMAXuALERaRqkNa6 Yh8pe8S1LcTzNq+uMGvKj1IWTU16geQ9Oe4BNqBeR3wOBuSHgL9O1sWvJl8n6ePBlw2WZeGcWGHy tINBaPHymmIbaS50KKZm3TjR9AorjIm1/XH26x3+9Xn2+cOH3XWitIX745M3r7CMexL/AFVeCT6S dKPiTHe6IoGxZ6bSwxnC5IBi3WbGOWk9COiuuCLX3FSjQPbIoF2VT4eYEVWFohtMCCmI97Ge59/x H1qdOwTpjJNHb9DYPPfEjUEjpE907JtI44zSBaTh+8jum8PjjpPgs3jEWZBNB6fTchaumNCaXZ/S WF+O1K+29OfeWZXnf8oBpyezFRCC3n4SPPmL4Sz9x2ngTMEJMihYtuCEFqJwYAOmyRQNC0izJecK m1aHzzJDpmaTmxF/Lwuq34m6iBK3jCgtJwr9ogKHfbbXEjV82NpSjns/MIayHoadR5rQ+RrCcrJk vuv1gjV4wSUTpEiBiSOmDPmolBE4PHfJ/nRWruY2mxRRTeE+5VO6gglLPgc3YyyT4Q5/++SSnW88 lDnuNbMWz/NryiwCc1oGB8ISxWwyXmDW2fb3ZfNllvlpJ09CHxn06TFr2jdqhVpbEIUpZxvN0Loe GU+H492TgXooxtKHyIJH/Gis6cmxqsgAWZtiYRkO4stZ4uLMr2ZdjxHGia9Ycd2alk9K09zcHuPK Q/wJz1FCnQWxiCmjeUSsi7eUmNYZrtZcCUFTEtg+/Pfv/72SYuOI8OHfvf/fH7OLGGUT93LP5HgX L02BHfZcLuaRbOPLC+BOzi9sWsInR2+zDidK54NvUteUmE1dPg3MGWZNny9XmOqMfQwjEvEYRV4n DcdLTRpunmTnlmqUVW4/bZp/y+P1U2J0yK2xtTj4H4FfMl4t97DQi3GNA46tzv7oXOOKul7le1/8 5kvWCaKfMPIhaZcdSTF7OMWP4Q8J3cOfL6neNP6icHn8gXmsGi67XQw/RydnbPEd3zFlJT3+gPiA P54ah9+EsmY2obzhPJzdV6sr/OeIzDRdqwKlZ6tTe3FT8aj4WPAt+dwK8zLCNA884+fiXvosP6OR oLZPfvNtQrPMZzl/kP2tm195sjo3r5LuazQu4Y/nlMWk+yMmguZloz8L5GcBPnIITVBvq1uuQEej rm4l4Z58HfPIIiTCEvcLE3o3QR3c5BPaA0qdgL8w1piGCNOkbcZE3Lwbc0C3lV0hxImRyWuNDitG z0eFuohUeLIbI5Fa3jt1pv1QXjJA0KApwQxzXauST87x346Av9oAhPC3B+SGH9YW2zyuDdnEthxU FAq279syV8850Dm11QodH8C2T77VOQm5JS8oeyMJ9Oo4BO5CytF72O2GDkGT8Yp0dEiF8psJCSJp e5ZOzsfpwknFWVSGYwton1WcP4PzfWDo9pBS23sGBlwEEgFSXe3aVAoaJs9QNH1hYIOkRVD7zcL0 0kV0QdaVQNTUsrL7XmYKjin3J32813CXB0SX1qn8a2VENbfGfqfdVBWwptxnAypBQcYxzKo2ppRt KDPhwWnKOV2yaJPLeTNH24BK3BZctxTBYx2w1fk5+tOXcyz414RnLO1ypapMa6c5DMErCg4jQqTY kaJgQ9jvYt430jaWCSnPznIqADNCyUP2W5uQ0Oe2EtOOb9bhxyT2oP4pe15RLh3YCbRf0Nt0z+eh HX5Fv2sVQnav8mgx1raSyrlGcEFC8kcAXOfzYTCDkuBVaWiq4LLD3skwPks/zXt9vx06E6EVKEm+ /trEJ3EYYVsgOQIRxwwEIAcAU9BSnJOR6VIz2N0T5fjQmBpyyZiXVHuS+2zJvsEDzSrK9/Cf471f +/ppqjTboRgwOIbxEqBJtAZoEi0CmkSrgCbxMqBJpA5o0iwEmkQqgSbNUqBJSy3QJFIMFJ/dV48O PiTRap9Js9xn0qz3mTQLfibNip9JpORn0qz5mUSLfibxqp9JtOxn4tf9bK0im7SXkU2idWSTaCHZ RFWSlSuxQf9bCz/aRqqEHCqJZvn4CknZ2WqWkKLznCmqreaZJetuTqYuwYVp6Bf9e6cEp/ewvMvs FBNJ0j3gpzYd62JGXslKJRmu41j8i/XAEvgguSmnjLHuQ3gvFOwZ0N/GSCzKErcUGcpu6aSMmohb ai87g5phe9alSlTfIve3mGtOs3i1ceHpeCU01jFr/gKKBfgYG51ss3zAdWN1uO4Wy6hXD7qMfuHl U7b3ge/j1pLmMCgsh2GcjJeUjpeuF2ZcdZpbO3dGdsP6wUrkwy4iRbfJCNsu0rj7tRKszSGm7fum y6Aa6WEovVI0z7922+djSGn8tbOAA2MM/JF6ZzrVYLwglvqEcPHbpgeMIKjBJZ+C+OZqFv8LnUiw 5gyCjjzwmhJPQAUIONdfatVgnHAPHhCzIJnvFNMRwWrNl0eRmZMYricH63H5nlRpLJHpWF1RzuGi BuyLfid02OTnwmNS+ADq+9xg4LQvqxUGB0O7uIHfLERILtZQlLskR8C4bDFAUn6DRm4iB90Ecyuc YFzw8yIgeqrIfdxqzCewJnNAJKLf+7CJF298WD7hU5dyMbJpmDTPtyZ0P0iMFI/Nt8OxH9gcfd02 p8C/056MEd2cyACMaGNgGOoRZVLqcoYqM4SNlD88I59ydw6SYGBDhQvbr0JjLkO1sz/vgmld2+hU xTkwchBlLHFXx2YZOec5e1qOqynxedVqsWwZbqTv/hbF6jYdxbUnpqPpUSSNQptrIwfrNzoo1NOj 8D7ZcKSs8khCQf/Q6byC25O29UlNbe7QdXlDY1dfkKuEKZpNQeJl3txvIyTh9ckUK5qIRH9Zp/GK IjQvJwEetqVd9FFI3PF5NXAOXYoo4v/Q360Z4kyFJxbv9Tj7VNKm+wl79tdJHxhQaJvtr7EDLYkE /Zm3JAM0H1jLlKi+mp7npArv99dFkG5HgPHH0J/ittzMFkTzDodvTSLEO3APa1McqjHQo3YAQa7D OAuwLhnjltkR7YDuxgM0ZtTvfPr137j7P4U3/ivf9427Xm/gPwu+tieTtEn1LAR8snU+yfitQX// We8p9u4m+wT8LxrKKlIkZHMOyeDzA3oQOyCNrJLY0NTqUeOzHO88BQIfsJbz+th0o3BL+60Q8srP GiV9+uuG7rWO7vL2eSy3XpU1mS3/eusjHx0pYbge3hfAKgVmf/2qBmCgr/n2oL/dSscheJfctpk3 t17xDWk4IyuOjbu/BBp2H8ga33WdvI4blieWHvRui9OWKjSyNJfX0/oXWppPX5stFgcnxO8oEAQm MTBxvCHc1kzFsfynekHVB/wPh5/jmW+4evET9nuUGPWveNE+eODP+2feho59biRJVTfmYgutdStD DK3xhl1EbHfb3seo5dZVVOO6SD2XykTvWy0hSS7uudEmdpt7q8ZulWmmsMbP3Fin0P0k5aIAINeD fzl5aHneAbPLz6LcRSQvbeP8ZkIoYrAj+V6j55K05Ybg2Iy2P28Lf5YmjAQxb2WiSqxNUbT3kh/G t6fi4WDastSOpUBqiV++GmN03fS369J10JJ4TnqYeAolffcWKLd6F9d0NbVV/q4YB6twd6xYRVkj 2MaP4QW9fjdSUGIrXaUNih3ptAKfvikc6kNLOZIC11zJWn3kYeLWa80qtOCmhj7o/5x5/xKI+LOv lMZZbuR5tsk2mtfJHZTDoeXxZ4HZjszcS55ijKAxXBE6FJLvEGtK2mKWbTaslnPAieU4T8Ag+fNf YreSYrx/IVqGwx7Z6rZ/RaQJPxRavfz3yvoVUbh7bRsX1mJL8/o2bM9fm6mJl1Wtlp6TUh0okehJ 9FbFrkF5zHiFRqE6Ddj9zmZzh/r8VjH4RC3ivuK/uPUmtuZqvJGFx9TUduHhDzUll1/ewuJHLWsP vTfwNFmWEY45B7mW1W/UnWwohVVG5nZCx8UBh3pspmBgax9XQNDvFyssSBUhqJFfRlE6clxjbSJH /NFsGkf7eGIjifi42LGdrCWRUS+XBiZHvFuahFFjx19ZW6k/1fnwP7z/V5LDwUXdffgf35/8hWNT 2KOAUxoEflj4miM+QITF2CX0L+fwDuT3RjZMRTI6S/5sTG8gzeQJMDDj87xSISiDpKyR4uEtmt8U y0FSlGEoihmyA3Z1Vc79dxk/NE0KYETnnz/mNjg88+Jo9OLo5avfDejHsxdv+Mebg+9k6BJOZJpL ilj0aKuu+FdRw0Ok5kWNWFvU06LCfzBkGv8FlL3EbIac5KQTC3f9Jkk/H+yqXKCYP2lcU5WulMuo YJxT08OHGkBj3aivfPsVHMzSMl4Yj8IjWIK0PP1jbnMseolT2jKHRLJVZaOyxgU11tku0E1jzGvP 3MlLp3s2ymiYiDKVVqb5PTS7qD/5e39nMgDZr5fXIISGyWsovozQIna40PXToH0+FW+w9+/fJ9RD nXqDnNcutxNFp7NnN5X/5gQRwKij6i2Flhh0vbheoX6A5rQqps2Ti0Bstp7mnDhsPZgT5kkxm0SB 7pxFDlOXzPLMKxz+y07/vFpsOX1oyVH353b65xunT8EVeLLCCUtrOb0RjAQZdRS4z/HZXAMJjv+2 kPB0h5Bc5VImrAgi7cc+BJRn/Yf4tL4u6+LmNeZdYKqW4e9vx7VOHzy5ACQ3pu4aixISAlCQ63A3 QJHJBdZc4WNRXxQLFPxtjCx15yTWlADBww7/HZCUW9QYkMPuWcHhxWOpWZwEvBq/wstQfAsmyLFj gHVjPAFzrqJ01Szsbzg9nBkLB1dMU/xHBY2btzRieE3/ejwrfKEZX3rjKkETr4brOKNAweRmP7mR pC+4/7C8/ajrT9CoJa1Z9JTAvUM7OqA4i5v+ICFq4Z2UbXoSaurOFmEwJ0cMexUJ4eAPKlDAhuBi gvzYpU9ITIb9ttGYDw1MvZdK0uvb2+4SXy9Lwd5yNm2myUwWeAZgSrezPLkYV1MaCHlLgsRxkVeC WXpgrSOS0XDydIkOtovlDQym7Y3NlLk6rcvZaunnSqKDxdk7gvXiwh7ugPG6potSIpuCWfQbhNp8 L0jr0zY/GfVAxeiEi9/uBy2pqjgmjshNGjFc3uM58a44VrFOeo96eKzHs+vxLSYsED4MoQaneuY0 FJwqUDR68jnAmxmsO3YMnbpn09zR2LZm7OtFTWEeqzmLylmdB16cfuZSeM02nLSXZb1B0n8wB2Ym taOFJ/07bgJ/oIH9EqmlaZaXJckwFE39O5N3wB2FfESXh4nlLQCPGObxYy9CCZ/Zb/sU0fu6uc+b X5drxf+8yapjL3f8PoMNBkAPO53nR98ynjF04iroXrF3HapxguvO3IcvEd/oPmQwqvYG87TQtyDG hX3pzzAOHg6ZYebxO3zcGHORHagpoYkiarMx93chMl6OBR4JByn/UNTQZHLBbJLKBhiSVWStppwc htcZndJJJcgOkuPkSkAh1bXZkGsbm1OTogqxK1+oYZByEa5Owx+Yv3WZCWTCiROJ5HBclweRDyf2 nIwBxz/F7rAhR6iF7bFNAdcUfNIeu4OXh4ev7w591gK+ZdLeMkbY0FZWlD+TKb7RQInxoK18aDsY ljvXANIA/K6x238L/jXGwy6zgDOOyHtSkSG/WcD5QzrkRUKbM/LCFc/BY2qKSstJfc0ZFo223Pak 55L1hY5uwaEUlKp3VVWYqhe2DUhDWSku8sWZKDhEc1wsTRavOuyNBZ/wro5DcZMyPC3Q/QIunx16 Q+HF8AIkOCQn+dR1BkEr56Q13tzsDToZVyBMwcwMD8AZv/z+sI4lA8EkuRzaZ9eMZih0kZJU1ajP uZWlddorqks0hkY1yoyqFyejmufXQK0o49QSGfn8GsjzooUlL/yF3Y+V/auMiN92g8KHJtfac3bm V4tgJUJcJGr7FlOWylMrxOHCsMRzIBshd8EpBJvlK9zWx9JZ01dNThrXNG1WHQhG6pei2hS29ntk mVzIGlwxsMGUTJsPXYBb3fUK1C7FD8138qvF8jbhidOBsBdv1zvqF+P6opkcWI4uvkxbOP/RKP9g aQTdyFqM3rNMWbBh9WNd8gq7kd6p4oR6AmijooPh72Wz8tpLXtcerIifrR9HO2x5E3p+GCGh3kNH +/qxXp553ro8Ns3Hkm2i2FlmrgDMlpsAeHj39eZl1drCuwH/5g7AkQaduZjKELwSUkmBgCULqE0P Hp8BN0VojiSNiBklSx2DcILQenGSxQzh3fCKmVc4qmk4QA3RHOVmf2/forc3zm6zyk5hFZYyNOzk vLTruJ203sBXQ7kMGF+KaW5blV+VH82mocZkDySF8znWcKXP1dE7n3vBpUL7BMTHXrJJih4l6u9l xeGfBLvvhYR733HXsPzN+WLoS/oaLwBN8FJ0mZpzATRtvdlYNHbJmMlI1VTwxBRLLDpzKQGZdcmq GKLYJIigfACbPC2v65hSKYoBfiabC0zp/cUXX8kWYHnLcrJEXmD3y93dznYaKHhaL6dZfUGRWdUV rnyw/fEaON52e39tVfWoVY10RYaVbdUY61bKX6V1y7NGqYWb16rSkiQz9u4b0DWISfmG3avp3wIx mVys5pc1sLnDv338xeOvvooTt4v8ZlpgOhtEEwTh6sMsMddbU62/neOZSPkIEa1yQBrDkkbbpLbn Aj40LaRi3fpivNeNI6ZrR826sfpVfgVA06Mflq64UESa7LC2Zdqwn6b+hTxI4sJ5nJF6RjkpsMpO cgH/D/yPyR10v6KPYjYA83HtiXxmGJdykc/TXnXaW2MkZsK0F4mtWyGcM06ebNGl3+aVB81bXOwc H5ZZfIqIvtRAclIDMDUdTtQWqMizyays81QhPUoIjOwPHlxet2lGYcvYVKAy9RMu+3KNEUlcyWET leHCWAjUbYLF5csVA+Cc7/v7Ya2x8f4jLHPyCNs8WpaPxo/o6GC+Hr/hzc0axnhagVzZ6BD8z+tQ NGtbxP6n+pq08Fv1MWRKpZPfzoGN++rpe7zQ6R9RbGHpD7nQa2H0nJa2wQddXgfcz+kflTgT5eMV dkLrjrfK1mQ+sCsy8OY54DxMPCqgB6e3aIUKWJguwzKgbN8QUNebTs+8oqJX4cSwge4vjZBv6QGo aJ84gSnmQM6LqTGfTdjl536Fnj5wgNbcbgssFHF5ndX5UhQWqT8mf622EG54NS+vj2kOn1C2aYu7 naRlrn6OGBMm34pmZHVjw8p6D5PwxOKI7aypVMGptNI7mvYEBcxmmTFgd/PqJPi89w6LBXinvznF YD9MV4vJbheClnW+6A2SpnnCP0LG5cRH8e791ICv76fYHf6x+16HqKSOmxPk3OmRDDbwMyDfWI8c VT7IeVyjoqmHjXqicwsNgkGEoSn3oYmA5IVzkw7DaYA+Y6or1l/o6peDXl8lEOcIIY7rl3ChRlFS 0oY1AqaQbpHHHKAWbW2ktJvEH5kCmSED64GQ7W4F4tuXGOT+zt5Jfxu22BY3kbqdxzt7J1FOwAzH non9lrKYNKY4gWgfBn1FimuQwbXCiil0dNsKYhY4nJ299kKYHi2Ws+7+7vXiJKF1eJtAHu8XJ+5O OS72T9pGbtfSo6ztXzXI0kp444iD9HYjUGjU/4SFaL9zEIuiF48/bJe83dELUwREeD0KXCOWj0IK o3IMcnJOiCeChqcAq+QVZJC7FdM42+ds5GBD9maa3TzMRtO6HctieijqKsc3jcuXxg7f+K76tks7 /qAZW2nULpr9MTqy1QLonFWt8kXgSq2E6+v2gb51h01gpT2NFn1xCLGQscb0+ViFou6hIOgNEQUe IMC8FeyIMNxD3QqVHACswOubwxiwdBM1md+6C0zCHZCio3mz1Yqhd7l2zvjGyslWqUpuhmObdbk6 9xR0GM6sw9mx/YkGsI4ZhaHz4qHdIe3BQHuNfFHXZgQnDXch+WSVo1iTT1MZbtwxiHWGONwWNY4z A1TnbS1kLDKqLfMIqXlkxZwiCHZ54WL5AOQrjUBjHhguYbFIGx4V61Qv9xDbQJheza03D/uNYFp6 pfnKmrdo8Nneo8id4xrZokGPiLUKhqhwQX49JLx76C34ncSgFmatQUpiHBjpCWwGvnzYq6jGUQ03 CStM8a9Jiac1LGavz/ecAMHBJD1q4HSEgJXFFI2W9AGnKRURHZMvKXMpakiR8Ob5dI1OlGFFbG+u YhQ3kfp1fl+eWlSpHdfAFSXpVkJ19BXlFLdLZX70t/RVa4GobR5n43qp6G7gqDa5KGbT7VGGmrcI yYSQTAJNdYlgEtR7ky+qzbtuX8a0laTLjqpuWoR7G11gnQ+adyZmJQS0BnDI5uw1mO8uYEK3VVh2 1i0Qw6jpSfL3yge49Y7uIvJvC5faMmBrbcrajmzLRc2rR+smVYYl3GtyMa5MoYDug98eo1u8NagY isSOGPXSzGuAh1dcJeqyWsbOO/nzO3ZKahHD/b8o67o4ZUMCjACveUcA4BklhPGJOchOthd+b80Z RwDGUwL71RxZEbHwc2We4ToPTJpxmzpfLboOheBzZI4gn746MPRaKz6Mdnsjvo1a8/YuI++xOqdC Gggwcl2bI++PjRrH9R90YryT31+rtz2mtidtmByyIsWMk2yiT8TzVz+gLxkWDNDD+bm705Dv19Q6 XLNETfkowDGs9VDMeK360eB5kx+EmwRxIoiehDYVFgrAv9aLNahdX+MMja8NQ7uaT/NqdovMM5ss 2bsm4hUtK0jeWwhBORcvi6t134PLYinKcpHPsIMZARGRTR+kT2ij1OJWaIzxSSVuI2aSxbYsKqAf FLXO2s2g0bqx6NjIHdsL13oOuNLaXq9ZXIo2tZCgxa+G3CdITbq4JXNJPvVm28A1nHzkQEN3fNPS tylvs917ki76rdfNwg8E2CrWoPJ0cMovVZiFG/F89mu/Kx7/JlhS6Rpvu5FPawtr2GuhXgRUO9Df 2ECAtB9XZUykVE8nqi+5WYdrsb2/GdAg+uvBtWGlncPG5YijkYdKdijKUUKloxEcC8kAkVRrGlMH 0Tf4muNjpGJztpVgHCLx5pAN1pz5vLCB4hRBqyuTlhEoIOVmbEREcDFfQyHhQi15NuibiFRNTyWw m16vtZuu9VpQJYRlbJw68u5GzatLx5k9iOhWRGj6m7imy1NyocztB6iY+ca0Rq2bQyMa2O1eeDu9 6Dd32U2GymaOYB3GlbkJuHSyljWDCVKfhPtwFWG7iVlMjpQVcUHWBXukNsXKX16YpHUOMAh1Wmfh NnP9UC42HKwOxiUHa8NS5BarRLVh/DVKVjR7ckWzUXIGZNYujhvE+mddvl5MmL7jgnprydqN694W a/kvHNXITNyTygh5VKDQwkdRn2JxRF6hbWzDzou3Kid5XSfUv7vB5an5WULnlq/efZy0s1xJHGPL XLXu7UwSpsC7+uCytCMcUGT8uTWMGoxLW11rrryCLs08NR5a3pXyj3jjYd8b4RWCYMMAVXz3d27C bVojM5pdFF8SehRKAz2w/hrHxN1tonyoD19yUY9mF2hz8P7F0duYRrfC8Cpg3qYFZaogkegRAJTj yUHBEt+4vEAu8JEgdRaBhiYHzLBI4vzSpI0nH9AYAm+Ys3fAYrKS228559sYVIQMUcTFmO0MO3LV E81nKT9JYeKCy0A0fSGGVqmf4RRuy5XcDRghHbo5kWWZ6lD3QueouRUFKZkUepVOJYfbODC3xQng WgYkMIgAPCDbu/Ego0ULUkY8VxRljffRlGkTz7+wN1XfHuDY8JSUb0LgBoQTeLNRjW9/g984jXot 0nSyxEKrjdBcAYIHHeHEY7ncN9vDRaFNoHDZnBBSATbjbIGwXf0I/5RslVKSUnI5TWYswrCxoLP2 Fb3Dis2iS+Y2Ol86FcuA1S0xZSq0i6hZ2MM2V1ZpNoD2CE7P6KgspJT4fj7rfXc2EXF7NX8c++DH 0I9UgsrwsbLJuFgw7FvlZCqlypnoW+a+bIokwwdR/YV3Qht/Y78cq7uxXghcYdeGPQQfbkbMuwFN d/YM5AbGuvvnxavfP3n5S3yN/hwTbvTdd5U1JBLgqbJmqGCEkiM4VKBiOZs2Aw7XO2iXSjlqY+DX rMOrw4NXb2MgPIRckxxirWrXzKIjeWeCTE1mkcb1aHI9XaO+lH6JdEQ358mFLGGtzwAyCtNVJUKS 4+Wp3zTpolDSNeCy5HCOUWNIvjDp1FI+x7E+uAwAriW+xy0z7/AaLOba7rgKa5lGaGBh6bwaM+se s9ERQ5YFZgcsD0fs6MwRddam4nWoYkxK3odjFHG8jcZ5PCFp48665rGvax5RKZ/WoMAehaam96t+ L7nv+2MoEPUyAkGr5Mmag9kUgVaa9GRm1K83jDr4GoeDOBv82sQ5i7wiWRNLMXipc8jIjoIq/mCX F5+vAcTF01AY6gACHok5Eq1W1jvGJ4tABBxykDZHwok3Z8hpZnHgKfpJHJwg+vZ2YeRQmsj9Krla AXIgYzk3k+AUtFIM8VOy6cQ13GsIF0V7mHw4vuy3TS/JhROY9Be3i8vzDQeW8Ol2eYGZG8aTy/F5 bt2oZmVJceGGYcBD1FHu/3IDrBbASk9rOe/1EuOw7akfz228fKYjqt84Fos8qxIZKXndUswH8hxY FRtFjxYWX7oE1wMOV0RUszHkV5qKA1PIFPsiKpvh12gUuBlJFT01NeDSxQC6deEzH30pemd8SsWP 6BPWRHQXeG5NGEpDY8rvG6qA+rZWjo/8jA9SYMa1iqWmbqgW1UnUd8F1ongqtm52o8tcm3z0qDNB YC2eZPLWWEq3isEj8L8a2s7HuycboDtXsto7WpLlxJLVuamObpZPljQmgymXSVQ5jk0yRxSy+Sxe UdZO36lJPmJY3gEdUHs65cixkpAOckd7QsBr2JvVhKX6yQTkcGzK3+EMU7b9WwAnLyirApzFxWr5 CD8HI1wtzN5wmzprIofM3ZJzKzWQKyXyRThsnjQMw8vUQGbndDkm2qNOmISQkt4UJ7ACCt8IcIXr kuQGUhaYPbT6Fgx64xDi8QyVNbcRLbXZtqHBUX/cZkH4ZT71XDTMNwS62RNKtuMwau1ycaQzMEue 4FZSak1qc0FfrtfehkpzFL0EA45bDK2bCGvRQMFA/2G7MdG1t0+DGJiWrYUTBRyt+tA0j2gjQ78P +jAG6wFDPex2TaYtAdVvRGa0uMZTDALRKYN/LbGf1DhblIvImMxaYZ5jqZ4SePWsCRW2c29RwzY/ wmuuo+Wamv+A2Ht/DcxH/Y+osFX5Vj9STFtRg2NpdtKJqTNdsIdaXECVbquDAX7gnqujTliNntjL C3LwrvHVFZZFa4sUoM6UNIaWf4EqXcPqYALqZVkmxeSSZF6CHs6PCNKQykSbvFURfwt8cbzzxf4J fivtwZwmWLUB/i1jwV8eXOq7H8a9kDFf3rqKE73/FU4vCUjbgv3NSfKQBtJrGbYDrnz4sDal3qA4 S+Rv6q82bmrr1B+fbBHaXdcK120eDYGyQccf0S14MP3EJR5vhi3aDFs0lFiuNDkGAzNJ8ansxFF8 jVp5bQazTeduY3wjnQ4qzz1OJiAIlVeJHfm0RMa8zlfTcoepQEtsu7gmYLB4LQnHUc6KUwzpZs+S cI1xZ5/YBBlxtk/FpmxymKucvWE9oSkzlSbakrK12Pzy2eYdiCugIxjg1Lu3NY5TmWs+orlmgfaA UblY1m0qg2m5WrKhnsJWEMiKsnBi0k7MASj+imKiGgTB+nnF9XM4lYzEnGMiT9IEMDQUUHzBHZlF Y8iF+9zK/sX8I7GLJhx1eVGVq/MLN5b6Ip/N4mwM5zJfnVq4nNPhNbuxv37x+kCHVH7kBODOl3ZZ UdzHRyVD27U77vE6cUCt/xgoBT32PoBjwGdkjTm2eHPCARXhzqiQHPwKSucIFr8FcCjr6GqOXF3u p002Da7HxTKwtkZM2Ay8kduO9j9qg7aj2WiFJi3HEin5blNEjg8F5he5HNzEo8OBd9sMx+NZjWl1 cjVFbMyY0FboEUb/cYf6LqVu/J0aNH3j6b13PCkydDKzlRxYM1OJ+EdRP+uCWby8dWcgyEy1ukVs JHxKfNOqcs59/eTt936QIynnSBLk0Wju2t/JpZVizCGF8y1+9XSDsRAJs8hIMBqLj5Tvizqei56G ZjAQXU4ts8x9Ao32n32gFQURCdjI0zG65SMEk34QNVBkHeeMqbH5n66WlJcbu2D7ye05NG4VhTgW LaJDWTBauuIQcY/tjTZaa4Nd67nCUWBRkWlTTJmJwazdJQssWj7/WFTl/LiHiuDeiYke/w/tkcq9 ntGpMDQkyph0QD9cE3NMqCBqltaA6Nb7V+5x2E2RafQUjv5w9PbghzeHh297Jy0ZEjZwMK2ZGrYM qJblPa7yDK6ctHf/iMb6BsZ6vzdQIxdd2GbawhpISkvI4E/u4Ei0brvhzLvt3u81cl+Mp9NmCOc6 /JI+D/09we8cvH9rPyVSQTO/NPW2lUy7/U5cOd6CXhSNOZ0ivwKNGFjLmjTO603fSdSUtJzVbHgp E8S7Y+g25z1oL4R2fyNGiCQh7aPu9HfyGl9Lg9ZKQU+ePj042vIMaTcIOcN48WEQDoqfV/nyAu1K /LTvJ924KK/Q+QUvSV27K9yAm4AafH/4w0HvpLPV2Y/uZgCwiwCfvXnx+4PuCYeoeZ/iA3U3gSlc FR22OKtTccpXaxCsl3oja3bPXFv36D4fzyT1tVXZYpI/PCxhSm8+WD4MyX8+gtcLJFrBDgSWH4bT AwY/Rxab/KCNYcebeSriATRjNewY/lrVK7QcW2c47YQeL6OgTrCRGQUi8oH4m6wvDEZPI1hE/cr3 aMenzJrhO/QvW8eIvVaMmFezAESQvL4gY/YWS4OGr+vcrkO5qjh+Ms6YsDBjJu5x3jzkFqcWeYkr QWyz2+N+DBPjdkO73rJWlMJniJyzwO/L6sv7YOHlqV7z8WU+4rIo8A058wNUxJ8VN0OQJcmYvNPz N2SQXOb5Yvj5Ok4d8ORyhLZ3Fmv2vnz81e5uf5+UFsvrMpmOb+vYtoKA9WGlnVk4RsHUbjmnXUKj yXiu82D7ar/xTXG1ugImE2u6oIwrvdHwXderK7EwUJIIK/OOzxAwT71h3sYJY3csGhgk6dTDm5GP Ao4thUHAwx3s6F+8hn3nVI3tYa2fjk9eNvXFGPAZ9ziNxHRSJAw2oLU09XFWSy6uQmxQyrYREi3E G4DXqO8NmDj8uUk3Ek36BoBO5zqzlsC5Q2J+EzY+X6an82MM4zYwTlpT8jvv9Taera47Hd/Rd7Xk FTGYJCsjyEYKEkw1YnMZqO48IPsA7e4AJTTHcHbFpmcmY02CmYk6bVyp7L0Jh43ZrBlGsPVRgwk0 XGvI8QYFPwSvB9gzYBnvETlhTALSGye40a1dMSqbibHbNy8k5hvAhJr01Yd7/V/KGTzu+G1vAQmX igAqmO5c5eM5uUkCgaFY9xXfP+NzkIJjK20RYSjreZfC0w6LuG9nK26TvQw0bq7QYx3v8Eu21Mpk vO1iT8+ASiXjpYfjvFpYCdHLq6CIvj89fCN2A9xsccGgkQSS0NXtgipjcaJ9LAPTEO0vxjWFmBmg g6SnIjpjlhXT0ov8JLzCr22V6cyCkOihls5IcgHHR7xuI9MrdkjvsWELjvZl2k/qYrmSepgUX2Oc duxi1xflajaNoTYnbMYOtKCS/vq6ELLOiC5ggIRXq7lHsxSkor4kc3Wei98jnEuPhYL/r1FkHFeA +M8pH/913CwRjsrgmnj30BzTIoMDdJ3LrRwBZL2OSfldUbqIeQHM3WkO65YriP0sduoUFqFalHZs 3dWy/VVk8UFyi29REmbDHeTFYVCVUYB9jqFSVRpBqb53smFTraOpYU46AQOz/89xpbANAZ59PTRM UbJDw2kRpDH1vEpaFiUSWykFllhIYXZm3Pol7UBra6yiYDd1uz6iGvB4XdSLnNbp8vHOcq+ffL2G JrbRcNrQ+rJYeIwm++YhtHy6nbpgs8aNvsRnj08aMnpwsdX23NmE/b3ZWe/uWyAOwHRAOOf7BjXh uiiQzdeksvkR7YChk3cBORd56zJIfuSEXvQXuhKsV6t0AiaHyg2qTo1VwGoq4tyhFRfvjg7e9E40 iQNIq5tBgsVrZj9Dd7Lme6+eoF4GvxVL379RZ6Ig94QB7rn1qKtJIkbgFWlF3EXI9ZqqyfE+/Mdk 5NzpkfUN/oX/GtBrghDqbDWn5AzToBI8jfrwKDJoj5jGIAoLkMKwBkkUbiqAB0mYqD1SgLYf+Xwo 068MM9mQuEMZPXwvJflc+g87aP6sXw/BNUNzWjWRCpLUXkGyeUgCYDadO4yK8/8Dwl+MMZYECMM5 8gZkOaTGZ7j3tMNhQnlv0c8EE6ji4TYZFDZlnids+pnJ5+MOuDRUYfC2SDXPNRxVeF+jGY3VRvBy OjTlLKysWybzKt6W9Px49yQDXmu2uBgD7yKZjOAh5WYdaSZXDifnvZX0gt1RF3PU9mNlebj2slQm xU/gdd7vfPif3v+Xn3322WiBG7zMpuUE//3wP7//P/4dVV5H1m8ChJzr7CITKU1qiTZfkWoR3uFD 1nRma0qym5Sb4qNmqqkvUVI7HU8uXXl1hDewZdbNAMXZVlo9L24Q/Jv8w4paP1/NJ/LsxfysdFXY Maghm1AYBPd8S37q49mbfAHnG//7HIb+UvKA8K7xJ0fj6bSkkMOU+CBz8vmPDN4Cb5r2ZFlG3PRs Nj6v0ZmM/0zob2K+zPL1nB6NK3FgcGt3YML2hsfdg5cvX7w+enHUFS2HKWspHzYlM9PupJzNgGPo qmaZG3R3Z0e+uSPb1XWfHlM2sWG3XmJhFNRzqSFwskfb9iKfLYbdEAUwXyu6+jZh40EZdqWteb1x jOez8rRtgGpsXWz8IFveLOEhUNHxx3E17ALn0Q0HbAdLkqg2lmNqNQtxP1EQ43OgoW2cABeZEe+r Ha4187NWnAGaRddFQ1pXeySVbsQRVAbR99BasIZcukyVOZap5FYALC7ObVhCxn93lIU8o1zW6Czr OQ6imY3aZrw4mY8C0aDJZ9yEHdH80XSsY2VqP8r+mrBV5K9Z1UvMrDKfmqGKBjvDEKNi6SrXEUX9 qePxqWI/nBNiDGXgcLaotk3qb30zdEzG/RYG1VxHUyGWqMu4mEnjVNMeVTQ9qFKJgWQmLxEVdcq1 VUiqDbsmlHTe/ek3pN4o6eC/9oPo2sMjMamfdLJNMl8V89yG5FDngCm9pqeYfCvvt48tU19aXtt1 kfV4scxBsGTyjr/bl0TqbtDqDvAymlsPnil2Dw1HnCNTfcZkybRwNcRwAgQel5V++C/pc8je4L8q 3HI1px0OgrcUPPwndSC8UM1FNToDNHF5H4AvxZK/OpaHby/BSi8sgduiuKMi61JpmcEivIV/nzP8 bbytTM938/xmAYQC+F4Tex9WmJemMnhYFjMYOkSB4DFGRhqXzuuUyQsfvWSR/ZbezJkBm5lyBDRi 83cjASC+RFQFybbVt0feD5tOWC0aQtNeQ39o5uke+Jr9K6BQ6M3ulgqZAMzRC+MOnNWDUx7yKqmZ 7kDGMjDQ+0HiS/Yxs+uZHa6Wi9VSyjMHqqw3B68P37wdvXv24vlz1UU/buyBoTK+1dgMr29S7uV1 OqnCxIOmb9MTxm1Yu72iEDOF2oMBPdg1i5LsJHu7fayu9v79+99GHVsMsbNTOS72uXNLwBk1sr40 93c/nyb3qcZJWjzkOnx5S3LBAv139rbELufHdfD+yQ+vXx4kLw+fPnn74vBV8u7V714d/vhqwCFE F1yaCjky5ngo+Hi8NMgYUacVlLABhfxvvvmmt3ZZDEZz6Xn2M+Ld7G+xPL3f/va3sDrwfz1aIPru +jWyQ8uyrNcsdBsjd3Fq129ZV9wEORVZSWcBRO8zKdiZynzbSWVAls7R3UyfDxO71P1p3t0q0BHv h5FMjI8RiS2W7KJIk3qkFajmZERXRPsMj7vvXh28f33w9O3Bs+Tg/dOD14g6+4yqG/yUFlXqjYq/ 2j9p/5oV5DIuVT/KzejTB9sMXfiqkGWKMUPr6hDrHNmR+9+7a80t613FFOV4VrZkDKAL/EyCsJgB 6R4LPpwIEeDANorqMi5WIxQDR+g1DGKbUQE0b3T5CMY3pM8OX70doQvY67ejt2/eHYyeH74Z7Q0t okdfN3FWt/v25ZNXv3v54tVBFIp92wTy6vDND09evviPB6Mfv3/x9uDo9ZOnDkbsZROEkWltN/Og 2fTFdwDyYGQxdvTs4O2TFy9tz5b3TUBPD394/eTNiyNo8vzlk+/ct8MXIh/hRikpPvWkIvUCM0KE 4hFKDqgO6EbUAUIEFA6MSCGElSYbyOGajieob+NKoEiP8SHS42AkinE3vf5x2PzYMT450Whmmgdc uRVpvOMjbDryH4pNb2F7W5jVe0kN57g+u03+wdff/IP2n9N6dj5uq/lEqoz8+S9usleuPAsLfSDQ ElCdJMYMFGGk/TWKY8kKzhCEDp9d4a6qZ+kcE0dKfnyAOMT/3CmAAdmxWS2ii5mYpJ9U6kf64qji 1cGAN2+5gviroDnOYjaThzqjGZK9fDpA6U8xdnST4XaHlUlSRes49AokdPjIDPbwYx5qLIIjMgzP UiTWA/CsGqN8XQ+J4rm1HoZTwle8WHwPDZpBJ6NyzuqOIZcR+ZhXp2WdI7vp47dRNUQRWnQjWyK0 CarkRfIDZpEsiOIyiK2UcH2TBYjJx8i252+ZP71duGvkof8lGaVNh9D/lEq7esxWWdJbp31qK6co G4CWz7S3mhNBXJZmqWXo9yubmSdcg83u+b7V8BelPjFyEeigU0zrdXwygG6ffLTNuuIpgfNGBcLu dlLU9Fc1p2RAI9zMahVloVG3TEkmckwuVNRX2hgy9aRHw2PTc4VF6rhzHvAmAXDslNGxWKD56er8 DT1N7dEdeCRF/fbLRNE8SH7DEWVkeeRpGbJl5evNxFpTJX/1I4UFcOQiLtT71o6fXy2Wt1ZX3vgi p/XSOjCC43KdGw3XIGFN0Yd///7ffPbZZ2jOKMrMKNTIblV9+F/e/7+7ZLDpdL7PZ8D20rWypKRQ VCYTmomntOnJZhu22HQ61NVYX+rbGpM4OmNMZ3H7+aVkDZBSycS8o2nqm2HyubW0SNygc5m+AamI rYcdimgZwUdHE4o7tiHcQG7Lanw1NlqX4oxTb5jMgkhIqbOQUI/KyZcMjM4mKtYgkQYAjSlw2m0M GG+VzrbEko3Clv2fFlf5nPJ0Bcw/7UhZD84m8+VswDSIdfAoywMHgs+zAlBllu4NpHUGTO/T7358 8eroPw66P+3u7nYffMUH4iJH94fBdTE1RcUAXraaYwqFNOlewP+w5jvC7ifH+489dlA6J9S74zhi gzUjemEmwK3hI+Zju80N8iAKs6uXouP7sdjIUwqqVqKXJeNhgPc9dmvBiEiYEwqfyWk+Uy5qzjgP mCXD8KJl7yXPn7x8+e2Tp7/Tzx4kWKU7sRKsJHJRnjjYhpL5cJAk8JyT2p4vSa/FwmSdpLuDXZ3d nBcDnZqd6wYnt316+PLdD6+OeoPkq12TMo/0VuT4Ju4cibeKFGN5mien5fkKju4sX/ZquOjmnMX3 VBw27ey/Tr5Qszdj+WpXI4IggL/vQtFDZOh0eHwr+iD5R4/yejJeYPk3oEOyH5T3DwY8WlQ4byYO 0I7KTJlUTPP8GuV74d/OZqv6wkvMznV5IgltxNMUKQcHBjMqcsFVytdYcbG+voEDn7bB7kqLRCOi dLCK1mPbYULvGv09YvUrS6wsfUV7+3J5qyUPGVba67HD23Hvp5u90+P79RVyOpNySlQb/0XVWz05 6SfJw6afIkJpPmZYu1e9vmDpk1dHL5hCJmQE72KKwmXX+iDwkgejezgEQPNeJ5xtgyqumSZ025MZ +KTxlDNgeuTULTMtfnp84wIS8TkWSsHl3TtZxwILZD85CHQ3svafU1yV/eT54ZuD794cvnv1jDUW g6TpiIqFE5WDlhdD9PneoO9BeXPwbBBpiK660xYQjwMQ3705OHgVG8h5lefzFiCfx4D8Y2Ng95Lb fDaLOO4ylC8CKN++fBdZEoByOmsJb0w//9sIjOZAyCW9Cm09DsqvN0CRRbqXTG7HbWvyZQCjdYeB Ri/bBvKbbYHQaYoCcaIC+q6juUcQkSg9EZrwA15iB0TmoOApwvnHoe724tXbAzjgb/9gGx69fTY6 fPf29bu3o++fvHr28oBiS/a89wdv3hy+0a8fB+X1OEe0pab+MEA6mNJx+i5fHi2n39OfaQh33Tlt h+CNvK9z5hIJq7nPU7j2yhnLWAyrn11bx726Ey5Y6vr/TbJ7s3umbuMjCw7VXhaIwB0QjH4QxoNx SEgn+8k3yeePv/z1V/sNg5g4lWGr431qEwQsqcvpmGGcdDzB4ma5Fur2M7CTN/4UdXBzelDtRYu3 b9COnhnHNg5PGE3L0dW4QsXlmVOksCO+x9m8/sMImJvDN0c9KsPZ2+s1VOv2Rtii+26zuyP7hp+V sBEJGeErStxFvEtLOYYknIAx/Pzbgzc/9CiioDddXZ32mj2QkUg1N6AD33p/HH8cy5cB9MjWXJ8v e1Y7ZXxDfiSxLuVAV1nQkbrFSAFwOgNed/j5LjqLTIdwIfE9MYR7RYj98PO2eE0k40Og+kKLh0C8 iaAOgf4yVRwCFY33/Za++8UuOs5Nh1/Ad7+j734B3/0Df/eLz1v7wne/gO++5u9+Ad99it/9Ar77 I333i7bvIjUckmUVBIohfOyUqr79LeYOBql0OfzS45anmIoZE/dIbuaitHUs2jxMFB9q+myqedzK jxpVmcBpqXZihzY0DCzIQCDf4zF+cZhuYzh0/cgnmCk2JsBx3fxUQCj6kSsqnVaHuT5k/+R0iT50 uXXwikhCN/QKkWERJqN+VVqvKYisorwEMh/Obuy4copUFvqjHzYvsycgcrwtf0S2lWeMi56Pr3w1 nhkOXtLmJ3CfprKZ0A/zCoSz7mp5tvNVt9/QBtLXvUBxUSHOZmuFKK81LASTVBRpolQ2+C6GjcGd RDK4yhXMUphx8DISV5Ae2Mgx3of3Y1fVLyKwOPkkJN/4Xgeq02z12IOK0CwutFR/DUsuG29rk6uY 82sKTd2mDNZqfjkvr+cyrv3kPqYdZx+yfiNe8fL6mFLLNQHDJ20GZG8M3KEfT7FvdpLXgSUk3Emv yohZLPiFRYOhXbG0FM0ioPzdrK7tUDRKzTQG+yjd0cF7eXJejqly7rLkRIUU1oh+JJiGt05mJecB lVrPWjlP+bJMdmQO22UfFmS3yFsEQ8qa392kMlThl2cYe0gaCBOdSBGXQC5WV1jmzGpYMESxyvHJ OICBobM8n5UfMHU9pqSkcBkVZ7eP5vlqWY1nGFmBKqIASIppUMecUQvxioaS34wnS4ZNE+wHnepS lDuUbf0M1T8fyWAy/lgWU9E5szeGTI49W1r2cUe7ISHHiejS7mtFMZ7XY1i5x8nD5PED3BQ0M2IW H+KHsXvLDsnqY+wn/M/1F1TtP3i1NRDzvwYA3SfZ0dB2ksctQKhX2t6tnzx6lKT+p/xdeZX8TAC4 hHSk6GXyIHnV8I3DnMTkPmVczLCPHG9iW2brZC23b2sWrGWnglWFuWgYsYG6eaSt/bRFCmkxKlpt MHTtzlRVllecdmrONhkL3RQmIuWyDw2LBxST1Qxa8WlHy17BhIWi3Cl7hwE0Ky7zpDtKukFOB/hY MUMugBMQy6GQQB5YShlAjuz8mSVxXmS8pVkP9eStHtJH8v3mWj60i+l0l03PbvqGkPN4vcur+jxG 7uHxfjx/rivNgT1TMuDwFdyPpTCuz0WKxfb9aBppx88gpxFezRwkh68ZFhcC5OvfDX4LXlgDgf/6 5hwqqQr0MHWc2sD1UGtHqyo36bDXa6wd9ZcFDsfGsMmvEI+lLnKguqFm1fM4U59U27kfzRPfwqJF 63ZiJ0xaUuX04R25WpYXnHmWWdBudIwardpmF/H8NxOseu0sqj0ZilVVS2aXQS0AumY+ppt6GIDb UeDUcrkO34SZUdU4u3DuH7i2VhAncUFUKiKM+7K5chf5F3LUtIKsmUJ063N4Z8Xcz1TQKQctDIIa neIMA2Xd7vPdRnvRqLpuMUeVy2vK9d9D1QGc47DC79aa1XWwq/wTQL85eBavBW9HDMf47mBRWb4e LqmI7g6YtO7rIbPK6RNB/+PGtWnz7zEQQ5TZ/bK5a3dT9K65NCLXnP3+/p0/q7SzhvxYrYmnAoyo rGiAHEferqRq03AEBFrBQpu++6u9jLZP5rzvBEFCXG4Z/+EWDCVzFc27EsfcUKmogYRVvVkbHfXS RneWs4a1klv5pBy1VA1y34n7hpCjixg+5S18gt+L7tGYRaV4HZdkk8wTxIqWIvKuM9M0TDTKRuOd 9ydPf0eTHjLS75KJDn0gliapakAeEt18DxldVMoY67BUAUPqk4W96aDq3o9behONaXSHY514H/+i pXtlEuSFtjHd+cuwhSXWpsVXPviC3d5AEsCy9/wBdPlYu5KwkBjra3SNvLTNrv6q7kW7RtZWwQjX 9vF6GGqFFZBwhb9YD6SKLEO4zl/uhi3Cdf4q+pFwtRmpvz988xZVs1x3YjKqL0yJCiZ7Tw8P3zxL 5fUROS75ATxAf/PZtMYSFMdp7z1cNgSzJX982vuDbXGiPnP0w5OXL2G1nr7d/lsv87Plxs+9LRcb 27xBiXVjq2/L5bK8io7+6eGro8OXB6Ojp4gzo2/fPX9+8Aa25fnh9rOZXh8Vf0L+gla8dRTT66er qi6r12VNuriNHRSD1xtYypj9uK5PXTFxxMnajVkzpB84PyN38qZxwmg20pyrQzfU681m2WVezfPZ 548z3arZLxtX58br79hO5BnO5CTSusprbEGucNKWCbe9qjx2+hITMDesl6NmGzk4cQaifW4tHdYB i0+YJxFs5claOJGl+Pbw8KXbG+l1NEEi9u0KQ+5esPO0s6i271lL703Q105voz+wDOf1IVK/N2n7 EeyfbBxI2/ooRInITorP4rVaQwYcA7VmHJb7lLmd3lb5WUqhcA0TBD7104U3nVk/SXaUucSnrJRx R6vTGmMLMYdgzkwYO0NOMQTPT304IZIFnOp4USsQlKSGFXbIBP80TyZjcoZH1aLVmyO/Ni1qYERV qUG1ChlTzuwPA+/P9xhgzD4RTmIAWYFFhX1llUZVJ2aGq5MuvOriRYnqQ0QIkf1dC+JeyI3UsJbl 1WJGxWg4Ka9VmWZwHMlKiOrOJZcDz2F81SRHr0xkt3/bdM29RyU8bh9/SYszPsXcjcZTnPRDZeLM yaI3nTeFh3tiobTpxanaB2pt5dMmIr2mxMK8CSKLFHqLJuMF+TeUmH1Yh0vMRFtj5S7xF37H8A9I ngg8sM3kfk0J7shP2RQvSU5z2ntTgYczHNQqzZWz7LeIM9FIG2+gRsrRMOKZbNfNQim2zSw4KSDG cSXN1eSyBbyOnWhWu60cCqybTzMo2MuYec/6XO8nbKGk+HOz76i6hkObV+6zVjdr1qcrjXe4f7ef TXN+Ma4nRdFdiwd6qB+S9/+ZymW1mJ5++NX7/+s/5zxWFPGCyXc+ouHsdHV+jutFKP362bcDXVWZ glDO84oLdt8tkRV8VAVRdPx0ViqeYpsMU60Jn87zOcxl5uUiUkB6OzswjF7jUmtJPYR5g+AsQJf2 TEReQiJOoY4LphdVFm8qi4eHjyO/siDxkK3paC4Ooa5/7tXoFYEB5L19aQxbk/Yz+/wvQQYjjD/D EG7+5fzOGml8ZH7qppImi9kKEEFiRV3m1dfT0xdUaAmjt3rQlcsuGZU9uxin8NyNbeCGnI08sH2n rSjm+rbcsj+rQzuNHuTzw9Fz5lHHhdRF4cRmrbI9ZaPJLB/PMbUV+yecYYEIUUlZsDwBPFSvqdIg HiC2rKFFurIqjyofz2jENmd8Yzykplb+CzKNWPVz3gH6llsBe5IBc6tysaD8F/Pb5MUh0kBAK3iQ BYXqpCAl3GvIx9DfgGNno9OxKiQKvWGUkXq6rJHy59FqL7dQIr0oRTE9QDvNQoUsdxuqRYbTJNT8 PKtXNe6WQAEWbsS1dYJcTcq3zHMy7EdzOjWeondJ9xugEV1/D9IXhzt2sROuJAY3+Fk/mEdsDS7K 8jKT44y5NasR4Iv6NGLPa3ziUDylHQOsFLS0R3VflfpmgCZwZ2TolMkjRWXS0QtuIOE5mjCYPZtz zsAImdhm51p2bdsdU6vhRptJqgo76k44ZRPXSZTXZZGqKMthM52Ul+NrWaXS1MtcEljOrD+4sZ+R QPTqyUtSVn6T3K+hU3Lft8YFPUPeYnmKYWGLEnPEVcv8amSziLjkHBYjoNWIm6XL074JrwuXS6+U x35TkvKdlYgKKhUbgqx6Lnzr2mmB71l+kSK96jy/qp3PDQeJGQ6MIuOxlgDcysCCSa0f9ktDzgwZ +HyZYw0eILUVEsm6NMXB6YxuhXdmlJUMHLim0fK60zzA3sG16yqICr3D3GyNPrSyVL/w2bfSbdv9 CvfKfBL3CbMVzXUEkHAB8N7s6doPmD19si5RmaHMsHVnqxknP3djygTEO0EGVavRxfyheTYfSxAG 8YImZFqYuchnDRuiY8p07ptBrFNTGxTPl3Ms8Zo+6x50MQl7sLGsJsZDk8l8NAeKeFFMp/l8xLcf jHFyabgnSaWFmbPQZYVeoXDL28exDwW7i+K74+IEk9aejSjbFyXeT7sjt2HwIeCau02jYOGcz4x4 bbhijTYmG6Wh9alcCdozQEJUaTzGkRs4+ka11TGWScAJCows2iu8fM/WFILEc7BxYaOpiWQwfE6w Wq299xYZxRPZvyyTDaw9O25iMHiX8vZiMDiX//44X1WzD/fe/+k3HAYuAf2wNsVcCgqvTiV026tm iukqpkk5F/dDvj86WPaWSk4C4F7GZUBttt+CyR9J0iRBQaNkL/ucfcNBRgW6SYU/SVyFfS+tpAD0 F8RD6gTUb1YA9ySDAhJIMehyrMp6wGHoqAlBMq6EJwk2NydQkm5yqQuX85fLHJjo8KsrOJfRdzD4 6wm6o8KPWLtsMp5c5Jho2/T4dlWgwbZePiET31N8P0ieIB9KvzudZwffvvuOhSjDpxx9nD/lRcUS Zqn9WAYv8Mm3Y3s8uEATj5CTjo+dI2x5Rjy2sy6m4kZ7S9U3lnlf7bQhuai+p4oCzAwzMz6rq/wj TQ7wLzYnrNwAH8d+w73HEl0O3TC7h+3opu01393dpRR8dY6OvPXw17vZrvb2Gc3z69FIKo/RBgJM cUwer8RHObBgoyBESJup7n2/fqyluAx00kjYAJ8xpSbgpx9btyLXZnqHv4NgfvcSeCX81w3ObiY5 MZ2Op6j4qINyGRqCuPP1HoVOUgJa2oU5VT9SmteP/mMZtjdi5TquF50Sn40aeW3OFHw0M0ezqfWY xqT3q77NxhIuRGsqNtd5kAiAVEMY2BFoJMGjWWCxpo9CoCdXU66vHlZI5FrnmEmdiJGQL0AlkmOx vl+C/AYMgROZ5x8LooRB+TW7DPH6a9ofH8dGHLAa05p1kOQxx72dqucmi1URqAK63327j/nrpPwy folV0gszo4FjD07fCPBPOo2Jde/XXYsYEq6QouNGnxgv/EUJw6G9640yzRI1Df4CzGzeyAAqqQyn iEmeC/FZcSO1i7jkZm45dvT+Hc97S2UjIH2aKvtesU9MN+lyaMvMIylEyoO8HpS+oIuriV0l3x/B UeGqK+epiPSBK6DjIU3DprLVXs3yRh+zs1ttadIbY0aKnreN0BlHZGkVLBovVooOyvC2cRKIsrRr N66oDnEvwaoetn2GxSzgFSsj67QlnEXmhgjtOYHK49h0m1U9aImDGvMMMdCwt5Wi9+EZvZBhtdP+ 8V4jH22aZyTDUmET9NBKDm4KTOhPkaE7e0lZrbUmNrqjEDee3mJdNQWm3xaQFJS9CzIqNRNetSHX AqtyfAJqDVwt1kWxyOls4wTIU34J//zLxTmacohx/DC2Bmbl6izaUdGiNVlCDSHUl52GQrzUaJrP kHO6lXEERTvlgnfLY4P1opPHsEVPbSnu0opvy+wHqWaMJPdDaDqeTK0MlpcZ9qpeS1neObXNOUbT FshMzouPOVUJybPwpsWHJhIv7VaoaajedQf9TS7t1O8+K1Pq1YK0H1OKiME3Og4PmO68Eo95r0o4 2isRn4GZ5vErEzCN314Vn84auNPVM98yN1m6ZabIdvQZJP1tst+uGctOhaFEnzQiWILBmrFp/JkW 9ExQiBgS9o2PsCaqxLUrSsly6pmu+cvP8J4OsqqIdfpWkI6amXDvOl5vd2Zzh/LgRe0p6UQX/UYs D5Z2+yKGoY4ov3j1+ycvZcZdlK0NLfs4nhXTbt8PyhaowHR/0b6HxJSEq7fl/oOYlJqElMNer98C TDRhcISKs1tOAIjetnWSsph3taqpnloxp2mghrOva3gX1VabzIVWk7+J7zZvqmwkdM68BF5w3/Su 6vNecpnfXpfV1G4ueSnkUjASbhkqZ0fuBvFd5zYjtkPzMDm/A0KHTaPpJKe3qGGYFadkeOLM02r3 eCYiqQW7FGulWPgefQArl+ygf58bTuj2HFwNCpg5WE1HHdeoo7KZLszFsoTx5UtyShn24HkB6x2b aUjnEQQfKbTtERDeJyKsWAlKChqgXT+g9CaC3ny7B7PqcdrsfvtFHz9XBkbXCHBc1r64ulpRBHXD dTzgopkA4mR2roj8uf8AIaQQnM7diHI/IIY8wn5/w2ZyM72RKhZsTrrDxoZ1+c20BTdDekqx7mSw 2Hbjkpad46H8nH0Tevhzdo0Ky5pd29lh1yZv99bvHIVX/VLbxxVcmqewtbG3v1QZ01T5mWBGEzqP puryNgdSCu2OhWGpFBlNMVpWV3au8pxKy1MpTtr9zhbHVvM7/z9vdXXlHU9zMiO7d9d9spuQ31Dy YzlkZcBws/TDuTlLWEwSWRJHVa1ESh2N9xuuEglxqCDAtJAlWW1ZMVHUA8dt+toEXS4lMfrL6NUl 3wtLrMj421UyaQTvIw7WLe0F/KB/cjf8CFReJpc46vhQ74Wvt0AG2QcpHAKCH9+0dNEOmhcgD1Zt 9Lx2BZXWcyfclLXsY1ZU7QhPQsvOAjqGaBo3KZAx/BknnF8meXGW3JarpF7kE07B2WBaeoCVZPP3 S5sAE2MqZrMYTHRuiriEuTMC3jjO4PzzUG65XNZwQ1z3VHNczAft+nmcKd+j3I8YyV+n8PG8qjkl aDP98o1IdxGNiV/wM8IpB1N+dXjw6q1jMi7GvFYoVRDfS8ayX/leHjfIvXOXaISvGR7uN1Z2bdPr 4OpQDTs1mrfPXrxJb0igV/tyxE9jPP+NIhXCbJvBwbmbLUvdzyWqt60DCWiQ7PWPd09UXtCrBe+i R4Ay4GjxVbqmvqt0zeQ8mg8OErMuDTXPkIwGxuYW49daBNeuHGRVh8WRMv5sS3SJ31ZGTKhs1qrf 0vMmaNamqm6ldZ7WsvU+u9lQndaMuVGe3lBHQgUj7knqiobUp5RjVbnAk+rq73lqrlpruI2lpied etIhHAN0O97f2TtBNQwawVyiDclD2/G/T/aRhoat/dPYXlnVTGUx6CLYzbkXwvfHN5mk2HBUiMuA 7e2fnDR0e1aj+Ro++RI++ayw/mVSn8hOI1ZJyNeeUfhLbaK2rFF9B+bzsQAsIhBYT4lc/TWx5/Iz ZjEsq+PVCcbOozr/4KrVjHCRoPHIvFY9Tq3DosHmRnYtjn3AFdLg49m2gDqeRlwXdWDJenIs7LND isbY25e2xnoIwE0hmmPzHRq3u0TFXI2vycCsVxa/hRnzqLzBFs7/bTg5o0LAOx97Ud//LcwS25km TC43ZV6Yl/MdYlpyk+uKVJ58kxtDw5qiGdGtGPAn+vFcAOrz3YPHGEX7m/3uX/tLbEfBy/YMI1D/ 6jPr4aeQNUG8GTv/itte/1fDv+Z339n6KKjS/et9bVZeI9LLVyUhAHFCmOEhn97ly1hX7Gj9l8Mu pOmPtN1EyiP0LqgnSQ6vtXF5jVS0Ndre2k+I7r3mkDUk2c6nJ+UeLaUM+QqQlK+YPzbrcZ0Q8pv6 WyQC0xWQAXyB1Klu10Lp+RkjeeqgM2Xut69JVjeL/pgy8arZL2Z72k6ToC0Wzi0JhYSyIhqctniL iNHqrtW3DGHf2oziGc/ah/Vpg1HDUSmo6JJzeWlNWlrYvtA3Ci88bK8uNozxR8PHILHeYQADc12A 9OpMc/CMCjT4UixKIaZXTQa2VkFTOVxRtCOsRDMNLAWeELP0/NUPWGc7p3yqrUyKLHk7iyKWE92N jCgBSVKsytD7hpZpAl7FY3xoKehwYSw2JWtGAb8XCc/T+bmcwLeNGV/EPN+Oj+hEXKmTpomZJgqW qpMeMmEnQfjifsOJjZldx+TyM24NAsZJqJMBBCAWnNoxAjZ4enqneLRZeW4VnB9HFDAm+It/A81C pacp8BR6BmvWmPEartmX5fkBikBWQcZ1jax+O+vYL1HmUQyOxT/YJ1+8vVLR25hKSNDoDKgtBRX3 GQLKRNKfcoe19f3+4Mkz6ALLJtPAXlyzxOpwImMmZ1jK9snVYaj8EoZJzs/xlOnT1bRf95N7SG8x ErQm19BK1iAnVwy1KWYlhom3KrgFhNNdHH43IdcNee/1xlUYJmo9WnrC245GOPXloWkq/nYMs3FG 8Q3cHuh/1V1LjG0zsl3vSxpM+0GLWQ43ZWOkn9kmmsTOR5qC+uTN1YzcWYZJq+EckDrZ2YGGnIbT aCG2pPapTGGgxzVIfOO5ClMrr3BM2f9H3Ls1uZEdaYKyfRlrTO9lbNbWbMZs10KRzUGgiAwysy5S pwqUSiyWiitVsaxIdVOWlQ0iE4HMEJEIEAEwE6XRw/yd/Sv7vG/7uq/7sL9g/XrugUSyWtaa6SIS OFc/fvz48eP++RT+1WR49aKGPx0bS4Xjla9LcmsrZB7uDm3RUhmhJMNsKmFOORrUuxyaLWlbPL2C Uwl4D/77bTOtEqnPtJESg1ZeEajByH757A/PvgG1c/ztiy+fJe9LMDCDhGwu1LprCm1nkDIhQNVe 7+Dx0fHHn3z62S9++Y97fPrsFz2EfT0+/vQzCWddvtWGjz77FHj8fXb8SXb0i5NPPzUoW+VyK8mN 2mWzXvPzzO82QPFh9vKfvkW39/IxwpZnmjsateT6ckFBiWSAbOVpelr9/Oc/pyEcfXx0nP25uVos tg5Bjj47/kX2zWSbPf40O/rk5ONjSvw2xmjo1WSNkbQ4FnEn99VPjYbBjvqPf93n24kgAF/X0ymj +k7wwj2tJZc8SNWbqwp9XSRck1N7a0j+AT57vMVUoS3wGe0AjP8F3ZhN1nPMxIjhAiQpSoxs8hKI rvr/kn1U/Pq7z4Hxn/wwfTjIHuJfuJ+a1ZPy4a/xi8e/5jJt/WNFhQa/znyLeJ9+R5eDJz/cPMwe /jD9y/Ffs4enP0xPzrRNlKJPyo8G/9AfdMGkBWiSByZp1wSxF2p8eqFrAW083u5tdrVeL08ePfIS kB+Maa2OYK3of3/eXOtPj7P/fTOHxc2OPj05/iUsPsj8q0c28h1VH1VvDPVK+jqArxSwNPqppABv SvgQvXax9RZLn7JmEj/RUKFTtLeh+vKof5KyMkpMrC2PBrq4IGtB9HbR3yGsvbI0LEs9BaEk0x6q InMCD3zMGT2+6/szZGvtdMye7+h1y3PFB42zgBoUgsPcZWjCf/YDnQaZzRTBP/pnoulp+/wl3WYe +3WvMR5Fg/LH+McYLT3j67rFzJnjbTVZSSPIs9EopbrT1kcZBkvA/1xH/eqd4VzyRuvyLhwjX4zH SDwqZ74BZexg/AH/AwFzQPvcTSH5gU1RMNcuOhHKibkxoN43WUzm2x85Ho+oQ4KMNuUkw4pzQZIH 4ZXLLoXDvCdvZ3SjZsTzbNpULTp+Y6Qh/YZdZqhAsUDuS+/McpPr8/qy2YjTkephGj40gevGdCIZ 5caovo1oeOUlraHCMq/pvUp+g6bFSsEsAGcbXaWpHp74VJOryB4YZv0H531j2pvCWXBn+SmUl5BA Qcf1ilDeL5g3cPIViPcT0BYUB8pPown0PMnJKgKt3OGFaXma2g7HiC3g0P7U916PsH/WVxi66rGL 5GJbP/EqDG35dCdfnzz4Bvr5+OTTs2hUuFI4AqsyjY06VGChIa8KQlluh15/w+zxkP6fd+s09Z9w 4z6dqFsT1fjBfakrlzAdiYzL60LbM4AMGDVGmlInNugSOSGEAXUijPBnV9VDLe6fONqUsVn6f3z1 1eEvwxglDkY0DVxWDqRpn3/sDzqbMI7e0gqI/S9SpxK6aeHGH3uj9TvTModYZkefbr9eux1ZeUwZ e/Ds7B7PI3QvefcPr/+DG5ap6/HuwevsZwxEgzkya/WUbrcthsVMljWJnHf/5fV/1Or+u8C7/uv/ 5d/97GcOtIx+3Jxr5GMQIGl/UTH2Hd5nhtl3z797xpG2bsiElcHCf4rhI+K0mUlAAF6A+1CjT9E8 CFA/WeFDs46YdxvLDO9Vg+prWPXM+GtSah9KSl8aMW7jr28Q60iewVB/7VerVZ9wehkBT8AsFY6K KmNnhzJsAxUmXZUanE2nhSWRxsvCoUGGHNMlfsLDUCP8HyldOIqHdWV8mkFQNDYRaNFiwMM/rzAC HRRp6naytr3Q6wxIMeZX/+zRkY2cYZbfaSQCaOVwSs85TarHxDA+dJeYzMfyntomCjHw1chtGbgC 7XeI0BB+zxsJKgyRuG7MDRAV6QHrb9OqppJEf559fKKIXB9jUBb6igSUHApgF1Km25FA8b4dNONO 6h9kf2ZUIs2zQtlo6nUYHmS2dOL1raM/JmDppoqSVQwiwGSSBVFP6ZaoHfbjmKaJ5NoO/OW1g+81 d7fTrifrTeus3LKZz50lo5+DZMvZM97vzeIr2p4Flxpm+i+xoXKFd3ZRtBGfUmEj/jNPN6616YxE ZLpLO2ADo1B6zUTBtUIF/hD86HTEi2z+DC4l5Jzixi4xkDUtk+YdNl8zF/jhV2Pg+DgMV2iXBxQ7 yR5MM8JVIZtX4cxkaAY0NGOgZMzqvOiJUptbie57/a6guH7PF9ujcA17ZlMGPwDxWY7ijSTVQb+j Fg6I68gIZGMW/s4cZmhjchmHEO3eFQSGoMBvgqrzbvD6v33CYAggvw8Js4P33SPeNhYiKruu0ARb t9dweu0AfaMbDJKegvJ7vfg4bgSAAB1xOC0gf/+qwn8nqy0+VTuwcAFAnEEeqBtbExMB9lRWjtxE fpwubYlWAhgDXvwwwfHjk6xPkXj9YXbEn2HS8Mcx/4En6F//pgh0hqX7hwINhRi9Hv5cPuwFEnaU z6a5mwMQISDy6WaZD8jGAPe9betUu67Wk/eT1Sjn92lMaX/V1MBto9P+DDMy9KE8/rNo+mfDno9h ZzjC5QFs5oQARkHZmU3/K9T/r4um3GOWbTg9BKdr1zgm/HeULxqDtScEycMhERb2BaossOcM3UY8 gF7vN8LdmL2DcLMQ3xSm4S7jvJlMSfzVcPojhBB+2xaItLEVuLyhLOYwczxgFyjw3FIlJbobYxGL 18cbLkBw82olcOUUTespT+cb/q1YtLpNB3GzFoePqwMbRDhbGrGE7yHWbdcvhuY91t4IHAODhKAM Oc6B9rSBbXGzSPQOKzzWn2UEDMkyNszSJgYwbxhT0ih3fIga+ds6GaMs5B2Ig8VFNZbK48nadu0j NORShO7oqIEIHEuMzyU/nJoaZyUN5ZkdiZsffcfkd4zOEED8EEFRqwn3UdkuQ2ZEeiASDMMG2b1W 1G27qf7x44HDJCWd25bEhdE6LxqymW0RwDzURNOAakaxkdqKnJZ2QXD0OQ7Rgk+DXifkGR+yot74 fN2pzbBwCa/iY5NrI0yzgdCEOpmOFjCIVqqPMpSdSfeFb/DJUgaJ8+K7ABJPPslvo6++fOpuSOMR 5PSB8vendfJy297ZC4jK/TrRxLzQi3xEHD1+Tb7T6TuV1zM+CyjDp5Ledej0OTVQ5OTlli8creOI n9tKUSCM7VwN8QELKLd0VuRk0/bvwgs68uVXOGT4xfQrFmQyILojlgiCAOJwJ/oltoFQ2LBG43Uz bkBGBL5HWAhOzGXnsDegmzlUiLaQnT4XTjcUyAdeDssuQaPTikBtQc8bow0cj0Fn2EwrP8Tip9CJ 6cOyrEQoBf4iRSiehTNFnAL8X9Kfi5uxNIjnJFbCLX5BSC0eQ0gxUjm1RII7pFjHtLWRXVwiZUp+ yS9SfvDecOwfTqx5lZ5e15Q6WP1fbzIX86Y1DwOdyluA34naBChT83l1geZeJ0ZNvmxW/gng+F+Z EookXOJdY5CwrPq7ahAyY3TcOr/pscuX0NSha5lwyfdeOn8RaY/N10WcOGuzTnkHALtX/Pxk/Bxz Ef9TucjlZAuIcy/DGD+kRaiWs2Fh1/nBdLnXsq42C/oXZLDJZx3st50L4y9FgvZjbI3AlkAUUS/5 4MOGiBGLHzBCY9H3dyA10TGNg25RS3GTaCNnO3YHl91FB2zkQ8mwhnsNq8B/48XSjpIDXa+29DoT jvJttT1voB7j/a42y7XF+g0gfnWoVaBa799ZB6bwffqJT2CmgSXuEF1RXAzUvWUNnUp4a2FxOZYt XmB7QF8rJfatYaVAr0dzxgmB6jubVmIOc/Oq8m/kPoDCf6qXvJai7+vrKnfu7rP6FkfPby9UsVhh hEq7ts8vFfn4t44y2khOkdbPx/HIXkyoe3rZ1vsUyzR5A5m8n9Rzihx4X0+yN2+4a0/VePNGVXDc Na1ivV5cWU/MN28KY3iF4pSBPngtn9FFncw46KRFMyvNvg7Ny1qA/mLuStBb7cpclsCRA23AWhe+ YvoW4TVDX1Q7V2I2vfdCkHVvWrUXq3qJzlnZEa3C8f3XYjb9my0F3tjuWot7rII4ObsGuv50s3TB CTQjwdt6WTAzZLpUi6qatginRTa9D1jW4IpqV9W/i0vxzru4LAnVCSWY+xtrmuZPFz6N9NQd1xHU n+68FJvrx94BA3qNjoaavhNWu26ErJ/e8xpY3ftyw215V5yffCc0eyUYffRW6CMOCk2SN6w9HgK9 xvRuRQKkncyqMdrix8DZKBcKQUwbRq9xo/yPr776ZR6/tk8opIszPjGmB8Mzo1mzj16K0DRnfiLj tAA2mwF+9eXhvHpfUUYgid0IJILzfqlX1xnBu/PX3sJ6hJyhfWpW4qAWGoQh5DIWRd9SeZ4rspvb ExIEYd7yAeNEixDxBhHcVg7wpRjh9lHg0tvthCnUrmEVrxGiHInzZ0SnwsPYedl1VmyWwEtfVDc0 L5ZGxWw66JgBjtofFCHQPRxhIUsjbmo2ped5alw54PEA57FosnPKvKaOCjI2zvk0/UqYZvdDrnlS dSp56YE54Q5qKPikfrHOsWsTyoPyV+FlPiZ/ZLHDfvrpp51+szxqO7JQ4PHv0CV/uDvjcDKTMMyi 814Lvw319TvgD/iJMaHvmVGYx6rGXug7GBV5TTiOwxiE4gLOs3duX6BITAm/E249yFc8HsuWMASO guqJL3TjGLxr+YKEk6mb80TygYbaK4f4Z4/LIvwczcIYDqAoB0+w/F3nlm/WDeLRKN5xnDgHuEMd l+9aF1kBnNdzrXHk1Yhu+c4zvNY4dm8gwWHYgYLdOfQyNE9pjc6hd9boHLqpYW9h8WmZiHeHUgYh sV2A5nYF4gsvCfadm0NfKPcKRRBDSyJHWx9SILx6JQ/MXSvGrN+sLv2HlF1LZqt4Ub/Wkkkjim6T wWqmTbp7LBO3dr+FStVBBjcBsjsYKaprVSX4XX6uppofJbCH383D3VPlFu4101SV8F3DHXU+6Jh2 1BBPa56YubtrPUUwwftYwrmlcbwZPvba74TPw+hVfxb9MVXr34lBezNpDWozdr6sptFzDo/AyW+z 3/JMm8X9FqejQjfvSYU91GkXR0NFirqhUE4ags1Ie9QEIkWaKeyOgwaLgUsQ9woh/h75MO2dS9vP bwA7TzRgfKW/beRE4OnpKceuYBQoiXQhX0viQEYZ2JAhfD65Pp9OGDzsRI5LbtVcSK06L19gBrp1 80gCFzjYumlFR0dV2loOnJQciQOYEXtQnVyzR1EqMUappQza02zafSvyaoxbVKuNIuz9Fl2PXrxM 3IvUH42oyLQ68TEA7Lsa0zhZKDa0o7esmdcoexyb9J2HVqHO0BjnCBJWnLAYTwddovKoDS0zYrhr pEP1frHB3HB5mIrP9RW0F31rbSpiyqWnptNTJ7GuBEN6t/Dcx4o0ygRNcnbSaUuwE+28r47ym/OH iTm7K8ER48bh7KQbSOsuIhmWTmGRtNW+LZutnTpO7aTlU2eRMe8e/sPedu9MnqJem58bYYCxwc18 OpuOHrRPcgOnaKcdb8BQS02J4pe0xRxr5MIuyqZlr4Vr0Op+RLhAmYaPHhnlT4AbK3ozFqkBBVs/ 8sQUWXDnYYmtTQORZwGxEVvvGt0BncQZJImOi2BxArINeh0cEWvQdFQEBJ2pchuyBeLeVW/duwnj OrEa7J+0q9D7Cm6e+5hXXIUYalDoob3vrjAHOGWiHnSBTDkuoGPM33e75lrQWvLSyxNbr9C4uvYu Xukp+6HWIav3+86zO2oTd+pkGJxPbpGqiJkkEngLIX883c8kxJ21rd4y+iVBLKEX84/Vqgn4OjjK EuZLr0iC17zfOzkNSrPVtGOrhJwY6GYuv/nuAc6NJmlVdrk7ujr4+2XnRIJ7xF19Rfr6vlvTt6bg rY6VGTKG+IxCJfQ+SpwQPKxEqNQu86OX6C0H7QabRWw0+I9NNL6e/TIfSCJQtBdac9vM9s8s6s7Z WqpC+op1R1O8mTOu8+1hhyInQdju4Xo6m4ZwLJx62jgfYYY8H2WRYf+5LQ+87y59wwHByVlXOtmh LH3ZLNbfg0T8CjTc54vlJvTrSJ/gtj67tXfsDue43n0uti4dzMyHXmMfehKo3DdZxB10jqQsTR0d RobulJg7p4FL7iADmOtyE3oZ3F+03NnrnQLjXuTfLQ1Mt57lNP5Vswfrros40VzGjNYMzLM55xyi ZZY9n1bksYzv/ZKyqNaEihilp+8qjvmAAb7PKye99ZAVbmNdhyZZ6OiLL8ddNdlssoLRc54K8gy4 WFXVAsZBSTVt05rOHh+HcRDN5vKKT0LNZYbxlpt1c80JhtHHGriwRTggaOi8QjgJAh1fTdDEdzVh 53bEFkLYD8oEipmH7btQ+DDkm4JJ4XGAswfhA/7zF6Ljaf4n9tchirLHtzx6162hinn4nUwpjn9E H73vWvfLMXqKrOimTt+Z0YmGHmrjkf4JfRIqGpDspa71kvLW832RQZ61uUHuuvmidWjbofBLcs+d z6kcnfTR6//sRCehljedzIHSGCOEyaLfPXx98vc/+9nBz7NHm3b16LxePKoW7/El/apZYDTX1zXw SrWqEDzmT82GohmBYW4aDOhCut9ckdcJzOyyngCnnc+bczzToCnkfmJLbCBDFHoEJqfMrBgnhnYJ amq1wqBkCqK4qfpQdLMkd5MGfREYnBcYuW42bVZcNs2UolSwKfz3vMKXnQMMLZksmnr684GkjCV8 FURT++wT77CdZD/WS9b1eNz6p8bzttDaJJttcJ8qDAWczdBUfSE+BhlrCCUhVnzHXzGeyxVD7iNN MP4FhnXxdnKJCrLUrNeE9kql5Ucuj9M97B1QDBBnr72Z8M4l9RyNAhWBupMA4SjibZ+CP5q3ggwG e1L6hTr1tILmKEW47ajahs2WOgHkRsw3QPHWZGnDDc2enXhRoNg+TstGfQzp9kDQHyDmL64Ino3A MfC2BhRDz3a4el1WOc8QOzgH+QPLgROlh0QULEAS7g9Xq8x+KyKHki8BnW4qpj3Pe3Ex31BsNK8H hsEj0WaGvjRxrom8WGb/jKHV/IUVZ2t5v0U2onlfw8rj6lcrbG6FeSnnilY0RdMZRWLfXDVEP1jY qlmieQe+gGO1v0YvYMkuvJTAX6TJukGywVAxDMisDhYjuyMvgeaP1AztOhdZNmYzxvXHBbebj+FF mNkFr+aEpnQx0Xw8OFX4ZsVcR20gygo/aIcdynh41udbudtTDxouL9ma5U9cR4Irzd68AeWYGjk8 vKwWvEFG4tOI8FFv3pS9HsM80TMxnAG/efnij98/ffbyN272ZSeikXev/vXjvD43By9oqM+vOf+8 /8iYCuflTqPbhhmLfHIF/GIq4aSqPIM4YAUDwRUSr45agHRYOLIo1I0R6MKg9OzJKCuOh79IeRzc oKjkEMe1JqT6nBnquPxFVrA31hI6ayWjKXU0CFqiwKeKEibAElAWbkSOaQg1YT3FBC/cEu7JGrHg GrqV4D4tU3fxEFjVTLdeeNTs9FtJVn6Y9U3QdP/+Tbljc/AfJx1r52FwUSJVjGwzpU/yYWbK+mh4 6+2yMlAW31BpjAbeYec2vqM8l1NtNwD/bMfLt5deSJxj9/p9tU3ZvLua9qnZ0ZF90yM1s2F8VEJP a10u71PItGUrwagYuVF+cOdQ4IPC1rTkMV8OwnZgmHR/R9Uqf9A+EkRF/dZZsrgirphoZSFf8Swj lxmuh/uWajlrYa82zZjRSJqhrcFWnAG50LybRCBYTrhj0CKyIUYd8ArdmcFAFpLykviTZkNfV9rH zgZ8TkjfCWtKhC6x77AK4zGegOOx3LwTWBoktj5Gr6ITh1OBaDnfLS0F583F4CTz/vzBzWCngef1 xVvn0hvJY2M8mbQXdU3WE0mvQSbKREVusUQWaQs8L0pEMLxewozbgk8T+mZaUQuFngzCoL7hQAG4 vqNGUUsIBnzX5HF7IahVc+HN/kOGyzAl7ngdjDDygfJORC1nAGIwYJ1hgeCIr1br4vHQVB7oXQwR OYETfvPs21ff/+k3bPjSmdGvQ85G1RYDsyneDV//e4ENEsvYu8PX2//kwQVZzAbJpiMAr/RR4Ra+ BVZ0pB1fArlIoakUfPtd/HN2+EQroac9IVdmDfzNb8at5vPUCnb/f6+ekGH1LvBp+3zPTeET/lhH hJuu4/Ti0qVb1jfs+5GbTuOwuTF6INE23TsNOkWRu9kpDZEGJpHmxAwjT4gGGZXO3xKXicXqV1zM 6GBeDotQEavepfwzFHn7XSpc7JoRlvDpljICvxtEXdAlPbz/hjqDV2mBlttEhdr6HV07yE7uEZM9 Sb0G1xZ7zfsaEbZGZpan9Vn6TdedZt2ZrwQaSyz8y3WzfE7LUOOV3acN0OwSjj24la7vJJEzabtj Mf/UCP+7Y5/CrwUxwrkX82dQvvW3OH1WZ24Wz3XFt3rYoc0R3R3+u2to8/mHDY3SZ3UOz1fX3DHb 4TF6PZ1m+KFjkCI0xxfXSwL2WaJgrfjdiWJ84Bs4eZwcbo5tlRo280OEoqVAnUN5C3pOCczcUxsa lg5DtR7qdfvTo7/99bLbYwDHJE0Xt8NsO+jI0sHkcmZe3J4+PoMK8N99LPn362dX+8hApwVMuqjm hKszGGb6iZhE/nBZ5Wy324hQKE1Bn/jw32g0BHdvONZdGq3X2fic82tIuV1hpPMwE0dtDtuwoHzt l93JJUL2UyUdZQ0YO3RFlShKajV3dw5mwIN714+g7UlaP/eLjp3EBuBqbe5pQS2yEbaIv7pC83av WsAhueI0deazM4rfThzYEijj/d0xhrCOLW/b/R1f7pvVs9saJ+f93dEun7peycK0HbxqkvHTIm/h OuEa8mmBQICapGBFBj5F9dfIDbRYGbceeiAl0xyqpXDCnKtH09Pv2Mh1XH7KllxSdG+gH/nFhcKn 7I2lnzqsbWNqBBheFr6m3+uNQZOsbhHQ9PcSgfpcA1CH+PoJhyM2AfdP9ETZiqeI1/zAWQW0JlIo 3Mh83HGMaJHCDxYQ3jUxaRgtABcpLA0XqQFdsu66RdFFocjJHDEmkDy0S/yKvh+P8L+ipalNjMVm qxg4ZN89n1xgbsupWaZ6Xq+3gqXMhB7jfYKvEeR5aMOP1Y2Dhm+Chfj04KiOlJN9ECSRchphp2uM Cuk8MmwUBd9zihiCsPsc6Kys4w6AXiisJhh3nDSGW215PWN38PM/O35Zdcv3yNuYKZyObpU8bkUi +Z31cHiC74yxR3bhqEEMfaGbsA/eU1+jOlfo20V3hIeWoPsF1oHLhToLeS1iQUKBv0+buVpQ8mSb tGL3bA/rpNrDbcLOhFDuct6ct8K/cF9NcS8VSXMlbiUxc9HMV5gQ/chnR64+orLlbIx/TuZ+Ol7s 2Jbga3Pke46/+ixK1ZLjkgapa6vHLtV3FCfu+YzGJknOsDCCSqE/WTKfJxTT1/y0uZDagxOWAtdR Tg3xJQSD9uFsqTl2Z+AZS8ZkIKEp8NJgmLvZ2iLgxmpIgEMAH4xU3pEQY1FlIUkTos3+4e4bt7zu Hd1Lyj2oCMjHzjPi/luftvC9N74Gnf30nV1f09b+t9/YXSGyu3b6h0TJJtrDj9RkPGI+eIvd6bkx z831hDfsUl45l9uP38ppbWA5fYexlmBo+k5SEdjhffiWnjq4o9AcsrRpqtF7kEo7ROC8Fj8s/Cbh 684muYrbJJZ29z4xOOfKsI3Qw5Vbi36nrBQWBsK7EyT6lizsGHnL4YqneKzeOlluuVZwK4sMWvWC HXbDTObtiSRa9pN9I1SgxAR4dgTTazxS0Q60ZqxrkHeTOuMtB72u32h+/s/OcHy7gVOPkkd5x9mY 9RM5W+xxpn/sy6GkX3Yw6Hi8Xk0uKqxzVU9Z6w6DhmQA6UOJTsd9TktsYcTFOw5MPvw6e5Ij0G8n OFb1BO1sxDQQDgCJdOwRXGm9nxJPom9VEeMWF1gbGHaYrc+dVbqT2BJRorcJaqHv1PKfchjjft6W BAxsChXasXOwyhUDFv6uce4co+nS1Oops3bQbo9GaWyocmPEvl8d0ZAHjHIALWxZPSg+IkzYGMTA JtRrN+ROxw488sgx1Vc9w/8av4Ot9VQ66Is2fbvj5BqPud3xOHiwk1OKH2ISR5RigYYZlffIBeo8 N9qHZLOYHyksUu9d+fp/cny++J9q9e7R6//7nzgNRDGtW1RmKB5fHnAHQLYlCQ5K6wdVUJsStxDK yikuKYTYKiF2SQxqfTaD0/bC/LWq9BPiEhnk6flkjbnFGXp6tuAsVfKj/JlINtEJYa0I1qIzmndG OuIFWFuBujEiQH7/umnePkXUL0Qmnk4F63KsMF1+RTSRa8WXMBpSMJ69fv5q/OL3aGPCbAsIxDSv MCMOAR5gvcPbaW3Il4QCkg5iMCD7OCW5kdhzo8Hwe/RcusThNm9XmKsNE4bjH5L2h7F8XAQfrIDz /V5Km/yQ6g8CXfB+UNsQbxQGET5HpyUBSMNugpRFwqrsT/bF6tLMxaSN0V86fXX82TsPJPQ1vRvS J++h3Zs+t0NEcNP52BLQiEsBolc5Xl4Pkl0iWhfdj+ofpay2gymq6/ZqzH97Ngs1DDmlBa8F3QKW m/N5fcHg1sXcLvSLBWFFm4TILds0zUvm3PiNTZC9yKGRgPVb5OYyWAU3zyphs6ARHDNA5+P87KdB sC+38/rcgya3LfQPDxfN4bpp5u1hs+DkOF4srY9VvoaDwMCTgwqG9ZoF1soNgk0CqYhgy4sc9tQF ve9SPXRv+u6LV18TTwN9UAe6bNiDjWy+KBsursnRV5HVBx4h1A8aES3x00CTG5JRlb0y0V2ad8A1 Il2gEyCl3CozWr817hlzGPH+4INNd/gYTyacYYx3kyyRNkuminMsLT3zT84xyd9VIYJGPWvKFV6N YQmbi9xRUxMNhV+VEtpV5P+AVMTtTHr9cptbf/jvkFOmKEs7Nzg7CUW3LD9warPEBHaFlEpnHiQv rTtDJKdRUBZ6jBZ+UMP0tE+t9s/i0Eo7pezBqvjoowerwROTCkPynk8tBVzJ0p0by4U9j4gQwtzH yPYOZNic9NnTs+Dhd9oQmCYKoAs52fgwaBO095tTfFI7caeZ0lu+QQKc1J8LiKeGD1I2zsTHa+Ge vjJuJxf1DoD4uIOB58HpyeY0YppX2w1bIfxrIIbDtG2nAZx+TZmSWYgzq7ZeQj5XTmNHJKrpgzpB 8tLW/PYgTK+aqeNmxqfzWF3XFSNzAbvcG/HdVz2TFU+dgWoaOz1Ians910pqblPh7S++mXFEhrSS SpROSabpIY6KSAJB/67ZoLIyHRoymUe7whLstD45GyTj3R0yjnhF0q/GYg/Kv/3im2fffPHq6de5 yiyfM8OHDrgSFTSLoUOcoXSrroTdEfLa7dOvnz39/bPvtWcUatzsAITt4ZN81zC6I9e9ib3Y3cfO LtgKvADlelOlSYHwZJh+9WHCHYY4B9MS97oHF9M9R60nOar0hFW3ntTzIr+gECe07aBPN4hwYTVG 1y8c7hv4wEcOGHHguXnnViJO3c2n8UvZPvxpAvCE18+6/FPwd/ObxjWdhsS44EMNkYtOLDUGZ35N uKWu8Tw4zTOxtoVGPDskx5DnrcIPi9zilbWDWNCmKT3Xw9uIY/+2LXd4dAybUxLfo6Eu6TySs3OT jfPACevBZ1K98WYMytt6o5PveIApjiaJPMoDEOd5c8k1rWpJgTT8ZR6b2U9vS6ng09WbejtwRD9d jz2g9hrLYK7IkYtf80EDZFDklKXRgEZiLWni5grT2085SbneulGPpDFWPvjRPE4Ij4DtzoSV5jzy 8PBNWmQcIy7FVjIS07KkP34+EkRu8zX6H1TTtLA8yAjF/JHCY5OzAqovMqzsUGKH6stFQ9l/mjYt DJOSco+HDM9DwpmdmZk+ccCIhlkfv9bnHZwr/h03mByMvoor42R0yOofhN67JITceir6S35ykifO sbmqjSvXOi7Nz+8C6ggEk7MZmYOQ+g9WJ1m+G60WLpDeRkY7DCz7z0m4mWkNB94ARXo8yY7uGGXU dz5rNgS7DES7Jk4wO6L1x83Z8+wIQDztkE8ieVB0wlV0h+iRrd2/19buJ2QP7r+79uGAvcSWJSdM jcdaTaUftBV1RK5qy2Zu/fQQnXAe0D8lk0ObinElF0tHnCD68zL8koe3t9zxaJ2nRph1kTyPT/Zd 8qae+Xs5x72rj5QUl0Fyq0NVpUaTG888h1DmCSZJIt8w/3B3C0y/xKsYJ1FM1ZcF5zEOtauhVHGC l2EPdS6w8ifu0Ujj8DhjEN2J5Ce9ctM4Ro/NSPAjj8VzjQXtdK5jxs9m3PiHYaNE/6FSorzJfuu2 2aigYVhbUr6Kimr/tiR/40FrY3L71GWXdcaTMzEXuGYvQT4fj1E9Q/+OwAgty/AH+PUp/jpI18bf v6EDf9XdgBRIt4B/Teuw9vp6KT+gpn29fBWUcruwZXu9VXU7tjllVlWprit58cP04SArfrh5iEH3 bLn5frP4nrLE7LBNrwmVlpRY8jGTT9MNe9/HVmu2WK+jtKyqk+vHKJ2rFtCPYTLZKaPTuiTXtqLE s1MGVHXLarNBWZ0Iotds3IgCWiw0CHXtVNyaBKpQL9y4HWe2sWDst8Bsi2lLbgcURRy7+El3REaz mmh5n+KtASslIeO0Xlpw4hb+y1/TiHf4Cri5xtsb6T+7G6LGTqHomWRqh6qDXc7oU7UTWjb+6U8h 3s9PyXBtfy0lP+Z4TB2Px04MLGIRrarr5n1lIN457zlo7rCRcMPJg5W1+4BuTM7rYfNc/gq0UzQT cpweokwUuexHx5dHLLjahN7GTDJe/yZNLDVZXFbF0ePH+9wDZOgjHW15/RbFhURG4u21DkyXopPb /NDPXj9/+WpPHdq3aCj+DI+AP/g/yhNqoLaQPbLdktVe1iQucHGFE8Hgu8n8ZrJtM/pij3cr+kX/ vA+yoOVTUGRdREGa2NC3uFLrKclgtSx/inECUXlqwB+L5WAXYG4zn8II+oNkzgf6TcnlcPy0IrgD eUhXWAqgNeFSUGixpH4KVk69Ayg8mOVVuy7cYGgMz8LIyEjMQYGE5rRwoLSgBLl68BtNP4XXp5Hz fP+bLRhqsMWtSk5HzqIMOsyMZD2KvAgcc8LbaoyW/nHwlNr1WpFINekVZTjAlXFgj+35/DNJAvng Pcz6He/B5dzM3e+yXM5RmohPAr5ltDOHrhE7RdGa+zImHvxzN+Mq0p78lzXF1ZpzJCcea4jN1C4v DnrKeu7IEs6F6gCcgHBEC92ATXQR71xPlkVcRZI4D0CidrUX+FW3lch9bwG7hb+ZrROzXGgziurh 36PDiDa7axk0msO4rgPCLIN1JjKQpbFcVDcFzGcE/zfoJCa6upQvOdaf+glRxmFzbZUyrRNjgaiA h7/M0w8WPtagxKt3bO0OYE63r3RghXs1T8xvbFO/WxvuqZ0M6V+e7sf1StL4zgZ785/fXZCSBw5d DCRTXICSn7AHLrbiIYMrPqRh+lgotrp80jfwQar4UhwypSzeyM/zQXylX3e7KTIfLmOhs+750jbc 8d0+yF7+H1M1FhN++5oO24PB6WgVyy+31KxWG0kFv1GQrfu2R631Mbc2HGnr5jZuEF3aYclnl11N mq1pupYmQjPDFrsRXfT5omYtGDSIUzEw9YOTTubqQMzdg/D9crnt7yT9+nb9k9qH+t0diAolUlHt G0lUIjLCJzlV3DwcudeL9DArd1HFwK8Gg10aqxqCnNKWKm/1jO3KO+OKYKuxe00st52NWE5xqtpd zReSItc7FvuthFzEfYlbHyKH8yeXXxea62coqIm0TN4lLaitvkSh4tQ/OelrqiekGDbjTQeYmpaB 3pL9n4XTyXVNjCjSr2KV0h8j+XcQwc7Q1+WyWqH/pdo22T9/OTgbIgQVnZSS0QRt03f3zYpX2DlK t3qNLuibdiSekrtxSoHMOHGH1MRNJ8EQdMXJMGFdt6jsPZbj1iHIjLi5PCdD/pw9qLzm/laEv/23 pzl3bnM+059JxtYfYYRl62wRmedmvo5N7VIHmV2rR3hGUFFfm5VQZlhSaZCaBdRzoEM3CyfBa3Si iIcu3fEQGq1auSCPBFbXS8F3CPxKdAAdkLMfvTqxZeeGIqsFfM1NJsy4gYgnvmreM0ZhJUOwnubQ DjVj3HIDdVm/t1TgOYziqvSiQb/GTkfyPedItqCjC9Tb8FHDQ67SSL+PxHcyOMO8M1rP1YBKBtrA bQL0r9PlWfIYsCMpPprvGOFRB0isRB5Rl4EPoWqhJrRp8GEzSU9B7rGpSTiF6IVQr73uy1Pe/a6U 8nqQavRS9PHQtKwv2Mh95hk7cQnGwqdHZxF5A1nw0Q6lpV6IVz5N0ydM//BQE8Mv5tv+mbeObjXu hrUdsY6NPEtKB1H9GvLvILoqn97SDdk+HwnR2a9CSY5FZLgIFRzxJbWGNL5IseMemt6FLxQlbyz3 eBLdGCOP5FtVOJKpGS6M7qX8G9hy5ATxbSqhYaa1oYKIJZfLtznF/Tlj1ygQ6VMmUUSXcSdmwuGN HUvm8fYF+/TEuwv+6x6Oso3i15YOc4+jL+wWH1G4IgUr7hlPyHVdOx3sB7JIV9fLfmIRfTty7NtG yyIUz21TI3HKcrRn+D9SXfq2uwh8zwbCIB1izcr/vRwDCYFuSjZmc9ec7Z6IN5Vg4iICsCJEyyF5 UyNYeSOPDOhWfzWZzw5JYGXBYA40Ey3aPNdXG8ICpqAUQgGs16gpthkc37pLpni4gnJFSMEEW2Xb ugBiZAXhFd/UnD5dMNbZ/aRd49AQIA20AcywQABAtxOEyB147tV8mRg7/Rax2VfNgqmNhyHO/H3K +JOqUU4br79Qie2sJ2M1btMOfFq3ITWeYKRByFKlNhWOL72vOvV2luWRmg2Tdki8x8BtvfuM3eh2 NGij76BeiPfIUW5eqfOEJdZVD9tIX6AnLFF8E1ovepLDt6U6fmqfJ3uhwIm4hAt6/kC6IScq8kvi DMIIbPvD4kH7Ax/p6ouUMCNq11bh4xtARKfWJ5RDEugPjlCHJjwA+K7LcCMFRd845QbO/D6dRvwF 4nVEzgF1gZMi4O0+ysL59gYffHebnU9CS64MWK2Nf+2lLCeOoohnvmeB1+Ek3gGcak46wPwgTOVo 9sudF17Uzg01nJdWNt7qctCNWs0W/sVW484QJMNxzqGDfXy+JSoJ/XmRIgtMcMvjUuUYM4PpNTfh 9swVyt2Oz2bfUmHPT7tS1QtuFnIqkXME/VutVqyMuZC1i/ccJwUf6hVwQBAQBF+f9r/706uvX3yL wWT9MxtV1VZLNoHDyiHMKgfln/rri8BBpD5d3ExBI0IT/HvSptxGh1m/PzhzTuW3N6d9KEi9wb/R NjHRr+V3NGed7W6HSBoPUmPkE2Xk0ca7O6vklg66bJWkf2sZ5yVrZwvyTUqzkp8cFfMo9SqT8zzc F8XjrnIwQbecRBgIHHruMEx+sVlBzVE+DExuzvrMjmgXYkxzyUyHlrIjjJi4yYMnnV863c6OU/WO 76wXOTagJjWiSMMS/xOkPKKNYMSDxyHKAbMjs/qz45hvCOtnPJuCKCX7r4Rmk+/0Tb34+DgfREna UMPHvsqbiRfZlMYTOorwhJhA0dc7aL36QFqv7kVr9q2CATNOEns+c2L2wG+EHKtgCrsK/kRq8H6b bq6XY26Z97EBYdlRkra4lEzltjYub4W6tpFX29Bls0NgPHeDO83bJPUIHb/cBfXjPhFShVTYjnkV lL2KBYeEkjKaLSOMhT/yW+EzegRMONFTI+JajncRhupZN5gi89ymGDFZEtG1ZbYcDnxxuNye1yrR OKcFq0ihZothsiLbeBnQhr2lJDiXQClTEw0j+FVSqpJQ1ZYCVCWnsWAw/osP5591NB1RiU0qsSDK OkpCgU5hcM1aVXCHahbSD/w5A86QNDOcAGSFqY0yOUURXCbOZiH5cJHUecGIF5hAhtBqueFBHmau 0KVBP7QFXFlazVyFw0Boy/KyxNw5nG0EW0zBZYS9RfHMwwjXP75xa9qktxgxLXPBJC6ga9P1NQ51 p5u4XZmAlRAX01s+OHDgWg0XegZL85/u+JeO5A/IEvj2xoWK6IU6scEkZ5EAFcnjNzrE8fcswgad jBkSVNbP51JnSB3p4T+MLQlGysKN/Cp+onywGvxKg9MQjZ6eCo0lZLALYYXT0UQTTyze+MI8j1D6 G+9qy/lxOtYH6Cwl9iZwfoiQetpTOBr7rv9Rwh7v6TFsDlxsrs+rVTUd4/MojGtW345y09ZhkPD8 bVUplvSqadD/b+S6mIWWMte2NXrQ9mEhlsMsEnYHHSazA/UIRovxYgYkQA8qfRi9HQQlY2vZgb+q B1EE1UEwWNvNqOwPo4E6Ppq3QdiB/uTHgAvQ35m3g7lkEhMNxrDsG0MoAlPfcTDwQZSL2Mt12R2v gOXkZjH2OINhEPEtcIm3ODzQURM8elw+/lfbmZ6MjAUiirH3CNVm8hAteTSHNF5+cMsHvoNxdR26 ZPGjfi513VQii/fNW/JPUow5dFeDiQ9T57Ah38ARCKAocxqazONhCXYtuIehGZmSNS0paVaoe0dU 9/8MF85eYu9aLqGBta6zWGxWvARKIpAfH5eP87QLLebM7C+3y+3YRTXrD8jQ2v/sE9p6egUA8YGR bJGN01t5bOzws0+y85o9QgVNyiRdVEZzrxYY3gR3lJso3au0fMvBwzrhaVMx5vhNs3qL+kk9OWcd hRv59c+7+3LN8PlsVVXn7bSDk/fu1TRj3wabS01zH19IcZVLurvy5cR3LAMKk7+pdOvykbQ6kn/3 MYNKUb5LBJ2UwleEduoyWmQlxdIGtYghlqd4+9gD0xNKKSizuud16O9fVh36u7qgP//21bPvv/3i D7gIh3hzO+SGJVepJMOdyq4kWyft23TI3Lasm7KdgDKLqAc4maEFb9EAp46QjCiBHPVYN3zeQrsm sXAXPEd8cToOoqvFokuO6VyA/Qi4AZhmwc/n8+3A3KWOkhnbJvRMTVec2/VqwgFFZBkuk0lt7oQ1 gNPA5DKRmacSFPsFUsmK/RJh4mKeEvQEDWvMsedNHAeTMawAAo8wZpyQWQjsrq5U6Iy5ycJQJYn0 WwgWysJ1mVG/+0TchHGWtfUDTXknJ/i6Bf+cApgRDom8kHXmu9vzK3U1zR+M060fjaaxy1TGiQVx 12G8glOlue6aq+nInNf+6nWaEI5jE4MbHJo0MmC8N6X+HUFZqCADRfWNfJl3Y8IwmsH0JFPUFKoz 2BPnJI1WEgfD0wDhium95HA2YxRsHPPm5ZljMk9maxOzMVsE0xFMEiVggEnSEaDHrVC8Kf7r0EtM M4sOorkaEbV9Wj88OjnrffCkpacODutiLdqkV80NPlcfkYPJcXTmh0YnW1RMTyn72b48a2SZQwmH DJiGSjJRe2ELjsD2XEb2Qp7ZtUcWDVGNpkqBzD4gsYVq4oHHC+uMWI6eBFJTsNG0TkfoAq5PXt1O LgTr4eSDNpcJV1cO1V53bmzuXKrs0zFXQDKBJmkqaF/3HG0XWpNY8fzF6g5A5TFJ6X0mkeQEj4+S U8bLwT5Tttyr3iqm8H3RmzgjGXp4GNH7gG52lTxlkKZHywwDeffYQ76lKHrQMd4dvf4/Cka+dTFu 8edHpOwbB1BGPb+erN7CrciDuLW4tg7YrdmM3Yi0PwVlk7MAz7txNkG1ovHvja+pFe6G1sxtrmrO 7sPpxkkXJfpMM25pL/xMeuclowIPvtSBhNF27hUs9AUZI7TBAmnATDWfXJ9PJyfo6sixh1QXrr06 RWhy4PvtLEBWdXvoRTYjKF662Zxef8XYFVY37OgZKmq6RB47LBuomaQp04mFqgQxmWN1y5Eh6xlS blozmgDxKJm/L2tcBXKgUma1qHOmgoOPk7NbNCeJps3NIXBllj3DDxzpfUW0bMVVgXpympCcv4Je ShFRt+sye8YuUTw6GHA/vNT/wA+GP+R9b0RYvLWOYOghwU7SklKcKlmrA+1yp/rVer08efRIWKRZ XT6CkvDxke7z8mp9Pc8F1fW+xOdbvyEl4X20zUJNoJsFWeiHrLkoAj9tBZ6RzsqsjjNyzC+/kMs2 OoMz9k1q/a4oFb27Wk4zL5bspD7fZi00Vc+2lK8Uh0kC7bxaYypY9utFSxuBXcHIaY9jd05jmCSe ffRof6NvOr7ssP05MZ8S88+jG6/0XV+4rZlMXUU7oCXVyQ5NNnq6jEKz1xzOj1Qc0ghZtEhvQJrW bRiVQHTYyzDanXKX3YiTHk8TsbaRZCjmlLAe0V4CE92Pc1x5RsBHS0S99YFMKGUKscyI/mvumCIi CucUK8NEbQSiRsnYOC6AeWNeX9SMrU0hAq4takAnEY2LvxDezHOnRT7JqC1cQnqpQ5LiSUe+lfaQ E9dLlSrcmoGP3iMHgM6Saw56t/48HVEpZPkG9omInab78o2+PZFXETt9cyCG5/tGP0RYwL9h/8/1 1nRyBedAtdqFR0UOSJJbhB2fTdseVMJ508w7oRLwR67HHQ6EmItm8WO1aoiM2oRt9GbSUmqTjkYT 4eWw1fqeIz3V5yQAGkt64bZEW83xASv6/FU/CmTn71NWuNS4HIMC9KiS0R1ai7synFmXxZBvUlIn MhYa3ko400GR7nwKsfVD65wenWHiwMV6ckt30MQV4bq9JNzMLM8+ytyKZTObYWrKh9knFEX8L/nw LFXbuGs7/ZzomsGQ8ct8H62YR2I2Zokn5GQ9NnJ3jKK5+MgM8eQ4CL721GoaBx0+qAcQRh2KoBXH XIUh0R4YGv4HnUl3FHnQdv/4wG6toa7eEt2hjcEMZjoYdLu1wTyQCOLi6ZvUJH9ICgL8L/2m7Z+A Gg87CDgFPvIbCKsI+KcRBPzVX3uuW6wJPsECmAKwk5unil2O1cqxproZj++VycpvhbJXSUORGXTq pSNM7Th932O5FHTk2jCUfrEzga1exrEOzlOEhP7FVgU1TuBqGxvdzhad7b1c8VvFquu27IkiZCcX YcDmg9sBv2yGfjHBa+aYFLOQJ+hlbkVw76k2dsMvKxkproYPznzQDSIQ++SIeofpBxCumLOMWMRF TqyyqxlPBKBapnmmVZsUteLlq++ff/u7u7A23R1PuKQbwkjFAw6uaS2qZUaxbct8cDfp6QRFCneC bK8cfLZOfjHtdVo09mat+9hxd/Qd5KWTg5zL9odZKMpUAQH1eI3v2HpVD6L73XNTdpITuuVV9RtH ZXOymLC67osK/MlXFYglIkQiURiweDKPWqSzLFf9bjNxnu9jJ5eyhqlOslzQvMxaRsIRB9jrmXQ7 eF0rQWRTag5Xz9dwS9KUOSpWUme9ZzRGIIqnwxasq/b5CiyqlFzo8LtSFRk/XKQcOw3qx17qQd00 FCyYWDRsY6z3dwyPzUNyG0apMaZvQCklR20J/3UIsdxyqkQE1+PPDjESLThluJ2uXowhiFRHK1O7 LULu5ILpunxovkyQ3GVVU4z5eoNMHTjdpR0BTr998er7P357RuzmNROsi89mGH2pGaQSnIYuWYLd zWtF6PY8FotZaVNqrCgzpOIf4qMPyw85rF1iqZwRHrBk87axw4ipCviTV/4AU5Ku13SnpAMDTUJw tIo1Fg4nFP8NaCGbhd7+JRNbL3A/0X6iguKAYnC7E/i35FaqBxeogosW7/KIvdjATe9G05QxNFCb 3XoGPWp40iqh5BhmQUJWbeazaFxe7HZplydn+FUWX/T6sBdnUxp6QqMjAwxa4Mm9trLtUDYATRY3 Eax+/QJBCh2Vx2XXMpUVfte0vXbZ5gQaeNd8BZjWmbBlPBwl3SIt4jB9Z7eMuezyMv8Qb/WU2PSJ EWcYt3Xdq3A8r+T507madx1G3WQJyzmU75Yefg5LGnzXDugeOLIUMbzKid6Hj8UsLsmIml2gUBqY Hequ8Xq7rBCMoJw3CwQsWJFmC2fp3HPK1CrnW7Kclnx6/goODYT3JJMUOqySOtuwWVBsei7cRpMt G3HlxxJkGwIJi6YkstzaCF81F07rFua3DTA73K4YtIMczXG+5l6NBho11omRXF52bHTHXADp+LVR DLIE7mDI0VFaTzYdCV7bva2n9THIJNkPZhwUjBEgKsiRa/QBE9voCoOhL/FWb43C3llEXxLoMiPF CJ6EPaxVYvP3GLMkDJT7O5R/TwONq+J2K1yK7yS5eSzphVjj2E4Kbtw0wzDa2MJr+E+Rv/7ui5cv 4dNf+ttqPm9u4DKP5/pfBwFtyMYc0Edl6COBuXWIo2XH7eYamHVbhJUVnJqxV/zfXGVnvZLEHsDl K9fn2U04qtQxW0T+1NnGrtLSNC4ca/zMHI9TvtJQjrz+5fnj6+ffvjqhoIz+4aqf8TlFF8Gq4tdb 5/J3ENz1hBwZn0yUEDL04e3w0RZTYs84RljnBgodBfIgKbrohXIRi6BIvA3kIb5Rj4WE0UKJY0go Y7Wt18m2mO73aQtXcfZVqrG2xveyrrZAE+KBg7qVf/XF8z+g43FXB+3LZAfMNPed+bMPGiwhJONY n33//Yvv7WDF48NLm1uO1zdlWy2LHIMrc+hgxeySuWyU73DyCuGeqUViY3EIUh+fOweOO4UwHa4n KuEMnn9YydlW+MlMMBRMTg6JlMxaNm2qcdEPL26mIIJBfa3fV2POsVLYdCuD2BtPrck8h+xBAe1T vJqhwV1bgId3u8+8jbw2k7/dMfvbv+30vUNVz6BuAuWvdR+he4hQKbIlkRIcJ7LxGsqMkUHeujxq 3yEkhNomS8lOaougt9QOU4a41E6lE/k3pDaewJlGTBC9M59crlU1tKV6lgEfNEUvo1S9H+GIlPZH C+jvWeQ9vA+n+Cl2fuZmV/19tQ3s8AeOw4/5joNInzyxToGoglCbh9d1i/Aa5JPkW6PwL4HRVZ9b TUXBVLiGr0Y5Di8fdE+SR52NCLGQaKkNezZpmfSt5PiYoW1wSmdEW2hmEXmDtWQj4zwG6pB1PtTj 3lZb6hLRcyOd1sFsgnKKRVZQ6SFWdZxw4DBYi1ESCw9BARgoH1EFLjv3VQMqKWFEMLypAl47TsTa SIHD4KIDCusy/aursntk3HFu3qXh2VxDnibWl+/7ND1l74ioB1aLA7YHLcxWDJU4X4GLFa38gdUc SRsbGqP+4aolGlKCKjptswdxA0g15Y1AkQtegGfsxjNK85WrrXHJILzYzIS0gjFpBc7AVS/I49yf lJWD8Tl5fRaNuW3h+ZvozRP1XgjQS1mMLO94FHJkIH44/ceTszuOipe/f/5ddvpgegZi8OTBVIB2 ko0XO+aCfozHr//e8WNcNG317uPX/9ffsQ+jeuYBqYCObYbkXFfsAoRF2W/RdVfs9E50E9srLhhZ +ch10eQrR8rap2az7+hr8u8Q/wI1RjK7oe+YSVtb9LVdhD7Rz8f4B46572MIyXO+ZlbAPeW0lwxp 4xQKuKyYriIC33eGiv5gWLzUwn7+ILRZFG75gZ8raR8D7j0NeEkaeyKA8w22m/N2Xa/VP0tbJ3ee ift6kLnO5NgxAWNwJlrJAqPuk70dL4X0EIG6T8KYNhhaK9XA68vMmrs81r8T7zAwlP2eYeiNd7xs EJK9nuDLAsZitmu3TPwWTLYVBK3Dc0i6/h051a4jd49Lgk9xaux61oLCqJrgKOAjjTb1vIXTHzfi tYeV0HUAH424Qm/3SzaWDwb/XH7rkFlxf1z/jm6xoDeXKDU0z95vXl0hbMMhkAT5sokP6RyO5Lk4 orHDH55GaFVUiD8u4TJuPCVneTrmdIAv5YQqiLdBzGB9U7HbInvWaUpPMq7ycDCu03HqpT4UfZg5 EU/2yg+wNN7H2iIRkNlxwJ5sovomCtybp3dSXzsIF+Au0tl6nkbiPtIY/uvmdVIRDhJ9eTU6uuNH 6bm77fx6vuglGAOFJBPZqwCzK5eqZg+ZX3fuf3/0pk7AYjyUO5fsQCxonGYaX6rQqlcjlDPBYtJi 0j8tBjFs51WQblZawbDmmhBW9LSU0nIsuYdWIPPMZL8Sl8/wvSVw3+M62k2JZ+LTSVuZ2j29xLlk IuI4vprX1fqKTm59TTQF3FfEup3Vt2v0fh7Zo5tqIiQmD1tKqL+qvRJLF+FjBM9G28VvHPcfHDRG CksvHuc+F0HUR//sLRrLoeB1iyljmxs9YitjHWXfV2Ae9EdeX00W7ssGWufXiDqKOYHJ+fbK8VXl zmMYbhKz7z55/T846h5Hjb/79PX/+Xdx0ApDh7NzL+praEJjNoFeK0IX99y22zJzw1hWVS9QAa1q 6CqDoHot4OK0xKAbVQydr0zA9KuKBvs1Z33rdOyNcItT4IZBBjX08jO/8Z9sKWH65I5Pi5Nszse9 QHSPoyDAupgSGjCGjA+M0hfRcssoj6ha+QZI4zXNfaCbE70sAHPMCd0C7hhA8+cEVbRpN+iu7+dB YjcuWCg0wGPdPs+ob2MHJqvLDQIqYTDexVWAakXY8RxRcL1cb3HfvttUh8tqdUhALohXIQ9bZjY+ AsmC9tDlZrKagL7FT+nnFTeXjg0/gB01by7L8WRZ30xWiyJ/clQe4eWNJsHZ7qLh511on2vF0qAk PpSYw10yAphxsn44K2vTPymcTYicFAKIeL2Fh6o2EueD0jqCPKL97oIRugfujplGpIwR7s5jC7pj UUegybcGE8R3x7I7psiZXAhl2JXeRK51hiqBD5iT4x2LpDZH6THHbo9u7eY+7q/hGvoOFVGLsqD6 fQJZ27bnAzzqD0ld3LAAHeVFh9JtSknSwkFn78JK+7h7dw24m6MkzdFhoN/7a4CGKpe3OSsxwmPF lYSdFtWNKQ9MtR6kVnrtZYHkdCQxXIa0yCX2CxykITsHjwyUPCy9o8fDww4DBiWlyCnMeLOYNjAL SREoxjn4XkP5rN3Zy2eK+as4wgHxI8VhM6iqUYB9exxhNScVatSCuRCL8sIXBuo4SIEM+83AenSe VnyT6kkU9wUlfuLTgUK7JvBNEEFojgoWRBfAECakqt2cOx2IO4YvEXjVrVTIXmFGExontCIXuxob e+Ox8RtO8ucMuuy5R06QHxbfKChkwP+xhBEW+ekP/3yGBxGaEq2E/uaL1//0xR+g2MePzeNkJUn9 sify80mYkBb/OT3hH9ncd3tnpls5nlKHUs+zxr/77PV/D2oeYtOZVGXvfvH6+f/MWt458MbicFpN 8LaAL5kSEMzIDYv6kLV/dANpy17xdJB93yxAa/1uNlks2our63oKzPd1M7+EOr9fVW/hXnV4mH3z /FU2ry/wPjXtIX3HBvKJIKcfl8fltHp/nPfgF1Tw8dvTvkmhhha673AgJKYxi9rTF9988+zbV0+/ /uL7lwRa/atc1UFbsAj90BJaoW/9xLgPuyCmenlnpSC5LoNz4z8xhsuiEdyCReP/yOE16PjmDBZU ku7EuGjjNWDqpueh29fDo6Fp3QQIvmRv/X9mz9CCuX9wh+acDorbqT9HgXHYOI6rmd2dhE043Sku ETtBSJz1VKcXGtdRnYYOnIbI06vd3XgBd9KUVpZ/bduxR/t4LLD0hmj45LOzx5YXoT013Z6dQqUz t1FocZXCfbqQCMdUe+FUTs/8+HMhqD++vYnvvaS5zkMtBcIWMgoqOOLqQTfkThzwhAX0D9BiTOvw U1czzOCaSVhY3KZfvIu7ectMJ+tJGNzg7mWTTRBtisgPi7pyM2CBbMcm0rE0M/SaVpD40oe8Tyqv 9GXztlpYqFUSxGglWRWzwJEgie1MP0Q4zrGml+wGp+LiSNNJEibtGHNygtbPY8+4WsKL/FPkWINS 0zBKkBqXxxMnshGe74xVEkR48rvVPvqLxlS8gkMNDiXy0cTHzYSGKvM59YZ2FktrvbsRb3aNxx3z wqfKjjizcALTDcZko3O5NvZg1X9gd1kC+cTrSudy5i9St9Jv5rXoaOiDBk9N0sh5tfce9qkuAfGH C/HvxBqnT2+2lDnagHNAeke3bZSZ3zZK8teT4nFaQSuMo6TP2kuMd5VqXFVAlkX+hjS+Zjr0QfDM gTckJlEHk3rGSpVU+mXKt5zyIBp/hvSmxXYGqaFIuV4EjLRzOJ0biawkyZwcnbzHZildHKzcT/Gc rp1R7O9DBFYx6NAIiYA4JfWCAU66qXCPBdHo+B3Bh0k62DASEbHuyBIkwddQum7Q1P3MhG6ZsbiB 40fhV/x8enic8FHAi4/W2R1t+kFz6OwPB5buR4bcxyhyRoouTA3h6zvYgWZ7cnh0lj3M6Lwc3p0V 1NnMVsiYLe2+CpzPJ4u3mQ9zSK9KiMSNRn7jfBoDJvpA4rGYd6DTTBby0CYZQ6XJlCzPuw8PwXYX L9zTx2foh9U/7YdNgbpiBxE52VygsHRveGkHSZ0Dw3NeYKraeD7ucHCx0OX4LO+M7KRyR7iswSQj EugkyrDHg0AQ844XmuIY69ZDc9mpBLrKkTfd/gguxUdJk2F+kiMBuwVmBHwYWAPZNmp/T+imqbHu HG+OoG1HKZy2OzvbRy4Qv6KGYbApEwuHg9PlkkEmVi8puuNd5DGDxwjpm653dIY3DWMX8BRRuskV XsXBINxkUK3z4HCYGoo9zI5St+bwTN/j/txlbJfSxS5dLoKgiJ1eXWAJHs2ui3Yi+wgeM5rTvFvx 5m2g3QfJ2qX/wFLi9Hj3NT15O3ZGw3dkY6vpuCjvNwKD7Ty2eWxj8wN8GdFEPQo6DpYL3cZzYe/T k6Mz16YYCeveu196CIj6pP/uH183/4nNjFPsDjhlq+hgCwnbbdfTw3l9TnblXCvm4nNAPqX86sPP xOPZBg3W47G+Dk/O22a+WYNqTX/HEIlJf8TgCRojtnDpKK53VtEDq2C1+c/TnI0js51Q8XGyrIJ8 aWkvUL4XRL+rdwm+s1BKSMeDhDdpc/5n4+mBcG3GO+O8qnREEhUJwgFKsymdTSMN2lvw2Zw9LH4d e6xrhHyrddiPwnGHPLWrc2Z8NQadqE3dAEpOoYNsSyEyjXgayqxhsC6//RH61Q7lNslOOyPrhWOs QF5hWYqn+IsMddHgM4RkwyDEOxgFLyDxgDyJXGNkKKFiyhcJfCdP/V83sC9hCBTOOVlnIM8ZyR4G qu43xqNCRtDZmoX6Jo/EQMpczI3xxsUEqmfGBwZK4FvSWFeM3TzHBvQjKXhtoKyLNLlxI/W5Xfj2 j0uiaQqgQ5ztug4onpGTBE1d48Je8Icv4YfOjkzNHX0BiTz/Oa3jWO83KGNdrmHj4qDUkYZZKSOh j7vebEfZ7djYHxq0P+2xbDh6b/L5mKJjx/i4lACLCFzjRbiL66BlYMrDS/eP2UQcdeSo0NE670Wk k9CA6ZFTR++slLhUWv8G3oS6yb6hnwfe3AhRu23QDQklYYjQ5B6X3Dc2q+vwLYIgFkqvgAS3Dr9o EfchzkXRQmFoS98Cb9XXlFUXuOo2NMv6Ir2Q+sOM1oVJMEic2aHzmi+niGOCS09AGXLJCpnCLxUw ATstJ+mAOCOv2Ond3zYamSB1d9ofKFVH6A+fr2/qFg6aElSDydyc9HmqI+lsszaGDwwlk65/PoIf zDlSyoDTV4EOEjuz9OjsuIkFNUL/RO5ubD3H6QK4W/qyvo7tUGJvmxpXXFxdEEe/js+HfjvDLFHN TZ0TlGb30DE7+EVhB17h0i1amKF0doPiR96e82TD+jANomY+F3HTuoJSpWwCEa5zPsZfea8pBaXd WTlpMiYrEiYyK6088BFRHJ0ajgphBamymtzIF56pZrNAhJ3MOOQ6/prERwUGtMtGyWijmKP/vJo3 Trpm24HDGfZLPMTtX31vQN1XM9uiRv0ZLew5zi3ViKhrr7bL1J08/VrVZRGY74SMLD5K9e/Vt9n1 svzbF6+enWTPFxi4CBf0cziBLODr9+hT2cIisDPJDuy4XLA4UNguKBp1vj35YeEleOkErROIyPlg GOJAdtg20ji8Q7x5njfAuc8Reme1Wa4HO8w1HY2f3D1eipA/AVX47QL1ow7i7SDWyqMr5jbC6FKX MXeTwt7z/el2pCFJ1U1S8CRFk528HsrgMUIoj8duPGh/bPeXGxaqLGqTKk2n9lnJypMOMcH9OSIl ZHtp8itGmvlXaNRt9SXFUIVNcqTfDquOG4GlKMvphSGQuF3wuONODDtB57NBczsq74BVjGjhQ/EG Cydmw7upbSDY83wPSjFYmxeon6bX7S5OvtdU/mhsoC8ZJqxjnf0JcBcRxJiJNPW5J9lw58HZrpvl fQ5a0QF3a1YFr7zqdPZBBWpX5nix2NPBTglUvXJ3PWedpQDhc3LkoXOW1XP0xvDfVigiK7s9QU36 tpyt0OQ8U9xcDsy2N/G+b841TSdP8NIdjZP1Y29cyTuCRaNYnCgExw9xZDTEFCBaEIDplUyl6knq DhiSRQ3JI1riVNjlvW357CCtfN0PKXG5atYNXPmj2Lm7aOYHPfXTFyZOMmsvV3Yq4bXr1LTA1sdS oMn69tFVhJp6OWV0tZIvjSOjk40RoTJ1m43J6RPtwO2YhjhWqIHCdyKDFaDULnbnjOk9RZ4N8G+E Y3P/POc/Ak5Z4n3hnyarNnwSUWQ9bfluzx9Hed6Bw97p9qJj3v1AbUqNGG/OjG+wz7gKre6QTMmz x54IljYkvqW7tjnsCNG1VHc+J7W2jjvAB41m4LB1xJEsYompet5V/45KwSh68RpzKy4y7B7sPgUO GIECaLb61GMJx+hGFr8fm2VVEobmDEPGxO5Hhofnpg9b3BcDNQsmqfT8exfdI2iiCAXM0JYXRRLG qVrr0aD37uT134nDN2FmvfvV6//u39MrTI8d7TP4etEcmoQqiqWA5rjnL9BI07QkiNuy13Oi+Ai6 HkF2qL4aWcTvevG+XjULHLGb1YCfqvA6sculuUQMnxV6NWfGrdkgBsAnAWEYD++CBo9qoj3lQ+pN m4s9qnXkfqb8ToM7ax8Q9KutcSfu+eBOL3HKKH/6oD3zPMTvNbEPntMgkch+fFMviFmgMXRHpCLH J8xA5bNvXzz79hW3+XHqy6NfmG+fvX7+Ur+1ZX/7x5d/GmLoM7l+XUyz6Qpu9sMMNIQMGvrm2ZfP //gNwgte44PZ5D0GS2JULo/DHcirL59/z80fP05//dkvkt9/ar794unTZy+HaB+aLLZs1uWgy1/3 /uptlm9QK/OdlPGJdD75sZ5vbaSlvam7G5TCaZZN29Jt/rsXL5+/lv1oUF4mrfq8ZksKGa4IPW/R 9NWAXWbZF3PUizBYR9SZ1nkSkWfDcFP70TKczWPE/4ohFXs55srWD9g84qN1645HfHEgysd56uXe V/+C93t2p1AjGg0lfBFwnmBwPFSGXzs9B8vWQ8xnS/5FIgcGfOdnAnEalKPRc/LaHbHoEO8U6p3t 5zUBY5CYC2ZDEvlkCMGbB3nN5GIIeoYFHkxRLuD3gQcjVyQCkZrDYryQ9ocZfzHskAF/6Vsx3T/p w+EjeI1pidEXSUS5UdCNhkrTKvw1aQ4IaMPTpfGmCGp+s293nLuCEeYlVy2cp8OsOy8f7klC75g4 IcbovECsOFnIMerYfuHuvCT/Z9ia5f2SXHexBvYc5Q4MOYNolPKo8Yxrapt88ZJXMus4sx3OEpcp uNKf35nqyAWqkVoidQb7mP1SFIrzuVCD6hte+nKvU4c2vg3m5ibj++d6MW1u2q40TFbu4FOkFXMB Qc2PcQsHmmoQ+wcOkQ6HqGPBL5fw7STjzGGZLEuM5tMts/DjPledTkt9d9vuyX1KH846rd1pweRT MPZU5+9hBAVogIxeqMmLRGvLWOm4k00iy2CvV7lnE5+3oBh//vp/FMUYQQUQUADTtI5e/7+gLxtv oCH7CvEh9qWANqA7Fhcv4q+6A42u20s/dDC0dtkAwA+PJtxPx7bQcHuFDe4Xjqjl+aZlUBro5U3C PYUI8NXFW8JaGh0PjTx1LQAH/DaGd/HrpkVMk6cvvnv+7Eu+PrHt47j85JEsW1sut/1WktmtFD7+ IPtdtdaUofQYh49P6tYZJGQzQwpT3JMNTwQe7gv6u3BcWRk0apQd+Z4OiE4o5j8B2xwrfDpGfk+d Lgf4AH5o63P6a6odSOEmaDWUuxfN7n5G2E9SKNKYO5xvTQPIa/jvT0o2r9SJdip38dClpLsAOm8y e3Z34Y2WW+KNBXyfFQyCJOwIW2CAe0CZ0vApLy6xUsiw9iPuEcO7M4tTZLgwrHqU5nUkvgmGT/lg 6HLyu1a7nuKTKBru2SNtzhna1rX7PmNkg76EXaK5+wY/2tLMK6t27QgQn6DRYUFY9qtoOzg81tvT tVts4tqUvMVFkQo0iaMd623b4bFZc3u6LVMqiOqDZejraUMGWWnF7834Pcmvp7bO2Y5Bmmr55wwy 8yRPLW/wToC/QMMW+VtKOqyxmDtpGUoQmZ6pllLRz8tqMRXIUZCTF/kANY7o+yb073DGpR8p4MWP bPDb+QdkNzws92gMEfbnGAjRN7Uw0B9F+SDBioi9JVTEK+EYk7KPw5thUrlx+kZWA0XiPdwsP+RF AY0L59UU0dTI2LdETI1VKzl0ribvK9MDpyQ631xmB7/8+B+PPj3aNay+TqcfOX1FSx5UZZpYKIsQ XUaLWpHGLmYJZSZWULhZljnmqMUPY00WXMjX+Jq0ri6b1XYkzQ0jBscoAi3PUdDDQF6N9FeJ8XBU jEvMyrMdhYNJveF7pAJO0cLaCHlS/kWuliCw3z0xqiCJSg6/ePfr1//PL3/2sw5X80uF8APtkIqc 1y05K/PP/Nd4VV9erV2vc/ko8nvI0c71j1UIgYaX7tY4i9MSoyW+d7HcjgW1mzAX6FOvZ9heaown khyGRz+xrqjfbZ9+NX7x7R/+NP7i5SvEWMF/x1/94Yvf9WQPPKeCzgYwJaBHBjIZc5Ag+8cppgQR LTZkTaDn680ab8EKxoKJAgm2LGNKZwRLDgfJJd4+7aKLYWsLeh3oMehdhQ70AUyLkuOiwae6lRlj QgH/CHHR0td7o/q2ok63fpQvwaY7mQ37OiRN4GY5leIkgtL8ZVSWwPQmxA/0b5vMGoe/pB43V+vE QGPNFgsOZXkGu9sh3Dg/6NDI+ajFglCKh5RTfXBHw6e3GpmHOXYHNPFbnfXZHp3tnUs1mo6Ey/2w SGPd8rDSei+r4abFnWlVTSmMMtRQsN0ZVWN9OTmRRBBuWq92pw5cx3tL6KfsOppWg8QK4/vWHS1q C4X5MpUcRFCunDLOZqzema1I6bH2NYbKEEZcKxj+Hie3z1DUSHjJC7sVe+/A9JoaHFuk9saA8YdB CDOgRAzumDdjwnSvPLQKJYDjqqXGvBX86n7UZWrLnsNKch5wTBuxoGgUxGcCicxyQuG8sdV80G2l xhlTTZgyj4K4jT82S2/1QQfoNB3MFRslZhqnB8XVpD6AzZx2FtWNnCUjPYkG8Y9GwjvkpeZOoLWz KL+8VnN9m1b1LqxCwj7gcchZR4RUYM4IAXNeTegkdMK9M4bwm6YxMO3k8aAbGsINAtsBlcs+p4IK TxtOukNMcVXvFs5tYltP5OdEm/Bzp+jDqodui92L5a7U6cnZvosVrtQSVI4VGhoUs7OCM6ca9eEM nsxAT6BPIhP7WT/7KPskvaQT0E6WBnouXlxvnn3upk/06VNH/YzdimAdaDxGgQmXlqtakvDfljDU mv2Z/hzstwHMMZwVPOXsIUdJe6muLJ3PdmwdHpb8+TDTf3l4gWzu3khylvDa/KsvA77T8MC4aZt8 j2Fz+dtDViLSq3FPgXIqhH24H1m7CYPiDpHery15NN6dU9yg8SiM23PoJPLbtCEgjBofjETwrSdE EOqCYAOzghXpKV8dHg/2kEMaAmY6XWG8ZBGNO4nE6+7pJBW4sQ8gReGcFJxSQ4jRLidMiewa7gfX k3ko/4R0eF/E7JsuBQVV26VbkyaRaO/F4+xztdCDQDYCe5B60nYPZqmCuQ2B64kKzlE8QZRPbxUi muEtzQGtcQ8Jo+ZofUt6o+eJojabwc06dM7zNmZ86GkbvO+4idKb7vOZfG2iwdaYDOFyg17IE92h mhmVCiI/RjDYZL0EOi8O7RFaZtnLzXmLcUmLtcgBXkMy0Ex8tRUtZqnuKGfrOd5NlzUCz1Src/j9 GggfDmJLj3rAkptrA2NNtzpYtusN3FlYNU5jWmeYK+J6soU6CsWtNgHC5+b3QLgDM9SnbTBIn8Sy rM2q9UW5XP76g+QYH7ceA5SSt5CJMthHsrcUZEpw98xC5u4RBK86TESh1xguzEMFnjCNDLOrarOC O2Z9EcGY+3YB5DUxAaWJHV0y1OhCGKfhjSKygxgBsQVWuR2zE8GKgI/E6VsNMhRWOmkx91a/uq0u +rsA+KLmeDglZVbygkB1ukF9XV69tJRmBQc7+w3r7QgiO9CJcaWHeJ3WFLo4weCO4E/JrZRC/9gV FZR0WuiIm/BuZXcCt9gQ2z2AVn9YiB9c8pJiiMOeJGrt5FsYZdVjLojdX2bzyeXImhI1Id9qjD/E xadwBo3rBVxH6zXis8PlaEHvLzvkszQ5ZSObAB27jwkqgf2dsaA0fBPEDFmjXyg6qJoaLE0liC6S h8JZj0gBWjZt7abSlvcjfsvbdW6aztBGlrZoCyY6/j16HLuOG+p0e3TbIvH7riTo5gH71vfF0Lwm mRYSz7xD79cEiOQ5xwznnz+YHmJlzP+Erg98ufYNm71dLqqBDTR6Qt35mBA8KNCgHiI02smD6ROC RoMJJ3EHO953E22tMrc5Q59Uw0YuJXcdtgZyZMcDJb3xWTO5SJ+hk7v8mpJV4haLxNFLklwJoV/d Rj5Pp0dnAerfqjo0wZIiBNn7rBW/BZDslJ+DkWPkzPYfCtvLhJHipLqVJ5GzOECi5MM5XghtyyaS zT8yxZGQ/xLYRKMKBQkNTD9vxAgmqJmgUZ5mhJlrTuQZPfOfmhwlg4jnkJbMseJYLF0OEpV0pCM7 yUQhsxXN50Qh8gChIvgpoXlTsd1mNmSY7L/Y55BO6+FFE1tG6Y54C0QPDOCp26FipwC3KUw6chx6 wz4ZZR+nniVRi1xuP+63meMawJxPDgID9nlkr+GJ+2jot4N2i0m2rJYfPz5Gmx3hcIzHWVmWnDnK vHPuamTNh43wzCHmC0FYn5uKUlGhWjubvK1QZUP+ifkWg0TNm1eREyTStJLmxsu22kwbcTBNRGwH PhISOXW+RUKcKo+ehYCtQW035grLYfnreKSlQ6NQ6EpLuLiUObfk/LnuCIqjoYMg1w47tpDlq95B 7yBbbs7n9UX2xXfPM0pmfrFxci1BiZ6jlIwj+ZfQS4i121GYizCtlQRaiPPUpw+TTn4iluWw4BMM qnV1EKvdIM/h6zder/nuB2fYYjLnhM2ibFA6rBZUbfcoBLqsagwODuxC/J7YsLe706fXJWbbWlUX G9hgGP9v8k445Vv/qRF1iokPlCIQW9aNTIiN5UoQFB5SBG5SWLANorqJmUaAIGBH4bkAFX4duZXv eZS1/sIwA91Pv2ntHZF70kwmWNski+7o3Oqi5pOXewKZV5O5zloW1IWF8kH++d415WKqIb6QF55L gllX5jA3c8dznwn4YQMu1tOKEyfD4qppKIeby6H48OnyeqpEkCn7KfpNGZyU7ti4SB2ZIZZVEbtt ObIZm80Svr5Zl7cXVtgXrENvMDRfB4m9FWeR2UKT1bka9oJchDz5aI5Zx0+R8itjvT2ccMZD2wS6 JbbGXyAZd/j8xa6g3viMNhOi5fJ8Za3nF/4U+rtJ4nBnD6vJrF74WXn9VMksiq+qObprR9I3mOFJ zGD8q4h911vPXfEUoQySgH0Rh61d3QbI570USIgHWioLmTYPhfZtDy3Yt2/biXjAkCqslFxq1zXT iRwxGBIp4bBo5u5TcL1qV4hPGW2riFjPrX0vYCvTSP5D/tvN5eVWlXN1Eb2AVa0RCG2zvFzRa91Q RQv0J7P8QURIzEzcPj83u9RROSs/22iOnmeE9cxvgdOob0A9iaDnCUgtdlxwoZOr2yXs/vXkvA2z b4Wwn5FyGu9Mo62jjZveQQ7J2p1IRuZ5PsTKtmnpcTDXEXwVPx7XYueWnkCVDxxjCGaimkwJdt8o NlJnb8Ix8BgVCC6h/D6KFqVUjX6f5W7NwOodw+jFDI7jAbEJ/79oGSl8PIDPlf08Nhkz6h9xx1CT 1ZhzaJj0wAu48hR15KSDq0izeWJWrE24DNBigbLwDI4JhA5dLDf4NIK62XRXe7oMg53o3e0p1znM js662VGa9ziSH9ARU/uEuaMTWTvR7ancmc9gYl/KZovBt2UGBvKdgKUjuPIaF0FeqXhpqgQyO6uA X9IFSre3Yk2j7scs28wSlYzNX5O1FHVZlc7XYkgY7DWD9rQ+84RjEUpH65ZYvsIPYUiUOYIPsi+m rEjLKwvoWvUUZ9hWMMBn5SVZGjE6zsTFoTGBDijxcDBDFNchHqLPQGee6NTvrT45Ng9fY3rSgnaO zTGOidsGnnekOkceoO66htL0YGzaaImzhDiSYQ3v1XCLQY2f2z1EqaNEePkKLt60EvyI2oqXBK7y LXk6ruVuOLdCyZgA8KpwM5m/LZyRxv5Ct3KpaNfXa9LOEr+xYVyyEYaZAZQHjMXkMMRjdxE4c4JJ PW+mW7TxNysU0gnYfLx7eWiaYa7lYAdD+fTehMsI3r/kUY/yGT3iXvktDbgGQYsRwcwsVAdenMwT ukK0fTtZO+F5iXjcImMYXm5Ma4UmS8dzt5j75kleVZAgp14llF0mpMj94Ymchc5S8Fut0az9s49/ 9Fv3dSrnwbaXfCj3H31FBQuey/GLNTJboFDIt7FGQSFUi7W+FTl3ww5TVfZ5VhwPfxHGkEozD9m2 231p0oEYD+dCqgIrcu/m4WmYHT0+/mSADIQfiIdhP+4bhHLHC3ozn3YTc9CdD8BZp1QvO+WVTF5D 2Byj2UWzolzslBRcg7UOgP2gyqHalul0JHutxRzBMpRkPLtGtjZ5lp0EI1jkRn8nA9+8wolaDxq6 EZ9jAuA2m5hBKO9UDDXu843wMyqBznVCjlCppB5lD7Mj11aCYFUZ5iy1Zkd024DzZTarVpLmPDE0 N4fKNtu06q/xW/z1K6yx0kvbBs4gzVEa3SAG+DPJnGpuz2TqYzzjZuzFw2ncSyUBU7xRXzz2qFzY QbOqgMoUtSqNwjLnzBPTnAwsyb5LKYI70n3AZ78+L8mI3aa4f4ukDTpqgtxxdrwHkw2meftTtM9o SlQNTXCr4iP4HBk4CqU2KKIvZkTyYXSxS/gdjvxuKMHRQ16UPR+WLV7dgbK9bJR2jV4iywaUAzZy yrbD89nusKHZubVJjDt3trCjm3pLQV6TqBfPE1l6JOUIRg1w6NUBx3Wls/dEDpjxpcteytSzhwXR cJ9TZ6eg9Jy0fpqD1k9xzjJQDdbLih9GGfrEnxHe8VFOUrCqbwZmQ+76CsTdvLmsLyjFwmK+ZYEC YzLhyaRIUiCzVDwqyTLEZsq1+AjJH45OQ09rKNSapYGSEnM+MthExC7uQlU0M9/n7vCI7JueMmnW I2kPSMiR4HWTVLMG7fD2vqJwBrMNKGyE9VhNgd2viIQk8i4mqyhKuU84+329Z7O3LAra4CuN3zFf 7+PQPq/fojnfJrzII+NFzqTI1WHe9JhTc973cZdyafPgOsybbSxKNaD+zDkY3m3qi7dwzMJ/yMer QsRw8zwcnhK+g+tByAtwVhW8DeStGeF8eYvl6D6I5is0gbSDaMQOtnIfN/bt7S1cnvteQWMf7P+w yOTVVusPAi80879/yej48d/3Em/1/kRMb7Hwd16Ph9kL0DVnwIfyp1XuEgonrZQzzGNnC1Zs0og3 oO4u0mr8vYVR31ajGTw8itN4Wc8q+pDyWjeIn1K4dN3mdsWleHolM7/7sJ6DNIOLTz1Vsy4LM3E9 J2Z6MCUfExUViCfbe/eb1/+rk7LHSIoSU51InOu7L17/t39noDGcYEaNWYxrb+B4VAH2WzZWf6E/ Mr7Jhg2+xpK9buh9XoMK/dJFso1uwI2PgiC/ZPUyWcmTm/BF4A6HW+w7kfKfEXhLtSauoMqj0TFy z4mag2F3wdV4O+hu4xf8InnevCd9dzK/mWxbv1G0fR4FLbBOCb+ia8B5pccfdcYHahklwjPtPcmO UkmHl6uabnpRSpoONBmvQhhWnXwJcrBONoXUT74B7UD69tpI2gHyz0/PV6hSGjiUM4QUhJvLg8e3 0ydpvHPYFjIg6101zOqpGeZOj8qZ83rxFcMiBG+ue2B8GuEx44bwZBUf24Q9xTrMdqfu2An643uC sizyYhAUEcbV5/wo1tTrnTmP9+g16YbRzXFp/1UeueP5WqYeLuzbGR2Vgi+4YxGSYztg5Q81RFBs m6y5uNissumGUoU5ElPyENygZ3sYd6En+dh1w8QnDrwAfr7aLJ7k0d7lUe3cDE7v1ltgKF4HYwQL Tixems5Oq/nnF+S1gDxmHtNdQJ1gO4m7ocGK7Ghc8m4V2tMQjqKUMelJVnw8zNTTJBLfijSHA5WD pM07WhqhXSr7jG5K+OtyPlnjLLyb1J8n7yeKX9Fxsi2qG0PozAT16xdo4rYL0bP07WiN4uH3be3d b1//R+esvm4Wb6vtcrK+uHr39PX/979xhj3nW9Yo4cYKl2D8rG/VoCWstyVfa/QoRzxXPNkFZUnP ZQMrYEOvvZR1ksIMl8J0W0hiGHvtewVHE+sxoNe+eeOUffNGs6BZwEvYMPKILeYaTu7S4gaBFa9n W3XSGWYIAYEzwqRWjFhbVgxnd3LSc1JWmQ5LBXU0iaIMuB3qVDC/YJu4dafVPKx7d6WWQ4MRSHVJ b8hOp53dUI37dgMzL7wZ4fUCNMYwNUfQV1Rtj8625BExlg7ITydd8uJqWq/kd97E8zmvYs1OPq2J twE9lfyqKNpxTSxDfKThs5QvyuAlYfJDUOfr9qqalhly2Js3MvA3bwQUBc9ebMxIrpa0OoNUhxzj h4+zkUYGxI9VpK3jPaFaP0JqsU/7Ei1eOg5QvUGIXFYBQMU1kYCQWuzm0Actzp3kZaXj8iXSwXv2 4u97PfUQQHBbSXSJhC3445iI7D13SYbLNPihU2vo7m+SkHlprsJOucDRxHoeFfn1hnJQmkScNsJm fSWvlENqkSD+Oo92b1QDpQJhjsjjGRMaTbC2pGNa4593uGWxq8lY6AfKP9dwc7pT4j3CJc0He8cG oXHBEi0cxr1wC9kBzEnkY89gfcdcbNHIwQAhDOe3E3DC5RBfEZXJi9e+cPFKMjeXcebmFXEtv7MF uLuRLiGXoJXy4E6VlJcPLylYvuOSQq3ChuU89V1Z6u0yX7rCHj/FhZ3mwjsMO8PubGFP9KgPW3aJ qXywUiEz0W4yAcq0o0o+SeEvlDLW5sL7tlmbiIF9ECM/X1AFUPN6/IlUY/yAmd64TUe8WUvvCx78 26paMuLPqrpoVmR1kSP4ER5yj+D0eSTHiVgPW4uZG13tozQx0pYPhWN+wh5SP13cTFNZ/hy0Z3dj yME4YgIE56MfevUStTazSpy+olmY1q6r62ZV/6jXddD+BMLWWipMJGMS61oPI9vHtGbJUN3WwDhW 5/kKClNW7kVdIfDhttnQvYXh/slKSlIZlcw3b3iAoI2ROdG6N8lJaCHPplh+kk2bNX52hPxQAC9g cPTQsnRfWayFwg6cgOAyuOpPMMeBJaOnHxp1LW8IUAkWDmSSDbvMH+UDOe5pvCQo6TJFCgHXECXT DUZ786Zp4Wu+QDhUC/QIWUFffxBlgNhOnLpxv3r5fLyZyh19MkcXMER25zChQhaaFFtPGrBN97rC t5BaApKJGzpi8u8ULz74mBdaalKsLBzJEFznHK1BOXk3FlOkHmCEsy5lYmuxzpES5HlYS8ozs7Eu wNxlmDLdjlovacjBwwDTYEQj8kOIaIhG5YhVL/7JcQ2DLe17xvizZSJ7RkZhNrqpSe2O1UiC3+ed x4PX9WDgmsIn7xsQGyy94cp1saqXGO+R4QsKGcTrC750PaIy/NlzT5IX2bplnGihQ6BqKS1ErTCI fYiMlqaHJ9SdN4qAjNzyIIbqT/GWi3Aw7xDx+8j2L1H5d/f1mzdYFaULXpqtEB068ehBHHMozdcd 0hxkxPu62bTzbSTYn9PDpekbjUecwUXSvjvCvG6NmHedAe4h1Y1Qt8/VKty7hbo3VleaWkOXeCPB RBz/wNS1q+fqaUacXtdt2wngcrc0nGVqd/ubCz1lOW8vdko7X2T5de8v8/YXgPeXcwHSvze9iJzC AV0k253OI4Yv2EtG3EkQT71PSulAqU4upac/ktVGoC/qC18KxXqisV3BHl/Ancju6XUjaqGPvONq te68nb7gYyxdnXnA76cagshY/K5wTI//bpHoC0KcV5l9T0trLC2UNxC4tWrRoSsh0/615ARojndK CBUAclmHAd+XZXVe+zPrT1g0YT67eB7TofnOzVAT2P4S+BDIfJVN+gE1VpQOyWPAN2+ooTdvSlke adDRtul4gTsbSNs1AiuiesuRhZsVOuqlO/FTQFAIGrcsirl0m02m6HCAjnp6r3DGYLst3YVVRa7V 5COepqX9EISdeDs7BuOkSsj/PjR1Hzo1ZDG8pVYpYEvtUEbCpbvvTmNPBkPjeNPxjkOWcuxYf7Ot l1zuu/ai4NbMO6imJJF/XXkb2KCZkI4RVEn3nSwdsA/8qNxNb0D8Nzr0U4ALn5AaftqWKXQSN3M9 5mVvJ+8rGUo6Wb1TQGJx8ePpicM48p0jHpCBaSou2AyZ0jun+ZRdr9z9d9Os6OEH6oGy3sARA1On 66vRGL14STbCsPubsQ8QbIAXJRrGVAdUsiaWJPqKa4Exl3rfw1FpzHaFnCYewsrTcJgku+Qv9BA9 QSAx0ciegvP8I3xvtG9rkMpe8bsvsD+GBW6uKx9QD5vjhA9l9hRKCS4VELGC8iDaEAhBrmnVbIaW sc0C/axtrspmA5s1u0YkyPANz7yIUDeUG9elOforhc9ZBmFCFaXohHMv/kk92L1Xhc3v84wcvZZ1 XPMYfMyx0eF8rHLUPS0UGTunlZxSp0OEHLHSbSDcY/CqHU4O6DaMTjp4qRKjD70coYcko2GQnz2u KNy+YXNO2QttH6IGAzR6XFLhiEjrbK59BJgVViY/lFM8UlDiEp1yIe20YnarKTvolB1kvX335ev/ 4AL4q7H43bPX5c/4QVyiesViAbR7REED4rSOpxrCaeB+evfV67933tcvYCu++93rL7/ipKn8bfbd fHNZL76ZLCaXqPPAjRD9gKHTGl/xJiY9HN5B6dBzMqc2bXdGAMen7kDCHrxXPPIyZ7NNvbrYzCcr +b3t9eShBakwVq+HcWkecQanJ8cEIHPaP0Jguk/6Z6CA5nS9nc95yAjuM4ftJDdJzJhTo2GyQVvL UKCJ8SzgYOgq6y+3fXqD8HvFA2u5/VhOutiZ47F5NXg1uXyF9/TVyZ6m/vXk8hiGecEpJb3fblY1 Q+R6Xjv0k8RbYkSxCzKazj6pCHE6tJebcynIyrl7HLMLzBhOgnZiYErXhIgReB/64XzkLXd4dMbO C2HYwi3wjbrUHQYwU+I1Q78F6VhCUaHtaO5NP5YrTu4apFgzRMsxE+xHLiV7Mbawn3XjQQu8g8ln f1igEZJrDTMbx3UinSOtnD7Per0wHNER+jShEmVaG3rJ+sBV0Dm687X4LEojyMwQ3PNrEMeSU2Cp QZEGRqvQ8rnP6ro8GELExF5QHspXwEVOD7Hg4x6Kvrhih+hZ0cHmb5tTbPss2cPOQ83GwMiFU4bB JOE/wr1q9iN/8KoLZZuVR1Tzbee+4XIxeD9+jzZmdHqlQir4TvLBHq/TUQ/U0KC3i4jo7anjjcQZ yIxOv+RV06x5xiHF8Bd8hm6cqxr9oNObiFMut4o6YKe3s2mwTHBxGTKALMv1NlyY1JLYpqOVLMOF 3Fvc+piGhelj6FDgoSOByQ1mMp2O+V1izDDrq4Iylcof5JnmBB4hLjCoRGg/pmgWfQ/ERqdZLrW8 xJM5wZnNNeQ9h+ZzTY9g6q+voBDWbg2mkl6ymlV9ib49pjBfgAXrCG5ZpM2bliSeiW9fhM1EoZ/4 WMivBMxn8NVGHhT0CZnJkE0uJ/VCbvYuFTK5ubimlBbNH8ADGwl7l5gr+85T66wI5mqNjogtPmdA WxTsRO8FWGKMgn3VMLanOFBdyA1oBxX0/iKOJ+54zQL05BGJiGpf1GiZ7X2Cku7hQDAquOjO44sQ m35H3Ql1hTEFv5+zBUN9fXk+0VFFLYh+0IZDHdoheq5d2l6ignQhuDBkcSFOJ9+QgPKUXVPmSqBd we/lZW2TRrIF8/vNAi+l8lQRruSE3E4IubPbvajgnJOSGLvxAVD1b4O5xGPULIkuZaPJBHv3n+F3 y1ONu/1kOxpIFdlFGDdNW4VwWATyYnKBocMNSPqSH/oZpIVjOMmytQZeBa3e41/N4aBd9tRqKSuI ewNv/C8264vmutLN77QtvdkxEuA5DZG3cSOOjFkhYT3rZvl8LbeTAVkpV1PeXt6QVNhgMBXeLstu UDMKxQ3oPGAgDMJRd+nEcKjuGAK/vx1smOsDJjUor0x0WDVCn5FLLUpImQB4Ctm3RdXObWaw/4jQ 6iJWGHdQu+dpgE4Uw87pG01WYxaH6AMl578zK8cJSibdzFymxcaGWVVjYL4PkcK2Nk4EzT3wmj51 GJK8WqR/dGFh4c8+IjxY9p0lcd1gO/YJmgzGpjex4mqUgrOrJnpiWBMoVKNbnHPHSig4zs7tVkll bCPOah6pob+dtFVHABBVtyMJMpG7V7OLSpdINC/6I9JkdCT8odfRj+8o5ix/cE/Vq4DWTNo/XaUn 6DZ1j9OLgrQZmrvgrt31RlXdnh6dlSgh7YN4AV8eBym83Sg8YZbio+rWsrZn8vDz/CVY4Kpp3qJF oxW40eWqmtW3o1wiBvLoXo/nxfGS+khc7cf8S5t042sWM2x0RxH+6RgHxXiXbaoPzROZaIFIhx4E qt8XA3qsy7nla6JKPkh2O55i9gLmodg98WqzniKqTfwbjha+/hr++b6aT7aFoSlu6NMzIOr1SJV0 oi7/479Gj8UEtfOmRtMzGr1c7aRoz8W3RlrXlwjLgcN6ak9jVJvhEqsGr15wv4rfTHJW2H0vBFkH +UE9NpwsjMBn04bUBcmpzkEhwyxS9Fjw8KoZcq6QjjzbuCDPXxMkhdGWVIRvJazahNoieTg2uFPt MepsUfhpt0SwneSsCORy8+Hu8sPDJ/ANNiNS7I4ZENyD/zQxSt2XdCHxmBTiBguClZRPC45LsO+X zdjwhKwJ/+0h36LQAXJNSUmBQ/a8xuAj1yYFNUqvrYCLOXcrqOw4PpJh0pn86XS3g+W0Fa0VsV5Y QPJFU8pxB0qQC+kNmXa5eJAZaWdDbpgiKKGibEXGHu5IP8cJgF7tUznb+fTouY474riIokGvSDow m6KanxTrqfzkuhfoUOpWp1dNC3dqyYRFNvS+yPmAMG8dthk0wo3QDkd3iOIOnxyeuvYckccZ8oGV XUWu3aFAGXqNuBe6S+cG2ckUIX5ZTUve/V4BP/qUYgCjLavmsHtIcJsq/ilE6JVGQMGBAHd/OTiK aMZdp9kpf4UmKefb7hPWvBrxn+5MlVeTz7X+SavW1pDMSfR88Wdceqg3yTO+q9k7QlVNdft+HrZw oNByDrwUmW6s2aNV33DMaiXqyBoLe57seAezhMa7mUN2f3z2h5KWVropIjODn5Bms0hKmTu1akMF fquJ12aXkTe9yh0tJczzlpc9gSb2+kHHK+1I2TD5eNzFvB3bqWuHUJBQago/eRnNknnHZPIi5Kt8 yud8+zXNVAvkS78lpw3J7+m1FMAQoLVvFHYWB0kF965Qz95buXaX+mJeTVYuUbzjpOO8TByIIKNF BrJA3SF77eYJvpPda3wFdAqYUOj/Z+/dmtxKkjSxWr2sGbQa7YNMkunpNLhcHLCQIJnVczFMoXqq eenhdhVZIlndnM3KAZHAyUwMkQCIAzAzu6bmWf9Cf0F/QU96kpl+in6C/BrhcTkAyL7NmKl3tog8 J05cPTzcPdw/j15FowzWlJi35p4F6Xu/LsOM3H9qP0pEdDfSuiH4Kuz85/t6XL+brWbn4myVN7jb 8HyQkOxE5/Oj+QDSKEING1MdCE2F3s0Lr9wi11jf1K5rgLPlkoX7mAZyc9Y8vsa0Twan8bDs0ztY z05m2lQH643qXtCGFbWYqQop+90z4k4wGxsQ2Vgf4nde464WHxzHRS68juaBwy68Nx21LMUyMo6P OWmeNiijGdV7neQIK4OkaIybPlL3xghoG3eF34A6lPZ3//D6yavXo++++f5Xz56/aud86TSMVShg VU1yzYLSsF1tgJjqEflVkxE22WMpsiEhH7y7QNsO4WfULmxqQ4OBL0ZcV694PKvZZ322XDxfbp4i yNLBocIyZ4wmB5tmi952YoIIQahWFIAdN192mIQePowddkQdqFb9JJRJtkYAd5FhYxnF4uSvB2nu KW7BL6M14hgw4eTlAaBqjU5azkYErWPunTzES25pDmw1a7vRw7qEVvGZE8i6OcumSG7BSRdxQ0eo jP5Wq/YcmTHIq2+1ediD/xzjXP4OOC5fN5EHyMPBaSpX4QcoVrWPVu0Gadk3T32EukpsIdtBV8L1 MAIWXF8EBLVYDtp5koSSJ19EdOTWM8f0E0OnHNy78I6oHiM/5/SIZo3o6OFuPSbqJU5Gsz0nw6/w g8wk63lubCj4J4emZgQkN7qwpNBa+LA/ohu50WhHOIwzUURe5ynBcJ1Ru7khSUEx1C2n1kTDwdqq icNLUMSFD4lEA1p4GZonsv6rUYwWx7qXc9qh7MORYWvSPJdOMdD1aEobPOwMil7q+KPTOfU8kTIm WUie5rSufad18ykHNTjsjKjSP0SC1l3wGNLOoSeQlaLCeZWK8Fzq7u1SdJ+yN5djs+QbBQBwiV7R QVG44xB4zaqiHcpLy313p9UUO5jhU3ox4dzbsCa8+3WSt8B/lJ6Gqj5dtO+NSnKMhDZhQgWN+x83 tCd53HDGqIY/rQmuzuh5qtFkmWeshu5Tf5xXXaigUphq8ESs3nXqa+51Qqn0gKRWaAUwfEzPex3+ J6GEZGUS47GNbQK9oW4pg+lkSEnHqSSDX8WmtLRSGCR5AuRqxLn86Nrwo2xlxkqXqyxn5ZvnW5+7 zCHQVuaxzkTq62nOLLzYD/i1LiW2Fdz3JArrt5iGBS9QSrEJDSWnp+wIX4PuBbXWdtPzmBsZ8j89 dsvg6x4+mPvoOwS0U6oDXMDDxRUcT6OB9avyz1MnCz4KEn3UxFE7jCTa8jFjNnky4d/T1r5jwNRn ururWl/sVO+i3Zx7JwuZGIxFRKs7pWuhDDkIKy7e/y5N231ZKnZsaLrDji4Xw+WIr3IYxFBsyGLW lz8jGxvXBmX4R+7lSXs0os6zh2dbAy9yfgs5m5zpKKXbc3+19kL+INVusc723ak4RMDI77J/Yc3I wZWkZJbXXUFENjOQela3v3SLBmeVzunw7vorPLe41Z6dA2sSFaKPuopz4ybTfJmzlUq/IjGIvWaG QZGMpVSaOPENnsB/WGOghLr8B54dYl6pZe27p7vYOIm9hpHvEIACVzn+lt0Ouz31DKE5SnC6EHjO Fk9CnKv6AHVKVlo58Lqqs+l9YuLLB0bJkNZVnTVJNn6f+sxoDig367jDJWEBZc+xcofJPKA+r8wg OfUAZ0ZWFqG7vycOt0v2B8RgVnGufYYuXLV4dVGhHrkBtpWLtJW+0PNWpCfNeoW4TA7Q8rJCgJv5 eduAFcqSzBaT+XYKkh7HCVJ8IEPFk5VV3BDh7RkBfDs3MBBLGFv6C8WGl7BDyTjLiaDDz+owHSpn 3/XCDU9tW+FbQD/78aeM055zlcNcx+2Rrkw7OBlSi6lztcvAyuxzJ5MLD/Ea5slvfYTU5a2XhgkK AbmszqFMopqn66nSDXeWg8uDArIJo7GY7ofz3FHv/o7cIgX6oO9ePrjWdh9OwjLfDeGwkmUzn3qz wTUTK5Yi6OCrq3ziWx6Y17DdJkBom4AGmlYEq5alCOfcAWW5pdYnZrln565cOCdY7c3JgFJSagnh zmHi34Rw8cM9aX9jR9Eb5zXnvLf2e8qhP9fOy6XU3GG+RYGjm95Zsr8YnF3uj8Q3DrHxVld5f7fV lfUNo5sLrCj2m+FOU0AM/kguWNWi4jqRu3d2F2ZaSifDSAKj6EIuKWqkg+mUEiSRoGbQKnhd4n3B nEar6+auuZWb0yFvyubj0TKW9qSLro1AXHNWMTmAOuY1cIMIxtct9kR8BdmXK0CUsHKr+b0fHUcE m3oYiTXBESuT1+02xo3bvlxOMuibslRZMMw7nGCgRAw4RAEmzwwiwjieXPYH1bbPWUk91CkXCNZ4 Vyi1IHtK1k+J188Qnb2TRJj/STr1ovN1LYMhZ4PYDykcilckdJN6hTJUJrUBOwtZYdf4sFdrBDAf EatjkbJap8pK8IEZqPVQavBNIfdrdMRHVPckMs1oprtc1XJ2e15I9jT7DeY58am/zD20eprJvq0v QGuxgTl2XzP0j7slyBqY441seF73QAOOOPNeZHZEmizT6SXx9GTvRKjqxiuIWT1arhjvPcdb9B1W 0sxc3MlD4SsgTkJp8cxwko5vJy/1M5ot5dMCwfPdAp2esZ4Bbrfc0BrnUlSunLo1yHUdywrIE7lm KFfb1U+nIdxlg+74AzxG6d8mrkzh1caTzRYmGuifwACWCwlA3vWJ1kydo0BhNObuYM5QpieB59CQ Dn0nN8d8mRwvHMxAxLM5XAlLBPILnyg7BRhyrM4cNz13hDhzyjDwBAtds8V/kX6HRcxN9KGmjtCH WbqBolBsXMmXVPuhm6v45kZ0NqEs10Bxp6jHMD+3BXDXybsmA5H88nw15ciBFSo1PEaHfd+sg/Eb jydpF5m44z6YCL9y7og4HDjad7JQU4/rm3Xxtj51OdyH6ED0zvzB0ejqDroYhknfazLk8klrwgv6 cXRBaDAmMILYVPgJ1RefF80NHRru0GSMdsbL5mW30mFMLaHB2QYCxadvfK9FoCt8ICNHraacl4y+ ELMr+wcmR8ogSPZN+36Y3A6jQeaHViRQ5C4VXW6StgSdesZpdHGlV4StIBtny2rnLha5Z7AxWHPg 2nCGVxh3bBLJ6jNRtfEj6MH7v3/z3xt0mXU1wcu998/e/J//LQPVMEA6yrkuHEkyC4WZL3hd/GSm kDL6fSufq0WaTvO0aGh68Vup4CV1iRxkWe9kp+kwVYsXOqmeewi0tlyVk/Gmuliub9kQ9/btwMc8 166LxZWCXHH0PH/SdxWJVyl+TT8dVpsfIhZ9VcEZutmsBvfvw66p+2z17y/XF/fns7P1eH17392k Xm6u5iRImCxGHGm+cL2SjszgLAgsY82ZhWzG6+V8ej6bb/iu0bUrjyzwm3tXzzCCl0uUHTFSGC87 jj3BaBipJdY5M62gA6DriOEWmcQjQdVdARCoUK2MCWFX+hL8pK9/BlHu+CYgRTpdOEtxsAt/hLGD dI3Tz2dhZ1BET37SLCjBU7Gd5aP/cXPJyU3kq+Hdb99mUQAE4VKCwRHn4LE0BmsuExKShbl7hinH tRhVN6v5bDKzWr2uEcjeQZGOwTGwz3dgGbgL0dCwHzeeBziQUs09izr0yf1Im28FtBpPVPB3WlRK ZA3PGkycHbCEfgzSfbe/Bzt7IcrRfHA49rQgHofZLRHD3SN/L6dbYLQpzaEIRWTeDTYXZgbTA1q2 6VS+GDTfbxIgTM9xXBTdFblB4Rrw31QYow9JiqVf4WutjoLn+Gcss0vOu6FrMCzAjdM1Kv5IX8or HXHMoA4EE6NjJLg9JVn0cnkti10ePEXDBzmnOWxAN0e0KmXGmeTQ5egemGQTduBo92jyGnB+hNR0 zqMlYxD3EVdfunTYf/WpnUw6FFmfoxrscWseZ87b4Btb1AOAgQgjHpnzeihLF4GFQhkGTiAMjbUs szbTc3H4Crgg/IIgeOsEwnPWK64J6myxvUJACok5zpj3CRhLk1yX130/X9DXPa50RJg4uFn3cK7l 09m2xSrC1hxnMSXcGt9dCWZwYgu7mq1v7V68E6wIwrJoKRdLlBYbqUeclh2N0sgjftC07R0mpoeL EJklCbhqIJcM5bXe/5c3/9FI9yuQcauz2eL9r9/8y39g8R7W6woOGVSJMPoQsVxQrK+B6Ik2vDTK GDdaBZRYf5hNBAw+dE90f/Ws+L+prla4cULxH2Q1NtOV5HSuSAAX6+V2hfc39BDVF3pStjnlzRhR RbBWH65P7/umvs7RkXa2Q5rq+MN4PWxfLaeVMWaNSXsZdurNcl1BuSn6HLf1w3ZPb+84kNobzS+X MPh6eNJhZRIBLFEwPPVFME3ksI0YMaJw/jP7AYFwDjN5Rk30F9UmnVLUDP9O02mO1+/64rhm580H pgfh7RIwO7vo8yy4JSedFTrQtvfWeCByaQsbsTauvR2db55u9O0z0avEOYpoSaq18YqXrEKEH08K 1XVFYGLTJaVi/1tTmcthe0kHlALAwMNIx6zoTmRc1HOEq10ogBTXQl9tKXUNz9TRDYdHUOQKZ3UK ciKtm71NZG5GOodIvQh6J4Tcf10hZYMa9xT+KjvXn3e6caYZwqzAb9b90eaaEQgjgFroQ4VQQTNk rVl5Nq6vzKKD7ep1X75Dk1RyWvue0eCkL8EuhQVopDd1IOLneGViW+4EuAuYyMORi2BvMpgbIxHT ydraOZK6qt6VD+yJS5xqvrzw1Bx+geH/xpciW2YyX9ZVaVXbebagGQshWCy368IhYs8YsCjZD3+w HYe9kvVSt5eTDq1W59TuAVrLensFzOPWNM6LPKor4KNDtMC/AubEHQ+4/Hc44OIVcyNzta4TsV2j ajmBeYXa0ExML0q/Et20URSUyrZhdVT2CAp7SFRTv9jGkjaUZrwOzUhUVA6VYgqTp/4zEzB8Vtkr H7EDrWog5fVvfsvCCbzEwQp6GpWbhgWdDYYPuXXVaJH5Msga7WL7oP757Ey/h7+WK4T0gx/VwoHj hY4n5ru+2Dyi77NF6Sw1BaV+n5WWQIjcpx182xm44fqTrTMHRryGVx0Wpb/o5AZ88uAUD50vqPNa tGNqAY12tr7Fah5ew6aWVwyCxCTWQetZPbh/369iR5OvrpaLGhmWjLiEf+GwHm/GQze0kkfV7VoW cEW4WsBGxmtMCt25XFfnw/b99fj6fvnD9efddqfnqu/qYl4lhu3O3fo+Slr379YdtM9S81d9llIe dnP+Qvrl2XjqWoDBF5+7vwKeq3xgJBu5jBmDZ8Hxm36DDPAzkAFYFmnH3Wo5/hRXpo2opENsbo2m bevSlHTh9+Q154QRR5GmSdXUNDn/aJ+6h8RGSEJ6jNJESX217uN/nI5Bf2FA66wikGv6G3n+fDn5 lLgJbg/ZNfRU5OtLoEPihFB3dAxfs7/bbAliBY/3t4JoTAkvZsso8TUv3aq/Wer8lJvrKE4G27/u awU4Y4RwEXsTsxpFLtPdGGR5J8NPJAnL6+/WxdHRVxIHRH4Xlr93W++/efO/GN3EZ593aPnfvtn+ T4xyL16iHBfDIiVlEAGhnq5yLFHJBQ8nEZU66wDwfnVrbyeIRWay1yunNI/Csq52x1M3s/nvp91M q7PtBW/eQK0JtBput5O3lYg+0yZ9puHSnnUcriZShwJBUnQcxDKihcVtvK44Px/+Xs3HqCJ1m1ph xcl/nS3mFLNvXzx+0lCGVal2WxA0/boWNGEXjPm2nGNKlA71qrPTlUzA4Tg9ZVoX1qLj3F2RlgIe Wus+opwZAmCsKVJuRQXcWRmi1vEVlukUHJLrVBfv76yoIzPeKUpO5kEL0S3ksfZ0Zx1mFMSC642k pa0LT/Cb5e5pDkbTNBQUoRppfbH8CHIfbYBDtndTIyOg7dgWiyU3uJMUHz/57uWTR1+/fvK4APlr BlwVXXNgAXV3Dnlv7BjX1fhiNkGzAQ1S/vqjj/Fju68GbXc18Arpwgnf9JdDAPZUK8giu4KZVF1E BpTY89n9+8qq9oEbsMg3sSuw60C7G/LhBu1V2pHa3PFoWWM3Mqv4Qo5QKMg285rW1PpLS3PCN1s+ AJk9CpRP7ogskH2HV9Wg5y2W78cHhzpr446B7wjEvVP8crm5LP4LR6mhev6IozeK4/5f9R9wnqCv X70ugGHWfHtJAGY29xTX40mCR4ecmvwDr8bzEHrd2GRKyvAzH2+QSVgfis4/wVFBQc1Z4k40kMEX pIKUx73ir1D1ythU8tOiy/Izt1rmMg1BPiTquC6JfP0KE9U6eSFjdUAr8AK5gYSO9hm/0lXgUosb /Fv5Fy9Cwyu6LMMwZ1I/LN4NiEY8QB3w0G5SlNLywlf8UpcVHavKbkKWFDgJQxpFqeSwvq67TR2N z5bbzUiwmkaOasz06gTyOzqeoD8hXyoDptL0mQLZkl9hUxlBcXSMQ4KYaIYkFSHdMRTURZ8AYp/B TNpu6lYr8qENkrbww0U4p4OGqRaUPJ7niBnO55xzSk027u6DzK3a9nIxv3UpGsgYa6UAjPqSmkSu uYNZxIyZVT0RCcwQRf+1puFAVxlrnZXPJTJMk0Nq9UG7XTuL0v3+x85mSNa45UZSlZuRcMrW2wX9 SyBOJcZXeAPUK3zG9iER+qkX5IdI8LLrSlxY8YPXDOXotqiA9rPJTueWYNMxTzNqFH1yadSaZuea CIPv6yTzRjHZgnhw5W9Fig+zsePHuzumeQRrFGJpKGiIp/pke2DZWY0By3LSk/4T2L/UCRHUO2yg XK4wCPccc5fPLi434RUlBd3unzGXhnW8rgx8vPeZp27D6OvgvpNcb10mUlcR5TdgMMMwS+I5kNny Okire694AQcJkD/892xJt6VwDCw4ASeR/nS9JMQLioMsjj58IHh6TELSN7U8uTqrKJYElpwTLOG3 VT0ZrziPCspjvMqScsk0FKjpcBqCpmiqfnYuU+JIp3JpUCpt9u6Ry0jLTcNkzoGxWUWE1Y4NbjRq BHga92VDHkVmsh1+v6SDkWLQztlt8yBc/hUJWdlsbgsKoWlMvopLNnIu1JyimAi1kVzKzL3NkD7U E2G5GipJDg1dDpk6wyiM6ppGoP75o1zs7+zclcv6+Jf19ooC01ddtlpgbfoFoWQVXxV/8+De3zRq UJzixg1BjXlKkV8Wx918wIBtBe+ULZI+WotuNs2Qx53HOZMK6BwL8mrrEa9pA7m3kW7QANrppuko 3QxC60j2fSG7sv0DXqm2f4B/eFrId8bMzGnGS6Bmy1g8BqjrX9pdDiLQz7ORInYS8zJ+g8yTdgP+ 68dyF4dy926729oTUJ5y8aHllfmjZlON14S3ak6bXEWcBcLWIEcYg7ZHR/wf+uBkdT7oRUY+dmfl N+PfzYCrOjXGKwfIevBqZVo5D5SL+fKMbtFoXXpWsG25u41GY5wpHQilu8XcfXUys9X6JGvQXgF2 kHoHik3EB4OqVTmQ2DMRvUnc947RkFTISZUnBDMNupBXkmtJS4R0pKKalfDaO407bc26PbtYLEE+ bu9Edgo70VYDLbZXEzQ5Cy6YwEugBNqtQLCtN9NqLQbmsv3br18+f/b8V4MC4WGCyj/fEdkEvZ2M kYFlLHUyB+JhMN01+DacdpL2GGUEHMd3ms1VKA5O0V0VlNgcQic4RwX8+ujFL7o/sOniTvHkZoVc nmQxtqZ0CPlzTh1mtqzS2B65s/n1kDlK+qb1/vmb/0Ey2IrM3n8H642/379487/9N599ltjSlzW7 +7TkLlAVeKJNEK++OG7bZABYvEMu12gE6xAP7iw2ncxekQYmm9uVcNRdxg7OAoG9LVezOAIPM4bL eCZXU8rN1t6M63dYvLj/tLj/3bPHxd0pXlnAx71uQ9x/cwPfvXzx6MmrV6PXT15+++z516+fFHHi jks42MmPhMfTh6mZzuf9d9V6Uc2/OO6/WFWL77iPzed00oyESvYK7FIoDeWbkVumTaVtcb96xdHD g75/hB4Tf0/fyKfdlp+nxjlaMiHR7BYP/1Lu+aOC6JhGK6L6Iuy4mcn6ZGpuvf/uzb8XSgUe8f5/ ffO//ztHnESObMB8tZmGOYKwDTRaoQa1OppXH6q5bkSn4rpISMwryPiLdOPXi0hTIkWu0DTOWsh4 QjTmVKQDkwmLU4fAAUo/7Meye5wVNcJwTIEVoSqDcJVFVGxGBGav8OCeE+OYkBmjX8B2LqG2PNsc qRQ2IZLQVasF30BfcBlgzV5SfmwfdITy9Xx58f7Vm//nv2O/RPTnuRqjX011RNdktA6Bb6Lmfgzv /sYFGexaKCOSOxFf/bUy/OoP7YhI12MyFPWB4zrr5psA9wXfBfCfR/x302WeuzNDS0+jjyLb+rEI nRQ6m+gLQZMp8wdN9TUWbbe53A9uGHkZujdiyYEz8ANeKaBnBm4O/yUskvfbq4uS7D/OyO7LaRh3 4l1GX88Wq22A4zedrcWBf8nJ4fvypNS/x2eU+710TXQToAYtOqsxAF8q6Ca54JFrwMvalfCBJ8sL 8REklxTXFEawwHI+7MLUkMZztj0/R/ClxDxsp/gl/f5meeEGL/UnVuXQlyyA4g0q7R5mo7SdcOlN nXefJVgPFWAXz/qWyKO+dH2no11IRY3jM1DK8cgkdpMsoFZxmlyOCdKZVEF0t6YH0o0L2iKgqtLD kwenfY+qf17LS/eOn7iX600A6UL2AzLFLOQTUMJtwstrVyMWs7V5q4IWGUrzieWBG04V1QumdL5a 6Aw6qWaa6fJukMuwyn5nl5Qflr0fNe+aDnz4NY4eJyOIuxG8GvQig7nslCedXGMhNl7QgXBr+mnX +bXRSpq8nCro+rgl3YD7sgvGGzQ61/m145qR979jGvqL+CfwB+DStxG/MLmFydNmecEY/Jq1HCFo xwh2Oq82mEIK7yYK9Xcy3TL2FLLFjchf567iKfpvtcYuR70MbZdDs5macpx3FeVlIKtnmUrhcevS NhbPtuSRfWHIkvLUJdHEA3jvkHUkhqnplx0kv9m0k0lC4b7KApqYOrmueEP7vPNmrfaskon2CU1C UAO3Egw8BOSSbtB9Dd5eolbclksGeoPqdQJHFMJzs63LUG7fWl+5nhGp7oSSKdM4lO4Y5k1Xq1Cb RbOmq3S2WHRuoj2tU4Ctu+Xp+4kJwH1dLW+aa+l0wm92zIH5qt3OfsUuPL9Hj+WtgGV/TEVBdlTd GG4bKBnvoyO5T9tLQygL7Zip3TNiVr79NDWCHDphzSeSGG/CyWzswqudXWhTLnEBKy+izmTCJz9h 0skmBHpCRdoTTzooXhFzIpvuelxb7iSleujPJW8TDpUyNC6I3nmsGyQcrZmbSWXtyfV0wDOC5hI8 UucI+hHn5orZGrO0zs8kq6MOEtS912/+QlT02bI/Ga+A21Tvv39zc+Q09WWdAYzwupqPHXMaLllq Z0tVPl+Rk+uzF60mpZbKa6nkq1ajx7467LNI8Bq0ymcvSv0ughiTKBtaY3RF7+5LD4GFesV2MZuE XlCuUniPVjouIMVDzK7OiJzdoTuoQH7/+unR33S6TDN4TREJYdrxftJVY7zhQZK2rtPTNO2/RCLf Mes8a1Lq06ftI6aMjRYuBBgdsTbFuDiDLnB+v4EEh1JF3YOnp0UePUAjaKLBQIkHA1BGN1OKLnzI v4E3wB/H/Ads+M5PKko+ffyIyd4bn+RBATO9Wd6neR0XFzPQm2E3iEEKaR7U5Ml6ttos17vRwRHg pdqcT+EXbxbJ/bpYXpPreK/QESRY4RQIikq51lH4RnskPKA+y9E1kfwjEXDUU7SBrat+gXfTGBfI 3YDFy90FVFOoLwilwx9lt9B7BWwyYux0Q3FDNxRV/uqYvQR1FEM3oECkc/3yrjXuE5CZHkRwuLtC /s7imD+tfFhMtzwi5PeyQ4dt2p/RjeF5ohTzKFxN8itO2wgLRmNc1n1oqwyGHnN8WvccyOlyPoU3 FgnwtvaUgrR+onWeRgaT60x95KwX5EqmB/uynMEQzlGYLO3QEkPli1eNRkoLpYlfT6OtQ4yXAJ96 mZsZQt/E+xiC6pcxFJvr2aT6RTvNfOPpC4jFWarsokUUJKtERqFp9WGxnc/5sISHL0YvH794/s0/ dOMJgTU9LnE7P0heMb2cT7tNYO56NPDq5hJe1I3LHQzxtFc8Xi42L6vx9ClwqGdodyt3JnHRntvp YICNZanY8CmV/hH7bzsSJApfJKH1yAe3C47+wGUlZ81iu+qJhsR+RsHuLOm/Yh/IsqRgQoS0G+fB LW5+IyQUmLKrYN7jYNmDp/gjp1dq6WYx5pR9hbaLpcvfFh35uAh8zT4uOHRJ4y+X69kFmdxpzv3m zk47sexVM+/u7uRGmRXjCh0pd5ODEF6y2MACg0cviXB+THll/IIe5U8MPOHk/GbbD54eDxi7A3/K ZZ87WBrSClA4LJ3dhkzJYbuDwbLQ4HyGjj3okHneCh3VZ7V/P1XZleQTIBvXqU4hQTn+kOd3RT37 HWwPuZqQVQSpwH3JUK0dGVHHSoTkKXd9WaE8gRdvBqukZoYvHqljvPKhO+vN7MyckHa0M3YpIJem okTllVvEFzKN7D1ovtdPN0gCTiLhWa2mYV6CgHyI1Z87Iold/+kfOI04xOEQ9Hnf3115zmS92TcU LZxGLlD+0YQS51UcKaVE1QyMYEbj3aHO8P4rEm3cYieAU9xhPPendCxSp5nuDcl7CkcQGdgr51MT BhlFRfOQd9bX/bhxSi+fUDTx9GkkzXXT6Rdp336wz3Q8QmjL8ZWpNsnPTQXwIpd/ha/dKIauhojT SkPQkXCdjVIF75p0KniFE3v2T30Jqg5ajSxccZWYODC2MdT1LumBWkPzAXY3OxHCZOl9OFC2NfNo 8XeEUSTKtNr6XYmMVUNY+OEX70IBVjXvu5UVAFimDVH7UrogwEBCLNqFGphweLwDg8XdboCC1uuu JI+5Rk0snNkt+5pDIbI2URAtH6vbDUh198lAJX+EECUM95lB+gz9RNSpm3VYV5ziJnAE96NsSOrk KgahsB/SKCawybQXqHyIywbztutEZ4t2MxZf4zmt84pEuewTalSZ7PtgBVpuLoZs/ZAMJ/jIUBRX lZE/6YW6vEGl99mUICZ8QcCnCZvKjKF3CgtKdT+YmYy0R7XHwl6qQqEvOwbcj6e33KE4wQZXFHN1 6A+efDQPortSaZa1QY4aRnjuZnrbdHzYvkttTsGSv1lomibrhFxKSkSIL6ZriaqN54B0VnYH/f7Z MGleXmWb5yFoiUzzwccpBTni8XrztqZbzCyFMBVs1whXUNSL8aq+xHAZJgvCx74CWfl3lZN9I8KA 5oSmOXXVeMpPyu5hS5nrP/XeO1sJm3v6uJRfRjqlsA0uOcbQCwpiUS4gIcrw5OnjhzT5Tx8ftyy/ QHdREDoXKKGNi+fff/ONWJ/wkwdFKVEj6IBi+jme1my8lK01W3TZUjVe3KL4i5zrQe9h7zjWLkxS MIyFJiMCxt+QVIiEcVa5HZnGxESnPUyUGONgvuTX1eymmsZBu7PFKLba8Z9qzkvEBPE0CjBcqDfQ ZntAJBY+hx7Ac/hv9Jz6A2/o3+gddAvewH+j59rJ9sD1NyoB/YaX8F///KeMRas81MiEp6U9oenj aLdAP13GEpmekw48NGhJzDiiImjH9UXMVvFF0Lrri9BUpYXosSmmU5OW1Ded4KIUujo4EFqTh+rM zBhimZqBdwSGOyrTH1lkzawFLhHrmHcPGuyiLuA0c0wRHxREq4zRx1eyjGSUHZijtMB+Yh76iZF/ dyaq8NO2b4qSnSh05LAZt5t+bMn9lKkFykvuR1S4I4LbNW+7e2Jz5iJfOGgpVObZfWu7Y/2b1453 nl+74z/h2tEG1xnD0INPXrvQFq7JE0JdLJLTkEfl8HvhuTOxN3+93G6yX+O67/8aB577GucgMe+j A95V1SDHwhs5GQn5EfUAZ8JDyaTIiCaNDN7Za3t0VRWfgUYwKmPZhS1N9Wa58t1JBCJPzTk6bZjk 0Phv9lWTkBpvw0icaliNsBlDjE3CqG0Gi+9tJkNwEdNA0kurwaXIXStFR7kXE4OFsXTkZNBmiddJ unSPi0JbqCK5xd2nB5FI1M1pEKrcgLQojZXx0u68/KBKdjaNUlc3pz00NW2We1fTqkXFc36iuoWB Fk5b6RV2zs+TiwNRoGPVpgozheLwxDCU8zyBdzm1PBPbSVpMRfldxb5ooeH6Go9qe5jrs4vCTBWT T1dLvGr+z0J3IBUfkcp12w4UFdIQBG0bzweCTiJ8OawHpzLSSPrFsw3BLli7Md6V12mr/0xf+JgU gVEV7ARvClluJ5c2VA2NksVjr90UJUbEWY1N4srGm+4nqTNec7GKzQ69ZT6VveeGmJaQLeICAdMS MBe+xGzRykhHNp6AJc0YodbvYXH0iZHd1cywTyBrEMR4GLHwSnKX7dwe2YtryffQWSJaGfUA/vtp 2tUOyUXnJarJraU57ZLPkpnzC2xOr+SzRC1yq16Y0wp/Z+6u/xVJFI6kEikid6ynUypbZ4+MkTWD ZS6GHfkkwsaO3gS68Xya6AKJKJK1ijX1ZsdCD+3O/xg5408lr/5RJRomguTIb9yO4T5sAgL1kk7m fA21iGbyaRRtkJJ2NUxyzq6GSQHJn/Hefsrnd7Lv3SnvnABgprdnfNyjHXBaUfg43SozhYEwwFGc CHuheDGePGDZMP7xrCr4UhgWDxgJEc1qWdczjN3AWwC6dVL7YEsuLM7H66IWzD1yKZmsq2rhgHhc 1RqghfF62Inl9uKSVV4NZUcRYLtZXtElPYVHwhTWaJ+Eis4ovIDEGPIthkOd9wr8i0i8kha0mt+m Jz1JepKiMM7tRyLNsxdyWYAl6YKIZBmau+tLuoDn6wmC9efxtzVHEMPgUnTAeBo8q+1DEDdgABQQ S89Mcgy6YI+zPCYXGWuM1COIKhRxJCdBXW2nS2YQcOKiU4Le17d9jqkZHsW3DXkkffQUZ/ZQj51u BNjg/WaN25dczfOD1o77fxRd6r5mHPTB8Wl9nefff9PJhqoHpe7D3/fxQaf1/jdv/oMJwcU0E+9/ +2Z7j6NvJY6uuKomQCqz+koiSNfvCFYXz76KMMQ8eoHe99VRRhAne38LX1frNDmjUh69QXpGsgZO OBYPemq2Wt93ki7DSh6WuA2/7Qyo7V/hmMYg8pbdn34/lF6anfG8KfGIRzg/etdJMo1oMK/Ajb6r bq+X66kJ4u3YbCVP3nz38smrV89ePG/Hgb0EzwabXUA0GMuDEheaW9h6eyY+VB59tR97QLa/DnFm a557XNUK2TVwMIwXNkXiCui6mdgd55xFcAnX9BF1Cv19L8boHsBsigvGFQlQ1wyzKtDtFtEOHrpP GFRuUBy9Kzq0bJKVWlPWxFUt0XuowzNSkUoXZqysxcWP6ofpQ7gN2mtxRejghB0Pmu1gu/yAG8rM 6nQ64wTUsFCyzjw1OiHImKV97IvvWUMXeB0367HMHoPrwWR16OlIGhnJmDvoxtdL5xhGW80RRdm0 yORDwJ6yhLDSF3iuMQOFIfBZddVva+7Q3dTfPrpq76N+2tpAVob88R7YY0J//fLXuAX2Eb/L18lU j9UGBJ/MQeWo6aogJvHQib3413EnN8rsII+YPdXt3m6gXkkHdLm8FoYGmreYPTS1POPdVeuj1XpJ /megL9TdsCfCjKArQA5l2zeuP1l7Dwgd3nbU26UTg0Fe0akLJDNb7EklJA0M4ujs6dIABhgnjEZE +3zcqEfoCkYW6b+cdm1dUaI8whajMNOyPWhjgH2Eqa94QUE2pbv1QIEqesUZKBAZZH34VHD6rYOQ fdPNTIONqE9k1AetzJRjaidGDBFXigakzhEZgm4xfr2mwPZag45lfmTrI9En6AzyjiGPiTXkSule tDkkba1+f0gN2RQSd/TUJiBCTBmGpjTYJ23B1rsYbzT53Z0CjnMoMx3fYl6of9oicIorPmbvpLMK dgYnriPsOehCmxL/qox4B7+FHXNG4dIMe8oVzOeb5QU7kdbLpUuOaQYVJGg+srQWzicFESHWlHmM kf0tUU5gkbaLzWweBNaHTZ0cERwf1DVoByYw823gTBP2wNY0OHooxlwYrRwLLmskMNaKQVn9s3MC qJ4j3eBOI/oJjDiN6ywvSvm6Z0tGO9M3rBH48tEuqzUrjjoFqakrnITc1XGGHKN4OyqB1O1H4T5q gFA8YCwR4CQQ9baKjNuyNkkVSh2+lYSn2oBrX4x3/tA/MBo4vuEkgq7hQPT+FnrhvIhBgv5Os2WP C4ruhDmhAk7Sx7OE5TqiG9aFFR9kOf/AVmwkWQqqIpBf/Mqkfevvsh2rRGQB0m+xCnaP2ETHBBTv iZkESFg/7jNH3BkxSB/1aBKeLc6XBNeef/0Yc2WiipADCue+4clbQuuxP5zvuvyKnEexn3ucR0n4 nC3CCt0a/ppH/FHL6GaJSv+KZKOxS1ZOch7uhRX5QHlVAd5hXBw7RdUqEMpi770ToNKJlZ/rGPLb XXMD3Yimh86NYG6okpSR8JcEJwr/NiYczTmiM9fmwzfLL/hs9LdFr/UahzUugsm/1R0gMwsa61jl fK+SSaUO5lJ6gJpWqe30ih9/6tltq13pu13Ttb09gE2nfebuSEmr3UEJ11XkM7hfsG1ett/irZYb NY6LZn15XrjWZ4vJfDsVVDQhn+U5OfOyWicU+QKleFXQTDHY0gabsppxHEgxoJ0wePsI/3mL23gs qdz4+VMReN9y7Vb/6rlmlotAedqlOkFnWnyXd1vwwIzqxJU45cipS7jWgfQdbhjcntXUbQfmcyLH QIfDCcM/1M2TmTCczdgbUY5ppmz6OUnAqrtGD3wlHoN8lAA+GI7IYxWR+Zk8jViiHQfxRGpAPN1z wxkTIPW4FgXW6cOoA8sQl+t0YHbz22FQLVqJHU7SsV19ijaodsT5rm8u12hylWWWRb5Sx9Ig+aWQ fke/7TRwMB2Ey36hoH975tcMQ1n8MDoUSvuRC/ppw/8TeFfDFWxWTorIxoSc47ryIjt2uibEUZCm 35E9k4Fk8K+H/S8STwPp1olp5bTl7jebpG6SrPk+Ld/Tk59bBC09K0muS9rDsqcJVzUFmLHKl4cl iUm3VqIZ47k52Vh0Ja9tjmLwJyuUOZuk90J4OkaGe0vTr4wtkE3eSnRaXRwh08arOSBMZlTF27em 7bdvCwwcm1cbgkbkfdwvnClt4CP+/Cj9o0BproEk3AQ45AaaN6XkMhfqwyk+8MhAhjpG/D6uqBOM DgUzHRh9IkfL27dBE2+1TAKFsCc+x6CJoQo2ah+CdPmtP82LK1ROn794zVfhfM9DXhX1BA1aO0Ns eeGzTnUjYD+Td2UWNDNYdbv/acT84WEooDJ6I1zGppwGJKgDUh0G7qlB7WigyYryavGRGTjI7uPM APvNPjdQxBVHyD4pWlJReBACLxF3venGpKKcaMeE5alGUtGPC0UprKYiFxK4GpmduoJXiO/rDcUl 4X/C2wslIw4Ha49GGEI0Ggmz/MGj3qn7lZbDJqAc/P5yPr46m46/gm8QDMz9aXmQIzHPg74GEpOH GXMiA2bgI2ecL35L0bgrmGi55NQACU4a2bjX/b3FLayZpt49H7yFOQBp9QPnlkBtGC3SLNA40eFL IE8JPn43W30lYl8wJsf22PC+PN+gWEt9mgIdvWOEbcsJ2Rg8DHj486+/fRLukzt6NAatBZUcZyqh 1X84JJUTwUApQS2O9HfQnbCqlg+PW3DukrNKZxinwq1QnYqcdjx/R31pfQLX5jVtmE++1aXcQLDU 5HZGUdRxLpWHfYyx0SxCFAooh5K62tWkF5BBHw4zkdgxYHCLgpaYo3wXx06qd6qLlgWVC/oiQl2t 0dsq21Fr9RIe+8ouKG+jTirfowuQPMtBQudjvKI5X24XU1YbxkL7GpF43DxKJ0seMNCWcV3/iIGO nW3DRfgvw1xs2gkyGutNksZrulpdyB9dYEwLhS7DjA3+TKBvAqLQWfiizzSjdME6MV2P0RRSr13u zTFmFH5HPg4gP21ZaKZvjVP/rA8Cy2zj8DcY0aCBJGniLVCEryf4olNrUutiu5oSK3Cf+skQ0ACa SgthhD0UVfj5clMNODEOA4afoe1ZwY/DXiq/Ey+JJVtakBhYiY3JBU22RLIEBVrh+Ma13o1myIdG IBslQzrL7Fd1v3WIOadH8bsSSMRxsxZxwp38CuZqcVzpBX4BL+gf6EnstMhVopX7Wov8+BP37O9W 6yWQzObW9Q/5GSE7510zfEfu0NmFqZ2h1ukRw0QU5XH/5/2HcLhOObkCHp1BpDflQUjw2X10l6hr /clydWsGImOfEiRth/IaJBJd+8uQJu7i/33lxYJiGvSEz3vrhNMYDk4oT0Svnr3C1wxeL4s90DOj 4tMZ09nhRSkiQYSh3LRlr1G4AUrilu9rw1D8iDyy2ZAk39tkrlaSoi/0RoEriLCRtuRCji9iyQw+ xwRKNFqU2vmKtoxlpqZskNH/QmmqMxqdIVMfjTq5rJBGiE/L568M0k/48CcPlIZvSP6UwPS+L95Y NjXVzHtFhHKQ+19UP6VlYuSe08bv8mFckeS88jHKrY+vJNOtfJ+aq7kkp1Mbg0Bz75hAHIUQrxh/ nkXDzDajB225O3myb96xv55ldY1fd1vNdTYMkPv2KfPPX5L+k+9mY2Yr7IS/qLxW3shfxZzx3XWf j9kyrlW4vj8iPi+C2bEsHdghHofCD/vmWOJuy7H07robWFhwsbxi8614sImYpIoAqBgNphanPvQP OyO1H2ZD3hk4A7lzYdt/bMJXuVMeN3uvqK5Wm1vmBqBJO0DFxjPX1hrLkgUeZ9jK+jaoeEP+NA11 Rwd2pP/DI7pjgv1c2kkRwuie7j9ugwOTJFs4K2mB4V9Zaj06W5+29cxRqzugcQ2RdvAoNJK2kxj5 qsQddDLU1Elcp0W5ZjA13W5m8T6PVs/usWhHWcokj9mc0/ntrJpPY12hLirQIjgDm6B0jdXT84hk 3WAoKFLZjnsTiQwvZDdhk/HWdaNvvX/z5n+M8k1BS++qKXKa9//wZv4Xn33W0n48pTd426Mp5lEx uB6T0oZOYWMvRlNGGK5Kswk5zfoCLZKE8qX0JnfBEmbBMR7kiO+RVvD+h2sAbXJ2AbuT1726mQke +rbekXImRTmGua4vQVfRDBaYmEPx/kezJUFAkn+yN/Kda4YRBEpy73pF+9rnK2dwQA9FNkgACc8N LKOChEm2d9CEn8639eVH4fSeZ+Hv+M051hak/TjAaJsBVtJC1k7melt61u9JhKt78ubZ61evv379 /avRkzePnnz3+tmL5zCJX7Qa4XSBgprUHujDbFKNCKJ3+CATgj65nM2no+ViRMZi+cY9REqJ1ScV lbOSiPDakwAbQrdf7gPHnn+MIDZgUCxu7j8q9vN5DImZztYCsci/AsDw/tW7Kb6K1b2XT17/5utv /Hd9zspbdtYUHtKJir96/fjF968zxQVxOS3+5OXLfHGKpva2sdVMcPKQQYSBzfBqgGY+4B9yJ2m5 R9Ag1wL/Df2c5Gta9n0fJ45NejkA35ae2HoRZUVEFV4P4KeyrQ6uwN4KUmZcjBFE/7pFJe7KaDQa G3sSevCxA6MvZSoh5xL4BEGu0Wp2RZVe0hHYyke26Y+UEz7sWYLotvKxaPoj/f64Zykk0M6B7M5V EmXyZLTe9vWZudvxXATKPth93+LmPJW/MagDXpuF7e4HxMBLx2DtmmEL82yozErzMHAdNyxqec8I Tffu7VMFcNaE6cspBifL1QozguC7bnfnKJDiPmIQWLzModJkAmRvJgRvSfyIcsq6gBMSQzLgHza9 qGQvILsInlEuqwLIrumnAVHQjOUOm90wc0z0CTqY6Vnula5A/M6BCD/MPDsOnvGs+g5bSMXxbONy CCMbwQfVeghf4a8wrSOlc4R9iH4bJATBXHD5UtlcAGTNYKSudApoU/d/++zpq2e/ev71N08el7Zs LiDayV7Mzn+LaTHh4/A70C4fHv/NAVg1SXV+fsIad8Ex2Do8q2CJkQPV/Vz95+LBzV+fxx45pgoX kkufD1rNm9gyr876rHMAZ+EKRgKPyX/lMOyylOsr2EGi6BUp/AGTQyt/GIWSYjqJ7uvgfAyDoPkw iPsbhiYzw0/KCOAGOoxHYopIlpwArPQL0ZMV6EnXVFXoSYPdAGPDVdwQNa8CCl/l59wDtATXFeCd jabVPFXztGoUKyxrxbOYLhsU0hxFE3QTbpZMwpkJc6LtRbX9iCmL7hCCjeP/iAKu3TaiH+FLRzX8 I4fgkIOZsOJD6/1/dfoonR+j1e3xZj2eVHid8P7kzf/d+uyzO8VkucKLQ7rS4YC5o+P+X/e/6NSF K9wH9e9O8ejvv37+qyevBvDzqKiXVxWCwxKaNcObYIjx+lb0b7kzFzxexfZs3XHZcCgPMqmLbHkf OYDsES5yWWEJ8Zb27p9PqSzZLDygNuXko2hL32Omstfh1eC6ir7ENogxsVN2jTgjoBOzOeSM72tQ MgOy2YxcYfeEvurz5ZlRvjn6UFyUuQ4efo/tFNWCIZsF3JxcQfQyDoZHrp7YT6rBRe65SxGu7G+L y+U1yF3rHk4gff3qForecAyqGyPfs7paavwEKIvDlEmeLTFgnAOzMJFdNe0W01kNS3oLu2JD6bGC BLWUJl7c6inwm5ptSag8XhNOyAlxahbhCrbn+AI9ZqYIxk7YBOQ04ddCv6LZm1+Pb/k2HifazKG6 vJIVqhXmJr5TfO19xDQCnTFJPiAS/xWwDajifDuXdRLXBZzDM9lKd4iyNzNyjF1WlDlgvZlNtvPx es4ebS4Y1c+wEI7U8NVXX4lfDRd92JMfx/h2isDFBEjPxeWjR8DU1uKsvnQKiQuRr+vtGRJg6ao0 q93VICIaMTp8XgOh8qW1n2DGHa3fhXkIMOpojo7RwnpLczMje/CX47ry0c72rioty4m21eEWUxgF H1Apl7UG3XJwTPS0i49DsG2FfxoJi6DTGxnFiMLXAhYhBtmaGhhyQ331I2q1gqsnmEs6CbQGO5UH t15nWr+D4EcEPCy7gnfE3xYUM1ndjMnP2m8dmXz6hFwzeBkUQ0CsJYHEc1Vf9ApnMGOQ8MWyh9AN FCl7xhAEXfic2ZMzeogjnFvJKM4/g0YvjaC5RX/CkrW/ZBr8yltUqcMua2rBAE3tuxi1SY5yd6c/ LDpo5477HSYwlr43K1RxO0Vxt+aa5VNyY13FmS1QGKfp2a2qTeCA2FAMPnrfSYVrrrEDzXRPBlzN aX8u7SR13MH7jCOuBDjchmP6ixL9tIChjc9Ahic/zLOqeIfLQcbouXXJbuxSWU76QLwMEsB+VRTB XXS6HB5Hthr3Ra5zJD8Bg6jwymU84VCK8WQCtMdd4QE+xLvq1bI2Un/jEtyt/5GXQEHpTQ98F5jh DpF8W62knkO2WGAvpa9ZfDiEOTj54aVCzmsAkTtVifCOjmD58AhmP/Jz9h1MpRO14lPtKAVhYgOR iDgYy9mwnUSgHG+hUDlQdhDsIE7m+MMCb4So+5k96csNCi0bjBU5aDxTMlFRDwcpc5FvNFefGUkz 88gA1fONZzgVuysJuJAmNP5yuyCJhDxA7tZy2fMV0hodG1y7Z/Lvf3jzHw0eiIrz70/f/M/w+E5r NNLEIQjG0kEx97jTev+PEYrIbPF+9Ob/nTCKCHpGF+QmifuTBaAlux8ScAhrHggnPUN1gKOPeoWk uy3my+UqABNZV5k7FW66V0gf/FUL2SN62H6UvdBHVdfq9v7tliZK4ihQjJWf385uZovdOSW/r6v1 Y8wJKHXhb/osqaZF5XWyYJgL9D3gr6RTsEOqEWYjRugYkccn203GuF76pcKDYTTqYsp7SnwO2tod Up2QEAUQAD0gl1dXyPiIqtGkMXrxazJO0O/XT169fvX062ffPHkMDx/yw2fPX4Pi/P13r+nhsXmI dpmXL1+8pEsUevz9q69/9USf/bzVIsJaM8ZPH52vMBtK+x9Pxke/+/rov45Of7i+95/a3UOAWCLM A+AyFYi7NUL7EPIBR+dg0AQMH10WmTN/WIISjIPn4lCtgWPATTBs4/lusCdOOv17mEXz0W9e4T+j 6Xg9qfHXj/Dj8if8da9fXVx0JBXenahnvADUA2nqjqKjc7f4Op30PAGJqihsk4lR9gbDjNkKuLMK 4WA73L537z5N3b3+5mZjv3EXv77E6hZnC/6+R9mb8W8Wku50DwO8QTjOLXvhGwwg3NUszDch4nSO bnDujo6QKEk47+TRMtzA8kjlDBriKmknBRhkgw3LJEajyIjgRKQQiIYF5xIrZjQJ7W6vqdNHV+Mb LGoBeRbbq7TZGNyE1guYr4c5oXrM+B7s6vr4HFG7uM/QHnUXEztg1xlItN8800ccjNTZA0cStIp3 5gLbMKPDB9kZp066Hq9xvRFLDNMe72u/fTSx+C1IyTofUK3OB2wWFWabuoR2Qg9/RkRG3PMtfvhW ASBoyzi7Ce2kysQu0+Ezm7AOb2siHL+2BXfJkb3wZCR7f2YEIw8mXqNlQcZhapcHR/LkAHgYNtHx Zwxt00OYys5GkuBUgsAT0GzQidUt8rTDWoOZw2kjN2/Qqwl8w5p8akWBAnn03fiiipbdrvoRCOFM +9ouS6eWGDghddQH/o5TT0vOHz/XRXmFueOOKCCxmna1/TuM04fYZBccZTwjlo9Tvjg/gok6Alas CCnA54pH8Iu2e01hRpuZ2AXv0J1lXWxXF2tGsbMuHtlFXpzzgdxRavaPzAanO3+veOocUKHcojt6 F87cqcUl5wM52vqkuWgO3ku50+pse8GjN821aYeLnFVQmQvl5cEGaaZxdIJFi7AbvD6Ih9405GDk ZxRw6hAZ/TnOIgsuqiAa0pB3Qr7prhmSQ1v5DKodPqOQ3EcaxT50v3qkZQ+fEgbgK56QofwbaABU l1Q9lH+7h0SNinAWBX8WaDPmbIWI/HSbDyd1B1wCC+Kgeug8ITmtxZ4549VIFlb6gYzD3eiDEP3q XcWBoFYMRBkcCP9KdTKljaFOig7Kvg1N9CJI8kgW/KJyd16BgpNoO7sBpOIaH+a+tUAp0j9NOcyr WttVzVV7HKLYwKS5GUy+FUVAFvd7NMtmQiLVrfW27qNKPaMr55OHp/3E9ZewVmo2Zyeu8aFrg0JZ kYTt9NcSTVrdGCy1aZm8iB6P6NfV7dlyvJ4+w7NgvY0v1T/uQj2zNO+k/tFMG9Ab9qH8e+gYjErS 2uUH8EldXiw3IJ57g4V2shduwI/qq2pKsVVNPQxgOowp+BXdCz8JnXGaqQE1btSTB8VkvEXXmlcr OESX0AVf0c9+WLT3YjDxEEgvqFk8zuVkaRqoUR5b2ativxpkygE++OSGRTM4+87W1fidiXOa3E7m Jr+7Nkv7mu9L4b+hu5bf0F/Bjh4cyCnEvaFpoMo7ejs8BIbppDR37GET+8sDx6n4QuCAwLOB26g3 26i+BIljeb0og+Mq7cyBYH/yffYcoeJy6NlPPX/0DvYiAySHzGYJhydjkrD0NfvdmB3IgjlW7ZJR HTnlIZpHAnj1zHp6kTHP9zOfiJUJN0/6TR6ErwzHG825BDZq+TKsJdOcx1nUKsJT3ugTiZWRsQL1 8h0Ev0V1QzhK5Sxw4iMhiq5UPaaJmkZYuD82pd9VFdm/7MlFuA3XGtbJt4jkIx6gQdzR2qiOOqxh M5NI0/M1oRDUxbw63+w3gsqsMLTZ7POHp/Gp9WwxrW4yB7BUQF4jHgyn5/BwKtCqEXejKoM2zMzp dLIfoZncAHCt30xXIyV6AsYZMjiM1jPUHxGCuvA5unzF5AI5uAEt5U7qalqmXwZcgYnFECMrXY5S UfmK4CRZq9hcGpsi9ZI/xCe1B5BEHzlVXegdWqmc+jxyqiG+Gq6yNQV/wmLJ7R2s83w7rWBD+Nag MVU7pWZ3X+CLG48YUzOQ5AavTE5CS+oNXwHdEGm4Kk6DOSQFFbETTXXO2fzV3wMBfLde3tzudYw5 rzOz7f2za4Hq5h/hywRI5mBHej5BXKiVWTYFzpUSpemFp82b6EMid1p0DPReS+yqVBH7V0m47AkW QnTCm5iV3Yhix4qRhvuWZgjk6HKRpsu1/gDFEcGDimQehFJFIQR6YWAAVXSNtW1szCVsfg6y468V aMra85sXeRGm0eaoF86ZvtC8794DnN3L+ZX81Qio8iMVIng72tY/7YLSQ5jCA+6abBMIpnSaUQ4y TNa5mglkV1MMZZipPm6Yv3awdty+GVOdjim8mExmiarQG/zIYW7H9KS5AybjBd43TlFvxgvnWws8 SZaB9gGBV3VVLQQFJ+hmmjzDT2T+mh1r0riv3Nwl7oviflstgm7Oq0VjvB3GW8u2ldF0zbfQUN30 IXJ8jgM+PLbP7izGSMM9crfmsD63a3qFdz/ET0Iei1In2ZG4AFbjzDwkQaIRiKQPhvLwxsXNuhIt w3+g3i1VzY5P5H0Os9yjasQNTtCsqbt1PwKiygSG8jppGBDxUPlDBc8oGujOAOSr7WL2fivgihhs KM5b9QSYlNq3hWRSpmJDSm215iMP7kg8pYEpCT9K6riV2aQjyeB2NZ1WHtyvb48vU6XankhkJUqY 1eqeGHl/OiuV/vKVy5OgdjL3kzrMx7j6EGk76EEks6HenCWi7pxVUfR4eEa7A4VaRug/etPRmPNM 1G19X1l51B5a3mll4wAs3R7D8BwyW00JhkD76CaSEFxTmMWteGXomR/73WZgMEOESj5zCdibffkY xAR9/M5nhCB4PruhPC/VOe9EwU30MEek9GWgYY81KYt+z8FrvlnfR9xg2qMUHWSGwkku+FWWrQb9 eUZWdSyIR/7NrcMqp+gmIW3CnGqn+RQtBaIsiuWollB24tsF7JHvtOnVHelWm5cpVIrlAvC57AH3 sppipiL1p1AfSEJHuyXXS8O+DEDet8vplnJwRRJWm1+I+EygqplC9FzKqGtippi+kpIKxZopqa+0 5CzbN3ysrbIelrQIj4MDGAXSLRDlFfsnZiXhybw2O9cUsacxFvrZMC8wRm43t6BCgCQ9Xs3worRs H/cf4HWhpLAhxnqXFHAvqSYJOZASvOw6Wt2q4nQ1fleR2tnv97vGMZxHmavGnG50OGmeg0Q0gCF+ xEENQ+Bg+zKEYnDuQzvTMIezzdA4wiODcKP1QopM6NAXt+doG7MrwqaigG+6mo4j8clnnvx1xW9a L5NC1T2Iasctsw6AVbgPziGMjAi1umokJNTWN7m0p+a7rJC8q15mJ0mtqRE3qAQ93O7S4vvHJ4Pj 01aUFNLaLYCOZUJp7MNgEYbyb+8QpJ2CaG82HToJbjY98EPf3aH/6cB7OfMOnyyI50qnD9F5w2HA bedOg3ExGBzVFR5MeAaLW/q0wgsANHFt6lhSxKMVAbJDwtmtVHH7H4Omab9DZdmhThEvmKbRVaJB u60s5XZgY4mgJG18XrQHA8xs4cRGyxcux/VlI1/Al6VZY5svFEqs8hnRPAjheE0G7J2lRphXF0++ iWYfJVj1NQvWatPs2osGfY37YFTdjHBw+szvZXapSTac/zy3keWjRg3NZjJeV6RRlvLRyYPTnlZw 8tD8Pj7dgR2rndkNihCV3UWctaBNMfJjeq/p+w8Cc3WTMUDuvHTz0xpefrZySEbpjMvn3R2t1tkx U0agfOZnpSSPfd6cjtM5NqMYGGlJ6CNCnhjYcBShO6YbCpbk18vlRsDwA0UzYBvUkQjSgaUcrN49 4zSKbLVuojmqSn3B0xQlUi0deZFtib9EsMJ1nclXRK8DjBwxXcjc8x/RRE5vYTkEQZMBcyQlQgBM KRqn+/LtWy719m0hetdYWTJqdgZE9Z7Hsbbt+n1tPWwZnU48fLM4rWGiEO5EL9gGhPpGXUkA8Glc wwimWWbFnNQpaJu2syvlSGqOEgponhmGq2538xrkCbfaVzss/xncIYXrG/EdFr42yYrSjHtdernm G96Zp2JdcIoJQ182DSnjekR8G3NKwHCfmMBml8sEDcENDBqLN26UnaTxjC7580SSzSjTK8qgtMkv 023MPILRqAFDCrMYZBiTi7ngdBTEmSLNXgCYotwQdd/OY6Dcp/l1crzH5o+gBcgmj0grVwslcZys USHhNGEF4QyRn1eDAHJyw3Yud3kT9/M0IG97x9EgGx16M2K5Ivk6gIii++Z8tkhOFwYCj25hzyqH GIzXq4HdSyudGi5JuYEl6SWySfIb3FUJumJ+MBnHhY7gHKP5oeDXQjIhqvOlmDdQfOvmWWxgABlR UXJw6AdzcT5bMNpKN1wDIk7V8+Z1hsEQuwCSsMbNovQpZZbo+m8BJzkYFsdrIljFQCoqIdkw7Pkr iT6y562+VNAFqxXyq7jrYZXyKz5u9Vjlt0bEXa23i8pFezixiL2iGgVjUtlFYAKuFn6GmuvtvIrt yue6y/36icVNvEtae/2Tzq/6T/mTb0B53K7iwM9gW3MFHErJsWDYa5sj8uwczlk6RoOsTHolEjpE nG/nc5qnGDwFhwoq+OKivUNDZj0qmuys85npFcUhkHtD8J1Dyibg89kmuRjDLlGmCQQVb2dcqbhA EfX6TvHmzRuNvtb5EwQaDGMh4EZNKk4w/Eu9jSi7GlAF/flFK+lM1vSQn+fNme8/9GW92TUALnAA qko05FYDtchoCeeUENeQMPaaDzBGmC7z62FmQP7t/oqImOi/PUcIQ/3h7ov93sPwxWgv6mWVu1Yq n/sLYWRz/r7JpydQ255cOLnUQ96dyBmrKEfylrIhrMlDHM+BLcKMjc2llrP/Bp1J828HZpGFBMkk rvg9C6YgBkgxCkW5WLTDjWqWAXjww+XUhuKKripXN3GWpfMtsnLmjykWoJ8vN8ZgLpL0GBPdjcPr W7uEjSyYxyDJDXEefEfk0wQAO89FiUbtiiQi1YTQTwwDbQoThUJ9Qc/u5oFz45MiOiNkB3cjo8uO ZdS8AOTFD2xSZBK6QJkQngdixFA8m/qMOSoOJyh0QbCmns7I3ZB1egXnLRn4a+a+q9DakA89StMc PXJ1Fy2D5/d+MdyzMC2xLeqRVCZb9q4aZv1qFFfBfGs+Tjlo0MgibEX8lqixKHK0m/OL7jfUxXyu 7HrfJs/F3K/97k0ffeXtblVD1yyZMjgYb25uWOLVhDQjJjO8f1nd/iLG4ecP+6i+B4Y/Asrf7Wex rua+Avhjs5Qr3qYFXOdA/qQf8K6VeUyqrmD/lMsa5LFVr2jft8r7FrZWaaZfxGkXml1a5wKd5EzM QtaxbL/BeC4fmM9lMuwBi9augMQYuw2GQwmH7reTqZVq5dfuOXB2vDl3WkgSA4nNxDQ7gih/dh7F fNdODgFyanFhvEuMD+kx1jabFBIW+cHd4dDtEab+YKsFgVDE6TtaYvgA+YAhL88whdh8M0NVK1dj lCbS+J96L9Y/nIMJExeHR/0eVDVi72xQAiWcniyagckwLKFIgpfoUUOuXJKIJWTO8nCQBSULWnRg 2pkqw9OdvMgFgrpB+1fmxVOnMk16raQXU3Fduy+D9KuPuQ4yd3oCbebGEXKhO0BgIA3I9iKH7/db IKCiplSOlio9PAqe1ZFLqCY3AbVeXPnL9shUTR+1MYviAcCCjunQVyfuJvLB6WkGxrPBzTCoKNBd lcX73pWmiW4GDybuRepoG016qSThvsKrGxS73IPj0yT8yq42pquLF976zek759/2LdqdEgGdJE+U aKcu5zmJVeyiKIHPY/+C84ZaFqcBfSnjFBZo/MmTaLBIAPS458XMf+aDNQMZbzS6Ij8TBg4Rw3rd kfQ8q9svGplb4iNt+t7PltXzKGSJu3U+4ZcRpxuGNia7ScJ4HDXuGYYMIjVXgj7vsGWBQZEWG3NP E2wVgoQSlTtffjVDROjb67E44lCn6E8aPhnI04B1e7ss+BkOlsL61mcgNqIKNA4rEdbihs7rY+cd Zfy59t9TW3UyjMLR2M4s6OW+wAkoEkZNBN90kzY1lANETGa8ssb8R9gBftaX1VTToWoZ/Bb0jOtx zZAS2WSgliA+jwNefdCvJcYLwrjcUiggg0wk4ql+KJAdUTtfDbVALuAvJkSEExCMHPJRuzt16BRp Lo7GwXVNiLSuLE+Ry5mYTr5fHlSkZxti+LwgJJUnVKQhG9y8eNFJ4IYxSYcOfKrCHHysWyI/4W8P dKBv/l48P2xciR5EZu33+YLEAWk+w4kIhxfVgkRPZk6+c+QZmYZ87MA7J9uNuqrE7TKauDYW9jof xIcnBsLkYPnSMuSUlQv3Nn3lMK96GLWWRS9uaN7BXueOAu9cf2Xt8c2zbcb+cQkf7AJk0i8gxy/b UbttJhFuuZv5gs+I2WKKOnDAZPR02HCiy8A7Id1DySViVGS9qTNVKKXov+a9ZJbJx8JrfUJhiHcB hZC0csKX7YRqCPTHzsIYIIaZgKhkZE5b0RkZQnSVGRFhlqEoOTv4nyH8s3dZjuyy6OnmViYyFRIg TziVZjrJ/OW5YL4OC45XLpZspLi7dhk8z+GPLvF3rTE1OYb90Vmn9O7cIkEWsFciV0NQmxmgxTdv 3gxYlgwTb7qTPIFfKO9xq90YQl03XpZ/w0r02Ya0Ozgey3FyxYxmolErM1vfoPkYZF1f4hDpifax pKixLFOPeE2DafacoyA2debQg6cJi8HVHgzaDDx5NV6VhNDE+ySzUZTf8CUTO/4zVFCbuE3TJ80M p1lxDC707UHSkOiQ00zd5LRK0agGGUDP64rieUAbmU1Ze3pXiYGBz8B6mf9KI8MougHT+aICpRc2 AUp2XqRy29DmAuulgCFdE3ixj12Y1C/xCWTjmlEv3MNHRddmFRKzmYZ5G0jgZ8h6mIDhw2hJxJUa 54dq6BXt2QJE1BmlnANGgm7kONz0ckcFNmrhA0h5G8S8HbLxv7gZFDfSLtrvoOGDnIphiYZqOiKV plecnfOlIqwvMORI+NlNg9hyGcmHuwgxZSgyP2YWZTSt5tZJrSdH57KhN6x45nJjaI8S+qCPs/Lz zAqAgYQcmr+FyTJf8zJ5ZnpmEpjTbw5AH9q4aCvPNbtTpT6LueN35GZpGNxNxNGKQh6fMiU+Sj7E /vgDDZkHF/H5jT3UI4U+mXxLbQuiJmy7eWZDe8PB9JCbfQfq1bgEO6EtRnBAwKR8gD1D0HayPDem 76AsxClChIWdLGu2T4zPSH0qO/1O9xSd3W/5RTCnJPXApN7069UceA8WHkRWVoGrA6mI82PiDUBH HTPZUMz1oOk/+hZ5ASPk06eIal0oYF9xjRgZeKGObsbQcvQt7K4JwRn2QTeZikWNPxpPNlvyt/Xg +9fL9Ttx4IutxFvMdwg9rrer1VLC3s44CTscgmtKIB3FS7ZijG4aK0MCJneZDPrKHItj+HdEhqvK ul8gmPZwmRlJEu2I0Uy4W4v4dq4JuXdvN/I+LJxXcW/OqvOpS4YTTxAN4OT4FK/HcBDf/fpXo8fP Xj559PrFy39Ia4sJGXYT5T6HYXdPD+iwfg/lT+ONBs+s/qqyQE5sMD7yzhLBB06x2eKVFluDiMPw tqiIihAoqd5EMTMseqIRPRA78r5IvD1ysqtYlSL2EEkyojVKW7KxUertZq46VfFzl5Lt+yDa8s1k Ih7Zvvq7PGR3LFBLtTCTZ3Vk/ZVz0zDl7iFuWbmpkKwGKMrTfNPRQDuzMJrXIe5ZtpbGT5v0L/z4 8yKde5hMAZJJjXPw2pNfJOH03E1GKthYZcR/1k4/+SjjB1Vioq1cdxprRWTeISEmUMHung4WbFRC pJKvCugtfA6iMff9ow0C1PaweJCzc+sVUtTxk8HD1EGIg+esVf7gZRAidjdOgs5PxbLqdhJ2blwh kFDiYMzAbQPvw1V34Q8eDixDQ61blzCyKal6ru0Pdjj2M9yE0Ddej3ezZ0DDQDPdUQWPdPuc8XIz W0S+XWksatArf3sXTXLWRJW2u8egcTmuxU9/mtw7JcrJPosHtCUu+kNetuZc9HbOrHXEUOTJzWnP E0K325zXPhhD4FgcOtqOJywdPJZsTgy1TOEp7bLbZh8Suh11fppN5GDbJOC7Co8AnZ4uTsBDeuEn BJvIT4gbJOx/JIbyQRyl/oecOvKh/EjDpY+w06btncpCLfdNYEjCHbVkW0q1Pm1XpgPAWp3/ICOw pTuBNeMAO6VRXf8z7cZzhqQ51MIYWg38OnAN3ebdl7OffQxZtFrv30YJ83jiQG5Zzqfvx2/+ryef fZbk7uAEHQsEt960JDcH5YlwaTFIKgUZCvEXEBhhWsGoWpJwT5pyLelHv2Qfg6/1OckoPZfsproB 6W4hbhc482K5q274RjsMgXVeZ3zN+VGYX6B9yI2dJpYn4j9rjo9NoMKk9d/MqusE9wgfGpc3CRV6 dl48Yg8gRQNBAz6Wpcx4i+IRAt6xu3nNWuvNrUbzjdco9qn3mj696Us6QFI1C1eppOGCz0UleoTE J9ki2DqHCue4uKdduYefPcLceBS2AMzy7JaqWYMWh0kG5strbEwxKlEC3tZqSL3mYKfiAw6ce0GJ TdL+lOHoH6GtT6eBZxt5sQwvU9ONTKZzzqoFUoIRCJyArCn1uFW0JmPAByb74xjYNSUpQJsCVfeC 0sqhlUBSfpARoK425KM4No0hJj7f7FVUgWukp7nywjlExAI/LbJeunxEDh+AgCkbkERsSn08GTVV MBrBF6OR74jJQmjm3Of9IGCTeClHIywL1ZBqWEu8AjNZVmWAhrjQu+oWyvGsQp9/easAsj2BhBKM JNP4rHaVXS0Rzp6R8SfhehfXl6B/+67gNQVNeLzKsmMWS85D6CqZSVI57QgmgOEAG0wX4CBHTIyX JSb0vSqe+ui6Hmw60gHZZMOpPeZoVRPvUWmWK6L+Ywuu+8MCMWB6xdlyOe8VBAdD9Iv+0HhWblxs LRpF0DzFecK0BYzIzddIWUqwwp6u06KgFzycHvzWOcJAcTF7oRuHnctHSD4YhErRGc6UxLYlLCbL qrtqTgEEHLrCM5wlLwkGn64lp6hLzDjmI0Nmy3KqXpAaJFjsHtaw/ICRGBRIaEiQx/iq4pSZLiZS s6UupDaMvyR7UxRhQxWpP+WPP/EzM9MBKN4Cn5ao3VHXaKZ7xT3Nuf7uehpru5iFmobXT75O0DZ5 A9MH8Sv3ERVwf7liiHCoCrCfmnIHnkSIBuQ+drPxEWiSDVUxLbickwjZmHPd3YWFin8EoKGGzSZ8 XDLYXc6AQ8OOv6VpYg6MR4etZV3R/oKXnE3ZUyHl7tBzsrUDtEPXSzppR+Hnf4fDsnzu583WQOK/ r0Kcoz1CWKjLixTWn9V+psMVQvRHtLxKQQyRXi/DFUnFZ/koJATkSB5OM7EWoHyL3zxiMEeSZz0s 4+xcv33U1z12msrUeSE5UFuScHILPBoRXg4x1HRqyJFJiCvtn5bpvjOaV2ZsiWUiij72A+7x2ZqR 6H0ZZDzmCwMrf7mcTYyxy1JKTCOxuUe+3eEPZ4cbomCgSizfsz6crUVKWINQSlaURuUMPVZw17nA Cvk2Vy0lPez8oiMz5zrCruyHQqF17tbl3XW34/BJg+F6OLRge2rmmog6fAj5uQKPkucG/ANf+oLI gkMnD3jn5ZRFXC/XFJEGK3jmw5Z/SlhwLeMFjrmgUFIsSVp26sbXrI0xGhYDZ6JIMS7Oq2sBpRD5 2GFPGFUriWSZ1SPRtNTxch0ijgR3ke6zClSphg/ugFwynx9RUBvO03bxbrG8xtBiDNmsHSpe84GG JaGjIAP0n7iPynAx4/J9k+q38yV276tO7mhjVr2v8IQzloima3rxCJ78isHvlhj1uVp3kQfj4wQV TDgozU+fJmyyTMGerOb7sUBPbGp+auJlI0nEdSLitaIXW7JIHmGGvrUEyMlBKWY0E9GzXXwkFRBI xZUiShxGBIyQWbK7LD54tbnalCd2RePwj5QkoKu7F5lbOXyBZV1vqsnoT7KwHk8PWKY1nzRwyYyh pYwX2UA6431mwHekRnOQ4dQ/D7DpgHtw0EGeCOrldk3hER12Y+To/7KrhoqL+fKMHiAr99B3+1y+ eeahbcynV5r9xe11/8BrkWWA0Dr3/sCh/9se6u4jIhgrSUtmqVGf9Y+DaShTBs0eBO5n99/EBO04 DDnE87kbVZc7x8UaXLhkS8VV7eLbjBipEBNXaA85ZDNL0YNGIvw4FE20PxZqDTlvbpBkAVGbW4/K HTsr+XKVyt0ROAAfPp1uzoeUwBMmWzbgzQQ1r5oamaPxyigkIHvM5Q31lCYrOWuOk6mhp+mhdJyd m4a1bSPkL/5fPqqHp9p/0UvmN+T1QWu6Z9sjPCHWaAEfYUIgbNA8WmPcNDbvqt7vJxSKHsmePBCF luk16NuQRsw1f1otNJwhz41KMxlPpR1MImUUTcxin4RmdhV1SDfw14vpIZsXih26cZUEMvfy1AHd hSSSZcWwlLYz8lYTZdse6FV8TLuZveAoyKx6a+8ONoUzOzjcvZkt1yk7xedFh46tDvsQ2e538WW3 o0v1Yn3ISr1Y//8L9UdZJJiWXWvUuoMGju8XmNXW3PYMhy1MjzaeY/4Bmmcy/9dqCYZf4sKL8/2j XM2A6Au0Bv8bFB2kOsNU8Een58o9I0c4LFf+S1SqK8V+4ggUNCmY4G/q6ddrUOezVJVSFtsQ3Msc fdnhDP3P7gHEkznc91JQZrF8o86jr5OfvI/7327C/LiDyffx044V/GEPpz/9odJiO6+QtW5eT1Fd 2Q2/nGW2w2H0//V0KvRfxjLD58kZ2zUb4tX2rOnDo50ffrudN314b+eHj2cfmj68v7vFZeMY7+78 8LvldbVu6GpzX/N8gNfoz8IIqMNZRoBvuknZRkZAw8zXxDOQlv4YpmJ27N4Nm2U72PlOTwbczEYO ro9GABXKSEx9f06+REIzrdPvLzTzyP518TezU7wp69F4Psf0NgdpwFI2tHYsl/vNOuZGyEyVeBhh Dd3O72u8+LhTMe7F0Oqyf2YziPhSZZhB6IxH3m45NtAsG38Yc0pGuxnPF50B18XD/ymzfkHxshMG wDtBO/X1D50ix2yQloxgGVlW8LSR3EKLn3NtpFfYlwPCA3xtQaCV1hPO7zjcpeNG/gqDVDO5mZW7 U7TR4XUhTnH4BT45kc9OaQB5qV/72xh8JOvx+dB1AmT3Xidn6kg0k3Ez227AvnWNde7Ww7t1j4yQ 0see9qB7UONcQ1RBA993yDib8XqUUpR7nN8h7nU3/9VHLit+19m5mL7mzKKaObzX4WiThmXLzhp9 Y7qeW0CdrmnDfE33TNi0Ycamnzpl6Ay0e8qmB8/ZJ00afTTdM215+2F5t+6m1kPms9ZyCKJLTpUO V4XG0Yc+1XjnXELnY/u0slf+cTI4MunCzTTsOhv3WQ9Bng4Z0h/7JlVDTcgT29+FMPloxI3a7kl2 yJnu124w6X3qHmG3g5gdP95FcsdfPxHXWYOs2SsyF3osBP1KHJwOkIGk6J/mFiB7AFNp5qZ86saJ oj6eSA5Szv8kd/DJWspIy9R8Hwy+a+7SZ+xF6Xzm0PGmqr0PscojPfZARvGPc1bCMlX1JkgzqgtQ dvSCJZqrHt4JMAJlm+/vOhlBVO4141XUL5O13HGVh8MYzXxWy1AsTsMxPm61/7DLHfc1TpgQvP8z cQAy9LysjmZul7JDB/Ruixlu1QWDbD966UBhGgfdO1DJQ3xACD0oyyzwTTcol2UWGHF/tZrPzm+L joQAcSoIzh3Mv4foKd2xa1ByhX5OGCxRDi36CmZTv+4QjYdKevy9P/Jw8uPcQnFxBB+PHp08/MvB 0fGpGRmSKzs2Cxsb14Ub5ZfmU+O1EnI9amO/Y4/WiTJE3K3WzqsU00ACyX7bpLZnw37+9OYCR9Wz i8WBVA0lD6Hq3/8I3HtnkltFIHL8BxYxPjdyPldH0H8lro064Y9pjFc2HQ5nG/YT4JVyNgSTv09q rzdMlXE/drhpQROnYfldjlkHOGUh6kLGJytzrFgHrT+zSCAE+XhWT8brg+53pei/XpJM6FAxjnHZ DxggljtkdJzl/Gqz6/aT3iczAA+7SbE+tiTjZ5dgQTPXvCPadjRaarafON9xA5RjxD3M3umiPoZx MYOizZs42L+hxSL6jN14MVix3kyX203/ej3bVCUmGAZ5ACUCUvGQ2CfG/bnSgMfQLEFjZsSLWmbb ItPrZW1qtOHHHDWJAR70d2kws7TA6rZPMaFPqYChNSFU8mDGxjtIjB0JBUxifFkYDd2AuWzWnkj0 6O2JAT/IGhZ373W/z6VcEHtKz5MI0pOHFg4hoqrMOmePXWO4jNVrpoBqvVYK8FG3jOnL+I6UcDxP rUjzdz79fyBbfv3ds+J+8WQB81usliDE1PDw0yskanSSqpPo5c6KYY9pEocksMmMCPRSTAJCWFJH B3l/p2to4g5LXe0LxMygKto9+dFKjbvSB6BmmPQ+xi7UTNKv4Wd3cDjZB6QosWuGC/0+NKbRTDGZ fRRpG4Lk2O00vY7PTUNTCEQ18azPrFLihly2y5hIexSPTJkSZ/DvGAO1SGBBTt9O5Ls2tciefRjl Wk1niLNPvA0j1xECkoG+sfp+UbzaXlyg1rtc1INcfRjejkq0cBwTmHBWnSOwmAhL+BJd12tECFss r8YXs0m3ndvHMlYOrRBE66v6ogyTHoXU5RJAxUFE8sIQlMtDgJlNw2x5d4RIBTgW2t2c4e9yc2YL 7KLOOwrb5zYhVqDnMJ/QFC2fJC06UfOet/tt1tBy36mY3T7myV0JqdxQ5Fq81aF8Zrd7sKY0BOuG sj90I4IucFtqml5tRZamQgJZHEnSXoK/LKAakUs9ares3e8pClBGMD58TSdxVmuWm7xiyhh3Pyw6 3bAcYjZ9Dkd/UXz5pTqA6nnebZATsBq24VIVwnswiSeZgge+nkhOiM3JaG6CzwK1OVToBro/OoG+ f8N66c3m5OFfCTKQRn7BQ5G2UND7E8sdu4+L3EnxR2TZsVjQas0oIplWA003HQwGnC1Gow5XekdD oT3sxXmZBnz8pcd+ybz9wr29LG8yMXULDCxnPYxlwza0UdzDurBPfyl8T94Rty276cPyXHz+8Ttg ng+iMudc3YX7dgaz9XNbYobvk7rxHhIe0scPwleGMRx//sXnPwfami/Hm64m08NlaxPrCb+70XH5 UgY2FxoDulguV3VHPuMScHj1CswL+LBXHOffcOdtU1fjm/IEa4Rxn9IYfh72pXNZzefLzgm+JxK4 DFrtXGzf8X3sJc0CvHt/9uYvPvvsM02lDf9cLhfvJ2/+j7/9d58hUOB39IBtcFNQJTHkHqNKKfMw LhAeuGgYwAKamkgwAkUKEJDSVoIYo2AxHkDGl8H6WoclgO9JsnQ2EYVwMhMC2+GPXkty1ZfVat3S lqT2FmfXS7KgaOMjAp4djboeHbbVQvaChwUyK4xI5RTmz1+8fvXktQvzh4Kz2mWKHprYbJfIScK0 g5fsioW4IwTzEWDZ6FMQmLeC+kkgoYz3gigwtGjHHrm6IElgjv6wyE4m8GvNxzyHRtwy85I3Jkcj D8mdZzWeCIslgtd0lalgLr85nJBTXY+6qDYTgfK4RTyM8QKxDEHf0AsETs2s9wYEmdAeja7XeFM5 xesCz1fgJU9l3xRoRaEdVEOHvKlG47qT/VzfcpCuDMQw+3h4DcqklqHcUSAedHsOnUG9caSEm7XZ Fa405cCVngWngn4Gr5HM4B8Z4J6UYo3eQFjR7Ipq+pj0ZObzls/OR9mhnwql8j5rRE0C7rDidHPj q1xyXkTTAYJlDazHAcuTzY3+PZvWSWo78lzAavEwxH/DV9wUmwLgR/hSmkMzEf8KX2vz8F5/Rukf prQlbRL70Qj3nk+QKfMSoS8I6kLmrRcyf4MiGEuZWfestiQ+5AXgOEeC+V0jgkV5NaZs8YJUcb7F Ql0DPalt94WBST2GDwW50s3aswmOaFc+Kmnih21929Yllswz0bJGy4iHSCn1j7ueSyDXIpY+1nZA 7yJsad95BSwiZCL9TnBkiPOVFLSOEWFril9fbjfcN8QxQjzbJS7bTHycTEvaAsMhkRFZrNtxEWpv PkZE3LNK9vl5ta6AGUiWXKSxGSVqcEkgx5cCWgOn48JlrOREGEaSrAvFJMSc0dAOVkVIRP7I68Mz pYJSfviL0CvakTiM4PylylxGA6xVh8W4mwgRtQDltSXeKlu+xwNyAtY8uYTPpSP6mbuqdHqQuzSW Ii1LdoyMRAT6TwT6JEs5QLRfIqcBQzHR1kZ9ndslVB7XZg2a3HiNij5CHi3PUxXckWRRCigR8GPe OkClbWebcTncbD+YiAeY+M4hWWkqa09E0jMaEK+1IlSkoYCOAOpGakKRCVHP5D3RRVLRljJyzDa2 t7LLBshhOOFBXD8Bg0ErH8bIIsgBERriXKmIiJnJoYiWcCTePmFC8VVmaSCeuowhNSbYhflsMttk UFhkN1A0dlVNeVtoR2wv7XCASwzcbIs+jQy3GiP5LddA7avlgqCdoDZB5zIsvl4yyie8Yag2xCC2 swq19QUMDOulIuvlhxn0T+ugb5VSGegOZy4EffMAa9S+jEExMWacFZvvCZCYWWuRc0lUUF50PY0E iNViHPBOVR5n7+LURTZ3Dpc79oM7hbXdrnRPe+17qOjnLs+dkXa0khJXSk1M5jxz5y8h5vBfgS0k 3/FQUNAu8tEB/18ETjqVR3+qQ4haO2o6iqiW8smb7568fPbtk+evv/6ma0+nzfhdxRBqNR4lnqMC ox2sbgdYzeCtcHVp4y2aL9UshPBEmfMJ+4dEMy7evqUOvn1rIdHwMY/q7duWeHMKLAZ8KOTuq+0T KhoVvNxsVoP796VHy/XF/WpxH0+5enOfGtJPLjdXc+IlV0s6Bs6X/X+bG8DIm2QTtPsha4X9KNI9 zMU+6EFE7shusfdAO6s1nvh8tKMdQHaAbIvVLUKVaB5jTsswsDkQYyAPueXShB+Mcliq7sckIJDE kbfitNqVWN2BjvdVA5ou0W7RZvUTI8AFyI+OdQYZGteFw/Jl3lqKQEfbtR87mVJu9TlGRZXdXsBa 3AzASDTNM/8XuqF3sgJ2O55O+YhnW53afC9AYV7pReIaJ4eeEJYxop6KQE0P+76OzpHyiRr9XeEv Xrc6DUAcE+0MMdPmuqJ7OaDMKXQJHl0ur7UaekgkIAwsrueymq/4E4v9KV9z7iPG7OR8tgUqykCi wMNlDDJEGATlhDVCZZsTcQzbOALTkZNT3wtuXo9rKeGVE4aGJIlcwDRhvWF9cPHz7TOJkFEl7oAN P+OOdGgN7/VXtzjd90ZiqeokHURYkKN6czuXhBUuJy4yMGvJEkOuM2jt7KQI6I3z1EbZu91LesPb mIV87JnI3nFfWNE7rCtOwG/uzOb36kwgp0Z3Xm0GBAu6ajfZ5GqKlg8yOpdB7iPOAm+yX1jaN9q+ eVrGaVFl1z8IN7ZKbZyQtoQejo2d5Y7AfM7qelXN5yRjIv+5uoIRHokmPvaos5R4kKTXOZp98DwH ol7H5iZtpa+zhcYnVRhmv6usAUoycfz44Cf8PCrXK1y/+M4Kt5EWoRLt6G7KWDoxT0efwZnSHrlr mW7uHoIqQbEt/c40fogRymSzIiGBzyxK0EBtmEa1KdNCeU/0V8VLlT/fXXPYRUBdRA94DgakpRlV aZ/QvdaI7i3b0gHDT9q2ZYmdqCleh++AuwMGpB5HW8EhEvrFaHNqJrwXF6iY6eyc9KBNqE7j7PR9 EwqnDXqFqWxBMMTMRMdOKZIvOLcs71YhVNzFCBaMkhWZLkxdFHamVQhm877K3AA10byv7oncGBV/ ZyevA5U8BOo9edg7Pu0W10S6cxRKUVe7XtI8Oh3YVCcCnqaX9/vHYRpjzUNOrqD4wP75cd/UhZpr KsaKDGt6mxFhI+7WlnuxWqrvfjRlNdhoHvYK89cxYzMPWONgvXzMOjMSkemPMRDoKk3dadsvdo7c Cu53TL8KHZvdVGIW0UTs7BrFG0v+6qsCdjVejC9IHhXB+Ft+4D5rtf7Omq2A4yD8sm2NyGuFIc/S BvG02vsluIThlHrdP7di349umjrSs85A58avSCdQHqFE8Lcpx13oFAPpjHklcip8bNpkT1J4xj+A 8z/C8xsePGLYg84zUZ7hkf40lao6AW+f+tPDeaXCY/fbfIWC0txJmThe+FMWlqNSf4Lpj1RltXl1 zRowUYMq/H6LvvNeO/ZWRyF8ld15900wTSyZO+HwpJQo6CgCp7mHB3VwvFS1pLtq7aeK1S3deSDL KPn3zGcFIdu1N1r7907nQFuGfzqa1bTS1VS/KqNIAvf8nv3Mh/mFuqDOedi2Pg0qlmI//pRLgm3b kmUiXVq5cRoJQDmZ4T8YF6jt0d8No7mnHwVKEudfDI7RKI+m5m90LiobSfKF6We8U+qGktyA1N0e pKnP8Pu+MozdyUNNvkv5TvgsXpSBpNuxmkEnn7GJeie3ymU+9WUDxFounjdKyKn5MaNR7ciUmUtX iq7nPNGYh1jyGqY5M2XqW+F+aPg0Wilp9ttMgWjTYcf47nTd3BDSZjnRDDhsD6C7TWluud1gtJje lkkXkOLlDU7RiP1NvQsTlsiaEFicfbVZrp5tLCIcpaSktAShqQCXjsJ1enjZ3AGFaYkuey4zp7l3 8312uoeMqk8FcGRAXtCsNZ44zG25ivcfoa/QZAsa/BXX36Yi7dAlXCcB6HtS6TRQQZfOklbcVdtV dhN0EPdz3D+SVuLLcr6H5MC6H1xP8BJbj2syV+FcpJ5Qd0AUmrxDOeKKmDpZJ4rt4oz8BzQvSglq 07b6+V9/gQmJCUofpCmbhZQv19WQpD3jG+w2004rAUB3HCtcJpa4dBpA/kcVcgqn2KNj9K2FXQjC xjDjhMnZu+VThAg9q/RKTilv7O/7UjfOu0LpQVfjMdF+wTFl8kvPGMXVxZWk4/JbxUefNBDFAfAD aw9RH9DowhkHSr93DyDSdaWaVjCMPe4Kxm1iPb7Gn/wFPB2dz8dwFP7n4otjoDRXY2hLz+uVlNSW nFzMXSalcFuAdgRsa2ITfN1B/wzQtVB4uUI6xsX2VznLdd0AP84ml+/QkPpouUCfwjAdk/Pzi2yt bWa26nM1rzNFLHMwAZ5xMRUN292gO9/ObmaL0vbM2HbhoZVm6Io+Y+9tjqyz0P42p8iBHiIe/9y5 1bi8A9AP6l5To7Y56nhdaVL72ME1bobeJ/SnM3lO5l+sTs2/bWBi1Xp+i4eImKJ5dWVVXOeDVC4y gDwIdpDnQyQD4g0GYtia4IGASAASvxg45cYbJio1/S8m8+1UTvcgJEEFcrfPaACUp3ZdzSnNjt6I YsbJ8Yz8C8S1NEjNS+i1ukDIL+hB2Q0L9NfosVnbEDjNtNuQe5M+2594Uyk8wwyzqTI1gyj5RMcQ N7kGeDNmqjc5R33ILcmuKXmavKUng6MvTnPypl2/xtyYwYo2J+ejuXWJRBvTQKay644P+VW6jriG 7X6bfbmpUJpvx6dH7p+go8RJO9oUzimucWcEJfp06vtwPHJTJvfl6HtO2omZhYB+fxHJFFpTK4Pj zM5+GHwxRnVmRPm3uAdpivcFJg7jsrOz2Xy2uQ21kVoTQN/WffHJOWFnQ/5rNDp1vp8JFmnNapKl sEk7Q4+uFf4Rwpmoqz45I2LT2ZHtSJ+iKbxdJVlPRjnWbL5rw6e6cb5es9m4JnZ2TBzGgrZ72oI/ 0lxKzdIfb5l8mwNPMZEELPkYs8lETHrnqh7xDcdouSZE/ZHe1cU3Jx3NvupajJWCP1STcm+UNrjn e26f/xixKBd1JuTy1eRdrdAeF5RcjZiaNCLJAbEhvfs5UlxO9o3zoAUzdBSeFWpq59iSbKuMwi6u xUF+c9HjTfdTeZk4s4kK4cLdRoklyfp7h4fNLkA0WszeJRkYx4XcA5JTkcRiob5Eye7EGT2sTXUG ui7CKyIoLT5UlCiP28D0POyepFopM4leVBvqa9IOObGByH2NHUU/j0UtBzg2EUn7iDmB0FYzdUgj ZOJfxA9OzANWDn/IJ5DlLjhLiWgFHzPXeYQ+GX/M0UXFC2SlQxSoKGMXz+HzX/YxQygnDl3DIJdX WjMnoVxV1Tv1f1W0GPWNMfWUeMos17ML9PzHBIuLzRoWbaLeB2NgUt/dkhEeBTV0BsNb+l94VodV kzSUDqzjYGoo81QoLmEuV8kCFaVZ0wp8qrdoRqhJPeulHgeJY8Ptq0VocZynUht8xPdTUGVqinOa opTxQLK5PAeyCbDdvISTFey0qycKc5ZN4r32ScycOcrrsbnuiG0pjwi4szdpKCB5UaCM3G3MAo9T C/+kEuJcE3WvbY61eR+dMhDVb8jBFAUOaUD/7RuxqHsyOD5NDta5321uNvy5ZO1yROZyarPbOtkh VeaQKdWDOuf1bb5qtgzmDTVD36eh69gwFAFD04QdBD4NB+IU78hZSUT9QCSEPQH9SMs+ClNpspYu hZFx8E+sCrlpAIC5AUZTn1frkVzxldLDHn6kEd7Gyf5KW2+4LPMlvckfxcCrvjfUOdnYzQe11k0u zuHDb+Wn75eppGeP4d0OaVD/0IxoGA8ssR6oSRC2gGiaWf+L04+JNzF1nubkfOpgO9tOLGRrpjrh mBPMDJTvYYRVElB9WJKirCgRXinV99xSDJ2fiT+ynoahFanVWAu0E6Ooc40gq26dS/anH4d2QyEb TwND87u7M+XieDp110oYaunc7mHLkk04uqU6Nq9DrMvpdCQVjVZ1tZ0udROMoKxQto4QOntl5kxP IRo2nJDkOLJrMmjhtmeitLfv1id369N2cVemRevpz6bpiZGZyKHUFU7oPl9ObWWoP7hh5Hy6L/dV 0bBke78TjNh6+KMZ6gDP05/EhrtnOcwFj1mTgGmFvlNhRAczyOX6ikILvBzM/h7oOOXtti2LOchB KOLm6y5Vy1m/6utT77JhQsi9aH6NzqOLjYTi0EU1Rltv1U0afWfQKRJ+rityjmmpNA4FZ4ReqK4L jyuKOdhO2NlaIiWc406/5Q0UlKWezI1nUP2tCKQ0NeP5xRIhw69oI0NBYI0Y8Yhg4K9gaY51Hpc+ FGcylgYn62pMXTLxEbT1UCFCkRFkTmVrrWZecfLg1N1GJ8pqvITk3YS5xakmMqvn5146rpcqbr3Q 5ZzCYJj2CBlymbgsaVDRsYsOEAkVn2kwnzw6ePfLXTrvVvWnImukbgTtZV6EFQlJIXMlj5z7OIof tNtc3gU41dJ+DPorIx7RfAzNExAQNuKiWbpRnJx28w3OFlPKmmtaxLj1qIHurtYduLX0tBur4NFE uKXJ8Ft8vNiirON6OHLl4QUKM25Un5CBxTbi7DQp/3ZNBiDT+KA+0c+9IJGSBYU2q8n/DuyRC5gn TD8Pgvj5bDIbzw176NQuwogZDoYaBTxHN/fsqlImIXwHA7DpdsKyG9gnxIWIkDXMg6Lo+25vWDZg fDNHueM32A+0xER0spRCdclOuCOcivb+WMLvaJTAJy5nF+huB38uDNuvSDc2NVDIzDvoPI4AXpMr IlpJmKdhsAf6C8ExRfYW1+8igBiEOarWR9wB0HBndb/4LXZlW8ttNInqmHc+4pA4wfCkZW2804rv Rjj0zAUWetOVcp2UhuIoiUAfQNs/ffmzoQktGSQY2Gx0HVHZET6w56yJM8kEV+S1V9XnuNtDDWmk STFaq2nl20iE99NDIYv09mgOyzT32htzX6xZFqLka57rzDUJj9J9msSJkMOm8JSZhIWQ9e+YpRC/ gIOEbxnatnv7ZEclrtyuxOKGaIaF2YxlKPD0ik7HwfbvZGC4yHxijmiHOdGK5KhdX6aEt7O429C9 QgLa+Irw4Knzz0+bKC8f1uNQ7vbMu49Lgqcth3XQPD2Rz2HkLUjlHeoAFJfVQqSqRrwB78NN/4wm 8yUyJf7TTk2MKOB8oF2+iAg6IKhPrgfd32nRiHPHj3h29hsXnOSNgieJbhIVAFrpJcWfFxO5g0Ue R27EEu+DYQvySOqQF1LDVbW+qDQ4p3K3ylSm7w6Uy+V8yu77ZdSnrFWA9WbqxlC+7ftnH2MLSCx1 4X2vrzRrpNPIA3a01KIpXeNTnfVd2rGvw5cW0lRvO77AejpDD2Bzy2Ucah8FXNZH+vx/1L17k+NG li+2f9jhCIbtcNwvYAw7egmqQfZDsw9zxZ6rkVq7HR5pFJLGo3WpgsUiUVWYZhFsAOyqunO1//sT OsJ/+LM4zyvz5AMotmZnHXdjVl0EEvnOk+f5OyWprwOonNPcENj6VN7W1X8pt+gxOwEniQnrflYE aoO95/vgMaX9kPpqjkFIFApblW2ASi99wtTE4g1NyYmlLa0FDLsW24PvSvHngb8a5izYFFODGw3w VApmMa2qQiBhpfQ0W5Lazss9HN/2AR8rZDi1Sb9/2Hfr+xQ6CvorYrW8sj3gHWmwPUQaJrx2CE/D UL6mG8eo8rrjb7HbX1ct2m8SnRqGCPuobo8FrAni5m65ycVP+3FfSWv9Ap87CG1CgiW2cpdjIF1H RgCj8QtCW+DryQVUty6uH3so2gD0SMdxfWQ7//L2mx8WZg/f1h/AfnR4QF7TdPx5BmZ8bAVP6nOG blynICCP+8rcX2jqQc4HjvpDfWxUT9mrIP44e5qVc8+L3MWeaJBRO90qcpHgRv1DzPZXoulygs3D ttrCpUOHDih6eIKhJntOUSSJiYR5uLLK+Xsz7M4VZCOfefCHg+cgZ7PwqK+TLO+p9dtCww2kOZsn 5lZdaIcQs2s372AiySCLb2j2Al0pXEYdx/gbuaVuK0YLMatHqTKcekiCKCgKNcyu9QSkyrsSA8fI hevYYNAYd5781CLPJ2c+hP1i/s71kKdnL85TjnquhPLMedy/1PtQGTvQlyxhA+2MWP1lfbfnyJiC McO0owzos1LrPljn1tTJ3Rio9D96rSf/Pyy2GWp6ja/AqG1YAYjKEsQ28+yjllvXcRVMBzHL260t k9u/VJ5ENG+czASJUtNje/o9CszNAjy/G1LCTxS9xcdfvAT/tcAfXEVY+67hcGMlSbrIGMCTko64 RphXZbTnyNoeJ4bwSdoa5Px/yRIxzqdjzwwxPT+JKAtyYJJmTlSZSYJk0se9p8hvwR1T+9S0wEBz k0KXnn50NRI2cGI9oashb+REIzFJodlIU5THZiTVhn3mzYZ9Ov2oCtQ89NQQn0l18sPZsXKLbLfE OR0QO5QzpnN6ziMGAqzy/0Fyho2o7Jc09uWdFRxTnRj0WteCFg7LaSQQBMa55+OfitTdwm8iczcs pzPQgLlvvtKwCjYIxCHpDJ90qN4MHu1uBLxKzQDwkA6j9t2/lSmd1CUT8Ddsy+ZDuaXVDN1l9cwE RUeel5oSzdXm6HX5jreRXqPE9h5covgaS27TUeJONWIN3j79twlQGEkpw4wQfjEJ4jOZlkhRx68E pePOptqQBTy1lbi8qwe8SRmow7sVOFxBGk/cBsHXj1wLfukEy+Ezd9i8N6KP5ekGCZ9H8ixVOzTH fWlh5vkY+GD6PScFlCpTi4im5StGMIEUaFhzqMjaagRxzC2U5sbIH0u5eKN63XxDL/DPlAO4l0Uh habvWyd0UZd8YXPsdDSqamep/o6NFqo2VV1Cg6yb3fe0m3TqO7mJx5ox8wLxGNgagTtH2cb9efOr YF/waSgeQEjkp3//awZxAGs4JKHAScPtAtHtBCQP/hDB16jQIhCnDIBDwCQDcfQc3kj+xuBhjBWE s5/Yhd0liR5gIgIosnHSbxOMx9Fwp9nr7FV6WrEbmJgFPJ6jbA0vIX6hP8IFvwSD9wr0XSvsYD5B fddEH058y/j1q8ODfzqLjPVku3p/PfbPqvSobJpIRxwARyRcz+vOVoBWFtBYx+dY8wKQhUF/0cOa eDyC8CfRKGV8QT4pGCv+14+dsZ+Gs1Mfze5sQrhkSTaCL0XkNkIR+kDTwyNuNATUNVf8BmymjmXg zTSw07xbY2jrSVW0gGlFdt/cBPNhU9FKaGow02mWtocPfUIskwsRRU0zelK7eHN4DMeawEV3ba0N 6PsP9Ts23T+XCw2M0of6cNytGzFpaR/0ak8e55cPzBwiXzgmWLMx2IsIAgrAbslIQ/HWWcpn0TLR 2AVEfJybpQTOJ+CcnyBSjDdbcwfczwAwUseqah3Tt3r56a/9VkOGcIDhCpzQYy91oC9Vkd0jedkf b9Hr0l6TeZgX0/n2ocmvVS6/CD0JHoz309RBt8iU8Me0L+WjyvfytMkYPgTyvNjvac9guhclUmKP ptNR0ku+z7IvrotnT7fguJhVJ6ho7DeTp+0Ev0rFRw5750eo4zBWh3lLaES89fYz1mtjlW7YEUjk 4579O3FEwmkLvFitFbddEgCYuFHicg35xOul53CpEPQhcPDHFcsREIttiEkhBcvpE0S4xx2f0R77 pPno7MV5oXM0rMAmQCFIie1MoX7mm0QX4MXLxZBfA9fguap4x0P6E1YlmJ3BgWLzvaja3FTCz5CH n4iCzFOhoJBVdT4OPnz9K8mDMZfvksE/hFMjsPMO3CgE0QdRGN4jph/6F4lvIjpE9cnDAYIBEmjG 1SG0PE20H7FXa/M8gHOtd8T1Y7xFxdBsBOlL/kjkMqY9lqwdvi7/1L4zs8SG+Cx724GxqbWmYiwZ wQ1RiNkd+0uhM5fNAZJdVh1BGO4MnwndnPsBC3bQjwctJGMVNFQgSv32Ae4PX6hzMxyEQFSnLIcD G/uOHuSxe6B4kKy8bTP1UiQfAavq2Pmb5U+tD76+L+8U2lNwXQlxvap6IJvU15Ya2vH4b+LJUe2q epLQxOnBjkYrQ+/QwbDVmWdERS8eyT7MRcKlJgDQtNe/CkKRP/0C6aljr4QtO8R6XIFO3xF9AhGc RsoHHYYbWU+ZlWUKunyaLIPtDFWl3VmxO+w4RyGgLcZqXSsvafPCTDwmnguqEg/9xKDYrZfeKD7V yj6Jyd9Acbd83lqoGKfWubkeD1vLTclDryT7hupyGridS8k4vHLy0CvJw/IK8jOvnO8zrEt7b/xv 7NZBvBu9nfxyar/4myNZaqXZSP9porzsnmhHhffqRmeKwQBloBV1xzgd5db5rfm8CoPE6TPhoOO8 lXwklcx4ewR2BbxwiW0Dq+XUxybBBtJB7n0phVTHAhLGd+X/Xj4k3FNEZ+HNIziJ2GN4Ap8aY2R4 MqReDiz1nwUZxo652va4U41njI1xuz7khlcDRRhqfUhs9nabnkRDaBAy1eHXABaz9kf8AN6aHSC8 FzZmp7BO7gnXT/KXNMemvJ9GQQ+FqQ52wn+pDnnYRhI3J7n3YNeNAm9WpfPkUUwFc9D8jmtWkQnn knWJep3ohT7V8oX8DvcJjnB4Z1Cl5e3BdBO3okVGDeQOvW4ifuiAMI+UCSFypE0vM3jYudhMElJg TbEDwUKhOJs+pwOrcj9N36PSr5iEA2dttfN9E/bYHEgGkMfq0YHF/cc40bRPOn1yqXAxh+ZraP+s VKoqZ6KTw/EF+nwAA++kBoBBL9nd3cZ2fG1j4DwLnc90cmqD/aTDUAhk6UFJS+gZBHF8pVof+4Az zhXOz5wREypdScoGaC4p8FqQ6nAeLy4UwnB7cUEAm005ezX/1O+Htg1qEqq/t26uEmicntV+/tEh OnuRyRyUjIHHRFw58jiV743xZ5f8VcCIipNY4AdqDw/H4Hpgc66AGqvzYEfV7oCL9yoOzgm/TIbH 0mgk/jyok0ImY554RWnnlCqB+Fo74xqIO/SDt0DjANdDrvhhRpzCD4oJVwD22efbLcghXj4rjqtR 0Go+SDqlrIIiQHKcB8GVAj8X4ziB1EivjdT7rR9+CMSF7d0q8mh7bKQJVtNC0cPNui0pfdVDfbQH lNScDnAlxa1DwChIhaYspwXnGYPbBKM2EWKUne8lAIxqhrCvufM9oQxdIhgaIRxhkmctaGVRv8Zg NNvS0Ez4AxOaMSK5xJ32WVR4bS2y+3PUYvHU4pdcfZvoEU39AtPcSZimW5EtZCK4xYTSYJWqrzpY mAiLGBaE9N6sno7R7jn2k1ZC0OnDcBWUogHX1d3dri8QUesyglUAyO5V+k2qtja7KxuFkq6OQHZ7 bDsfUv+bGSHi+wwYwsoSScfXs3JHOZQcQv6aekKa6w4SzaNDgdlZqU6FyyAby+Zuo8ZsFGuU7my9 d7NVBTBBl+RQCFPX+uEz8KXfOVuLztEXah/sZVh1FOrMnia4N90JIkuBOoWxTwAdRkpMhduGjw5G FK47fWxT56cnJRzvfNHFz71230pJUwwnFfN7JLLHuW0RZo6LUPbCLHJhg9ITcAeV+BpwGMVDbc9D LiZe2zT5EwRw07htZLR1IzczUGVMX0e3JY7AS0vnVPfVlglrkOHP9kQy3IE+IxpMIj3e6XnxfEKh ZzlcW875CBKhPfpVR/RQMqdhCCLPvcu/6Pf4B1vQLLRV0GCCJptmE9MgyfcWgzWo6C3PC1j3Mshm 02CqtP2DnJWZPR+MkibpbVGxqm0BOHi8csxKbh/AUrDhTvKtyKj6mNgeQi778dU8Q+O2MutxNJKR p3hyRL/sWsmGyqmRMf7XvAA3OlVVfWVzvvgpPu/gRodvcdL5gGAo5+Gwe/BDyljx3DlWGTg/rT5N 676oAcjb7M5ghFJVCeH2bYIqN0tAsit09bcWGCpY+InBExY/00uOV/NK8vcIl/5xYez8IWp3wS9C xmFz2PT0gHW9VgxVAAEVgon1fnjGf9jOnlNV3kL53bOQBdTPEH4ysUI+foCCh1RLmPhsNGCBc1zq kBlOhWae3c+BLh7yqZOvLdPYHoxMk4+L8RSasiWjaFcGTsCPpuCs8HLRM0m8L3PYR9Qib0f7+jwc neOvRv31OTHZVPuJ36HzURxrno6Q4QB2F4U+SuAzEBrCHBUyeRB3LgsivEgULyFXGQTfAVEkhEXh 2esDxkKUSDd+E4Vfsjifto0oLSfDTUTCWA/qWspojfaxvQUoYkXnaQfWkxJJEetmiDVgkPObJ4ny BJG2aQyUW+R8Fc5Vba/2CdwA63oACR4DtSh9AYnF/cdtoh68nMGvzGwbqAoMqryFkpQxmrLJU7Hu u5sXefinwDq0k0fnzm+tsD2Zxntr2y4SQ6q2gBfR5Gkx1UzGVF8iCbk4BInRArR5debbR6bnqYwj VlEpitPTLhqlA4Nxs84V6Ih3jlPE2vZY4aZYY8/gF3OrYB5ULbdnaljnJ15Z+s4B3BZvZsy1M6il Tv2f1lz3DsriVrtBTnv0IVLEKTzWWwp19hWxrEeqtktFYKk36kmg2cid11uBUZ2Ks5qi3mONmg9E SopUHl7mHSc/DSgmtCx0BPv+N3VX+qy6iHAyyqnCn1U1Mw8ZVH9oKiC+ew3ha4ZoptowiMDAYSLu I3uSOfAa05N/rY9C8VFcxxhX6YM+2Z5aBUnIg8sY55LduZFas3YgA1hdr2NheSsiOimE2TUPnEUU so6jxiFitG0YcE8r1XbhBAPB2bwm5BSYFcD6IS3T4diYO03UC2aYPgYrKnzbIzLChsm+qLYXKJiL FJSxk1S1jWWlsFO4zUAv5OQSlVb+EuXsuuXM6Yw4FOaC9imrVc2ZGTHSzzX5k0A6aKURuLgIlc8h jjPTNmu9l4TNwJI71s0ZP2ChfJd99WVPzJR2n0iq+7UD28cxCMrpN5e7GQL9oBbcBAiVoTDQ5uI9 NxRPkvZlsHaXRC7kiE8xZAnnEblEEBjL7Thhwukzu6AhG24YRRvV52jm7prQolNt3e0Y3cVDtmLz IXJRWWQmg3qANGFTQ14JnjmeLWcpm1mK6lvczlbSNptmzT2HrLhDuaq298wv2Kyy8GvAfE3cxxXe 25GfZtvv8R2at60/eYATYk7PKPYGxF7nV7t63SFqPvgzN0V2Wdc7co8Ch9NpAt3DrKjtqHrGEzB9 Rkt+P9VzBMYBnBjhCxynoKYKzsAKt83ZI1M7SsQC6LJihw6bY8krtKxzw5Jg6DFOUFsjiHk8c8M0 /3gcXDTWUdzvk1i+85ESFmlCDXubfWZZXe38BwmBs9v1A7ndWZ3ZOrtcb4m1J8p+W673pNgS/RoS JbwzRj6DfIYLO82e4c3G+ryqkF9er6E73lSDGIGTm8qeTB1HoPOVzQgHQVYE9gHyu+QA1XXq57nY 7la6AUzyLBsxemG/SacUZQ3zygVvIt04NkbqItMXwp/szA23c6nkbH5BALXzs9uz3496D7iY9Cbh RYdKXvcBWjArNFZ3rfbJtVWPF4vQU+SMuju/BCffcsfpDpvOfD89NyuJf79cnCspiaqzCVekeQZ7 actDkY2fS/qV7o5moqrnP6CJZr37Y1O5kKQPZXMJIAZiJQVmHrdzPuZXUhOjVKd9PQl70GaUt2KX ghfEe/s2MoIuRjHMWhs6jMIzB3hJExDlGtHfKy4ilC6TbSfBozzcN42QphVfZneRa/OOGanclZyT TwAtseqvzJNcWDkQCPUZ+HybAQ5JTkEjKtHM0FeJzWa6fWpDdgHcM3FnckNCtHp7EsG2Z03tdjUk rQFc55z6IuM+qctETT+ohKQFPyWj18SvxJyfDNdixHGVL2QsxCyVbae7m2Oe5mnqjTllubmczEmz eZFFvY9U8mkLyiQe2zSuIpyawAsBPJn4YH62zF5oVERDGDBWajV+HPpM6nidvUhzpqRWGD9ts9mM +2ynXxbkFA6X6uFPR+EMqlJFdt2U5T4AzfoFZ2iLn8SnwDxfrVDF5kWwm8exNIExk5Cvot6I3lf0 wT/th7bEmDChnmEN8unQPHkfPm0BUgZaZXOd3dow/2YKisSBNIPkSROIRDdXVg/Jk8R8D93NHLNO 524fXYsKJgZT+VrHeBqODSnWISkQNSOJGrHsPJFkCmQ6SAq36+rc65ftSPjaY/zMJD3dwnxc7SUt 1LOXZvAusSMfXUq3zW5ZNDn0KH/DsROW6y6yT0iM+OQTtqo4ty6+Q9Ciu6ZAjEszQ++e+6jX3Np/ juomKgh2WZSP1hnHIzLrjzl3wIh9Z96yVP8DCJTsTnagZDLgIXBx0QP9ZqRwDoGh799esV3wW0Jh fDX/OzRxX9YfzPEFdQuwlzYdkR0I+H5JZno0JfIlvlg4yez169ek3eW5/D/Lpv6y+lDB5Y9in1rM +XwO/7x8/oK+/z1il6FFUfQ8zuxORlWKuVlnXT27LGespeIw/KAXfR0oLFKRadidvc+8SYO+vab6 6kSvwNBwWXUN6ItsBylRueijwu6gf11+P13ITn35/F7PxIl9vyqyRzp9cj33y1OG/zlsgmYLSFSt OBRW6I5FoHRMiggAnyONtqevxfgqfzEdn9CPb4lnx2ymoLSgbTQL/48Kf1/dVhAKi2mujtc3nT5N eBTQEE37v+AYuwrx8QGkW3R+SOnMeqGr0QYD6nn1zK7rOW72sKFpHKuBo4qCGJ83I5KXzaFBLZzZ Uqau4wEdZ67NroLoaKdm5RP7BffK1ALXsuoR5mmE02+fZZuHDXME+cVF2LfZ7HU8JfAQI/7NagIQ ASyXzAH02y8pKGL6C3hOs/XBdBSOA3AGtBmjTkxFQkWQM56Ud2V5QDgDmT07oK2TIZHK4vggphnw FZAcmK/CxhmilvvKNVAy6x14Ex0N07PDInugZFBntUksAKnNvy9L63FUXzFYO3f84qJrHszMYhAz KpXNBY00gNSjV+Jmty07Q9p5OOC42dyu1RqLVnS1skgHN0ayN0yJci83l2N0g8Bx/BxvITlWAaip BarEhHDroLAqy5JhBgCS7fGSXHFtrKDcn1o0ogjvm647tIvnzw1JvDxu3pXdvG6un9M9O9uWH/jP 5whe8fzlP/w9PyCy4C53rSZYSyfnR1gpZkp+S33wRxCknzPXVPqWvW3BqTcf2+3sXPTq3XZGiAES +Fg3Hjbb2CxfYzYOs+m/NUKIYg9ASnhqky57yrgEM4HeB4HzvukT7NmodFIgcXBCBLdlPj4huByG /zQDcx5+oNK/p+qMeqL1hf01x5+xoOc8FuI8Id/hPpBM2HEVoxTwE3qSQJBx22mmYoOpeZeZF0sV JxWlYvCp2n4U1gyAtph4Fn7nL0NpAx/Pr1ZIcVqyqHplbERH4IAjeKrMCjL5JL800n77VferlQOQ n+/RsxiHNMXsrdUulD4VFw539IrHLw1SsARkoKs3IeIMeGZsq+1+8gOqFDNbGqRJ6SvmmIS8MdcS k/yboBrRAhP0h5n4+sEcJvR81dyPVXgPnoMgB3zA7yY0bhw6ynumf2Yx5gCZfdCdKYb/37+Dnuno y7dfZt/8/ofsu8/ffv/GpWT3D8ZjsbNDRxatHfHVsewhlfYThkQRJYxqugQuhtsOG3Jf2dj7fXln CicnJI1+x3V4Td6r0X7SHVSzg7cm05/uADqQpAFtcDG0zcbQBshyDallcYSfZfmrIvuHKO/z4eHV 3y8AlcX2egpbZ0UO1+TnbjMhcTRW5NT8RHFehBUUvIaLF+7d43U7J0h9vHnxnv2Hf/y7T5OXhyOC ZkLAYdC7zBIXCfSbvECwE4UH/9UdYm3HgWDB+CP5KycnZPV5ctNYnAbTvWhnwMguFcakBYfCltKb HIR/I/4TD7NuDZvHqLnOj9QwbqZMgLUYwvzwHnlrChfZYFwS6gVc9fAFbDtyCjdS1I4c+SXug/Fw 2DkCGFqSeIi/DJwNPFbxutyjfcAqSBNUQeeXY7AT8lwhvX0Qk5NpPA9MMseFGRnFnIvv3/zggkqX EqqK6v2+ynS6uTDiysOusrBVMga/99zlU1JMek531DkxBsXBVW3IMLADHealZYsADnzRhxXJpUfD QZ4KwzfMpcstwpQnGkn4csWFwtasO1ccNm9ak4eLxysKYlMtWKID1OhB19aIG4MArAHERzr2VnaB Q0CSALd4K1gvLQufuKpahlaSw6RVr1QkxAixv/5dovhgS7N7jJ+ZQj1P3aa97iC940rG0FLOPQ0z OZYdMjZUOZGSQaCobK4Q7b82zRjqGu3Q1i91SJsd4VyqDsTXjtrz3hno848UwC0v61pPFLcQTpXF MuURZFPB2kSb5Iw77snS7HAKdN1+8LFAz/UAzJAvy0CALq5wGJyrwiI5tc7EYrQyDxYF3yYwqjWY todvPYDRzGBQNheR26Ccicgcl/02H5+Np8AXJRI9itAMZrjZyyTUFBqwFtX54BgcFBwDS/RN4+rw AMO0Sa31TOYUswwuieSEj8IWwSnx9IJW49X8FUMMykqy3ioZ46wPe3Ra09gQPjjCGG+pMaMbeVZq B9d43HcJEgLMCOtlByNoffDmVE5uRNxF/0w3f0u1X3vxo5+wL391Fa6/OWFoyWbl+T5DeAU/hDf2 qtLUIInI8DGpn6wTVY+lsi2cMcsiQl+19CwSs5FFbN9Vh3x8DUifOBzndIleQ9ag8hSC6TNrsRoN RgtY3P9C9UnfYElGitZDgyIr3CZeuxEqIV7BMYE7BjgTcQ5Zwh2pXp+NOf/JOWrSyHUErNk2LYpX mLIGWtyEqI5npg5zfY+L4DuRUOJPpUb40pYqsuB7G6QSfa9qhipsQTME4XLGbCrF74R2UJIEYna3 9UZzsVB2S4FcJX6ThwBW6NDuCBmYlNjqTCvqjNMQXk8eXeEZUu6u9jv0tlSjIxYLHpz3+haihiOO ACCVnn9OcrDvo9LO+udUsGkpWeNWzICgucp7srZamEXqVoypaOeXh11wwCn9V9vmPTOvN98OgsO/ Sh+V0T63xJvA+6zHM6h42Zm8jh2h52IZ80k/wgq0kHq0bC1eARcJozCt1RfTgOwzArld78CqFDpO U57gtrTmGOkPoBTowEyJGto9JID9A6nQUfCQ21SXI+oY5Yej5gs3I7X4kaNqT+bD/HlZ4mUZgSiE /HMYcWQq/x5DzciuWBBQwVXmnVQkGZbmYGompFbB9TUUs0bsvjDWKQQ436tMw/F5QoKbIE98+IsA PEKlsqsD3UkTvf2FEokvhfmjGfTYi3mqfR3TLDhjit1QVjXMAZpTpAggVlqjomwhIhd9kDFwBWMJ y8IxfRn57CrY9ty8+mgl0z4HwuSKeTmmU4kDPBfCREIoyikIJiRSeksqIAxbUXHbHPkTfAwsB21W 8rGUMTCcNsdyGFqyX5t+QHx8UAGQ8Xd7QIpeY7Z1sO8+D/AQenLXujnpFdrRzXL0SJiyugwUjbEZ OQLfzN6zk84Aq6PNddcpKbVZlNvbY4dXGOXEAi9h1Lmu4S5pynXLCCwKSUwOW3D8/K3wYprNspeP 7AW4RfIZ1fc6850222kygpLvst8ZDvx4oOvYm8Ne6qDnxx+PcABqLil0r+9Mk54tdao5hyvfaICW xHeguYbrTYVwDWw4dveCL2F451ntBwZd4j75TNj0cUkYOudFx3HHqit9H3P6LUgB7mBIMGX3SX20 mr6gf8yeum6amyrVQ2JXcsZOIJmOUGCi8DI81XxQy63fPVO7eeNS5rgOEsyiOVeSluALP5FTdcUf J81W9EqNMoY07ElwBIOTd8H4aglMOHl4TyBaoSPQo+MB7f+URQ98DsRPQIrMfzD/+cKwSV+F4WqD oJJ60lZQj+W0ThQfFeRXILIrjsW/LxQrL/4b/bmwnSVRu1FWt9CIQiMePi3pjLeY1om0RV5GwF+y FfvmNNqInCe+9wipI47CZR/1wdym7UMLbCoiX2vQHB4OA41Ij13GqtP6Th3oOwIiLqY6KO+eC+qJ ii8VQAPFGGG+894u4Vupsa83EiyTXmLCDcMSYpE9aQYkNEeHQrv0RxwPbTMyes2aku6Vy1Nh9xI5 DLIH5/qqQ5gmd/IwjQ32G64R9ubqEaagnaq98dQ+Ns7YJyjgzHBsjwgghLvB5Zpqb9ZbCJMER1MV QcA6pQ0IIhFqczIzJUewLz221HKlQzPIX3reLDsWxFJ8rw+w0bd6XqIOr/kwMyA9Xqr+cPtL/lcN BAF6aHsLejT+CKH8KHyZX1J4McNS+bTFBRQ7I/cP/goZdvnquJOQcIqPFt82NEKs5eDxuXMogHt0 Ekw0FgFF0ZcQKr04PCzwol5cuNi15t3cA+65SGVRBX6yo520tqH84C/qKvnm86/f5PP5fHpxkQ6M Tms9PVpwRn31cHiCgZ9wgUVxubyOSrEMJUp8xyvdXgfLLM7rMdfq/AcJdZFTTQX0x2UJD4WMBB/s 0JGpK+p0xepNFfWjD1JCrxHI0HKbV2jvH+u34yKWuqchuqxD7O8LIidIGh11TtdOf4y6fq35fElH k5QRFdQ7pBjfrpyOnhPyucR4Ys5HAuYULIbINmuz7VJgnZ5J8Du6SEh3BnRacC85VgDPxMUFtnpx kf2treniQrpgHlNQNjzEjoAybA8O19IN88ACRxJUg746vKoc78JAB3zjCAhfe7xs4VbZs+1Qi96u n3cIU9GUdLD5LqKBmW7+EXa4tQt9itQJPXxU0BGuMKJYXFx4ywDRGYatkhAD0eCBVLqDoN01LYZH yiKNJAP7XRthtyRFpuRUZnAGNSaF9+FuAiRDPiGUSVy4VkzXyuoDRWCYNf9Q1ccWEsoh9qKdkAB4 D14COd3XMwu74WJjYEKpwr7vyUHSBhqwA9URURIvLqSmi4sCZhbINf1Je/fiwk9w0+Ci4rVo5h3R xKl9dBY36wJ/76qrkpzM6yt/rf2uyXZcAFtE2Bno2g96XKnLvIZacgWtLLd8mu6zl5a2k88lmnlC ewb3zyQFvM6huKoYJZMgxueuXL9ryqvfqJw9pgT0cJnlIUEr+jkORw+mflVB5jbVjf5rjdDhsNCZ 9OdEeH+Far4iw0vPIBg4MeCXXOuhkcwOyPUoAUgPGgVhawdFOMopZI9a2nVgW+56Z8GHw6UmY0iJ k/lSfxqY94fR6SwN3lXSpzgF+v8lKS6RpW7AFFEiJwYltwlCxSRAUZvPEbvH0U+ENTUTCjq5EsGF LMt+WXYdc5FkZcHQuPAGFxxJc9UA04uKvS4jQ0u1PxwVaDALFiE8rbOJC64zQhQhgTbiwFaQmymM br3HbtjmGanZz42LGtah6DqKLaLpq9AfH9vp7Vt2WW8f0jQkVJWv1ojGq0waljmY82VkSNxxB+AB vgI98WXfXhhWs6QUuKed8qjeKMLejjNQ91sGKHBmhbZitrIPMpCsVMtszBfnOH1+SaX3bVsetzVX /mV51Z+l1Jt3IcBFhhENsbroRCjGxPSHPUqHiXhBQLc1bEGE8IJdCTc9/kk635t6/6nzS9Zqd7Ca 7swdQ5p0NoACYVAbk0frHCk0mVHwAD2WOs30UmX9Vru0oaBfGx7sfBEjOsncrMVytlbRQPoSTxJI 7MvFqHfniozB9YGfj3vfqzdU8AZ9WR53c1i0pk2hENhshv4HDCmRWgN/yPyXkaFQsWdT13nTl7g+ VM0LLzsapg4FDu94GVjUL8sriJyDPYS59voQyZ5k+W6NV4MSM1Ijsec5AU/hUdjHhEU5hKoan0+P yJa4BTpDh3gw2ZxIEcFiYpX78nuhpPVpuhHyVh714CSaAi8GXJ4I+hmiS28rCBQFzuYSAdhh+7lQ OckDpqADQUMMuGcDLcfjlwRegV0t7NOVg68DfwcNQUfQ1wxfy8DagqkdVINI3x3i51F5gd+weopB 3DvyM3OIt/Fo/DRjakzRQfbrGmQhZbsRwO6Z96XC8FUnaJl9f7zUTqWF4Ifjx4UPSarPSsptb53d mK1QNrOdISu7jB2ALMODzBiCEADSXJNRKe3X4Xrmc+y+Xdhn1HVHIAAao28gmgRdL5g2CEijt3Q5 mzUuj9e/0ZkYwcu0azkHtx/zTXjwuHPgDuu5wKB1LK7oanTSn7DO77G9RMKHoiDsppnzTC3dpGkH vj2wwov4dES89hWGG8Ow6ByjjlS0BKVSzyfyJz2qO9YIKqh+Px2yXDXldgVoNoeFkkjS0/hxvAtW vIO4VtCyBBr1k5i6IEeCQGPfVu0txFDnpzfHRKd5IP4ejZguVhKQAa6OwU2M2VCsy8UasoE/2JCp tMMpxa2h49TX3McFAqyCPLFV8hLsyaeNnN+YcRw7UGt2yVXF/cu5SH0OE7PDKGnsd1W2P+0JHigq mweTNrCagKpD8Gc4OdNpAufmQHNE2YY8lXA4gwEvJ/Md4D37IFJOlPLYwmChuakYX6jfo1j7EvPn wQqnzPsBdJuG5boKwKA5cETCuwl1gEGV8k8Uio88k15M410pPCKB7Cxogp+2PQt8kGEWMjHKhRmD auMM29CKz0j6bl6xhczC1i+1RBQdQLQkIRVEbHnMygOJxq+8IL1t2R4AYx4uCed/GSU77zGXekB7 tLa0g1fWOU4XjxRSFXnRWach0Hy4sZFrSTiwK3MZYCSmOeNXOp4RxqBlE9Wv3n7bQBrFNUnKbnim nEkNKUsE/woI02e+Jy4eqKfNa5u+noi9uO0qRsX/zgunNHeF5657Y6YHpYJrDqMM/XdHEVL2cy7g jE8Jz1hu41R2KfKe9YQiFFNdEr8eD9gBWSTMk9gbhpjOdOheWf47lTPTc5f15ZhQrE4L01hK8wfB qNSbIW9jyyKmJK7IZdclow6DvVIevCp1dU+mvISXrv0oeDXgmut9kpjmwMwoxb0siI946YZD8Vxz Tzqf7sjB/e6OZ78dQDmMu4OrGQ6yzYZx5ORmH7GmwJcoECmXzi0qiT48I1anbG7YcY/EDNqxeTm/ nptn34uDy75kW95aeQGKIgWd4kmMAh2aeMWwxxCNy14jjOrH0SU67WeY7MRdPVMXPGL5RVaZMEXZ l3f6FpPbRFdni2Sv/Re6pmkY+KCN5OpvtRQbNGQCIWnEUmvZMKkly02/W04HZlgxSE09HSSZlnGz tPO2vU6m1nT6l5DQ4evTqCZBTqljEPNlQc5OBP4x/3UnhPggOCXhGekuExyhIWAI+riU18wKuXa4 T2d6HKHP6Llf3Mh7HbBTgOlLmHTZ/SK7Z+DKaMSKXaIBydj0ZQFvejUJ0kn8F7NFsUIEva3k6LEv xz4rGS6v7CYtqOnagRyRShLtMkpup921Wq2IueL4J3bFoe6EUXfAzPbxydbr8VE7Aa5Vka0UBww8 JVpz8V1PZax4e/v7HtMATs2KlmGMrohPmatHlE72ecDQUS+AKhaZeGflrkZDhP3hP3sZMOOxyk7X FPVnfEKVsi5VYdFNHeY3SV1pWwYfCwQ0bRjRNFnQds8hoKYLAg461Laz0KoOeHdizu5k2m9VQTi8 UeJAJNAJrH637zr1eh9DVIf5JULg4QRmNWGDp0zAxDYyjngPBfEiJeLVW28w2GGJMQ85tI6Xj5XE lcqmsO0ltgGokqiu9DxHKNSxctMeDKtMQADt+rjfOiZDbo3402dLEPnVnAsZXDDWMMR8kULAlpn2 1wM8xuTwMEdZYDazwMtn8ABOxfmEJArAacSEJmayVSpEvirjS/Y7uD78g1XIBYF3YOHdetP+6xpr Epx1+DGQ4dqcbtluFjlXNYuERKLnYjMtdsjdcfxXgMTjqgAkH/crvI53ToKhP8MCtoNYxgf6HWAK 7Ni7uuNJ4dF3d9p4ZOGRE+Zc3ireAhQKDlkfX5oFq+jhSUlDMdNLS+v8irxq1MT1w0N7CM8peOhU n2OIcVuNRJNbTn6n2Xi1BngF+Bvya8bz9UCG2H3chyuvCA4Ekxo5JEt0ozbEBjy6zRu2xWn4Tkgt BS2y+8eXlF9KxaFdIZlrS0e1dD4qm/YJnClQfsDCI+384adN5Y6iNt8ZwS3IKA2AfLZo0607dDU7 bnC0vf0EzzCtWoDzzuaw2W25uVnvq03LoTAdxENRxC+CQnE/EODWRlxUnDsY3QIgMAlVLogiPaOc ztYjuqcO84YSN4kbCVpBLQoVVNcqQQqonNkTELJcg/Tl9CckmqrETdx02dfyTb3btt5GIPcYu2dg mt3styz27MoP4L1NsdeQr6LaHAG1V3nffE5JXgFuVRIz20orqgeUVreXiANdvSOnGkYfnsG3M7Hv gfc4f8pvIZOWeTpDh+et6u2ujtOpmSU15/p4kJ0c2HRmun6b7HYtoSjPcdc7THA0kPGHvh+81WUQ kLF1T+VsuPBaR/eml4yyUN8eAIuZJ4nGQ1HA4tdo+wuOqTpvPWaN4XmXQqRyr+ZZOY8+dNZ2hRWk Nhja95FZ4P6wbc3rPSww77U/HOgaxrmZqdzeLfnxe4NGI6A9Z9vC7X+sC53wd3gx8LirJtzIQbw8 sG1G3jHNABfD+Ce8MKsVkcWEp/sy8bCnLFzxyfLwojdo389mE9rqXJaVUcIpVOVg4QjLx3RfUUR8 W5b7w+54bWabnCajEHUgBGVjqAIU7SlDDYHFMNUGMbcrQzBWfDxtNt58LH73LuOMqScfq5M3nqoM vP5459R1iSsQO6iO1qN3Yx1FHgCTMaQegadSfgmATbVoY3hNL5L56YAGas9eqmS8rx10VhQeYCp/ xC8ARCPRPL48QUj0PvCQF5R7DIc/KJ9lkpML9fkQzpeqRi2/JpDO9Ynq9dYwiq8nSiRVSu16lnXd vRMW1KO+wbTUhu/SJUaeoIiBN32QCBqsykItIPP9aiA3EZfLdaO/xIgeWngiq1pA7FT2s+EOsxX1 yRNyH0fuDRChJG2ni6ZA6akC1q/aZOgt2NJtzLRTEs6XtkKJv7grOZALnRM6yG5CQJ3lrr6LPsfm 7dkUYCo81yvn2CAQJ/jcP430zFl0FUkb9ACwmbi8IxP7eEVpUqjy+Qoik0qN9/iXI1M9gfhHYlUF 27SUjlp+kjjCI6f2RA+KEJcClsHxPuA+XTmMUsWWURLnfA0iAGRg2AYVXT7w5YoMTYjlAJOP+amQ mdW5lGB10Yvh8JDC1bNTf5hvqwZt3FPO/6Ivg6auOy/Rj9dwWx4AXW78vMd71zYS5Eg7qLRooU1N Cym0zHGGsWiXYS5L3pkSy6vCAs2OQhEt3OP2BPDe9tLr4V6x93LytgMXQyqR+wKrOxDJY0Bj7Ttn 3jjEYK+vbXVfmlkJQgZtqBjA4SvOnqgSBwjDzvVjBUO2wHfbkOxgstNad9Z7WIsEwj5uAbVFOa1a 0kOc3qV3VcVJVPn79M4r7zsjWzR2751Vi+rZy/M+1agtj/yE/OD4wfGib4NTMHGQ6Ss1pWKUsBOo /ecgY0eGEoS3CkA0IH0bSQLaiQ8cG1+gWiDgTL0mMfWb1yuINXQmkTQOzP055NObSzvRtaebSDF0 cv963sl8MZJ6FG9TD8aQ5MFQllIySZtZJuk6CH2NEWp49lpP3jI88xyDYszVKJciUGTM46vrYGcj Xx/zcLd+KBBrCNxc7BnrM1/Dkh4OaKHhC1lcHssGw12aErSn0LjZbhawHPql6kDXttm2MkvxoWw8 AJz1NYjNmOFibW4kNXDtvC2fQkdQaa28vVtWEFD4MHz5XLxkAJVz35rnyldUKdLdIoY6cz3/wv7o qASPhllVuQfTd1s212WOgT8guE7jLHGYDJyzd6W16eSLKIc31an0YU6VFGW8qVDZCbGT6TDlQYEP DII7FOFmL4N4Bnn1q6UGMvL6EkyGq6z3g9TkpQKo++dF+XVW+6w3V+hJ9DCBfdWXUjTeHGkkqB5T ysdBW3n2Db20klx0brMh94S5DDP8o5DtkHzyiIwjt7noOYMMNmr2bWBAf+y7s1bZwkOQa3EQTJ+F yvdUolJe3tXk+pCP1CPCtsSGrLiwE2LlXzdwC8M6USELE5ZszVMQOM3PszN4cH6e5g2MmPSuOriY cA/t0Waa6+MUAmwB3XOVFjTx+uzFeT8TYYeoOpMnUq/yjH6kQCsQlqhIkYDVMMbmY+vctrqKatue Yk0X4gASUiUJHFNaPwARsAGeo5hxFw0y5Nmtrh7IAkwnCf/2GIwWYqEAYsBbavLB94As2rMFxcDV zbZsVlQr1af64Aspjhlf1c2KYLLxXrRZHQRMi72oF6OILR7yQ7TaP+ZluZUBEbbni7n+KhLPpFBw pwNcu63OMv2eRnJQxE+UR2HNPpmeKIIIFTQ7WX3st01DFrJhS0m2jmTcn+Dbg7U7j6vsvdGeJHTz DJcTqrYz1nrn5l+EssBArzASC4l9mY1FcuXqx2T28NUCjPuzVHw3gwZ5MyrOGlS6N6yRZyFUIVj5 gLo//cjr3vbRnJn1cSd6T6osANRJ4dIDVxN14TygMXH2Haq5EJpis82EMEqaV7+GJIWcfovEi9WK d5FZPRXmA+DjR/CAvGtqZbeP94S1GZ22mXpcj1wGhsfWpj8Y1hkIPbWBnAk4HicRfkZFYjGUf33M bYQA/Zvufsnfyu/TvrY0VP4o8AbiuqLbxzFCadxZQ/t5W3IunLPzgYjg+c26XUmC50Wfj9Bjsb7p RfaBVXHz7etMGiMbH8mPV2bPdYnvUcas0CxutkurM3TqrRCjwbkqyvuKPAp1X9AkC3oLhF4RVZjZ 1IkKOGxQWR+xCoYf3yLYNisk2/moT6NzdkVejMg58QryCffXIMHZySLQLORVkfWtg6WIc75xFsOq m6Q/FnCCvequQc2Y1Jfz9WsGPDE8qy4ynaY0KygiBa7BkQ4wzr33OArzR0JHsOzj6ezjvc2lUA3J 5KrXca61A9Faz6B4GO7eJkYfh5j1CotJlaQ68r3aSaRbHsABuqZDsKBYsDAbgPpbY7v1x6m58lOb J5md4tH/SDxOdQJ23G3kFhtlrowq1GGN6MiXjRc/7X/ag29UC6hIBMdEGBX5dAoF6K105fEAQQJE 29mpWMVzYd3ZKQlkYW8GniFAIuQnixDAqWpFeq4bb4ChHDywGDGn0l4vKSvTynprmz5WoCWj1XZZ iCsHtqlzGHY6NofSXUY5LjElsoeAB5m6IYfjfbdajRP45/hFkm1L1wVPx1pJAUceHua+ls2iHU1P AIUJvlfk4fuuPrztYDGS16JnaOu/AD9urdDO4a+VdfKBIJZbuobWFLAywZITb04SOG0yH6kcp5ge 96+16XxWX0kSnAQMtMQXFziIi4t5loakGb81vG+53hqmFKIsCbSONNRggtqXzvfruR1HX13w9a5k hbXpCTirU+A9OvXhapeIAmF+zKPN1n8CuEvgJ+a7R1o8Hwpq4qydZSPZQyKF/GDQjO9DUFjLldOl kMeFikJM8a+WOQ2Ed+I6UzE4cTxZjzsDlqZumUL8BzIBfhHN77iCOkeV7xVMuXi9uOhTgoMG4hMV IIcXLUWfwB5KkEIXG9lKWGQ7SvrJWBhy2Fkvob54VB/hOrNMedFgJbKYphL50y9ge+I6FaTs2mK0 9zaOIXSBmWfnHw3oHFTiBAgpqiKr0LcriqoKCTYZE4J6F8k8jir/hLR/qFNhJniYH4XKAP8Ukpqw trXFymjRcMYRb+suhRzD7rke0NyjKQ4V0FfKwQGQ/zilmSrpJlRQQbzwZE9raDac8AFKL+yDghqO KUMAbloebdUVM2XVeHNiSxBxDJLg+Bp/7wgMAF55IXv9qHQBfw7zgYRxhVO0elc+YFphP8jYnz6/ hiHkGXnLlDbUNvudobkYgCELlO+/GgSO6wmRFtd9WCll2rx9cONXc5kK6A7R5YLUBP6eTPBz/ve9 VhFZGr0sTSN4nsm1AJnWG8fSfZ1U+EGFj5pldHqEpkRdff6J+TKmEWnWzr/3wz4/sbZ4h3sL6gUX txwaZ2yKLlb2jSJFiKkR4YDBExqwjSpTG5xPgTxzwLj78i4LHTXVBgno4FCyV48QjaJMsnKjpNZY aDCSWNl5Mroii2WIRCZFx3Hp2hJUNuKXYabEI+gSosjEgdyQkGMAy/okC7tnfRswHvOubt5Z54wx dGNsqoXVbYN61i3n/Sy383APR20MblF/6Ji/w+bhmzuxN63Ww69+pWZs0ClAuCv3a44qYsN3hn0+ IX7WLv5HSsofY6HzOJ+k+GZBBRZpwNsIS5NQzDWdKTzwsDwR9ujjYKbrFXrn1+xTT5+MnArJkFvM FAhPwmSTArwEfxBPDX8BSkOMpeQFVPpYao6Jn7LWA3AMbmtzER5Ab4WZZV0YtJNwBPnleHsJ/MOV 4izQn/R4AG8vqEi9yeHu2z9MXfgYu/OEPt9kHR/b194txDoU+zKaLoIvxLaXuLIUZkM+A2N4Pi7i 5zZXEBfABm2LWFvyGAs6ESh+D+Q2iR6T0r3e3S7jmFsrCwIgIWd2mANhB1gi0+78yzdfff6H3/1w 7omg0KBtZMrqu5R0wRlfnYSh5D5y3kZ3EaJ5kPpsfniYtIZ9bZyr+xN1c0isfNWiABwEyZuraadw MLw4KGLr5ebRJVGDdNeA5LBdrcbeEfDq0z/n6hNZJyWaRRonT2xzo6AcIm4YTpB7MbIEXXXiV25U ybqfLYcPUQzW7A9rFERJBDBcuehHze9mfQd/urqnANLMVAXMQumDhem/V1Jk0kuQE1+u7GerlXis TDGDHY3LjFw1DXtUfrrD64pEp4j07DL4Mzeri5n6zD8I/d+YciNzU++u68bs7Vs8nOBOivAle07x 5rFmNiMFeW0Y0li1oyeMOa7iGUSnsFy+yCQd8pSCmOn8Um7TVpozdSADx5yJQqgxRY6bG/TzrLNb w7TdAnypo6tjwNakouPRE/b2wDZE3dfS0U95eyxkL5mrqF05zP+RSGkOYNRcSuv9dZm/cM65q4Du R3WdWZRRsI/HMiBBjRHkWCD4QSUcAwb8h14Ey0lAmVyBoYEfb2QDg0IJsfkMvoNuwXtfc6emabUm sByaroJC0gp/kIg2G89w+Gl1va/Za05/aztujQJ2yl8v45mGkwSHhpYv+yz7NDoi+GpkXX1W23qv cCciWGkqRIIDOxWtWgJSxL/RAxVhh2gEpqqfYkZqV21KvbN6xus2xDTZgdApyU7iIEsYDCE50dKw WJNE523H25d5FeD5ESG2lq4R7j+4pXu6RCU/qZmTalNGQ7U+z7xBBHMDJcSzXhcL5hCuAjecZ7oX rqCsoV1PZgwGVpAAPFfefFr2wEiihwoQBFHyAvKGh5pCiI4E6xvKs5w4YeQJXKXAFQLp4pS0JDdD gBeGhD6gc/sfS+os+70f2FD/hCeBrOl7zBUmUd80E/saTa16k0Nj+ms1W3ISg4EvoOzWk8DhlxEL wX/BXAC/UYtCK9KIa532hWgQFQE8KXE0nO1lFKDpCIF0aDpV6CzOvRPlddBdZF0Jdy3WMeF3g6Kn q5z/movSYmO6gvtj2uNMjXQXx4oid3qYIQ0B2Fb6VjWZVtcmSAe7NlbnA4VbshEQ+R8oR4c3guvR dOFO7UOwfwBP0Uh0PGy9tKTt3Xv9rrK/aF171hixQP3pJTd3+/anQQIbfCv5xnD9FyeQZph00foP d7pfwZZYnser1LcW/RFmR0+WRtdNf9DTIa1f/rGXqMefMrkltYP7rxXYTmd+IvFbCCCuM2rdd7se R3CmuUgiCWUBsO4pf6XQZmeS5IvO8iqfJVgVOPtaZPF0RBu5riz2/eiEwFZra/f3yRNTHSUC6EoL kwWUzbCs2/o2o2u7vnJSk3bvQrXhnoONFJiktVILtwUhTQDOcl3aGlUlbibbmhSyZQtX1y3nlgAu /tDUl+vL3UPKEuKhxKInWWuTGySRv0DT3voZA5xp4VeOeTzR01eznstl9mIhTuV+7J1i0EGpler8 NPZe1TW/xGuBdCsfU22RqcS6j7TxakHA/6Fvxsc0wT82u8Dpknxl4BqjI3oPmiHKAma9sHmpQHWg JOykk3Z1Fbs3w3fTmCPlUw1vnTon8ouOqIBXRAzQxP3aXYqukfAONZlbdRgxz6mce+8Mc/Xe6Mac 7VQpeKM01s7t7rI2IupbgFBqjgd1GTp1ar8S9wlC4VswJgqxINQsgg8QPNAcPTyvzF54l1W3CKIf JUZ44rAESGuPADRsNIj8VkYpH0GGeTWr+4ocP4y4iwUn+HOyyDCNOilTJrT9zUNKac1PpQXznH1m AFm8GP1s7wIFCU4YIBoMFhA/5NzbfiCroIyRDhnE31weFjqf+mRmAw/OIsjCqjLBjo/7d3vQaZBu wrvy9qyf4uzeeMTeb3/8T3/zN39zeAAY7O6G9OfHrtq9L3/87/+nv/kb2IKU05fRdsmDpiVcr+6m KdfbWbu+Yjs7LPUOndlsqt7PzeX3BbyjEAZSr5te1A2Y/7Y56uPxz7KRTOJG2DZ7PkcOYESaQI6A 2gHGhITWrxluGJwDLJyQTg1ZCnQZDINQoKrbUvYj/r1uCY0cAoFoB/123VYb7HFO27wf2O92fQ89 rcp2+fLVP4bOF+4tZvmVH4E3S3Pcsx+MkZ9y9c1MffP8H0OAArh2SbfjcsVilpPAWOFKzyULihf7 TzNNw4H5XqRT0kEFZ5jh0H0NWFX+10WGD2KEdRgkqNfa7q6EiIc8NZwzztqIdbh27HZQzcC+Nwsd BT1FFjHrqaFGcJIjcnUljSx67E7ai1o2s+qibOmBzuGwdBCz2vYnddKvoO88BWtxdM3IeoVrjk/n 5Cqj1jtaxVTqeiiEyV5lH6MFgz7L6DsfHWKPDBwfExeYA+vlO6y6cq+X4QmLPYbgfKw3G8MzsiIJ BzVpuQ+jSLxBwCoaORWhA9ErFwEX6ebQxa/hWWPe8TxuhqATAs0Amz/UEGc+eQj3Jn3x2jCMSUxg NQCr6jUyOnzUEygKGcSyr3/I2qo7ri0anOHxyDWZ4pQuIUppX456bcKadIen1NJX2Jubuu0+xwQ3 RGkd0fVQ6LHsD4Y4P6fCs0193COJT103zuQPXac5QAGEUxAriD2BcDCywRbQeOqrke8DfbydSY6s WX01W8+oik/w1ph19QyP2MzUMVPnRFAXOZ2pRZMwlLftyKZA3SIEDtylpRcQ6a4udRXAPdtCyCHi chwPZbMBED833q9Av+HNhWG9DHd5We2q7iFwXKZbzfkoydJyb1ClhsOce6iiT+jC1NlPwYUYttut GR7hbfKsVB6Ax+oE4ogGIuLa4Wt1QCjnFn+hnpf7bbI807A/4jyX2y94x7zBfWkqgwML+fBMew6O P136sfsfl7mASaVVjS4+2jTLwOsQ3/H2FOJt6zBP7N9uCl1WxrAN/upZVFH6Inc9kb6ZI2A2VIdz c3TH9PNrMw0DhxO5QtqpSKRaJPr0wO1b2Euw9+oashD6G+pRhgp/t6Vh97bm94v5Cz12OAW56yS5 TUzntkJX1TRiy7hOYsv4x6lskX/nxlwF+L/hJWJ4hPsD+HfmqbzfPpMbcRf2wvff6/v5485X/ymi 4eBMqjNizxXE7/jT1tcdtW8+6vjgNCHRghbD/X3KEfJrcBPjliD0bR6iHJ3lL/ggvb/68X8gIQmk w/fXP/6/5hcLEe1DO6pgZJQmC+S4yWoFeunVasLmRSpJsiVFVaFjU9XlFkis2oODk1OwudqL8EP2 jzkTfPTJOYZnYZnRE6LHQO8///Ytr+6hrlBDVpLafIKRkhMV9TDC219WZ354GL2/sXIhujWQ6tEU fV/9+H//j/7oZXij0W/JofNzKSwgq8rXk/9t536h0QidreB6XqPiGLUlT8jR0TAyCOjg0AsBIZaU oYDy2ZUN+fjQ51ULJtsDW+BXBHG8guyR6z1uklz97SgaEjQqjHnHVSHaUd/AO8hpDvrc8vay3EL0 qSG3hMyOF3q7WR8A0PbG8LsfKCQWgmzZugj3eKk0PIvsp/2fC/Ofn8kesP+3OfEPZKrq7mrGyu0c Di8BNu3JeKf6iIZynbYdxGWLLqwLWj+D8n4NPEOb5XOEq1p9gSlhCwKvWll9sNma3C/MOoJ6LFcL yt/wTLXh3D/bg5lKCwIugPeQ/ge+o5NatebDB2AfQBHc+rdEs75bCfS9XjgKa5kyTPvkp/1kymwK LYJbGEpkAJoD2jlmxmm+/41CISV3jG3p7MX5uR3ejrww5NXLxbmnvdl5uS7+PEG3G//hz6mH/xbm xPDS9e2GvHKpI5AKxlz6k5/MyCGKcjTyvD+p0IJRdGyumxfq9wZzQ8sjjYXfM1SCuPdGGwnNUjP0 L+H7aRqcwNRn2eQU6FsofodHaBKnxbGTZWRGGnfgiKL7AnP1MvlWqnmRimGQl2aKYZYnpt+fYIOU 32f2Eu9Hxv+HGdMLl5qzn8M5YzqWKpgYcmyWtcOIX9EQzih3kJkDnATp6BAYcE+X/m0yPEVmbtzU RHMitboSS1kSvnjhEFOOEF5Oy577l0WevGf6+YxP0M/djTH5+Tz5UZCEtj0hplXlr4LAZww+eXGe 9JLWMRDmKi3vF4/4OLtvB9sdf3Z22dTvyr31YT7PniK2/dMX99vXydyfbP6GvpqpwGmHrJ/V1o5g MFJAhYh/BZbOHFgVTCuPv8LkRemZk2DzK6ro6rjb0bOUuwOXfjTQJNlU1CTHp0OqKYnHzq/mkqrF sj9BVo/Emr4FJUtPDqqo1W/6tCnDJnnXaxdZvy1tbP08ldTJbTk018zffPP7N9/8MLAIyb5xXlYw yiJcZb3ZHJtsS8K/8GJNSTqIgniDNCzIpl7ZbDSINtoBuzD+zMiSr8dR8Ab1anDTq9Z5TooMEPgR +XoF0YKJxeu5d/RRcgn4tiWltil14ozX4xTqk3j3tz2Vc3heLi0VhtbBMM2hMewd2HgoZfrrLP8U fB2pmohikSwAYkc2Fs6a2SY3GytQHJkC8E+4RH6uM3KUf/h0rCQRNJtYOWBlTwJqo4j1t1WCVi1o OD0qM/JXRfb35KMMrw1b18GUejDTfzIdG0+nw/1Al/zhfqjRqKf+lsG+jt7/CcUeNqfOIb0UGZve v/vxv/tPaA7LeCS4BwrKQHVbtu36GjhbAKygvDPKRDUnbtYJSr5EyL/qFuMfSGphmK/1dlujqJAj MJzccddNfTxQBHRLUNH4BHKtXR6vqW2+q/HF3NUzmc14AIALg6LCcowZgFadOR1j3+0cRrccM4Mu eYV21aWdBAzcl9m3Z0Ji96lxNYrx7AYSgc1mUPE43QFI6dwtx1Qi0RtzoO+8acdO+DZB6EtfHyaz gxo6MS+2VUYiwt/o1o7eaJEvPkAqflg3yzGQr3H0mjparpvdw2xXr7eMhMvI3TmKQ7M1SSTTXuiF H4z096GuthlUgd7xgoZvdgqoXkGYv9jXiwsGgWPBqqc6KLmtwVmnu/AXyNsdCLnCW6jI5MFMnoR1 96wgzh3DGqRnB6tFGIhqyzAfkNYoU9jymKOsNX0t+jqL+/3kTsEC4xcndhE/t8mm7NnGKvwkWnvI Vge9xnfzXX09mWNSEg8qHlIhUGxMow/55hbTLK7wNIuysD52mxq9JtHzhUV/TgvDL+Hgc6hb7twM CEye5miO/dGuXOgaU7eU8GB9iT43+TjovIJcAMYOPBtycs6Z3CkZgJta4XeYwtKwbu7LOWKG5GOm FS2Pd/YUdVr4T7xVoSs39d68/Wm/udsu4V/M0wJ/AGBQwLry/K5WcsGsCrwl1G+v/HjOaQghhavh k4rodppO/S9qdOYwfQHNiAy5bqprFBCi2fBR/A1bs+J9k/OEKHW0aRlmvWlkquAf2GJqPbyNZjgk mAcAayJ/rFGYiwA0NHpzHfcuEYGXgkDBHtBziCOyK6ml1GiZ54BGrBWnqYHUXXnCMEaBh1zQkA8t wO+RcmD2CJhebLDJydFplDpXqF0Nx+4fE15/dVDitCCy0cK0IPHgUZNYyX63dyVseLorIV4J2JnU JOTJHa32GW0w5KNQiU2/uTCGyvJY4ywq8DZGPRetT1+Z5CDxI8LwmqZDPVH/4U8zkNVoX21rlStD Tau55qF8NBr3md7biU5QiEVQDTXf3dH6VvVcUnj+kfbRlN/zMGVLMqdlxsF/sVYZq57aj1SKR/8X 5L1sy0OejZfAADElvyJAla7DcFr/u/EZbYRzTIlHE9hyEAdBdPnEU/CeTOn/2tX3+C/6R843V9TS Yhz2bBQC4AbDBY1IgA8CAzZs7gMEKjsWKfEdWsZ85D8wb5sP00E/+Aac4DD7phsbeCkTSl2WP22n iFNH3pzwhVt2zmo8zrKns1e/biWXqPmamPQ48SaqpxbmF+gZ7qptd3POU2JnKPunnnU0yxgsF2bi K5UsJRkFoZvgWSjJbPn5o9/bZAphBS5zml9DDnt97zu9OF9yJFt1s9pW6I0qIJ7wM9hIIsLKp1Nu CJX962YPVbu94t93Ky6gdoztH79aSH5r/l1E+VIZ5nk0El5wJdvfMONYIp94GW4Al30ibvfMZduU NMA9T8ydfm69d3sp5sI3CNDO9ehtetCcZ2eLQKdX9WiA6Hpq/jEe0K6ud23mkvTYvD5jP/EPVF9E 6X9iem3uK+X+LHmOJnJzTWC6D/Ii0MuBf2eJdgFz4GasM6Tlgubnh6YGm+6KTiA+4nksoN1pv0mD k4hzA37QPOYz1le36aC5Jg11XYO1emh10hwv7nDvsRJr+hbjiN5+jks1fxlRd4bDf/SK9nnOqcJq wSQpH3VZ8xcp+xAHJHIJbiWagxMGS0hOqa0mznDprY4uzpwijZ3cIih1vUkTUcaK84w3ZwJtCy3I flK2E3R4Dep33D4f3Jl4abywycoZZWqa2qWj97sf/xelI5Js1+9vfyy/Jg2RPMpoG7PoTrlgdztM toZMflODg9l8NBKGcZ1d1/VWVLDImxmRETGFCDXxw7pBJCNXMciU7OCc1Co5bZOy1ZOXxF+gaBrH QwS2Rv9ASOjlmEAhd/3KmA+kZTA7+tIIFUozg65+sW6FxHgurgT5FwVL7dUekJjaMqMyVfcQaBC8 5t9T8++PVdmd2jgWTjW9LT+m6UYrLjyVhdVW0IRCvjClkloyVo7ooPj1KKUnM/SiWVN6v/Z4a1iP BxTEQEHqWIPLhwzryPKrqeE+wH8hFMzH+Zsp2g2KLG+nkOME3Rzy++kVf5H/OIVAMVNdfjcVLmDe v+47mnjoJQpYbe9s+Aoc98GAFkfNAJVFxhmo4uV6867Fy2x9yZ4kXMl0oLMzWohTF6x/rUyNiaXK t4ZQlRvKhQyavVkzHehMdzlRVWLCh/GwDsz2r7vk4raDEwAHj1Vom5saguCWZ/ze8Ff1HjWCZlZh JrLJnh4bsoi/1nChTM6H1H0w+YbsVXtMsl1mOdT9HCp+jrU+h8qeU03P9/XgigApxUppH8HPGf/+ d9NRUmzS5gjwIQ/+/mHRp0IW05QY7Oum3tWNXjN8cOqaceHTV+yhbN36YOG+VcGq3X1VH7uDGWxu KjDT/xw+xXGNknktPbYs0qcAec5my+AFkk6+VVETAte0iODf8SOrkGKtg+nWdNSrYrNpoaXGAjzc qEZ5NJn+5cwippB7YHVTtwZw8cCvgKGXUQoNtYyBslDPAKkaViz1q7bPkWMGePdhFRgzEhD+RYu0 oGLjwnZ4aoUfatUM1F8/+xhYP3a9Mr/E+9KfHyosUyrFlPbM+TXgaV/l4y/ffPvdmy8+/+HNlwum cBizBdDShjcSAptxA8HRAKZv6VRQHrMct25hdEixghn9uBB7i42LFKqrlF/KX0k7uoVf5MKgsqDr cNwHUmln9hkUHicALoMK7+lSPa3C+7FaQLrH0+uF7xx4ln3kpzjA5KTg8pYqIIdIJTB1vUlhEeqe wlc+6I+8Tcl+6KRqRNhjywfb6W7p95zYDSXglB3Rk/F87DSQXJjXKFW6jUvT/KcKfzUeeZiSWBzd HAA3FtxTg1Vzn16N49HP2ZRTcLkieD4/grUot175fyTGiihlr8PTBoNU2TzqUoYhK3LVCvB3Emoc ATeXWEPgNs/G1qXU678O0jEH+OGtAht3P6x7V3gBDAyMLgYkCOnus4mM/ghcyYUrF/f95KUV4JSj /hjUEPKRq+X1klXdXmmKYz+1NDA/JBCiiiD8JvxktT/ecoK6Emb7xSioslt3Ae6zPG8g2XZk1vBo Keqjk9pZtu65CznoFirUyWe+4YQVSfU61DONYGz9dSCmBBzpgZFJZb/p7gDBHhSpKJ2C5vDkOg1X dEKVyBUGW4s0pnZ5Y0B5nwSn7toIhd82GPfChTGYR1AHHwFTvTbOUSLqP0/4zpgsssk9sulE8OB3 O/kZ49GhLFcQWkuE6ofjcJ0gJoVGL0ZnP+mXeajT5XjHwE/5TryRpMihK3mxGE89P0nYj1SHIOl6 K5BYxHCF6A9/H3u9klMxvzQnsDEcMRjDU1AXdnWUKSB6RxYjbuEZ8IDTUU8hmKpwass9ZHhdkSsH T6316wAxfjkeK9jmRbzjveH/aslfLz5uJOEkUiVDIw7TxEEEFPR3MfQRlkihUPd2ZPZKAezTXLGL fxjdk5yQv3AaCG3CWzF3J4FGG8ZCBzeKAtTWxKBouAnscCgRU7JSgahVzsMgAN13aNFKhBX4ETi2 ZMHAHai12BmBItyvwSwndrO1oyWH1JR6nnrHw10EX1YcQN/sjX9qxuxVPjCDYJ2jBs1fRdZVHbMK /Qv0+DipUqku2XpLOWO5bS5nvlmixRf2eWpfxBWbcq5StR3ASbS3GiznSkQ5bcWHCRecKyzvN6Af DzKcWWeAYMNIaSHXYPdPHCktyr795oc3333z+e/efPfd7797ncnaRXfPy6i7u/qaNYgeQ+s4x4i5 VX0R3aMi8p2XlFEMkaBA1KkZxba59LnsHBpfhj1Yqs48Cp3OnV2GHDn3Peq6WCb4d7yebHB0NkO5 L8jWsXiEG0rqN5T24tvf/eGf336jTJLWZssGmzC/LOBVo2M4ZGoB9K0Hw7TAGMQ1HA2dzwUclwwQ fhWMkwoAluAp1B33667cPWSb9YHM4JgOhRRUEBHU+/n1urnc+eXNLNyVqHYINungBkbFSzjz29IU Q+67JyN0es9N3HcT3HUetGjcTHPcy0lAJiVgtWTreTlliIxR0DViG8DNBW5IoIIBVbfNo6k+eglx hmXLOAmM8kNO2JnpBGy/aDOFckvyxiHaJB3FCZXef2K73zf/Pi9EFH88DmKrAokrEFhaJY0GPGZf qz5zCzVQqwOLQ6yyTfSj9BSs/yArpGjLOGoq4IrBhjd/RPuxNP8oNeC6cxqDu7rZUlabRzYhfgV7 j8mLVyXfJdDuqlnvE2IVMB2szQCPa/gJTYfQKwK3l7E5yD/6Q/m8ZU2d/PvZMkQ44X44uPoDarq3 5YQg4gc3xeB6m6rm9nzhME8OFXE8Svhh/BHm/LMZpWECCwJLT2gk6a2VEeHnCV0ivVSkHvPovFT5 54nZwuV+soDF/jmtmYTKQoVYT2UNCJyPVBVp4nrqeijBQT5VXT+F0Wv4CfxIU5qBTTS4YVJkidbI MYRRpFOwQ4bKD2yxXh414VUxPJ4UZ332tAVjw9NMJnB+bW7fu/XDXLMnPV8/NgNhYwlO8GTBzxqh UAUm/HYsHAX6FUsZ0maq10sNzu4vej6WxgwbM5/PM8M1XtY78Vfr6dnwvdCvaO4n3mPk3cchAYeK R+EZSyq8B6oWA8Zg5RYk6x4FhXun/J9L0jGPtN0XGk5RQWElFJnPlgpgP7oP7DoGV80QKYduCSWY vJkkOA2+abkTuSe3em9UjsUIcC7NX8u++iy8vcSz0S4YIWcq3DNaHNDWTfAlcYvqmqal6vlElH7B R5I6Mcmojd0yjB9BHVCl4TSMfRH+GcejRsuLyZ5p/3jWExp9ohkwa2XPs6dbLgKUif7yJj61w4Pv ZWebCvjPU3dXes78JowQnNpXzkPeIxX9cxtKHkQc+4kexH1WVw/kf5cChQp2sCJVyXiRoCFGGdWC h2RTCXUPuijCgy0JOSxA1tFU2VlUFkPMoJoTdrg2zDg5MlGbLKWMk3PsnC4fD/g5W3yqDwvLwBKR CoHzs1n2LYYliRisQ1aLzHpjJu5iRPCZHB4ODyvdZngxP9bfqIKg09Jx2JZnUHiG7rvn2FuuvK+m T8/9wePWNkPGSugP9oglFcBDGG0VOsNOBzj619mLDG3zEdG0vhgeLL5Og+l/ANNqNm95We0l59Ei OR8wBJuGHpGXIDsruH9NR4Oyv+ct+rjMxt7KiZCmpfqSk35tq2bp2SCC5swRhvksA/daUc9d7QDg fI+Uop3+Emrid1qbV/X1tq/Y8jf2KDdPAr8OCKf9JjD6aCOLX0E81Wdj/mpBYVPcEPvn+hXb14rH +IVO+49ES+3i3BQf45iPwJKUCiNypk/x8/DcC4jngzju4eq5bvjn7B8WcQ6NnbB2ccZe3yFavMKZ 3AHlJZq0m0baW3aL7r+rVHbp1D3Sa6+F741Y95Ay3KBKy/IXcg9i1fOAifQUV45TYmvpdECix2vn VxSuJaPBrNMq+CbcCqDxETPqSa2xmmje1eKzlksHEgkvRWGeePjiL7lsn3DqG1i7dXPtZ7/RyxOY Hp8kFf94S6Pw9lQ0x3n17KWtfjr1UIVTS5nSrD4BV0vyHgWoSZJHMOcaJsImWPNMdo7iFRFnvlu/ A/g4BKMEPNYPhFL8lsUVU9O7deYl2b4sN2vQGRtSWzaZjWKGKq5rjq/CPN7Vlv37b8FP1EjNv1Q8 eKz47GUqrcRxH7p86B05kO4toBuYeMFTmE4WC3O1vox0pn7bZ5JXm37ijqcIihfA+b9MdosK4Bd4 YDAqNucaOLDkMeUF7banQKe2Ki4QK5meolk5dX7Et0nN0HBBnkW2q4LiOZ8uFkBKFovx9IRRhZah FIMsmG4qwBIRgPzb+pExAlBfuV25UyPDhHC6zQ0CUwKGF2R+AG/IDC5dHJ9XDWW4wy4lFZLc2WXc 3tnCIYL1YFNfNuX6XUynewDRCAgSYfvixlxbixQ8nYaVM18ltHnI/OzmdGTMROfThJfmEwmli/K9 eKukgOSymTlm2ScQvjoePbrhmROnimDD76Yp8U7jTaRFPO9uBkRSsjmog5fCoVDPYwiKRIfHgW+I NANLBKktzc3wqsh+nWJjOWhlRdJ/ylFDSsjFPFRG7KtJh4+Yr5cbecXf56FbOXLwfYPDhDgJ3oUZ 73eciKWSRCxBp1zmgqjk6ra8rUfJESrz5DRdArmSPJYHpJWV65D1E0DpNhT9091CNF78YE4OcJSo FiE80hpTHcUfK3OtHI19mfS0Opl+5Ew7/qO3UNAXdoCwdodHVoW0CPzRHLFtm3V7M086zyo1B/Cb nvBp5mAcJe0Zw9ExxU5hH2ygTEynpHuPMp/p6zMeXbIiN9eerca3aEv2J0Hc29YA2zENwi/eGfkx jzw+QpsQj39zB4ngdxhNtKKPkveqmTZqDZlJRL009J9ErqgbQXuEITDDlMpUNCF2gbyHL8UOfZbg AXaGyYIKAX9R+IbJHDw5DRM2pQSYEI3E7zLzjjKaN+vbtl9HeWYlt5TQ4PlAPBHembXpAKds+GLK mwOmfkkRas5kts7Gz8ezPUIiY047dLWMnTdDsQNB1/Uy+kzSGC3uaEYGdr61Lay7MB8aijkJ6z6m Ase2XdU//QQVP08JztAl1BJ9xlqikx1D40NBwxufyT4/H4fSMrYGrqE+3DxfXiCpqbMB9vkkMSQD n7QSEr/0USJHBGsQTe0GKjg4PiznqWHH5P7zG39ASA56hxJBckqKAhrbHJxLfMoSJcTpS1bYi/jZ 08T0bPF3gXRzQgt6MngpnzD6NN2zkP2AYpAUn6XKecFYIvCqHHYJbZM1ugXKBRJ6zs6ng44S93B5 HraXiBGSUkRY5dB9rOJRXo4hJ9Xjessu6+O78MilvfNgHM4tL2msj4FFeuSiXuOB+PfxGMax2HAH 09vfUMDW/vEpoMxYNBMMnXnMF/Burp0Y74Qd0BqRiKHt8272XfoosBejkPZ1lEIOt5nMudp4VjOV mnIu9Mtn/KvP3/7uD9+9+T4x1awo621ieJQgecEi9ETIeQ4iHjXyXJ4eV5qfDsvLgM/SYkjQT2kX 520V8n/xBjSil6nOCiVYdbR7WGD6q+4dMlD/dbYOOg0PbBxHPM64Hwl5/pcsStI3CAL8+rS3lm0a 2Bc0nEzbzimyt99NCmMKKStkdzyMF4/Xvu7I1w6UkadXL455J7ZgXXgHGjl5T5+wn8O3KXbiUf05 3cQbUQ8SxBFRnzn77bc98SE4gNm4kO+j3c7Vnc1ASQYT+lNqKh2ukpRfzF6eD4SkWJyk6GSTAB9Z /ZHPWG0FAdezw0s2uchc7xh2Tnuej+lCsM6b7G7i9AqxfkrClbN7/shd5Mya+yvBSenU9Y9ptWP+ RaU9x8T2qaTC1mjl5Uk6rIlkBewTtxxXRo0tMPOy56gu1A9Sl2JSmNtD90A5ljjHOaj9o45RtqWA wcGvXELeoP0PKVcTOxZrmnu6FYYDZE7z0ZQSVMVAeNZohxVE/g1PUf32dP4KQ1cgrxPVil4r4XZS cFbKQxP8LiaLzHfQNEMRpsJfZUzYQqTafxFY7QNvUqzekOBkY/F9HHu2JisY8lCIfI5TFxQH24Q+ j3F1hiTMXi4eCzRIhxTFSr34PteRBUPzmrBdv0vHQZvtFHkawwEZkBnGs3e0K98FLinpFhAC8f7Q hE3cDjZxmz1toI3biAbvFo/eQchUmMODDu6anF0+cLXplBi+l92Znu1zc/TGyjLu+4WyI2GzIkBj Nh/mH3TYOhz7ON76Awdaayed3jzg5hzP8X/k8AMD+aBzeOc/PBxIgi1UnuhEml/D63zgblvnEoHe F8lz5+0839cz36EXBLmyT2M0jgfttnKf4KUow/vDwNmmEvej0fv9jyPOTnZ/u7su9+/rH/+f/5Wy VXMICzRJ2GPIbpEDcFOBKgl+m8/w2U1n/jBjP24wyGhkdgPCAGYtptPMaPEk3/l8NMo30+ymNm2a 26Qp35W7Qn4a5ui2bMyBPt5n5XGevXrx4n/TuGzoCdaUo96MCJ8WL1QOm2PeJlbJvd5XIG/CzHMU Z+ABpdRFKPuv+IsYY4/rvp+rMjGeLmyQe52irreT0jW+c/in2dT8l4V9+AYgOg/rTfl12a3xUY6Y rhr+gf2/LAJEoCNhLxlIdEWp94Lgfkqm6KtyAvcXJtnwue1QqhKdZd0WpATjiN1nhKhmvemUyAIg QYReS9zXih8o/EKAxOVSKpENxdeAiZHZHy7z0WPD3sH8+f4BckutDDNZbd49UO5Cv3b76dnEHBYo gYkGPV8lSGm/RHxa1kLlbqCSQQhA06UqbZLqlFmHGfNdnFrSPLMgIetrpDECOEWJoaASL89kD3JI Im7eMd2YxnO1mh8PW3B4kZD0wXxSySopK6npaZSO1A9ypxwwtC74N47DBcOrlt2RDO5+ndZVjhxZ hJecygyWt8HkMKqaUURC2NuGPn3Vr4D8HkniH+ir/wNSBJr9JvezVDClVIK5bxkVygC2YGuPUIOk JFXhCNkvhdeIN9RcUm1GN+FnTxs4KEyss6eY6EqcQirmnUyz7vAuUyRoYp9NzIamyorMbOM/Y4sT dYwNO4mR5eoF9xIYTbML5IU+ZuYVY879bGF9/sVcQ7C/zf/rK+AjFwhq6VsXTITUdCi/cBTDR6zU E0juSMD1hx0YE/De3MtE8SjgYW5nj/upZ8V0l0dq96ebFx1xqOYYnSU3XX5mrrGXU8eLOHZtsi7W l5dNsd409f7htlhvt+YqbwszAbuyK9ZNuS4ui8ttXVxW18WluaHfFS6d4ORyV2/evT/WXVlc1tuH wtRkyGlX7wsIPQY97aYEu2uxMcxkgUreTb3TNZifiPpnnt9C4rBiuy22hjPYXu0L8E/dVh+KrfnZ FeVtgYlD9ddXwNVAktMrI/IX6FGOOdPg0c3L4uZVcfNpcfPr4ubvipu/L0B5VcBE6yqqosJPiur2 uqj2h2NXQJKYd5fbYre+ND3ZldewF3ZVgaPfoc/rta7idn0oDFv+/liWhRnDsQCswgIz1cBo97WZ ln1Nnd/X1EH9/b5uN0116Ao+MOYbw+zTtLC/9qE4NGXxvmgLLqo+J6a6aCHBagE5QwvwNnpXwj+1 6SkqKIv2eGn+/1Cg87b+vMOV67YFYBXggndXdd0V3Y35H8wYwSt0TdF1xbE47or724O3CdbmQMJ/ aBFwMm+aAljcbXlfoJW1aNfmow/rhr6zqUeLyRRu1HtBj6fD8D30+OSrKcEwG66NtBV34g8X88z3 5nTcO3PxCrEwJylFm75uoWaXW7FZ3/ndNDzrn44tJIG/rO8pnBzyvYFGCo3klqMjqH4qwQl6SazZ b3ZHyI1rNr+pdvcgaQsoHH8g/7ep2XQldDWhp8RAmj+k48n7KByJIWibo2G0P5SU1RbgLmuCCpFx zIcykmNJS3xfFACc734omopi3yLh1wGBu/BvgCaFidJjoC7sJMZ3/fnnjLI5Q9o5cj6ur2Q4dRAo Y33K6I8Iucq+t3/7Rch5NlCZiQcxDxGuYvcDdGXwi1ViQK9Bw2MYVpW13l4w5Oih5geWBvKKrTsz D02Gmei25aSl0/McjmJLDvB2dRzHiRGqliPoNytj+4aQ3dRbq4iAeT8z1ZyHFmXJuJ4AkjxeMpuP DCnk3WvqkF+O27v2Dp1UYvmXIV2gqufR/Jaxd2TaSpWYjNWKjkvCG85OE6Red1+OErWhJwfTvid4 zgUd98pQc8T8vTECzc4ssxkM6n624Mf9Yc2HAh27KdUZTNGNWXlwvsGqgKFDPlD1lI4pPeDZ9amG igwFgpAK88kpS3QuPBYU01ZYoIqpqv2amTR5iD1tuk+c/tbwofBcBDt95pOE4Iw/gHV46SmzzY2J Tr3mbUKmoaMHZVTngMVkfKL1dbJv8Hywb9EZM18w9ZBdxbTkTBs4HkmO6lUSA+upuYAO+nNhnrCg IAeuA/nLSq042IT8ME3hhTGdFHwLOiXABaCilpua9seKQz6nZ4Z7nmQTcOf1q50GYn8awo678Gyp KXtfg6alz8Af+LVpzsg63MHCCZioGmhx2qYJr1deK1GyQrGYEWENRI+SlXba/UDliaTV/gieywBk gocmZpaemJjoQU0sY3O9z1LTknShNGsOakAjP9T7nmVPrsRzXghpu5iejPCgq3ntpsRVZWdHnWg1 ltTBfmKVnqUq6s69eYRpc0DGwnMz99U0UmAO8RlqDROuSZJCSj5JecZJbHKzsp2xjbJqbxQhmbTD V+DO4RUoBctO8JXEaQEFCDoGJ2olgn7S9MLvtl8L+Qq9DyerUA0pMNpCoXQ1o1TUn3VAnSRTouhI v8iQ7KvmsekC7rNEPaYUEP4ldZBvs1MgZuS74BbFaqZJV9NJ9rRdjp+244lSymA1as7tQqU2M3Hz WJldFrxvDW9VdTZ/MVQA4N0e3xhdW9gMKBaIOszxt9UEfoy3IXdJHYdEgD/Uzift7P4ZgLKaa+KB 5Twyh0uHRNo7T7YCVwsWpbkECmEe/ZO5bmgH25bM945Z0tTMTm2wic10gZiXw90H0tzUiHNZ/aFs mmprKC32kXnYstVzqxWRTkDwWq+0y/e/f9OE1qt0aSINpkRE0y5+TzOi1UuZ0i9FWz6fXDaoX0H1 AikEQDNy05CqBBUrqEaYJNn0CellULUw0boDjr6nKfqI7qwz0HplrPXKLjNRX2SX2zq7rK6NZJCB zgrRE7PtFXgvZFgg0cNJlZnBZdjJ7N3lNkPFUfY+azNQe2SkoMlQQZOBgiYjBU2yLlLawJqBRjwT pUzWddkRchhNZPhm207P/yKai1YfYu3+AppLZZPI1wmnNdnwqOxX202U/sEovIY/7kxyS8LiWvM+ fvgxJ6ynIvrKqoJWRM574Ncj2FQsDJoKb8IMOQK6tIA//hb0qv80mRbw4zP7dGefvbbPrvFZWNPf 2vdmE/JH48nYPjzUbfRZoFEBHOvyatWU9+gCP9/Ut4dqB5zW+L/Kva/Gw85I0yBGCBRsIsrfgtKi xxJDlZxhkTkly3rhkeIV5AhwCi/SoQW3nBFdZjy7IANT9nBf6/bI9cb1OqNrLi2FVxsTxy9L+G/i euutyYhYx+5q9o8Ta4Ge8DxNpsmpcQsxN5QhtzFaOLVuKkYju7F4PxrG8/3hx/9ZJV0jd5L373/8 +f+ilGugeZfoHU4iQrARM8SikAzxklicM6bYeWQT/bq5xkxn1mR/syvvbdI0Sf9jHzwcSptSTXze Rirx2pPsy99/M+kyLzEbgpfa2PIKdKtH0HVxoc3DxvTX0M8jgJh6vgN1O8JYHJ4E+QIzwIEBmXQv yPciPs6hhlB5s+ngDMOEeJ+bOYTk5lTHtwj48DVBY4C5h5tAR8HjYfSECcQXPIdv8bOvyJ82f4M7 ycE6JNSoFJEShxLaT+eDH4TKSkIm1+DudPiouItB5CR3mAEaQxAJCJrxLbTLhGIuIYaTEYcxiV1m yDyYZciPxGyqGW8fAk5tjvs5ne8FQCdAM4tMkpF6+9K8Ot6iRKzKW6yNIH8pu5yAaswwQ5CKaaZS hBKsboLRwLW2AVNzGVvsP2QzZQCcIUjq9CAn2zb3aqpdiZKLrwIk2W3JlEafFogbP1dZYPtSQqTy +mioG3vuJOdyKXsm/6Scx1uKWnPQ5POG0/iEaWZ1QXJwXgB2wI5UP5A21iZbz0vcdMkqeNf8ehSz /uLEEIcWJ3KTLyVHBJ81LrIgD/Nb0351We3ApdDZXcnjEYO7wD+t2rBGFiMRpaI/QIQJeYeEJxV2 PRJvgvzG/XzENC/46ANHqsAGGsE+gd1Fov+IdbySgRd8h2ncY9DwUq9clsjjfg8HibypDttLuEw6 bI7xncnTWKHKjbvbAyQsua335kZGOwEYP4DOZoL7hFnMeCPvASKDFJlA/K4NEUQro63vT9Ak+H1R uPquvs629Qb6oPyUR4xJUsLy89DE8MZaUtgcMhdkrOYfooiAkHgGF2KwIcgQLvm3olfWFVDqifaP bQAUaezbAYFml235/oiYJ4alQEqBs46mOEhEaVj/dXZlhnuTiTpAZTTmDpiF+xYX3rsDWNfjQyZZ kvEFkQrv7ZRhwFHjRsALv7Heg+TgtM+CTbMI8JqkIbqVuBTm8PYysXqF3ZIFRKyf1pu5hgIxv49P iYqZPz8A7oVLDaV0KkwjdSKdaVTLGXjMoTuPqgRV62FFOTpNFngDTGMs06i8qXj6mIcafLgWC61Z Abl7sJGFuLxifUpfIxMAfA+fCee4FG6b1GaO7xkLp9XGhrUQMivh4t+T6y9M6pvaGUmCi/xdPtzM 0vtFufuWbh74OrS0tG8XM2Rve3PsIJZAu1TCcgl5Tp0+71c/VyWsX7s8kz/PI2+0RP2Rd5qryP41 DREleeYjyIvaXPn7D5WR+Anr6tt//eHN9z+svnzz2z/8c6i7NHeNyyJlfvgv94bpIlFDZHZTxIgZ 8mJCIsc/Bg4OyXBfaokYju3xAFIA1SaVLeWPaSr4N7G4Lh6jbRMQI+YwAKcCOStMO6TNT2F4aqiL BOKe4GxtTdcqVEswqBbaTf08v3hLNg9XVQNHGq/dNe6JDNVecNwpGAgQOPCP9ri5cQkC/EgeRn0z 9WxuTIvNA10kpgFMcQp6H3P5Y2PP121WrpvdA+QRNiJ4WxlhZT6e/iWjACDS/6hBQFswhh1ekekh YDwwRwyLumSVjg3m0cJLShYyfvtybFOULF0WDznxmE3bcWD0m4GLUvICyq9WmMX5bOfE1/d60mDT fAVyftBDl8yZt1rvQYMIecWX2e9x1/8zZfneGJncSIwsT48LzgMewN5wfCV8knIgWbnmMZ2U/AhK HTm74DGGR4GRsao+dJeBV8gOM1dqj5ttxuXkqQ9dGnpQ9TAKC7PgpKFFKzW+nJvwDBqkBNKOzqYy ZE0x169NlR4sDWwMQJfLYVcgMzc1BwMq2HKnMlyluYtlWsDbBbtLUMJ5LklJiV1B1QMjeIKuVj3B jTibAW/NHlvqS+yra6PuwHuH3PwgwcoWP66bbYmMR1CLreYH0zW6ss0XlGSevXYRW2SfXVzYBMoX Fxl7rVinkFY7obfV9X6NIoT5dHF4WAChWFxwynpbjS3/ma9Emn8bFHx9kV0erUNbhoAJ7MCmc3gc wCfrQ8m99xzcYGIuLrgVnoOLi7leWo/M2Cr0SYp2Iq2h6LxxqfswKbCofUnV+0c72og9Z7vKdNZK Rom8bg4JhEju9zTRcddt2j6jYR8mXd2cbISEH4mPIqaPRutM4jbzNrtXQoZZ8LJEPXxkTyS2xhyt hApRny3McCvnCUlOgW6RtEUgdXFDJ4mppT4z0PACd62ywjOYDmwb3O0r7vXUbHh719Ex1vN1IUpK 09HLZt086Jef3XTdYfH8uRFsAekZpO153Vw/f/WcCz+Xr+fgQ/z6YqW/Xm+A6WnVqD9H/Zc3M/B1 5YaJcJjrD+tqhwbYms4BqxKCJKx8xD9UazNiPyLwm8+/fmPGfYfK0YsL/mkEtGN7NJf2A3iw2nou KbcM6uNMYaDNprCd2YLco+7XwD/YjxRFycezGSyVzbAOzZkf8/l82ndOg5vSkYs82F/qDkJRg21Y fpyIp4hdmZeg4NmVnVXIGoZFP/a7YRqkw6rBDeiJEjKCKnL/07SK3r6e4z/wfZufUeiX8wWCp9pq p5oP7ESPjhMYmlYeOnFAj/DrByJc36oWfNrWunmgn8+M8O2v13ma4A6SWt7hMbUCsglCCpbSF6dU PU8iOpvhCyl28wwHX/g86n4ONabRhZn6SMf7e4g+ItQOnC4kV3kaU2TtiuEG7ivGnfc6nH+yx43v oeau2xtDKd6RzpqXVriKrZEespz0ZHB8J8+VLJeelPyrt797s/r9d6sv334HDBTI4pNPJtO53TXL nk3EG9tWG5zMlSEp3kVBypWIS8TCfNiVi2NbBjFdDtWWrcl771MXZZb05hcPfcG2VzXFFx6X1dUX mZqnkAit3u0NE0OnOUmPTqMoWrEV0YPeaZ9HXcDGAVNY39mGkfeYZGCaCrSxsRTDusMUn+xu8b0T k+IrPGaPofCHdVPB3eXKQaMLbFrKSRl75Rv2bt3dgC7t4qKAu8UMydxBZkYuLuCapDcex429X1jf aN4koOIL+wwWKIhSBzbUXIHvj4aZLrcB+0zfm/7pMbTSP7MI5psPhruG23ZNkm/n4Ckdn8z3sFlv WAF0G4hY5C90mdc9NySrx3HaID6LVm0s8wTx9zBL8K/MUJQgmQU9iyidu11gN8C0RwL0we1F1v6c yUiv/QP//Q4UcltUDO/tJ1ZpDotAIhjLINXezD6gfjcS72KoMOzAfaeNfNJCn4yOuA8RvcFREUiH BteR+xlDxrecLzeSNznksw/3yX6fxvXj7ffUIv/n/leF7dz0cZRAKRothZ16eoyanNvqttq0eNb2 JUjThlc1+/hm/aHCPJ5Xlp7MiRuwS7cym2N1uz54fiiTat9NFmZhumKkvZJAibiAmXOPf2ZzSrlH BpYsvi1AHl+D4RGMv1W91epqynBPOsAf/vXbN6s/fv7dNzZnfG/QMMsMSTmk7cAYb8Z3i0EmHBwB ZIdgBNFVYJ/pezHBnEK9ph/4b5inB0QUkDCSGhpghvteAocslZKCF55MYu95OxUngDGiVoArPZvA r8l5KhBm8pQPPUKbQLk0r2MT56IOrheDb8JyibmKMnS6sNIQYINQS2MQ58AIfFlO+ivKNjfr/bWh B11tPs2FNJlDM+mHAPzqCGoKTi7cXwwRwXeGeO+WnyaV0+lIpUg3HYdqPKhJB5o6OTEIyqs2PvBP KPfvbXV907Epag2gRGRZXhtJt9ztCsavvVsbIom62I7VuAPOy6aThZfoHOPCQpcpHVUBQwSPwJu6 2pST9G55ZMf+go1FQahw81k7G4Q0WRlxiggRYo572swnw1VlX9UNsW7gIoKza/5Hla0JuQQB3Nrj 4bAzvEH2WH12T5teQD8f7UAusoW5Caboso1rgURsOoxyeeI2H97qbm9ZfUd5f0CPGBoB+VFhVg8w SxhBs+d7jCJTvBxaMDB6Koyr0VEP9oQIwAU/pI3VTs4N//ox+JD/Te65/2Z3TbiCwnrMhVs4M/+e J/I2oAobPVcgyzpMBpgtZq/VgxUT+2tM9Zu2CeCy9JHaR+KA+FvzTz8lf6IiIFBYKJlNhW7SCJhn XyUMLupuJ1nE9lRu219yLwjCILIZK9p2bU5Ln8xNFNtUrEHGMiQ9c8RMSVDYHMmzVwsFnz4Di/Fq ckoIVpJNSbfneClo8GUi0dYj0Y4BgI8nofSzHOBTY84h6ZgbUTrjeZuwQd8xn6TxGUCM0Rzhs3Ai /fiyqB5zTBAoB7IdaYW2WXvUzcY7TlhT2WCod0V+bhJBRMomiLcH8aAs5tkyvgYG3Y84DK09gRNV rPMZ/Pc8Ctz2I+JODAqKTofd2oqRxvEHfMzabrN+5hjKrN0utzyy2eyKFQ22/ZPwK7NM1/QJ/BWV T3QCKkhvJhI5nOgTUgFrgA3kHgsQgYpiEfEU2CSylEAxLrVguG4tT8SQo3DzWbsI5usir8VAe4rx 0hFZAQTBcg931zT7LEza8lEHdWw1AySk2st3kUjrQ86SgLQBF2wHScnM391dDcIFQIkZIROPO0ji pkI55D4x052PU84omgtFMMfEMhvPxshDwpOXGLI47k0q+FFEyo5fU6fHZ8GbCWHTIPfqDIAF75HO 7Ov9bAu6ZZicqUxJvxAVTVVKGBZiArN3StijnkkI9sS5VJP56q8ymcqs+DFzic77pLCazcAottvV d4R4KZP5F02jvS68WXwU1csQDoLHncg85JOYTLo1ipRL8PUziLJVZTCeErMNhZ9DCjogc6NTmQzd gisSNmDfRPWr7/EKC77EKyvRpyDREfKM096ekYrarxmxEx+vWW6L/sqtrjrsOd0siSbo47PZK8LA xqw1yKXu7tYPRMSycl8fr2+AUqMOJh/b5R9n01RXllLtYvbqPDW900mcXgVeWo2j8njo9aFMu+Sw M0TKXUrFXkeaMmsJXOoaUzrclKrNmmBCe1XKpWFInQgfgCabaQZMOVyX14G/EKi7GdIH/HAYkBQI 8NqjOSAJGtG7ugJNQ0WuMc4YX6IWAhDXWHS6KZGzm6tuT2Yzc68BqnCLEFXwa0Y/tXUL/PJb0fSh 5w0aCXXxDFLCFmgacXVi3PjId2MwnTFzs99+8gn2CIyRtxAhgaxntV/LyNh+NZe6krYNa/2zezax BKE6Vka/suosMdXhnB8hLx9D8Smq+VFr/dfrV5CrLfWV9qpLjCnyY3clYk9wx5uhqbSP+junPOZk jIinOJl51cIV1+SD1692k8fim3XLTjxyNs1WLJsP5XYciyUH5byZOL1z3/NQDDQpCqCuTTLiMNUK HB6sjlrWmJ4Pxdqp98pNMaAuyqqbqn+edCjlQZK3ps82gHECzi0tPzrh3ALac0PIO8svm/rwPRKb 5neGuPyLKfqVFIkM1oGpmk3ANvApYQReA3eToTCJiM8QSQcI7KwxFaucZ7FEgz9Eenh2/dBUrdr1 tgN8GO9kTp8cv3Rf4Y41/7o9PJR7w67PKp8c9xDicr3HjGt2TKBtmwxkjEE9PKDMG25vkk0o5Bk6 GCB12Eh5HLT2JxA0FfwovHShuOzdoUV2O9lfe2sP5KuIqP9V4E9HdsJtdXWFwh2BCppuNevs5uFw U+5Z/pxhlpX1wRzpTz6BCswF4FWxpqQN5I7Hojw5jOm6qCq89mD7kDeeU7rdrg+WBcQ3sPvMNXls 8CZE17TtlncfT5gejdQPI96AmR+FHnCla0oaHciB1scOKNy+tFmmSbFLIhZjZZlhI6IgXaLgh8d9 Zqc7JTKDLwBsH5E4X2GqkNYziCNZ4XhLqmjlwgHlYG4Cy3VtNgLCLaUXen5ihV5wCVWJE4B/coI/ ODOGv8SZcmYRORApczR9PvIBieyO39AlNlkJ1drGvZyEiH0ET5Q0fjcKZckxfNQHi/2R+VZUFuOh LInyOOxcPQabA72Bw6Gev+Tn00hN7LYY7PHJ7KZgh+QJ5uOYzdaXG2TJ1r5un0Y/H5oPO6CTphue rgQC5zyYHDbgx+sRnDPT0z//7G8Q930SvsOrX0cPIIeBR9J77rvZJR3svKVy60G/z0grYMhsOglQ lBGamSPmfFBmZ+Sn2SwF/ZRSIUwUaVHnAGV/SHIPOopFdva0PZ88kp+O/u+pGHKmKZ3T/b1lO2XM iwiBSgqJehfOLeMKuiVJqGOtNLJ0Vfj6/EkSMtN9KOiFboHN4vyUGjfm9rDFzmwV56AGhJfSg75E 9KlvVceVwhw8DlSPIMrhsjRX3VWFtBgWCaW08v9r7t263Eiu9cB+xqzx+MFr3matFGg6gW4geWn5 2AtuUIfqpmRaEruHpI6oVSqDWUCiKkUUEkQCrIJ0euwZ+wfNj5kfMi9+d+xbxI5LolDd6mP3OWIB yLhlXHbs67fxlgD5GPU2C0TDVO2ISHNTZR+qaoM1tqgkbcQFlUMvUKOqHUbu2OKcmPJHb3J10kMG Nxlac8Y6Azc7qBzvWPrhPTp0lVEhMc11oOtJ5A2qEbekOon5n7vbsry9YCjEOMXIkhAkFSX4RWZy zjAlHPTFgWDmMi0xjZyzEDY3JQjCAnKSURoUzt7Lbi82i0l00/usfrMm7+x0tBg49D2FfkwXbSok S6oDfeCPQQkZJTZ13SxSrUAZc20BBABDgrq8SOiHCDAXSoejMedlThHDgYu6qUF3YQbVKTMKHAfd Rd820y+8Xfa8DStflwfUsZhFM+ODAKEUAI2f+JRTJ3/ScX1A5K8PY5B+weUM5iMfwuEmwwfEf8Hv vpAB4hXLNp8wDvA5RCqRhwxukC+3C8wadpCwagpmgr69lpACwRxVC4glvqk+YWhwgy/TWNJAtYGs wiyAKxq45K2ay3re8526tlXaNXS+3zK2qxczH6ao99ecK9H5s0tTuDIjyLlCioo0fc8SyIphI6jp 9yFnZWe2rOWjKrDws2Y7M3UUJd2vF+V6bkiX9f/z4ttLdBZ1LYbmc8SxadGVW2eWJlq/ra6bTxWC XY/BpHJY78pbn4gyCo4ZHGTIggTYkTMVcMthAjLVOfw5m9SBgVFeyVsDguSBOX8SdUMeywOqOATW /Kai6SFfSvJujsGm3dpDuArsRUscpLFEJISedZszQjFTqkQyrWPUFb+nVnjFhVhI4Vf0ty4kmeVy THmj4T8wF+ouNyR8hSds3dbmpsat8TlgeUBohKddwOqFkenmHwbmoZn0SRqal0vC3QQorpid+/N+ 2j/u9kiDd73QrR/XGj52uE2nZPqOr5Iz+Hai48k8FiTcmdtydk88GZj8cDDsTjCsiQ5lCfN/NFzE atcMqNmOGUsy9hIZLoefNG/2NPUVHlk/ydLqyrxscIw61+3aAbvTreu2t2oprSeaa/bJNJTyBUis FpAIqJlaYnrgoB0BLgSY2hk34dlfgm0j3Mu0czP6rwILD6+POV3BjlHhW0DJ4em54U2NkRVB8UsM Fnmi70e0I0hsk908CMAgg/Vy2BB21U49UiFrdaZ/ONWt68Mlb1hvC24O/GAQkX+p0YmgOWMwFLrT FrP20NL6DPwuTBlw8Y3nPblutOODQdJcDu4L60ELlAa40z2MApCz1Ek5vggQ2NH46TUNnUnNOP8c z7eUr5OUdJIMHqTBI9OertadZkZWGboEGomDI7rIIxlmwu5MpzK6bg9XDhWC5WNpHfrvLI6D66JN lo6LrNHl4yXP4ybc8We8wO7dav4oZFVvUy6qFW4NpjtnXPS8d/S8oZOYCIfXC7L8tLF4eNWsFhYT zimGW+V/VxwR6VK56o6lvjvBiYNyrrkxZw+3kHBt4LU7sih0r5qdkdsmp7f86tu3b168fdbv9dZY FcVA+GCOg7JNgJiuePNcCdr1ZTyPJFFjAAJD8ZCwT/L1KAC5ws1OUT8IjHQH6IoPiKYcJidev5Gk GKyjrjdYmFmq5hB7NkSEDRW6d2kDWI+F7FlUCzDcVuUiZYsETDe3+dzpmIHToJrsLpMimyoD4Fgw GPYfin9hdsa79hw1kfxPURTnGGk2K0emu8BJXCHXhFgrruDQm+dgBT3gO2erDaDMfEQ53x17S5kC 43r0qNg2zQ5VVn2a+v6wQ9vBwHmk/hEVi0+bpGjQBMIhJYcAT+J4yK7kUqBFf8q+zLHCZVWVa4xO j/xS0hhstOf7tO/S7+7XBK9QqY0wyIDqaXGA+fcQ2c3NIeJmLRKBdkFd7zBGuOEIv8xnOjmlqkCq 0kDa5RcHzwikDf20F91fc695CD+M+vw+sd4CXMcIew77lQfAIHWjkxT6cpEyvl08AjcAQ7eBDTny wk5NhtYYuPn93LKmicBiogGQw7B3Q3DowQgqDk+dcyImMIScyJDMLFOl72PXDbWLAnHySFe2DnZF 37ir7xUHv2gCbLc4vZJLKOTGcWybe5qNaF+43hg+NogAMAPar+8a0n2G46u3ovHozrwRHSEIMUKi HT7GPokcBFDMjKYWIWRhim8IUBKwNuB10dRNCNagP2/WRQzmoge/ai65OgG4eV1O+e9pR23Zrljp L04rpq16Qbp0T4EyE3jc2Q0jIXeHa/jzBuAMtFv70oZhptDroj8sZrubGHfQg79McCsRJITaIcDT p5BgOd/zKPlwmPBtDBAz1AtGA463kxrbzRWoE5nTkYsr0I4heQ+KJDJRmXJ625kzWi8PCmKaXpBR psXbLZFrXRi5tfj+F8v9aoUcQiIVjBlaHz3778oZAwXBV/FT1deyO7DODuUc9gO66QJbiO5SQDr8 7QrOlKh0b6eXAdRI7p7lIzrmARtGCWcoB2uC7VLJnfShQjuV2ZrkfsSjnvLfe91bmbzpNAKEZ42v ihEu1wfMBRVrSwVRHBTuPAxBfobEban8XhapVBK8vXz19sXrV89/i3jhzwQgHFoeHqu9XO3bK73R 5jcLc6evcGlnRCJUosx64YVb0U85gW1JLTEYA/9Jsj1A4IBzki5h+onuQWeXBIkJDAQE8WoaMt+D eTO7WOwUqhBbZWioftY1/M0qIr2uigsI3q6wwYG0HNEDaoGm6u9RmlO5J2HuwKYJ4iV66M1XFrQH Zc6IkFF6CCMGbPfzHWEpuFxR+wuWKMCQpq+Ik8GORc2LwNgpQhiCos7E4sh+dsTLtOIJHJQOwYNY Tlcv7GtB0SLg101iK3ORaMBoleA3NePTef08NHvFfofCS6C+JH1IqHhAygj+t2B9DMoSOvXA/1HD VKe4dhl6pPTm/tWAFWCn9WHWoGUqm515EoRK4i8doSO+kGVRbKAK/NBLRWVgYJcLypAbJB0dC6RO h3MUQsOlRjJH4a67vHxiZB0P0g1z2BiWSGDwaa6WbaCP7mZTbG6AL2L7rC8apzT83FHEGaBRjo36 tgEZHaISzyKGIehNORDoCoVz/J0FLr9H+y4Yvlh4dpWXCYpaYKuAMJHbwUww15Xs0gGZ5aYc40uI 9UMcs/1moFozVLcGlZiYVtwDpSgL8b2Jro+EbGMD7tt8CeRtGyad9u6Ru6z7DtwNpiRnugc+NuR6 m3KhgKcw8vyOxsxEcPgK1DDf6muEjdxWH/c1yC/sAiOFfHJQhVCNjiqn0nrbZfVXpZZAnYAqQKkz cHLycPU7YNOff/PNt9+9fcPeTubkoHd1R3NsG4Oh9LnrflSH9z7YD/ntB6dRUu+eOq0KbsVd06za WbU2pwJTELUn9memIyyZOpDglXHfAxOnf4wlwCRV0eQB5dlRFzoiZQjwYHRldFHOrTsy6WDJo9l0 5DpoC8JX3sJHXt1JAtbipgrQdzZgJoVkuugL/Gg8luAv8+ym2X5ItNE22Z8hrHRV7STwmvTjW0gz 5eRvxmWv1ou0ISa4IyzaCRt4uoNag9w8oV9Xmw0etkPK18Ppek4I6eVUDJYYeOckRFFLqrGI9DiG F2glHWmPKEWu4/Q0yFmIDdETkUyKwDvg+kClBFV1xn0Y5rCjBnSGlb7KPqXQl8n0ye2pbEHpiPWH 7eThYiKUteV644ctOvDvzYrYX3Jg47p9THiuhBUl46p6ABdBs/TmsQNEhkqMEnMyPA2Q9wE9ZK9A MbM5Rz2zxTmIknl9MiwVKR1fEG9L19coiycCk55iCAN1rroFe1B23YDT5ppA6NiixR1HRoZmW18y J5Gg/h2knDL2OAsTGrkmR3SOokWS5jRhDNOkCF1Mk2oHvso5bRx3Ggn3mFItugOtsy+iaRg5dxBK CHo+AqhRlZNCu6GgHJ8IpSWeBEAmYoBRRONk9Q/G3aOPJ/hWKtOwEWOBC4GwVYdpcagQ8ABsmwAr iA6iGIuIfuDQ40VlmKKq9TDAHYaV6DNqs0EpgbMnwt4GLILvVMEbVoGt3XIGIteATDFOi9kthjWH IGDCaUQj04LS1kkeUaXd9PFc02mcEyZY9ltfZ5NttZy8N62Q7+BXzJK2z94X2UsfFd0FJ6PYZs4f XHXo3apS5u2uthiADi6/dbNNQKF6PGX2VVeaAMRA9cwU2UBgymn0rAcwh75U0aZwayKpXdyRvNNz 6BFz3plzJrjTgSdVk5J8a3zfeE+ozjGMXkuDnesZDd/LKuBBt4akwMd7Pe3d4hje/Rr5vtRu4kRX lO5geIQflGTB6vq5z6DA6MWveDRZPU8ulw2bIOjc40mIjVhwR/ZxaQiwSSz4brBCm0hY67iQhx0+ SKu08yXr9ij+xsk6BGMdv9JKCMxiI2EWK+dljKJXcnOueh7+jX1dxBdOn6VoNB1NWGjidJJ3CqMj l6VyM1iV1xeLMrudGFpps0wSKVZ65SGuybH88B52cuu7o/uH0lMvKK3JTJb6mFtltO3RydFMOkj/ 7qK2epLYZ1M1e+JxpZF7b2QaEodYbw+a3w3rhjqKWWrjBZuONxyMnRw/6TWSSjN1zXG57vx9bujU 9lQ+2YCi/qN+UL1oq83wSAv8ynaX0wjsLu8lTwWXizSwK++i9dAiBM2EoNLJcWqEuTUjVAbvHo5d kmgXK/R0CFzvSjBUZNkfmz2FxYB7O93IB9+DE5kaCF1aZe/fj8fffvcWENMlEA19k6TVPugm+zrb SuEP5CicuoTCLSnge02B3hCgELQC8zKBSrAIvhgEj5Rdb9FURNepHT/EdEtZi3CTy7ylwmAYOcbX EqOoSMvmX8apOyoApyt0toBUUnshJuTZDm/bFU/q+TMfZwvu4Qod34tr5QZ4+s2YHnq3W4lT2eJC QjpMwwnIYmJ4SIotSPMXbkdR9i3OnSmV9VnExY8ocCplgfLrI7c+5cw39HaN5gZdocCBXPputvi+ P3IESC/o+j1xKExjGDUGRsQRQXSd15frZltNX5DC0wYup9xoJZOnC3rwsm5SS1FxdgmT0JSl5LE2 HI34k4u4L1ksbv0EFhalBpNb6EBsgHM773XKo9JeoPw+78WIIH6t6P4zv/nGPBg6V+VAFo5uCNXS UkG9LgqG6u0TEWBmAPCYLiVVNhmNIuvZ5R5uWEdrBT0U9mvxcl1LuuBhl2M547LnPGau2VbzI+lt 1OLDuM0+H7m6Z9LiebIu5fNVc4W8MtEL83O/u8cHhPRBiJNGdq+uN7vDyeNjNznFE43Uvz2XI5oC MGfAr0BqgIHSVj1g9dC2ym7gdrvBg8t5CygpZzJfl4iokj2akDkJSYuThni70SagZ/x2WrxgYBKa e3SrA/0mVJmhw5+MrNF+uMzm+OHA6Ch/JEm5KR7u5ggXDiEOHNYQVKTwBhh68OBEkAfccEFVCSwb ptroHna3Kru9KslTb1NQA9FbpIETsNZRsTU9JqrZO3U9Ei+VMBfaLNnhbNUtBDcOj7UXVvElCMXr qkJ86EJrqjWAqpNHNAN+Vnv7brLHdY4wdta+6ugXU6P+qfoHacGTs9imy94rSZrSi7eTmtDj1VQX o8xOmB0K38PeOM+kmfNRdqYp7ijr75pb+YhrUJja/XMfbYdfKHnWURyUAmv7GndfnH7jHJ1JQ4DQ zIJvvo6Lz09decTQZBfDbj2NF9Q1j+RcTZuUnKUNXSZPad6VEROcSERmisfRXX6qDSyLDYdOJBRl Z70GoXtq3jdpiaWpWXTrsDgmKnPXLeUZSubLo35BJ9IWv0OnkLeQiEFCsJLudmHwVSLWjpsuZjPw +p7FiiztNKPeNgobM8+kET/3VOzgjnqWSO8UeXzGnQZ1Tu72AYiuF38G3z6a6BAYyglIp7wCpZtj L31vZB+37/75Z599JtFHkj7+Y/vuzeCzzyhyrfkgKnryFqGcRuyRwT5CsOE/NR8ggTCo0K/Lem1O H8qtAm3BJSUG60E2/lv9Z9p6Sdbk+i+E1/K3bLynnJckWGSQChWDlFgWm41DVNDUDfhsaH1CjEM0 QVxm6+qGgtISKd7SETvUM/vDYbSgNzbrYTFw4xGxHLJvN4SgMX7GkHLEAV+XC8OBrpoLtH+4TLAc PaOywTosDchgZ2gEZXm3gHQX1RKyYHUiqZSUIgvsJy61WqePe7d3u3utWhadXRCteXVk2WaE5bH2 JbQ7YsepPgs0yzECn/iCpQbom0/DwemQPzK5HbrywvOUsXqCx1xEM+MwZT1sUJwIyZzIkH1jcjvX yINg8KRfeY44AT1pH3Albb5iAXGvIRknjJEwgUs25/Gm/or+IlbVs/fUCa0xbwU0erMjyYUZ4nrN kJ4lRXVs95LYEfV4jMmavcX8N8kdNMKmjxr9eIogC/AJScKdio97tXZhhmrC89hhXMROTshIzukW saSE2YKwRikOIG0AhpUq66bYRaFj9J2WDI8dEaJm+mXLu6TmK8OgMqpkKlGkVkGdEnhq805KVkrO qckJLI+l3h7/uEyVQKOkUx5DyR1vQd0sxma3xWEF7c6ufKqg8k2UW8S2gR0PyQkk1MEKzUCSKbM3 j+w9WYwdgqi5AaNcnWXLlXRMJaQDr28xwb1FBGOxC3rxqIXNOi9Vj1NKuGX96Bp0lqcziHd0tQVU MyGEUD4gRXPnA6F1t/b8kzEWEaTogiffAYnt4RsM2jNnGgcHnayaZpOks8gX3EFmO1z5SCGoHfoC qGR4dzvulsH4ygVTng4YsfJKQqqbZdKO0kmUO+Kb1AqUcfZ1ocvWx4RvRCW9LYBNsMhfTMBTQ1fw X+lt0hmDpcbINxCxcuRXD8fEyEw78HOI2uRVhgUecGze6VuPK2dQG+sMZIpMNbqAluZl2ytzFrzt o3pN7p6/LS+phoPb+yfjJl1HibnkCeTzZkdkFgnScq84TlJc3rw4yaj5OzkbW3JGDAsJm9zoKJPz hj93b3Q3bYKPyS8BJgowLpqNi7l9wPA7RvbBMpnYtNnqYzTRFvFpsyOkLdK9+04YDR4r9oZaxEeb jBTS50Cis4ITxEwo2h6VS674Q9POxytnd4WrpdbDsV6WiTbVzOrw6QESwATKjJTSLDVbcN1C5ydK wLlaCYTkNZxhkdEY6sKShORLnbgjZtL1gWfBw9FK0JFtia6b4Edsh30I3p7eLLVVXXenjg+a6hqa 1Rjajl81C7yF0abqHyDUZGbPIVOREcwghg3bgaxtCPuBFNuXJiCJOHRpbni0HzM8GEu3q+byEuaB bkh/BhJvggarAX9p9J1mf6OMQK1tJ3UrwTHi59ViAN9USzcVuYDbAsKPQ7nUDYfFKDR5QH+S4xKi fXRki6qt1LDa9LVhh9NmrgKkPPpQHSC/R9zudfnB7uoZjzU1jUJP37+3Tws54cP3JMUIImz2NT14 jc15OzXR3T/BlfTdYXfVEBClE9YwTpS9fn+6S2pzkLeFV2ccpeMnrsxI36e2yJFDF9BC5DUvKr0p qnJ+lUk4W6bwcb0GqhRtoDbtKTbt7jlT/KHZSzgFia6YIT7z0Xdxc68qyV7QoGkDR0JHXpWOCG5q 4u4ia34dOAduL4vmzsgoCSJnzrWRhaDGI3Uw4SqBtq9cJgEU5zkmU5alODJwpA13Dhs2JWLCDOhz QHlQmDYSV2W4d7uGspELv3Pb1F29CnjEjASE62pXQl3VrYWXGFybNmojGwxh05ppNCIbao1MN7gx ymBIP4GKEgdjrmfhgn+64xvcB3S1wCeKTlcTFDmR+Aw3AGtg7WHRJQnMhCGVDqrbXbD4gVAmFdFE 8whW4NHOiHWAIOJxt5Y1JFphbwZQNc9XexTs5uXGbH/4ZCEfiGXS3BFRaXsXa80TtDdxTeOBIUd+ NVI3KuDmhIfUzchLT4hDAMd6c7wW410zvqjG8FT1MRBaiElD6iRuXt1KEFZ2DV7ptfk0FL2rzQ/g 9BkY+ZVqSCmw/GWTKRf11EScHZoGwDYmxNeSQ95yv4XsJsyreqoBnWSaLQARIQx3yl3nOtx8jFMw ygSZRe2t1rC1RjTGacd8iUaMN/Upkk0A2Y/wON5mHCSoluNt34dTiOQOq7x/392yKxU1bOhOdVvN QZ2EWc5hmO/fQ9ljDcrKdR84TxBKDvv9+x++fWXvuo2R2niuAqSfkybjPcxKtD1lgU21JIxbdVuC 1YLfHixOhbm4+KATY8s5CpeAqGPo+zZ5ttqG/Ur5rSmEy7IIeFXhdhjLbdCm9StO4/WhYsaTlgSa SHFFSqkrek/Yq9W2eGs+E7P5XsNs+9ySqs61X8JWAXoX6oyD5r82A3q5XjbvO8+me4d7nM4uyUAU SaVgOMWEnuow1AkwBI0l906PnW2uwIOuWfIxoUONL/ZT2BA14NQ/EXPNvRGZizUaTHlEuYP63qEz ucU0gkv6KpIRqvNMH7u9lrpurhqhjWZNRYhjufxvPbdKCkZOtbbWOQGTRYyYn26mqRvELAWcnXLr zHfNxlwt1RJMKBDbF5kZq9vNquSMkyTHQ/26hdvPcNPLskYKxC9iSm95VZnGvnb+guTc0Qi7rlo2 wwBSegPey5ZgWGzuZikefwWJOvzNSkvg9cK5gasbUDW36BlYrt0P2NDn9fpzuBgpDbHUrlrDSKG+ 91WDlxHkWcOsFLswXtEmD8ULf0EmwnZVX+6uILEnqvLMb2vJzykkTDVBcpgZxP76utweFHH9qfZc vV6u9pWRSsw7O25w4LksMMm0qG7Dn2wr0ghmYHmotnYXIg0AYI/ExcHLRRO3qFuzaw5kb6JG4AUb 1p/Q6N1rRqpU7h6FJqQJMQF3WdDMJTAG8eCy2R44Seiq2u0YW/dTtb1ozIYFzQzH8+heuzq864qx wHq8QwYhSp4GBIb4XpuqL2OnY8rawVPBrajBxXe5QhAUuEAGLhTm0wEDJm86gU9w6kFzFsvMNlZi c7ySFAVfCtgWTKVrPhtcGFIAR54kEVCcX6gcJ5Rr0HbInp+7mhhKVEPu6lW5xdYf2UH/FCLtopnj /fHTXpLcC/tdgPYNCcyA/8b7VjDB0CsEirAihNgobk5t0I4O/gn0eoitl12ZDUBXiKSHgm27qC72 SoX80yn4OhBqR1nk3gRbtrrxXb+yy2an4rQTKukUjqDFZEyrge0kYKU2bvRDdbhoDC9JrW/3m93g aINSPrPl4zatCmEmKbpQ8iR+fpRFVNL0aGSTGmXh1QhnxkzH0+LnQ+n55opRBMq1U1CYkyuB5BY0 wOzZBi9N9MK64IMuicLAo4M2iVU7eLYjFGC4S0w9k+yMGezSxnKh44TMs62wqj9UWR/CgQqbbqGf FoDg8t/ONouLQTzp+w0YKxcXiBpNaHFDqP9x9+5/++yzzzYHyl7Aru4f9+/+21P0N+zB/9gptmkx W8MIs2XdQvGedZeFk/g7QPen25uiOE2rvbq9qddfPmX8HXNT7lB6hLAFfNAHpefAusO2kDUUFKsW OxNT4613uYW+/xrCmIwwSe84W1TgaDkz2wQ9i6s1Yhrl5GYMwE/mKH+AvwBnPyJ0+7wbc94P8WWw VZvbSQEC1zHCLMa6GZbtpXPXQu9yVwvtY/evtmh2yZoaKw5WTyJwvMSXhYbnMkK2g2yJk4pDaFRQ N4IKgdktcsLF6h4KaCmmiBaiO68FW+5+7y/vlRx65yxE/cMDerv7NaSnBANnXBoeDDo5qTEq6ldf rtF4cVoDUthvwux9GtixNiTAlTAIbBW/pVkFrlwAh0lNfbhJoDgqL/gPN+kUJwgetIsgrtEwXuFJ igLy0+loqLCO0P0RKYQ4Yd3Z5EtKtml2e94Ve8fj9xDD7xzuncM++3Jyno7ZO/EVvCQnYZxAdSxf EB0x8Pc/BkVFUb1zIq/K9xjWXkfpuj05PCGrEISBHQrgthFYubyBj2AdMjtx3gC83LzZG57wWfak M1XOAO18pgqjTQyz/8jLdGc0Y7wJu4NKuDfQuXNHph/8hn3/uG55kQdmMpCLKl68+vbFq7eIfGB/ ePvNy9f6l1/+/s0fhykIOnySLSvzIhRIb5iVbYXRilvw2Rgl6oD6AMCNPtRrhAZYV8CWgyjW1nBr mv5/9+Kbl7//XaKu8CiUQZU80tmSmUyPJDGzFJ2fuKM7Z19qfrjpnmRTzFAfCfUfTo6iXx/dCApI AEmCudaS0TP3GxxM1Y8coHJnsjl/IOjqNTKPA8sLcts68dF35mT+0lxdcboeiU703UmtWf3Qgv4d 2R1Jbivx6sJ0QdYV/qh5qEX9yeW7BcVZx0WG0WBwHVEhIh8zw5DuK2zCNM+NAYbc4csPHTxAEHxv b/wN25zIfagr2B6QXi4OoBoY5FI1h2ha0qRZ9gEkVyNS7A4D+W3khRlb/mAGMutsNvTYw67B8qMf MFau6YYqTamR8k/+QPnHxDh1irjUYOE5Bc5rmBIc8ikj1s27Yetf9dj17/4L6CeJtxCuNhi8+bla txa8hMYNekaxV8NvwOOe9C6mNfcKyN66kZuv/oDND+ldgSG0nEWMfKgTycSU8gSG6Dz38AVYuYwp zUGj7Jx3XCxLkXXuKCMY2/08zc3L46EMB6N53HIxuwD88kNqktHz3/PWukBx1KVNhxIy2/Fmx9dg +JVqPci3FwDb3WbLJPLRsoDWBuHwdk6uMZdLA93dOczfQ3iw1QH+gKH2t33X3dT2e8rgvdHzwK8h VUq+zX/a+YVe7j2/aLAQIHo/1W16iAhjaA4dmT5wlG50EN6OUcd446GRosdWEWsC4VyBrmpFPAv6 nkFJ/yUlyn0bAyFQpmxC5YZXy7e/z5NgPKJmJKix/E/r/Fh06VIa5V0bNnosMyqNhCY1yp8CKqdE yslivmrMla4WBmINUgfSC2HhHtnZbL/e1PMPK5lXNyk+ME34bhf58E54RcuzkvywEO8zSNlRUK8F jHiUqSRGyddNvCrsBd5+kKai2gWvjJm9nXc3gMtisWiT8M9ObB+m4BAd//3y1T88/+2Aao2SiLMo mUD3jNSHOn9KQM00G6JddtBX/y4E7S1dw/yKIVaBG9W7b178wwS58rURU+qF2fdN244X1ad6jlCn H+K2583mELWsesYp1tqAjoSSKUMYlKxay082S7cWScYGs+uIUkJjPhFCkcuxGeYdgcdoUmEXfqfx I+hsvI1rG0wp//3BkMBmv3O348iLFqgVc0AqKm39RSIVNMizLorISS8+r5ha2spOJf6QLvXYl7AI oHUAZiYU7OBux1HFugNMO56pTswPMSqk2Q7eSKL9QXsM3hvKPRBQNq8M4NGBXpyh6DJx4LTqArN8 GBiFwaG0NiWIGanJiVJwj3iUQwTkwS8Zgt2zmTWYvgTlDwWyDzeQlFG0wNkke/J9khkSYYa2YuF0 YGbzdenpzPBBTe9vTmHX1IYSJusR5OZBXhdbYcBfCPIe59xWrjYYbS5+YOa3BKNDYpt9btMQUqMg HRqBXNws5b9fBMWAY2RHPNu2jyrSVh/Pgwq2JMn0H/0KP6MaYQXJRgzlbYWX9rDR65lLt8TIOtwV 4xZMfuWOvBSI+4XZI+W7csdEBzXOw4wNWX90DNnL8s9z9MfcouaBbLEa5JirFV4SGT0wgCgE3GMe YHJ8UlgPDI0/NBNmHJfwbjtvN6TBDEUH8Op3WHU7kE02CBIRao0z47veQZ3JqMUurDaZlUifQvnc 1dQoH7ecu8iLY4fPhwOlYASg7yOrihgm71mnkOw/3E6Y/PGoJQE2A7RnD23TGpd8txWM3ClquWVG ArQsKYS4jfbr2fjJuU3XZRY2TBhnq33hyjiwd8no5zc3PbHoU69n/UKUItDq7P1X6TahJS1oCCkj BrQInatpybCwNq0BUPqAe/fg+kLinaoksz7s5Hi55bNVtdYVJuc+bjAX0/3r0r0f1LKkwO5rowlm yhQbHoviofYACznWwBO7EeKw1VF13SocashJ2H/tm0p9cunWSU91OjcaVpCD6ujpLvXZBv5IOHxv 1gZmL+6vLeCeGv8QfsJsxu0eHe7LXcwnoqpAjRM3F1ZCXwnGfDT1e+F9L57FFhps4UBK212avMTQ XkubQTNO6KWm3WzS+X4bckOoxpoKO4yQbosq5Kv4HaAsstg8bILoB+9XCL9fL5qb9sheT7QLvT7V IyBCDr+E0uiKc0rjxHQV46nAJuN5kGTM+LhAA8tAiA2kNHpyAsQWtPE4hilHAgBze244kHU4Jh79 EXByLhFIyyiYyDubQdJOWyUFdSp8H+DcaGXuMkmr0yuoqbYKQefdWQOZc6/aXSZ8zRH7eVaswVpw 146gT5eIfjYWB0/Sw4D3qEWiU/HL/jFd7VtH7khmTR9Mc7i2Tq/iI4rDL+dBbtnAssfZ3bgVX2Nj W+ZPHYj5ZqtRK7ZgvOViLDm7CblOlBuF5zcYbsE/D45hhzNFSdtAAoUulSUejG0yeK0gBDjG9ngs GcNiuyilaluRvKhbSi8Vz7Vnckek3lEGQCvZXxjfmIH9hjx2+TqMCPAtMC7dui3oL7XYt71UQaVu KBeLThOSmj50eHOMIc1bjhVy8Dy1rL5luE/Sg+Mv8u0LbaFSQ5xfb04ZYgsuUeQmMRgb2fbxKPvi yfC0LCWmCybUuy0x0rQc/HX4A6geNinc5ChT7wbAtWLKd+vuZYmczVa7znc+mmqFR5x95b/BDyTb OHjTlhu9G+MnI3+I9t9QT04Ubmgcf2K4bGU+HWUXyylrn2G1kvT0UJubqiX4FzNwAK0AvDg8v0yl GsnSoxQ6Vt0D0vIApHwrUyJI0QqdKsxCMMlxgdRXVcw1oT4cGZKKBgSDZ2ggVo4gWRg46T8LYhhp FqvFsBf8PD9xqOSlCILwtlm14EUZRZmR7zS0B+lqUOJODdMfAa0LDmKdWYN2RkZs8YykQgtw3bTB ZeZKwNwcAZLjGjUPSqZts8HFQYYxwpXUcamY/Rk92MO5uVjaNAa4APMSgnFLvFEWuyu6W9uq3ALr 7eVaCFL3EFj/wnRJlYrsG0m1wBjrfigcpJDSHeMvkPsRsEaA1BmKjSYQp15emZVfpWm/RWT/Bzgh Rsw2S40HQ84EnAM6AcPislqnNOK46Qz1dhQBiqvUKNuq5SZ8jOpmGyfctbnczEMQU9FIMJvlScGx LaAYlj0p9aBUUJShNcTccl1HabYogun23VZL8HXgiwRagXiQndw5ZUskrlPiE9o3nXoEi3Y2L8ak ywX1yCJ1oc1iFdNTiGFfA0fmdErm+7CjBewvboEllbnXjPke5PvRefqwJbW0bBicdzbMWX9gwia+ z10K09VWM//6brr0tubfIK0uUZkpz6b/0DvQUzPR/mNIAdugLyD+QfUR0gt0WlbpirzcEeu0L3F0 W8q5JtfiAs4UgnKHV6R6jdT92NMU3QqXbnJMm60z6OELDc42pDwF4sDD6HJ52njyDM7BgO8OvHkw zGg+2AyH5xE7Hc1xjDFNpjJCVd4mkhPYYXKaDDO5WKPDp4rI1aaXri6vz688TGoXCr7E5e3ktyS2 fNiftPE/5KWZwNiTOjni5R5YMIQPxMt/ahXbmvnF85ze2q6ibsfTrYtC28ykkb9ww6MuwpDI8RMb M01KdIoY0L/5lSX8gFr4GbQwDBGZXzPqgOEK/kD6mpGn3wcUMiM/8TNitqxyvx0FrcGuD2vz9kCw r+9gSGEjRfaaMlwFjUFDyQpOCEwPqwj5Q3+1bEItb4JosSijll6QY+vhT6a4aWmX+CM0WvIy7dCI cTXEbLDQPF+KlCa1/bT+RUrxJvrlui0v2kG8UeO3B1PPF/Yl6aNnlXEeCuCLwLY8605v0/pgR73e x082IqZuCjk4H2/e/R+fEQJ3vd7sd4+a/c78ySDfM2wzjKW5ffcvJJaGQt5c9cO7AVe/qi+vxsi0 ARkYS8iiDTrDlv7y7p8pGHCCDfj413f/33Nqw6xCPRc4Jw33qbBRAlwQFcdzsbiQj+2h7ZGLDWBi 84/wuadCe3xMfCwO74gu3ehBxQXecoSn2fXb41DYvCJ/tUuUQ9R27mBSMIrbHcIc4p/0Y/iuHtMA KFsTGHv1d1UM4u51K/CdHn/f6z3oPQgi6SjO7wTk58tts8cUK4Q0fFnt8JdBPw7/hXwM+guCgkz7 hIy0Yg8RrK0wlPPxeMGJONtckSaCi532QatX9Sk76LRe71zKOhKAAYrpU2m6edVXtWHrmrpXRqZ9 lbWQhseCQ+As2C6zwavpY8FBHBb94egHhQe79qZZWEQAhxmt2BaVCFtXN4pxUEzQbptomvpGRajN TcCx0Zxs19QDi9OuLQhrehDEvZiSlBERK3QKNVugtbmMNCXT4CicHpwzODHhW/iNq9eiasi4fKgO U50lU3obqoK+slJalwnU/Ghxs613kKPFbNUpZgrhXeCvfz+V1+RI7Ydt2ED20H1xTKIsCv49m9gS 571eMPXB3HCcNsgAm4K+uGSSk4lZvwmMx/w7jMeLWar7Dx8/LZ4u2+zh+N+af2CEvpkMWpYBYaxp ARoICT8fDk+FDRGsEEI0gl0Gd+Mb+PIGvphVugsvpLulQvBbIOfEwAqYAKsJ8DKd7F8QOW/5Pxvy PrVFfgDGGCI71TrReYQgFazkFKuEsFL0q3wjwsW5h6i9jmFM7Xh6USAFelAka5uxYTYb1Y7K8mfO +Lb6uCe7nBx4qtif8ZO+PXCqNNzN6CIB7yIllRiPP8Pi8CObXQnuE2S5TQszD86Ikun0cchDhaiG afPMR5tcD3YtAZJpsoJFrR0k3QP8zB14PdxRTbYjVXVXTbwyQ0m+hphYmGpDoIgIJsQhclMAM5dH hEjAgaKsbahZoIlGyI1dk102WXlTHuKlCCfdracfeEMAi9KFspw450WYitNgy7Cx1MllbAMqexJQ mac+wHa5pJ/R0epRXeEH2ZsdowHPKztRlP3EiAq7a7gnrx3AgaOZmG2cUxntLjiG23Q0g0aUogKf 7S6K3cUM4cmgS8j4+jn4gX6eLbdaYoA2wPgzoyzR2Ev8UFKIU5LmuC68y0U5/4AduyvFcNVmMKb/ X1e7bFsvyPsWL3lwSbWcqB99/AOA3TpX1tJkBEgLK98H+oWOMGCAofbbvMPAnn131nyloICGGfZZ H3ubpQhygiTgY0aCHTMG7JiUEaaPvsfQ8wv85/Xrb1/3fS0g9w1M9ybsXFrhh8guwD9vfvPyu+9e fNM/Ik9a/50R/69HzPpLT8KhiU0TJrq6HYUH1+KFaH8QYI5prSw90CCvLteguwBgHqbqmlMUEm6H xMUXQNJNHS7dFMHpZLnNEN27d9ygHsrblDeMTRsIqrqZQqpwKBqDBGxG2E0H5EY4XmnF690jj7wa 9xuN2CsBa5bRQ+z9GYcsK7YbrQn9m7K9hX3fh/SScRJI1Sr40Svdtw+ucd/aRpoufrm4+D/39U7Y wpP20sRuJj+Hm63Yz75wiCU17zpx83O7b2Tb8NZBMAZZSz2hFvT243HQsKbwj4PY4MoucvQ1wu48 clY6Wh2Hfg3gXcSpObPIg4lVotqK0CzbUQq5t7AtddOmjCKmHxqp2rqmfQzaud1RShEZwYR0c0vH KjFHo2tqbqV/XV03rE7p+zwxkt6pWwj7gPBNp6gtGdwd2cGoRfAesYb/NwyH81LQcBJNGCF/E3fn rjC/yUQDbqIlHt9bFNVoor8740JE8c29hL60cLvBHrcEYEJSl8OmkNN1d14/2xjN6kTACdRMjyJP nf5Xsqlpvz/cmgE8c/XobDIqo00d3K4MHwrDQqlRoTWnkmzDY8MKSJV5OWd78B2uDiDJYl1b1cUC VKDS6D9sC/x/FKTPcszpgER62eTnAGnhCVThGIBvg1bOHrbnIJyPxwJg/5Bl34C8mi7qRX4+gg+G 4xKPY/jlE/AK5mdCAAX3gPw8mmsbiQ6u34Sj6mLRu054EO9D4bczSJU3mxX7zSIKytg1ouoR8+5e 32urZg135VaMEvK9l7JHY/0cJi/U25hGC1z8aDeQExFsiWGqTenPtOtGGrYuhQr1MvAaR7Z/MrDQ jlIaTGKkcMTrizX+mwYZsS31v9qvN1tzeSMGiLT7rO+ZOkHkIUxeMQxtq2V9mwSOkWBMMWulE5Iz yIJ2AY/aDOxe+Ni237N4CJS9WUK0tdrMvOS8kUTlWJKFd+KbT6lGJbkac7Wn1BMGmKfx76WCizVq rQN4h58oa7woThW1XBCVfl8oZL7YkLOxt5uovOQBXAJj/mTWA8tw6g8gKXA6B2eD29GToXM2QdZE Cp0Pg0tec1Ks15qLVvjsXKssdUk3EXYu7cqlTrxlJfzzE8ercPuj9J0Y0wLpm5c/eZjNc/2CVj5K 849s4wmY0M6OZf/4HIDrEiELYBTzbdmGXrNqhOgSyO5+hg/HM79u4BNjZB6jQXdMRL102wo3PXJf CZ9wNxxSaABnAQ1CuITgB8auPxii6PhQsllkiLZKHN2dHc10T7PNwW6DozgtEXI5pDgkLaVvvthd 4KOhU2MTd2EOhUcG7VhACxCTQ/lFtG6D/teYXwEQfncLubsH2Cr2MLStD33dp4UzH3ia1oSCNf5P TvJIVn2UuasN36ujogx/lDkrBfMFakCORVA4Nb9E+yan5SDsQfK8GpSrtnHBf7TyaJwX9SGlEKmX gl9+QJo+dIiJHexHqH0eJV48ftFgJuw7T8GRWl57+hi4GyOlbEtfeIEYKpsv12bFIk/Khc8JWZMH fejpZsps4OB7yJdXTvOiAZByPEeZmSqEbVpg3ujA4RSame/25cpOgMoPi7D8Y9CjXQMiN6EeL5cV +sAKQoMvlUlGKxDEquISQR9KRhVHt871VQXmGEkaqhrU+XuOmya8OUApevyMHa/hZgII4u1BIjgx NnS1cteX9i8xLVyXWwQ4MvuzmdcINk+hXjwHTr71R6auQ/nojQxr26NTrm7KQ2vlU77CRpaOjhyF D/pxNJc/eb2InF1mTNWCoPxoOi1BtHyxbo7Hl+MBA9RMOFbwV85ZDipk3ksqMwskCCi6BWjdhYSm mPM3JwbRsPjlMMNzguoFczgIMxVD3CQjRLBm7RW7KQfSq+Mq2Fd1ztZHb23Q6wFyTjUfMLntfk2Z KyT/h9+o4o7kY++4wEKH/m7p2QqpjjICFp9Iqrzi5uOzWFpT9GGUaVlW7RpFeWn9kPvvIsEd1zuv pFOcdNsXhSrGZK9z+3Ut39n5aVN8zxx0rPa1ajKXhW6mlEGBaohu1RSf+UN4Vp+v0qj34lGzbpRi B+jCTPmvGx7uDZGKEYT0QdkCJTK/3MCTTu9Qg6p6P4AFVXMYMli6XzOpcD/1h4XlU/9HcKlo0BCp xI7c40H1qJNhoiLs27bAMmNF+X5CZtW9clpDOYuqmU623ZZQZmIvO6LayEITYr7Nti7qZNLG56Q8 k8Bxa/otlI0kw6Ahm0twZgrObHpOZwPoWVWyN7iI1BzhxBLsJiv3ep28JvJdHUQnZKHuuF3vR7Cs gpc/mKs4JFzdV9LJV0isLRBmqONCISUVqRQEmk79dJ+byVtIuJxW1ZpedmpEkaM3VHRLrdhHnqdt 2HFZRedDexh2b6Dr9vLIhWOenqpCtLowrw3Yhgu0JNqBKn+eLsxNcv1hoQXZb/SzKzGIHyUXlWvV Zae1aPvJdw1f03SCFvHoznQpuAAW53u37OViYZ/Z+BP+DtLkSpm85Y0MxYAQpNKV9EFDuFbh3Tv0 m7jvjcgcjzFOmDJEt6WRB2xyJdOrxoHzPZ/S4U8MuyFdW1ccd+XxoxHJRsOw5uZQXOxriGArJBhu YMc5jPA97Duu9WoAvQTKsl/X5FjXmuUGZBkSXqnQ5FHnggFiP7tzuvGenQ9FK6AG5DbJptmgGdz6 MAS7RYY6VSMtTKXQCGQbmIEsJKMiiiObQ3ULs+RGLoCB0SbydmP0vjAM+6J4EWnbVhjLTAHmrnoY AbXGmCCv8ROA+paQ2SulQk+41zj/CvBr/xbwfyieSGV9YFTDFhyaLg6gwNimEJpxxy8qzDqBee9s MkcJVCxS+NowLZ3Y327eOpx3qAG/otr55l5AA+PA3KpzvdhHtkbXwtNaB7vE7qOEEcXug6S/i9rJ 1u1GvRgn+fbO5Kxrp4Rn2MX/pI/1n/yJhiQp3XTFXTiabAVnknay6yJhwo3Ptf+2HyqM6bfRmfp1 U5F9x9bQtBURRBvTpdpNvBx5PtEmSDpPkVNgtQCYSHvPAWcmOSCRVvMXDIybX1GyvQRf5V5i19yY T+0gajq5baU0c51RnVNXRizffPlO46bOJpbhwULD81PAKjpX3CGDsBNh13FD9oOU4wTnbYhKw0Cx Lis1Tq3c4HBBjUlN5x8PrWM1/X6qm31rqJTXvAejnFpfOaxqRX/oWhLBJERIhm5DpIlQkXrlsvtA Ih7MKxIQCP9kd/r3m5IQ2CpZqQw1TPn4JyknZNnVFYepIcTbJtg1k/OkWwhc3eKX26xOuNxgNOSp et8rLnyP7ksl4V4ZSoyRSkZ8nJwE69zrPH9yLkC+5Lb01LWnhGOv4lHFUFifhV6Qf61MBuyDeEc7 1oT1KpTp+hSfN+03c4r/nUo6n3TCG8bS9wNDiX7Ef6Y+qCKzb0kke+Gn84bQIeDecPcawiXmBMPz i0gUVowyFgBxCgsRipihU+3+gpqRK7V1ymattxd0RvJGuwCQ15243StKwIJle6cVyAiHHDNlVgRc jEnOc8tlh1okhE6flplflLjpgmypYXTDwk+n+1aZto4CpBTeIKzk/tBNIwjnzBnMcILNnp5hfN5s NpJsDKY5zsRAw7FSLun9BuGq8UiJ/70y5Khur8CEkH35IbsxvLk5dHC9rACariYAJCaRLVesAXBk QXIkev5zV4qFRlcUzOh4hWFdj9b1nIO7ZjMyGeGgc2k6t+HQqPvrGjViQND9QJYoSjBbz2vS5sKQ 2EQPWkGFlH1Hty9u690gcuxL9Aqs4/V1tQCbE/iPXG7La0oRDHlvMuvp3j6iADsIXL9jC/f36w9r yutcto3HM3dszWigyf0NKRJvNw0Mm0iAzRPcYzC13cBpXygFA0u9sHQ2PScYaOMuMTnebltfXrrM hZIfhOfgykhHON8WJ4KQRF9Iz70e9OgcKUxReEbjA8X1AOenrxU0EKmAyy5JrZGE2FhsUmqwvplz 8k4MlcoBhXYPshon4MU8rDs0T1OwOG0bMCyiewekaUIjIyEtmm2yrcS8iHCMni/Rfg0HwuxxJHCG 0FFS1ZYyAl7XrQUOEv+8VjyXKd0OJNiF/NHZm0qPB+0DG6qHYa6wAReV6WUV0McT5l1IAkwqTr/v xgKhblSCFgBPEC1AksLSjqHTB8mMoDwsDeMtrQ7j44v0O14kIqkTSFbHvUxgxy0h0AeLwwGwBtLW wQyL8VSZHxMCNWmSOP2RO6AqeYEW1u8xnUyqeDbdFPHfYQ/G500v1ejR9OqwZ0j0QGbVa0xZBQ6j OqJNYd9QNbPliJ4hMgyaNkDntqqAq+67Rvp4fHctv5P4os5ALUjurQWiPJsJcpVAnnapeDHPOG70 nkZNtkdfGHoeD0BwMgSWDJVm1mXHlm5cLnBq8qbZfmBYhRYj4m1JzthNBj3MsfmkeFp82ccsWdAb fS8W1acnCLCLID73OSEwFsAesguRgwEdAMZzwEQwJ34OJ9hw0IaHuaXMqrFvsSHD+M6GEHNDXrjX S3wY+HLi+vfnqDtCjec16+zh9pfhsHnHfGUunma7PeMC1hfPX8VU8DU00mN3ZdgFKk7BPEE0ILtN cs0446Zd78zDARTAJYltD2emyOBWeRjasuIDWfSHdrgyBqXBcV3AE4CR41/cqw3D2eO993CLB0Hv 84doAfi4r3Gntux+Hlg87KJzp/oY+s5ZMHcf//Hd/8rIERZV4eP370YfPvssgmGwkA2G2diATxT/ /vW3s394/vr561+/GfHn37z44x++ff3Nm16PmZMZm0DI3QP+XdUXFA9gZVaz+ajBQQ4FcrQKYkFI I8oY1NoB/ezxefZsmn1JE0jeQJYi8tiImCrxBg5nz1lsfUyJ2ebw9MQmrKFokbC83GxBLN5m5bYx l6n4vCNihehDjvBRnKkwzpFqA4+oAASXNDNwwEKwyQjoHAupoAuVBFG6uCN4RNqGlaMaheoxVd4c D7KUh1Xcg3GAAUz2uagXH+vlBMjGENidQN3VpMt5kekbBmKT+d0NQctG1ceTUsxh/SmDTpovuol1 dVcTouG0TXQZXlNO2h4KrwYp1bks2ma/nVc0I5DXkm+w2tm8yMkORoL1MFh3ze555k5DyGJM/mR2 QAAruqGNRnhikIN5IHOit4wyXUE6e3DnQ4uU2X5kl0Mlho4E5q0vWGAR2hJIftQStHFVojCH1yrc 4zdVvV1AcGM9D+qxOAjC6QLSgQM9OoMdioErbALHz+eYkcGHDNpYuDP//SLkn05fe8Pz0XocX0o+ um9o6XhRl5wEAhlHXlXM3cIIlHPxiohgGTW1E/pGDbgye9DwzBB5Dh4gTJMaKrxyJOpDJQV++GNf TB1aI+vwGyLZTb3VAwd/awtyU2Z7S7oJb1IcMJMahXo9HWgC0fh8dAHK5igANnm6WtlA0v5Q9Hfq 9Xqhzjc3fWACkbbaETYkOh4rCGdqi5falK4xTEbrppTztMs8RE50LHh0zCNAQdGmAlWHEXdwyJfs NgAToaLXb9QZcOYaSaqLhFSn2dUn2ow6Su5N1b6w9Zar8rLN/pXiLu5Xw/IgYQooKmyGgBN5NpGW zq3aBkADokv9D/6dXsqtjhAD2VWzwkx4yxkSP1JWLmeAbGu+EYco/qRGztwybouA/EvynwUaMjpD Ubd+SldyDpHrFp8Wy1nimqXLWUajyurxqYL8DqpN/CF1XQYIC5ThwGM7kEWShojr6CCK6KkCmzVF OuxDuiho2muUFIPEMHYQhaOyaSt1mgz0+8M0Sr7fJPBT/oh5LTTI/yfr4EMc2+efm40X5fvg1c9y KJTL3URT6w0YqEObI4AwRXyU6MVS80dcJksT2l7iZSUZD/mKERHh/rXKwbs13H7w9gdldhtG5cR/ DN80nEmcEZoLf1eObH0vSUI1n50wgabYD5m8f3ds8n66qVBSD73g8fnIvCRMG/GW8ghUdBPlbbk0 s2H4vPV4W833Rmz6ZPowR2AMu3SoM+ghlc/5vj2WJMoMvG4KaBnHwSPQmSYwoXLXAL2UkD/4jhX3 fbxrW8kMz1nTGSvOXXunXrCUmreKLlW5SMPL59RL1QzbDM33jMNBbi+t9VekM5wF0/lwclJCT9Ou DdAyVUf+ljwzP50Pk3bW31SHjhhccBK3WKE1XU/N3OweetE9pG/LvmsP8ybOrAjjsc7+IkS/WJvR xwJyKYngAA8XPUdKJbvbO5DMQBjS5oVW3m62GrnhiCCN7Ud+QPKAuBT82HGpymMAGFIXq7uyqp0a pMqnq/pkF5Zr5LkRSge4Kwi4AZ+IfuiI4L3ztRVFEzLENpE6O7jSfmXLuLeGdyFWoqvlbbWy3qcd wq6dDNp0eL3TBelE/ftEn3gbJnvYTh4unMlQNU/+xGoIXzz5YfzEHRII51lwXIc+1MxTTOOXt9xB NGkn8QynS/s23SwIsUqw7wKGD6bQo75EMI6tdoIPtBehDTy3LfkJyftc0pBstCytygMlkEallb7a 0PXAENPUer12T+l+L2sErXUL5NJAY3Y0tCuBnjRtUCGT/Q1IiDD80mVmMN+gBvPiMcoI054kQ+k2 hhjG7fggt922Dj1fbhWjPPNmAFsaqekfsVMmxoiwF3giMEQ5A96mgPWTujI3t5KzIwPGgXkERjm5 HQ2HKXAXS4xv00nouIC35SyVSOsKHoAR/z+wlQvZfaVAZJkJwLs34A8E5rnILlDeDo5QplH22Bfy 1TBGhmDvUPOjrVYBG2K3nzt6RSBM31TOHkuYEHDNcdNwdCntE0L3wu+7baW4zgc26YYPfCTeCGmd TiHSDql2NLXZluvLaqZzJN2HitWi1TkqSHn+0eASOoUXW5M86D2EoFyZCs4/HLdKLSTJV7Dx0f20 qxm6g2UY0i2QYopg9z29BV2JAfCjnXpEZ86djLLZCKMFpukF0HR/xNN6v/j/oMMp/43Qnd6ggS/B 69Ho9EWuM/PFAW0nTjFO7Jkpee5WPn0RnuE0T8w4GHPXbkZ9ndCPnoBxVS8Wcb6YRD4VfYuzjgbs ysDcx9bTYDO3zeoTK80JvdU3sJn9QApGJJsgO+7b6rQ8kt2X6lkejSo/753EuXcJCFFPLFoe7+ok QUGyBrtUQsTmoQdXuDrR+JZrfUUm04u5nPPxALB6/otf/MIJqwL9H9AKTycfDQO2fsddvQov69Pw 0u4GROM++2b0EaPWz7Jf1Wj6Ndwv3BYP2z+tM/wXWOHlOmB8R4xvhAK9W4V1t1gQzg8rQ+00ScIF OYPUvsfNcfGQnYPm+sNI/huAtK4EP/vAGkKr9bzctPsVO1iadpfVFnMVgCEHshU4QWqOTlx4KqUZ Tqjie0e8YOHOlyq6xMTdRUBJMJ08BhnQ7UouPpHTDWMJhupHsdLuLgC1gHBpQ39tFN8gF2SCOSOf f5C5j5JbB0OFi0qCNrSYLAnNYcJKQcoNNmUbud0tzQsMjwU5pyqZKiov5X6nkrawdyvtXf6iODL+ xRwZUMPYCl1KILcBhNslozt6l9kE47XaiUGetQNs8k8LytsOUB3XF/Xawo9oLBNS5WveMcy2RkFX dMmAnRU5CIxpaMYX1diy1Mq1oFXpiP2R4agRIrmFGRQHZ+5E3i05AwB3EmX8IelnR7o+8MlsAWP+ uvlE7CvFBwI1Y1fJi3rHOfAgHMxrDu1aNl2IKI+FP31kX294PCcc7IkwlApZs1tFmqLnnGu9kwUc DCh5rA6fklqUQmYYGckQcF9tOV1bO1xIS+iSsto1eRKqlXAYuCinT1aNDzv6512mur61+qcp78GO qloq8uqnpR5oT309kjXd0e9bpzdKWkX05W84NgiysdQAArlcF6QGbffmZhnY9ulGGxa6shf/5SeL Q34dYLsH7ao23x8Pw5fgXjxH84H5MRo8aistLcZMlEL51irTBazpbWH5zuF9CBIcF3GjpfBqPHjh iV+uOR2mINri6QP21+lJReM80l29NG36x4C7HlHCOIrh1HwxanHh1GKsmwvyxPS1Phki1ZJaKOT1 qAUzKRE5lZSTSL/oPSmFqdfMS5wGsoOCsoWm1c+AASAPbsJBU/OpGh4zS7jdyusonNLQF/IR8AO3 8hH5AWO5QPlBA1BEm1TGuDirqnTTxVPlBHXCr5J63Rkya0zuAmIhZusdS9TVEL+FmcVEYw0lzurz lO6H1Ltu7jrPt6/yVsf5bPzkXKvk0HDUmAtiUd0emTTcUlBGbgUkQI+8ZYetg+hQ3GaQZLq+hPu3 Qgd9c5EbDnQLcQkjm3x63bi6ZJTYqj3rJQln7Nm/fu9P98iZG6q1OU5bMM0lMo8+yOqF56yBtm7g xjBQDhYc3HvZFSCRY60lYR/TH3FcxTXmx6WZWlTzBtOqodcRK3A2ddAQHRLKzwTz4rkP4i7EgBVz R109Iuix6uPecK27g98QeEgRhFXpI0s5FQvtm0jLXi8G0RNwj+F55FvK7w31U0ZKYD8uzqUjy1aC 2cP06TOSCPACKhkFOICU/uw8zr2eCJn33yCBwQjhgsvYjUFvDnS5g5IQxTzpSkm5LMTEuSzYkj3D We/W34Dpg18fX5IHMXsyNR/uX+3pVEY67MjJqE50nc5BrxfVGd1TuryevB9yXuRVnne+EfAXnePO k++a/8K5prv4JQ0OnnSubYPoTxdmLBKkW2WIF2Iw4E/1pY0YDAm09axHyR+h3adZnncKjfuNFVlI vx3KKzWaqNP60h1mbTsSwYrQCL6lgUIUHS9k2jh7cj7KnqN50UwXakpSwE9OQy/O8VI3v24v81AD emQMXSAPtoPWNn68PXgX+aIRl3M2luYdm5sYO2+J/PefZHlgT3UIwGZgHgafd2nj3vOrSpoY8z6P z7tryor4lSWNDM1Gd224WuxWDPq/4PpPj9THQa4jJyz4WSvF4LsNuDzSmuV2BmKWijnbwGKtM+JE lQb8JvcBfPJTNkBSt4sVwBEuFGq+vJ+CdHLyp+dBNAd/UDm12wMa3495mPgTgjpjsoP5LC8ywrk0 mLPWuGpFaTyyqVvVTjGNhWgnZPrzN/GIw5LAhZSwUVU4KmkAAp2Bt6M8/M0M2XHWQAzaJnFgTJFA SY1SigVYNRKCYc4AxzTNhqN1BK7YVKSEW66ROhjKiiKUtvhzU69RGm6jp/Cn2IY6WaCwPP+RuQJr KMISEI4EeVFdOfwDXeM83Knws9ppPqYh7jdAXLjTSuHvD0dPgJcGqIOExBN0VHCmrAAnx8PjDg4b nwshD3JM7AHx7cta9nDnrPBlqqFOmuzUZwn2MvCa7+An+V0Bcg3U4r8VwDndOijBeey+rKcc5SDR KHEhdOxHjJ9N7jc+W1JeIDydFNxdkETJ6ZskOdsx8gE34BC9x4JzKBpJ36DrK+zcUCf4WbwswPE4 EER7ESD4BBEC/xHX7x/XzT+COvOT4nOolE84+P0mIIhXNi/8gES1OMiwhjDpfTUMvOoA/LrF/Uoz O6Wu3fyJPoJfDnGYMa38Ii0d19wScJQ5NZYnDWmwOXx+EX6xt88rrDpIYaVARma3k0PSNejmPpCU dT+mo3ikuvRpeAqnW4srDAWbMIDVV3O/vMYkgqTgrRYviNEZqP3uPsqmx3/Te57/ql0vH9TOlw9x CMj1jiBMKxkGEJw7bYNpyoJqCF9+i8gA0QwasaYfYMoe+VRtGKsuMU+KRy1ne0pS8j/NGHk8PE4J TghXO5KPmOiQvsFhWZPDk/it/Ip1jSQx/ZqUDB7k4wPSgISGNoqaXDU3M0YUmGb9Z32bwkT9+qI7 kOEOimx3JFHdU4kw2XAdkZmqfkK0SvKu9Akic6pMsaa23yA6wiXolI9+AR48eEDQp+CxuL34cJio /wboBLGZse+D9ola1pcAEQDrSEUpPAetk4G/ThzPKYbuhB8icjvU3fjJ8G9v8076J/gDgsPU5at8 rPN4AF2DUAfrcXjSfm7OI83CMBuTQGE9AIYBR4XH2HMXi3yMxZWFTrzvXWbXf5j2rUobfJ2rFi3f ouK9Mky716ghW29965Sf9BYO/PqDkIOZctAPX1c8I+U0RJFdAZa68oAn5s98IGG5XnusovKID8GQ dOvaB54aZM5dXkfaHwbui5q/NGN/Dn3R1ebnmdJrLW6ZQMZnqPGejokFtSogTm96jEdcChFH6osk c5EBJCstM8pARVLEUvMYueRlqFCWcUFovDvYBclVHbsqDIAC55Rh5LbC7U7V+QGFrHvyVfZ40lXr Cz0apUCAlLgzSqQFlwZOlPeKsXRH08Or7jXwRabf9sx1fy7Ot8ccGpY8f2ij1u1MVEOJXEJHhkOe Od2l8dyoy/QLnIH+kRcZnjZkV+OLJ5MfNWiXPqqbPPFtNDWEVJYM59cxsHK1BcvvhmJEaTsjcOqE LbLI/dTClP6M8NAAIB0ShogKYpv+MfYVQWGzP3cthuc2dfTkffvm/z7nr+qivmQn9W3lqW40O2Yu cXVnSh82P0JSHGfQkfxP61yFmiFHx+OhDaX4sC94cGdPJn78kewa7vvICVMdpDY0mx559hLWGT2+ YKbSq4UXjopJGLEUnLhzlLwcv0B87XyoDvgrcOs4CWzvYaEUQe0BVeRnZmX/vh/XLVqAJ4mPICpa TUNQJp4B0QSzn6eDuAmnsaRMfflsJphus1me1oN7K9TXFUxHX8m3Z/1YCx/TPbdv36KrvXMYIiCf krCl0PHH3FMXh8gByrWAqt3B0PoyjNiMKUhLjOhSwKVrZqyjlUXdXu5rlAuQ6nyqKJsSMsCgWynS 8rURMHXiTccCBDpHrzdYdriZuDKA9Pybx+IBpBRtRwT7B8ectNEFkgGZR5geqsty5y/qw/GTx7Bb KdcaczYyyI53Oba41iBCSTa5+T/9CXXqGpgpWRWRNrofs0Jlg+Zf/sMzBoOuyuupzrV7Axm4tp3s 2G/p8LMu2CcMViKdOU8OZkp9PizFkdv7SHPxgXPTHaEOP55pihfpgRMVonADF+4yUg47jyFA5s/o kdrdpadxGGNMTHc/LiSmg4CK0ExNqDDFWGuXnjgRuq0EnqiYCI+chBpSCs8Q9SAXD7bSZsuCByf7 EBGG1louLcWpeNEpVj4VbkRkgIj7V5wEXdT47zEGJ7o9ExwuhhkQoiAwGegJDkSApt4H0umm6a4F ndNeWAxrIDSUru9PH6sv6LAAcjEGITpdVnAB1qvKXG1MeDu09Xorgs4+SqLkQgrDBFcBo9ExXV5d terMR3D/gatDqEhGgoLLNbJ7aKSaHumXZaVVilOe/AgG9+cxNxuNTTvks8hJQ3Fiv10254EdA4pp fdUJKpt1DPI0LC4qoO8r7CveHKzF+fbN8TiSlEMvXMrrDVzHfD1T8ynkc9qv600v1WzH9eELAl60 ijNn28MSGeiFA7UWlGD6XBvKyEDeiXp9tX9dIkYunS/t9X4N+QNT/h6mTt/Q+fp6f63crhZmDa5w LcB/rY/SIuQO8xLfpxYnGJ57lcAz0L0Suk+qkp6WXOxL3r2CaaY4LMZ7f4qwIiIb++05a3/gJsnO HgMaCd9XQ037gORF5AWtdVrRn+Q2hM9IJAjmQBRm32xzEb3nyZwG05vy23ET0//Zz35m6IBb0B1l OR20QMJZgPlX2aZpEc5k2L8jzYOiLM5Vg19h5Hq2ViN7Z4fsmLb2pE4TFNKnITG1ccJla+46Ibt0 pyHQ63nk2lQZKV1Or8lddiqXMEjZiXymMQFP+ZWgU3rNFNUaDTv5frcc/9s81uGeZJV6kP3qjy/J pOxyVbEzKSbTuDViFOKnVdvaZldhpwKap57Gw7O6CZU+qyGCXzfFW7MnXn6ro19v1DOayD8gV48p gad1E3oJuYxnuxhAzrRyiQgie8OK2kj5012GFNI8IEI9fHybAJxHj1bxC+dNEO+b01K9de6uSZie z9//3ve4qOz6OD9lIjupzqXGTySnDEqLnJIbFOKbaX8cgbFHab7jatr6EeWsM+t47G27llw0Jn5P LhdKlI6ctpt5sDEdb+jthuFTlGolCbleXUffEitLciDm6+jPsm6LpZDzJHlMzYK76tS3XoCc4Oi7 /XzMUHniSjzgdHU0AML0RFdxl+ka22u9SzuG2bnbb16/acyIEM/tBDUU5xJ+V7x2/X58oR669pDc pcIdhoMBlJ4EA2umeRZd8lznrP7iSVIvl3wP4CH+lNKHhKVJPLV5pWYnzoq352Gz8EZVMrqDJOG9 M0meCb9M+miwn4z3Wzft212E1iRvs/bJYad/7FCcWZmGu5Y2z7vPCHukO7KtqieOdjSce76OqED4 8amnz0w7arfMfiaPRtfYcBgNPzVw4uZOIEpKUhXjK30Tl5+EtNrxkvSK0YIpZwf9NS5oXS7cl0Rr NBzMi2gH9jcgeC4Pmn/oEojWahjHSItnV7PzlJKQFjx52te0/wKMeMNOSkdXx0WzWrBLC6R1Nf/z azzoIozE9ERvrxeo68358bGb+a7XPv2VT39d/Qopc84DTQnt8RhlfVIUd/QbzlvQRdckePNJWyWd dq9jT9zZfcf+u0sCEV4X4CDof6i57/9pHROaO+Fkgrk4vTwP3qNknr7vNPZZ+/A6bWBAnEQPKaqf Doy+wG2Y8gxZ3Sd/Op15sqD3cGVzJ81+t2E05AoyEAc+mw8YGbFcq5LXmDe43CFgTFYtakxFuAc/ JkQdd6jrmBNJD9vtRUqWhBjcuNJ+YDQYKscBn2MzLJ1NVJCo3ZSArAeZI1orHkWIepRyyVthNsic trZHb9N73aWn0CNNZfxdKT49p40aPX+CQfPVh1fePe+imAqTsWVZonNkP2lDZhhT+7pxI8jFwpjM Qga2wQ4bp2hSDU/8BX6y44AfnmbPYAYB8eumXoRa4MDNB2t1Bx3qlaAOuq2cPA/Zur2Hgfq0Ybj2 vzDTNEJvmkQ3x7sKBxo0cHwkd0yEviDMf+ZeFHs9+4Qy7uP8ypr1B6XE7PAVysGYYQorID38CMmX H+pjk99BjBLBl+et/dE5nCE4G1ecHE8eYMv1dDSveiUd0xtEHuV+gK8NT1XwyLaVIMgxBaXcURaR yPiH4JFNoUkzNjnpHbjwfQbPVY6PWpbNGZb5F9oP+/UP2xEUy3XSpsAFZlT7UzfFSfOvpvIs3APn KjF6aimOT5XXsqyMNNmTUCBOetNc/BkjAOfWbyxKSKZi7JVvtTizuMnwzGMO1hpUjY3Fk7sjaY0p ryJycXB5fT2DznLy0z1aFMphbycVPrmkvEFYlmLtbLJZjY5DFf0sP/mwM5ux7ce0ZfoZ2vbYh4Sz SxV1i3f5wPdYlv9uaeRqbQtp0i0yufKlrkQZzO2dIw9W+Tax7L3ex//r3b/47LPPZpx4kZJeQNa3 XfXxP737f//ZZ5/1zNZBVKfsomyvxvwUFPLsC004oIgZo2qTwcjwi6Dd7zGMg3v8bPq4+NfF32Eb jE/2ZfH00ZfFl9nAnI1qK1nnWvTD6xm6D6wk5bgrL+s5h7aio9Xs+etff/3t77777Yu3LwyH+6lA rESEvTCtANQ1xrT20OQAOXFw1WBMlGGvXBFYRq+nX8AWbPcbTiiG43xa/OtsUK7M5/0lZUuZXwFo RmtTt/QAIMYwWobemzZ/ZdFxtgc9vwOcOMPMOOcYtoUs6q3ZR6uD+ck0WfWwD06s+pzxdL7DygW2 QR4i0NfbK0qo00onOA0IFnxo9uZtDHO/wiR/0COgvDYUNyz2t3LVcxjxnH6Q5KORl3IWHEX7ZpzA wT3qZ+USusIfvnr7/JfP+j1Y+6pcCKyKgOxInaw/Qca02exoGopysZhJ14Ov0WWuwEDLWbOdmVqg PYfgmfzz/C6Zb1jY15/6s9HrfQsgFCMAalnxi9nXpKsIy7WyKJeNzcsAN9qiERAGPVxcHMzRap4c aGNhdlKVwNE8dKPq2cSPWOumWq2KbPBy6R8g2n32EI04dZLFWqpcM5T2CtkjzKjJuR/NAi9gW7z5 7sWLb37/XU8yVcM2QXwWc450l+0cYoZxHweHvTd4VO3mj+DXmfu1WDyiQzFWrRTtVTbsma5bTJeE Z0Zy9GIWV4aPI7g5CB6gXgUwBh01N/Wm6P3RbFlwIjOzSGEGivgAABzua1MYzx8tDKRHoOZ2NjVC D+Tc7/749t9/+0pTitm3v+m1hIDEqV6DFxkjFsy4KtvDmFdhzI0LbeiptebDqykVaewpJZlKcUVB pRXHUUMms7bHsRRER9OD7b189ebt89/+9tE3L375+1//+uWrX/fiJORvdUYImA0mXgDhvEYEFm/v MxwPJpXYb4rNwS1Dj97VyHFj2O04eqes75pRsFWUWwYR3MhbXwOSGO8FNSmmZRmsOmU4k4yHaImb yno4804JsfMBbR0FVBAqj5iG+iWzP+/bHRNar0OCQZBkNYZmmjnosdeYIq+MoeXop8uxkXtEwvB1 LzGQen0JlxAeUQRj2qKdq7wpDzDToJWcXwFZ9u6i6mJ/iVsc98cAM38APoyRfwnQgSjT3LxMA9Bq jpKJvfAW58ks19cz3D/TJ6a37Z5Z4nvt/n85YBy0zUZlV51fNdm/hGxzSIHw62OblhavbNSIwGa7 qIA5BQyqUfaEfbrg3c2ZBv+gFpPpmrdr7Wkye8osAeweTPpKaisaut6B0yfeG8oIexl7czNV311t DT9TOpjgLMcWXr56kWcD6/hNaLKmX8i4Yr3HCYs4QTcNpcUEICrrKH9sOP8oVLUQ5+azy7fe7kAX 2X4ty0avlsMDPhN2x2GVTngf4h0asFaFsWeomVHPDSOqvmk1LrGjovHE8BpIYPThJtA1mddF53gm fQ0A7K35zChi3QYR8k1LnnhsPKcOINBjkj3w/TnxCdz+GUVhSU3mIgZUAPRBqs1joVJei86zWV0s nosXLNIF2g38+DXDhPDlzC0isch/EfwaiRL8quMn55gt0415wsD7mOMJI6hvOeHmDWQ8WDd4IUeM D49PfDTh68CGQ+XF53ngGS/Ppplmo7pbGQ4TKKiYTnrAlWJxSd6qbs0sD26TIhAM4FEeuJKTIgIZ e8LDRcJKIx5gZkyYgxFOMX6FVTPX1TCAXLXcCWs2bs/cqk/OIw8exeT0aPhGhKi3pj4A7eeavIiI 9cA7/STJMLuG6bR39YVkU3RCQ/F3E0qC8AgePCJFe6/LB2vyFJywBk9H2d/pI4zAW/Vu8GQYi/Oi 2VKsmLsG7s6ALU2Pue3gopsmqJT2dOqQbiZ+hkUeV7nfNWFJldz4WHuYkyI9QLSzf/zP7/45J4Ze NZcW5/nj//3uP5ifQWVifsar9Pl3L7NBboj8Yj+vMMEanOG5oVfgKmK+m49r8lb8VJeST6sdUpqn j//Pu/+F+5Eu/su7//9/xy565leQp7HFzWFVX0yybbmpF4hjSAYXI+YBRnizQQliv6tXhgQjy8Z5 tImDNozwh0vgy9CkUP7lMF41JaI/t/sLLtr2oDm8FyD8NnuLoJb1ztQcQ9gO8CWG5TLXLojxIpO0 PSCh42ekub8mDOqWwS7pR47gEMYR805CyGVPtQpKgLXsPTz4vd5gPsz+fbO6NHV+s60+VKR6oXTw o+zp48c/Hz99/OTneF3qPOGGKjwpfl58+Tjv9VhrKy3PaCZ6vQcZMu2lQtr/3LrQcSKcev5hBdFW +irW+dpzqZpDvgduuni+qsv2d1hk0JcSoIeHNZYvOdUzG1+q8UwPBKPMMI5GLJv+NecC+UR6+H7E bJjZ3+30r0JKLDg8sKdeXl9ZXuQF2t3CNJUDstNiAl9GyQaAE70FNmnd5Chd8r6gRmj02Ax+nNAP IzrH+WxzMEQyz7DADFBAMSqAfqX+cl4uaGRzmPh56h9k4IBzA+MXQlgjsCcPlR08nxaPOanFclXu 3L4aSe6ZEpbCe/0H8H4fKsMxNAgNjP5gc0QXFYJLw4MO8AWoLxk1qrfmjeFT5t2PrwEgvPIfc+9X TQM4cszuG9FmjBD/3nptS0Y3AqICawIt/dUSwHw2WzRzM0/yA84yF53IQ2eczc14IM1isnzBDydS SNX7YBjwXF2JXj14CJ8nWErV+lUDEihoq/K41hIfgvJhospR7e9l9/B+91+aj0cuLVKhifysBvB8 U9Ppy72S7ueguxocjEFPFPT4cl1/zb+7F7GFJ+6x6hvVaaTYT9VRj4NBAMU7aZkhUiWxxu2n9c08 D9cKuUJ4Mnnzaf2Hr82Fe2222XfQl193v1Ur7dU1T6ByR1X0nkh2i08maDcPK5nmnu/hdbvHis/9 KXogPBDrxwFxH7QgY9Y0ANNtrmKaTkqFenQ6pWMomjw1bE1Jlec0UxMu49WjcEhdLa7HZVStr3HA WboWDhFL6HMGGCH5sRpUQlXx/LzzVBW/hKpqvSLzrt5cCVUNAi1btit0TYYu41dl40be0aMqoer5 ZsI8US8ooeqGRsY8qhuVULUDEMvc69nZDkMjsGpAJcCbmfspTzcQlupoIQ8nLdlCUHuzxYtwWx2p 7RXT1S2I3GZVUi6RPN1AomB42GEnAY9DAF2SphizKMrc01Hnb6cQTy6aOu3WrztPlHcPVY0tGIXa apGnerAPNZlFgTc4P1KBH6ri5foQExEpDg91Wf+iDsr693Nrd0ZqGP6GMMzzX6p16+8lKeseqhq/ LM0FJ0QkD2r4D1Uti7/2wkiOYS3/od5vhhevbjsmlB9qwgBC86yjOD/0DwMCayXX1z7UFYyoSYJC nqjgHupdB9mv8461oIe6gwszf2SvzOMO1ENvUA2gtHacA36oy9ftBbCs6beWh36FIx3wQ10ewHCu QSWYmiX3MKgCLCNIi3mqin0YVNKXR1QpvDe8GyOskCL3sD5LxSFEi4cPNUdhTiKIk8kK9qEeUudK RMug18ArqebfEdd6vdnvxuyqCRpySaiZ183dbJOwtU2KkC72m2XANtnyxbzc7PbbaiKFNIOB8XUp FkjV40Ka3sBEhPXCalJIc0/ffE0P8yP1XCHN3+0WcdWwpiqUrPqrb/K7q5pC3gTpIMPcrywemYQr MgnKerdKW8+Q2CVGH7Siyvp82UwKztBnMu9sIVFW30SMTpOn1k4eTmypcBO31+KMc12V6+z2evXo ane9ypw8QFvaPDhhT2O/pqipndrW0HKwOb0q+FyvVnkZFvfKw3PNTJQ3R4vDc1X8lWg68nRx91zT q9ZssdTB5Er8PBBMV00gFz/40YrPExbCdJFaBZDlb8rtOk+UL+ABWPNsIS2X8yCTFaEzW8DnlORl 8mQlXcDjSxhcNO/ozD4P7qujlS4TlVCyTm0b+1qh6P32m29//zbvrsAF/CovXr8+XgUK6CqHFrdN dxUq4Lba98Pex/+6L/47TY55Dw== """ import sys import base64 import zlib class DictImporter(object): def __init__(self, sources): self.sources = sources def find_module(self, fullname, path=None): if fullname == "argparse" and sys.version_info >= (2,7): # we were generated with = (3, 0): exec("def do_exec(co, loc): exec(co, loc)\n") import pickle sources = sources.encode("ascii") # ensure bytes sources = pickle.loads(zlib.decompress(base64.decodebytes(sources))) else: import cPickle as pickle exec("def do_exec(co, loc): exec co in loc\n") sources = pickle.loads(zlib.decompress(base64.decodestring(sources))) importer = DictImporter(sources) sys.meta_path.insert(0, importer) entry = "import pytest; raise SystemExit(pytest.cmdline.main())" do_exec(entry, locals()) # noqa aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/setup.cfg000066400000000000000000000004461261437612200234130ustar00rootroot00000000000000[versioneer] VCS = git style = pep440 versionfile_source = aiomeasures/_version.py versionfile_build = aiomeasures/_version.py tag_prefix = v [metadata] description-file = README.rst [flake8] exclude = _version.py ignore = F403 max-complexity = 10 max-line-length = 80 [wheel] universal = 1 aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/setup.py000066400000000000000000000031401261437612200232760ustar00rootroot00000000000000#!/usr/bin/env python from setuptools import setup, find_packages, Command import versioneer class PyTest(Command): user_options = [] def initialize_options(self): pass def finalize_options(self): pass def run(self): import subprocess import sys errno = subprocess.call([sys.executable, 'runtests.py', 'tests/', '--cov', 'aiomeasures', '--cov-report', 'html']) raise SystemExit(errno) cmds = versioneer.get_cmdclass() cmds.update({'test': PyTest}) setup( name='aiomeasures', version=versioneer.get_version(), description="Collect and send metrics to StatsD", author="Xavier Barbosa", author_email='clint.northwood@gmail.com', url='http://lab.errorist.xyz/abc/', packages=find_packages(), keywords=[''], install_requires=[], extras_require={ ':python_version=="3.3"': ['asyncio', 'singledispatch'], }, classifiers=[ "Development Status :: 5 - Production/Stable", "Intended Audience :: Developers", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.3", "Programming Language :: Python :: 3.4", "Programming Language :: Python :: 3.5", "Topic :: Software Development :: Libraries", "Topic :: Software Development :: Libraries :: Python Modules" ], license='MIT', cmdclass=cmds )aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/tests/000077500000000000000000000000001261437612200227305ustar00rootroot00000000000000aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/tests/conftest.py000066400000000000000000000006371261437612200251350ustar00rootroot00000000000000# debug asyncio import os import os.path import sys import logging import warnings from pytest import fixture from subprocess import Popen, PIPE from time import sleep os.environ['PYTHONASYNCIODEBUG'] = '1' # logging.basicConfig(level=logging.DEBUG) warnings.simplefilter("always") warnings.filterwarnings('ignore', '.*sys.meta_path is empty.*') warnings.filterwarnings('ignore', '.*deprecated.*', module='site') aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/tests/test_datadog.py000066400000000000000000000137301261437612200257500ustar00rootroot00000000000000import aiomeasures import asyncio import pytest from datetime import timedelta simple = [ (aiomeasures.CountingMetric('foo', 1), 'foo:1|c'), (aiomeasures.CountingMetric('foo', -1), 'foo:-1|c'), (aiomeasures.GaugeMetric('foo', 1), 'foo:1|g'), (aiomeasures.GaugeMetric('foo', -1), 'foo:-1|g'), (aiomeasures.HistogramMetric('foo', 42), 'foo:42|h'), (aiomeasures.HistogramMetric('foo', -42), 'foo:-42|h'), (aiomeasures.SetMetric('foo', 'bar'), 'foo:bar|s'), (aiomeasures.TimingMetric('foo', 100), 'foo:100|ms'), ] one_second = timedelta(seconds=1) twenty_ms = timedelta(microseconds=20000) rated = [ (aiomeasures.CountingMetric('foo', 1, 0.1), 'foo:1|c|@0.1'), (aiomeasures.GaugeMetric('foo', 1, 0.1), 'foo:1|g|@0.1'), (aiomeasures.SetMetric('foo', 'bar', 0.1), 'foo:bar|s|@0.1'), (aiomeasures.TimingMetric('foo', 100, 0.1), 'foo:100|ms|@0.1'), (aiomeasures.HistogramMetric('foo', -42, 0.1), 'foo:-42|h|@0.1'), (aiomeasures.CountingMetric('foo', 1, one_second), 'foo:1|c|@1'), (aiomeasures.GaugeMetric('foo', 1, one_second), 'foo:1|g|@1'), (aiomeasures.SetMetric('foo', 'bar', one_second), 'foo:bar|s|@1'), (aiomeasures.TimingMetric('foo', 100, one_second), 'foo:100|ms|@1'), (aiomeasures.HistogramMetric('foo', -42, one_second), 'foo:-42|h|@1'), (aiomeasures.CountingMetric('foo', 1, twenty_ms), 'foo:1|c|@0.02'), (aiomeasures.GaugeMetric('foo', 1, twenty_ms), 'foo:1|g|@0.02'), (aiomeasures.SetMetric('foo', 'bar', twenty_ms), 'foo:bar|s|@0.02'), (aiomeasures.TimingMetric('foo', 100, twenty_ms), 'foo:100|ms|@0.02'), (aiomeasures.HistogramMetric('foo', -42, twenty_ms), 'foo:-42|h|@0.02'), ] tagged = [ (aiomeasures.CountingMetric('foo', 1, tags={'bar': 'baz'}), 'foo:1|c|#bar:baz'), (aiomeasures.CountingMetric('foo', -1, tags={'bar': 'baz'}), 'foo:-1|c|#bar:baz'), (aiomeasures.GaugeMetric('foo', 1, tags={'bar': 'baz'}), 'foo:1|g|#bar:baz'), (aiomeasures.GaugeMetric('foo', -1, tags={'bar': 'baz'}), 'foo:-1|g|#bar:baz'), (aiomeasures.SetMetric('foo', 'bar', tags={'bar': 'baz'}), 'foo:bar|s|#bar:baz'), (aiomeasures.TimingMetric('foo', 100, tags={'bar': 'baz'}), 'foo:100|ms|#bar:baz'), ] whole = simple + rated + tagged @pytest.mark.parametrize('metric,expected', whole) def test_formatting(metric, expected): handler = aiomeasures.Datadog(':0') assert handler.format(metric) == expected tags = [ ({}, {}, ''), ({'bar': 'baz'}, {}, '|#bar:baz'), ({}, {'bar': 'baz'}, '|#bar:baz'), ({'bar': 'baz'}, {'bar': 'qux'}, '|#bar:baz,bar:qux'), ] @pytest.mark.parametrize('tags,defaults,expected', tags) def test_tags(tags, defaults, expected): metric = aiomeasures.CountingMetric('foo', 1, tags=tags) handler = aiomeasures.StatsD(':0', tags=defaults) assert handler.format(metric) == 'foo:1|c%s' % expected def test_events(): event = aiomeasures.Event('Man down!', 'This server needs assistance.') handler = aiomeasures.StatsD(':0') assert handler.format(event) == '_e{9,29}Man down!|This server needs assistance.' checks = [ (aiomeasures.Check('srv', 'OK'), '_sc|srv|0'), (aiomeasures.Check('srv', 'warning'), '_sc|srv|1'), (aiomeasures.Check('srv', 'crit'), '_sc|srv|2'), (aiomeasures.Check('srv', 'UNKNOWN'), '_sc|srv|3'), (aiomeasures.Check('srv', 'OK', tags={'foo': 'bar'}, message='baz'), '_sc|srv|0|#foo:bar|m:baz'), ] @pytest.mark.parametrize('check,expected', checks) def test_checks(check,expected): handler = aiomeasures.Datadog(':0') assert handler.format(check) == expected @asyncio.coroutine def fake_server(event_loop, port=None): port = port or 0 class Protocol: msg = [] def connection_made(self, transport): self.transport = transport def datagram_received(self, data, addr): message = data.decode().strip() self.msg.extend(message.split()) def connection_lost(self, *args): pass transport, protocol = yield from event_loop.create_datagram_endpoint( lambda: Protocol(), local_addr=('0.0.0.0', port) ) if port == 0: _, port = transport.get_extra_info('sockname') return transport, protocol, port @pytest.mark.asyncio def test_client_event(event_loop): transport, protocol, port = yield from fake_server(event_loop) client = aiomeasures.Datadog('udp://127.0.0.1:%s' % port) asyncio.sleep(.4) client.event('title', 'text') yield from asyncio.sleep(.1) assert '_e{5,4}title|text' in protocol.msg transport.close() client.close() @pytest.mark.asyncio def test_client(event_loop): transport, protocol, port = yield from fake_server(event_loop) client = aiomeasures.Datadog('udp://127.0.0.1:%s' % port) asyncio.sleep(.4) client.incr('example.a') client.timing('example.b', 500) client.gauge('example.c', 1) client.set('example.d', 'bar') client.decr('example.e') client.counter('example.f', 42) client.histogram('example.g', 13) yield from asyncio.sleep(.1) assert 'example.a:1|c' in protocol.msg assert 'example.b:500|ms' in protocol.msg assert 'example.c:1|g' in protocol.msg assert 'example.d:bar|s' in protocol.msg assert 'example.e:-1|c' in protocol.msg assert 'example.f:42|c' in protocol.msg assert 'example.g:13|h' in protocol.msg transport.close() client.close() @pytest.mark.asyncio def test_reliablility(event_loop): transport, protocol, port = yield from fake_server(event_loop) client = aiomeasures.Datadog('udp://127.0.0.1:%s' % port) asyncio.sleep(.4) client.incr('example.a') yield from asyncio.sleep(.1) assert 'example.a:1|c' in protocol.msg transport.close() client.incr('example.b') yield from asyncio.sleep(.1) assert 'example.b:1|c' not in protocol.msg transport, protocol, port = yield from fake_server(event_loop, port) client.incr('example.c') yield from asyncio.sleep(.1) assert 'example.c:1|c' in protocol.msg transport.close() client.close() aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/tests/test_statsd.py000066400000000000000000000137231261437612200256510ustar00rootroot00000000000000import aiomeasures import asyncio import pytest from datetime import timedelta simple = [ (aiomeasures.CountingMetric('foo', 1), 'foo:1|c'), (aiomeasures.CountingMetric('foo', -1), 'foo:-1|c'), (aiomeasures.GaugeMetric('foo', 1), 'foo:1|g'), (aiomeasures.GaugeMetric('foo', -1), 'foo:-1|g'), (aiomeasures.HistogramMetric('foo', 42), 'foo:42|h'), (aiomeasures.HistogramMetric('foo', -42), 'foo:-42|h'), (aiomeasures.SetMetric('foo', 'bar'), 'foo:bar|s'), (aiomeasures.TimingMetric('foo', 100), 'foo:100|ms'), ] one_second = timedelta(seconds=1) twenty_ms = timedelta(microseconds=20000) rated = [ (aiomeasures.CountingMetric('foo', 1, 0.1), 'foo:1|c|@0.1'), (aiomeasures.GaugeMetric('foo', 1, 0.1), 'foo:1|g|@0.1'), (aiomeasures.SetMetric('foo', 'bar', 0.1), 'foo:bar|s|@0.1'), (aiomeasures.TimingMetric('foo', 100, 0.1), 'foo:100|ms|@0.1'), (aiomeasures.HistogramMetric('foo', -42, 0.1), 'foo:-42|h|@0.1'), (aiomeasures.CountingMetric('foo', 1, one_second), 'foo:1|c|@1'), (aiomeasures.GaugeMetric('foo', 1, one_second), 'foo:1|g|@1'), (aiomeasures.SetMetric('foo', 'bar', one_second), 'foo:bar|s|@1'), (aiomeasures.TimingMetric('foo', 100, one_second), 'foo:100|ms|@1'), (aiomeasures.HistogramMetric('foo', -42, one_second), 'foo:-42|h|@1'), (aiomeasures.CountingMetric('foo', 1, twenty_ms), 'foo:1|c|@0.02'), (aiomeasures.GaugeMetric('foo', 1, twenty_ms), 'foo:1|g|@0.02'), (aiomeasures.SetMetric('foo', 'bar', twenty_ms), 'foo:bar|s|@0.02'), (aiomeasures.TimingMetric('foo', 100, twenty_ms), 'foo:100|ms|@0.02'), (aiomeasures.HistogramMetric('foo', -42, twenty_ms), 'foo:-42|h|@0.02'), ] tagged = [ (aiomeasures.CountingMetric('foo', 1, tags={'bar': 'baz'}), 'foo:1|c|#bar:baz'), (aiomeasures.CountingMetric('foo', -1, tags={'bar': 'baz'}), 'foo:-1|c|#bar:baz'), (aiomeasures.GaugeMetric('foo', 1, tags={'bar': 'baz'}), 'foo:1|g|#bar:baz'), (aiomeasures.GaugeMetric('foo', -1, tags={'bar': 'baz'}), 'foo:-1|g|#bar:baz'), (aiomeasures.SetMetric('foo', 'bar', tags={'bar': 'baz'}), 'foo:bar|s|#bar:baz'), (aiomeasures.TimingMetric('foo', 100, tags={'bar': 'baz'}), 'foo:100|ms|#bar:baz'), ] whole = simple + rated + tagged @pytest.mark.parametrize('metric,expected', whole) def test_formatting(metric, expected): handler = aiomeasures.StatsD(':0') assert handler.format(metric) == expected tags = [ ({}, {}, ''), ({'bar': 'baz'}, {}, '|#bar:baz'), ({}, {'bar': 'baz'}, '|#bar:baz'), ({'bar': 'baz'}, {'bar': 'qux'}, '|#bar:baz,bar:qux'), ] @pytest.mark.parametrize('tags,defaults,expected', tags) def test_tags(tags, defaults, expected): metric = aiomeasures.CountingMetric('foo', 1, tags=tags) handler = aiomeasures.StatsD(':0', tags=defaults) assert handler.format(metric) == 'foo:1|c%s' % expected def test_events(): event = aiomeasures.Event('Man down!', 'This server needs assistance.') handler = aiomeasures.StatsD(':0') assert handler.format(event) == '_e{9,29}Man down!|This server needs assistance.' checks = [ (aiomeasures.Check('srv', 'OK'), '_sc|srv|0'), (aiomeasures.Check('srv', 'warning'), '_sc|srv|1'), (aiomeasures.Check('srv', 'crit'), '_sc|srv|2'), (aiomeasures.Check('srv', 'UNKNOWN'), '_sc|srv|3'), (aiomeasures.Check('srv', 'OK', tags={'foo': 'bar'}, message='baz'), '_sc|srv|0|#foo:bar|m:baz'), ] @pytest.mark.parametrize('check,expected', checks) def test_checks(check,expected): handler = aiomeasures.StatsD(':0') assert handler.format(check) == expected @asyncio.coroutine def fake_server(event_loop, port=None): port = port or 0 class Protocol: msg = [] def connection_made(self, transport): self.transport = transport def datagram_received(self, data, addr): message = data.decode().strip() self.msg.extend(message.split()) def connection_lost(self, *args): pass transport, protocol = yield from event_loop.create_datagram_endpoint( lambda: Protocol(), local_addr=('0.0.0.0', port) ) if port == 0: _, port = transport.get_extra_info('sockname') return transport, protocol, port @pytest.mark.asyncio def test_client_event(event_loop): transport, protocol, port = yield from fake_server(event_loop) client = aiomeasures.StatsD('udp://127.0.0.1:%s' % port) asyncio.sleep(.4) client.event('title', 'text') yield from asyncio.sleep(.1) assert '_e{5,4}title|text' in protocol.msg transport.close() client.close() @pytest.mark.asyncio def test_client(event_loop): transport, protocol, port = yield from fake_server(event_loop) client = aiomeasures.StatsD('udp://127.0.0.1:%s' % port) asyncio.sleep(.4) client.incr('example.a') client.timing('example.b', 500) client.gauge('example.c', 1) client.set('example.d', 'bar') client.decr('example.e') client.counter('example.f', 42) client.histogram('example.g', 13) yield from asyncio.sleep(.1) assert 'example.a:1|c' in protocol.msg assert 'example.b:500|ms' in protocol.msg assert 'example.c:1|g' in protocol.msg assert 'example.d:bar|s' in protocol.msg assert 'example.e:-1|c' in protocol.msg assert 'example.f:42|c' in protocol.msg assert 'example.g:13|h' in protocol.msg transport.close() client.close() @pytest.mark.asyncio def test_reliablility(event_loop): transport, protocol, port = yield from fake_server(event_loop) client = aiomeasures.StatsD('udp://127.0.0.1:%s' % port) asyncio.sleep(.4) client.incr('example.a') yield from asyncio.sleep(.1) assert 'example.a:1|c' in protocol.msg transport.close() client.incr('example.b') yield from asyncio.sleep(.1) assert 'example.b:1|c' not in protocol.msg transport, protocol, port = yield from fake_server(event_loop, port) client.incr('example.c') yield from asyncio.sleep(.1) assert 'example.c:1|c' in protocol.msg transport.close() client.close() aiomeasures-v0.5.14-5bde8a08fb0ef6346e2e67c8203b84011a124315/versioneer.py000066400000000000000000001720121261437612200243240ustar00rootroot00000000000000 # Version: 0.15 """ The Versioneer ============== * like a rocketeer, but for versions! * https://github.com/warner/python-versioneer * Brian Warner * License: Public Domain * Compatible With: python2.6, 2.7, 3.2, 3.3, 3.4, and pypy * [![Latest Version] (https://pypip.in/version/versioneer/badge.svg?style=flat) ](https://pypi.python.org/pypi/versioneer/) * [![Build Status] (https://travis-ci.org/warner/python-versioneer.png?branch=master) ](https://travis-ci.org/warner/python-versioneer) This is a tool for managing a recorded version number in distutils-based python projects. The goal is to remove the tedious and error-prone "update the embedded version string" step from your release process. Making a new release should be as easy as recording a new tag in your version-control system, and maybe making new tarballs. ## Quick Install * `pip install versioneer` to somewhere to your $PATH * add a `[versioneer]` section to your setup.cfg (see below) * run `versioneer install` in your source tree, commit the results ## Version Identifiers Source trees come from a variety of places: * a version-control system checkout (mostly used by developers) * a nightly tarball, produced by build automation * a snapshot tarball, produced by a web-based VCS browser, like github's "tarball from tag" feature * a release tarball, produced by "setup.py sdist", distributed through PyPI Within each source tree, the version identifier (either a string or a number, this tool is format-agnostic) can come from a variety of places: * ask the VCS tool itself, e.g. "git describe" (for checkouts), which knows about recent "tags" and an absolute revision-id * the name of the directory into which the tarball was unpacked * an expanded VCS keyword ($Id$, etc) * a `_version.py` created by some earlier build step For released software, the version identifier is closely related to a VCS tag. Some projects use tag names that include more than just the version string (e.g. "myproject-1.2" instead of just "1.2"), in which case the tool needs to strip the tag prefix to extract the version identifier. For unreleased software (between tags), the version identifier should provide enough information to help developers recreate the same tree, while also giving them an idea of roughly how old the tree is (after version 1.2, before version 1.3). Many VCS systems can report a description that captures this, for example `git describe --tags --dirty --always` reports things like "0.7-1-g574ab98-dirty" to indicate that the checkout is one revision past the 0.7 tag, has a unique revision id of "574ab98", and is "dirty" (it has uncommitted changes. The version identifier is used for multiple purposes: * to allow the module to self-identify its version: `myproject.__version__` * to choose a name and prefix for a 'setup.py sdist' tarball ## Theory of Operation Versioneer works by adding a special `_version.py` file into your source tree, where your `__init__.py` can import it. This `_version.py` knows how to dynamically ask the VCS tool for version information at import time. `_version.py` also contains `$Revision$` markers, and the installation process marks `_version.py` to have this marker rewritten with a tag name during the `git archive` command. As a result, generated tarballs will contain enough information to get the proper version. To allow `setup.py` to compute a version too, a `versioneer.py` is added to the top level of your source tree, next to `setup.py` and the `setup.cfg` that configures it. This overrides several distutils/setuptools commands to compute the version when invoked, and changes `setup.py build` and `setup.py sdist` to replace `_version.py` with a small static file that contains just the generated version data. ## Installation First, decide on values for the following configuration variables: * `VCS`: the version control system you use. Currently accepts "git". * `style`: the style of version string to be produced. See "Styles" below for details. Defaults to "pep440", which looks like `TAG[+DISTANCE.gSHORTHASH[.dirty]]`. * `versionfile_source`: A project-relative pathname into which the generated version strings should be written. This is usually a `_version.py` next to your project's main `__init__.py` file, so it can be imported at runtime. If your project uses `src/myproject/__init__.py`, this should be `src/myproject/_version.py`. This file should be checked in to your VCS as usual: the copy created below by `setup.py setup_versioneer` will include code that parses expanded VCS keywords in generated tarballs. The 'build' and 'sdist' commands will replace it with a copy that has just the calculated version string. This must be set even if your project does not have any modules (and will therefore never import `_version.py`), since "setup.py sdist" -based trees still need somewhere to record the pre-calculated version strings. Anywhere in the source tree should do. If there is a `__init__.py` next to your `_version.py`, the `setup.py setup_versioneer` command (described below) will append some `__version__`-setting assignments, if they aren't already present. * `versionfile_build`: Like `versionfile_source`, but relative to the build directory instead of the source directory. These will differ when your setup.py uses 'package_dir='. If you have `package_dir={'myproject': 'src/myproject'}`, then you will probably have `versionfile_build='myproject/_version.py'` and `versionfile_source='src/myproject/_version.py'`. If this is set to None, then `setup.py build` will not attempt to rewrite any `_version.py` in the built tree. If your project does not have any libraries (e.g. if it only builds a script), then you should use `versionfile_build = None` and override `distutils.command.build_scripts` to explicitly insert a copy of `versioneer.get_version()` into your generated script. * `tag_prefix`: a string, like 'PROJECTNAME-', which appears at the start of all VCS tags. If your tags look like 'myproject-1.2.0', then you should use tag_prefix='myproject-'. If you use unprefixed tags like '1.2.0', this should be an empty string. * `parentdir_prefix`: a optional string, frequently the same as tag_prefix, which appears at the start of all unpacked tarball filenames. If your tarball unpacks into 'myproject-1.2.0', this should be 'myproject-'. To disable this feature, just omit the field from your `setup.cfg`. This tool provides one script, named `versioneer`. That script has one mode, "install", which writes a copy of `versioneer.py` into the current directory and runs `versioneer.py setup` to finish the installation. To versioneer-enable your project: * 1: Modify your `setup.cfg`, adding a section named `[versioneer]` and populating it with the configuration values you decided earlier (note that the option names are not case-sensitive): ```` [versioneer] VCS = git style = pep440 versionfile_source = src/myproject/_version.py versionfile_build = myproject/_version.py tag_prefix = "" parentdir_prefix = myproject- ```` * 2: Run `versioneer install`. This will do the following: * copy `versioneer.py` into the top of your source tree * create `_version.py` in the right place (`versionfile_source`) * modify your `__init__.py` (if one exists next to `_version.py`) to define `__version__` (by calling a function from `_version.py`) * modify your `MANIFEST.in` to include both `versioneer.py` and the generated `_version.py` in sdist tarballs `versioneer install` will complain about any problems it finds with your `setup.py` or `setup.cfg`. Run it multiple times until you have fixed all the problems. * 3: add a `import versioneer` to your setup.py, and add the following arguments to the setup() call: version=versioneer.get_version(), cmdclass=versioneer.get_cmdclass(), * 4: commit these changes to your VCS. To make sure you won't forget, `versioneer install` will mark everything it touched for addition using `git add`. Don't forget to add `setup.py` and `setup.cfg` too. ## Post-Installation Usage Once established, all uses of your tree from a VCS checkout should get the current version string. All generated tarballs should include an embedded version string (so users who unpack them will not need a VCS tool installed). If you distribute your project through PyPI, then the release process should boil down to two steps: * 1: git tag 1.0 * 2: python setup.py register sdist upload If you distribute it through github (i.e. users use github to generate tarballs with `git archive`), the process is: * 1: git tag 1.0 * 2: git push; git push --tags Versioneer will report "0+untagged.NUMCOMMITS.gHASH" until your tree has at least one tag in its history. ## Version-String Flavors Code which uses Versioneer can learn about its version string at runtime by importing `_version` from your main `__init__.py` file and running the `get_versions()` function. From the "outside" (e.g. in `setup.py`), you can import the top-level `versioneer.py` and run `get_versions()`. Both functions return a dictionary with different flavors of version information: * `['version']`: A condensed version string, rendered using the selected style. This is the most commonly used value for the project's version string. The default "pep440" style yields strings like `0.11`, `0.11+2.g1076c97`, or `0.11+2.g1076c97.dirty`. See the "Styles" section below for alternative styles. * `['full-revisionid']`: detailed revision identifier. For Git, this is the full SHA1 commit id, e.g. "1076c978a8d3cfc70f408fe5974aa6c092c949ac". * `['dirty']`: a boolean, True if the tree has uncommitted changes. Note that this is only accurate if run in a VCS checkout, otherwise it is likely to be False or None * `['error']`: if the version string could not be computed, this will be set to a string describing the problem, otherwise it will be None. It may be useful to throw an exception in setup.py if this is set, to avoid e.g. creating tarballs with a version string of "unknown". Some variants are more useful than others. Including `full-revisionid` in a bug report should allow developers to reconstruct the exact code being tested (or indicate the presence of local changes that should be shared with the developers). `version` is suitable for display in an "about" box or a CLI `--version` output: it can be easily compared against release notes and lists of bugs fixed in various releases. The installer adds the following text to your `__init__.py` to place a basic version in `YOURPROJECT.__version__`: from ._version import get_versions __version__ = get_versions()['version'] del get_versions ## Styles The setup.cfg `style=` configuration controls how the VCS information is rendered into a version string. The default style, "pep440", produces a PEP440-compliant string, equal to the un-prefixed tag name for actual releases, and containing an additional "local version" section with more detail for in-between builds. For Git, this is TAG[+DISTANCE.gHEX[.dirty]] , using information from `git describe --tags --dirty --always`. For example "0.11+2.g1076c97.dirty" indicates that the tree is like the "1076c97" commit but has uncommitted changes (".dirty"), and that this commit is two revisions ("+2") beyond the "0.11" tag. For released software (exactly equal to a known tag), the identifier will only contain the stripped tag, e.g. "0.11". Other styles are available. See details.md in the Versioneer source tree for descriptions. ## Debugging Versioneer tries to avoid fatal errors: if something goes wrong, it will tend to return a version of "0+unknown". To investigate the problem, run `setup.py version`, which will run the version-lookup code in a verbose mode, and will display the full contents of `get_versions()` (including the `error` string, which may help identify what went wrong). ## Updating Versioneer To upgrade your project to a new release of Versioneer, do the following: * install the new Versioneer (`pip install -U versioneer` or equivalent) * edit `setup.cfg`, if necessary, to include any new configuration settings indicated by the release notes * re-run `versioneer install` in your source tree, to replace `SRC/_version.py` * commit any changed files ### Upgrading to 0.15 Starting with this version, Versioneer is configured with a `[versioneer]` section in your `setup.cfg` file. Earlier versions required the `setup.py` to set attributes on the `versioneer` module immediately after import. The new version will refuse to run (raising an exception during import) until you have provided the necessary `setup.cfg` section. In addition, the Versioneer package provides an executable named `versioneer`, and the installation process is driven by running `versioneer install`. In 0.14 and earlier, the executable was named `versioneer-installer` and was run without an argument. ### Upgrading to 0.14 0.14 changes the format of the version string. 0.13 and earlier used hyphen-separated strings like "0.11-2-g1076c97-dirty". 0.14 and beyond use a plus-separated "local version" section strings, with dot-separated components, like "0.11+2.g1076c97". PEP440-strict tools did not like the old format, but should be ok with the new one. ### Upgrading from 0.11 to 0.12 Nothing special. ### Upgrading from 0.10 to 0.11 You must add a `versioneer.VCS = "git"` to your `setup.py` before re-running `setup.py setup_versioneer`. This will enable the use of additional version-control systems (SVN, etc) in the future. ## Future Directions This tool is designed to make it easily extended to other version-control systems: all VCS-specific components are in separate directories like src/git/ . The top-level `versioneer.py` script is assembled from these components by running make-versioneer.py . In the future, make-versioneer.py will take a VCS name as an argument, and will construct a version of `versioneer.py` that is specific to the given VCS. It might also take the configuration arguments that are currently provided manually during installation by editing setup.py . Alternatively, it might go the other direction and include code from all supported VCS systems, reducing the number of intermediate scripts. ## License To make Versioneer easier to embed, all its code is hereby released into the public domain. The `_version.py` that it creates is also in the public domain. """ from __future__ import print_function try: import configparser except ImportError: import ConfigParser as configparser import errno import json import os import re import subprocess import sys class VersioneerConfig: pass def get_root(): # we require that all commands are run from the project root, i.e. the # directory that contains setup.py, setup.cfg, and versioneer.py . root = os.path.realpath(os.path.abspath(os.getcwd())) setup_py = os.path.join(root, "setup.py") versioneer_py = os.path.join(root, "versioneer.py") if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)): # allow 'python path/to/setup.py COMMAND' root = os.path.dirname(os.path.realpath(os.path.abspath(sys.argv[0]))) setup_py = os.path.join(root, "setup.py") versioneer_py = os.path.join(root, "versioneer.py") if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)): err = ("Versioneer was unable to run the project root directory. " "Versioneer requires setup.py to be executed from " "its immediate directory (like 'python setup.py COMMAND'), " "or in a way that lets it use sys.argv[0] to find the root " "(like 'python path/to/setup.py COMMAND').") raise VersioneerBadRootError(err) try: # Certain runtime workflows (setup.py install/develop in a setuptools # tree) execute all dependencies in a single python process, so # "versioneer" may be imported multiple times, and python's shared # module-import table will cache the first one. So we can't use # os.path.dirname(__file__), as that will find whichever # versioneer.py was first imported, even in later projects. me = os.path.realpath(os.path.abspath(__file__)) if os.path.splitext(me)[0] != os.path.splitext(versioneer_py)[0]: print("Warning: build in %s is using versioneer.py from %s" % (os.path.dirname(me), versioneer_py)) except NameError: pass return root def get_config_from_root(root): # This might raise EnvironmentError (if setup.cfg is missing), or # configparser.NoSectionError (if it lacks a [versioneer] section), or # configparser.NoOptionError (if it lacks "VCS="). See the docstring at # the top of versioneer.py for instructions on writing your setup.cfg . setup_cfg = os.path.join(root, "setup.cfg") parser = configparser.SafeConfigParser() with open(setup_cfg, "r") as f: parser.readfp(f) VCS = parser.get("versioneer", "VCS") # mandatory def get(parser, name): if parser.has_option("versioneer", name): return parser.get("versioneer", name) return None cfg = VersioneerConfig() cfg.VCS = VCS cfg.style = get(parser, "style") or "" cfg.versionfile_source = get(parser, "versionfile_source") cfg.versionfile_build = get(parser, "versionfile_build") cfg.tag_prefix = get(parser, "tag_prefix") cfg.parentdir_prefix = get(parser, "parentdir_prefix") cfg.verbose = get(parser, "verbose") return cfg class NotThisMethod(Exception): pass # these dictionaries contain VCS-specific tools LONG_VERSION_PY = {} HANDLERS = {} def register_vcs_handler(vcs, method): # decorator def decorate(f): if vcs not in HANDLERS: HANDLERS[vcs] = {} HANDLERS[vcs][method] = f return f return decorate def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False): assert isinstance(commands, list) p = None for c in commands: try: dispcmd = str([c] + args) # remember shell=False, so use git.cmd on windows, not just git p = subprocess.Popen([c] + args, cwd=cwd, stdout=subprocess.PIPE, stderr=(subprocess.PIPE if hide_stderr else None)) break except EnvironmentError: e = sys.exc_info()[1] if e.errno == errno.ENOENT: continue if verbose: print("unable to run %s" % dispcmd) print(e) return None else: if verbose: print("unable to find command, tried %s" % (commands,)) return None stdout = p.communicate()[0].strip() if sys.version_info[0] >= 3: stdout = stdout.decode() if p.returncode != 0: if verbose: print("unable to run %s (error)" % dispcmd) return None return stdout LONG_VERSION_PY['git'] = ''' # This file helps to compute a version number in source trees obtained from # git-archive tarball (such as those provided by githubs download-from-tag # feature). Distribution tarballs (built by setup.py sdist) and build # directories (produced by setup.py build) will contain a much shorter file # that just contains the computed version number. # This file is released into the public domain. Generated by # versioneer-0.15 (https://github.com/warner/python-versioneer) import errno import os import re import subprocess import sys def get_keywords(): # these strings will be replaced by git during git-archive. # setup.py/versioneer.py will grep for the variable names, so they must # each be defined on a line of their own. _version.py will just call # get_keywords(). git_refnames = "%(DOLLAR)sFormat:%%d%(DOLLAR)s" git_full = "%(DOLLAR)sFormat:%%H%(DOLLAR)s" keywords = {"refnames": git_refnames, "full": git_full} return keywords class VersioneerConfig: pass def get_config(): # these strings are filled in when 'setup.py versioneer' creates # _version.py cfg = VersioneerConfig() cfg.VCS = "git" cfg.style = "%(STYLE)s" cfg.tag_prefix = "%(TAG_PREFIX)s" cfg.parentdir_prefix = "%(PARENTDIR_PREFIX)s" cfg.versionfile_source = "%(VERSIONFILE_SOURCE)s" cfg.verbose = False return cfg class NotThisMethod(Exception): pass LONG_VERSION_PY = {} HANDLERS = {} def register_vcs_handler(vcs, method): # decorator def decorate(f): if vcs not in HANDLERS: HANDLERS[vcs] = {} HANDLERS[vcs][method] = f return f return decorate def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False): assert isinstance(commands, list) p = None for c in commands: try: dispcmd = str([c] + args) # remember shell=False, so use git.cmd on windows, not just git p = subprocess.Popen([c] + args, cwd=cwd, stdout=subprocess.PIPE, stderr=(subprocess.PIPE if hide_stderr else None)) break except EnvironmentError: e = sys.exc_info()[1] if e.errno == errno.ENOENT: continue if verbose: print("unable to run %%s" %% dispcmd) print(e) return None else: if verbose: print("unable to find command, tried %%s" %% (commands,)) return None stdout = p.communicate()[0].strip() if sys.version_info[0] >= 3: stdout = stdout.decode() if p.returncode != 0: if verbose: print("unable to run %%s (error)" %% dispcmd) return None return stdout def versions_from_parentdir(parentdir_prefix, root, verbose): # Source tarballs conventionally unpack into a directory that includes # both the project name and a version string. dirname = os.path.basename(root) if not dirname.startswith(parentdir_prefix): if verbose: print("guessing rootdir is '%%s', but '%%s' doesn't start with " "prefix '%%s'" %% (root, dirname, parentdir_prefix)) raise NotThisMethod("rootdir doesn't start with parentdir_prefix") return {"version": dirname[len(parentdir_prefix):], "full-revisionid": None, "dirty": False, "error": None} @register_vcs_handler("git", "get_keywords") def git_get_keywords(versionfile_abs): # the code embedded in _version.py can just fetch the value of these # keywords. When used from setup.py, we don't want to import _version.py, # so we do it with a regexp instead. This function is not used from # _version.py. keywords = {} try: f = open(versionfile_abs, "r") for line in f.readlines(): if line.strip().startswith("git_refnames ="): mo = re.search(r'=\s*"(.*)"', line) if mo: keywords["refnames"] = mo.group(1) if line.strip().startswith("git_full ="): mo = re.search(r'=\s*"(.*)"', line) if mo: keywords["full"] = mo.group(1) f.close() except EnvironmentError: pass return keywords @register_vcs_handler("git", "keywords") def git_versions_from_keywords(keywords, tag_prefix, verbose): if not keywords: raise NotThisMethod("no keywords at all, weird") refnames = keywords["refnames"].strip() if refnames.startswith("$Format"): if verbose: print("keywords are unexpanded, not using") raise NotThisMethod("unexpanded keywords, not a git-archive tarball") refs = set([r.strip() for r in refnames.strip("()").split(",")]) # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of # just "foo-1.0". If we see a "tag: " prefix, prefer those. TAG = "tag: " tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)]) if not tags: # Either we're using git < 1.8.3, or there really are no tags. We use # a heuristic: assume all version tags have a digit. The old git %%d # expansion behaves like git log --decorate=short and strips out the # refs/heads/ and refs/tags/ prefixes that would let us distinguish # between branches and tags. By ignoring refnames without digits, we # filter out many common branch names like "release" and # "stabilization", as well as "HEAD" and "master". tags = set([r for r in refs if re.search(r'\d', r)]) if verbose: print("discarding '%%s', no digits" %% ",".join(refs-tags)) if verbose: print("likely tags: %%s" %% ",".join(sorted(tags))) for ref in sorted(tags): # sorting will prefer e.g. "2.0" over "2.0rc1" if ref.startswith(tag_prefix): r = ref[len(tag_prefix):] if verbose: print("picking %%s" %% r) return {"version": r, "full-revisionid": keywords["full"].strip(), "dirty": False, "error": None } # no suitable tags, so version is "0+unknown", but full hex is still there if verbose: print("no suitable tags, using unknown + full revision id") return {"version": "0+unknown", "full-revisionid": keywords["full"].strip(), "dirty": False, "error": "no suitable tags"} @register_vcs_handler("git", "pieces_from_vcs") def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): # this runs 'git' from the root of the source tree. This only gets called # if the git-archive 'subst' keywords were *not* expanded, and # _version.py hasn't already been rewritten with a short version string, # meaning we're inside a checked out source tree. if not os.path.exists(os.path.join(root, ".git")): if verbose: print("no .git in %%s" %% root) raise NotThisMethod("no .git directory") GITS = ["git"] if sys.platform == "win32": GITS = ["git.cmd", "git.exe"] # if there is a tag, this yields TAG-NUM-gHEX[-dirty] # if there are no tags, this yields HEX[-dirty] (no NUM) describe_out = run_command(GITS, ["describe", "--tags", "--dirty", "--always", "--long"], cwd=root) # --long was added in git-1.5.5 if describe_out is None: raise NotThisMethod("'git describe' failed") describe_out = describe_out.strip() full_out = run_command(GITS, ["rev-parse", "HEAD"], cwd=root) if full_out is None: raise NotThisMethod("'git rev-parse' failed") full_out = full_out.strip() pieces = {} pieces["long"] = full_out pieces["short"] = full_out[:7] # maybe improved later pieces["error"] = None # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] # TAG might have hyphens. git_describe = describe_out # look for -dirty suffix dirty = git_describe.endswith("-dirty") pieces["dirty"] = dirty if dirty: git_describe = git_describe[:git_describe.rindex("-dirty")] # now we have TAG-NUM-gHEX or HEX if "-" in git_describe: # TAG-NUM-gHEX mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) if not mo: # unparseable. Maybe git-describe is misbehaving? pieces["error"] = ("unable to parse git-describe output: '%%s'" %% describe_out) return pieces # tag full_tag = mo.group(1) if not full_tag.startswith(tag_prefix): if verbose: fmt = "tag '%%s' doesn't start with prefix '%%s'" print(fmt %% (full_tag, tag_prefix)) pieces["error"] = ("tag '%%s' doesn't start with prefix '%%s'" %% (full_tag, tag_prefix)) return pieces pieces["closest-tag"] = full_tag[len(tag_prefix):] # distance: number of commits since tag pieces["distance"] = int(mo.group(2)) # commit: short hex revision ID pieces["short"] = mo.group(3) else: # HEX: no tags pieces["closest-tag"] = None count_out = run_command(GITS, ["rev-list", "HEAD", "--count"], cwd=root) pieces["distance"] = int(count_out) # total number of commits return pieces def plus_or_dot(pieces): if "+" in pieces.get("closest-tag", ""): return "." return "+" def render_pep440(pieces): # now build up version string, with post-release "local version # identifier". Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you # get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty # exceptions: # 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"] or pieces["dirty"]: rendered += plus_or_dot(pieces) rendered += "%%d.g%%s" %% (pieces["distance"], pieces["short"]) if pieces["dirty"]: rendered += ".dirty" else: # exception #1 rendered = "0+untagged.%%d.g%%s" %% (pieces["distance"], pieces["short"]) if pieces["dirty"]: rendered += ".dirty" return rendered def render_pep440_pre(pieces): # TAG[.post.devDISTANCE] . No -dirty # exceptions: # 1: no tags. 0.post.devDISTANCE if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"]: rendered += ".post.dev%%d" %% pieces["distance"] else: # exception #1 rendered = "0.post.dev%%d" %% pieces["distance"] return rendered def render_pep440_post(pieces): # TAG[.postDISTANCE[.dev0]+gHEX] . The ".dev0" means dirty. Note that # .dev0 sorts backwards (a dirty tree will appear "older" than the # corresponding clean one), but you shouldn't be releasing software with # -dirty anyways. # exceptions: # 1: no tags. 0.postDISTANCE[.dev0] if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"] or pieces["dirty"]: rendered += ".post%%d" %% pieces["distance"] if pieces["dirty"]: rendered += ".dev0" rendered += plus_or_dot(pieces) rendered += "g%%s" %% pieces["short"] else: # exception #1 rendered = "0.post%%d" %% pieces["distance"] if pieces["dirty"]: rendered += ".dev0" rendered += "+g%%s" %% pieces["short"] return rendered def render_pep440_old(pieces): # TAG[.postDISTANCE[.dev0]] . The ".dev0" means dirty. # exceptions: # 1: no tags. 0.postDISTANCE[.dev0] if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"] or pieces["dirty"]: rendered += ".post%%d" %% pieces["distance"] if pieces["dirty"]: rendered += ".dev0" else: # exception #1 rendered = "0.post%%d" %% pieces["distance"] if pieces["dirty"]: rendered += ".dev0" return rendered def render_git_describe(pieces): # TAG[-DISTANCE-gHEX][-dirty], like 'git describe --tags --dirty # --always' # exceptions: # 1: no tags. HEX[-dirty] (note: no 'g' prefix) if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"]: rendered += "-%%d-g%%s" %% (pieces["distance"], pieces["short"]) else: # exception #1 rendered = pieces["short"] if pieces["dirty"]: rendered += "-dirty" return rendered def render_git_describe_long(pieces): # TAG-DISTANCE-gHEX[-dirty], like 'git describe --tags --dirty # --always -long'. The distance/hash is unconditional. # exceptions: # 1: no tags. HEX[-dirty] (note: no 'g' prefix) if pieces["closest-tag"]: rendered = pieces["closest-tag"] rendered += "-%%d-g%%s" %% (pieces["distance"], pieces["short"]) else: # exception #1 rendered = pieces["short"] if pieces["dirty"]: rendered += "-dirty" return rendered def render(pieces, style): if pieces["error"]: return {"version": "unknown", "full-revisionid": pieces.get("long"), "dirty": None, "error": pieces["error"]} if not style or style == "default": style = "pep440" # the default if style == "pep440": rendered = render_pep440(pieces) elif style == "pep440-pre": rendered = render_pep440_pre(pieces) elif style == "pep440-post": rendered = render_pep440_post(pieces) elif style == "pep440-old": rendered = render_pep440_old(pieces) elif style == "git-describe": rendered = render_git_describe(pieces) elif style == "git-describe-long": rendered = render_git_describe_long(pieces) else: raise ValueError("unknown style '%%s'" %% style) return {"version": rendered, "full-revisionid": pieces["long"], "dirty": pieces["dirty"], "error": None} def get_versions(): # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have # __file__, we can work backwards from there to the root. Some # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which # case we can only use expanded keywords. cfg = get_config() verbose = cfg.verbose try: return git_versions_from_keywords(get_keywords(), cfg.tag_prefix, verbose) except NotThisMethod: pass try: root = os.path.realpath(__file__) # versionfile_source is the relative path from the top of the source # tree (where the .git directory might live) to this file. Invert # this to find the root from __file__. for i in cfg.versionfile_source.split('/'): root = os.path.dirname(root) except NameError: return {"version": "0+unknown", "full-revisionid": None, "dirty": None, "error": "unable to find root of source tree"} try: pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose) return render(pieces, cfg.style) except NotThisMethod: pass try: if cfg.parentdir_prefix: return versions_from_parentdir(cfg.parentdir_prefix, root, verbose) except NotThisMethod: pass return {"version": "0+unknown", "full-revisionid": None, "dirty": None, "error": "unable to compute version"} ''' @register_vcs_handler("git", "get_keywords") def git_get_keywords(versionfile_abs): # the code embedded in _version.py can just fetch the value of these # keywords. When used from setup.py, we don't want to import _version.py, # so we do it with a regexp instead. This function is not used from # _version.py. keywords = {} try: f = open(versionfile_abs, "r") for line in f.readlines(): if line.strip().startswith("git_refnames ="): mo = re.search(r'=\s*"(.*)"', line) if mo: keywords["refnames"] = mo.group(1) if line.strip().startswith("git_full ="): mo = re.search(r'=\s*"(.*)"', line) if mo: keywords["full"] = mo.group(1) f.close() except EnvironmentError: pass return keywords @register_vcs_handler("git", "keywords") def git_versions_from_keywords(keywords, tag_prefix, verbose): if not keywords: raise NotThisMethod("no keywords at all, weird") refnames = keywords["refnames"].strip() if refnames.startswith("$Format"): if verbose: print("keywords are unexpanded, not using") raise NotThisMethod("unexpanded keywords, not a git-archive tarball") refs = set([r.strip() for r in refnames.strip("()").split(",")]) # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of # just "foo-1.0". If we see a "tag: " prefix, prefer those. TAG = "tag: " tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)]) if not tags: # Either we're using git < 1.8.3, or there really are no tags. We use # a heuristic: assume all version tags have a digit. The old git %d # expansion behaves like git log --decorate=short and strips out the # refs/heads/ and refs/tags/ prefixes that would let us distinguish # between branches and tags. By ignoring refnames without digits, we # filter out many common branch names like "release" and # "stabilization", as well as "HEAD" and "master". tags = set([r for r in refs if re.search(r'\d', r)]) if verbose: print("discarding '%s', no digits" % ",".join(refs-tags)) if verbose: print("likely tags: %s" % ",".join(sorted(tags))) for ref in sorted(tags): # sorting will prefer e.g. "2.0" over "2.0rc1" if ref.startswith(tag_prefix): r = ref[len(tag_prefix):] if verbose: print("picking %s" % r) return {"version": r, "full-revisionid": keywords["full"].strip(), "dirty": False, "error": None } # no suitable tags, so version is "0+unknown", but full hex is still there if verbose: print("no suitable tags, using unknown + full revision id") return {"version": "0+unknown", "full-revisionid": keywords["full"].strip(), "dirty": False, "error": "no suitable tags"} @register_vcs_handler("git", "pieces_from_vcs") def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): # this runs 'git' from the root of the source tree. This only gets called # if the git-archive 'subst' keywords were *not* expanded, and # _version.py hasn't already been rewritten with a short version string, # meaning we're inside a checked out source tree. if not os.path.exists(os.path.join(root, ".git")): if verbose: print("no .git in %s" % root) raise NotThisMethod("no .git directory") GITS = ["git"] if sys.platform == "win32": GITS = ["git.cmd", "git.exe"] # if there is a tag, this yields TAG-NUM-gHEX[-dirty] # if there are no tags, this yields HEX[-dirty] (no NUM) describe_out = run_command(GITS, ["describe", "--tags", "--dirty", "--always", "--long"], cwd=root) # --long was added in git-1.5.5 if describe_out is None: raise NotThisMethod("'git describe' failed") describe_out = describe_out.strip() full_out = run_command(GITS, ["rev-parse", "HEAD"], cwd=root) if full_out is None: raise NotThisMethod("'git rev-parse' failed") full_out = full_out.strip() pieces = {} pieces["long"] = full_out pieces["short"] = full_out[:7] # maybe improved later pieces["error"] = None # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] # TAG might have hyphens. git_describe = describe_out # look for -dirty suffix dirty = git_describe.endswith("-dirty") pieces["dirty"] = dirty if dirty: git_describe = git_describe[:git_describe.rindex("-dirty")] # now we have TAG-NUM-gHEX or HEX if "-" in git_describe: # TAG-NUM-gHEX mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) if not mo: # unparseable. Maybe git-describe is misbehaving? pieces["error"] = ("unable to parse git-describe output: '%s'" % describe_out) return pieces # tag full_tag = mo.group(1) if not full_tag.startswith(tag_prefix): if verbose: fmt = "tag '%s' doesn't start with prefix '%s'" print(fmt % (full_tag, tag_prefix)) pieces["error"] = ("tag '%s' doesn't start with prefix '%s'" % (full_tag, tag_prefix)) return pieces pieces["closest-tag"] = full_tag[len(tag_prefix):] # distance: number of commits since tag pieces["distance"] = int(mo.group(2)) # commit: short hex revision ID pieces["short"] = mo.group(3) else: # HEX: no tags pieces["closest-tag"] = None count_out = run_command(GITS, ["rev-list", "HEAD", "--count"], cwd=root) pieces["distance"] = int(count_out) # total number of commits return pieces def do_vcs_install(manifest_in, versionfile_source, ipy): GITS = ["git"] if sys.platform == "win32": GITS = ["git.cmd", "git.exe"] files = [manifest_in, versionfile_source] if ipy: files.append(ipy) try: me = __file__ if me.endswith(".pyc") or me.endswith(".pyo"): me = os.path.splitext(me)[0] + ".py" versioneer_file = os.path.relpath(me) except NameError: versioneer_file = "versioneer.py" files.append(versioneer_file) present = False try: f = open(".gitattributes", "r") for line in f.readlines(): if line.strip().startswith(versionfile_source): if "export-subst" in line.strip().split()[1:]: present = True f.close() except EnvironmentError: pass if not present: f = open(".gitattributes", "a+") f.write("%s export-subst\n" % versionfile_source) f.close() files.append(".gitattributes") run_command(GITS, ["add", "--"] + files) def versions_from_parentdir(parentdir_prefix, root, verbose): # Source tarballs conventionally unpack into a directory that includes # both the project name and a version string. dirname = os.path.basename(root) if not dirname.startswith(parentdir_prefix): if verbose: print("guessing rootdir is '%s', but '%s' doesn't start with " "prefix '%s'" % (root, dirname, parentdir_prefix)) raise NotThisMethod("rootdir doesn't start with parentdir_prefix") return {"version": dirname[len(parentdir_prefix):], "full-revisionid": None, "dirty": False, "error": None} SHORT_VERSION_PY = """ # This file was generated by 'versioneer.py' (0.15) from # revision-control system data, or from the parent directory name of an # unpacked source archive. Distribution tarballs contain a pre-generated copy # of this file. import json import sys version_json = ''' %s ''' # END VERSION_JSON def get_versions(): return json.loads(version_json) """ def versions_from_file(filename): try: with open(filename) as f: contents = f.read() except EnvironmentError: raise NotThisMethod("unable to read _version.py") mo = re.search(r"version_json = '''\n(.*)''' # END VERSION_JSON", contents, re.M | re.S) if not mo: raise NotThisMethod("no version_json in _version.py") return json.loads(mo.group(1)) def write_to_version_file(filename, versions): os.unlink(filename) contents = json.dumps(versions, sort_keys=True, indent=1, separators=(",", ": ")) with open(filename, "w") as f: f.write(SHORT_VERSION_PY % contents) print("set %s to '%s'" % (filename, versions["version"])) def plus_or_dot(pieces): if "+" in pieces.get("closest-tag", ""): return "." return "+" def render_pep440(pieces): # now build up version string, with post-release "local version # identifier". Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you # get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty # exceptions: # 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"] or pieces["dirty"]: rendered += plus_or_dot(pieces) rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) if pieces["dirty"]: rendered += ".dirty" else: # exception #1 rendered = "0+untagged.%d.g%s" % (pieces["distance"], pieces["short"]) if pieces["dirty"]: rendered += ".dirty" return rendered def render_pep440_pre(pieces): # TAG[.post.devDISTANCE] . No -dirty # exceptions: # 1: no tags. 0.post.devDISTANCE if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"]: rendered += ".post.dev%d" % pieces["distance"] else: # exception #1 rendered = "0.post.dev%d" % pieces["distance"] return rendered def render_pep440_post(pieces): # TAG[.postDISTANCE[.dev0]+gHEX] . The ".dev0" means dirty. Note that # .dev0 sorts backwards (a dirty tree will appear "older" than the # corresponding clean one), but you shouldn't be releasing software with # -dirty anyways. # exceptions: # 1: no tags. 0.postDISTANCE[.dev0] if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"] or pieces["dirty"]: rendered += ".post%d" % pieces["distance"] if pieces["dirty"]: rendered += ".dev0" rendered += plus_or_dot(pieces) rendered += "g%s" % pieces["short"] else: # exception #1 rendered = "0.post%d" % pieces["distance"] if pieces["dirty"]: rendered += ".dev0" rendered += "+g%s" % pieces["short"] return rendered def render_pep440_old(pieces): # TAG[.postDISTANCE[.dev0]] . The ".dev0" means dirty. # exceptions: # 1: no tags. 0.postDISTANCE[.dev0] if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"] or pieces["dirty"]: rendered += ".post%d" % pieces["distance"] if pieces["dirty"]: rendered += ".dev0" else: # exception #1 rendered = "0.post%d" % pieces["distance"] if pieces["dirty"]: rendered += ".dev0" return rendered def render_git_describe(pieces): # TAG[-DISTANCE-gHEX][-dirty], like 'git describe --tags --dirty # --always' # exceptions: # 1: no tags. HEX[-dirty] (note: no 'g' prefix) if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"]: rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) else: # exception #1 rendered = pieces["short"] if pieces["dirty"]: rendered += "-dirty" return rendered def render_git_describe_long(pieces): # TAG-DISTANCE-gHEX[-dirty], like 'git describe --tags --dirty # --always -long'. The distance/hash is unconditional. # exceptions: # 1: no tags. HEX[-dirty] (note: no 'g' prefix) if pieces["closest-tag"]: rendered = pieces["closest-tag"] rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) else: # exception #1 rendered = pieces["short"] if pieces["dirty"]: rendered += "-dirty" return rendered def render(pieces, style): if pieces["error"]: return {"version": "unknown", "full-revisionid": pieces.get("long"), "dirty": None, "error": pieces["error"]} if not style or style == "default": style = "pep440" # the default if style == "pep440": rendered = render_pep440(pieces) elif style == "pep440-pre": rendered = render_pep440_pre(pieces) elif style == "pep440-post": rendered = render_pep440_post(pieces) elif style == "pep440-old": rendered = render_pep440_old(pieces) elif style == "git-describe": rendered = render_git_describe(pieces) elif style == "git-describe-long": rendered = render_git_describe_long(pieces) else: raise ValueError("unknown style '%s'" % style) return {"version": rendered, "full-revisionid": pieces["long"], "dirty": pieces["dirty"], "error": None} class VersioneerBadRootError(Exception): pass def get_versions(verbose=False): # returns dict with two keys: 'version' and 'full' if "versioneer" in sys.modules: # see the discussion in cmdclass.py:get_cmdclass() del sys.modules["versioneer"] root = get_root() cfg = get_config_from_root(root) assert cfg.VCS is not None, "please set [versioneer]VCS= in setup.cfg" handlers = HANDLERS.get(cfg.VCS) assert handlers, "unrecognized VCS '%s'" % cfg.VCS verbose = verbose or cfg.verbose assert cfg.versionfile_source is not None, \ "please set versioneer.versionfile_source" assert cfg.tag_prefix is not None, "please set versioneer.tag_prefix" versionfile_abs = os.path.join(root, cfg.versionfile_source) # extract version from first of: _version.py, VCS command (e.g. 'git # describe'), parentdir. This is meant to work for developers using a # source checkout, for users of a tarball created by 'setup.py sdist', # and for users of a tarball/zipball created by 'git archive' or github's # download-from-tag feature or the equivalent in other VCSes. get_keywords_f = handlers.get("get_keywords") from_keywords_f = handlers.get("keywords") if get_keywords_f and from_keywords_f: try: keywords = get_keywords_f(versionfile_abs) ver = from_keywords_f(keywords, cfg.tag_prefix, verbose) if verbose: print("got version from expanded keyword %s" % ver) return ver except NotThisMethod: pass try: ver = versions_from_file(versionfile_abs) if verbose: print("got version from file %s %s" % (versionfile_abs, ver)) return ver except NotThisMethod: pass from_vcs_f = handlers.get("pieces_from_vcs") if from_vcs_f: try: pieces = from_vcs_f(cfg.tag_prefix, root, verbose) ver = render(pieces, cfg.style) if verbose: print("got version from VCS %s" % ver) return ver except NotThisMethod: pass try: if cfg.parentdir_prefix: ver = versions_from_parentdir(cfg.parentdir_prefix, root, verbose) if verbose: print("got version from parentdir %s" % ver) return ver except NotThisMethod: pass if verbose: print("unable to compute version") return {"version": "0+unknown", "full-revisionid": None, "dirty": None, "error": "unable to compute version"} def get_version(): return get_versions()["version"] def get_cmdclass(): if "versioneer" in sys.modules: del sys.modules["versioneer"] # this fixes the "python setup.py develop" case (also 'install' and # 'easy_install .'), in which subdependencies of the main project are # built (using setup.py bdist_egg) in the same python process. Assume # a main project A and a dependency B, which use different versions # of Versioneer. A's setup.py imports A's Versioneer, leaving it in # sys.modules by the time B's setup.py is executed, causing B to run # with the wrong versioneer. Setuptools wraps the sub-dep builds in a # sandbox that restores sys.modules to it's pre-build state, so the # parent is protected against the child's "import versioneer". By # removing ourselves from sys.modules here, before the child build # happens, we protect the child from the parent's versioneer too. # Also see https://github.com/warner/python-versioneer/issues/52 cmds = {} # we add "version" to both distutils and setuptools from distutils.core import Command class cmd_version(Command): description = "report generated version string" user_options = [] boolean_options = [] def initialize_options(self): pass def finalize_options(self): pass def run(self): vers = get_versions(verbose=True) print("Version: %s" % vers["version"]) print(" full-revisionid: %s" % vers.get("full-revisionid")) print(" dirty: %s" % vers.get("dirty")) if vers["error"]: print(" error: %s" % vers["error"]) cmds["version"] = cmd_version # we override "build_py" in both distutils and setuptools # # most invocation pathways end up running build_py: # distutils/build -> build_py # distutils/install -> distutils/build ->.. # setuptools/bdist_wheel -> distutils/install ->.. # setuptools/bdist_egg -> distutils/install_lib -> build_py # setuptools/install -> bdist_egg ->.. # setuptools/develop -> ? from distutils.command.build_py import build_py as _build_py class cmd_build_py(_build_py): def run(self): root = get_root() cfg = get_config_from_root(root) versions = get_versions() _build_py.run(self) # now locate _version.py in the new build/ directory and replace # it with an updated value if cfg.versionfile_build: target_versionfile = os.path.join(self.build_lib, cfg.versionfile_build) print("UPDATING %s" % target_versionfile) write_to_version_file(target_versionfile, versions) cmds["build_py"] = cmd_build_py if "cx_Freeze" in sys.modules: # cx_freeze enabled? from cx_Freeze.dist import build_exe as _build_exe class cmd_build_exe(_build_exe): def run(self): root = get_root() cfg = get_config_from_root(root) versions = get_versions() target_versionfile = cfg.versionfile_source print("UPDATING %s" % target_versionfile) write_to_version_file(target_versionfile, versions) _build_exe.run(self) os.unlink(target_versionfile) with open(cfg.versionfile_source, "w") as f: LONG = LONG_VERSION_PY[cfg.VCS] f.write(LONG % {"DOLLAR": "$", "STYLE": cfg.style, "TAG_PREFIX": cfg.tag_prefix, "PARENTDIR_PREFIX": cfg.parentdir_prefix, "VERSIONFILE_SOURCE": cfg.versionfile_source, }) cmds["build_exe"] = cmd_build_exe del cmds["build_py"] # we override different "sdist" commands for both environments if "setuptools" in sys.modules: from setuptools.command.sdist import sdist as _sdist else: from distutils.command.sdist import sdist as _sdist class cmd_sdist(_sdist): def run(self): versions = get_versions() self._versioneer_generated_versions = versions # unless we update this, the command will keep using the old # version self.distribution.metadata.version = versions["version"] return _sdist.run(self) def make_release_tree(self, base_dir, files): root = get_root() cfg = get_config_from_root(root) _sdist.make_release_tree(self, base_dir, files) # now locate _version.py in the new base_dir directory # (remembering that it may be a hardlink) and replace it with an # updated value target_versionfile = os.path.join(base_dir, cfg.versionfile_source) print("UPDATING %s" % target_versionfile) write_to_version_file(target_versionfile, self._versioneer_generated_versions) cmds["sdist"] = cmd_sdist return cmds CONFIG_ERROR = """ setup.cfg is missing the necessary Versioneer configuration. You need a section like: [versioneer] VCS = git style = pep440 versionfile_source = src/myproject/_version.py versionfile_build = myproject/_version.py tag_prefix = "" parentdir_prefix = myproject- You will also need to edit your setup.py to use the results: import versioneer setup(version=versioneer.get_version(), cmdclass=versioneer.get_cmdclass(), ...) Please read the docstring in ./versioneer.py for configuration instructions, edit setup.cfg, and re-run the installer or 'python versioneer.py setup'. """ SAMPLE_CONFIG = """ # See the docstring in versioneer.py for instructions. Note that you must # re-run 'versioneer.py setup' after changing this section, and commit the # resulting files. [versioneer] #VCS = git #style = pep440 #versionfile_source = #versionfile_build = #tag_prefix = #parentdir_prefix = """ INIT_PY_SNIPPET = """ from ._version import get_versions __version__ = get_versions()['version'] del get_versions """ def do_setup(): root = get_root() try: cfg = get_config_from_root(root) except (EnvironmentError, configparser.NoSectionError, configparser.NoOptionError) as e: if isinstance(e, (EnvironmentError, configparser.NoSectionError)): print("Adding sample versioneer config to setup.cfg", file=sys.stderr) with open(os.path.join(root, "setup.cfg"), "a") as f: f.write(SAMPLE_CONFIG) print(CONFIG_ERROR, file=sys.stderr) return 1 print(" creating %s" % cfg.versionfile_source) with open(cfg.versionfile_source, "w") as f: LONG = LONG_VERSION_PY[cfg.VCS] f.write(LONG % {"DOLLAR": "$", "STYLE": cfg.style, "TAG_PREFIX": cfg.tag_prefix, "PARENTDIR_PREFIX": cfg.parentdir_prefix, "VERSIONFILE_SOURCE": cfg.versionfile_source, }) ipy = os.path.join(os.path.dirname(cfg.versionfile_source), "__init__.py") if os.path.exists(ipy): try: with open(ipy, "r") as f: old = f.read() except EnvironmentError: old = "" if INIT_PY_SNIPPET not in old: print(" appending to %s" % ipy) with open(ipy, "a") as f: f.write(INIT_PY_SNIPPET) else: print(" %s unmodified" % ipy) else: print(" %s doesn't exist, ok" % ipy) ipy = None # Make sure both the top-level "versioneer.py" and versionfile_source # (PKG/_version.py, used by runtime code) are in MANIFEST.in, so # they'll be copied into source distributions. Pip won't be able to # install the package without this. manifest_in = os.path.join(root, "MANIFEST.in") simple_includes = set() try: with open(manifest_in, "r") as f: for line in f: if line.startswith("include "): for include in line.split()[1:]: simple_includes.add(include) except EnvironmentError: pass # That doesn't cover everything MANIFEST.in can do # (http://docs.python.org/2/distutils/sourcedist.html#commands), so # it might give some false negatives. Appending redundant 'include' # lines is safe, though. if "versioneer.py" not in simple_includes: print(" appending 'versioneer.py' to MANIFEST.in") with open(manifest_in, "a") as f: f.write("include versioneer.py\n") else: print(" 'versioneer.py' already in MANIFEST.in") if cfg.versionfile_source not in simple_includes: print(" appending versionfile_source ('%s') to MANIFEST.in" % cfg.versionfile_source) with open(manifest_in, "a") as f: f.write("include %s\n" % cfg.versionfile_source) else: print(" versionfile_source already in MANIFEST.in") # Make VCS-specific changes. For git, this means creating/changing # .gitattributes to mark _version.py for export-time keyword # substitution. do_vcs_install(manifest_in, cfg.versionfile_source, ipy) return 0 def scan_setup_py(): found = set() setters = False errors = 0 with open("setup.py", "r") as f: for line in f.readlines(): if "import versioneer" in line: found.add("import") if "versioneer.get_cmdclass()" in line: found.add("cmdclass") if "versioneer.get_version()" in line: found.add("get_version") if "versioneer.VCS" in line: setters = True if "versioneer.versionfile_source" in line: setters = True if len(found) != 3: print("") print("Your setup.py appears to be missing some important items") print("(but I might be wrong). Please make sure it has something") print("roughly like the following:") print("") print(" import versioneer") print(" setup( version=versioneer.get_version(),") print(" cmdclass=versioneer.get_cmdclass(), ...)") print("") errors += 1 if setters: print("You should remove lines like 'versioneer.VCS = ' and") print("'versioneer.versionfile_source = ' . This configuration") print("now lives in setup.cfg, and should be removed from setup.py") print("") errors += 1 return errors if __name__ == "__main__": cmd = sys.argv[1] if cmd == "setup": errors = do_setup() errors += scan_setup_py() if errors: sys.exit(1)