path
stringlengths 23
146
| source_code
stringlengths 0
261k
|
|---|---|
data/aerospike/aerospike-client-python/test/new_tests/test_list_get_range.py
|
import pytest
import sys
import random
from .test_base_class import TestBaseClass
from aerospike import exception as e
aerospike = pytest.importorskip("aerospike")
try:
import aerospike
except:
print("Please install aerospike python client.")
sys.exit(1)
class TestListGetRange(object):
@pytest.fixture(autouse=True)
def setup(self, request, as_connection):
keys = []
for i in range(5):
key = ('test', 'demo', i)
rec = {'name': 'name%s' % (str(i)), 'contact_no': [
i, i + 1, i + 2, i + 3, i + 4, i + 5],
'city': ['Pune', 'Dehli']}
self.as_connection.put(key, rec)
keys.append(key)
key = ('test', 'demo', 1)
self.as_connection.list_append(key, "contact_no", [45, 50, 80])
keys.append(key)
def teardown():
"""
Teardown method.
"""
for key in keys:
try:
as_connection.remove(key)
except e.RecordNotFound:
pass
request.addfinalizer(teardown)
def test_pos_list_get_range_with_correct_paramters(self):
"""
Invoke list_get_range() get back elements from the list with
correct parameters
"""
key = ('test', 'demo', 1)
bins = self.as_connection.list_get_range(key, "contact_no", 4, 3)
assert bins == [5, 6, [45, 50, 80]]
def test_pos_list_get_range_with_correct_policy(self):
"""
Invoke list_get_range() get back elements from the list with
correct policy
"""
key = ('test', 'demo', 1)
policy = {
'timeout': 1000,
'retry': aerospike.POLICY_RETRY_ONCE,
'commit_level': aerospike.POLICY_COMMIT_LEVEL_MASTER
}
bins = self.as_connection.list_get_range(
key, 'city', 0, 1, {}, policy)
assert bins == ['Pune']
def test_pos_list_get_range_with_nonexistent_bin(self):
"""
Invoke list_get_range() with non-existent bin
"""
key = ('test', 'demo', 1)
charSet = 'abcdefghijklmnopqrstuvwxyz1234567890'
minLength = 5
maxLength = 10
length = random.randint(minLength, maxLength)
bin = ''.join(map(lambda unused:
random.choice(charSet), range(length))) + ".com"
bins = self.as_connection.list_get_range(key, bin, 0, 1)
assert [] == bins
def test_neg_list_get_range_with_no_parameters(self):
"""
Invoke list_get_range() without any mandatory parameters.
"""
with pytest.raises(TypeError) as typeError:
self.as_connection.list_get_range()
assert "Required argument 'key' (pos 1) not found" in str(
typeError.value)
def test_neg_list_get_range_with_incorrect_policy(self):
"""
Invoke list_get_range() with incorrect policy
"""
key = ('test', 'demo', 1)
policy = {
'timeout': 0.5
}
try:
self.as_connection.list_get_range(
key, "contact_no", 0, 2, {}, policy)
except e.ParamError as exception:
assert exception.code == -2
assert exception.msg == "timeout is invalid"
def test_neg_list_get_range_with_nonexistent_key(self):
"""
Invoke list_get_range() with non-existent key
"""
charSet = 'abcdefghijklmnopqrstuvwxyz1234567890'
minLength = 5
maxLength = 30
length = random.randint(minLength, maxLength)
key = ('test', 'demo', ''.join(map(lambda unused:
random.choice(charSet),
range(length))) + ".com")
try:
self.as_connection.list_get_range(key, "abc", 0, 1)
except e.RecordNotFound as exception:
assert exception.code == 2
def test_neg_list_get_range_with_extra_parameter(self):
"""
Invoke list_get_range() with extra parameter.
"""
key = ('test', 'demo', 1)
policy = {'timeout': 1000}
with pytest.raises(TypeError) as typeError:
self.as_connection.list_get_range(
key, "contact_no", 1, 1, {}, policy, "")
assert "list_get_range() takes at most 6 arguments (7 given)" in str(
typeError.value)
def test_neg_list_get_range_policy_is_string(self):
"""
Invoke list_get_range() with policy is string
"""
key = ('test', 'demo', 1)
try:
self.as_connection.list_get_range(
key, "contact_no", 0, 1, {}, "")
except e.ParamError as exception:
assert exception.code == -2
assert exception.msg == "policy must be a dict"
def test_neg_list_get_range_key_is_none(self):
"""
Invoke list_get_range() with key is none
"""
try:
self.as_connection.list_get_range(None, "contact_no", 0, 2)
except e.ParamError as exception:
assert exception.code == -2
assert exception.msg == "key is invalid"
def test_neg_list_get_range_bin_is_none(self):
"""
Invoke list_get_range() with bin is none
"""
key = ('test', 'demo', 1)
try:
self.as_connection.list_get_range(key, None, 1, 3)
except e.ParamError as exception:
assert exception.code == -2
assert exception.msg == "Bin name should be of type string"
def test_neg_list_get_range_with_negative_index(self):
"""
Invoke list_get_range() with negative index
"""
key = ('test', 'demo', 1)
try:
self.as_connection.list_get_range(key, "contact_no", -56, 5)
except e.InvalidRequest as exception:
assert exception.code == 4
def test_neg_list_get_range_with_negative_length(self):
"""
Invoke list_get_range() with negative count
"""
key = ('test', 'demo', 1)
try:
self.as_connection.list_get_range(key, "contact_no", 0, -59)
except e.InvalidRequest as exception:
assert exception.code == 4
def test_neg_list_get_range_meta_type_integer(self):
"""
Invoke list_get_range() with metadata input is of type integer
"""
key = ('test', 'demo', 1)
try:
self.as_connection.list_get_range(
key, "contact_no", 0, 2, 888)
except e.ParamError as exception:
assert exception.code == -2
assert exception.msg == "Metadata should be of type dictionary"
def test_neg_list_get_range_index_type_string(self):
"""
Invoke list_get_range() with index is of type string
"""
key = ('test', 'demo', 1)
with pytest.raises(TypeError) as typeError:
self.as_connection.list_get_range(
key, "contact_no", "Fifth", 2)
assert "an integer is required" in str(typeError.value)
|
data/adblockplus/gyp/pylib/gyp/generator/xcode.py
|
import filecmp
import gyp.common
import gyp.xcodeproj_file
import gyp.xcode_ninja
import errno
import os
import sys
import posixpath
import re
import shutil
import subprocess
import tempfile
_intermediate_var = 'INTERMEDIATE_DIR'
_shared_intermediate_var = 'SHARED_INTERMEDIATE_DIR'
_library_search_paths_var = 'LIBRARY_SEARCH_PATHS'
generator_default_variables = {
'EXECUTABLE_PREFIX': '',
'EXECUTABLE_SUFFIX': '',
'STATIC_LIB_PREFIX': 'lib',
'SHARED_LIB_PREFIX': 'lib',
'STATIC_LIB_SUFFIX': '.a',
'SHARED_LIB_SUFFIX': '.dylib',
'INTERMEDIATE_DIR': '$(%s)' % _intermediate_var,
'OS': 'mac',
'PRODUCT_DIR': '$(BUILT_PRODUCTS_DIR)',
'LIB_DIR': '$(BUILT_PRODUCTS_DIR)',
'RULE_INPUT_ROOT': '$(INPUT_FILE_BASE)',
'RULE_INPUT_EXT': '$(INPUT_FILE_SUFFIX)',
'RULE_INPUT_NAME': '$(INPUT_FILE_NAME)',
'RULE_INPUT_PATH': '$(INPUT_FILE_PATH)',
'RULE_INPUT_DIRNAME': '$(INPUT_FILE_DIRNAME)',
'SHARED_INTERMEDIATE_DIR': '$(%s)' % _shared_intermediate_var,
'CONFIGURATION_NAME': '$(CONFIGURATION)',
}
generator_additional_path_sections = [
'mac_bundle_resources',
'mac_framework_headers',
'mac_framework_private_headers',
]
generator_additional_non_configuration_keys = [
'ios_app_extension',
'ios_watch_app',
'ios_watchkit_extension',
'mac_bundle',
'mac_bundle_resources',
'mac_framework_headers',
'mac_framework_private_headers',
'mac_xctest_bundle',
'xcode_create_dependents_test_runner',
]
generator_extra_sources_for_rules = [
'mac_bundle_resources',
'mac_framework_headers',
'mac_framework_private_headers',
]
xcode_standard_library_dirs = frozenset([
'$(SDKROOT)/usr/lib',
'$(SDKROOT)/usr/local/lib',
])
def CreateXCConfigurationList(configuration_names):
xccl = gyp.xcodeproj_file.XCConfigurationList({'buildConfigurations': []})
if len(configuration_names) == 0:
configuration_names = ['Default']
for configuration_name in configuration_names:
xcbc = gyp.xcodeproj_file.XCBuildConfiguration({
'name': configuration_name})
xccl.AppendProperty('buildConfigurations', xcbc)
xccl.SetProperty('defaultConfigurationName', configuration_names[0])
return xccl
class XcodeProject(object):
def __init__(self, gyp_path, path, build_file_dict):
self.gyp_path = gyp_path
self.path = path
self.project = gyp.xcodeproj_file.PBXProject(path=path)
projectDirPath = gyp.common.RelativePath(
os.path.dirname(os.path.abspath(self.gyp_path)),
os.path.dirname(path) or '.')
self.project.SetProperty('projectDirPath', projectDirPath)
self.project_file = \
gyp.xcodeproj_file.XCProjectFile({'rootObject': self.project})
self.build_file_dict = build_file_dict
self.created_dir = False
try:
os.makedirs(self.path)
self.created_dir = True
except OSError, e:
if e.errno != errno.EEXIST:
raise
def Finalize1(self, xcode_targets, serialize_all_tests):
configurations = []
for xct in self.project.GetProperty('targets'):
xccl = xct.GetProperty('buildConfigurationList')
xcbcs = xccl.GetProperty('buildConfigurations')
for xcbc in xcbcs:
name = xcbc.GetProperty('name')
if name not in configurations:
configurations.append(name)
try:
xccl = CreateXCConfigurationList(configurations)
self.project.SetProperty('buildConfigurationList', xccl)
except:
sys.stderr.write("Problem with gyp file %s\n" % self.gyp_path)
raise
xccl.SetBuildSetting(_intermediate_var,
'$(PROJECT_DERIVED_FILE_DIR)/$(CONFIGURATION)')
xccl.SetBuildSetting(_shared_intermediate_var,
'$(SYMROOT)/DerivedSources/$(CONFIGURATION)')
for xck, xcv in self.build_file_dict.get('xcode_settings', {}).iteritems():
xccl.SetBuildSetting(xck, xcv)
if 'xcode_config_file' in self.build_file_dict:
config_ref = self.project.AddOrGetFileInRootGroup(
self.build_file_dict['xcode_config_file'])
xccl.SetBaseConfiguration(config_ref)
build_file_configurations = self.build_file_dict.get('configurations', {})
if build_file_configurations:
for config_name in configurations:
build_file_configuration_named = \
build_file_configurations.get(config_name, {})
if build_file_configuration_named:
xcc = xccl.ConfigurationNamed(config_name)
for xck, xcv in build_file_configuration_named.get('xcode_settings',
{}).iteritems():
xcc.SetBuildSetting(xck, xcv)
if 'xcode_config_file' in build_file_configuration_named:
config_ref = self.project.AddOrGetFileInRootGroup(
build_file_configurations[config_name]['xcode_config_file'])
xcc.SetBaseConfiguration(config_ref)
ordinary_targets = []
run_test_targets = []
support_targets = []
targets = []
has_custom_all = False
targets_for_all = []
for target in self.build_file_dict['targets']:
target_name = target['target_name']
toolset = target['toolset']
qualified_target = gyp.common.QualifiedTarget(self.gyp_path, target_name,
toolset)
xcode_target = xcode_targets[qualified_target]
assert xcode_target in self.project._properties['targets']
targets.append(xcode_target)
ordinary_targets.append(xcode_target)
if xcode_target.support_target:
support_targets.append(xcode_target.support_target)
targets.append(xcode_target.support_target)
if not int(target.get('suppress_wildcard', False)):
targets_for_all.append(xcode_target)
if target_name.lower() == 'all':
has_custom_all = True;
if target.get('run_as'):
xccl = CreateXCConfigurationList(configurations)
run_target = gyp.xcodeproj_file.PBXAggregateTarget({
'name': 'Run ' + target_name,
'productName': xcode_target.GetProperty('productName'),
'buildConfigurationList': xccl,
},
parent=self.project)
run_target.AddDependency(xcode_target)
command = target['run_as']
script = ''
if command.get('working_directory'):
script = script + 'cd "%s"\n' % \
gyp.xcodeproj_file.ConvertVariablesToShellSyntax(
command.get('working_directory'))
if command.get('environment'):
script = script + "\n".join(
['export %s="%s"' %
(key, gyp.xcodeproj_file.ConvertVariablesToShellSyntax(val))
for (key, val) in command.get('environment').iteritems()]) + "\n"
command_prefix = ''
if serialize_all_tests:
command_prefix = \
"""python -c "import fcntl, subprocess, sys
file = open('$TMPDIR/GYP_serialize_test_runs', 'a')
fcntl.flock(file.fileno(), fcntl.LOCK_EX)
sys.exit(subprocess.call(sys.argv[1:]))" """
script = script + 'exec ' + command_prefix + '%s\nexit 1\n' % \
gyp.xcodeproj_file.ConvertVariablesToShellSyntax(
gyp.common.EncodePOSIXShellList(command.get('action')))
ssbp = gyp.xcodeproj_file.PBXShellScriptBuildPhase({
'shellScript': script,
'showEnvVarsInLog': 0,
})
run_target.AppendProperty('buildPhases', ssbp)
targets.append(run_target)
run_test_targets.append(run_target)
xcode_target.test_runner = run_target
assert len(self.project._properties['targets']) == \
len(ordinary_targets) + len(support_targets)
self.project._properties['targets'] = targets
self.project.RootGroupsTakeOverOnlyChildren(True)
self.project.SortGroups()
if len(targets_for_all) > 1 and not has_custom_all:
xccl = CreateXCConfigurationList(configurations)
all_target = gyp.xcodeproj_file.PBXAggregateTarget(
{
'buildConfigurationList': xccl,
'name': 'All',
},
parent=self.project)
for target in targets_for_all:
all_target.AddDependency(target)
self.project._properties['targets'].insert(0, all_target)
if len(run_test_targets) > 1:
xccl = CreateXCConfigurationList(configurations)
run_all_tests_target = gyp.xcodeproj_file.PBXAggregateTarget(
{
'buildConfigurationList': xccl,
'name': 'Run All Tests',
},
parent=self.project)
for run_test_target in run_test_targets:
run_all_tests_target.AddDependency(run_test_target)
self.project._properties['targets'].insert(1, run_all_tests_target)
def Finalize2(self, xcode_targets, xcode_target_to_target_dict):
for bf_tgt in self.build_file_dict['targets']:
if int(bf_tgt.get('xcode_create_dependents_test_runner', 0)):
tgt_name = bf_tgt['target_name']
toolset = bf_tgt['toolset']
qualified_target = gyp.common.QualifiedTarget(self.gyp_path,
tgt_name, toolset)
xcode_target = xcode_targets[qualified_target]
if isinstance(xcode_target, gyp.xcodeproj_file.PBXAggregateTarget):
all_run_tests = []
pbxtds = xcode_target.GetProperty('dependencies')
for pbxtd in pbxtds:
pbxcip = pbxtd.GetProperty('targetProxy')
dependency_xct = pbxcip.GetProperty('remoteGlobalIDString')
if hasattr(dependency_xct, 'test_runner'):
all_run_tests.append(dependency_xct.test_runner)
if len(all_run_tests) > 0:
run_all_target = gyp.xcodeproj_file.PBXAggregateTarget({
'name': 'Run %s Tests' % tgt_name,
'productName': tgt_name,
},
parent=self.project)
for run_test_target in all_run_tests:
run_all_target.AddDependency(run_test_target)
idx = self.project._properties['targets'].index(xcode_target)
self.project._properties['targets'].insert(idx + 1, run_all_target)
for other_pbxproject in self.project._other_pbxprojects.keys():
self.project.AddOrGetProjectReference(other_pbxproject)
self.project.SortRemoteProductReferences()
self.project_file.ComputeIDs()
self.project_file.EnsureNoIDCollisions()
def Write(self):
(output_fd, new_pbxproj_path) = \
tempfile.mkstemp(suffix='.tmp', prefix='project.pbxproj.gyp.',
dir=self.path)
try:
output_file = os.fdopen(output_fd, 'wb')
self.project_file.Print(output_file)
output_file.close()
pbxproj_path = os.path.join(self.path, 'project.pbxproj')
same = False
try:
same = filecmp.cmp(pbxproj_path, new_pbxproj_path, False)
except OSError, e:
if e.errno != errno.ENOENT:
raise
if same:
os.unlink(new_pbxproj_path)
else:
umask = os.umask(077)
os.umask(umask)
os.chmod(new_pbxproj_path, 0666 & ~umask)
os.rename(new_pbxproj_path, pbxproj_path)
except Exception:
os.unlink(new_pbxproj_path)
if self.created_dir:
shutil.rmtree(self.path, True)
raise
def AddSourceToTarget(source, type, pbxp, xct):
source_extensions = ['c', 'cc', 'cpp', 'cxx', 'm', 'mm', 's', 'swift']
library_extensions = ['a', 'dylib', 'framework', 'o']
basename = posixpath.basename(source)
(root, ext) = posixpath.splitext(basename)
if ext:
ext = ext[1:].lower()
if ext in source_extensions and type != 'none':
xct.SourcesPhase().AddFile(source)
elif ext in library_extensions and type != 'none':
xct.FrameworksPhase().AddFile(source)
else:
pbxp.AddOrGetFileInRootGroup(source)
def AddResourceToTarget(resource, pbxp, xct):
xct.ResourcesPhase().AddFile(resource)
def AddHeaderToTarget(header, pbxp, xct, is_public):
settings = '{ATTRIBUTES = (%s, ); }' % ('Private', 'Public')[is_public]
xct.HeadersPhase().AddFile(header, settings)
_xcode_variable_re = re.compile(r'(\$\((.*?)\))')
def ExpandXcodeVariables(string, expansions):
"""Expands Xcode-style $(VARIABLES) in string per the expansions dict.
In some rare cases, it is appropriate to expand Xcode variables when a
project file is generated. For any substring $(VAR) in string, if VAR is a
key in the expansions dict, $(VAR) will be replaced with expansions[VAR].
Any $(VAR) substring in string for which VAR is not a key in the expansions
dict will remain in the returned string.
"""
matches = _xcode_variable_re.findall(string)
if matches == None:
return string
matches.reverse()
for match in matches:
(to_replace, variable) = match
if not variable in expansions:
continue
replacement = expansions[variable]
string = re.sub(re.escape(to_replace), replacement, string)
return string
_xcode_define_re = re.compile(r'([\\\"\' ])')
def EscapeXcodeDefine(s):
"""We must escape the defines that we give to XCode so that it knows not to
split on spaces and to respect backslash and quote literals. However, we
must not quote the define, or Xcode will incorrectly intepret variables
especially $(inherited)."""
return re.sub(_xcode_define_re, r'\\\1', s)
def PerformBuild(data, configurations, params):
options = params['options']
for build_file, build_file_dict in data.iteritems():
(build_file_root, build_file_ext) = os.path.splitext(build_file)
if build_file_ext != '.gyp':
continue
xcodeproj_path = build_file_root + options.suffix + '.xcodeproj'
if options.generator_output:
xcodeproj_path = os.path.join(options.generator_output, xcodeproj_path)
for config in configurations:
arguments = ['xcodebuild', '-project', xcodeproj_path]
arguments += ['-configuration', config]
print "Building [%s]: %s" % (config, arguments)
subprocess.check_call(arguments)
def GenerateOutput(target_list, target_dicts, data, params):
ninja_wrapper = params.get('flavor') == 'ninja'
if ninja_wrapper:
(target_list, target_dicts, data) = \
gyp.xcode_ninja.CreateWrapper(target_list, target_dicts, data, params)
options = params['options']
generator_flags = params.get('generator_flags', {})
parallel_builds = generator_flags.get('xcode_parallel_builds', True)
serialize_all_tests = \
generator_flags.get('xcode_serialize_all_test_runs', True)
upgrade_check_project_version = \
generator_flags.get('xcode_upgrade_check_project_version', None)
if upgrade_check_project_version:
upgrade_check_project_version = str(upgrade_check_project_version)
while len(upgrade_check_project_version) < 4:
upgrade_check_project_version = '0' + upgrade_check_project_version
skip_excluded_files = \
not generator_flags.get('xcode_list_excluded_files', True)
xcode_projects = {}
for build_file, build_file_dict in data.iteritems():
(build_file_root, build_file_ext) = os.path.splitext(build_file)
if build_file_ext != '.gyp':
continue
xcodeproj_path = build_file_root + options.suffix + '.xcodeproj'
if options.generator_output:
xcodeproj_path = os.path.join(options.generator_output, xcodeproj_path)
xcp = XcodeProject(build_file, xcodeproj_path, build_file_dict)
xcode_projects[build_file] = xcp
pbxp = xcp.project
project_attributes = {};
if parallel_builds:
project_attributes['BuildIndependentTargetsInParallel'] = 'YES'
if upgrade_check_project_version:
project_attributes['LastUpgradeCheck'] = upgrade_check_project_version
project_attributes['LastTestingUpgradeCheck'] = \
upgrade_check_project_version
project_attributes['LastSwiftUpdateCheck'] = \
upgrade_check_project_version
pbxp.SetProperty('attributes', project_attributes)
if not generator_flags.get('standalone'):
main_group = pbxp.GetProperty('mainGroup')
build_group = gyp.xcodeproj_file.PBXGroup({'name': 'Build'})
main_group.AppendChild(build_group)
for included_file in build_file_dict['included_files']:
build_group.AddOrGetFileByPath(included_file, False)
xcode_targets = {}
xcode_target_to_target_dict = {}
for qualified_target in target_list:
[build_file, target_name, toolset] = \
gyp.common.ParseQualifiedTarget(qualified_target)
spec = target_dicts[qualified_target]
if spec['toolset'] != 'target':
raise Exception(
'Multiple toolsets not supported in xcode build (target %s)' %
qualified_target)
configuration_names = [spec['default_configuration']]
for configuration_name in sorted(spec['configurations'].keys()):
if configuration_name not in configuration_names:
configuration_names.append(configuration_name)
xcp = xcode_projects[build_file]
pbxp = xcp.project
xccl = CreateXCConfigurationList(configuration_names)
_types = {
'executable': 'com.apple.product-type.tool',
'loadable_module': 'com.googlecode.gyp.xcode.bundle',
'shared_library': 'com.apple.product-type.library.dynamic',
'static_library': 'com.apple.product-type.library.static',
'mac_kernel_extension': 'com.apple.product-type.kernel-extension',
'executable+bundle': 'com.apple.product-type.application',
'loadable_module+bundle': 'com.apple.product-type.bundle',
'loadable_module+xctest': 'com.apple.product-type.bundle.unit-test',
'shared_library+bundle': 'com.apple.product-type.framework',
'executable+extension+bundle': 'com.apple.product-type.app-extension',
'executable+watch+extension+bundle':
'com.apple.product-type.watchkit-extension',
'executable+watch+bundle':
'com.apple.product-type.application.watchapp',
'mac_kernel_extension+bundle': 'com.apple.product-type.kernel-extension',
}
target_properties = {
'buildConfigurationList': xccl,
'name': target_name,
}
type = spec['type']
is_xctest = int(spec.get('mac_xctest_bundle', 0))
is_bundle = int(spec.get('mac_bundle', 0)) or is_xctest
is_app_extension = int(spec.get('ios_app_extension', 0))
is_watchkit_extension = int(spec.get('ios_watchkit_extension', 0))
is_watch_app = int(spec.get('ios_watch_app', 0))
if type != 'none':
type_bundle_key = type
if is_xctest:
type_bundle_key += '+xctest'
assert type == 'loadable_module', (
'mac_xctest_bundle targets must have type loadable_module '
'(target %s)' % target_name)
elif is_app_extension:
assert is_bundle, ('ios_app_extension flag requires mac_bundle '
'(target %s)' % target_name)
type_bundle_key += '+extension+bundle'
elif is_watchkit_extension:
assert is_bundle, ('ios_watchkit_extension flag requires mac_bundle '
'(target %s)' % target_name)
type_bundle_key += '+watch+extension+bundle'
elif is_watch_app:
assert is_bundle, ('ios_watch_app flag requires mac_bundle '
'(target %s)' % target_name)
type_bundle_key += '+watch+bundle'
elif is_bundle:
type_bundle_key += '+bundle'
xctarget_type = gyp.xcodeproj_file.PBXNativeTarget
try:
target_properties['productType'] = _types[type_bundle_key]
except KeyError, e:
gyp.common.ExceptionAppend(e, "-- unknown product type while "
"writing target %s" % target_name)
raise
else:
xctarget_type = gyp.xcodeproj_file.PBXAggregateTarget
assert not is_bundle, (
'mac_bundle targets cannot have type none (target "%s")' %
target_name)
assert not is_xctest, (
'mac_xctest_bundle targets cannot have type none (target "%s")' %
target_name)
target_product_name = spec.get('product_name')
if target_product_name is not None:
target_properties['productName'] = target_product_name
xct = xctarget_type(target_properties, parent=pbxp,
force_outdir=spec.get('product_dir'),
force_prefix=spec.get('product_prefix'),
force_extension=spec.get('product_extension'))
pbxp.AppendProperty('targets', xct)
xcode_targets[qualified_target] = xct
xcode_target_to_target_dict[xct] = spec
spec_actions = spec.get('actions', [])
spec_rules = spec.get('rules', [])
support_xct = None
if type != 'none' and (spec_actions or spec_rules) and not ninja_wrapper:
support_xccl = CreateXCConfigurationList(configuration_names);
support_target_suffix = generator_flags.get(
'support_target_suffix', ' Support')
support_target_properties = {
'buildConfigurationList': support_xccl,
'name': target_name + support_target_suffix,
}
if target_product_name:
support_target_properties['productName'] = \
target_product_name + ' Support'
support_xct = \
gyp.xcodeproj_file.PBXAggregateTarget(support_target_properties,
parent=pbxp)
pbxp.AppendProperty('targets', support_xct)
xct.AddDependency(support_xct)
xct.support_target = support_xct
prebuild_index = 0
for action in spec_actions:
message = action.get('message')
if message:
message = 'echo note: ' + gyp.common.EncodePOSIXShellArgument(message)
else:
message = ''
action_string = gyp.common.EncodePOSIXShellList(action['action'])
message_sh = gyp.xcodeproj_file.ConvertVariablesToShellSyntax(message)
action_string_sh = gyp.xcodeproj_file.ConvertVariablesToShellSyntax(
action_string)
script = ''
if message_sh:
script += message_sh + '\n'
script += 'exec ' + action_string_sh + '\nexit 1\n'
ssbp = gyp.xcodeproj_file.PBXShellScriptBuildPhase({
'inputPaths': action['inputs'],
'name': 'Action "' + action['action_name'] + '"',
'outputPaths': action['outputs'],
'shellScript': script,
'showEnvVarsInLog': 0,
})
if support_xct:
support_xct.AppendProperty('buildPhases', ssbp)
else:
xct._properties['buildPhases'].insert(prebuild_index, ssbp)
prebuild_index = prebuild_index + 1
if int(action.get('process_outputs_as_sources', False)):
for output in action['outputs']:
AddSourceToTarget(output, type, pbxp, xct)
if int(action.get('process_outputs_as_mac_bundle_resources', False)):
for output in action['outputs']:
AddResourceToTarget(output, pbxp, xct)
if is_bundle:
tgt_mac_bundle_resources = spec.get('mac_bundle_resources', [])
else:
tgt_mac_bundle_resources = []
rules_by_ext = {}
for rule in spec_rules:
rules_by_ext[rule['extension']] = rule
concrete_outputs_by_rule_source = []
concrete_outputs_all = []
messages = []
actions = []
for rule_source in rule.get('rule_sources', []):
rule_source_dirname, rule_source_basename = \
posixpath.split(rule_source)
(rule_source_root, rule_source_ext) = \
posixpath.splitext(rule_source_basename)
rule_input_dict = {
'INPUT_FILE_BASE': rule_source_root,
'INPUT_FILE_SUFFIX': rule_source_ext,
'INPUT_FILE_NAME': rule_source_basename,
'INPUT_FILE_PATH': rule_source,
'INPUT_FILE_DIRNAME': rule_source_dirname,
}
concrete_outputs_for_this_rule_source = []
for output in rule.get('outputs', []):
concrete_output = ExpandXcodeVariables(output, rule_input_dict)
concrete_outputs_for_this_rule_source.append(concrete_output)
pbxp.AddOrGetFileInRootGroup(concrete_output)
concrete_outputs_by_rule_source.append( \
concrete_outputs_for_this_rule_source)
concrete_outputs_all.extend(concrete_outputs_for_this_rule_source)
if int(rule.get('process_outputs_as_sources', False)):
for output in concrete_outputs_for_this_rule_source:
AddSourceToTarget(output, type, pbxp, xct)
was_mac_bundle_resource = rule_source in tgt_mac_bundle_resources
if was_mac_bundle_resource or \
int(rule.get('process_outputs_as_mac_bundle_resources', False)):
for output in concrete_outputs_for_this_rule_source:
AddResourceToTarget(output, pbxp, xct)
message = rule.get('message')
if message:
message = gyp.common.EncodePOSIXShellArgument(message)
message = ExpandXcodeVariables(message, rule_input_dict)
messages.append(message)
action_string = gyp.common.EncodePOSIXShellList(rule['action'])
action = ExpandXcodeVariables(action_string, rule_input_dict)
actions.append(action)
if len(concrete_outputs_all) > 0:
makefile_name = '%s.make' % re.sub(
'[^a-zA-Z0-9_]', '_' , '%s_%s' % (target_name, rule['rule_name']))
makefile_path = os.path.join(xcode_projects[build_file].path,
makefile_name)
makefile = open(makefile_path, 'wb')
makefile.write('all: \\\n')
for concrete_output_index in \
xrange(0, len(concrete_outputs_by_rule_source)):
concrete_output = \
concrete_outputs_by_rule_source[concrete_output_index][0]
if concrete_output_index == len(concrete_outputs_by_rule_source) - 1:
eol = ''
else:
eol = ' \\'
makefile.write(' %s%s\n' % (concrete_output, eol))
for (rule_source, concrete_outputs, message, action) in \
zip(rule['rule_sources'], concrete_outputs_by_rule_source,
messages, actions):
makefile.write('\n')
concrete_output_dirs = []
for concrete_output_index in xrange(0, len(concrete_outputs)):
concrete_output = concrete_outputs[concrete_output_index]
if concrete_output_index == 0:
bol = ''
else:
bol = ' '
makefile.write('%s%s \\\n' % (bol, concrete_output))
concrete_output_dir = posixpath.dirname(concrete_output)
if (concrete_output_dir and
concrete_output_dir not in concrete_output_dirs):
concrete_output_dirs.append(concrete_output_dir)
makefile.write(' : \\\n')
prerequisites = [rule_source]
prerequisites.extend(rule.get('inputs', []))
for prerequisite_index in xrange(0, len(prerequisites)):
prerequisite = prerequisites[prerequisite_index]
if prerequisite_index == len(prerequisites) - 1:
eol = ''
else:
eol = ' \\'
makefile.write(' %s%s\n' % (prerequisite, eol))
if len(concrete_output_dirs) > 0:
makefile.write('\t@mkdir -p "%s"\n' %
'" "'.join(concrete_output_dirs))
if message:
makefile.write('\t@echo note: %s\n' % message)
makefile.write('\t%s\n' % action)
makefile.close()
script = \
"""JOB_COUNT="$(/usr/sbin/sysctl -n hw.ncpu)"
if [ "${JOB_COUNT}" -gt 4 ]; then
JOB_COUNT=4
fi
exec xcrun make -f "${PROJECT_FILE_PATH}/%s" -j "${JOB_COUNT}"
exit 1
""" % makefile_name
ssbp = gyp.xcodeproj_file.PBXShellScriptBuildPhase({
'name': 'Rule "' + rule['rule_name'] + '"',
'shellScript': script,
'showEnvVarsInLog': 0,
})
if support_xct:
support_xct.AppendProperty('buildPhases', ssbp)
else:
xct._properties['buildPhases'].insert(prebuild_index, ssbp)
prebuild_index = prebuild_index + 1
groups = ['inputs', 'inputs_excluded']
if skip_excluded_files:
groups = [x for x in groups if not x.endswith('_excluded')]
for group in groups:
for item in rule.get(group, []):
pbxp.AddOrGetFileInRootGroup(item)
for source in spec.get('sources', []):
(source_root, source_extension) = posixpath.splitext(source)
if source_extension[1:] not in rules_by_ext:
AddSourceToTarget(source, type, pbxp, xct)
else:
pbxp.AddOrGetFileInRootGroup(source)
if is_bundle:
for resource in tgt_mac_bundle_resources:
(resource_root, resource_extension) = posixpath.splitext(resource)
if resource_extension[1:] not in rules_by_ext:
AddResourceToTarget(resource, pbxp, xct)
else:
pbxp.AddOrGetFileInRootGroup(resource)
for header in spec.get('mac_framework_private_headers', []):
AddHeaderToTarget(header, pbxp, xct, False)
if is_bundle or type == 'static_library':
for header in spec.get('mac_framework_headers', []):
AddHeaderToTarget(header, pbxp, xct, True)
pbxcp_dict = {}
for copy_group in spec.get('copies', []):
dest = copy_group['destination']
if dest[0] not in ('/', '$'):
dest = '$(SRCROOT)/' + dest
code_sign = int(copy_group.get('xcode_code_sign', 0))
settings = (None, '{ATTRIBUTES = (CodeSignOnCopy, ); }')[code_sign];
pbxcp = pbxcp_dict.get(dest, None)
if pbxcp is None:
pbxcp = gyp.xcodeproj_file.PBXCopyFilesBuildPhase({
'name': 'Copy to ' + copy_group['destination']
},
parent=xct)
pbxcp.SetDestination(dest)
xct._properties['buildPhases'].insert(prebuild_index, pbxcp)
pbxcp_dict[dest] = pbxcp
for file in copy_group['files']:
pbxcp.AddFile(file, settings)
if not skip_excluded_files:
for key in ['sources', 'mac_bundle_resources', 'mac_framework_headers',
'mac_framework_private_headers']:
excluded_key = key + '_excluded'
for item in spec.get(excluded_key, []):
pbxp.AddOrGetFileInRootGroup(item)
groups = ['inputs', 'inputs_excluded', 'outputs', 'outputs_excluded']
if skip_excluded_files:
groups = [x for x in groups if not x.endswith('_excluded')]
for action in spec.get('actions', []):
for group in groups:
for item in action.get(group, []):
if not item.startswith('$(BUILT_PRODUCTS_DIR)/'):
pbxp.AddOrGetFileInRootGroup(item)
for postbuild in spec.get('postbuilds', []):
action_string_sh = gyp.common.EncodePOSIXShellList(postbuild['action'])
script = 'exec ' + action_string_sh + '\nexit 1\n'
ssbp = gyp.xcodeproj_file.PBXShellScriptBuildPhase({
'inputPaths': ['$(BUILT_PRODUCTS_DIR)/$(EXECUTABLE_PATH)'],
'name': 'Postbuild "' + postbuild['postbuild_name'] + '"',
'shellScript': script,
'showEnvVarsInLog': 0,
})
xct.AppendProperty('buildPhases', ssbp)
if 'dependencies' in spec:
for dependency in spec['dependencies']:
xct.AddDependency(xcode_targets[dependency])
if support_xct:
support_xct.AddDependency(xcode_targets[dependency])
if 'libraries' in spec:
for library in spec['libraries']:
xct.FrameworksPhase().AddFile(library)
library_dir = posixpath.dirname(library)
if library_dir not in xcode_standard_library_dirs and (
not xct.HasBuildSetting(_library_search_paths_var) or
library_dir not in xct.GetBuildSetting(_library_search_paths_var)):
xct.AppendBuildSetting(_library_search_paths_var, library_dir)
for configuration_name in configuration_names:
configuration = spec['configurations'][configuration_name]
xcbc = xct.ConfigurationNamed(configuration_name)
for include_dir in configuration.get('mac_framework_dirs', []):
xcbc.AppendBuildSetting('FRAMEWORK_SEARCH_PATHS', include_dir)
for include_dir in configuration.get('include_dirs', []):
xcbc.AppendBuildSetting('HEADER_SEARCH_PATHS', include_dir)
for library_dir in configuration.get('library_dirs', []):
if library_dir not in xcode_standard_library_dirs and (
not xcbc.HasBuildSetting(_library_search_paths_var) or
library_dir not in xcbc.GetBuildSetting(_library_search_paths_var)):
xcbc.AppendBuildSetting(_library_search_paths_var, library_dir)
if 'defines' in configuration:
for define in configuration['defines']:
set_define = EscapeXcodeDefine(define)
xcbc.AppendBuildSetting('GCC_PREPROCESSOR_DEFINITIONS', set_define)
if 'xcode_settings' in configuration:
for xck, xcv in configuration['xcode_settings'].iteritems():
xcbc.SetBuildSetting(xck, xcv)
if 'xcode_config_file' in configuration:
config_ref = pbxp.AddOrGetFileInRootGroup(
configuration['xcode_config_file'])
xcbc.SetBaseConfiguration(config_ref)
build_files = []
for build_file, build_file_dict in data.iteritems():
if build_file.endswith('.gyp'):
build_files.append(build_file)
for build_file in build_files:
xcode_projects[build_file].Finalize1(xcode_targets, serialize_all_tests)
for build_file in build_files:
xcode_projects[build_file].Finalize2(xcode_targets,
xcode_target_to_target_dict)
for build_file in build_files:
xcode_projects[build_file].Write()
|
data/Yipit/pyeqs/tests/unit/test_filter.py
|
from __future__ import unicode_literals
from pyeqs import Filter
from pyeqs.dsl import Term
from tests.helpers import homogeneous
def test_create_filter():
"""
Create Default Filter
"""
t = Filter()
results = {
"and": []
}
homogeneous(t, results)
def test_add_filter():
"""
Create Filter with Block
"""
t = Filter()
t.filter(Term("foo", "bar"))
results = {
"and": [
{
"term": {
"foo": "bar"
}
}
]
}
homogeneous(t, results)
def test_filter_with_or():
"""
Create OR Filter
"""
t = Filter("or")
results = {
"or": []
}
homogeneous(t, results)
def test_filter_with_and():
"""
Create AND Filter
"""
t = Filter("and")
results = {
"and": []
}
homogeneous(t, results)
|
data/adaptivdesign/django-sellmo/example/variation/admin.py
|
from django.contrib import admin
from sellmo.contrib.variation.models import Variation
class VariationAdmin(admin.ModelAdmin):
search_fields = ['description']
list_display = ['description', 'stock']
list_editable = ['stock']
def has_add_permission(self, request):
return False
admin.site.register(Variation, VariationAdmin)
|
data/Juniper/py-junos-eznc/tests/unit/utils/test_util.py
|
__author__ = "Nitin Kumar, Rick Sherman"
__credits__ = "Jeremy Schulman"
import unittest
from nose.plugins.attrib import attr
from jnpr.junos import Device
from jnpr.junos.utils.util import Util
from mock import patch
@attr('unit')
class TestUtil(unittest.TestCase):
@patch('ncclient.manager.connect')
def setUp(self, mock_connect):
self.dev = Device(host='1.1.1.1', user='nitin', password='password123',
gather_facts=False)
self.dev.open()
self.util = Util(self.dev)
def test_repr(self):
self.assertEqual(repr(self.util), 'jnpr.junos.utils.Util(1.1.1.1)')
def test_dev_setter_exception(self):
def mod_dev():
self.util.dev = 'abc'
self.assertRaises(RuntimeError, mod_dev)
def test_rpc_setter_exception(self):
def mod_rpc():
self.util.rpc = 'abc'
self.assertRaises(RuntimeError, mod_rpc)
|
data/SergioChan/SCTornadoTCP/Server/urls.py
|
__author__ = 'Yuheng Chen'
Handler_mapping = {}
def handler(cmdid):
'''
decorator for custom Handler
used to add mapping between cmdId and Handler
'''
def _module_dec(cls):
Handler_mapping[cmdid] = cls
return cls
return _module_dec
|
data/YelpArchive/pushmanager/pushmanager/tests/test_ui_methods.py
|
import testify as T
from pushmanager.ui_methods import authorized_to_manage_request
from pushmanager.ui_methods import sort_pickmes
class UIMethodTest(T.TestCase):
def test_authorized_to_manage_request_random_user(self):
request = {'user': 'testuser', 'watchers': None}
T.assert_equal(False, authorized_to_manage_request(None, request, 'notme'))
def test_authorized_to_manage_request_request_user(self):
request = {'user': 'testuser', 'watchers': None}
T.assert_equal(True, authorized_to_manage_request(None, request, 'testuser'))
def test_authorized_to_manage_request_pushmaster(self):
request = {'user': 'testuser', 'watchers': None}
T.assert_equal(True, authorized_to_manage_request(None, request, 'notme', True))
def test_authorized_to_manage_request_watcher(self):
request = {'user': 'testuser', 'watchers': 'watcher1'}
T.assert_equal(True, authorized_to_manage_request(None, request, 'watcher1'))
def test_sort_pickmes_regular_case(self):
requests = [
{'tags': 'fake_tags', 'user': 'userA'},
{'tags': 'fake_tags', 'user': 'userB'},
{'tags': 'urgent,no-verify', 'user': 'userA'},
{'tags': 'urgent,no-verify', 'user': 'userA'},
{'tags': 'urgent,no-verify', 'user': 'userB'},
{'tags': 'urgent,no-verify', 'user': 'userB'},
{'tags': 'urgent', 'user': 'userA'},
{'tags': 'urgent,no-verify,seagull', 'user': 'userB'},
]
sorted_requests = sort_pickmes(None, requests, ['urgent', 'no-verify', 'seagull'])
T.assert_equal(len(sorted_requests), 8)
T.assert_equal(sorted_requests[0], {'tags': 'urgent,no-verify,seagull', 'user': 'userB'})
T.assert_equal(sorted_requests[1], {'tags': 'urgent,no-verify', 'user': 'userA'})
T.assert_equal(sorted_requests[2], {'tags': 'urgent,no-verify', 'user': 'userA'})
T.assert_equal(sorted_requests[3], {'tags': 'urgent,no-verify', 'user': 'userB'})
T.assert_equal(sorted_requests[4], {'tags': 'urgent,no-verify', 'user': 'userB'})
T.assert_equal(sorted_requests[5], {'tags': 'urgent', 'user': 'userA'})
T.assert_equal(sorted_requests[6], {'tags': 'fake_tags', 'user': 'userA'})
T.assert_equal(sorted_requests[7], {'tags': 'fake_tags', 'user': 'userB'})
def test_sort_pickmes_all_tags_in_ordering(self):
requests = [
{'tags': 'no-verify', 'user': 'userA'},
{'tags': 'urgent', 'user': 'userC'},
{'tags': 'seagull', 'user': 'userA'},
{'tags': 'no-verify', 'user': 'userA'},
{'tags': 'seagull', 'user': 'userB'},
{'tags': 'seagull', 'user': 'userB'},
{'tags': 'no-verify', 'user': 'userA'},
{'tags': 'seagull', 'user': 'userB'},
{'tags': 'no-verify', 'user': 'userB'},
]
sorted_requests = sort_pickmes(None, requests, ['urgent', 'no-verify', 'seagull'])
T.assert_equal(len(sorted_requests), 9)
T.assert_equal(sorted_requests[0], {'tags': 'urgent', 'user': 'userC'})
T.assert_equal(sorted_requests[1], {'tags': 'no-verify', 'user': 'userA'})
T.assert_equal(sorted_requests[2], {'tags': 'no-verify', 'user': 'userA'})
T.assert_equal(sorted_requests[3], {'tags': 'no-verify', 'user': 'userA'})
T.assert_equal(sorted_requests[4], {'tags': 'no-verify', 'user': 'userB'})
T.assert_equal(sorted_requests[5], {'tags': 'seagull', 'user': 'userA'})
T.assert_equal(sorted_requests[6], {'tags': 'seagull', 'user': 'userB'})
T.assert_equal(sorted_requests[7], {'tags': 'seagull', 'user': 'userB'})
T.assert_equal(sorted_requests[8], {'tags': 'seagull', 'user': 'userB'})
def test_sort_pickmes_no_tags_order(self):
requests = [
{'tags': 'no-verify', 'user': 'userA'},
{'tags': 'urgent', 'user': 'userB'},
{'tags': 'seagull', 'user': 'userC'},
]
sorted_requests = sort_pickmes(None, requests, [])
T.assert_equal(len(sorted_requests), 3)
T.assert_equal(sorted_requests[0], {'tags': 'no-verify', 'user': 'userA'})
T.assert_equal(sorted_requests[1], {'tags': 'urgent', 'user': 'userB'})
T.assert_equal(sorted_requests[2], {'tags': 'seagull', 'user': 'userC'})
if __name__ == '__main__':
T.run()
|
data/NVIDIA/DIGITS/digits/dataset/images/__init__.py
|
from __future__ import absolute_import
from .classification import *
from .generic import *
from .job import ImageDatasetJob
|
data/Koed00/django-q/runtests.py
|
sources = """
eNrcvWuTG0eSIKjbe2Nvds/sztbsvmWDxwFAopIPqbd7sCrNUCTVzRuJpJFUN9tKNWAWkKjKLiAT
zExUFVqrsftwP/i+nN3X81dEekRGAihKvTN2sm5WIjPC4+Xh4e7hj//z3/z08bPh+//w2Wefrbfx
dFbM03iaVFVa1lmR5+n1x//q/YeHn33W7/d732T5PMryOi1X6TxL6jRKr5Llpk6waFSm1WZZV1Ag
4vpRBV/SVZrDy/qiLDbnF9HZJlvWUOLJ23dx791FVkXVRbFZzqH2epnM0qhpu1jO4/UWmgAAm2S5
3MY97EQvW60LBL6tzGNS1fb1ettblMUqsoOx8CIpMV0U5Sqpp+kNtJhT38fR19yvJ6bw87Isyh5A
XWBDMZSssVoMQyrr6jqrL4b9PydXSX8UJTApWOYqLSuoOc3yRRF9GQ0fj6Nfj6PHo0kvgv/uRG/T
NLqo6/XkwYOzzXkV/3lbXxR5XJTnD7Kq2qSPvvi731BR7FlZRcfRsP91USxfrfvjqP91lvPD93lS
bvnx22R1Nk/w6cXi+Q29epbN6v6YwDT/9b/NqvppsaISv0vztEzqopQaf8rS5RwfsEBSpvQI092G
8iZdl/j15WaFf97W9OtJXZfZ2aamim83Z9WszNY1lUtWabgv+PXdZr1M+yMecVWvah7xN5t8hgvw
LF1QT5awfvL8Jq03ZU6jTJcpNwgLlp3n7VaebM7Np6j/ugSkxYdvCuryHy+yZcrTRj9hNQl+klWB
Dr8rt89vZimPCX7ALkBslNYBXQgS4Vbz9A3gYBvU85t0RmuwLM6SJT7BIlCXXsMwaZnLNLnk1cgB
Hzd2hhAnpjkgNE5TldbD8xR2V10OAfnHUQ5TPYoAQ+kJtyAjkZreW1Wm9eDK83QRTbMK9iVtmXKI
cASp8b+SViXKiXBMZ7he06ntAbfaAoTwDwfUdL+XLqt0cpt+ZVWWw6bNZykVGCOxiLH86DadCkLB
8iOgEdTV6JskW27KdMi4AhgsUIBmETGBCd4ApbhG3GMiugbgWX5OtJAom+0Q0JCsnk6HVbpcjCNF
qI77fdU5/BzPkk2V4rICCUpvZkR+hiO3jIIAJdUv6D02aLszrIpNOYPxLUpAhbEQ5+kCxnb8TQJz
L62vijkAwkkAklGlUo1bvYLJAvIC35+lQOheGNhpOSSoXKout81ApEpMf4cAnMukNJVmZpviC37R
GvTJo1N/4QDRpfRQ/jJopOvN2FrrPewPm3MDS6TzMZxdNSxfCtgAf5MKyh6Vm5w2Tt/b6bDsayQ6
uLzOgYnnZVqNEcQ8mwOy1wQ+jqK3m/PztMIGq0kI3gzIM1BZc7YiCqcVHjjRWQpdSOGItR+hR4gU
R0d5ccSvRkBHaKmhx8NisUjzOfRtusxys9jHL4vcLC/MDr0DvI/wtZp6en2Mxyudrt/g7yEuwxSn
mn49GvEcm71jkSvYrvQrsFATQQKNu4HD25TXWC6YiJMNlUwB2ioGSRADgAJSGbWnsGeVu0niar3M
avqgNhbUx9Wj1xNnuehVnKzXMNhhvz9yYZ88PI3uH0f96Msvo7tVP7obcR/GTTl3yP0f8n785yLL
h1Rftk96U+O3u4AsAsUd5cNTIKJIz6dTh4JY9EcIDjvj8j4Tg0ua4Eir+Ofk0X+cnOplxpdAToo1
cxfTVbKGoj9SESQUX2f1qzIC1P7Pci7Ky/cFvf0n9+0TIJXw9m/V22/fXmSLGt9++aV6/ca+/uor
9frJnADcV6+AOcFXR+rVd8Cx4rt76t2z7ApfPVCvvlkWRWne6w/fFdTKXfXq+Ud8c3ysXr0san77
K/32Wx6L8+Y5vdKlfsdDc95Qqa90qdfFNQ1Dj+NFha+yynkFXeG3iLz6S06vc7fX/BbRHL70fur1
Nsh8tpZWgGK5u05z+RViEHz6Z+f992Yl3LdmyeAttiXnausQ4Rbn6R/40GiOWVsIT9SI2Z26iM6X
abJCerjYLOF4BWjnTJaZlOAGj3Ydv0ylvFPX0EH621Q9R+Y6m035IOP6HkdxB86z5fIsmV3yYXKd
RvMiH9TRRXIFBDyq1uksS5YorSxJeOIuarqzi+1xT+fn9pTgck6xWUHcIIxmiocLHHLN0Wt3vD6m
m0MSJT1TmaYgRklwOCvc2nKAW5YoAAp5bss7+bU1GVRtgaxYDrkTbg0hRY5kx+Ua2rrMdnN87gTC
Bt/AvJxgodNDpg9Y9xS5/AOmUc8eVJn+wtMnk4Hn95j+VXNQpS4shuOeAMP+LGG8zOfAstIpw9wv
nO/NZjFjZ2Q3/CPMRHrcR6Tot7lpW0UK979UQrrZxLR8QPcIlGqQttYUEbthj8t2GzS5vA2xQMzn
vA9GlpcBIfIrTgfOJcQPlEDgS3xWzL01VE2IKOACf0msEdMAl4QEENTgkktBcssvNzoEPLuB1cuF
P1sWs2TZkAeeU2INSuw6fQa+JWKSD9QQRU94QTwDAomzueI9AlitmfsgMlMbe8jBbly+w9QPqDVg
wgYHBvNeAfYF2yFJpMWI4cdJaAeYQfqkYAe18FZSVCOymDgvmmNMF7h6+DbGZ+eDq2WiN+568zrj
h5GDesUasAZYqmmxxmX8S7YeUgvFuuIexDPqFPJalUe+qJ7TML0JNSxNuJSjWE+r7eqswLnW/NxJ
sW4k89MdtBrY0oj+R0jWngfbwLhF0br+88fk9rjB+imdini4T2lhoBvqVZmdX9TUqaYLe6m6j/+f
ci6OI69jxwoXDp+F1liO1cr+vMOjc26DQ5VNxw1Pgv0/Q1VWqEv/mG7PiqScE79WbtZ1R9cCddsl
263s23Y7d0evoQ64/ErSnSLXwXvOoT30zqc7KEHSB4VnuhtOm+50I0hfomzvsFKUarejY6xOFjJ2
Bj8KTciAKSK1jVJ2cZkYiRFyQ6/KoJCKoz059cgXkA26LZB2+AD2xrXjHGTyJGA6+UIrZndiL08n
AT7mEe7DoZw5e54NHEMf9SnyD/3uEtSH/eg+nzYkrut+juBLf9T/hDUTfb8sGglgas3WSQ2bCFu3
otkJPcVhWi0T6pNjfhlaAQPMWwd35KYXRFfbDezkLlRdTbxTUoyPdnAdh1JbfDh2h3goW3IAhbzF
5sMbHLP3srzweYgDWQWqGrsMAx0Fbn1+1Q2Avis1cfC856JhTPJx3xz5o44z/3YHfmtEo96nn/Wt
g/5TmNy/8uHeOtj1Av6L4CteAhqOFx61aLTJZ+7i4hsXy7BKjK+bppPyfNp9atDvH/WaYu1+NCHg
P2koG75Tbh068AkPHGoanr3Dxmt+TC9CGwTej1o15VTQ/bPsbT4EAu/xkXl1Yqqdoi7BtuVD5sGY
c8zUGe3qulM6uMo4G5fp9roo53ZG5PenzopUN4L0f5n5kUanSqqtju8KYNOj0Hq5s+qBgbqmbX3C
7JrpMATnkHOuBmjGUbv+M/DQgXHQjGPh/i+Bhv17Mse3nSen4p7pubz+uZPDEA6amsvrefULTc2n
z80Bk4MD4m9ZnqIWEo0BmJ/04XZeGN2thuYcbpNqtwG3Yb85HvmeoxebsO0hlL/mQXvvnjvun3ka
NuwzTNoP+Y93cQrw6SfNqq8PUD93MsRQGk/YdeAW7tDzGNXVYjhFCBdWKuqxlBFf2jTqPpJcmvdG
Ldhvr63qu9WcycPPXdhGM/tJWkIBwOo/j1uxZkgyOWjeomVb1lco0RYLxLP6hiXbb4tkPururquV
JdjexHnMLr8LchfYrneItvZvLIQiBJsAhLrg7UtSexuCY+r8F2KCSeZyJuEX3LSt2Wo2bsx7l6Yu
vGFvoWvzL2l+FpjDFvJO9PQinV0aHT9+RMU9WTQmeDnCyNut7jeGXd5ajKPBdDrPZvV0OhhHP/4U
2veKtfmFsAW7PTV9/msijd/Qu3Lj6Oic7z5Grw+8XDzkrPhrnwRC6+i2zBC6qiprx0aj8iRvehMk
RVg1xs8Oc+ZDcKxEiPjC6OlvdCz2rz+0tkMLCHBAAuKHvO+RWr8w2Zi4r04e/Xpy9LhT/SDGKkLu
WnPQMttRczI5QLFPRClsI/yL69xDeKC6G0CG7DxvkAF+qNmlg8ZFB37VgQ9Qe8/hFMcx4X1judQx
08KEk7kGMi1t7Z49eYc76CkaPeXFse5bzO+668yK5bRYLKq0dus171U30+spF5LOyoRKRUB9oKkV
s0Bjrzf7+tHdn1BPAlYHtm+nOylx0O6ghckBe4M2/dXY8VdWO+mmeh//zfv/5bPPPpuut4jr8arI
QeQG4jm7+Phfv/9/I3JAiNRbNOFByrMqZpf4vBC78WSZ1ds4irSrQFGNyV3AOAYYJwTjEHCWVNAm
TMI52yJyH0iwQZlrqpoFIv5xgwTTWh29g3OaRwfi2ocPquyHD5GAiNZlcZWRPdJFKhdbF+lynZbR
Kq0vijkZKsEqZottVJz9OZ0hxuF5jSMqM6iIdyoVENGrrITpn/QU1tgG40pOfwBhEJZtC2mJYHzH
eDKOgnXn6dKvu78SNJjV6Wq4AhEXSjqNdjZDNW7bDIx86IxoDScpnCliltzVVqvaAY1tK3i4mEoD
eEFxES45u5hnpXynAk+WS17FbCYqzusMXp2l0SafFzkwdAtgBoi1EzxCnDMnoMXh6CIBni/Ls+oi
nccRYtiHD9LxDx96zIzgPkZgc/x3RVarcLYleLvK9ubwPysUNUeV6RDt2blhNGGCH+BsUet8BWD6
kRcR08DYYDxbgNMUACXSm8PY/dLQ4mQ+X6CvRPaXtBxy+RjnwbEO5vc9MUSfg5R1lU55Y+LEDvlx
is928YyVsvH4wcnrhaU8p7ra6CO6zov7Rh5W5ZQpEdG1d9t1KgZRqw2sEkxeclYVSzTGNl2AahED
HhPEuyUcj53HgtMrayxd1Y1Gm2ccbyGbkrx85D7AnyfdpB52FxpLy0ROp0OuMVbWYGMUFufFbDrt
t+g8+7CwHbB/m6omze9Gc5dRl8ksRRvHC6B606nPkluWmok9Wi4P+zPyAyPQ4taVb6Nqc4a4XouV
886TVs2VZ8EggxeORNC5JLPuIYxnHD3yTecQfVlr52rj26ZzwnmWBgd3MpK8fKgRx/Kj6KvoUdh4
giS/Y+7Iulh7pn3uMp9rqu/KkwFwJw9PQ9YcsrXCvdnTgmCNS21+KbTg4xBVV0KNEtMM77JI9Spo
AEmCLE5Vz9oUvyzqyiAuW/yi1CcWv21bwv6XOVX4ClgKfoKeMwxYGIGp6KDlDaJX3PnLNF0TwwIQ
Z3gnUywiOasf4Gn4AI6pB3LuRLOLJD9Pq9iS2pZNsm+MPBVY7o2Y/YQthD7Nruc0DmUZKnWSq9T0
RgrYjhgWg+UNvbPkiD3mGfJO2qbHOC1vYQabZWQ3jSK30Fbpqiizv+CM4eFUAFlg/t0C+XqLnUlQ
ghHTVQf3tP6E2zDONulNBpjVcE/fQOFZkV+leZai7mBbbKJZkrMVNjBjiZB12OZwBnMHga+DfTy7
sEDMmWptV+FghfJJNC9qfFanxDhCGZg6B1hTE22zcM5SM+Sm46R5jYDzTtAevJlGh9O0jF8feETo
IawsELUluYdGN+TMMBLGgfpLlBbRuCbWgmsIu8oswEI+FRW8XpE4ombN40hkBV1ORNgKwkvx8cUN
7SganJGKgWqyLNNkvkX+rkrzOhrKQhOL7JALWgRAlgT4LHTJwlUgbBjFGtt6B9MfWSdgHmD1lSkY
dJVHyF2s/DOvzXYYTNYcR5cyQPEX6LRlljKwtZhpCVHovl9LyjOyMTPB2GWRMgzHOFdTlz0jduNO
hT1yb9Koi5ZnaTNxpleGf2umFvb2Fdn0ngeHzbPtaG8EBgl/UrtjWUKUYdjvPEicpkeqj3ei5KoA
+sF0HqQ48nAuyipaZpcpeblnM5bjHlAZftadFpSKs4oKSFMeSti5EAbFaGxxRw/D8+GQ/xhaQb3g
w3HkTSNDHul63UjW0HojErZp/SFEnp201Sx/+IBVkcygHN5Q03F05pFzC8cn63UHWQdicZUVm2q5
bVH4F7g5m7Yx4gDR9gyJdD7XVD2rLL1vFq++DXm31L2x7DJUvpu6O33VZBX7ikS64CsvXH7htZBG
ByW5nub4LF1dZRWC/FSyuLDOBn916mdQztmLnWTPpV1u3dsTv8Mp4c8geDJbQILa42zNaydTHiRt
+ySVw4jFYRdbO8m1x4cH19ThKEkjxFQGSJ5Ljtqco9WLwWbPQcxqNjfsFGYUHQR3GGE9btUWPLbJ
rBoHfD8xliLUhEMlw/3fTxtdiojjiiOKQtFocfDwgCEXKXrDhIjbL0UwgJfcSyoMJRD5Hzp8W5Q1
4zocWX/GognyNYvnIB2qBhtDipZeUbnDa+QTDSwaxkCNMkvOlqmDgB8+EKAPH2JZHgGo+G86Z0DM
A7ILJwre8iVzOhhmm7JEwMFGGO0sfYejSyALqy7NRskczXdgga2kofrQNBvrhTWsXeMRr9fctINt
mhAhShkdZBL5731b976qIYvhLLWhAk2pHVyJv3S33Wk4KWqO25uOdxyilFKN/dW2XnC59+1FmjWr
TW/NmpkS9wQi1Pf02zyRpDVzp+61LB2gD3w02E3hkPj3EmYERUU5KtGmiA3efKLRViu0Akt0aR9M
cycThTDyTpEFRFwaghooq+c7h/eU9CzOvrsuSrpMgnrArRdwtMCQSZC1LCO1a+G8JoVNkpNS2KgK
0BIZr5moKPssshKrk6g2+pgd88LqGivgu6EoDD/BOoY+Dd2/Zaf+8KTsorzQQutiA6cTVfe++gnn
8Xt4bxnwRnsVUXQvNNNEBQs6dVYO0iM4lJ1ml3GEpubkk1/jLKZQHohaBoRGJLV0sUA12iZfplXj
94S6mjlem5Vp62bQ3rNQM2QsautpNUZJG43MuzCoEzaWp7DMNVeKPtCoRyCjwC6aiV9qcxULRVAY
2NQFRhKYEYj5hrCgTpPyaF5c54GGXxY1Il7C4kyFJNW5OIwW2U294b5tkGAks7IA2TNptgA0gRcB
zrVRll/JFoyJPDkgDaizAlD2bNvcHVy0wNS4yixg56nRBXEZ7lc1dqYAh2smikkdzTrOn1QWrIhW
yRxPj0bjhZ0xDVfh/UHuZN6FJp5ADjvb4kO0wiYotmgx2AfvqbdbW0RztbZuh1QOhKvtqdCwsN3D
QsK+c1jBIQWvHRQjJM16R3DbQ7NDh890BFDxDoVAMso6ujvEGElVgQEt2Jn7AsW5CkjpnCMBHjKp
Xgcttx1kC1tT23XUIA4EyGpztFiLClVx79HUKMZDZDzcpiWutuyok9QT/I//zfu/kdiM0xVgFFpq
fPxv3/8G3jURD9dbAMm+qs2hM6Q6i2wJIv0ohgIkmY56H/+79/9eIPKJUKyAUHz879//P485zCP+
37WcgPOzqLIbmpWm1d6d6LviClaXeCqOQwBQe1l1neWfPzaHt4RORP/LPn0gV0obgg6bGJBZ82DM
vNMIiw7yemDvVsgoMi3FV2A6J75kWuRTYspSNvob0I8KoAyAIl3iXxg0/sE5GHTGd/FYA1oBWWEa
cMN4yrKN/BtijJRjorWkcwkdaWotTHCM21WbF3WwpjJKptVDFQtpkZSR3iAeqHM7vbGmguV52yQa
Xvp1Wy4ZOLvxAHh4eO7uCgWHIkcK3TiuySeM34wr2PXOWWi1zxooHN3tAOkpIf8iC7FMl3VxGDAu
6lZf5CsylTgIgCnsgrCWlLtgiNqW4Iwa40sX0pTitybWaP7y2guA4p1Nl9cx0t1q6KuqONCTH5mD
7ETShlbuPaek8Llzx9h2hzvwvlm0FSeTz0+ZohT1IHyi2f4Hr6N3Hqs7u33y+eQ0fHN/4BD0keuz
AtRqUF4IaVeDoPvA7t4tgTsj8holV0m2JOET115u1xkFGlw6LDiEiZoAc1Im1/g4xP6O4O0UcHBW
bEDc6rR+AABDpE1YRfQRo+ifZJm6Z8nxD2nNeJDhkNYwRoE0BO3QL2r75zUri4wHcYqLED9/+er5
y3fjSL949+zFG/3m6+/f/imgLb8T0ZdokcJA+Co7r4G3AoFjVpQoro4DdTBkJbDz0SVGbgZePE9n
IEGh5pTFGWj/u+fPXnz/XaCuuY+dYZWMVBI5mmZcFHmrtA4eyyxM4IzunH1T8/K6e5KhGFAfo+0b
TXaqqXcigrJNJpIgMRt+Zudwqn5mB+Ul0SBjqJIC6pFyat4KLEs0QcqhHuJrOLqGrGhorFOj6iIp
+Y5KRZOj9UL2Ahg0NA4hdkfsTq1e0DBdME/mUfNQ8+zKslAgxaVdMbjIlxCPIy4kEYmnNYySQJCd
Gj/dAfT6/LKDB/C0DvbEp7s1QG06MB3BUfcCo5OebVGNMxyYqoORsYVq2Ae01F3Dbt8OzTvXZs7y
B2I7N3LYw67OyqdP6KvUbLpqQKmeyiu3o/Iy0M81CPC7Zha/0zgZ9UWCpy4f0mMNvum2fqv7rt+7
A9BfAqMwXK3XeXid5pUyYSHUHgKxW27m5v4VedyDxgLQmiFw7FPbc/jpdhjjqQaxguQu3ij3yD82
undPPJfdzptIqig4Ww0kDUBr9NEs8jy7SnP+1DgoR50YlafXFp+PBzB42pR+ZzSPm8ynZxnK4aFJ
pvsKVA8ZC7vojCz2SO9FwiCWMLPdRnYaBnUM5jIfDsqzwQhv1BdBB8xFjNCGfvfqRq6Bw6WYu5fM
4W5+n2fIikSf3NU+eq2Y5o5tu4d03ul9E3EQ1qMc/HXnlwIo3nZ+OdyxhP8ojx/t7aK5DOAAyvaa
hXuHLv/kySiXI6gIBqTEss3dSLpqtAl8Q0M8S5rMLghq61oBz9yZxzXPChAmc+vYREMblN8Pgqah
UpgDPA8HP+SDXYrxhQEqWOsD7YgJpybZjyFNUDmdQLvmIp4tiyrVC7MsBHW81RgCtwX0AgS5+ci0
KHazm3ydzS6XZl6bSRm5SlZvbGeD/Y7clmdl+WE+RV0wMrtVPY+51Rh7PI4WKjJJaLiBoSIuOIZH
3pDxO2AJoBRRwdp6KfhIYqy9rdg+ClmJNfz3i5d/ePKtsVUIhGFPcpJMsHlWL+YYtRIN1RuajXdi
pETf645V8jEsQ/Tt8JtevX/2/A8T4spzEFPQGA0vBI7m6VUGbDzqu9qwZ8V624KsWqYp1tqADito
dTTZOy4sSfaZSWMvKmsRZGzIq9YoJdxLOsAdczrecxQQ2C59xus0nGrkWhuNH9+A02mcpZW6mcX/
MKdHsamb03Gs2WtjfEpQWUUlTOw1e7LB3vcAyqwbReSk196vwE8fP7KyU0IvwqUeuhIWvYyGq2TL
gh2e7dSrUUBBXnIbphF40Qu4TF46PWnhh73QrrDcHXl2x/QnzxR6tVnWGUgRVl0Ay4eKVLy5Gcva
sJFyYHLk7hHXmudpLL0ckX0l/YjWhaRMoB3lTF+A8vsC2eU1BpAyWuBoEj36KcgMGWGGUTFudGCA
fF16OvHidpHTsGsKoQyT9WCxWS6J1yUofPVJwTiOBgJroBCMkcu4ilsTjRaa3TMKJwGK0iEI5Npe
Ef/7e68YOdLwhaGF7VQ4qdKPp14FW5Jl+o9uhV9xDb+CsQzC8tpSQjYbDw8O3STLK9nVR1UqYWyx
FHO/OHuRcwdjbi8RzQyglfYDTaLBvQEWE7MGvsPVF85SLe75JugGnjGykg4G+2cK644V+XIrMwH9
OMex1Q42hO81jQ7g5XdUtTSREEeMmGGNMzwHTBl86syW8VklnoZLINJXjfRpKF9zNLGRAwsVA2li
EO/afMraU8qPI6TvY6uKGAXPWWXuebecCPlr7CaUIgItsg1obblcl/JWzJXMjDgXcU0hys5lf54c
PTqNfnVsTI68uK2q2v2mTGMHbtOaOeCODyz62GlZD4iu24+tzt4dSvcVWvAGjczWzAVa6/q4EMOZ
HKDNUF8krY/0fYdPvEOVzKyPOjlegXyCzm6qgjLjoVD8Uky3r0v3Pgmy8dvq60uTalOm08Yi6F5A
AOdCDWvgiN0YH8scuczndatwGFAjYf/YR3ucCTEfP6mtfYZSHfff2I82zuV7d3ei9zbyR4bDd2Zt
yCHViR6SmZLt/whfYYPAvc4uyCClzSeSqkD1k5CLKlF8XyYHWL9la2QMo6xfkJUWsXqYvLS4ZLlW
N412ohterG9KnxsiNdaxYYfxnns4T6t2xGUcA5YlFlu6TXYrWJ/s9/J5cV3twPUAXGz1se4BE3J8
40ujyzm7/9LEdBWTqSCQ7XkwOTLoc0wXLENDbDD68KMDzC8QxkM3mDYaWBABwLk9BQ4kb4dXXoZX
ZmlcaKVEyCnXjBk6KTmOgoI6F+7d4vastTL7rqTV7mU+VVXJqtDdf6sGMedOtX1X+Joj1ipadWFd
IpNXpU76tRZlKIuiPlpkZVVbPQxaX+H5XNVkb8RbPktdHF4vN1VD7lhmDW9MYyJ57BIYwg98c9pz
fZy9mz1ygzk2UFyNjYUsT8pWxUM1hmILHhQN3iCh1GlFApL59boby+thK4TJUsmuTFHCdyCeQpfL
Mg8mdzLWPpuqRi2bI1g3PM2FTS3F7EtDCi+VzLVz5Y5888042ppcEnKfi2g2kr6bn203lBtkXLp1
W9heaLFveqGCSt2QzOedV0hq+vL0WjOGPG8DqjCIAIZl9S3DfZAenN6YX/f1DZXq4my1PqSLFZpE
sZnE8Ahk24fj6P6jUbz7aDNKyJUsB3SBGWleDvk5+gSqRyANN8nG0TI2ON7sVX6z7o6d73S6rDvH
vDOoo/Q4+tIdwSeSbeo8wGp674W+Mvm5suUx38AAjZOn7ByY1fRYXZ+Oo7PFsWifcbWC9HSLuXAr
Ip3Y8QrYgGVx7ZiIOzZ/otCx6h6Uloco5VuZEt3LARwaVcBCCMmxgqsWTy3XRPpwYkhS7hB2Xtwj
RTlCZGHYSP/aJrmZRYzu6r2eHdhVNk5GQbgslhUmKsMFcM3CKLEZwkOPWJK4Q910e8DrQp3Im2hS
4llLbcInLjSn7GjGvBiOBDzYvCMBqqLmQcm0VTRsnEnHtJLWCwMaLVEcRvvF1tycLXB1SDlIC8Bp
VRM6Ueb1BZ+tVZqUyHqD6Iv3H8WitYLGjXUOTXKlOHrG7yY6cGkTfREdznXD9Ab92jDqE5I6oNh0
BdKol5ew8stuY+kbJPKSHQ95C9oYZk/gPuAdMMKopiGNOCEdUO+GImBxmn7DklQCwrEmxDets8M4
JuBHikKJKzqdDoKCYxVjMSp7iAm2raC9W4CYL5p8ZDtotlEE8+lbpgu0dTD+Hqi6Q6Nlc+YkFZO4
TonP0L7jY4dgMWbLYkw6Uwx2L5Izw0rrQlUqJ8atoUbHSqcEv0cdEKi9NgSRVGYOGPg9cuV27cRK
kNTSysXgrBOwRKagaEuuzV2HIyBXg3+9LIw02oWKKkGvhcocy2y6H50NfQwT7X4u1jXtwGPeiKQ+
InpBRstNSI2bkZP1MWxL3Dotzb5m0+IY95TnjsNHpBpG6HzsaYpuhcuZ8lYtq+ZCjwY0PFmz8hSJ
g3Sjy+Rp7cgzNAdDOTvo5Clwu8yG69HotMVOt+bYw0/MqkdXZexAWgYyHdlumtDLQ67RYVPF5Grd
C1c3w5chj4LahVgOcTM68264DrTpt2dg/IsM2iQfNzt1ssPK3bvBMHygBLU1im3N/NJ+DqN2U1HD
cXTrRqENMylh9FgXASTy6BFilVKis8eAfudWNu4HDOFXCGHkpxB8s8lz0iPn0R9ZXzN29PviTCbf
JGibUe5XYw9aIo61uragB3mcvcYu+UDi6E26Xiaz1AOGgIIVGiEw3K24IwSxmZ2Sm3MniBeLpspZ
kF3rMekF7CMdk/gdNFqKWydMtOQj8HIo3onev38fVVf534cUb0a/nFXJWTVsI2p79HjVc98Okh+d
W5nGQgFtEeQuz5rTs7GZaajX+/g/vP932iOGXFk+/o/vT39ihxj24WQViZeVFz+T2nU6XWzQNW46
Ne6wuLJTcnzC8j0uRhYnN8BMnZli8maV5Mk5sNgm7AQ63RR0a42xzdKbDLinrFDeNyaY6dT0i4Gh
bsD9JopPG92I9xqXIRZHPrydvnj77ct/HNMDGSXjw5vnv5OuyzLZ6HxnFQuReC3AT7SAY3uhTlqz
sWjB8C9e8lrLxF5PbjdQzwJzOUXPpuiraPj5+OGoIWOrZD1Nqilxn+goCHDqkK0pFYDCutCo16Cq
goNBKxNLOt/CFLhms0z85HbF0j/Pqlea1Tb/8bSocEJNir9+VU9NRrjRTvcjXOqm5i5nJNdPTNci
3+DmJ7f3D8Zc0bZeXOdpS5VJjCGhRejOLuCnM+zjhuarqJEfP2t9Pe9phmfLnmkhW6HrOVpMr683
mGSCxrTRWSZM1GAEgmaYHWM6L4vNeofVCn231qyIjS0roV9w+Ofl+sDhQ0kc/nl5bod/vnf4+/TR
snsDGAm0cOolU96poZbtfygk3N2t8IS1YhCAsCKItkpVKM/uhsTQHc85vGIeMlWL7XXzRJkUAZKb
fIkVBtggBGD90MOWgRFFAaBtUV1ka/cyHKsTJ0AQ3MPY/Rah9c6ZjhRwhtED883qLMVYvK6ygT5x
ZD+6QSHemgRSvz++AmcDxBKk/21Y/Ifdw45I2LlsPsQ/zXSfm6/UY/hMf93oar7UZhUKKk48zqOS
hERaIHueh6EbYVQhu4U6HIuDu4RcZmE+WI95MxpHRC2cnXJITVGGNpV9e9fLHSREYlRigGXOJpjN
yGYpqBDo7I1paOzoDLTV4yV+ttYexXLuHTtkoE+MZFVvl+hpXc7ZeAptpnLWZTBm6Y519kh6gxoL
aUtNltMxGLbTNwmXY0IhtyyEZzDYOvXnq+F3eYOJztyx/FKjGLUItWnPC23RNT7p9VhFtvEnv5ut
DdweB8ID3OEx8ao0rGIVDR6QQVKyvE62FPGH+TCE6l//NklYiASabJvS3AEXxzvvlzlhMBX1L4bD
V7LmM1/JDgdxPBhHo3s5MDND21t4M7rlIpgIYB72sw7FoVluhG9hKNq2R0zeAXcU8hFdPo4sbwF4
xDBPJH2I7FJ8Z9t2KaLTujnP263LseI2z6fBcWQPd2yfwXodoJe93jdvv2Y8Y+hWEm7OOlLNu8ed
OQ+/RXyj85DBKM8v0VzipW9OYQoxfOEChEXcZIaZpyAftN0YcxunMEXUlgnXRxskkXv0wcM94Zjh
32UVyVjMJqk44j5Z5UBIeI+55XkejpyLzgSjHxEopLomjsGg6hujnooS9yB2iTGVGyrA8Afmt2qf
VdrIiQSU37uM+CUIBNScJbOL9FN8kjv9iD3YDtvkcU2dRuLfvnr1+vbQlx3gOwbtTGOADe1kRbmZ
WPGNu0IkdPKh3WDChh3BoQy9qqHT/wD+NcTD1rHHGQfkvWPjMbaG/Yd0KHgb+QKNqyl9gudpQzv1
NTsfmIRgwZBU1jxMmFpzidlYsGkjXR2Yi0KgqcDLO6NkOVCaQRmeFuh+BofPEX0h3zw00wVaBOQk
nceBqEjO2OwJOktKEKZgZDb9ghuMi+rDPBYMBP1j6W60mTPXigAv21Cfs/W16uR8dJNAoYq9Nm2t
OPoe/SLT6yHZzuFpmZB9AvpadBrM7ol4Zq+Ouk9QDvnlXcGok4iVCGGRqKstpaDbA7dJmRN3h3TN
9NIHlXcXTK8lVogpOmzna/B6Kpqm4T52jcX1PyDLJFI6bgOyzl5z1H/cdB5u7YkE20fH9iI/Slfr
eisGmLQh7MHbd7b6RVJddOYRwI/DDs5/Ok0/dlpdVI8sU+YtWPVYJ4DAaqR3okJ9A2ivooPhP4qX
xXVaDg/waqNmq8fBCgeehLtc4LE/CF9PT57uczdH/mlojEV9i5GdVi1hI5a906q1hbcD/tUtgN/+
RtvYRtGddkpobi+1ydUoAeEEoXXY+DNDeDu8YuYVFfh+BzVEs5Xb9Z11C57efkzqsMpOYRXfu1i7
OTOPh0nrLXw1lMuAcaWY9rKJf52xmJihyxPf6E6puarDopM8C8UlTFlubqMhxZVUoSnLNBWVDQjf
sTM1up3mGJbfbKBJLeljnO1NlkuVjsKY4uwOXKkui8Wr62EglLWvWGLRGXiAmXH9RUYfNSREsUkQ
2WV63YUBrgvkBTBjwy+++K0sAd5MFbMaeYGHv3n4sHeYBkqukaqLDTAycbnCmfeWP3yV7iy38+sQ
85ZuNdKKLlYOVWPsmil3lnZNzw6lFi5ep0oLcxTCKWDPvjEdg/V2nR73V/NfAzGZXWzyywrY3ONf
P/7i8W9/GyZuF+nNPDtP2bgZQbDqaEF+WZgjt6XWb51c4WBFLOUjRLyVSzCTzzx0oHUmxWosnWhY
5KVTXSSP+mHEbMpRsTYDwnkgVfIuU8NFGnyriDTlgLQl2yYlQ/dAHkdh4TzMSD0r0DHuMi+uows0
iCzMskpepgv01jKNa3etW/mVBy3HiRJtEI44rlt0GfU64vBA8fDUKz4stvgUEH2pwGY9R69QAHZ7
73WUELp9mo1mlFMFpvNIrkBdN2oXddErslgCv4Uk+zLdXmMaKevdbHJHYvRojMJLTAbZc7edcZPJ
g6pYpQ+wzIO6eJA8oK2T3tRewZubHYzxHFMetCp4/3mey51hlkJAVFieg+oYMqXCxhyWyoDr6uE7
vBClWBPpD7nQa2H0Gi3taJ9nMtRW4kyQj9eeTGd/7jmzbK/Mm/BDbnicMYem8cPXuMPvMywDytb1
AfWd4TTBkkIxsLCAE++HCyHfQrFzuuJmtQmMCWsg12ccxVhC0KFfdvfptj6DoV9eYwB5UVh4MYjc
uTpAuOHZvLw+oTGchs6C7gC5rUh94bOdpGU2L+S0ZPXuIJxu3zgYp79jscd21BjSFqaGSzlWWTam
lCyW6QNWN59OR5MWaPsNfbac3d8eorcepqrF5GYVvJJVuh6Mo/b1hLuFjMmJi+L9uyYU1qi6O8Tq
8Meue+WjktpujSDX7B4m3/joke8qJQ0QcR7XqGgaYKGB6Nz8C8HKjVBMNNkjAhJ+phl0k+QBfU6P
xVx/yPoLbMwErBkPRlEzIHZ04jSP4vXUCwXoQ6jtFD4SPXVASxuIkyluVDSAk4enPgPrgJDl7gTi
3i8xyMnRo9PRIWyxDiNGNaFiV+xP6o7dEx2pNrlPYQLR3Q1qBQ2IjZN/SWZ1FHu3w642C5naOcTD
iYbGe735PRiESUJn9/aBPJlkp82ZcpJNTncGQcS5dChrd6sGWToJbxhxkN7uBQqFRp8wEd1nDvvk
BQ4et9s2kk31ryC6m+U02pvZaFoPY1lscJaGuupAhm350tzDt9pVbRPAJsZc8MLEYX+MjmyzBjpn
Vat8EDSxy7sD1nGQycMXIWmcCtEWhxCLIoksl9EAqw1QEHS6iAIPEGBeCjZEOH5k45KUHGVaorMV
BTn1wFo2B5ikuzRRBDpvMdwcL+soHDJCToYTI/3Bb0dBh3Geiehj9G6h+acawC5mlGKtYg0KZzqA
jvrsCMye6cFpy1xImhQP2vlQuhs2DGKdoRvD2ovJYa4ByvOuEtIX6VWwVNszWI1DJZKhANmB0Ugr
odDoHEG9JK/a9ehg1csdxDYQpje5teZhuxGK/9RovuL2Keo1O3gQOHOaQsZGHIrhjvK6qHBBnu5H
bFStJ/xWYlAHs9YiJSEOjPQEbnTEscTlMO6bNv5iIEWX2d+UxR6JKulRPaMjBOxmcpLAH1ZTKiI6
nAz6ujTjzLaYIGaHTpRhBe7erFu7CQ8i8QKcujy0W8TbywrSrfjqaBxjKFTlgbZqHRD1ncciqWpF
dz1DtdlFtpwfjjJUvENIJoRkEujHajb+zlh7ny2qlFUfQ9rK7nB0HcK9MdJtjA/aZyaGLgC0BnDI
5jxqMd8UHaZTWG5ut0AMo6KnGJXc2gB3ntF9RP5D4VJZBmxvm+KuLdtxUPPs0bzxlE7FyQJjg7HY
Uw/79/7+pM/54Bo3lcYQgz3ifNductkO7Hey52/YKQnoyQlLMGj51vg6wzHfEAB090I/AZeYYzxB
U4t9/jr3uPYXMy6C4Rt+RNdq19W+jLhLna8mXbtC8D4yW5B3XzXa5St66CW+deJz1i4m67EqpfQ8
5FXaRiiz5d2+uS6ojv6Ddoyz80c79bYnVPa0C5N9VoScQ8UmosMj9ueuTku+13I2Afei04anqC0f
eTjG4dp5rjo8p02YEyri50sy/tuN5/ZOsQa16zuMofGzYWg3+Twtl1uKTExXlmxd0+0mTdZbCEEZ
F2Outx3tUTwRVpaLfEbJ4XRk8n0NUhP6Umq99dJaE7cRupLFsn6Q2e5rUInl09pWUlE71gasA40B
rpS2x2sclqJNlDko8atjL0YSyyzrLV2XpHM3lm4rlwgMPrChoTp+6ajblrf53nsWdJs1/IbrCHCQ
r0Hp6OCUXaowCzc6um+Ix7/xprQVM1CX3cundbk1POqgXgRUG9DfWEeA4SisysBzLMs3oSwmqtUg
roXW/mZMnRjtBteFlXYMe6cjjEYOKtmuKEMJlecpGOuZS+yP9my3j5+dWgnGPhLvd9lQCXAsL2yg
NIqgjUTxGXOuwrMsb3lEcEhsQyEpbjSNxuRN3RGP+3rnvekhgbixg9K3BXXvE0JyX+6OnihC09+G
NV1+LEXPQcWMN6Q16lwc6tHYLvfaWen1qL3KzWCuy6xOdY6DcTRP6sSVNb0BUp2I61DpZhHjkBwp
M2JhSD7fgFj5ywuTfo6F63COhUVMgxriaEb+7KgUC2ZuWIo8YJawrjdH0aYyOQsaLzkDMu4Wxw1i
/YtO3+DAvA+7JtSZS9ZuXA8OmMt/5ahG18R0m9im/yJQaOEjqyibBc/QIXfDjRVvWWAuKs6G0d9j
8tRultC5o9Xb95NWFheG4x7weh9+JSFVdYN1YXtIWTdR+yoXowbjhp2mNayd6TwiXLS8LeWf8sJj
5BKfTRcEO/ZQxTV/5yJcptMzo11F8SUPW7msqYDu2GiHYeLDQ7x8qA4fckGL5sbR5vn7F2/fhTS6
JbpXYfpqCos/IZHoAcZ94e3JTsHi31hfIBf4QJA6DkDDK4clRiJHcb5u0gWEYv7vH7OzwUKykh8s
+aALFRsyOanpUgNKHMlRr7Ir6KhsQDS9QHI4SyNKEoMpvU2+gaRl5kQ3y8dI7ga+cVSuophWbFUa
CHi846plJwPiXYhwWtmHYSejdQdSBixXFGUN19GUaR/Pv7Yn1chu4FD3lJRvXODGhBN4suHcegv8
ptGoVyJNR/VmHYihIEBwoyOcsC9X02a3uyiU8RQu+5PRKMCmnx0QGhOesyIp5y9QsVVu1nXABtKv
YyMWBrvQhDskTWbIw7A1ocvuGb3FjC2DU9YsdFo3KpYxq1tCylQoF1CzLCTzQXMrzRegA4IzMDoq
C2nIib9pr49UTgdMwlxx41gHG0M7UnEqw9fqTqbxBeMUBnRVajIXqpZtaHzON4lnQhd/Y1tuK2n3
CYEbrNq6D8GXn5olqQsoRY9lyDuyAVGOol+iNfqZEG6MmnbVbUjAwVNFzVDOCAV7cChHxWI5bzsc
7jbQLpRy1PrA75gHSqcaAuEg5I7gEDtVu2YUkrvtH7xITWaSkgrzte9QX0q9SCpK/H6ewkrvAWQU
5pvSjwzL9eaY+gEEWwMujl7l6DWG5AuDTtXSHPv64DQAuA7/nmaaeYV3YDEHmsNZ2Mk0QgELS8fV
aFIb7DXEkGkx2WHQY0dHjqi6MzZaVDFXSk7DIYqYHKJx5sy3t9c1J66uuSutltQckGvq8G45GkR3
XXsMBaKqdyfm2pGWKyWXx72RS/WuR3eQ5g5+Z+CcNaZ2qCoKr+uEzqFLdhRUVxImOPEyBwDi4m7I
DHUAAY/EHPFWK6ojY5NFIDwO2QubI+7E+yPktKM48BDdIA6NIKoS1tBA7pbRalNRcGY4wWUQlCib
4Iw+LZpOWMO9g3CRt4eJh+PKfofUklg43pX+eru+PN+zYQmfKAk0bIbZZXKeWjOqZVGQX7hhGJy4
8M0JsFkDKz2vZL9XNUVbtjmhcusvH2uP6jcNi0WWVZH0lKxuJVh2k2ekg8WXKoHQ+CKimoXhSPgm
84LHFLsiKl/D79AocDGSKgZqaMClywVoh5gWNlhq0Je8dzBY91CasFdEt4HXzAlDaWlM+XtLFVBt
K2X4yO94I3nXuFax1NYNVTpkZMuX3FYifyq+3ewHp7myWce2TP87LMnkq7kpPcgHj8Bj2iapfPLw
dA/0xpSscraWRDmxZJVyEEgcCD2lIRlMmUyiyjExwRxRyOa9CAA3S8+oSRoxLO+YNqjdnbLlWElI
G7mnLSHgM6zNZsZS/WwGcjgW5XYiN6vZOwAnH0wy1/WmfoDNQQ83a7M2XKaK28ghY7fk3EoNZEqJ
fBF2mwets90ZwQKEjoRoj9ph4kLK+TlnFPdo1HJwdbLFmTW0+hZ0emMX4mSJypptQEttlu3Y4Kjb
bzMh/DGdOyYapg2BbtaEgu00GLVzutjTGZglR3ArKLQmlbmglqudp6HOerM7Oypx3DpB3Q7CmrVQ
0NN/2GpMdO3p0yIGpqRowNqgBBzN+rEp3pFHRtt92KwgwFAf9/sm0paAGrU8MzpM4yuTCK5v8K/D
95MKx+tiHeiTmSuAEvdjaxdymKuwHXuHGrbdCM+59pZra/49Yu/8GptG3UaU26q05X5n51ZFDU6k
2GkwMHfj7KEmF1Cl32lggA3cia6BHSCfVUkgm0uiDKCe13iTdH5Rd3kKUGUKGkPTv0aVrmF14jgG
QlFE2eySZF6C7o+PCNIxPsUmblXA3gI/nBx9MTnFtoYDGNNsMI7wbxFy/nLgUt2J7/dCl/nyNQZi
I75k/zvsXhKQDgX7d6fRferIoKPbDXBlwwd1nAUKs0Tuov5q76J2Dv3x6QGu3VWlcN3G0RAoe3T8
Ad2CA9MNXOLwZlii62KLuhKKlSbbYGwGKTaVvTCK71Ar74xgtm/f7fVvpN1xkVCMihkIQsUqsj2f
Y9redZVu5sURU4EO33YxTUBn8Sr+jvqDclaYYkg1u5eCmTI1G+YPkBHn8FBs6k4uvUlnbA3rCE3Q
l3k2q30/mmYCO+780uX+FQgroAMY0Kh3txX2U13XXOF1zRrvA6aY/6BLZTDHDNmkmiK3FQSyoSic
GLQTYwCKvaJcUY09Z/1UUmVyKBnxOcdAnqQJYGgooLiCOzKL5iIXkwcZ2T/Lr4hdNO6o9UVZbM4v
mr5UF+myK+sNxTLfnFm4HNPhNZuxv37x+rl2qbziAOCNLS2mrcX3Soa2c3cy4Hlih1r3NVAKeu00
gH3Ad3Qbc2Lx5pQdKvyVUS452ApK5wgW2wI4FHV0kyNX52WiMwWuk6z2blsDV9gMvBXbjtY/eAdt
e7P3Fpq0HDVS8odtETncFRhf4HBoBh7sDnw7pDsOz2quVmerOWJjzIS2RIsw+qfZ1IdFCgit1Lht
G0/fne1JnqGzZcV22mOTQV3EP/L62eXM4sStW4AgM9fqFrkj4V3iXq0q49zXT9793nVyjE1ibpPP
XXHX7krWVooxmxT2t9jV21xmNIqYBKNEbKRcW9QkFz0NjWAsupzKJitzSuP9zwRoRVZxTu/iLEGz
fIRgwg+iBopuxzliamj8Z5ua4nJjFSw/255D4U5RiH3RAjqUNaNlkxwibLG9947W3sHutFxhL7Cg
yLTPp8z4YFbNIQssWppfZWWRnwxQETw4Nd7j/6nbU3kwMDoVhoZEGYMO6Jc7fI4JFUTN0ukQ3Xn+
yjkOqykyjR7C2z+9fff8uzevXr0bnHZESNjDwXRGajjQoVqm96RMYzhyhoO7b6mvb6Cvdwdj1XPR
he2nLQuT+dxM7ektDIl2LTfs+Wa5J4NW7ItkPm+7cO7CL6lz310TbOf5+3e2KZEK2vGlqbZBjH7f
S8FnleMd6EXemPM58itQiIF1zElrv96MGomagpazmg0PZYJ4eww9ZL975YXQTvZihEgSUj5oTn8r
q/GdNGinFPTk6dPnbw/cQ9oMQvYwHnzohIPi5yqtL/Beid+O3KAbF8UKjV/wkNyVP+3Gowa/f/Xd
c0UHdu794Gp6APsI8NmbF3943j9lFzWnKd5QtxOY/FnRbovLaihG+WoOvPlSX2TO7phj6w6d58lS
Ql9blS0G+cPN4of05o3lwpD451P4vEai5a2Ad/PDcAbA4KfIYpMdtLnYcZPOi3gAxVgNi6k3N9UG
b46tMZw2Qg+nUVA72MiMAhH5QHym2xcGo4fhTaL+5Fq041tmzfAb2pftYsReK0bMyVkAIkhaXdBl
9gFTgxdf16mdh2JTsv9kmDFhYcYM3OG8ucsdRi3yEWeC2OZmjUchTAzfG9r5lrmiED7HyDkL/JHM
vnz3Jl7e6jlPLtMpp0WBNmTPj1ERv8hujkGWpMvko4G7IOPoMk3Xx5/v4tQBTy6nePfOYs2j3zz+
7cOHowkpLerrIpon2yq0rCBgfdxoYxb2UTC5W85plfDSJMl1HGxX7ZfcZKvNCjPExSzjSm28+K6q
zUpuGChIhJV5kwUC5qG3rrdxwFi9LlXnTFLYpnvLlFPn5tEQOgEvj7Cie/Aa9p1DNXa7tX46PjnR
1NcJ4DOu8TDg00meMFiA5tLkx9lwznpmg4Z8N0KihVgD8ByNnA4Th593pqmTMZ3lOrKWwLlFYH7j
Np7Xw7P8BN24DYzTzpD8jfV6F89WVc2U3bHBFHGkBpNkZgTZSEGCoUZsLANVnTvk5H8HKP51DEdX
bFtmMtZEGJmo18WVyto3CUvb42IY3tIHL0yg4M6LHKdT8CB4PcaaHst4h8gJYxKQ3jDBDS7thlHZ
DIzNvnkiMd4ABtSkVu8/Gv1SxuBhw297Coi7VABQxnRnlSY5mUkCgSFf9w2fP8k5SMGhmbaIcCzz
ObmFprHBIq7bO4jbZCsDjZsbtFjHM/ySb2plMM5ysaWnR6WipHZwnGcLMyE6cRUU0XeHh1/k3gAX
W0wwqCeeJLTarikzFgfaxzQwo6401gboOBooj87QzYop6Xh+El5hawdFOrMgxHuoozKSXMDxKc/b
1NQKbdI7fLEFW/tyOIqqrN6QKmjM/jXGaMdOdnVRbJbzEGpzwGasQBMq4a+vMyHrjOgCBkh4uclb
qdIFUlZd0nV1mordI+xLh4WC/1coMiYlIP43FI//Onwt4ffK4JpY99AYh1kMG+g6lVM5AMhaHZPy
u6RwEXkGzN1ZuihE5c0QR3Fo1yksQrUordiuo+Xwo8jig8QWPyAlzJ4zyPHDoCyjAPscXaXKYQCl
Rs7OhkW1hqaGOel5DMzkX+JI4TsEePflsWGKoiPqTocgjaHnVdCyIJE4SClQYyKF5cKY9UvYgc7S
mEXBLuphdUQ14PC6qBc5q4b146P60Sj6cgdN7KLhtKDVZbZ2GE22zUNo6fwwdcF+jRu1xHuPdxoy
enCwVXbf2YD9g+VicPslEANg2iAc832PmnCXF8j+Y1Ld+RHtgK6TdQEZFznzMjYpnukXmhLsVqv0
PCaH0g2qSq1ZwGwqYtyhFRffv33+ZnCqSRxA2tyMI0xes/wZupMd7b18gnoZbCsUvn+vzkRBHggD
PGjmoypnkVwCb0gr0hyEnK+pnJ1M4B8TkfNoQLdv8Bf+NaB3OCFU8San4AwIr+V98OptoNMOMQ1B
FBZgCN0aR0G4QwE8jvxA7YEEtKNA875MvzHMZEvi9mV0/7uk5GvCf9hOc7NuPoSmGF6nlTPJIEnl
FSQbh8QDZsO5Q684/j8g/EWCviRAGM6RN6CbQyq8wLWnFfYDyjuTvhBMoIyHh0RQ2Bd5nrDpZwaf
DxvgUleFwTsg1DzncFTufa1i1Ffrwcvh0JSxsLrdMpFX8bSk9ycPTzEJ+3J9kQDvIpGM4CXFZp1q
Jlc2J8e9lfCC/WkfY9SOQml5OPeyZCbFJvA4H/U+9t7/jSReBxYLDqNFdv7x375/8b9S3nWYMRBs
juYw75yoK2VeQIxB8+yIoyaSgjHuDZ+OojdFnm+j14skz6vZxSqb1+Po98US/Qz+sUwv02V0dBR9
9+IdENNZmldwrKFCYTo1OcjRuKT/MH4cz9Orx/0efIHJpbcngxd59pR6iGZar7EjtBUHp73e01ff
fff85bunv3/y5i1CuPOf+jZhsS04tN6DTp7xQDJwoBRpXoyjVaXjc9nq8d5KB+YP5yrIg9CD+xHg
oOxXne91Q5F17t+tJvC/6C5G2h7alse6rfuPxha6zen8lqOK/bFELr8M5WJ3hsto0go4KFla8RuF
/cIH96NCWuWmCf0qFjtzvCvIsSoe812Sl90dHYQZ2GW6HRs/SNFhAhDAtBrVp7ubMVCkDQJlKsvf
Brbxtey52euBoqzspAGE3S1KaLfqxDZ7egKVTp08huRq1srxzTWbRLkOPH8oJ6cjP/MiTqjbv4Mn
H6sFY69x/L6h9IIKHnP1Uci/zcUJnLlWoAMHeiuOQQOGEfyEDbsMilvasRe7ectgmAb/IkLvZes2
QcpDwIc8wzxfWvrioCEhRS6eaDbMatwWqoLMXl1cAsG03plEiIeIEMOFp44IHlz0oeWXHjBeDDWD
Q+GrZVzCakhXt0oWNUHuMCsx1v3xJ/eTwUX+5KyooZoWUXgJObcQqg+oP5O2bTLjfKeRBneJRIah
aWOALo1S8QIONTiUAAHQ3H8QyH9oxnPidO20Ta31Ub7LaMT2OXdnZVfGWG8A8w0sAhqjWWB3y8Hd
ZpcFopk5TZmxnLqLtNP9Ru+5NqBP6jyBpJ7zah/c7ROzBIQfijRyU7yDw6c3G6UpbkAdkM7R3QBl
5G+AEv11qHiF4TQcA46GGLd83Ewr+BcnNAUeLC3RsjAE3HB5YxvkptmQWJ4qma77CdFRuctT1IGk
jqbGUKruGwEeqTEcGXZsWoptE+qKlOvIWNHVnc6NZBjaW+CepA+VxaHkCSGcM2sXTF60bxKYxaBD
w58EUfMku2fhFgsis8BdusU8bPL0Zg0dxpxXRGJ1zwJTQtroYzP0sN8MlpkyBtCj4Cs+nxw9npx2
3YxMd1PMTx5DZ3vYsZ3BoAZ3qx/yuxX6gQ9tDcHrPehAo0WPkOh+xBGkRqEQr1DDJzC0mRsiY7f0
ROmfzpZJfkkfKtdeEu2T8XbSEASPgBCpAXmov+PElzL4Jy45nn0roRZ+7Ay5MnZJ3Z3Wds+YyzSC
7MnABwXsStOJlsJ6hsRSS3iBixo1BjaBm41QmG6NR3fHuIyddvsyUblHuKzjtlmuMwVmELHf4h2P
EPOOlzllgZ9cnIaHRMjSzJEz3MExCMXhmKD9Sd8EQ95x/agDvgXvW3ddqXfqgzv7C50K9vfA+/t9
dIHwFTkM2Mm0LUILR7oQWS7pZGD1gqQ7kPtaI4ODCGFJ1zk6fUnD6gUcRpQkuaFT0fUDkGqdB4dC
aih2P3oUkpr9M/0A+bkr8o6UHu7i5UaH6b8FovRml6DtqRDM8Wo81LsZb94GpvlhMPeQpylRLe4X
04PSseoNy8hWV9MhKB/WAxPOwc6Km9/FmNNJZhXdC6Ox7DhYZmYbLwW9TybiBGnW3CfWvY//0/t/
KzpGkbQ//s37//s/kIaxB29rVBVT7P/tMjubwDqgMQC+JdsKZIfSq3RZrCkCHWq8oZN8z8Mu7xu8
4IZK68tz8jpHVjv5y/ZoWSTkMl9tzqRo1SPPetQIpJWYiWGXoOYR+pPBBOCdd3SWYl4YEyO16uH8
Hn3FZGwFE0856NnAUjgQSj1nDUys32pPQcVLQhM3QOLg9eCY8tSj2EECAvjw+OHDL44eP3z0RUBJ
OngUfxF//nDQ65HvFYxbIE95Jno9OIcLvtOz12D3IhN0he1BKTQxaqV7UrnaVj3tIDcwVcnNSkDH
T5ZZUrHX4LBvSgA9x+ep+THgeoCWpprM9HBKjN90ClhZ1+XxjwMpMJiYFn7CRGnYIcDF6vhHNpi1
4YAKyhKF45gnJdL6ZnmxIDqGAagB0M16PsEf4yCAdVFlN5iSOy8GaCNo8IKBcO8JDD1O+MWYd9lg
ut5iEMKICkxXKe62RTHht9zeQJYLgay3E7V8cFQDS5fMMKThnGzP4HQ5y+Bc3IqBMUaVgA1w9Dh+
iJYvaDGyTOoGr8ZoQIHGaAkuhTP8Ozg+Ml1EywCVgd60IxasA2yABsBtmV7XdMFRLJdAEDo/rzB4
eup+ltYvMMYFxXxAO426WB8tcfs661Ua36SBWKggpB8teRpMp/NiBvNkXtAsS9GJ+dhYog7EvyxY
3jifTUwhVe8yWy4HisQ69fAjPk+olKr1TVFepvNvNrk06NRa0EfMbTJR5bj2TwZ7BN/dQcv2GBiI
XGhiXqsOPFlnvPsGTsnmtdecvdrxWmwuVNTwbeGJum9p6qh7l1Ad9dnrBFK8g5YZ48cE1ri6yq9n
A3+tyPcdv0zeXuV/fPoUTi1AM3KzcutuSrXSTl34gpU7qpLte7BZ+jKxKXh0JQD3ZIPD7e4rfXen
6I6JJQNEes3H8QMMx3V0nuaoJ0LVxJPXL3g68cOe6TQNY9HgrgGCgDEhQ+Vj5jknUsap95Y+6Wrt
elJG1XpKHY7CtaiLVELvs5KS5O6owSVUFXtF9wKo8SBUxS2hqr5Da1EkyoOu1poSqhqwn4uKOepB
12ToMm7VMrme6XnxWlQlVL01mmVPxUW3GgTqeSVU3U3equ3VbZVQtadPKN8JzJ6lAE3txHybeKU0
gDKlPEZr4BancD4NwgD8Uh0QBv6kBSF4tdclHYRluqO2U0xXxxB3ST0F5mSZ5KxvCgMIFPQ3O2IS
8jjs3JnM2Uq5InsLmXve6vLrEOIpRUO73WqbB4HyzUdVw+SPHIRasB81mSWpxts/poJ8VMWTfNsm
IqY4ftRl3YPaK+uez5XFjFA3XIQA5vkvaIdQh2al+ahqfJ3AAWeIyMCr4X5UtX7HJLwon99ktV/L
/ajxjSJLdEyofNSEoQSkn3YUl4/uZiCZN7i+9qOuAII+CwqDQIXmo8Y64Limg4614I+6gSYv2qDd
gProdIpCFHTsA/moy0sghPCozUe3wo4G5KMujxqJFYfkaJdvPnpVkGVEaXEQqmI/epX04dGq5J8b
zonhVwiRexN8ZdC1ePRRcxSwE1GcDFawH3WXOleitQx6DZySav4b4prl6019VGxqdH+4SJdrE7Ru
kBX72SbD1hYhQjrfrBce22TLx7NkXWMSD1NIMxjQzxevQiyQqieFNL3BifDr+dVMIc09PXvKHwc7
6jWFNH9Xz9tV/ZqqULDqN88G+6tCIWeCMHhosvwj2uKVA7dyLR/JUK+ceGWdU6XKpkTsAr33oKiy
Ll82NQWn19mcGPkOCIGy+iRKUPpel4PQ2pmPE1vKR+JqhXoK5A7QQDu6WS0fXNSrZdTIA4zS8OEA
nKZ2oSjUDqE1QvaQ06lC3/VqJed+cac8ftfMRHK9szh+V8VfGk3HIFy8+a7pVQUoFtqYUkm+e4Lp
svDk4jsRvDpHzSFIW9EQdRTzzQy4nQGH4UA3b2SX4Dc85nITmdl0GSqoUPdCQBOhVUBZ/jop80Gg
fIwfMDexLaTlculksCI2Zgu4nJIZzCBYSRdw+JK0RmeJ1uqoevzdO692VjoPVCLJOoQ2dli+6P3u
2avv3w26K0gBt8rzN292V8ECusq2IrTprsIFGlT7adT7+O/e/2+fffbZlDVmjbQQlylRk4///v3/
/H+RWvwNv4hskejJ23eo1xNUjPIM/iGNJJCGqkrO0wpVxEaNi3Gf5ZH0m+YHkqy6KJaVfbFam8dV
UlYXydL8LGyZstEOU3ADrSs2rvEYR862vt6yTro1UKOiRh1+DxXUXCCaJeRmzNNQY46L7QzjxkZT
AEEfp9O4p5wAM3SD7xPtTc5NoMPXf3r3/O276bsnv4uOsaVYvg8xyEj/iD/3e83VnQIIYyH19Xpr
tbSoz9UxFNH+Ga/SsRBfp9NNLgWJNTkw8Db5z8lV0m9X+zOpdkxFfXtoSszWqgj0QqJ06v60x9m/
Wx3dreAfGR5aLiDAMUI4eXjKfx+dmgTPS/w9pjZ7vdd/ejp9/v4dBTyFQaHlApCk9GxzPp0SqevP
+nht0YeJoMLvnrz4lsOjQlnVD/xBoHq9N8//+ObFu+fTl8//+O2Ll8/fBkZxMnl8io55w8fj6Dcj
Tt/sFYm+jIafj6PHo96Tt09fvJi+eDt99vybJ99/+276/OXTV89evPxdCPDDU6j4ea8n6+JA/OoY
Qf5aVhSNO57i6XqMjzE+KsxQX5fJ6myeRMn4bDyb2LLDZBydjaOZY/RjjU2t/oP3MZDs3xfFpWt5
Ctv19fPXnz98HHEsStabc2QKoQeV7H9OvBC2V/XNUyV6g29+xibffEsQsM+cGp/DKTq3T9eX51PM
+EK3zkM3j81UWrC3xfTL78YClUhsRUrflVk1dB4vjRDVKZ6kziPnDUGemvbRnWjKw1A3n2yz69+h
m1inBtyuvDPeXFXW/tX0wH7D80l6ZsY0lVWqdfo/+hXXJfllqG5HKAUBuwDkQgz1I/ei2QRGZs8O
MZaIXWMJtDVStvQU/LgJfxiMA707evMdTHJEgb05uoHkF/g8/nxsaybR1DJdrym28ZjR1Td1S+g+
FiPGLdNVZUMpsS0AR+FAl9O45zsN0tVyVYfD0VPcBzK4BiIb8BNaWxcLoALOyLn77UEHjVYW83G0
yMk/aibHiEY6M/OhyGJiv8Db+RaxiKSfi/lui7/FPJhVrF6zm9Xs5HErihh+4zG8/tP06avvXr/4
9vmzoC2he7Dyzp/iIT6l47ff4ba7yGWOWjWGi/w2yRgJ0CLvCKkM4/iVHcfbV9+/efo85Fn/jOJN
X+bFNSAmubJS8ML4oFVo9436ZOIrk1vyGm2FeWNiggrS1+LmHMHcI49BUZcbe48cuBfj+uNEUtJz
cyd6UXFPE7J5IGeqv2/Hhwd6gylTspoCgS/ykb+D/yhRgTnnHuy1LWzFMl1slhEZKpyltDOFB6vY
NT/Da+E52S944OoyO0ezhCSabWd+CNldR0331mLfc2txwmfEpCsCop0+KEiBaHD774jD5lBcjlwz
b2Y0uss5YmBvj7oDAoY9BLvRtms7d3pgBA64HRi4Z0jD66RSiXwxvCbfy48mPNzOcXrTcIcMYcr0
4wZgAyQ5qjC+aQUk+TLVuDlGsxLhUECgiE2M0J4O4IDpKCqUKc4zjICGu8VmcJJr/AjNczimGRGP
sQXqxtaR03VMfKKt08gKXDtG/E+W0DUiP24Z7cgtpzClRMJIHCaCGwgaBMPmFrpGAxnT5wJWjA00
4JVrHGhyh4kso0JuGObP9pyitIJoA3NWRMlVkc17zobDmPZuzJqKDD1WSUbmXJxto1gui2sEleVX
SZkleY1xWvWU0RSgPRWlZ0qW18kWyQtlM01rNsjM5jzkV2tRJVWIQBgLgCdAr0BdrDIo+vrV2xfv
0VSGfpuk8ACVknwA9cl1fg5ey2MmX8CMz4u8nkrSb5gqXAFblmU8dox2KG5DBOAjH7x9JRT2HfNH
An7AGW/ylg9ts8GDPOhnTt9F9IByJFoMRyBgxSxoBwgZpU6gr52hinien2cSnSjVgq8K0mOylJiU
rqGALgYvVyukB0mVkh9xVsO6nXEgCUqBC8uSH+GE55wlLBwdRrRhwBpgICwAhug4ALkoO88xEktG
1FxWFdHpsEAn9mCnPXgic0Px/seR/fXu2Ys3p11z9Sp3UsIRbgMVxtDnSBVtml6euTFRseW2A5g5
GmFspZCFv2RronbhERncbqcgCA+Ngnjaob159c3bLr8pTfFxsTlmjh2IEPaotS9Gn9TPKj0kIBUj
oggcTcsm3hswbZ+figoAFQQqD9rM3892x40VVH0QvSxqVG2R2WKKWexwXzfLglNy5E7JOHoxWEXn
hc5KdMemBuGYtYoiynmFQaklGnaxrrNVstSRPWZoez3FxhCrGyqEGWBnY71KDgGaFWFJw1tVcyx0
siTCTXNOWdMX3mR4xgwJ3rhZipaw1NURnpvXJph3Er3dwsFyw/FQ5Hwhld1tBJcA2cX/phTVwp7B
NJHScWd8NKOzYnQoH8Th12VBHZUhrXVwUrX6w7oQzgpqfHcibjy22xoHxzeHg7iXkmKRibPK1CXB
SrHaPBoAO74k77Mo02yJsrkdcxSwgtxT6TDeVGZDuKDjaPjKBP0ae+xXmSKE4ciYknBsNxO9HcZe
cgTMeNQLuXo23Qn7hCsTYfGzbrbOWDa+nnTyHPP3+gvoVHUBf2YY5Cz684ZUwXi6gKRHEy/WZ3OS
YMYUTd4mIUGz2LrQPlIppTQGBmyNMffpULOKjMf3xyJlAfxrau8sJZYFwdvp0OC2kdOHZk+0MygZ
lMKO5+m1QRh3wC1exMupMiviWUE/W96HSBdLvAzcmlGYCDWIdDi6OACZ9wjB1njeFGAk44QuiPXO
oe3mYJkOcWHDmVdCGVf8TCvtNCvuGdONWCoqQDWVNFDhrdia4D3KHHd59qlvpIfuUbpHbxPQ2QT1
NSbAc6Ov+cffTYH9ef703as3fzLZj5uIQcrveYfithVIuolkQnnEbFItW8X4MRBizDmrC+EbY0oc
fQfH5plRYjYbYgN4gtFhMOQZSmqSQNaIFjhB2RxDCtad+cFbi2cuk/SQvE0h9vyYH7HZD8z1IveH
pu8lRrnmVI0lJ7Kg7Lx+Grymidh4J9wSMXS0sLdZjinLWCDEf9jbQgQx1AFx8O0meyKH9R57om/0
jN2d4MC+yuYSy3iNBA7Evlrxpu4ILE7I/sbbOYnx7JTzoLsxVMj1VYXE8PYaLN0rMnID0VnuMUwl
vDUPrzHplinwhYE4jiiAFGLMIrjdFhz1Ce9WCN+tqGF4CSRLPj8h/bwTvUtnF5i8hwinzUhn1GT8
FxUQeOwJA7FK8PpU6g+fjvgEgTZoTaE04FYfhfi+BOeMcrSE5NMH+BA4NoRuGkskwps4+n1xndLd
GzELA1Ss1PUSN19SFejZdpXRgFBZ8CK6gGkyViAgYFMKbNbsoQkVPoouzzsoUbkuOpIV8AdvUwOF
M46STxdinuJrAGJxlcahKF5rE6iEmLT+9ZkI3GZLvPK2A+cP2icbO+wcX2IblpgWATcErAKGMqKK
xxzQiPqAqYs0D4GZAlkWTfJttEiyJRI2mAWrShKFkBO5/Y5JKlqicgUq8iLgDrHZtI/mGNMFThAt
i59RjNREAaLeprUSfVsHhTenEmvM3FCTjkxnUKLwk3hc5cDpN5jNYSkVT8sR23QJevW30cObb+S/
dqt8hR8j5R/2v1wu+2Nub0zwdC/YHCCebzA8P2yyxbor3tnaOeRk+Bgiptd78xKvi38of8j7MecW
H/Y39eLot4BI/CnwoTfDxEooO1DkgViQe1j2/+kk+qH+YXF67058j1NPnUyOT/Hl6b2Tox+u49P7
UP/rV99Nv3/3zW/RS+6Hm3Txw83ZGfx/MRAaEpalmntZjO1cFyRr0m40esl7i/yevLD5GEiRyCx+
bEids94In8RmSU7fc4U8/kQ0rl962+s5B3TELevts7DzPTAjnbflWmChQhTYHgNe8yEQmVxeSByE
a34cR38Eil1QAGn+qqDMU2BISolebGqwmEGKRtRXAmXByrDByJxTH3kKEpSp4ACiT9y3EjPbx9Hb
ZG453rMUyHUGpGJepMxupTfATcxdGcCgCim98LKeQ7iYq0oK1I4qtiKy7gHULHcv0UrsJQwtP3oE
RPRJHS1TjIMBJbdWvhDhAR0Vl9ksq2WGIkbeKh5F7wo3RHyVlnTgwGiY6pkx0dnEQhCcQLNU99yQ
epoYRy1OHbfLdobx6cnsgNIHOp2Jo++BFJf1Jgdc5xl1QnuvWGG9WXMcBY5EiVrqiw0roM2JySoV
zpZxldLdrknsqsDB+DqW1CAAcWh5oZCusvPoCGGMZCB8UdzpFdJ5dG2GpUfTA5R+qk0a3Xn8H/8u
jv6UsO+vkfm82+k7yKDIVVuJAWIbig1o9MiSUhIRhkiYRrrA40CBMde8r+/mYUqGpPLmsirzgSFL
ZPHiZmYz9C7miy6ue/JwguBPRzo0zCH1TKew+uOm+mjSFVNdaGAfTuw5Keb7wcjlZrWqJvn5puLg
93QpxNyVUMudKqRAMA1mCmwPYLbpBNkfFq0r9IQsAIMb9pNqlmX9zoAT36MH4zx9RqV3BJ64E32b
UshkZDUoinaaLA2Pt++OcHyLm8I5u8zqOekZ1bdBcbFvqoS4ITeDqPc4/g1fOdnEJLAr0o8b6Cjs
4c/jR42ccccE9OTIGVV0L89uMGQThZqJzbHiG3VN2qeYTLeJRfrmJQwWDe9eto/EukxTsbuSCFtU
1zn7lGJSH13fpnKtvy7WSK8I+QxVCS6FqztMDJNMDU/C2sLwihmuQe4jhziKAM9M6lpzDGGZMZ/9
JeuP+6hM6R8y1Bd4ZcMXj8vUxOa2Rwc8cM5VEA5A4DiXOWjdm6L0bTXOrEF7IRuVDCUo58sCDzeQ
TXFiaifHa8fsyfhuOX+SnJOV2sKL3VJJ7PNoyJ0qJTBRDnh9D8rfs/yYZ6WpaXL/Osv7jjZXQoRH
53Bg1XgqzZabKsNsyzZ4AEpEkSTVwugUwJBYsZLvRhU8viUl+kgKTrk3N/7xtP+9m6YDhdyAKSl0
/yLlgL8FpeXEoYxNtHe5sM0qe6P7DKfPY2P1QZ5zZi3SUEjmUsKRC04JKtqXucCj1GJCANAywMnI
O2WlMP57XwxIMYamytXgnKGHzIFAHbViffNAh6aATJdh/uVSx1gdUAHC8GOx9byZ6PMSDTV5F25F
JLBX/TAWCbSCPIyLhjFrU96YyF8OiiJGbgif0DwHtjOnYiVbn7in1SY75fFynzzu39qQAmax3qEy
bQufLHf6KX4d6ZMET88uTSKqgXBIws2jxy1Nqy/eIEvbur5HwjNoFu1uNZq0K0rENrOifvi90N3V
neipvR5EOwq0hyhsGqw5WnkaXUTs8HZoh0jx4NAk7dFjrIQ/TyZfnBojNSXVw+dAnmUSwdHPuhHC
CcYXk1MCO3RE8kOmpHsIODP6fN01KS1soMPMaALoQmmxbq+j8Xc9eAE1RDnPPmEJxTQOreI4pg2p
KTilPYYSwIT2B00eGwsoEnibObOhrkRD6bMJq2LeEJI3jYWTnM98wq7IcCGjtPL22PKsyNNyOIrL
TU4QjTrUuI6hbXnTzO8wsUSE35Acl3TI50366lLxBq4PiRCtdxfa9YSVoiRXDinfQNu3HagDmY9l
pejoDQcpOkt2vJo3StQtK8St9dXsIoGlqU1keSGC5tKr6Uzc2QHWC7CqYCOj5IhVcOoCo0QTgfYq
mqkqDP3GtIHGnsT0iTvNiVTRNA6D6ABmymfo1eCH/EdxCfsh/2lAQ2I7Exm2XDaYq97/4+2rl9QP
M89mpalvZCSq3AJpSQ3/4iZyp5TsWEZffrmJ22uTUtdlELxSTV4HG6FyXVoevmYpGPYUPOATol3Y
s4fWxVzZtJcHKUMgJAJGhy0+JoLL8p1hrqpzF6e/YdU8p3+kFW0wVNA3Ogc+LZe5RX0BO4sLVlAC
A8ufVA2K0qEIK/jPAxMwiwB0YxrpuJQ+J11RWC2y1lkw2hiFiJWkuEMcHYw3YuWvNwnqmwrv3bIS
bTAcHLlDa4OxrjgVV2VvMBLi/1kEVIl8UDcjM9BrIhliUDi0/uJ+4YYgrYhs0HF0wbcUrNkxJIMi
UAmQeErBMaZTnAhq04K1MwpQrZYOwBvosYD4vWkDyA+bvJE+6Br+Bzw3u7k1k2vAxjv2AmIKnn3u
J8JuhUW0k5GDOvtzc4hUU9l9jb7e3TLVjp3pQrAKi3Anq19ut5J/Snif5v8M+1R/uitf7t7tjyw9
kU67o3QheiAdGc6cPnQBxvhwvizOkiXdnaopVxlIjLIJPpIRJ9+y9tn/CwuokZpQATzTDnk4K4pl
sR6qHQlEGYZjU/Jo+nIc9Yfk1kYF2KWNHNr4H/oteck1QHIYHPV3rKUq/YvTYAVbLcjg7oCWY3AX
Hsyc4DzpWDXDYo15lCnMcEUx9PDWN01mF9NmTeiEpVJcAvfhX7L1kDS0xN8ClNHIh7PL0GJe5MbU
t1S39D6DGKzkqPkwbULLiqKxyofPRJb1mMPWF3JGHLfL4+hOstNmWrwfqDk9dc36GNa+sKpczF9J
ODI3GP4RJAKU3n40/oXxy6KeRH2EeLfqj+3rF+QmBV/+2Xn9/dvNGbw8cl8+mc/h5X142fup1zvL
8mLdaufrrH5VQqn/rCrCu/fogNb/J/flkxzh/a16+e3bi2yB3fnyS/X2jXn71VfqrfRGvZFOqzff
YbjyqH9PvXqWXcGbB+rNN8uiKOW1fv9dgQ0AIcP4iYanXNiDXnGqtsrzj1Dj+FgBgXmnl7/SL7+l
ITovnuMbXeZ3NGDnBZb5Spd5XVzj6PTwXlTwJnOWuOK1Z4Ry1h7f5m5n6SVHr6VVvtMYtX1x3wse
qXT6UBvILHrsPS1IPqqNnmuqX4oeVr9SfrBEZPS34SwQRVbqU/oxTD5G80fWh0ZOQb9RMntBBgot
zpuUC7NiOS0WCyjR8HpvgWfAUpGpE6EpAa4tqzNnmxJVcsutlZX4hMhu9gE3IbG5AMfFRmXN1BoQ
eQaP9LUrTRNCapo4FFpTgzTF5ocTJ5gyn5LJM8wlhROmN1MEUNEgPcmWBk9lgqPv2TKdE+Se1/O0
y5s5JdwCzJynfwDZu7YHL6zFk7bOmVzNScDlE62RMNGrJYL35XYNBzBJZiiQoYEmybkjybOem72/
oeTFLOvzFiHGntjx+oLTxM7JwDMsX/PV/ZEVwVfm7njNFlB8J7xK52iIw4F9Rb0J+FWz8tuTnIGv
NyY2F3W9njx4sN6eoet2fLYszqt1Ucdn6YPHDx89evDwNw/O0gvo4VE1S4FLPioWRyxGVUfA4h41
shRGWrEnNXLhcCJcZSkp64E/l1EX5aWW12kiI55JY41sppHYdJomXD4cHII0M9Wzin6rhnDnHKcA
u4JnJBN6b2ojyQiN81/JCl4hbpg1RDcx7GUu7yWOIN5uJ5cwydwdud3E+1mQsoHikJBO2wEzdCMy
YTIRvKxQ3SVLDdY5m8EUZXZOenUfByYomhgUqKy5uyhI7AowbhV78aLRdVtURc2uaY1VruzRj8au
ldOIqF64YoNgmn0VvQFJR3TZf4OCkfFmX6DAoqRdQgt/fskXG+te8V5FWz4YDOZV4lcOFmCUESIx
RhfSrHYsDoApUhjCBK5Oq81kw567uQVE08QXDCUvKl3360Hy2Q348WxTcgJq8SVkX3sY0yUykeQ1
CmiCV3xCAyJNZqnKpMGLSfRECAH2ReGL2g0Kb2Rdevrea0XGqgyYPO3O0B7e+DviFeRmSZacZ1uY
dylgUJ6nSF4asCTdn3Geb9UlE6ebFGNogptwHnY8ImCd+O7f9o3NPuZWXWXh+H2dUoL6FPi8p/xA
9JWS3dNG2uTZx01qO4kCfDpvzHqhnwp2FP3BlkOum+GgBQAumh6+slKwFpYUHQU63P+H9VY0PA/7
pr8YCIIN98iRcceCoSrxBo5/Mp9d6AvPZlsxngI8DvDOa2XvuBQwDGzEAW3UxBoLQqNSom3Om5dw
yYlsagag0Hlq/HFLxMAITeXxEmEpWKJLgjCSrJpbE8Kau0dK20rIeVEs5wDMbKSsdLdSz4pahjRU
1jiUb8VRzqRN5xE5M0R7vWHmyiAp+mwYqVuMbtgciSBSclgBYPfe7BIHTQ8GPcNzQxNTWcdWatD0
I15vqot2wzgB4S6J9QO6xVrZs+mmhOS3M4tqaBYXOOescaps5ilP7bmKekNDhlAnRfeqKTnX81Hk
HYREE1M2G8R57MlGInN46ofQYa0CthwsHtdscd3cGhj1p2FtgtcG96D8PcdWkex/te213JbgBcNZ
Md9OWv4lZMVFd+pFHLJvV5YJOXcBTQ+MstxEFRAVbV2sDQKIkTEq5ZNFTee8Y+FVzIyaFvs/nS42
GBlwOjUgm85QrHsKjnKC5xL9HGpNioSwjJsEA0RvzPv+aByy0Glg9TtDc/UZFH6cJmV/dKp0HGg4
M7XD8DUa6wI7/LCd2uWhw/BjChNzAdReH7x4bDWE06UuvzJyICCZF2hB28is0Vc6VWLiZ7ji27oc
BSy/oEm8EbaF4yqYZkjiQT179fLdVAyGSCSC6l22VO8a/EAd8zyr8AyZh2xXdhlXBdNBYYabYwob
Ax0YRUfRo4DtV2vt2p6y5M079G4am8lmt5BvymIljtYwS5zw4KvoYej6N+IyMuxfHaMu1OB8yO7O
IgyDbqeeDAeuQLyD8T/quf40dvdwv4cnhPmnRiI8bguGxw+DvsUkm1DyCZQXeGeeahc5QuMT6MYE
/i/OcdgBfQXPWSZsmKuelpOppwCnAcr0mr61xWpSP87F03DUyiHGRjjEvjpiNb0JStRWU24XXZhf
jFHUEYcEzwQnG6TfjWzciPZN+kcCvCO0idsNkfIb1nxHTdlmZZJXxILxTMc7y8MgYrat5vxELMlR
qztCp3Q7k2u4kiyPge0s3T3mt+/2DNhi0AHNAYKTuozVIpJQOr0ehZ36h21sMF3qpLdNZCJWXInx
l2bY2JabWP9Bbe7TOoG1dos/8joKdxObHHVhrp4vxseGL7HMvRdxzpoacLpRLuRwHXei78kXr7nf
N5YqWW6zXcyBjRG2sJa4KJSL58Ih+xJ/QEkQxoYsp9s1QlVP8vFdwK2oY0YaTPLl5qKGtrJzw5fR
FLoTgLaB9/D9PZwIDA6lJ0B67bQ+9APeNVKWdEv2NrZ7YtWrjJx8ThclWmSdSodGnSrZpo5VyJpx
wWELnPm2c2AU/9C9+ETm19VDOGPVCcMx5HZaDvumal+aaNqXEjqM372kPK8CvUiksI1ZJf7vunHA
CplrO3jNsbmTYFk/2PpS44nRJQwFEl5SIoa1p7A92VOOCQkg+HgY0kA417odsLChYd9lMg6yXkXG
aV+CBd7Dwvec4UqJ4Jgbhndfv9WoNcBxtANv2iJsFwbJgJg8cPyDLvmW9YsAIW78aEn6YjUDmizs
reqbQJvATKqa9R1J4/M4+vABnQofjqoPHyQXnALb4Eg+Z/CUMA0LWNddtwUD3apzslqFUCG/ahKt
ZRMh1WLtGRC9oGCr5kIvvZWiORrt7algWCQ/sY/IrOGIfYTp36XL9KZ9vCWvlPwaEtzbR8ZT1kAx
WrQXx8GA1J9bayKDqlNUKCfOhTlZkDhxIcRExsyJ5OtrdAGylG21SARybnPjTbho9LAMQwze5jb5
33xu9GG2Xkjhg7ZA7PXRoc+QMTaNF9Yx2aguQLbWCg2jk66kE40yJdyDDsTqRo5AzFjS8pgDa0dV
RToCo7W0YzltExBl8xVS36DCLLwFPRyy4I3LNqVqNCJvo0+2GkGJfaCWH3vg6OOM/rNDq2d0j6hp
bEjJ3ASvM5gj/grS+yrJ7OiQKDSKUYe7VO6nhu43YxCtiz9bHUtupu9Yr6krQdk4uqTea4eB7ESY
ppYTn/Yy3VohFGZ/CL9HtJ3hgaI3cJdiLDdUihZBHNKoHovhwKzG6pUcuqYm7wY4tEZOZan1dZa/
YvshQomxuelCJ1HVxijIeHKB25PcZiVvz+Jhm5/G4lGeiGw2ZQlO+A5X0gVk+L31Y7UCiRsqQexf
CFmhMw4fIupIJXCwJGXlDdVvixTCUlNXAjnSx23EahiN2PCtUFCP1bn3kpy39GPayWV59wzuRaK+
6DRj85mT/TeJ6hax2VCfdpvoubN+6o0inWIOYeu+VQweEGrGHFWHK2Dt+Gb2CKu0OB9BTO8CgtHs
MgBJ0cX2x+DtgRJI3dwKxsfpbJPPLnD19HVacwCvpzYk59izMFQ6EkE4uirVTQrH490tNfBRU2Yg
NWNrCFB6bhojqy80JwMSJvZBSLecDh4kXb5YDA3YMbVPwopD9c1oVtW5S/athbbps4hyA9+CezDW
QPwgm46Z5g/5V7IgSFzVxx1h4XQ/zGnS7+9sZk8bMFHoJZg6R4VtZmys3IYjqy93LEFV9IxmcgJM
j2lGnU+r2pvMftv0HGN16GmE7d6W/9wbyg4JML2ZcSUWXA0gwAHoyCnLrfr8D+RZ+Oo4+jyQP30q
nXmDP2ByZiY3Qvcy7qrn10ZMNWjM9Zx9tkyTkhaxwAzD6mYb77JTFjPE8IcAxy0up7nnd/ro0LUd
x3W3XtLJ/u605GqLZzSG40jxB7bk2DPGo7kZBSJzt7Y8QdVT9U124wZ7cG6jqnrVxOlWNhVeU8qo
D2s0u93cIpjfvpmZry1qmvAPdDYsDAdefMacgLDU7OdEkjVN84KD3iZkRLhsBEB1JXOn24R9hCJf
flkJkBlaMJN2s7nIK2aV3kQ0EKPj6VOjeOMIe8nbT3lTM34qNsmGmpD+MJtjNTYIHSIHeII1FIh5
IR4HrqotPJT+2MswQXyKEDg4e+UkeVUiVTvh3o2liVNNMtYGLV8snt+shwhGODXDklE7DWk0gwkq
WDuZPE9NyGggHWVEYBcAxxC1ml4l5Q49K7H7KCR4LCgRR5QdcJUUpVQqwvW6pSG00MZwotAG66Cz
7HbA3rSKReYBxMWaa73S4oLhBZDxPm7tDrtJgUWY6jIBtoFuIRHR8A5UmmR2070NPYhrei3e3mTW
RIH98vkYxemyPppl5WzDtp4LsSFyyUk2jq7cGy+3O63L7iyQPQBHnOU58Y2BGzZyb6JQjGilQcGC
1yXGC1oWxVrsHpEJOEuXxXU4Ln9YSANOCSGPVQ+YVzLea3tgoRO0rdmm1bsnXrBbHDUcZvPKLaVP
xqBsKZukJV6yHOXzTNKlHUyMZoA8ADObWEkU42vA9BMF1iOJe1YA7RmGCHPUCnScRV8KnrcxhvDh
2HFIcS4Xp10xXqRiB6+NX9vn/A7M3M2FM24ptNpXHxoRGuFiVLsY0ofeHqx0ytAKKR44xI/yzu2P
I0UEaXY2K/ayGrlUdwcGOc11KzgcxBUKu+v0WLZOD7OKfHyQO46iOcYi9jiyjjon9AQEGqPoohH8
dNqsq1C/Ke1L86O9Pw0I+r5LDaLxzFQa61ZGYSWJ6ffdaKh7MW4fniTGyNmJPkLaH3K7Oiuw59Z5
6ISeOsa+TBe1qM3Mozdsro0fVa8x3JZUs8/BevTVRSDty3e3iuh/I4o6Y3swlmFo6PtmnCdFjccM
WwEpO2Zei47eXCO9m37+a5ltIlrhELxsPf3BJJT7YOyuTXCnz+Nfs+8B2swFIWCgacwLDScT/BuY
Umw9xm+KmynPqaCnn0FQeGXZfnt53X5Ppj/leSQXlDGWmBxyZEFBl7zZ7hii6K6c7pqV+tLKUeua
pKu2NyYJ60E9ksLMiLQb5tFrii0VbEX4HjpC4YBRJdrHTGvgqjReqx0bDYV3MqPwHN25E92jq3JW
z36Axw8296zVHRIokIhaIceC7aPPmm3SJ+D9u9XQbDqLa+NoAP9j51kLTk0Dzt/MzbA4bFDWLOtY
zfNOXbFAc8o4OH+QutjS8A0afzXD+yH/8S42iU8/0TgN+HHUPPl0paEIDTyfIGBivTKdm3SJ/MsR
Y9F2sPHp+/UY0zJwMTZsI4cA8vlnthYnkCgizkdvD4JLgz6CN8G48Cus472BrH6QoC3T82S2vTVR
a2ja5/EXRM2I+/7wr4uc4XucCLQgNEX8pGa/HMnbSc8OoIn/akneJ5A09K3G/uPst2fUrEtoEE61
Pf3o3+tumUc7Cc9CZ8M+udpPUf9lCOp4nz2mzK+t8f8jCnzHTlKE3U/QwBrNEPNzNsFBStvEReGb
E7LJ4DKRDaiC+RbIL4YsmKRKQxuBVOJys+OIF5iz16E/l1zE0a8VGVUQj11eMhBCoqsw0+le61bU
aq7kYhR+uw7RntEoFohn9U0jc43CeWBwfd1bZoLddJSdC+hPgKRTO62jKcSuN0Mw/gpYlS3ugnq7
n4Wca9J8OFgZM2L6OxlLduBqM2jV226BonXwimpYDl345SdZ3q06ItGGoHdIagjSF9RY1G6uOjx9
KmvzKOytDRZCYChiiBITMbuAyWTcqKCunLUiYFccQ1c1q65zUUnVDcbosPbCyXAx3QgnTad5amMK
nEJPHCYkQR8tl277d9rblfdG4qXgSzP5p74eFOVLNBuZisiO3c5q/wC6kZWjp/bKaQAtXSF2wZo3
CyRP1bZdOQJ/WNQ3Y9SsAOr74F1AX8jbhaXzgHCuhtKu22oioFKUbVV69yYNksMoUKtoRnx60LWY
VpQqbDvJTk/tTi69noT3VWDNPCP4YMg0L5LNggxH8cLpKsmW7n0Tacvk/HcUc34QoP54r3cEjvvd
Zo0W/bDCrmbtFpWbbf7JICRE0SfWthGKgkeAZA23e/3/Y+9Nm9y4sgUxfnMEHDEe22PPjMd2pFBN
ZyYJgFVFLd1wQ3rsUknNaIpkiNQT3xRrQBSQKGYXgISQQC29vF/hfzFf/Nf8D3y2u99EoUipe549
jFZXIvPu99xzz36SL/3E4XzXeJqwJwtS8JvJbVVeUwumrJ18fFeLpibRqIi8f/rXb/7be/fuLW96
w1l13oP/fvrv3/w3//bePeSezkZ1OYb+z88pAI6whiPKVIsJGonWQVVINdmMi9UjNHFEJUxSj9/D
Wei1Wm/evDExOtjQ9cnLp/0km49uMIbhZs1pPtdVUmM/xaq3vPnKEhLAS1iCZ/Qpi7scAs0zgPHj
8F+9/vrFD6/jmzwpzjbnuxTERDaA+waucQDWopwzbTgaswp9NoEBmU3abhGpHCkVnxKNXp4pFw/6
pQx6vV4TqO48DW8euJ8q69UNos1ahWD5ji2GMo7Hl1vBeYaYEnw4FCpBMYKdxPOkIDjTIqKBLugW
EN4Y/xhqhEByERhyK5vwpM0cC1wkGACoY1qyrfMw70Z53dTGyf36NKFbo92X5pwB2y0NgWdZyYTD
pvg8cWcYxY1+qxnkOqTNSzkO7oLC+icZkPOrghJ05QgA+uTgoRCeoC4wzImKmSqxPuloODbboyRV
py2VSIoqDQlFq1muSjI7FHuUej0BHqZjUT+TYrXqcKDxDqUYwntkwnlPOP4R2rW8vHl50z3oHfRc
f3IBGdhO9cRZUclNHpObYNhFMuws/2SMoNSKH2o8QYbft8ObPM3xYl0N2HTnwYOLK5fNUMGpTL0U
yO9ynXrshQWpa0L06kWPime+ee1wG2gbWSyPLp4a1S0yUHlxhs77eK+6jlvWWjSJmNkA/r8VVKGg
EkioL/E0uIdBz9E5DOfsv6h3xDOSgbmnw5QCU8GHiN1VohkrshfzHOI08AvJoclEb0gYYpGMOpyN
Yc9K28FLtRdwQeqDPTWia9S8Iq5hEkpfx6FIJKS+lSEvUWCcwe1vCxvxotSTcrYNo3ebWt7CW8tK
LTQnfoSvXFuhbrcpQdC5Qkh/4Pff0RAa0HsTOm86qxjYFSnebagyaAOQ5fJGuEiJ3GYakczHtw6k
R+ZmvjVvWGyznFDT1KgzcGcHDJ7xAEBpivU2J5QHR6z8OBywrmvZNHMMy5JxNwUN40AVGFhqU5Kd
l2kSUOzVaHZB6TMocwQRWrZ3iDKkPhuNLyR7b8mm4Ga7OdfDql5HxjqKISKOOILzA5SfTeEsUJYn
NIhGm3LGGIKk8qhAPcKr63XsJPudpHsQhEePJKLZCi4n6s1JH3imViSxDkB2QzodvJbLxabYETAB
KrJUJpx2NH5W3y34qRvhp6NX34OkuljbYMRJwynci9nEXuJ6Ni8oOjnmQUDEg9eUc+dY4jTTfe0I
3qJXHdz3GGOPr9Dg3rN5kfiFqnHMlktVNzsMbktq1hMHWmCMQ8xj9whG2+crpI2OPPdXCjkan7UV
VydCTzeZexnUZQcszLo1QHBkPy2RploeVQqWhy6NNOIF708jSrG379s+ZLxHaiw4QSTWuhgDniap
u/XtowzC/qa0J3ELwtSnjdOX80uOsOkfhwwtxQ1Za2f6M4thKFD7DmVCNMk4sldKhVJzfaIwm2lT
k1KSenvIOdNaUcoJBuzccVmuI4PqITee0miLvVuq6vbl/rJursb27KIt5w5141nHGzCFW629FoY3
4aHU8EvuedrugOlAdlPDxNUKWuMkfghNGYFTrkKxOwFPXWLcvuPFz0HB/9QAvkFgoevWlLkNCmRj
Hx+sjmlnUp/spsxAg2TaSLYZKLyFaMMlCFyNqH0PylCV6OTms/PY6Uow4OlsU7/3D7rVLH3PNAX2
crR+f8vOkFM3rgP7aynXL+T0sPbWvZGs7p2EJY8DijMUkQpMitnoppgM2b1UiiVnm+m0QCTKL3wC
bMiNIutOD5FVVHEocDflp7+ZuhMUDqtnX0nkji+2uLhABLg2n6JferTonCP3OLOghBqjFIEwvUoN
OaNyH7mTolhpxd8OML2bhVtrU4ft/Jb1+CDgpmSS7gbdDtM4Y5Y8eReBC8wGhAWrI+L3ED28akb0
2Mnx99/frRPMEr3zbcKn89UNyh5v74ECYlLZZDIq5tXCDbDnnUoyEEdJ6cBPkIlR/9XHqLjAqkrr
/+zFt8Onz7954WnoTCn1+PNDJJBFsII9nrb8yZzuie6kVYUFRdp2iF+QNWgff3f8/bfJk2fH379O
jr5/+jqB3Ux+fPL986fPv02ev3j99Og4wXklXx//7odv24oOlUji1MwgaePs0diBXkRyIIsogHex
w8U6icguMmcC8jV3Epu5QgrbdLeuWz/9D2/+9b1791TsPrXHP/2Pb/4dvN5rDYdK945OZulh79e9
/bT1079xavGfYvXT//TmP/9fJFpPMh2ODlhAxWkBg7hUSW7Ik4azlpNPDSIulRputjnHSISJJdM9
H6snlOzKI2WkQq5Ovaj0J/S3Hutfq0JXKef6WeU05LQ80wXxlDoPD//UvW7OJGdfy4iZzROOm5sx
dLZqiWjAoZf8h+J3S4FX7EDcSY7fPH09fPEHifuu4u9MJhUlgMg426iAz15yvqo2S9Ki42skoOhN
1lbbgdJ59ZwQUHcpYjaQKNRgLbhSGjAdpd3urK6mqXPFjkg5Mmizqm+92qBz1ATaG7SxcFtzlZHr
GbVtg6y92iySb77mRMiU/xgrUkpFpbFrK2l1bExQnadjONhBu1zIvujR6GKuLm/8viqhHAzDrtI2
Gwu/8qZRC2RCYYwzyrm4cSklgu9okaS61TRph6RJGy9k01eaZBLAqzunQK65GMu0ddh/2X5A1tPy
fLMiRgee9PaTE/0cra2Rm5JgR3NYk3KJ2bkAzuEEvVhgPq3RRWFkKCzqZh83BY7D6WY2wxyrIfqJ
lhDMggYFHlLxiyPdUffwqTc6q/FvplEN3rrDYW+FLC6AbTVuW6xepCH/lU7w0v4VnDq663BHAR0p
dRQzxbBqeDrIpCRjYLUuC4JG4rGewZdvJs+K0cURv3MDeUjBnhI9DRX+yHI/8R91yWhsPlqMUO23
Ks4x/Q2w09yM0aeE3QaaKkyKiKQQLVnt04FIdygyECM8D3GK1thNTV2MjheVG0Lt5WadwZ9AsGwq
Whev6cEbxrKc8G6rnKSBnPqmJ+DfG88n2A7vRtL9ZrrYT7rL5P4EWX+obJO/4Vj5zscRm96xaFkT
jYsOtHGTK0qFZWWwTacpx0bO2kCbF+sC+udsIezfGwtLmM6LeeqXStrr63VQN0nHVxOnrKUmdXbl
5LTliB45v9gC5yhUA1F0oa9f44w5pQDG55TUG9JO+nY/Dd2kprh1XPxk//TkoH8aaUwzQlLwIF4Q
5ftS1lnrR2lD+ESzEsq0JJtODNuXW4u2BTDDY+nBZyCgbYbHy3aQqDMLS/cI93Ui6c9zP0K01IBB
3oisLKyExgYqgTIQOetiXnutkHcCOUergNiUoLxYnM/K+r3fJ+bUqPuPHp2V67MN4JV1r1qdP2Ic
2p0Ul/D4qKzrTVE/+vzz2Glxw/nGzDeoGEVspg8SMrD3vqou0CoiwwcSyRSrARbDXME3dAvRT6Mp
Ecy+wtgm8Bej9copx0drOSlH3oHCYx5eNJt2gxAalXJgwCOgipY3Q9uo1D9a52N0u8f4urZRIPZ9
2Ni3a4w/YWS7zk7WGPGBKF6FBerDU/QibvpqZ9CawbVQTAyeWPstkd0TtoFqSu741DXiMQ24c+SA
N4HXJadmMXbY8A8t04Buw6aQlZoAohwTrrxPNkJ2F751GzUmAXFPSIDCJodTmoFV8TTfPorkdwXU
K/rtO3XgL2e86SfoJvYBLR9ua5l+wMbc1rn2SLlf9+F/uNa4sBywWiJE5B7eolOGLqh0LUgOPkI8
mJKb83GzsKuFOa/QSmlcLUuJzEZpIBYFmsohqSIsHAAkup8rk4x5sUKTjCsga2/srGgp062HvS/S
frJKj/pv2Wz78Iu3/AWWrBDOQZf93Cv7eWPZx70Dt+zjgy1lD72yh1vKPvbKPt5S9lOv7Kdbyn7m
lf3MLfvXlpKFc/INUryw7G08Alpw8Oe/Cu5x7ieVFg+LnGDx09ZWvaBpnBMkEn1MVwWKBlBN61kn
lFOrTqj/oYt+kLT/SHNpR6J7B3yxX2KJ2BGRoC7Se0nUCh0m0znAbLvbFWzcPo1be20WJZbAsByS
KFUuFJZ/DexOnr48DikcNA/C04fLg6MgSzZodcw6hwgRg2QbVsBsl4e9zzR1B+/idIyzB1HPQYz0
D031Dtt3a0huc7zMN+d1jzeFrnO6wA+++M2+FS1VgwyFIlVN+aBlfWmpi3taXqOrR0b2lfXgxDrA
Hfvkd+xjxVIGPjdbzGdTvHS55vLmcXrKOqLR4oYrZxjXsdDB4YXSlJc9GlArWJvwVOkkrVa5QAYp
XiWKUCRAB0T3+NCDc6cvhQlJl84H2LWgvOVUbT+l9nmIgY353CMGMmugpcPN9W6N+gJ57UVljDXg
wplWmwVd544hUgRQ9jiA7GiNd3e9RuGeEJTXk1KL7nx44nyr/M7bZ5QV6lDHEqiazfwqlNdjCKJz
FIxUFyuglFdw1omo5AGyyERlCaNWsMLvocD3UtrE9uRS2EWtUpTNUTCibcqh6hmy0iJKwW7qnpdq
nAb6kibyZHWu56L1YOpLo5GpO3st65bXBuIdgx5n+twOLYJpxC4BjdgrQOsFHP88j3aJIrYpRtQt
/yRlVTuwewtgK4b8GzirgKG3S7f0PTdcbs5m5ZhNurOZ2WgSRllRjGqmRji8DDK9xODgFowQvMgt
DOASoAC6MAHLpYWTa6LGrokawyNyjVQwpQRpnxpjVRQeTNC/q3FL+CyLW6KvHKRwpsOhsrbynRe5
kCArN/R9k+HixNgDStuW1ZhoMZPJSUqtpqehwaOZUnJ/lT14cH+Vo8VjZsbSSSZGvGTDgt4KfkE5
kQjOFdBz6B86xImSXFnpnJCXq3WSSKxJFWsVCNqtidAuoMOoG8MfjTk9G9LyaLi4HJ2PVGQ5MQri
JmMpnnwNlC1gC3bO+Yro1v7tluU5uFIYCjpPw6RDIetKj8ja1hGIcdtTRL7ZLrshqZy7HVK8ChTF
AXGietuxY9LmeEsAh6caapMIbwnw4A+xWVKkzasFZtaCchnPusODsQRxPjqI2lW6fWaeYSKui3Xq
aldpaMfBZb+Y0OJLObTRX6VQ88/ICQEZ5b7EBxWLT0BVvJeHKqAgNXXq5KzAuHuSSUSNF1OEls6I
h0Otf3pfTgpSkLn5uJ1EVdIASePgGlTtmdhl0A4HvkMEAeQJmidPV+izd5D3pkP+5uXzkVbCNeqw
uBopQC5Cgan3w9w+JUZQUstkYoyZBTsp+6fx7D7WMg4GERtpS927WA+z9vMn3x1/9+T10e/bCum6
LtE+yXMJZBHNomMtTke6FeS5JZuN6vbo98dHfzj+XvWMWJmbJcbjy/a2YWxPzKMn9mJ7H1u7iFpz
OkuBqajQzvZhJAsXQU6Qv8odXLjubbxoo6OKT9iROIzJgg+ZIbL+vb8SULu/MhQkv8rd8PVjFekx
sLS/9Sip9E9b4DQUju8Cn3jZ2rB+2mTC68QLIQYULwx/McZ8K2NMsr5FT5+6NbVUqZ2IxydyxNe5
IWjMkCz5UVzuQy3mIaKNr/TMEl8yOnbFAmLXRmK9HJftoKO2NIwdMEOHPVFHut5zSsGPJ4Hyltmj
k3c8wBhEE0YetD2h8Kw655pGNUoSWn7ZDo30T657UsFdV2fqdX7q6RC4jhI/YxngPteDtsXbftAA
O5RzY+AZyzim+FhLmrh6X9UYSJ7zbIglAepBaYwAfbYVyyyMMQXN2BNWa84j9y/fRvt1EYNIshAK
s96jH0hn4yK29WskQIpJU7LCGqa4fLQuRqtJdbUgagVpEhlW0gWIQ3lkeb5AwnCNk2/tjClvMXRx
SCRvdnpmyp4GRoT2nvA6FQYf54q/dzDCtwNCKMChxIb6BznaL3sY26ecKNVevx/NXWii3CwDo7ZZ
zIz8H1HDLXbkHmKyDqPxnbi/6sdsFRy7hUXlHGRk/WHbPyHkpqfVCR2HZzGPYX+UQd9tkkQkh7ho
c4IEfSJqd9yEN60RJLN8C34SzCPxG7egHjna6Z2OdhrBPXj+bjuHOS4WgsOUkg2EYy0m0g+KJ7a5
ItlzS+NDNI0j/Sk8RtAon2IvWMNFCYDoveTh7Yx3nLVux0aYNC15RO29Dd+UU/cst/HsttVZHii8
1UCqUqPRg6f9O7BzWZKwEflwewu8fvFQvQ31lRkFjbGjuupIFdvpGJawaYMVfOIZDSgOBzLygCeS
T4r9pnEM9vVI8JHHMth3ehzN1JjxWY8bf2gwivTvEyUKNjkos2k2KKgB1pSUV0FR1b8pyW+s48L+
eDFml2nG/qmIDqJiTyTPMIiCJ/eUbXgGXzEcR+ZZfSE1hWGshljgO7rxV80tSIGGEeCLSamrd5L1
fAm/h9PRGDj+G7e517cUhj5WxfVQNonklRT0BW2029nbycM8yU7eXnVPH+btXCRQ328W31OsCS1+
ek1B5/EV+ojBiV+wz4a49IvsR9/nwN9ylnQYJGe5l9FyRmX+BkMiUrifPBMHQqbSx6MlLoWoPsUm
W1LPr1bbqtS6ClpYqzztWL+f9Jc3fZpd/521A+84CQr5olMa+XfvpEMk8PN376zkaihHkYxZymsI
iWbMjAerUKGs1E5kplsSw9QhDZXaZDG4GSCMdnXbCM2MJhsO7t1PvpYnRgcY2MuWwjUKtNdkikXD
IQ2bPKl2Q1E3i7nXXnRlaQJNyOTRy60mLaNIQx798M0TtoSzz4xqK8jrMmFdoF1WNeuVVRNBv3Z5
tNhalO414VpHuYHyCuSPVje4BaoKefd1vwR+loEN27M9Rzg30mqOEvqEzd/YbF8nTRK1p/ICn/R8
N1ZlS7YqUIMq0TT1eoeXayp7nyo7h35MmUqjp43U2AAVBhPkPNnSLXIxq3rxy3fiJsoLEoBs5igB
WItd3JaGqLETKHoq6QOgar5NXTYJpH/Olu5+1+GOy82id0nldZuYZZOIpGTPxQk4sNC6tMKJS2qR
JNuH8z1Ck+M1gNAE84pV4/FmlSuZO2V2FMggEBoJwb5xE8zqS9YF2S237IRUnW1+ARTU/raLVgrL
m2hpc9dKYX7BZbW+Qm4gc1fojDQ0LfhU0FUkq4cJsMi5Az4+YlNtSiEF60WztbQX8D8d1QdX7t07
vtwAhcp9mcBto1KOoSaRNwHOq6VurEWTiOkGeQjakcHpOEl+WMyUXQQiY6zefzd+jz3qVJwoL9Lt
lvADbw0sjQRsXw0QVpCaURkHr6oV+tSbxWi8MbkBvjStG8HRPb8LEiDqLEBqC/2O+uKj0U+eaH99
eYWbgZOgtTHzJqhjy+h3tl2tKaHt9t9R+tByXVJIybVsHRo6zpfrG+4PJqlaUP06mUSVuw+UlfS0
65slzQ8Nq9jxEBNK6utYRx7gkJQKRhwV86YuJORMjenupmiASf3ocAaIpzh33C4KrO0U2RblsJGr
oGnXqphXlwVcTstZOZZMrgSY1KrSyRs9Q13AF3SZd3rtFYsajgBufdYWmrEdJHJUWmMl7usNScA6
HDZFTjjY399F0CRjHajh9eYXSIZSr5wvsgwC55HQByCZbeqOj988ffV6RyGNKzKnVdYj4AfPF01g
LMyYR0kg6ptafBQyUu6QdQm8yCW5Jv4GSBoN6WUeaYGTckt6TzQMpSr00qdHCINkmEFlNLsaQQV6
sYNyn76on1a6NQbxgVvT+E2IA07bcsBxnSxVA8BaG9eamJulrj/0+tTvdX03pILVg+Wv82Fd2J5c
OwcZkkspub+i4EKZBTEdV0VKixtL3Axc5CLZLJXnDTm7JxgRBc+fHWDlFTJW6k4AECinnKVLKlIG
zCUe1JVqhGKwlHUrCM8ypk4Jg26WiFUBvVUFR4cQrBFF99Yt+766QroRMV65Vjh2VlUXbAZESmJD
jMIyW8mja9EZF5OmnJhyToCHppBt5pAwVx2csCbHdQzdUc0mMOy40zp/U0fHo+/J82OIYQiLyVDO
nK25jhcIt/hrKpdIASYAKcnAWVEsEq6OLATzusSnezlRKb4Yx5Swtxl3knwTuWmJslxHE5JKEU6w
ynoDO6OUzxyYrHouyukB2MH9VqAyPoalAg+HEh2t8Wb9U7UsejR6AOyCru6LoiALBAwAyDDrVc6I
FjoDOL9CJylUKMwoQTT7K0atU1ED4fbVblDvmWmJJa2l77koyAZi6JlXNZmW+BnYLZLKtrN5J0Fw
XlIz34nBRST1r+0N7/TZSdorCqZnoVrfoQw/05UsD47VlzuDHW4HbuZ2oy8uZ4nH6ExFEN6E4146
CCYgJG3ifELxajbrag5EzJiIv82SxBGUsbEk0qYBk8ABV/iC0XJw1qOxB3bBGiiRmFkc4hChRsdj
wPjTa45IFrHMYWJTTD4kOwC9y7x0sUEg/brarMZiJqoC9wzXFQU4JV8w1v4GEI+hJMMqKmQa0FJN
7bn0EaAVFfXChphmsk/PFs4jpZEGBjlTzXRkOq6KJpYngkuTXI+jO0OLnqGTt8+0DKTE7sGJzGA+
A/gvb1xM9LfqvaIXWSSNA6GFG7UyKNFaQA2MHtLerKfdX7fjtjD2qpb1GZIaWd1gnFLHd9XuSz3k
jRHFIvMbbtinjFMCi3nAiZkMiWUckRDXo4yjQdDnLfDndheEZ8J4obhJ3Dh79+Y9mlKRqVUErM/x
OtyrwFSXJ+UenMeKLyXuhZRFZc9ZOw+1Ret4HAoDh8sQy63da8I/8A/4xGOYzjC6onNHUDgVLawh
OrJnZwkSkbZEJhW+kypJsKwNRrEpF+PZZqIsJSfVumdP5bh33mPPZ6tpQirJk9mMnli8AMTbmgYH
1FstwcU4Ig9CSzFhh/aWm+mCjVaSxBLbq8Zw/deoQq/VhqlQIi3Pd1TqE1YRMQNNUrXkiGbWNpcr
ISGJsRVExOuAGddZcBNZDLXUevPS3voaQwekOJ0D9XCY5m2zZJLSJDlGU1UrmODaGjmHluqIBR5+
YXQlUiITN3/bGlkrsNvY4VpOO6IeGqQn/HD6dsEREupBd1W/XThzsa9HW1ds7q/w5nJhXnmHqfiV
jMMdSP9RwqzQxNiPTHYV2OGUa6T2zHtNw8IOlzdTCelG/Q6kR3dUsBI7DGhdXeOafcxonJWH9sLh
AHcMX8fT8y0DEgUAmUdLFAlW6LO0lqBdxso8NwOFE6RGXXl6+jKQ0MEeh8Oc+9NFeURP2TI/EZuA
1KN9Zb2tKLFNGO0VJqsdb9iUyqxOLhnTEtx4jcF6t4Ne2iNnoC3AB4f1ZxsctHXH0TGqaBieMKNC
6CgNwfp9xLbr5YrFiSOLpZZgTlhDBzIhrBnIfSNEMtpXB2Syy4XHuT0kUlBGFY/IxNIri64KeHSL
rkNxnEiyzJZdKDYgsDn0L8Ss3pzlhhFo2g6h74wg0OltebNzfxJpZTkao/uyv6YcjA2l/WZc1Vrp
F7TU+d07JbwFyH1nsrDxRV0xt09c97g6BxaKL9hRc+fxA25N1hA5LJnN2tYI2uHh56YlmBA0KE82
skKzM50TB3EDgXgjvjLGR5xMT19+1jT65JonzTlaZxXqSPDRkcj+la4Bg907REKzriD+CZbE1qcT
8cnbzmPnMj7TKOPFxJLJkzuoRLxpu+EWvSVXoXp8bj/t93U0EDxDTtKwZeAS6HyWVSRnLiXJ5N4o
xkYmPwbyN0wJRa97y2KFLo/K9Ip9cZeYyvq8WBC3JY7jdi6O5r5ZWuB3jiRySeE8N/VAglrFcjc5
FylO3IJPwi8fA5gKYWIEUAuA5BS8I1UfKnRaW+FPgMyGrEx/meRK6acbYSjX0BMCHs7rZ4M8IRhs
xa6JF0UreAcgvbbAZEoXXO+MrC9nHLbJae6XAsfrvz8kcucaTc7opwuK32LWNrpg0BWOlb4o6BH9
uweePlDCFbFZ1SS/FfmYD89sU638WUXBarCJ+N9ZHYuzUsEq6XJxK6ZS84LF7dXWRSFbhCxeYNop
dUjsLNX7kQRayrtB7bFeUakUzQsN9cwerDYLKwJMlKjeMCJoa2u5dvIUI2bYS81R0YhVpJVS5yqj
JSdjA9brKlevkPVkNUyezDe1NgyAHXn3jmxbN5hD3jLBUilOiG0PUrInXF71CZTFarNw7HjWFSyR
ip8O47a8t3E9OozLCmQREX3gtM01y633xHxWtfauARLEkZsAVsZlPDhY7O70bbmN8NZ4HMiemYha
2WIFjBequHR0OurtaiQyArWcZABDQzCKDGiHmtF75skh1XuzyDyHQVjV3qkA8Pg9QaUBv3KBggFU
JfIsHTgEHmQ8n2CBkA9BqBTrG6WGWWj7LI4U+O6dFQASQSdADtCGhGRtc49txhMjS4pORCchCRij
rh+0jdKUct2R2bLaqUljYXZbLflUzBHlVAc3GY+OhVciLRzLZaxhgZchQi6aJYTLcEG840rbf0oA
tdX5Zq4ESgCtdis8o36z/sW/RINJNPLXiif2AHympPj27icPk5PlaZR7MUCUPZiFwOVdMw/iwOTu
6Ena7cpNgeah6SlucbnoqsAnZnJIKtHVQTkD1BpIXfQnoksDV3rkkD9blzICqYwxDS6yRvvOyOxg
+xCq8dqybjFtLgVM+aQI7RnZjIpQXoREM8uL1kK/FyX12jMNJrshvQiOntS6cq3VuNMquIyrTolj
7Xxbb1gXd6ytNjrQD51ck1rImOOjKk77qSl/CSyiN7GdB4BHrZHXfQyZ7SJJCYHOhTEXl9gr9HeB
jp50pi0k4VYN793bkQRfyZjypia3I8spf81Giyo9qZLZ6ct7oWwiSCxzdqO9lOxcZNVm/UhMjqmB
qNFbjEcV7NiMF9E402OC4wse4URIQ9zX6UQIRPPkmDCxRHJQK1T7Ev0YkMhiGq1FDGM/+cgjZtGk
TGgc8YHoB1q8IIDutZJ6xBKYwHkTnxt9E3iWAbGwrnYAB2MjJopetp7lt23KC2ENXgW5lk6PVLRB
X0NqLzPdP3RolYVCPZC/O9q0eE56MDd28vXpeG1aMKa4AduSePIucJVbfC7FxMB4ANjk481ShJlX
iMPZVRAg86warSZsDbPaLK0TmMApm00ci6M9OIfjERqfluhMCjc4QuHKVhrphhD1WJSKl62BhjhI
DnX6HHtLF9VQBjgcr1ezsa8SVuFEZLoBGlezGurBhDpLbmMkLuX1SffgFPiqMcaq7JEl64BywlA7
T1UzTXl5goLZrVYdEZO8Xe4P5e4QOveI7sO+SpgB4KukLuflbLSyqFAx6kEkd4WyVdeML8u1nXbP
F3Pbe+WI6qM5JlxhvmXwWl0hO1HOix7+n/VF3INYXldWvVfryRG/sgoFVq4N+cGWccrBX+WY6esr
ChJ7fA333qhOIrrt7UfT4JiCUo7acharl2P6gw5CodGuCtrQ42ATUCMSSm/XUTy2ZOoLxARuYSuA
n2wAIBI0W/Pzc3uJN5zA1tGsGfDkhBjGs6t91jKDtJpj23lhmmmczovGmhZ8dQHiHDmZb+K1VW5l
TsZOx9TEtGegYy91PIjaPLYjpvCUfmyhPdMUHWIFsiZk6tgHWxIslwDT69okmJA0uhLNnBQfQ7IJ
R7t09yg4ujvf8Dc8QVYIc69ZXjFvmWQgJ35oDnzvysX068CVius6UbC7XdVtLBz2Hh2kJGuTNQSW
QgFmva6VwztNKg8PmWvQHt7ShBFV2FkzhoGEH7H0bfAfyXtTM063Oz1G9rRQxZpGqKDAyYtsiaq3
cMAKfliJxwyBJ2BncoCTVQp0KiK5DpQBi8vqgklZ3dxZVa1hlyREFskvYDNd1ZWdl3jcYP1pagBe
csw+HW8XDhBjbAGGIk3gIPccUc30An3E2PNbFGvWtJ9OLZ2yUIrvyDCbTJKBtNuIne374sbKzee5
jCiLZmaTlFmLymhQTIwjm2vw+sEnvOVFmW3YD63+8FZkCNgSFlQBGCMC24/DllteEeuWAomHN/6V
41tJU51Uan4AQ+9Hs2mXgpkk3mD2VJY5Nsff1NgyRZjEGSJziinuEmDMtPqIAuAVK6B5EYEsbqy2
0K47ySjI+xWScHzlMYziJgHFyrswIrfBDiGi4nqEueh3sfZVKyXrb40qOLkyz9jZRZLnbsfXmnyz
qky0JEr/0XjUouBvhVpyFH+2UrlD2r/RrK6E0La5W59vpFN5VwVc5gl61HpPKosh/YU3SsvqaYe0
/BplA2hhMLCUJ42aVq1jErUE/dZWwN6WqVRiRiBMcmsxgXCE1gog0tpaIi2RE3KDuQgEesZAtvTJ
GZxzHXNNWkrUOSg5E+Wj2CrEFpm92K0GRdW69QM7RmdRaAw6U719c6KCijVJZ4VOT9wAWEowaCtd
6kAoTb52opKL6ONK9nbsqRBoegZNVsXOWorRwn6HErdSNxROiCL0YJRPWq7+28X9+i0LsxUJEKF2
VddGjcJq1QBaaxdc4yjF1boaubaWDQR6h785fLpjtPHALopaaA9VgWb/uQN412T7JwVFq3DCDZy6
62s14qIExhyIsQYZcC88tHIdJMx0cYPyRvKU1wiU795x06F+S/bAFOA9oMVnFZlB2UYdY9RTfLuy
/NUl5dz9cfVe9kmMjfdWhdUtyi5ZCiTduPUmCylf47WLMDdqlBJ2oHatn/z4vuDsMBXfcSoXomfD
Rotud+Z568xuXKNFvoKQkiG1ynaTtguUnvx5u/NI3/fHENhWPgN/bcXsEy0lHTJ3jlBTr0Eo57Gq
qVVAR4m9tu9eq670W41rUBWsN9UWHJm0rMrmTlnbuUY0KhY2lLCjNxEADc9uaJVUgks6zzFTxy1m
UdrBz8OLVsHgeCJZWRejFUY42HbCbSsXd+o6TBs5rRJnFr97eU6oEoj3s8VC0EZmkaMQv6ZpdKhu
ohVrgFvP0IXH2BvOi3mlMwKFkUa5Qm97rFFNplFhJzRqobRzwA8KuyJRhFhSxXIMd+OfEjsbpNcI
7FuJwPVLIWdCLpmbldhLuqElIp7A4gbx8p9e//7F85dPXv/e6umfqg0yM2ejMxTgj6AdiQLhaLqY
SC9GTURPsbjkDHLwUK6qhR8ZHV6fpKb/9NRkF6yLJfs7wQHHGNqcXf7ERQPrVcbp6cZXkyxHMd3i
ksTEdqOdJE3zU0uAcXF1kkJB6g3+Bhevn95EbeH2wIpaMThwd3rgbLgj31OslnQQsz1RAjq2XVZ3
i20ZQMVcm5QANurRpTq/ElTJFmGo6FGOtQFzancR9PnSu0zPy5LUbZ21vIkJ6eSTpW47iLkNtnl6
to/tYVM5mLNdTqIri3qj3wawSVIurUYalhbVBpauOXevZe6bWxWmB3QBYQ7bHmMHLH6A0aSv2p5P
4q+tYU0PY/UOb60XKCeatR80H5Xah25GB+oVVE8PNERPDzsRpUBVF5isbJA5qVg+0alYPKmjaEMJ
w12NnKjvUXXB9KBHfXgjnx4Gr7es9eoD13p1p7XmqGUw4BWgxixnxYGEd/OTh2HBw60FP3I1+DxO
NvOlRJhj3KS1KltKEtoy2pWAzrF1Khw0jhQlnVAJYhCA1TzjAYkuN11uy+xo+7hyhL9ISHPt1iqn
Ewty1snBdBnkf5R8jccLna8xyGm+WEvYXZQmspAcbsH7tdZKAx2ioIKiiEyXHduFBgP+s/AJT5Lv
Uk+SyvFogTw4Ntamg2OS83TqMRDN67wdUYdTRCDOLElInUrihU62pCPFQmFr/qb5vQRZeDvoyruo
fhr5uihM6iSWkzyyyH0lrLcMSK4jp0NUbVqxMO5y7dx269Dl4s1OhhqZy3CsTcLpjg2nozI6j5O2
lGl3blOC3WVs7e64bbqP6erNTb6rsZdinslXyVRnAoKJ9xgZgQyssndxAm5F1A1kvk58BZXUbfBu
cyC27hLYUcfKibWKPehqMmGr5NmNZelqVFjvTDC1JVEqN56hLJtRKDq2tDw+SOHJMd6KiUXpAqhN
y2ul1zAJxbtt9vQqgDGuLKaHxdqzcrw2mhDJZcOt69T2KqEjYijL2nnrcD+a0go8i9i6SU18iC5n
POWBPVf30sYYLgOmqldVhd7JA4tMyn3tjq3oHNyvU0zr3EnQYJYUgRpFNehP91QsSjSgXEzhCGCQ
DuU3dZ17JUMN6J6rAt0LbJH2vMGabga9tBMM1AoAdu0FTVaf3Aw215y9xsnFqoLmBZpZHsMy1WZd
mDfUH4KjN3OviqCsj0oe+B6sy9HVYugYDHAsAHSYwVCUQ7yOkY472O/tN6MNPsNLruNznghltXCY
zA2S0JRS1mu8A7Bek15s6QjpIhFj9OGpPS8P6V4MwrTqqFG2ruDSo/TZ97ItrdkhzpjRBso0kaAa
GGQF1qsT3wyLcgWqGOsBDeAcB8n6kXHLHT0itQtx6S5tGhLawSa5P/19NqKFHXfX8JHN+7t12aNY
SIprk0bW7VYrzkiolh2uuce9fTfAnJO8OQ2SN0sO9/TzTwlDKF4CsBzKoQpfXuMkQsTGup9/mpyV
HIyp3iw5ZJY7giBdJDA7QFG1oy1fc4YWNWEdcQ1FKxjZqiQpCVwC3MhXnzT3ZZuOtKerojirJ+38
43rVzRhNaXVO8vco54sQ1CMmmbkcN8QKb/5Ag4gFo9LqQP7uouyUosyUeJ30BGYpqakNxIEaFEvr
bIQTSrA+ITOwLRyDSiy/Wfe4hg5U08AIWInboy21nz5/ffz98yfPcBO6yAJ2uWGm5dAlaUymF3zi
SY1GOCGel4AMDesRhmRbUlTrvGNS/Kko8g0pDv14otxjWWkDxtfF9frpCzvknZcDLeTADrcEPZbE
5OT4pdVdGTvNoIW5Tszdiy2c9ndkDQnH/CalYxyv3Jo76nKkFWlq5ij0IweRLI8vTU/tj50yzS1R
F8WF/VVnpr/EnMvG9s8HTzviONfJvZjussDO9koNHRX5m1lxXSJ7pKXtKOSGFfMCHlNkFqDiS4zk
J6aYEi05mcF1xfGjxUsar2eJJC2uGHIP1LpV2lKOWo9qM7rhzY7xZqksntBcuUIj0XKmJMoqmFAn
KXtFDyMw45BtOYbWGG4LnJv4ocsle8RC8ustbMvIeh0LT2epTYC3ARojAWL7vGTvRxhThDEzQbVM
dx77vvWcuAQif47lOJTzE0QrU3CxvT23UlPT/KCDc7nh9FX6HCpjRTe1oXS4Ario5ltwwhFlheNN
ISNGFQSLQcyjJhSXyUDrARSn7sVQmgC7FP5c2mpZMrQlypPYkCphl6SE4zgRP4leOoKNKJIqhW+a
jEerSd1AJuq10kSeezwbhU2HoTDKTrESFUeVPFekLa7RFlfWGtkICtu2PbMi5wSb9BOVe5Dq5Dtm
C4zn/AtTStEA769cKxBeeLy5OOq/bW8gkMJZTRlQpgtvOq5Vh8L2GAfVVSGqFVYh7z3wsQqFO202
uknjV3Z0B15uwYYkCTwPyhsj1tNqx0SMuGjYNpugp7ZPyocHfcuV767LLj01HNMt5/MVa3l1DgFc
B32bcMi3Dz2i1Ix4rywsgU/hbwiZqIpAhSaoajrJDoFkqB0LWuAxeEgqGR676Sy6+veqYNMHOiEU
V87zx2s49HRhvK+u0Gj0gGzCDwNy2xccm6IiPo7JwHfFJpqMsCDEAo8F7BRDnhs706KVHB+5nTJr
bsNei4rWVK3jICGbIKcIB8LjgYcAb41YqL5IJloPBao6DfEzcX/axfVoLPDS/yC0p6OLq5Oret2K
crlzqbJLx1wBlwnIIl1B9XXH0TZlo5Xgtu5mNSdH4TFJ6V0mEYUEB46iU8ZzucuUDfQqHwVd+K7Z
aVfFnEJ5bBb6UrxPgppC1JHEZNE2w0B++p/f/Jt79+4pk+IhHGLMZoXOkz/92zf/97+6d68F2IHC
cqOQ5n1Xvio7TyjPlvtK4a5qE3GGpBkiq9aiKCa1/fnLwX7vs97n1IaoDR73Dh897j1OsmoGw0xE
wFFT1pQW4FRO40g477wca3Ed4Ljhk++/PXrx3ctnx6+PyaQBWJAVIukFR25HZRsq8MmAXcsFcEyc
mwZTrnOYGnsCuqCIRNQ4D3ufJdlohiT++XtxxORw5GxIN1q3EPvOy0W1yqHNb7Sj9+rGXt+MFm6V
W24HEiaEJX6zG8m/3lpLJBe8WZ7IHURZ1VdslTVksRv09VrCJdWqE1oGsum/qTYik0cLFeWhrCw5
l1VdspahZSzyJHEPCx2JtCSyEocB6DtpwzjR0OdRW+Lv0Yvfvn7yuy/bLTF0UaZHEuVP10nanKCl
Wq55GSgbu+o6OxKjb5zLsFqhhB5Nv9A+M32Q3mZYkvf09AfuarRaL9AwsIMJiHSuEDVNUi1xuVpt
ynmlaC6yFZxUiiizh6ucVWu+yQmwYI3O7NRH8NGMqjXSeWrww1Uxm/WS7OnUPUC1hEqTQ9ThYWho
AuJfNwP7V4oNJSmasOJZQUohBItXL4+Pv/7hZWvA/whMzjGEE5wju0tRQyIce4e9lT0q1uNH+HZo
3vYmj/hQdK1WevX7JG9RqhgT/W9VnaNdGoxvUnA6LwqEv0I/Eun1XGJKURz8ZbnstdCoColZWEUM
zLtMLOSDofQJrqEwnT8dEVeaW1cSMhhR9J5YbdmYYvjiD61aDD7ZH8mbSJdyeHeLUX3TlV3oSuMK
N7SsvZbDa2MqTD1/w3tjYpBIeCtEyOVUhU1szUcrzCjBeDQ+2NbT569eP3n27NHXx7/74dtvnz7/
Vm2o+dd6ractqyHIi/hCcqdxYF9yNNScnxiDmOptaPFcgVfrcqqg94WVDa1pRZHeGYk9cbXU5sHI
iwgsWIsCLavBWqdMR62ykRv3SnacQ+eUsIOUh1s7HhbEypI93SuZ/JH9ERDROh3SlSFaWI4xOiHV
rYdeRe1r8KdRF6cOksjyFpH6FG9aiH0WTZM+aHQ1usGVRlE3MADVwjmYk+Jsc04gTvCREWn/vpgt
p5sZp3BmzDSGyVTowWAwmaxccc2OZE++PxoS/AwOoLfVRrya7wT9v8okA9hyaSJ1FuP3VfKrr1oJ
YyD6uc8Qrq5som618x2xcp3kQGg3nDucaZRpUyQTnF2tTxNJTnFVKNeRGO7x0G0IHBw4M1QjbCVO
ZDIY0gromRHGBWABdpJSC0+fH6eJTK6sjXcaHA5KzkHyFklDE+JNwLQksxOQBCZIPVZ1i900kfmT
d/isBJzfjOr1NwhXR2rbeGopfpAzoSGOqqRNkkFLbz5A+tSXEVrfMZ+jZRRgtYgHRbfImvEmGwrK
0ymoj8yWF8of2iDr2otPICarvZpTJXMHJwf9036y59kU4Zch56DAeB2qplARorVH7a/V5rZgHU6L
+5ZLhL5YHO4RN+nMz/KMavkHOo4pt8gKuK+8t4HURKbaPThFLs8ac1/sm5ByhEFsFrjixvtxUdGF
HBA+Mj4VcRB/yprAkqS9B77rsvo2SGwyqrmVPA8dvWtSD2ZSKZQMqVmVNaqTryNsJA/gUeolwWHO
hwh79kYmxMojzkg+j2vQ4fTv+BN3Da4rP/+Cpk6Elbo+MbveP414DWoip8XDV9bXZBltoxflsb7n
nH7mZIRcw7dwtZ6poOuGaeh93mdpzCP88Ai1myPW3YnO01bpnvQPT5PfJtlhJ/ncPsJkEVWuswOe
hqPGE8Rik2LmGmhZGrynVNBT3emmu9K2d9ENIljK1pg1cDdOPAE9Loze7ZdsmdO6rT1jxRIMkARC
P/27N/+7xdGyXg6hAdhKbUf3079/86dv793TxINIiBS+xgAzGnkvbyyMjlwQpSplhC6Zn1dq7WmQ
QDlgTsPlDdJ6AJ9cNBzQZl3OVEWGhiHc0rPRQvit37GU7YmqQBvWauH88QID7rO49vKTwAiLa3Or
lLPNqug3XRXoDuJfDwAhYtRB6kF5Xp+hPI4AZEzg6asNxeWHHXm4938si6uMPcJzrbXDl2TswbeY
yCCBLjpimWq9OePaQDdi2Q67uh2hbbuJUw738vWN9jZfIR3RUmHt5O21yEdH4/UG2XvVKKMUrC7n
9QhRGtO8Mzb4Is/o5IEaygOsdmTYlolQAkA7oa3aWTGrrrCzKhldVuWELOE2OpzslXDulzhx0T7q
4KvOeDJ39kck2ZBl4NUmepSnF2npOkiBShVUHj1HeG56JTmxE0p/RVz7AtvD5ohfTpAOYtMjxrxA
EJHbp83HIv3M0YxNGhPqpKOyt7prWAK/apZF9kttH4HDJQAwmcBq9y1qjxeDQuABSEON4dAMxFLU
WmsOQKpiHdaRrRwOsSw0Q5ESa+Vj2TLRXQCGuNBFcQPlJON4kvzuRok2mD3njqBlq/PSuNfPK0x/
IfIGd7+BQq1qayjIM9CC+7ssJwZIgnqDJK1qpKwVSc0DIeUGmbMWk9rYZWJciAXfOzYwUX6bb0wM
hQ4cOqIfmZyfliuy3qwuVHhe6ZYbovFjD3r4gyTr9XodjC8y6yTwyDZKRC6SWzbx0GgoTvS9Cv6g
e8BggvEWS8xzhA12jC8sfeDpdOBZrRGK/26I5SIpor2WRyq+ZknBozHI4kqz8pbESp0qdKpCxHxZ
zG54haPgpWIhrkgdB+ClmW6+NWS1bEzVSTxZmdnsDrZQwSRWHCbMAsGeJDsAnhx5BNm1RIJ3UALf
KUsAlEevY1NADY1HwOOZnOP2Sttq/eEC32Zo9UpDo5V2TKsnvikC+qXR9HpBbd9/Qg4wVfA/6UpU
QP8ynmnFjVYomaXZFoRMyppG+YVejRNo4dS3eNJs4i5NMSyo44GxJaPGjPb6Ap2J+EtfzPjDsfC1
0GyAx8XO+n0JGBpO/A0tE2NgvDrsVlY6celmqW0RaJtSNF5U96Q/XBlepndUXtCI9KBT2ck0lwnY
MzR7E08wa4OCWVO7BVJmmCY6uPcdjYUcDTVrHsgar6zNLvQ9c27KNKwKoj/tqnJ3K+QepZILJIit
EBBhQfF7LCI81jmigkRumFFTtD6ue9RT5+80zN+GjTSq0iV6vPf2xEp15AOlXkH72JpBSaBnNAQw
b7PwTHrcoTe3gDEk1tjY65gJd/jejXCKpgwiJauGbRtZlePCGIbbkOLDiJ8LU+pG7RfD6bopmVEc
IfXjIUTFFpNK2KEFQ7DaQz7iDIVjJCvDkBpLynJLdWPNIoOSpV+lsnJ6IB3A5fnOaZ3T+3V2f5Wn
OqGzM10dpaDjHE80y8O2PegYz9QRRFCgD5yfd1ZDTVMQ0XPfARv4ZmiYhd8ut+SBxk1ZYAgoU7Fl
3kJpbTj4VPF7SEVmRElrVuQJM2uYDVA84yVZ1hSudY5NIbSzNoWzuDPFbZow0/VQuDBl6LNyIxXI
mrP1gK5WAJvVUGEPaJbZrIt8Ka3TZoEBuhY4ipWkscBh182XHZaEgQJ90DvWlTJ3M/3yPeSqJfNp
+lsc3pdp7NpjVH1b4THb2AojbI3iCN5IEpFqlWHHOeJgfJ3lcQxK69OjBRtXgVWywxV7RxEtirzy
kRKKX+bD4htryyA8XCs8sw0WwSs0jaKhkxGA1VzUuX1XKKAs0qR83B0IviNKUEID4ItX6zlmQLJ2
9DS/DSRgqNs3mXvZfYNlX6+L8fBvsrF60ReAMm2JSwOWDEUzmb/HxlT5OUqlHbQjDVr3GK48lnOQ
B7vAx2FAp6JN75PdJ5WtySqMrjHWSMCLVIWyFKXHdlt/Xnjoew18XmYdryBX8c+yFVH8B73z6Hec
+r/sqW6/IZy5ih5BbzWyuua1swxZiJ8l0ph6zP9FLNCWu7DeLDGmiZ5VzoPjYj5Vx6Gk1ZHym9qG
tgmWWiqs/hxFJbscZim600wEHbuUiRrPKnfKRSdJwhEljiN/ttWhNq6uliHZ7SV857snGnsX1aOU
R1QixaNhBYnJDMlRtxos71wAsm+5/q5W2DQTf2nobXgnHUbXpmFv2+RwmDT5F/FS25J3f31dXO/0
ps5se4g3xAqF48NZMV1jh9YrUvJj97rp22Oju5RHcCZvj6+TGCNYZ2wDmjG3/GGt0HQGvDaKmImE
Tt+CJEJE0YQsbiPQrFNFA1IH+MlissvhhWK7HlwFAnWYGo4GoE4hUWRRKiyE7Qi51QTZ9giUbtOH
3chZ0BBk7Xrr1hNsFY6cYPf0Ro5cmqWogWa1OPsM2cNHjX2ap2qrXqx22akXq/+6Ub/IJsGybNuj
1h7KN35YoDO6pQgaDFoYE2E0Ky8LXmfSDNRKSAxPS7h4Cgyrukj+LFobIH0B1jBSXZIi1FlIBR/S
ji73dHGJHpVQLvtnr1Quxf7a42ifORuTiuScRvpkhS7DMagKIYtFCI4LhA9f9nQG5jHfAXgil/ut
EBTZLNMpMpKz0bjI0vji3e3fdsC828Vkxvhh1wo+2JfT3/5SaalQHwTW6vAaiMrlNPyujByH3eD/
yWQi8J/5NMPD4I7NrQPxanPWVLG7teJ3m1lTxQdbK35dXjZVfLS9x6pxjve3VnxZXRWrhqE2jzWO
B3iP/i6IgAYcRQT4JQ/KNiICNg6NtsQrEJa+C1KxTuytBzaKdnDwaUcm3IxGdm6PZgANykys9v6e
eImIZtqnjyeaeWb/ZeE366QYUdbRaDZD35WdOGAp60o7qup2sY6lELKWSoyPsIU8/Vjhxd1uRX8U
A5uX/TuLQcTMKoIMyJbLKRdFA8208eVohW/+bB/G6SLtc1s8/b9G9s8pnqUOrT3ShHY0OZC19SOW
R/+BEzFGaFlJ0Yjg5kr8tHUhfcKx7OAwZ1pzfEhVO+76jtxTOmrErzBJJSW3VuX+BGV0qC3EJXZr
4JsTqXZKE4hT/Wq8ZU0DjmA+3o+HAz0IoN07aUzUEXAmo2a0HV8901l6vx7crzskhJQxdtQI8p06
5xa8BhrwPprJcgSS0WoYQpR+HT8h+nMer3XHbcV66dbNNC1HNtVawwcpBy9r2LboqlEda+ixDVTL
NWlYr8ktCzZpWLHJhy4Z2gltX7LJzmv2QYtGlSa3LFtcfpjdr/NQesh41pYcYvTsCCvt7grnV4Ex
SUq0ji+N1eiVH0763YPTVmQZtt2Nt0kPgZ52EdIvrUjVLtoTuquVLoTBB2UQtuyeaIeY6H6lJxOq
U28hdlPM0/Ln+wju+PRXwjoroDU7SUShx0TQt2L7tAMNJEX/NlqA6AVMpRmb8q0Lw9muHvsgufOd
OXZtkhyxomPFw3ejGzG7NC6tdLTZcZytMuejxfmsmHwVU0FkGnjUpJ3IccMh5R+OO+s7tfSppDoN
youQBnd1Acpizt8bbdlG5nJsXcPx9tvxrKFDQaMfswlkd8xLN8RRkbKiDZjQ6uFh0gAxW/UcAm+E
F+0eOvkvBFN/E1uPAGnIkcpCPZGzZnZOPXF7NMA8rtCtUduxK8K3w1bwyGckpcR59pIx65XPUqXJ
89aqg5syKcdrgnKSuEegVhToIUhyzQBpbNEZ4zSGOgHlwOO/gr7vuNs/73b7Y3VidpBA3fr+d7pq
SKL4fdHV7kkjlZ0bY4wbUx8SMirtFnkF7aTgopK72BpRULzorYRfcqdc9FbaU1HfdW4w9NNIUgmO
+Ftr2pYNkYsbqPHbzaxUm0jSSeh2/bm1VbNldZDvkqGa8EXcF+tvLr3Re1+eL3bceyi5y95/PEVy
qwortou9Xg//wCb62DVmAYcJlhVw6YgKI5rjXDm1sCS5dhbAyEhYLk/mV6H6xEI982qy3WgOujh1
y28zk9vBRA5aiFnIRZCvbS73d744BSC/LmsMZ7YLRErR/3JBMoBDmSNt+w4TxHK7zI5Mn6HsNmU0
fQ9WAF7mQTGKci7zZwNtuLSq1Xo4lQ0rTCAIe7bUbS8whcyVY7L1MqpiR5IQPZj6SZsPsXN+XQGS
V41p3iBfPXDbmEcT702iLBHYx5YxeqFcU10pEc2ZYlZktaw2heuXaSvdeShD49fs34quLfRbOVjb
BVRg0W+ogAVrAqhkT46dpwiMqTht8jVlyTqZZHONsrlsVLxL8GjEuw4+iMp5t591c86lnOMlTO8D
X98TS/oQQFVkn6PXriVH9qUdOlqgggDtI01uexTCTKChAVoR5vc+/B9QYE9ePk0eJccmNk0NLz+8
QYJGTc9puldUiByGhBbRSTEqaQB9EBDAkjZSxP1pbsGEJKRvn1cqf2e7Iw+tUNYuYyAfd4bl1/CY
93eHdwcGxb3QQj8fA1zK4cyHrzvBtB3mXDz7JVQlfDeozdqFwOg7a2c+EHLObAq2U8LfEbrMEUGC
mDzk39vUIxtSor9xMSkxpT3hLgwjsE4m5YTPCTTfS5JXm/Nz5P2qBeC/SHsYawBZScEolhuIRC8S
Ygg/oqMAXNbdLv8ewFEpF3k7dlhlwuzNovLk1ueAd8a4QQZ9OiiMvoV+W/LBAp5j2hEY5VPcbdUo
g61AogTHhH7XZ/icrc/sAtsgcU/lbdYnTaLPykVIMHBGtzp13NMAcaJEqkbWCpz1+qynuS2dhbXF
MUsGkfMM5SNHmvymW3Gvt2s/4DWTVXgEJdyt7kXnk6DIrhzvMLnP8RuvO0J8ygJc6737yPseV0Fu
WGuQKrCqVUVCvKdvF6kXvPVk/xSl0+0k+e1vldGturTzBmIAm2G5uUQVZz7zes3i975pxyMGfBF+
KVHgLelf6nJtfXVIUof1vWbm83p9cvC5xJtVznbwUkgqpOb+xsTF9jshdh38gujZv/spYo7aDZRi
pOh/WS6Gw1RFyhHPdBOFZJqFPjafWWGzI58fm8/vnYhCypGRAn2mYvxDNGAbukkeYGs4rM8E9ck3
wrpZHr7MpuJqgfUAie57Zabc3LmuW8KCfWqXKCnPvN82qn/hJVXedz9ZuOHw4eOHnwJ4zarRGhtg
IISdaxP2cetdq3mZUgLXMjsAjapa1qlU4xJwiXWSMbR20EkO41948HZX89F1doItwrxPaQ6fumNJ
3xezWZWe4HeCgvdOr+n55oLV4O9pFeDbT//Lm3917949gPohh8C6XFyNf/oPb776z/fuobsl/O4e
SQ4ejBczwaBFM8LLWjg2givzTIImJT9y2t6janmTvMQWcQavLhc/Hkkz+DJROXwpHqEKQWMHbavq
Dof5wTh0GLeXogYWi8loFYkHpNPFcYgfNRsV1AeTRyADudf98H9AhR6NJCT5iAR0eArrkhJCrYrL
kmaPy4Tvu5QKGOpk5xKhBWY7x1nXGMFXBwFRyY5LZ1EB7SIp/ObNG0pdlczXXcy48nHjF/aZoitI
rMFVtaTg6TryhNAM8gsDRHJ4OnmBFfiXNPY9TJVI9cbYRpvVDHfvkjcSztd86Yc6giLQKPy/Ly+4
JD/PS/e1bkaywtKz7Wldr5sdrdu4N3iH/Z/364SvskyNoaO77Xg95fZ0j8z6YboZjG+DrzmEB8D3
CAMQT8p6jOFCiokNJQwTKoIQJyVRkCMR6EsKgAInSuUY4pDDYwlbwxEdMaLJymQN0cAncjh0HTdR
Rugi0gmLDvfRuwjTx2MYaAoWzFEWryiZOkYTpkik8BPdWznW6IiAnTtp7ZbZh2bNhk0mn/ysGK12
Lg0kdjMI2Xe+js1wGTfL4ZWyixoQilbwIUzlHXbdF4hBVSIjmkBgV0WAPeCiCGGhbJk/xUE6XjY8
FVo8K8xnXTBqosy/UOUWd4TQtIinNjCHO4sd4piNAyyCdrPAim4hNUAuIUdDj9JO12E23rG5a0oE
fYf9sMlRvS95P+5Md5X8NtihhwY3wImKa6XVRBnyiPOcK7bzeL1a3DRujYWq9Og6Zudbt5ftHvg4
T71uaUzEOF0js4yENgnc9DpI8Zjixz159uzFj8dfD49+/+T7V6RyTrqP3r4d/Kr3zw/vt5M9DEY8
fj8CTo4idY8wzjtewmiQT+w5XpPFpBVLW8eptXn93H6QY+m33c6Hv3/x6jWMwCuZpP/QT5kjQJoe
ZiBUSAZ/ByensrEOHS6rAgVULBAVjBFg8tozjLiUhKWSlH48nyCRn7Vxrbo/AVsv/VnJtS4dblU1
kvaEq7pU7FovzTG2pFUMY6/z4bkMIhVdyiyLejxaFkOMyVsAlwwMkZoj803EO+NbxQ7B6Ov1pOen
Nk9p/dOA79L1jVH4r9Aw4u3bX6V5nBcbEu05hJaHZ6PJEAGipjY6CaUrKOTdwNk8K0bJWGVTtaYj
ox/3yno0W2zmfupETKtTLlwNMrXjdHlLHZmK1kS7ZsBajA2z4kkZVAF03fvlRU4U/k+bEiMPY3LR
0Zm6sjknyHKzgiMHpOv5ppxUyVXvK0VGrStEbyXTPSpJW//RI8AMB2bvsBwlokeNlpXi8X2FcS2h
PhG52EapwOpRqlvggXJcYMqAxeHk+czWJmzVoksdjasZSs7Xtb2mWXR3uf/whObJWzef/CoOHTJy
rwnfyCdMQKQGj2MX+QthNxY7Dz/un9YvXS6QRfkdMDsZMw499dsErUnwp0e10/pKbZ+g72laDGMt
c9BdJ18bzGNbSC44Hrhi9I3pZY6Jvb7JpHYnYc0o/38bC6nAc8jDEXPXzm8llHFuOv+hiLrQ6qKo
9TQzDhXPXy67nL05b0xuroZu9fwesxc00ej4MbNr2pFCiiuVT/zBxZU3bI5LCsOeVxPO9aB4UrUQ
tAjJE/S9v0x1fHiXTFhMMCQ/hTeF3jTd62aIpAj5OjeYsgo3CTtoBDdoVltWG+6Xz1a/3/Iu8ffr
9RIOPh4pjBL8CG/pR1jhESUgRTTrVvhLA4P3F8syuIwbjzX9+4tqATn8u9bkfgHVFXeurVuwZ2nD
UXX2xzCCoRvvL7cLC3l8ccUho3GbDVvnlhxtCHWqovhTlcVnU1gWs6MXp+NMFkWfazub1tkNRrLz
rK9UupWOrua0AU24qXdT9YkSCV9cBbRsateXQuQ/DE1F68Qxarm4HM3KiZthRnDrxdXWAO5nvHo1
ZralCJ2ZOyZ3mXx71HVYG0dOq5n7k8XinFgN1S2uTLkXi6DB7cM3UoW7J+ji6sSsLhq7w0y4lAln
6Q5M9i7tKFjIm0oCcldA5MS/R9cRp1t3yAiPguxIzJ6pfmoUTyzxj17Hmrdmy840t+ZVVamGz/7o
3kUCwZKNHR49RItSApNQh/CaDqFMGDZJARWmEkma7hA3TRtKvyihK96GI841Y3Bkj5N6U7MYKlNp
Xzw8zTTWjAMHcz4kGYQDzD0X4WL2pfnoRsrceJiccbRb444I+mdHzx+KnD8WNW9FzCs/vR9v18C5
8oUmDY8DEkpkoFVy0idFvAb+F2LFJWbkLlul2HQqAoddndJYeE4tllBjYWaMBk1OHX60tZndsj62
W5vmxrCtHVy3VJNsrcL1QiEEfFUFeysMz0zoLiasIG1H96AhOWvkujK/0/QO6f22NXXSL0/NLXlS
9k+jYhW1qs5l0WDeb61u410S7hdeJLc2GNwz2yfOVyeaK8rN+XWFMbNJSIo7KHemOzwTF9amfouf
tHScQlLHqW+01SEmEPEiqxUu7fjDBSYU5iSlEco707mmcUXwB3dF6fe8qWVG3D7gEdEPNIuLfci9
kNSNk5GhKIcQ3YiprlNYSxDrJj4ECXHiqjKtOKlxsxVxnic6VRAaZwDL7U5S3Qs4CmqHMT7Hnce7
qk55nan2Akn4eIZeMSMIffiCgNLifYcokSPDonud4DCNEFXmRhJcQGELdSh86nBCwOmyt11tpWG9
koveJYtjmC4PVBwupas2jJu0RPHAahqp7MI1n7RBlpOyrwuTZY2zIStetecsJntbqIGrTqIniIq6
A6LIyBHmlRRamOlBdUoDrt2u1SjtzqnBSFIaKmklcS//VMT6tdK4YxG1AJIzylkUUos28sus7u9h
I6bXOYm8t3dLehrmfVVSOahkD+TWTqmbVksFoRuhAgtljSoCr3XyWRIpMDGeT8KD7wkrsUxL2ha5
YTmbzEfXAI72zPY8qIIS5XwzN2ouFjjgvKiFOslsVEVHVL4YocQej+tS7bgSpu/Z5EiH9Z9KiTBE
iACqgqwqeIGsEZoGUStPR4oMm1gKMRlqhnPPuQku7RXA3MukS1Zz27YOlta5q9eCM51q0YYzXZYT
BeKjPUYvMZyhxUgyclOecmJRjsVRMqsw/d1oduGkWEStYxcHpy6rUudeoRY4N/OBt4JaNL/nYlNn
XWluDrjkeVhpiX2itGWQuHM1KJXmrPKW4d/Ma0dUAdnTF3TLdxJP8t+j13lkyEapttekkNxzaQnd
R3tMufDwYjE5OQEJq91OnN1m+yu6aBqhS+KGoOS1WNVKiql+WycVoRCTg3mIpdkHx0IZnFuM8cYF
QoEQ4WnUG+emRwkDew2ep06sdzl3mJSxtvWudGacj7uO2wxYqmf59lE+f3H8/HXjMMPM43HC0VYw
OLNAZPzzLTq2ln78fNxwS9ewUPXHjvFjBhWHBbr+OTvocjWkW5GVs+pUllqJvvJ5phifFIrEzGnk
uPR84FQnLWMhsDI9IevTErINiE+6d0VXjajXHiac9/v/1L0/796fvL7/+/797/r3X7Vd1RpWm19Q
JdOeNkJ5CbTKM1iVr8vxOkOfUUsrMUrwLaZJIhUs0sTTApOPi28r3JVo/vvqcqFsupTNG9yVs9Gf
ytmNukIitjxMgl4UN0RR2WikJPGsU/gELWzpLjEZC1XVU881yMLMXjoWDCdmZxqxOlXko3QeK2zT
7dq3NzT4cAhRgl5FjDqNWDOtw8463EwT6cqn/ppCIReZMVe9VTGrLCufHQ2fPHs2OBKfYvU6JdV9
hR76QP6hpm+zuCDaCH1Y4IKuq9llYbhIJAqAHFWaEXz106Zi8/i6BghpPX327PjbJ8+01j99kPwl
eZs8SvrJb5Mvk6+St+vk7SJ5e71/hv83Tt6uUiXASeCkcepGSSnqNMaTcl4BITavLouMa+Stp69+
fPr86xc/vhL7V9tmQJamBaTV+ZD0vMNJWV+QOUxPEgBmq/Q/AavV/dPp2/7bt/lXJ/+pf/oQNdhQ
5Glu66vp+if1kuzFbFacj5BicgZ4IlKMeqlIB5uWgrnqEVuKa25KzS3tp0HwDW8OPWLks3p5mwo0
pY1EASbnuFys0YByBE8z1Mz1c+mK9OqiKa2Xrk4dX0v4chbOsk8GJXizqsksbhuQWjdtCJKwfzsO
lLyt8UMn16h7/X64robTWq9/B7Mzj9Z2ktxgi7ZvAdUnUKavSHh94mJ5qprer/9BIgjUy44uq3wx
VEORWr8/fvK1queg6nrJ04JTNSQHdh+qeJ4y7mDi7HJEBfEQivk52mtAg7PyrEdvt0Aay38GDeDE
fVliVzUYfjAmHm/foo3HIxdMqY3e+araLLMDDy51S+kjdBBMOfCEXT7S+O3h32i6MuwTNNV228z7
tpw2JLn0qOx2Yq42WwqKxC0GRGbSBpD4XQhM0d4cUJKaDjgRJdd/9MhtPLcsE55sAHj8ZJ4KD8DZ
I4ESajaR/sJ0GdouwVhob7nhN3Uhyk708OIoYGR9OsRG6Yh22PsGjnp5WUQzW6tG0DBFHv3rntum
Y8GPbgHTJRQxP9xC1jCUSxD/sqQmo4sCODfOHBkQsxsZpDNoA7dttntqp7ZQDkY7MZQCj31rFXQf
8pNWU8eB/FCHx+p21WAGbSA+CRSoSscNX8Wj2daOGqFph+t4DemQPWapt7W6qLpYpEul04asD2Y7
tje16FpF04B6SlUUL/id72zl/Vs5KRr+BvdrTE35pbH3VoCeo13k9fBsxrDgUBJv6wfZ28nDnP6+
epgnWe8BXrDmODpODVushZahSRDQaNOCzGtGYxQxPHIldxXZY16xMwUc8GVZWDLpp2s0k9E5Zety
Xs7g1oZaJOrbLMYcWRLuYckCTtejW85Ouo5z0Epc7Hk8K2Gkrhk5my4xqRampRzP6k5yNcbOBhKk
YSOPtyalxMxirXhESm6xk4TJx6Acf7STPw6wYCNPyeVdZfRYsLO0RRS6U6pssHFErQpXyu8S2TRm
BrmbyZsMVTzw1MLkHjOlJyC2q3pSarBuccGyDn4NtBnGnECbncGBOZuMkus+aZeuTbe5Z4kmRmT4
SfO5l/GWrllsAIeTcMtgP2ddhdOekoa5xmxblGq2PMFanIHJp4kVAHPrj6mSgt5moldOdSMq+SaU
UtXj3Kb42Fhi90haN5bdkkAZH/fErDBTb0TY7Fg1hREOdFsdJzk56lF5V/J4/k/0xfkwU8MfMZ1v
MXf25gM1BVo+uZkv1c6e/dFTfyzL8cVMp/CFq6RiXItbiSiwSd+ht7pHzWPDlornchHZa0sUr7y2
lLGnlsL/eNTF6bt6li0bLu2pYyodq03ePYFkm9z2MIdkW+eQVNaTyV7SMfu68yWqFMjWwbaqImWF
KKOBtFIhT5kUbfbKsY0P7O3Bej2PerO7x+8wZQNTFO229i8bUcDSH7z/SMVHimZkdC2ijKKQ2iYi
wQTzhqOCo6D+WYFtp3p1x+cruPFgnaR41TK1D4VO/YFLRkA5QAhZLEzDJ60zNi2iLRIFEnZCxc40
vaWoQKdVB1Zsw3H0p5mW1+K7yAnQiuQMUDNGNLhCtzS0gCDkeYXXFskqzeXCaH9gS72Sh0k7aYt7
eX7HaJicYxrlYN8dv3r15NvjV6HhyvtqNmESpVhclisgxqJSPLIJ0GUoizA2fRQ2yF5zERcQH38S
o1cugAe/iXoT4cjiliXhQLDsHUxTJsXMb6QVytyjmizP8Wur07lsarGiBE8ow++hDcUqNMniUj0W
vus82WnuM9Qu1ePpBWLJpWZe4+3jw33495t++6PbRl8HZ9ykuGctiBp5LHBpWGc0WxWjyc1d614d
fAZTOezvWqHNx0+M3iflCi7AanWjViK/fSmO3zx9FVsKNwKZMhLd2DYQVyWJKyNeenhL8mfkMtj8
44fvn7k3IiMghcRTLg9U0wm0dWrhUKK6K9sRVDgLoHt8XE9yECnP8T2RLoExEPJR1L0zDIVlXeYc
akVvLEudbvsqu5pevFfEYMqHRoSw7d5YMeMs+uc5t5FNV3rQexwzfcZhogsdSZraW6Rl5bS53S3N
3p8gieE7I8axk32tpt0Vx0pfZWxEFitEBEoDlIyrlG95C0A2ywlAv4AHAkVK8rWtMioEFK5ns9c3
fKlqmNV+HwlFHEy6XybYdO5CEFAHBEE4ORrAqS8NaRSEYFU17XYgCWk3LsMGLcyxsrUMHK1LiA22
NaK4U8UgvUq9qVNZbZFEFDOfEEReAJi4ClfjyHk1JDN353Rk0+tiWnGrXR9SFRpvsV2eCCAUfb3d
UMqzdbNIehkB9y1yCMvezWJNFui3B+UDChbziBoDMddcRMvfsEiPQ29ACWBXPRcJLmD3EmYFaK5O
n+cXrrVCwJpzCvhahYKUFWcHqcjac1F28h8xBdlFekxZ4POtlWRnN4l4NQBf6SXmQEiBgwAzQGt6
ZUk/CvygyByEt5cOYer7UC20zwDiT8CGYxiGBBkfWbBBuxo1yFyqHSKa8oFL+eIeyfqGoiP1RZBf
MXECwDnb2BtNJkEydGbcXA8PQmXkToR2MJ3E31FVqwEkNMwtIwC3FZiWKmBf237nDlsP2YjHL5Tt
T/ycCm3xf8QPrEANWeTSxH1L2a1WsvaGBUAe3iaG2UqpcJpvN7/F6eH0Izw8eq1XmxUJIkXMGtIm
1BOUTO3c8KzOVZfNeHDQYZgdHAQIDkvKSUkoAY9ZN6Dhih66II5TGAVqL0r3gJXniwoNL5FjBSSL
AUHo5+xqdFOzXXim2LBq6tIoCyg7u8E7jdz5i/losS7HDdbMIjCCkXRIgoAcHd5ZMny8kuAbD3J2
046rDLxD5F22zEqSzfQEQz7Igmejxc0cJvkVYOc/bmrVpYs9HdklJ5uWLci3BfiYzkYRso42ylMX
YkFLGUFF0jwGCdwvnOgHVMkmUYF0EJBYjzB+in+GkLQgDIdCdyrRcxBYQ3QBqqdyJRtr/g47ynNP
uQOcqM7YNhIuYaxFrQElu4yIYEJW6S4jg/27iJ1DjFMyoq8Y0X882yCY5UmlA0tzPECH3NoYk21N
EGELaR64BwmQBkE69hJA0xSUA6OGsAUmc0aFipB4i0h+s0CvjwVXJiuKywXPQxQptvRzs2ia/2bB
K6DsVmc3tCTU0K2T5mbj08YIvraHJFTop/nPsQo6hmQGfZx82nd4tVkxWmyWcakpo8PFDc3OSr8Q
3WUOfMVxHJESmJbXSJ2QEHp288knn9ySa0eWPN8aRHupE0wSQ7serTe1YjOJOagH+4zl98nPCdWF
s9qh0SxSFojh2awgyj1PXlFjSiatZcOhAf6e8i2EHTqrqgtAb5PuGSwj+RnSm/fr+WwP/ffH77uP
uzU02P2097h3YLVh/zs83D/gh4PfHKqXf9zME84V4C5xy/Ww5Rnepo/CrZFrAraDGFhZvDwSK9X1
ga4Wuh/iturkprD9nsNrf++gd6iC0tR9M0qU1nW7fFF29VvfBtYqnLr8+tinS8ZOmXAgUIL7dC7F
tOUB7aQqakI7yFkiKkNHlNqYXshfc9/vCZqKrP9eMInYjB3RBQOuJ7bgl1R/s22KVkGr2eCIwZ2A
RXjTk+4lXAnX81lCZgE8PL4cRKydRWFC+uow7aGn497rMcRHqqEPEm5Gxv23HzGBUlWtZRSD5Mej
Vwb15D1EjCxZRgzLaptt58Np6813z+7UnPIa0G3YPPx0aklVIqI27ZuHRX2+nQ0OzkeoiDTeCygX
y4Sp9F3CxXKBXJiwswaCNSawE+kbnqJQaGcLl9rdVaKlV/n2+xVnpcVN20ShZDiyNYgKOaThAqEb
oNhYAAsAu8m5ZNwBZ2q5OkRNAJpccWDmPB4gwxo8DZzG49jRSNYFa9GojIokTNQCWu/SC4dfBOQl
hTwFpRKCIkE+mvgVSUPVAR5FdSMTIJ/9xWaOeTYi2Yn+BHSMGVnH9O/HBZqTnY7Y7Iipo64Y+odj
LPZdQmHAQixhNSkI9n1yL0O6jg2DNF4Xh9vbzT3axfUSbmsgXNgOj/SyvBi5z75cdsT9DFNXzNnc
sQ6YHNxHBcpZuViTGFXVpKnHHI8xyQbb1OKSMUj5dk69B0f0fl0Yx62ELZ96Yjv99YvXT549yy22
BysIipjX54M0FZ444H+oR5ISqOhy5G9n36NSqo6QgWVyvgHMnpC2kvhaTRdOUC57VmA66eQ9sMhf
fWIy0gm2l967c4xd3VbcS3dWnbPJan0eM97rBFxEQDFg+5j4Mek+T1s7o//gMkXVHZm6kGEAqXsD
3d0fipvIdUb0q0v0h6eEh2I2Xg4LlI2KTxCo5sba1vW3rR0HYPF2iMuNkI1xvG8RvbOTBXF3gbsi
9eObK6FUCIjE5bYcPCj+m7AoKaUOPLmQkot5rhkedy/TS9XUUBaALlXM0i5zrdzfquidGOnE7p7T
58FSNa8Qx9zwxn2uxx07/RTbAl15kUvEJAzlDM/QorhChOGOE2CxeZzwsVgXHzdUaONnGqr2/RYO
renqnQO6JB536nmDI0DqN+wZ1Ws9Jc4AaQm2cyYBtUXnaMcq1SwQ9hznmcRaG4rHQF+gMU8WGmE5
IitEpEL3+7hwEy1Shhplkss6jkmvQ72VUGzqzutLXfgYKCOWV8Auc3KtpA/Gw4vzDhz0T09jU3Bc
13jckmXAkmNdYjq9bZuLBYxJClpHLs4VYaWhsfQ2c4KeUC1LnBmIq2NbxKSTIwik3p09iq52Q810
6x39/40Qd/81wt0dAimR3siFHtuA19NsInAQWGwBvubqt2hRdbktGlM/YkujnvFfaOyWHfbAKK6s
yf8MS0sWV9oNhw2gDxpWdZGgGy/elZvxGvW5TF9fUijXyxI1LZYDUNQcVfXBaiZNg/YUuZKHlgzT
agczPWGjHNyHVdMmZ/AdZDe7GacpUWbPGFW9FNUybbxr7qEVcs12advtxzrcU0MwKmsUbRkAKec0
wkbziVU1a//cvYeJTZmRevWPz5OD3mPyG5E9qtDKF9O9kRc4cPLE9FIKQDitFK8Ds2MB7+u1J2C4
/wlqfSpY2TMoR/7HkpuL8l9t0Cm5Up2VqluvLSSdOOdcrxfYS3ENTWageVLalD5cyopNomV9OEq0
elIrHNLdzeTsNec+8pg9v/jVa4+gTJX15ntEZnsrAJLRGUZmBqyFQQ4xcwqMuLqq6SzjFrBfEC4Q
mYcB+xvYMOwY3Nv2rMEzTojtEx+z3R0E203L228nD7fekW2Ut34yUL4selQdb0yerMTnlcVHohUw
svDOKCAl5Iek/yyVEWFdrdZbRZt18dOmwGzVFV89tRVLUhrljBwqDH+JttCYvANFfaz3V9I/k/uD
h4ViHGJNFr5f2Ph9VY6L5kvMziBYzvwsZsyeoqWieKN98/w7ZPrhTMDr3JOubBZkuaPsdYC0wTHR
ZfIMt+ClFTLFCQ8CG4+Y3fJ09s1MsKaOcohAicJDS7HAjJMjl0Quwly8ZeCqoTaSO89DUcDut24o
JKTpcM6pjGyWYRFhPPAHXsesggggVHTCwGoAYIu4VCrGsBaa4hBMaDgFdlTRVmy7t0obr38si7JF
xNGarmLLRawbNZrT7Ztwcp7p3m3BX+MeNHYtLB+NQeSKdhpCEUXijcRs4sjZxY4ZEg31o4IFhOQv
dqVx1u4xhHQwLdX9liA3mYcwO77ddX6X4EJ/E1opSial+SeDRuKkabxO43e7jz+gp0gm992CMbFx
yrnRcw3JasKYmA/haKORFwz3DPiSwEAwquZ5Vp0fSy4aiazjBWlr6Z5UEjT6IeH0Rfhu1GTaqbdc
ad2YjE3VdxI0+XXZahmjssg0PAEXNhAZM0y14uimEkYIrYNF1jJxxVtiRmaZg+V0wVDqMiAMa7rg
VrIMQEuUS9u9QC3GIHEWhqyuERu3yZBdDOv5u1MbF2KQWEvSULOwjOtZbag6HqiSErmOmxwkMXcS
+Fot1yZrdpMASBdDpWPdFzpHd6rhy8n/gtsj9dRm0Ty6lzQLq0v2qIIGLl0PK+t+p6BAZ0AWIk2i
SX2za3APSl8NHm+mLbx2Fx1hDTqKaWBHqyVeK48za0APG4xT4v9Stp46FzsCpYlPdMiCO7WmVr5j
L2dHT7Zzt8YafONYuWTP+A6z2GGQSST7BZEcuNS4XzrdYe8lXeroYBhFnLxjA7vC05fHjWVhV3cs
i3kmORyI/m6RQC6cDHjgKPubA8GJosfML8zKH+2hvK4wF1CmG7ohs2pBbECSV0g72z6ZQLeWk2re
Ob6GNaNbEVkDyv4I+5Ft9TUs8LqUBnrkxPiKbSa4+8DexPRxW2ykhagFFG6+RS/P9O+5TmUGOHcN
dyffR2Q2TJfAEQbC7FE4zOdAv0XCIqhGKBctZjRGbKZfHj87/g5IkuHzF18fRyOaW4pmdTNkqnZ+
qwD7/y8BcndNZeOR3C6PYsdhxui4TDUrMx5uEMMLsNZqkGSpkvynnZRMqlFrDcs3nZVj1ASmm4Vc
0imlJGY7pTQ8ximr9KgYKoOGpmFshExc6ZEMn4ajy1E5wxBhsabKBYoxsDmsgXEp52VNumb8Lfbs
KUdYuOAnUbtPQpfbvNUUnUhFvFAmScS/mB90ea1iAUd6XpCPnRKNctuIGughjJpBOIYfWvHUBlRS
7Z7PyNhhI1jvfGLb045mM8uNimQVTLV5aqGJSc96l/5VvHwJBMfJYy6uTvDlaYgVsFnFlZ8HQ88b
HJNPsAoKaQ4ct/dJ76K48X2hYIKeHqOH70IHlpmKT40CDBY91mNUywKxK1JHJHmKtFYuE4fAx46Q
qD0r1lcFXKE6QpVyuNyT2JbvgVm5xJyoyFKTFI0TypG2l9soubrSI2NPJCJdpGsVN7tgR8IzVtTB
97rCHDuAUlcVRu3vZ8YiR1vveZGHHqL9zV+6OT29ekh/ew+/gr9/Puz8VQUiUsBiGfrBaR11yKjv
g45LoLtRuEjbM6PtNnYCNE8azw0SNXD0RqQGo8ZhtlkQDp89HJ17P6J5FuwBjsDWUPdjdl9YWAmP
QxAN8gHS9knuTqGBcOM5swNZIQTuI6R4x2scP5/0f33KGu2TX3vJL/aEfxtXs83cNa0f73fGB53x
YWf8uDP+tDP+rHP9eWf8BdL12IPbDGZ+epAqTbtv0480Ig+fqrY7lLotY58VCp1Tr9VLfPaE0xgc
ch/bTr968zQiPp4uZKKy8AxHB03CBWgLBfZfNeTi0DjZQAbr1qbAaozO6sFBHhcGaPDqyTWliBU/
vpGjkJHRvLnDaIwksVGWbZX2NIRmFs3BoUgqaTURyiYjk1Z3+l1m/fSX2wO53f3RNJ82F2bVKBHq
/vmTlAKQfkpjfpVGwFvSsFRrnYW+mIj95qoYF+UlCkUB3OXQjve9kcwtlNSzELBYxvGh2M2CFMf9
BY30QcPq0nnBJqO5i37Oc+DRaLeBRiP2U/wDnnFXcOdbc/e3SQYdFM6mqvVaYWuoCQhDLcnPMji5
bSz/kjRPvmwUJzLpQC6MpDtHX2i4rycVmZH2ej10bXk/WtaoyLwaLfBrQ0P1mu/3OUnx1oWtSSXH
RpkJ3CMdTJC8Ks/frxvaQmFbuSaxGcv11tWyOwN6ZGbcZtBeUDwpr8px0dBSVqHWCrpT9TqJegM8
6WoO65NoPoFccfKGloyfKY0IyClSJEs+0Nrz57nbXu4lF0WBpn43vjdA3EDbD8wultrqcs53kgEH
hEeHj2mD2fVdD+eeCEOlqIhDW/Gb8bsI3ojVR84U7xHMIjlB7THbljtexZxTT3ZUsdMIzqGtuoU4
FM+3DWHY98gTRtCP6cfDNOlva5zgdNeWv063tiXM6q6tHW1vTfHLuzb3z9ubsxneXZv8ZHuThqPe
tcHvtzeo+O1bm6O44vvNVLNDfil9wNZGowfxI+9xnPdB4yGyxuiINraNUznwUWSzCplA9N3jMKja
b4/9DIKRHNJInvHh+Ix+/GH7sFgQsm0828mLO1z+8Zip2LLBabeAji8fiWOSqLQkhhc82UnkjjcE
RH9H2oc7Nz9u5/ZC9zei2TQnjYJ2NMkYc5TdzHzREYBtjzv1IEfm5+fK+dJLsaU0yaBrFWJPG3St
2SiSIj+sc47tM0pqzb5HuXWGe2SttVNjxwnLUr9HZ3ciN/pERlhV6dYxNIAxOeyQ4oqIDioz3cz4
O462nNphBt8XHHrpakQGyUSekHuQZnSAILO9C5EIqewmJsVopu1WSNFKqSxw8LAcxKBQfot10uXP
5M6FdJbViPG0xfMzWtnkk3grj5AghHlYZJStUDIUVbVgQZEody3pSV2pASZT6IOEKSWO/5eXnigV
SXJ3HcmkGjeoSBAad1aQ3G6WEBB96IBjO7Zt0IyevKFhTKgTOhYvyt/dvB6dY3pOzaq4kcmlYpP7
rIdGuDAmZcU+nqism2TF72ty6OigaqSYkWCqcVxUKA1iRBF5KQ14vVEsYs9tiYZbzNw6kd6uxl0u
C+zWvrvKBM0KxFSDXtdYJg0vD7vqAPUE2pQjckk1Es9ikxXnbe8u34lyGETMeMPV3OFuY71F/tMs
+7HnF5f+7Cb5+QCpz85robQyv8C2NYiEPnyoRr30S4x2J1K7WYQlWSXjxyiCL+IniXV5iQT3tT7A
TRhPPI29pvuh/kxTYulX4UdNe8U+UkzEgZ8QOrIjbcVNtGN2kXW9AwMgcnaFw9aVewWZJScf+NvR
HRcMcZ0ipaWdODmpl0wV220Xw0VNt3wf8r1ldxG7vKhsQ0cYVE231W8UK1PyJ4oPrQvDslgWA/2t
ttkynYcwVjIgoOs4ruCLAkwwjFumjK3Qxr3dOqydxk8j8kbeuju6aEVEMtYRQHNmrS7HMxsX12QR
pXs5eXtHAU5wC8M4lFIXdb9hJ0Kb9h1jgLCYc3lbOv+wpJKXcEFjbRDrGrGVQmdugb+Sb5FZxo61
pP6Srym7otI0G2zdcaafB5W2Mr/k530b4UOFQnRt1xWdecaz7egFzz9cEvEvjkm3ZXOMBfCP7+wC
wDeZFZTFthZyVMU9QWPIeUUS82nlOTyrralvRft2y+GmmYYia2dR0qZc7PpYOfTyajvBHEHZdn0C
G223o3FI3v9YFY/vAnqxy+pxDLnAeqxYZNJC/gFCrJ9TwOI7VfWbTIPE2cqOnoVGZH0/7NkP3z/r
K4dkzJBZA6t/0VsUa4zB9gidqcgxeb0CbPhoUtZr653b0vcIeSWh7h9+ePp1P5lO9idfnE0Pu5Pp
2efd/ccH+91fTx4fdM++KMbT4jefj0aTkVNfFGnJ4cFndjw3vOGSP5QwWXM7WJ9fwSUz2cyKvohK
rE/P0L7tSK6QJ3RuYbLLi6YiMATsfX+/qcDXAHJQYn//cRdmc/gFPPY/fdw/+DR5uA/Vkuw7lPTA
+xdwmWEx2/74JcdXKIuaG/2BIHii2juAJUoOPu1/+kX/01877cH759WltLfNzknZgigvwZ/fGsTk
dXUtH9J+ioYPflkoBP+vlZM6tEyCh907aKpV+htVEE9UPohLhwBrCHpI0eknJynmH9oxhgxLWxwd
2/MG/4y2Jyz3BTWdpLGqiPBDuzvOX41jRloNf6WnKom4uOaSFJGCKSOV5ZS8ZT2M7hlqafr9NN9t
ZawmSIYWT1fsBKiFbkhc4+c2JltXO7cw2cc6sqkUDVOFUKOwDShGigyIoz9Mhs7cvLqnjS0LZ9HU
OJYc6lvfbViqnjY1TRR8U8NzyYbNWbuvxnjfk7Gu2we1cRqJ0SPVrbYeJAf79O8DEoANhxg0hTPF
UTn9xs4tbo3SzS5uLIpraA9wBmXfQzE3XAdjYCB+eH1kjIhRqjxC2cIHIFGOcqbsUlI0B+zKfwn8
15f/8iQ7edg9pafeA8AzTqLy0HolVKtLBbZ08yKdNWU+527+hI42gep8D5Vo2IIQf7okBYrHuEkd
Jze2FdELFu/uWdSTeBZ1dM5YTEYrgp/zuZtJXSUHjcXTuRojxbI9ox/fONvLrIpr16yzbd2I1SJJ
yYiz384D0HKjDYnzcPdLO3qOiTSkgc2E5THheMKbEUHiWnLVYyfmVmWHf2rFylJVLtTVR64+2b7l
c8Fx+AREXROMuNnU7TYdEtKqS9aNUeMOQb4G6GyS3bLzxk3cIgjEjpRRveWCYS2CZAzDeEb7p05A
ZeBzfSm+tOYtVfRa1z1r52F5EWTy0yUB2udoTPR+dFlwMiUVvQpg6RMrdDfu6AkvAhIOTrwlpT7S
rTrHhaq2+GQYnRBHITk5Nfnq6U2AWumtJu8TqNqboGaLGlKKI/c77fcKBdswLFXSaI5axt1fspqd
RBRYp96Rx1EI66A8VxpZBu3R0m81UA7aY6ZJGugqgWZLcl30/HZ0I1sddrCq661Db7a76jgVnxP4
oSSZL+s4R+k6L3Bty6moWdxHUuBIb/P6vKErXd603yy349u9Pr/boJrFy5F2I1LKpkkRLdJgO0gX
+f4X3cPfvIaLfP+z/sFB77Pf/Przx1/8x2gFubDuPjFOPMOyFaZKRsvV0KFJdp4QRRrYBhLinuRh
w8ADJA7h1F8jePuCtADUlzuAeuOAFRJFbp891ai5PN81dWb622fK5Q6tMICeEBOM+zWJtODvl6EH
p8IUHftEdcyeoS/XT//rm//u3r17w+UNig5649ESQzX99L+9+X8+vXcPb21A4F38JD6Qj8Rfkgsi
PTYvkDgu63mvRR7XhDyHw+kGGwIaVrAm3kpkx0wCnlZLXtc3tXqsaq6L8TTJ4U7evy7wL1AZ38BL
XXF5Y55I6sGVgd8pK1Pzev30RQv9OVFe4bhvou9mq7VEsgDGoKiM/T5G356U6FV2wM8wafhxyD9g
6ulf5QbifoejiWT/ZOpNEeF086tTsULszDFL27CPxWo0E0KQXvasRvQOpt2u7AbGeCZKa9AmU952
x44Sgd6mg/Z00qYMjqOaswXjdTzZLNs54Z6kDXO0qs2L9ehytBq0WarV7qiALoOTdEpSPyjPQuP0
1FTD1LeDtoYIGwawGbS8ISvc6eQvUP8vi6q3wyxrf3pDzCeDLiD0d9BeVPAMRxYeZUHa/pCAOl+t
xxuO2qvXbcADaLX+QaD7fVVdoJ9/hg9XKzyVK04GY2/orBpN6BYGPgDHMsW3dVaMVrMb+l2ed2Rb
Jfg27/iCZJlWqR7pKoZYZEjEDDpnMVU725yXi/loMTovVn4t56OQGEv4CeWOeGLf8bdsUasDm4fN
wsk/B7IKUxVTdQAIKSwFVAYQCYJgUm65xdAMSOW1QHkJGnevOboscEUbOCBX7CvkTAK2eqiybXD/
Pao71EBTR7oHOuQc4UkzeF66jxq7RoMlFSeBfXlnGABpKJWHo/VQjStz0/22pUibHA9vSNewmQVe
j+bDia5x2qOhHJuRDKxQH41T3zI2PX0J1JsA7XaO661ALkFAxNWgaGVE85sTl5H12G+ED5cVJtLR
LLDQ9IDAxhWR/TdlIUlbyWOd/d6lbr2p8Y6Svc80ay610R6KTOOiUexxyRhVSixjxyVdvmKgFf5K
MeEUDezCdCMlzCjGp4OH/Bp5LXpwwwSpyTS0ALNT1QcJYtBokKjvMEyJDBLnJR6uGIaAn+Tb4Juv
j+zDqEkdqw/Ewh/Xyaub+tZeAGHu1gkBMPcij+ViKBFktgUOacw2FN4IzB3L0ttxJF1I9cge4S1Z
QFNbjrxtUynIPmk6V9FCPBBQ0NJYkRlo8ztzYv662MsfMnwxwb1YWEcMtj1izkbvCCCwWmNiCPiI
bQxhr2CPhutqWAGOyPKgENyby8Zhb4BCs1YhOEJm+lw43pCHH3g7DLh4jU4KShGK2sDpZjHGK9Aa
Nq+V66L9MevUFONTIzhKAcEvsh3TYdOy8pytBcEJw3/R2NfcvuUcH6yARAy7wRfk0OSAjxQjMlWV
iMCSFGtYJNXINpiSMj2O8pPFQs47wzE/rOQrRXx6TVNqOBg/32TGs6rWYe13IPjURIToI0GrJMhC
XqzS8b3lZbVybw4rwqEu0ZHWesip5FFtjX0ag7w8wTVtfVPXNTOWscvagOOSU6bQvQ2nbMjRT0IX
ryAfg1TvYQ4vJHJ0Ko+2XBsTYQPbpM3OgxZhjB/SIlRr0wTzbfcOr8sHbvBqs6C/gMUlARyb6YSS
tfgWuZsS2YUhtkaWQ5ioEntp5x872DHgpg8YK7P7wfl0fSjdCe01o23UUszQ1Qn560bIu21FsJGP
X5A1UNpE2P/SG6g6ahwy3DkkJYuP96K4OaughSGly15tlgqbCBkdGXThke4f0i31BhdawX4JH9Jj
eNfzupgF7wAzUtiRTXfGTnSjIXvECHYoSCHD9mDNDV7ZtYbBG60WzRknBET2dFKI60hb8gCifzB/
k1jiy+lEMZMU6h3FlW1LVjAtr3H0JBjgitkKQ+3Wa6MKKxZo5VRbZG8lec4524bmih4ZFoi6J/dp
xbn9v9S93ZMb2ZEvpnCEwxGIvb5rh5/8YNeAl1tVbADsJmekEXbAEcVpSlzNkAySs6JusxesBqq7
S41GgVUAu1sr7bP/M99H+8lvfvP/4fw636fQIEdaX8+u2Kiq8/2RJzNP5i+ZCgoCtbadSj5WRfL+
PVft8C/v3ytmH/dUq+7FCMJLbubev8/UpGBygvod9WyvKpSGaRBIFpaejfSu9+9iVQJ64tUVGW91
0cFpUX3qcxJGh/GUxzfzBRp1TdI5E6fzT54I0ibOy3bWVCs4ptvkgGbhwafPxen8bzYVKBveNhef
MAtyuWkrBNP5ZmVfCsr4thcVcGO8I9RULcty3iJyIukQP2NaPWHYzKor9UvyTqlfpoTy+BTM/sZc
qn601ADM424RfJDjulX81oLOYNeoGkpgD5oalz7LbbIn87afKHCWnyxGcVmO3PSTpU+9V7zWByKb
Y/+ixiQqtolRlL7sjBmN2YUpuYwISFucllPU/U9hZSNdyATJeqB06VMF3Tjp//jm6dd9y/JBb2rC
uMRSJHg6+02i8hQBvRIoekEQkqQMl2jRuoFPvxPADLxoqtu2OvEpgmqBJSSjhKxeOxPrDOQpasJO
R9iopQJ91v6Oorl0NaInfWUpbteEAwK19PuMNa6IiNOIMFhzqVHFyAag4BFq1zCLwDQsShwcwhvB
w7hax2aMPWZd1n9ZXlG/mBplp/O8owfYai++HF777E0wkRkjLup0TqikVLhaAfs5Q5wkJ5vT07JR
iB/StkPseTl/KotGTxIa/XlLx2g37Uy8TGTciFQj3eqj/cVs3SeAN14ON0R/2VF6dfMwodsr1vh+
9dVXeRex5FablvkEj79DlfzD/WitOfXT7GNW24rh2skfOyVh+DZI5LrNWx/wCQf+5I9ck2jkVFUD
7a7lq/W4rUqtDHV7reLAniZOF0Jc28iDCAKH9+psZqNTeNCLVDr7CVujK1tCD7AHIyjrQm0cnt6R
zkbESeftc0f6uYoup1aIe/bYS4QhZ5kYwwHk2HnGzcuj55arQPac9inaxjRyDnCFql37+dY4jpSD
m6tyHDg5Ar0Azz51TeV4kDuxzp3D0Ds9EItRGhlv+shXbakcnU3vzNHZdJ3DSGHhaRkBe4VUGiag
XQLndg7kC4UEc6/OkNqni017juQUSxI62o780LqO6BU9MLfNGC/9ujlzr2y2TZnJ4sT2MVpQalEg
TXqzGVce7zBNXNqnTVQsDy5wHOXbFlKQ17BK8F0+l3hAuaj9gTK9Yw13d5VL+KSexrL4Nyh2q/t5
R7eDgrhbi0jP7V3rMIKRtY8pLCmNsezxStm8k3XuR5Rxe5FOKZtv4hjeTBFgxwK3xQ1VvsI+exw4
t0Dmb/fpwdC+nzQ5HRm6155k2IGdtrhTTVKU2YsEtT3tsuBpo4DSmdlxUGCW2wNiixBiX9IPBSOz
/dwCKJZXWID2p3pey4nA3VOnHHtiUQyGOdt0ywpk/MING7YWlyfzgsP+jeW45FK1QGrYeXmRPHsB
RPY+qTcLiU9Tt8KjIyttNAc8Ul0HMLQOjn5kJ9dswRSFeVap0Gpcft7iJqKSTVtkqzUj7HwLxKMX
r7tcRtQo8liNXQAWc4PHYxxNFKrmYW5NvybJfidmHM66jM5AK+dw+8lLCRKIJlghKJxKM+EwQTgO
5cflZrFA9rGfx1dge9MaQd9om7Jw5LotNbF7yiitjUjOtmzhmKt1wWkS3FC3BaHpaKe8Oulfnez1
o76ceiYqCt+kDdy2mVbeMkh6ScfMObtsW8OS9daOHaem0/KrM8mUdw8/GGl3V2vK/jeaGGD4i3ox
P52jBSVFP3F21SCyAX0uNUaKX9MWs7SRSzMpm5btIy6Bq/sTYmRKNxwiHBAClFjRejKLNcjb+pmr
GhkoWnDrYYmlzT2SRzsWjhDEBl/eIFK4teiYEj3IvMnxhs2/JNIrIuSg6ajwBvRUMbf+soCiyvLC
lk04gjSzwe5J2/hWXiB57qJesRliyFFQ9B4t7zbo9nCCatRoqKw2HjGEckFpUaGXO4a+vRSDZN//
4nfZdmK2YmAqw+HUurJHbuJWnozBwgkwlhkx7QiFUghZ/an9TETcmtvyApdznZDPMUau+FPZ1N66
9o6yiPrSSRJZa873zpUGqVlr2rFV/JXo8Wb2enNNCyyJJqpVtld3IDq4+2VrRzw54ra6An59163p
alNQqmNmhpQh7kKhFEoepZXgXawE4crtxY+2qLD4vXItHQ2h5YtyqL9Zn37dz1UESLQB1eq2U1M/
L1G7z0ZT5Y+vaHeEHTRnXOfdwxZGTtyo7MP16HR+7MkVcLDYZk43rVL9OMmkLCdi9238hgqMQTaF
xCuNtzBL39XL9SugiE+Bw322XG18S5D4CW7ysxl9x+6wjuvt52Jrj4Pu+cAp7HNPAkX3YaxJ2rHa
GqelsaND09CtFHNrN3DK814oLte+5cGnk5Zba72VYHzS8G+nBrpaR3MafiUNVmZ2XbAStTCmuWZY
PJsTDsw5SpJnCDu5uCGLA5YKcENw0OFyPtD3Kpb6QDvq4nziZe4pRuVBhltr1xE0l4iOuvGlMtqa
4C4RM1zFMwTCVpZLaMebcwYZlaLZ0nvT4OUwNqLenJ3zSaiwyBnYqr5EX3jC90hgFbYI71lRiBcQ
4rGSWVOgiu+8YBN69DKHrDABSInKxY25F/IvhlxVMDE8Vsj73L/Af/ZCIxezUTlb89CIsm25CYGt
RkVf/BZzcbHFn8671n45RUuRhiR1emcwZplD97nxgP+EOglVAYbstZrrVVtu5jXLixgWfFmr4vK+
bVCM2qGbDoafDfW3X6cSJNyH/+Vt3/KG+gg7EUECp6tidlGcle1IHREf/te3kO5nH5K3f2+l/+MG
Pl5fLj588fZ/v0vuUwnbrcgKIDM8wtf5px8h5RDxcRmNdkCeK7hwaKX+djNv6yVxm3h+oiS3Ls8a
jgcGcjQCWIx6vRc8ZbgaoRQydUDYmHZ8//4ZFLM5Qbfu+38slxfAsc6q+9fYviF7idw/WdQn9y8L
9BC53zYz+AkvFR5Gex/2vpWT87Rcwv31zQpSoBS6uH/dzu9Tv4cH+yN46PV+XbQEL5uIDw1fX9F6
e1Wj02txtShvODxn4MxVa3ewpoz4iFFkM8/v607y8ga24DJ5MHpLQ/YQ/lLI8nV1Ui2q9Q0GFkUr
GsH9IFzXo/3j5Jvk4dg4/GIzZ63yHUMNQ8+cjKhMO6db8fNGv2CnMmBC2Le9po1ZoXcbk7t/wnHB
KLvoS/xceQDJoqMFh63/fUnXfTh7GDmB6M7mBHUiEtCgWrL8papsEIuCqGDdzDmCKhSDi+lgtC/2
JxiunXMRxC9uJB4kWk9A0X5LQcMRR7xYzDYLxMW6I8DDNxhie0Z014oUcV40c6E+1ZpIIqMlcHMw
BdUHpcwgKaIHjxGjp0nG40ly5/qXyZ/h38f073fw79Gd6wf7Q/j9i6dPj/n5cH8f3zx9+vS74140
9iUlI1yNIf6FlE+Pe9NFeYaeWlTrJMn2r/d/OUjg38f0LxyNkkLGbSJukpDwwT4m+cWhAKDCm6/p
DTbKvMN24VtsmHlLzcDX3A74oCuC6Z6SvuNIpizr322Hd1tgaO8mGS+lbFFf5QNZV9l5dXYeDTOC
ZAGTAvHDJDibTm96cZ/m+goWNzkyFdfShuN466Dy69yAMdiDeZzsJU6eXrXwirCQI1RX06N/udse
p9DVraYyOnma89WsU1OOHnkLpzX2C+m79UYaSDYeJ9WSnkuUjsoMzkML7xwl7ozQILyLbNQqNnP9
iaEb7NgveGeUfDOhhRA1N9FdunN9d//BWxyCpNoagDfM9qWdTcEeMAFpiqvMnQCQME8y7NBApbG6
jKEaYyZ0cMBCP6kEwWe4CQ3qxC6L/QGL+ZxgxpsCQREsVAfFJq2LMx04GekG0SSsl4p7Q3EruTzi
LhZsVEcnXcZcKHHtufBpfGFxUtINETNRTI6oOGjCkKXEuWs1w35FS/SLtMocxy6RlC2b8ubs43D4
d2FuohEmYd++TQttMoNn12Y8bNmdPzLYxMAuCV2zqdAXGuXosiBH315H3VdFs8ywy5P0ycMUXdna
FviRCdSy3SDttEXgJ3Kudez31Nuj8QMXnoIG8Cf5NwM/cUnCObM+xlOLnYBNcelwqBgmdDWWpyE/
djk80zyjKzAkQ9/6/sA4M8uz8okmx387I/sKM0BVoiuD8/tG4B8bseeCNc/XQISFdUvzVw1w69d2
D/SbLZ3QjQbu4fY2Q4l008Ulk+CADAZjwwDVNp1hLr6fO1OoxBV0VcFfMoUyhIT3S8uMezaS9yro
JOLML5khwh0JXzGGNDKiC1Ti4Xpqk+x6rs1qEL1HikZ2zDZDVRsupbwVioD2Ha611aBV39dnwNRk
UtbAa6U1+LlfQJcjtCneHaDNsnuILBWObv2UF6lRE3OXx47ob9W2vX2bpW6haRl8PFvg1U+7pmnO
GA5HXM0VKNC1xu/rj1Y3YrKnD3NZH9A2QgPOckFHo/fIAE/0T1POfSglHaUOVaBUFmgNTotjqhSH
rmGpTebIwmviLxKaHbcY4uss5xiyNHNfwRZpM0mfexqGsBgEm6R4tOpFcdLSc0cJsp0m0kRPRYNe
/y7UiODjoepB+zpcVGhTAI/7brLTAq9RVDJt7eelcs+Siib1X/9i+RBGzhs7Gq9/xsULPcIIFaR6
xCn32CP8xsXYN2i423EEZkWrDP+YQnpaUGxwsFQ5JZ001VyAvfpjRBEzG8HQL7UIx8OD48A4gmfG
8/rTeUcgn0AXs/2BndrCqIJd2wb4031dQH+c9Ed95j9NqV44hL6k9MaNGw1t9pPjSoPkMgj6pN0/
9tKRx8k42Tev/+LeWLn5D467Lbepn0d91Mj0j4kt9/NG1rZyxSMpdaQn+949Ks1ZDaTlU1bZ8ykf
Ml3LgiDVi5UK8JyljKCSInaKx2IBU6dQxCdJ373wV0GiBxponJwjqGPo1Kg8Cl1PQhCybhE8uv6T
Jkcu8qxW7k1Ua3x9vEkUUaUXtik3jTdDrKzLy2G6p2qO2y/ILEEZmS/Y6Cpze7YkQ8xa10w+hY2R
lK5VLb+cBkSky34tSBizYPGrDLrKi9CqLTqHR50z6+RnnnxikciJx57HxGwruQ5MHnRuRDjZHWYd
x5E48fGnjsIRNqTJwsnAM6dru9mH0p4dxZzV8PGtK6UEFeGpZdz7g7rusFjTkgglJGZ5hsYWyD80
ICHOypNidjEiaTFAWzTiF+YFZuWqaK+xyqgZ4valIgdvpkShPhU0vCyaC6Vxp0FpQb7mSAblfHHT
zyOGJ+oMd0YvauPkdkB3ni/yG1Lm9yMERNpoE2Zr1CjbSNJEoprY5gZetUrpMsApyT+l5h0uAE3e
yHy7w2iSeiRKPnhGDDBRkJTnUa04LdJ25VDrwavBb1feuZCwkMhXYdR+8tZR4AG27+1fdQPZfeGx
46puGZDbPdb0FpIu4CWDTEvfZ5mFkaXR6hoBtTX/XcZAVfaTRyE+DlJ8MA4OzfAHYusS+NtPI8P1
IQLBZ03jLdP3uXR8l+lS5eS7ulnqPisSz5Q/0u2QxtE1Ip35uMaW9YAmuykLvHrbTjCR99Fpbdjd
/mvuH8gVEWrslO+LYfrb0S/Hx/nnHof9u+0Y/j8hPjjJtvXx1kHGa75J3/IS7t+WQ02HqSTkiLZt
pM+ivx5EBMj6Dn5LbAGr5YZWBWRDQ3AdUW9YWw5WVXfxthjbhwDB96ywQLJH0vmG729T9DOMUYMI
y51HGs2sXsCa+F0ivI1xcodDi5ZMD+4rWIttogZzm35fiReRSvjI3NqEL3QTtlbFpM+vq5snsfMq
zmFbS2V1dVIlTey6VpUcBbeuKAIr7J6gHRaTO4ixIQ7Wi8NxfN4g+md21zh0IIvQ0TTuPls8Ez+P
5qkCtigneiGp0yPY6xYEuZkc0FifEaoP7Hvb76B/Wg+kSF8H1eMkqsx+Ho4ZCB8UkLsTgaDdIIFj
X0c7kADhJ3eWh7ZB7blf4LxSwdaU8lPeBMpQW3maB2j4KnXVQv5MysgDY3REzYCPrU4R0+6ik4Zd
G1DBq9T4J0/Szfp0+LUVc0YNSL2KjYebCl9O5+WCFpafcRgfYKO63Fwq/a4jP9siQc/vkhi7pd98
i9cCYkwy6R+M9vumT33qU//bR2nekd+sYmpe1qEucVfdlgXJ+21i7b1BIDwBnZQU3Dc3BW5++Sx0
wP1O7ZmoMfO+Vdiwu6OHp8hw+FNj0uYjdc+N9m3L9WQ/DwcoMIeUla/uFKft5hIkfKUDV6+ZaDnh
VPxPPPawhVZZf4j3JAzDjBwjTibWrpkmb4N86BNE9upmNMX2j9hC6sOdt//P1z/7WQfatZQOcyG4
1CcV6ivVZ36aNtXZ+Tpi5QQCP3Kz0MH6olxWf7JMngQiGw2wVGE/EFYtApX3ZitEoSV7DI7iuSK7
XO1NIjmmhUQJ49Zj4Cv58vLmydPpi+ff/2H6+PUbjCGOf6dPv3/8m544lzyjhJZvmU6hbzeoQGWh
qOytadDcSyO0jyug5svNmgwCBEbjvF6QlVGRSGwmsR8rzvC23Kwobc45L3lJiWmSYxSghmNWI3vY
6DZGLqzuISZ7C3/vXVx5NpS8IsTeUccwObau+zCqFuWi+JGpahJQOwPURRdqFG3DS80vg7SEZi9g
9tS2aMQw/BKLcNusIw0NIRsw4UCmJ99eDkHg08NWLRWXmBHSEcod7Tq/pWC8xuQoJP13S/sCExMd
71CZ7WdwAqyBROjboTtW1JloWERqVty9jc1mdYnbAwqoVCQodMZ3s/87AQHqojOFLpCcZnbh+uyu
w6rjvSXjp5brZF7mkRmuEO9ze4mqhEy/dNvEbZUoKVaa3YJjbUULkiaoUFlu83cAC/IgTLAQ1qfG
XLq4WvFDz3WtscZ5VseEC4K3B7qXF+VNJ5IKBfUD5jK/pd8Ufm+70hqj/bXrcqVDwnJEjINY/9hW
HGbyWsU+Eg/dRTVDRB+mE2ymBfQZSu3n3chL2GPKCV3mVtBq45/1ypn9RbnsdNhcaD4yWDRWDTyo
Ugcss9yBEJKzZKJOojz8qCm8NbxU3BhKO/YbpbPZfi+4r7td8yGLOtPkrKOBXMOwLxTYkL50xMBO
Yqt/siiWF3LuYEDaj8r0zT7p6JzSnceDbqAHLvdiR7EL+DeUUJno+J3uIFOc1RHuuEws65F8jpQJ
nztJH2YdOvqfzsmyZ+pofLzrZPkztQKWo8EYVQo6qYQzp5ykaLR1CnwC/RKamCZpci/5Mj6lBXAn
qxtlqR1OrtPPlKuRiJFUUZow7inMA7VHMzD+1HJWMyT8bJk6nDJ7I5/pMd9tA+hjOBHeHOQgUrs7
AUzNOB9v2TrcLHncS9Rfbp5Hm7s3kpwlCifmrzwN6P7DDeOiGWgLM7LVH78dMhMRn41PJChHMrB7
uw1r98AguVMxdCzQK1TsMsACSqQ+qI41TkK/dRniLYBmBAWcPQ5OHRk90oBQFZvLE1hgGTPSgga8
n+9Ah6iHdsPJejsL2p3HYmHaezo6ClzYZwxFZp0UDMspg9GuCh4JiglnRy+WrsnQodFevXRHkCyf
9ULi9sSHSLj3bB9NyjkhEGRNsKO++vbBLFkQjQVWPY1C3w7Otx64sxCMGUppehLcQ0KzOSq/jfvu
7M369LQt1757rLMxw0NPlcH7josYOd19diqvlfsrDuoyOduULRlPc352h5KEuB5dxQSZnQMDD+O8
HJojdJQkr9G95sMGJ5F3KM8hoxZ6QcqvMAJOWN1VBUSEPAFXFfTjY9mcwPdLGHi/ETfkiwNLcnPJ
Tj4nLDTgtF0i9huzxtFFwu7Pl8UN5EHnMDK2F50A+Q/qwDwSx1QXaBXBq5aQfpJyPRutVt9+Fh3j
49ZZAPxBLYN8F8reksE4yvvKtVTJHiT8RhcRfqE7N24qOjOpQgbJeblpQMa0PASMVG7rBXCtiZl1
fLADIUMpXcjC3ZcoAj2IJhA3sFSup7PzcnZBJ7JgEl2PlUImux7A6d9SnK3yupyl224pg+LE4J40
bb2eI6Jxd738anqV0DLSM7j1djTIl3cP1B3VMc60h+L0IOlfo54NO+jJCG6X7EyxyNeEo/5MwahH
yKKfJ4J0GkhltzrluFhu02m73oIn824pNqRRIUUPDqMKyI0sm/ozlA+vgvCa4XRRnE2MKlG5WjVT
/BAmn8MZNK2WII5W6wlw/yAcLU8bVVd8a0mRc1ayCYQlribVTkWB3Z2xJJcAoMRAyKrTCkMmmxxM
Teew1RfFTUAPZWXdJwZIQ4UI50ahBpqEWr313NSVoY7MiXGuvuQjWmD0PNkPw5nq0emGdDJJJuRM
h9ImPWcHCE1hGuzq25cDOZwnpoTRKSuPZ/XU3MnbXzmLUxBqstAu9pu78yFmhtQJKdkZI9lRbEZu
G6ekeZ1O/aSu8BYZ03Ag9GhPuFF7SYp2BnMOOgkdFg5mFz1UrKwmsYvT4xMrWNOl6K7D0oCOdJOq
Gc6KpSYX6jOwrEEYCxi3WECOXhPlihB9CqONSwQSkntxlttG13wQN+UQrztLQhhgIqhggDl2JVB2
PKvEU1fObNfQrj2LKCnG5fWIxynQ9MIXPpwj9n1Slrpq7Sf9ezo5DuS/eDrRIAO5pCUIsajJCDAk
JwUq5alHQIroWiXHZas3pnuxVV7R4FlDS+pYnlpVZR7JpFo6MZ2MJNJbUf+OJCKgakpCYUFDzpuS
bVez4YJJ/sFch3RqD2d1qBklGfEaBt1TgMekQ2WAFHFofzRRHu3uykMucnXzMG3V1dJIa4AJUy5P
iFa2VHGRcPTDSDmotyiSVbl6uP8AdXZ1MSfAh9FohK7kcAClawX+3V3Img8bWTNDurBtayxA+cGf
YkRIYNlw/YTrFgH79Z1X1p+ubsh1n4ubMmDElKuPAOStUPk4H6mBkEiPJzc4EEdqjR6r+6uO3HaM
SEyH6S/Dlo6sMfKJrpSEk8shxOlfpwXZAfuYMRVsBx1byKyr3p3enWS1OVlUs+Txy2eJiYu6WbK3
BKToWUzJNKB/Eb6ElnY7cRUDXVyJx4VYV33qYtLIx0LLYcIL2GdXNg9iuBuO0VGReM2yn1hx0Hgp
uIMFSGptgjAGjc2eNVX5EZK6eiG+T1T+yqZOp8piidFOZxvYYB9LoGfsNurwSW0Qx4OvUi1sUw8v
Tg02phsBobCtYmmTCsSMUtNsViSBwI7CcwEyfBsEtd/xKGvdieEF9Gn8TWtkRK5JYo8icdWrIOuo
3PCi+pcbGaSWAA3YhJYJdWacV3D9vLJVuYnybUoydg4VPkHPq+C4MkPbE6WCvQj4YuME8cvYWKCc
a9VQHySXoSCYq+l1WAkTT5q4uido10BuNBazgNTJYxUCduQULUEzjyS5tBmLBS43chMYZtMZAs4l
0hhbgqH+GmnytBXH4FMGofE47CU2yKWP+pgdHtisOhe0Q7TG6cAUcQryaavtBTyeUqTvF5HOaFSV
8IzWHaLp0t7NTsvpE2mMLD5BYGutPaxUZng5Z69grkJ1g0kxem+jOONTX6+H43CB8Vch+7qJ3ozH
BkoGyL4Rh61dXnu4S1baQJ7lE0AmMq4e8vXbpFiTO3xPv206ctwLbmTMcCm9ru5OYIjBESTUloO0
cGTMnI3njuC6aZsZAfJ42yoYrGdGv+ctK11I/13/15uzsxvFnAvnRTHKKzjgk83qrCk4lIWQFgTz
4QrfCQkJFxOXz9fN9ugoOiuf9UjwOGkNjqN+s6X8yleguu6ZanIihguC9EUTyj7Y6+LEd3hTZjCj
hUx5wJxG4rEqbh113HQPMiRtd8ihuZYPIbOtS9r3+uoiT6vL40r03FITsPKeYYwCUMPXU83YSJ6d
B47iC3ICTwjl+1HUKMVyKIjWai24adFm9CLBfqA9QDbh/zM6MOFnDr9L83tK4E+iLx4pi7cpvWkz
Be29RFjOKjDSwVmk3jzSMxZDuaXJAmbhcEkoUQTpgN0A3my+rTw1DZEirSXYHnGeYXJw3L0cFeqR
vSL5Ah3eHI15dRyPqpbwt7oMb6xqj0RmPoaOfSebLcijeqDEYfZUCnyYK/Jb5lsqnhqaoTwmp31H
ApTa3nSpVC03yPvxkq1PI5m0zp+nuk2yalSOrNeiSMh36kF7VB07xDHzqaMxSxy9wR8+trQ+gu8k
j+fMSMstC/Ba1Rx72JbQwMPRGWkaCQxHVLakTKADSiwcdBPFdIib6C4gF8FGvTf85FRffLEpMJTz
QB/jSxOqSPT9yjjyDvKua0hNF8a6DA4gKYPD1y6IdrZEXFwYbC53iFRHDcLrNyB400zwJWorVhI4
y9dk6bgW2XBhiJJWAaCocFUsLrKlG1TJtRe6FqGiXV+uiTuLfGPF+G+5yd760+6VWmMCWy6POuRj
o/oUN/uknhPmSN0gkY64eqDsZVxhrhVqRQivLR2C9PG9CcIIyl9yqUchu+9zrXyXViC0JuyPq6WZ
qPgmV/2EqhD2xHTWdHgxamsdCogRJqY0V+TBYCx3s4WrntSBFY6cTEi71EHlfHgkZ6E1FXxXqzlr
9+zjj27pLk9lXdj2ohfl7qWvsGDedTm+WONi8xgKeRtyFAbCge6KLNmwQ1WVfJNkDwa/yH3VrMZY
QC1Yt9CkGqItnDPJioGXqXZ98TRIDvYffElh3fAHrWHYj750ZEBII8ZO3Tfo9WLePZhRHQ2z1tY8
xWrZSq+k87kQF0tpNqubhsMQkjHWWFIMMctQ6ZbpdCR9LdEynQaNGNHgAZY1ysTl5WotZFsnuVLf
ScG3QATexljQkER8AgLiRavi6qr+EXb+PFw3sp6RCbTECTlCJZOyKNtLDmxdCbqfJC0iymm1I5pt
wPmCQdagRYRdGTbNKuLkRkIxYFN/jV+fYo5GCW0bdAhh7VIoQeT4mWhOuTBnMtUxPeVijOBhFW4x
Lnewi1fKFo8tKpem0cwqIDNFpUqhMM19XhPzPilYonWPJAnuSPsCn+36kOxpVsiKtIyaiKgOOiiC
zHG23AeTDqa++CncZ9AlyoYquCa7B7/DoBdqtIERfXFKQz4IBLuI3eHErWaBGrw9npQdL5ZXOuDs
HbXsZaO0a7QSWdUVI0oXatvh+Wx22EDvXImJqe0pxz2PN3WmgqwmkS8OhDDFC9uOyXf6xBagYIrf
bjHADIUuI5Qpyx4mRINdTp2thNIx0vppBlo/xTiLL3pgCxorK74YBTqDlTo9Qhkf6eQp2my6amBW
5BKS7qI+q2ZI9+rl4oYJSr0UDcKD0ZeM71wu6ivJeDAizRCrKddiIyQPFk+j0YrrleJZlTofF1gh
ZBd3oWI0E9fmbnhA+k2HmdTzEdUHROiId7tJrFmNengjr6DlE90sbxBMGF25ELR9dk5DSCRvVng3
PNCStN2s0DJW5Gy2lkVC671S/jv69S4G7YvqAtX5BWIs0wV5P1Be9HkodFxZXWOfinPeh1WK0Fba
5FHf2YaklKdkz7osvpN82FSzCzhm4R+y8SpXOJDqCPdPCdfA9Y6/FuCsyngbyF0zLME+b7E+mg+i
+gpVIG0etNiCV0txY19fX4PwnDoJtX4wfbdM5NZW5c89KzT9378kdPy493uRu3q3I7q2kPhbt8eD
5AXwmqewDuXRMHcRhpNmymrmA2sLlqzSCDeg2l3E1bh7a+9gYHE0+Z7vZWGPGP+IWa3LQtSJR7bZ
3Da/FIev5MVvX6z3gZoxKrg0gomZmJ7TYro7JxsTRSrQrbn34T+9/Z8tmHsUK+fFAng5GJMV3rl9
uPv2//y7n/3szhfJ/U3b3D+plvfL5UehdIhx/tsKYYCb8gv4/Yd6gyaNSD6vajx0cVFfnRPTCLTy
rCqWxPSc4OBDURgUgvzHiUWt2kFygyWQ7+SdBMFJuaimQUtMQiy+KlNIulnh9mnryxIKXmJQ+9Oi
qepNm2RndT2nKcSi8C+hDePlaQFDUlfzL/IRB31AtF4yVPn5l04MmiL5U7XiEEjcbvWojamhtEIo
n7oAAHEYioIzgUcy4cA5I7oreMmvqD5uL3WF3ZRVAIKBysmcJ6eWj5weuzuE4lAXwVzIVcHsB+kD
MFZeiYxSxfjutLxvcLQWdX3BYPIYqkLqrUi7DcVhsVZF5Y1f7Eh1AIM0FFAaHV7EepNsQjADSEVx
zkA022AoIXInJtJKXlRy0tZ88PXRZQtG7GJZXy3K+RkQXuohVnBSwqyXS+woIUHjNkQFALP6MFuj
5NcSiYN2cEXaJxp7wbWfLTbzkqcW5gO9B3DQTvX4Usc5J67FEcL0z2t+YaJ8rCWsOS4j6re6qS4b
LK5BTB0KBY/MyBwjSqK9Lqz2msYPJhYOcWJsahFjMOCJhCvhm4ZLHBNC+C+hqdB2MzuYjMJx8hQo
/gbpJjSrVH2RaeNl9uwUG4sTbjbfeX3FHUN4br7nHlOXkMsRvGToKrxpeNVRGXi/xaYefoXSHu61
JWdVLHjSfC9VU/ER55FO0+T9+9UN+b8nwyGIDLxBJoLt0o5WN+/fj3o9CVJBoJH93q9ev/jx1ZPD
17+iOCmhOzXvXvX0p0V1ouPRVLM1G/KWza2AtlJpAOKg2yK/7Lgny7kYoijrTyAHrAPDy8JIMG6V
gDBciuaMyH6fAxX7WpRHk5gahXQCV0gqjYs7radvFOP5C8UQrKAywo9WFeVeSScbpKXExsEUEAMN
mxEnD53/5jCS2nQehWEcI7FTLzyLfkv/Ee2usnWSMez0eoxm3gPGw2EGP60ou2167tBuJz53jtHG
qkHhrm+lHvcHiU5r2IVtbvudHJC285O+HKlyPVahna4uEFPNM27WNtQx1VZX0e5odlRkzKONUaWy
QrFXuW/fzkMk5iZiQDVqy7UY5mcmp2XhpQfeLweaSWHt0Liqf7e9L/gN6q01ZWFGyy7LX1fcS3e4
dD7ct5TLmguDA1BPscPZrB6YHBzcEA1qlvWHInCysSzJvBL19YVcBmvcZ8cE3Z9IghRwO83xL+N2
zlsKcFdCPFQaGj1NMTGOCczCdIon4HTaj9g0KH+Ki7OpjjOU2MOyzbUCx4kjVwuMSv/w1asXr8YM
bLWu60UrchmdPeUclVhO7vK6WmcPNF57lJw+RHAuS0OJk9nnUHBmZhf1LB8nzqNTmeonCHGWAWRw
TuhYh0U7qyoKdggHHuo0KaJoJCOXOMKl22Z4jo3Y7BFGs834lKM385JKyNSJJRvHVeoozcFLKhS5
F6/Bt3Uetz1KwfXMHerPaC7fUNrttS7kSJfqnNQqXU9NLUZTmDJskZZYVWbp+xKWIpKJXx0+f/Pq
D7+SkCHSMfpKfQMCmuV6r374h7f/HUO/IPvxIX37f8OTzWC4qz9Vqz91LhQlUJWzDkWUwuToh2Om
xpQ+8DMqMpFKe9JjsodRUbBQjMH4vGT5yf0l1WOL163EbaXERKWJxJeDlQ/ZMOiP7HFgr3ofMkK7
UbLevJ5R1/O3exLRbF61sxo2DvEkyItKEmIkpIn0jZEYK6TwyJh1IOUUJ229AGFgys860JdCAXWj
fQ00BI5qoHDJkkri1rziWCecUgP3kHAgCd8IPtArwtHFfzFc9/diVLhLABTxw4KvMHhZKqMw5aRk
9Yj+XfzIVpA0Q2q0LHcfxllE+x4rEshR//D775+9fP3sdf843x5xRYSrjjgl/eFQ6hzK7Fj4UU6E
kukaTnWrCXwbqNNyKBJ/xvFuHCYhCcvmOC2SVn2+tY1nIGx1NdBqG4Gc3hutr9deBJi+32DdWBLO
KbwTOVng1X6z1CWOE6vEeB+oabd2gPEWh7zOhqxz+0kjLgCOUr59OnaO9pTzyJ6aSiP8oDCM/Ec2
o2y6iGpGDTnCoUp4vcFbCUXU04A2FKODbK4o9IgjxbiRWtwlEOXHv+MkzPS5relp2J9MV0phBXCq
cIuh3WHK9j7SVAHKG6ENRLUm0Dv8J6cbkHeWoQoUJ05iS1oYE2m4jiPrTn3o+iftxgi54TgqKZOo
S1EtJHFm055ucRNdhZSRszgA+KKnnYQRa/XjFugqXSGGI+eWKDy1qw5zN1OIp828ordZBKTZbszI
qgnqMNFgaTyerctLdR7i7+4hUZJzQ3f9KJGWjfgrzDG7L0/TPUJmVSOO7pqpzewS/Q5Q8Tis9MP9
SNWhNzQfvtqKkPUUvp8ou7pOgVQ64MpcSrRa/OOksePXNR5MP7DNyMDmAW8ni7fn+INRWgQKtCyE
Mkk5grF6A3+fcvm7oDCrnD9qlH19Terf6UpSaTz5W3FjaK95Zt4FqpRwhJ1MI/kQwBOGKZ2ee46H
EhSPnwOtO34Uu6BO11Btkh14CcW9HnV6u/Q91U/z4qADV18NFfIKI8VzepTUIQY+SxOBgo5C7RtH
c/QGmQpoo3bWdhO/Onz54tWb6Y/fPXv61MzAyH4dTIGGX+vw2tWhhbNZM9nP475ywVWJma94hBxK
RrGKrjNrCgb0Yl+b2A+Tg/1cws5/G7quWiRRd+Wokju8426zUuMyeXf/4VzhTFZ0WYSkMx5OpAo9
dbsXl64iPXz7+IeX3x8m37948vjNsxfPkx+f/+75i98/HzAk0zlf0CLfxnwRKciLtVqLMSA8NkcF
AefRo0fp1mFRC1rurQhej2cz32F40m+//RZGB/6fPIG53u1jpJs2Go3S0Ps1Ru3ixK7DEJmAjGX1
jxiCfKqsjGYIYUz97aaUHlU6q6E/9v7IVXwsR4junmsK0DiVjln+EJrqPkPvY4eyaqfkvLuHR/0f
nx++fXn45M3hd8nh2yeHL3HpCCTq1mMA6U7mtIprzY+7azMxHjj89VQbAGf3dmm6cF8+YxVjmW6H
eujkEpyjVh2yzklM8S1P6w5cCMbbFbcgZlP6R7IejoUIUBo6hYg3J5qLwuIUr+M2GiktcqBLJahd
zL578fzN9PETnLXpm1c/Hk6fvng1PZjohR79HK5ZO92vv3/8/HffP3t+GC1Ffw0Lef7i1Q+Pv3/2
nw+nv//tszeHr18+fmLKiH0Mi1CSr86mXoRJn/0Gijyc6hU7/e7wzeNn3+ucHd/Dgp68+OHl41fP
XkMS9N42dfsfwqyPv//+xe+nPz5/9uTFd4cTmkLyR9WHJ04oanm0QbqlJMgcocv6gJAjvvSFgglq
G/oRbYNQD2vxTBlWdxJZVSZpMZtpTxok5OTGDoTca4klF6hcf56ElR3hG8cmWSXveVy/FpmcjSdi
ADIuMCK38dUdbK4EG55KxFscAFIST+WDhDKzzT7QeLBqGJBKTTyRbWjIPyYVXsoubuhijfxz5e53
XqHZ3uJm0HOvzPBTXbZklSouvGgkyKDGHOVBHSkWYDVBEFg0gzghi+Gy+FeN5cMpcycko1cKKlod
NhdlWYJsRcpBTqM0KhNv2MifdLOcFc2ZFzwNTbQUC5oqYygq1aWv9OrIJEV1pVGRmuG3lpoYQNv7
w4MmU1KZpkrlyebsFb3NEIWrbkvEvrFKmFi/d4wrI5MzibPA1sphXZzdHOYpXtJ7a/JERjG6u6nk
yHDiBzxWSsI1rLrF/0aESFd8tCRHkRn5SOnIp+0tyUyoTaw4L1kuEQ0VO0eaPmM6KZ3k6398/fp3
z15a9CvRgG7aNz7cqVaDYGDgKbsWhRHfQKkRxbIHfLNpGSXTJ9U6fadjlWn5I1kdSw3bq+qGHb+H
dUjb09ynVEop5ZAmA+5EWrQdKZOKmehtTQ7YAktUNNr92N2j2tbREMKi6VNlxIlDyAFFXbHd6qSp
qxuuIYu7Y3eBodmd9nVr6TZlZdohLjiTuVnSAYdGSDze0vS7TapYK38MtjPXIabYnaQFdrI9vUne
u3cL78n1d91sZuu6Adnjk08fT0CYIgWARf5TCPMd8UpQCBlKZSzDogxIL0u0wK3aS6vN4rLgi0a+
08L//0i145PAxknSXXKfz3hsrOt6Pqxur52i0xHZnnhTGDrSOtRqTKsKFrD4AKgLiqBG9g+2taRU
Dp8MoiSm0RwkDsH3lpveZka3qsjyjy0TQI8nI126Q/3IkJIjynGxCco9KLqhetcpkwyfYHlmvkto
z17t2JiRrGIJek2zdGnWC6dRunzVH6F4YWEqgcjFp5cjs4VISCOXNjvLgNo5wX8GnxEyeLZoRfms
+iGeDL04GXDphzstsSzYo8VCT6MLNuEm7VnSY7AH3ClnFBU0VVTb8gUpNZ6I3k+ZxYv1aXHBhz9w
8IgepwGCHZlHHftIiPmyapOmElSds4sL8ghX3OlmIW4uJTMVLR6BilYJAg5eM0K+l3y7+4BWpDw8
HPFSerxkZQhHbELVH3lYoKPNx7qay5mABE+JS33lmWZhUy3QKDMA8lERDmMjOkjSH/mNM3JpqACI
5R7F8maOwYPDNsirRsytuK/RMqLz6aI+6t9PGLaW7sfVQlwCPZ4yW4EXumyxBoO1XKwvENcNrSNd
yna+Xq/a8f37Z9X6fHOCEED3MTH941RrmNgFLPemWEwbjkmrYYOafvbu93/+l/xo8+NxdtS8Ov72
6F36rn+c9/EmbCQLzeK8ifkiztaJRo5WtcBNo5bNOkvymM1TdLxGW8v8rMDiTkPCcG9tpzm/a2Rn
g0bbx/A/JN0ah86irdgUDkfEJo3F2SV65qHZ9seyiUAOaOAs8l5iMGR0hoDzQWy75+zzZG/hahkp
qd40jhk4PFKleOtBU4GUoLXKeUgFh9inpJDD0AjTzVRRnmx9ve7gI7UN2wgIHrPL1tqENZe+O3j3
IIWT9XrtgToQ7SqWDNfh14gfQm4T1k40NbzPI1P077o6t65Q39xPUMN2o2rQi9jr3udSSHPGxRa7
f8ydVe0asRbITEkOPVy37smFeW8VVZWqVaakkbIt3jdLnWJBiPxw7+1/b9lRrS9X86r5sPf2P/49
m1EpxRAFeWrqjxU5lqBDTd2QxwvpluqmgtUARxobUykcqRE31zobXFMzL1yYasRlvbwob1Zo6WAk
Jv1Ky71vSmrs0wLrv9HjKs/CScfauWEfZbHrR9t/BHjFtDrZjRzeb87ZT8N8UC6VLCZixFfLP/v9
++EQk2NZ79/LejXz1mUwwGX5ZhPassUyadEf6WpCf+NH0kf0eQr71g0Am2tim3TwmYYQoCDd5MAD
XM7miP06Q3v8XK2ocBhvyColjFlhgSZSHWivSWjwEjuGo1klybM1M0KbAA39pESDJ1xLCkk+5R6l
el2hH8DGhIVwvZxpjZJpn8gtsP2A+RyuymbIhk/Lj+r6WfcmCGmDDl4b9LFalxoNn4rrAMBf3WAk
vtG0WFVXRbPM+o8ORgcI70CdoPaHze9HQ0ngLKo1lOUjnrzMnjL4nzW7lxfWzCpVzUAwXMp5BK/+
CbvKkG+pmVBxIdR7wZ9wQ6Cc4C/PTmHVq8revx8o42Asy2TGyaZ5QDGObBFRx8zZjPhF501yRs3D
DYrA3csbOKsROB/92ZYdaNtqvKwwHmYIfUxu1VjPPV6AnjHP6PICo4qqwdymmlr5JgIUcnSq6phi
OdyviZ6b4Oi6KMsVqhiaul7jBKt2kKnvBcWphLN04uLRGDKQ9XkNwHpbBUtq5Rjp61Hpjv7UtQBG
26MQOBG1VDWfEt/Mn0PXOC8oUSZUvY/AMpjyXBsO9SEK7aOXABvcdbBlOhXzShGcL28p7XJljslx
BQQrClkJ9TFS1YZV+8SitIHti/QLv3RhFiGNImIwtDYsy7y6TahYWQEtHG5WHaWE6z4nWNY4X8sr
nQyNuAZ2yU6ZBRjWp0M2rsB2f5JaNCi415FEUVY+BHdePt37W7U9/Qkcrm7dRP7mEcR8q2lrm2oB
3VyQFWkkkxAKjHKj0gO5WEftFdaOa2AkiLNdIqfo5xaOGa9CzZAJIC7xW5sGr4l5yfI5JQituEYh
L2ela0mi1Vd1cyH4Vk4B5fJj1dRLYgIy9Bu4c7B/oMI8eSwyFKux3hyyJd2V7yNd/a1OPo4n3p0E
LUTg1J+TbxlwFifA6qxvesKfCpAZeqM5DGvPM3MWdjJzmEH7tHazM/rzel0gk0z7kxla4hkVnrDw
sOwyS/7Nlyu8IEY/S32qsi5FRRdi80gqTFDjmP3hy7CPwMbRZUaxDlpOMZYHfLMsN9GiJTtBVdZH
YKQwyk1TCscnTWbuaHoq3RJFqlIdujNKa96SBWSu1sHgqlG0TMRH09miLJablcLoO4ItA6JADdtg
xKtYPBjgfStYcJx1kKRTbqYMCQrcA7qCwVjaljrVyqo8QVLDfmO2kXkMSuj1fiUikPQ+a2f1qpyk
Miggr5FBtDNimShXgw0XrBhlWabBp1mTKZprZ6C1MM0qXjWCziCEzbVap1o18Fpr3eeqVnZKFxbc
uQBcaS4S1g5id7ryZmJYeybBCgydXN7hfEtu4XaZ7BmGh8Q/bidqijgsGGEZvHfOhPfTnjLUd6C8
1WiKuYMaTdTwj7Stg/5IKp7+0bvfH6PgMO2LEyUl+uHx239+/D0ke6jBZAlcEhMkj+Tz2LevwD9H
Y/7I1i6IDehOyEjkh5jUYC+F696HgQ4wTl1vPy43zeLD8O2ffkm6gp7c37HbFkfG3pwoBGJrcGjU
tW897ka8Buwpn/sUCk4F1kI7alWXRMDwPGDyBYmSg9FDIoPn1RkGt0XKw1gSsJ1qvl8sMLJiuRCs
grJoFhVQNGlUO+rZvvh1O2CHNiZkTRDPfHVjgm2RA0VTz2D3GP8t6qTBOgJKFf8Gjb+a4bKEH7F0
HGRhs64WKsevN9ViPqvb9eMZVvkEvw+Sx0C4z+h3r/fd4a9//M1ENKYSzfzj8gkP6ktkC3RlI/iA
b35dOIBWqoULgpBhEZmuV2q0I23xcgUD28E0ZDqoOTLAa1iDZqZl0VDIJNK3jIzuY7pom/IjR0SY
RPuUXRbX6BQI+SYHD77OVTa8rtEZTbed5Pv7+2Qo3ZZAr+bt5Of7o30nCi9wP9NpNlu0A5lAKFPu
xopNiHNAIBITtaOt7HkHuikXOluEivyPZFRDxlIfXWXDhvDe6Rv+9iDbzMd23Th48GYySVI5Keaz
86JpM9eOwC5BcM/T+6knRErRks73j/lIxOmj+1qa7bTYxiywBp3MU4OYZMragspHOP6oNJkyjcnu
Nrk2lfAHotNg1mQeJFJAZpcw0C2wFwluTSAV8FYp5y7ng+SeBfCutouChymWRIyEfA0SNhKnOwIE
eoUmiO7kY0WU0AsTpoehw+/dEquxbeRUbrVpyzjInfVROkSGRdVzTPFu23XmZt+tMnec6PNfb5Ts
gSGIYZxBMbKH8o2htu5Y/27b1wtjWrazYlVmdFPNmNbwS3BDrMBEC8UAugOgIXf9Usn9fY4rKbdt
WIDnUWpfYgJKDbdzRbh76ZrRgq4qRv+1rHVENzpJ+onEBls4JIVIuadnQgCPjNBiMatYZVM5ltnL
Rttm4vzAmGF63KSZn1SmGnK4c+rkUTO705RirEhYw6kzjZAZW6RpFQwaD1aGMdDga7ATiLJ0+sdg
eXuTBIMs75n0JJPDJ7HLy+J61an0DRe0vZLV61h3AzUXD7Ec/COnRE/XhRyim2wUi8h2a0A29Cgt
0TWEDYFStOxLDlF4a9M8+QJpZzzuilWJn71YoNGuaFZ1MXkXMCF0hczdRoeHb5+9fuMZUIXWaF2L
awXCzPIzltbAhOldVSuWXxoJOt+u59Xyv941R132Vxy/jI2BGrl2FM1o0aItvhyKENqHnV0K8VLT
ebkg9AVpByUy5ckBb4aHoJ06Ox8E2pGraotvG+kKkRgxn8J8V241zhoZju3lGKzYEZuXlBatQ3BF
E3tvbp8w78g/afGlsgPP+g1KWc2P/UE0hrVBY8z6lO8ug9LKfSjiGgM7QbGjcjueNUVOYf21CetJ
YapoPRdrfcmrL6io/fqo+HzWwOyuVNWlTrJsR41k9/IZJPkuPkpb2jLE6Jmf1yIYgsGWttnrByRb
UoHyEiKGJIjQ460k96aK5dRTR9tI7/Cc9mKFCBr2jSw6SqYu9zpCZS80ihE3Xtzq+FW5csGRCXU/
+Sb5MrZCDVF+9hzke+lxnzQaQssIQ7Nvz5spFZjuL7vnkJgSf/R2nH8Qk/TV2SRN847CBEwYtlB1
esP2vuvzet4mGYt5l5uWMN6rJXWDLqStS0/UMe0yyYIL+A/x2eZJlYmEzCPHFhTOm/SyPUuTi/Lm
qm7m5uKZ7Uy1DUG1Vl7K8VnnNFMoC6afm0mX9VQ6TBp1B69GV4i1fWIpsqzZ456IpObNUiyVxcKn
VAGiUAwv04HVHE8S9I8GqzC1sfLgoDOJ7GDSK3WwrKF95XqAYVknqcShj/XUp/NYBG8pVBRTIYLF
jIQVQXzE6xwKHnmUXoXyUHWn0KtUAnp0H/TxfaXK6CsBjvGiq8vLDfmS9f0x9LhoJoDYmeElkT/z
DxBCDB17y31RQPhyjxhyC/P8lsnkZPZEWj6iuFkjE9bnL/OOtenTU9I7EoDmrhOXdMwcN+WnzJvQ
w58ya3hpoWdtOAS2c1a6s7d95nBu/2rTxzAb4S7sTOzML11TK8SW2eRA9iN/2G1DcloECyaGpbHI
aEbxeM3zuilLNhudIfNDZkI7bFub3/l3nurm0tmeamdGZu9T58mYYV2TZ5JsstpjuFn6YVCxmpCJ
QWRJDFXVEillVDdrOEokxKGCgMJZ0J27wrEdGG7TD+prbi/0vVD06JL6fCMKaX+3SiaLrPs8pHQd
6aX4geWdv9P68FReyv8UdXyo98LPOywGmQeBd0gVXjwdtIPwAOTG+vZ2O3En2liqQNBpat9QeBIa
dhbQkwz9fRl8C2QMt8e0HfORICYnBJp9ipEDAqYlRbsCvNhJfZs9ZotY/0/4bzNt9VZ4vHGcwfn/
hnLL4bKFG2JTEJvjYj5o3/W4Yl9NPh/RQrHNoPKyaUvfek76et1tHnRbVEi/y89fHD5/Y5gMRCjG
sUKpgiHwkZX+ou8IBtfIvXOWcczwXjVPGQt26XVwdCRurm7Nm++evcquSaC35uU1v43x/NcWqRBm
WzUO9t1iXdv5jCupTu1JQIPkID/aP+7ZVlE8i54ZzsXcM+8LdHWSVRn6qAotI0pfzTOhSwN15xbj
1zoE175sZAstw5AyrjaPs3luWmkxLWVtftiR89pL1qWq7qR1jtay8zy7tl37KaRdfJQDUzhFHWkp
KHFPglUEUp+lHGvqFe7U23CE7ZuaVDKl9p256xRwNB4eYJxMugQz9sgShrHn1k/3I4GGrbtqTG/d
qin8pwZRo2l1Y6DV8PvR9ciORXytQ7YeHYyPjwPdntZovoQqv4cqEW1WxsmOSYbdiOG9uNozBOBJ
2DOYApTJpfpQLKjnjuukQ+wZ60MNhmZ1HOsDzDxtyw8GGmSKg4SGB+qzleNkqUoLYCBUOMcBtQdH
yC4+JH/ip36y7HQqwry97eRY2GezKIK2dw9ti1YeaGVTc2uG1G5ziMp1NX6mC2Z7ZLEujIc9NwZ0
W33gu9bkgkBdhx/TqBv8DtcSu11NKPgq63phWS+HxLTgCqnEfkCd5OqiYYtHe3QqBlxFzA7Urb5/
+GAf/vvluP+3ronvUShoFAal+Zv3LMWqVhJrqzD2FTdp/sXkb1nvjxq8AFW6f7vaFvUVLnqplU8F
5oTQiaqcf0rNiP70envNfhbS9EfS3kbKI/TOQ/0j2Ll2S0Rupe1t44G62PqVnMWRZBubnoxzdADO
8REwIoqFazMdpezRT3ZTXyERmG8QAB0+IHXaAmRg909dkmemdKbMefeY2HFqPVpsJ/ur3T3tpkmw
byyMWRIKCXVDNDjrsBaRS6tPtvIWwr7zNYpzedbdrM9rjNUcE0uEDzkVR6RaiG0UTp9vG4UHHqa3
HeM4ui0aVynrMCgDPXlAejVXc/COLDYDnyudq6ULtk5B0zK4grJIyvfOSqxiIgZ4o6fPf0BTYSAu
8LqTSVGutZ0simVxqbLRJYpHkixWZeLUYcs0Hq/iMD7sfoab6wIDvCFcPwr4aSQOu0h71m2j79DX
TZpJzHPv8XE5EVdqpGm2L0UKllk73WfCHB0NNHYcGLExs2uYXH7HqUHAOPZ1MrAAiAWndLwAQ8cm
/NazI+GcaQXnR45ILOsXn4FmodJT4bnYsTx91pjXNRyz39dnhxSfQK23ViynRb896umayL5ehcNE
uUJbe2Wit5GYZRwZvMEKYD9xCRJ1mCyJMK5rV97fHj7+DrJgAHLuBuZCBcXA6HAibSZjWIxOJlbU
FOtAolvO2QK2+/46T+5QEOMK3pJpaKOtx9EUw5oUNRKTxBkVcu6gqJTY/H5Cphvy3cnNUW6t8ejI
SQFcHWgCXfNEJRV7Oy4z2KP4BU4PCsu1lRjrZHR3PRY8XF2hXllmbcrESD41TdSJ4UfqglXl9eWC
zFkmSefFOSzqZDiEhAw3q7QQO1L7TLowsNs1SNzLczf2E1Q1msNf5XddLSt4tHQsJbZXXo/IrC2T
ftg7tEVNpcMKERtUn5WyOOVoyHiHYrEj2hZPzuFUgrUH/z7HiCuh7k0VQmb0GHgJZ1i/PPz+8Adg
O6fPX3x3GJWXoGGKhzECtdo1mSonj6kQIGuvd2f/4MHDL7/6+S++/uUOv37+ix7GFH3w4KufCxbJ
6kIVfPDzr2CNf0wefJkc/GL81VdOfBMOz9uu6vWar2d+s6nQVeX1Pz9Hs/fRPsUy03HEYZNXZ0vy
ECYFZKuxL7744gtqwsHDgwfJH+vz5fLGGpCDnz/4RfJDcZPsf5UcfDl++IA8KqYY7qYp4FRvqS1i
Tu6yn2MrlnS6/23K0on4aV1W8/mC6BOHgVWxBYGqXp2XFERxTb4VEuCzUvHb0eEVg++iTxftAAwu
Abwxq6wXrcTDcFFZzFyl/5Lcy759+Q0s/Efv5nt5sodPuJ/q5tFo71t8sf8tp2mrP5WUKP82cTXi
KX1Hk4NH7672kr1383998Jdk7+jdfHysykQq+mh0L/9Pad7l1k/cuR2Fba0jda5vVhjikfGoaePx
dm8JrGZ8/74DE31nSnN1AHNF//1xc6k+7Sf/tFnA5CYHX40ffA2TDzT//L6JI0YgCsJi6NEb0Wsv
HALFLp1wjhEFDiGAt+C2i7W3mPqIOZPwioYSHaG+DdmX+x7v4pRjpUcFXZiQuSC6u0i3EGsnLTXL
jB59g+1Cqj2KL4HWddk+8W/py9SDXWCnoSlbvqPVLfcVLzSOvdHA43rKq0uPCT+mHk+Di00nwYf0
WDg9VT6/JGlm3817if4oCpWTvMGnqOmZXlYE1jq9KYtGCsE1G7RSsltl3UvQWQL+sw31yw965ZI1
Wpd1oUSKw8GjdPoNMGN3pp/xHwX8xH1eGpCE9jOLIpfKbeOEr43EgHxfsSwWN39ixAIaHSJktCmL
BDMCIaN9isFeZZfCYd5TeBf4iqFuDJwuhyotE6ySPKNbgbLg2nnJFZcn1Vm9aaNeq2iwupwXbNiL
qFdXeGcC2UdnNIcKi2tN91XyDYoWLYW4I4JIdq7y4YlPOTmL7IFBkt49SbVqb17c3J5+DukfcHpi
WCeJkwQoHfUbVvI5kPcxcAubdRkJtAfjOe6TVgRKucUK06xpKttvI5aATftD6tweYf3Mr2zoXmrf
9u01pY+dDAOTPl7Jb8d3f4B6Ho6/Og5ahTOFLTAs01SzQxkmGvCsDHCoB059g2R/QP/nSJ06/yMu
3B0nqnao4i98dl3KlEsWHZGMs8tMladj4aDXGHFKncFvVrgSguCzxsOIAGAsVg+5uH9mDH2OM5j+
+Obp8GvfR4njUekCzsq1xpLIUv6Y5p1FaENvKQXI/uPYqYRmWrjxp05r3cpUmiGm2VKniylrlRuy
pW4ac/BsrR7PIzQv+TB6+x/ELVOHj/tw/+3gQocABBbOCgZIhA2BxMmZld8/eTH958evHr/6zeuB
/P7d4R9+/+LVd697PdQTgQRKflwSvanXoxAG1QnfykqK0RTWhcDvppggJTMASohwxZFglrBRMJ7l
Qx4ShvJTMRdU2/zQC1MCVjMcgBs8b7q6ebBjEbKkn+DsOUGV8VC4alBIaFTMeUF1IzA5Tts6SKJ+
UKziCpO6/m6oq1GAjZJggHjKU4Wj3Q8s0SmRFT0DloK8VCVsuf5mYGGDxi45RlaNsfSwM3UUICeL
+TD0wr3o6BBuFqeGHRBgmOajSCeG96T+twd9nNxtQAbXw+fbYsF704TP4G0ov2Jr4MF1Hr2tCKWM
00Vw9l8h21k26xtdmLZQ79JA2c7SFBxTNEAiLdGIZFCdWA5VRpPC/s90WYT5yJYMYVHXhLRlQB/E
aMi51g2MvNSY2EvGdoG7LG5OSgkIj2I9h05nO78zf+l3QOqwoMslYRnnRYPobIvqgjmyq7Jq5ijf
VzMvn4iaqOaaI/oG0qMjXKGsMQf5BZhh+n1MjNm3AXBTrH8d+EnhJGIUZCvkcedUytZ9zVMnk6p0
aFiImlU2qzzVkntU/+1QO+1OTgWYNFDoIJnqEL50p2Y1Fbsc6Dcwk1nuP7lj1qZNW9VDBxLTwU/T
u9AklKIKc+3pDIqaHqcVVvds1Cu0/pKti/E3typ/15uV7U6kjedwbbSx7gXQpynUkaKYjx4CqJ5l
Dazlf8BlyVRD6oohVZaud4lvv9cyFDHGJYanjnFEbA5eVOcItL/hGYExoF3v2D8ysVQjZltyMoYy
EVLcGuqNvaOh1YHlJWfb0/kU8KvhLj4th+ZBfFUcJ4Ym0EAejVVJx+pMf9qgObt/qP/ePdMLdaqf
YmrgjhfkUHg65fjKJJ6fKrB0BUKkQXIahk1pFR5kiSD3qDgYbUN6pKp87lgft/R1BA0Ij1k+nC30
fZXWbp+VUPpglUkvYsclpfChJx22g1gkVRBzHR1EEYjxmtAjYqRDf+SDgocd1WHrqE88VW2o7FYn
OI8M9DugFb0ikZ9yWyxzYVttf9RxR5lju3cPFl5gxyuzn6SYKFVnEw+tq1vE3CmZtPINdrEgQET5
yRbZiia0vUhnW6U6RUFPiIjUb0dUdU4Nsx6c9UFChx27R73nwzOjnvojSSPCY+GuyoHO71i9l7Pp
DgOIkdo/Y/D+cdvg/e2GwpJ6uIPbxyPxIqMqPtImUMFJlLbFKYxGhiZVTTnbgNj0EQHTluWQNLcK
RoAEM6TyqZy30X6bjVLVIyyZ2iEtsOwGWwr23NVA5Z9snXyfccaqC1Y6a1t1t8xRQqgnGP5GH3u7
HrDVcrbYzMvgUFUHqX/47HqoNhQJJrzNgiJ00GElndEoQOW7Ge9hudqgBrIO3CV5BK+O86gJ3+/K
mw6rPfJbtK4b8HiqZ7B6uKOMVfyyvZnV4Q0XtkejKyshmi/GAgFZq0b1jV5hye4G8YfgX9r1DYXq
0WY6eICKkQSj6HUL0nwf5x2ZU/WBuRT62XGoqs+j9Yl9sJojq1xbjbR8z21veL4XJ0dwch4n7god
yBf18ixwMHL6fKlF0YgM0Si3u3CPqSPtqU5jeo19YVaiq+SmXFDI6y0wAXoweNHR8c4HpBH1bwfy
kRL737gLhu7L549QWPeLt6ypuJK9g8/jJ26RQMR523Ad9qYWnmISdl5zB8Gg7cQz7C7taxdJFGIt
wT5CtWND6FBfJhhbA3yGfKA+CFWTM12SCgQq4UAlJZBswk5fFGS6T0X2naONMNeAmMbm65X5yue7
mOCbCbIx8AsocQ0pXEN0m9wVJwjGckUAZdB8+s6+QvCEOYQX9/lKTXuiDKVZGMp5TLcvV9b6ToZr
i1GeOiNAJQ2s4R+I2x5Fa7Ug9jxNiWXgdh0zb4vqyszYasBCZByERyC1WQLFxfxCLGJ8HV07KoGz
5DSViOsK7iC+3z+xgMXsvqVAFJlpeIAwUOQeYCkGpGaMeL2FMpEPl90eqxkDINhr0vzEzBaVwkMt
P7P1Rp4wfVVqEHo8Vmkp6qJx6+JsAVnE+0Z8j2YsrZ2/gp4vE613ZrtAgnKyFWSuBltJOxq8Vq+/
Bi22poUVqO9TqFiltDpbBSnHkBYYJwR5a9dLlgd9K1s9FJ1WtlxClHx5Cx9Tbg2LbpqhqiWHPsgn
boYWvBbboSkoeH+lbtGZSyWDZDpI2CAtOgE23R/IsH4e6rNUOJG/AYrU65vluriOAUdR6+yDfM9S
F4QGEjsOMQ3sEaQ8NjMfPwiPaJjH0A657NSL0T5O+KUjYJxX87mA/MR3JrH0lQvBIjoaQnIF/hrY
Ec1sQnnldOpHTqoXH0VpHsYnuqxhPbCCUQch3LQd/s/bgO7dQxVjyHqtssxAtnLuXQJCUJOIltur
2klQCEMsMZsHJ0bI5QXtO13aR6QXwFMDoFnOFZHs6bfffpvGYwIbWuHo5INmkF1G/Kxe+Ie1GZGT
umjmz3Dmm80qZnjg5YnW2YfWB4xaP0nIMehuA9wvnhZ323fLhP5FVvh06TG+KpQum2LpWVh2iwX+
+Igy1IcT1nuQy3e4OUnus3NYXD8P5L8MpXVL8NMf9EVouZwVq3azIJhy8u88LRsB5eXAdUaQ0hCy
phhxiHOtYA5FuHOlii4xcX3iURL8WhULNLqi01UAmoQd8XoQgJCoW9r1ySBJQdRaltdrP9IriW8Z
kKcIc3Z1jmsAZe6t5JbsNyh4Jk0qC9pYYjTljCxZ4N+RtMhblBiJ0VM2Qwe2onbFMkEWC8ZHh+/C
HS7m9Lx2VUxJw5HJG9gyqIbRGbqUQGYBaFxyunRXUYJYtVlZK9El4ghZ0tQfOZTMEt1PLk+qpTYz
ZSlTjkZS5du8o4oPaTxG0CSfDxm8ZyUOggzC6uFJOdQstWVa0KKAUjaXhArmASqgUhvd1locwbWC
CeVKjBNfZASApxkF3mMs/YhbQdGilJORtzWzr9DkzZLOsZLvdk+qtcTFRBj+ELGM8Nspno4ojxV/
el93L4/rTpX/Bq4JDySRWbNrizQF38WoppMFzDKFQEGm/3Vj5WJs4jy4JCMzd2vJ2bltgwtVEpmk
LNZ1mkdBMzGLSiroBVbheUf9ssqsqq+1/mkia7Ajqy0VOfnjUg+WZz1uCZ1o6Pe10Rvlt4E1A8eG
oLmaGgAjaFXBatB2AydLpsvnEy0f2ZkxW4fLFvHr6xvEhFlU8Lyf+52QWtjWlA4jKBFeBo0nbaWm
xexPIJRvOVkUlyfzIrkeCyKG5jvzTyFIBFsF52hRLQlNuBUUJG/HAztDZt06EgHtPmR/jZ5UaZwH
dlUYLtndBlI1x5lUUWYtvliHoyVwYxNgo4DOzT2kIEpnTRTxelwCDEpAThXCDNEv7ifRMbeYZzQM
fA+KyhYeVqcsishiBhw1NR/LfNu1hFmtMo+KU8pdIX/WFO25BXEVnUqySUXlBzfAItqsMqbJWZTF
vOcNlRHUiT7rfKNOalghNSSxMBsCMzdcKMGGnnxXPKWxxhRH1XFM98PqXTN2nfvbVXlb2xnt7m2V
HF0c1UuMJX69ZdBoSWEadSoQAbrvTDsunaY0ZbrIyE11hudvSY59cJADB9pUhLeiAvwsa5OXLyUa
a806gImC9C/xtvVwD8x1Q7mE7dQU64BRFuuguWOsQXfdyI2V5ZyxjSiUBJsCeFnZqohmFeFJCujJ
GQzGJR6ZcjepHWTI6kgUOKvKK4g3yVm5pHa2rvkgrcLz4iNJtef36fYrKT9sCgoe5BSEFlLYcPIc
Kdt1RMXC6ybQslfzLPiC5jEyjnJKubWRfgqkBLHjErRlNW0FXntAnS4jicc6qWTaci1khCn90XGg
4lyEa/rU7UHwHeRrNFQIzRjsxUEmd5gSDcrHXV7xpyN1xXk6kpvsKY16t/4Grz6k+9RJacT0YAI/
Pj3bg4lqad4RXs4GK3HHWd0W2pNqLt1jurye6h97RJO/VNrZI+QvOtsdD2yWfot2vjiUqRYeDxUh
RZexuHFt62GL6H2hJUgzy+QDxkAwH6uzQjPUHoFWBGRKkv8aRCRUMqSdQuNmpUUW1m/78kpFV9Rx
fSl+8PFR/JXu3zRIaFHNC0EZRwfHg+QxXS/CcJGmJLIoLA29hjaVvAIh62pAt7QhvuKsClpd+Pby
sC/qYUQCU4vsUpbKZWnasbjF1dWeIrf/48TzyELDbWnc2go/eGfsHdq09jzXJ/IPxWy2V0iQM0BA
pMxMkjn3wZbceLTopejVfyL5H2zJT41cBkZY+NpWiuEzRqGBV5a6MyxNczuZupYKOdtYGFFKYO6y
DEsmPck/4TLYIQDouLw+AdZowjfCgvWo+jdIFNdk2uHiZs7QHlTt2uaGLt+3WZi4A8LRv+gezGV5
iRFOVYGpaI3LVimNmQf3VkoESpOv/txFPGAbVjIhJeNrqwzRAASBk60VVYpBSqEq1RqIrK0jG0Y5
0JqJYFxXdqnAQGclMGdLJwSIA0suMDdRTwkzXQNrY1i3KIrSSiwThiLzvuIfFYLI9W+S8Q+uKyiH
RVg8wpHHIqjqqo70mrJzBJhq+NpaaU1jUWfBD7qe3X5L4a4PQ0+Ql4ZvMYnHq4jHlKuz9hk6fMBa
ILHH32yyLxR5UNtEbxD3ftmWPcw+G7kylQsGotVnEfbSs5rv4Celr6+gC6gW/16QhTO7dFSCS9td
Wc8ylEN/SuZCeNvjrfjNopyw+Y3LlhQnLekeJeH6hCXKCe9olNDRSGsb+cATMCfrMW8fKo2ke6Hr
KuxMU8fsBiq2E2h47Amibj7s0DjBDv2Z5u/Py/rPqM78aPE5nMolHNK/MQripUaXy1hUC26JCGiE
FoandgD+vaX1yiM74arN+Cl9hHQOy6nOEKCoG6hHLKCAMnBhafQiDReHyy/iG336PKesIeom0N12
PbdWsk+6sm7ug0hZ92feiluyqzqBpzC6tTBDrpG+nW2cW2N/eokE6ykreMv5ITM6mbXezU+16Onf
+JqXv9aqVz+sla9+hC4gl4jYCud6qZrhooh33A3GKcuR7c3P8ltABphmcItt+oFX2QOXqoWAHLhL
UYay27dZVkid/qtpo7RH2qmcE/zZDuQjITqsb9C2T2LwpOxWnipPedqZv2ElAyJ26G14hzUg/kUb
e00u6qvpZdFcUGTi/iPOgWVbbw+7HRluoch6RQo80Y5EmO9wDZGZWPX4HsVsXekSROFUhWJNdL2e
d4RUj/yO/PScjbnxaAHBv7zPyuyF9FPOYY0atKW6MxPbh7ETNI4iJeM8clJ2z6HbSc9eJ/TnVBfd
ETtE4na4uuFB/te/847aJ7gNws3UZau8rfKwAV2NsDbWvr/TvoT9yKOQJ0MWKLQFQO5xVLSNHXOx
wMZYmbLwjnety/T853HbqviFrzHV4umbl7JW8rh5jR05TVnra6P8qLWwZ9fvuRxMLQN9v7vKMlLt
hjimfghrCV+Y+YMfLCxXS4dVtCziY0jqqnTbBp4LFM5ddUeVn+d5FwuB5PAx1uUFqsSA9M5cK7NM
JONT0nhPhsyCahXQILlVxDxVRJyoL5HMebJZqWkmGWgUFbGOjrtN8hJSKKt2oWu82dgjlqs6VpXv
AIXGKSGSqZQ7sfYPKmTNl2+S/XFXrj27NZYCYQXnyxSOrNPqmkJa4kA5XQylOx4eBcNlF7CX2L09
MtUfK+PbbQYNpzJ+dEdtlzO2CgrX4LbmhBCrbmraN9Zhukcj0N/SkXy3Jpscewfjn9Ro0trNlBIw
Tp7kNJoAIVVTRuNrGFh1tHnTb5oiUVWV1eVUsUVS90DqmPCfAW2aYiF20AEVpDLdbewqgvxivzQl
+vs2tvVUf/vwf/fk0Tqoz8RIvSkd1Y3NjmF4S3NcqTqkWR3ieBRDmDm6uYWpbvNhe9I4xITvxVaN
1L1lh1kVxBa0XD3K6EVuZ+z2eSMVny06cCyfhIFIwZEzx5KXo8DL3rFzUd7QW+TWGVKQ73tEKEV4
wBmiinwBM/urfpg3hkWsIOaxIEwTjoDSBIudJyaOIqErRNd0OhX3wHY6TeN6cGeG+nYGqOgb9fSo
H0PNbjvU+HeSN+ccwEUZDM3IPgAv8U9KNvxhOEHfAMqUQKpdjEgg8sVArjGhXFI3CaLLCA9dGLGO
UuZVe7apSC4gqvOxZIRgYoBRtzKKy9cgYArQjMcCeDpHHwiXTibJjCETf7GvLIAsRdsWwf7OVhxN
NJQbsLsiRg8BYS3fZVLvDg/2cbUScKhYYupGdvRl2+TqCxFy7VLFv3tHOnUqvqtUjbTR/VkUKiu6
/pU/MmLY6LK4nChpFwkcBRZsOtmx73nz+2EpiDBoiXRqB6BlJYrDh8U4cn0e2Vy8Z9x0i6vDT2ea
wkm6Y0SFwN3AuLsMLIOdfXSQ+SNZpHZX6WgchuQT012PcYnpIKBKaOYiLDfFUGsXHzgldGsJPJIx
4h459jWk7J6h1IOS3FtKq0YED8FdVyIMz7U6tCxOxfFO0fKp4kaUDBBw/xYnwQc1/buNwQkxvkIO
l9wMJNId9JAswZEICHStA6TTTdNNCYqB41tXZjH0BaELK6zU93qzIP4gOSEaXVbu46WXCwxTRIS3
Q1tvL0XU2UvbvIGibS8FBRNiz9k4ZuRh8lqzLnyE1O+ZOviKZEbxxeka6DU0sIoe2J0VpVWMUx7/
BAb3y5CbDdpmG+SLyMlNMWK/nrZogG4b/F20VDuobJYhyFM+OkHcyHJBdYWLQ7Q4L15v9yOJGfQS
YP4Kj2M5nrn4POa1Tut1uYqhvHcdH64g4HirmOtsvVmCC3rFgeobFG/4TBnWJQNbJ9rza9vXRXzk
tDzg3C2+2iwRYjFm74GomEDnq8vNpWV2NYc5OKe5QPs1As3E8VSlM3cUmxyveaYrnmWgFZ1KID2j
WnJ1v+ScK7AxmkLcYpz+s4cVE9nQbs/c9ntmkmLskXFL5LzKbdoXxPxQZ4aj6I9yG4rPoDUTmGdW
hn3TxQX0XgZz4g1vzG7HDEz/iy++ADpgJnRdztZ0oY8kXASYf0gorg8kyPu3hBa0KIsx1ZAuDEzN
+tZIn9k+O2bf9sR2Eyayd0NkaNU6zJ1MdN1lbUHvGqx360WgU/PAlGmclMj/olhg1vFt91QmVJZ1
T+QyjRF4ym8UOqVTjEb93KxPHdRPpcPd6VbqTvL0D880KjgGblUmG6sbtPMcXs8xsBwCnTTkzaSv
obVGomfj4Zl4baZXNRP8qh69gTXx7IXt/XplfeOB/D1x9WiEXU6q2rcSqteSLFuHAHJQyhkhiGyA
FdWe8rubDN1tjdlEsU7u7l8b9AjtB0AWrcouXBZBuG7sZZF3ItV2ri7vPspf/85zmFStev3bu7gq
5daOKKhuWzGfyxcr8OFAxdRBhfhq0h/2g7syKU1r0MNs9u2HNYNiTXW1tbddU26C8tk1aTQc1Srv
RL3C+J4ZxfgMGWD4SlKtFJjbs2voW2RmWQ4skbHpT5PuG0tFzqPkMTYK5qiznnoecoKh7/r3tovK
HWeCbdBVAxjTk0zFTcAHKq91Du0QZud2u3m7pyEjwjy3EdRInIvYXcnc9fvhgXrTtYbUWaq4Q78x
iNITYWBhmKfBIS95jqq9jgiFsX4gD/Eupg/xU7N4SuyHqf72UXHWPC4WWah5LwJJImtnHN0Tbpr4
1hA7GeddN+1bn/i3Sc5i7bPBTn/bpjjSMo1Urco87t4jYpFuyLaVPbK1g+Z8YneUCkQ+77r7YNhJ
uwXrmS0aTWF5HjQ/1nDm5nYgSpakqi5f+UmZ/ESk1Y5OcheDCbOMHezHMKE2uTAPkdK4OWg5YRr2
VyB4+jbA23QRRGurGdtIi3OvpscpJiHNZfBsW9P+IV7i5Z2Ujo+Ok3oxF5MWKGYC/3Nz3OkijMz0
RAIWmgnq6rl83nYy39bt3bu8e3ftLsSuc+7YlFBvj0HSZ0VxR73+uHlVdA2CM568VMZRXP6ONXFr
9R3r7zYJRPG6CAfB/yPNff/dMiQ0t8LJeGOxe3ppvEPJHH3fbuyzbcNrtIEecVJ6SKX66cDo88yG
OVKN1n3Kr92ZJw16j0e2VCIRWnB/lAVC+Lo2m3cEGbFYWilBmGI3PQSMSco5Btxtkw3aMRHquEFd
b890gB1prF5q2IH2TOITw0y7jtGxsMFcGvx7NLacRPWipEh0Y9En61F2gEUGmNs9q+RCZre53Xqa
ftJZugs9sqmMuyqVTc9urSbLH6/RcvTRkfeJZ1FIhfmy5ZQCvXgKdyMRaUOojkKIi8U2wUR6d4Md
d5xKkwo88R790u3AFw8wMMwVIX5dVfNYeBHLzIdydTsd2jPBFXTfcso4QF8+4YJ6t2aY8vdgmAZk
TROpZntVfkO9Ara35JaBsA8I+A/ORXVfLzahgvs4O9fX+lmhfHbkCBVnTNsujmx/N2v1iciX6+qT
6HrWtcCXp61+aQzOCJxNMo63Bw/Q6Xq2N6/VJdun1/M8Sl0HX+2easEj61I8J8cYlHJHWkIikxfe
J9VZGbHxTn2QxJ/SeMmyvdVq2szFsrzh9bBZft6KYF+unRYFTbCg2u+6KHYaf2soj/w1cExhv/LO
qdg+VE7JamZUkT3lCiRBb+qTP5IH4EzbjdnDxCGsjI+9ZVutjFnMYDjXYwbWGlWNtcaTuyVoDaS3
PHKpcWl1OcXKUrbT3ZoU01FtOyXeOaXqgZ+Wfe1mhK2NqgwLHYczulF+0lAd5CaHeqAsqCfX5YkN
iUSXGlUtneWZa7Gs/rvmlltzO1JFmklmU77Ykagac31ry71Zvo5Me6/3Yf/t//izn/1sypr3Ebqc
s7nSh4O3/wW+4BKTu4GEb3vJK13YvXZA92VscSVGTrzeaMEFgbi4FvVUo2/PTSvHBn2aFnOJcJ8R
vKhieygwp4oF2aDGnd5k6bw82Zxx3XIdQR9Gppx0OJQOwMrgSGiTfgssbUl4CJ4bHfZu0p9X7WpR
3EijCOxCDQL5snP77ZuHvl251Yv+8BxP8uEQC+7HGwDMWbue9DlFpDXkT2cPOzXCGXBqS1cb0uHK
6jqTe13rarE5g4VLz4yDgxr6QKxCQBA0Z+9TxK7gMze0LJrFzXBRF3OFPEeFJ9klRvMeEjYYSM+j
pB9dqP03dVJ8rCuMe1TMBalL2jfQkLTvl/X4fcI2vwNCDusqDlPO6xlO4Xt3gpzVQWp/WUKwqeTF
UL3xy+6YQRo7cQqKjw4Vi9PWVnON20zxfZantPlWNxykHNo66GosrfedG4UTTDl2bCJlN+Cgam9T
EY4RMExqypuDvo0W9Vk6Iq7wV4qS1PUFRk7P8IeElRPfXGu7zy7nZJLEEbVls4MkOqsJAIBgAnsM
pIazgQcnfyRLFA4GYp/BmGjEozWilo17nq1F3bIViBiPZH2vG5agSu9O5byGTSMWQelVGkmjdKdC
J1p1l3kXlu7qhv6Ey7TP0IxD1IrMruYT/EseYviDsTM9r3sa2+lUXddOB8TYWs9O+v5INCyXxQoN
UQbBXW/uaVxgeNA3+mqOdnUynlPEOCIp0/RbPtGaHjV1vUZWk40jM29MTKbNcl5P1aKaqDJ4h18W
S6BszahcopmsSmXHYUYrZpinplFDjX8INtHMoLNI17VCIE1cLQyzpRgBQVfjo1yqHswWdVt6htOx
lmBQutvbsV1ZZWoN7wm3jXcIgmIPdBZMGhCU6WxRFks4QJ1hyHuxvXlZwALirDJMwVaTFTXeElRP
L13s4HS6bV7fiGWAnL7q5MUtxCevMheIjWoW3SPWyuXlZmBl+FkSk0WI9NXmIE2mbs+brjTRTlKm
vcTVjDlefuUiGGYk0mN/Nqcw1YoXsFcqcg2YIeiOylcuW8gxBW48kls3hVaEX9ZYoufSZDRdWxlJ
NL/JUqV5UnmEhJIthno3mq6ves5NlGqqsH0wDPJLvN6pTbkqipUTsSelhk/6kz4hAdNhQqS95Rhx
ShWvVRxHvI6OEVN3yOPfKhg0vA71qLkcIyADVH9e19f0F4qG43t2yjWN+37Ler4XhtddVPNRqLex
AwnFOJI2vxbJh9b6nsMGCkIIuRPHdWLEoD4Dxlg3oCDRiNIuu9vmxuSecuSO2TW7wd0dPviyVWpa
yM0SQ96L6ZiOxrYK71jF9lYjlPxjxzzCNHrThei1JTDGH4tqQRgW7EbUUjPHSIuIlgyH8v7W/MBd
wg4owwLUB78EQi/AmKOzupmrwKXQ/+q0QnqFVK9upvOKAoQrfHd89BaSsnBVWXOvIrxU0DsGXaHV
sYwr6apoEO2GvxNIo5OSQgekkqhlTdA4VLVLgmRMKkinTKXo57swg7UiV3uIu8bc7FTtGRAnKEUm
DKOQBKw9VRGxRE7gAJEwbsj/p8CZHGtVSCeVlptn1+rfofFR2oQ1S0umcwoOq5HMOsi96+NCe3td
1wvEKDqDAkq8XpSujfvuzSS/Rheadr3tpOArZqXWULlSdWamfEcuH/KAQViLa9/dFhhKMibjizas
drRqalQOTXnz0isZTbIT3+Lr2We/Tm2hFPq/WUwDrxIgzAUcdlvnKM6vM/yx/doSz7omg+6wxobj
hl8gsg+p+7cyBy7/bKOUwMtPZBMkxxYrekkhtQRjsENnUdT7WMaWGiP1blvwBKImR3LMrE32oUL9
7dSEhUszZoSNPCAl1FzfDr4fKti6WuVb1yWdNvv6VpA7oXzMnDX64cHb/8HSc7HkCOLeh4dv/4//
wGoueIJTY3YO6Yd0ktI5QFS/5ainKvqkJwkX0E3gkXuEw0X8e48CwQXqr/on6br6iocSol4R4khf
d0XNnhDeboWHzsHqDn4c8rOjSLD0PFr/gyy9pU0gJ46eq0UgSRsXlRrNBqiBAEvR+EFVpCywhQ3N
g3ospurcxNsp+otgvqya8iPSPxTUGTJe5YRJahdoRYhBXYCNIetiTepNOl87zPXBEFHuarnaONEQ
4OgWmEKlUpA3ma9i0FXkue/HopJWLWTOpABvL0Ea9ImBj61OYcH3OBoKXRWpKQbJQQ5DQ7zZyYZM
KOeBGGAP8Sv6/X19pjsv5QfSg0tc1BGYBYW6s2zLGp3zrM4/Pf5Te8EaYdeePPtOQ16NpOmBCD8v
F2Hnt/dvs9Q99HtGMMfVbEozjVRTejQ7R/D0CRFSIr70QppxJsqoI3qJeFqGVT9VIDz626kB48Gf
5EXI8Ws09ZYIjZzFwU1Ylle6xCXB6rvQPrgQTZKJVB9Qfq44JNdnvNKZIqfjNLyziDR5+wngFjlK
tyFfuGnve9XrqikWkh4R3rXLIMyOeLKj+wPqN7OjNFaZufULGuBuTTPsanztY0nBRp6xakqbf6gN
6KBjRaw+/A069kNZi76Uf3gmLZpoqF9EP4E+AJW+8eiFbgCJ5FPI4fgv474WmyiQpMuGIwKjbXBj
rFa8+1Bysp6iSY9iUe28qsSczUAndpPjFn+qNoaZoAPf1+hFape62cgvUpPuOHZZ1M7GqB4O4Fu7
rHpiETWVM8XlV80DCGMCAJVccUHdlCkS2WkEq8ufq1tmyfRVsfFo7QV/oQSuxem4azUkzSBYWcSf
wAvMvgS1pC8cRHC8zRS0KbWbkhBgvDYYuUIF/kYxdtPKME6kORbxpnAsUJqNXExc9pwRKq5TX+Ti
IRBrPWmxGRhDeuxS3naXkqZuni1jYOWyzKrsXKcUCfQntFi+thcVUKhPKujowXEeUA29DdQyvm0d
zerFAsjYrWtIIkp2jdT2EbFmvv+0H3Gw3m3Auk8kgfZ2B7OzCa+3NoHsGOcisSReY0Kz288ZdHV/
R2HojH+jR5xspy1FnSQVRQuSrwGFCgkaJwRRRGSDgKJ1UzMprD+7mo95RDwv7e1kTS7kvkgHyi1Y
MEY+fPn2fwJxD2X7VVNj8LXRRbVY4O8PX7393/6bn/0sIpyJNYJ4RIJMt0Yxj8zyr6rlwwfkOqON
TlrkTPHERykqzRnwdS2EwTGzkQpmqElsbQObZ/TBs67BiZzX2NpsVc3DY0z1Z3Y5L6/LGYiFRXuB
yZP7T5P7L599l9ydozAMmRUuiruqt1bw8tWLJ4evX0/fHL764dnzx28OYXYOXJsEQtNBzoL6M4Kh
mS8WowtYcuXi4YPRC2CFXnIbs877rqAaidIzSLBJrmIrXo3Yxq5LVRe3i8LP7JL/CUoFv6U8kjXv
mXHqHKOaFxKNbnLwlQgBXkLUJtCMyFwh8lA1N0ZYVsm9Dz9/+/eWYgKo37o8qZYffvH2v/wd6yXa
zcllxQCoBKLZuDoJ76axSFQR6D77sZpJeN+oBQ6ud/kJYsrqlIz2/soqik6jlKFqaDow6gUMG2+p
HUQdkZI6ItU2K5KxUw8xO6+h4+3kKOXzArcocCXpsa+qaDGeLKf5M1qIkb4PRvGEqhgty3U4nKi5
CKwcYMOjL2LEwiEu8AaaP10NkhvkoGxchy03bLdcsImPNAUh8ianbLS+r1XYuwM8ic9Rf3JVEn7P
vE4QUfsfHR9N8tpeAiVAsUeF5kIALhUHDAnThkIioXbMaF/sINGYi50PbK/vAbsqXBcwqKVrw9eN
4mfuv3gMRbhRSxpoBa7xorl5SmFgrvY8ObFezOlkIfgHvIXkgyYIfLkuyylfTALxv3fv4sozvffL
c5JF+IWw1XLvSfCynoLfbhl1Ttqym4LFUt4avYpdc+q4khAOoFouovlnxOV5CRJESfJSb2tP2rK8
yPbtA5zolaPLc3OgmjC0VnDTbFPm2AltD5flHP1gGrZMt6JZBfvhr7bjsFUyX9MpXsVOp0cpzZYV
rvgOS9RA3y8vCwsWfy02AlO56QTG6jWQKR8WGy3hscPJa6ZLfZtF44HYNBT+CMYVSluWVzxCmZmJ
PKyUbwAtokdpUTs8tqxpdPlyAAZ1qDVjTkT6+4TSYWQSSMrlCBGwKK4itMzYjlVRY0mvnvkrC5Lw
ETsrAe0o3dxNqK3B+bhryl4H+kXyTZI9REwxz4EAykc7UMkPT6hwHeAPBsWIcFpWPljcHzZ4bLv5
o0npVLUSSvl8s1k0BV3y/KvOmpKF9Fh315xx6QIIcQOfUrYze5h2wX3AofOQ4cQkqWVimJbXq6q5
wWIOrmBTyycOUcdLLD1fr1ft+P59M4up0uuu6mWLBEt6nMFfOLaLdTHRXcu4V3luk4BLEuSBjBTN
7Dxr0vOmPJ307zfF1f3s3dVe3qfrUC5eK4QvA+P29G57H2/m799tU9Q0UfWXI+ZXDqIMssp5Usx1
DRhsZk8/OTRX0YGpbOTMJwyKBPOEKk7PUsyR0sfNM+rgDlDBwvxK329wT1MuvzBVieKGiACKSYCt
rfKa8BOpEAfQI3iMoGjLGkHalO8A48UeglCIFpg93A4bFGF4cGz7fcbAvbocHNz6kJAj7iDz33iz
TTSyKVe+dxQkdmd3JHRRLxGx2OuY7YHEa6pqL4qNyOvbHL/J4f9qpAqwQGl6EVUGQ8Z7ovj2QyPg
Ruzz4m6bDIeP5BoWhm3gnBEg5XxNbgbKCWukHXI+/PLt//V3Whq35BEQzHu/Zo1t4JZzu+9Or0e4
O+hYg8FaGYKBGeG2BCbzqmJoWAEfAvlM63hIe8Jx9zh71SL40Erubqc64MpqUSwlWIb5bc47C5KW
giNZiZiUP8dvi8UNwdSWlyclhrLFc5ENJbDdZTsrViVImkDAyo8lxfVsMKYunzZroIlWFCY4BN8t
/3UA//yFWLV3y38bJckbHYJ7fVVTqdjDpQqbO6uxXKgQT0yrjagNgcI1S48FFmq/OAn1LZRw7W2S
jT5WbbWePoGeoR0xP+ndlgGh53YR0hlFSTWlkGCA76w6JAwoWVTBUJI7AdSkcCTICQDzsXTNzhtk
uF6dnrZulEQ4P6bKEsWeOJSr0zREqr4jk2AmBmWQ05p9GXDlwIjzeP+ba+aia4ID9lh3b8Ghc9Un
564OnTOdmIL/SvG6vZd/ib38N5+AOqYSi213aNwQIJfodpq+g56jv23PupdV3s9HY9GqQ82ECaWi
C9LzjKyP1CvnfibeVQ+JAXsb4hVIydi+eCiOFIc+sYIndutxKTlHiEo9hFc8PdRg6Xt0TwKz24Jj
dRD9qorZ98k3lqivKpM9HOUU2n2P43dgbgxiggj6AleOI+bp84Mx+4s/ZorARxJGuuxeZjrdCD9x
F44oBY4BDYJq6JYF1tWkf0u3DxGMjRmaYEzsk4xTTNSUKAYOljJfssp0auw097DIoudM99XrPU/s
j2YfRTPZ6z/0kY+HmyF4BUZaWFNMECQoUbBS61ycwlEag2bcPeSMVW//m6OTpr4Auqzg7I4TsTDc
v6bYlnFNr7TVw7FTPdga0cLyJn6KMVUylFqIDaOng0A5Ehs5BXh9ygWhobEXbSgKnR1XMm2tKsTr
jkQrMjAVrgt03hGblu8IEGKzgz8Nag2wQXfDCzCtNnGWTKAeg2oYX3J0zTQ6fP7i8PmbLZMQbZul
TSxgbjg6ejLfNGzCxbxYU3IgwoFSNcbKsaIy4hy2qMCqYeU2m+Wj/qgXneyti96qXcNnnyok8ylK
A5HJ6zh37K3EoQlwjSEWKnLzpS1RPepHsaO7QTVsvI9M1TTI9T2Wo9t45Og2Aop1Wc83aKeJDVWc
tbBNZjSm9QKBlPr4x58iaqxlRI/GzzcP+9bNigPGMJrqnYClab9aKRJj2HoVx3sFPX8wSH5OfFFm
X945SE9/hIb1FQxzVztQL3VLO6zeWG/dJUNt7X0Ya7GHLjUpftZmXS0+/OPb/5bNTnskJ/DAkwqn
QEQD4nCRvS/mQ4wFwWHmsWELoiXMeY96vccgOzzBby0hJTLXBlSnbnD+5hyNnn6qqAWowKXLU/gE
q+SyXJ/Xc9btkoOu51hMW44RSteViUHO7SGyztauHHK3utSKK/oNA3eGDjaXGv/u10VbzajFt5o4
XRbXIsxPDh587Vs4ma+IGqQfPCAm2P6I/EgRXNaZlWdo5bn/tXfPTDpbL84desw1AbiuTj3i77GY
a9IdHO9AyWQKOILvFjLqdLXxc0cCtlFu6iSKI+36qkTQzCzWHSpfRUEw9ejlYFWDTAJMdBBQKDj6
UM/t98A7IH5X3kROLzTo4Eq6WBQ7BJJazFYT1ZLe0jgHLtNMBi37nRrpFtC1n7y52Jhq1Hz5c85A
mqSdsec7mEVvrXGIzM2S4yiqdYykLeFsCedz468h7KneJiY6NEVzcSxwTLpHE3+HBUE/PuL+cFyd
qFNpK21wJ1v8Eo4kmAEn4Q3RyZPg0WHGUANL8V6jErP8OKwmFuhIgcBbXRy65CGOdP7IjwqnVRSm
A9pX4mjcFWZNwVQnP7xJ2mq9Ec9/grplai5QtydlctbFwFFzbdLt71JNX3Ftzup2/XiGpgdMaQ3R
tSwUHnPaN0Cc73PiIfAmHH81dtwYJgqbzmOAzluFwv5qSWG2oeiA3L9VA+fajKK+O72CIR8WVGXZ
DuvTYTHkIu7RqTFc10PaYkMoY2jtE/wP1Ub0SpY+VgOUFw0iNrNzaZZoz3CVWoZaErWc+2YdBXjO
AluHDAgwjptVCbze3A7w/PT/pe7dmtu4snTBmvMwEYMzceZlXs5bNjQaIGUwZcnVXT1o01UuWa7W
dFlWWPIp1WEzQJBIktkCkTASEMmqqKf5N/Pj5jfMuu699iVByNXdJ7qi2yIy9y33Ze11/RZiCQdz
UVwu67vmvFk223u4vDcITTFntRXfaj5wQpdWRoNS05w+M9RLPeIL0+nb4Egh4gWFUcDnMUcsswIF
LdL6AcSR2CD22sLa5oDAXMJzqTG2idMX2fJCw/5A81wvXsiOYUxYaAwPLPAs2J+Xt/OlH7r/JQsT
TCqvanLxaX4y3iKhpxhvTyXerg0MlNC//RSypjx3t0utz5KG8he5H4mODY4AbKjtvWbyUg3EFUzD
nsP5jsWiCzpEO9QoItHnB37f4l7Cvde26HMQbqgHGSr63WG02QJ+f15ZiyedgrEfJMMsll6p4Zsq
E7ZM2mS2TH4cyhaFd27KVThUa+AR0CxZL2JP74RSlmnSX3fhh+/t/fxp56v/FPHn0EyaM+LOFar7
wmnrG47ZN590fGiaiGhhj/H+PuQIhS34ifFLEJ2c7T7KsXX8hRykn74MPOB28A34x0/H7/+f/8oe
cIumIzPFPXuV71YrAQfqtoujZXOOrj3FUCsOBUCb3MWZGSLhZDa73GHkNoi3igF43rVLuK9m/Nu5
wrksB8YslXegQyvVwCUcX3WXNdFpCTKXftW1jwHqfCdUfJYtSz7GZGvl0t9BoZe4RpjrPHTRW9+L
kzVlTkJeZCwP2o3mU/BIZI/QDajQqYJ7qV55UA3CtuoIXW2Oboe85WCemy0mHem2L+Zd/euMg+ul
pBzUOgyVhoI4C7bdiV+d00pbKntDAoQtd+ktsqbuR8U9Gn+6FmMaRsh80FfDYK0S+EfoVzuUAFE0
Ca62x26W/D0VFJaleIFvZKir1uCKo/YHRyEJS3EPCDbAzXwlvkLywESXZ5lDuOwXNQyB+YgteStd
XAMxgYGiCx6pgHZr2goJlHncmjufFKMen82LpYu0QAA4s4Qu7m5Jrs0zXbEZbkaKPo/lQTPN8BGx
Xzx1b+P5qF14+uOa5jQX+8J1+rOJ0xcZryUQuReIuhD3gi++gRe9Hbmae/pCvdpicYnm9uZPZLXn
OmV0TdpdoxeljtSrD3i3xcvBfj96HOW0Y2O/bzGC/oBlw9EHHz+cUaTMbDacFJns41HkjWQuIS+v
auY3MHm7kSfS5RwPCdz0cq/oaCP155IGjOfCjd6slCi4fGZCPoR6yL6j12XwbZfALC66FhVUjBcV
BhBa4BTuG5vVdXiNUBJjna9oCu7MftEiueQseNRCqMm7AOryLjZChCR9LPUnBa0LT0FYhQDOHGn9
Vpj/kE7RjolQh6KZofjGeFOEpaJNwPFd2XkYwUscUXJsVHEjdfdaSnbEe/sLgHx9httbDKJdVFvM
6+Ru+mGuI+lst7VJ4rXrvzmGF+4eqWTAedG7Z4rNVwbzPPBJtqIaslX1t+wpzSPm0nzspb7M1mI7
F/POHQceAM4+L0O4E0XwCPZh2I6AoIfVjMdvXHpEY5ux6neU459d4coWHbuh9HaD5EdcHYfZhuUl
kprlUrF0LKFUKhtP3b7v0TqHfVJU2n6VXz0UYHELmDDXi5BnwUA1IyXAVRGmlNvMb9OscuiOjGiI
xbpFKahJ0qyjDQe4AD4oBR0Ud/Wfo37QMNSuAxuP5R5S5Lz7NQoGtEdr6lpU+2uUnC7TiLBr7+7X
OU+6rMG014q6DBNPqrOVDGH8JNd/UB9heEHgHn8OW/H19+9eTotXK3Lk2jZoknJfQ1D7FPQgxsVh
ry5yaFyKOCfP8n5KAI35MQilQBuhS6azLBGqkb6sD91XpnFsqvvJn6DMet7Czn2FNqbNbr3tw/tN
TPz7zPzJeF/+8MP3P0yBFf6wQv6oZ/L2TNYmmFeYp8cb9BAwG3P/VHidfPi5hzszFNkZzOWp3L/X
YxosrvwBqvrMn6+T01KdV9wWtZnuXpp4TE+8smSC+zMkJd720uS37JT6r9CobfUtcPJpk/W8c7de
9ggb2XUspQf5hcEifQvDo6xB2MVSsDaB7CvDGuEQ6fou91SunPtaAACRnQvkVeDvGYtq0cLdrSlp
6cOzrdN0PBweMFN3dOI4KJmmq2++7vbt5E/6lB9XtXzM2x0p4HvWOfwA7mLn6nZcl0zeWDrcPdmG
ey/ObtuuP+WiFR5wP2clHl/K04VGtoczKUesXrW/3mEJmDWJcuh7Ob85X8yLuyly0ncVOTdVl7Or
ZXuOiZ7IQd5L4qMygrWXprM3eJVN5ZwPXST/4DR2UVEgULEkIfyoX5qQ27QPLDMJnvl1zDqHXBwh
4syyCcex3cpT5aAkOSR+foDbF4WEYUO8B36O4z/vuEd5NuxTMa51FtebdttetEuLEnTQ7LEztw5y
lBeiKKjDCFz+o2JR7MS1wBrJSiIbTGiaEDpVKBckbslDZwMw0bb1xQd39GbOUtbNaIgzjXIYhwjM
sBYU1utPE5tPOJaXfmPotv15HsX58p5Zowzx3+abjt5m0nlqy3kMAiObWIY6pKIHeHlJT/0Yq2YT
zgRvFf8Zu/GVh4xrrNXNlOn0HHA6oqWNJ9/Pu7aZz7BmZ938neXkeuSCnzUaAyae7kgmu7SpBoH4
/0ClaBSZkDBuRWIdD93uC9gBxw5htUFEgVWdVWWTFvBP7bquyIHsEhMFKGoEKiNeuT588ZAMNEyi
pNKrH2zkV9TEOCYwE19emEsYp3Kyz8rBT1+9/5/Ji43MMr9+f/OffvGLR8WbP777x+9fz77+4Xcv
vv/uze9fvns5+/6fyBWMC05JUUi0S43amFKg7sjBgGz3nLKH/cdmM0qB4uBiRwg7LqGGox8RclZS
L/ETASfXn0iAETHX/saF0d8G4XNEsLINmssIDnNGyB0zgjmHt1OOEgKijU4M86K72DSwhzHd0L0G
RxZHmqp8JJaI2xrviKsrDtFhQb0Y4h4aoj/dgnLbYwv4loNHvHXHRgeKeclbKt/ewyrfvLxrnK6U
8NiRrXvEEZu3NUf1iBVnEFqSBAhMmmfuA1uYFH5SJ8gY1ahEddk2ZH55+nR2J4XO66AMenGxjX6a
B4OozXHJhg64xnfLuYPLr54w7O8a93zXEi6DfGlZ3LabD3AR//Sb9/9Z3CjFK/Wnr9/f/9cgbGzg
qB0CQW46Svapfw6EEqFW2FAiYielCJCen3Y13MKhx1X6ujj6Sishg7JBqaSgICpxS2nZzUQreL3s
D2wqmSfVbYd5fRc3RWYZHVEKuuo8Ebh0ZcuOE+jJbOPAcCITkmmbNqOj5OPhfHNF7lS4pG6SyuJm
R1ZFPDjSbopv70al3+8nd+AJVqaYs3gHfER0eUBbOfUfPCZ160+51KZ4IFiTzh5yP5VJFzCGNLNp
5P8RVkKU+FyFxqfwln7T5OBZ17OmOIqDjtTvTZuEoZ80p3k2wn5mk0kITJ+BjWUW/i0Iaa+2krUm
nhuYs6vt9ewaYfUemiLz0f7EzlfoIwH/3XNO4e2YNsJ5AHaIVqA7ccKjdwn3lwuC4fEESgF5xjYm
M7QlKiThv/uGtlz+vKGR0Nc7vNDcZcfsh9ex4f5Y/ugZpBDN2cUN6lPwv48oolKdzPAJXHYf6nsg
uAsM2zHiOTXsvg9vhrWw5FBe/pKjemxdiKBh6TCI/IDPJrfJPuMRAuPcrPsZaMrdwk2jNe5+f9Iz
8+Xju5PPT6FCGjyV5eY/rZ997S/J9RU+eizunuVEHT9LjpsVL1CzVfaF0/kZ2mN+c5MP/01Gg3C0
fsfapdF6vY0v2cFWyu0NK41dcRt32cYF5XFYdu8ukWk/0anDaRzPzLyiUfg0PjxLe3IwDBx4mD/V
mAGH6Kd90HOSiOmB151yPFEt4MlQd4Aupe3u6nqAzsVINWtyvJe/zSh+C2y4V6ofh797xhDX8eV9
u79DVGK8M5FxhDLB7552+dYNSo5d25EfOrknGsMVrBPFp9NtsZjAPsZnHK0ORAYVSPhs3XYdGRK2
Pus1g+AQeKKxNJB88EJyej6v/rZAdG829d9CP/LGQvVT1q3KclCkxUlmIwxzGvno+RGwrBQ1iUJ2
Yn2YGE58UnxX37Sbe2Geg+ZLswqohaI4qGP3555rRItEeSNl7wZJKIeaMXLYF+d1HAR6IR5XMR4y
8i05pcIfxT/Q89kx/le4NNnVGvs1EPEGvQgKVB/ewpS4ZWLvZ2TY0X+NjOHnsDcZgoKjCb3mFaEr
gB+i4RPqC7qui2oH5yFR3oSqMap3jmJBRr9D9fuvDDadY6LNRU1wM9r/IfdAb2UddxShzY5w4bhh
ImJMd2q14/Uss5k53cw1HX33+C7dFKajO50eW5Gm/MF6ODzJvIMZDPzCUYPo14r/DkIX3uYG2bnx
ZarilT7UIH3ptAwgX2AdciVjh4+gRSyIBrZPanOoRrlhtk1asU9sj9PIpu3hMcEQ0/EllEMNfSf7
d9le5HYvFcnvStHKxzHNIdo4VT8u2HagJoE4X4wpQYipXRKfRVr/EEQAq2XHJQ1S156PXWt2Afzw
4Wa4x3vAh1yvYzg38qNbRuWhWIzodsE5eygjsg+8xZ6JTk1QO4UYt3C3NLEPGtGz8UUr68NLA0vo
j7ZTVChnOEPO19E7ImJMqlDpvWocsldI2vwPe25seT07epZ095COkv/svSM+/ejTEf7kgy/jLf/6
k93c0NH+H3+wkx15wElPrK77zEP97bm81umIBXKeMCCyyJHIU92AWHwz5wPLiMRoQvrig9zWDkcg
jO/rajyeIwNogkBf8JQMQtxRrA7BGvyGjGpUOo78QfCMoEl43NskV7FNYml79mmDjwho0jdCymFb
i4EoUdkqCRPb3TaQCTJ9izc2ApSxp80JXqt3pZe/udZpuV+h1aw+zpfNwkrBpODS7EJFCOAx3840
qCrQI7he05EKd6A1M7GFBgE0RheL0EHvIgAMM5zITdbXgzWJrrMZ8ydyt/jrTH8cukOJv+zZoLOZ
Mz5fNwvmuoMZk6sS+sxfSnQ7HnJbzslHOrKhxyvAX9fPLMp73050reoN2tuIayAeAE7S82DCda4P
Y+KJ9G1q2rjs6U2hRNtzs0oPTrag5qg0QS2MTC3U/A7CMwJdVSiO+UJj7dhcrCJiwMI/NM69Y3Rd
uloD3aw9c3dAozQ2ZLnhWEbV0fYkGKbQwj2zB+MnZJIw4Xgau+Sw1MQDBiFl7n0ADQuWfv/LbFNr
SbbPKLVncnPNJCxpNosSy+xDjw/d2nps2Kmkoxpa4yXgMxK5xXziPF5++i1ZZFxo0+L8pxfv/yCJ
1MiGKWnqKKnflbf4ffPbCc2iSPbf0Ot683PCtKDTPQFafxWMOSV1mi/3YZcvzj8pC/sOCPri/OA0
7EjJcZrsVMqULWTKMK8ZS6BxLjVnTxu77Fq0un8eaa5nhIvlwrAgY4pW4ed/GXwSdrkDmdTvK6cH
Jgp7szh/tfrYfqgRH3AEVRv6NZILiiFmxvDcj23ih1zNgmY963uJplHjx3VYfZRvjJOAKebSKDkd
dtAkeY6yR6M+GkQtxB3lpmXQ16vBiFWQa0ncreb5S0yRKBELrgVPt9509W7R4rHjwLIFJnnqFCcZ
JLQlfZAjWMlw3XdHU2HDHPjDc3AVvKjUvZ8zRxLgMGxaDnNEC9Cr78WrBB6ELEQ/cm4/f1DC1R2I
vtA2fFbGHCHAHcGH90PNayuZWgYcfCg+MfJmmATRcDuZPDb0vOp2HS6vtDIGOTUDNvUJgLM82jhj
KTdiEyybp4T7+xWy1eHyjV99f+TWqUDCAhdfe3lZDrN4KMEE2aRONZK2Gew+0zXuxTf4xJ+nMS2n
D9F0hGMap71xmtyZUk2xCK8oXw5K15nkQ25BKR/cA5jv/cvas6SHLqeZDT/ayjgVc56rT8j0k3Nr
tZicNl+OgJ5SMvpIVozz1g9fvX738ofXX/+ewgS+Ukh4bLXsq3m53HXXNmrznPZt221vkG26MYxl
4lKLpWZcbIwMp7Bq8XTZmXKRzu/fv0fnmE19hEZOJHiSNGap7k6jzkFT80GRmuf1xZzrEJQcwtdg
apWPLciHpAtXJTA0jr4s6CHa7s6XwuU9kqSMW9JjYb4EYBIJH0r8pQWTlg7wQfsuBowelphcIJ/3
3h9cN69DzYibhZAO6tDM4pfBqdfM4weuV7xW2iWuEydHt4y++oKsdU33dqBr+nWxaC+I4HlP9peB
HQpmHZYOGHNGn/NjqqSJH2Uz7FawO5cU1GNDsIA9mS+MtU/600so023Gk1d9lsWLMVMp1YEFdRzb
fvL8tB+iXquojzQWVpjqZrWYIb7ybAUUEWSiRb2a8dXIcKnCyzFKB0ZLGSTVo0LE69tr1Nw0pKhh
3NfmlFKSiljMYZ2J8DVMY8WN84rqIpVHt9umtLZIvArkSijD/FXQ7YzGI0QPAwdi0oWvJ/SB0kaV
rZVkOu3XDWBbD09sVrCSwfA5gWbeuHuPolTqrfvlWH4QNFghA2P86Zv3/8XIW0wufnr5/n//f1nk
Ajpzg2tE1F0SQEN3q+aIVG/4CusIDoXmpXKMlgpamysShZxYdb2s73pRMTidmfy4nW/QqceKYYNH
xTffvx5tQ9dGSifkCGyDmDbwh7OnX9xfoHlYqamX7yaYPTtiBNUvkXFEETF8W68oKda6RZUp7BR0
DSOQ8sApktiSKxXcizdEZb9jsjsp/lGcHL+jMG7+jd3w78FAnSBhGcOi4yG3D3TTDe04qm7KoLMA
zwkJfLv14JFjc17IarGQr4FHMfXIuL9xSrz07ndVq70VIvhETs+X5hf1Kgb5S84y+aai5lN0ieL7
aZWJRp1So3MCZzOcX1I+qnqDEZ8sEcD2PdIEajRLm91Kc8JAF6xgJV8W1EMGJ8Dpbm15GYuvovnS
yauQbnh0XNxt2yMVU+FiZyzajO8P7SxEhjDgaCq0BLqcRLHjJCn0kMXYb34wZuuADDNR92R3BBqv
4gSxtxzP2LSaI2/5BxECHEsWwwl4tnBf6G1dpdsqFiMI5HsjgMHIji2yggsX1lhTD4mL/sIuzdC4
riQPcL4Z2UW/3KPXyoZAZJkt9upfc4qTDFaLOnql2WnFVZocyEVRcpyTtLIGUCvaA+1CvZfN4VVa
OBzvsB0tO4HEdZTXqs6gBKdMvMy7TDQl7CgTL4RfKi2SD5wyzLL1/XCaJudWThZPKHAhsfX4zCko
/AcklAypAkkx+BFCFXdYvKBHH4HbwNJ4wMixHE8f+tWdEt1BjZqImgSDzJ8yRBwOHpVP9bVbrZDQ
sC4NGAMPviLSWeGwl0QBMdzerBcNzHC7+lDfUxIxmKILvPF8ckBU3Mm5XrVd7RG+MUG8xBBoe/+C
Xd7dLE3We2UyCeANiN5HYKOQyWfBDCZQzdX+I5FniD69jIshfo1eOCSuKqsdeeZPA211uy10ikUp
xD9U54RslJCsUjSP9pFTEmq9hG11DZqQvkcIOMV+4FuSfjt2HIO5pWQtrNgo5sCU1911oZw2M02R
0uoNK8LsrS4nyZHeFzzYjBoRDxPd3M2qiObXKBYD2iF6ehHWsHI5SGiGnyguN7vRkYUp0r4/Rwho
yZCmnylBBXyZre+ndJ6mZ5HyJ/PdZxNWvMuX6O0ivs3oonHP6DkLuSrfBYkcEZj9HFO0caoT5E2v
FBgam23RxQ/xB8mi0nyoOUJELkwo3uphxjCB3YpB2fgFNP3qm5dRdhZnXXfbKVKVug0cXZz9DIek
WkjZerEcI3mEPz+6LBZk4jPCnNzLNjFxmbRyoskZStNI5AzGDY2B00NHamRDyjKDohaVT73H2Ej2
31BOFOM12ZUlexRSTBedgZ0Aod/QfUrtGUKvE4BsvpAab+R2R8UuRva49aq0Y5C45BjpedM8pKt8
kVS+5mKTIOOF98np8dWOLnyQCpDKynGED5dWM8AcvdkTeqwbcUOyrfuVocpDkPiVJtMIKh4Hvya0
isd+3YRZCLyEE6tMP69hELjF8nqx3IFMb21LbI8MbEu4AfGpBdynUoVaPDGvrUIW8iJTPu1/th8b
t6AVBPOO/V2dJjhD5YNfMWH9WG+I/+ksCWVJsAqJJmn7FgvNTIsUvblsOIecD2YEDkhCkZ4QDaVc
tnI/c4jmdR3IJZPi7OzNH9+9fPtu9ub3P/7u1euzs6JefSw+zjcN+YBBQZmOs7NwrqAkW65d4Y4B
vsyhAUqNQ2By/g8ysLMzI/hDKzpQybFBk320W//DfuzYBBo2M/kJRqxKuhMCTwaSfdncHeuSDmNw
FR1mxOKYSKxH7GLida4tG/GdaiO43YwNAsj2cyxz0xIq7Z//0tM1FYRCfWUudltkBCMTEr9ftW4U
6oIziKEEZ6oV6MaxCiOaDUdJQvA3IIJtV8GWaTYgchI6hOynb17+9sffxUF7wFDL/cbsf+SzJSps
jx0FRSbo6MUvMGn2bnv596MDosq5J5Y6FzvKusytOVfvHp/rXqDPxIk/mB8SU6tN25LlVYxcTsDJ
GKLqFZ4Z0lOyfGcRS2gRFCOZYwPaDecsCg2a7u+qgrqwoy9wI06nxfPq7/1yo4IZKQyKQHkCE26G
M9U6V9m+RLUG80tOlKgvOR6+ej6c9EEwXXZLEZeOFdcIzaIdZx9KMyn1NgSkHkUw8l6ILq/gA3T8
yKX2A0M5MC03cX7uy4LlxSohC/j1Y5mCMgu6HR6seP2MzQzv1pkq72bteqtrrtyEudY8oMPe2y8a
jzeN8/ThJ5nzFfTjiuFA8Jg+RFdz48+3iGQCG+21Yls3pPFQAWDYZER57PFPViPPl9gj/jYgJ8Nc
0nPo0SJjMYalOprxXMhA04AHqJtbKFxSu1DR4iYr9ulT6Xt4aN+mpyM7mNwipAuQbI0HGlP5oIc/
6lsPvMiGtLasahhOkwUJXveTAlj+Bt2amotcG+5d+Zf9S4v4AM3lPU29rCn+yf/l5j6J1bDNJQ3Z
pRjOZpRTScKmcOP7kij+Rd54QkeJYhp8OEtHTX3niB7UzxPuZ/2EOyLe2tPe8mg+bhYZXJw+Wv54
Q19ekNXF0OJggh4m47QnVMwk6ZLkmeh899FxA79gGJ2QEsceyJxj68E9EQlhmWMJDWUAAqw4Jhoa
bwaoaFp0m/fRCnY0P6bV5iaOdRAqu9EYM4gI2yDhkWqS2H0lpHGPHByoWTwoQ/lBxKymLPT4boG2
DsyPWxZsb8teoV4rJa6mbjBw1PcNBviUH3xgumZYEXHe5We5ajB4U1PzmVm1bI5GbLftcpwdVOr+
4mVXHlzgpeh9QFbtLXu/+bGp8qK+W7d4DhIwtKqqStPMbS2J/2CYN+1HtFByuadyYaJGXpH8I1kb
+BMQiMiqL9mypWBECNw9PKWWijmf0zjxjKrmKN2N+6zwvA5lBW7mF9fQ4+aedaiYiwKEJtzLaHnl
D0BTwnyDaag7F59r2bCf8RU4If9eH4F94TcQpEz0Cf7aIeojPAQTQrNLJBjlWF9FuiZ5OiEqXjLm
zp+DkY6QtI+mxejVs8gpeCSV4aU2E7735B6KpER8xOQ9eRdJp5Z2LdsrIbMR0RLqJLFHEtorund1
JCu+fvOK7YE5wRqowQr1VFeDMNHADL31xB7qhOnOUAyyEUW+oWTqk0q+I5QcOyEY84LVvKh8Hrpm
omSeX3dx5Zv5PSlvYEeBsI5uRznviPCmvm5gH2ICRW86LtDN++b+CMqTzxcqB0YlUgJO6QTkiZ6H
LAMK/rgHG3TZ7ioYHyaaZxUluWF8sVkgg7u9d0SadjUlbwxCRDEzB6tyXPp3SnaBH0MJ6TmNGNVm
V7PVJZJ4zB0Be0C0Vd6xfFPnxcuL3QbRx5nJ8RrucblPASKVOODKLU3ly0zQa59ttqGKL/s/YW3j
RvisPaRs8TX9Y5MhgtU6XVAQNwry2tBHmG4ADvx1u8nmGiBfiGblW4wgXdlVAq0AZLSOMubJtYHH
+QidCO+BFN4lsEA0/ehgNB5Op6nTcIPA90fPckoS56dxMo3wf9wnBWvGXh+4Rs/KFC+xwePLFcsp
X3+sbCTnR3IpitKcRTCsm/sZ7l1HDLSxTDo9O+txXJhLY8AlsqjuSVfynZb8p4WYNuknRtuL4ku5
oETDJON/JElnKGuxmhJobzxBQyZsrC7I9U3V2clgDC9h1lOJnMMGuSTabaAcen5Ckzn5DqGN9jT4
4BfdJRG14XvvHRSqROITmAdmOX0wIjejmz3BX4dnEKXT0nSkbMx8/QX5+Rz3zwDVh7nDf8flIWAQ
zE/CxQJkaTG/7+g2gOtmMyc76O2c8dAIU4nZJlRRWirjW/IJd6E4x2TgVUOm0SUbUfkHRWpwM5Kq
ItMavKwlTYvVxmG2hWYjKTrZjHFfeALbO2cnp9nEl9w9mRxw7vAe68Y9G89tFUPPyY00eggC23Lb
jrnpsj9JOeZGbla7fHpMq8HngC5H6YbG/tGD1y8BTdrAnj1ldD9uZ7H135Mf01J/elOaaHWouGkX
5SAXPJEeDqTjWDV3oviFiRVFCYoiN6UNw5ElJ1sOxUPnpQydjlqyPzn8PylZHuCEJWO+Qf2RUYLl
FF8HgjYnGyRK9RdJtvG6eRHSrd70QCIW249O7IMD6dn6w5Vs3mArru/lxTi5prVGr7uyGnmZ91gg
uBEv0DjsAsqg7Tyd+OzC8daPBilxs59q3OEVyvu62h4mRRbTfr8BkZyfbqwesN/iF64YioLtIkRS
4Wsi/nJ3e8SLo+Wb7EU37aGu+KVkpMxX07zHvQSXukQiS4NjwiojIUM8f8Kxjq6fvokrGK41+aTQ
Qe32kcMuIGZ5g914yAJNEVIWdk+hipmazk/DndSkB09LQqlWhdlzuD2BMZ+zW5/IsmIItxVstjZ1
DhEJVBnGELYDG4dL+9kE/vMcZ+lPzVq8dvC/6FGUwlVhBfKGOFoPe5DIM74p2EOZG6Ar4UYY8mvw
IDAZrNppzE6yfwaWPPlieprDTt3OzkEq/AAkPm+XyHh/7LNNJK26wsVn0QWQMmJUOXS5w4/OzE0P
bZdEbClX61THYUlRR4cPq9mMpMhZDmzWjSCit5oCLh1qvfqYz2gRfOiMbZyRD8Aw8Cl5OyxzHchI
nB3toI6Cizn23hGUm/RKDdsQVF70cQhnHJ4kZ8Oo3RhwOnV+oxFzZAX+o7GLk2Hq1C7DUW/OtMee
7WTqma+LvDx1IhP1/E1L4QXbeqWvgUBp2LWqgoRTmpBuvvAuuhPTkIv6I0cpjT0dVuik2RotP6J/
m4gFimtj7ZdpTG94mhjVCRZw97MCHPgqh93s4CxUgW+aUcBv9uapYlwRqzblbzfYVPaoGeW+zuFD
aJ+2DZ3YxkO8Zj0H+VNkuwzV6QapjLSwD2fV1o2L70Pr8BUPx+wIU1nFnFMmzCPFi+/B9+YSmPTv
Q7NmcKXIzdQhI0R5mcpDMm4Z695QMsDqDft4I9BJY78Z6uqmuyrLffRdZCsDReIn9DSH3i1Em4iU
bqaHaTILXepLSAggBjeBftNZyQcWca5kja9j5HcNNmo+ztGyBAwHsatTMhygNE6wInjq5pv5DeLI
c1YSzP7LCeZwP2NSCb/NUG+LaibB+jCRe4l3oY16UiVvX5QYhVaoyzQ3CQxGbHGVzFKrdnV/0+5Q
NvyeNsbvGCXlAuhFe6Oa6OFEcFSihKUiTmKVLtQsCIfruidgUv0R554iw8wxDzy+uVYNzXDGaw+R
xlHrm+nYLxBXNGBtOgaMeuL5atdpHqN4+DlGDyPDFtnUpHHtsXQR2IEZjsZK7dAYBZMQzsxQ4uZy
WF1onhjj9qW4iRLjCaCBhQyqoCWsvBg1xbdT5gQlgYGUZPQbX9CMYApMNLqS+id0Yo6OMBqmaHfb
9W5ratJYfR8cO0DNTzjCgNjpzYLjz6NWXDPvCLhEcCcYwYd10ZTZHA7K2ZlD6jk7U08bZ4vuLBXv
mqvVfCtxdOiyh4bJ6ZngAblmXPkv44CLqOBXZ3SRkk3mnEzGt+TVbu/QTY2EjBB9ePT8Xj4UJ0Z9
fyuZg7OzvOUGp8s1YY9ZshN5DdUNm5a6TyFDRd1LRUiy5z7ZiD0HHw0anweDbSbQII3WYWGP7bjL
zMD9sHn7JOM+hw3+IUttNBNo89mzCX9J4njBX2t9QYNj/wS9lxCwEW/SGK9RLx44WhkDoz1b2MpU
zxPRo4lG1sAW2VB2GTpJQkrtmcGOp7Rri7kqwDoxWOK2od0+k1GXsOGdbd2EDMn/zjTAGwZ6vplv
7u3LL6+32/X06dNFe9FpZrB2c/X0+VMp/FRrV9fbm+VXZ7NBAH2FTENnvvpriugNZgZrN/4ziXGd
f5w3DIDa8jkQBjMC+ZEj/rGZi0c7nD6Z6Ndff/cSvvuWAsvPzuQnMJO7bocBl+hG7to5vyePYoow
hsJIm6Gwm9kJA/LfzdFfwVUyFGU8PDrCpXLAXtgd/EB/kb5zGl2jnlyMo/0VuUD26ByCQHZ4qRgj
hQvUv7ePw2FAh3xYraKXn4wDXF/bxDismnfDda/FuxKHnWJxChJnYHmS7iPx98HvJGu/PtxYH1D3
hd/dM+F643uYxLd/GRI7owHnn58VJ9ECnuYp8F7aK1s+l2eiQ/mCS9mbVJuuArnDhG4pbfYTj5RA
mUAe/hhbLLPaxlYBTx4aIWmIuB88buwDnbdszH0x2tF9xWTwwYDHT1Z0EspQaL3msEIMy5e1VjYD
bazFmLWOeJ5HT0dlugvCPr599fuXs+9/mH3z6gfkqNAfZvRkVFZuGx337CrvzcrNxt7KQGOCm4OV
gAnbyN4sraZu0OzvXT0O0WXVQXsiIgJZ3HxVn4o4qxHuRG3TyvVsWir7kJdt85PCzFPiQU95ofl4
ZwkUkD4qyDISd9MJ/8lpvoSYE0/GWaaNXLUl1CUDANWstnm6aqlPMLTVYrZbmWHSAE8+P+35krj4
v/5XTUxkVyHQe5qMyX+6DEKnYN+nH0bGbWhqQoR7t3aVLLNxGBMuCYYeiCXIpk4Kk65TYS4zkonn
m1Zegk6ZplQgwcIa/ebLYadT6lrLaRnHZAFDPd9eo3X07Axj8PB74NaH6Tg7Q8aE3wQyDo1+6sKm
5RSiZiUes7jLEOMPi/bTDsQXF02tAgvXh/HZb+h0fLACUOcjyDPI38zZt9GkSPGSicfdxBVgtVks
lLywZb7q4UlEX8fJSleFIA0NdZ4w3gNnCf/VGUpCc0TuZqRYhF3wu8BtgLJHIFdr0SoA9/tazkIv
RgT9+wMlmWG3GlfFh8rDIrDQK1KfAntLnr1mRZog2IGr7aeoTBAkIyXo9FWIvXGMBRJei9AIF5rq
I5bwZzN4nEZYqm7B1c+aniU+p3jsAMrHYa2JG9whyL9SNFkKN/X8mHx1b5qb5oLS+xSrGvUXIB3A
Pr6ef2zQ+7C9dMSkYv7L44vC5pjdzJFt8S60IyBzoyk6u3jt94gjueEx/BH7vT4qOJxPUIPIKe2K
wCnXcPjahY0p59hAvk/e/fHNy9kfvv7hdRiimVnsJyKlZSU/gvfFK+SGDLXrTfMRnY/hWHfUMzna
rwrLeGTEAWwXjW74b/SOhMKZBPAkCjMUP/peLtglkhrl+NAF5Q1P9pabigNcNUgPI42ejPDX6DTn
jjZ6LIeeIP6xXJ6ZVKywirTGvUblkUiCK3aR6hw8WVUMtaehuuWf16P+hoqL6/nqiiOGh48VNaWE
QzPqj5n5llCo/8Bj7S9GyG5LIN7L4y+y7g95d48ktDWZeTgpftKRpo4O9SSxzaYH/hEzF+zEzA4Y
c0x6UCuw0G2NQKmLdjXaOo+2C0K9wcO/x2IHg/wERAaMFcFPPC5GF9dtg5jUe/3Ienbsz9hYtCfo
5rNJTL1UTpYoh6bxeFON9jdVfMuucV2NMGM0u/B/Gj5J/OLtdb2iuJ0l8AbFQ+25PQ2jwHE+OICx
Cm9wE5QjvApoLRjFfm9Y2KHbfP9WN16NqmFiwMtOvoBR/7aSBg5F+576eKdYXo7R9iWtX16YtCdE
U6rLQ95Y3eg0Scq4H9bjP+Se+w+7a+IVVNajUm7hBP49zTi9ktFAXPIZOgWtSEdfmQczIfZwF1px
PvRNwmXpI7X9G8XWhX/6Kfkjr19kYaEWNpVs/vQFwrPPMvYvc7ezLOJGqrftz7kXhNGoic2Y8bbj
yPYuyRTtOItEtxUxJD1zJExJVBiO5Mnz6Wm1qddL9A0bHSHgxGx0iB92lk3J9+d5Kezw2TTdR2qa
Xy3qu56b2vsqhhJKP8tB6XXnotXfqJqfzttIIlU988kqtUgKCDxMDUf4WTyRRjAnnVvUDhyT9YKC
41b31oSAWU/P73MWV2VNdYORppv4uZEDpIs3Qbo9mAcVMc+VCVVcWIZYZbJyPMyJGtb5BP97aiLo
RWuz3W5+lvdwcDrc1jaMNH1/xMfM3TbrZ46xzNzvcscjw2Y3rGi07R/FtWCZrrgK/pWUzwwCG8hv
JhY5wug9SwWcyTuSezjGYHnPqnkV8QzeBbGUSDHOrWA47xxPhJPMbLi3RM23lMskNmxyLESRkhVM
v1Sv8O4qiy+L531OxQccVJfySyRpd/lOe8Lfhy67/RbGgFG/29sWhQvEa0YHL7IMwUXaYr7Y0BrK
xMwOHjjf51m2GGcQiwDBYj/RIfGQ+OTZKYaAwZPyX4FIue+31OnhWQhmQtm0dnNTHN1NivEd0ZlV
uzpaoPIeJ6fUKekXopKpygnDSkxw9g64JIKZnD6XuTST+fzfZDKNIfdT5pJz/pDC6ugIzZAYGsSo
izqZf9U0uusimEWj/8BMEKkuakMZfvAy0HkYj1Iy6dcoUS5h7c+gui0DvOdniPyveUn8qxJeIJkb
HMpk2B58kbgD9yZp39SnKyyqSVdWZkzqXMekknnGsndkrKIOW8ZnB7Sst0V/405XHY+cb5ZMF1z5
5Ai4LxK/4TVh+86XtxjTRhu4XmH+ckoUhJf/eOiWf1iUuaEca7PTo+enuektRxnUC3jpNI7Gx6QX
3TzvBCXuJznvNXFtD2yourLO1HpsW8zpcHOqNmd/iQ2COSeSfepEClafa0Q352aCu/Iq8tBCdTdT
6ho9nyRTIBLgeUBzUBJkvEIULdgZybs/1KSF2NSdik7XNXF2VRGkN4N7DZNgdrg36NcR/7TmQ0QM
6lTTR75OZIW1xeFeX95PyDTi20SOzbNa7DgCg4G5WS2ePKERobX3BlGkifVsVnP9MjFeVdpWn3GM
V9Xt2cwSxOpY/fqZT90ttlCa8x3CXnHSNks1P2mt/+3GxdjomWH5WtaPMfNNCQytL5EGKnvejGzR
fdTfu0EKJwMinuFkqqbDK24z3nv9WpRbKo7+sTw6PZuYP2PzsV4MU7Fkbfx6M6e3Cn091UCTowDm
2mQjjlCtyMXE6ah1jd/YhIPZfA34fmL8hTOpxHFBjENxJN+EfqxxCGlIpYxpODfOKusnLJPFTrgh
+0Hge5i0kPMZFpw1AJMz0fQcf7Np12+JaG1+D0TqH6Hot1rEenqYryBFmLpMj0Nf6TJwlr5U/+iB
DasW3HjWZyMANcOpFzdotcEgUehrB5cSdoYjcUSXcK43e7yE/Y/YkyDyGxAjuPMNyJjBOfSbxOkt
+cRdCmwI64zVLhnYbDWw7GPgOhJb6i3kShQI9jE9y6g+ZKr6MXt6KdPGitIh+1OcP7BoKKabcrRb
ITb31ar5Ux0lUiY146gYcWw29lqWp9nWcHAfJsVHcm6leJRxtCLq/LInTpuGpEd3VIixlAaBbZdl
vxaJc6phGmweKzUVVVDdA0+7dZqpKBfNgr8wZnywuCMg+06IJyfhwXFGWeEH+Aq+jNxIJeVjc3lJ
EvaSwgto+orr+/V1vRIlwBGciuVyvga6+uQJNgC3cNAE+mmq77TqU9hP0rbFTRHvgTuYnVC95vNm
vnZ8OL3BAwC8ym5D7Ai5wiwWcgBkxuzXaPv4xRfoayGnn0ZHX4fCuHMtxWtmpfLpjWjXWc4VOJkj
zrYgnAy6n8qYxZHH6C3QIQN3sor9z4ttoyl9A8xkSZrCDc183gqlDXG6+hZ2wnbDsZeZha4ObDAA
neQmaQLoTzy2f8PHFugjzZS3TenZzPkEcHXL8Rl121zS3o9mSvIX6ShHEiMYSh9d1gNhU3cRp4Td
8RhE7YjcaNCW6FKwLOtT6LPH5jEafvgNHg7z/Jk8LxNdvd9iuMdHR9cT8cMfFfT7aH5+QXzxPDSw
8NdX++bDfdBB041PZykgh3B27EWRrkd0zmCkf/5LjEqq9bPQAUH7lqEgNo+OZPA8dCbNupEGS+XX
g3+fsGoGLoUDMB0MQyTspwk5hrUZlYcpBEeGtJhzQAqYFpYeFUXT4uRxdzo6CBj2sVrTypzi7+7O
8f76zZEhAtF87vSLWMeO51aC7/2SZHTiTiQ89k2ERpVRmbvZfUXpxSxwDMzv7lPMEeiKnbgmTlEX
iy91BH1oRLm6ZuCGkUO3DzMiDO4hTLTLhmgxLpJwbfgelRSc6GTeXdeWIVS58rYuPtT1mr0vSVPd
qqO1RByRWtt67TywxQU24K/e5Oakx1JGNqLsRBQ3fnbIQtGz9OUndOgrk1boeGSThRxE3rAa80um
k5QBeritgU/12gNiEsZeB/aiRb0MAkil6Olgr5GUTECaf+9mwXJdN2Z2wOSpum6XC5cVy3McnbGu
Vb2ZFFDSFwjGONBSfbrZXjdWoMYDVLTkD/ilH3PxePMVxt0G7U5cHq7X7bZTDNyDWn79/bu3L999
NRwMVlSVUiBsOT2D4Xpx/Q203sgmM2yu0olE3U9HYfGK5MrbiMNpJxFWK+GaCA4lIndX+/01w9RO
xh46DfpNAreihbT1xh5xt6SQReOZe+UCAPZ55LowQcHoyqkaMDuV330mRzTaBM1s90n6ookITv1O
sJ/VfFicyLY9pTtO/lNV1Sk5ks7mE+gu8gExccJx8KovWAbzHK1gkLTLq2KidEJpHqEQRcYJv0FC
ApMRgjAxeOpjn2UCo83WxzeprzJLCBm9CsKxiJ9BmioEhIQVheYkvpuUNC7bP73aMzFVhJQtkBH5
z/TIyIsEyxKPyqJFoy/sLqAM5aG4AlxD4QSwZj8IrUHzDDBoteOQKU2qO/1lHsKWAbZ9zKlu/jIM
UtCF0Gy/cE4jzfvXqHn3EZOcAVSEPXLZ4xh7SoQlUiEqr4n5aC8H/nTVxVijDaF4s7poKCSJOBL5
JpNqqaxSf2AZq97HNFhD22DiQrRrm4HM5+2LV3/ftgjANpMlcEX3LIEkuxRMcz/YTHKpHhd3M6Jp
D0xXzzbODtr2aAe3v5b/1Jn51vvw/HIm7GCtpnF6T+cNoouJ+Q2TJKA2+YzBpeY8uA5s2uQByEb3
ryh8GnavZhlAHpX0FZxRGFUqcH7SQNRPwYqmVY5y1y4QCckM9TgLbB2mMZA/JzZbQRlCHcwU7GYm
2Xz2uEOFhNFAyTjEHOBnSKM2LKvZ9jYFjg/SrWX4hST861Hxw8tvn+lRwxrIgScZ5WAfTYpcg1Wc
EbY39M98qPEQa7eY58In4+UuJB+v2nUylgPlaVbq5VJd7pZLuizjdOn3S7zphuTDsg9+SwuiVe5j
PbTOh8hG+pzQuDJkkJb0bYwHHe4TNBtyKvnjqyhqceTfjTSf/CQdyjH9N8eBbDycpd30inXOCl4Z
9bH8O/m0NDDypcdJ+mzRURhv+PnqHmSiLoP7q7mXMUZIhqGZX4f/vMripyUZfV+9fvfyh9df/54y
+36lmX2x5XJf7cvlrru2BOnidjGj/GqwtDM+rWp6px/BkRBwekWg4lqFgaxlREOMpt1twxLQT3IZ
eOEPpQfUWTLAD2PfRvMGu1ght00hASTnoYYYd/RMi4ddVecYplBTg2NtOTmR3AJP1W9IsGFsETd3
qD9AikmWmIuli/8l+SsXUErobNvNDoF7kYmgmCbKP7s7F+YaMeQDtPberJz+beVRC8VkROxUp+br
qHQcUizipxl76LRJIaRh3Sz2Vj7NdopbeJfMtCbMdQyFgclxduwIhlHhwOBN5C5LT3rch0Jm3kUy
YhV8MMh55pBzn3fMUdqa95C2SFxGxpu4Gll0xG1/ef1Loit5N9r0JZgQwyRLN7ceIaD3pWmgHCCz
JINKTlLJZ3uwDVTeJDkzxkgDFIjVXQxxdDJQPLAB2Y6tysUnZ2O9/YYi3x7mCihIH/FrEBimQT0F
exPBb6O0gA1j24vzMjKZmSgVoWb8r4tLPJqbrGRuDJcnI2mHvHRtww/XlD59TXkQ1oxI6UO5HTxU
Ai7KSOgF6vLYxJdLoIFvcYZGDzQGMy++SlgDfjU3JCcxNHmtSVbVoWlUBuc+QV/11Iz2+DSV2Wlj
hWvXqFdWdPwJpHV6GuVA7kmx+fU333z/5t1b0arCPiEzbk9zgnGIQxlK18OkjggLiOEvXx+vTB/x
tPS97I88ybRBRIAOAmXtBlkNahHSQKcorM+eDfcBF2bACKkfxgDExJTF8IJCkZD4UZoX319B/YmW
wQUu1zYr9b4PR5jUqGSO1KDH336ykZIK5UJy7dmcJGIz81j2cgDTy89lSwkPn61UIoJ0AvBy0DiO
czj++R0QinzZS8BSb5KZJ33ILZxrOsD8cvqXeNdkkb0j9yXBevTg3ifPEtMYkGgGg9vgn3JWcukZ
busocHWN2PSrrVhwnx4dqd8kvLttNx8ybXRt8S/okb2stxqzwLrnTYOIAU7glqRV9WrR43LNByI6
CnHGo64YP+5K4taLukqTBuR92yVDtyOUAQ2JdS1ZjR6TZXOJwN3F5C4g2In5nt+GI+KG+I0KLlWE
x3tzz6UU0GkmfQDD2VMDO6NKXxYfc8BvbNaV9n5EFcS+WI/H3fTxYqq3TqepvR935ESB/mDuyQhN
J/2OQTJXyt4yPL15gZdkexnMY080JZeYZOakPAwL7BG/lHxZapHyiDKSP6TpQiVmlVMdRo7nfLVP
inQihohaQm4k3LnpluB7GP94xWgMYvuRjhM9dbtproTFS2/GSCPMRp+DEjHa/6VJGW0uxvCiKRNe
Jn/Rch4Yk38Rxzbdo0xVfZM2ZwmtJ6oJck/m/vJAU0yGjZCQaB+wRHQt3aII3FJIG/yd5i2gAvsE
73h0wuSMXFqsURYdPh2KBSiCXiNLid0UEfCQyUFogwJI15FxrGemFUPOUrghwuYRFRlF4VAKOHQz
MOYSEPWRTSWEbBfhdl9T+BPaQhFkhOAYyTOZHBKwx/MauOa6CzAYfUS76nwaOKX0QaGYfxdNb4hp
nIJt3+H3W0P7nRoSaFoIlXyBIQGM2kJmrQVVgUFgkUAXG6I7JfBNRkYPLLbiQLEqppv6cnoGrXCq
sC+F2em+OquKVyEqpQ9VIAEeiBDe3uToYSDNt9cbCkfBjIBNu8kAIwVCR/FlH0wrISJ5BQjiLDnD
DY9e1LZA+ebG95zylhLsULhO+/PCqAHxxDsfPBilnasJm4FDbBzUV7onTOcUVGMBFnvXMxl+gOoa
ADnF1ChEfzrs21KPfoU8y+ymqaQFodNd7hFyeO8FjMynDAqTtcgn9gLQm8mVsoMUyqTuz8QjdUej
B3KlaUMYqeiguKIVWvcKFBFXUvZkp1mm+b1QgSb6T3YE88Iwu92nn7RUArNYq7/P0icVJNk8uzmX
gyAa1n0uoY3lz1Iymp4mHFBZPiUd+3NyMpv5eryc35wv5sXdFGglxmmux6VgJFrde0lrcrrHHhIg
qXVhtsrwUO7qfMa9mS71vvxcybYnuHuYdLylux6fgjQDmGn7wDPLww8+CxrSRGvBRoTnPi1KZvdF
O092HX4AZxHjb8nqUM1dJ+UmYedZNzdu+1j/cu5tw6fDqHrV1etyTwvyyW6r8wjcVh9kj4aUS/Tb
y+C2DQLINMCR0RPZ2wqYvA/NOgnUCi7j1I2Jt7IBVMRIjj6U96oo/tjuOHUuZrSUVIEhIgNxNnAh
w1V0dnZ09P2bdwiiqG6RLucgZXJGVfXQQl5X4UD2IiyqY+Ylhx+sOOwAURajVnBepliJso8HAiG+
MgbQRVt3EkaF7YQOzxuGjme9jsxbLrBQgklDowEJzaJJDm7k3EUV4VVUFqE14ZuxfKBtwq/t824O
4C328wafgIyRXo4r4zt4+PWYH3q/rxH5m/mFxKxVwA7oYlJK2BxvkGcy/I7iFAjEVxSusj2LtPgJ
Gc55YBhfQHYFNA6AZS9MrS8UZSPUvtsNfe9fOQKiF3wHHzgUoTESSIojkizAfKc3V6t2Ux+/ZLW4
c6PP+d5KH0QtOT1tad1uuaWkuMAxylQAJyPiLbA1mrlIFR8qNN6FgLYucJXAboNMZEdDiTHLCqPa
XmQi4RphiFxYK7n/KA2Zvd1w6FJVkqVKqszYeKEVzOeSdGi+PgNZAwPA13wpmbJZd39dz77sgcA/
qm0Zvsr9rF6tGvHfXfdmTxWoxpGMWWp29cUeSHGz+Dhu2OcTX/dEW8zHBhLfZ+eKGGamF/B42N/j
I447YxAaEODrm/X2/uDxiaun4Ykm5r8Dt39nnKR9hvwKaqrGRm/3SBRlm7q4xdvtlg6uQJmSGj6f
NEHlVGlEwHo4uF5whIPdKCq3TiEdefGigZEjt3B2vVsd6TcHOZYekiYxd4RxOuv9h4My7oYjyQpP
6XDX+zJ2XRZryXoZVeTslzj06MWBIUe04aKqmrg4l3p6z7D3AMpdz9nTcV1xA8lX5MN4qNZe2TU/
Jq45OHQ9Mh+VMSrTTOFI4tlqOsxnXu5rL64SShCG1zWF5NDFRn5nmjcnj2lGaKs7gOypqa6fsXOW
f0+/hBoND1VCaAuBnKVZv4/7acog3U5mQvdXM11MCjdhbihyDwfjPNFmTifFiaW4k2K4be/0T1qD
CmoPT8PYT/mg7FkncVALrNxnPHxxho1L1m8eAqb8ruTm67n4wvxBe0xubjHc1rPRq33zCB+FycVo
k7IHPdBldp+XXZkwwZnkD1A8TfUQou9SWWo49inihHrOvRK75+ZD457a3NpFvyJL8y7665Yt+Nkc
JdwvKka66juKxHqH2KzZFH3qlxhHbGVSMUvT1WyGpqBZPlt9l35tkjYY3mkjIRx9GvVAypZE+ZRm
pk06jeoc3O0jFF3P/wWdIHmi4zBlLyAd8glBJshgZLwzGTA/8cFWj+YnzIxHkWsgWbygeiA6v5Oa
f6CKHozfePDPLy7aDYVFiIeoDexvMrEWVfESzvw9+ZyLicWZb5MeuQoLCMA6kUDvwrzmURCHQOXu
yF4Dm10jQKogon97K5dCW4WdjeP58Heo9Yq8aJdIhY+L0X3dmbjP7W0Fw7uZbz5QkJCLw9jTwKrt
r+/jIoQWbW8HP337/n/5xS9+AYOfkZvzT797/5/+8y9+gV/GS43wKKv2SMwvFwX5s9aMX//qe4pb
ZdgDTOmF1YRMwRmdwKsJ19cAP8nXkJcOD4kwfNwBIZGEoYWJXKTmYW/PJGvnbPagg3ZSE7f7z6m3
aC8OqDYshnzjoE4ZcxV4+2VZPlj7kQdsC+/lvv89nD0CZdkhxvNp8tVP/7Cf/U1pFMNgMLsFrgw3
i0378HzKG6h6+fr7l6/fcZtf5B4++5V7+vL9q7f61Jf97Y9v/zhBBCGU5IqLRbHYNB9rlougoe9e
fvPqx+/gA+DyLHYrSjfnM8g8twN5h1mh+PHn+cd/96vs8791T79+8eLl2wnjEN0DaQFid07I078e
/CU4LN/NP9SbNCJ2Of9Ts7xXyKLOZAC2B7SeAylct13XoMP4m+/fvnov51GnfwzkD/ZIg9H9a84G
XYyoyEhST5dVUXy9XBbd7uLakWvjgLE7l9FGhzokkWwcPeZ/OcMH9fKcK4eJVWcz4UECOL8I6Qqe
qJA5G+bMh3s1nfWqNawODSVWrl4sO2tJpTI02jFUtv4fFlaYr0yomvqqL7vQqmMaFM9qaHZ6oMXY
TN4J1DtQeoAxCFfG25BIPt6apJuucQ6GP7Kl9SUWeEzKU3we6U65Ik0QwegzGR9L+5OCH0x6aMCf
R55Mj6YjuHyovb4cGyOhRKMpOqRgAAYH5MB0/SWHbhzPDX8ujTc3oe6dj21BbWS9oCA/ExPax964
IA30EjBRopT/i/NmrOQadXFZ5GmMWR4ukMSEvgKzGYVdnc8vPlzD4SbONYjB7Nsa2HOe5TA7g+bo
0MTi4+/f8koWPXe22VnCKU6K7Xniqrkv2kFqCdU5KJd4bobSqE9qkF0idnUV0r3sNObNiDK+PzSr
RXvb5T4+pDuv4QR4MhdNqHvZ45SK2j7CrFlphxPksVD3h/poJPhIpmVZUn1SP83CP/8qyPz+tu3N
fUJ/5JJoPJTlxs8gm8DT5zCCMXCAYpbB3e65NtbflA9uk+Ag4f8Gg9reTXzfloOf/vH9/yaM8bK9
qsSX96dX7/8/4JedKD7Bfe4A2sTMAsdbEl6M00f9AI+UN4ytKKjPDS6DfdnD1MIO/4QvuBV4xX98
Ao9NHrCGKTS+q9wWJkoOk4btYTSTzGEMPbpuOKgZ7S/izyqTYDKBPJ84empNW4+AW0JYRMxP1HYI
Nf/i+zevXn7DvlmclPh59cunLunK+n7U+UDqUhr5Xb1VoEeL8jhIlSZ+SDi8TZB+Voy9QPDwXNDv
8TPjzIC1oMAzY/HZrVDjQUWryxndwBftTEONKuDHFqbLEqX7o2dRiDnVjrXgUauJ12a7v59j7CdL
FGnMPVhNrgHca/jvX6U/09lJTip38ZmdSbsA+t143PeGJZvRckt8sGDfF2NY8YvaYSY/7hCSfqyb
0u1TXlzaSvGG9X/iGXF7V/8Qm2m26rP8XsfJV5Yiq7zX5WQlRLddYD5zTKqEXB2+HPveLd4l0Qao
oQzgZn6Lf/rSvFc2cL48AQknNLksCBNjkxwHs8diFsMb4MOWrpbt+ZyvHGxKgk4HMWgnfcSzPevt
2+GxwQ6RR/m2XCnz0Wq91NuG7JfSSqJC3VHUu7w98XX2+Ya5asMv2V731TC3vNIoh1+oA9XIaZW0
pNkaK9zl7rwLjLL9JihR1auFGMCBTl4MyQaWPG/j+HIzLv3zZHr07DR0ugvb+T9wu+FleUBjHmPM
1SLQMCDlOWsGa6RpFlEknGHa3FksGWaZG9M3bjVEYsUcwBnm5aHcMKhcOK8XC4JMBw4JLn9K98Gh
RuQzrj3g/VkX57ur4tHff/F/PfvbZ/uGNdLPGcWe++mSR1V5TgYMW5ZxxdOinqQ1hNuYYWZSBoWb
ZZoT5Deb1Xco2zTbsTzGFLvb+qrd3B8nycB0CMdoPFaYEfI8nET06ljf8s+JYTHQBRwajwfjgtVB
TBeXo9BQBTtFC2sjsGs87BAQ7J/+7/f/BVhBxepi7uKnf3r/v373P6GitHhDDxhOZdF0Fy0qoycc
y8hC4I591LCAElcJ1xdOclPrX5erG0yh6H5icYyHHDieU/8SIm8UroPQRES8kI4atcBqQvoO/v6m
vmg38y2Kdviz3rBAIfxTpTzJotZKqtn+ATbGYOAOkrytV7ubQRoCSuki1pv51c18ig57NDfCfH2P
kUGkZiM4A6CoMpFfVL/8rODw0XmBtzk2xyceelHbp36sfGD0syLcgCtKKsR/AZdOIZDPkyPgqmQ8
UrnOs6QOt+mqVBv2DB62QD7RVoJDfOdSvtVjtqAxPB4G1pA+D9pvOne3H+uKVv4hvFcFmX9JTwZ4
T9HEHVvwEH06kKR3Er0I0hFxVXPljQujiUDM8iXyZiivIyLRxnofoh5/5N4ABWZ/6KkYBR9RaIxm
YkQUqPZmTZEz4lXSqDvlupVUErzM1eCHl797+X6GqRN1lnz1MYZOwzwaOAWZAMR7aa5Wc8wrOLLS
lCIgY8RuBOGlEohvpXJtcNly4G+TA1vTlrgkFoSf4yeG99Jn0oMIPvA9M4/gjj3YDowqB3XxLYqt
yIdBsQtYwq20AtsOsfOdfDumcOmwDXrE4iHID7qTkSDRgri36gnDx6M03knAsS9npFWC1TTaZ8I2
4+z086XnTsVoJq69Y1E835fF7QZtjgstcM6+SY62Vfi+I67DPUJjfjNfhlpkFnwcvgZaT5F+c+tA
ti1g9vm/8DmrTIGMYEeNJN1mG8JSdn7hmZuqy46vJDNRj4q7uzsKDl4ore2KenuhPtMIID1HN2yB
lR343tK5H8TYIjjsEfFHs3k3yo5X3w4EZyvD8gfDHuRDxrTMybNTdFbYlhP6crtZpYSbjeaGBm62
dc7zU/Y4/iNL8wCbtU/vWTU3M7dAB7Jsprr4Xcwv65nxfyByE3jam0Pw++ZDrWSSjEihZ3OxW5MO
+N7bZsTJ3g1JDc/olbduMc98wwFmcCcypnj9sVmO9F4UispH4m2NUSTdrn7+7JehMToz0/s/yU69
G2vShjpsq7br2+YOyee3cviZiehVbgFXtCYXZRAHu4yeHxP5wIWl2UHum3q5uNje6e9m0WWzNlGz
yLfjvwlkGnTFCU3gjyhqlLtDHx3+K3yt3cN7/TOCTVnQlbywJh3GBJwZg0GEb02EhzWmmbdZl/R8
iDovwCUvAF+vmKyJcl8UY4zNOK/VUeKSEvCWJqDa+TAI3yPtGD6EIOUyh0Tglvn+oUpjmvjjob4d
6hJLYpNoWaNlJOd0RXouPZlEroX41bn2A0figqAWvQMGtfAOnTJ8PXFvJc5nTJia6J+wcWDtNDYS
yTg/DBk+mez5nrSHgjgbGwITF6H+OC/luTpWXNYbzNq74GTouMcaiq930Nfzawl/AamAZC0Cd5gW
zqtLPJtw3GrLvaBkNRwzbPj5Cp7pLhjLH16Wu6ETiZ8RyB3UmMvQia3qZ5H3ODLMzWq926oLvUMI
iIOXtZpz4eGVhE8nIcIUGdhtR3nGeIMiMaoXspQcp4Pbaco5ROhoIxXkftn/RvvsxCl1Isk7UvAB
tyULlzx1IkcHPQ95ltkHkRAwh3YcvImnPtsasDkUBN1emk0kI6MP4rW+gW6a9TJ1cfMboOvdTZQ9
B5qS97QvkoZ25OPdbO1o5ZS5AKdJ0j6lNYFePhIIATlwQ0cMK4KhU6khab4iBQV0VGAoNh3gYozt
uoSBWwS+RdOmyPqZUB85DSQE1PVCUrrKQOwo7ecAlZi62ZbMmEhwyZsBjjrsdrharYNYSOK7lsPB
4M09GdSQqbOzCq1RfDlwQ9guFWFHCudASHV1pyqI6sLnm/OB4L5/+Qa9iFHdLtIYk0lGgJN7ycZr
udtIrJgWt4NPqtI4m/lAA2Jy9/B4z3lwt7D2W8rwdNR+hKprdkKDYQu1kTGuFOy4HWx7m0PA3b8U
sMq/Av/s/MBDRkGHyFcH/L/oz+lWnv17XULU21HfVUStjF++f/Pyh1ffvXz97uvfl/Z22s4/CJgC
ZUXyFBUIrYElYKoufZwhPyls2ZpjM1JyAePDTTMvzs5ogGdnNrgSH/NXnTGOASzbtqbUJSbVmWu2
Io6SCl5vt+vp06cyonZz9bRePcVbrts+pY60yvX2htlUSphGQK7/MQ+A4TfJa9yeh1DJ/HO27mFA
scEIou2O5FagcdcbvPH5aiddOZ8AORbre+DwZ+wjsL0fG68pEcxi0yxClRoEERg6Zpu8yvgBlxFo
zKLujyQxOKiVioqL9kKcwa/JsKa6ALrWqbnbeUf5xYgpYNo6FoaOjmtFVn/TkTVpTALS4mbgCoOi
bfgVDEMVHDGEvADFy+xQVlWXDhEnh56Mh3wZLIWh5uSrQUpU5cg4JapCGqfOTZzJ5HiIEQL1bAvL
PqSMtdtjzNZ2q80MfZQ3E7C4HcqqSFWMNlVrTyQlHqaHlpwYqAuBLQo0XL4hxGEcGqZyyNgexwy6
4AdycupHwd3rda3CrxNOOHqOOHJiyGm9YX0MylPUP28RUqzGA7C5CXggBCc0e4JGIZjuJzPR0I+S
AaLp7IghqQlrZk1501bsJ2k1+GJEcor8vYMUBr13nobIew8nyWj4GDOTjyMT3jseCwt6hw3FMfj9
g9n+VYMJ+NQoS/mQEY6DoWbPx/DoiBX1RzDPtRkdjgLDEswiX1y3zUXdwcDdu2LIwQvDUz0q3Bo3
ln4Xln3KVXAnovGN9KGUs4Grqgimctck+TYT2M5AgdgcgtAFdEShu9BQNw7gcRN3fXu8pzZtmns6
jlHghbB9HvapjOmMsRlhEeZG5/YIDluLHMKScMwJUbtb18slGruI6+WQr+JI3RQL5+bvkqIi/PnW
NWcyn0KrM98aJvN0glHzpxpPo/zeQNPmZ02/TdA0qs+QLNn2pjk8Zf28SnfihCrHQUzszPHnz/9C
sR2jPz/7C/SuLWtEB9AkPz4Y7jCjhzF2MbR9iqI/HYZ1QsPxlKkeji9snKa0thnGIUpQ3glu+oQV
IKwa6sN0ql2ZHsZPRC2gXqLyU51Fgx0dpciQiZa9nGCsDWUA5hwObc/QgaSwRvs3ZW4qp+o0G1IY
FaPNURxSIk0C2SR5cCX5SpGhDbQUODuV70KENxTXTGMojOrdNHeyptTgZLZMBBV2rJN8mCvRCJm2
cA+7JkgM6h5szH0gvahscy/v5jfwZlr8xk4ewiw+g3188mzy/LQsbmkTL5HXRxH4tuUQHIeqMjDE
i/hmlLztFLPehG5kbPmY7UJz4Oeu6415/rwybaFCIJUORDQwo81IBtGlMaz5KztpvvzkndWj+kIf
Kv/r+aSoqgp2GQlyrO6YsyoCN5EZj9G7eKQ57aAq9n65lYcemXEV+m32UIm2ibzJxvJDDpamYlG5
1me6EnnjO37gqg0Gv5HR9OC6m34dNLAGhhKN6yofOOIgV9H84J9bvvrPbsJGMsbRVGfJr80okM6h
RPDblOMhjIqpDMa8EkEAKps+OTYUnvEfcKe8IK+gaUH/wu9Xop2AR/qnaVTlNXj7rTsHo9/xJdpu
4LH729RCTnTp2Pgp5ZXUJWaYh7/AQkS6CFUq2jWQLAwYmujx/FH94NW6Ufghn8PeJHQ+e6BLjUtN
V5oX4RP2x/qe7HAU8sB/YxixWu/QTODtA/69E+9QbeSfzpqO1rxeaC0bjmxbGz+x1foi1XX2w771
adCwFIvSzgpche1LFozUFkqhI2cxae4E/oNBJNof/e75midaKZBHyZU1vFppe5OQI8g5LHvLNKFD
Mrt0I6b/wCGzbMm5DaPVp0kGGapfKRFBTV1DQKvjCCBO5wQe05xwvQuXepBQWq0QNsqH0dPoxF0J
+/jrwuYNW0PtSwK+6KuuUMxoP4D8eHc/ziZfaSyc7vpeJ/pm/qGWdKAEk2Tn/FimfhCeh56q0UpJ
t99lCmSOH/7B3gib3BG0XeIuHcsD9NJim613L2h3W8SNVROlDIZSYfObir0IMGf52Ol2sURWb8Ms
79ttu36FyG2O8mPyHo5PDPUzuIi3mFZ9gi4O6FzfFs22wCeDyNjpx+ykIfmqCnFbgTBqsSTQD//3
QhygfC3CRNx12/aGaw5fsEtpGD0vswBb/aLWeaCCDtuQFt81WxpckniE7oDnBomYuRcfJHIUpUxU
6BS71Tm5XLFk3BVjstb/8ldflJgiCSSJJXBKhbGaONePwLmFvSOGvPKDJErJDiwOyXLfQN7mlJBt
+AKzLmhCtixiN0OyUFVEUjuv1Yqp+8ZHuFXDpIXHsk+DocbfRLsdvymD0UH7RgXbdpP5Lr/R3W3d
t6KHoHXUzkYRbLCV06eM/ck7YIdh5i4mJMFnPOAK0+OFzx74yzlcaf9n8cVz2GmuxdD8kJcZMUyG
/QKN+Ze8kFcg+QDRCUJEHqHvD8hRyI7c4D7GxfbWr3bT9WCxsZbqDeqeX3AwTRiv7JzbI/X0kImm
nFsOL4uL2JPtDM1pMWX2hmUwnO+au2Y1tiMz6nB4aLkS8mrIqMh73caDeFzlgz7RYdxVZpctG19H
w+vr1HZHA+9qBYXN4fDabsLgulhhfkka88vO682HQMTqzfIer4C1dUSSVXGDt9nh9APykWABsqXc
8EQb6EEKeCiYqupKBHfUfMubSq0lq4vlbiG39D78U/kA0gHGeegwEGzekEsGNxQlVLue+8SdSC/o
gc2phr8rgR8yzwmWKAW0ZRPKiqtlaKAztK4oiabu8PJAIDJx/ycbTAK6k+uAD2OmeU39gNaWICJk
mG5P7ZVjQb44zeKQmfWb9gEFBivaj9JHc9sPaNPPg+6pyK/SdSS8jEoAL6hQimLhgYOrE9RWnwyj
Q+EcLntPRlCiolvftcDZSimkOqrPiSYQCh72768jnkJbyiapI0dS9Lqeo1hi471ivh9ZwY6UxlC2
OW+WTYSIeNlppkUD0MQuuBruf+pc5uMNyZWTWKRMuI72wn+EMUdBKBd2nf2yPZFY3OjEN5L1kg3B
rdV8qnRqXwIGiVwhR9rExy7oe6I9+CvthXIoY3+9uaww7iXMmU81Cfc+bm/2F8+jaQQXGYlzdTdj
oxDmukOT0EzNm7GxaaSoGa7HpsNdgiPSFIwBB0eesyjbcRriulB2kHTndFdOxK8KfZYQIoGtlzYZ
xG+wi4o9tplB934bWUBm/cTIv3eCkVXcvcsca2AgcNb/DSZPjIa5qQtkDTd9fZ2GTg5MMKIFp4po
2GO3Vb82KTtLyNHJBA3Vr3WoE0QFKbJUtJQbQagpE1j75Nss3MmeD6PBxtO/91MMld2/CC4tKKZP
Mmjc0+y+ISQQUuLjVuXsSXTHSSesuqOO1Hp6JJZlhdUxCJII9RdmsMjDh+PRcHDpMhmBesYMPxWf
6KI2qMaS86eXgU3irB/xZxtM9SVmVAKy9AGtJWJJ3zBm0SXKurhDKLW4BK+FrakISab/htHCxAux
Jtw2RTEWBz9VMfCdMYlaw90n/ZAbKEhgBI+LnlKrTrMGQxcpLut49GQkqV8pXGVTjH4dPzgxD3ir
/3OWpZAhOAWYCImfMtehFOWoDn9/kpyNJf4QFP4AedrnDjG8wuvfVgQ28rFtEKJmtWhvtGVJYVfX
H9SDXEMo1bvMtDNGpgNTc2Fg4PIeL7UNLNqF+u/M4c56c0/2FuTb0Z0S/Vx+7QkPNk3McfphI+14
RNGYpwlgNkqMjY/Dwgt449kmj2QWzQh1qayftOPiRC2uU70KFcmZrBRQSVA343QUHpsTebA+ZM7o
2PJxr1d9wLwZPl+H6hIAJcfZazkYgUN1i16tkQVJrbt+dM+9o8kl4ugk7VQP6guN7gT+Oc2kjwGp
nXNkGH57WaFb0/hDfX8s6Vnwk6b038pwyeXJ9PnpvrQabjYsfFfIsTwSJo6vHVIvKwsqU6p8Wy5u
wtTqV/Pm9XbHfkzHbmDH0W0XaKrsR+DT8EOcHiZy9xPJL5AQ4EzAONKypI+JMdKkMBIO/hObQmoa
MANbIDTdZb2ZiTV3LCOcMHiUoM3543WjvffYRU38uLPkoFRwU3nmxIlKbj4icDb1kYCK38mfflym
kYm9hve7dEL7x+aLjuMPU4XwcZTQybm5iHFzmHXyiSUiaU3pmWguslXLXG800p/VFaIxlQf0JNUy
GqngWIQtcPpGSio9lgYOdKTN/I9SOupKHzsvqf0IvfvHl2nOX7DfhqFUqb1CCwwTjb7z2SGuO5o0
MvS41kOlt2xyv2OPzd/7vvQRZT9U2+a4RAcJqQoEhgwakan0uXkdShCLxUwamq27erdo9cjOoKzC
XMkXwmBvzJzpnUmfDfc5eTTtmwwBn1SU6ccdQpm6XC+unapZpPdbZiKPpa1wQh/actrLsf7BHSOd
ViryUBM9S/ZgPbj7btvNojv+s/nUKd7+fxEDxAPLYWyLZk0CEmscCQ34McfFMDlvNzcUSuS5dnZE
IixldzFJKyxGcdCZuPU7y/64qepKn3pformHLfKCxG3NaZs59I7E//quvthpWAQ6daETNPy5qclr
SxNqrDi7Ccoq4lPzTU0xRrsLDq6QyCjnUVYNvHbttuZI3U17Ds3fC/tMUzNfXgEbvL2+oYMMBSmL
5n3xAhp7C0vzXOex9aF3F3PpkICWyQ3Vx0PR0UPxTVJ/Ku0d9NOKk89PnUtEIlHHS0hudy7XFdmE
8nMvA1eLoFsvDDGhsDfee5JCOPal0yDC5y4aSPhpfKbBu/Lo4NMvDh18WtXRj1TpehB0lHmGW/g5
aYKZVVM5ihe2x1zenUjVU048m8IV+i+e0XwcmycWicZ9xUkEmOiP9GqBPtC2x2VNKX1tB+W+3vW+
1pEmYJzRRLilydBbfMwYLG6EM1ceXhAylX7Vz7yvta1Zilpmv5CK2XmhB92JVj8dJJPptgVBmai9
6pFLIFsg+MNlc4Fp1z15GHUuopAJDoYWBjRHD3dzUyuRELrjETsNuYFzQlSINrKGdXEaCnc2LBkw
TsOz3PUbnAdaYsnXa3ddchIeCaWisz+XcFv6SqAT183VNaFBz1eG7NckyZsWKETuAwwevwBek48s
6nQkTwASXI/m78ddmCiuRzhH9eaIBwDyeNNVxR9wKLtOXClIsMAstxGFxAm2auFHbFQjwx6HmrpA
Yq9oU6qT7qE4KiqQXtBwRTX/5tiEkoVHROqh3w2VneEDe8+auLJMMFVe1lbpk4d9rCHMNClGxja9
fBcJHH56KESZ3h4xAqKrxdQXW5aFGLON8jZj4+OvdFWTuDDyJBaa0kgYGOkqnzMX4hdwmtAts7ft
2T7Z04grtw9gz2ya48IcxnHI8EyK0WhSHELAcJH5xpzRCXOsFfFR+2qmG29vcXegRf/u7BSHTp1/
ftq38/oTQh0y7z4OEZ4a9KDe6YlcYCPnVSrvUEaguKzWK+CKe/FFfHAB/TO7WLZIlPinnZoYQcQ5
5x+7NsICQXti23a/06IR5Y4fKQgU6UAWY2a68YdxB/6B5qPjXKWwShwiTOawJZDVxT2HekhA3RR/
TGVXFOS/f9t0QvAoAhnvo2tiAkgcl4ARb1xDfTlNNh5cFyNPUXKNJl352H4gjfym5kuhBZpT9ePO
kNcaOd17jzb/rZU3uB8U7JJmLqFW2NX32HfGT/Ar6BfHtIQl+JmswsMaKScAIf9PHLTED23mFChx
XnPSGVGV0xdLmKWYN/GRtCEvpIWbenNVa0xk7TxTqEzl7vXrdrng8J5xNKasXxLrKmTiuW7ln30K
NlKi3g19RnyjWc2uRiax07UW7UVbt8eB5t+ciPh/+EoLlvtz/GWb9sPJdOBf+i6EEqmHLxvbv6XU
XcYib87vi+BS9YGcNe/NCAHyMJcpsS/XN23zp3pBXvojdOgaiWJyxsGMNHq5/h+yKO3TrVYUY8pI
B03NiuXU22UHfNtYYzGoSKV9WRV1PLTUdwVtUex7KBD4xEiKnRBJDeUmMVCmHnnyxkSweyNpPtq0
3JskvQi0+XBsuOq4XiGl7+7p8bHvNUEyfnu/2s7v+lIrcOOyN3rQndQN1AXfvCIjBrmFUv4fjF+m
WO/NdljmUzvI8BmE87umI/NkZlB1kqThJPKjOXjYQwUrxSvjRrqc/vNq2FfSGXfRwxijNIm0qmeQ
9wTJt1EUj7vsC+c2ggffI2500aWm6iOKqKHv+sR+/vHV63dTOAU37Uc0j67vSTiBgT8t0GmJeqGz
/hTOP2N0ZFrZrRpgeAqXmhaJxX2725iRig9VWrl4XNRVEPvio+joSK03DXyhn24T4TycBJny7Mnh
20dpADzsmgVej3xsg7x4ehFDS+6kc0bNhMzAw5mzPd3BZ299QbFhw4Mf14E7sMpctnZWRjq0fVdo
fwd5VvgR3P9T6/4Gu/biA04k+xvQG569SLmO1+ZWQGDmhcf9RG5zQqo9r0/UIDCGKbDSJ7fVtbh3
MQSWHVZ3Gwp/lcGbxHbm+3Jwo/aby5xTsn9tvBAf9qUPKhpLHvnNZgz823q++aa9XUlcX5xnkhDN
Vz05QPe1uYA2ZRh7Gv33XunR/4ilhm/NuVCivwYwEhhbqnC+8OyTFtu2cRlNBktWi4UrM3Z/lQ5A
kmNxDmahVAMeME39zjIwFygg+k/K2PcoLmb44hl66kaRLwZ+IwyCoXyROXKuAilyzmxQaClPjfFH
YZSAssc/J36SNx36SAc2Ww3H5TCwWZWnBxFkhZXO0suRKTPKkEuu3HuGwh78IXVPoQeBax1NbOny
k5vRAKkD24mdqmUjZzpJCYpmIMjRk4dmJNeHexbMhntaflIDZh56WkjPpDn58ew4qUe3W+ac7hFa
jNu5D+8YJ8wDASj/+0gpLhq8X05Z1bc+3U9mEHvjc6yYRp/l1VeEEOYDkehPQ+pu8LfzhiZtgsCy
wG3zrcXcceFuXvGy/6Rj8/DxZKTlbATcDQLZWDCIMNDFOIewbm2ErrRdvflYL3g148AAOzNR0TAZ
iE2o5DdHb3BLuo3sGmW2994lSq+x7DYNFB4Oc59vn/7bBCmMJusQNohqjKKIcqElWtRzK1HpbM7o
pA9dwEN7Scv7dtBRWlCcgltBArO088xtENV+4FoIS2dYjpC1o+6DL/pUjm4v4QtInqNq681uVXts
fUnPeXdBvjTTfScFVTKlg8u0spVgP13ulktqOVa3LWoDzf4CDUchCrwZaBjIhJ6HJraFTDPQBL+g
P3ORL+KRx1+IGTL56yr3LLRs2aLu7+pit7Xh9KafY/N3avAyrZnmMtYH2+2qp9+s++rBXRC7va8f
mBiMRKPuXIqEXCt9jUj4QpyxoewLfcONs3pgxP1rMojDUMNVzQ6tjCUZjFT/4u9+Kbg56OeB+Pa0
pLS3EUKE862hp09Um3R3DEdYIFYTGhsRsESizn1iYmog3huZI7M9ZykJjZ8IqjnM6pHRLSL53LL4
qnien0IaBubAoMiDuOLJMwwr6598zp7R0Qldb2Y0wPGIFHMjS0noLQLqoO1rfR+SkkkhCr1lu7oa
hoRFR1RvNonaPULoKbOKb22As59CxZToRKlRgho9fFTA0CgzlXylfl+UeA+/lf4bhjS6qvHstDvM
MhoD/4tBnF+qdgAkOIpF4Ic72mgEDc9ZrOqF529kM+3ZacEVt2/raVO8gHmdfd/cRPMhDKOHNIhm
Os9/9zDNj5i/85H7pFSniAYP4oGP8VgzTPaya61rCBn8+MZ+qrcvulus2/VuOd+osdbGgjQrjvzg
WD1lYocM0DlESyjj7yFsO9u9GAajiFyGQ46fhkDYxRUiL85llxhVJ4FzBbNV+dRbgrmlbcyaznOo
s2df/DLsNeZe93CHUTBIGi2C9KWZFHdEXla7G3Iedrf4uIxOrfda5VS2xvWeQJTRN/cum0fZYSzj
H33pkwtMRsXq++HjTSHoTFB/5erznqHkukb+pRGV5SAbrdLns6JOuSePF+iSWzQH6JNcndHjbkS1
cmHr+6NkkvwZ+K0evZ0B4GTrrY5EAU9N+s9O4I4fjrBZqosdTVvkn+38E7pjxlxUB2Farn2xKXbp
c6G0aaANrdiYMAjFLJuVqKicPUGM4L+VM9pj8oVKJ5+fTmy2sRkaLzgUMLOdOQI7TqXo8CLgit3n
sSMtBE5YwfHQ8cRNKfp0dKDE5q96QT+V+DMWOEaqzQv0PSQRNtswowvW/hvN6FZpvWwQHsOAuQRe
Sw9gGKaDQbkd36MtjdAundctufr1Ce8RsAwRaIEtY5hSS7QfcAGwHg+IhzhfsohCcU+NoGEyOD17
kLAzpPXFc64Nbf0v3QeYJfFtKIpXW7SKdc4qTiUTNDcO9bwVT0ByU3TZ7IrzZsvotJgFGodZhYFD
7qMfDh7KxgxZdFZSUbgHtD9CCdTPcBSK1ByyHB7f8Qd+kEnXq75Rs2Db2CNMIivyP+Fm+ZcuTCOy
qm8NmF50XSlxvWx6EPFMbUcN3feEb9LJMf2adrIg+/mPHQxmQO/IdbazORTVnqC+9iH6UC7TeoiT
7K5/Ewymf4YF8lMnDhgLcfUOuAKbiCqpwul8G1S4+C/rKTNzTMF2XGbLUD/7mrKO2jQccQnlUOxO
sLANjusCIzPb3eYi9onT2JPMR4nDOr8xfKqTfTKTf4HF/fIFa2FiDTvvwL1bLxw3pQ+DkuL1bMvZ
FCRSSr8jKKcPg5LyWUFBeRaUC73hbengTVjHbR2CIbPbKSxn9ku4ObKlZpaNDJ9myuvuSXZUfK9e
2JxnBBSAtKLdCnxSvfAemSGvIhic9kx4ZM5gJR9IijZc7JBdQf9yZtvQwFqGkFHUQR6xoy+LoBlY
RMLkrvyn+j7jR6M6i2Ae0ZvFHcMD+NQUuiiQIe1yUKnfKGCXx9dY9HiODY8Esuhmvh4DrzaR3KFj
FpuD3WYnEQgNoVR7WDHMKtBZV9uP6Ja5xWQlExeONnHxGxmvZnYFhnNT35VJPM8EmsOt8KdmPY77
yOKZZTcfbrtB5D+NA8eErrj3GQGNPiXEcRWnbqPNjWqWigMLzzOxoj5Q51STDvKXZkZuSYHW0N/x
5qJZ2b+duNH6Zg3Dpf3rEKwjYcUutsosNj4yoH9KvTw9tHsDPRB9YDVLNrgPaADR4pIMnD/ce1by
rsxfvjqulO4jO+7sD30T9tAcaAKsh9qxqAD9Zz/TdUhvQxprsIr3zde+/TMzmRq9EVIP1AvyaUGu
34samC2jlugPF+r0nQsJDWyQIacqmX0wuT1GBpEcgJpdhr5hKPpL0/swBA/zjn6hK3lK3WwjOSsn
3Gzol+ESq+I8np0ZJPju7IxBjzf10fPqi3AcOaQo2nGmvnMDVpSA/Kx6CY7+1dIuGzano+s6H550
dpYNMIfxUvS5uPHX97RMWEmMkknShDnnONFmFO7ehV+Jot7AjAsIEV7Dkq3AUw7xaOePbtX5tiDI
32LuW3Ldk7aVEI80l1/zcb6xaPzdFAkHBoeGGSeR3282XnMYtBu0Jc+mRYpJ2VvpYgn9ymcIqjp9
Q9KT+YKC/ffPzvCOPDsLPkggCdm537pjHdZu0BYvw9RAvGPtKY12eqZ56UVH/YL+OdPexGMgwCF3
KQTiWUvFuaoyyvHptIBDERCaH7s6PUGCABSe1oyA5bNMBBAagp5BCBnMfQhERi61ryDhH0utSFJT
d8/IJ9xdFAK/EIDk+gLmq3zwEtk+9kT3zNK4zLhmFhlBwMwEKCVqk6PlU6FxxhmGja6NBT834zY5
SBwC5ZKfIMwgR2HFyQ8nYTxkvAJIU79eLFBQD1KXyg41xy/c6pydFIvg9er9gS5NQhZ1dWE0NR11
VRRvwshzPDfivWKCThe7jXYhdgwsur6edzVnKr1vd+4yYjuARwbLibOIFYBqEyi75cwyEgiPsfqE
aS6xPhr2y41isG/lja2ch1VPGdBmytVw1KHFgnTPApi2qIE1wD8oba0kSFG0gT5royyrSzTzlDS8
MqtUU5rvMiPiWZ9SMmMNzveLscCETDdAm7oCLbbt5RbXJEmDgGuhQWCkrUuT78gVwougyXLiIEXS
MCGQvL9o/FgwJM3nfUW8/Dpo9HWuta64Rarr2jO7v7jZddsww8/rI07QE8omTLiJc6HXR/WSM2X6
hD1zHglbdbZ4Z9ElDJsqN6h4GXRPJavAX4B4Zm27rOerqvjavmYMilGiF++Kcbc7l8tUmykppy0F
DeoBVEzjjmz4ktZt04YyBhb2p/AlzoIDVUiy7c5XNrSX9MPUEUKCBK2eOz5n3oWhncTDBFPomrT5
omP9oeNMmy3DcIhjG50gf8TZ1mfIROqCxNSCk6TS5pYDToGN862lK7lT3pOeWM6nWtOqoN9XWhKK
0T7DsMxcJmO/eeMsxgl8cZzROO5QR4K+5xp0iN7pRHrcqR2rk4brmt2XonwctLn1a9uNssl4bdC2
4+ucviBIkeyNb81CKH+UbdqNRLMto0Yy+ZhMqubDczTntrsQlmhtJf846nQ8J7xlqq1ZfCk8Xube
5wIPR/zOFYSFdipWSoboUr5TSk6t78Dto4Zeybygfb7AzIobStu7utezcuTOh/KYkoaWTCPWmkcf
T3cirOTiHm19FzJIubZFMkCcfMo+349UGrgKLBpYj918GaqO/dVUbzkGGVaJc58Qfw27qUavXdNU
e+kS5YXp5m+R5cC6NOlyQAhmYL1e3odxtmI62nq5FVlTawDJa6+5AxjczJ/BBO+x0esltOqbhHbR
xcJB1M6GygUnlFrwG0UsztjsYZQSxBuUlPoVvvs0iBWpSPYZ9GzS73CJ/3pGINYapxMy4DUNwXL2
VjyRP9xgT7mpYKHC4Tk4HR5njOudWaEQ28bgbpslzFQb7LGhezZ6nyHdwAac3FVIF9fj0iu73H3a
rZfNdjycDEvsypVMkBgE1IcvcnQ3ejbtmSTZl2PcR9yjbEf3+jT+Os8FDvrb8zoraPZJOKDTQYqD
kg/GE3AVj5AyyGAHMVJPRdrRcYSJosrZ3hxeecuk2BcEwiiR8g50FSGr9MoB3llnGJNzdHNVloPQ
B0BEhoZBG6Y5BTR+EQIRVngjwXnqzE7jPJk2gxG7y5t2o7zohzasWsSkab/htZf9G/5ndhYtnmOE
cx6cZgHzi9y/dm6mWKiEa+7xZmqWkaDOUE1JOxwX9TDKmV36DEKLtydQknNeTb9FFperDJ6Qc9zC
RO/RduYa8CJ63GXaIcYIvXLhyGJT6I4ixzd7KyXTN3qsvlGe6yEp7zGybd3owekKe5u4kZRpxqoY
CJQ/qVkgjtRmnNdhwGSU9gLPKE1i8DirXYFXJ6F1uTzNpcNzFhu1Oh12yRtjAH63GKyQhgc0NHdR
uhEbPDVnKt9bo3Lmuf2Gue7EfNfpgfyCvfAR0C2YGrjz99r4cv+zdr/er3LZWPxXlj3aMi3i1WHz
BYNihCYp0TI2i2Nzu/FozJNI7zX2etEJRe8btrYkrdic9GIEoZgoxEJ9rGfO+9VWVhDdoXvU63Zb
h3KSys/6laWB0TctCwMfNb/eNEiAVzYTwYJymAN3jtwzSPUX25044npUOxjJH9udSo6k0SEsAx2D
PdqB0o1oyL3PcezTM/svdV5BkQDmrF5efpCtSNcOBjZv7lmi4hzuqJRKpJxYBZ+K8FMvlSlc+BVD
quGsIAgg6yDXu8267VQDBZ8ZQsmT6avbkRQCEs5ZszgjFYmKoIX4mDaLVFCNB0XbDFWHXihkEUhr
1nc4lAVjqzIUod5wiZ5bUZvkM7bXIHpeXYvBKVDHnJ3FZjir3DfEzTk/CeeHdNWwEd4MjAsVhmeZ
mj3xsdb7LGv4tP6/h3N5HtOHYibGyqIgS4Ct0CZQRZZPayjOx/tiB/OuYM4CnX5ihmlZEH1iFh2l
9XoxzBiz+wzQ5AeEV4yhjaY6eQltN7Ftu1n46zG5jPe52kBFYoeLxGEA20HSRF3tc+oKvJnEhyDn
PZCj+g51HP0QGEOtWcA9R3KQh79sFnfCMEydyy782uP9w+zHJV3ciZt71x8wE3sHuXCcCJELTs9g
kHpT07DHl8t2vqVkUBgPspmQHpjdS9Fhv8wAQcGSupHGrDw1+sPL3718P3v3xzcv09ooW0t+Gt8A
SWXmaMbQktQq+bO9RNe1g4bE8eT4lFrTMElqaqRICKP8APX1IOpDFrn8jLf1XWn3AZrHaPGV9/Hc
kNkOeM5ndDROHtg+g0y4mC2rnkpxdyLax85X0rGmBn2I3bX2OOaQT/xnwj8Bm5p86yAd90F87enA
aCN4QoGHL750/Lz1DwfSiRhv9+yZ7ZSy8+J8vmD5hW+vm3q+Ys2pKnCJ8NK9OAilgBNa2LL4jG5v
URg3E/0VjBqHE0w1yko0uRh66LyGWYcpA6ecNGpVv8F0jgJchQqimdjObZv2+Vit1zPbwQyb0Y2Y
vHB1pA1dUe41tO8PmOCx/V6MGzMPU0BUc7cBMZfNwgTytYT7XTmx7S36/oYuA4zCO2MT33w5u900
6Pknk0LVPtabc4S0UTs7Mvy0HcZDeaUpDCUhR96dnoGLP8IdS6FETjYLsImt8Rwv+pvEpp7CFCvz
Yat6UhWLl6bYA3CGASCshU61WkeYX44MWQojNfYlK/aO4jUxmkedA72wxnh4TDUMmQFCsE9yijox
6RP31eKRVOcYkFMvKREhDPvQjjKLpFou/0mUdMftRTT/OkcMtxqanQmvc01lImOa5LYCqXu0hzBN
eNDF36izRzbaVfKemLRnQz0LuRyS29sKY5IzCXbhTVevx0C4UaElh9nZVoiCPO5QgSTfltEHxVMT
4xZeukP35XHxuYVLPvn8lEJNZ8OHwTi1ja+Kz/OcKesVho+74uhIxuymXxfkEA6X25Gqg3gGTalJ
cbWp65Uktv8rztCCqqSnAJ7PZih2hGgl8DiVJijkHNNutReqdFdl/D+v9m2JIWP/fUYtaNV98xRU
fNwheBj2KrZSt7Vx/mEKJpkDCR8pk6bYyX6unO5RJim4QcQVkM/dKrkYTGY0hBP0cUX8OQ4vwkb0
YdChph+nslUmdSrKdJjqeLltx8G43EDi1wFTBJP0eIHzcbnSZKefPYOP9+nK5eiSPNKJgypPDj8a
a+jZrFa2e1I8YTniyROxaXkPV7lEyJ4+50C2c5iiD0/DfBjS3W/SxpkOolmcJKR5IQHdhSthkZc9
9LK41q45Kx66kaC7Zxbk80w9+6T+q0sxy75hB8fn1d+Sh8F5+xEOMCpckPlyeRW9G2gn/jtqyZUr
ejr1stlXX33FCl6Zzf9eb9pvmo8NXu0k+JXWUbDCf549/Zzrf08olWTQVU2P93pgmzYHLc6LbXt0
Xh+JnkpAV6JR9A1g4nDpoGN/+r4MJg3H9hW312ZGhWaE82a7QY2RGyB9ttNIxcMhX+PxXTnVvfrs
6Z2diQPHfjkpHhj0we3cHR/y+V/jJtgsEHWwU+fqhtz1GH5UiBHnxpFQzcXhazG8HH9eDg8Yxxvm
W1FsxGtZKOVR/D8u/La5aRBLgPJ17q6ut/Y0ib800ALe/xMJUm4odQ7m71CtH9E6WC/yR7sgRBJZ
Pdh1PcfNHTbyTKBm2L0axBQ5byCT15v1hvRwsKWgrd2a/JauYFchvIRXtMqJfSGjglbwYjYjovzj
ePrds+Li/kJ4gvHZWTy2o6Ov0inBhwSZAquJSC64XDoHOO6wpCJG2hr4nGfrIwwUjwPyBrwZk0GU
Kr8RoKVMyoe6XpMvmc6e+6CFl7CIzNL3ISgEoucQOYBacefqZM5jlRYozS9IrB9Rrb5tllRkhZQM
22wuMgvAivO3de0cvtpLyeMiAz87227uYWYJBYLUynBFEw1gBeml+mIu6i2QdvkcdOzd3MzNGqte
dOaBfK5B7gW2xITaEHxLfIXgefya7iE9VxECtsMkptS286iwKSs55gvECu525+zb7qKt9Qq10hFj
ZFxvt+tu+vTpFRTdnWNm9Kd8zx4t6o/y51PC/umePvvV3/kL3YrNcx1VtcO1EUbkt9xpOOQocy5c
TD0X602Hft7joXvqXTfb5eKIUVY0WLzdBOCbQ1ixDewV4c1/C5LHS88SoGjwWO3Roa4sx0GQ/TsK
XoLXjBAUF8/KIar5glIHQHHghz8u0HxHFYwGLWwr7trqzfY1mdQrB4PQLyTNFPYD3QIvmHnItZHV
PJLDDqIxdFvLPCDlnbD00MUifZC8BothVbPpGP8BIcqRKaXf42exXEGPq8sZUZaOjadBGRfFFvk5
KUK28HxCJtn9j/XcYdP9CuQIuu0teZjTJyHvfLNulrGcafhtvItn8v3aIQeIYcrc9iKG5kJUhkWz
WI3ekWKtcKUpzYWMlZJiY+q4KwVv+HXUjOpCOTYFJr69hxNEbtCWyxHV9kN7X3ZOD2ObifCXIHvZ
NP1TS4FWxNYjwodh7f8NRhiYib559U3x+vt3xQ9fv3r7cuggBsKz8RDMwN5zS6aNzC1x3EckTaUL
wZcgnYvpvUaWRbpPu9JaDqlkVd9C4eyc5IFNpY2gyzvzwU+2a9Pt3itSqNB2jSqPrL1s73pYEw0Q
iI/1BrlVymNQfFmMn0+KX5VxmtP1/fO/myKGlRt1idtnxp7uHPngMiKK43ziQP7IsFmMrBa9xksW
7tjz3VVXcWha1W6u+Fr91d//7Rf5S8NRQpgQdM4MrrHMRYLjRhov+d4mAZTjdp0qN9YM8SiV9K8x
O3yb6tlN41BtYHjJzsAvOzfwwQ5Kj3rq2eYo7IO4zwzLvAOmTvDQvdMusGlQJsLRjVHRZJO8gsKT
4qGITOCpXPNYA/cde+CDzLTk2A6NAhL4MHGGQPaV5ZtMsGEYDYdhnGRgcgrRDGWwiWYFG4o9VVgH
H0VoFRb+iLLNSmEBkoKD8fblOx+Cf6yR/aSq72vM5p2N4+8CqD+H8qffEI5ehnxIZuzAsY4Hp4aR
NNSui9kG8ZhD/Ci1ANCHT/twgKX0YH94u8FnR8cFi88uPeKUZzrJOG+lheLenP9WijICvenD6cMN
RVH5DgjX4w/15E2wAEV7wbUjRKQ86oDuAg8Yp+GO6VZwXlkOGnfWdIJEp4fJqlq5SAyp5H79q8R0
4pYWd5gwZ5F5nrtOe90/er8rix7AyXcthPBQd8gQyHIm1Y4i97ksUtZfrSwkjQHZZLO+v5k0Wb0D
SO8ds+eDM9DnEKn4hEH61R78CiWcJp11zgPIJa53GbfZ33bYky/Mw7rYtkPYBUXq7MHjYt+VPdAE
tMIxLEEaoz5y+NvChCWwA5n8AzZRQpC7YA/+vmDnuaSEfoNKSkI4LqvFeHgyLJExymR8VnkZzW5H
z7LIfGSwmjane7/BI2cKDk/fNM7W9/iZeO0nMzlmtAZ0QeSIBxK5mKuQ6UUtxvPquSCy6kqKliqL
7mAPe3Ja81A6ITzMkG6poYDBBVZpj267W20zJASZEdHC7o2nDoH5GWeGUCEEMoLnjBykxn7+js1+
7c0N8Kgg0BUHd2LirjlXpLiAY8p0BJYJA7pTLypLDbJYNJ+SfJCcpvZYJruJN145tP/Ljp8lwjax
iN2HZj0eXiEwMn2Od7IkDxpnPnmMMCKFs1AN9kYEOFeliRmTvcGyjBSvhwW8NzB3snYDUkU8x2Oi
IRdj5ZnwjjSvT4aS1+qUlGic/w2t1y7dVVCY0wc7xJikjc+gDbi+h5OonoooaVVt8f9n712f3Diy
fDF9cwTC4bDD9v3oqAGDiyoJDT6k2ZmLFTRDUeQMYyRSS1I7nNvqBdFAdXct0SgIBbC7d1b33/Mn
/0sO53llnnxUAU3OYx22doddqMo8+T558uQ5vwM5baphFuS3HkFRfkUZSNiEpgki5fT5ahTzCe+g
ADgk7C7quZZiIe2CvOZKzJOHeH9owO4YGVwg8S2zMj6zYAtk3RSuIWXeavOhdaVqHYlY8OKk1ZbQ
4vsXCWtMf53kcJ+Pujtra1PBpKWozQu59AP9Vd4Svt2i0lK1Ygha27/c7CF799K/+i7eu9b1+tuB
D/lb6d4z2iPLvAnr1Fo4g3aXjcfr2PB5JPdgPutHf6AmwFfhJKHLq73jxRBPq4wwwWdLuEMKDaWh
08Ez1V6+SH0As0J7wYpj0vImEbQlOBU6Dh5Km2pzRE2j/HDc3Dk7QbfRzQ0q+KQ/zONpiZtlBKkR
ys+hi5Eh/gr9+ugWcUjYFWeZt1KRZViegyH3kFsF21eXgyCJ+yJYpwAzffQV7R/oHRJcB3nHh4+C
cwlVy44GmlYmavuBJxL/FOa3ptP6LpapMPx8QvRQ4oa6Q8Ng4Dl5hgDAr71ClClE7KINLAu2YExh
RTjmLz1fXIWbPNevPnaNvnrxRiY5YuibZE2aEkFhPJPBRKg/ijYLt0ek+pYwb+imopzk2dMnyAwi
B01WspeUNnD0AfbdMLxkNTP1ADCCgACw8XcrANY3EgeEsjIDci8An2gJYu/6pPXQDqm63fZs14U8
xkZbMjNCW/u3rp10KHjt2q+rjtgZcPdwebnb4hZG0Q7BYhaVrjPYSzblrGE8HoWhKIstWH7+VLhf
ZEfZgz1zAXaR/IjofZX5RppNkXSZ5L3sWyOB79a0HXt92ModdP/47REJQPUlueq1rWnSs6VWNUcR
d/BusgeabbieV4iNwbfEbl/wTxjeelbzgS2UuU6+EFbsPwlD5TxvOK5Ydab3Yw6taKg6TAss6rA6
Wk1fUD8WT101zU6VqiGJKzkDVdCZrg3R7cpF0SgXfvUMdfPFhUNzFSRUWrOuJIrLYz9IX3XGmZNX
V/RJtTJGgG0JXgeNk29B+2ox0j+4eXfAcn9LOFi7Nd79U3xUMDAQGwFJMnpt/nlsxKSnoXtaJwav
7jQEQ7SS1oHHRwUAFxzZlcTi7xdKlBdjjbSnmn+bqM0mq0soRIG3d6+WdCx0DNlH2qLDwAU7xqqt
T6OJSPF3i9YlpJY4Hi7buA/GrG5uGhBTMVCARiiyAJKI6iI1dtEID6s7VaBtCchxMVVB+XZPIGaU
P6lA0inBCPa+9irhV6HYVhtxHEkPsYJrlCvZg3pA3FS067MLbcf+zzbabgCTuli4by6uj51MZB/I
Bpuzs23pQ0xi2C+sOOwjbLzVcpqCcqrmwtP7WMdin6OATcOu2SFcE04HF0iwuZgtwC8S7EqVywAr
leZwEolQ7pNhh9llfeLJpVYs7epCzukZtSz5JJYSfH04k7bh8wIbecWHYV/p9UTVh8uf8F/VEIRD
ovktaPv4I0R2JH9l/kj+xAwCFiCXWg9id8392h8hIy+f7ZbiA04O0WLJhrcQM1l5vPAcKOQKbQIT
hUWwXJQTfKPH65sQHhVBhjyYpLepANnkC4UzaWZ99wV8l4g8f/Tdk3w0GhUA+ZryhE6rPT1mcEx1
9VCPgoYfsINFjrg8jkqzDClK/MYj3ZwHwyy26rHY6qwFCS+FQ/MFDAizJ08ZCUHYoclTVdTqivWb
ys1HL6SEYiM4RMt2XuGFf19/7Q/jY3cRAgi5CCdtXuOVBVQUN3Pad9qd0vVnLehL+K7kIVGFxpjN
DZecOiU9R1t1UU/lPh8ZmNOwGCa7mZlpl8Ju9e4EX9JOQsoz4NMCg8quAbgm3r7FUt++zf7BUnr7
VqpgXpMXNrzEioA2bAX21VIN88KCiRI2g946PFJOeGFkA95xBPIQsS3NrrLiy0N99nb1vEJcik1J
C5v3ImqYqeYfYYbbi6HPkTuhjY/yMqJQmyWaiXvDAM4YRq4SjwJR4cGxdAkerDMaDI+VRSpJhlE8
N6fdkjSZzMEFjUG1SQF8uJ2gsMjTlhFKJ45dKaZqZfWeHC7MmL+v6l0DATgR6dJ2SABzCB+Bna7q
I4uz4XxhoEOJYFt+spO0fgVsQrVDTMq3b4XS27dD6Flg1/RIc/ftWz8g2AYHFbdFxJheIPiGoKWY
cYHnZXVWkk15feaPtV81mY5jEHYILAMt+UGRK7TMZ6CSK2Rs2eXTfJ/ttPRF+Uhcewc0Z3D+DFJx
KtivViWj4Dsk+FyVs3eb8uw3KsaZSQE1nGR5yNCG7RKH4weFTyqIdKmq0b6tERYfJjqW+hwYDkUF
dJjSzUtLIximMpCXXOnhLZltkKtRIhYHqBRErO08w1EMNrvU0rYDi3LZ2gs+RDIVGWNIHCyX+t3g
0BC8qDbeVtKmOQX+/w1pLlGk3sBdRImSGKRcJBgVswDFbR4hWI/jnwgiazoUlHIloglZkf203G5Z
iqRrFvSEC3dwQe00Ww0IvajZ22Z001Kt1jsFJM0HixAM2F2KC8w3YhIhgzbHgYUAeZPX3GyF1bDF
M3q3H/gcVaxdznTkSkTdV6G/JZbTWrfstF7cpHlIqCufzhD7WN1pWOFgxJuRYXG75RYspD0NeiJn
21zo1rOkNLiHrfKIbuRSb9sZ6PutABSYs0JZsVjZhhNI11STrM8bZz+9fkmn931T7hY1E/+mPGuP
6uz1uzDgYYaODbG+6EDgy0T3hzVKO4p4Lj+XNUxBxOyCWQk7PT6S0veiXn2exfbid+jadGn2GFKl
8w0oMAY1Mbm1zpJCsxmFB9ByVaeFXiLWfm2XviloV4cHM1+OEeDOFh4l5LqKGtIWqJcgeR+Me60z
V84YTA8Mfdz3VsWhwjNoi4q7HMGgbZoU7ICN/upnYAyJ1Bj4TeYnc4ZCzZ4N9el1X2L7UJTHXjRJ
DLUMEt7uNLhSPy3PwFEO5hDGJm2DILuT5UuEGtLHjFRL7HpO4FF4HHbfYVEWoSLjy+kR2xK7QHfT
ISZMNoZcxLCYWeX++X2oTutFuhAyV+61ACOaBPc7bJ4IaBucSS8r8AsFyeYU4e5h+jk3OYmbqLAC
QUUMQGcdJcftl4CHwcVaWKczh1cHBg8ac46AxhksmGHMBcE8IIO46lsEzKP0grdh9RSdQHdkaObw
hePW+GEZVZuihezT6hQhZboRnPGxl1MhJqsVNMle7U61VelQ0Nox89AHIdVrJWW3N8suzFQoN0dL
w1aWGVsAWYEHhTHEHABouU1GqbRhh6uZL7H7F8O+oK4rAv7O6H8D/iRoe8G8QVAZvaHL+V7jdHf+
Gx25FsxMt9TPoYs3oe/jzIE9rGUDg9IxueKr0Uq/wzq/fXOJDh+Kg7CdZs49NXGdpi34ViAKj+PV
EcnaZ+hdDM2idYw6UtESlEo9nwgdt1d3rCFTUP1+OEC8KsrNCtBsdh9KopOeBlPjWTDlGcRUQcsS
aNQPEuqCiBQCRH5ZNZfgMZ0fXhwznc0Nyfd4i+lcJgEI4GwX7MQYIcfaXBgBvN7cWKeptMUpea6h
5dR3XMcxIqrCeWKhzkswJ+9uZP3GgmNf4ViTTa5K7m/Ow1R26Jglekhjvauy+XFFeEBR2jzotI7R
BBgdwrbDzimKBLDNmvqIgk95KuGwBwNZTvo7QHj2UaPcUcoTC4OB5qJiQKF2k2JtTMzZgxFO3e/L
6qQrSg+H6yyAf2bPkSmhC6Adebog7AeRAgk3Z0xdeLdpGcK1NGQoTVdWyug8G61oLMUXFX1LrvgO
zIYBmOgzT7TE8K4I+RwGMMFYTKt65Qw80A9vUTbrCowqtzqGoyf+ddyIOq8HcsSGCYF1m1r7N508
UjlVZChn7YJAt+HaRtYjYcPODLtHb0uzis+0yyK0QZ8+VL1a6219ZZRcxG3Fd8pe1DCrhIOv4Cp9
6Rvb4pK5u/nKxjAgdi6WuUoU8fN5HpNmN/Asci9M96Dcf86ekqGJbhwa8h4nGHWFDOQyDhWIIgNZ
79iDB1EXobTFyLXjtBEGgW31NEyHcXWfrISdCgjsWcT6J5Xw4Jw+LmMqLQEErVJfugyKrRCYOlNF
Vrk2deTPlTLSdanbQiMmDHFtpuBTh/WtlyXRzcFFoiT3QrzuMcQNm+JZ3x60Pt2Sgx3cLc92Tb+y
CXcLV4sUdPsa+oqTJX0kfILkoVChXBC/KCWa6fRYYTK/YNs8OkjQjM3L0fnIvHslNiyrkm/rZsrQ
T1QlaPdOByXQkonhCxsFUbvsNsJAfexAomMah8Fj3NZTOP8QKxGyUoQ5yqq80ruY7CaanE2SfeV/
0JSK0LdBX4OrZzUUc7yqBEaykbtYK2gJlSw39W44vJoRtsyyXRSdLNOKZpZ3XjbnyViqTsMSMjr8
fBjXJAwptQxiySsI0oqwPuZft0JI4IFVEq6R7WlC5jMMDHEcJ/KZRSFXDtfpWLcjNAs98ZObE90W
xKnL2TonkLnsepxdMxZl1GIlLlGDpG16s4AvrboCqST+xehbrPJAeypZemytscpKxr8rt4MGFHFN
R2RQddbcZhQsUBtkNVrVclZvtLENVSd0rANxtU0StoaNe28CcKyG2RTNnS0GJd3X4rcc5s6mnC1x
ZYfAlIGm7dmLlrsA7KkpjUofjQ/vshiPOJxs5IDOop7LVHxG4omWO4qGJ/u98dmDsHaRjk5TiurT
P4CkDFM1tPilDvGajlnpywteJQhZumHM0mRCWz2HcZpOCCjgQG1pwVMdtO7ALOVB0X6NgnB3vcT6
SOARWIVu2+7q1T4GmA4jSITQwgeBTCtFIkT/WER1avONiEdvNkf3hgl6OeRQOu5F9uitdDRDW15i
GoDuiGil+znCmY61mXZhWO0BQmTXu9XCyRyyicRZP5vAGV/1uXDFMaMJg5cXaQBsmqKdDogcg/XN
CI8GR0cWWvkYXsCqOBnQAQNwGDFkielsFWmSd854z30Ju4m/sIayX+CWOPQ2waJ990ZKrxksHX60
YzvB6pbpZrFxVbHISMRfLr6XxQq5LY+fAvAdRwLAe9yvcHdeugMNPYYJbAUxjQ/l2yEj2LZva0GQ
59Zvr/RtkQVATtzf8lTxBmCoAI/18qVesJod7pQ02DJ9tLzOJ+SRUR3XDgDtYTinAKBTdY5BxC0Z
8R+3gv1SS/VqDHAL8Cfkd4zX68EKscG4D0heEQAIhutwSJVoN22YDZhwmy98+abhOSF4FJTI9h7f
UAQp5Xl2hmyuKR3X0hGnbGAnsJ7A4wQm7mlrDz8qLVcU1ffu1tuCiFIDyEiLJt1si7Zluzm2trWe
YAqmNQ2w3vn+6+iynF/MVtW8YeeXLXhAkY8vwkBxPRDA1vpYVByaGe0AwBUJNTAIE31Egb2tCXQL
DQiIjaGZxG4Erz0t7hSQa9S5CricmRPgpFzDYcypU+ikqkIzcdFlW8kX9XLReBOB7GHsnIFudr3f
8CloWb4Hc23ytoa40tV8B6i8ytzmEcXQBThViXttiVZEB3RYl6eI81y9IysaRhc+grxHcqEH5uKc
lb9CrCzz9ggtnBeqtss6DphmhtSs691aZnJwiXOk6dtYwjNxPrmHs96BfuONGGf0Dd+taoOAiq09
Kgcbhs/anzc9ZBTk+3INWMvcSdQe8vsVQ0ZbX7BE5RBqZJwEMVO43yUR6dirUVaOoozuel2hA6kJ
hhf6KCxwffgyzas9DDDPtR/WtA1j3xyp0OkUTt5vNN762XW2GLr5j7TQ6n6JGwO3u9qEEznwkAex
zRx/TDEYU5MQT3hgplNiiwnT9kniZUta2OKT6eFDq5u+H8slvJxzMVJ6CStQFUFFRX3pUoVFPvCw
zMuNWfNNWVJp26RbOl0ApiiQ6Do17GDKi8+GMs77YkbvosEYOnlfrat+ocIX+60ZrZe782olbgJy
ram97+hbX3uFB0BjDJFHkKgUHwLAUC16GG7C42R8OeBw2lCXiPRXtYPCiqz9DfE91/xw8BE144MD
joBeBg9JQVm7sDeDMkFuctZA2OxduF2KjBp+zf6cJRPR9cYw8pcnPiMkhbruZU27tcMCOioPxvQ2
UpVO0fOOgehH0wZxoMGnLHQCitYhiMOlcoLndLku9EPuxMPrnOgKLWBlKrJXd4XVpahgOuESmjqT
AEEHwfca5AuXcTjFYhOnKCwIURpNwTGn1HiHH4/MdAfc/0hwE2zPUipqpSuSj3YcyhINCEJcBvAC
cZIAWA9XDqNTCSkUtTifgUAM8QYWAaHTG95qcHsPsQzglgfjMaFop2MHATvDS/z1TQpXznb9erSo
NnjFW3C8E808N3W99QLbeAU35RrQ1fr3WoxXbSH0MGLY9xxzDiFfEV04aZGdhnmYCYqDd7+rGb/i
uCZd4ENmfYcAGl1JfjSv2WMUxtJ3Hgs3Fv8eX+JDSd837jq/ZXNKgK1jp6hB48BaSZNh+pbu54rD
aHL+9FiU11sje27saBxX4+qzBydtqjObHnck+cEOZf1x25BL2BYv1lOqS0WHbTtQG1RBxIYMJUxv
FGAZQQAvkhS1VRdYut3HY2MguXhFYvAvr1bgfOY06GlkkOsTiKg2knIixqmLSIkEwsE9c1VmraQ+
Q37sAdvReSGUtZXM2mR2mz0PfCFjzBLuvcaTx43UNUIviauSTLjMQgAehZFcNQ22PvHP6zdXs5sh
os+AVYRdY223nTCk6zUq9NlDTmzgyg36P2xK0K5B4Wa6WQxrqJeigbZOR4vKDMX7cuNBoszO4ViF
0Q7MyVc3XFvzSlaoCCo1lflvwwdI8ieFnPfEqAJwGleNea+MB5Wi1Q1iqFPV/S8bqDZT93iYVaV6
wG2X5ea8zNETBA42RRwnDMNBc/SmtLaVjNNk8aYqlV7MqZSirDUE1bUSVjLtt9p5IID7oyUeAo4e
BAbu8ukXEw1t49Ul6AxHrDVDqvNSHrXt/aIM/apV2LgWH442fphAQwrQj+wFaTw50thALar224Ed
efpvPbQSXnJkY8W2+D10i4yRxCgRxRErRXZz0YMF0UxU71tL8XZnaHebYRN3gXDFXhFtNxi+YQul
8iJvJseHTGr2HNfEWWDKid0xSP66hltgzoGyYR/w2ci8hSOL+Xl8DC9OTtKywZ0MsEWdk7CH/2cj
jfU6ELgatlnnKuuQGN3RAtwpI0f5bIjqm6Ljak6VeHwtym2cGde8InmzJ035sF9AsTZla8UCn3k9
ACq+pXyWYtrracdI9WaeiB7KU+KWZzpBZURdgrhghl4jt6W5aDSJatEccl0s3A0OPZWEIEyptcAt
3rosRizAqUghVGx1dkNXnMQK8NmTkBrw7gGneW+uklW5B83QHI/Jq6veLMrNlKgSPVUH/9zhThPT
ejMl5Gfc2G2gAsGHYrvgcS+S67vs7qwCjIVxLqXjVNqSY6RzRScuSRQIJYBAbsnZU4unlOs0W0+k
Bzu93L4pDjxDCRs3M1ll9sumJgvfs6kkAEXSk00g2+E6N49Jtm7JdxLKZwaACXW3Gat1c/MXwRnQ
dSn0LcLdqsz6vxV7eiLfJ72+f9JnJJuJOjgwDI7Xo2KNQKlbHfW4F0KtgD3gUPWLW8orto5mzcx2
S1H9EbEAIiYFtU5B2YMqnAQ8Jt4jiPJQeIoNoBICA+nDxjlE2eO4UnQ+mk55FpnRU44rgKe9A4u/
q02tLqbjOWEvRQ6bTC22NS6owL6xaXfvdDdgnt5D1gQsj4MYP+P88Dmaf91mN0LM+fn2esJ55fdh
uS0PlYch7kBMK9p9nCSXhlI1vJ+nJYd3OT7p8HEdXcyaqcQoHrcZwezzXk0Pso8VipNvVWdSGF1i
0QH4zMy5bSI/HpIrvPc106XRISb1VIjxzRyJ8roiCzpdF7xzBMULgomQeq3JzKROEGBHOHW9hiQY
UXuB+NGsY2xGvTaV1PEZWe2hSMUjKJHuvTFIiKYyCNQLeTXM2sbBcsQR7zjjbt1T0uAIZMBWfV2n
ak/o5bz9mgYPjNCtkxRFSjWEZ7zAFDZSYsYx5fYDC98SDIEPb54aPp7bnArldGZXrZZhjW2IVtsG
yUMH7ibR+thpqvW0m9SpqiXfql5FvuW57KMpNri/ySUOGXm6Z41W1u555dIXNtAvG4GjgY2YVOoY
4jjbyO4zCskYEdSOemiplvXHP65+XIHxTwM4PwQwRKgLeVFAAvoqVdnv8kYQX0vbFdO4L6z5NgU3
HNqdQYK9n9k34150GJTjf73xGhge5DsGI5ZUmvMJBRqaWutkU8cK1Hw02i6MbuXgI3Vcvq32RaEw
jlHsRozp62G6QahpiEt4vZ1O+wlIb8yRFNvStOBtX2tZYMnDy9xXE1r8nuIAmJMgv2IPr7b1+tkW
BiO5LXp3Z+0b4O3GCi9q/LGyVizgtHFJ29CMHDQGmHLg9UkCeUz6IxW7E+O+/rUmnS/qq5MEx7UC
Nffbt9iIt29HWRpkpf/MyL7lbGGEUvAqJBg2UrGDIdOqdMZN92w72mhB7mXJGndTE7DGJldytFrD
0S4R18D8GEWTrX0FcJXAEMq3/7MINeTEw5Eoy40ExIhuFDqdRPxr9KG9enO6FDI6UF53KfnVCqfB
4Z2kzpTPSew/1XKjj6mpWiYRP6AQ4CfR8o5LqMMu+WavFGPW8/Q9xBmmwx9PQUx43kGUBeZQghU6
X8BG3ACbXtJUxCJrw8x6APTiVt3CemSSMiRBIjKYhog8+glsTVylgihUC6iB+Tcac+eIeHxya4zi
gIg7QEhS5UmE5k2RF1HIsOk2JKA7ToYmVCEVpPx1nfKjwMW8F/wB8Jno1ITUZhb9ocGbP/bwmm1T
WChsf+pBp+2N2qegq1I2C4Blx1G6VErXoYJz4bnjelpDM+FEDlCKbR/mEmLSI6Q0DY++lpZ71mrj
9YlNQcwxiOviX1l4S6ADwslzUWvHWQvkc+gPZIxT7KLpu/IGQ+X6TrV+9/kUurBU5Ctz2lDb7FeG
+qIDWCtQu/+iEwqtxSVYbNNhpNTd7OWNa7/qy5QDc4iXFqDt+3MyIc/5+VuvdWRo9LBsNoJQmRwL
ONN67Zi43EmFHxDce6+kEf83Jerq809NzphHpEU7f98P63zHGhM4JFdQLzg/3fB2yUadYmVfL1KE
GIoIcAumvoDWUxlqsD4FxMtBva7Kqyy0VVQTJOCDXfFLPUbUC6/zNavFzTmKnipbTnQ+laloo1l0
Dtid7NTMVsb1PwWvJ4EtZ7tniU6R7r6OKo9QG2pErLBCRadpXAp7CEdHzKioklw7w7Z2AbjpnbgH
xCAEnRyv6s07a9HSh+r2DVmYUU1AZ9bYMPOjj+tlv4swDIYNZzdyR+20KhFz/UL1bKclhUh07lfH
QHRBYDK3uuWx/PDQ1krEiowrrad+Mn5mAD9JwN+akQ09vK28SEQM7HXTFGbqU/VZs8+jDsU3yC0A
CTj3YHBGwSmCBxLY4QkgD2LoIc8d0YcecyeEglUqAApwWZtddg1KMUbQES9id3wSGJXd5SkIJ2dK
bEH7090abOGAkPqSw8a6uimc8xUbO4U21WQ70LefvS2OFTT2Y9RdhPaHZU9wVMlJhSwq+vC+P4zf
29g6nAALtCUiteR6Fagf0CqvyYwWJCpbvdbZLe0Y2SscRBNCsW89gl0DMH5MuaNvnjx99MO3r0+8
8y0UaAspWDeYOrpwhFR3fFGHSoLKRmMaYm4QKmy0vhk0RjbeOFPyO2pbEsfzqsHTdeC+Dr7nClTC
8yKiM4NsazolqqeuNnAsWUynfW8JePT0z5HKIuOkzn2ROss7E7pW0N7lmuFOifd7lnOrSvzCtSpJ
+7NJ9yKKsY39ZvWsMsheNbpuwqe6XjYjNNaeLVVXqSOsAgfAwkVha35vZlfwaGnSXlJo2xgmHQ5f
UIY8HtNMxCzoi6AvTwnvBz9JII/YVPDdFa2YrnS68BGh9ubvrlJ6tA/rBtcDfF2X5kkYaXwqSQat
e1ci59Rmm07FFKrAYHnUCjNpVNHQqfLT8T2XJGJAdP9hB8VNyPGRyubzkPY8Jl3PSDPL83pj2MIl
DhPYKSOMyoqjyXkis419QdY0Zlepmt4dRjdnB1ekwrqeyeR+JpGXC/KeJtZHYVQbKc7QQMGapTeF
lGOS7OYXaEBcZ5dGmL4EoFS3JfUBxZOS9nt32AoHyxA1bENcM2WFQ/1rusZMx2bqogv0ZNI6KFOz
n89W52V+31l9T4MtM6J1bPFMwW4hPpsT5BlBnwUrAYiwexrIaHoQrNAFaXIFygYG4tHdJCRKqDOO
IR9UC777GlXVTdMZgfZQdw3JW27oNxJxbeMeDrNW56uazTF1Xltxe1lju/yrSdzTsJJg0dDwZV9m
n0dLBD/1rAnWdFGvFOBFBGBNiehAx8Ze04YgG/EZTZsR/ohaYEj9GPusLat5qWdWS3vdhCiSFQiN
xWwndkrPQROSHS0Fyy2fbD+2vW1BXiEQAGLR1lI1ijAA/g6ejleda1XPCdnUZa4an8+8RgR9AynE
ZUMnC/oQtgLXnM90LVxCGUM7nixTdYwgQYVOvf60ktVVma0rQDLE0ymwN1zU5K21IwDhUM/AIRp6
3qG0FNhEYF0c/Zb0GRATDL1Vb9Br4o8lVZYdKtZsQHGHO4GsHFYYlUzczaknVjVegetJDoXp3Kq3
ZCUGDR9D2oWnGYFf5ugMdiVmA/iNGhQakY2YPGoblQ3CMYBtK7aG48r0AhgfYZAOxqcKvRC4dnKp
EFQXpX7Cf4t1f5iv83juiPPTSJRJRl6j+VG0WOkj38W2oloi3cyQhwBALOVVRabV6AnWwSan1UlH
4obuboj9d6SjxRvhBGm+cKXmIdxLgUyxEbd8mHppbYS373WaWt9+XFvGGDFJ/e4lM2r79cdOBhvk
lchmOP7jA1gzdLrcxnRXul3xmRie/ST1rkUPYSD2ZGo0qfUbXXRpY/PbbqKefMrslrQ17l971j1c
+Ik0F8IAcZzxNmS5bPEwYJ6LLJLgHQBVnyJlCm92V8W80VlZ5cuEqAJrX5+sPFXaXLYri7LfO8CH
2NpA+PPkjiFHIQe2pcXnAs5mRNZFfZnRtl2fuVOTNrtD1eqKvdgUqKW1HhBpC3zlABXmvLQUFRHX
k01NivKyga3rkqNYgBS/3tSns9PlTeqGykOrRQu/xoZRSEKOwQ1I48cmcFc+v3DC44EW2Fr0nEyy
+2Mx9vedOpWADvrAVOWL2KpYU36A2wKppW5DdpipGL57yng4phADoc3MbYrgH/NlYAxLNkywjdES
vQalGsUbs9bxPFSgdVEn7KTxfHUWm51DviKWSHlVw1enCYvs1SMu4CURwwCSfu0sRZNV+IZK4IVa
jBhRVda9t4aZvNe6PsdVVbrwKGK2M4c8rc0R9RlgN212a7UZOk10u977DoLuWxQocn0huC5CERJc
0hwtb8/MXHiXVZcI1x+FYEBBlsLP0s0GIt/wxUpkT9RL2W4y3KwZ3YdkkGOOu5hwgD8H4wwjtpMy
ZUDT37yk6Nn8Vkow79mWCRDOh72f7V6goMkJnkSD0gIYiax7Ww8UFdQlsQMt8SeXh8nOqz4ZQ8FD
2gjivaqYs/3d6t0KdBqkm/C2vBXrpziQOC6xn7598z998sknEpd3swNTq5++e3P3608+gckMupa5
9c5Gs4HdCs1MDFfd1uYDjO4S7QopDjDuVjzip4tTeWzMgZ8AoCo49tFL8oviH+sb94TWK5h8fTOa
omINb8s4gcb7ozXJ7iq4z6wBccFHDP6z7bEBmHMMbOeO0bzD6doG4BeoP8Nv9ZkqYGY7Jhtn+rdK
Zhb2VlOB3/T5517vTu+OYMORQXp2UdfvGq8hRhaqcenl6KklBjfnm3q3JpMk8xIGE9/kfQH749AY
RoQCpEf9A03nJ30ynlvyzMDcI1fY4OhosSNbSE8DOcMFMukjRp0htr1Zl5MKAm2x9o/j3YIL4PuZ
KeZ5X+UGeEiT98II78+NWFtfURx1w7vvYS/YIrP8+eS+iEzFqF8MvU6RRk6b3aXhqze5vKB22l5y
9CZZmERwPqjBI5tUVqnL27IRMEdOkKay2WWDjzDQFgABofOxyQeW2ttmRJEV88Ds26REnR9lGLeZ
D20AS2QgNU2hui60L4dJ7l1vLXziqlmUDUEjfJyIa9tRhUroh0YT6tKB2sJrhGad06Y0U3UCM1Nm
gT/+/ZTSvSP33SYkkN11P5S9MA8K/j0e2xRs7aa6Pugb611oPo8CTJf+eGzGbwz1Mf8WcX0ZVvL+
w9HDsya7e/TrhpA1vdGC0bGdO8RyIBCzdiZQK4D5P2rTcx/ULBFoCGJXwY9X8CMvEoSsRd4eSiNR
a08xPJlYvz43dQTopFbIVbH9DO0FlU2oPHrt5E1mKpsMn7nAjBvPnWOrah1VwDxHQb5lfU59FIzk
BLOI95gUTW99/wDeOYleSzUmtj56rwH/ZFZNJ3OburEPs6Wjrk3NGnfQ7rLgOXS6hMro2wWnUguO
GrZFUvoa5xEODn/KpdJrMasAJx/iZVIgToA+Vtmmrjd4iXRsHk/cJeZ6BKfEcqHZCiYVJtRSArzm
ArwS9mST6UhZh557gj8yBWsayXMMw4lJrGHcdcl46xQ0nXSTJCrWGZ9GLUiddDQGTTMy6nmdza5m
N/FQhJ3uxhPNr/2vtgiFCWYvRbArkguDTj7hWkitXA4LyfqaFC0MOahIeccNpMsp82Lv6eDVFn0X
wJ3GdpQhb3b+dd1sL2GfhNhBp7vzc42KDPLEkGxmAZCZjSucyYwKOYDQy6PtKbqcYJGA5PAp3A18
mp1tPNtwQwMgUqZAHvLdrBMfKRD6JLDYdXkl3hUW3NOmuaYypvzfgYktmL+fUbhhuqawkmhwvEoN
gHVlaedynTy5vDbyWZjZLwmnEoGNmLy7Jqc37gKMfuPeA23I7dp3a813+ucMFBsvvL9hS9NteV5v
wP7pwiRdYsxpM8rl5rRuyiO4iU8ddPp4nISSn+A/L1++eNnveUoHLhuE7nVYuFDhjyguwD+v/vDs
+++ffNPf7+4HeJr0vx4J68+8E47yD4sYE23djsOD+8hCbnzRA4V5rQw98CAvL+egvcB8FIUdbnOK
Q8LukNj4AEdM1WhCpKHICfxjNw5TRdf2lh2U6dCfCU8Ye5pFe2lEgGZjbau4QKY9zLwZFhZjE1sS
eLIO6ytUvNI99sijcbvaMAX4AkwGGZXsn/GtpxK7DQkzL65mzTXM+z7YWMR6PkUVkMyVsQ3MyZGL
+3PL3OY0Pfp6cfrPu2pbaC/FfXNpbCcT+9D0g7EG70jIQWPLs0655fHsG1oa3jg8NnVA/Ew6LoyJ
gp5+XA+q1gT+sRKkZHbqs5dowHjP9hJtIzMdBkXC1TrN+J0xqdeMIG8zKpztkexbSEvttCnnKzQk
xUqqjW2M6lvYcYDN2xqM0UMPDEIsuySJRufU0kr/srysWZ3S92ViZL0TNxDOhQkkWdh9qsuyK1wq
h79go9HA42W/+k+VV6/j4mJbVSKZIOA6WqyivEEJoY/98vZarorJOZcSxe0xuxvMccsAOJ4BeQer
jHQG7zL/dsSoVw2ljQsQwEa5RRwyTCY1zfe7G1MBFTGM1ibRLqxGuVkaORSqhadGhY+YUv6iJm9q
s+Dl5CE3OQuL2CtZ7af3ePHav9uM8P/xIH08gPM9MemzenByPP78xDtQhXUAuQ2oHN9tTuBwfnSU
fU8BhO82Ek6n51sEDarF4GQID0biMgfrLVhowZv3ICuY1+TjBMg2g5Oor60f5tezpnxJ+xUt+WLc
CgYO7ChyYJvCPdZ0Otqtwb8L7f/aY2nUO72vAej9hmDJ+XBLv3utnl8D6LxQb2OIUiSKaDa4QJBF
iqaUZ+i6mobUJdFINQaa0TH9k57UtpZCMOlV/cOqgnX/ZIX/piNBWUr9L3er9cZs3hixRuh+1fcB
JIzkS/cAgq0cAvq4aELIqsnPnWHe54FGSvRVASJNK0gQ3T7RZ0u/15Pb0RJBMTf1utxsb7wAZaaR
85pDJFNKPrxzTOkDslFKzsZS7SH5RADmbvytZHDumHjh1uIYYOccgEsQsBxoucCSNXWECeROEuGY
Km9sKNnY3U1UXvIBNoEjfjLj0eM7QzTXBc2dWZ35cX49fKCQ71A0kUQnRbDJa0mK9Vpz0Qofn/QC
6Kx4O7F9aUcuteKtKBF53AeYTkx/mN4TY14gZfPwJxczxBhSDbTno7T8yHc8gRDaWrDMH18CcEWi
pybUYr6ZRb5mqoY5bLwbBDOHkDwjibu0GZkTcjM779yC93REdeamFYX+BekrEdzOVYcUGiBZAEGA
Keb2JICOEFXIyaFsfwxhj1ii21vQVJc0Xd/YaXAroELEWiMtpX99sT1VMGyoxibpAv2DFBu0dQEt
QMwO5Y2F9ek/nq3R/dQUvZC9O0eqWEJhqRe+7tNMsJeODVhNa0LBGv8nK3kooz7M3NaG7eq1eW9J
JCF3S8FygaqQExHUZf3XeL+Jlwh8rubIPDnCPKPDEZpk48hrA28OnFqdid3ODfL0YuTFgEqIH6H2
eZhoeNzQoCdsmydgGi3NntwH6cacUjYz//CygvhCS7Q9UpF5CO154UtCAYR9T5OZZTnEHzCSmhlP
P3jbogZbPFxHjDuPZjTkqaoBu4AMukk6bCCwEWK0f1APHoEejQDrTkttG8Txg/xTGbbGtAsOYhje
FkzwxGsUEcUuSriOWXCsa0WQzAFGB1xNeH2Ap+ijr0hhiDuTSTPb3AjsB/rmLpdu+5qp6KeGgo1x
1DT1HCPvkIOU9IE73/o1U9uhPHo1w9x26cyWV7Obxp5PeQsbWj46dBw+KMfxXH7ySpFz9ixjrgYL
hyKepiqtGKKVizU5rt8AF9jAiLCwrOCvrLMBqJB5LpXO+gBiGo3aD9C6CLHHM+tvTgIixCorMlwn
XvAtssYT995gzJoLRtgMYwhZqQLDR8rvwh8btHrYGqo1BqA37cj+bddsbawmn6iSjuSx131goUV/
i7jWjjNClEk5qfKITyTGdXy4F/alz7Jq1ijOS+MnwZmSLLhle+eRdIqT9vtF4Yox22udfm3Dd3xy
WBcr8RfEXgHyFU0w/7TBpFnta9Vk9vtoqpRBgWpI0NNiOfNDZFZfrkI+yBY/YlGzqrUTsuELToGK
4YpeEasYAp4apB3hicxPlwc4EZ1qUJXvA0RQ1YehgKXLNZ0K+1O/GFk59e8hpeKFhpxKbM09GVTX
OgnvK4d9SwtuZuxRPgUeo0t9TKW6iKn2Y6vYblOoa2Im8zKY6JYnxHJbL/RaJG38gJRnA88XGm6R
1R0J2cHaUIJTkxBN8II7ABvZ3a9cxGo6JLGEuMnKvV6rrIlyVwvTCUWoPbvr7RiWVfDyg9mKQ8bV
viUdvIXE2gIRhtqABAgPgm14yRpMvbrNzuQNJGxOy3JFjZ2Yo0jnDhXtUhaAmQgULZtVtD4Oiyjs
EDFT4yfx5g9QIVpdmEdDB7Dliip7HqvnlLOMEVDoxAaCEh9aUPxGO7sZxoAhf1cRtRuYPXYZNx2g
dFHkxC3diEd7pkUqYlSog+DE4DS5VFfe0iLDMSC2zcylFF9dilnDuUbevkPvxHxvSNfxCNRvquDT
upg5ucu5EjNUsTkIU7Babfk00vXrBR6IUrQ1xXFbHn8a0tmoCHMqkCKL464Q1KwgGRRkFZw4GmKc
DZbxHGWNjKvp8EqJxvdaB0wDStv6Hp8UXZBu03W9xmtwa8MQzBap6kTVNHAuo3rYfoaz0FSjjUll
dLHQS67mPJ/iSeTNxqi9UA3bUB9NhSDEPB9ScuJ12UMsM8Sk8IkX+/XpJkcamLQFdMZBa7xYLW/Y
p9EpqXCen5bkunl6AwqMzTBBAGf8ogQQPDyrNhf1brmAnGzNuhglEbdMt7RC8Lt+azHeIQJBcMIk
PNf1XA92x9RoG3ga62CW2HmUuESx8yBp76Jm8sgBz3pXD+GanLbNlHANN/ZInV7WgZcgeDK285Ve
CI+LbCtYkwpgEYtIAX9H69pvLXszsnjhN7dI0esYQ8/RT6HBhHQTjSPLJxcyJTKeIqNACLU8dfsc
Awo7Xs0/RtAcDFedFym5yjViW1+ZpyaPSCenraRmqTPKc+jIyM03b76TmNTx2Ao8mKg4iZfp6aac
vTtsxF24GDYibFtuKH6Qclziw4ehwGF+YyRw3sExQDWp6fzloXWsAqlnuJRHfqR339T4ymJVI/qh
Y8m+jmBhBCOAfsazZhspUgG5mfy4ALO4tDGsFYPwV3arfb9JCaAu3OlwUk7Z+Cc5p8k60hmLVBXi
aRPMmvFJ0iwEtm6xy62XB2xuUBuyVL3tFhe2o31TSZhXhifGSCUjNk7uBOvM6zx7ck5AtuQ29cTR
U4djL2OnYijMz4deOP/aMxmID2Id7bktWhzrg2zetN3MIfZ3tmYtRnhFfPq+YzjRR/xn8oMqMntB
R7InTu0EjQTXIZDecPYK8CV4CY7suT/MmId3m8CcwkSMBA44P6dERrbUximbtd6edftsjXZqDmyZ
xX1WnIAPls3eWyCATqfziUQfCGKk26qOEodOn5dBHAR33HQA1kQYzbDw6XDbKkMraRprbai8StiT
+13XjXA4Z8lgih1s5vQU/fOmU7aZmk4bjE00sdWxp1zS++XhqHnQcheGHVXNBVwhZJ+/A1fSMwii
a7aXpVkMDHeSMYtsBHBkxV7kJhla/nNRSoRGUxQM3HqBbl33VtWcnbumU7oywkoPhPTAgsGj7q+t
1ugbTPsD3UStwOsV8A5ImwtV0tEtHJbhnmKfXFfbPDLsS5QKouPlZbmoMIzcpj7fzC7RNbHJzOrP
rKV7c48c7KqyKfZMYetvatZmU3syc8vUjCqanN89uHlf11BtYgF8o8feEFDp3GlfoJHwCpckDJ1p
nFnJGAHYTOmoyOwKkL021fk5BGsfqY62fXBhTkfY3+jO43xtn0jJvR6U6AwpTFL4xsA+Zlbl2D99
raABTwUcdjBpQ04GLMQPZpyxvnmUGb6/LceGSw0A+XIHZzUkdYqG9DBdILQCZORpAxeLaN7h4qUB
Uk5ppglEYKLS0LvasyXaIYSKmePI4AyjW3DQY3TovqwaGzhY7PMasVxelCANlKu5mSqmwq9KXR+8
H1hTPnRzhQm4KLeAp+7zxwP6XVgCdCp2v2/GAq5ulMJFsuEBSHJYmjG0+solXd3D0HDMqeXNUfcg
fceDRCx1DMGGuZQxBVFd8tDAArAXpBTX6mwHUa358lRdPyYO1KRJAtJgROlcUeSY7x/Wb9GdzKq4
N10X8d+iB/XzupdyMPqCdnvODXOia9XLasUGo9qjTWEiUDYz5YifMRoCCM6zbbYsQaruOyJ9XL4c
hnU6FVvUqQtMZ6bcM7geUSVjSHQLoIKgzDjRe6zjq0FrYpe+CPRcH8AagZPnaWmreoueNUx/bfrI
9QeExBqU78EYk2J5z2EhGUHWiBLXBJoQm/gabohFG37IhDyvq2f4MTCpxGHoz1GFg4rHS1adwyYs
1eFbFvPTx6495gTWJM7vzDQYBh/a3gM+1naj3AXMFwSktKM1CORXn3qMghUH/0IYgHfnU4GBbKR9
6AUvJcFkWb8P7d2T3eW6zIG32yAJQg6YFSAg77Z2WnCxiagzfVikXhVhM4fqWXoQjXd1bk6u8ZBw
z0hnKo3Q+n3ObwF20PxyvVek2sPz2NQbFpVeM3c3Q9fGqmFT9gTEn529XLBe1r6xF0yC3k/P3/yX
Tz75xMI0TNc3D+0a+enFm/+r98kn5vRcryuRe4iZHT0c/Wr0+aBxTM3Iq2bXf/z7R89/9+TV2Dwe
oTobhEREFSK3azO7zAxhbEA8EaDCG9EhuIt7dwRIAhz+WGIgLqvOPcAI8lI5Hjp29RTT0iWAEwvB
CYMslWyNifu/BibjQmtwCEGXE70PgZOTwZAgi9JGckp7uu+qiNBhnn/iCEvhjic6VePA9ogGNX+Y
lXBpYvZl6CWAHAMILLhd4vo+R2Ow5c3QYqbJ6QYoNibXUvryn7KL+qpEU/wz3vJfIfeiAMfuDh/U
b45KA1nAwssU2hDYfW4tf1G+LhdFtqjA4P+GRQIMsOhMceiIZTJxdxLT7NmL7aye4169UIPAkpO2
PCOLHjcWkgt7jyykRKGj+lAOD4hy0LM7AJ8hHq0cqCLrzemGHhnJZTkDCzCzyfM4MfIXBnKysIkw
s8EmqEEsoCEhFM93RlADYQTu7qgiuod54jCFr776ivdySvpgyA8PESwRRA44xLI/M2d6vISAEqZp
Jhv0L10fnJqUIEpWjTkNwwTMLUk12uJJfYUt3l5s6iszUQmyr/TO1ZcA+gP9V5t9FlFJAIJrKRd1
htXl2jCa1iBc2Kdd4+K0uK5Hz/jta/PLy4CpNBvFNuFbxHcyrYvvnY+nzCJQ4QyMggAcPBbBgBEN
OxTjN3us7fU8y2/RLAgF3ZUHl94kSr+TPaMTzIxXBa2If8oQYQVV4mYSuaXDnY9ZEBeShoEWp73C
9fZdlAnR1pP2ArGGqc/OmnILEckW8KoQt2kE597jHN4CIyeF4O0ZP0JYri9pDn6lrO6hwqKAHGTZ
U9CV9++Cdy98yu4uflwNMLxkUG9/m+W6t2NwhuVk2d2GKHPWEVRtncewx9Q93eiec7NBbNEzHAOi
EcENURyYYorjMZE5GS25nF4KCHN1REQMh9uSp3mWw4HNMLTZaVNklztc2dk7GA6C1KnOV7BHdVcp
z+cjM3kJRInUWxjZLRuQ58UcUfJsjlTlSMa+2JSAZThjaWg2N/LpiqpCDXwAVxjmjM9g+J1DcLf5
VxqCwWD0b3UFGk5bA1cFceUHfUMvonPIEvPjIEBuEh8OYQ5WfnjJkQut5andVXHiHR2xPbbpxoYs
NZLSiRw6CCsIpeypSES5cl4E0VEkAuF4MP8k39hbQeTlByFR7xL/SqxJl26cSVqvrcBBw57ijgpq
2O7EyFKbbkk780hEhLEKydCPs/NywXIhJjDwnM/AvghvmL6CuYbbBlF3TP6n79/8jwoxDfQsP/3z
m3/+jPDSEF6rmhspADArq4bg7SERWoWDXFeirnh1Lqd6C3A30tBpHF/Aarkp9juBvGnNosw5EsjM
0oSNHKccG3iSIuieOzOjJHMQaNoA8gJanvnzOxs8tPi591FQZSkEMkXEgagdvVMQZCEC2QLCWfbZ
Dr7vcMjgzG1RyJ68+f7lk1evnr3QcGSERoY8CqywyVBG4bAqLY/Zwq0cBiqchpzOfXbVf7RSn0ks
56GFs/9uRlNLJQkJ0FYNKmDCSYUjhC36CCsFl4oAlSqQWZQwJDSj2FnVJiOMP8LiBNXck+sZgFiM
s6N3YFoPN1TkIYHOTE10qO2jXDegHoEqIXBOowFacWsg+qb7ajPtcO8OCdlDgS52gFsKvqCCEr26
IDUkmqg4VwrTNdIhcADk8qEurmYtVaBxBJt/6j0S8k1nDfDtlAuZcpsHGYo6UR+b1pZwBdeoEmn6
4AmAh9CM9PnKVHJhDtwoj9G19+Woz/BSe2Z//+iyv2/249I200pNf1B32un/3aOXf4AlsG/yW/0u
K6ANWW/CR31Q2tl0mSGTeGBt3uDXw0GqlclGHrEzDAAU6jZOt5tdGdUbBVxxn8n5ImQo6mUO8XFk
5F104TJbYVP4NWFmZKpipkPed4XLI7Jrf6KbrwPY32AzHxQ+75tfovw2Bd+nnFzz5IqZ2LhsE/TN
3uF6TnxctLaZw8/TRT2lR7AQV8APVyAJeIRHpAlxCImIQLeRKnlGACT8rqQUCP+m+yLQK0kgTMSv
IuGXvYFNvzwIbACuCPku7/9W30gYKQIECKJ0Wi/FpDXIigLVxgOI1V+KqHvKVQM2/2acEp1kA3Yl
RmpkpAk6+bL21h9Te5sL127V2Y0Xn8EbZOYYsFbQmkCPKn8jnStylFQqWcL66KipumXFFJK4jRZP
FP0VLeRW/6hPXvHlOWpDOC2oNLf1YnYDd6bohOSSs9rrtDQLChjmEOWJvqlCH5Ue5WyhYlAwsHZG
QZOIwHK5rc2cAq1AU7uQU6pR2uPeZFETzu9PKDUDbBr1+vgBR4AiMcocKKqlB6zmF3V8ZNKjY/C4
791MqrxWfx/XQFMaHz3g8zeFHQB+aQ/Phh+X7IfoQX8qi74g3I5fT3+c+YMz7lMpg+XpClaWOb6R
Y+yuQrf80gXjXosjLndCFEgFbxej6Rj4q2AKmN2uFTZTkbYdPaAte/HU7dhEJCzAqy0lYrjaQMYl
o5U/cS+CCDDHY4r1ywV7Evt3M7wAtSfD7zf1+2qB8VnAn2Jp+oRuSOWUAFsQiYNknTiHa2yedU29
fE9naZiy9uqKLnqN2MmXjJ2h5UWQUkNweQMkJO5TZOY5lMPlymZuRcZXmjrG8oNOQHyDwG5Vff6m
nNd4skhMC64bhobwzETJssRVnZ+0hQtsbKaeztvHIcRrKB0dpnpqyfAY/oFafKthtL2EqX+HIpVT
BaB4CGsBLAFu1AnDfGNfWFLPkhzJg73fqRxSR/bPEqyOoi129I2pRtA9gqbi+iYRwBsYCeVEs0Lz
Nx5CjYoavCOuTZtvkl/Q3ugUK6/BJAVDsuFBDdXNN7ICuGfJZ6RcpD1FpAu5BnBAy6WcYfbnn4d6
2UpVrOd1UejaHsCm4zpTdTilPhQCoqhUle1lybcFCf0RLvxtq6FdpCi1/i5DMwLz5W7B9nE8fRCT
suHTIM9I9BuQc51KBu5AdI6BQ1ZZ4RY+y8a4EsZvEUf/LXp+k80Dv3/KcvJboq6PbUNbTL3yzlxd
Jy65zYKRpYapExcRsWcqe8rCUNlaaPcXzCWF8pTlQHxObnMWC7/D0GaZzEAyayIOteEztQr15sHV
h3GGEibIXfgw1FYJQCAxkf31pNuBPJFANtBGINkckwY0Bw2fe+0xGo7O3MR6EzdML37dDKQiRHRz
oop11SlYoFIRC/AHV0u78wseZh5kq7hO+Wy4EA4tHEwaoeK7kp3tnv5VzRAWPwk2hVxnsgrZvvk/
jtikuIIXRwOMVEQHbEV2vPrDiApGmn6H2so+TkD49WD0eT+yxKBaHKtSTnoWCKhN6kbJmrT76Zoe
f6FtwC3s3DZVHqQ9ibiqSkCMlXOGJ2h7dksdn9XSio7NsG/OFfygPnIyWXvc8oQyq8p09klPZ8Bw
6eZVGJsnm7y1jg1H1jCRr2Jn2du3quy3b1nZv63dPfEosxq4sfMqcK10r7yTM+Dce+AQ7P1i+k1m
ciiFoX6bQBRgywCGOssGQmjgtQ4EM2kYwTEQd3771iviraQZuVtwK0bAQmwTsRhh7fg+HcGmYWAT
vL32sQrz/nduN6c7rOcvXlMMZLLBQ2vFZg56sKIDYY9nwCDpjISm87mzrVJz1xt1vf7J7RAzJhsb
3VBw65VwGep5Eif5A0AcvVsMJQvz6WGSLZOivKh9uAcOUv5YNcB+3Q8EvrbJzYhL0hyT6hDQeMGE
3PW6CKeKcKKODkvPmrt05QV2XOewUYGJB2XHuyuxtiLjxQZjJQE+Kgao9i49ZBoRDGx/ij6EEDc8
iNinozBjOroeAlXil4TI95XJ84uJ+ql5kJ1ijgc9AktdepnQQrJfVKN0+tkfMYLa2nQ0m3lUW1r1
bBfVttbddceN2AKPN+XZ+O0GAtSV703fnd4wPD6aYBqBxooOX5rpaU7em3oJJmdfsdjntUn5UoAo
WZ9tQazFOi3IqBh8sjUnJB3yxOPhzx999yS8Weat0SvNI/IwQQRH/8GELvJAV6ZD8fmkemJ0CyZ/
GKDutJQehq6wI9TEIqduz2+xLr0P4No0pi39qZzUOYoYGRTXIDvYA2pmBAWwi+WUjC3FN9A0Bcmw
li7qzWbGEru1YmN1lIr/Y6V6e3SxFm9o+sVCHZI1a9fKdlgahuZzxADf1HXqbgsRYqs53vOQHMTz
fAY3OxTIFI8NM5774pn8sL2VVpY8oKGuYqv6Fg2dWd2GQMZRmx05F6A9AAbb+gaDS7MyFjcZ3ntA
Uw33oluvSpmEQx5vUkgvfD6iOSPzgs7EZJYFXYi1tpHPZxAA6x04ZZoptdmR0Ix5lZd4NTICS7Vl
ltiQAWHblLSG8WLs5eh4OQaNBSQkvJGFy+o6g9FUsSsrFUUQ8XHEfBG8ItAcEsyXwVLwfYmeokDb
r6XwOzQ8hQ6mIPNwdCQtcjBdQGWLU9awQwq4izHg6Uo1MX2wBbxQElOnTuZqlElhhzoHg2k37CT2
7sr+iNBmyHhqNQuhZDisCP4xNQk9YIkkaLmvJIngdcToL8DPoIROtFioyB3cu8A6Frxqj8AmHqw/
H46+GD0wm+uC4DjQonm/O9rCojaIW2QQSJbbvkB3yQH8GiTc0vw5AXjcjB3DaHBeTWi/F6ho6BlC
jIanwOPZCC08Xx17ZfQOO9hj2TNK2p23F3S/irBYPogULNkrEG4ApwRLvicFm+RHaP5MiiTOz7ay
Iw+LhCIQN/ZGgQgEJvVmvvPMCCWzqplKIEU2QRlVDdkxorAUirjgOYxdg0FGsdQ8FLBI90t0i+SN
gXxNXwwo6Z7ErQFt8WieUrRHLobvUw79BRlHLltXAOdAMWOpDFGJW3RHStZlHtsfJ6157ogZMkYz
hx0LjOVpJ3xfVwtilmwutK/ydwTjstmZ5UvjaCS52XxeLVKGf6lKu+fPsmNYBe11D/pUZ06Dg3TG
mY6ptRTfTuaiXi5K7Y1C08VypxDlJZxklL0T4MQrRiSAvDuQtyve8uWh5sGtudtDdjdtDaS6FR/Q
/5STonAnq1m06fahEu4G9UqYNuUKWfa7K4ex71Pl7cjtXZ9lXu/ovcY6Feeq7bhFUrV5v0QYf3Xs
8kONfMdmeSy/yQnFrJgWHZA914wO27ylHgEYL2vurUne/v3c5EqJH8SVysv19oYY10pFD28VBjTV
UMhVcLYe4S3aB7XQDiSJcMRpwMwXYYu57htOLcbtByHEWcn77oYG3fzlEe8ALj1kBRYeYBkPaMtQ
IkIZQorZ+gReonYj5qZ6G7XXLRZ52yurSIzhZ8Eg6qUWLCw9Qc2hIu5QaAGFNgjOMg35EG3KJSMu
QAQetmIllH6vKRxQ3VbcqXC4eeNELG/LPIMVbFvf++nlm/+VfcvYoXs0v1yAY+5Pr978l//hk09U
bGF53J1yUhVWmKR/+0XUrt9DxOZh9v2z758wbggRz83f2HdVnMzq3Xa9w6tc5yE8MDkG5GrVAGQJ
+9djjXvK65YLGIn3VGmx5fnaqb68RFNG9IcaCbJ4iO+1putn8FcelJvNwHESddJ0maGwI662YGhL
UdYjB32sXBexIyGqGEAeskVy3ImshNAepph7ofOdeLOdWzA5SZoX1m8Z7JSGVOxs60rBeOhGvPvh
9dOjXw/8Ozyp2URVc4RDCOMFMebK5ZLCrnmTzdQPvBdnyyl7wTWJRM12YTpooimbWQEeVWZL3ITv
C8EuHkLnUiwOmp2mU6E/KNyq3JCbztBxdEAd/mX2+RgdJcz0/BxMqUxvhW6MQ/r8EHqmXcvMfTyV
Tmbf3mTv38n+jeySQfFnXdaUauYAzXNLedSBI/sWzHtpFDXGpUksVv/Ye9JvidxhOcqeCbtc6Jhf
Hh3z+wA6NrKT5FzXGNdWhgw/j4Mw609ovdcrdp6nVBLKaZjhNJRZ4blHmJcOrMMnYpgbLtCRdgxL
CBW2MMTeTxe5FzwmCrzFvUAPwUdVEA2y/eknNHWAe7bLQCigYTL/RvC3BH2rd6dm27HbBz02zu4u
yCOLglKolgxthYa2DhZKZBM69BLshTWlMGfKUbDL0JgMej7bnoRj2LOLMvgw8oFb4gIGLbnoLgHy
cA14Yeb+yhxm4PqoJw7qkX96/eZ/C7ZNmQU//fAm/4Q8VS6q84ujZfm+XAJDPRL2emE2hSWsHeC7
P/1L4NxN6Hymquas8NMf3/yfT+webLZZtxsPrfsK7jcMjLDx/PbBrgNYwA1QPi9XPXYO56JsSZLp
a7L2fiTvuQem1nVqvZytGCkfuoGtCMprCkNnodJM9cprjdiz25SdCNGhvs2MBU8vNmLD566gtRaR
mCGhpfR/qcqrCMYXXmanYBTAym788Owse0yuJRawykggkHZI9xSP8+uCTzAN7dLXN3KwmW1AiW4F
An57PWLXdYrGYYmyy6jJzn6Mj0GyYa8d2jbBgniWfSpV+RSyPQY/bjQ/pyPU1ipoT8tlfQWFiUoD
Lh93jSCeXJHWLHsPDadauKsDrz653/rHQ7hZ4G4o7NWNnOZiStfcmXYVkXDOyELYVnXdIKUido53
SwH6eticr9mgCnXtIBXNFG6OgC/PVGGGEmviMWCJK2QoxgR+H8LVhesWHi8ZPpwO780ERn2jFeyQ
HnUG3X1MpyaHh5riPOZVn7NfGnkwxUM5nUJaQwaBRvk6km87yCDDzCFKZM6UJh31qqnz1zeyCRPg
gLWUVoVXjSV2WZtDIh805/54s5uRrQocWLHDw1HmFbOqyWfeYbzxfZJUZLYxX5HzQcQPe3gjeyhq
mppMeOf6FAV3NOUYmkWHngwk1pJHwRKQBfE8ZIslQlh/KMFWf5Llo9EIXCIA79E80h0zXk8QMg4I
xgDgfFaRCRoHheAS4LSfplittkRwKOO0yvADNWdonqWPAKnhhk73cOrQfflYLvMqvLppjPy/obuZ
U3Is52GVVbXEiytAIhRsieT0gqtViOuzYfwLCyIwoy2De0tzqqH4Hlj7PDvYQ6BQv4cAEyjyqSlI
bQRMKsTr5FEL4b3hOkIHArImLkhIwlr++WdBIbI97Z2vV/A239T1FquGPe1dHyxC61yQgsiqJsod
4fTTAsYM4SebCRPYX9qhwV2i2K7ZG0bW6tdsZtsbYPp1kogrmwLZSZOiuWDxETzDbqXk67I0wgsk
bU6n2GzEx9nb+qIyHNqs+BvsJuLAsHVoKpsS1xegoq0lOw3TAC4FZZ8Mqyv6Zj1ew/iWy/V/xzUa
Z3f9pimI4bE26B9aTuOZgAMLCW5woKf9ETJv9FWPacflpvZHJNYacyZ/IihUaPgeemtz0Irjx5gQ
RQpXa/aGgZePR7LGTsKrJg7C26aFps8RsIbWKwYTz/agXpquUhw9o1ztLt3bPF53hW9oFbRt3Ou+
XnINFhDvuIUuDTAelUM5xV3U1bx0MPd6poRzJLRC5rxpB/uouX6oSbj/4/x0BZikwin0ZWM8rQAm
6vIUzNTQr8UMZgX8mvOmyKKD/uA3A+45WxEwOD084sjgbpPf3RQDG6HZa65DLfWWp5ixBrNjvpQl
iJa88AG1oeaPyekSAgv2TZXBE8Rh0YZ0iVKR0qOqjD331qS2Nx+Ie7k2rcW4Eigt2+PGI4Yp2wJa
B55R2JLmrLxiq3GWj63vhDpqiXuY7eqqmfJJS2J8bJJuN+z6IdnQYjid4Q6AKS6PEPYQ+kkAR5Xr
BFS7ad/Q2I/NyACjJzZT7g9mmH6kYGkGX0L1vhqktjZi1fsSzykWOp90VS0emzcOWQEdR4AHw+sw
9LqN6w79M8IOm9cR6oV38h3fMni7g4bcMdZ70Rl7KDwX62kRvQKrRqw6rEUvJo+bBpvd6pazAIPd
4MXV4ZPgO5T2cjKsgRevtpfb/FiP6Emxb0qYqnYPMpVy+ADzuF6X8+nfZGBtpwO8sVaftHDJhKIl
DwfZXbY+B1shj+8wRbWRQddDOo97oD9dyyQgbEXo/rsIdYJpm7wQRcX5sj7FF8DK7a3SXgwZ6nlT
NmAO5Gp9UXnFX3gskgzQlE61P7Dp/+9uavcW4bWVDcLtUMN51r32uqH7zte39v/P3EEdmyHa9eTP
basKqhwlC8U6bLZdUiGpLr6Nc8mGRrvE0B8HLGZOelBLmB/7oonUZ1N46ZKNRA2I6NyGmO6hvXeu
101rdA12EOEIhEUqvBIiv893pMAD6Q3c90rtrtm0+b37E0hvc2nLmzgaC7Uk7Bp8G29KD5N90zK2
fYzkTcG8E4HzqKtdjmHUvz6v90qTNdufwg6BgSOny/JsCwWqVxsI6wzFW9L7o4j4oke0Jm8RSj2o
2wRb3Brq8QAq2JwJ9Y1IM4lAJx1MImYUbcxin4SmVhVWSBbwo9XikMVrkh26cGUKBEFzz1A1ut7Y
VYgiWVIMi+d2Qt5qm9m6BmI3E87dxFqwM0iNem/vClaJi32xlBJLbpAPss+yAW5bjFyoqw/hdAeF
jeTwYnPISL3Y/P8D9VcZJDBa6BgjjHST/YCh3tVtz2TSe1eW6xlGHcF+RvV/I5pg87SeQcQGcAfN
/sxXM0b0NXMNPK+yAcw6xVTggZHvZugL/h4iopl0+X8PUhWc7GeHyEFI9DibsKaPNuDwm5pV8cwi
HYLntRTOL92ciXssDpg8ic197wxKDJYrdMSQ4Pkg3Xm3+697Yt5uY3J1/LBtBR705vS331QY3oqn
tSxeN6MKXg1fV4nlcNj8B1QAmv95KDN8Fu2xhVoQr3anbRmPOjN+t1u2Zfy0M+M31fu2jPe6S6xb
23i3M+P39VW5aalqe13TfIDG6O/CCLDCSUYAX4oobSsjwGamKVEPxKlvw1TUit27YJNsByo/GHKD
29nIwfSwBYYgt0TR+3vyJRSacZw+Xmimlv3n4m9qpThV1uPZcgkgNwedgDmtr+2o6/1qHXUjpLqK
LYyAQjH4WOXF7XbFsBYTfZb9O6tB2JYqwQzQYMtLl2QD7bLx+xlFLteL8Ww1GBMtav7PifHzkucD
3zTeCtqxK56PmjYjhTQjzBSt0Hww3XyNn3WiwU8WUrLb9cdRi0D+ZlH/zvxVOmvlr6aRoiZXvXJ3
ATo6uC6ELvZzwJtjznaCDUhL/VLfVg8tHg/ykcBKGNl9OEipOqKTyaydbad7zxU2uNtM7jZDVEJy
HYdSg+KgwolCQKCF76swwJtpPKPs6/QKsZ+LdK5bDivkG3QOpqOcGFTVh58OyOGrZdiSvYZ5VNVT
AyjdtWjpr8WeDlu09NjiQ7sMjIG6u2xxcJ99UKdhpsWebkvrD/O7TRFrD4nPas0hRD5LHKX9UcF2
jEydCJXKVD7UTwt7pQfCYE10Q9feuE97aORpnyH9tW9SWc2EfabuQmj6SOwG0d2j7JBS3W9sY+L7
1D3C7gCM5/98F6Y7PP2MXAfCgw2zxIUeCUG/YwOnA2QgTvq3uQVIbsCYmrgp7bqmOt3XY3snyUGH
87/JHXw0ltzSPFbfe40v1F06+3tptzFA5rM2xCKPDMkCWYKLIDQJRViNByAfyAVL0FeIjkTwDYyi
NEgIonyvGY6i5IzGsugOGDi1+CSTQCyOyr7laP9lhzusqweTinpO9f3vxAFQ0fOyPKrsKiWDjjOK
ZGpNMFD3I5cO6KZx0L0DpjzEBmRLIPQJZrH1UOMR/SnFLBg/qjq7yQbkX0JnDkZcpucJWEoP9Bjk
RND1iYZSHGAu05uSe1D4oEK2Qiq/2/Kg84uAtYfJDdHw1fGDX46PHp6olmEMG3K6IDY2azLbyi9V
VmW14nM9LGO/YY/QBBkirFav8ypFFRC2OKXFIE6YdPv526sL7KyuzlcHzmqT8pBZ/fFb4N47k9Qo
mkkOf8wghvtGyubqCIOF0OTaihF+AMxKqsvG6wB3KCdFMNr7xPp6xVQpPG2HmZYp4sRP32WYdYBR
lqGQsslKbCvaQOvvLBLwhPymauazzUH3u5z0P++UjOYhtxGH/YAGQrpDWkfRNS+3Xbef+D3qAfOy
iJKNoCRuP5kEU1DuKUf4zqXsoLVY7CgyvrM+yOpl8k4XzmPgFzPGEBnh+vU1FkG2vnXSZ8drjtpC
4d5cwDfwZVTmz6U4PPpqCYJOIGBU7m2NUyaXtbHShl6T1yQ4eODvXOGKSoL1zQh9Qp9iAjXXeKKi
BTMUzsG2+RYFtykdPBSFUd8MmNIm9Yk4H50+0eMHScVi91p365zTeb6n+D7yID1Wx91oViXGObnt
KsVleLy+sS7zPAOc1+2ZOFvzbGiZrTDn73z4f0a2fPT9s+xe9mRl+jdb10aIaczLDydICK8ykFai
5zsrCteLnThBgY17hOEuwinAE4tpDNBlu1Bz4g5JXf1zAMZGEhB+Cx96sXKX62Bms+n0EcWwxSmN
AWzHh097P1Qr+a4pLvQxc0y8mcJpdquprSYkx+GWiNlqd7VRv6ELIfKlgl9woxSZIef9PJykGFcZ
ZPgVQuzNwFELBRbg9HGw9j6WSJZ94OVaLirAa6G4loiWuagIOg/Ij7Ls1e78HE69gPGaogfu7XCI
Zo6jHBNOS1OFUoQl+Aim6w2EAF3Vl7Pzal70U+uY20quFTChwS+rOTcsaQ6D5jirx93wW+xExB/U
hLLoEAi/I0RpRvMk5QigptztKYbf2p7qBF2z8w7X3i1CICD7MO3Q6C3PBY/sXDgW9Z7T+203puSR
PWIWIx0S9xo918KlbtInVrsLORa7YF0Pw5DQKHFZcIW8b0vhoSkXFIGXQrfcJZDp66EfPvbajt1H
igLQC7z5Fn6Q1obkJncwRdBtDCPspwPQmc/M1p9lX34pBqCynxctcgKQIR0ukmDeU15vXWjYtJwQ
qpNB3WSyecdm/0A3lvUx8M7713Quvd4eP/jHsRdiAF6ytAWC3t9Y7ujeLlI7xV+RZYdiQa9XoUcy
Y4igahRiU02ngzEH5JD4jVZaPstjh49f2q/nia+f268X+XXCp24FjuV0DiPZsG/KyD4FWlCnXzLf
42/IbfMifpmfsc0/5DPM836Q5ozIndu8lemtL3SKCr5HtOEe0rzEzPf9T4oxPPzs88++MHNrWc+2
QIBmoBm2PrIeP9+1tMul4knNrTPzoq7XzYCzUQqzeQ0zAGN9MMwepr9Q5XVRl7Pr/BgomnafYBu+
8OsyADCsenAM33EKXHilDs537+g+9gJ7wXz76c2b/52hXirDkjmOJIWR/OlPb/7v+4ga0+v9vlwC
/JfDpYdNFpIxTJzk5JisZn8GCBOKOawBYmoN0La++fwdz/IQKeuriZlqAg3DdyVWrDBMAPz/txDc
6qpaff5wagqdzlG0slEB5/WyNqtsJrfcDMlleNQWXJowNAVm7idiVXNJQkMv1Gf4KfB6j6NAMAGs
k/clUWFP+9tVjMX64aDbAPdVmQ0SXRNyP4YKjkjdDM/mq+1ySKjfPcHUhukF70dVPd8u8wdDTj16
/ezF49/98dnzV/9t2P/x/v37/U9/TRPoogTDneFVtdhe0A5t6I12q7XZwPOsf2H+M0Iw0i6y4/FD
j21z5gxz9+z+qOKWwgdpAKU2hUhh9+MB8ihCXNSgKzzxNYQBOkSEvYMdDVMbtGHogIiANj1/HHjL
4WqYqmoKTx99++3Xjx7/Qb/7NINI6QqP6gLvZxW2JqSBOBCAUGH+v7yczRu7vjiEA7H/JsvvD++7
DUw6w4gtuRnLcvW+2hjpwHRNPnj84tsfvnv+ajDMfn2/sCGa3rx5g2KqmZSL+qrJvF7kQBHZaX0O
IFvLEsAQmtkKFOmz7LTa+q3/MvtCtV7q8uv7eiLwBPDHnQTOaDLADQTUb4cFEuJJ2cxn65KCPvN4
IGanqfAU5fucmINJN0QuxDjqjAFIEICGse+aC+8gCFKDSZ0QGqpl6bDuBNZMiSijjRZNQYHTzC0I
t5bToUaRjN4Ao8dvUX6PWf3CMivLX81Bf7bd3uSx5JQPWH47Hvx4/eD0+G5zCTzfyDQcnBQRMkw5
Zg/JPosONkglfk207l8OCp6lj56/ekYcMkP8wj7Eodz2rbBNXR7U7jOSL3thayOu2NFMk+0BtyCI
W1MvFyE7dd1MWAHH19gJ10wAiF1D9z446YK+YMou3iyTpRjvk+zPeYH2vk9fvHzyu5cvfnj+zfSP
v3/2+skwgdVNsCRJo7z88wfDwqPy8sk3wyTi96ZctJB4GJD43csnT56nKnK+KctVC5HPU0T+I6rY
newGJI6rFipfBFS+/vaHRJdAbOLlrmyh8csEjbgiwK93m/Wyjco/7qHCnXQnm9/M2vrkVwGN1hE2
PHrbVpH/eigRXE1JIs4OEW7F4SjIExE5PTKasADPDAUmsz+9kc5/THS2Z89fPzEL/PWfbMJXr7+Z
vvjh9fc/vJ7+/tHzb759Yko+evDA+/7k5csXL/Xnh96tNrNYx039aiAIISyn35XbV9vF7/FnHtLt
WqftFLyaOxKmK5CFNZTnsdn26mWJChKiVYyuHG5cL+yw3OX/h+z+9f0ztRu/suReG85niTBdgQmy
++UFdA6cT4BPFtlX2ecPf/WPvw7uooAhks4Wj8djTHMS2Iar8zPRONGDAO87qR7eAtv4lDIromo3
Wth9g3T4LudLBdbfLGqMBLZb55DEbdShZPP9n6ZGuHnx8tUAj0SDB4PoWGp3hAOy3x+0oJZoeVbC
UlTQDQPaosgCwN+0VOQwgSkMin/95OV3A4wYNljsLk8HcQ48D2tpwFOo/Nvs/YxLNqSndB9qiK22
A3td+Jolqz/isc6HnpyqXQxsbvLTpZF1J5/fH8IWMzEbEu0TE7OvMLOfmN0hbVMObHxiuD7z4olh
3shQJ4b/ElecGC6azvs1lvuFKfelKfcLU+7vsNwvTLl/onK/+Lw1ryn3C1Pu91TuF6bcx1DuF6bc
P2K5X7SVC9xw8gBUn+CeYAoDxee7yS/hkg088Ca/8qTlRbnelID0zHjNVW1B9NvQRJUcKnlI+Bxa
OO0wwk+rPOpUg0inxQnEVm0iAqw5A5nzPSzjZy/yQ6ycXT64tXCXhj4MlDpaSQgcWq1u5vqU/ZXT
R/7A5mHBJ2QJ/dBIhquFM/lpxaWpfoxxo3UUGaJMi7OfWq4YA44P/cmC5ePokTlyvK7/CGIrtRg6
vZxdBlfdDi5bo1PbOCXEP+STOZz1d9uzo1/3QyhALh3++F/AFKvzEOWlNh1BLBWONEkuG5QLCIpm
T8IzuJvefArj6W1PXP78tecYr+Bxaqv6ixxY3PkkZN+kNJbac2t13QGoMTqVBY7TEtPz3VU63KcX
wVJ4apuV0b+AAp7vGATSiPuHbhVs5MrQE+LqGI3FY8KmSLH09utAGYo05qCMJPUDnZBgJBVOUFNK
Z5mn+cVsY9JVW8vR7ATk30FfVmcuRZqb6RnsT2mlEcHYGvVsiYixNQHYwzu8rzrFaG3LGlB3GwiY
0lSnap3cUZDf83pF0dooAgGIW0CiyL6cZHG5+1SGnmXtVcnGeAwfieCjhl3sLlcZRnAgDctVScEx
VxyKTp0Lyytuzw4t+jYlARxlVzOMC2U2o+rs5t6q3G03s2X172UQKw+J5Ia+wPzDvGLw89l8S7Sx
gUWQqalZuXOK4K6g/nlfulBUFA+G7p0EGxPDSrSM45E5TXsSJ0wXAWuKJ8Ad6JOrmem5h9ln2cNP
UUdfLZfggI/yMGRvGSHufQhcaP5z+XmqFp8+P5iI/BcR0HmyI03tKHvYQgRz5e3ZiuzevSz3i/JH
5Xn2kQSgC3FJ4cfs0+y573ZLN70+Ngzk4eWNYsuy6MRtlHHr6LCWkQp61bRF00hV1LUjb83n2bqv
SNHaVNvdzMJF05ra1PUleeitGOtQqDNIMDqpDn1qayNzV/Pd0qSi1S7YyMRKJBApE0Is8P4063ux
Qe+AAUS1pJhKs7ldFKSyh64MUYqJxenV5HjWZ7rxVg/pT/Jx3Jef2c50ukt/28ebf7q9R3buNgM6
z9F2cNmcp9i9eb0P+xRz5niBQ1twkXB5NIn4FAvpo50wkGco2lKCCn4mWpiFt39X+QNkYU3E/Otf
50CPTA0/zJ2kNnQ5VN9hr/JOOhkMor7D/NzBYd1U/HJYlnmIFU3ZyADA2UKWqkg1nOMkYliLiBYL
LPPZCjKBPcumxIKPeGvZXkCYDxFB+8k66mnV1jqc3ukGbgbtIqpdGWHkduoy2w060mh1dvYQd+pJ
QO5IkVPd5TJ8pe96gnr2zbr/1KW1B3E8LrBKhQ/j/tlcBYL5T7LUtIIs8hY+fB3eWjH3kQo6hWGB
cYBOoYWBsu7+0/uxHzVpVF22FODbuysKPAuqA7OO9UVSkl6bZrWL9qb8ANIvn3yTCJupa2yW8e3J
grK8my6qiG5PGLXu3ZRJ5fSBpP9jb9+0RcYUiuGUuf+reNRup+jt2DQS25wtf3zrYpV2VtiP1Zp4
KsCEygorSADQ7UqqNg1HwKAVLbjTd7/SYsVitp35bM4rJ3DiNolhuZo/lEIcFjj1EG4lEWYlUqmo
iuRYpqsOaaOTeLhkZhXeVlIqn5WDlipi9720bQiFS6KLT/5qiqDvrHuUa9E5hmuimPNQAB4q51RG
b981TXRFo+5ovPX+6PEfsNETmvT38YoObCBQlxIl/+FJppM/AEEXlDJyO4zBCRtUD4/C3LhQde6H
LbmRx0TZzbLOvMK/aMm+kciK4d2YzvyrMIVl1pLi1z55do81JwGIj0oFgMlHZ0+ajjzH2ExMBLs2
zur36oNk1kTfKhph3z7spqF6WBEJe/iLbiKbRDeE/fyr+2GKsJ9/nSwk7G2a1L9/8fI1qGbJtH4+
RRhXBYT1+MWLl9/k/PkVGi7tNh4K1hlg5zdTDFI7eGM2G6RZpG8M8sGfbIoTVcyr7x59+63prcev
Dy/rW8KP6i7udb3em+YlA0d1p/q63m7ry2TtH794/urFt0+mrx7DnJl+/cPTp09emmF5+uLw1iyu
XlX/DvIF9nhrLRZXj3ebpt58z6GN92ZQAt5gaDnj6I9deZoNMUdorB2Yjip9N7uuLneXlMlrBkcS
mWrJ1U030Ostl6N35WZVLj9/ONKp4nyABCRWf8e2Id9AS04SqcHt0qRAUzhOS4zbblWeOP3O1CWB
4B6n4YWTFiDa29aSoYtYusHUiGAoTzrpJLri6xcvvnVjw7lezYGJfb07Oys3z8j/wd2oto9ZS+59
1Dubtxd3i6vz/Qvgfi/z9iVYnOytSFv/qImSODspOYv6qoMNOAGqox5W+uS2nd5syrMcHU2iKwh4
q47qSWPWDzo7clvSTVbKuFe70wa8ULYYU83CYKDizMjPoC+8Au0H3hwgyzKS6mzd6MhRFGcNFHYg
BP8Icc52DdqvKb05yGuLqjGC6M0o1Qsj4pyjPw29n2+yo+wB2US4E4M5K9BRYaxupUHVua0AzKNv
PvVhowT1IUwIPvu7FCi9oBmpiJY1oCPMMYQkBsgTlSk4QeEtIag7wVHPNKM09QMnHQ7E+5vYNJfj
Gz/8FXbO7LR+X1pLcdQP1coHlfWmq/jwcIdvKLNds8Pwi1f1RoKAUMBk05hmdm4qnTOwiT2LVHqI
5rM12jfUEFuv0HYnrK2x5y62F/6B6D/B80RggS2N+0dwGLtEO2XQuGDdTksce44qDf4wGFKdDNX9
m/2W40wSEMGrqJxyNI0iiaPY1Qql2JZWNFsMZjirllncmxQuivoxIrLWgdE6DQqsmU90K0pnKx+B
AKS/cUY3lBnYlcu4g+raLNpy44q1ulnpnz4nPqL8/WK0KOnDrJlXVb9zHuiq/vTf3vwvElV3tr1w
IXWP32QcUhcMlKuSTAk4YHI2W1cUSvfHN/+HSTZd3yAMhvVhHK3KK+td9tPJm3e/JEeLpxXGr1MO
iuBuvGPsFXLnxVs49jFRKCzsoZmJt8SjV69HvddgRc4LiU/CoBiwRY/WNxALcrXFNTYijw3nsCGP
s2bbU44byCqjNsnRdWemUksSs005n7quCL90zm6zeuqD1VPfckCI9Xix3a7H9+6d7s6bEYU7H9Wb
83tV0+zKB1/811+xsdP1GjWJef/rul6+WPeHWf/rakUPCHNMj9/OLk8XM3h6dvbkGl99U823/XBP
739bNVuIfwEpLLYE5/gTyMbwwAEy8NF0c0zlZbnewNfnu0v4YyRt+GOFH3xn9qr5plpvMd3sskzX
Bb6+hmt8nuFTwCqgFj9l351vyjOsCYj9/PwS1x+2slyWVCAhecSlPNqdy6es/z3ceMPD0xqr/Eew
YqRuw59msJA+XCLEpF5vbsgnFWu9uXkK2pPlDZduZgNSwlninp6aiRWTgmDaOAYYGQaewNkfq2ia
icMMcPA0GuAGvLM9BHNiimAQeAmwzcU6BwNVI+iUZwFCk0h1760y43gUTuqpmqlJijTzIOw0Cwjo
JeqiaUoNpi7ylSYE9A8n5Krfc1z7wHqpWwZIQBALDinkwEolqRDkhguwPn1l1j4EoRXID/wl4dH9
6OjCFL5HJpA9HGVmkoMMNssWu8vLGwlMW+uiOZbvbHk1u0EzCNQ2j9T5WKpgVafiiOVFFM+tj7UL
tUfh4ykyKVn5WhYIuyuwaRt8NqGKVW61k34/VL+SxNEdgjzCW3FQKx8Mm8AjoZESqNT3plcNCzTf
vykNM7aesuWmFcqAs4zwL+LydDrGss/rLREN+O//p8AG6PfEjHe1Ql9ScZyuzXENDyxT5aN/Oy9q
30k69Kn2HOLd/EqWWxzoLw9ixSgRja6MgUwJuhBc7HF9yMxgn/q/uEf9X8qfnip7/+Tv4lRPsRzq
zfRyBuahLmDD19X2xSYzs/I/+kP98k2Nb//Vf/vIcDnz9h/U229fXVRnEMmk/+WX6vVL+/qrr9Rr
iA9h3n3W9yM/mFdHfS+mA2b9tO+HazCv7qlXT5d1vZH3+gNEaDDv7qpXT36CN5OJevW83tLbX+i3
31JbvDdP8JVO9TtqmvcGU32lU31fX2EzdDueNfCqarxXEDYG3wLX0F9W+Hrl15rekk1qv/dzr7cD
2TYaWiYK6e56xUnsmf5/997/ICPhv5UhM2+hLAEpC/k/lbgo/4X4vdshbSLYDCmiJ2gJzpfl7BJY
2dluaXZGQ+2cOCoxAVRQdO2cEeo+Wpcy/8K/Lus5yO7VfEp7EOUPBJY7IBSQJzDuA1dltqhXgy1Z
o84yCKVdgYkqYCzAkYyqqE/+XVKVv7GqiLU+tr1Ft2OjGbMvwIWu3TW7sRUFm811RRxSVu29VprZ
B5fYGgDKLwsRS1NgpcyJPBjbADoOrQK6BMokjOAxJDo5pPvMyQDgO/qHBtpoC9z68d2nYICGvs1N
rFkhOv4GgCZaOC9Rb4rbCwnXhWcaxW1nkzQW/UxPlJM+TIp+LKzbLJy4/6U6/HswsV8RIpa2xcKl
NYWJ7STbTVwGdi4tQ4Rio906JMPDy+ZR9aIF6A9gIk/rRQr2mVc6nTR84ohWyTygNbjaMFhNPgcJ
oZdBRcF6tRXLVRifcxQjKvf3RLlFYWGFUG8LHQk+ntVaLk9OZixjDzvonst32Ba/BqFjBw0D8zMz
+5LleJMZbFnxPcuYHga6j2WH6Ypk9BDpiJBddHCUYLQl0ikNOPSdlg0pkhG8xdhF3oepRx3f+HOC
5oIf84gCmAIkwfV2Wq9hqP+9WudYQr1uqAajOVYK5LEw+jvm8wrGN6mCuYjAoG89bW4uT2sYDy3z
Hddrpxw46eDnvsl43A+2gMMDz4Rt+sggo7mrwl7OH66RD9k7h8lgSdOPD5akRvbjNpjbBbjTZsH+
Qrx1TFus5h/Km9N6tlmgnLfZtaIvH4TTHJeybyl2rpie5kd4xJyClELrr8NrZYNHxiiDmnq6Fl6R
kZHfpkyY9/mLbqOukA5nbaTkZs4GMSVqzdvMoKKiRunBKM0I+BOFHC0OjCuKnASvLrgc2rfj6KJt
2ydxLCZzUDzR9ISm7kTCE2rhvinEENLUG9CGPuxE/A/+bgPUzQGCFzegZPTQftH/gDHjWwgeNDy3
qTGTkIqTzJ7ojvFplGbf3KHTOL6zeZkaASEWjIPfcqkFstq4gE6hROXtB1jafe3xmIh2dhgDRlRu
v4mHSjMHMM1bLD64V5K1V63qUKw4UHrArEHcRNwd/Pz0qp1AEC4xLQJQ0vRMCue+SAFFixhwOxkg
alEi1svB23+093+IbPxX3u/TgRH/nvMVriZFCDaP+kS1W839wUX8LW+WQZYRvHZFzzbn0/ZdA3//
WY8p5O5nYyT+s6ay4zAj4aZjPsGGg0XHAb6C4jEyW3KBmPdFV3C+zfnQXv8kRB8gy3tIP4iQFivy
Vxjwa2oj3tkqpchSu2XL63/KIrcQCP3DU32ezOzx6kMc4FqaaI8Aq9zseMPiL9layXd4E4P3/onL
hhDk6cK/P3TKcHZRToQ+PPzV5P7L9SUTnSo9QTO5y9lUicX+vg1IfeCUSlP5S80tiJbXP2RRfNyq
OHBZwH+9w2a2Pk+IMQBMuWE2AJYAfGpAar3iAycfTmChFUUePIwXHbYyb8+DPpb/dPTeu6u/VN8R
pYN6Lp6GH9xzH951B/QdNIi+VSu0kwBLFzqWhHTbhHod5jHe8f0C/ILD4qjleyQ4KMKWB1T+mvLa
p5+umr+gUOVOYf0gpJo+8a0PuPxoPVeZ1CCorRNXwIeKdVMXZhInXFqlrduyERgbq2zGA7B7L0rp
fjy2qu5WJ8sPHzuw7l7gg3TU6TjTJPQ6t0nqHPTVjBzktTRoEozm22tSkHxbzxZFe3X9OwHfD5Ta
HZyZ6F1SSIVyA3EjWr8jZhQp2kggVYVgXXIUTVqWkucj1+ZHKVTxPO/1TFIXmrIC828qvpvdnJZB
BEzCbirLBd44nwJ4zup8WS5+06YUtV3i2aNijEs4kdivNtYffksrTGOlpz8qsgHG0TH5dD4EkH8y
FYHIu4MilpgOVHlbQzfZBD9yUAg2A7tyyj71/Smoy1Qhn2Wuvzp6oWVuauoJcfkW7f5LTMSP3lKi
tey2lRHtLLiw09vJLe4YwgvsjyJzGJu5kz0GFA4dfhb06mghPlvZqLPtV6Et6wBnP8eJHWZ//jm1
K6nDyV+Il4WhW/9qkyYsKLw89b+rS9TEvY2XNtqw1gdaaRwi9vy1hRretinOLO/ZTbPZBgFj/UmJ
b5K7KmQN4sgGK5GN6ZjrRLSL3v5bM1X8XyEC6sddAqb6XNU30fES33PIkUBVk1A+8bueXrX0vcm9
R6aheKXazrKl93nbssFG47sFK7DlHYwOTDRX9UTXbUTv2vPM6+W0Pjtryq2fz71X1SyvppTID5jK
GY1IYZhdQ5LzMKjNvnq01ydVk4SplK3bSSeLTBpLpWOr7wueqmfHX1nprYvq/fSvb/5n5ZbVvKvW
62p1/tP0zfIzcupqdmv0TkJrIvP53jX6xrkAOHAwAtCjctOQGSK7M7kIN8p/ykXCU15U9gnqQEbQ
9DydLRY1tpxiS8mJBLAQ1hL4cgP40fgm7+M5wyJu4cuRozE4Akt1rP/Amz2zOXkVNNt6UyKrMqtk
YSow6UsGfIFYSAxZrPNflMs1JkWO0aAjGe/yN4hyif2zyIhS4TVxXq/OqnMYQXpyhuf0e0SVH0lF
xhqyHe3PceTwm5qsmNWIx+VsBX1AGpQlenONwT8H5QjKa+awNNGQVLoUqOWqXuefolYCcbdQX5SI
w2OXdb124fVM7d48Ra8BZXraUjJcC3KMJ6q7GbZqVdFkRfi2Pk8y5fPUhwlZneUWzbQY4xwlmNQK
RgGDpstkRThekk0kg7rU7muvQoRKp7UyyrIn8DBTYWoa9NdlEFBFgiOjkdoAsUDARt2sYAo4lnGF
ByGc6o+Ep/pjf+DVCJKTLzK2g/AWGTaVw9V8/jCznoGme73asC8gTxFwA1yCc/P2nqzz0cX2ckkZ
ilt3Pg6d60oQUWaNWUZkr2nmK0eZQT7VsFcFLgVqkbTKjo6q+Ywcx9FzGDxK2dUlMX4XkNQbLUXm
Bc5D9JpGq2QM2EPVRIZ2WoJIxlGEwKYamBnUnKLZm+IUsZt6x4bOuL4R8RMcwQ1ThxN01J5R9uzM
DJQtu5prajbwUd4UOKTS2GEGBc1N85dVgyiYlzAjqReHWEM+QFBppmsaTdikRY99gMslFxt06Tot
uZmmO7HLgM1Jx3qdprxID5w5mp/Bho2YnoJcwHsQYurjlJngvxaMi1kEs4QR+gElvMeoAxb2tAR7
WjWvthRqy4yDZoR5QQbxUC96wXPTOo4BRdrJkBYMIUZww/jucHTYmh3GbXLone+4ClFDdzW6w7b7
2kW1wLCDLtQCbdPSSspZ9K79dipWyd3ynVknzHZEi5Mw7QforkiTiRIHfAFrHvPH/8AC4sqa/f92
vQHjh+2NC2lo9oFykwb+ctTt3SEGcLC0tWn1FGyguLIxJfhI+ahAdiWdrurVv5ebGrtRSCiMtFlj
uqVatBCFo4fg3FMfDcxS03Cg1Qrz47hYC+x5GP60cfbM23xArwbRIYfepxSfqXr54WqFM+qqNXhO
ClrWqQmecp5DpUb2hJy3+0rGN/+S5/jByTB7dbPazq7xFNYKoXlMwJ8644jk7uyz7Au0CfvX/vAk
ldve9qhyxjJmpsrwsn8QWC2BedpAy9ZjjrtlCqw5/9RWcfwwcI9QDCln59WS5QAMequcD39c9VtP
I334B8OItye527R/vOuW1tD6sW6M6GQo0k0T4DV0HOVMO6AT2HPVB5qR+41gxoFg+edB3QzGRoyH
C9sbeMTAlQMSEeCnZQT06mfPTkaWDyaoT/+tfTYvRrv1wuwueNk2mk65TtNpNKW7VNs+Fby3Y0LR
cWjhXQ2lVpyKlcE8hGTDQccdR3D5aSFhkbUFdbVHSTUELcjOmD1h1WPXslUp+EHZnNKxTzT6DHAC
UQJwd0FUKNDV469vynmNBnD/hDJL8tqA87wrS5BKN+ABVp8hJAnY6F+Cc1sDAsemnJdmn0Qrk0QU
sTvZ1LQHpZuZh50VdIAeAu4IUHVy3kEbBiqTnngdKLluA31qCR3n4VgMPeJ8Lor5GRtnmeSUBDuE
yKbLhAywvDlhM+51qq4xKTrsbloThmHSgXfoSKCnM7MHYZycYtypUrETbT6bX5SLKUriIRMgbyZz
WC5aabX3uKpynwSlvly4Uv+N9+p8CAaK5frTkgICg8iLQJXLkk4aAAC1lxRtICj2w8UY4jXxIYKl
yVevXz57/jvD4X888MKgjw6TuwY2EJBrzOm8AWncnmeaUX8vKb0vRVC5rYOGwpZDpWjpdkre3c0+
14mCTLYkxzPXhMeRhSp8KYYs+4kcMtv3cOX2+dfRKgeikNgRBJBZu9Bu1SW60xsF5jq6lh4fwc7x
svrEtc9/sG/BJwqA5NdU97O9GekaAxZvgV4SWT2SsNebFD/mNvb7BwyApLVrYZzBPWkjG4A/d5Vm
s9fr/ZbXxEVdvwO349wIGWfVptmiCqLQ51Nzuse/eMLLgXMJyIJhZ6g8mvhnr5zOWANS3QxcfFpO
PxIBXIkPwA+niqA89oI1DO9ySygYW9bEOWJ0Xm2pHqk1VRT0Kb4xhyloMjXUO6ivb1BIguNzTs+q
MxIUVBqi01aKVWAi63ZbQ7smUzcuaK4XSUteJrpcT1qbjGb4DqY3zoN40nlKg/7x8xevX/7w/AQn
nkcmGJd4wsEDYCKag3T7nLucvStJCcOjpuzL6912XuPJ/AbgsnruRpK/QDVYbS9hvVW3yZLn2eA6
0FvaakqmMsAnLz2EjKq2W9SKiFv/fNbgQaQEJQmBGRo5ercS/VWzQ2juXiDESTlRQg7aaNo6wt0R
gktBv/Q14sBVafdgI3euGtBGgad1nV3UV9zNBNRnDu7XnkoaCc8a6SgWLIi54A0vzbioXoVHwQ1P
n4Bw+j3rjH/QHMco6tAUUiGil3h5Zv7n6KBNpjnqIGwnRuBTL0blZqPkOD1xI3XZvmZ7dElrqsO5
BO1FlZ/XYDfxJLohZOF0+M4tHquuoWH+MV70KQbqd0a0zFVercyJ25Xck1pHc98G1d4tYTrV8+18
xId0wMq3rYD2isOUwgkvfKL34XWxg4s8Qrl82hWqxxhQVcGSYQQR52AloYs+xs7TS1eynN6g7n9E
++g/AXrl6pyj19VzulzhUE+sldbhoupsXVekcIcUqN1cAJ4Z3z04kFpReDPObBA8Txd1hXGwEOkV
2ms1QwRrRepmvubhu0mFlVm6m2m5+UD3VNcdLallj5OagOLJW3qSn+NcxuX0endwtlCnSpgh1u5v
svWmPge9lLvW8PYifDnFi0qzA+yanN64bVs4Nr2H4KQ8gfr+CqXvMiWSihG6IyoR/PG6b6/7/InP
dChlCxmY4ETmjfkn77/5/tGrV+bpzxIXZYw7/M9F0Dd4SxL0j/DQe+vl7rxa6c6xUUOb3aWZrDd5
mJl7AO34wm9a7NluRvQaMFrVsfWOxkCU3rFLhH9Ka/Uq8kjDwNExgSbH/SJISnUkOFe+wPv9s+ev
x4iHNjjaDDLap/BMW5Yc/K0fE5F7SOoOApSenVJ0KzOB+kWcxXcqlmghGl+MvdcwpCnEiINr1Jb+
Ar4ISYAlXgf8sDFb/5S7MBooWjFNyGOF1pskLer329CCUTx7miLWIPxRGy0jCVHFIdTt00fPvgXT
nrYCmlfJAmjS3LblTz6osiUoXKGuGDXFVbaicG6NvqwYTbdXI4iW2p/AgsUoFHSxpqdR3/dLQ84I
hvU+NUXRBuNz0dH3VxxWyjAj1T8vEl5k8fpVywqebANDxgTVBcm8WmUpnrWumxRxlg/nV+CLbcTX
6n2JgKPVAvdQeowjPlrvF2pDdjc39BG/yPbBviVA1bs+pN2WX9vGX3e0/vqv23xvU5U9qL2D+m9k
HYGJHPdSpN5CIbiXsnZzhDKreODbWq+39zAJ7m1Kta+3mdG73qYX6d4Ov/0/zL3rkhtJliZW+2tN
MNnu6o8kk5nMokBRiGAhwUvNbVMFzlQXWT3cqSJLJGuas1kpMBKIzIwmEgEiAGaia0pmehL90wvs
s+gl9A4yk5+b+/FLBDKru2fU1lZERnj43Y+f63f+lWcbbmCLf4PznfnTpdXEoXLY0xEIwyGFSBjF
z7VSSZya7EswUv0Sw6hajK6g+Ak0fjrw8VhCWHvlsmafUTrjp08Zrd/QQmBBsM6jq7ptOVd15muo
4C+EaXcYoeI4SLOgEca6B0m9NpXcMP+eS8Wekp0HfcNQtuegUFzgHdHmfFNIljM3bWhtANBzzBIb
8nEfqj02ad7HPC17A0OYrilXwNXypZkVLD2GT5UbmbkMtqzJhMJjwwAUFr8EPqCyS581wJL4Gs0m
C7QyePkwllIJRgtT0WIM1mXbPk/LUl8ZB+7NQxyeMGtTnxMb8fMRDs/CrIaTes9xcWbbGy7MfRgy
cT4DFzNaw/uOc0RubGztE0ebFufwChBx8bbN7scVYNZc3hsBIxf4MJyTI9o0va88Z3x8FWCj2ZEg
VzBDrkB1XPiCwKyPrPLuylzfLWQcEC9gK23B/ZtozSP1XnDSG16MrDMOydFA+HHyH49PD1wVb/7h
xQ/Zyf3FqSGDx/cXjGGbTq7UMxYz/R/fv/v3nF+hbiZtCaqh9eZj+e6//FeffRb5ygJ9GkhMIwuL
eD4H8N9lfUZUxxr5DIGkL0HjvwZObsQFR9YR641p8zWFPOCbCfyh3KXa3RkVbFBm2+B7zh9fX9Vb
clQkDSVmdobU7FxWKTsIHWm+3C0wjbrFMAWfRiuCW/l7sdugXxZkngEFifRGJfe1OIo3HdYV1HGD
j27ljw0DPMiSCx8PvDpnnDhD6gZkmk/V0jukb7aber4lB7/yA/TzetOAQhTg+MzFco05KBat51GL
Hd7FquvhyBo7d53WEW9NG8xUOxzdb0fDwtw/u0CJZSodDUe/qtIRuKSMUpX2mG76OzfhtBvmmSEA
m+FPI52KkvdvfnNyzOmpb8gofVqESb/bInua+YWCyYQUKOVN/mjMHki23NGXxcOHT3wy83tXOix8
VAcAfKqX9am5Z25OoEM3xdHvj0/joi2XGk0mkxFwlCfUfSgdbdRg93m+V8nt17XDNVXwt7Uu5fBt
sPIHgWN35KRzL3u7IX3Kp3JVL5cldpOd/z9UhjigKk3yxpMdtQY/U5rMaHLQ7mRbDj199FYytK66
SYQ+DPoQ8uZLcx0aFml71u/oBo/ZI9LCLMCnXjzpbvVh1VxrCPTOmCVpBlo1dVXJEN0Do7sbDqBq
0XY0pUQbfXVyv83hXBdCXMGtGIkzXF8ZJXQAT4lHN/dvno5AjEq2RkonadfsHxeIqxDbjaxxUxQ9
kL3J42zujMR1njrQpmTqOHcdaSweHug7nVT/tCI/ybc05MKAXPfYyvTJXzzSbsv0RYnX4RFelKDx
M1/i3B/R8UBmx/kX01JwmlYjh0GJGZ7o2Ux5JZvLddcqjWarXb3NGTQMMcdeUHaxjHQxTtFtLU0j
Gcoo4xgac6ttzcGmu2sODurbJlsZGrRhj2Z1V5u7H6Y5yzDLkou2gOPPRlECSaccpjBOuH8fCq8i
X5TLersXIwAMaVFuFtmTyV9lcGV7V/89M8RPdXWtBoMwz0JqWmaKLFNTuMeOxNM+gZUJ3gLr0vGO
nOun2eO/eqRFDHovu8Hwc2deZJWIEh/n7/6f/5Uiq+SRCj8Q+8cOXNohDYZ5tt40YI6cDCiHFU7q
RdMsJKQXtWdghobwhS2T6E3d7JQBIAPzdEtZrbyEVFdlbdNVPX/34u3s1T+M6cfb52/evgGNyvNn
/ASTM77+8Ye38ITsePj8xzdf//Y56gW54MtX+PE3r7777vk3pnQQ4JVkZiU+DByzpACHtdhQMen0
DBT3F3twnKJfgz8qaCxehyGly7Z/lOemzDQZXTbT4WWf4LI4OjJn5KxpIXGqBJbNzb6Pk2ZxiBkX
VxFmhm5RSJnhk0FAMCuKZczpmAzZ0zfR/Edq/uOurra3bRwLp5peVHdpeqMD6rxwOhdJ5/T7Q98p
ypBOc/WaTWv6Sq8HQWgdCO5spIgUybANOMCGjD5YR5afF5ywJrTQDvPnBeqz4TYpWBA1v28KSXGT
vytYf5dfF9flZmW2gamxLEAC6V7+Jc0/dJbwYTonxY8xdB/0RBmqiaCyZDZh73bTu0XdQlpCnALx
G+vp7BGtx23XrXvJTI2JFcsXcANBLk0zn5iFZ1P0dGZ7NlJVttv9Mk6T1tG/7RkXtx0clbttM4o+
n182taGk0xN+n41AqwX/4rUIP1b02Mjm+BcqTkenUU00RDv5GSkIQZ9nNomp+yFU/BBrfQiVPaSa
Hq6a3hUBso+V0j6CP4/4796pcLupK0DVdZq8T+Y7w+et9v7+oa/Rht9Aid6+Yh5yvWb44LZrxoVv
v2J7zHjN64OFu1aFEqRbmt7stmsz2NxUYKb/IXyK47pFCK7v0cNUOjuaBi+Qgoq7FlmYp9lbbv81
P7K6bZfx1Qu4JFP0VbkqLyrgIi7qdluJCR7d3kNdpHNE9LuD+WEySkSvHuNK06NjTx1xtUfV3Cbf
luCnngjwZT9owTW7Ktd5C86pWDQ0IrABQlueT1Tb5FrneS1zP7HQZNM0W1AXM9MDOTxokY6pGGTT
4A67dFnUKuhSvfWzjxGXjW4B85fkxAoctrCwTKkUU+5bTmTD0z7Lh8+e//D6+TdfGwbnmCkcMuJV
uQA+TggsW9onwdEAz46pMyh4So64dVGHiscdxHhyIc7QNRynlJpSfiq/JsD3rhOZZzHehAsr56Yu
PamdWUgBlgheQuWTrlAMi7eq8GaoFpCu8/R64buB548SOBBoJ4NkAe1lwJoy1Rv0woNXnxvpuhwl
ncJUz6ForIQT2/uhCkyJ8+ftzbvrkRYsXIHB3fx42K8mNBsuKTYCMEWUS1+XM48r3calQ/uvK/zt
MOEphM5tn6ed29yn58N49OL3NuZy4+D5ZAcyZm5V2b8jno2ob2fwLBnROHs2pbmqF8zenLfinxX6
7VO6STLswT/+C64NhEf6FQTfYhsQfos/gpRctk2wtNg/bCKx8FLpGRhdNkhkgu4HshQVDQcHz+yR
819acUACrJLXpP8NcK2Xhi7iAge1PJ1mj+LSZCa5bWlgt0hcPm8S34SfzFa7Kw4GQjveo0FQJRj1
nJVUP99sF/WGbCuYBRtZ8bwIspon0kUKzWdtJLEAQbe219J5uuEg/NlbpgmIZOZetW5qfHXzet8R
tazzf9DPIHXqfLfZVKutXRYPg4tDZzSxTt3KfvnLsgV30J3F3AIfH/vQKa3ZSsob21SvPQKQsGY/
j/h2GR1no5sRx2qs6e929AvaZ6EsVxB5CvD9EI5DxZwjO0OjFx98lxuPsy5poHhv+/LiAW9jdg9x
UfSdXN7Hx8Pi5NFpYEnFOj6fJlYgEdIdrhD98Pef1yvZzZMzCP8zvLN5l1ORIq7eemB1vKPM8dzC
F8AtFoOOQhsv5J2mtlqBAWFmRMbz+oanlv4Yk9w/HQ6TCDQSJ+sP30wafX18t5GEk0iV9I2YSngL
h/097vsIS6jhHO7I0RM3YzxXq+oahxGHLt9qv9xlGvC0+yvmbpotenw8eEAHN7wo3aDjouEmsMMR
d+dEpew+oS0oICrdbMk18DjyWPIN4bak2VagAmpRvwFmyXC/BrOc2M3WITE5pE2l56lzPNxFsBWR
b2PH7A1/2oDk1Nmc86/gNIYALritt8wAdC/Q4XFSpVJdsvWW4mq5bS5nvpmiCyjs89S+iCs25Vyl
ajsYgbG7GiznSrgKmFPGUBtzW+KCO8CPTeVlXdROqOGGkdJCrn9ahcKWu7VZ6EVl+cuvv0O9+NNM
1i66ex5H3V02F6xy9NhUxw9GLKvqi1VWThUro/2vhlJi6PyU4ihx3RgGdATD9TjVIbq+gAOc4lmD
DpliHk+ew6Cm4cimqt3D4dk0CdOQfw+dG2XA4rPDf8f7hHQwM1G+VAu5h/B5isQe1rAo/ckP3/34
2xcvM1e9TXhNDQTYvRTIvgWTD7noXZV7Bh8TpxgMYX24rcrNorlOBLWTo9f1ZT2/zHbgaLPdrQz7
uNxn83Jtdl8FMUMbUZFdVpvuzy/KzdnSL09gZKD4CDZ/78FA1U8484vKFENuXMEateFZj/byyH1H
XncTc1hhienzqBkJwzQnDJmfgIWTree5+BB5dJ4NeCOaNUElECjbbdZ59dHjlh3eAR0jY0w48kQD
dLGV9oeQzRTKMcmbjGiedBQnVHr/wHa/a/59HotukmEYdBBIYOGxV7JrwLt2teozzVADtdqzOBwi
S6vjaTVcUKzS1zHMQcBtg8VzckBXMjX/KEUkhAqIfgGT5PjpBtObEL9SDq1elXxHQbuzTbkKgQWY
mWHdh8RSQtOh881605yVZ+bksl3KP/p98FOypk4e/spIvL1B/QhMPIJV5tjc3k3Ru97O21ymtrgt
FoPjfcIPk64k6vaCCUzfW0jQ8K2VPeHPW3SJtFiTlA++pfNS5c8js4Wr1egYQ9LSulGoLBU+kahs
A4LsgaqSQXiJuiRaLq6um8LoNXxAAYrzdMLJrk3Uu2FSZInWyDGaEcpLsEP6yvdssU7eNwFC1D+e
FMd+cr8Fc8f9TCZwcmFu3+tyP6kT6Dh3GFGqsQSHeWuB0prBBB8nIVNaRG+nt7GUIW0oezrNHncx
yflQGjNsDEBbDyEt63LB0AkdPeu/F/ojSTu4YZQJhiEBh4qTMarJY9ZRtZhQeitHTgXiHm5QALlx
5gfBovFJ281YICteANTGaZ9i84sp+tcxMxQBi8k6BldNHymHbgklGD0fJTgNvmm5E7nvU63f0CKe
gxaTgekO8deyr74Kby8dYooLhoJ9RqNXi4NRGhLIaNZEXdM2pCP1iRfYEah6TfeTjNrQLcOw594K
SsNpGPqqgS+mDgHHW14EUaT949laaPSJZsCwlj3M7i+4CEYs4S9v4lM7PPhedrapgH/ednel58xv
IgRK5H3FrABeD4pUdM9tKHlw6Ggn0ZsZPr0+31OUUUAAU3tbkaoU/NCytOhDQZMtYUZqEYQfRdoN
XRTEOwg6Mv9M4D95OuOCs7X0opKq2XGhuuRbRW2yvDJMzrY5i2xrsdjTZnCXZhLNm9YHt2Dx16Jd
32+zo6PsBywuErCGwx5L7UUSjhExKNf79V6aQifk8E52HRxOQr8FbCys4OT4y9PAmQE6DjvyBAof
3W/N/08p/QJV3lXTl6f+4L/ArHC0+KYO+En/oO/iEU/BII1MNLN1zxC2z/8ba9DPih6+/2n2yGJ/
dfiMeDh2GkXM/wBWwGzv6qxepdMQyrBhpS2IFzrhA9AyuKkVg14NgRdtdViyow3vzyGVnqovx5nY
PKaeBSRozhx0mE99wLRy8HwJeVxWuY4WvBvN8TutTbb6ElzVbC8cevSdJ4FfB+TVfhOYnLSJx68g
nuqTIX8F+qmx1MnKqtyv2L42nIhzlUF1Fh+/pH8T4F+Kum1Rk77DJ2eujuNBdxBydIsM6btWVGsu
G6M0B9EJfFra3LVSFJFmFlvquy8AfKa97KTgaS6GvweI1ZRRBtVK9o6XuwirngSMnKc8ctwKW0KL
HqkaCf7nMDcKEpMxd9phkUQx5SD027cmaDYQCEbW6lw6UHQFkD1OxVo8+mOuOcRbqSmTD2fJrgwX
BaneK4+wBWbFe0mlPt6PKEDZUM+8/uKxrb7QwVbppUxpNwneCH1IAVmFZIKSAiXqDTisg/5Xdo7i
1xAXDaI0bIDGsio/VVjLCxsTUn4os1zH955V8xL0tgCitsnkNGASgosGoy0bIP7Zpl5wRAIg7u+v
FZjSHVn0Q8WPHh8nEtftVqEbht6RCAEF0QswXen9x4FdCLfkKS1Hx8fm4noc6S39tk8kty396QHu
mEvtcbJbVAC/wAODGRdyroFD2A8pEGi33Qcyhlx2riq9VS7p286PeCOpGeovyLNoQzmPj/Pi+BhI
CaiBbzGqNPSEz5puwafaS3JfrxZwBLy78MAYAS6wWszcqbG4W+bCmV+W5k4oTh4fnwJCGfhEZnCl
4fi8aq4va9Ldzz8klYLc2Wnc3skxCpPwvjhNz78PleSNf7JuQjdNdGVsljDeuDHX1nGiMaqSb03z
VUKjhqzFkrNDmInOi2EqdygxVubGTqD+2lXKXW+yI3PMsgeAgj8cHNzwzAtTRbDhl0WXiBUDbqbF
LO+Wrm5qtgCoI5hC3lTPY9zNRNe19wDFpsygrRkBUk4D9v5OkVZhjFVcUxhvFXijyJCRHEWdS+my
pBBqB1IOIlJCmIa+MmJ/TTqaxBz9QQg25N27hmh2bjiDKTaLOfAP1f6sKTcL9BDY7NbboI+Laskf
RCVnV9VVM0gOWFkzi3QJZKDyWDCQVmauQ9ZdAbnUUD+Q7hZiZBMIJvnhbTApArA4HQpW89bGQBxM
hdDR6qi440w7VqmzUARvPeewzlutCmke+CMMzZxvyvZykvTMVboQYI09KRTQGf6B23ohbQ3hPJli
t+F0bGRPMnwbu3eQT07f9PHokhW5ufZMO74BPMQmWTQQHloE8SIfjCCZR44noQmpB4EqxQKYaaPW
kO+Filzi6KgbQXvwz8nxEdw5XDSB2mLK0UsxW58k2JWl4QehQvOPZXFGE3AoNfxi4cB7+V1m3qG7
ECS/aLtVmicsgy5TbE/muUzcEzafle8Z3ECcIhg9AxbskEFpz4YPh0crAFBZ1n+oFiiaDGIf0lBC
ggvJW0afnxuigR6tziB5tLYF37PHSmQJZwBwwKS2XdU//QQVPxwmIXkp7iP7itVFt/ZPjQ8FDW94
Ivv8dBgK9tgaeKj6qXD4LgOhUp0NMOcniSHZA6WVUeQglTpKFiB2Hk+l5KbBgr3jI0hUrasdkrfQ
3/oDQnLQOZTOpFI0Nov45SjLndLxdGS6TzZRnBz/ZSCI3TKXvcsvQKAADA1A92xdtRw0pRhBVc6L
HhPZPEiltvTlEGujC/QgJJ+dnBa9fhU3cHmuF2egu1ildCYW0Owm1kYpZ8uQserwAGbP+eF1eOTS
ToKISGi9A5O2fXnbtRBdulBnYWAtuHgFdgN/XcMsd7cXsN+/QxxCsSZcY3jOIQ/C64n2crwWrkDr
cCI2t8vX2ncEpIBkjHRaNTGIN+w2lVxO9p/VpaVmngv9+okH+eLH18/fJKaaVXudTfSPEmRFWISO
yD7PrcQjSp6j1GEleuz60pVFiNg+22JI12/TrsWp68yvQ9UbEdFUZ0UVrDraPSxG/Vn3Dpm1/zxb
B8XOno3jaMgJ9+O0Kxvf3RYl6VEEQYRd+mbLPfXsC0Yw1hZ3ikjudq6yoPzodTc8Plx7ueUMos35
HaoXd75btmAdf3saufWevsV+Dt+muIqDGn+6kOei0MSQEKY+E44iaDuiVXAAR8OxfB/tdq7u5AjU
ejChP6WmUhqd2vLHR49PewJkuFjiZJMcH/kKILsxW+w24iGvbPbZUYdp337PPg6IY1BA4i6AEJx5
TbpIGTp3kbH9Pip77k+eYGhGYyQpvBip5rCD6mvrKIitE6a+OXPgASAI+4M+C3PkWZoiKByqEXq2
xdWZJTx6fHzInTwdkBLrYmL6q/3HfUIWyLU+Ewj/+5COfuWMuOHG/NDD6g2PPhDb8iHwPki3gHm4
wwRopomr3iauGKH4Kjozy+ODNAMvgfuMMZu5OQOgGao2T1/9ni/ViZ7t02LsACWWReF7/1kQRPIp
EZeSTzqU2XT9Uxxl+4nDa7U/RidAtDklE/w/+XbAQD5pdOj87X5Ngsc4+0eAWghz3ipx5hN32zoH
CNi8CAzL445QGyMU5GCSEIflIkZ92Gu3g5vE3Yd662zfIzVSiRvqZDdFQWJCX5qtjIprzjNjHc/Z
VU5tA0+vb3NaCAK6FTbI1VJiqAppZCb5nIhU/jySDyB41xcX2hFZAhnlENR/ZofC5alynzJ0NJ5n
lGtgIEFuIXgveSXN20hoMw+PQYz042uE/boEEytkDb9aGyKFMNX1xYqjQK6ixYEW5CR6uNjyv8Rw
bJTAuiSGz8fFjjv+qVxiFKEIctirKKXfp9DzDppkI2mwFK6WqM/YJ0tbDGFgsQvOu2mhGNtq2VYp
Xo7WGQNrYGoNdJglH7tm4IrErKR9pnHgAeFnmqFjvMOkcBvHqyec3UQ97BSvqqK929s4ufgP4uMW
VavhLLzLnWHrDrmmHKfQ0TlmDLIc4T7WDjOOHTaL2Ga7lgzhoFnl+j8fBCby0c9Q0WS9aQB4Ervy
yxE9409+GXEGbQAa207hP9qn4OMOtJPNCny7gLH6VK3qytA3Q9nRpUGSBl8iLUBoLM+vwzToYXXz
yQ9VFyp5/clfK2xO9IRYVPN6QUniyJuC7g+zYecfAJMDvmr9fFAQCreiE31FJ7gEIOqK5zPsolCN
0OlXToNjS63a5uMCcb0D7MKP1bvf/xuEgWRwQzMn+ytzCbKu10zfwvRnQR5NF/sh9KD8ZM4JTLBK
dzU4L5fmI4QhM+OmylCqkQ9Jd3xZCdgWTcMa0JYQD3Jg70YPGVJ6MOPZayeMusgAIg9gBlfNx/Lu
nyp/RVsJ37kvsITS9mHFB1s+XP/Hc4TjBA/KZXMxEcCUjxfv/tNnBMdpHl/AxH39w4ssH5mTsNjN
TTUjwkc1W7oFvyHzt/m5opvvU11mzPK1BUKTDj5eesu9qeZAlj7W7/7Lf0fNbCDP9gKxwuVmFIxz
0Oha8FRylQRKTBXz2AzfAFkKe0E0peIAd9NlrURuYHZe30AQKLNb2E8j8eFBdvi1rwW+lsN329fY
fwU6S7GRZr4+1WDrNjutrQAW7rJZtOy89yB7/x78GQAO8KLZ7ImRe//+2B6TsrXdNlLIdn7pQN/p
k4mtaL40F3KOX+PPDJN0Qzo3GTYWfVNV2eV2uz5++HDRzFv2T540m4uHy/psYzifhzYy+HJ7tSR/
EgdHT3BhVgcpHanNbvaAaK/N1LnoZjs9zOAg7i4UiUO0J5S76LxeAoTLiE+n0uEQzwYf+/im9vzm
FugMJ/HnkcNcRKhvw0EFT3ydKN6YwGfhv79wK8EnaDpmmO4IgcNMwteUCAQ3wfv3UDgPy75/b/jv
+uICssOX2TOu38wxT9qfZ0LL5XW5b8lsx1G8kKnenjr0mKNuqQAGM5cAnpIaxkDnrClX+3wzkd0J
kkg8LlKSoSLbvFE32WxmgRcvzaExZCrMOI0IyzS1pj6kh4bV2pjrnmJEmTwlGkVWDNdMNNnW7LXl
FcblziXdqdgRbrnGiHyF/YPFBE6unu+W5hja3BDXsqp0DgmaFbaSYSYxd+MKwsf/Lmwfb+KzCiCj
5QHVSLIuSkeqenoLOb7YU5J6drVrtzJi7C8XxzpyuEQzyL4OTAp8j9mw4b5HP0dwRnRwr1iYhDIe
CwIwE4C+rABMghCg9+/tVuTF+J5sCuYAEKJ3O2ayQrDNVTm/tOMhTHbdkr0LeGZ2IE+h3RdVUjeA
CYAO1WMYBeB5Mn40QVTD9sfKDPHl2wiXzfRGVXisHKyfPn3KBwx3yOvdCjRTPBa1fyFiTx88vDqG
V3t5Yjj94Fv/hGPmaHXGv4G/zZkNt0ThnbiNNgTxElNVKhWvE6yh/MmjU3D69zCjEHNiitWF2YzU
11QMPnWqyw0xn6BgQB02/J0/Vh70DRAufDw5nxFK72TerPe5V2ayWy/A/dgjK4624YiCZAZ+Gqk3
CPyNXSxsTqlARnMIJsBIzHg80reLZXNWQpoD050iIcPAzuM50i6ynR3k1XBkEzwrPdLJEHZMzRe8
8jkdi6ITyc6CewilHQc5UcG4Dk/or9BB6gAanyXfU1t/gMjHbalUrH4B6gI7oaya+Gv+Mv6KvxkE
kIXuvvOmBohweOqB3ydu0iarlQNJe+rrRbkGNhVZZEeb5sBfWevxe3f7di4CAlgkcRBnDG5Bp4L+
aE+cKH6Kukkqw9o63Gr8LKiswqTYC0+f494imUUhmD1CN40hxNu9AgxqI5cxM663kPaXSfSG95+b
quFwmE6pAp/oKTEnHvyH7azUfiu/NYxDGdUPOlLwZr3pb+ekPvVm30wDt+M38mKLkQuGyG+a3cUl
51q5xZAQJtC1p606M7Ovk43BvK12V2dmp9125qzKN2wFuH8OdFq20/hGMXX90Kwp+UG9wSvcb24c
Zp2Qa6G6MS35neGYj+tEtAf1KwEeIcmtwHnAkhrT16Lbi8XWh77aKrPIr2fvYEDnmCPDeT/g3gWu
DnrjZpTEoHjVvkGZaHvrPa82IVjN7PGivYEnMt4dYquRE+tP0sHxuzlgNoFn4JtyhUsKlWZmOrbX
9bzCMGPP5TckFl7d9JKEAGsqZzI14cdJGjYJv+G/T47DKHvw33G4Vl4d6tXAc5tUL/LbXGqDPnBO
hnSDotNE9KXamayXCq/dQQeY1q3v2WIQANS0W8g8Y+gxxvg2RnDVs+QleEn0Vc/Or+/b1HVwqiIv
o4UO1i+1ZPdAVmyuKRENMABS3ty5Z5Xct1plOK86GksJpUZowYXR7tgBafFO4Y26jR9I4qUOgI4/
05k0XYAjCSwghJdhI7i0QK67zmj/ybrV6oT7I2KYRHgIGahupjIUMySjRZrN2a1V5dwY5ZUqrBox
52/pH7WgZI/PhypZEkqoZg+ZM3JEzj4syYIQF8XIDM1I6k/CxP1OLkNYEi9juC/7xLJ9EsUPRNCb
OV6TwQfHXc44rH+c1C1dl+b7ruBP3EzWhgqmerNLtuZv/CgAWInrDUTB48A/NFAemEmOBh00EX1j
GFIYUgzU3Nv1oF8hkUn0LHx0p6N9YP/x9+5LTcMgyjgjYRvR+kYbsmAwGNByb3NmoT1T9qjeVKAB
LC3rDjumpP0SdVTzBbef6h6V2qqjLqtVC5iSO5O7AGoBrJD58NmLZ9nLV2+z3339+qU5Xx9//+7f
ubSsjJv48cO7myOblbVpEzp4p5g3MsMaRcDA0FKLtQbTiK4uXrzqN4JIqeirAcx64PSQfZXlX44l
D53Ax99sX7zK5bsgrkOj1S7KbZl2ZVY0BgqNM86SmlgGeG9mXdKoUnGNKYGJvlfmZU1ZeH58++3R
34wKSk0LMQOBP6N0fBJ1deC0FzRISPxmp6dr2n8Dy94z6zRrXOrXT9sdpiykO0M8FkaG3EJON8gI
Qg43VFFx6+kZrEHkN3tkUc9BhP75EQCjbxcI3/GYfptL3fzxhP6oNpvRL3LRfvvsG9r2LqkhP8jM
TG+bhzivpaQubI8wUylyZIuqnW/q9bbZTHo1DBA8X23PAbWPDgtfyavmeko+aDKCCCwKMxOD/Vbq
yFyjpBtuADK1zFbVtR+hUMGCQxYx1NOAyrSaZNkL2OjSDbN4Prdq84yV9lxP3vKPvLDpF6HJKnAD
W2WkvAENnu69f33YUUztgDQ5dv0igoy6b/nk88j97hyTmKt+4oC/hc6Ors++CBOacuXTbLGjEQGz
xCd0OsTzGboBT+bLpo1go11N/CuUoMyC4RibdmLayr2h+0AgvO4pCcdwUO2+VZlbERxI7/UTqfM0
AEu6TkO4bby4RIfQ1Bc3Y4ZwDk4iuR5aFCvz6k0ihIXOu/Mty4fw9SI4Okh4zfGvE7nsgEGsF9m+
2WFCXe5yQZLz3w5j70q3v8xmsZCjetGCHcSrBDs6X1SfVrvlkkKbzMNXs9fPXr387p+KcELMmj7J
4Tg/il7RfjmP4//CKFNa3TSQSddye0M8HWfPmtX2dVUuvjUU6gWYnfLejLTScz0dpANu8mKcdezS
P2P/dUfUxlw0Me4/0MHdCmujrEXLyvB0u/WYhUrKzu6dzhz/y3rmJEnyJoS3duc82MVNH4RoB36e
9haWeW+r6kP+qBjceYrvOL1cS5HUzgr58nH2m81F+sqHRcASNu81KAzQJLepLzAhHc65O9zJaUeS
ve6m3UUvNUqsGFVot3IRXYTmJbENxDA4ZdMK7LbHqfJC+NlrwN0YcMPx/X22Oz9HNQHkFQVqBz8p
PaG7WJTA7SVMNhc23d1qm6JNdwQmUNPgsgZhAVSc50riBltZ3br3C+FdkT8Bb3bpFLrybDfN0l3y
9A5zNduMiLyKhiuwXxIs8ohHNNIcIaJoXV9WaILVUhV0Suw0EPFRQvplsN6V2/pM3ZB6tAA0Tm60
hn0AgzS3CC94Gkllrr6XTzEns0oIDbNaLXxLrLd9kNSf203iz+iU/jG30TmYearBLaI0XX/7sreL
7XBAqC3Xmi8Q+pGScJ5OtYgjUBC8qboFTjUaF5t8NvSh0N1WIAne195Th+HeX+C1iJ2mfa+2vNvh
YEgwZ+VcoygG9lYacm99xd3Gyb18DgWrxbcBN1fE08/cvv7gkHV2BoHZ5ZWqNgKwxAKQyIp+hblH
eBRTW0M6zQxk1O5yoMfc62mZyryCiT37PbXEN1M8B6HrAFbpuw2Q43Pb9nEP2BpEA2AC8NREMJHF
9/5AEW1OJYsJ7FQsTI9GHDIhJRIYFkzCfcslXIh22YIYZ94BHtyjXVnyaOW9wWJfvC/QUWwODgV9
3mIRhYdUUGPA2cFsPAX7+FxHmSgaTFeLwLUusz1dq5iL4iH6ivMfPoILuVYmvCp9BwvgnaE+kmFt
cXR4gBE8pIF4HyGXxYKw1w9u1FDgVHueyIcQicu270YnQIO0R1rvPS3zCpuyATjpSuPbODAEtwID
OxdT0n6QG2cOjzwoZ6gqwX/iC5Xf7iGpEnCmJNcaTdhCsohA8m5klNqJNzMJbg9rD5m9WIS6Bg+p
pdm9iz11KMpERt0MqLrpD5mPTIclUR+UJl7b8FGseRgkpneI14eXwpVqswIW/01M0yJaJ6BSXAI6
HjjzeB/7OJnSWT4d+PvzadQ8v0o2T0OQEonmvY/jHWQ3jwq+a9HqmNwhtAtIAZ21q3LdXoJGmhPS
gMfPleGVDfslvG+wMUxzvKcJk7lc0JO8uN1SpvqPvWca92a7YDL37bOcfynuFB3zqCRaCClZNlMB
pL/45Ntnj3Hyv332ZKDpBSTxYf9xQ/9e/vjdd6x9gk8eZTmUWW8w4Y/qZ7ngsAA+WvWqIE2V8vl7
NH48fhJKFwraGyJCUYkAwRjIFcLGOKvsifS9cBO3vZkoVsaZ+eJfV/VNtQgTjterWai1oz9FnRex
CQ3bxqbZz97WG5o2h8e4xfznpgfmuflv8Bz7Y97gv8E70y3zxvw3eC6dNC/lZ1DC9Nu8NP91z39J
aLTy2yqZ4LbUNzR+HLpYrGbW/MnTczIyD0enA59wBEVAj3s68A93UAS0u64ITlVcCB+rYjI1cUl5
owqjQW92C0QYrIqGatXM+aOUGjid1N7r2lR+FCksmaQGLmLriHYfd+hFvbSnwTWFdHCEJCCl9HGV
NAGP0j0xtMBuYh67ieF/e0FO3LQdmqLoJPI+ksU2f0xCTe6vmVqz8yL7iDB3uOH65q2/J0u1FEAX
brUUwvP0g4r0rH/32tHJc2v35F9w7fCAy4yZP3792vm6cKBbB+EBgUalHJLMc6ti7/4atl3qa1j3
w1/DwFNfwxxE6n3A9LyqOvhY84ZvRgzVAjnAqvCAM8kSrEkngbf62jGaqsI7UDFGeci7cAKubbN2
3YkYIrebU/u0Y5J95b86V11MangMA3aqYzX8ZtRm7GJGdTNQ/GAziQ0XEA3YenE1sBQps1JwlTs2
0VsYvY8sD9rN8VpOF+24wLT5IpJd3ENyELJERUqCEOHGcIvcWB4uba/xY7eNkg0ETQPXVaSkh66m
1XL3NS1SVDjnJyJbnHpgoUEr40zP+XlkOGABOhRtKgxxEK0HDo8VQ8NE6Lx5lxLLdR5iwL252ZJO
owItSCK18PlkuwEo1m2le5jqs0jnCcHk14slTjT/Z953his+QpFrP/QEFZQQ2OWa8ik1KwiXo3pg
KgOJZJK92KLDkdYbg628jVv9Z/wiK0VvTGj3i6ZCZaZThTQ7zFxqPlnugQyDUjJ75qSbLAcYey2x
oXMQ2AiKXyXOOMlFCzY9cstywWfPDjEuwUeESmiOw5Ywc+FK+FHnwh1pICziNOFQjZKEgB19ArWH
VTMcYsg6GDEaRsi8It+lO3eA96Ja0j20mohBQjww//110lUP5yLzEtRk11LddtFn0cy5BVa3V/RZ
JBbZVc/UbQW/E7br/x9xFHZLRVxE6lqPp5SPzgEeI6kGSxiG7faJmI2e3niy8XIRyQIRK5LUinX1
pmehp/rk34XP+JfiV/+sHA1tgujK7zyO/jkEXBpsMAUnj5xO4n71pYju7dPJ2sBO6msY+Zy+hlEA
Sd/xTn9K93d07u0tb50AzEzvzui6Bz3gogLlP1mVaYcZZqCczyuwHI9tbmq3Pcyy7ZaQuzojo7BZ
PENIcNOsm7atIdEwWAHQ6iT6wQEbLM5LQPAD+wt5NpjbuKrM9U88iKtaEOUJsASiBi4uSeSV/DPA
Auy2zRUa6RH9wkxhC/pJU9EZJUUGNgYgQzHMAr82/15gTB0A+kI28/imR06PXaoD+xOxNC9esbEA
SqKBCHkZnDvK+CFJzls7/qEAuxBkJWI5lwvvWasfShifPLO9YwN7cLJiQ4Zps94Q0MgbWdV1W+0W
DREIgABfNVJdMXQZMGq4ivdRC7TfXGglhZGJx44qSaK/1W0oty82zdODQY/9H1iX1mYTGa22I+03
q+sbvfzxuxSOUlDqofn7ITwYDT4u3/3XCmMFALM/Xr37v88JYGUOQTkYdHNldinhioGOHPOqX0Dc
PhwMUATXWwuGOM44/3i2bJo1ESx2E95Ug9ipm5oeC+TNwLqCY1LAMbQf+B27VFutOCB/T6nwvi/X
a3TBbzP++X19Yy6GXm/wH9tq8wy8ebku+I2fRdUMPGweSD8P4C30lYDNm8sd0flh0dltfr4D8HUS
cRDIHePZc4tjBEE81WxWTEwphGY398c9DBOinCfEiAMZuLoSTP8BJz4xtT4ahLlPzMPHgzB5h3n4
RD18+fV3BH86zb4cBIlRzLO/GCTzoZg3fzkYwF40wiMeRxs1P/zfTsqjP3x99J9npz9dP/ifhoWH
tFIuFqRTA8Sy1oYU0R8T89bsIXDSNqd0Zx6ZmYB8mUM6thDDsAbMPvS9a7LyU1MvGDcXigNuu1MB
QnDJdAjEytTAjkfTk9HkAXjGf/OPb+Cf2aLczCF4bPSz+XH5C/x6MKkuLkbs3hp0DMYAS+N1iiW4
toIqaJUQ1xFvDyYnGIqkP8DUYGgaBzfmYFUnB4fB3bsX9I92Dk4QV3FPDDI0a+RujaIf30tVJpDd
rRxq6rGugDohPhK6I8MHDx7iyj6YbG+2+hvL4LgS6z3Mm/n7wQy3vPmbLBz3aDgXmwbBUnlUhj/A
J/nwojJHrFzC13DcKLwGc2Vzrj1W1A5VPRO12UZHN7C0R0dwmjC+DgIG8dPp0DDum2pmmI1KDSxt
HDHHcDsd2kqGUQGAMqECjOYEIUGQCxBDsNmpYpMxoiNOwrAYd3X66KpE8McRGHG35adyMx2udldx
s95QzChwvWpI+EQ95nrU+B71db08B0aB+mzas5kMoeuku5h0z/QReB/MuyY43apZVKYQBBAIFbC3
lkWPMTwO5JQ60P7waD5UswU7WeYDU9XSfHCOTSBgXV1aNuXCcVyU0BFRH+DD97i6oLKBI7PZs0Mj
nqTKod/QrVnP621YE4oOQxYQOrc9XyZ+Xklv5N7Eq0yYtNv5wRE/6V0PGjXFt9FnRMbGnKGF/G4I
kTPYs14n1nugVbdrzcwcQuxB5OsacKKARTaf74DPaOHe9fEGg2XXq35EgKFD1y7FA+vNAJQ76gMD
jSJTxG5GKodnfgXuqkeoAawWhbR/j4j7HDhnwlWr8Q6AKV+dH5mJOsJcrpKrdZ99Y37hcW+rLfBJ
dbnkmiDzXJvt1hcbYpzNqK+r5bJ7kVfnxEmMZDe7R+qAo53XaQ5lDrBQatHtfmfKPGozSTOEt5uN
04EEMt17cNVIHYe2APXdle8mvtTLZ7gNsZvgpKG6etvjhEmZaUlUP/wc3VjmQi4Y79R2D/qsNKtq
REm7IvIgXI+udfAGCh+rWCrH+xADCDuNJTscci+QnRzlaQbu+vkLU+0U/jM2G5IzHU7trzGqg6ff
oiz0hiZkyv96GJxYF1c95X99Ps8lP/PSMDOrS89sLmPMMkBe26D43w8c+rzC6ba3rkae8oG88ZJD
rpdQ2TblWlDhc0lYvWhqBQH05oNhIbYACKbYL5BozGm8EgFY9sZUJkUGpd9OdM48yUdII1nRiwqZ
9MjGHRm8eVSzRaOmsQjTUtsqH6c+1vn/NC6+pD6etnpZU9U+CVQuiUHCVNp5lQqBR3gUxmrxuv8I
qBNdUVvhN1F6uDBefc4JsQXE67nEBbzwk193TEsiNSDXOZXkgIenIJSugkH8Cbq8araGYZ/ZoAfp
5Njf/Xfqqwh9oZ1Cchya6VC+22/2htW5en5Tb1ORV1bzy77SQ1AegMh/nM3L3cXlNnuzNtdqY7rg
Kvr8p5VQ68jR1s0SxmMa4vD8hpgoc0thfldDhs6rDWAhZ/P9fKmCP2XcNtPZ/NL81zdSu03+1Ozy
41ueHk56mvAT8c7TOJFOUJZgGq9KEZKyGeFqeukjPdIb1+HT3StUm81gEXzSK/B+KZqIxZmA60/D
JOygDBLM45BgbhvIpEuQr8jecHY7pxCibrD4RiIyuTEzwLJTaieWwfFkaRKW+IT1T7AX429sEAzP
J/aHxLJIvxfqVRw4ove1zUyOkaDpWkJFSnBphmP0105aY0wgKZ/7V29i2C7Dg1Th35xKcIi6jS7d
OrvbqrpB2La89hOuA2MCWnLn629VNMTFP1GlAbsc9eaGfAjyBYQZMl9tKAL6+6+gCtwr6luujfHP
vRoQMgnjtxBZ0nRnWZ1vD2fo41nBpNcn9RcqeY2oDAFxLnVzUQVoyxsopDRJo63B0lQbauZkOslz
Qk2uo1mQY7t7f8/k8OVQcFojdyf1TOVHYJ1hMommBTBcpkIApJS9gDHlS/ilR51os6jNSNKV3akU
5+yzhMipby+V1hN7SR+iss0yipTvjBl/fIcAhSIcz6wMCK+m62RN3p9msTgDgFnn5W5RmQPhWjON
iXzJNdvYOVdcmb9VzWZLbsFh/8TX9d4ULn+Jq+LUm0OURME2oaqzwBFv/t5sgB82zc2+M4RMEmWu
ryBQ+ar5VAEOVBt6WnA2VMkq6r9cw3ZcB7FlqjJU+dq/7hAZdSP2v/XVpN2dmRM/gy2NuNjVhrM+
ctWUMKCdho2HwSczEEdmsxP4GHw0b0ISxklaSMYQjMtc9QxtSBdxBM49Bd2dHQG4r3CyHm5pEO4l
lgwO9NJLK21DYzYG7KXhBP+BMe9zbWjoDhNc+ZF5OA8rCsNcSSipW8xyQ9m54BX/FQKFQQ4khBP7
GQtB173sVGnATkhkcov8p7qJE/PNaYLVT9BWMSNz/6PURGnpIWyYvpY8Uty+GlMbj2lMBvgYmVUN
wUwVFtJVLQxP0D09sTlyTkBwCxBBK5WFBjuKQvawOAxiygluJIDMdjO2x7uJTAe4Qk0CpZyau6ID
A7VaHUY/jeBMZTQ6OygmFur40CLR6qYwp1VXW8Ov9MlCwotn5H77FCHd7akZZw5OGT6JgIIzVMlQ
AajGakyQgQV9CjIdqJZRysPtpmLZxH0gqKgVZz2aX9bLxQai6KEaxtDnZH/YXcIW7SQESDBpnVjF
RJcX/yF8bwDBd+/YsFW7Vf1xRzlc0FOBDVGGj11b/TVvmZioqLQxA12t+mhuB73yEHp8osT0KKpj
z7OJCiJakABqOlAiQQof2q/0IKpS1DjIqa4Y1ADg9s1gAw8eq/CRX65yfuLVjvpHFG7p9sZ4W9UO
BFA66QDNCDkDxvtusf7NbC8UbBkcFPHNSJxpdRfkjD4UUh60h1A2sLIBRqQlN1P/HlJHTTYMwnei
pfECtofhcDYuWQsw+3A/wvGQdCMhjJ8pP+PyMyxTtUy4PIw9BOXHrJZgKwVNrBEPz+t5jVgfmGHF
nAQ6iaQcpXzx1XYTZlQnUgOb9In4ecj3cNep1Iv3XB/hgEmPYkjsGviVlBMXL1trJPgateZQEK78
mz0NCf2HAdKVtja8brswrIXPvoBw4eYD1pKr3cHduwc9cp1WvbrH3RrSMvkyORv4XvIZsC+rBTg/
iaMHOyhhTWf7rAXrmyNfCn7se0EsDzisIb1grvkbJJ9xIXzOZV5IBpy4mLzikt+KkBmXlFdSsk72
DR5LqyR+RS2ax94FDMLHzmzKKwLUTDK486UHn+WK6NsYCn0+TTOMx2HWAUyuVK5rSgnxZPIIzIFw
1JpzIqz3Ue52nGoS08rxrrP1XuSlq/JDhdLmZDIpyDGsAsUYjTJVjbrd8HKCi9QfnsQjL9s7XNSQ
aXwDt7IwBzjDs5n5hU4ms97IrgACEb4QGqlBIWD+GDEdL31JT+4fY3I12OqsKejG57AMMHcExtdx
LgSxy/gSu+eiebt0GDZ7erSFhvImFUmhvksyyX31EjmJao0jSrxKhvfbY8pR6B6fHD85DZBba62u
MPtY8tgAGZyZCQP6PuesHVM0KkVJOqbeWk0FudpPYWeK1Iup5ecA1s31a+p+yna4J9m0cOkQ2xjW
GXd0B9mnelN0v8yOj4/aCq4guG0ZpGpRgeKeMSsCnhAu0U3VBl68/eITtR8KTl04Qeruw+9AKnbA
6nDqQ0gCJyrbQ8vl0mdWywfcxhfZ8PgY0mZbBlFTgMuyveykAPAyV+ungw0gZWjanVKKSD7R/lIz
CMqBO24uoQtjjJchFlqUloU2RMhr2PGz6mYGg5Nn7tSSc0x0tNznqSPLH3XKYjoMalOh7JjzR5iC
R34/Vr+fnPYE9UlniuQm87tuy94GQwUVZEVs8XP9N6xxdXPY4hfQGzutWsMbuYp3zTh/XvS02ibH
DOqnNh02prOizC/BTNLtyy+pIpDhC+Qh8PYgj0HTsD8esFtZ7+lN02AdoUjpkQ3siJ9Om9XJiHkv
z8gHm9TSXXsOq5IEB77SWFWLl1ugRaIvN5hsNRHpia/d/Bnyx0oKSYeDfwQTudib5aAsZ/CFobNU
zOLWkbM8yZb2y/fvqZRLyWVxA0GGE//mzYfJA5tvMY0k5Dn5whfWydj8fgaQ+KVGG/TxrqgTY+8Y
gBKBuhKcQR7X1K+Z6wgwtQLIaGnH+/IgoA/vgO6Z+R6rDWF+rA6NWp2IwpX+9IxE/voGdIfYrG20
opxXVaTmZkMW4NrtYllwjGwEdyDKHC31MKNWUkZW/5xwPmc9DszI3EGgoXjnQendGi/QOJ/eJPFG
Me2Ms9wrPbbVFN25csx3PkFCOe+DJ777M27zjoKZjSlTIMMzAjwyt+BjRafcz27jifFOfu+jPWgT
Y4MYZ+sSAholIdCViy4SKU5SfRBRGr8Cf4bQOaqDATm5IY2Wtc6E/Tz1yBc6LRheQjb4eb2KroEL
WJRNYA9FdKDlUhArPVWUVLpQ5AwjgIhZRXqGrnp9lYDL3ScVV8gLbi4cHMiYU1SUIOSLvyNrHIDP
KnqAtEUnMcOi6EIx8ebivF5xGgWPFtAucsmqEpQAzzVgeSt9Y5bXK7CQIYGCYACdDMVcZ/NLHO/K
pc1lnSVLaahW0BclI2QlL0Z5KdGOWlCjV6ncVa5K/hXeiz44l+JF15vdqrKRIZZ/mQcZIAIOFqVo
5mwM+fE/A2FyH2dbOZfj6NaPlWCc9G5w0AHo/GryLX3ynZHndmu8RdJ8pFSAthFObw691nB8Z5Ss
JoSLEyuF75pwvlsucZ4C4QaHaqTi1cWwR2glgSeY7KR3l+oVep+io4H3nYXAw6j6ehvZqjDzzNSI
ChCCN0y4SlGBLOj1vezdu3cS5SfzZw4FTJtkI7Shg4hO34iBIC8k+Mr0528HUWeS2oD0PG/PXP8x
l3zfAKjALXB+giEPOnYLjxaT7KIuABED+lQ+WPllc00pQaeJAbm3hyvCzYT/HduNMJUf1oTrzh6g
rwZn0QJ6CpOfv3Q2WkzwYK0hcq5aq25jG5BNQugcezSAxPZy16LJDZ2y4R4wnCXmTbB2JquS9TpD
XJ/1NQz1F6vMA9l00gbakrbm1sAEuaQTZAVMkHxCOtwpD+mkvna4eLG37GgtslERJVTC+y1QPKav
KeJ0XzZbpcNmlrc0+9ucZM+iqpewkwTTGAQhtdQd4U8jeJk0FcU9qlck4n3mmNlIEdCkOggQIW7m
E84kmwZZj26K4I7gE1wE2pGeZUQnWbBJcrJm5knQpjHHnJntbrnFEDLx3rK72J8g3ytA62RGM2u0
Go2zZXl1tiiPneV3YivUat3bXqUxyhFb00KgI0vv3WLYZ77aURe1vyfzHfk5TT1zTUCB9bfq45iC
eo2s/FbYgwgbC6JMi5Tj8aSjLk6lVzgvI0fF7K/isMPRXa3Q1tDpO0nxlJmL8ebmhjheCaqc0TYD
k8h67y48SSiMH05AzvY0dJj0pN/1YVMtXQXmj23DVteuBTRlEotF/TDvBonHKJMKQHrTGn5sPc6G
D7WUjZnJ1PRHWfG0vV8m2Xnp9nt4HdbsSmi4+pwnQ1+woJbythhFppvhgFHLDCiaWq6Wf/XPgVW4
LanTvCUhtFhNTLdvhtBn62PMuZQQWoRuLSoM5r3wki6htnqecSTiJ2tWQYOOuVgqUi9Q1jZOey/y
3YA1FIY/uKrB8d3IaRg+BqJWqsbWx1lQnqDOn/RP5/NBm4uCf/6IXTUjf20jBM4FYfbEF46DEtxr
EFXZuwqzbq+2PnHmhyn+PWhRNJR5okr/dke/8vOmz4QhxIumTniaRCZsXriDyYv8XMb81V3sNsrM
xp6PdhxFkCL2DPSJfLzQ9frjDjKltOCo4e1Kh8oOd/XUEwDEfxI0AOzcnw9nqmr8aDjOfv6lOIzU
aYkOfnVijYOPTk9TWJlpzz+vIk92FRLveperJmIYz7gXscdrMOm5bAn7FdhYgO2yD56cFkUqP7Cr
JFp47com76zL2fegzYoYdOQ8Kb0JYIixU03GXoMca1y6F6jf8kmc8tyOwqlUK219YVg7VqbYT1yY
oSVRM04pixgsI9ZstyOzFc9Rh/ylhdbjCJOYZKs+mTrUX530znMXR48OV+kkWVauKJ9K9ouBTEID
4jdN5eA9b59YpxxyI/Leq1ASG/Hnv1SRIuF751gvmojge+DanIs6/onDRWV2HCauLcEMqmHBILSj
ewJ3o0jAWqUATIqUX96EvLdZxzQRdai6wowQQnPsiyF9RmdHnkn1DqsAEfa5IUUYGqrSwcRxNcnk
c6INORQKYYr4cRDeN8Wv6pcEcBh2log8zw794XeSnk14W4X4hfQWUALLlhAjUpi9emN+EQaOuuhZ
vYoWostCSEScsHzIgBx+M0+n8r4D1Nnb7xAozsg96KB2f2GhJ9BjN3mCwzYLFWksS0/zgzs3PfMD
hfQEBAVvFloNZP+jrShRGnS22IOOYzWU7tt33hNZ6db8g6Y0J/TtLZ3n7+ksxWQmE5QZiHYuyX+M
o/GCL9EzkTO1LJdxpH3w0PdbuAp2kEcH/B23n0ktdKsg/OuVF+TDL/KUFObHo8CHLjSIQkcmi/qc
I0XzuLWETGcrjHfrPYL12FCKeqmKHLYpjTf6v5Zb0lcleAycHr4zVCBP3hWwcwv96j3yL4DRUk/I
/OPUZge6oRcKVn2Q4GpSexDmG/5O7Vx64WhdEKzI3hag5SWe+6JaoTAUIm6i+2yii50nh7SJ4uUU
tkuJfqQxf3LTgaYzhNvdY/lc8wMxJ8HMg+orhQC206C1ZFqhjuY55LiHE4mYCQivCFp0oRpX2pTU
vSxqkrwbCN6lLQr4xl8pL7WTY1zyYdDukGRRarlIfEG8DYATrrb+pSVczfa82a0WvgdMTJUjQ3VQ
ZLNtE1XIlpJ/1XtUAWwu0MJq+h7mNaP6eCsCEIkpBHswJTfoTohwi3/0FoYoQyNtU8lAE7xG3s5H
ossTG6hObD1mReifqfnn4LIc6WURhsquTAQB2myCqVTTiZpbd6+m60CBjQAjh/mqIf3afUxgz+l7
7m8KZBikxlhb7vdHZh3Tg1OL2f32pxX5uFI10GIRV3Dv3bt3xyQqeT7AjnmMwC/yB9RqkNxmaw9e
kiMwKzEh9WePwZM4xQmluEwI1RIDVev6jrv5KlJTcTArPpE+5hiDmHQiDWhNh1XhnGJqtm2CjTJP
IxIDq318PKR0fVflOkc8LzoniYMi9IbsoxRGQsBSQ6Q2XZ90E5xunYfnNKJvnCI9tfu6Wi5UnKri
5lgZkLrqDR8HV7zha+oFCf4fKtaN0WXZNumvJM4QY2WWe/QqsLZG4AotuEhHGhQ5hlbzhgfC98s8
eXxaFIPbTCqSC3cTRTeQDo4HlcYBOspqItJ+rJt1gESMgirywrmZgOnjYEnYMR/mB2sYA34/ZfWC
PXd/A0EJMNzYLikiALbwycgNW0j/PCW7VXZznN1wu5ii5nFx0A5NR2g+Fa0niuLj7OycEfRbIMgB
l9S/BzGBcCBx9G3EmKDw/KhZ5NEMultHjRQ60+cdvSENQJvolfQo2h/4cVIiqzWn6MlcvszARJbo
mpPyEtNTc5jXpBvFYKqhDDTj1+2yF/vFpq7fmZ2lqWdWC2NfeXv8milxUAs+MM6faMg0uIDOb/Wl
HiiiosnXu22Fuwna7p5ZX0926/2Qmn2Ltta5BL34KDNzQZhJ+WTODAIh8vLcqL4bqSJE/2cSdtK0
pFcrz1DMykeTUXEKARV7euHNKXI9ZlJvJu16aWgPFA51AAxuaLii7SXhFGKub3L+JRsH1RMliL2H
tACD/ujTZf2hygTekZKZgC8IuLKbloNvzemaI/jlxAgxC1Ya00dGQt2hTzdWXQN9v242H9hJNDRw
AGA49LjdrdcNB1ESEjpcgpD1tAyjb4MqeKwEIBmZ4QnBmCgWIUL04AxIiMxhhoByTRPuKKba8GfC
GtxClUYXQPXBbqTVAxBosug2ervuutTzwec4gJMnp2DZhUH88A+/nT178fr5N29fvf6nVIYzfyOb
0wRDzc2wi9NbdFi+N+VPw4Nmnmn5VXiBFNugk3WIdoUuHE6ITOpFpDB0LCjjO4B1GYk6CN1D1hPs
Px7bkXajo+OR4l2J9oXkIeBkWGrktvhgA9dbJKz0Ivi5pOsPDWtLRvWIPdJ9dWZoIHfEUHO1ZibP
WqWtVvemIsrFbTwKU1OB9K9FVh7nG68GPJmZkrxu41moa+n8tEv+go+/yOK5N5PJaESxute8dtsv
4HDG1ggXMzZaGHGfDeNP7qT8wEpURJ/tTmetgONMCiIsWBzoYEbaJ8C9eZqZ3prPx5C2Ffp+Z4UA
tu1homlvPbJ+Bh0/OX4c+7ZRgKY2Ft16GXgTW2MpCsLM8yfF7QjEQHnxwEYJQ3s9jyNw5RDZhT54
fKwJGkjdsoSBTknEc2n/uCd4hMBLeH+DZ0eRvAM6Bprojgh4KNuntJzbehW4JcaRzV6vnPk3mOSk
iipu94BC47JsORZkEdlLI+HkkMbDtHVjE2wgBNKgW0xzc6a1I2pHntycjt1GSGiO0mPwfOJ9H3FI
QAPcwbOWvJAImBttO8O8GJL7E5rfrYtx13bQbSKKYwVXgExPARNA6bbdhEAT6QmxgzTnHzYDpBv2
w0f/lFOH7r93VFy6KE5pWlvpVqLi74LWYuooJYdcavDrTmU8AKjVqvEJxi8+CSQZe0g8neL6v9Jp
PCeAo9tqGH2tgVsHqqHoPn0p/dldtsXH1bt/+9lnn633k1m7XXxs3v2f/+azzziEz0gSKj9kDAUF
WjdAu1kfLatP1VIQ6sWCWX4q6yXkoAEc91JlZFTJ3K8Y8BSx9F12CMovFTjyR/4wESoZu29xoDT3
4w6QfJEEA3yCaRJ7yc6BUXh3p4RCl7rv35YPzUybiT42W2y35AArmu373QgiV4OB+QZAt7cAVvBx
/e6/5TVjnS6EF32oFuDo9vHju+W/++yzgfDt3+IbAIIBKfdTDTct4HlgugFINqGi8jBEjqqSaJqB
hFxglOoWMRxc3CWq4ij1HuX9w+RsnN5Ko/eb386zaqGQgHdmlXGFoyxITTtQ+5B/XhlZ5xLiPQcS
Xbtbne3Qsr2Y1U0O4qaks+CFBXgjI92vQEme23eGg7t2GJZGNPwcsrhKuiu3kJCQard+krt3pgF2
rKCj8fVu23y73LWXOrvUOeVF5W0G8UrBGT5njGh8Fbw5h9qUiuxWezeBYODh7fA729vcAb25LULV
ATzvm7dfv/3xzez5u2+e//D2xauXmBSp0y/N7CDPkM04JvTHqp5XM6QQiVQrGcXAGEo7Q6ck8eKV
h7BTQvfd21hgNQbAOfcn/QG/i53XzKAI18F/zKVjs66tiH6E9umrNXmMuV+e79jk6sMCXoV22dfP
3/7j19+57yYEi52PNuiPNAqKv3n77NWPbxPF6Zgmij9//TpdHDNsOzXIGrFTGqI1Po64eXWMOraV
RBdo6uGD3WEta43fAjc3f43LfuhjT1/oiD9+m7vNNg52VrCptAKZPuVjdesKNDjqBr3cV801GJkg
jYmFOHPkdYw6PLrgXClVyVW5RieWF6+IqSXX+UsURNyyedlO5UdMCR+P9YYowu85/6T8iL9/MtY7
xLuSzLY7F4GbtucECezw+kwJxI6KeK6dsa/KuZrzmNGBRH81MG+2zC1cr+vzYO0Oa/788nmRUjYq
4ASzqPkDSw/G2YMHigZ0fSxEn28xc7Ncrduc3iWkIj0KyqN160FA8TylUE0kTb5TKgYKElVJDjgI
D4OqZhy9ikk1MTYt/NTbFDhjqcum30eINr3V0yZ6lnolKxC+M/uLHj1OPHviPaNZdR32ENUgIws7
KWGMRwnhqVPzFfwyhEuHsgMqF6npbUYKKp8LmRtnQRJZVTo6PqaR37349s2L30Iyi2e5LptKkq0T
YcCnb5+//t587H+XfZE9fvI3t9A+RtW5+fFr7BHVvDqUFzhyjMTNu7n6n7NHN399HmqzVBU2TTN+
fjzoPsSaeI02Z6NbUBaqYIYR6FP+a4IpYQMuLrVzXQU9W5RQZJA+QIYnoQ8zn1OMJ9F+7d2PfmJs
ugzC/vrpqongR2XYEA8+mQGbwpzlaxRvc7cQY16BMXdNRIUxN+ibcG3FHV7pwqAk1e5eCaorLwI8
6lhotGDQtW8ZIg9XyP62rIzculuTErJedXMm/swIY81T4gnOCe75DlN2HALJqoOj8qD4fuX2GOGP
EMmedw398F9qJiNoWLEPg4+bd/+NSpl7YXjI+aZebz+27z7/D5Q3N3eYnIXGlaS4wSO0XUDFRxxm
b1gjANDi9LoME6vy5iaFw/WHi922XiZkScmky3Ij2h+3zRrZCY1+j1qbfWs92tnY7GYdIyzDqA/+
wp2IZX1mCkHZh2H0rXnV44JjEdPOAhs51EXWqeH9FpKFRqoCCD9oFr5jSlqb33BeaVRPKBgTVm9Q
zooPF2itlEkaIwKbuABYBwsx0+Fk4B95cYIKVC4tDwvW+XMfRpMRjeZEGgDb/snNZG2EDwladkox
rOTUdc2s3eyKsgPo1ZO6QGqLV3gglosn7WbuxD2w7HK5YPKAI0cVkmf3gK9tr73+gsHMvlDkkwSc
e5HhneLEcOsD3rh8Se5TI0gRG3oxmKHDZPPakOXcrRDVVUTx1thj8xEa9LBMSNzvUYTD9WVl+mrK
ZG2z20BKKdBe2gBeoI9nFSnUAXJJfU6YHAJ9APo8SwSAsu4gO21rqNvvd+YYn0GIDHBwKbsRdBat
a14fyK8ZJuz+BrRQ5IvmT4Cn5pCqXLoLQBm1m4b/lWRARCRgHf/qL8w81vMPAH/yBzmGfNnTc2ba
uYZxxiwil/kDnm9uDpU74+w/eiWoFSNnYyZrBJ1TSiAuBP9MFhUUyUdlO6/rkZ910LwfBGOTxKC5
tvdxN9121+4ygSGMywrUWOqceZ3onFVRzhGVn9E+yKuVYajGNn+pXIc04HgUthwd7av1Mk4XHqcJ
J6oyAoX/olyayxxu5CXAc8Fp4vQ2QMGhQu+Q4lPzX+tCMPq7N69+fP3N8zd/N2INXmfB5y/fvv4n
KIZj9CbJFBzcJu33rTJ1dmZ8tadtOI4SIKezoFJyTv1df25YxudxEyuXMp9ycygJbMxIz6AqxmUK
Mp53Z2Tzr2nJWoCDtXREh2hyIJ7rvtXk2kdKq38NWnyv6gkNZyboUTOUZTdeMkv6dAI9zoe/+/r1
yxcvf3tsSBl4aDTnPoFz3M0kTmVqtsIi8CNZQLquaZadjNaYn5h7Bz/51ymibi13Fxd7aMDM7MIs
5yKQCSfMJFHKr6+y/Mn4r4M7A5qyPv1mbXCDBaGLdphyZheyrOinBlaCZiXJxiZ/dUS/vpx8+cUX
wz6RJJ6+dANws4SNJCDX0Rq02GES3pEMZQQjrMDZYr6fZD+Sk0t/FeZzxYK64pJ5FXhRORXx2tnt
GBI4r7GR5UFhOf8X5rZc2sdc9iOdiQmeiaIYjaPFc09cH/Sp8GmifZMoLBqb4H1i9eVsu9POh4qt
VLbKeLOfNctwxpgUPjqQoJeL/Tw631TVH6oZYR5W7eg4C578Iny8/zh3tkn893WEt8Xel+SPgpko
zvYwgRyzYogYg8+dVZyvFmvGYvObGbXnQ5UQywP+RADORKl8ANNdwjXXe3trYsEvOksyEfAvWQ5z
4YSUce10S5prdVOd1zfT0SiYgxcIkgb56g2pIHBJHDyjnoqtFsfOKMHEbHEKHCTqzOtzU+SyjLhr
DM/5nEA03eHvHlx29NTbMidC+ybEBIK73Kq6tnnQgwNhSeVkXq4BhrH7fRO/nEwm3oNTb6rYx1Pm
tBCdgGHSjj0fQpltvK6x7GSGyelmMwQkdw8pY4MRbcQv2KeR1nvRCQbAn80E2Ka2/BBKQSTeTnBu
ZV5PMAjVV2q4z46j0AREno2XR7xUkX1yXqKF3VjIM+I4OiMVeFK+yK56roSgKIrHH7fvMqU/kLvO
8oITugc/7t79X1tUJwx+wKDm7ymSesxIRWFiF5BJNuUcWNrBwF2lGPu9qVGIAby1DHYKahmw0ozi
s68Q4o6IxEBSvjz+y0dcqmXpDTs8wP5cYG6bNmsBTXRr+sN3M6Zz/Q0k60XIkstydVFRhLLgeVWY
t8z8GHxf/r4BpMtlBQDZCPu6YfC+7B2s3PDd5J8m/3lYQHKa82zf7LJr05hkHJJBrgbmzQa0VQgm
DcWYriFwIgZnq2sTiIwRRMgHAJzbB0Oq6en00eTx5NH4K/Ofocth2u7M0awh8Y2eV8M7zasNaG5Q
mKQwrHU1h3xFnP4Wn9UCSFgSaBKsE0YzM1jeBH0WMHyROMq4JtN7fIgGNnDhBT8UApJ/GdY/GXyd
aheJneGaDB+J/vlbI/c2kK1Ids6eMn8Z/n2+g6fHAzA7izPHwnARDGgxBAdK+GtZwh818zSGkJqy
ZAikSqoB2f5McShqxvn3zTXgxI+zoGroL2QnXlcbBKX0uz6ArsNrgiQw/8GUU6tmdaQ+jOYhy2gi
+D3WgtuBe0dbnDK6XBrBiKCv0TucAuN4ImBWGsD2InAEswf+Pl4g4ImBbTAnB1xN4LYBHOjdstyI
m5D1OsEUYYOzhjPL2OdIckSz4N1aNYINUAgjHSVQbWLrK3Mcn5fzy+SaO0cX4Kg35gPw+bsAWE8C
Xm429QWmm/NGM3AWXIfD3N8pM9tvG84TBpQi3sPtADbGp2b5qXJ389JseAgEoQnj89txbsxYB+wG
CcoVr+1XKwx1pPWFjAHmStUzhvgkRKZg7wzK1CE720uKs3JFCy41wOngdARw1kFNfMYEboBxA/BR
qtNms7wF8nvZtOZgm324aUoCr76qmI4tEQ0fPzYsnVlWnJp6Bafd3Bo7SIFwBvpowr0m3TpjT1QV
82olwp9D+jHYXyjbmVn5zR79djclZJiS9F1HoJBZDFzxqwpodN1ewcqah6YmiLcBLhK8puGyoJzp
MItn1WX5qQZiazioFfdgPMB5t1QVkljsgFkxIzJcU7OmZbLXBmNiL/cUzNMSdqhsOnOjbfGaOB4M
jpTrlqCqw9ImtpcZ7+94bWg6zTXsr++qcVSU0bSAajEsAWKvH9GxNQ1t9u6KbBlznHX1vUcN+vEC
jAc1EtgWpSvdfX2fUrXJzci82L6Cuj6smmsi0xieiothTiCDtRAQfMVWQ8rqBjHCsHJmBwEICvAJ
S4Ds4AmHPU0o7ln2ptpuadNnQ9KwlEuoeWhJtCT0lmkNhk6xXXhTEp/yj9RJ8w717KMW6X1AY3CG
rmqMz54w2j3SDyTu6NksvUFksosNn9Jqew3sg+C80KINqceGkwDqq3JK0BQDRwDLvSzNMl1mj49f
2ntkkNm1qRb9S0tN2fPiZ5A6+KU6Z4jRct1kglGztdev7dkxBLhsAOoO5KEhbxcUTZChw6SOxOMg
gpLdBXTnBh1xSMxwa2JqDaoY5IOv+cohmpez/qyQi+xiV24MraoqiSK0ey+kdqYuYQU4SQHfZvUm
bNflqJwk5mYoCcKGiqytDau+hXDA+aXrhiEGuK/VEtpJZ2VONa8AF8d2mhceaiBXI9QynVXAmHJn
mQTgqCapVV/U7RwuMZgSZqOFMPOZNnUhoc1wq2PahG3TmIbpKSpOeUjcQouzKSy8a9C7hPml495p
NGaeaWPUG3UvDgbKgqjshubYrCGn6mA2E30agvo9mnw5eTwyT0FSgicnQ0/wgOyDyRPu6wCHwB9B
C5xKZkxPYHj85NQ0vd5/yX7Lnk7vaZZ/ic4gYlP2K3PO2DZnisBSOxxYSMtCl5DsBCPYpK4Mkub/
iYkD+c0bUrmtiKsFECxhSlC0zVCTtkVhglvnJL98pXjTBSprTHEOrbYZaOU3tCdl+5BKokT/Y0cr
RDY3R9Krj8QtpPTQF92xQ57jY690aFX3hjj1iur6MHWf8oAlvTv5rypaNcVQHMPE8Rmmv0NM8fOM
Igk8f0ELU2HOS+skhDZrVh6rHOQCoYjk8gMum8xtyRevtwg5C5Lc9sp5I7pOOFppF1nuf84qtV4v
WdAp4y7RMu9a4ZnVKCCSGb5USV5enOupgysRVIn4IVwFTurLX5qmLR++uzqD3Enniu754FldF1FB
k4VXhiGAL76avnRXx4uR2fHRgHruDj0MWW47BiuoMX8jVwPgvm9QEQG3AxqV9qr7IJLjFCqS7u76
FPQ/pwpEZ3FZ6ZnhHVpMKhEHrNqeQvtq9jvSy6fytnPuKVuTXkPkRNK56qA/48SZ+yIbzqDXwyRO
CGbH1AdM/VbHTH6kgXmg6YGXhlDJhl3A6AxH2DW1Ww8iOumh1VmBR9/d1fBH0vdY/Ooi8H88dbcc
/b8MYf/XoetKgSJ0XcsI/CzetRb9lD9idZG9C/6VLgOLRRveA67dBN27yz2g6b+Xu+7gPaDn1RLR
UkQkF76cEBadUdEHCUNUNE7xkp/txTSekWu1fYUupa4BqBuTkoFdpPA7Keuqbqo6efacJdWczarc
gBrDScS6hyjOYCZLc5+9TOt+GHTfdEzGHHULttfderVEOfpXdyq4/rQmUt3iyeGA2qRVilLIygZb
XV2CVTZE08EQZWPWUzohhe0KpiUYDM0vvwVFcqAbjbgc/lDX7TSfXtX0GEWtQ3XipehqpWpY/MLd
9v79DEjpq9123lxV79+LoG5z7IRnxoKTZWglwOu1oa8l41u9AoUZ8Ro6a5xV2IbdxaLFLVkJWLhO
VuI2tzpU0HOra/KqfgdEVv/RjSRmSa78cFSX//0VnMGtuAI7S3fjBfzJJWaC7L4rSB4HxqqgHPyH
FwF+emkLrHliTFgARWcxtFv0l9IGif6SnsbMFhXmZva2vHgLEeSb41uG9G7LiyfgdZ2IzyO9buTw
jphmBL4BwQQagjodOclL4fr2ZnfGJcnFUKfSoDx+M879xcVMJ1vGbT3uiIRH1M0jSJ8AGz2V65Nj
CqFQKqAR3x3rl6k4CqrHzNRAI1XQXAyzEDESe6xciGXWhoYKZA/0VA4GGm0UAyy9lof32/ttdnK/
Pf1phTih9JnNRjLOhoJXCZOlGj0dRFBeYwothnsHR0TQm6HPP3bEejaZ1s3/7rcEVup1QVVZRE4p
WIuCaCYH/9str96FSmogw1kE+CMTR+Fj/jZSLcSxBeybNmKXaayn6MlH7h+cE6j7NNlCL2q6n2/T
HHHuBoc34R/habUnkn54n/PMNhtvUu3TzoND5cx2DZOTlXgsEMQKC1mIqGFR3AkWglrAiopB3ySS
zED9TZA0QzY6QzzAH57GHM4ZZjafYoEgYpgHaP7plE4eBJvS1jhJbOSJ3gN6aa724eKklsXVHa3m
JFzM21NdBm7AueRhTWiy3CR8oegw+UGhImIGNxIkOsjhxwxNe6BFN4TtqhXP0nmD29F7P7moZ3MB
DyGdxuvdCuyurNUIypPHORCX+wtygEsxHfm8mcybGVEb+i1oA+5vcyHD+V011Ec7ILpcF7i68XAU
swXy4e/A9i9WO1/aYjGePfmshGYZbGRC2Y8ZWewMvDY8DhWV8CQYGAnt4oLZSdG1cU99cZM0V4x4
bM6EYmslOb2qnJtzndyCxg37yHEcDLmV5ew2uW3W5MgGTBHcC2hmYmx/1yfUDELgdQMCxjbQFniE
EiB1wokuMJaB5Dk9UUglvT4oT7dDW3G4qCkckcQXRo6AQyyc+9SbL+Ks4w6He7iFa0/XU9yhT5eA
x2GkeLNsulv9Q8UbQfv/q8bBKZszEqr4Nz0ut31fOYlF7VyobZxVNTkarHxZxyJ0OiudU0PBDnj/
3nXACFKckpMNXthbF55CwhPO0SCWrDjNlLMf2qNVtmzGc6CILna6N01dICylb2zrSAql8+iW/k3Z
VjYwO/G564oPRu2xrvNKFknS6yDGVUjkpSeB+iRoxx+y2gAdYZbyZb8YZdvv5XOFj+I6Q5U2WNO6
1NfVzcnj0wkQyplOhA2ZzLwvZrxH8gfVTUHwqR/LwYDjjV0LoLPIYUNwICt9NF+2yHNCFmXxb8bm
9QuwR2rhCLqzAAXwc+d11qXn1LlkxqzrGJN6ItJ76rLAxCTz0GBR1plMucIA+eScuDv8N4gUXWLe
2rBywLE3RB7FVpinQQJrPMwLzFWNk/NR9IwsbEzS23cxT6g+wP+iWqIV2Jpw+mgqUDcxods88Y1T
VaWpuqTw1UPMO3tQJCY+55rpg1v0hI9UmkLLnOxWiyYped9mamUgdgt7avwYMOwb2Fs/eLuRviMu
hZ61nrsBaRnOQ68CYDg8gyB5+WrrRuQg1aIXP18a79+XiwU+zTmPX7MhLrR4/36SrijoQx57QbWF
agMref/e6tjpc6ie+B9/ItBNiR2YxYe2JMd7cpZGD40a7u1yg2CFCBO98h0R4Q9QMCRsoX7vwR10
5TyKOH8yXD3K6+hsaWgjxk5QAzhgYvg41ZNGn255lhdVu679fIw0BF4g8O7FqLYLfLXbgHtda32S
kI68f28Y5zOzKuzhkZtpGwRGjXZ31lYfd+Q5B+wQ1QpevShds5sWTAmlCiTD2d18A8aorGYn+ACH
im01rgAsD/ksdzo+WXaOrb8bw4VdrHDJyRRWc3wmQVKSGcy14OMxH7RqBbkrICiWt0GsTuNMYZjh
CvmcTdtdarZAL0/kA8JMQZKX0UnGeUEpGTVNCaFzGal+BuT+Nbit5SGiLlZB1uQod5FbgqmarSjD
UUDDOD8FkWHiGS0dPc5+8tmB7yGyGUh6HpRkgmxNucWEzRgeBIU0610+QU0epBS7jFHOZnbWonVx
mKYTVd4/MHxEKkLsA3dJFJK0mRjE2tTEpEV0v0ye7r9OOexluaSV52yXiWP0WmhsKXQqECkNZWhW
4HNMp8OQEFS1sfnYR1kwhH7ZzD/I5ElXyLHyNXJhpfJikEq4YfS7hMjgvZoIoaT++eOzoOCQoWOS
bGFm+4wlhP57tgVdg8sKoc5pY68d+zo+p2kMcl0PHh7V2Dg7enwY3x/SDvBMygLyG5x8Q1zr1aLG
5LurJr62u91GfuA1pnlW8wvq26lNN9WbJcYfjvQvGrnOxEPYweB8K6Ze8ngEoErxHkVTOWDgwZDI
0Ruk5bNKYbDd4zCeBRwh0pfgfesl+4h6cqI6fGo5Zd07y2n4xu3QXNro/XqQiHOz0KJP2kO0bd6D
i9qyKnFuPmt7Eg4QY3ADs5Q+7BForl9LL6JZl9nL+yvGGGPhf2pxMLv7o4dlPoC75wUkq5UvvC1G
9Y6zA83zRSaN28tNDBFI/VJYb+Lo0A3vpu/Ib3AdGQOD1l6Ic9GRxKyjQ/A7kQ1uyV2aAEA2XG55
0ZMdbYbxNHvsg5JrYJ6KzrEAXP/+rJqB54j5FB229nn3d/SNeDBiWuH+wrzZxUrkj1TyGbg1Vnag
xLaObzKdyuZ2m26DJiApIzuqz1Ye7BeEnW4jc1MgSG8ge1fC0HgvOweDLIe6faoCFUwbGlNxE3B7
tq2I5cIOgHMWQie2ILrkYaEIiyhgLl24s5ZNk1yEwMp2sBLuK8dMsGMFGuY4VMsBTXW47jNlBA4C
o5FBTEK0EnPH7eYQzhNkR+EkOh2wtJw8zPIYsnzjbIjZdM8t/8BlrM7eSAns3lQthhG6j8rudIjN
SPfMCgS2GnoicFAqhVKCsTjh24w2jscDoMaU+Ydjzr80OMikJGCNF9Wyq2HfeOyxyJ0XImbGk+N5
cpq45aiggLrJfEQT6xEQz6I242GnTV+wS7GAN132XicJkmiz2szAtkT8UkIeVKcGj4hPgDoXMFDn
1u3hMai0X5oRh7FdtJrttkFeOMKS1Al+1xVuU5oRdpQn7jzva9d738mdE6IEah5/LBIkmQiLgBqR
UGhIhLA6J4l967xwNwn5fk9+YcBPiiMl8JFz8ws8tZZ7f14kdUoPs9Y9MFxwEUtjjs15LwdVdLBu
rqpetu1y/uvYn/kB5md+C9YnWuax6/Vd2aJ5iilqO3p3z+5x5afv3C4lTBYiF8VmBR3rGCmY2Gfe
LszvOi6hhxrcPzc1s6l5A2Z1+NOIqPKkJ81Egsebj736415QHhRJo+NfJt2peGJhUQyogOmH3pz3
OfQchoRIcP3ZRPOIvYqJQZFi/dz5SFKQwzzggWMVwPX3c4MUD8HHx7O68cYLtfiKQuNuqwKlsI0i
SdHhlt02Uvdn4d0SrkKPSYv0O9FVEalbOq81757tu9n9eQnUL4d7F+iYyMna4yAnZv63FYdbhgK4
kWVIo2tneLdaIBfq4lqxYtZhgw1e+DoHMLq38ax+RJMvUEwAXqA5Q8NDpABrUMERrTTifpChXDOK
79+jPtGswCQx6aE4MxRQG9mLqPEyBepF7itc/O3ZzUXw5LuZZtWeOHc4dqhjp3ZykX4/brkJ7NLH
86eUjhRckN6unhtjkplJOzQ6Pt1w05/KZadaLghY0VQ5tGyiaOyZ4lGGNudWwqPywiKwQOGJcvVN
EeZkvGse9VQ0fPc3P63wAsQfNiRupaDWtk3m4Z3E1NwK+RNPH2PNoFrFh4d2A0YgNyTzd+KioSwi
JDlT4Y6Cdx585wRY/Iz7lHLPZkj6adUBVccbAjlQBKdh/9Z0aZdxCZokK0a3IvXQtKKrYNq/fkYW
NtMtV4llBMaQJJGdfb1pLTRpQKzdGfAGYN5L3F3/iNvaj7AXSzGy0IRHa2hDCOXivAyS2EEbh6Qw
psCIa1jcniVOnW57sEkpxamnjlNpdSGX5udTQzoTSeP6tYVFZ9K62yjmhAVE7Sayf9hVzQDig9ux
gKplXG/t6X/cy4Hd+fB4m3q3IrgPPkWIhCZn6yDvB9vcbWu12fVWBJj9mYMkmCEYAWERCEK7fTJL
3GDfme8tkh4qjD7uqs1e8/m0PxXsgasxc3GNDrQwCGuGHnZxbNgggPVuKoJMbgVOFVHesKEZjWac
PQN1A2OYGFbmWwhp87Z2hWD30Zd59wywbqjVTJ26O02drEj426SVSrEI1ZrIuTWiKSWEvDu+XSrO
ZO4Gq+kylcGMJhOkJKfolq2y91qCYZtK/xOe+oFFXSQm+735FN4lYheqVZ6sQu9t8yh83SMpCFCm
FH3Ic4be8Rx3SHZl2ciJiPs+wQKxL2/VaWQzFfPY32EoLZ1dl/XmYOsJdixgGJVg0cc3Yoi0BlMB
0irMqzv73FQ3C5tQVDqjbRHrtuaE32jYgmYjV2i3I6DouOj9Q45uZF8BFzguC4yXrbtHnS0e8mGs
Fo1GbzMX8pj8ZcllYew7uZASlWJ+F0DF0KVjo+NF379XPnazTs82I6mEeDoAVOfJPT6qDXWcAW9S
HhRjBofVdYgV0LlZWBS6D9X+utksFJSaLLRt1BtWwnGvd3g2OtRU6VS2iIPnwNtaO1/mC0gpVi5b
CAI4Xu+PUc9wnI4rDQLDbZRp6/lGk3COQeJ6LifJ+FAbOhd7aib34wT2jtvKgY9X4pRTCY3zE61u
clv65wy+Ea8kxbPho4EX7Brvw24XHa/m7vzkXjFds+czY093547p7wikgWJHz14/a783Q4qzGHoN
DY+OnponUh37iN9i2JjrPEncumiWvzuUCQVc+4gCz+jEKv3BOPPsMm2XPgHU+UpfbI+zPbNQ2YLn
NTgc4orqQFuQkoW6M+EZ9HFtVsIF+t30tyQgTd6G7+ePIRMDE9Jphh4dBEC7RH/HoCUU88vW6m24
ztPYIqjqDfZ1qGyH/rJUiD+Vxp3+hpsu1Hf28+b4XYcWOxJdqBElutCDftHFMnwB85+SqsTqSuqA
A9OjNPW3dUfgPCsVUesPlWG04QR9IIordgK+nkyJettRxQXAf1A4zHLPK79A6HzW8q06HbEOuQrp
SG5lILXuE/NkwPxl5DEIa+PCGqzjpHMEF5yHUiB8zQm7gmKA+Bbgw7YPmfJNnNMuOXKtrC4WTvNs
hjWQi7+DKq0JX8TIQzhLDCpxT+E3W9z/GpE2N1XZCm4lKmlXgNFrlum8ngtsJFTgagUVArlG1EAR
1ktTcFst9yotBCS6MpTnyeRv5OsG9gK5l+OxrrfmGeC8oPu1RPYhiiSM7qwCKFmGXudlvUcR0uxr
ShZS2Hz1+f6hOVeggF4r7N7KiJHNetLp9hyzJGRkgtM5/fmXMEDAFecDRn/cIScuPTsZeis3PJW4
DT+JGXcEXvJPxUfwHAQMBNRnO6BaTEU7tTbcKbS2Kiirqd8X8kjWsJTqMjf3COc0UzMVMw8zdj0L
CqKPQpFMbOxGdcKKtVPReopeytZjVW+nKTe8Wb/CVzN4Xnyq+1bOaE6ByGMJysLlKBIeP52fhv0L
nJySKV57scoCp6L4Fa61kLZN1cbWyc76vdwMXnQ2MNUJKAtJ0Te8T/wGJtHIrfzu1r0Ye65ecovT
AR1yg8PQxC/V51A/FzLFTRu2CX5aQGLPIEkgj2b4laPU2X1LA6b3N0+xtzZDoc5zS+HLn8oN7jKB
fgE3MOAJvYgJJbRb4kwwY6BbYGubg7sSayhdIg0FIYMwwATsBYibLUeRsnkV/LqGQtWGYo8lbHoO
U5nYEBS+VZBADmFQQzD9mg4pOAeb/2O3QoxtiFEB/TGEwkqED4oeZ5gzw4adbi+zHyhHjkQJgQ8x
OBTTpUFyo/8ZnwFhEufl/LJSHCJN7VAUzYZBNyQ5DhO2sbnma0NZZWWGp4NexAcb2wvxLASHOqlb
nNb8UPQqBg1R2OpEJj+MXv1a0L4SSBPcZS8hqWygTCQp3/OCD6jrqaUm2FnnEmkL0BynYIu4+/48
jyRWcMTRu57jmuteUsbyum94mzzdDSY4/vKV14g+ZacT/uLpPDCV/jR6tUI/uGaAIZBNceI6eqxe
m9M5N/tye3qbVqFqnedQC7Ml36Y8FHmidoeZTHnqTyFUe3NyfAT0S0qwAOONLN7n8KHu+Nv9uura
7DxlN45XtdFHjmYhX37ZLMGUL0jawDsSTDowal4gYkv5DCARRau0+BLH2Ini2ReQhqJ2DI3EGg1W
Y+ghiNB2IPGsUkXxnU0cXyDHscOtFdVCr1vsjgqCCfpphbY4VEzLb6nXKlZL93IQOKUF/e1mHNgL
N+nIFmvmYyeslJCrHbHsRFvTXMAJiMjk3+sp4XnoY7SEHcEPD3TnOBVuTQyHtRwGE56azWmqnYH2
LwxIaLpbsklck8KcZlPHQUh1HhcR3kiJBpR1hAfLdzoL9LYtkL3KFQh6aIEOAq1dj2Kx5AsyH1hr
diygzJSE4gPAae9JDmQUSPdUKmu6fDgggg6G9rmyvhu32126smGcddv30IlsHBTNhym1O1QtGIg8
tuyWkUkNzcO0Y3mPcgYSFuMXE+f1Qr/SzDx4gUt1J/VpH8MPbmZ+xAR23ydHHeFvYXGtYeoJmIu8
Fq2NmkQJYPSQjWa9ijY2+SokJ4ynnXf6hTbhaqcB8e1B0wg/USMeJBtnzMBkLRNzVs3pyx+l4n9s
TJFUgxJWuh4VshNWEg7gHrmGIuIpoHJaUNZAtYvjgLBfw1QIz50dBap6ktvr7Ok0e4R8JJc0W66j
x1TtUajzDyakNvTjsZ6Ug1Kjk8uUEttKY0JOx0U3OtiDyFQQXgSeI1jaLhkELsf39hfBVktEAysK
VM8VxhhzFixpptgKj3hZ0zhrdQzd+fkXqqnQ2ay5pT9IBCUmoxptQ7k9zWv80eNEzEJxGe402iAe
BuJVifUQxUZMwgVplxiYAfIXN5tyUy/3mAa9ntegq1TAsHJ8HcS+MzrzPDFykZNvQ2PEciEJLGOi
N9Yv7FPPacRRfu6Mf0D4VowQXlNY2OMAKrsYHIrV5CCqr2Cmng6d4iA2KtAQDujrI/FWHYbcniil
HlyBTjh1h6tJHMessJlzdXBTcZB6ByXglLyjG1/IosFF8FTrhKpPU0rb526B4DicUD9OY5iZQGkH
JJPa7NPeEa5JMwfF28mjUz+9CSzrAeCjIDTXqY2sKi1kgQl2U7wWpjFcesgAOpZUf5kEIHLB3D4o
Eu17v0up7y12hwpF9fcSa30kN3swygB/J/Sxs7BhShPHHQd8uMqm0bKGc4S5EjaSue9xNoJ0bCVm
XdUypfMFDbQrcoEBNixeWpHexaZIHQcKFNvqxLYpShMpVAwcJ/Bn6of0gWqGbQ8y0wN5DPIOP4v6
9vHTu/9R5TR1yW03lc1t+/H63f/xbz/7LE5ItN4P0IAcfw0JYMW97ze72ognq6/lJS72YEcpoc/o
5WS2bbbmQrI7xC+dJ+voVhiEeKPJzyfJjwa+33UbsnDmUP5gM3FfV+hWBYwafjydPsEMeMK/GO4y
vxnvi+46/pqCfc/AtIZG1+ty3/qVgsDxOKiBYJfAtvLoVCWYwcZIUT0JpQVX39PscUzpts16UyOq
smd66o4m8z8w/Tjs2Ig04qoFh4Jdzt8nfRs7AASjOtLu5V+dnG3MpbCyHOtpdr9FcNRHN4unaZ90
c9q4Qw7ldZzVC9vNXrDec9rMqJn8doMBHPt2MjPLeI5/PQ4g3NOzg16xQPKpovPdcknPUncYlz54
eyWbipqkH0ApEEoEjB75+UQgYO25DhKmJ1buBShCEsrzZKuROutw/KLfa1AeUM8XFTn35EUxAb/Y
ddpp1iwSAqpMnr989fzl255FSPbtHrlAgDkc3SOa+Xy3yRY7DB5WFJPzCAs4Z6IehbpLYGmYVHT4
1Wa3ejqMzi71qvcwqNZ5Tgy7MWa0mBncn4nFS8+zqnX41RzRZmCPLYAjv6ohsMghlwXHiQ0ewqO0
HZWzjTiXlkA4hGF2ZZWjaiLyzbo1SHk35IukHXbUZFp7Ms7+ipy295Cru9zCKDQYxPD35adSFF0d
N5tO+m4d2O2DstULoW7+jtoMd3372j7evPsfkne1XGQf9+8e//eUeZwNeGQCsFk6YA2Jk9Lgc8xf
YTJRqbOd6CSE5qJXt783lqtm9aHarwEISAagHnXwB1IS2AS2zVIRkHooYCPH+Fa54y82zW6NKejh
IdApfJIPEUpv3qzO6wtGasMXE1fP6OiI2h2l/bxKyps0BFmjSuf8AKjA7XRI1ZhN11VsftnU86qd
5sNNhdDyQzSG0wrCb7Pp6tVwXHS1ggakqfs6WcxIOGabbqbD7189e95RBiAEp2YBGU3ZratCNES/
+EmWjbBXo14nOLYioW04URfUIuPsr0jt59aaOeTKaV02mz2z/L2VGYpphLNPNaTBsZ2qbmC/t7Sx
7Saf9FY04hkfGS4AkCkllSo/lp721qFGAYEI4LAlsTZuw2+b/mn2RtM1lAzheDv2+qq5w3afbc2V
MOzfjV2pwuyxWDXUYO9WfPb8h9fPv/n67fNnWfVxVxtBrqI82nI6p3Q2esZ1VV7U85ER73CQ/Nef
fYx37X4kwLyBfWEFWvzLeva6XcthF33WVaJyGN4fqR+vyBh/JdkCIpBL+jiCqbQdGBY+HabyIM7S
L26Q2+HaTBWYriTXpLEQ/4yokN0oeAknXuOaakMTN8d0Uyqmp9PM0skepw8+d6ByF2jskGPFEgmW
VRq3BLxXtf+bxkhk/4lcQkGk+4YkvMyIiZNHFAj69Zu3mSGYnMQYAfxC5vCe2hI0Oouud1UubdRA
yHPlXRzNCDiaEcx32sE2YJNOjr9EjCRklYDxStjD0tMiy/K5XS2VewADF5kY5rh93QrjrrX8guLa
eX8YYawqV0ANSKd+hbEZqoKJIKMobYIwg4ZY+ExjkmCoO2kSaBi8TcMxsFYy6N+KXJpfuIpfy7KC
CjEvom0JawJX/MxMyGVgpqJhX5eb1aw8a3bbGWcZnNldo6ZXJpDeEUTkNKBLuUdUuj4T0FvOI58u
w5EalnCwfxnOEIs3GAibYRfHLBFbbO8imrmujgwSWIQeyBw9XPkzGWi+vUlmQ6qbYW4aVPC8/XLa
dQGNxFzo5OeA1zQP4p5OZNiiN7dEgpFIqJkD8NOzWdWd1zUGud6UmFucfQPgxrgqCeKbUtgg4jh2
5uhmIeFh98SXb9FULaNfY/Veu4Xe0tz9Se+UJ6bbXzNyRKGq7Iz4U2bEW/wXAzNziGd0ut438Iyi
c1kWwF6gCgdd3zdkgKILEpDJPVmMoqzwsNm5xTA8gBMBQWOC2iCpqSbH7Rq4LDNzGDwDJec7wzVA
TAzcCkB8P9WlJdP9HUO8dBLmW3JpB10B1se7CsrWLQQNMAOAYlGUKxb2ylm9ggbyZj3OltX5dpxt
6ovLrW+Zs4a5/o6xsaPCBy6IzlnNsds2my0ZpdmXHAU4a/vjAENwnQDsWT8A8LzhkADXxwfZq08Y
/2H+e9ZgVgtzO6xKBzy22DSYEwc9V7OjT58wlsH0ZTFRtTy/OqswKNMsOSUog2+rdl6uKZMrsGm0
ypyyTDXkqYIwz6uu+sU5T4ndOqiRgR5klTR7/2h+WRoCBzZJxksz1c89+YSkkS0cNEome5+z8G0d
6L/sXJ5czkjLxUw7Z/vuQUAx5xtotvx2n6FuEqtPhT2i+cXGBMBpm9S4UTu3i69RJXIwxQ/lomjW
U9mSU7Uvp7Q7ffiJ6hpHYF39Uz7qoDHicknfm7zdXaEH+rogZUaGmJP0xcnj41PQZ//Nowd/0ylY
YcCLGwIDQkxkR36VPekCjL1srmdXJTr3PupQrhqODOJmZpI1D3oqvQOnDakj+bkdhpQ6PsWwucgs
0g0/MXqW0ujYfmU5ePJDOgtKx9ctnBvBCsjf0JzAIWxl6NLIbOFgiEXs0GSX2XQdykz4bOTDn1ag
9PjJ/ENrtyTlof3itMOym5gAU9f/PiwIrMXOb2q/6JVOyycd/FrcDUBOtWO5D0O5f39YDA5Eb8RX
zVQT9PR9uK3KzaK5XukrMVURwUfqGviepQDZgA/5U9/upIrwepHg7e2F/l35B3AHsSKYE2yWuDfR
yiH06mLZnJVLIcNjT/HZrUCVylVpj6HuZ9EP1Uk3gk2phAM+zHwfx+7frM9BNYPnre5JGwnP7yic
oGc04uWK3rfL5R4DbZxClyOGJSNKqKMa9iqmhgJoQPC4i2GfNSzoxFCUy9Bei/BzxF1hEm+KUBkO
PPmn3S6qzYbydObD3339+uWLl789zobg26Qr/6K700PT23kJJC2hZeQ5YDftRd/gh4x0hxh5SwTL
Ycne7jhz1fdVkENzEJFDnk8cNnr06m+Ln0jtci97fgO5ZYhhJE3QqI1yszDLeIA57n49JYoSvxl8
/MO7f//ZZ58ZsjurG2dN+BldAzB7zGq92z40e978g6wWDARO7sd/fvcflElC0Cg//vLu/y3o0xRQ
rYpp5eCCsWniU2NTYVyVhvSv93h1803g0FrI88M7u+gafGFJzd9zN74vNx8gvat0i92x3Kt8SBXA
MtzLjv5U/zN1vZAcSbR45N0nqVJAtDPsx168cf6UTf9/zX1bdyNHkt6zcfziB++ry+DpBdBdRF80
453Fin1W1nhsHa9mdGYku32oPmiAKJI1BAE0CmiSI0u+X3+iX/avOL645K2yQFJSn9k9Oy2iKisz
MjMyMjIy4ove31pvh+Z2pRd/8S2L5JSKsmd5yW2wJbsYKEnxspGBVLEG1jfsBEjc4LNX4cA0sxyX
QUony9EVgx63HPAVh11MoQ/qDbs/bbBL+x7opmw5plDk+LWGxQhW+fWMJKnsOiRJPCSdekf5pVa4
+u2AZxvlwWGSWurrILvng3qjzlUBXqm5krWmScEjoqVUXGQgHx/MFbm7Nx5NQ6rfXvC742Z3tzR8
OnGmI6GhT0XPkEzWFjbE4+bc2q7pUMy7iYk4Qa2eFROa/Mk77cmn8l/Oofr6nQauu7ykHCZ/VhUa
Vj8nElcrBV+Zyd5G2pU2PwGEovRqAkhSQAyR9LtGnayVak9KrtoJc0DVgGgiSS4e/RCNx+NR8akJ
IFWtvkpKvX7nD2baKoYJN/86PLJOcu1QQW7EVdDdGBVFS1zydzolOFrKMZTGeXYGaxFDAGzX+4tL
d2wPsHh01tJWPuf/vDZwHs7FCa+y+kMFd1Ku5TjogFe9daAEKi1frS9GDbi7MVq727pSLCZJsS7R
s+0JGx8iACN4X+s8dJAI1mjPIBmlYSD+am6rVcDimMGxN0Tp2Kl8qUWtgWTYcuAsOB6A0C4/g6Xm
U9tS8e6dUqbZ42YWxSgBxSvB6xUCOYOdfCSdsi+JqFs4IHIiWp1wrg2tDD3Gw8h96Rp9pIjquByC
RDKRyPe4uRUWwMozry9cYmb2/FZkGBUo2EJ5cHk5Y9Alw5ECDY69aElEcrrFBh38eff5f7le7yDx
JWVZa5vPgK3TSY/2m2qFdTjpHXmmQJ8/2S7Yff7OjwSSPi1xgw8Q/Qq5sOmjRd2cMfbVXOUtTydp
TMs1cKFdyOZH0iwCxIEMd1wvMOFTnt5hkgA2cMz0u3SYUDJaSiXzSDteALXozpZrmC2djb/ciBuN
lgKpH0BvjTjVY5hpmllhXaNlnC6UB40GVNrO5ZIE6oqhn3bAmCxFDPvaeyj09IozPCfwSU20aYHo
tsWq3Ml2cjU7oBEGW2mNJR/rdV6mxmDNUHz1mYWnNrqpsuAJEjmFqnRf7ljSHh5vfZ4TGsnI/8xL
2F/jKJzgn2XRdN0lsRO8sIZOp6MW1uY1/U4gyM3c014f7tOpsL3gSWp572DAj7tluh8tzTdn9FWL
kk/3NKkoydjkx6y9OY2aqyY2OGar2vgAhVmD1uOokbA49LR2ivADp0PMHEbPELeENj5tmBDOFsDW
f9pyVj7ZrCxl1gZ2lzxJntzc1kWfETEqDrAb6upAxlgW/bQbV8DUqjHf6yh/L9t47ZgtfJzd1B/C
hFNr7U47DiPBateeAxWPtP2xEwH8Bx2ld0mHpTOdTMnesF3NGViIr+y3MIPlEfj5Rrf4jNQtnI1W
5hHj0lSx/hFvJ+/eSZOkQxETzZSAsaoLy7X4y4n4jHuV6Ql7Xwz1xzqUi+6ZxIw3rh4n2UIOpJXi
roWTm1JECvxx3+z8vbGdeNj63TXGYnUbyn+ydMmi4124m7JF1VQBWU1+O3PkcKJl/QD3W4pN+rj1
CGcZxyraj9wQm6R89869HdsiBnBpCMVZfC4vfs/VjT+GdqiWQtnq7PBr5u8/32azubOhxLiKBeae
tTcrvuRiAbMcWH6JcEvQcFk5nzF6paYPDSzRUQVVTkpInWHaOb6rrc/ZyHozWzk3yzM6ve2q2M59
zmy+rNQLa7FmSzBTIos/KP14CRqPLNjfs6nhmJBqm5Ft4naAL54H61FSuwgX2ekSkyH0lTYH48dS
CWYUkDT5O5EvbJQILN4RA7clwkW1YhiFqSiJcKwJQtsEfFpKFEODTxxZlO9W1H4HYJo09hFWJRND
u6Rqwf8AFqRSAlW8W+PpOiRYN/A1fzNs6UYm10f5fUa2LPxV8oYZtB0cluSCOLm4RAo9fD16nDy3
z02Ftcar213CislhInIgeo6ReW53p5E+7DROkUpuNyoVKw0jeDbb7CR0p7J4M9G2QsXKOwKpUuXt
iahv4qvmCZJLtoBSTxUUQVNNw2qs0xPRSs5onmhtL4536+N5dYy3QRvDKKN43eTunRTQqYL2S2oY
KY0rzLwI5BBwVK1U2KGyfumBWTJ/XW1Gx4lKsfl6DXe5iUugtQLU9RbAo/kU0ZrMGqZguf8JRG6G
XYzbhuDSmjgS5o4kYpgDccUrissymtVeTMMz4JteLKtDytIhF7VE8X2XjgtLVP7k3bvumn2pVsUk
AA0E1dzDqBWUPVRh5D2QXUXRoSlL9rt3P54nfbYpm+0cN/kP4CNnVbYZU+2dvKnn+dK0vOp2xl6N
0ntcIo5pK9TVKxqy2NkE/oA2mm12wTRrTfepvRaPTadhnLlUEscO7PfxqoG3uVxVqsHKdKH6nMIV
4uSrvRZ8XG3HX9PforVGmPmxIhZ8rl9/ATaCgEtN/0n18Cr8YnW+fnfvYuw6UZh7qm7mOWGtLgC8
90o0khPZ/oah2FwqdqasClnDTOvHUNeVWHFz+YhaQdt9R6Rae+tXQWMmHTYijryduy0Ssu5AJXxc
dwKMGp4iL9cmCmlOTUnInNGJ6e+1+JstQLc8nn6GmSYmX5h++jPPV3AiZ/W5dqZi9flQmJePNnsZ
B0rvJ5nz2/U278C1U20K5hzctAMyg0gw00A0fYA7gZHs1TNEUHOUN8zkissjsgZEKPSfZiyHLf3l
zmvwtpNDu3O75TweK/+AK3par54WM/3cfa3euVR3kIwSr/a7wM2Yzbz4hGtiRWAhF8LNsr7YXS7v
SrEc0rOVuGf5bCZBFXISJCL219ez7d1Hu/DxPFevzpf7anUmsd+mJQ4jRxaVrFOJnJ4tRx+NFYWC
KSzp1dZxIcuVRb3N7S86XTJwi7ohrrmT20WphD1K1ZYj1Ptujh+18wlpfDhkGdTeMCLEq2McNy7W
2zsOX9/ultWOfQ9InzWnXc5uI9kvI4qCVo3oqXLE0B7IJ7EfxWIRglk1lUtF7LqutQQNFo9wraC9
Eo6DyCVyTet4dlGV7P4o5y1osudNRpf1+6h+HRgtaVXOClfZjKvTOZUgp5nWzQPnqy+Gc4Sq0eK3
FCKcDjaMasLSsgbVH3RXi3Y6E3Sv5WzLtT93RH+Mg/pifcb7yZ/vYK4U6JUiTJAshob63zYH64zJ
RSaKqA1HdDKt7iMMFaNaFJc01bJt8P25Xiz7kO+Pq8tYg0zLkM7U2Bihe3Cen7xBwxHJH2V0j6vq
br4mnVFq3+43u+HBCq184cq363THfamUDhF8oBRVvCxa0olapCNHzefWZcn3CjUiO38xCsO6DGXd
1c6RLIy4udC1hqPNZs0bGXudzXXJKRXsUyOT6EwEX3dFktXnXY2pIj3b2eKdrYJxdh8s6ysgyl/V
m7HD2+nnVX5syNvpZjEftgd9v8FV5GLO0V8SBDhi19Af3vzTwDWUEbA1vn37/j+9efrPBKjiutpe
oDfxJbam9xJwefuq17NsSPqCs54gvo3Gp4GVZ61xSYX6g872pBDNBBv3rieXemocudXx0PA5rpAh
L9qYF1LEfv2RVDTxPl03Y77ZM2iMaoPNk1TwDbKj7Oy3/OkCwz9HS/dCXkdqtovmVucIi41sQVDi
UF1vfewkAr3pgYRN9GUO+qNHRYin3+QCu7kMAiW3WZRgiwxFAbG7CZ39UTbTpuvHmJGPc1ljk3Ia
vznqHShzfUX/DgMMTJzD8agz4bdTlPyVJk+32uE5ujVN/K3RZB6U2H3qgjHvKg05xEW7vxrhqwoo
y/9hvWc5AWNrkFwJmYfYiUZvL7B66Xg1LkgRYZyD585tbjHbzeazJqBif70hJeJsuyb+Cw+5YXLD
CdvjuR8T56DptEQJI10hkbscwt+9e/7uHXievsItWzxHXyK4nVeiX7LyNSen2AapygEmqZ7hcR01
zgHQdbZNdLtOq+iSYzsxF2xaFGlAA7Zt8oFwxFpYlhx7BFqoWV2WreBh91yK5nKLh/DJBuDEYhb+
0KImaWeFYdwgNf0O7FrHpSK+cAE/7C/6lmTNCwlbc6hXOZc2vDaGYFItr//Bh0FZPKXiY1L1691w
8HyQpBL1NZYOAyW7JqRidZGMzU6on5cBHUj5vc80RMIQzK8f61dSBzG8pMlmh8syvp9PczVgvIUQ
t0sGDEwEhPwb8anRPC6+afa8A7tTZMx7Nq2Oe9fnKd/yz4B5xykhSq0nRvcxdnUOcsJgOI4RS9RC
aaCjJAAvlb8jf+qUw5nRDBM14hLwR5RRD/erWcmahYrjZcbfrDcVbSIktbGrnR/MZIQ9UlIXn2dh
2PwK6pDttmXw2NgwAMFPgDH5rrqdaNi84sKEBCFP86AkHN3AHaSLkf/hMhe35EkBJ63YjXFer5wK
RZtAfZYOsN4m7+42VRPehq1oX4DwwvP0G1YVZa9ZcrA8p17mQ/IMPknjn8KTzFwkpfjNKBSBo14X
F95kubDNOhLB96SZGPaE54MywWRknsVOOZTXQM8TW9TJq7JoYMGgjxs9I5o293e/+SrIBQCGkt+q
8Ce3l8fHy/NiCGMrkKSP1cg3MjfHEAPgJ+mDcpZgeunlYHkO2CQB1GJ+HCRowmJsPwEPDVPtDnNl
Jyt2PvB1j1pgz/IyMyvor4L4OlWTpyjQMp/7QkHaqI4Yw1al333v133WJpbA1h8iOYQx9I0cwMLZ
r9i0ScdI5D6Ez+OCTbjASBj1H4C56FF1jDuKJ76KHB6wW5uWOs0T2oEv1xdh1HddbynyAYvQAgOl
Rb+fTaaJLh87JiYaJyqbGYKqNRGtKyPh6uik7cC52R1L5xUqWf8WP1yKFC2gfmTNQb441cJiCUN0
fZRzgxM9rDhgKmg0k2iD3zJ2C2JvcZzsd+xcvm3OjRi1X7KaOWoNT+yf1zE0ell/YtRo3mPOOjuQ
l1jlOM9v6M9kz8frrn6pmdDA1w8x/L1dHN37iUKDZzmUb0TdYHWDzbLliG+SHTuk6Z/vFRkdrNEx
N22naUm+cMB1ui1kJPXpoTHGIade75vl3dQJttO3XUUcSyRFwuFhiiadSAmPmPssfQbLxf4GvYfj
+LZ60V2RLtH20CiqTVzPJAO2G7h/cMJuVpcQnsoB6axbtKQ28orDiztTnRqntCKp5Gy/heMkInvs
prqd5jnMR+XEzwMkcWb6MKunDBfSHpdn7VF5wA50qMpWYaU3BJNJ3YJPWkS0BV96Wx2sqaDTTssJ
hup+exQATARp0BIE2CLtN0tS+jmmPR1b2d1SDDpRVJoORSXdfH8aoK14Si47gDAdZQOokiTvFepy
4KEuB6Xici7PA9RLgbEU7YKtyOZepH6wyjoJjkFfg2tZH8GnQ41M4DWJm2fp8gOoPb+H2pDhW2Sr
eiX04v4YTxxhbsny17iXS3rBNnTBnZB4FK1J0Kz2DelQMzbbpB/SFsFmORdaKZ4s5sTygG7LMYTB
dA5237Ns2nk8VAuAXinRsU3yBJkfVODpqZ73zYNJY6vsA2gT826boTgpOCYnJhGHded+54KxWyij
ncFxfllroK8boA74FnaFVUs80teYbEltBOE7JxFc5aCv97cBmgVn33Gpfh4aCRvKDVrkYvLXEmGB
GBjBgkSHdqi0T0hkLc+lLI+gEahc2RPMOLSxrd7v6Y2S4W7V+eE4pOpe34GuedAb+NDiuNSD/uaO
70PGHINKJ/l5hYtVfjuMJKkzTLYsOH17Y8cJ/V7Zxs2Td3CIdgvmiI3kpbDLG/4lV2I3QmS9Hn+t
1/r/HvYBMzTsbjjjwTAgghFn3NbRIt9h3ap5PFOmbWqLm2EnqevN7q5tGxbMscX++howOnLtoKTC
vB/d9CStSty3lNCyegn0oe8621S03xwD1yo0MOp76JD0QC64VlzX+EPd1LvhcnY9X8yK20lxi4zG
iNsKcWJhJjixT4mnl7v1EF+PHJaWveOLsv7zoOP0JmceEIM0xiE61aA0jR6/SCyZNsRPGn/vsF/B
tmwR05BSZRa3p4V1RGwYGaza+lOuvUnrO00ZVM2uAz683X3xu+TmSlgWw1Rq+RP5z6il5Ruimrz3
KtBIbPzsopW7QHMEF8zi+Nu0sxzTLDyqM97TtLN5TkIT8QBWQX4UsXnKYEEUYz+GCuT7llabynAJ
/Uc40OqyouInL9P3cr7AENJ8PMc0bJQPtYVR64CxcZzcHith6LSK7iF9wo6PM76nw+63rFYXtIie
LLptONpMSa009Z+wnka9SBC8/89v/nFwmb4iCfz+v7z5+38kGEusDfG13p7R6mH1JP5Wv8CmUg+I
IIVD5yV3uKe6LA0rVNfsVAhfAOX1qt54NwrHYvyYDaOaoc3kFWffE6QfsX7DaGH1wmxhf7/CD9A8
iGHAURsweyWKi6VCUF8kFkzdv0Z2vcEfiCT4Sw/Sm+mAVChIKD62wtHoczqlYVi+A9T2kGd3Laiu
Y/VdcWEm9gBpaeC+SjrTikRkdoyDHhwRV+0GDZ9nd/XO4gWsdkkPpfSNUVERprNBw68UltCnO1LB
3nFe91UNeUMMaZd7lZF0mM1ko6gt12tp8pX97tC1OMtip/98Ky6j5lzDzq1mCu5BybCMK+dGmK0f
Eu1YWu/+tUSpuYhS+78L2P2K4IucfcLYjgoT2zEV9CdTO8hIFc5wKDoVKUtUckwbPOx38kHWYBPy
xyol/gt91wFm2m5Po5wPN4uCUV9SE6opP1H1PFRRxamI5pgKjfhcVh8qDbBQ78Ot3qmbr4WUSDMy
Zdo82KejN2/eSEA+OA2h9DeVd6lycSSC0S3k3Ky3V4H5g9swZ3zhRIHRJAHiQkyGtpBcjTyAwo4j
sRGORIBkCjyapw+OvjWQTsB9Q+e/64Xbrku1GC6ebl7nnfgo01b0RUdzlks7JC76LhbCD4kQj9dQ
EJh7YP3H1Puo8pjFhJR7p+yo4KS7ktKdA4zg514DxoxYUWOR+T8NfHmBNBVbHHougaDoUm5v1tK6
QYXbVyLzXGd/Y5lCeS/61nWYb1nSb6wZDj36nFQg97U7mYXDxIMTuFRp4t0T6A7MQK6AXYlI3KKZ
WU78Jq5Zcvuqk2gJi8Pyeqnl9k3ceaQ3Vi9bjD24MIjGeWDYSl57pI5c22rQ8M36ZrumgteNgh7q
ZquelIAPY88gYp5Lzl80WwVVNUj0BtMwHyg0ROU6SYzcTmvNYvb9f33zTxSak+FyHTjnf3szVnDO
jcGRStTUevWcXcE15Br0ffbVF4LW+d/f/EU2gRiAQd//jzdPjrnGb+hXvas1WD6T7inMDCbH60Cf
dF4krEp601Rj6uQfYI4g1up1JWCxAprrudfLpu+McaIt48f4gWlGjzjgJUJXDkDXxLjISUx1jzJE
eEWDhQuwGxgD8XKZ/8QXnzHNkmwuFQO3IJMeAhc93CucoxhqBLBm6r1dqKtVkHsbWBrnHJPDeyTj
56qJ7bKi73+NGfrC49KOe9340RmI+eBv7+cryI1cuBGPY1dIToy/xTvG0CRKq0NA/UhicgNYNt3j
gT0rvsrbKlhPzaT4dvVdSf98L7Jp9YMGKEm8z+5mzbVySNBCt2eGQzMnljDLAGxElUff4FlxMx0W
dAcVTbvRFEM5gE4REDmknVt+fWZfI9ek0MVmaA6C9bWwFoFnYaSXiyltNjPAYAoWgoCzl0U1vhh7
V3INyeG0ffX5eRPniQhrPSl455ttmmp6DozpaCZ74sEj+PRTtgt0zrpuHJoxQFMVC/L7UPDfw61l
Pxx8S3u2HNjtAlZxwQ8Q5Fjrcy2DzsxW7JAKXhaYbBEFa1klnNKT7+RYGvdDQG3ilRtmJ/5FZI/H
Y2IdGab5cn12lQydlD5R+9rNJc7pELaBcw1brk9cyYD6Ma2/xbBvLVub/VIKRydR/fykOE4S7s63
1cznsRHt1uix29HpWdzwKRP1NjKb1HTkgqSoVvtrxtcYtj6YvB217v21+mf0MdwZqBsZbwah6lma
e5jvLFsVfN9ZwXFaQaC2con8cSUeoWhMzg4Y4mQbTpJH9/er+WwJbYbkN7zDvDtYGCsZZvhdscGB
ueBZUXs3NOOH1SKc53DQ8elx8ZLTaGF1TBL/x3DVRrM1kfml9lpz+OzlLydU7zHV+uwQTHtCxzNk
x4jKC/2Ykr8K13Ek0mX5HhYTbgX/PgwqFYS/Rf2hXuxnSxU5mreotWvwtsKW1m1ah3zIFGArplH8
DlYh4rIBi2/664eBLGnAfIkPuNtvkvBTEfibDSnQRougKfrcNUvsy0QwpqvweV5iobGd3bgkH+FY
4MaN5OBgNDK36m/tGGPFT923py/evnUbBOdF8a9osqJznQCCLpHgm8qdDngMvsc/P+Cf14O3MWtx
LeZFsTxkrZb2mJvAo+j1s2IZMoSE9iorZDYBN/+/4XcaoBvPfHua2frPZa0zMp0/hKMOBoDz6zXp
uTZUmkOHttnVxR4hEC72gtTyDU3+QBibBD/qRaX4U2rXJcMPoPuVxW52JWEo20pZ1sUdzZZrjSC/
md3FkdaeP326HhnzmE9s85RRnryUCad1fIZcHJYnnX+fcfp0exTa8ztYAtlVwux+3w3awt1qxgRn
HLg4bzoPUVEMHpQNWr6QER6ktxnUluO5yikBmVJKUXtDsbdWzYvU3xA12ksipHg2GBG/4i8i5yk3
y3WMjl/iRaP3GaeR9ONtqzV+37eswtwheLXlu5B5JQSecgn0kLtoBBxYharCcElb47ay223nx05Y
V9MOySBk+eSHgXpzBuWOk7raA43h1RbSITXifXUnRlsUys2QD19pVltcnWg4EUJj+Nj6iT8vBq9P
gh92TPzt7DoMGYhK0x8qrX4MIoMucI43mS05XDNKU4aF2cDVErKG43ie81+rReNUynrBV+C/eoFx
/SX9g6FZbzDMr2ADoGeQcU0obcriZcF5BRxOuOB3gUg+t7lrwmZ2XnE2OKH/enaLa6ITXHFxy89f
2YURetbxLb/zH/OHxyDTtaeVWKg7r/snTcH/TxxE+pIrKsPpm9Pbw5qG3x/e3UXxMDAo3ZZUDYe/
8cVK6Y77o9HBFDTemhNW5dnALuMbCPmo9c4v9ANOEtH9AV6PXO8OlRzS6xJ2jz+xiTKMrsLJUeC6
hx7/L5+xFg4JKJNzu5YB4IxYURFdI1/fbXJhNfpxcK4yHIUwla/lWtZ3KupjjdWhBERkk8hZb1jh
PTkZtDYkpResM9IkDvwgzWeY15GnOPtOXQ3Kc6X14CE7GNNgfBnR4R520ZI9abNYmVbvp1Gdhylz
exDzUELE7ke3v3tc02DlqG1+8OMad3Xd33od8X/Yvnt4Hw1J41Fl9xPQPqfl85wd6P0YEeO0MeYT
zx12dm4PJH7FuokuIIlx+NkXEVVbr+5bRSpEHBjApJev7TRqjfaIYQSH5NOZT6D0kyIQhvUvOF9h
o56jY1IyEtoHpC7MaW6R/cnu/y4ZmZWD++6KKW840+l4NEgCXfbIAc1mctcH4JgNR6O3vdBTK+hO
K3JWLKTBg1PdDpOTuZ2ODosnySzfUjWSE7GLPERldHbd3VSMWUn7GL2YY3CFpG+QJLUpjo9NfptZ
eueOWXzZD39WgwHZbSXKTKyk/pzl08FJoDXyRuzWxVVVbTwtOIVdz5Z6EtJUqew5zV8yaXh2547d
UDdwo7peEY07iYZGT+JTEt8NoIVlPbd7gRV+Z/YcDW6IL+9ksMMLAJASLAQUYA3G6U0jUl9Ji/Z+
aFsc1dmwMBhlmtCZPNAGl/CNyFp8SCtgwpYjZQ0TIHRFBi60GGHuB4COuC0shD9V27U6FcXGQLEn
rC6qIU3b0DS7Ucm6qBA3ap8XUea0fovM7VyG/m6Lk9gch3EqXhe/eJVUxpalF0U7YsJOAKxFs/Pd
7e6AXeyUZApccTinCtypHIMaYw8OqorFIODzesWMJui1xx9cblPos3V80lKekRGZxO9srnWMgrc8
hjrWkOF+tCftqBw/R+6bUVZjYSKOw3k5zk1M3lbaMUHpJD1gYtLJeXZodkzU3Dc9P2WO0nmaHGcK
xJPliqQd0XPytt4EVrtcrJlLXAsqedYi/8ryAd11ZEVfajrdbjvsQ3WeaKPpkjC2o9EEfuMGmjR/
CVTfkwBH/wZK1FGxuFvNruszE9B8bVVVi/3GvAU1/QxeqjDvtU8HfGYMrHgnemk83shDWQXRsMQS
9uDHstLyX7elym+skxPrZbfSc0TS9uxqQmsEqba/2vIdr2t35G0YdMI/Z52Gr/wCYiX9AcfXnM0Q
sIH9EdhzC9wm1go4FYaKHbn3sHyryfGGMZL5amNMp2Xs+s2+Ko7+6uWvxsGXnzFO3Hp7JdaEMp5V
qAqGwi55xh1YJm9eI0N6AdgqwPkFCFd/qFNzmDm9Pa1KOld3KzHjt2zMxPwemtKuD5Oc4gemsxie
I8UybKw+MQp3DOPo+jMKpr2l2QfSIE5Xraw99qs/IL9sdSj23T28pg+eIKM1ndWJfsy2/5AtPyPx
P9ux6eoWEp8XUPFkiwqebAeH7TZPimFdWpOlazBJJO73sGg7fZ3dTTPk/R22BOfqz9lwePWV6jMg
flcCaQ1jVq+b3IzJ7dRT8bY0DlpGlH76IErTk9PveaN6BN3Fk/hSNGPiO3VEOVozmLMkMJ6Fp5ec
TO7e144S7+CcTB5l+X33I1mdKQ02/uJYqvAvo02fLbDnOxe1YF9npyYwev8rN97u6pJbI8Ing1Ec
tGAh1pnKOxpIpks8QiMamfgfQaR0+l4qk+ofTeaDhFqnZej+WUbyN/7tjGRj3nYblxvNcxebqhFM
cMIm2uHwSsXM1VsFLCk0hR7MPef2Diq6rJOrt27suR6zMLf0poy8+d11LbtXpADr0m1rsZ0LiW9Q
4CgZCJUmwh3LNP659olD+weBJE3KJsuS22lrSrx/yohfHRq3f54ZN94JDpH6ayogmdDa1Lq24lpy
NSUc+R2pZUrW97jzG4C4wWHniCJTh/Xne6cV0MIyKePttMeF57uesyVa0ftWa9fWFK3UjD6SzF7U
twMM7wkbxZM9CrpostL3SzvpdTXXxweJpM6N7GfppeO7tJsqCzL97JZUgS0U6M6legVkD1Ks8ZyI
AYsdv/CFNIBoWX11OuGCwkMwb9pzfvwMa5y/m5iQ28J3e6oXVVzRM/4uXI/B3hx+kJA70uR2N/rV
qVzZ1S4OUX1FJ3yWTpaAdN8uBH/xatR2RIiXZuZuOTAGDFJTBkioV3GwSOb74+LHfvms/aUORXKP
bRfYr2KfgNRgn3wsYZHh9Zu8773/n2966pV9e72kY9X7//Xm/xmgrTgMYxDNBVstsQ0JQoSI4Dd9
xs8ud/QHHTr2Z3BQb3ruYNYwdFic+wvgf8OzUXG5pjZpHWyrq2pZ2s8Z8h1sieb9bVHtx8WrFy/+
uhe4ajd3DWCFej1sMXfNmHM2Mgby+bp4fVIMPylfBIC0+2GTwZX0r1c1LO249hTo5hN25J/kIvFu
ESQy1S+m00EWdKO4HQdl2u7wiDq7HfX8pHUSaaSps6r+hJ1W/nLgbXAp4Av4L6vdjB8NAX8XofJq
xIIDYkuAYmFqoSfw8+H7m+kg65BoLsPikNgKWUTV+NwRdB/sqCsoER8ccDpHHuqzXRBZu5tdwKnB
YfBN9cF0GjZupVqhE9CJFHNLyzy6b0wdxk8A2lpQv9OGFKcrmJlozhMRYJ+eDmixoMQA2DT4I6ge
3kmYs6EEkwx9RzWqsURYolUVQh9LIIqfVBRrWlxHz4xbvp5dsOOCYTzww880msWDOXcA+D19enUT
5KGOUYpZZZ5ODRtLS/a6wACfShrmTJXNflNth0SpwNKMXLzIUGqMYf9kXvhv7oerMGzZL8kEQC+E
mrUlp4CJ6sOF6aWVg83MV9NriRDplGEthnc4MbTVH1gkfiNf/TtcHhO/LVVYWwUWNM7EtiTDsN9X
d/Vl1Em5UUx7uJLThc6RMhT9Jezawq749MkWC8UuLZ8sXrOPsTBXvZDaqVm/eE9yImjgng2IoS0R
OrHxd9ziIFjGgwkv1zJ4oVTSG3CBvQiXGb1iHafsfT8y3v43tA2Bv+l/4RbwyAlCLV3zork8GOpC
daxHzBQC5zhrx6IgfY4EEu+bKxso7QUeDt3oKZ3hqBC52lPHn35cwsjWYIzteHlK29jLwDgZYOnM
ytl8vi0BsL26uy5niwWS9ZTAb612JZ2KZ+W8nC/W5by+KOe0Q1+V/oZkwCEK7/frXVXO14u7kmoi
cbpbr0okKISf2Bnj75fI0lly1pCz9TKsgX4y0E+JQxvGerEoF6QZLM5X5aLe0v8+lAv6uSur65Ij
dMKvz+tquYDn0jkpXSX08PIcmTnx6PJlefmqvPykvPxFefnL8vJflNBWSwx0WEVd1vxJWV9flHw9
TP825dV8US5nc6JkiahN+lGX3HuIUdhOgyquZ5vyerZ9v6+qkvqwL5FFtOQIGfR2taZhWa2F+NVa
CAy/X62bs2292ZW6YOib9UZAtUrxbCo35WZble/LptSiweeCXVY2iGQqEZxTwhJ8VeE/a6KUwyvL
Zj+n/23KHe5hws93PHO7RQnlnCd8d75e78rdJf0/RmxHx5Oq3G3L3a7cl/tleXu9iZhgRgsS/8gk
8GBebktcR9MRomTQ35IO8Jvyw2wr3zmH83LAXp+3b1WkyWL4Ayh+8NaUuaskrY0BX69uxoJ5mLmo
xOHo1l11k/ZDmt7xIAcCGW63qNlD6G5nNzGZpLPyFfismK9v3fWJw1SfOY3OMhihhPof6LENoMaV
pU1f3pmVbL3fAfStG2aXao7d82x3o6eiQNIfRnh2P0p7AmTBPSnaQJmWIrALCS6x9mN8CPiXSzrh
+6IE0qD/EchUBkxICJdmTqSSBDpYsakCrYyfM5EKqFscMSNIuKL672h3AmAt/sx5IssfSVtGMvwN
7e+4iAR4N/F+wm98F7EV+x+4K8MvQU9iDbVgvJMA/9tvMFFiW5saRNgh8XPFt0QoMGhk9TxnL1FN
6hBiWovGuZJQXN1Vun05uX0X/OzH/ZSqeZs6b/7b6i7ju8nOx/u5qvmskFLL19t1qi+327uIFp1V
4vSXMPQ6cR4I67nXUa7tfpD3hMsMxnQapK9ssycPE8Ck/Je9TG2cvEdl35H4LmmiAHcpKDl1tgXj
AALSAQBBH2a6KI44s9WHNaD2w+wSjJFICp2AtHtKZZkqIJeMbiw1jvzqi/10g+cSnzQ0HQvFQodh
SMVc1XHNKpqC77C1Zj9Ul33SQ/HcDnbhms8KglP9APPwMjLd0o7JFwv0NnOmkaWHMgFxUDGFtt3s
Iksbnh+krbXG6AuVHsZVKksQMpGusS+wm2ZWWVTJb0OgkXQsQGA8FvREDwq24HY4f7lTK3c2c35o
o6d7OWlXEbJKoAUwtpQ2lTtDCkv0v131NTiGlIKnSbWj5NifqcaT8OwklOxdDVJLnz5pnjSvJT5A
CSz9AZNNAw0P2yiToEfnyixuKNZWRNQC0QFHLZx2e6DyTDxP3IPn1gEb4EMDc5wfmIw1kWrSM7bW
+yw3LPkkSHUjqarpHNAx7dmZeK4TYW2nWQ46YrzSal77IfFVudEJVnTQl9zCPnJGzwBfwYMg4xG7
uOCMxetmHJtprMAYLiLBHCYHTwY6U1wx+yS1MTYmHvis74hxjVqynRZGenN4C7SDLmLfAgLtfoOb
JMHABwhZBg+0SiR0yvDid9NthXzF13SDaWqGlAQnXkKF1bTArKD0EOkaOzbNoVepwJNGQznbdqPV
bBq0n+UcHVcs+E80c4rq1w8I6bDvkl1Ukchy5uVB8aQ56T9p+oPAKMPVxEmQZKJyzBwmBXMIEsy+
wN1jYEnW1qgCzg8a6o2tbYub0cgjsCD/dpbAdN+KjaxZ8/npoWBDrl1X2unts8EEt6V0vJNz3p1A
SCpBdtp7m20FWwsXlbGEhKBHf1MYDIRryXzuWVkKpZkb2nbONRzzhtj7cJobcWKbDwDGW5CkZRpV
h62acGxDQ6Q/IESt6/75sZrWyCpvS7PTYO6ISO2K7wKPSGheKgL7Uovlh4P5lu0rbF4QgwAsI5db
MZWwYYXNCHnv24HYZdi0MAhtB3abz0P0CHJmBaxehVq9inlh5otivlgX8/qCTgYFbFYCh7M4X9FR
reACGQoHdUGd09iCq/miYMNR8b5o4A+xKcRAU7CBRtBTxECTrUuMNpgzWMQLM8oUu12xL2BAse7j
/vDtT5K5fOsjqt1PkLlSlvaZ/B6TwNIbw7OxP2A3M/onvYgaftyaNAhMVXFNKZcPH7PCOiqSr5wp
aCrivCMrZnoKksKwVKRudZBLE/zxl7Cr/s1gVOLHp+7p0j177Z5d8LO0pr9074kJ9aP+oO8ebtZN
67PEogI/9+p8umVPgm01hqcUoGapov9o+37QHyS2aYbRWXCqBjY7yl/DaNFxEyOVnHKRseQUeBGJ
4ilDtTmDl4bCxrscHV2OdXR9QrTY6nbP9rZ3sdm2Ne/DoNtga1Ph+OsK/2a2t86agBq7Oz/+1cDd
QA90nAb5NIt+IsYkGfSq0IbWD0Wv5xhL+ZEUz/f/2934zzb15uri/f958/d/ITf+8mDCBsrtemnR
XXJd4e4oJNuf3ufTg6vZRTXu9QBOdbnbbSbPn2/uNvVYCozX2wv+/Vwqz97744K/OC6+/OJr0kLO
EHIcXvevmxDwlwOuOLebOex/yX4KiBju9aZTcwbAdcfg5fiT8aL6MFCHmc3ddDZvGMYd/3jbpmxj
EjZfaA3cTSnt8xCzcXZZIdUeXjQS//VHGYs/IiwewBtVVK+lKgxxDKZEC0sKvBFHgnSmXcOxEqRv
NWXvOOqPgjeSoKGRHtL/RDmUKaRXjWwBJ7wxjgLTLj7Rw40sEZ1W6Z5nA0Ft4+zyjV836+UiD2ys
FKh3nrfRnocAivwx+1UAZ3oKy3uApHgepsZjb6JgEvW2bXHqP4ZF47yXuG0EbTj2CA8DXIF/gzrk
k3Hw+ECljHa3zdTpXkRV2tMDNXq2iOrTx6jtNOLmkQcfd81IYRdzSJ8v1rhqNauUZwu20mQmRMrr
fCSkyLuoX/xIZsQcAPwhONPPvh0SwuQ1vrbIk0DzcQmffbapZdHneRyq6oYEZH174t4L36uvrWfT
Uy2AftAjXUAsV+j8BihtztDJn4cwoOIaBXcAKUzbkCvLF9n6bzBSUcyk1dda11Kzi9uVPAL60M6r
MABYBar/9cdBtoNby/nbRNVLXTbN8qAsbkcx2Amemhbjx9nL2MiniLpm2XYPIUFEuXzx0WNOhRHr
1q6W69kmd3EQNwUsXe6tq2EUU+/zqqYpVT2xdqjX+3Suh3NLATtldze0YShdld0OL3paZ57BfhMx
q7AMc2qy4pQYd70f+Q7pS1aG+FTsmcA3xPeqalIBUMYWaDdnFXtYvE2r4rHNXKkxtyu1XMD/LNRw
FZ4q0JP2HZAMAae8EPND96XskWQ/KPo0prhmtxxV/uLHVXbPRa0rN+q1aQlHKRyzPGEJ+nowlYyv
krFJ7udqZRo8acZPGjbbZPrRvsAilSkVeFpZFw9lLqwDYacfQ9hJ1Q8aNSn6EOsrMFwbYQsbQj2e
TjJX6SowJXeYGrdfZAZBJZ2VE+xj/AW0KZrEfj9386e1owwOtuNB/s7PExHw8jN73OsCfGzL759n
xuNZX9azJp13pSz/6eMm26Tr2KkE3V16DHMcxhAJZcypUZjZae/3akts54GGIRR2qXuRsbuvRU5w
3cTO5Eqg+3Q0OtiEKp5d9Q9YhR4klctHcc3L7KY5+NQtfgQq4jIjw039om9299aRMa4h93k01m7P
zLoJk86/nP2pZmCM6w3sxj7luNwub7PutOjgfnW1Wt+sxuF524l4azYv44M7yu1F1brbFB0h3dcO
awuuprAIC6FMVYmdyymIT6WWUXCj09J+WqydtCmL4GFOFHzdyXRnnZzz+3s2k2hFdJZFVLS4VmiO
D5ITlM1tXRrWRUsYjB7rU51BvTXMyUMqeO8+mZRm0M3OimVlODAT986G7Hk0cMURKzPeRerYLBb1
bq+AnMVivZ8vq2M0Chv9JQuI3JI3xEHRN53fPh83bJmEK1ZOSql0ZJenM0lpuPMJDS3pqx5hdmvc
EChcO4f9W33gMOQZ64VBTIuqOcM1sD8PuJMaH3X4r0Ch1Hsh9+mY+2PEhuuXS3beTyZSFygfg1FW
tQwWPWvEmZRhOVaIdiYVgPkt+gFHlpA3UmmMftpJQsY5PkrwM4s4DjUAmrBIA/ArIjwtiOZw+ja6
CbxGVoZWrhV6GpN9m194becq1e1luA9dKd8GB87briWM475ulrejzHkYsLJhoEIwJtGxNPEMzesM
RpUpeB3dynXl2QltstASrFDHdu3pw4YNvrRd103h7SilVkeJOaorRKeTeRORbDOeE8tdqSoy1XkA
MU9mkwkiap+dQ8EcE2Nl03pJKB4KTlJhne1daL6INGbJnKZ+Hu//7378/wHkwasO
"""
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):
return None
if fullname in self.sources:
return self
if fullname + '.__init__' in self.sources:
return self
return None
def load_module(self, fullname):
from types import ModuleType
try:
s = self.sources[fullname]
is_pkg = False
except KeyError:
s = self.sources[fullname + '.__init__']
is_pkg = True
co = compile(s, fullname, 'exec')
module = sys.modules.setdefault(fullname, ModuleType(fullname))
module.__file__ = "%s/%s" % (__file__, fullname)
module.__loader__ = self
if is_pkg:
module.__path__ = [fullname]
do_exec(co, module.__dict__)
return sys.modules[fullname]
def get_source(self, name):
res = self.sources.get(name)
if res is None:
res = self.sources.get(name + '.__init__')
return res
if __name__ == "__main__":
try:
import pkg_resources
except ImportError:
sys.stderr.write("ERROR: setuptools not installed\n")
sys.exit(2)
if sys.version_info >= (3, 0):
exec("def do_exec(co, loc): exec(co, loc)\n")
import pickle
sources = sources.encode("ascii")
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())
|
data/WatchPeopleCode/WatchPeopleCode/migrations/versions/14bb1343f5dc_.py
|
"""empty message
Revision ID: 14bb1343f5dc
Revises: 15119ab3dc68
Create Date: 2015-04-06 01:26:26.626951
"""
revision = '14bb1343f5dc'
down_revision = '15119ab3dc68'
from alembic import op
import sqlalchemy as sa
def upgrade():
op.create_table('chat_message',
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('sent_on', sa.DateTime(), nullable=True),
sa.Column('sender', sa.String(), nullable=True),
sa.Column('text', sa.String(), nullable=True),
sa.PrimaryKeyConstraint('id')
)
def downgrade():
op.drop_table('chat_message')
|
data/SmokinCaterpillar/pypet/examples/example_01_first_steps.py
|
__author__ = 'Robert Meyer'
import os
from pypet import Environment
from pypet.utils.explore import cartesian_product
def multiply(traj):
"""Example of a sophisticated simulation that involves multiplying two values.
:param traj:
Trajectory containing
the parameters in a particular combination,
it also serves as a container for results.
"""
z = traj.x * traj.y
traj.f_add_result('z', z, comment='Result of our simulation!')
filename = os.path.join('hdf5','example_01.hdf5')
env = Environment(trajectory='Multiplication',
filename=filename,
overwrite_file=True,
file_title='Example_01_First_Steps',
comment='The first example!',
large_overview_tables=True,
)
traj = env.trajectory
traj.f_add_parameter('x', 1, comment='I am the first dimension!')
traj.f_add_parameter('y', 1, comment='I am the second dimension!')
traj.f_explore(cartesian_product({'x':[1,2,3,4], 'y':[6,7,8]}))
env.run(multiply)
from pypet.trajectory import Trajectory
del traj
env.disable_logging()
del env
traj = Trajectory(filename=filename)
traj.f_load(index=-1, load_parameters=2, load_results=2)
print('The result of `run_00000001` is: ')
print(traj.run_00000001.z)
|
data/adobe/brackets-shell/gyp/pylib/gyp/__init__.py
|
import copy
import gyp.input
import optparse
import os.path
import re
import shlex
import sys
import traceback
from gyp.common import GypError
debug = {}
DEBUG_GENERAL = 'general'
DEBUG_VARIABLES = 'variables'
DEBUG_INCLUDES = 'includes'
def DebugOutput(mode, message):
if 'all' in gyp.debug.keys() or mode in gyp.debug.keys():
ctx = ('unknown', 0, 'unknown')
try:
f = traceback.extract_stack(limit=2)
if f:
ctx = f[0][:3]
except:
pass
print '%s:%s:%d:%s %s' % (mode.upper(), os.path.basename(ctx[0]),
ctx[1], ctx[2], message)
def FindBuildFiles():
extension = '.gyp'
files = os.listdir(os.getcwd())
build_files = []
for file in files:
if file.endswith(extension):
build_files.append(file)
return build_files
def Load(build_files, format, default_variables={},
includes=[], depth='.', params=None, check=False,
circular_check=True):
"""
Loads one or more specified build files.
default_variables and includes will be copied before use.
Returns the generator for the specified format and the
data returned by loading the specified build files.
"""
if params is None:
params = {}
flavor = None
if '-' in format:
format, params['flavor'] = format.split('-', 1)
default_variables = copy.copy(default_variables)
default_variables['GENERATOR'] = format
if format.endswith('.py'):
generator_name = os.path.splitext(format)[0]
path, generator_name = os.path.split(generator_name)
path = os.path.abspath(path)
if path not in sys.path:
sys.path.insert(0, path)
else:
generator_name = 'gyp.generator.' + format
generator = __import__(generator_name, globals(), locals(), generator_name)
for (key, val) in generator.generator_default_variables.items():
default_variables.setdefault(key, val)
if getattr(generator, 'CalculateVariables', None):
generator.CalculateVariables(default_variables, params)
if getattr(generator, 'CalculateGeneratorInputInfo', None):
generator.CalculateGeneratorInputInfo(params)
generator_input_info = {
'generator_wants_absolute_build_file_paths':
getattr(generator, 'generator_wants_absolute_build_file_paths', False),
'generator_handles_variants':
getattr(generator, 'generator_handles_variants', False),
'non_configuration_keys':
getattr(generator, 'generator_additional_non_configuration_keys', []),
'path_sections':
getattr(generator, 'generator_additional_path_sections', []),
'extra_sources_for_rules':
getattr(generator, 'generator_extra_sources_for_rules', []),
'generator_supports_multiple_toolsets':
getattr(generator, 'generator_supports_multiple_toolsets', False),
'generator_wants_static_library_dependencies_adjusted':
getattr(generator,
'generator_wants_static_library_dependencies_adjusted', True),
'generator_wants_sorted_dependencies':
getattr(generator, 'generator_wants_sorted_dependencies', False),
}
result = gyp.input.Load(build_files, default_variables, includes[:],
depth, generator_input_info, check, circular_check,
params['parallel'])
return [generator] + result
def NameValueListToDict(name_value_list):
"""
Takes an array of strings of the form 'NAME=VALUE' and creates a dictionary
of the pairs. If a string is simply NAME, then the value in the dictionary
is set to True. If VALUE can be converted to an integer, it is.
"""
result = { }
for item in name_value_list:
tokens = item.split('=', 1)
if len(tokens) == 2:
try:
token_value = int(tokens[1])
except ValueError:
token_value = tokens[1]
result[tokens[0]] = token_value
else:
result[tokens[0]] = True
return result
def ShlexEnv(env_name):
flags = os.environ.get(env_name, [])
if flags:
flags = shlex.split(flags)
return flags
def FormatOpt(opt, value):
if opt.startswith('--'):
return '%s=%s' % (opt, value)
return opt + value
def RegenerateAppendFlag(flag, values, predicate, env_name, options):
"""Regenerate a list of command line flags, for an option of action='append'.
The |env_name|, if given, is checked in the environment and used to generate
an initial list of options, then the options that were specified on the
command line (given in |values|) are appended. This matches the handling of
environment variables and command line flags where command line flags override
the environment, while not requiring the environment to be set when the flags
are used again.
"""
flags = []
if options.use_environment and env_name:
for flag_value in ShlexEnv(env_name):
value = FormatOpt(flag, predicate(flag_value))
if value in flags:
flags.remove(value)
flags.append(value)
if values:
for flag_value in values:
flags.append(FormatOpt(flag, predicate(flag_value)))
return flags
def RegenerateFlags(options):
"""Given a parsed options object, and taking the environment variables into
account, returns a list of flags that should regenerate an equivalent options
object (even in the absence of the environment variables.)
Any path options will be normalized relative to depth.
The format flag is not included, as it is assumed the calling generator will
set that as appropriate.
"""
def FixPath(path):
path = gyp.common.FixIfRelativePath(path, options.depth)
if not path:
return os.path.curdir
return path
def Noop(value):
return value
flags = ['--ignore-environment']
for name, metadata in options._regeneration_metadata.iteritems():
opt = metadata['opt']
value = getattr(options, name)
value_predicate = metadata['type'] == 'path' and FixPath or Noop
action = metadata['action']
env_name = metadata['env_name']
if action == 'append':
flags.extend(RegenerateAppendFlag(opt, value, value_predicate,
env_name, options))
elif action in ('store', None):
if value:
flags.append(FormatOpt(opt, value_predicate(value)))
elif options.use_environment and env_name and os.environ.get(env_name):
flags.append(FormatOpt(opt, value_predicate(os.environ.get(env_name))))
elif action in ('store_true', 'store_false'):
if ((action == 'store_true' and value) or
(action == 'store_false' and not value)):
flags.append(opt)
elif options.use_environment and env_name:
print >>sys.stderr, ('Warning: environment regeneration unimplemented '
'for %s flag %r env_name %r' % (action, opt,
env_name))
else:
print >>sys.stderr, ('Warning: regeneration unimplemented for action %r '
'flag %r' % (action, opt))
return flags
class RegeneratableOptionParser(optparse.OptionParser):
def __init__(self):
self.__regeneratable_options = {}
optparse.OptionParser.__init__(self)
def add_option(self, *args, **kw):
"""Add an option to the parser.
This accepts the same arguments as OptionParser.add_option, plus the
following:
regenerate: can be set to False to prevent this option from being included
in regeneration.
env_name: name of environment variable that additional values for this
option come from.
type: adds type='path', to tell the regenerator that the values of
this option need to be made relative to options.depth
"""
env_name = kw.pop('env_name', None)
if 'dest' in kw and kw.pop('regenerate', True):
dest = kw['dest']
type = kw.get('type')
if type == 'path':
kw['type'] = 'string'
self.__regeneratable_options[dest] = {
'action': kw.get('action'),
'type': type,
'env_name': env_name,
'opt': args[0],
}
optparse.OptionParser.add_option(self, *args, **kw)
def parse_args(self, *args):
values, args = optparse.OptionParser.parse_args(self, *args)
values._regeneration_metadata = self.__regeneratable_options
return values, args
def gyp_main(args):
my_name = os.path.basename(sys.argv[0])
parser = RegeneratableOptionParser()
usage = 'usage: %s [options ...] [build_file ...]'
parser.set_usage(usage.replace('%s', '%prog'))
parser.add_option('-D', dest='defines', action='append', metavar='VAR=VAL',
env_name='GYP_DEFINES',
help='sets variable VAR to value VAL')
parser.add_option('-f', '--format', dest='formats', action='append',
env_name='GYP_GENERATORS', regenerate=False,
help='output formats to generate')
parser.add_option('--msvs-version', dest='msvs_version',
regenerate=False,
help='Deprecated; use -G msvs_version=MSVS_VERSION instead')
parser.add_option('-I', '--include', dest='includes', action='append',
metavar='INCLUDE', type='path',
help='files to include in all loaded .gyp files')
parser.add_option('--depth', dest='depth', metavar='PATH', type='path',
help='set DEPTH gyp variable to a relative path to PATH')
parser.add_option('-d', '--debug', dest='debug', metavar='DEBUGMODE',
action='append', default=[], help='turn on a debugging '
'mode for debugging GYP. Supported modes are "variables", '
'"includes" and "general" or "all" for all of them.')
parser.add_option('-S', '--suffix', dest='suffix', default='',
help='suffix to add to generated files')
parser.add_option('-G', dest='generator_flags', action='append', default=[],
metavar='FLAG=VAL', env_name='GYP_GENERATOR_FLAGS',
help='sets generator flag FLAG to VAL')
parser.add_option('--generator-output', dest='generator_output',
action='store', default=None, metavar='DIR', type='path',
env_name='GYP_GENERATOR_OUTPUT',
help='puts generated build files under DIR')
parser.add_option('--ignore-environment', dest='use_environment',
action='store_false', default=True, regenerate=False,
help='do not read options from environment variables')
parser.add_option('--check', dest='check', action='store_true',
help='check format of gyp files')
parser.add_option('--parallel', action='store_true',
env_name='GYP_PARALLEL',
help='Use multiprocessing for speed (experimental)')
parser.add_option('--toplevel-dir', dest='toplevel_dir', action='store',
default=None, metavar='DIR', type='path',
help='directory to use as the root of the source tree')
parser.add_option('--build', dest='configs', action='append',
help='configuration for build after project generation')
parser.add_option('--no-circular-check', dest='circular_check',
action='store_false', default=True, regenerate=False,
help="don't check for circular relationships between files")
home_vars = ['HOME']
if sys.platform in ('cygwin', 'win32'):
home_vars.append('USERPROFILE')
home = None
home_dot_gyp = None
for home_var in home_vars:
home = os.getenv(home_var)
if home != None:
home_dot_gyp = os.path.join(home, '.gyp')
if not os.path.exists(home_dot_gyp):
home_dot_gyp = None
else:
break
options, build_files_arg = parser.parse_args(args)
build_files = build_files_arg
if not options.formats:
generate_formats = []
if options.use_environment:
generate_formats = os.environ.get('GYP_GENERATORS', [])
if generate_formats:
generate_formats = re.split('[\s,]', generate_formats)
if generate_formats:
options.formats = generate_formats
else:
if sys.platform == 'darwin':
options.formats = ['xcode']
elif sys.platform in ('win32', 'cygwin'):
options.formats = ['msvs']
else:
options.formats = ['make']
if not options.generator_output and options.use_environment:
g_o = os.environ.get('GYP_GENERATOR_OUTPUT')
if g_o:
options.generator_output = g_o
if not options.parallel and options.use_environment:
options.parallel = bool(os.environ.get('GYP_PARALLEL'))
for mode in options.debug:
gyp.debug[mode] = 1
if DEBUG_GENERAL in gyp.debug.keys():
DebugOutput(DEBUG_GENERAL, 'running with these options:')
for option, value in sorted(options.__dict__.items()):
if option[0] == '_':
continue
if isinstance(value, basestring):
DebugOutput(DEBUG_GENERAL, " %s: '%s'" % (option, value))
else:
DebugOutput(DEBUG_GENERAL, " %s: %s" % (option, str(value)))
if not build_files:
build_files = FindBuildFiles()
if not build_files:
raise GypError((usage + '\n\n%s: error: no build_file') %
(my_name, my_name))
if not options.depth:
for build_file in build_files:
build_file_dir = os.path.abspath(os.path.dirname(build_file))
build_file_dir_components = build_file_dir.split(os.path.sep)
components_len = len(build_file_dir_components)
for index in xrange(components_len - 1, -1, -1):
if build_file_dir_components[index] == 'src':
options.depth = os.path.sep.join(build_file_dir_components)
break
del build_file_dir_components[index]
if options.depth:
break
if not options.depth:
raise GypError('Could not automatically locate src directory. This is'
'a temporary Chromium feature that will be removed. Use'
'--depth as a workaround.')
if not options.toplevel_dir:
options.toplevel_dir = options.depth
cmdline_default_variables = {}
defines = []
if options.use_environment:
defines += ShlexEnv('GYP_DEFINES')
if options.defines:
defines += options.defines
cmdline_default_variables = NameValueListToDict(defines)
if DEBUG_GENERAL in gyp.debug.keys():
DebugOutput(DEBUG_GENERAL,
"cmdline_default_variables: %s" % cmdline_default_variables)
includes = []
if home_dot_gyp != None:
default_include = os.path.join(home_dot_gyp, 'include.gypi')
if os.path.exists(default_include):
print 'Using overrides found in ' + default_include
includes.append(default_include)
if options.includes:
includes.extend(options.includes)
gen_flags = []
if options.use_environment:
gen_flags += ShlexEnv('GYP_GENERATOR_FLAGS')
if options.generator_flags:
gen_flags += options.generator_flags
generator_flags = NameValueListToDict(gen_flags)
if DEBUG_GENERAL in gyp.debug.keys():
DebugOutput(DEBUG_GENERAL, "generator_flags: %s" % generator_flags)
if options.msvs_version:
print >>sys.stderr, \
'DEPRECATED: Use generator flag (-G msvs_version=' + \
options.msvs_version + ') instead of --msvs-version=' + \
options.msvs_version
generator_flags['msvs_version'] = options.msvs_version
for format in set(options.formats):
params = {'options': options,
'build_files': build_files,
'generator_flags': generator_flags,
'cwd': os.getcwd(),
'build_files_arg': build_files_arg,
'gyp_binary': sys.argv[0],
'home_dot_gyp': home_dot_gyp,
'parallel': options.parallel}
[generator, flat_list, targets, data] = Load(build_files, format,
cmdline_default_variables,
includes, options.depth,
params, options.check,
options.circular_check)
generator.GenerateOutput(flat_list, targets, data, params)
if options.configs:
valid_configs = targets[flat_list[0]]['configurations'].keys()
for conf in options.configs:
if conf not in valid_configs:
raise GypError('Invalid config specified via --build: %s' % conf)
generator.PerformBuild(data, options.configs, params)
return 0
def main(args):
try:
return gyp_main(args)
except GypError, e:
sys.stderr.write("gyp: %s\n" % e)
return 1
if __name__ == '__main__':
sys.exit(main(sys.argv[1:]))
|
data/SUSE/azurectl/azurectl/management/request_result.py
|
import time
from ..azurectl_exceptions import (
AzureRequestStatusError,
AzureRequestTimeout,
AzureRequestError
)
class RequestResult(object):
"""
operate on azure request ID and provide methods
to get status information as well as define operations
based on the request status
"""
def __init__(self, request_id):
self.request_id = request_id
self.request_timeout_count = 60
self.request_timeout = 5
def status(self, service):
"""
query status for given request id
"""
try:
return service.get_operation_status(self.request_id)
except Exception as e:
raise AzureRequestStatusError(
'%s: %s' % (type(e).__name__, format(e))
)
def wait_for_request_completion(self, service):
"""
poll on status, waiting for success until timeout
"""
count = 0
result = self.status(service)
while result.status == 'InProgress':
count = count + 1
if count > self.request_timeout_count:
raise AzureRequestTimeout(
'Operation %s timed out' % self.request_id
)
time.sleep(self.request_timeout)
result = self.status(service)
if result.status != 'Succeeded':
raise AzureRequestError(
'Operation %s failed. %s (%s)' % (
self.request_id,
format(result.error.message),
format(result.error.code)
)
)
|
data/agoragames/torus/test/functional/web_test.py
|
'''
Copyright (c) 2013, Agora Games, LLC All rights reserved.
https://github.com/agoragames/torus/blob/master/LICENSE.txt
'''
import time
import ujson
from chai import Chai
from torus.web import Web
from torus.configuration import Configuration
SCHEMAS = {
'redis-minutely' : {
'type' : 'histogram',
'host' : 'redis://localhost',
'match' : '.*',
'intervals' : {
'second' : {
'step' : 1,
'steps' : 60
},
'minute' : {
'step' : 60,
'steps' : 5,
}
}
},
'mongo-hourly': {
'type' : 'histogram',
'host' : 'mongodb://localhost',
'match' : '.*',
'intervals' : {
'minute' : {
'step' : 60,
'steps' : 5,
},
'hour' : {
'step' : '1h',
'steps' : 24,
},
}
}
}
AGGREGATES = (
('foo', 'foo.*'),
('foo', 'foo.*.*'),
('foo.<bar>', 'foo.<bar>.*')
)
config = Configuration()
for name,spec in SCHEMAS.iteritems():
config.load_schema( name, spec )
config.load_aggregate( AGGREGATES )
config._transforms['unique'] = lambda dct, duration: len(dct)
config._macros['redis_keylen'] = {
'fetch' : lambda handle, key: handle.hlen(key),
'condense' : lambda data: sum(data.values()),
'process_row' : lambda data: data,
'join_rows' : lambda rows: sum(rows),
'collapse' : True,
}
for schema in config._schemas:
schema.timeseries.delete( 'foo' )
schema.timeseries.delete( 'foo.bar' )
schema.timeseries.delete( 'foo.bor' )
schema.timeseries.delete( 'foo.bar.cat' )
schema.timeseries.delete( 'foo.bor.cat' )
schema.timeseries.delete( 'foo.bar.dog' )
t = time.time() - 7200
for x in xrange(0,7200,30):
config.process( 'foo.bar.cat', x/15, t+x )
config.process( 'foo.bor.cat', x/15, t+x )
config.process( 'foo.bar.dog', x/15, t+x )
web = Web(configuration=config)
class WebTest(Chai):
def setUp(self):
super(WebTest,self).setUp()
def _request(self, request):
'''
Helper to make a request and confirm that it can be encoded. Needed
until this test actually starts a webserver and queries it.
'''
result = web._series(request)
ujson.dumps( result, double_precision=4 )
return result
def test_series(self):
request = {
'stat' : ['count(foo)', 'count(foo.bar)', 'count(foo.bor)',
'count(foo.bar.dog)', 'count(foo.bor.cat)', 'min(foo)', 'max(foo)'],
}
result = self._request(request)
counts = {}
for row in result:
counts[ row['stat'] ] = row['datapoints'].values()[-1]
dog = counts['count(foo.bar.dog)']
assert_not_equals( 0, dog )
assert_equals( dog, counts['count(foo.bor.cat)'] )
assert_equals( dog, counts['count(foo.bor)'] )
assert_equals( 2*dog, counts['count(foo.bar)'] )
assert_equals( 3*dog, counts['count(foo)'] )
assert_not_equals( counts['count(foo)'], counts['max(foo)'] )
assert_not_equals( counts['max(foo)'], counts['min(foo)'] )
request = {
'stat' : ['foo'],
'interval' : ['second']
}
result = self._request(request)
assert_equals( 'redis-minutely', result[0]['schema'] )
request = {
'stat' : ['foo'],
'start' : ['yesterday']
}
result = self._request(request)
request = {
'stat' : ['foo'],
'start' : ['8675309']
}
result = self._request(request)
def test_series_with_stat_lists(self):
request = {
'stat' : ['count(foo.bar.cat,foo.bar.dog)', 'count(foo.bar.cat)', 'count(foo.bar.dog)'],
}
result = self._request(request)
counts = {}
for row in result:
counts[ row['stat'] ] = row['datapoints'].values()[-1]
assert_not_equals( 0, counts['count(foo.bar.cat,foo.bar.dog)'] )
assert_equals( counts['count(foo.bar.cat,foo.bar.dog)'],
counts['count(foo.bar.cat)'] + counts['count(foo.bar.dog)'] )
request = {
'stat' : [
'foo.bar.cat,foo.bar.dog', 'foo.bar.cat', 'foo.bar.dog',
'unique(foo.bar.cat,foo.bar.dog)', 'unique(foo.bar.cat)', 'unique(foo.bar.dog)'
],
'format' : ['json'],
'collapse' : ['true'],
}
result = self._request(request)
counts = {}
for row in result:
counts[ row['stat'] ] = row['datapoints'].values()[-1]
uniques = filter( lambda row: row['function']=='unique', result )
assert_equals( 3, len(uniques) )
assert_equals( 1, len(uniques[0]['datapoints']) )
assert_equals( 1, len(uniques[1]['datapoints']) )
assert_equals( 1, len(uniques[2]['datapoints']) )
assert_not_equals( 0, counts['foo.bar.cat,foo.bar.dog'][0] )
assert_equals( counts['foo.bar.cat,foo.bar.dog'][0],
counts['foo.bar.cat'][0] + counts['foo.bar.dog'][0] )
assert_equals( counts['unique(foo.bar.cat,foo.bar.dog)'], 240 )
assert_equals( counts['unique(foo.bar.cat,foo.bar.dog)'],
counts['unique(foo.bar.cat)'] )
assert_equals( counts['unique(foo.bar.cat,foo.bar.dog)'],
counts['unique(foo.bar.dog)'] )
def test_series_with_macros(self):
request = {
'stat' : ['redis_keylen(foo.bar.cat,foo.bar.dog)', 'redis_keylen(foo.bar.cat)', 'redis_keylen(foo.bar.dog)'],
'schema' : ['redis-minutely'],
}
result = self._request(request)
counts = {}
for row in result:
counts[ row['stat'] ] = row['datapoints'].values()[-1]
assert_not_equals( 0, counts['redis_keylen(foo.bar.cat,foo.bar.dog)'] )
assert_equals( counts['redis_keylen(foo.bar.cat,foo.bar.dog)'],
counts['redis_keylen(foo.bar.cat)'] + counts['redis_keylen(foo.bar.dog)'] )
|
data/Netflix/security_monkey/security_monkey/watchers/redshift.py
|
"""
.. module: security_monkey.watchers.redshift
:platform: Unix
.. version:: $$VERSION$$
.. moduleauthor:: Ivan Leichtling <ivanlei@yelp.com> @c0wl
"""
from security_monkey.watcher import Watcher
from security_monkey.watcher import ChangeItem
from security_monkey.constants import TROUBLE_REGIONS
from security_monkey.exceptions import BotoConnectionIssue
from security_monkey import app
from boto.redshift import regions
class Redshift(Watcher):
index = 'redshift'
i_am_singular = 'Redshift Cluster'
i_am_plural = 'Redshift Clusters'
def __init__(self, accounts=None, debug=False):
super(Redshift, self).__init__(accounts=accounts, debug=debug)
def slurp(self):
"""
:returns: item_list - list of Redshift Policies.
:returns: exception_map - A dict where the keys are a tuple containing the
location of the exception and the value is the actual exception
"""
self.prep_for_slurp()
from security_monkey.common.sts_connect import connect
item_list = []
exception_map = {}
for account in self.accounts:
for region in regions():
app.logger.debug("Checking {}/{}/{}".format(self.index, account, region.name))
try:
redshift = connect(account, 'redshift', region=region)
all_clusters = []
marker = None
while True:
response = self.wrap_aws_rate_limited_call(
redshift.describe_clusters,
marker=marker
)
all_clusters.extend(response['DescribeClustersResponse']['DescribeClustersResult']['Clusters'])
if response['DescribeClustersResponse']['DescribeClustersResult']['Marker'] is not None:
marker = response['DescribeClustersResponse']['DescribeClustersResult']['Marker']
else:
break
except Exception as e:
if region.name not in TROUBLE_REGIONS:
exc = BotoConnectionIssue(str(e), 'redshift', account, region.name)
self.slurp_exception((self.index, account, region.name), exc, exception_map)
continue
app.logger.debug("Found {} {}".format(len(all_clusters), Redshift.i_am_plural))
for cluster in all_clusters:
cluster_id = cluster['ClusterIdentifier']
if self.check_ignore_list(cluster_id):
continue
item = RedshiftCluster(region=region.name, account=account, name=cluster_id, config=dict(cluster))
item_list.append(item)
return item_list, exception_map
class RedshiftCluster(ChangeItem):
def __init__(self, region=None, account=None, name=None, config={}):
super(RedshiftCluster, self).__init__(
index=Redshift.index,
region=region,
account=account,
name=name,
new_config=config)
|
data/RoseOu/flasky/venv/lib/python2.7/site-packages/httpie/compat.py
|
"""
Python 2/3 compatibility.
"""
from requests.compat import (
is_windows,
bytes,
str,
is_py3,
is_py26,
)
try:
from urllib.parse import urlsplit
except ImportError:
from urlparse import urlsplit
|
data/PythonJS/PythonJS/regtests/bench/webworker_single.py
|
'''
webworker single
'''
from time import time
from time import sleep
import threading
def main():
if PYTHON=='PYTHONJS':
pythonjs.configure( direct_operator='+' )
pass
starttime = time()
n = 3000
seq = []
cache = []
w1 = threading.start_webworker( worker, (0, n, seq, cache) )
sleep(1.0)
testtime = time()-starttime
primes_per_sec = len(seq) * (1.0 / testtime)
print(primes_per_sec)
print('
print('-----main exit')
with webworker:
def worker(start, end, seq, cache):
print('------enter worker------')
for i in range(start, end):
if i in cache:
pass
else:
cache.append( i )
if is_prime(i):
seq.append( i )
print('
def is_prime(n):
hits = 0
for x in range(2, n):
for y in range(2, n):
if x*y == n:
hits += 1
if hits > 1:
return False
return True
|
data/Net-ng/kansha/kansha/card_addons/gallery/view.py
|
from nagare.i18n import _
from nagare import presentation, ajax, security, component
from .comp import Gallery, Asset, AssetCropper
def render_image(self, h, comp, size, randomize=False, **kw):
metadata = self.assets_manager.get_metadata(self.filename)
src = self.assets_manager.get_image_url(self.filename, size)
if randomize:
src += '?r=' + h.generate_id()
return h.img(title=metadata['filename'], alt=metadata['filename'],
src=src, **kw)
def render_file(self, h, comp, size, **kw):
kw['class'] += ' file_icon'
metadata = self.assets_manager.get_metadata(self.filename)
res = [h.img(title=metadata['filename'], alt=metadata['filename'],
src="img/file-icon.jpg", **kw)]
if size == 'medium':
res.append(h.span(metadata['filename']))
return res
CONTENT_TYPES = {'image/png': render_image,
'image/jpeg': render_image,
'image/pjpeg': render_image,
'image/gif': render_image}
@presentation.render_for(Gallery)
def render(self, h, comp, *args):
with h.div(id='gal' + self.comp_id):
with h.div(class_='nbItems'):
h << comp.render(h, model='badge')
with h.div(id="card-gallery"):
h << comp.render(h, self.model)
return h.root
@presentation.render_for(Gallery, 'view')
def render_Gallery_view(self, h, comp, model):
model = 'edit' if security.has_permissions('edit', self) else 'anonymous'
for asset in self.assets:
h << asset.render(h, model)
return h.root
@presentation.render_for(Gallery, 'crop')
def render_Gallery_crop(self, h, comp, model):
return self.cropper.on_answer(self.action)
@presentation.render_for(Gallery, 'cover')
def render_cover(self, h, comp, model):
cover = self.get_cover()
if cover:
h << h.p(component.Component(self.get_cover(), model='cover'), class_='cover')
return h.root
@presentation.render_for(Gallery, "action")
def render_download(self, h, comp, *args):
if security.has_permissions('edit', self):
submit_id = h.generate_id("attach_submit")
input_id = h.generate_id("attach_input")
h << h.label((h.i(class_='icon-file'),
_("Add file")), class_='btn', for_=input_id)
with h.form:
h << h.script(
u'''
function valueChanged(e) {
if (YAHOO.kansha.app.checkFileSize(this, %(max_size)s)) {
YAHOO.util.Dom.get(%(submit_id)s).click();
YAHOO.kansha.app.showModal('oip');
} else {
alert(%(error)s);
}
}
YAHOO.util.Event.onDOMReady(function() {
YAHOO.util.Event.on(%(input_id)s, 'change', valueChanged);
});''' %
{
'max_size': ajax.py2js(self.assets_manager.max_size),
'input_id': ajax.py2js(input_id),
'submit_id': ajax.py2js(submit_id),
'error': ajax.py2js(
_(u'Max file size exceeded')
).decode('UTF-8')
}
)
submit_action = ajax.Update(
render=lambda r: r.div(comp.render(r, model=None), r.script('YAHOO.kansha.app.closeModal()')),
component_to_update='gal' + self.comp_id,
)
h << h.input(id=input_id, class_='hidden', type="file", name="file", multiple="multiple", maxlength="100",).action(self.add_assets)
h << h.input(class_='hidden', id=submit_id, type="submit").action(submit_action)
return h.root
@presentation.render_for(Gallery, model='badge')
def render_gallery_badge(self, h, *args):
"""Gallery badge for the card"""
if self.assets:
with h.span(class_='badge'):
h << h.span(h.i(class_='icon-file'), ' ', len(self.assets), class_='label')
return h.root
@presentation.render_for(Asset)
@presentation.render_for(Asset, model='thumb')
@presentation.render_for(Asset, model='medium')
@presentation.render_for(Asset, model='cover')
def render_asset(self, h, comp, model, *args):
res = []
metadata = self.assets_manager.get_metadata(self.filename)
kw = {'randomize': True} if model == 'cover' else {}
kw['class'] = model
if self.is_cover:
res.append(h.span(class_='is_cover'))
meth = CONTENT_TYPES.get(metadata['content-type'], render_file)
res.append(meth(self, h, comp, model, **kw))
return res
@presentation.render_for(Asset, model='edit')
def render_Asset_thumb(self, h, comp, model, *args):
with h.div(class_='asset'):
action = h.a.action(lambda: comp.answer(('delete', self))).get('onclick')
onclick = _(u'Are you sure you want to delete this file?')
onclick = u'if (confirm("%s")) { %s }' % (onclick, action)
with h.a(class_='delete', title=_(u'Delete'), href='
h << h.i(class_='icon-cancel')
if self.is_image():
with h.a(class_='cover', title=_(u'Configure cover')).action(lambda: comp.answer(('configure_cover', self))):
if self.is_cover:
h << {'style': 'visibility: visible'}
h << h.i(class_='icon-checkmark')
with h.a(href=self.assets_manager.get_image_url(self.filename), target='_blank'):
h << comp.render(h, 'thumb')
return h.root
@presentation.render_for(Asset, model="anonymous")
def render_asset_anonymous(self, h, comp, model, *args):
with h.div(class_='asset'):
with h.a(href=self.assets_manager.get_image_url(self.filename), target='_blank'):
h << comp.render(h, model="thumb")
return h.root
@presentation.render_for(AssetCropper)
def render_gallery_cropper(self, h, comp, *args):
h << h.p(_('Use the controls below to create the cover of your card.'))
form_id = h.generate_id()
img_id = h.generate_id()
with h.form:
for crop_name in 'crop_left', 'crop_top', 'crop_width', 'crop_height':
h << h.input(type='hidden', id=form_id + '_' + crop_name).action(getattr(self, crop_name))
h << h.p(render_image(self.asset, h, comp, 'medium', id=img_id))
h << h.script(
"YAHOO.util.Event.onContentReady(%s,"
"function(){YAHOO.kansha.app.initCrop(%s, %s, %s, %s)})" % (
ajax.py2js(img_id),
ajax.py2js(img_id),
ajax.py2js(form_id),
ajax.py2js(self.crop_width()),
ajax.py2js(self.crop_height())
)
)
with h.div(class_='buttons'):
h << h.button(_('Create cover'), class_='btn btn-primary').action(self.commit, comp)
if self.asset.is_cover:
h << ' '
h << h.button(_('Remove cover'), class_='btn delete').action(self.remove_cover, comp)
h << ' '
h << h.button(_('Cancel'), class_='btn').action(self.cancel, comp)
return h.root
|
data/ImageEngine/gaffer/python/GafferSceneTest/SceneTimeWarpTest.py
|
import unittest
import IECore
import Gaffer
import GafferTest
import GafferScene
import GafferSceneTest
class SceneTimeWarpTest( GafferSceneTest.SceneTestCase ) :
def testConstruct( self ) :
s = Gaffer.ScriptNode()
s["n"] = GafferScene.SceneTimeWarp()
self.assertEqual( s["n"]["speed"].getValue(), 1 )
self.assertEqual( s["n"]["offset"].getValue(), 0 )
def testRunTimeTyped( self ) :
n = GafferScene.SceneTimeWarp()
self.failUnless( n.isInstanceOf( GafferScene.SceneTimeWarp.staticTypeId() ) )
self.failUnless( n.isInstanceOf( GafferScene.SceneContextProcessor.staticTypeId() ) )
self.failUnless( n.isInstanceOf( GafferScene.SceneProcessor.staticTypeId() ) )
self.failUnless( n.isInstanceOf( GafferScene.SceneNode.staticTypeId() ) )
self.failUnless( n.isInstanceOf( Gaffer.Node.staticTypeId() ) )
baseTypeIds = IECore.RunTimeTyped.baseTypeIds( n.typeId() )
self.failUnless( GafferScene.SceneContextProcessor.staticTypeId() in baseTypeIds )
self.failUnless( GafferScene.SceneProcessor.staticTypeId() in baseTypeIds )
self.failUnless( GafferScene.SceneNode.staticTypeId() in baseTypeIds )
self.failUnless( Gaffer.Node.staticTypeId() in baseTypeIds )
def testAffects( self ) :
n = GafferScene.SceneTimeWarp()
c = GafferTest.CapturingSlot( n.plugDirtiedSignal() )
n["speed"].setValue( 2 )
found = False
for cc in c :
if cc[0].isSame( n["out"] ) :
found = True
self.failUnless( found )
del c[:]
n["offset"].setValue( 2 )
found = False
for cc in c :
if cc[0].isSame( n["out"] ) :
found = True
self.failUnless( found )
def testNoExtraInputs( self ) :
p = GafferScene.Plane()
n = GafferScene.SceneTimeWarp()
n["in"].setInput( p["out"] )
self.assertTrue( "in1" not in n )
if __name__ == "__main__":
unittest.main()
|
data/ImageEngine/gaffer/python/GafferTest/SequencePathTest.py
|
import unittest
import IECore
import Gaffer
import GafferTest
class SequencePathTest( GafferTest.TestCase ) :
def __dictPath( self ) :
dict = {}
dict["dir"] = {}
for f in IECore.FileSequence( "a.
dict["dir"][f] = 1
for f in IECore.FileSequence( "b.
dict["dir"][f] = 1
return Gaffer.DictPath( dict, "/" )
def test( self ) :
path = Gaffer.SequencePath( self.__dictPath() )
self.failUnless( path.isValid() )
self.failUnless( not path.isLeaf() )
path.append( "dir" )
self.failUnless( path.isValid() )
self.failUnless( not path.isLeaf() )
path[0] = "oops!"
self.failIf( path.isValid() )
self.failIf( path.isLeaf() )
path[:] = [ "dir" ]
children = path.children()
for child in children :
self.failUnless( isinstance( child, Gaffer.SequencePath ) )
self.assertEqual( len( children ), 2 )
childrenStrings = [ str( c ) for c in children ]
self.failUnless( "/dir/a.
self.failUnless( "/dir/b.
def testNonLeafChildren( self ) :
path = Gaffer.SequencePath( self.__dictPath() )
children = path.children()
for child in children :
self.failUnless( isinstance( child, Gaffer.SequencePath ) )
self.assertEqual( len( children ), 1 )
self.assertEqual( str( children[0] ), "/dir" )
def testCopy( self ) :
path = Gaffer.SequencePath( self.__dictPath() )
path.append( "dir" )
path2 = path.copy()
self.failUnless( isinstance( path2, Gaffer.SequencePath ) )
self.assertEqual( path[:], path2[:] )
self.failUnless( path.getFilter() is path2.getFilter() )
c = [ str( p ) for p in path.children() ]
c2 = [ str( p ) for p in path2.children() ]
self.assertEqual( c, c2 )
def testInfo( self ) :
dictPath = self.__dictPath()
path = Gaffer.SequencePath( dictPath )
self.assertEqual( dictPath.info(), path.info() )
def testInfoOfInvalidPath( self ) :
fp = Gaffer.FileSystemPath( "/iSurelyDontExist" )
self.assertEqual( fp.isValid(), False )
self.assertEqual( fp.info(), None )
sp = Gaffer.SequencePath( fp )
self.assertEqual( sp.isValid(), False )
self.assertEqual( sp.info(), None )
def testFilter( self ) :
dictPath = self.__dictPath()
path = Gaffer.SequencePath( dictPath )
def testIsEmpty( self ) :
dictPath = self.__dictPath()
path = Gaffer.SequencePath( dictPath )
path.setFromString( "" )
self.assertTrue( path.isEmpty() )
path2 = path.copy()
self.assertTrue( path2.isEmpty() )
def testProperties( self ) :
dictPath = self.__dictPath()
path = Gaffer.SequencePath( dictPath )
self.assertEqual( dictPath.propertyNames(), path.propertyNames() )
self.assertEqual( dictPath.property( "dict:value" ), path.property( "dict:value" ) )
if __name__ == "__main__":
unittest.main()
|
data/Yelp/mrjob/mrjob/examples/mr_next_word_stats.py
|
"""For any word that appears in a document, compute stats about which
words come next (including percentage).
This is meant as a simple demonstration of why SORT_VALUES is useful.
"""
from mrjob.job import MRJob
from mrjob.step import MRStep
import re
WORD_RE = re.compile(r"[\w']+")
class MRNextWordStats(MRJob):
SORT_VALUES = True
def steps(self):
return [MRStep(mapper=self.m_find_words,
combiner=self.c_combine_counts,
reducer=self.r_sum_counts),
MRStep(reducer=self.r_compute_stats)]
def m_find_words(self, _, line):
"""Tokenize lines, and look for pairs of adjacent words.
Yield (prev_word, word), 1 and (prev_word, '*'), 1 for each pair
"""
prev_word = None
for word in WORD_RE.findall(line):
word = word.lower()
if prev_word is not None:
yield (prev_word, '*'), 1
yield (prev_word, word), 1
prev_word = word
def c_combine_counts(self, key, counts):
"""Sum up all those 1s before passing data off to the reducer"""
yield key, sum(counts)
def r_sum_counts(self, key, counts):
"""Compute the number of times each pair of words appears, and the
number of times the first word in a pair appears, and send it to
a reducer that keys on the first word in the pair.
"""
count = sum(counts)
prev_word, word = key
if word == '*':
yield prev_word, ('A: total', count)
else:
yield prev_word, ('B: stats', (word, count))
def r_compute_stats(self, prev_word, value):
"""For each pair of words, compute how many times it appears,
how many times the first word appears in a pair, and the percentage
of time the second word follows the first.
This relies on values appearing in sorted order; we need the total
number of times the first word appears before we can compute the
percentage for each second word.
"""
total = None
for value_type, data in value:
if value_type == 'A: total':
total = data
else:
assert value_type == 'B: stats'
word, count = data
percent = 100.0 * count / total
yield (prev_word, word), (total, count, percent)
if __name__ == '__main__':
MRNextWordStats.run()
|
data/PyHDI/veriloggen/examples/dataflow_example/test_dataflow_example.py
|
from __future__ import absolute_import
from __future__ import print_function
import dataflow_example
expected_verilog = """
module test;
reg CLK;
reg RST;
reg [32-1:0] xdata;
reg xvalid;
wire xready;
reg [32-1:0] ydata;
reg yvalid;
wire yready;
wire [32-1:0] zdata;
wire zvalid;
reg zready;
main
uut
(
.CLK(CLK),
.RST(RST),
.xdata(xdata),
.xvalid(xvalid),
.xready(xready),
.ydata(ydata),
.yvalid(yvalid),
.yready(yready),
.zdata(zdata),
.zvalid(zvalid),
.zready(zready)
);
reg reset_done;
initial begin
$dumpfile("uut.vcd");
$dumpvars(0, uut);
end
initial begin
CLK = 0;
forever begin
end
end
initial begin
RST = 0;
reset_done = 0;
xdata = 0;
xvalid = 0;
ydata = 0;
yvalid = 0;
zready = 0;
RST = 1;
RST = 0;
reset_done = 1;
@(posedge CLK);
$finish;
end
reg [32-1:0] xfsm;
localparam xfsm_init = 0;
reg [32-1:0] _tmp_0;
localparam xfsm_1 = 1;
localparam xfsm_2 = 2;
localparam xfsm_3 = 3;
localparam xfsm_4 = 4;
localparam xfsm_5 = 5;
localparam xfsm_6 = 6;
localparam xfsm_7 = 7;
localparam xfsm_8 = 8;
localparam xfsm_9 = 9;
localparam xfsm_10 = 10;
localparam xfsm_11 = 11;
localparam xfsm_12 = 12;
localparam xfsm_13 = 13;
localparam xfsm_14 = 14;
localparam xfsm_15 = 15;
localparam xfsm_16 = 16;
localparam xfsm_17 = 17;
localparam xfsm_18 = 18;
localparam xfsm_19 = 19;
localparam xfsm_20 = 20;
localparam xfsm_21 = 21;
localparam xfsm_22 = 22;
localparam xfsm_23 = 23;
localparam xfsm_24 = 24;
always @(posedge CLK) begin
if(RST) begin
xfsm <= xfsm_init;
_tmp_0 <= 0;
end else begin
case(xfsm)
xfsm_init: begin
xvalid <= 0;
if(reset_done) begin
xfsm <= xfsm_1;
end
end
xfsm_1: begin
xfsm <= xfsm_2;
end
xfsm_2: begin
xfsm <= xfsm_3;
end
xfsm_3: begin
xfsm <= xfsm_4;
end
xfsm_4: begin
xfsm <= xfsm_5;
end
xfsm_5: begin
xfsm <= xfsm_6;
end
xfsm_6: begin
xfsm <= xfsm_7;
end
xfsm_7: begin
xfsm <= xfsm_8;
end
xfsm_8: begin
xfsm <= xfsm_9;
end
xfsm_9: begin
xfsm <= xfsm_10;
end
xfsm_10: begin
xfsm <= xfsm_11;
end
xfsm_11: begin
xvalid <= 1;
xfsm <= xfsm_12;
end
xfsm_12: begin
if(xready) begin
xdata <= xdata + 1;
end
if(xready) begin
_tmp_0 <= _tmp_0 + 1;
end
if((_tmp_0 == 5) && xready) begin
xfsm <= xfsm_13;
end
end
xfsm_13: begin
xvalid <= 0;
xfsm <= xfsm_14;
end
xfsm_14: begin
xfsm <= xfsm_15;
end
xfsm_15: begin
xfsm <= xfsm_16;
end
xfsm_16: begin
xfsm <= xfsm_17;
end
xfsm_17: begin
xfsm <= xfsm_18;
end
xfsm_18: begin
xfsm <= xfsm_19;
end
xfsm_19: begin
xfsm <= xfsm_20;
end
xfsm_20: begin
xfsm <= xfsm_21;
end
xfsm_21: begin
xfsm <= xfsm_22;
end
xfsm_22: begin
xfsm <= xfsm_23;
end
xfsm_23: begin
xvalid <= 1;
if(xready) begin
xdata <= xdata + 1;
end
if(xready) begin
_tmp_0 <= _tmp_0 + 1;
end
if((_tmp_0 == 10) && xready) begin
xfsm <= xfsm_24;
end
end
xfsm_24: begin
xvalid <= 0;
end
endcase
end
end
reg [32-1:0] yfsm;
localparam yfsm_init = 0;
reg [32-1:0] _tmp_1;
localparam yfsm_1 = 1;
localparam yfsm_2 = 2;
localparam yfsm_3 = 3;
localparam yfsm_4 = 4;
localparam yfsm_5 = 5;
localparam yfsm_6 = 6;
localparam yfsm_7 = 7;
localparam yfsm_8 = 8;
localparam yfsm_9 = 9;
localparam yfsm_10 = 10;
localparam yfsm_11 = 11;
localparam yfsm_12 = 12;
localparam yfsm_13 = 13;
localparam yfsm_14 = 14;
localparam yfsm_15 = 15;
localparam yfsm_16 = 16;
localparam yfsm_17 = 17;
localparam yfsm_18 = 18;
localparam yfsm_19 = 19;
localparam yfsm_20 = 20;
localparam yfsm_21 = 21;
localparam yfsm_22 = 22;
localparam yfsm_23 = 23;
localparam yfsm_24 = 24;
localparam yfsm_25 = 25;
localparam yfsm_26 = 26;
localparam yfsm_27 = 27;
localparam yfsm_28 = 28;
localparam yfsm_29 = 29;
localparam yfsm_30 = 30;
localparam yfsm_31 = 31;
localparam yfsm_32 = 32;
localparam yfsm_33 = 33;
localparam yfsm_34 = 34;
localparam yfsm_35 = 35;
localparam yfsm_36 = 36;
localparam yfsm_37 = 37;
localparam yfsm_38 = 38;
localparam yfsm_39 = 39;
localparam yfsm_40 = 40;
localparam yfsm_41 = 41;
localparam yfsm_42 = 42;
localparam yfsm_43 = 43;
localparam yfsm_44 = 44;
always @(posedge CLK) begin
if(RST) begin
yfsm <= yfsm_init;
_tmp_1 <= 0;
end else begin
case(yfsm)
yfsm_init: begin
yvalid <= 0;
if(reset_done) begin
yfsm <= yfsm_1;
end
end
yfsm_1: begin
yfsm <= yfsm_2;
end
yfsm_2: begin
yfsm <= yfsm_3;
end
yfsm_3: begin
yfsm <= yfsm_4;
end
yfsm_4: begin
yfsm <= yfsm_5;
end
yfsm_5: begin
yfsm <= yfsm_6;
end
yfsm_6: begin
yfsm <= yfsm_7;
end
yfsm_7: begin
yfsm <= yfsm_8;
end
yfsm_8: begin
yfsm <= yfsm_9;
end
yfsm_9: begin
yfsm <= yfsm_10;
end
yfsm_10: begin
yfsm <= yfsm_11;
end
yfsm_11: begin
yfsm <= yfsm_12;
end
yfsm_12: begin
yfsm <= yfsm_13;
end
yfsm_13: begin
yfsm <= yfsm_14;
end
yfsm_14: begin
yfsm <= yfsm_15;
end
yfsm_15: begin
yfsm <= yfsm_16;
end
yfsm_16: begin
yfsm <= yfsm_17;
end
yfsm_17: begin
yfsm <= yfsm_18;
end
yfsm_18: begin
yfsm <= yfsm_19;
end
yfsm_19: begin
yfsm <= yfsm_20;
end
yfsm_20: begin
yfsm <= yfsm_21;
end
yfsm_21: begin
yvalid <= 1;
yfsm <= yfsm_22;
end
yfsm_22: begin
if(yready) begin
ydata <= ydata + 2;
end
if(yready) begin
_tmp_1 <= _tmp_1 + 1;
end
if((_tmp_1 == 5) && yready) begin
yfsm <= yfsm_23;
end
end
yfsm_23: begin
yvalid <= 0;
yfsm <= yfsm_24;
end
yfsm_24: begin
yfsm <= yfsm_25;
end
yfsm_25: begin
yfsm <= yfsm_26;
end
yfsm_26: begin
yfsm <= yfsm_27;
end
yfsm_27: begin
yfsm <= yfsm_28;
end
yfsm_28: begin
yfsm <= yfsm_29;
end
yfsm_29: begin
yfsm <= yfsm_30;
end
yfsm_30: begin
yfsm <= yfsm_31;
end
yfsm_31: begin
yfsm <= yfsm_32;
end
yfsm_32: begin
yfsm <= yfsm_33;
end
yfsm_33: begin
yfsm <= yfsm_34;
end
yfsm_34: begin
yfsm <= yfsm_35;
end
yfsm_35: begin
yfsm <= yfsm_36;
end
yfsm_36: begin
yfsm <= yfsm_37;
end
yfsm_37: begin
yfsm <= yfsm_38;
end
yfsm_38: begin
yfsm <= yfsm_39;
end
yfsm_39: begin
yfsm <= yfsm_40;
end
yfsm_40: begin
yfsm <= yfsm_41;
end
yfsm_41: begin
yfsm <= yfsm_42;
end
yfsm_42: begin
yfsm <= yfsm_43;
end
yfsm_43: begin
yvalid <= 1;
if(yready) begin
ydata <= ydata + 2;
end
if(yready) begin
_tmp_1 <= _tmp_1 + 1;
end
if((_tmp_1 == 10) && yready) begin
yfsm <= yfsm_44;
end
end
yfsm_44: begin
yvalid <= 0;
end
endcase
end
end
reg [32-1:0] zfsm;
localparam zfsm_init = 0;
localparam zfsm_1 = 1;
localparam zfsm_2 = 2;
localparam zfsm_3 = 3;
localparam zfsm_4 = 4;
localparam zfsm_5 = 5;
localparam zfsm_6 = 6;
localparam zfsm_7 = 7;
localparam zfsm_8 = 8;
always @(posedge CLK) begin
if(RST) begin
zfsm <= zfsm_init;
end else begin
case(zfsm)
zfsm_init: begin
zready <= 0;
if(reset_done) begin
zfsm <= zfsm_1;
end
end
zfsm_1: begin
zfsm <= zfsm_2;
end
zfsm_2: begin
if(zvalid) begin
zready <= 1;
end
if(zvalid) begin
zfsm <= zfsm_3;
end
end
zfsm_3: begin
zready <= 0;
zfsm <= zfsm_4;
end
zfsm_4: begin
zready <= 0;
zfsm <= zfsm_5;
end
zfsm_5: begin
zready <= 0;
zfsm <= zfsm_6;
end
zfsm_6: begin
zready <= 0;
zfsm <= zfsm_7;
end
zfsm_7: begin
zready <= 0;
zfsm <= zfsm_8;
end
zfsm_8: begin
zfsm <= zfsm_2;
end
endcase
end
end
always @(posedge CLK) begin
if(reset_done) begin
if(xvalid && xready) begin
$display("xdata=%d", xdata);
end
if(yvalid && yready) begin
$display("ydata=%d", ydata);
end
if(zvalid && zready) begin
$display("zdata=%d", zdata);
end
end
end
endmodule
module main
(
input CLK,
input RST,
input [32-1:0] xdata,
input xvalid,
output xready,
input [32-1:0] ydata,
input yvalid,
output yready,
output [32-1:0] zdata,
output zvalid,
input zready
);
reg [32-1:0] _tmp_data_0;
reg _tmp_valid_0;
wire _tmp_ready_0;
assign xready = (_tmp_ready_0 || !_tmp_valid_0) && (xvalid && yvalid);
assign yready = (_tmp_ready_0 || !_tmp_valid_0) && (xvalid && yvalid);
assign zdata = _tmp_data_0;
assign zvalid = _tmp_valid_0;
assign _tmp_ready_0 = zready;
always @(posedge CLK) begin
if(RST) begin
_tmp_data_0 <= 0;
_tmp_valid_0 <= 0;
end else begin
if((_tmp_ready_0 || !_tmp_valid_0) && (xready && yready) && (xvalid && yvalid)) begin
_tmp_data_0 <= xdata + ydata;
end
if(_tmp_valid_0 && _tmp_ready_0) begin
_tmp_valid_0 <= 0;
end
if((_tmp_ready_0 || !_tmp_valid_0) && (xready && yready)) begin
_tmp_valid_0 <= xvalid && yvalid;
end
end
end
endmodule
"""
def test():
test_module = dataflow_example.mkTest()
code = test_module.to_verilog()
from pyverilog.vparser.parser import VerilogParser
from pyverilog.ast_code_generator.codegen import ASTCodeGenerator
parser = VerilogParser()
expected_ast = parser.parse(expected_verilog)
codegen = ASTCodeGenerator()
expected_code = codegen.visit(expected_ast)
assert(expected_code == code)
|
data/IvanMalison/okcupyd/okcupyd/db/adapters.py
|
import logging
from okcupyd.db import model, txn, with_txn
log = logging.getLogger(__name__)
class UserAdapter(object):
def __init__(self, profile):
self.profile = profile
def build(self, session):
found = model.User.query_no_txn(session, model.User.handle ==
self.profile.username)
if found:
return found[0]
else:
return model.User(okc_id=self.profile.id,
handle=self.profile.username,
age=self.profile.age,
location=self.profile.location)
def get_no_txn(self, session):
return model.User.upsert_one_no_txn(session, self.build(session),
id_key='okc_id')
get = with_txn(get_no_txn)
class ThreadAdapter(object):
def __init__(self, thread):
self.thread = thread
def _get_thread(self, session):
initiator = UserAdapter(self.thread.initiator).get_no_txn(session)
respondent = UserAdapter(self.thread.respondent).get_no_txn(session)
message_thread = model.MessageThread(okc_id=self.thread.id,
initiator=initiator,
respondent=respondent)
return model.MessageThread.upsert_one_no_txn(session, message_thread,
id_key='okc_id')
def _add_messages(self, thread_model):
existing_message_ids = set([m.okc_id for m in thread_model.messages])
new_messages = [message for message in self.thread.messages
if message.id not in existing_message_ids]
new_message_models = []
for new_message in new_messages:
from_initiator = thread_model.initiator.handle.lower() == \
new_message.sender.username.lower()
sender, recipient = (thread_model.initiator,
thread_model.respondent) \
if from_initiator else \
(thread_model.respondent,
thread_model.initiator)
new_message_model = model.Message(okc_id=new_message.id,
text=new_message.content,
sender=sender,
recipient=recipient,
time_sent=new_message.time_sent)
new_message_models.append(new_message_model)
thread_model.messages.append(new_message_model)
return new_message_models
def add_messages(self):
with txn() as session:
thread_model = model.MessageThread.find_no_txn(session,
self.thread.id,
id_key='okc_id')
return self._add_messages(thread_model)
def get_thread(self):
with txn() as session:
thread_model = self._get_thread(session)
return thread_model, self._add_messages(thread_model)
|
data/Shopify/shopify_python_api/shopify/resources/shipping_zone.py
|
from ..base import ShopifyResource
class ShippingZone(ShopifyResource):
pass
|
data/VisTrails/VisTrails/contrib/titan/__init__.py
|
"""The Titan Informatics Toolkit is a collaborative effort between
Sandia National Laboratories and Kitware Inc. It represents a
significant expansion of the Visualization ToolKit (VTK) to support
the ingestion, processing, and display of informatics data. By
leveraging the VTK engine, Titan provides a flexible, component
based, pipeline architecture for the integration and deployment of
algorithms in the fields of intelligence, semantic graph and
information analysis.
https://www.kitware.com/InfovisWiki/"""
identifier = 'edu.utah.sci.vistrails.titan'
name = 'Titan'
version = '0.1.2'
def package_dependencies():
import core.packagemanager
manager = core.packagemanager.get_package_manager()
ret = []
ret.append('edu.utah.sci.vistrails.vtk')
ret.append('edu.utah.sci.vistrails.spreadsheet')
return ret
def package_requirements():
import core.requirements
if not core.requirements.python_module_exists('titan'):
raise core.requirements.MissingRequirement('titan')
if not core.requirements.python_module_exists('PyQt4'):
print 'PyQt4 is not available. There will be no interaction',
print 'between Titan and the spreadsheet.'
import titan
|
data/Havate/havate-openstack/proto-build/gui/horizon/Horizon_GUI/openstack_dashboard/openstack/common/rpc/zmq_receiver.py
|
import eventlet
eventlet.monkey_patch()
import contextlib
import sys
from oslo.config import cfg
from openstack_dashboard.openstack.common import log as logging
from openstack_dashboard.openstack.common import rpc
from openstack_dashboard.openstack.common.rpc import impl_zmq
CONF = cfg.CONF
CONF.register_opts(rpc.rpc_opts)
CONF.register_opts(impl_zmq.zmq_opts)
def main():
CONF(sys.argv[1:], project='oslo')
logging.setup("oslo")
with contextlib.closing(impl_zmq.ZmqProxy(CONF)) as reactor:
reactor.consume_in_thread()
reactor.wait()
|
data/Tivix/django-rest-auth/rest_auth/tests/test_api.py
|
from django.core.urlresolvers import reverse
from django.test import TestCase
from django.contrib.auth import get_user_model
from django.core import mail
from django.conf import settings
from django.test.utils import override_settings
from django.utils.encoding import force_text
from rest_framework import status
from .test_base import BaseAPITestCase
class APITestCase1(TestCase, BaseAPITestCase):
"""
Case
- user profile: defined
- custom registration: backend defined
"""
urls = 'tests.urls'
USERNAME = 'person'
PASS = 'person'
EMAIL = "person1@world.com"
NEW_PASS = 'new-test-pass'
REGISTRATION_VIEW = 'rest_auth.runtests.RegistrationView'
REGISTRATION_DATA = {
"username": USERNAME,
"password1": PASS,
"password2": PASS
}
REGISTRATION_DATA_WITH_EMAIL = REGISTRATION_DATA.copy()
REGISTRATION_DATA_WITH_EMAIL['email'] = EMAIL
BASIC_USER_DATA = {
'first_name': "John",
'last_name': 'Smith',
'email': EMAIL
}
USER_DATA = BASIC_USER_DATA.copy()
USER_DATA['newsletter_subscribe'] = True
def setUp(self):
self.init()
def _generate_uid_and_token(self, user):
result = {}
from django.utils.encoding import force_bytes
from django.contrib.auth.tokens import default_token_generator
from django.utils.http import urlsafe_base64_encode
result['uid'] = urlsafe_base64_encode(force_bytes(user.pk))
result['token'] = default_token_generator.make_token(user)
return result
def test_login(self):
payload = {
"username": self.USERNAME,
"password": self.PASS
}
self.post(self.login_url, data=payload, status_code=400)
self.post(self.password_change_url, status_code=403)
user = get_user_model().objects.create_user(self.USERNAME, '', self.PASS)
self.post(self.login_url, data=payload, status_code=200)
self.assertEqual('key' in self.response.json.keys(), True)
self.token = self.response.json['key']
self.post(self.password_change_url, status_code=400)
user.is_active = False
user.save()
self.post(self.login_url, data=payload, status_code=400)
payload = {
"username": self.USERNAME + '?',
"password": self.PASS
}
self.post(self.login_url, data=payload, status_code=400)
self.post(self.login_url, data={}, status_code=400)
@override_settings(REST_USE_JWT=True)
def test_login_jwt(self):
payload = {
"username": self.USERNAME,
"password": self.PASS
}
get_user_model().objects.create_user(self.USERNAME, '', self.PASS)
self.post(self.login_url, data=payload, status_code=200)
self.assertEqual('token' in self.response.json.keys(), True)
self.token = self.response.json['token']
def test_login_by_email(self):
settings.INSTALLED_APPS.remove('allauth')
payload = {
"email": self.EMAIL.lower(),
"password": self.PASS
}
self.post(self.login_url, data=payload, status_code=400)
self.post(self.password_change_url, status_code=403)
user = get_user_model().objects.create_user(self.USERNAME, self.EMAIL, self.PASS)
self.post(self.login_url, data=payload, status_code=200)
self.assertEqual('key' in self.response.json.keys(), True)
self.token = self.response.json['key']
payload = {
"email": self.EMAIL.upper(),
"password": self.PASS
}
self.post(self.login_url, data=payload, status_code=200)
self.assertEqual('key' in self.response.json.keys(), True)
self.token = self.response.json['key']
user.is_active = False
user.save()
self.post(self.login_url, data=payload, status_code=400)
payload = {
"email": 't' + self.EMAIL,
"password": self.PASS
}
self.post(self.login_url, data=payload, status_code=400)
self.post(self.login_url, data={}, status_code=400)
def test_password_change(self):
login_payload = {
"username": self.USERNAME,
"password": self.PASS
}
get_user_model().objects.create_user(self.USERNAME, '', self.PASS)
self.post(self.login_url, data=login_payload, status_code=200)
self.token = self.response.json['key']
new_password_payload = {
"new_password1": "new_person",
"new_password2": "new_person"
}
self.post(
self.password_change_url,
data=new_password_payload,
status_code=200
)
self.post(self.login_url, data=login_payload, status_code=400)
login_payload['password'] = new_password_payload['new_password1']
self.post(self.login_url, data=login_payload, status_code=200)
new_password_payload = {
"new_password1": "new_person1",
"new_password2": "new_person"
}
self.post(
self.password_change_url,
data=new_password_payload,
status_code=400
)
self.post(self.password_change_url, data={}, status_code=400)
@override_settings(OLD_PASSWORD_FIELD_ENABLED=True)
def test_password_change_with_old_password(self):
login_payload = {
"username": self.USERNAME,
"password": self.PASS
}
get_user_model().objects.create_user(self.USERNAME, '', self.PASS)
self.post(self.login_url, data=login_payload, status_code=200)
self.token = self.response.json['key']
new_password_payload = {
"old_password": "%s!" % self.PASS,
"new_password1": "new_person",
"new_password2": "new_person"
}
self.post(
self.password_change_url,
data=new_password_payload,
status_code=400
)
new_password_payload = {
"old_password": self.PASS,
"new_password1": "new_person",
"new_password2": "new_person"
}
self.post(
self.password_change_url,
data=new_password_payload,
status_code=200
)
self.post(self.login_url, data=login_payload, status_code=400)
login_payload['password'] = new_password_payload['new_password1']
self.post(self.login_url, data=login_payload, status_code=200)
def test_password_reset(self):
user = get_user_model().objects.create_user(self.USERNAME, self.EMAIL, self.PASS)
mail_count = len(mail.outbox)
payload = {'email': self.EMAIL}
self.post(self.password_reset_url, data=payload, status_code=200)
self.assertEqual(len(mail.outbox), mail_count + 1)
url_kwargs = self._generate_uid_and_token(user)
url = reverse('rest_password_reset_confirm')
data = {
'new_password1': self.NEW_PASS,
'new_password2': self.NEW_PASS,
'uid': force_text(url_kwargs['uid']),
'token': '-wrong-token-'
}
self.post(url, data=data, status_code=400)
data = {
'new_password1': self.NEW_PASS,
'new_password2': self.NEW_PASS,
'uid': '-wrong-uid-',
'token': url_kwargs['token']
}
self.post(url, data=data, status_code=400)
data = {
'new_password1': self.NEW_PASS,
'new_password2': self.NEW_PASS,
'uid': '-wrong-uid-',
'token': '-wrong-token-'
}
self.post(url, data=data, status_code=400)
data = {
'new_password1': self.NEW_PASS,
'new_password2': self.NEW_PASS,
'uid': force_text(url_kwargs['uid']),
'token': url_kwargs['token']
}
url = reverse('rest_password_reset_confirm')
self.post(url, data=data, status_code=200)
payload = {
"username": self.USERNAME,
"password": self.NEW_PASS
}
self.post(self.login_url, data=payload, status_code=200)
def test_password_reset_with_email_in_different_case(self):
get_user_model().objects.create_user(self.USERNAME, self.EMAIL.lower(), self.PASS)
mail_count = len(mail.outbox)
payload = {'email': self.EMAIL.upper()}
self.post(self.password_reset_url, data=payload, status_code=200)
self.assertEqual(len(mail.outbox), mail_count + 1)
def test_password_reset_with_invalid_email(self):
"""
Invalid email should not raise error, as this would leak users
"""
get_user_model().objects.create_user(self.USERNAME, self.EMAIL, self.PASS)
mail_count = len(mail.outbox)
payload = {'email': 'nonexisting@email.com'}
self.post(self.password_reset_url, data=payload, status_code=200)
self.assertEqual(len(mail.outbox), mail_count)
def test_user_details(self):
user = get_user_model().objects.create_user(self.USERNAME, self.EMAIL, self.PASS)
payload = {
"username": self.USERNAME,
"password": self.PASS
}
self.post(self.login_url, data=payload, status_code=200)
self.token = self.response.json['key']
self.get(self.user_url, status_code=200)
self.patch(self.user_url, data=self.BASIC_USER_DATA, status_code=200)
user = get_user_model().objects.get(pk=user.pk)
self.assertEqual(user.first_name, self.response.json['first_name'])
self.assertEqual(user.last_name, self.response.json['last_name'])
self.assertEqual(user.email, self.response.json['email'])
@override_settings(REST_USE_JWT=True)
def test_user_details_using_jwt(self):
user = get_user_model().objects.create_user(self.USERNAME, self.EMAIL, self.PASS)
payload = {
"username": self.USERNAME,
"password": self.PASS
}
self.post(self.login_url, data=payload, status_code=200)
self.token = self.response.json['token']
self.get(self.user_url, status_code=200)
self.patch(self.user_url, data=self.BASIC_USER_DATA, status_code=200)
user = get_user_model().objects.get(pk=user.pk)
self.assertEqual(user.email, self.response.json['email'])
def test_registration(self):
user_count = get_user_model().objects.all().count()
self.post(self.register_url, data={}, status_code=400)
result = self.post(self.register_url, data=self.REGISTRATION_DATA, status_code=201)
self.assertIn('key', result.data)
self.assertEqual(get_user_model().objects.all().count(), user_count + 1)
new_user = get_user_model().objects.latest('id')
self.assertEqual(new_user.username, self.REGISTRATION_DATA['username'])
self._login()
self._logout()
@override_settings(REST_USE_JWT=True)
def test_registration_with_jwt(self):
user_count = get_user_model().objects.all().count()
self.post(self.register_url, data={}, status_code=400)
result = self.post(self.register_url, data=self.REGISTRATION_DATA, status_code=201)
self.assertIn('token', result.data)
self.assertEqual(get_user_model().objects.all().count(), user_count + 1)
self._login()
self._logout()
def test_registration_with_invalid_password(self):
data = self.REGISTRATION_DATA.copy()
data['password2'] = 'foobar'
self.post(self.register_url, data=data, status_code=400)
@override_settings(
ACCOUNT_EMAIL_VERIFICATION='mandatory',
ACCOUNT_EMAIL_REQUIRED=True
)
def test_registration_with_email_verification(self):
user_count = get_user_model().objects.all().count()
mail_count = len(mail.outbox)
self.post(
self.register_url,
data={},
status_code=status.HTTP_400_BAD_REQUEST
)
result = self.post(
self.register_url,
data=self.REGISTRATION_DATA_WITH_EMAIL,
status_code=status.HTTP_201_CREATED
)
self.assertNotIn('key', result.data)
self.assertEqual(get_user_model().objects.all().count(), user_count + 1)
self.assertEqual(len(mail.outbox), mail_count + 1)
new_user = get_user_model().objects.latest('id')
self.assertEqual(new_user.username, self.REGISTRATION_DATA['username'])
payload = {
"username": self.USERNAME,
"password": self.PASS
}
self.post(
self.login_url,
data=payload,
status=status.HTTP_400_BAD_REQUEST
)
email_confirmation = new_user.emailaddress_set.get(email=self.EMAIL)\
.emailconfirmation_set.order_by('-created')[0]
self.post(
self.veirfy_email_url,
data={"key": email_confirmation.key},
status_code=status.HTTP_200_OK
)
self._login()
self._logout()
@override_settings(ACCOUNT_LOGOUT_ON_GET=True)
def test_logout_on_get(self):
payload = {
"username": self.USERNAME,
"password": self.PASS
}
get_user_model().objects.create_user(self.USERNAME, '', self.PASS)
self.post(self.login_url, data=payload, status_code=200)
self.get(self.logout_url, status=status.HTTP_200_OK)
@override_settings(ACCOUNT_LOGOUT_ON_GET=False)
def test_logout_on_post_only(self):
payload = {
"username": self.USERNAME,
"password": self.PASS
}
get_user_model().objects.create_user(self.USERNAME, '', self.PASS)
self.post(self.login_url, data=payload, status_code=status.HTTP_200_OK)
self.get(self.logout_url, status_code=status.HTTP_405_METHOD_NOT_ALLOWED)
|
data/HenryHu/pybbs/digest.py
|
import re
import os
import stat
import json
import struct
import time
import Config
import Board
import Post
import BoardManager
from Util import Util
from Log import Log
from errors import *
DEFAULT_DIGEST_LIST_COUNT = 20
class DigestItem:
def __init__(self, basepath):
self.basepath = basepath
self.title = ''
self.host = ''
self.port = 0
self.attachpos = 0
self.fname = ''
self.mtitle = ''
self.items = []
self.update_time = 0
self.id = 0
self.sysop_only = 0
self.bms_only = 0
self.zixia_only = 0
def IsDir(self):
try:
st = os.stat(self.realpath())
return stat.S_ISDIR(st.st_mode)
except:
return False
def IsFile(self):
try:
st = os.stat(self.realpath())
return stat.S_ISREG(st.st_mode)
except:
return False
def GetModTime(self):
try:
st = os.stat(self.realpath())
mtime = st.st_mtime
except:
mtime = time.time()
return mtime
def names_path(self):
return "%s/.Names" % self.realpath()
def realpath(self):
return "%s/%s" % (Config.BBS_ROOT, self.path())
def path(self):
if (self.fname):
return "%s/%s" % (self.basepath, self.fname)
else:
return self.basepath
def CheckUpdate(self):
try:
stat = os.stat(self.names_path())
if (stat.st_mtime > self.update_time):
self.LoadNames()
except:
return False
return True
def LoadNames(self):
try:
f = open(self.names_path(), "r")
except IOError:
return 0
stat = os.fstat(f.fileno())
self.update_time = stat.st_mtime
item = DigestItem(self.path())
hostname = ''
_id = 0
bms_only = 0
sysop_only = 0
zixia_only = 0
while (True):
line = f.readline()
if (line == ""): break
npos = line.find("\n")
if (npos != -1): line = line[:npos]
if (line[:1] == '
if (line[:8] == "
if (not self.mtitle):
self.mtitle = line[8:]
result = re.match('([^=]*)=(.*)', line)
if (result):
key = result.group(1)
value = result.group(2)
if (key == "Name"):
item.title = value
item.attachpos = 0
elif (key == "Path"):
if (value[:2] == "~/"):
item.fname = value[2:]
else:
item.fname = value
if (item.fname.find("..") != -1):
continue
if (item.title.find("(BM: BMS)") != -1):
bms_only += 1
elif (item.title.find("(BM: SYSOPS)") != -1):
sysop_only += 1
elif (item.title.find("(BM: ZIXIAs)") != -1):
zixia_only += 1
if (item.fname.find("!@
parts = re.split('[!@
newparts = []
for part in parts:
if (part):
newparts += [part]
hostname = newparts[0]
item.fname = newparts[1]
try:
item.port = int(newparts[2])
except:
item.port = 0
item.id = _id
_id += 1
item.bms_only = bms_only
item.sysop_only = sysop_only
item.zixia_only = zixia_only
item.host = hostname
self.items += [item]
item = DigestItem(self.path())
hostname = ''
elif (key == "Host"):
hostname = value
elif (key == "Port"):
try:
item.port = int(value)
except:
item.port = 0
elif (key == "Attach"):
try:
item.attachpos = int(value)
except:
item.attachpos = 0
f.close()
return 1
def GetItem(self, user, route, has_perm = False, need_perm = False):
self.CheckUpdate()
if (self.mtitle.find("(BM:") != -1):
if (Board.Board.IsBM(user, self.mtitle[4:],) or user.IsSysop()):
has_perm = True
elif (need_perm and not has_perm):
return None
if (self.mtitle.find("(BM: BMS)") != -1
or self.mtitle.find("(BM: SECRET)") != -1
or self.mtitle.find("(BM: SYSOPS)") != -1):
need_perm = True
if (len(route) == 0):
return self
target = route[0] - 1
_id = target
if (_id >= len(self.items)):
return None
while (self.items[_id].EffectiveId(user) < target):
_id += 1
if (_id >= len(self.items)):
return None
item = self.items[_id]
item.mtitle = item.title
if (len(route) == 1):
return item
else:
if (item.IsDir()):
if (not item.CheckUpdate()):
return None
return item.GetItem(user, route[1:], has_perm, need_perm)
else:
return None
def GetRange(self, user, route, start, end, has_perm = False, need_perm = False):
self.CheckUpdate()
firstitem = self.GetItem(user, route + [start], has_perm, need_perm)
if (not firstitem):
return []
parent = self.GetItem(user, route, has_perm, need_perm)
if (not parent):
return []
if (not parent.IsDir()):
return []
result = []
_id = start - 1
for i in range(start, end + 1):
target = i - 1
if (_id >= len(parent.items)):
return []
while (parent.items[_id].EffectiveId(user) < target):
_id += 1
if (_id >= len(parent.items)):
return result
item = parent.items[_id]
item.mtitle = item.title
result += [item]
return result
def EffectiveId(self, user):
_id = self.id
if (user.IsSysop()):
return _id
if (not user.IsSysop()):
_id -= self.sysop_only
if (not user.IsBM()):
_id -= self.bms_only
if (not user.IsSECANC()):
_id -= self.zixia_only
return _id
def GetInfo(self):
info = {}
info['mtitle'] = Util.gbkDec(self.mtitle)
info['title'] = Util.gbkDec(self.title)
info['attach'] = self.attachpos
if (self.host != ''):
info['host'] = self.host
info['port'] = self.port
info['type'] = 'link'
elif (self.IsDir()):
info['type'] = 'dir'
elif (self.IsFile()):
info['type'] = 'file'
else:
info['type'] = 'other'
info['mtime'] = int(self.GetModTime())
return info
def GetInfoForUser(self, user):
info = self.GetInfo()
info['id'] = self.EffectiveId(user) + 1
return info
def GetAttachLink(self, session):
_hash = Util.HashGen(self.path(), "python nb")
filename = ''
for i in range(2):
filename += "%0x" % struct.unpack('=I', _hash[i*4:(i+1)*4])
link = "http://%s/bbscon.php?b=xattach&f=%s" % (session.GetMirror(Config.Config.GetInt('ATTACHMENT_PORT', 80)), filename)
linkfile = "%s/boards/xattach/%s" % (Config.BBS_ROOT, filename)
target = "../../%s" % self.path()
try:
os.symlink(target, linkfile)
except:
pass
return link
class Digest:
root = DigestItem("0Announce")
def __init__(self, board, path):
self.board = board
self.path = path
self.root = DigestItem(self.path)
@staticmethod
def GET(svc, session, params, action):
if (session is None): raise Unauthorized('login first')
if not session.CheckScope('bbs'): raise NoPerm("out of scope")
user = session.GetUser()
boardname = svc.get_str(params, 'board', '')
if (boardname):
board = BoardManager.BoardManager.GetBoard(boardname)
if (board is None): raise NotFound('board %s not found' % boardname)
if (not board.CheckReadPerm(user)):
raise NoPerm('permission denied')
basenode = board.digest.root
has_perm = user.IsDigestMgr() or user.IsSysop() or user.IsSuperBM()
else:
basenode = Digest.root
has_perm = user.IsDigestMgr()
if (action == "list"):
route = svc.get_str(params, 'route')
start = svc.get_int(params, 'start', 1)
end = svc.get_int(params, 'end', start + DEFAULT_DIGEST_LIST_COUNT - 1)
Digest.List(svc, basenode, route, start, end, session, has_perm)
return
elif (action == "view"):
route = svc.get_str(params, 'route')
start = svc.get_int(params, 'start', 0)
count = svc.get_int(params, 'count', 0)
Digest.View(svc, basenode, route, session, has_perm, start, count)
return
else:
raise WrongArgs('unknown action %s' % action)
@staticmethod
def ParseRoute(route):
ret = []
items = re.split('-', route)
items = items[1:]
for item in items:
try:
ret += [int(item)]
except:
raise WrongArgs('fail to parse route element: %s' % item)
return ret
@staticmethod
def List(svc, basenode, route, start, end, session, has_perm):
route_array = Digest.ParseRoute(route)
parent = basenode.GetItem(session.GetUser(), route_array, has_perm)
if (not parent):
raise WrongArgs('route %s does not exist!' % route)
if (not parent.IsDir()):
raise WrongArgs('route %s does not point to a dir!' % route)
items = basenode.GetRange(session.GetUser(), route_array, start, end, has_perm)
result = {}
result['parent'] = parent.GetInfoForUser(session.GetUser())
result['count'] = len(items)
result_list = []
for item in items:
result_list += [item.GetInfoForUser(session.GetUser())]
result['items'] = result_list
svc.writedata(json.dumps(result))
@staticmethod
def View(svc, basenode, route, session, has_perm, start, count):
route_array = Digest.ParseRoute(route)
item = basenode.GetItem(session.GetUser(), route_array, has_perm)
if (not item):
raise WrongArgs('route %s does not exist!' % route)
if (not item.IsFile()):
raise WrongArgs('route %s does not point to a file' % route)
result = {}
result['item'] = item.GetInfoForUser(session.GetUser())
postinfo = Post.Post(item.realpath(), None)
(result['content'], result['has_end']) = postinfo.GetContent(start, count)
attachlist = postinfo.GetAttachListByType()
result['picattach'] = attachlist[0]
result['otherattach'] = attachlist[1]
if (attachlist[0] or attachlist[1]):
result['attachlink'] = item.GetAttachLink(session)
svc.writedata(json.dumps(result))
|
data/adamchainz/django-mysql/tests/testapp/test_monkey_patches.py
|
from django.db import connections
from django.test import TestCase
class IsMariaDBTests(TestCase):
def test_connections(self):
for alias in connections:
connection = connections[alias]
if not hasattr(connection, 'mysql_version'):
continue
with connection.cursor() as cursor:
cursor.execute("SELECT VERSION()")
version = cursor.fetchone()[0]
is_mariadb = ('MariaDB' in version)
assert connection.is_mariadb == is_mariadb
assert 'is_mariadb' in connection.__dict__
|
data/Simont3/hcpsdk/src/setup.py
|
from setuptools import setup, find_packages
from codecs import open
from os import path
from hcpsdk.version import _Version
here = path.abspath(path.dirname(__file__))
with open(path.normpath(path.join(here, 'DESCRIPTION.rst')),encoding='utf-8') as f:
long_description = f.read()
setup(
name='hcpsdk',
version=str(_Version()),
description='An SDK for the Hitachi Content Platform (HCP)',
long_description=long_description,
url='http://simont3.github.io/hcpsdk',
author='Thorsten Simons',
author_email='sw@snomis.de',
license='MIT',
classifiers=[
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'Topic :: Software Development :: Libraries :: Python Modules',
'Topic :: Internet :: WWW/HTTP :: Session',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python :: 3.4',
'Operating System :: OS Independent',
'Natural Language :: English',
],
keywords='hcp sdk Hitachi Content Platform',
packages=find_packages(exclude=[]),
install_requires = ['dnspython3==1.12.0'],
)
|
data/ImageEngine/gaffer/python/GafferImageUI/DisplayUI.py
|
import threading
import IECore
import Gaffer
import GafferUI
import GafferImage
__all__ = []
Gaffer.Metadata.registerNode(
GafferImage.Display,
"description",
"""
Interactively displays images as they are rendered.
This node runs a server on a background thread,
allowing it to receive images from both local and
remote render processes. To set up a render to
output to the Display node, use an Outputs node with
an Interactive output configured to render to the
same port as is specified on the Display node.
""",
plugs = {
"port" : [
"description",
"""
The port number on which to run the display server.
Outputs which specify this port number will appear
in this node - use multiple nodes with different
port numbers to receive multiple images at once.
""",
],
}
)
__plugsPendingUpdate = []
__plugsPendingUpdateLock = threading.Lock()
def __scheduleUpdate( plug, force = False ) :
if not force :
global __plugsPendingUpdate
global __plugsPendingUpdateLock
with __plugsPendingUpdateLock :
for p in __plugsPendingUpdate :
if plug.isSame( p ) :
return
__plugsPendingUpdate.append( plug )
GafferUI.EventLoop.executeOnUIThread( lambda : __update( plug ) )
def __update( plug ) :
node = plug.node()
if node:
updateCountPlug = node["__updateCount"]
updateCountPlug.setValue( updateCountPlug.getValue() + 1 )
global __plugsPendingUpdate
global __plugsPendingUpdateLock
with __plugsPendingUpdateLock :
__plugsPendingUpdate = [ p for p in __plugsPendingUpdate if not p.isSame( plug ) ]
__displayDataReceivedConnection = GafferImage.Display.dataReceivedSignal().connect( __scheduleUpdate )
__displayImageReceivedConnection = GafferImage.Display.imageReceivedSignal().connect( IECore.curry( __scheduleUpdate, force = True ) )
|
data/RoseOu/flasky/venv/lib/python2.7/site-packages/pip/_vendor/html5lib/treewalkers/_base.py
|
from __future__ import absolute_import, division, unicode_literals
from pip._vendor.six import text_type
import gettext
_ = gettext.gettext
from ..constants import voidElements, spaceCharacters
spaceCharacters = "".join(spaceCharacters)
class TreeWalker(object):
def __init__(self, tree):
self.tree = tree
def __iter__(self):
raise NotImplementedError
def error(self, msg):
return {"type": "SerializeError", "data": msg}
def emptyTag(self, namespace, name, attrs, hasChildren=False):
assert namespace is None or isinstance(namespace, text_type), type(namespace)
assert isinstance(name, text_type), type(name)
assert all((namespace is None or isinstance(namespace, text_type)) and
isinstance(name, text_type) and
isinstance(value, text_type)
for (namespace, name), value in attrs.items())
yield {"type": "EmptyTag", "name": name,
"namespace": namespace,
"data": attrs}
if hasChildren:
yield self.error(_("Void element has children"))
def startTag(self, namespace, name, attrs):
assert namespace is None or isinstance(namespace, text_type), type(namespace)
assert isinstance(name, text_type), type(name)
assert all((namespace is None or isinstance(namespace, text_type)) and
isinstance(name, text_type) and
isinstance(value, text_type)
for (namespace, name), value in attrs.items())
return {"type": "StartTag",
"name": name,
"namespace": namespace,
"data": attrs}
def endTag(self, namespace, name):
assert namespace is None or isinstance(namespace, text_type), type(namespace)
assert isinstance(name, text_type), type(namespace)
return {"type": "EndTag",
"name": name,
"namespace": namespace,
"data": {}}
def text(self, data):
assert isinstance(data, text_type), type(data)
data = data
middle = data.lstrip(spaceCharacters)
left = data[:len(data) - len(middle)]
if left:
yield {"type": "SpaceCharacters", "data": left}
data = middle
middle = data.rstrip(spaceCharacters)
right = data[len(middle):]
if middle:
yield {"type": "Characters", "data": middle}
if right:
yield {"type": "SpaceCharacters", "data": right}
def comment(self, data):
assert isinstance(data, text_type), type(data)
return {"type": "Comment", "data": data}
def doctype(self, name, publicId=None, systemId=None, correct=True):
assert name is None or isinstance(name, text_type), type(name)
assert publicId is None or isinstance(publicId, text_type), type(publicId)
assert systemId is None or isinstance(systemId, text_type), type(systemId)
return {"type": "Doctype",
"name": name if name is not None else "",
"publicId": publicId,
"systemId": systemId,
"correct": correct}
def entity(self, name):
assert isinstance(name, text_type), type(name)
return {"type": "Entity", "name": name}
def unknown(self, nodeType):
return self.error(_("Unknown node type: ") + nodeType)
class RecursiveTreeWalker(TreeWalker):
def walkChildren(self, node):
raise NotImplementedError
def element(self, node, namespace, name, attrs, hasChildren):
if name in voidElements:
for token in self.emptyTag(namespace, name, attrs, hasChildren):
yield token
else:
yield self.startTag(name, attrs)
if hasChildren:
for token in self.walkChildren(node):
yield token
yield self.endTag(name)
from xml.dom import Node
DOCUMENT = Node.DOCUMENT_NODE
DOCTYPE = Node.DOCUMENT_TYPE_NODE
TEXT = Node.TEXT_NODE
ELEMENT = Node.ELEMENT_NODE
COMMENT = Node.COMMENT_NODE
ENTITY = Node.ENTITY_NODE
UNKNOWN = "<
class NonRecursiveTreeWalker(TreeWalker):
def getNodeDetails(self, node):
raise NotImplementedError
def getFirstChild(self, node):
raise NotImplementedError
def getNextSibling(self, node):
raise NotImplementedError
def getParentNode(self, node):
raise NotImplementedError
def __iter__(self):
currentNode = self.tree
while currentNode is not None:
details = self.getNodeDetails(currentNode)
type, details = details[0], details[1:]
hasChildren = False
if type == DOCTYPE:
yield self.doctype(*details)
elif type == TEXT:
for token in self.text(*details):
yield token
elif type == ELEMENT:
namespace, name, attributes, hasChildren = details
if name in voidElements:
for token in self.emptyTag(namespace, name, attributes,
hasChildren):
yield token
hasChildren = False
else:
yield self.startTag(namespace, name, attributes)
elif type == COMMENT:
yield self.comment(details[0])
elif type == ENTITY:
yield self.entity(details[0])
elif type == DOCUMENT:
hasChildren = True
else:
yield self.unknown(details[0])
if hasChildren:
firstChild = self.getFirstChild(currentNode)
else:
firstChild = None
if firstChild is not None:
currentNode = firstChild
else:
while currentNode is not None:
details = self.getNodeDetails(currentNode)
type, details = details[0], details[1:]
if type == ELEMENT:
namespace, name, attributes, hasChildren = details
if name not in voidElements:
yield self.endTag(namespace, name)
if self.tree is currentNode:
currentNode = None
break
nextSibling = self.getNextSibling(currentNode)
if nextSibling is not None:
currentNode = nextSibling
break
else:
currentNode = self.getParentNode(currentNode)
|
data/ODM2/ODMToolsPython/tests/test_odmdata/test_session_factory.py
|
from odmtools.odmdata import SessionFactory
class TestSessionFactory:
def setup(self):
self.connection_string = "sqlite:///:memory:"
self.session_factory = SessionFactory(self.connection_string, echo=True)
def test_create_session_factory(self):
assert repr(self.session_factory) == "<SessionFactory('Engine(%s)')>" % self.connection_string
assert self.session_factory.Session != None
def test_get_session(self):
session = self.session_factory.get_session()
assert 'sqlalchemy.orm.session.Session' in repr(session)
|
data/JeremyGrosser/supervisor/src/supervisor/medusa/demo/publish.py
|
from supervisor.medusa import asyncore_25 as asyncore
from supervisor.medusa import default_handler
from supervisor.medusa import http_server
from supervisor.medusa import put_handler
from supervisor.medusa import auth_handler
from supervisor.medusa import filesys
users = { 'mozart' : 'jupiter', 'beethoven' : 'pastoral' }
fs = filesys.os_filesystem('/home/medusa')
dh = default_handler.default_handler(fs)
ph = put_handler.put_handler(fs, '/.*')
ah = auth_handler.auth_handler(users, ph)
hs = http_server.http_server(ip='', port=8080)
hs.install_handler(dh)
hs.install_handler(ah)
asyncore.loop()
|
data/Yelp/paasta/tests/monitoring/test_replication_utils.py
|
import os
import mock
import requests
from paasta_tools.monitoring.replication_utils import backend_is_up
from paasta_tools.monitoring.replication_utils import get_registered_marathon_tasks
from paasta_tools.monitoring.replication_utils import get_replication_for_services
from paasta_tools.monitoring.replication_utils import ip_port_hostname_from_svname
from paasta_tools.monitoring.replication_utils import match_backends_and_tasks
from paasta_tools.utils import DEFAULT_SYNAPSE_HAPROXY_URL_FORMAT
def test_get_replication_for_service():
testdir = os.path.dirname(os.path.realpath(__file__))
testdata = os.path.join(testdir, 'haproxy_snapshot.txt')
with open(testdata, 'r') as fd:
mock_haproxy_data = fd.read()
mock_response = mock.Mock()
mock_response.text = mock_haproxy_data
mock_get = mock.Mock(return_value=(mock_response))
with mock.patch.object(requests.Session, 'get', mock_get):
replication_result = get_replication_for_services(
'fake_host',
6666,
DEFAULT_SYNAPSE_HAPROXY_URL_FORMAT,
['service1', 'service2', 'service3', 'service4']
)
expected = {
'service1': 18,
'service2': 19,
'service3': 0,
'service4': 3
}
assert expected == replication_result
def test_get_registered_marathon_tasks():
backends = [
{"pxname": "servicename.main", "svname": "10.50.2.4:31000_box4", "status": "UP"},
{"pxname": "servicename.main", "svname": "10.50.2.5:31001_box5", "status": "UP"},
{"pxname": "servicename.main", "svname": "10.50.2.6:31001_box6", "status": "UP"},
{"pxname": "servicename.main", "svname": "10.50.2.6:31002_box7", "status": "UP"},
{"pxname": "servicename.main", "svname": "10.50.2.8:31000_box8", "status": "UP"},
]
hostnames = {
'box4': '10.50.2.4',
'box5': '10.50.2.5',
'box6': '10.50.2.6',
'box7': '10.50.2.7',
'box8': '10.50.2.8',
}
good_task1 = mock.Mock(host='box4', ports=[31000])
good_task2 = mock.Mock(host='box5', ports=[31001])
bad_task = mock.Mock(host='box7', ports=[31000])
marathon_tasks = [
good_task1,
good_task2,
bad_task,
]
with mock.patch(
'paasta_tools.monitoring.replication_utils.get_multiple_backends',
return_value=backends
) as mock_get_multiple_backends:
with mock.patch(
'paasta_tools.monitoring.replication_utils.'
'socket.gethostbyname',
side_effect=lambda x: hostnames[x],
):
actual = get_registered_marathon_tasks(
'fake_host',
6666,
DEFAULT_SYNAPSE_HAPROXY_URL_FORMAT,
'servicename.main',
marathon_tasks,
)
expected = [good_task1, good_task2]
assert actual == expected
mock_get_multiple_backends.assert_called_once_with(
['servicename.main'],
synapse_host='fake_host',
synapse_port=6666,
synapse_haproxy_url_format=DEFAULT_SYNAPSE_HAPROXY_URL_FORMAT,
)
def test_backend_is_up():
assert True is backend_is_up({"status": "UP"})
assert True is backend_is_up({"status": "UP 1/2"})
assert False is backend_is_up({"status": "DOWN"})
assert False is backend_is_up({"status": "DOWN 1/2"})
assert False is backend_is_up({"status": "MAINT"})
def test_ip_port_hostname_from_svname():
assert ("1.2.3.4", 5, "six") == ip_port_hostname_from_svname("1.2.3.4:5_six")
def test_match_backends_and_tasks():
backends = [
{"pxname": "servicename.main", "svname": "10.50.2.4:31000_box4", "status": "UP"},
{"pxname": "servicename.main", "svname": "10.50.2.5:31001_box5", "status": "UP"},
{"pxname": "servicename.main", "svname": "10.50.2.6:31001_box6", "status": "UP"},
{"pxname": "servicename.main", "svname": "10.50.2.6:31002_box7", "status": "UP"},
{"pxname": "servicename.main", "svname": "10.50.2.8:31000_box8", "status": "UP"},
]
hostnames = {
'box4': '10.50.2.4',
'box5': '10.50.2.5',
'box6': '10.50.2.6',
'box7': '10.50.2.7',
'box8': '10.50.2.8',
}
good_task1 = mock.Mock(host='box4', ports=[31000])
good_task2 = mock.Mock(host='box5', ports=[31001])
bad_task = mock.Mock(host='box7', ports=[31000])
tasks = [good_task1, good_task2, bad_task]
with mock.patch(
'paasta_tools.monitoring.replication_utils.'
'socket.gethostbyname',
side_effect=lambda x: hostnames[x],
):
expected = [
(backends[0], good_task1),
(backends[1], good_task2),
(None, bad_task),
(backends[2], None),
(backends[3], None),
(backends[4], None),
]
actual = match_backends_and_tasks(backends, tasks)
assert sorted(actual) == sorted(expected)
|
data/adaptivdesign/django-sellmo/sellmo/contrib/checkout/mailing/internal/models.py
|
from django.db import models
from django.utils.translation import ugettext_lazy as _
from sellmo.core.loading import load
import sellmo.contrib.checkout.mailing as _checkout_mailing
@load(action='finalize_checkout_OrderMailMessage')
def finalize_model():
class OrderMailMessage(_checkout_mailing.models.OrderMailMessage):
objects = (
_checkout_mailing.models.OrderMailMessageManager.from_queryset(
_checkout_mailing.models.OrderMailMessageQuerySet
)
)()
class Meta(_checkout_mailing.models.OrderMailMessage.Meta):
app_label = 'checkout'
_checkout_mailing.models.OrderMailMessage = OrderMailMessage
class OrderMailMessageQuerySet(models.QuerySet):
pass
class OrderMailMessageManager(models.Manager):
pass
class OrderMailMessage(models.Model):
order = models.ForeignKey('checkout.Order')
mail_message = models.ForeignKey('mailing.MailMessage')
def __unicode__(self):
return unicode(self.mail_message)
class Meta:
abstract = True
verbose_name = _("order mail message")
verbose_name_plural = _("order mail messages")
|
data/ImageEngine/gaffer/python/GafferArnoldUITest/DocumentationTest.py
|
import GafferUITest
import GafferScene
import GafferSceneUI
import GafferArnold
import GafferArnoldUI
class DocumentationTest( GafferUITest.TestCase ) :
def test( self ) :
self.maxDiff = None
self.assertNodesAreDocumented(
GafferArnold,
additionalTerminalPlugTypes = ( GafferScene.ScenePlug, )
)
if __name__ == "__main__":
unittest.main()
|
data/aerospike/aerospike-client-python/examples/client/append.py
|
from __future__ import print_function
import aerospike
import sys
from optparse import OptionParser
usage = "usage: %prog [options] key"
optparser = OptionParser(usage=usage, add_help_option=False)
optparser.add_option(
"--help", dest="help", action="store_true",
help="Displays this message.")
optparser.add_option(
"-U", "--username", dest="username", type="string", metavar="<USERNAME>",
help="Username to connect to database.")
optparser.add_option(
"-P", "--password", dest="password", type="string", metavar="<PASSWORD>",
help="Password to connect to database.")
optparser.add_option(
"-h", "--host", dest="host", type="string", default="127.0.0.1", metavar="<ADDRESS>",
help="Address of Aerospike server.")
optparser.add_option(
"-p", "--port", dest="port", type="int", default=3000, metavar="<PORT>",
help="Port of the Aerospike server.")
optparser.add_option(
"-n", "--namespace", dest="namespace", type="string", default="test", metavar="<NS>",
help="Port of the Aerospike server.")
optparser.add_option(
"-s", "--set", dest="set", type="string", default="demo", metavar="<SET>",
help="Port of the Aerospike server.")
optparser.add_option(
"--gen", dest="gen", type="int", default=10, metavar="<GEN>",
help="Generation of the record being written.")
optparser.add_option(
"--ttl", dest="ttl", type="int", default=1000, metavar="<TTL>",
help="TTL of the record being written.")
(options, args) = optparser.parse_args()
if options.help:
optparser.print_help()
print()
sys.exit(1)
if len(args) != 1:
optparser.print_help()
print()
sys.exit(1)
config = {
'hosts': [(options.host, options.port)]
}
exitCode = 0
try:
client = aerospike.client(config).connect(
options.username, options.password)
try:
namespace = options.namespace if options.namespace and options.namespace != 'None' else None
set = options.set if options.set and options.set != 'None' else None
key = args.pop()
record = {
'example_name': 'John',
'example_age': 1
}
meta = {}
if (options.gen):
meta['gen'] = options.gen
if (options.ttl):
meta['ttl'] = options.ttl
policy = None
client.put((namespace, set, key), record, meta, policy)
print(record)
print("---")
print("OK, 1 record written.")
client.append(
(namespace, set, key), "example_name", " Smith", meta, policy)
(key, meta, bins) = client.get((namespace, set, key))
print(bins)
print("---")
print("OK, 1 record appended.")
except Exception as e:
print("error: {0}".format(e), file=sys.stderr)
exitCode = 2
client.close()
except Exception as eargs:
print("error: {0}".format(eargs), file=sys.stderr)
exitCode = 3
sys.exit(exitCode)
|
data/Keeper-Security/Commander/keepercommander/plugins/adpasswd/adpasswd.py
|
from ldap3 import Server, Connection, ALL
"""Commander Plugin for Active Directory
Dependencies:
pip3 install ldap3
"""
def rotate(record, newpassword):
result = False
host = record.get('cmdr:host')
user_dn = record.get('cmdr:userdn')
try:
server = Server(
host=host,
use_ssl=True,
get_info=ALL)
conn = Connection(
server=server,
user=user_dn,
password=record.password,
auto_bind=True)
changePwdResult = conn.extend.microsoft.modify_password(user_dn, newpassword)
if (changePwdResult == True):
print('Password changed successfully')
record.password = newpassword
result = True
else:
print("Server returned this message: %s" % (changePwdResult))
conn.unbind()
except:
print("Error during connection to AD server")
return result
|
data/JustinSGray/Hyperloop/src/hyperloop/test/test_tube_temp.py
|
import unittest
from openmdao.main.api import set_as_top, Assembly
from openmdao.util.testutil import assert_rel_error
from openmdao.lib.drivers.api import BroydenSolver
from hyperloop.tube_wall_temp import TubeWallTemp
class TubeHeatBalance(Assembly):
def configure(self):
tm = self.add('tm', TubeWallTemp())
driver = self.add('driver',BroydenSolver())
driver.add_parameter('tm.temp_boundary',low=0.,high=10000.)
driver.add_constraint('tm.ss_temp_residual=0')
driver.workflow.add(['tm'])
class TubeWallTestCase(unittest.TestCase):
def test_tube_temp(self):
test = set_as_top(TubeHeatBalance())
test.tm.nozzle_air.setTotalTP(1710, 0.304434211)
test.tm.nozzle_air.W = 1.08
test.tm.bearing_air.W = 0.
test.tm.diameter_outer_tube = 2.22504
test.tm.length_tube = 482803.
test.tm.num_pods = 34.
test.tm.temp_boundary = 322.361
test.tm.temp_outside_ambient = 305.6
test.run()
assert_rel_error(self,test.tm.heat_rate_pod, 353244., 0.02)
assert_rel_error(self,test.tm.total_heat_rate_pods,12010290., 0.02)
assert_rel_error(self,test.tm.GrDelTL3,123775609, 0.02)
assert_rel_error(self,test.tm.Pr,0.707, 0.02)
assert_rel_error(self,test.tm.Gr,23163846280., 0.02)
assert_rel_error(self,test.tm.Ra,16369476896., 0.02)
assert_rel_error(self,test.tm.Nu,281.6714, 0.02)
assert_rel_error(self,test.tm.k,0.02655, 0.02)
assert_rel_error(self,test.tm.h,3.3611, 0.02)
assert_rel_error(self,test.tm.area_convection,3374876, 0.02)
assert_rel_error(self,test.tm.q_per_area_nat_conv,57.10, 0.02)
assert_rel_error(self,test.tm.total_q_nat_conv,192710349, 0.02)
assert_rel_error(self,test.tm.area_viewing,1074256., 0.02)
assert_rel_error(self,test.tm.q_per_area_solar,350., 0.02)
assert_rel_error(self,test.tm.q_total_solar,375989751., 0.02)
assert_rel_error(self,test.tm.area_rad,3374876.115, 0.02)
assert_rel_error(self,test.tm.q_rad_per_area,59.7, 0.02)
assert_rel_error(self,test.tm.q_rad_tot,201533208, 0.02)
assert_rel_error(self,test.tm.q_total_out,394673364., 0.02)
if __name__ == "__main__":
unittest.main()
|
data/SawdustSoftware/disredis/disredis/disredis_client/client.py
|
"""
Distributed Redis Client
The DisredisClient class can be used in place of a StrictRedis client. Instead
of passing the host and port in, pass in a list of Sentinel addresses in
the form of "host:port". It will connect to the first responding Sentinel
and query it for masters that it knows about. These masters will become the
nodes that are sharded across. As long as the number of masters does not
change, the sharding will be stable even if there is a node failure.
Node failures are handled by asking the Sentinel for the updated master of
the given node. During the initial failure, some request may error out
with a ConnectionError if they are made between when the node fails and
when Sentinel executes the fail-over procedure.
"""
import logging
from hashlib import sha1
from functools import wraps
from redis.client import StrictRedis
from redis.exceptions import ConnectionError
class Node(object):
"""
Represents a single master node in the Redis cluster.
"""
redis_client_class = StrictRedis
def __init__(self, name, host, port):
self.name = name
self.host = host
self.port = port
logger = logging.getLogger('console')
logger.info("Connecting to Redis master %s - %s:%s" % (name, host, port))
self.connection = self.redis_client_class(host, int(port))
def executeOnNode(func):
"""
Decorator that will cause the function to be executed on the proper
redis node. In the case of a Connection failure, it will attempt to find
a new master node and perform the action there.
"""
@wraps(func)
def wrapper(self, key, *args, **kwargs):
node = self.get_node_for_key(key)
nodeFunc = getattr(node.connection, func.__name__)
try:
return nodeFunc(key, *args, **kwargs)
except ConnectionError:
node = self.get_master(node)
nodeFunc = getattr(node.connection, func.__name__)
return nodeFunc(key, *args, **kwargs)
return wrapper
class DisredisClient(object):
"""
StrictRedis-compatible client object for a cluster of redis servers. The
constructor takes a list of Sentinel addresses in the form of "host:port".
Redis master nodes will be obtained from the Sentinels.
"""
redis_client_class = StrictRedis
sentinel = None
nodes = None
def __init__(self, sentinel_addresses):
self.sentinel_addresses = sentinel_addresses
self._get_nodes()
def _connect(self):
"""
Connect to a sentinel, accounting for sentinels that fail.
"""
while True:
try:
address = self.sentinel_addresses.pop(0)
logger = logging.getLogger('custommade_logging')
logger.info("Connecting to Sentinel %s" % address)
host, port = address.split(":")
self.sentinel = self.redis_client_class(host, int(port))
self.sentinel_addresses.append(address)
break
except ConnectionError:
if not self.sentinel_addresses:
raise
except IndexError:
raise ConnectionError("Out of available Sentinel addresses!")
def _execute_sentinel_command(self, *args, **kwargs):
"""
Run a command on a sentinel, but fail over to the next sentinel in the
list if there's a connection problem.
"""
while True:
try:
if self.sentinel is None:
self._connect()
return self.sentinel.execute_command("SENTINEL", *args,
**kwargs)
except ConnectionError:
self.sentinel = None
if self.sentinel_addresses:
self.sentinel_addresses.pop()
else:
raise
def _get_nodes(self):
"""
Retrieve the list of nodes and their masters from the Sentinel server.
"""
masterList = self._execute_sentinel_command("MASTERS")
self.nodes = []
for master in masterList:
info = dict(zip(master[::2], master[1::2]))
self.nodes.append(Node(info["name"], info["ip"], info["port"]))
def get_master(self, node):
"""
Returns the current master for a node. If it's different from the
passed in node, update our node list accordingly.
"""
host, port = self._execute_sentinel_command("get-master-addr-by-name",
node.name)
if host == node.host and port == node.port:
return node
newNode = Node(node.name, host, port)
self.nodes[self.nodes.index(node)] = newNode
return newNode
def get_node_for_key(self, key):
"""
Returns a node for the given key. Keys with {} in them will be sharded
based on only the string between the brackets. This is for future
compatibility with Redis Cluster (and is also a nice feature to have).
"""
if "{" in key and "}" in key:
key = key[key.index("{") + 1: key.index("}")]
return self.nodes[int(sha1(key).hexdigest(), 16) % len(self.nodes)]
def set_response_callback(self, command, callback):
"Set a custom Response Callback"
raise NotImplementedError("Not supported for disredis.")
def pipeline(self, transaction=True, shard_hint=None):
"""
Return a new pipeline object that can queue multiple commands for
later execution. ``transaction`` indicates whether all commands
should be executed atomically. Apart from making a group of operations
atomic, pipelines are useful for reducing the back-and-forth overhead
between the client and server.
"""
raise NotImplementedError("Not supported for disredis.")
def transaction(self, func, *watches, **kwargs):
"""
Convenience method for executing the callable `func` as a transaction
while watching all keys specified in `watches`. The 'func' callable
should expect a single arguement which is a Pipeline object.
"""
raise NotImplementedError("Not supported for disredis.")
@executeOnNode
def lock(self, name, timeout=None, sleep=0.1):
"""
Return a new Lock object using key ``name`` that mimics
the behavior of threading.Lock.
If specified, ``timeout`` indicates a maximum life for the lock.
By default, it will remain locked until release() is called.
``sleep`` indicates the amount of time to sleep per loop iteration
when the lock is in blocking mode and another client is currently
holding the lock.
"""
@executeOnNode
def pubsub(self, shard_hint=None):
"""
Return a Publish/Subscribe object. With this object, you can
subscribe to channels and listen for messages that get published to
them.
"""
def bgrewriteaof(self):
"Tell the Redis server to rewrite the AOF file from data in memory."
raise NotImplementedError("Not supported for disredis.")
def bgsave(self):
"""
Tell the Redis server to save its data to disk. Unlike save(),
this method is asynchronous and returns immediately.
"""
raise NotImplementedError("Not supported for disredis.")
def client_kill(self, address):
"Disconnects the client at ``address`` (ip:port)"
raise NotImplementedError("Not supported for disredis.")
def client_list(self):
"Returns a list of currently connected clients"
raise NotImplementedError("Not supported for disredis.")
def client_getname(self):
"Returns the current connection name"
raise NotImplementedError("Not supported for disredis.")
def client_setname(self, name):
"Sets the current connection name"
raise NotImplementedError("Not supported for disredis.")
def config_get(self, pattern="*"):
"Return a dictionary of configuration based on the ``pattern``"
raise NotImplementedError("Not supported for disredis.")
def config_set(self, name, value):
"Set config item ``name`` with ``value``"
raise NotImplementedError("Not supported for disredis.")
def dbsize(self):
"Returns the number of keys in the current database"
raise NotImplementedError("Not supported for disredis.")
def time(self):
"""
Returns the server time as a 2-item tuple of ints:
(seconds since epoch, microseconds into this second).
"""
raise NotImplementedError("Not supported for disredis.")
@executeOnNode
def debug_object(self, key):
"Returns version specific metainformation about a give key"
def delete(self, *names):
"Delete one or more keys specified by ``names``"
return self.execute_command('DEL', *names)
__delitem__ = delete
def echo(self, value):
"Echo the string back from the server"
raise NotImplementedError("Not supported for disredis.")
def flushall(self):
"Delete all keys in all databases on the current host"
raise NotImplementedError("Not supported for disredis.")
def flushdb(self):
"Delete all keys in the current database"
raise NotImplementedError("Not supported for disredis.")
def info(self, section=None):
"""
Returns a dictionary containing information about the Redis server
The ``section`` option can be used to select a specific section
of information
The section option is not supported by older versions of Redis Server,
and will generate ResponseError
"""
raise NotImplementedError("Not supported for disredis.")
def lastsave(self):
"""
Return a Python datetime object representing the last time the
Redis database was saved to disk
"""
raise NotImplementedError("Not supported for disredis.")
def object(self, infotype, key):
"Return the encoding, idletime, or refcount about the key"
raise NotImplementedError("Not supported for disredis.")
def ping(self):
"Ping the Redis server"
raise NotImplementedError("Not supported for disredis.")
def save(self):
"""
Tell the Redis server to save its data to disk,
blocking until the save is complete
"""
raise NotImplementedError("Not supported for disredis.")
def shutdown(self):
"Shutdown the server"
raise NotImplementedError("Not supported for disredis.")
def slaveof(self, host=None, port=None):
"""
Set the server to be a replicated slave of the instance identified
by the ``host`` and ``port``. If called without arguements, the
instance is promoted to a master instead.
"""
raise NotImplementedError("Not supported for disredis.")
@executeOnNode
def append(self, key, value):
"""
Appends the string ``value`` to the value at ``key``. If ``key``
doesn't already exist, create it with a value of ``value``.
Returns the new length of the value at ``key``.
"""
@executeOnNode
def getrange(self, key, start, end):
"""
Returns the substring of the string value stored at ``key``,
determined by the offsets ``start`` and ``end`` (both are inclusive)
"""
@executeOnNode
def bitcount(self, key, start=None, end=None):
"""
Returns the count of set bits in the value of ``key``. Optional
``start`` and ``end`` paramaters indicate which bytes to consider
"""
def bitop(self, operation, dest, *keys):
"""
Perform a bitwise operation using ``operation`` between ``keys`` and
store the result in ``dest``.
"""
raise NotImplementedError("Not supported for disredis.")
@executeOnNode
def decr(self, name, amount=1):
"""
Decrements the value of ``key`` by ``amount``. If no key exists,
the value will be initialized as 0 - ``amount``
"""
@executeOnNode
def exists(self, name):
"Returns a boolean indicating whether key ``name`` exists"
__contains__ = exists
@executeOnNode
def expire(self, name, time):
"""
Set an expire flag on key ``name`` for ``time`` seconds. ``time``
can be represented by an integer or a Python timedelta object.
"""
@executeOnNode
def expireat(self, name, when):
"""
Set an expire flag on key ``name``. ``when`` can be represented
as an integer indicating unix time or a Python datetime object.
"""
@executeOnNode
def get(self, name):
"""
Return the value at key ``name``, or None if the key doesn't exist
"""
def __getitem__(self, name):
"""
Return the value at key ``name``, raises a KeyError if the key
doesn't exist.
"""
value = self.get(name)
if value:
return value
raise KeyError(name)
@executeOnNode
def getbit(self, name, offset):
"Returns a boolean indicating the value of ``offset`` in ``name``"
@executeOnNode
def getset(self, name, value):
"""
Set the value at key ``name`` to ``value`` if key doesn't exist
Return the value at key ``name`` atomically
"""
@executeOnNode
def incr(self, name, amount=1):
"""
Increments the value of ``key`` by ``amount``. If no key exists,
the value will be initialized as ``amount``
"""
def incrby(self, name, amount=1):
"""
Increments the value of ``key`` by ``amount``. If no key exists,
the value will be initialized as ``amount``
"""
return self.incr(name, amount)
@executeOnNode
def incrbyfloat(self, name, amount=1.0):
"""
Increments the value at key ``name`` by floating ``amount``.
If no key exists, the value will be initialized as ``amount``
"""
def keys(self, pattern='*'):
"Returns a list of keys matching ``pattern``"
raise NotImplementedError("Not supported for disredis.")
def mget(self, keys, *args):
"""
Returns a list of values ordered identically to ``keys``
"""
raise NotImplementedError("Not supported for disredis.")
def mset(self, mapping):
"Sets each key in the ``mapping`` dict to its corresponding value"
raise NotImplementedError("Not supported for disredis.")
def msetnx(self, mapping):
"""
Sets each key in the ``mapping`` dict to its corresponding value if
none of the keys are already set
"""
raise NotImplementedError("Not supported for disredis.")
@executeOnNode
def move(self, name, db):
"Moves the key ``name`` to a different Redis database ``db``"
@executeOnNode
def persist(self, name):
"Removes an expiration on ``name``"
@executeOnNode
def pexpire(self, name, time):
"""
Set an expire flag on key ``name`` for ``time`` milliseconds.
``time`` can be represented by an integer or a Python timedelta
object.
"""
@executeOnNode
def pexpireat(self, name, when):
"""
Set an expire flag on key ``name``. ``when`` can be represented
as an integer representing unix time in milliseconds (unix time * 1000)
or a Python datetime object.
"""
@executeOnNode
def psetex(self, name, time_ms, value):
"""
Set the value of key ``name`` to ``value`` that expires in ``time_ms``
milliseconds. ``time_ms`` can be represented by an integer or a Python
timedelta object
"""
@executeOnNode
def pttl(self, name):
"Returns the number of milliseconds until the key ``name`` will expire"
def randomkey(self):
"Returns the name of a random key"
raise NotImplementedError("Not supported for disredis.")
def rename(self, src, dst):
"""
Rename key ``src`` to ``dst``
"""
raise NotImplementedError("Not supported for disredis.")
def renamenx(self, src, dst):
"Rename key ``src`` to ``dst`` if ``dst`` doesn't already exist"
raise NotImplementedError("Not supported for disredis.")
@executeOnNode
def set(self, name, value, ex=None, px=None, nx=False, xx=False):
"""
Set the value at key ``name`` to ``value``
``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
``nx`` if set to True, set the value at key ``name`` to ``value`` if it
does not already exist.
``xx`` if set to True, set the value at key ``name`` to ``value`` if it
already exists.
"""
__setitem__ = set
@executeOnNode
def setbit(self, name, offset, value):
"""
Flag the ``offset`` in ``name`` as ``value``. Returns a boolean
indicating the previous value of ``offset``.
"""
@executeOnNode
def setex(self, name, time, value):
"""
Set the value of key ``name`` to ``value`` that expires in ``time``
seconds. ``time`` can be represented by an integer or a Python
timedelta object.
"""
@executeOnNode
def setnx(self, name, value):
"Set the value of key ``name`` to ``value`` if key doesn't exist"
@executeOnNode
def setrange(self, name, offset, value):
"""
Overwrite bytes in the value of ``name`` starting at ``offset`` with
``value``. If ``offset`` plus the length of ``value`` exceeds the
length of the original value, the new value will be larger than before.
If ``offset`` exceeds the length of the original value, null bytes
will be used to pad between the end of the previous value and the start
of what's being injected.
Returns the length of the new string.
"""
@executeOnNode
def strlen(self, name):
"Return the number of bytes stored in the value of ``name``"
@executeOnNode
def substr(self, name, start, end=-1):
"""
Return a substring of the string at key ``name``. ``start`` and ``end``
are 0-based integers specifying the portion of the string to return.
"""
@executeOnNode
def ttl(self, name):
"Returns the number of seconds until the key ``name`` will expire"
@executeOnNode
def type(self, name):
"Returns the type of key ``name``"
def blpop(self, keys, timeout=0):
"""
LPOP a value off of the first non-empty list
named in the ``keys`` list.
If none of the lists in ``keys`` has a value to LPOP, then block
for ``timeout`` seconds, or until a value gets pushed on to one
of the lists.
If timeout is 0, then block indefinitely.
"""
raise NotImplementedError("Not supported for disredis.")
def brpop(self, keys, timeout=0):
"""
RPOP a value off of the first non-empty list
named in the ``keys`` list.
If none of the lists in ``keys`` has a value to LPOP, then block
for ``timeout`` seconds, or until a value gets pushed on to one
of the lists.
If timeout is 0, then block indefinitely.
"""
raise NotImplementedError("Not supported for disredis.")
def brpoplpush(self, src, dst, timeout=0):
"""
Pop a value off the tail of ``src``, push it on the head of ``dst``
and then return it.
This command blocks until a value is in ``src`` or until ``timeout``
seconds elapse, whichever is first. A ``timeout`` value of 0 blocks
forever.
"""
raise NotImplementedError("Not supported for disredis.")
@executeOnNode
def lindex(self, name, index):
"""
Return the item from list ``name`` at position ``index``
Negative indexes are supported and will return an item at the
end of the list
"""
@executeOnNode
def linsert(self, name, where, refvalue, value):
"""
Insert ``value`` in list ``name`` either immediately before or after
[``where``] ``refvalue``
Returns the new length of the list on success or -1 if ``refvalue``
is not in the list.
"""
@executeOnNode
def llen(self, name):
"Return the length of the list ``name``"
@executeOnNode
def lpop(self, name):
"Remove and return the first item of the list ``name``"
@executeOnNode
def lpush(self, name, *values):
"Push ``values`` onto the head of the list ``name``"
@executeOnNode
def lpushx(self, name, value):
"Push ``value`` onto the head of the list ``name`` if ``name`` exists"
@executeOnNode
def lrange(self, name, start, end):
"""
Return a slice of the list ``name`` between
position ``start`` and ``end``
``start`` and ``end`` can be negative numbers just like
Python slicing notation
"""
@executeOnNode
def lrem(self, name, count, value):
"""
Remove the first ``count`` occurrences of elements equal to ``value``
from the list stored at ``name``.
The count argument influences the operation in the following ways:
count > 0: Remove elements equal to value moving from head to tail.
count < 0: Remove elements equal to value moving from tail to head.
count = 0: Remove all elements equal to value.
"""
@executeOnNode
def lset(self, name, index, value):
"Set ``position`` of list ``name`` to ``value``"
@executeOnNode
def ltrim(self, name, start, end):
"""
Trim the list ``name``, removing all values not within the slice
between ``start`` and ``end``
``start`` and ``end`` can be negative numbers just like
Python slicing notation
"""
@executeOnNode
def rpop(self, name):
"Remove and return the last item of the list ``name``"
def rpoplpush(self, src, dst):
"""
RPOP a value off of the ``src`` list and atomically LPUSH it
on to the ``dst`` list. Returns the value.
"""
raise NotImplementedError("Not supported for disredis.")
@executeOnNode
def rpush(self, name, *values):
"Push ``values`` onto the tail of the list ``name``"
@executeOnNode
def rpushx(self, name, value):
"Push ``value`` onto the tail of the list ``name`` if ``name`` exists"
@executeOnNode
def sort(self, name, start=None, num=None, by=None, get=None,
desc=False, alpha=False, store=None, groups=False):
"""
Sort and return the list, set or sorted set at ``name``.
``start`` and ``num`` allow for paging through the sorted data
``by`` allows using an external key to weight and sort the items.
Use an "*" to indicate where in the key the item value is located
``get`` allows for returning items from external keys rather than the
sorted data itself. Use an "*" to indicate where int he key
the item value is located
``desc`` allows for reversing the sort
``alpha`` allows for sorting lexicographically rather than numerically
``store`` allows for storing the result of the sort into
the key ``store``
``groups`` if set to True and if ``get`` contains at least two
elements, sort will return a list of tuples, each containing the
values fetched from the arguments to ``get``.
"""
@executeOnNode
def sadd(self, name, *values):
"Add ``value(s)`` to set ``name``"
@executeOnNode
def scard(self, name):
"Return the number of elements in set ``name``"
def sdiff(self, keys, *args):
"Return the difference of sets specified by ``keys``"
raise NotImplementedError("Not supported for disredis.")
def sdiffstore(self, dest, keys, *args):
"""
Store the difference of sets specified by ``keys`` into a new
set named ``dest``. Returns the number of keys in the new set.
"""
raise NotImplementedError("Not supported for disredis.")
def sinter(self, keys, *args):
"Return the intersection of sets specified by ``keys``"
raise NotImplementedError("Not supported for disredis.")
def sinterstore(self, dest, keys, *args):
"""
Store the intersection of sets specified by ``keys`` into a new
set named ``dest``. Returns the number of keys in the new set.
"""
raise NotImplementedError("Not supported for disredis.")
@executeOnNode
def sismember(self, name, value):
"Return a boolean indicating if ``value`` is a member of set ``name``"
@executeOnNode
def smembers(self, name):
"Return all members of the set ``name``"
def smove(self, src, dst, value):
"Move ``value`` from set ``src`` to set ``dst`` atomically"
return self.execute_command('SMOVE', src, dst, value)
@executeOnNode
def spop(self, name):
"Remove and return a random member of set ``name``"
@executeOnNode
def srandmember(self, name, number=None):
"""
If ``number`` is None, returns a random member of set ``name``.
If ``number`` is supplied, returns a list of ``number`` random
memebers of set ``name``. Note this is only available when running
Redis 2.6+.
"""
@executeOnNode
def srem(self, name, *values):
"Remove ``values`` from set ``name``"
def sunion(self, keys, *args):
"Return the union of sets specifiued by ``keys``"
raise NotImplementedError("Not supported for disredis.")
def sunionstore(self, dest, keys, *args):
"""
Store the union of sets specified by ``keys`` into a new
set named ``dest``. Returns the number of keys in the new set.
"""
raise NotImplementedError("Not supported for disredis.")
@executeOnNode
def zadd(self, name, *args, **kwargs):
"""
Set any number of score, element-name pairs to the key ``name``. Pairs
can be specified in two ways:
As *args, in the form of: score1, name1, score2, name2, ...
or as **kwargs, in the form of: name1=score1, name2=score2, ...
The following example would add four values to the 'my-key' key:
redis.zadd('my-key', 1.1, 'name1', 2.2, 'name2', name3=3.3, name4=4.4)
"""
@executeOnNode
def zcard(self, name):
"Return the number of elements in the sorted set ``name``"
@executeOnNode
def zcount(self, name, min, max):
"""
"""
@executeOnNode
def zincrby(self, name, value, amount=1):
"Increment the score of ``value`` in sorted set ``name`` by ``amount``"
def zinterstore(self, dest, keys, aggregate=None):
"""
Intersect multiple sorted sets specified by ``keys`` into
a new sorted set, ``dest``. Scores in the destination will be
aggregated based on the ``aggregate``, or SUM if none is provided.
"""
raise NotImplementedError("Not supported for disredis.")
@executeOnNode
def zrange(self, name, start, end, desc=False, withscores=False,
score_cast_func=float):
"""
Return a range of values from sorted set ``name`` between
``start`` and ``end`` sorted in ascending order.
``start`` and ``end`` can be negative, indicating the end of the range.
``desc`` a boolean indicating whether to sort the results descendingly
``withscores`` indicates to return the scores along with the values.
The return type is a list of (value, score) pairs
``score_cast_func`` a callable used to cast the score return value
"""
@executeOnNode
def zrangebyscore(self, name, min, max, start=None, num=None,
withscores=False, score_cast_func=float):
"""
Return a range of values from the sorted set ``name`` with scores
between ``min`` and ``max``.
If ``start`` and ``num`` are specified, then return a slice
of the range.
``withscores`` indicates to return the scores along with the values.
The return type is a list of (value, score) pairs
`score_cast_func`` a callable used to cast the score return value
"""
@executeOnNode
def zrank(self, name, value):
"""
Returns a 0-based value indicating the rank of ``value`` in sorted set
``name``
"""
@executeOnNode
def zrem(self, name, *values):
"Remove member ``values`` from sorted set ``name``"
@executeOnNode
def zremrangebyrank(self, name, min, max):
"""
Remove all elements in the sorted set ``name`` with ranks between
``min`` and ``max``. Values are 0-based, ordered from smallest score
to largest. Values can be negative indicating the highest scores.
Returns the number of elements removed
"""
@executeOnNode
def zremrangebyscore(self, name, min, max):
"""
Remove all elements in the sorted set ``name`` with scores
between ``min`` and ``max``. Returns the number of elements removed.
"""
@executeOnNode
def zrevrange(self, name, start, num, withscores=False,
score_cast_func=float):
"""
Return a range of values from sorted set ``name`` between
``start`` and ``num`` sorted in descending order.
``start`` and ``num`` can be negative, indicating the end of the range.
``withscores`` indicates to return the scores along with the values
The return type is a list of (value, score) pairs
``score_cast_func`` a callable used to cast the score return value
"""
@executeOnNode
def zrevrangebyscore(self, name, max, min, start=None, num=None,
withscores=False, score_cast_func=float):
"""
Return a range of values from the sorted set ``name`` with scores
between ``min`` and ``max`` in descending order.
If ``start`` and ``num`` are specified, then return a slice
of the range.
``withscores`` indicates to return the scores along with the values.
The return type is a list of (value, score) pairs
``score_cast_func`` a callable used to cast the score return value
"""
@executeOnNode
def zrevrank(self, name, value):
"""
Returns a 0-based value indicating the descending rank of
``value`` in sorted set ``name``
"""
@executeOnNode
def zscore(self, name, value):
"Return the score of element ``value`` in sorted set ``name``"
def zunionstore(self, dest, keys, aggregate=None):
"""
Union multiple sorted sets specified by ``keys`` into
a new sorted set, ``dest``. Scores in the destination will be
aggregated based on the ``aggregate``, or SUM if none is provided.
"""
raise NotImplementedError("Not supported for disredis.")
@executeOnNode
def hdel(self, name, *keys):
"Delete ``keys`` from hash ``name``"
@executeOnNode
def hexists(self, name, key):
"Returns a boolean indicating if ``key`` exists within hash ``name``"
@executeOnNode
def hget(self, name, key):
"Return the value of ``key`` within the hash ``name``"
@executeOnNode
def hgetall(self, name):
"Return a Python dict of the hash's name/value pairs"
@executeOnNode
def hincrby(self, name, key, amount=1):
"Increment the value of ``key`` in hash ``name`` by ``amount``"
@executeOnNode
def hincrbyfloat(self, name, key, amount=1.0):
"""
Increment the value of ``key`` in hash ``name`` by floating ``amount``
"""
@executeOnNode
def hkeys(self, name):
"Return the list of keys within hash ``name``"
@executeOnNode
def hlen(self, name):
"Return the number of elements in hash ``name``"
@executeOnNode
def hset(self, name, key, value):
"""
Set ``key`` to ``value`` within hash ``name``
Returns 1 if HSET created a new field, otherwise 0
"""
@executeOnNode
def hsetnx(self, name, key, value):
"""
Set ``key`` to ``value`` within hash ``name`` if ``key`` does not
exist. Returns 1 if HSETNX created a field, otherwise 0.
"""
@executeOnNode
def hmset(self, name, mapping):
"""
Sets each key in the ``mapping`` dict to its corresponding value
in the hash ``name``
"""
@executeOnNode
def hmget(self, name, keys, *args):
"Returns a list of values ordered identically to ``keys``"
@executeOnNode
def hvals(self, name):
"Return the list of values within hash ``name``"
def publish(self, channel, message):
"""
Publish ``message`` on ``channel``.
Returns the number of subscribers the message was delivered to.
"""
raise NotImplementedError("Not supported for disredis.")
def eval(self, script, numkeys, *keys_and_args):
"""
Execute the LUA ``script``, specifying the ``numkeys`` the script
will touch and the key names and argument values in ``keys_and_args``.
Returns the result of the script.
In practice, use the object returned by ``register_script``. This
function exists purely for Redis API completion.
"""
raise NotImplementedError("Not supported for disredis.")
def evalsha(self, sha, numkeys, *keys_and_args):
"""
Use the ``sha`` to execute a LUA script already registered via EVAL
or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
key names and argument values in ``keys_and_args``. Returns the result
of the script.
In practice, use the object returned by ``register_script``. This
function exists purely for Redis API completion.
"""
raise NotImplementedError("Not supported for disredis.")
def script_exists(self, *args):
"""
Check if a script exists in the script cache by specifying the SHAs of
each script as ``args``. Returns a list of boolean values indicating if
if each already script exists in the cache.
"""
raise NotImplementedError("Not supported for disredis.")
def script_flush(self):
"Flush all scripts from the script cache"
raise NotImplementedError("Not supported for disredis.")
def script_kill(self):
"Kill the currently executing LUA script"
raise NotImplementedError("Not supported for disredis.")
def script_load(self, script):
"Load a LUA ``script`` into the script cache. Returns the SHA."
raise NotImplementedError("Not supported for disredis.")
def register_script(self, script):
"""
Register a LUA ``script`` specifying the ``keys`` it will touch.
Returns a Script object that is callable and hides the complexity of
deal with scripts, keys, and shas. This is the preferred way to work
with LUA scripts.
"""
raise NotImplementedError("Not supported for disredis.")
|
data/adblockplus/gyp/test/win/gyptest-link-force-symbol-reference.py
|
"""
Make sure ForceSymbolReference is translated properly.
"""
import TestGyp
import sys
if sys.platform == 'win32':
test = TestGyp.TestGyp(formats=['msvs', 'ninja'])
CHDIR = 'linker-flags'
test.run_gyp('force-symbol-reference.gyp', chdir=CHDIR)
test.build('force-symbol-reference.gyp', test.ALL, chdir=CHDIR)
output = test.run_dumpbin(
'/disasm', test.built_file_path('test_force_reference.exe', chdir=CHDIR))
if '?x@@YAHXZ:' not in output or '?y@@YAHXZ:' not in output:
test.fail_test()
test.pass_test()
|
data/Unidata/netcdf4-python/examples/bench.py
|
from numpy.random.mtrand import uniform
import netCDF4
from timeit import Timer
import os, sys
n1dim = 30
n2dim = 15
n3dim = 73
n4dim = 144
ntrials = 10
sys.stdout.write('reading and writing a %s by %s by %s by %s random array ..\n'%(n1dim,n2dim,n3dim,n4dim))
array = uniform(size=(n1dim,n2dim,n3dim,n4dim))
def write_netcdf(filename,zlib=False,least_significant_digit=None,format='NETCDF4'):
file = netCDF4.Dataset(filename,'w',format=format)
file.createDimension('n1', n1dim)
file.createDimension('n2', n2dim)
file.createDimension('n3', n3dim)
file.createDimension('n4', n4dim)
foo = file.createVariable('data', 'f8',('n1','n2','n3','n4'),zlib=zlib,least_significant_digit=least_significant_digit)
foo[:] = array
file.close()
def read_netcdf(filename):
file = netCDF4.Dataset(filename)
data = file.variables['data'][:]
file.close()
for format in ['NETCDF3_CLASSIC','NETCDF3_64BIT','NETCDF4_CLASSIC','NETCDF4']:
sys.stdout.write('testing file format %s ...\n' % format)
t = Timer("write_netcdf('test1.nc',format='%s')" % format,"from __main__ import write_netcdf")
sys.stdout.write('writing took %s seconds\n' %\
repr(sum(t.repeat(ntrials,1))/ntrials))
t = Timer("read_netcdf('test1.nc')","from __main__ import read_netcdf")
sys.stdout.write('reading took %s seconds\n' %
repr(sum(t.repeat(ntrials,1))/ntrials))
|
data/adblockplus/gyp/test/ninja/use-console/gyptest-use-console.py
|
"""
Make sure 'ninja_use_console' is supported in actions and rules.
"""
import TestGyp
test = TestGyp.TestGyp(formats=['ninja'])
test.run_gyp('use-console.gyp')
no_pool = open(test.built_file_path('obj/no_pool.ninja')).read()
if 'pool =' in no_pool:
test.fail_test()
action_pool = open(test.built_file_path('obj/action_pool.ninja')).read()
if 'pool = console' not in action_pool:
test.fail_test()
rule_pool = open(test.built_file_path('obj/rule_pool.ninja')).read()
if 'pool = console' not in rule_pool:
test.fail_test()
test.pass_test()
|
data/SheffieldML/GPy/GPy/mappings/piecewise_linear.py
|
from GPy.core.mapping import Mapping
from GPy.core import Param
import numpy as np
class PiecewiseLinear(Mapping):
"""
A piecewise-linear mapping.
The parameters of this mapping are the positions and values of the function where it is broken (self.breaks, self.values).
Outside the range of the breaks, the function is assumed to have gradient 1
"""
def __init__(self, input_dim, output_dim, values, breaks, name='piecewise_linear'):
assert input_dim==1
assert output_dim==1
Mapping.__init__(self, input_dim, output_dim, name)
values, breaks = np.array(values).flatten(), np.array(breaks).flatten()
assert values.size == breaks.size
self.values = Param('values', values)
self.breaks = Param('breaks', breaks)
self.link_parameter(self.values)
self.link_parameter(self.breaks)
def parameters_changed(self):
self.order = np.argsort(self.breaks)*1
self.reverse_order = np.zeros_like(self.order)
self.reverse_order[self.order] = np.arange(self.order.size)
self.sorted_breaks = self.breaks[self.order]
self.sorted_values = self.values[self.order]
self.grads = np.diff(self.sorted_values)/np.diff(self.sorted_breaks)
def f(self, X):
x = X.flatten()
y = x.copy()
y[x<self.sorted_breaks[0]] = x[x<self.sorted_breaks[0]] + self.sorted_values[0] - self.sorted_breaks[0]
y[x>self.sorted_breaks[-1]] = x[x>self.sorted_breaks[-1]] + self.sorted_values[-1] - self.sorted_breaks[-1]
for low, up, g, v in zip(self. sorted_breaks[:-1], self.sorted_breaks[1:], self.grads, self.sorted_values[:-1]):
i = np.logical_and(x>low, x<up)
y[i] = v + (x[i]-low)*g
return y.reshape(-1,1)
def update_gradients(self, dL_dF, X):
x = X.flatten()
dL_dF = dL_dF.flatten()
dL_db = np.zeros(self.sorted_breaks.size)
dL_dv = np.zeros(self.sorted_values.size)
for i, (low, up, g, v) in enumerate(zip(self. sorted_breaks[:-1], self.sorted_breaks[1:], self.grads, self.sorted_values[:-1])):
index = np.logical_and(x>low, x<up)
xx = x[index]
grad = dL_dF[index]
span = up-low
dL_dv[i] += np.sum(grad*( (low - xx)/span + 1))
dL_dv[i+1] += np.sum(grad*(xx-low)/span)
dL_db[i] += np.sum(grad*g*(xx-up)/span)
dL_db[i+1] += np.sum(grad*g*(low-xx)/span)
dL_db[0] -= np.sum(dL_dF[x<self.sorted_breaks[0]])
dL_db[-1] -= np.sum(dL_dF[x>self.sorted_breaks[-1]])
dL_dv[0] += np.sum(dL_dF[x<self.sorted_breaks[0]])
dL_dv[-1] += np.sum(dL_dF[x>self.sorted_breaks[-1]])
self.breaks.gradient = dL_db[self.reverse_order]
self.values.gradient = dL_dv[self.reverse_order]
def gradients_X(self, dL_dF, X):
x = X.flatten()
dL_dX = dL_dF.copy().flatten()
for low, up, g, v in zip(self. sorted_breaks[:-1], self.sorted_breaks[1:], self.grads, self.sorted_values[:-1]):
i = np.logical_and(x>low, x<up)
dL_dX[i] = dL_dF[i]*g
return dL_dX.reshape(-1,1)
|
data/JelteF/PyLaTeX/examples/numpy_ex.py
|
"""
This example shows numpy functionality.
.. :copyright: (c) 2014 by Jelte Fennema.
:license: MIT, see License for more details.
"""
import numpy as np
from pylatex import Document, Section, Subsection, Math, Matrix, VectorName
if __name__ == '__main__':
a = np.array([[100, 10, 20]]).T
doc = Document()
section = Section('Numpy tests')
subsection = Subsection('Array')
vec = Matrix(a)
vec_name = VectorName('a')
math = Math(data=[vec_name, '=', vec])
subsection.append(math)
section.append(subsection)
subsection = Subsection('Matrix')
M = np.matrix([[2, 3, 4],
[0, 0, 1],
[0, 0, 2]])
matrix = Matrix(M, mtype='b')
math = Math(data=['M=', matrix])
subsection.append(math)
section.append(subsection)
subsection = Subsection('Product')
math = Math(data=['M', vec_name, '=', Matrix(M*a)])
subsection.append(math)
section.append(subsection)
doc.append(section)
doc.generate_pdf('numpy_ex')
|
data/Toblerity/Shapely/tests/test_wkt.py
|
from math import pi
import pytest
from shapely.geometry import LineString, Point
from shapely.wkt import dumps
@pytest.fixture(scope="module")
def pipi():
return Point((pi, -pi))
@pytest.fixture(scope="module")
def pipi4():
return Point((pi*4, -pi*4))
def test_wkt(pipi):
""".wkt and wkt.dumps() both do not trim by default."""
assert pipi.wkt == "POINT ({0:.16f} {1:.16f})".format(pi, -pi)
def test_wkt(pipi4):
""".wkt and wkt.dumps() both do not trim by default."""
assert pipi4.wkt == "POINT ({0:.16f} {1:.16f})".format(pi*4, -pi*4)
def test_dumps(pipi4):
assert dumps(pipi4) == "POINT ({0:.16f} {1:.16f})".format(pi*4, -pi*4)
def test_dumps_precision(pipi4):
assert dumps(pipi4, rounding_precision=4) == "POINT ({0:.4f} {1:.4f})".format(pi*4, -pi*4)
|
data/SafeSlingerProject/SafeSlinger-AppEngine/safeslinger-demo/python/cleanup.py
|
import datetime
from google.appengine.ext import db, webapp
from google.appengine.ext.webapp import util
import member
class CleanUp(webapp.RequestHandler):
def get(self):
if self.request.headers.get('X-AppEngine-Cron') == 'true':
now = datetime.datetime.now()
deltaMem = datetime.timedelta(seconds=600)
thenMem = now - deltaMem
query = db.Query(member.Member).filter('inserted <', thenMem)
mems = []
for m in query:
mems.append(m)
db.delete(mems)
def main():
application = webapp.WSGIApplication([('/cron/cleanup', CleanUp)],
debug=True)
util.run_wsgi_app(application)
if __name__ == '__main__':
main()
|
data/PythonJS/PythonJS/regtests/loop/range.py
|
'''
range builtin
'''
def main():
a = range(10)
TestError( a[0]==0 )
TestError( a[1]==1 )
TestError( len(a)==10 )
b = range(1,10)
TestError( b[0]==1 )
TestError( b[1]==2 )
TestError( len(b)==9 )
c = 0
for i in range(10):
c += 1
TestError( c == 10 )
d = 0
for i in range(1, 10):
d += 1
TestError( d == 9 )
e = 0
for i in range(1, 8+2):
e += 1
TestError( e == 9 )
|
data/IDSIA/brainstorm/docs/conf.py
|
import os
import sys
try:
from unittest.mock import MagicMock
except ImportError:
from mock import Mock as MagicMock
class Mock(MagicMock):
@classmethod
def __getattr__(cls, name):
return Mock()
MOCK_MODULES = ['h5py', 'brainstorm.handlers._cpuop']
sys.modules.update((mod_name, Mock()) for mod_name in MOCK_MODULES)
cwd = os.getcwd()
parent = os.path.dirname(cwd)
sys.path.insert(0, parent)
import brainstorm
extensions = ['sphinx.ext.autodoc', 'sphinx.ext.viewcode',
'sphinx.ext.napoleon']
templates_path = ['_templates']
source_suffix = '.rst'
master_doc = 'index'
project = u'brainstorm'
copyright = u'2015, IDSIA'
version = brainstorm.__version__
release = brainstorm.__version__
exclude_patterns = ['_build']
pygments_style = 'sphinx'
on_rtd = os.environ.get('READTHEDOCS', None) == 'True'
if not on_rtd:
try:
import sphinx_rtd_theme
html_theme = 'sphinx_rtd_theme'
html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
except ImportError:
html_theme = 'alabaster'
html_static_path = ['_static']
htmlhelp_basename = 'brainstormdoc'
latex_elements = {
}
latex_documents = [
('index', 'brainstorm.tex', u'brainstorm Documentation',
u'Klaus Greff', 'manual'),
]
man_pages = [
('index', 'brainstorm', u'brainstorm Documentation',
[u'Klaus Greff'], 1)
]
texinfo_documents = [
('index', 'brainstorm', u'brainstorm Documentation',
u'Klaus Greff', 'brainstorm', 'One line description of project.',
'Miscellaneous'),
]
|
data/ReactiveX/RxPY/rx/linq/observable/multicast.py
|
from rx import Observable, AnonymousObservable
from rx.linq.connectableobservable import ConnectableObservable
from rx.disposables import CompositeDisposable
from rx.internal import extensionmethod
@extensionmethod(Observable)
def multicast(self, subject=None, subject_selector=None, selector=None):
"""Multicasts the source sequence notifications through an instantiated
subject into all uses of the sequence within a selector function. Each
subscription to the resulting sequence causes a separate multicast
invocation, exposing the sequence resulting from the selector function's
invocation. For specializations with fixed subject types, see Publish,
PublishLast, and Replay.
Example:
1 - res = source.multicast(observable)
2 - res = source.multicast(subject_selector=lambda: Subject(),
selector=lambda x: x)
Keyword arguments:
subject_selector -- {Function} Factory function to create an
intermediate subject through which the source sequence's elements
will be multicast to the selector function.
subject -- Subject {Subject} to push source elements into.
selector -- {Function} [Optional] Optional selector function which can
use the multicasted source sequence subject to the policies enforced
by the created subject. Specified only if subject_selector" is a
factory function.
Returns an observable {Observable} sequence that contains the elements
of a sequence produced by multicasting the source sequence within a
selector function.
"""
source = self
if subject_selector:
def subscribe(observer):
connectable = source.multicast(subject=subject_selector())
return CompositeDisposable(selector(connectable).subscribe(observer), connectable.connect())
return AnonymousObservable(subscribe)
else:
return ConnectableObservable(source, subject)
|
data/Miserlou/django-easy-api/easy_api/shortcuts.py
|
"""
This is based off of Django's own shorcuts.py which provides render_to_response.
The key function here is easy_api_render_to_response()
"""
from django.template import loader, RequestContext
from django.http import HttpResponse, Http404
from django.http import HttpResponseRedirect, HttpResponsePermanentRedirect
from django.db.models.base import ModelBase
from django.db.models.manager import Manager
from django.db.models.query import QuerySet
from django.core import urlresolvers
from django.utils import six
import datetime
try:
import json
except Exception, e:
import simplejson as json
from .dumper import DataDumper
from dicttoxml import dicttoxml as dict2xml
from xml.dom.minidom import parseString
import yaml
def render_to_easy_api_response(*args, **kwargs):
"""
Returns a HttpResponse whose content is filled with the result of calling
django.template.loader.render_to_string() with the passed arguments.
"""
httpresponse_kwargs = {'content_type': kwargs.pop('content_type', None)}
context = kwargs.pop('context_instance')
processors = context.context_processors
request = processors['django.core.context_processors.request']['request']
if request.GET.has_key('api'):
api_type = request.GET['api']
for arg in args:
passed = arg
dump_me = {}
for key in passed.keys():
value = passed[key]
dump_me[key] = dump_object(value)
if api_type == 'xml':
def replace_spaces(dump_me):
new = {}
for k, v in dump_me.iteritems():
if isinstance(v, dict):
v = replace_spaces(v)
new[k.replace(' ', '_')] = v
return new
new = replace_spaces(dump_me)
dump_me = dict2xml(new)
dom = parseString(dump_me)
pretty = dom.toprettyxml()
return HttpResponse(pretty, content_type='application/xml')
if api_type == 'yaml':
yml = yaml.safe_dump(dump_me)
return HttpResponse(yml, content_type='application/x-yaml')
else:
dump_me = json.dumps(dump_me, indent=2)
return HttpResponse(dump_me, content_type='application/json')
return HttpResponse(loader.render_to_string(*args, **kwargs), **httpresponse_kwargs)
def render_to_response(*args, **kwargs):
"""
This is just a wrapper around render_to_easy_api_response to make it easier to use as a drop-in replacement.
"""
return render_to_easy_api_response(*args, **kwargs)
def dump_object(queryset):
if str(type(queryset)) != "<class 'django.db.models.query.QuerySet'>":
d = DataDumper()
ret = d.dump(queryset)
return ret
try:
modelName = queryset[0].__class__.__name__
modelNameData = []
fields = get_fields(queryset[0])
for obj in queryset:
temp_dict = dict()
for field in fields:
try:
attribute = getattr(obj, str(field))
temp_dict[field] = attribute
except Exception, e:
continue
modelNameData.append(temp_dict)
dthandler = lambda obj: obj.isoformat() if isinstance(obj, datetime.datetime) or isinstance(obj, datetime.date) else None
return json.loads(json.dumps(modelNameData, default=dthandler))
except Exception, e:
return ''
def get_fields(model):
try:
if hasattr(model, "easy_api_fields"):
fields = model.easy_api_fields()
else:
try:
fields = model.to_dict().keys()
except Exception, e:
fields = model._meta.get_all_field_names()
return fields
except Exception, e:
return []
|
data/aerospike/aerospike-client-python/test/old_tests/test_admin_set_password.py
|
import pytest
import sys
from .test_base_class import TestBaseClass
from aerospike import exception as e
aerospike = pytest.importorskip("aerospike")
try:
import aerospike
except:
print("Please install aerospike python client.")
sys.exit(1)
class TestSetPassword(TestBaseClass):
pytestmark = pytest.mark.skipif(
TestBaseClass().get_hosts()[1] == None,
reason="No user specified, may be not secured cluster.")
def setup_method(self, method):
"""
Setup method
"""
hostlist, user, password = TestBaseClass().get_hosts()
config = {"hosts": hostlist}
TestSetPassword.Me = self
self.client = aerospike.client(config).connect(user, password)
try:
self.client.admin_drop_user("testsetpassworduser")
except:
pass
self.client.admin_create_user(
"testsetpassworduser", "aerospike", ["read"], {})
self.delete_users = []
def teardown_method(self, method):
"""
Teardown method
"""
self.client.admin_drop_user("testsetpassworduser")
self.client.close()
def test_set_password_without_any_parameters(self):
with pytest.raises(TypeError) as typeError:
self.client.admin_set_password()
assert "Required argument 'user' (pos 1) not found" in str(
typeError.value)
def test_set_password_with_proper_parameters(self):
user = "testsetpassworduser"
password = "newpassword"
status = self.client.admin_set_password(user, password)
assert status == 0
def test_set_password_with_invalid_timeout_policy_value(self):
policy = {'timeout': 0.1}
user = "testsetpassworduser"
password = "newpassword"
try:
self.client.admin_set_password(user, password, policy)
except e.ParamError as exception:
assert exception.code == -2
assert exception.msg == "timeout is invalid"
def test_set_password_with_proper_timeout_policy_value(self):
policy = {'timeout': 50}
user = "testsetpassworduser"
password = "newpassword"
status = self.client.admin_set_password(user, password, policy)
assert status == 0
def test_set_password_with_none_username(self):
user = None
password = "newpassword"
try:
self.client.admin_set_password(user, password)
except e.ParamError as exception:
assert exception.code == -2
assert exception.msg == "Username should be a string"
def test_set_password_with_none_password(self):
user = "testsetpassworduser"
password = None
try:
self.client.admin_set_password(user, password)
except e.ParamError as exception:
assert exception.code == -2
assert exception.msg == "Password should be a string"
def test_set_password_with_non_existent_user(self):
policy = {}
user = "new_user"
password = "newpassword"
try:
self.client.admin_set_password(user, password, policy)
except e.InvalidUser as exception:
assert exception.code == 60
assert exception.msg == "AEROSPIKE_INVALID_USER"
def test_set_password_with_too_long_password(self):
policy = {}
user = "testsetpassworduser"
password = "newpassword$" * 1000
status = self.client.admin_set_password(user, password, policy)
assert status == 0
|
data/SimonSapin/Flask-FlatPages/flask_flatpages/compat.py
|
"""
======================
flask_flatpages.compat
======================
Compatibility module for supporting both Python 2 and Python 3.
"""
import sys
IS_PY3 = sys.version_info[0] == 3
string_types = (str, ) if IS_PY3 else (basestring, )
text_type = str if IS_PY3 else unicode
def itervalues(obj, **kwargs):
"""Iterate over dict values."""
return iter(obj.values(**kwargs)) if IS_PY3 else obj.itervalues(**kwargs)
|
data/MontmereLimited/django-lean/django_lean/utils.py
|
from contextlib import contextmanager
from django.contrib.sites.models import Site
from django.core import mail
from django.db import transaction
from django.utils.functional import LazyObject
def get_current_site():
if Site._meta.installed:
return Site.objects.get_current()
return None
def in_transaction(test_ignore=True):
result = transaction.is_managed()
if test_ignore:
result = result and not hasattr(mail, 'outbox')
return result
@contextmanager
def patch(namespace, name, function):
"""Patches `namespace`.`name` with `function`."""
if isinstance(namespace, LazyObject):
if namespace._wrapped is None:
namespace._setup()
namespace = namespace._wrapped
try:
original = getattr(namespace, name)
except AttributeError:
original = NotImplemented
try:
setattr(namespace, name, function)
yield
finally:
if original is NotImplemented:
delattr(namespace, name)
else:
setattr(namespace, name, original)
|
data/StackStorm/st2/st2common/st2common/models/api/auth.py
|
import six
from oslo_config import cfg
from st2common.util import isotime
from st2common.models.api.base import BaseAPI
from st2common.models.db.auth import UserDB, TokenDB, ApiKeyDB
from st2common import log as logging
LOG = logging.getLogger(__name__)
def get_system_username():
return cfg.CONF.system_user.user
class UserAPI(BaseAPI):
model = UserDB
schema = {
"title": "User",
"type": "object",
"properties": {
"name": {
"type": "string",
"required": True
}
},
"additionalProperties": False
}
@classmethod
def to_model(cls, user):
name = user.name
model = cls.model(name=name)
return model
class TokenAPI(BaseAPI):
model = TokenDB
schema = {
"title": "Token",
"type": "object",
"properties": {
"id": {
"type": "string"
},
"user": {
"type": ["string", "null"]
},
"token": {
"type": ["string", "null"]
},
"ttl": {
"type": "integer",
"minimum": 1
},
"expiry": {
"type": ["string", "null"],
"pattern": isotime.ISO8601_UTC_REGEX
},
"metadata": {
"type": ["object", "null"]
}
},
"additionalProperties": False
}
@classmethod
def from_model(cls, model, mask_secrets=False):
doc = super(cls, cls)._from_model(model, mask_secrets=mask_secrets)
doc['expiry'] = isotime.format(model.expiry, offset=False) if model.expiry else None
return cls(**doc)
@classmethod
def to_model(cls, instance):
user = str(instance.user) if instance.user else None
token = str(instance.token) if instance.token else None
expiry = isotime.parse(instance.expiry) if instance.expiry else None
model = cls.model(user=user, token=token, expiry=expiry)
return model
class ApiKeyAPI(BaseAPI):
model = ApiKeyDB
schema = {
"title": "ApiKey",
"type": "object",
"properties": {
"id": {
"type": "string"
},
"uid": {
"type": "string"
},
"user": {
"type": ["string", "null"],
"default": ""
},
"key_hash": {
"type": ["string", "null"]
},
"metadata": {
"type": ["object", "null"]
},
'created_at': {
'description': 'The start time when the action is executed.',
'type': 'string',
'pattern': isotime.ISO8601_UTC_REGEX
},
"enabled": {
"description": "Enable or disable the action from invocation.",
"type": "boolean",
"default": True
}
},
"additionalProperties": False
}
@classmethod
def from_model(cls, model, mask_secrets=False):
doc = super(cls, cls)._from_model(model, mask_secrets=mask_secrets)
doc['created_at'] = isotime.format(model.created_at, offset=False) if model.created_at \
else None
return cls(**doc)
@classmethod
def to_model(cls, instance):
user = str(instance.user) if instance.user else None
key_hash = getattr(instance, 'key_hash', None)
metadata = getattr(instance, 'metadata', {})
enabled = bool(getattr(instance, 'enabled', True))
model = cls.model(user=user, key_hash=key_hash, metadata=metadata, enabled=enabled)
return model
class ApiKeyCreateResponseAPI(BaseAPI):
schema = {
"title": "APIKeyCreateResponse",
"type": "object",
"properties": {
"id": {
"type": "string"
},
"uid": {
"type": "string"
},
"user": {
"type": ["string", "null"],
"default": ""
},
"key": {
"type": ["string", "null"]
},
"metadata": {
"type": ["object", "null"]
},
'created_at': {
'description': 'The start time when the action is executed.',
'type': 'string',
'pattern': isotime.ISO8601_UTC_REGEX
},
"enabled": {
"description": "Enable or disable the action from invocation.",
"type": "boolean",
"default": True
}
},
"additionalProperties": False
}
@classmethod
def from_model(cls, model, mask_secrets=False):
doc = cls._from_model(model=model, mask_secrets=mask_secrets)
attrs = {attr: value for attr, value in six.iteritems(doc) if value is not None}
attrs['created_at'] = isotime.format(model.created_at, offset=False) if model.created_at \
else None
attrs.pop('key_hash', None)
attrs['key'] = None
return cls(**attrs)
|
data/LLNL/boxfish/boxfish/gl/glutils.py
|
"""
Support for nicely indented GL sections in python using Python's with
statement.
Author:
Todd Gamblin, tgamblin@llnl.gov
"""
from contextlib import contextmanager
from OpenGL.GL import *
@contextmanager
def glSection(type):
glBegin(type)
yield
glEnd()
@contextmanager
def glMatrix():
glPushMatrix()
yield
glPopMatrix()
@contextmanager
def glModeMatrix(type):
glMatrixMode(type)
glPushMatrix()
yield
glMatrixMode(type)
glPopMatrix()
@contextmanager
def attributes(*glBits):
for bit in glBits:
glPushAttrib(bit)
yield
for bit in glBits:
glPopAttrib()
@contextmanager
def enabled(*glBits):
for bit in glBits:
glEnable(bit)
yield
for bit in glBits:
glDisable(bit)
@contextmanager
def disabled(*glBits):
for bit in glBits:
glDisable(bit)
yield
for bit in glBits:
glEnable(bit)
@contextmanager
def overlays2D(width, height, background_color):
"""The before and after gl calls necessary to setup 2D overlays to the
main gl drawing. This should be encase all methods which have a call to
setup_overlay2D.
"""
glDisable(GL_LIGHTING)
glDisable(GL_LIGHT0)
glDisable(GL_BLEND)
glEnable(GL_SCISSOR_TEST)
with glModeMatrix(GL_PROJECTION):
yield
glViewport(0, 0, width, height)
glDisable(GL_SCISSOR_TEST)
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
glEnable(GL_LIGHTING)
glEnable(GL_LIGHT0)
glEnable(GL_BLEND)
glClearColor(*background_color)
def setup_overlay2D(x, y, width, height):
"""Sets up the small 2D overlay area. The background is clear.
"""
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
glScissor(x, y, width, height)
glViewport(x, y, width, height)
glOrtho(x, x + width, y, y + height, -1, 1)
glMatrixMode(GL_MODELVIEW)
cyltrigs = [ 0.587785, 0.809017, 0.951057, 0.309017 ];
def notGlePolyCylinder(points, color, radius):
trigs = [radius * x for x in cyltrigs];
if abs(points[1][0] - points[2][0]) > 1e-6:
with glSection(GL_QUAD_STRIP):
glNormal3f(0, 0, 1.)
glVertex(points[1][0], 0, radius)
glVertex(points[2][0], 0, radius)
glNormal3f(0, cyltrigs[0], cyltrigs[1])
glVertex(points[1][0], trigs[0], trigs[1])
glVertex(points[2][0], trigs[0], trigs[1])
glNormal3f(0, cyltrigs[2], cyltrigs[3])
glVertex(points[1][0], trigs[2], trigs[3])
glVertex(points[2][0], trigs[2], trigs[3])
glNormal3f(0, cyltrigs[2], -cyltrigs[3])
glVertex(points[1][0], trigs[2], -trigs[3])
glVertex(points[2][0], trigs[2], -trigs[3])
glNormal3f(0, cyltrigs[0], -cyltrigs[1])
glVertex(points[1][0], trigs[0], -trigs[1])
glVertex(points[2][0], trigs[0], -trigs[1])
glNormal3f(0, 0, -1.)
glVertex(points[1][0], 0, -radius)
glVertex(points[2][0], 0, -radius)
glNormal3f(0, -cyltrigs[0], -cyltrigs[1])
glVertex(points[1][0], -trigs[0], -trigs[1])
glVertex(points[2][0], -trigs[0], -trigs[1])
glNormal3f(0, -cyltrigs[2], -cyltrigs[3])
glVertex(points[1][0], -trigs[2], -trigs[3])
glVertex(points[2][0], -trigs[2], -trigs[3])
glNormal3f(0, -cyltrigs[2], cyltrigs[3])
glVertex(points[1][0], -trigs[2], trigs[3])
glVertex(points[2][0], -trigs[2], trigs[3])
glNormal3f(0, -cyltrigs[0], cyltrigs[1])
glVertex(points[1][0], -trigs[0], trigs[1])
glVertex(points[2][0], -trigs[0], trigs[1])
glNormal3f(0, 0, 1.)
glVertex(points[1][0], 0, radius)
glVertex(points[2][0], 0, radius)
elif abs(points[1][1] - points[2][1]) > 1e-6:
p1 = points[1][1]
p2 = points[2][1]
with glSection(GL_QUAD_STRIP):
glNormal3f(0, 0, 1.)
glVertex(0, p1, radius)
glVertex(0, p2, radius)
glNormal3f(cyltrigs[0], 0, cyltrigs[1])
glVertex(trigs[0], p1, trigs[1])
glVertex(trigs[0], p2, trigs[1])
glNormal3f(cyltrigs[2], 0, cyltrigs[3])
glVertex(trigs[2], p1, trigs[3])
glVertex(trigs[2], p2, trigs[3])
glNormal3f(cyltrigs[2], 0, -cyltrigs[3])
glVertex(trigs[2], p1, -trigs[3])
glVertex(trigs[2], p2, -trigs[3])
glNormal3f(cyltrigs[0], 0, -cyltrigs[1])
glVertex(trigs[0], p1, -trigs[1])
glVertex(trigs[0], p2, -trigs[1])
glNormal3f(0, 0, -1.)
glVertex(0, p1, -radius)
glVertex(0, p2, -radius)
glNormal3f(-cyltrigs[0], 0, -cyltrigs[1])
glVertex(-trigs[0], p1, -trigs[1])
glVertex(-trigs[0], p2, -trigs[1])
glNormal3f(-cyltrigs[2], 0, -cyltrigs[3])
glVertex(-trigs[2], p1, -trigs[3])
glVertex(-trigs[2], p2, -trigs[3])
glNormal3f(-cyltrigs[2], 0, cyltrigs[3])
glVertex(-trigs[2], p1, trigs[3])
glVertex(-trigs[2], p2, trigs[3])
glNormal3f(-cyltrigs[0], 0, cyltrigs[1])
glVertex(-trigs[0], p1, trigs[1])
glVertex(-trigs[0], p2, trigs[1])
glNormal3f(0, 0, 1.)
glVertex(0, p1, radius)
glVertex(0, p2, radius)
else:
p1 = points[1][2]
p2 = points[2][2]
with glSection(GL_QUAD_STRIP):
glNormal3f(0, 1., 0)
glVertex(0, radius, p1)
glVertex(0, radius, p2)
glNormal3f(cyltrigs[0], cyltrigs[1], 0)
glVertex(trigs[0], trigs[1], p1)
glVertex(trigs[0], trigs[1], p2)
glNormal3f(cyltrigs[2], cyltrigs[3], 0)
glVertex(trigs[2], trigs[3], p1)
glVertex(trigs[2], trigs[3], p2)
glNormal3f(cyltrigs[2], -cyltrigs[3], 0)
glVertex(trigs[2], -trigs[3], p1)
glVertex(trigs[2], -trigs[3], p2)
glNormal3f(cyltrigs[0], -cyltrigs[1], 0)
glVertex(trigs[0], -trigs[1], p1)
glVertex(trigs[0], -trigs[1], p2)
glNormal3f(0, -1., 0)
glVertex(0, -radius, p1)
glVertex(0, -radius, p2)
glNormal3f(-cyltrigs[0], -cyltrigs[1], 0)
glVertex(-trigs[0], -trigs[1], p1)
glVertex(-trigs[0], -trigs[1], p2)
glNormal3f(-cyltrigs[2], -cyltrigs[3], 0)
glVertex(-trigs[2], -trigs[3], p1)
glVertex(-trigs[2], -trigs[3], p2)
glNormal3f(-cyltrigs[2], cyltrigs[3], 0)
glVertex(-trigs[2], trigs[3], p1)
glVertex(-trigs[2], trigs[3], p2)
glNormal3f(-cyltrigs[0], cyltrigs[1], 0)
glVertex(-trigs[0], trigs[1], p1)
glVertex(-trigs[0], trigs[1], p2)
glNormal3f(0, 1., 0)
glVertex(0, radius, p1)
glVertex(0, radius, p2)
def notGlutSolidCube(size):
p = size / 2
n = -1 * p
with glSection(GL_QUADS):
glNormal3f(0, 0, 1.)
glVertex(n, p, n)
glVertex(n, n, n)
glVertex(p, n, n)
glVertex(p, p, n)
with glSection(GL_QUADS):
glNormal3f(0, 1., 0)
glVertex(n, p, p)
glVertex(n, p, n)
glVertex(p, p, n)
glVertex(p, p, p)
with glSection(GL_QUADS):
glNormal3f(1., 0, 0)
glVertex(p, p, n)
glVertex(p, n, n)
glVertex(p, n, p)
glVertex(p, p, p)
with glSection(GL_QUADS):
glNormal3f(0, 0, -1.)
glVertex(p, p, p)
glVertex(p, n, p)
glVertex(n, n, p)
glVertex(n, p, p)
with glSection(GL_QUADS):
glNormal3f(0, -1., 0)
glVertex(p, n, p)
glVertex(p, n, n)
glVertex(n, n, n)
glVertex(n, n, p)
with glSection(GL_QUADS):
glNormal3f(-1., 0, 0)
glVertex(n, p, p)
glVertex(n, n, p)
glVertex(n, n, n)
glVertex(n, p, n)
class DisplayList(object):
"""Use this to turn some rendering function of yours into a DisplayList,
without all the tedious setup.
Suppose you have a rendering function that looks like this:
def myRenderFunction():
And you want to use it to build a displayList:
myList = DisplayList(myRenderFunction)
Now to call the list, just do this:
myList()
If you want the render function to get called again the next time your
display list is called, you call "update()" on the display list:
myList.update()
Now the next call to myList() will generate you a new display list by
running your render function again. After that, it just calls the
new list.
Note that your render function *can* take args, and you can pass them
when you call the display list, but they're only really passed along
when an update is needed, so it's probably best to just not make
render functions with arguments.
TODO: this should probably have ways to keep around active list ids so
TODO: that they can be freed up at the end of execution.
"""
def __init__(self, renderFunction):
self.renderFunction = renderFunction
self.needsUpdate = True
self.listId = None
def update(self):
self.needsUpdate = True
def __call__(self, *args):
if self.needsUpdate:
if self.listId:
glDeleteLists(self.listId, 1)
self.listId = glGenLists(1)
glNewList(self.listId, GL_COMPILE_AND_EXECUTE)
self.renderFunction(*args)
glEndList()
self.needsUpdate = False
else:
glCallList(self.listId)
|
data/ProgVal/Limnoria/plugins/MoobotFactoids/__init__.py
|
"""
Moobot factoid compatibility module. Moobot's factoids were originally
designed to emulate Blootbot's factoids, so in either case, you should find
this plugin comfortable.
"""
import supybot
import supybot.world as world
__version__ = "0.1"
__author__ = supybot.authors.strike
__contributors__ = {}
from . import config
from . import plugin
from imp import reload
reload(plugin)
if world.testing:
from . import test
Class = plugin.Class
configure = config.configure
|
data/agoragames/haigha/tests/unit/transports/gevent_transport_test.py
|
'''
Copyright (c) 2011-2015, Agora Games, LLC All rights reserved.
https://github.com/agoragames/haigha/blob/master/LICENSE.txt
'''
from chai import Chai
import errno
import unittest
try:
import gevent
from gevent.coros import Semaphore
from gevent import socket
from gevent.pool import Pool
from haigha.transports import gevent_transport
from haigha.transports.gevent_transport import *
except ImportError:
import warnings
warnings.warn('Failed to load gevent modules')
gevent = None
@unittest.skipIf(gevent is None, 'skipping gevent tests')
class GeventTransportTest(Chai):
def setUp(self):
super(GeventTransportTest, self).setUp()
self.connection = mock()
self.transport = GeventTransport(self.connection)
self.transport._host = 'server:1234'
def test_init(self):
assert_equals(bytearray(), self.transport._buffer)
assert_true(isinstance(self.transport._read_lock, Semaphore))
assert_true(isinstance(self.transport._write_lock, Semaphore))
def test_connect(self):
with expect(mock(gevent_transport, 'super')).args(is_arg(GeventTransport), GeventTransport).returns(mock()) as parent:
expect(parent.connect).args(
('host', 'port'), klass=is_arg(socket.socket)).returns('somedata')
self.transport.connect(('host', 'port'))
def test_read(self):
expect(self.transport._read_lock.acquire)
with expect(mock(gevent_transport, 'super')).args(is_arg(GeventTransport), GeventTransport).returns(mock()) as parent:
expect(parent.read).args(timeout=None).returns('somedata')
expect(self.transport._read_lock.release)
expect(self.transport._read_wait.set)
expect(self.transport._read_wait.clear)
assert_equals('somedata', self.transport.read())
def test_read_when_already_locked(self):
expect(self.transport._read_lock.locked).returns(True)
stub(self.transport._read_lock.acquire)
stub(mock(gevent_transport, 'super'))
stub(self.transport._read_lock.release)
expect(self.transport._read_wait.wait)
assert_equals(None, self.transport.read())
def test_read_when_raises_exception(self):
expect(self.transport._read_lock.acquire)
with expect(mock(gevent_transport, 'super')).args(is_arg(GeventTransport), GeventTransport).returns(mock()) as parent:
expect(parent.read).args(timeout='5').raises(Exception('fail'))
expect(self.transport._read_lock.release)
assert_raises(Exception, self.transport.read, timeout='5')
def test_buffer(self):
expect(self.transport._read_lock.acquire)
with expect(mock(gevent_transport, 'super')).args(is_arg(GeventTransport), GeventTransport).returns(mock()) as parent:
expect(parent.buffer).args('datas')
expect(self.transport._read_lock.release)
self.transport.buffer('datas')
def test_buffer_when_raises_exception(self):
expect(self.transport._read_lock.acquire)
with expect(mock(gevent_transport, 'super')).args(is_arg(GeventTransport), GeventTransport).returns(mock()) as parent:
expect(parent.buffer).args('datas').raises(Exception('fail'))
expect(self.transport._read_lock.release)
assert_raises(Exception, self.transport.buffer, 'datas')
def test_write(self):
expect(self.transport._write_lock.acquire)
with expect(mock(gevent_transport, 'super')).args(is_arg(GeventTransport), GeventTransport).returns(mock()) as parent:
expect(parent.write).args('datas')
expect(self.transport._write_lock.release)
self.transport.write('datas')
def test_write_when_raises_an_exception(self):
expect(self.transport._write_lock.acquire)
with expect(mock(gevent_transport, 'super')).args(is_arg(GeventTransport), GeventTransport).returns(mock()) as parent:
expect(parent.write).args('datas').raises(Exception('fail'))
expect(self.transport._write_lock.release)
assert_raises(Exception, self.transport.write, 'datas')
@unittest.skipIf(gevent is None, 'skipping gevent tests')
class GeventPoolTransportTest(Chai):
def setUp(self):
super(GeventPoolTransportTest, self).setUp()
self.connection = mock()
self.transport = GeventPoolTransport(self.connection)
self.transport._host = 'server:1234'
def test_init(self):
assert_equals(bytearray(), self.transport._buffer)
assert_true(isinstance(self.transport._read_lock, Semaphore))
assert_true(isinstance(self.transport.pool, Pool))
trans = GeventPoolTransport(self.connection, pool='inground')
assert_equals('inground', trans.pool)
def test_process_channels(self):
chs = [mock(), mock()]
self.transport._pool = mock()
expect(self.transport._pool.spawn).args(chs[0].process_frames)
expect(self.transport._pool.spawn).args(chs[1].process_frames)
self.transport.process_channels(chs)
|
data/SUSE/azurectl/azurectl/azurectl_exceptions.py
|
class AzureError(Exception):
"""
Base class to handle all known exceptions. Specific exceptions
are sub classes of this base class
"""
def __init__(self, message):
self.message = message
def __str__(self):
return repr(self.message)
class AzureAccountConfigurationError(AzureError):
pass
class AzureAccountDefaultSectionNotFound(AzureError):
pass
class AzureAccountLoadFailed(AzureError):
pass
class AzureBlobServicePropertyError(AzureError):
pass
class AzureCannotInit(AzureError):
pass
class AzureCloudServiceAddCertificateError(AzureError):
pass
class AzureCloudServiceAddressError(AzureError):
pass
class AzureCloudServiceCreateError(AzureError):
pass
class AzureCloudServiceDeleteError(AzureError):
pass
class AzureCloudServiceOpenSSLError(AzureError):
pass
class AzureCommandNotLoaded(AzureError):
pass
class AzureConfigDefaultLinkError(AzureError):
pass
class AzureConfigAccountFileNotFound(AzureError):
pass
class AzureConfigAccountNotFound(AzureError):
pass
class AzureConfigAddAccountSectionError(AzureError):
pass
class AzureConfigAddRegionSectionError(AzureError):
pass
class AzureConfigParseError(AzureError):
pass
class AzureConfigPublishSettingsError(AzureError):
pass
class AzureConfigRegionNotFound(AzureError):
pass
class AzureConfigSectionNotFound(AzureError):
pass
class AzureConfigVariableNotFound(AzureError):
pass
class AzureConfigWriteError(AzureError):
pass
class AzureContainerCreateError(AzureError):
pass
class AzureContainerDeleteError(AzureError):
pass
class AzureContainerListContentError(AzureError):
pass
class AzureContainerListError(AzureError):
pass
class AzureDataDiskCreateError(AzureError):
pass
class AzureDataDiskDeleteError(AzureError):
pass
class AzureDataDiskNoAvailableLun(AzureError):
pass
class AzureDataDiskShowError(AzureError):
pass
class AzureDomainLookupError(AzureError):
pass
class AzureEndpointCreateError(AzureError):
pass
class AzureEndpointDeleteError(AzureError):
pass
class AzureEndpointListError(AzureError):
pass
class AzureEndpointShowError(AzureError):
pass
class AzureFileShareCreateError(AzureError):
pass
class AzureFileShareDeleteError(AzureError):
pass
class AzureFileShareListError(AzureError):
pass
class AzureHelpNoCommandGiven(AzureError):
pass
class AzureImageNotReachableByCloudServiceError(AzureError):
pass
class AzureInvalidCommand(AzureError):
pass
class AzureLoadCommandUndefined(AzureError):
pass
class AzureManagementCertificateNotFound(AzureError):
pass
class AzureOsImageCreateError(AzureError):
pass
class AzureOsImageDeleteError(AzureError):
pass
class AzureOsImageDetailsShowError(AzureError):
pass
class AzureOsImageListError(AzureError):
pass
class AzureOsImagePublishError(AzureError):
pass
class AzureOsImageReplicateError(AzureError):
pass
class AzureOsImageShowError(AzureError):
pass
class AzureOsImageUnReplicateError(AzureError):
pass
class AzureOsImageUpdateError(AzureError):
pass
class AzurePageBlobAlignmentViolation(AzureError):
pass
class AzurePageBlobSetupError(AzureError):
pass
class AzurePageBlobUpdateError(AzureError):
pass
class AzurePageBlobZeroPageError(AzureError):
pass
class AzureRequestError(AzureError):
pass
class AzureRequestStatusError(AzureError):
pass
class AzureRequestTimeout(AzureError):
pass
class AzureReservedIpCreateError(AzureError):
pass
class AzureReservedIpDeleteError(AzureError):
pass
class AzureReservedIpListError(AzureError):
pass
class AzureReservedIpShowError(AzureError):
pass
class AzureSSHKeyFileNotFound(AzureError):
pass
class AzureServiceManagementError(AzureError):
pass
class AzureServiceManagementUrlNotFound(AzureError):
pass
class AzureStorageAccountCreateError(AzureError):
pass
class AzureStorageAccountDeleteError(AzureError):
pass
class AzureStorageAccountListError(AzureError):
pass
class AzureStorageAccountShowError(AzureError):
pass
class AzureStorageAccountUpdateError(AzureError):
pass
class AzureStorageDeleteError(AzureError):
pass
class AzureStorageFileNotFound(AzureError):
pass
class AzureStorageListError(AzureError):
pass
class AzureStorageNotReachableByCloudServiceError(AzureError):
pass
class AzureStorageStreamError(AzureError):
pass
class AzureStorageUploadError(AzureError):
pass
class AzureSubscriptionCertificateDecodeError(AzureError):
pass
class AzureSubscriptionIdNotFound(AzureError):
pass
class AzureSubscriptionPKCS12DecodeError(AzureError):
pass
class AzureSubscriptionParseError(AzureError):
pass
class AzureSubscriptionPrivateKeyDecodeError(AzureError):
pass
class AzureUnknownCommand(AzureError):
pass
class AzureUnknownServiceName(AzureError):
pass
class AzureUnrecognizedManagementUrl(AzureError):
pass
class AzureVmCreateError(AzureError):
pass
class AzureVmDeleteError(AzureError):
pass
class AzureXZError(AzureError):
pass
|
data/Stiivi/brewery/brewery/tests/test_sql_streams.py
|
import unittest
import threading
import time
from brewery import ds
import brewery.metadata
from sqlalchemy import Table, Column, Integer, String, Text
from sqlalchemy import create_engine, MetaData
class SQLStreamsTestCase(unittest.TestCase):
def setUp(self):
self.engine = create_engine("sqlite://")
self.metadata = MetaData()
self.fields = brewery.metadata.FieldList([
("category", "string"),
("category_label", "string"),
("subcategory", "string"),
("subcategory_label", "string"),
("line_item", "string"),
("year", "integer"),
("amount", "integer")])
self.example_row = ["cat", "Category", "scat", "Sub-category", "foo", 2012, 100]
def test_table_fields(self):
table = Table('users', self.metadata,
Column('id', Integer, primary_key=True),
Column('login', String(32)),
Column('full_name', String(255)),
Column('profile', Text)
)
self.metadata.create_all(self.engine)
stream = ds.SQLDataSource(connection=self.engine, table=str(table))
fields = stream.fields
self.assertEqual(4, len(fields))
def test_target_no_existing_table(self):
stream = ds.SQLDataTarget(connection=self.engine, table="test")
self.assertRaises(Exception, stream.initialize)
def test_target_create_table(self):
stream = ds.SQLDataTarget(connection=self.engine, table="test", create=True)
self.assertRaises(Exception, stream.initialize)
stream.fields = self.fields
stream.initialize()
cnames = [str(c) for c in stream.table.columns]
fnames = ["test."+f.name for f in self.fields]
self.assertEqual(fnames, cnames)
stream.finalize()
def test_target_replace_table(self):
table = Table('test', self.metadata,
Column('id', Integer, primary_key=True),
Column('login', String(32)),
Column('full_name', String(255)),
Column('profile', Text)
)
self.metadata.create_all(self.engine)
stream = ds.SQLDataTarget(connection=self.engine, table="test",
create=True, replace = False)
stream.fields = self.fields
self.assertRaises(Exception, stream.initialize)
stream = ds.SQLDataTarget(connection=self.engine, table="test",
create=True, replace = True)
stream.fields = self.fields
stream.initialize()
cnames = [str(c) for c in stream.table.columns]
fnames = ["test."+f.name for f in self.fields]
self.assertEqual(fnames, cnames)
stream.finalize()
def test_target_concrete_type_map(self):
ctm = {"string": String(123)}
stream = ds.SQLDataTarget(connection=self.engine, table="test",
create=True,
fields=self.fields,
concrete_type_map=ctm)
stream.initialize()
c = stream.table.c["line_item"]
self.assertEqual(123, c.type.length)
|
data/PyHDI/veriloggen/tests/core/cond/cond.py
|
from __future__ import absolute_import
from __future__ import print_function
import sys
import os
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))))
from veriloggen import *
def mkLed():
m = Module('blinkled')
width = m.Parameter('WIDTH', 8)
clk = m.Input('CLK')
rst = m.Input('RST')
led = m.OutputReg('LED', width)
count = m.Reg('count', 32)
m.Always(Posedge(clk))(
If(rst)(
count(0)
).Else(
count( Cond(count==1023, 0, count + 1) )
))
m.Always(Posedge(clk))(
If(rst)(
led(0)
).Else(
led( Cond(count==1024-1, led+1, led) )
))
return m
if __name__ == '__main__':
led = mkLed()
verilog = led.to_verilog('')
print(verilog)
|
data/OpenCobolIDE/OpenCobolIDE/open_cobol_ide/extlibs/future/backports/email/__init__.py
|
"""
Backport of the Python 3.3 email package for Python-Future.
A package for parsing, handling, and generating email messages.
"""
from __future__ import unicode_literals
from __future__ import division
from __future__ import absolute_import
from future.utils import surrogateescape
surrogateescape.register_surrogateescape()
__version__ = '5.1.0'
__all__ = [
'base64mime',
'charset',
'encoders',
'errors',
'feedparser',
'generator',
'header',
'iterators',
'message',
'message_from_file',
'message_from_binary_file',
'message_from_string',
'message_from_bytes',
'mime',
'parser',
'quoprimime',
'utils',
]
def message_from_string(s, *args, **kws):
"""Parse a string into a Message object model.
Optional _class and strict are passed to the Parser constructor.
"""
from future.backports.email.parser import Parser
return Parser(*args, **kws).parsestr(s)
def message_from_bytes(s, *args, **kws):
"""Parse a bytes string into a Message object model.
Optional _class and strict are passed to the Parser constructor.
"""
from future.backports.email.parser import BytesParser
return BytesParser(*args, **kws).parsebytes(s)
def message_from_file(fp, *args, **kws):
"""Read a file and parse its contents into a Message object model.
Optional _class and strict are passed to the Parser constructor.
"""
from future.backports.email.parser import Parser
return Parser(*args, **kws).parse(fp)
def message_from_binary_file(fp, *args, **kws):
"""Read a binary file and parse its contents into a Message object model.
Optional _class and strict are passed to the Parser constructor.
"""
from future.backports.email.parser import BytesParser
return BytesParser(*args, **kws).parse(fp)
|
data/Pylons/venusian/venusian/tests/fixtures/category.py
|
from venusian.tests.fixtures import categorydecorator
from venusian.tests.fixtures import categorydecorator2
@categorydecorator(function=True)
def function(request):
return request
@categorydecorator2(function=True)
def function2(request):
return request
|
data/Kozea/WeasyPrint/weasyprint/layout/float.py
|
"""
weasyprint.float
----------------
:copyright: Copyright 2011-2014 Simon Sapin and contributors, see AUTHORS.
:license: BSD, see LICENSE for details.
"""
from __future__ import division, unicode_literals
from .markers import list_marker_layout
from .min_max import handle_min_max_width
from .percentages import resolve_percentages, resolve_position_percentages
from .preferred import shrink_to_fit
from .tables import table_wrapper_width
from ..formatting_structure import boxes
@handle_min_max_width
def float_width(box, context, containing_block):
if box.width == 'auto':
box.width = shrink_to_fit(context, box, containing_block.width)
def float_layout(context, box, containing_block, device_size, absolute_boxes,
fixed_boxes):
"""Set the width and position of floating ``box``."""
from .blocks import block_container_layout
from .inlines import inline_replaced_box_width_height
resolve_percentages(box, (containing_block.width, containing_block.height))
resolve_position_percentages(
box, (containing_block.width, containing_block.height))
if box.margin_left == 'auto':
box.margin_left = 0
if box.margin_right == 'auto':
box.margin_right = 0
if box.margin_top == 'auto':
box.margin_top = 0
if box.margin_bottom == 'auto':
box.margin_bottom = 0
clearance = get_clearance(context, box)
if clearance is not None:
box.position_y += clearance
if isinstance(box, boxes.BlockReplacedBox):
inline_replaced_box_width_height(box, device_size=None)
elif box.width == 'auto':
float_width(box, context, containing_block)
if box.is_table_wrapper:
table_wrapper_width(
context, box, (containing_block.width, containing_block.height))
if isinstance(box, boxes.BlockBox):
context.create_block_formatting_context()
box, _, _, _, _ = block_container_layout(
context, box, max_position_y=float('inf'),
skip_stack=None, device_size=device_size, page_is_empty=False,
absolute_boxes=absolute_boxes, fixed_boxes=fixed_boxes,
adjoining_margins=None)
list_marker_layout(context, box)
context.finish_block_formatting_context(box)
else:
assert isinstance(box, boxes.BlockReplacedBox)
box = find_float_position(context, box, containing_block)
context.excluded_shapes.append(box)
return box
def find_float_position(context, box, containing_block):
"""Get the right position of the float ``box``."""
if context.excluded_shapes:
highest_y = context.excluded_shapes[-1].position_y
if box.position_y < highest_y:
box.translate(0, highest_y - box.position_y)
position_x, position_y, available_width = avoid_collisions(
context, box, containing_block)
if box.style.float == 'right':
position_x += available_width - box.margin_width()
box.translate(position_x - box.position_x, position_y - box.position_y)
return box
def get_clearance(context, box, collapsed_margin=0):
"""Return None if there is no clearance, otherwise the clearance value."""
clearance = None
hypothetical_position = box.position_y + collapsed_margin
for excluded_shape in context.excluded_shapes:
if box.style.clear in (excluded_shape.style.float, 'both'):
y, h = excluded_shape.position_y, excluded_shape.margin_height()
if hypothetical_position < y + h:
clearance = max(
(clearance or 0), y + h - hypothetical_position)
return clearance
def avoid_collisions(context, box, containing_block, outer=True):
excluded_shapes = context.excluded_shapes
position_y = box.position_y if outer else box.border_box_y()
box_width = box.margin_width() if outer else box.border_width()
box_height = box.margin_height() if outer else box.border_height()
if box.border_height() == 0 and box.is_floated():
return 0, 0, containing_block.width
while True:
colliding_shapes = [
shape for shape in excluded_shapes
if (shape.position_y < position_y <
shape.position_y + shape.margin_height()) or
(shape.position_y < position_y + box_height <
shape.position_y + shape.margin_height()) or
(shape.position_y >= position_y and
shape.position_y + shape.margin_height() <=
position_y + box_height)
]
left_bounds = [
shape.position_x + shape.margin_width()
for shape in colliding_shapes
if shape.style.float == 'left']
right_bounds = [
shape.position_x
for shape in colliding_shapes
if shape.style.float == 'right']
max_left_bound = containing_block.content_box_x()
max_right_bound = \
containing_block.content_box_x() + containing_block.width
if not outer:
max_left_bound += box.margin_left
max_right_bound -= box.margin_right
if left_bounds or right_bounds:
if left_bounds:
max_left_bound = max(max(left_bounds), max_left_bound)
if right_bounds:
max_right_bound = min(min(right_bounds), max_right_bound)
if box_width > max_right_bound - max_left_bound:
new_positon_y = min(
shape.position_y + shape.margin_height()
for shape in colliding_shapes)
if new_positon_y > position_y:
position_y = new_positon_y
continue
break
position_x = max_left_bound
available_width = max_right_bound - max_left_bound
if not outer:
position_x -= box.margin_left
position_y -= box.margin_top
return position_x, position_y, available_width
|
data/Toblerity/Shapely/tests/__init__.py
|
import sys
from shapely.geos import geos_version_string, lgeos, WKTWriter
from shapely import speedups
test_int_types = [int]
try:
import numpy
numpy_version = numpy.version.version
test_int_types.extend([int, numpy.int16, numpy.int32, numpy.int64])
except ImportError:
numpy = False
numpy_version = 'not available'
print('Python version: ' + sys.version.replace('\n', ' '))
print('GEOS version: ' + geos_version_string)
print('Numpy version: ' + numpy_version)
print('Cython speedups: ' + str(speedups.available))
if lgeos.geos_version >= (3, 3, 0):
WKTWriter.defaults = {}
if sys.version_info[0:2] <= (2, 6):
import unittest2 as unittest
else:
import unittest
|
data/MontmereLimited/django-lean/django_lean/experiments/migrations/0001_initial.py
|
from south.db import db
from django.db import models
from django_lean.experiments.models import *
class Migration:
def forwards(self, orm):
db.create_table('experiments_experiment', (
('id', orm['experiments.Experiment:id']),
('name', orm['experiments.Experiment:name']),
('state', orm['experiments.Experiment:state']),
('start_date', orm['experiments.Experiment:start_date']),
('end_date', orm['experiments.Experiment:end_date']),
))
db.send_create_signal('experiments', ['Experiment'])
db.create_table('experiments_participant', (
('id', orm['experiments.Participant:id']),
('user', orm['experiments.Participant:user']),
('experiment', orm['experiments.Participant:experiment']),
('enrollment_date', orm['experiments.Participant:enrollment_date']),
('group', orm['experiments.Participant:group']),
))
db.send_create_signal('experiments', ['Participant'])
db.create_table('experiments_dailyreport', (
('id', orm['experiments.DailyReport:id']),
('date', orm['experiments.DailyReport:date']),
('experiment', orm['experiments.DailyReport:experiment']),
('test_score', orm['experiments.DailyReport:test_score']),
('control_score', orm['experiments.DailyReport:control_score']),
))
db.send_create_signal('experiments', ['DailyReport'])
db.create_unique('experiments_participant', ['user_id', 'experiment_id'])
def backwards(self, orm):
db.delete_table('experiments_experiment')
db.delete_table('experiments_participant')
db.delete_table('experiments_dailyreport')
db.delete_unique('experiments_participant', ['user_id', 'experiment_id'])
models = {
'auth.group': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '80', 'unique': 'True'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'blank': 'True'})
},
'auth.permission': {
'Meta': {'unique_together': "(('content_type', 'codename'),)"},
'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
'auth.user': {
'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True', 'blank': 'True'}),
'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'blank': 'True'}),
'username': ('django.db.models.fields.CharField', [], {'max_length': '30', 'unique': 'True'})
},
'contenttypes.contenttype': {
'Meta': {'unique_together': "(('app_label', 'model'),)", 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'experiments.dailyreport': {
'control_score': ('django.db.models.fields.FloatField', [], {}),
'date': ('django.db.models.fields.DateField', [], {}),
'experiment': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['experiments.Experiment']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'test_score': ('django.db.models.fields.FloatField', [], {})
},
'experiments.experiment': {
'end_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '128', 'unique': 'True'}),
'start_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'state': ('django.db.models.fields.IntegerField', [], {'default': '0'})
},
'experiments.participant': {
'Meta': {'unique_together': "(('user', 'experiment'),)"},
'enrollment_date': ('django.db.models.fields.DateField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'experiment': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['experiments.Experiment']"}),
'group': ('django.db.models.fields.IntegerField', [], {}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']"})
}
}
complete_apps = ['experiments']
|
data/adamcharnock/django-su/django_su/tests/test_backends.py
|
from django.test import TestCase
try:
from django.contrib.auth import get_user_model
User = get_user_model()
except ImportError:
from django.contrib.auth.models import User
class TestSuBackend(TestCase):
def setUp(self):
super(TestSuBackend, self).setUp()
from django_su.backends import SuBackend
self.user = User.objects.create(username='testuser')
self.backend = SuBackend()
def test_authenticate_do_it(self):
"""Ensure authentication passes when su=True and user id is valid"""
self.assertEqual(
self.backend.authenticate(su=True, user_id=self.user.pk),
self.user
)
def test_authenticate_dont_do_it(self):
"""Ensure authentication fails when su=False and user id is valid"""
self.assertEqual(
self.backend.authenticate(su=False, user_id=self.user.pk),
None
)
def test_authenticate_id_none(self):
"""Ensure authentication fails when user_id is None"""
self.assertEqual(
self.backend.authenticate(su=True, user_id=None),
None
)
def test_authenticate_id_non_existent(self):
"""Ensure authentication fails when user_id doesn't exist"""
self.assertEqual(
self.backend.authenticate(su=True, user_id=999),
None
)
def test_authenticate_id_invalid(self):
"""Ensure authentication fails when user_id is invalid"""
self.assertEqual(
self.backend.authenticate(su=True, user_id='abc'),
None
)
def test_get_user_exists(self):
"""Ensure get_user returns the expected user"""
self.assertEqual(
self.backend.get_user(user_id=self.user.pk),
self.user
)
def test_get_user_does_not_exist(self):
"""Ensure get_user returns None if user is not found"""
self.assertEqual(
self.backend.get_user(user_id=999),
None
)
|
data/OpenBazaar/OpenBazaar-Installer/windows/PyNaCl-0.3.0-py2.7-win-amd64.egg/nacl/_lib/__init__.py
|
from __future__ import absolute_import, division, print_function
import glob
import os.path
from cffi import FFI
from cffi.verifier import Verifier
__all__ = ["ffi"]
HEADERS = glob.glob(
os.path.join(os.path.abspath(os.path.dirname(__file__)), "*.h")
)
ffi = FFI()
for header in sorted(HEADERS):
with open(header, "r") as hfile:
ffi.cdef(hfile.read())
ffi.verifier = Verifier(
ffi,
"
libraries=["sodium"],
ext_package="nacl._lib",
)
class Library(object):
def __init__(self, ffi):
self.ffi = ffi
self._lib = None
def _compile_module(*args, **kwargs):
raise RuntimeError("Cannot compile module during runtime")
self.ffi.verifier.compile_module = _compile_module
def __getattr__(self, name):
if self._lib is None:
self._lib = self.ffi.verifier.load_library()
return getattr(self._lib, name)
lib = Library(ffi)
|
data/PyTables/PyTables/c-blosc/bench/plot-speeds.py
|
"""Script for plotting the results of the 'suite' benchmark.
Invoke without parameters for usage hints.
:Author: Francesc Alted
:Date: 2010-06-01
"""
import matplotlib as mpl
from pylab import *
KB_ = 1024
MB_ = 1024*KB_
GB_ = 1024*MB_
NCHUNKS = 128
linewidth=2
markers= [ 's', 'o', 'v', '^', '+', 'x', '>', '<', '.', ',' ]
markersize = 8
def get_values(filename):
f = open(filename)
values = {"memcpyw": [], "memcpyr": []}
for line in f:
if line.startswith('-->'):
tmp = line.split('-->')[1]
nthreads, size, elsize, sbits, codec, shuffle = [i for i in tmp.split(', ')]
nthreads, size, elsize, sbits = map(int, (nthreads, size, elsize, sbits))
values["size"] = size * NCHUNKS / MB_;
values["elsize"] = elsize;
values["sbits"] = sbits;
values["codec"] = codec
values["shuffle"] = shuffle
(ratios, speedsw, speedsr) = ([], [], [])
values[nthreads] = (ratios, speedsw, speedsr)
elif line.startswith('memcpy(write):'):
tmp = line.split(',')[1]
memcpyw = float(tmp.split(' ')[1])
values["memcpyw"].append(memcpyw)
elif line.startswith('memcpy(read):'):
tmp = line.split(',')[1]
memcpyr = float(tmp.split(' ')[1])
values["memcpyr"].append(memcpyr)
elif line.startswith('comp(write):'):
tmp = line.split(',')[1]
speedw = float(tmp.split(' ')[1])
ratio = float(line.split(':')[-1])
speedsw.append(speedw)
ratios.append(ratio)
elif line.startswith('decomp(read):'):
tmp = line.split(',')[1]
speedr = float(tmp.split(' ')[1])
speedsr.append(speedr)
if "OK" not in line:
print "WARNING! OK not found in decomp line!"
f.close()
return nthreads, values
def show_plot(plots, yaxis, legends, gtitle, xmax=None):
xlabel('Compresssion ratio')
ylabel('Speed (MB/s)')
title(gtitle)
xlim(0, xmax)
ylim(0, None)
grid(True)
legend([p[0] for p in plots
if not isinstance(p, mpl.lines.Line2D)],
legends, loc = "best")
if outfile:
print "Saving plot to:", outfile
savefig(outfile, dpi=64)
else:
show()
if __name__ == '__main__':
from optparse import OptionParser
usage = "usage: %prog [-r] [-o outfile] [-t title ] [-d|-c] filename"
compress_title = 'Compression speed'
decompress_title = 'Decompression speed'
yaxis = 'No axis name'
parser = OptionParser(usage=usage)
parser.add_option('-o',
'--outfile',
dest='outfile',
help=('filename for output (many extensions '
'supported, e.g. .png, .jpg, .pdf)'))
parser.add_option('-t',
'--title',
dest='title',
help='title of the plot',)
parser.add_option('-l',
'--limit',
dest='limit',
help='expression to limit number of threads shown',)
parser.add_option('-x',
'--xmax',
dest='xmax',
help='limit the x-axis',
default=None)
parser.add_option('-r', '--report', action='store_true',
dest='report',
help='generate file for reporting ',
default=False)
parser.add_option('-d', '--decompress', action='store_true',
dest='dspeed',
help='plot decompression data',
default=False)
parser.add_option('-c', '--compress', action='store_true',
dest='cspeed',
help='plot compression data',
default=False)
(options, args) = parser.parse_args()
if len(args) == 0:
parser.error("No input arguments")
elif len(args) > 1:
parser.error("Too many input arguments")
else:
pass
if options.report and options.outfile:
parser.error("Can only select one of [-r, -o]")
if options.dspeed and options.cspeed:
parser.error("Can only select one of [-d, -c]")
elif options.cspeed:
options.dspeed = False
plot_title = compress_title
else:
options.dspeed = True
plot_title = decompress_title
filename = args[0]
cspeed = options.cspeed
dspeed = options.dspeed
if options.outfile:
outfile = options.outfile
elif options.report:
if cspeed:
outfile = filename[:filename.rindex('.')] + '-compr.png'
else:
outfile = filename[:filename.rindex('.')] + '-decompr.png'
else:
outfile = None
plots = []
legends = []
nthreads, values = get_values(filename)
if options.limit:
thread_range = eval(options.limit)
else:
thread_range = range(1, nthreads+1)
if options.title:
plot_title = options.title
else:
plot_title += " (%(size).1f MB, %(elsize)d bytes, %(sbits)d bits), %(codec)s %(shuffle)s" % values
gtitle = plot_title
for nt in thread_range:
(ratios, speedw, speedr) = values[nt]
if cspeed:
speed = speedw
else:
speed = speedr
plot_ = plot(ratios, speed, linewidth=2)
plots.append(plot_)
nmarker = nt
if nt >= len(markers):
nmarker = nt%len(markers)
setp(plot_, marker=markers[nmarker], markersize=markersize,
linewidth=linewidth)
legends.append("%d threads" % nt)
if cspeed:
mean = np.mean(values["memcpyw"])
message = "memcpy (write to memory)"
else:
mean = np.mean(values["memcpyr"])
message = "memcpy (read from memory)"
plot_ = axhline(mean, linewidth=3, linestyle='-.', color='black')
text(1.0, mean+50, message)
plots.append(plot_)
show_plot(plots, yaxis, legends, gtitle, xmax=int(options.xmax) if
options.xmax else None)
|
data/StackHut/stackhut/stackhut_toolkit/common/barrister/runtime.py
|
"""
Barrister runtime for Python. Includes all classes used when writing a client or server.
Hacked up for StackHut by StackHut :) Thx
:copyright: 2012 by James Cooper.
:license: MIT, see LICENSE for more details.
"""
import urllib.request
import urllib.error
import urllib.parse
import uuid
import itertools
import logging
import json
from .exceptions import InvalidFunctionError
ERR_PARSE = -32700
ERR_INVALID_REQ = -32600
ERR_METHOD_NOT_FOUND = -32601
ERR_INVALID_PARAMS = -32602
ERR_INTERNAL = -32603
ERR_UNKNOWN = -32000
ERR_INVALID_RESP = -32001
def contract_from_file(fname):
"""
Loads a Barrister IDL JSON from the given file and returns a Contract class
:Parameters:
fname
Filename containing Barrister IDL JSON to load
"""
f = open(fname)
j = f.read()
f.close()
return Contract(json.loads(j))
def unpack_method(method):
"""
Given a JSON-RPC method in: [interface].[function] notation, returns a tuple of the interface
name and function.
For example, unpack_method("MyService.LoadUser") would return: ("MyService", "LoadUser")
:Parameters:
method
String method name
"""
pos = method.find(".")
if pos == -1:
raise RpcException(ERR_METHOD_NOT_FOUND, "Method not found: %s" % method)
iface_name = method[:pos]
func_name = method[pos + 1:]
return iface_name, func_name
def idgen_uuid():
"""
Generates a uuid4 (random) and returns the hex representation as a string
"""
return uuid.uuid4().hex
idgen_seq_counter = itertools.count()
def idgen_seq():
"""
Generates an ID using itertools.count() and returns it as a string
"""
return str(next(idgen_seq_counter))
def err_response(reqid, code, msg, data=None):
"""
Formats a JSON-RPC error as a dict with keys: 'jsonrpc', 'id', 'error'
"""
err = {"code": code, "message": msg}
if data:
err["data"] = data
return {"jsonrpc": "2.0", "id": reqid, "error": err}
def safe_get(d, key, def_val=None):
"""
Helper function to fetch value from a dictionary
* `d` - Dictionary to fetch value from
* `key` - Key to lookup in dictionary
* `def_val` - Default value to return if dict does not have a member with key
"""
if key in d:
return d[key]
else:
return def_val
class RpcException(Exception, json.JSONEncoder):
"""
Represents a JSON-RPC style exception. Server implementations should raise this
exception if they wish to communicate error codes back to Barrister clients.
"""
def __init__(self, code, msg="", data=None):
"""
Creates a new RpcException
:Parameters:
code
Integer representing the error type. Applications may use any positive integer.
msg
Human readable description of the error
data
Optional extra info about the error. Should be a string, int, or list or dict of strings/ints
"""
self.code = code
self.msg = msg
self.data = data
def __str__(self):
s = "RpcException: code=%d msg=%s" % (self.code, self.msg)
if self.data:
s += " data=%s" % (str(self.data))
return s
class RequestContext(object):
"""
Stores state about a single request, including properties passed
into Server.call
"""
def __init__(self, props, req):
"""
Creates a new RequestContext
:Parameters:
props
Dict of meta properties for this request
req
Dict that represents a single JSON-RPC request
"""
self.props = props
self.request = req
self.response = None
self.error = None
def func_name(self):
return unpack_method(self.request["method"])[1]
def get_prop(self, key, default_val=None):
"""
Returns a property set on the context.
:Parameters:
key
String key to lookup in the context props dict
default_val
Value to return if key is not set on the context props
"""
if key in self.props:
return self.props[key]
else:
return default_val
def set_error(self, code, msg, data=None):
"""
Set an error on this request, which will prevent request execution.
Should only be called from "pre" hook methods. If called from a post hook, this
operation will be ignored.
:Parameters:
code
Integer error code
msg
String description of the error
data
Optional additional info about the error. Should be a primitive, or a list or
dict of primitives to avoid serialization issues.
"""
self.error = err_response(self.request["id"], code, msg, data)
class Filter(object):
"""
Base filter class that implements pre and post functions, but no-ops for both.
Subclass this and override pre/post to add filter functionality for your app.
"""
def pre(self, context):
"""
Pre-Handler hook. Called before the RPC request handler is invoked.
If context.send_error is called by any pre filter, then the request handler will
not be invoked, and the error will be returned instead.
:Parameters:
context
RequestContext instance for this request
"""
pass
def post(self, context):
"""
Post-Handler hook. Called after the RPC request handler is invoked.
Post handlers can inspect and log the response, but should not alter it.
:Parameters:
context
RequestContext instance for this request
"""
pass
class Server(object):
"""
Dispatches requests to user created handler classes based on method name.
Also responsible for validating requests and responses to ensure they conform to the
IDL Contract.
"""
def __init__(self, contract, validate_request=True, validate_response=True):
"""
Creates a new Server
:Parameters:
contract
Contract instance that this server should use
validate_request
If True, requests will be validated against the Contract and rejected if they are malformed
validate_response
If True, responses from handler methods will be validated against the Contract and rejected
if they are malformed
"""
logging.basicConfig()
self.log = logging.getLogger("common.barrister")
self.validate_req = validate_request
self.validate_resp = validate_response
self.contract = contract
self.handlers = {}
self.filters = None
def add_handler(self, iface_name, handler):
"""
Associates the given handler with the interface name. If the interface does not exist in
the Contract, an RpcException is raised.
:Parameters:
iface_name
Name of interface that this handler implements
handler
Instance of a class that implements all functions defined on the interface
"""
if self.contract.has_interface(iface_name):
self.handlers[iface_name] = handler
else:
raise RpcException(ERR_INVALID_REQ, "Unknown interface: '%s'" % iface_name)
def set_filters(self, filters):
"""
Sets the filters for the server.
:Parameters:
filters
List of filters to set on this server, or None to remove all filters.
Elements in list should subclass Filter
"""
if filters is None or isinstance(filters, (tuple, list)):
self.filters = filters
else:
self.filters = [filters]
def call_json(self, req_json, props=None):
"""
Deserializes req_json as JSON, invokes self.call(), and serializes result to JSON.
Returns JSON encoded string.
:Parameters:
req_json
JSON-RPC request serialized as JSON string
props
Application defined properties to set on RequestContext for use with filters.
For example: authentication headers. Must be a dict.
"""
try:
req = json.loads(req_json)
except Exception as e:
msg = "Unable to parse JSON: %s" % req_json
return json.dumps(err_response(None, -32700, msg))
return json.dumps(self.call(req, props))
def call(self, req, props=None):
"""
Executes a Barrister request and returns a response. If the request is a list, then the
response will also be a list. If the request is an empty list, a RpcException is raised.
:Parameters:
req
The request. Either a list of dicts, or a single dict.
props
Application defined properties to set on RequestContext for use with filters.
For example: authentication headers. Must be a dict.
"""
resp = None
if self.log.isEnabledFor(logging.DEBUG):
self.log.debug("Request: %s" % str(req))
if isinstance(req, list):
if len(req) < 1:
resp = err_response(None, ERR_INVALID_REQ, "Invalid Request. Empty batch.")
else:
resp = [self._call_and_format(r, props) for r in req]
else:
resp = self._call_and_format(req, props)
if self.log.isEnabledFor(logging.DEBUG):
self.log.debug("Response: %s" % str(resp))
return resp
def _call_and_format(self, req, props=None):
"""
Invokes a single request against a handler using _call() and traps any errors,
formatting them using _err(). If the request is successful it is wrapped in a
JSON-RPC 2.0 compliant dict with keys: 'jsonrpc', 'id', 'result'.
:Parameters:
req
A single dict representing a single JSON-RPC request
props
Application defined properties to set on RequestContext for use with filters.
For example: authentication headers. Must be a dict.
"""
if not isinstance(req, dict):
return err_response(None, ERR_INVALID_REQ,
"Invalid Request. %s is not an object." % str(req))
reqid = None
if "id" in req:
reqid = req["id"]
if props is None:
props = {}
context = RequestContext(props, req)
if self.filters:
for f in self.filters:
f.pre(context)
if context.error:
return context.error
resp = None
try:
result = self._call(context)
resp = {"jsonrpc": "2.0", "id": reqid, "result": result}
except RpcException as e:
resp = err_response(reqid, e.code, e.msg, e.data)
except Exception as e:
self.log.exception("Error processing request: %s" % str(req))
resp = err_response(reqid, ERR_UNKNOWN, "Server error. Check logs for details.",
data={
'exception': str(e)
})
if self.filters:
context.response = resp
for f in self.filters:
f.post(context)
return resp
def _call(self, context):
"""
Executes a single request against a handler. If the req.method == 'common.barrister-idl', the
Contract IDL JSON structure is returned. Otherwise the method is resolved to a handler
based on the interface name, and the appropriate function is called on the handler.
:Parameter:
req
A dict representing a valid JSON-RPC 2.0 request. 'method' must be provided.
"""
req = context.request
if "method" not in req:
raise RpcException(ERR_INVALID_REQ, "Invalid Request. No 'method'.")
method = req["method"]
if method == "common.barrister-idl" or method == "getIdl":
return self.contract.idl_parsed
iface_name, func_name = unpack_method(method)
if iface_name in self.handlers:
iface_impl = self.handlers[iface_name]
func = getattr(iface_impl, func_name)
if func:
if "params" in req:
params = req["params"]
else:
params = []
if self.validate_req:
self.contract.validate_request(iface_name, func_name, params)
if hasattr(iface_impl, "barrister_pre"):
pre_hook = getattr(iface_impl, "barrister_pre")
pre_hook(context, params)
if params:
result = func(*params)
else:
result = func()
if self.validate_resp:
self.contract.validate_response(iface_name, func_name, result)
return result
else:
msg = "Method '%s' not found" % method
raise RpcException(ERR_METHOD_NOT_FOUND, msg)
else:
msg = "No implementation of '%s' found" % iface_name
raise RpcException(ERR_METHOD_NOT_FOUND, msg)
class HttpTransport(object):
"""
A client transport that uses urllib2 to make requests against a HTTP server.
"""
def __init__(self, url, handlers=None, headers=None):
"""
Creates a new HttpTransport
:Parameters:
url
URL of the server endpoint
handlers
Optional list of handlers to pass to urllib2.build_opener()
headers
Optional list of HTTP headers to set on requests. Note that Content-Type will always be set
automatically to "application/json"
"""
if not headers:
headers = {}
headers['Content-Type'] = 'application/json'
self.url = url
self.headers = headers
if handlers:
self.opener = urllib.request.build_opener(*handlers)
else:
self.opener = urllib.request.build_opener()
def request(self, req):
"""
Makes a request against the server and returns the deserialized result.
:Parameters:
req
List or dict representing a JSON-RPC formatted request
"""
data = json.dumps(req)
req = urllib.request.Request(self.url, data, self.headers)
f = self.opener.open(req)
resp = f.read()
f.close()
return json.loads(resp)
class InProcTransport(object):
"""
A client transport that invokes calls directly against a Server instance in process.
This is useful for quickly unit testing services without having to go over the network.
"""
def __init__(self, server):
"""
Creates a new InProcTransport for the given Server
:Parameters:
server
Barrister Server instance to bind this transport to
"""
self.server = server
def request(self, req):
"""
Performs request against the given server.
:Parameters:
req
List or dict representing a JSON-RPC formatted request
"""
return self.server.call(req)
class Client(object):
"""
Main class for consuming a server implementation. Given a transport it loads the IDL from
the server and creates proxy objects that can be called like local classes from your
application code.
With the exception of start_batch, you generally never need to use the methods provided by this
class directly.
For example:
::
client = common.barrister.Client(common.barrister.HttpTransport("http://localhost:8080/OrderManagement"))
status = client.OrderService.getOrderStatus("order-123")
"""
def __init__(self, transport, validate_request=True, validate_response=True,
id_gen=idgen_uuid):
"""
Creates a new Client for the given transport. When the constructor is called the
client immediately makes a request to the server to load the IDL. It then creates
proxies for each interface in the IDL. After constructing a client you can immediately
begin making requests against the proxies.
:Parameters:
transport
Transport object to use to make requests
validate_request
If True, the request will be validated against the Contract and a RpcException raised if
it does not match the IDL
validate_response
If True, the response will be validated against the Contract and a RpcException raised if
it does not match the IDL
id_gen
A callable to use to create request IDs. JSON-RPC request IDs are only used by Barrister
to correlate requests with responses when using a batch, but your application may use them
for logging or other purposes. UUIDs are used by default, but you can substitute another
function if you prefer something shorter.
"""
logging.basicConfig()
self.log = logging.getLogger("common.barrister")
self.transport = transport
self.validate_req = validate_request
self.validate_resp = validate_response
self.id_gen = id_gen
req = {"jsonrpc": "2.0", "method": "common.barrister-idl", "id": "1"}
resp = transport.request(req)
self.contract = Contract(resp["result"])
for k, v in list(self.contract.interfaces.items()):
setattr(self, k, InterfaceClientProxy(self, v))
def get_meta(self):
"""
Returns the dict of metadata from the Contract
"""
return self.contract.meta
def call(self, iface_name, func_name, params):
"""
Makes a single RPC request and returns the result.
:Parameters:
iface_name
Interface name to call
func_name
Function to call on the interface
params
List of parameters to pass to the function
"""
req = self.to_request(iface_name, func_name, params)
if self.log.isEnabledFor(logging.DEBUG):
self.log.debug("Request: %s" % str(req))
resp = self.transport.request(req)
if self.log.isEnabledFor(logging.DEBUG):
self.log.debug("Response: %s" % str(resp))
return self.to_result(iface_name, func_name, resp)
def to_request(self, iface_name, func_name, params):
"""
Converts the arguments to a JSON-RPC request dict. The 'id' field is populated
using the id_gen function passed to the Client constructor.
If validate_request==True on the Client constructor, the params are validated
against the expected types for the function and a RpcException raised if they are
invalid.
:Parameters:
iface_name
Interface name to call
func_name
Function to call on the interface
params
List of parameters to pass to the function
"""
if self.validate_req:
self.contract.validate_request(iface_name, func_name, params)
method = "%s.%s" % (iface_name, func_name)
reqid = self.id_gen()
return {"jsonrpc": "2.0", "id": reqid, "method": method, "params": params}
def to_result(self, iface_name, func_name, resp):
"""
Takes a JSON-RPC response and checks for an "error" slot. If it exists,
a RpcException is raised. If no "error" slot exists, the "result" slot is
returned.
If validate_response==True on the Client constructor, the result is validated
against the expected return type for the function and a RpcException raised if it is
invalid.
:Parameters:
iface_name
Interface name that was called
func_name
Function that was called on the interface
resp
Dict formatted as a JSON-RPC response
"""
if "error" in resp:
e = resp["error"]
data = None
if "data" in e:
data = e["data"]
raise RpcException(e["code"], e["message"], data)
result = resp["result"]
if self.validate_resp:
self.contract.validate_response(iface_name, func_name, result)
return result
def start_batch(self):
"""
Returns a new Batch object for the Client that can be used to make multiple RPC calls
in a single request.
"""
return Batch(self)
class InterfaceClientProxy(object):
"""
Internal class used by the Client. One instance is created per Client per interface found
on the IDL returned from the server.
"""
def __init__(self, client, iface):
"""
Creates a new InterfaceClientProxy
:Parameters:
client
Client instance to associate with this proxy
iface
Dict interface from the parsed IDL. All functions defined on this interface will
be defined on this proxy class as callables.
"""
self.client = client
iface_name = iface.name
for func_name, func in list(iface.functions.items()):
setattr(self, func_name, self._caller(iface_name, func_name))
def _caller(self, iface_name, func_name):
"""
Returns a function for the given interface and function name. When invoked it
calls client.call() with the correct arguments.
:Parameters:
iface_name
Name of interface to call when invoked
func_name
Name of function to call when invoked
params
Params pass to function from the calling application
"""
def caller(*params):
return self.client.call(iface_name, func_name, params)
return caller
class Batch(object):
"""
Provides a way to batch requests together in a single call. This class functions
similiarly to the Client class. InterfaceClientProxy instances are attached to the Batch
instance, but when the application code calls them, the params are stored in memory until
`batch.send()` is called.
"""
def __init__(self, client):
"""
Creates a new Batch for the given Client instance. Rarely called directly. Use
client.start_batch() instead.
:Parameters:
client
Client instance to associate with this Batch
"""
self.client = client
self.req_list = []
self.sent = False
for k, v in list(client.contract.interfaces.items()):
setattr(self, k, InterfaceClientProxy(self, v))
def call(self, iface_name, func_name, params):
"""
Implements the call() function with same signature as Client.call(). Raises
a RpcException if send() has already been called on this batch. Otherwise
appends the request to an internal list.
This method is not commonly called directly.
"""
if self.sent:
raise Exception("Batch already sent. Cannot add more calls.")
else:
req = self.client.to_request(iface_name, func_name, params)
self.req_list.append(req)
def send(self):
"""
Sends the batch request to the server and returns a list of RpcResponse
objects. The list will be in the order that the requests were made to
the batch. Note that the RpcResponse objects may contain an error or a
successful result. When you iterate through the list, you must test for
response.error.
send() may not be called more than once.
"""
if self.sent:
raise Exception("Batch already sent. Cannot send() again.")
else:
self.sent = True
results = self.client.transport.request(self.req_list)
id_to_method = {}
by_id = {}
for res in results:
reqid = res["id"]
by_id[reqid] = res
in_req_order = []
for req in self.req_list:
reqid = req["id"]
result = None
error = None
resp = safe_get(by_id, reqid)
if resp is None:
msg = "Batch response missing result for request id: %s" % reqid
error = RpcException(ERR_INVALID_RESP, msg)
else:
r_err = safe_get(resp, "error")
if r_err is None:
result = resp["result"]
else:
error = RpcException(r_err["code"], r_err["message"], safe_get(r_err, "data"))
in_req_order.append(RpcResponse(req, result, error))
return in_req_order
class RpcResponse(object):
"""
Represents a single response in a batch call. Has the following properties:
* `request` - JSON-RPC request dict
* `result` - Result from this call. Set to None if there was an error.
* `error` - RpcException instance. Set to None if call was successful.
"""
def __init__(self, request, result, error):
self.request = request
self.result = result
self.error = error
class Contract(object):
"""
Represents a single IDL file
"""
def __init__(self, idl_parsed):
"""
Creates a new Contract from the parsed IDL JSON
:Parameters:
idl_parsed
Barrister parsed IDL as a list of dicts
"""
self.idl_parsed = idl_parsed
self.interfaces = {}
self.structs = {}
self.enums = {}
self.meta = {}
for e in idl_parsed:
if e["type"] == "struct":
self.structs[e["name"]] = Struct(e, self)
elif e["type"] == "enum":
self.enums[e["name"]] = Enum(e)
elif e["type"] == "interface":
self.interfaces[e["name"]] = Interface(e, self)
elif e["type"] == "meta":
for k, v in list(e.items()):
if k != "type":
self.meta[k] = v
def validate_request(self, iface_name, func_name, params):
"""
Validates that the given params match the expected length and types for this
interface and function.
Returns two element tuple: (bool, string)
- `bool` - True if valid, False if not
- `string` - Description of validation error, or None if valid
:Parameters:
iface_name
Name of interface
func_name
Name of function
params
List of params to validate against this function
"""
self.interface(iface_name).function(func_name).validate_params(params)
def validate_response(self, iface_name, func_name, resp):
"""
Validates that the response matches the return type for the function
Returns two element tuple: (bool, string)
- `bool` - True if valid, False if not
- `string` - Description of validation error, or None if valid
:Parameters:
iface_name
Name of interface
func_name
Name of function
resp
Result from calling the function
"""
self.interface(iface_name).function(func_name).validate_response(resp)
def get(self, name):
"""
Returns the struct, enum, or interface with the given name, or raises RpcException if
no elements match that name.
:Parameters:
name
Name of struct/enum/interface to return
"""
if name in self.structs:
return self.structs[name]
elif name in self.enums:
return self.enums[name]
elif name in self.interfaces:
return self.interfaces[name]
else:
raise RpcException(ERR_INVALID_PARAMS, "Unknown entity: '%s'" % name)
def struct(self, struct_name):
"""
Returns the struct with the given name, or raises RpcException if no struct matches
"""
if struct_name in self.structs:
return self.structs[struct_name]
else:
raise RpcException(ERR_INVALID_PARAMS, "Unknown struct: '%s'", struct_name)
def has_interface(self, iface_name):
"""
Returns True if an interface exists with the given name. Otherwise returns False
"""
return iface_name in self.interfaces
def interface(self, iface_name):
"""
Returns the interface with the given name, or raises RpcException if no interface matches
"""
if self.has_interface(iface_name):
return self.interfaces[iface_name]
else:
raise RpcException(ERR_INVALID_PARAMS, "Unknown interface: '%s'" % iface_name)
def validate(self, expected_type, is_array, val):
"""
Validates that the expected type matches the value
Returns two element tuple: (bool, string)
- `bool` - True if valid, False if not
- `string` - Description of validation error, or None if valid
:Parameters:
expected_type
string name of the type expected. This may be a Barrister primitive, or a user defined type.
is_array
If True then require that the val be a list
val
Value to validate against the expected type
"""
if val is None:
if expected_type.optional:
return True, None
else:
return False, "Value cannot be null"
elif is_array:
if not isinstance(val, list):
return self._type_err(val, "list")
else:
for v in val:
ok, msg = self.validate(expected_type, False, v)
if not ok:
return ok, msg
elif expected_type.type == "int":
if not isinstance(val, int):
return self._type_err(val, "int")
elif expected_type.type == "float":
if not isinstance(val, (float, int)):
return self._type_err(val, "float")
elif expected_type.type == "bool":
if not isinstance(val, bool):
return self._type_err(val, "bool")
elif expected_type.type == "string":
if not isinstance(val, str):
return self._type_err(val, "string")
else:
return self.get(expected_type.type).validate(val)
return True, None
def _type_err(self, val, expected):
return False, "'%s' is of type %s, expected %s" % (val, type(val), expected)
class Interface(object):
"""
Represents a Barrister IDL 'interface' entity.
"""
def __init__(self, iface, contract):
"""
Creates an Interface. Creates a 'functions' list of Function objects for
each function defined on the interface.
:Parameters:
iface
Dict representing the interface (from parsed IDL)
contract
Contract instance to associate the interface instance with
"""
self.name = iface["name"]
self.functions = {}
for f in iface["functions"]:
self.functions[f["name"]] = Function(self.name, f, contract)
def function(self, func_name):
"""
Returns the Function instance associated with the given func_name, or raises a
RpcException if no function matches.
"""
if func_name in self.functions:
return self.functions[func_name]
else:
raise RpcException(ERR_METHOD_NOT_FOUND,
"%s: Unknown function: '%s'" % (self.name, func_name))
class Enum(object):
"""
Represents a Barrister IDL 'enum' entity.
"""
def __init__(self, enum):
"""
Creates an Enum.
:Parameters:
enum
Dict representing the enum (from parsed IDL)
"""
self.name = enum["name"]
self.values = []
for v in enum["values"]:
self.values.append(v["value"])
def validate(self, val):
"""
Validates that the val is in the list of values for this Enum.
Returns two element tuple: (bool, string)
- `bool` - True if valid, False if not
- `string` - Description of validation error, or None if valid
:Parameters:
val
Value to validate. Should be a string.
"""
if val in self.values:
return True, None
else:
return False, "'%s' is not in enum: %s" % (val, str(self.values))
class Struct(object):
"""
Represents a Barrister IDL 'struct' entity.
"""
def __init__(self, s, contract):
"""
Creates a Struct.
:Parameters:
s
Dict representing the struct (from parsed IDL)
contract
Contract instance to associate with the Struct
"""
self.contract = contract
self.name = s["name"]
self.extends = s["extends"]
self.parent = None
self.fields = {}
for f in s["fields"]:
self.fields[f["name"]] = Type(f)
def field(self, name):
"""
Returns the field on this struct with the given name. Will try to find this
name on all ancestors if this struct extends another.
If found, returns a dict with keys: 'name', 'comment', 'type', 'is_array'
If not found, returns None
:Parameters:
name
string name of field to lookup
"""
if name in self.fields:
return self.fields[name]
elif self.extends:
if not self.parent:
self.parent = self.contract.struct(self.extends)
return self.parent.field(name)
else:
return None
def validate(self, val):
"""
Validates that the val matches the expected fields for this struct.
val must be a dict, and must contain only fields represented by this struct and its
ancestors.
Returns two element tuple: (bool, string)
- `bool` - True if valid, False if not
- `string` - Description of validation error, or None if valid
:Parameters:
val
Value to validate. Must be a dict
"""
if type(val) is not dict:
return False, "%s is not a dict" % (str(val))
for k, v in list(val.items()):
field = self.field(k)
if field:
ok, msg = self.contract.validate(field, field.is_array, v)
if not ok:
return False, "field '%s': %s" % (field.name, msg)
else:
return False, "field '%s' not found in struct %s" % (k, self.name)
all_fields = self.get_all_fields([])
for field in all_fields:
if field.name not in val and not field.optional:
return False, "field '%s' missing from: %s" % (field.name, str(val))
return True, None
def get_all_fields(self, arr):
"""
Returns a list containing this struct's fields and all the fields of
its ancestors. Used during validation.
"""
for k, v in list(self.fields.items()):
arr.append(v)
if self.extends:
parent = self.contract.get(self.extends)
if parent:
return parent.get_all_fields(arr)
return arr
class Function(object):
"""
Represents a function defined on an Interface
"""
def __init__(self, iface_name, f, contract):
"""
Creates a new Function
:Parameters:
iface_name
Name of interface this function belongs to
f
Dict from parsed IDL representing this function. keys: 'name', 'params', 'returns'
contract
Contract to associate this Function with
"""
self.contract = contract
self.name = f["name"]
self.params = []
for p in f["params"]:
self.params.append(Type(p))
self.returns = Type(f["returns"]) if "returns" in f else None
self.full_name = "%s.%s" % (iface_name, self.name)
self.validate_structure()
def validate_structure(self):
"""
Sanity check of own properties. Raises InvaildFunctionErrors.
"""
if self.name in [None, '']:
raise InvalidFunctionError(
'invalid function definition - name required'
)
if self.returns is None:
raise InvalidFunctionError(
'function definition "%s" is missing a return type' % (
self.full_name
)
)
def validate_params(self, params):
"""
Validates params against expected types for this function.
Raises RpcException if the params are invalid.
"""
if params is not None:
if len(self.params) != len(params):
vals = (self.full_name, len(self.params), len(params))
msg = "Function '%s' expects %d param(s). %d given." % vals
raise RpcException(ERR_INVALID_PARAMS, msg)
[self._validate_param(x, y) for (x, y) in zip(self.params, params)]
def validate_response(self, resp):
"""
Validates resp against expected return type for this function.
Raises RpcException if the response is invalid.
"""
ok, msg = self.contract.validate(self.returns,
self.returns.is_array, resp)
if not ok:
vals = (self.full_name, str(resp), msg)
msg = "Function '%s' invalid response: '%s'. %s" % vals
raise RpcException(ERR_INVALID_RESP, msg)
def _validate_param(self, expected, param):
"""
Validates a single param against its expected type.
Raises RpcException if the param is invalid
:Parameters:
expected
Type instance
param
Parameter value to validate
"""
ok, msg = self.contract.validate(expected, expected.is_array, param)
if not ok:
vals = (self.full_name, expected.name, msg)
msg = "Function '%s' invalid param '%s'. %s" % vals
raise RpcException(ERR_INVALID_PARAMS, msg)
class Type(object):
def __init__(self, type_dict):
self.name = ""
self.optional = False
if "name" in type_dict:
self.name = type_dict["name"]
self.type = type_dict["type"]
self.is_array = type_dict["is_array"]
if "optional" in type_dict:
self.optional = type_dict["optional"]
|
data/Miserlou/OpenWatch/openwatch/map/views.py
|
from django.http import HttpResponse, HttpResponseRedirect, HttpResponseNotFound
from django.template import Context, loader
from django.core.urlresolvers import reverse
from django.template import RequestContext
from django.shortcuts import get_object_or_404, render_to_response
from django.core.exceptions import ObjectDoesNotExist
from datetime import datetime
from tagging.models import Tag, TaggedItem
from django.views.decorators.csrf import csrf_exempt
from django.contrib.auth.models import User
from django.contrib.auth.decorators import login_required
from django.contrib.auth import authenticate, login
from django.core.mail import send_mail
from django.conf import settings
from django.http import Http404
from django.db.models import Q
import json
from openwatch.recordings.models import Recording
from openwatch import recording_tags
@login_required
def moderate(request):
''' Split map/table recording moderation.
Requires user is a superuser or has an org tag and can_moderate=True
'''
response_values = {}
org_tag = request.user.get_profile().org_tag
if not request.user.is_superuser and (not request.user.get_profile().can_moderate or org_tag == ''):
raise Http404
if recording_tags.ACLU_NJ in org_tag:
location = {}
location['lat'] = 40.167274
location['lon'] = -74.616338
response_values['location'] = location
response_values['total'] = 'lots!'
return render_to_response('moderate.html', response_values, context_instance=RequestContext(request))
def map(request):
total = "lots!"
return render_to_response('map.html', {'total': total}, context_instance=RequestContext(request))
def size(request):
featureset = Recording.objects.filter(~Q(lat=None), ~Q(lon=None), ~Q(jtype='organic')).exclude(location__exact='No description available').exclude(location__exact='0.0, 0.0').order_by('-date')
total = len(featureset)
return render_to_response('map.html', {'total': total}, context_instance=RequestContext(request))
def redir(self):
return HttpResponseRedirect('/')
def map_json(request):
featureset = Recording.objects.all().order_by('-date').filter(~Q(location='')).exclude(location__isnull=True).exclude(location__exact='')[:750]
resp = encode_queryset(featureset)
return HttpResponse(resp, mimetype="application/json")
@login_required
def map_json_moderate(request):
org_tag = request.user.get_profile().org_tag
if org_tag != '':
featureset = Recording.objects.filter(org_approved=False, org_flagged=False, tags__contains=org_tag)
else:
featureset = Recording.objects.all()
featureset = featureset.order_by('-date').filter(~Q(location='')).exclude(location__isnull=True).exclude(location__exact='')
resp = encode_queryset(featureset)
return HttpResponse(resp, mimetype="application/json")
def map_location_json(request, ne_lat=0, ne_lon=0, sw_lat=0, sw_lon=0):
ne_lat = float(ne_lat)
ne_lon = float(ne_lon)
sw_lat = float(sw_lat)
sw_lon = float(sw_lon)
featureset = Recording.objects.filter(lat__lt=ne_lat, lat__gt=sw_lat,lon__lt=ne_lon, lon__gt=sw_lon).order_by('-date').exclude(location__isnull=True).exclude(location__exact='').exclude(location__exact='No description available').exclude(location__exact='0.0, 0.0')[:750]
if len(featureset) < 1:
return HttpResponse("{\"objects\":[]}", mimetype="application/json")
resp = encode_queryset(featureset)
return HttpResponse(resp, mimetype="application/json")
def encode_queryset(featureset):
resp = '{"objects":['
for obj in featureset:
resp = resp + json.dumps(obj.to_dict()) + ','
resp = resp[:-1] + ']}'
return resp
|
data/RDFLib/rdflib/rdflib/plugins/parsers/nquads.py
|
"""
This is a rdflib plugin for parsing NQuad files into Conjunctive
graphs that can be used and queried. The store that backs the graph
*must* be able to handle contexts.
>>> from rdflib import ConjunctiveGraph, URIRef, Namespace
>>> g = ConjunctiveGraph()
>>> data = open("test/nquads.rdflib/example.nquads", "rb")
>>> g.parse(data, format="nquads")
<Graph identifier=... (<class 'rdflib.graph.Graph'>)>
>>> assert len(g.store) == 449
>>>
>>> assert len([x for x in g.store.contexts()]) == 16
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>> s = URIRef("http://bibliographica.org/entity/E10009")
>>> FOAF = Namespace("http://xmlns.com/foaf/0.1/")
>>> assert(g.value(s, FOAF.name).eq("Arco Publications"))
"""
from codecs import getreader
from rdflib.py3compat import b
from rdflib import ConjunctiveGraph
from rdflib.plugins.parsers.ntriples import NTriplesParser
from rdflib.plugins.parsers.ntriples import ParseError
from rdflib.plugins.parsers.ntriples import r_tail
from rdflib.plugins.parsers.ntriples import r_wspace
from rdflib.plugins.parsers.ntriples import r_wspaces
__all__ = ['NQuadsParser']
class NQuadsParser(NTriplesParser):
def parse(self, inputsource, sink, **kwargs):
"""Parse f as an N-Triples file."""
assert sink.store.context_aware, ("NQuadsParser must be given"
" a context aware store.")
self.sink = ConjunctiveGraph(store=sink.store, identifier=sink.identifier)
source = inputsource.getByteStream()
if not hasattr(source, 'read'):
raise ParseError("Item to parse must be a file-like object.")
source = getreader('utf-8')(source)
self.file = source
self.buffer = ''
while True:
self.line = __line = self.readline()
if self.line is None:
break
try:
self.parseline()
except ParseError, msg:
raise ParseError("Invalid line (%s):\n%r" % (msg, __line))
return self.sink
def parseline(self):
self.eat(r_wspace)
if (not self.line) or self.line.startswith(('
return
subject = self.subject()
self.eat(r_wspace)
predicate = self.predicate()
self.eat(r_wspace)
obj = self.object()
self.eat(r_wspace)
context = self.uriref() or self.nodeid() or self.sink.identifier
self.eat(r_tail)
if self.line:
raise ParseError("Trailing garbage")
self.sink.get_context(context).add((subject, predicate, obj))
|
data/VisualComputingInstitute/Beacon8/examples/Kaggle-Otto/test.py
|
import numpy as np
import theano as th
from kaggle_utils import multiclass_log_loss
from examples.utils import make_progressbar
def validate(dataset_x, dataset_y, model, epoch, batch_size):
progress = make_progressbar('Testing epoch
progress.start()
logloss = 0.
for j in range((dataset_x.shape[0] + batch_size - 1) // batch_size):
mini_batch_input = dataset_x[j*batch_size : (j+1)*batch_size].astype(th.config.floatX)
mini_batch_targets = dataset_y[j*batch_size : (j+1)*batch_size].astype(th.config.floatX)
mini_batch_prediction = model.forward(mini_batch_input)
logloss += multiclass_log_loss(mini_batch_targets, mini_batch_prediction, normalize=False)
progress.update(j * batch_size + len(mini_batch_input))
progress.finish()
print("Epoch
|
data/Skype4Py/Skype4Py/unittests/smstest.py
|
import unittest
import skype4pytest
from Skype4Py.sms import *
class SmsMessageTest(skype4pytest.TestCase):
def setUpObject(self):
self.obj = SmsMessage(self.skype, '1234')
def testDelete(self):
self.api.enqueue('DELETE SMS 1234')
self.obj.Delete()
self.failUnless(self.api.is_empty())
def testMarkAsSeen(self):
self.api.enqueue('SET SMS 1234 SEEN',
'SMS 1234 STATUS READ')
self.obj.MarkAsSeen()
self.failUnless(self.api.is_empty())
def testSend(self):
self.api.enqueue('ALTER SMS 1234 SEND')
self.obj.Send()
self.failUnless(self.api.is_empty())
def testBody(self):
self.api.enqueue('GET SMS 1234 BODY',
'SMS 1234 BODY eggs')
t = self.obj.Body
self.assertInstance(t, unicode)
self.assertEqual(t, 'eggs')
self.failUnless(self.api.is_empty())
self.api.enqueue('SET SMS 1234 BODY eggs',
'SMS 1234 BODY eggs')
self.obj.Body = 'eggs'
self.failUnless(self.api.is_empty())
def testChunks(self):
self.api.enqueue('GET SMS 1234 CHUNKING',
'SMS 1234 CHUNKING 2 30')
t = self.obj.Chunks
self.assertInstance(t, SmsChunkCollection)
self.assertEqual(len(t), 2)
self.failUnless(self.api.is_empty())
def testDatetime(self):
from datetime import datetime
from time import time
now = time()
self.api.enqueue('GET SMS 1234 TIMESTAMP',
'SMS 1234 TIMESTAMP %f' % now)
t = self.obj.Datetime
self.assertInstance(t, datetime)
self.assertEqual(t, datetime.fromtimestamp(now))
self.failUnless(self.api.is_empty())
def testFailureReason(self):
self.api.enqueue('GET SMS 1234 FAILUREREASON',
'SMS 1234 FAILUREREASON eggs')
t = self.obj.FailureReason
self.assertInstance(t, str)
self.assertEqual(t, 'eggs')
self.failUnless(self.api.is_empty())
def testId(self):
t = self.obj.Id
self.assertInstance(t, int)
self.assertEqual(t, 1234)
def testIsFailedUnseen(self):
self.api.enqueue('GET SMS 1234 IS_FAILED_UNSEEN',
'SMS 1234 IS_FAILED_UNSEEN TRUE')
t = self.obj.IsFailedUnseen
self.assertInstance(t, bool)
self.assertEqual(t, True)
self.failUnless(self.api.is_empty())
def testPrice(self):
self.api.enqueue('GET SMS 1234 PRICE',
'SMS 1234 PRICE 123')
t = self.obj.Price
self.assertInstance(t, int)
self.assertEqual(t, 123)
self.failUnless(self.api.is_empty())
def testPriceCurrency(self):
self.api.enqueue('GET SMS 1234 PRICE_CURRENCY',
'SMS 1234 PRICE_CURRENCY EUR')
t = self.obj.PriceCurrency
self.assertInstance(t, unicode)
self.assertEqual(t, 'EUR')
self.failUnless(self.api.is_empty())
def testPricePrecision(self):
self.api.enqueue('GET SMS 1234 PRICE_PRECISION',
'SMS 1234 PRICE_PRECISION 3')
t = self.obj.PricePrecision
self.assertInstance(t, int)
self.assertEqual(t, 3)
self.failUnless(self.api.is_empty())
def testPriceToText(self):
self.api.enqueue('GET SMS 1234 PRICE_CURRENCY',
'SMS 1234 PRICE_CURRENCY EUR')
self.api.enqueue('GET SMS 1234 PRICE',
'SMS 1234 PRICE 123')
self.api.enqueue('GET SMS 1234 PRICE_PRECISION',
'SMS 1234 PRICE_PRECISION 3')
t = self.obj.PriceToText
self.assertInstance(t, unicode)
self.assertEqual(t, 'EUR 0.123')
self.failUnless(self.api.is_empty())
def testPriceValue(self):
self.api.enqueue('GET SMS 1234 PRICE',
'SMS 1234 PRICE 123')
self.api.enqueue('GET SMS 1234 PRICE_PRECISION',
'SMS 1234 PRICE_PRECISION 3')
t = self.obj.PriceValue
self.assertInstance(t, float)
self.assertEqual(t, 0.123)
self.failUnless(self.api.is_empty())
def testReplyToNumber(self):
self.api.enqueue('GET SMS 1234 REPLY_TO_NUMBER',
'SMS 1234 REPLY_TO_NUMBER eggs')
t = self.obj.ReplyToNumber
self.assertInstance(t, str)
self.assertEqual(t, 'eggs')
self.failUnless(self.api.is_empty())
self.api.enqueue('SET SMS 1234 REPLY_TO_NUMBER eggs',
'SMS 1234 REPLY_TO_NUMBER eggs')
self.obj.ReplyToNumber = 'eggs'
self.failUnless(self.api.is_empty())
def testSeen(self):
from warnings import simplefilter
self.api.enqueue('SET SMS 1234 SEEN',
'SMS 1234 STATUS READ')
simplefilter('ignore')
try:
self.obj.Seen = True
finally:
simplefilter('default')
self.failUnless(self.api.is_empty())
def testStatus(self):
self.api.enqueue('GET SMS 1234 STATUS',
'SMS 1234 STATUS RECEIVED')
t = self.obj.Status
self.assertInstance(t, str)
self.assertEqual(t, 'RECEIVED')
self.failUnless(self.api.is_empty())
def testTargetNumbers(self):
self.api.enqueue('GET SMS 1234 TARGET_NUMBERS',
'SMS 1234 TARGET_NUMBERS +3712345678, +3723456789')
t = self.obj.TargetNumbers
self.assertInstance(t, tuple)
self.assertEqual(len(t), 2)
self.failUnless(self.api.is_empty())
self.api.enqueue('SET SMS 1234 TARGET_NUMBERS +3787654321',
'SMS 1234 TARGET_NUMBERS +3787654321')
self.obj.TargetNumbers = ('+3787654321',)
self.failUnless(self.api.is_empty())
def testTargets(self):
self.api.enqueue('GET SMS 1234 TARGET_NUMBERS',
'SMS 1234 TARGET_NUMBERS +3712345678, +3723456789')
t = self.obj.Targets
self.assertInstance(t, SmsTargetCollection)
self.assertEqual(len(t), 2)
self.failUnless(self.api.is_empty())
def testTimestamp(self):
self.api.enqueue('GET SMS 1234 TIMESTAMP',
'SMS 1234 TIMESTAMP 123.4')
t = self.obj.Timestamp
self.assertInstance(t, float)
self.assertEqual(t, 123.4)
self.failUnless(self.api.is_empty())
def testType(self):
self.api.enqueue('GET SMS 1234 TYPE',
'SMS 1234 TYPE INCOMING')
t = self.obj.Type
self.assertInstance(t, str)
self.assertEqual(t, 'INCOMING')
self.failUnless(self.api.is_empty())
class SmsChunkTest(skype4pytest.TestCase):
def setUpObject(self):
self.obj = SmsChunk(SmsMessage(self.skype, '1234'), 1)
def testCharactersLeft(self):
self.api.enqueue('GET SMS 1234 CHUNKING',
'SMS 1234 CHUNKING 2 30')
t = self.obj.CharactersLeft
self.assertInstance(t, int)
self.assertEqual(t, 30)
self.failUnless(self.api.is_empty())
def testId(self):
t = self.obj.Id
self.assertInstance(t, int)
self.assertEqual(t, 1)
def testMessage(self):
t = self.obj.Message
self.assertInstance(t, SmsMessage)
self.assertEqual(t.Id, 1234)
def testText(self):
self.api.enqueue('GET SMS 1234 CHUNK 1',
'SMS 1234 CHUNK 1 eggs')
t = self.obj.Text
self.assertInstance(t, unicode)
self.assertEqual(t, 'eggs')
self.failUnless(self.api.is_empty())
class SmsTargetTest(skype4pytest.TestCase):
def setUpObject(self):
self.obj = SmsTarget(SmsMessage(self.skype, '1234'), '+3712345678')
def testMessage(self):
t = self.obj.Message
self.assertInstance(t, SmsMessage)
self.assertEqual(t.Id, 1234)
def testNumber(self):
t = self.obj.Number
self.assertInstance(t, str)
self.assertEqual(t, '+3712345678')
def testStatus(self):
self.api.enqueue('GET SMS 1234 TARGET_STATUSES',
'SMS 1234 TARGET_STATUSES +3723456789=TARGET_NOT_ROUTABLE, +3712345678=TARGET_ACCEPTABLE')
t = self.obj.Status
self.assertInstance(t, str)
self.assertEqual(t, 'TARGET_ACCEPTABLE')
self.failUnless(self.api.is_empty())
def suite():
return unittest.TestSuite([
unittest.defaultTestLoader.loadTestsFromTestCase(SmsMessageTest),
unittest.defaultTestLoader.loadTestsFromTestCase(SmsChunkTest),
unittest.defaultTestLoader.loadTestsFromTestCase(SmsTargetTest),
])
if __name__ == '__main__':
unittest.main()
|
data/PythonJS/PythonJS/regtests/dict/if_empty.py
|
"""if empty dict then false"""
def main():
d = {}
if d:
err1 = 1
else:
err1 = 0
if {}:
err2 = 1
else:
err2 = 0
d['x'] = 'xxx'
if d:
err3 = 0
else:
err3 = 1
TestError( err1 == 0 )
TestError( err2 == 0 )
TestError( err3 == 0 )
|
data/OpenMDAO/OpenMDAO-Framework/openmdao.lib/src/openmdao/lib/drivers/slsqpdriver.py
|
"""
slsqpdriver.py - Contains a driver that wraps the SLSQP
optimizer as used in pyOpt:
Minimize a function using Sequential Least SQuares Programming.
SLSQP is a gradient optimizer that can handle both equality and
inequality constraints.
"""
from math import isnan
from numpy import zeros, array
from slsqp.slsqp import slsqp, closeunit, pyflush
from openmdao.main.datatypes.api import Enum, Float, Int, Str
from openmdao.main.driver_uses_derivatives import Driver
from openmdao.main.hasparameters import HasParameters
from openmdao.main.hasconstraints import HasConstraints
from openmdao.main.hasobjective import HasObjective
from openmdao.main.interfaces import IHasParameters, IHasConstraints, \
IHasObjective, implements, IOptimizer
from openmdao.util.decorators import add_delegate
@add_delegate(HasParameters, HasConstraints, HasObjective)
class SLSQPdriver(Driver):
"""Minimize a function using the Sequential Least SQuares Programming
(SLSQP) method.
SLSQP is a gradient optimizer that can handle both equality and
inequality constraints.
Note: Constraints should be added using the OpenMDAO convention
(positive = violated).
"""
implements(IHasParameters, IHasConstraints, IHasObjective, IOptimizer)
accuracy = Float(1.0e-6, iotype='in',
desc='Convergence accuracy')
maxiter = Int(50, iotype='in',
desc='Maximum number of iterations.')
iprint = Enum(0, [0, 1, 2, 3], iotype='in',
desc='Controls the frequency of output: 0 (no output),1,2,3.')
iout = Int(6, iotype='in',
desc='Fortran output unit. Leave this at 6 for STDOUT.')
output_filename = Str('slsqp.out', iotype='in',
desc='Name of output file (if iout not 6).')
error_code = Int(0, iotype='out',
desc='Error code returned from SLSQP.')
def __init__(self):
super(SLSQPdriver, self).__init__()
self.error_messages = {
-1 : "Gradient evaluation required (g & a)",
1 : "Function evaluation required (f & c)",
2 : "More equality constraints than independent variables",
3 : "More than 3*n iterations in LSQ subproblem",
4 : "Inequality constraints incompatible",
5 : "Singular matrix E in LSQ subproblem",
6 : "Singular matrix C in LSQ subproblem",
7 : "Rank-deficient equality constraint subproblem HFTI",
8 : "Positive directional derivative for linesearch",
9 : "Iteration limit exceeded",
}
self.x = zeros(0, 'd')
self.x_lower_bounds = zeros(0, 'd')
self.x_upper_bounds = zeros(0, 'd')
self.inputs = None
self.obj = None
self.con = None
self.nparam = None
self.ncon = None
self.neqcon = None
self.ff = 0
self.nfunc = 0
self.ngrad = 0
self._continue = None
def start_iteration(self):
"""Perform initial setup before iteration loop begins."""
super(SLSQPdriver, self).run_iteration()
self.inputs = self.list_param_group_targets()
self.obj = self.list_objective_targets()
self.con = self.list_constraint_targets()
self.nparam = self.total_parameters()
self.ncon = self.total_constraints()
self.neqcon = self.total_eq_constraints()
self.x = self.eval_parameters(self.parent)
self.x_lower_bounds = self.get_lower_bounds()
self.x_upper_bounds = self.get_upper_bounds()
self.ff = 0
self.nfunc = 0
self.ngrad = 0
self._continue = True
def run_iteration(self):
""" Note: slsqp controls the looping."""
n = self.nparam
m = self.ncon
meq = self.neqcon
la = max(m, 1)
gg = zeros([la], 'd')
df = zeros([n+1], 'd')
dg = zeros([la, n+1], 'd')
mineq = m - meq + 2*(n+1)
lsq = (n+1)*((n+1)+1) + meq*((n+1)+1) + mineq*((n+1)+1)
lsi = ((n+1)-meq+1)*(mineq+2) + 2*mineq
lsei = ((n+1)+mineq)*((n+1)-meq) + 2*meq + (n+1)
slsqpb = (n+1)*(n/2) + 2*m + 3*n + 3*(n+1) + 1
lw = lsq + lsi + lsei + slsqpb + n + m
w = zeros([lw], 'd')
ljw = max(mineq, (n+1)-meq)
jw = zeros([ljw], 'i')
try:
dg, self.error_code, self.nfunc, self.ngrad = \
slsqp(self.ncon, self.neqcon, la, self.nparam,
self.x, self.x_lower_bounds, self.x_upper_bounds,
self.ff, gg, df, dg, self.accuracy, self.maxiter,
self.iprint-1, self.iout, self.output_filename,
self.error_code, w, lw, jw, ljw,
self.nfunc, self.ngrad,
self._func, self._grad)
except Exception as err:
self._logger.error(str(err))
raise
if self.iprint > 0:
closeunit(self.iout)
if self.error_code != 0:
self._logger.warning(self.error_messages[self.error_code])
self._continue = False
def _func(self, m, me, la, n, f, g, xnew):
""" Return ndarrays containing the function and constraint
evaluations.
Note: m, me, la, n, f, and g are unused inputs."""
self.set_parameters(xnew)
super(SLSQPdriver, self).run_iteration()
f = self.eval_objective()
if isnan(f):
msg = "Numerical overflow in the objective."
self.raise_exception(msg, RuntimeError)
if self.ncon > 0:
g = -1. * array(self.eval_constraints(self.parent))
if self.iprint > 0:
pyflush(self.iout)
return f, g
def _grad(self, m, me, la, n, f, g, df, dg, xnew):
""" Return ndarrays containing the gradients of the objective
and constraints.
Note: m, me, la, n, f, and g are unused inputs."""
J = self._calc_gradient(self.inputs, self.obj + self.con)
df[0:self.nparam] = J[0, :].ravel()
if self.ncon > 0:
dg[0:self.ncon, 0:self.nparam] = -J[1:1+self.ncon, :]
return df, dg
def requires_derivs(self):
"""SLSQP requires derivatives."""
return True
|
data/StackStorm/st2/st2common/st2common/persistence/marker.py
|
from st2common.models.db import MongoDBAccess
from st2common.models.db.marker import MarkerDB
from st2common.models.db.marker import DumperMarkerDB
from st2common.persistence.base import Access
__all__ = [
'Marker'
]
class Marker(Access):
impl = MongoDBAccess(MarkerDB)
publisher = None
@classmethod
def _get_impl(cls):
return cls.impl
class DumperMarker(Access):
impl = MongoDBAccess(DumperMarkerDB)
publisher = None
@classmethod
def _get_impl(cls):
return cls.impl
|
data/StackStorm/st2/st2debug/st2debug/cmd/submit_debug_info.py
|
"""
This script submits information which helps StackStorm employees debug different
user problems and issues to StackStorm.
By default the following information is included:
- Logs from /var/log/st2
- StackStorm and mistral config file (/etc/st2/st2.conf, /etc/mistral/mistral.conf)
- All the content (integration packs).
- Information about your system and StackStorm installation (Operating system,
Python version, StackStorm version, Mistral version)
Note: This script currently assumes it's running on Linux.
"""
import os
import sys
import shutil
import socket
import logging
import tarfile
import argparse
import platform
import tempfile
import httplib
import six
import yaml
import gnupg
import requests
from distutils.spawn import find_executable
import st2common
from st2common.content.utils import get_packs_base_paths
from st2common import __version__ as st2_version
from st2common import config
from st2common.util import date as date_utils
from st2common.util.shell import run_command
from st2debug.constants import GPG_KEY
from st2debug.constants import GPG_KEY_FINGERPRINT
from st2debug.constants import S3_BUCKET_URL
from st2debug.constants import COMPANY_NAME
from st2debug.constants import ARG_NAMES
from st2debug.utils.fs import copy_files
from st2debug.utils.fs import get_full_file_list
from st2debug.utils.fs import get_dirs_in_path
from st2debug.utils.fs import remove_file
from st2debug.utils.system_info import get_cpu_info
from st2debug.utils.system_info import get_memory_info
from st2debug.utils.system_info import get_package_list
from st2debug.utils.git_utils import get_repo_latest_revision_hash
from st2debug.processors import process_st2_config
from st2debug.processors import process_mistral_config
from st2debug.processors import process_content_pack_dir
LOG = logging.getLogger(__name__)
GPG_INSTALLED = find_executable('gpg') is not None
LOG_FILE_PATHS = [
'/var/log/st2/*.log',
'/var/log/mistral*.log'
]
ST2_CONFIG_FILE_PATH = '/etc/st2/st2.conf'
MISTRAL_CONFIG_FILE_PATH = '/etc/mistral/mistral.conf'
SHELL_COMMANDS = []
DIRECTORY_STRUCTURE = [
'configs/',
'logs/',
'content/',
'commands/'
]
OUTPUT_PATHS = {
'logs': 'logs/',
'configs': 'configs/',
'content': 'content/',
'commands': 'commands/',
'system_info': 'system_info.yaml',
'user_info': 'user_info.yaml'
}
ST2_CONF_OPTIONS_TO_REMOVE = {
'database': ['username', 'password'],
'messaging': ['url']
}
REMOVE_VALUE_NAME = '**removed**'
OUTPUT_FILENAME_TEMPLATE = 'st2-debug-output-%(hostname)s-%(date)s.tar.gz'
DATE_FORMAT = '%Y-%m-%d-%H%M%S'
try:
config.parse_args(args=[])
except Exception:
pass
def setup_logging():
root = LOG
root.setLevel(logging.INFO)
ch = logging.StreamHandler(sys.stdout)
ch.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s %(levelname)s - %(message)s')
ch.setFormatter(formatter)
root.addHandler(ch)
class DebugInfoCollector(object):
def __init__(self, include_logs, include_configs, include_content, include_system_info,
include_shell_commands=False, user_info=None, debug=False, config_file=None,
output_path=None):
"""
Initialize a DebugInfoCollector object.
:param include_logs: Include log files in generated archive.
:type include_logs: ``bool``
:param include_configs: Include config files in generated archive.
:type include_configs: ``bool``
:param include_content: Include pack contents in generated archive.
:type include_content: ``bool``
:param include_system_info: Include system information in generated archive.
:type include_system_info: ``bool``
:param include_shell_commands: Include shell command output in generated archive.
:type include_shell_commands: ``bool``
:param user_info: User info to be included in generated archive.
:type user_info: ``dict``
:param debug: Enable debug logging.
:type debug: ``bool``
:param config_file: Values from config file to override defaults.
:type config_file: ``dict``
:param output_path: Path to write output file to. (optional)
:type output_path: ``str``
"""
self.include_logs = include_logs
self.include_configs = include_configs
self.include_content = include_content
self.include_system_info = include_system_info
self.include_shell_commands = include_shell_commands
self.user_info = user_info
self.debug = debug
self.output_path = output_path
config_file = config_file or {}
self.st2_config_file_path = config_file.get('st2_config_file_path', ST2_CONFIG_FILE_PATH)
self.mistral_config_file_path = config_file.get('mistral_config_file_path',
MISTRAL_CONFIG_FILE_PATH)
self.log_file_paths = config_file.get('log_file_paths', LOG_FILE_PATHS[:])
self.gpg_key = config_file.get('gpg_key', GPG_KEY)
self.gpg_key_fingerprint = config_file.get('gpg_key_fingerprint', GPG_KEY_FINGERPRINT)
self.s3_bucket_url = config_file.get('s3_bucket_url', S3_BUCKET_URL)
self.company_name = config_file.get('company_name', COMPANY_NAME)
self.shell_commands = config_file.get('shell_commands', SHELL_COMMANDS)
self.st2_config_file_name = os.path.basename(self.st2_config_file_path)
self.mistral_config_file_name = os.path.basename(self.mistral_config_file_path)
self.config_file_paths = [
self.st2_config_file_path,
self.mistral_config_file_path
]
def run(self, encrypt=False, upload=False, existing_file=None):
"""
Run the specified steps.
:param encrypt: If true, encrypt the archive file.
:param encrypt: ``bool``
:param upload: If true, upload the resulting file.
:param upload: ``bool``
:param existing_file: Path to an existing archive file. If not specified a new
archive will be created.
:param existing_file: ``str``
"""
temp_files = []
try:
if existing_file:
working_file = existing_file
else:
working_file = self.create_archive()
if not encrypt and not upload:
LOG.info('Debug tarball successfully '
'generated and can be reviewed at: %s' % working_file)
else:
temp_files.append(working_file)
if encrypt:
working_file = self.encrypt_archive(archive_file_path=working_file)
if not upload:
LOG.info('Encrypted debug tarball successfully generated at: %s' %
working_file)
else:
temp_files.append(working_file)
if upload:
self.upload_archive(archive_file_path=working_file)
tarball_name = os.path.basename(working_file)
LOG.info('Debug tarball successfully uploaded to %s (name=%s)' %
(self.company_name, tarball_name))
LOG.info('When communicating with support, please let them know the '
'tarball name - %s' % tarball_name)
finally:
for temp_file in temp_files:
assert temp_file.startswith('/tmp')
remove_file(file_path=temp_file)
def create_archive(self):
"""
Create an archive with debugging information.
:return: Path to the generated archive.
:rtype: ``str``
"""
try:
temp_dir_path = self.create_temp_directories()
output_paths = {}
for key, path in OUTPUT_PATHS.iteritems():
output_paths[key] = os.path.join(temp_dir_path, path)
LOG.info('Collecting files...')
if self.include_logs:
self.collect_logs(output_paths['logs'])
if self.include_configs:
self.collect_config_files(output_paths['configs'])
if self.include_content:
self.collect_pack_content(output_paths['content'])
if self.include_system_info:
self.add_system_information(output_paths['system_info'])
if self.user_info:
self.add_user_info(output_paths['user_info'])
if self.include_shell_commands:
self.add_shell_command_output(output_paths['commands'])
return self.create_tarball(temp_dir_path)
except Exception as e:
LOG.exception('Failed to generate tarball', exc_info=True)
raise e
def encrypt_archive(self, archive_file_path):
"""
Encrypt archive with debugging information using our public key.
:param archive_file_path: Path to the non-encrypted tarball file.
:type archive_file_path: ``str``
:return: Path to the encrypted archive.
:rtype: ``str``
"""
try:
assert archive_file_path.endswith('.tar.gz')
LOG.info('Encrypting tarball...')
gpg = gnupg.GPG(verbose=self.debug)
import_result = gpg.import_keys(self.gpg_key)
assert import_result.count == 1
encrypted_archive_output_file_name = os.path.basename(archive_file_path) + '.asc'
encrypted_archive_output_file_path = os.path.join('/tmp',
encrypted_archive_output_file_name)
with open(archive_file_path, 'rb') as fp:
gpg.encrypt_file(file=fp,
recipients=self.gpg_key_fingerprint,
always_trust=True,
output=encrypted_archive_output_file_path)
return encrypted_archive_output_file_path
except Exception as e:
LOG.exception('Failed to encrypt archive', exc_info=True)
raise e
def upload_archive(self, archive_file_path):
"""
Upload the encrypted archive.
:param archive_file_path: Path to the encrypted tarball file.
:type archive_file_path: ``str``
"""
try:
assert archive_file_path.endswith('.asc')
LOG.debug('Uploading tarball...')
file_name = os.path.basename(archive_file_path)
url = self.s3_bucket_url + file_name
assert url.startswith('https://')
with open(archive_file_path, 'rb') as fp:
response = requests.put(url=url, files={'file': fp})
assert response.status_code == httplib.OK
except Exception as e:
LOG.exception('Failed to upload tarball to %s' % self.company_name, exc_info=True)
raise e
def collect_logs(self, output_path):
"""
Copy log files to the output path.
:param output_path: Path where log files will be copied to.
:type output_path: ``str``
"""
LOG.debug('Including log files')
for file_path_glob in self.log_file_paths:
log_file_list = get_full_file_list(file_path_glob=file_path_glob)
copy_files(file_paths=log_file_list, destination=output_path)
def collect_config_files(self, output_path):
"""
Copy config files to the output path.
:param output_path: Path where config files will be copied to.
:type output_path: ``str``
"""
LOG.debug('Including config files')
copy_files(file_paths=self.config_file_paths, destination=output_path)
st2_config_path = os.path.join(output_path, self.st2_config_file_name)
process_st2_config(config_path=st2_config_path)
mistral_config_path = os.path.join(output_path, self.mistral_config_file_name)
process_mistral_config(config_path=mistral_config_path)
@staticmethod
def collect_pack_content(output_path):
"""
Copy pack contents to the output path.
:param output_path: Path where pack contents will be copied to.
:type output_path: ``str``
"""
LOG.debug('Including content')
packs_base_paths = get_packs_base_paths()
for index, packs_base_path in enumerate(packs_base_paths, 1):
dst = os.path.join(output_path, 'dir-%s' % index)
try:
shutil.copytree(src=packs_base_path, dst=dst)
except IOError:
continue
base_pack_dirs = get_dirs_in_path(file_path=output_path)
for base_pack_dir in base_pack_dirs:
pack_dirs = get_dirs_in_path(file_path=base_pack_dir)
for pack_dir in pack_dirs:
process_content_pack_dir(pack_dir=pack_dir)
def add_system_information(self, output_path):
"""
Collect and write system information to output path.
:param output_path: Path where system information will be written to.
:type output_path: ``str``
"""
LOG.debug('Including system info')
system_information = yaml.dump(self.get_system_information(),
default_flow_style=False)
with open(output_path, 'w') as fp:
fp.write(system_information)
def add_user_info(self, output_path):
"""
Write user info to output path as YAML.
:param output_path: Path where user info will be written.
:type output_path: ``str``
"""
LOG.debug('Including user info')
user_info = yaml.dump(self.user_info, default_flow_style=False)
with open(output_path, 'w') as fp:
fp.write(user_info)
def add_shell_command_output(self, output_path):
""""
Get output of the required shell command and redirect the output to output path.
:param output_path: Directory where output files will be written
:param output_path: ``str``
"""
LOG.debug('Including the required shell commands output files')
for cmd in self.shell_commands:
output_file = os.path.join(output_path, '%s.txt' % self.format_output_filename(cmd))
exit_code, stdout, stderr = run_command(cmd=cmd, shell=True)
with open(output_file, 'w') as fp:
fp.write('[BEGIN STDOUT]\n')
fp.write(stdout)
fp.write('[END STDOUT]\n')
fp.write('[BEGIN STDERR]\n')
fp.write(stderr)
fp.write('[END STDERR]')
def create_tarball(self, temp_dir_path):
"""
Create tarball with the contents of temp_dir_path.
Tarball will be written to self.output_path, if set. Otherwise it will
be written to /tmp a name generated according to OUTPUT_FILENAME_TEMPLATE.
:param temp_dir_path: Base directory to include in tarbal.
:type temp_dir_path: ``str``
:return: Path to the created tarball.
:rtype: ``str``
"""
LOG.info('Creating tarball...')
if self.output_path:
output_file_path = self.output_path
else:
date = date_utils.get_datetime_utc_now().strftime(DATE_FORMAT)
values = {'hostname': socket.gethostname(), 'date': date}
output_file_name = OUTPUT_FILENAME_TEMPLATE % values
output_file_path = os.path.join('/tmp', output_file_name)
with tarfile.open(output_file_path, 'w:gz') as tar:
tar.add(temp_dir_path, arcname='')
return output_file_path
@staticmethod
def create_temp_directories():
"""
Creates a new temp directory and creates the directory structure as defined
by DIRECTORY_STRUCTURE.
:return: Path to temp directory.
:rtype: ``str``
"""
temp_dir_path = tempfile.mkdtemp()
for directory_name in DIRECTORY_STRUCTURE:
full_path = os.path.join(temp_dir_path, directory_name)
os.mkdir(full_path)
return temp_dir_path
@staticmethod
def format_output_filename(cmd):
""""
Remove whitespace and special characters from a shell command.
Used to create filename-safe representations of a shell command.
:param cmd: Shell command.
:type cmd: ``str``
:return: Formatted filename.
:rtype: ``str``
"""
return cmd.translate(None, """ !@
@staticmethod
def get_system_information():
"""
Retrieve system information which is included in the report.
:rtype: ``dict``
"""
system_information = {
'hostname': socket.gethostname(),
'operating_system': {},
'hardware': {
'cpu': {},
'memory': {}
},
'python': {},
'stackstorm': {},
'mistral': {}
}
system_information['operating_system']['system'] = platform.system()
system_information['operating_system']['release'] = platform.release()
system_information['operating_system']['operating_system'] = platform.platform()
system_information['operating_system']['platform'] = platform.system()
system_information['operating_system']['architecture'] = ' '.join(platform.architecture())
if platform.system().lower() == 'linux':
distribution = ' '.join(platform.linux_distribution())
system_information['operating_system']['distribution'] = distribution
system_information['python']['version'] = sys.version.split('\n')[0]
cpu_info = get_cpu_info()
if cpu_info:
core_count = len(cpu_info)
model = cpu_info[0]['model_name']
system_information['hardware']['cpu'] = {
'core_count': core_count,
'model_name': model
}
else:
system_information['hardware']['cpu'] = 'unsupported platform'
memory_info = get_memory_info()
if memory_info:
total = memory_info['MemTotal'] / 1024
free = memory_info['MemFree'] / 1024
used = (total - free)
system_information['hardware']['memory'] = {
'total': total,
'used': used,
'free': free
}
else:
system_information['hardware']['memory'] = 'unsupported platform'
system_information['stackstorm']['version'] = st2_version
st2common_path = st2common.__file__
st2common_path = os.path.dirname(st2common_path)
if 'st2common/st2common' in st2common_path:
base_install_path = st2common_path.replace('/st2common/st2common', '')
revision_hash = get_repo_latest_revision_hash(repo_path=base_install_path)
system_information['stackstorm']['installation_method'] = 'source'
system_information['stackstorm']['revision_hash'] = revision_hash
else:
package_list = get_package_list(name_startswith='st2')
system_information['stackstorm']['installation_method'] = 'package'
system_information['stackstorm']['packages'] = package_list
repo_path = '/opt/openstack/mistral'
revision_hash = get_repo_latest_revision_hash(repo_path=repo_path)
system_information['mistral']['installation_method'] = 'source'
system_information['mistral']['revision_hash'] = revision_hash
return system_information
def main():
parser = argparse.ArgumentParser(description='')
parser.add_argument('--exclude-logs', action='store_true', default=False,
help='Don\'t include logs in the generated tarball')
parser.add_argument('--exclude-configs', action='store_true', default=False,
help='Don\'t include configs in the generated tarball')
parser.add_argument('--exclude-content', action='store_true', default=False,
help='Don\'t include content packs in the generated tarball')
parser.add_argument('--exclude-system-info', action='store_true', default=False,
help='Don\'t include system information in the generated tarball')
parser.add_argument('--exclude-shell-commands', action='store_true', default=False,
help='Don\'t include shell commands output in the generated tarball')
parser.add_argument('--yes', action='store_true', default=False,
help='Run in non-interactive mode and answer "yes" to all the questions')
parser.add_argument('--review', action='store_true', default=False,
help='Generate the tarball, but don\'t encrypt and upload it')
parser.add_argument('--debug', action='store_true', default=False,
help='Enable debug mode')
parser.add_argument('--config', action='store', default=None,
help='Get required configurations from config file')
parser.add_argument('--output', action='store', default=None,
help='Specify output file path')
parser.add_argument('--existing-file', action='store', default=None,
help='Specify an existing file to operate on')
args = parser.parse_args()
setup_logging()
abort = True
for arg_name in ARG_NAMES:
abort &= getattr(args, arg_name, False)
if abort:
print('Generated tarball would be empty. Aborting.')
sys.exit(2)
if args.config:
try:
with open(args.config, 'r') as yaml_file:
config_file = yaml.safe_load(yaml_file)
except Exception as e:
LOG.error('Failed to parse config file: %s' % e)
sys.exit(1)
if not isinstance(config_file, dict):
LOG.error('Unrecognized config file format')
sys.exit(1)
else:
config_file = {}
company_name = config_file.get('company_name', COMPANY_NAME)
encrypt = True
upload = True
if args.review:
encrypt = False
upload = False
if encrypt:
if not GPG_INSTALLED:
msg = ('"gpg" binary not found, can\'t proceed. Make sure "gpg" is installed '
'and available in PATH.')
raise ValueError(msg)
if not args.yes and not args.existing_file and upload:
submitted_content = [name.replace('exclude_', '') for name in ARG_NAMES if
not getattr(args, name, False)]
submitted_content = ', '.join(submitted_content)
print('This will submit the following information to %s: %s' % (company_name,
submitted_content))
value = six.moves.input('Are you sure you want to proceed? [y/n] ')
if value.strip().lower() not in ['y', 'yes']:
print('Aborting')
sys.exit(1)
user_info = {}
if not args.yes and not args.existing_file:
print('If you want us to get back to you via email, you can provide additional context '
'such as your name, email and an optional comment')
value = six.moves.input('Would you like to provide additional context? [y/n] ')
if value.strip().lower() in ['y', 'yes']:
user_info['name'] = six.moves.input('Name: ')
user_info['email'] = six.moves.input('Email: ')
user_info['comment'] = six.moves.input('Comment: ')
debug_collector = DebugInfoCollector(include_logs=not args.exclude_logs,
include_configs=not args.exclude_configs,
include_content=not args.exclude_content,
include_system_info=not args.exclude_system_info,
include_shell_commands=not args.exclude_shell_commands,
user_info=user_info,
debug=args.debug,
config_file=config_file,
output_path=args.output)
debug_collector.run(encrypt=encrypt, upload=upload, existing_file=args.existing_file)
|
data/StackStorm/st2/st2actions/st2actions/notifier/config.py
|
from oslo_config import cfg
import st2common.config as common_config
from st2common.constants.system import VERSION_STRING
common_config.register_opts()
CONF = cfg.CONF
def parse_args(args=None):
CONF(args=args, version=VERSION_STRING)
def register_opts():
_register_common_opts()
_register_notifier_opts()
def get_logging_config_path():
return cfg.CONF.notifier.logging
def _register_common_opts():
common_config.register_opts()
def _register_notifier_opts():
notifier_opts = [
cfg.StrOpt('logging', default='conf/logging.notifier.conf',
help='Location of the logging configuration file.')
]
CONF.register_opts(notifier_opts, group='notifier')
scheduler_opts = [
cfg.BoolOpt('enable', default=True, help='Specify to enable actions rescheduler.'),
cfg.IntOpt('delayed_execution_recovery', default=600,
help='The time in seconds to wait before recovering delayed action executions.'),
cfg.IntOpt('rescheduling_interval', default=300,
help='The frequency for rescheduling action executions.')
]
CONF.register_opts(scheduler_opts, group='scheduler')
register_opts()
|
data/OpenMDAO/OpenMDAO-Framework/openmdao.main/src/openmdao/main/datatypes/vtree.py
|
"""
Variable meant to contain a VariableTree of a particular type.
"""
__all__ = ["VarTree"]
from traits.api import Instance
from openmdao.main.variable import Variable, gui_excludes
class VarTree(Variable):
""" A Variable for a :class:`VariableTree` of a particular type. """
def __init__(self, default_value, allow_none=True, **metadata):
from openmdao.main.vartree import VariableTree
if isinstance(default_value, VariableTree):
klass = default_value.__class__
if 'iotype' in metadata:
default_value._iotype = metadata['iotype']
else:
metadata['iotype'] = default_value.iotype
else:
raise TypeError('default_value must be an instance of VariableTree'
' or subclass')
metadata.setdefault('copy', 'deep')
self._allow_none = allow_none
self.klass = klass
self._instance = Instance(klass=klass, allow_none=False, factory=None,
args=None, kw=None, **metadata)
self._instance.default_value = default_value
super(VarTree, self).__init__(default_value, **metadata)
def validate(self, obj, name, value):
""" Validates that a specified value is valid for this trait. """
if value is None:
if self._allow_none:
return value
self.validate_failed(obj, name, value)
try:
value = self._instance.validate(obj, name, value)
except Exception:
obj.raise_exception('%r must be an instance of %s.%s, not %r' %
(name, self._instance.klass.__module__,
self._instance.klass.__name__, type(value)),
TypeError)
return value
def post_setattr(self, obj, name, value):
""" VariableTrees must know their place within the hierarchy, so set
their parent here. This keeps side effects out of validate(). """
if value.parent is not obj:
value.parent = obj
value.name = name
value._iotype = self.iotype
def get_attribute(self, name, value, trait, meta):
"""Return the attribute dictionary for this variable. This dict is
used by the GUI to populate the edit UI. Slots also return an
attribute dictionary for the slot pane.
name: str
Name of variable
value: object
The value of the variable
trait: CTrait
The variable's trait
meta: dict
Dictionary of metadata for this variable
"""
io_attr = {}
io_attr['name'] = name
io_attr['type'] = trait.trait_type.klass.__name__
io_attr['ttype'] = 'vartree'
for field in meta:
if field not in gui_excludes:
io_attr[field] = meta[field]
return io_attr, None
|
data/PacificBiosciences/cDNA_primer/pbtranscript-tofu/pbtranscript/pbtools/pbtranscript/fusion_finder.py
|
import pdb
import os, sys
import itertools
from cPickle import *
from collections import defaultdict, namedtuple
from pbtools.pbtranscript.Utils import check_ids_unique
import pbtools.pbtranscript.tofu_wrap as tofu_wrap
import pbtools.pbtranscript.BioReaders as BioReaders
import pbtools.pbtranscript.branch.branch_simple2 as branch_simple2
import pbtools.pbtranscript.counting.compare_junctions as compare_junctions
from pbtools.pbtranscript.io.SeqReaders import LazyFastaReader, LazyFastqReader
from pbcore.io.FastaIO import FastaWriter
from pbcore.io.FastqIO import FastqWriter
from bx.intervals.cluster import ClusterTree
def pick_rep(fa_fq_filename, sam_filename, gff_filename, group_filename, output_filename, is_fq=False, pick_least_err_instead=False):
"""
For each group, select the representative record
If is FASTA file (is_fa False) -- then always pick the longest one
If is FASTQ file (is_fq True) -- then
If pick_least_err_instead is True, pick the one w/ least number of expected base errors
Else, pick the longest one
"""
if is_fq:
fd = LazyFastqReader(fa_fq_filename)
fout = FastqWriter(output_filename)
else:
fd = LazyFastaReader(fa_fq_filename)
fout = FastaWriter(output_filename)
rep_info = {}
id_to_rep = {}
for line in open(group_filename):
pb_id, members = line.strip().split('\t')
print >> sys.stderr, "Picking representative sequence for", pb_id
best_id = None
best_seq = None
best_qual = None
best_err = 9999999
err = 9999999
max_len = 0
for x in members.split(','):
if is_fq and pick_least_err_instead:
err = sum(i**-(i/10.) for i in fd[x].quality)
if (is_fq and pick_least_err_instead and err < best_err) or ((not is_fq or not pick_least_err_instead) and len(fd[x].sequence) >= max_len):
best_id = x
best_seq = fd[x].sequence
if is_fq:
best_qual = fd[x].quality
best_err = err
max_len = len(fd[x].sequence)
rep_info[pb_id] = (best_id, best_seq, best_qual)
id_to_rep[best_id] = pb_id
f_gff = open(gff_filename, 'w')
coords = {}
record_storage = {}
for r in BioReaders.GMAPSAMReader(sam_filename, True):
if r.qID in id_to_rep:
pb_id = id_to_rep[r.qID]
best_id, best_seq, best_qual = rep_info[pb_id]
if r.qID not in coords:
coords[r.qID] = "{0}:{1}-{2}({3})".format(r.sID, r.sStart, r.sEnd, r.flag.strand)
isoform_index = 1
record_storage[pb_id] = r
else:
coords[r.qID] += "+{0}:{1}-{2}({3})".format(r.sID, r.sStart, r.sEnd, r.flag.strand)
isoform_index = 1
old_r = record_storage[pb_id]
f_gff.write("{chr}\tPacBio\ttranscript\t{s}\t{e}\t.\t{strand}\t.\tgene_id \"{pi}\"; transcript_id \"{pi}.{j}\";\n".format(\
chr=old_r.sID, s=old_r.segments[0].start+1, e=old_r.segments[-1].end, pi=pb_id, j=isoform_index, strand=old_r.flag.strand))
for s in old_r.segments:
f_gff.write("{chr}\tPacBio\texon\t{s}\t{e}\t.\t{strand}\t.\tgene_id \"{pi}\"; transcript_id \"{pi}.{j}\";\n".format(\
chr=old_r.sID, s=s.start+1, e=s.end, pi=pb_id, j=isoform_index, strand=old_r.flag.strand))
isoform_index = 2
f_gff.write("{chr}\tPacBio\ttranscript\t{s}\t{e}\t.\t{strand}\t.\tgene_id \"{pi}\"; transcript_id \"{pi}.{j}\";\n".format(\
chr=r.sID, s=r.segments[0].start+1, e=r.segments[-1].end, pi=pb_id, j=isoform_index, strand=r.flag.strand))
for s in r.segments:
f_gff.write("{chr}\tPacBio\texon\t{s}\t{e}\t.\t{strand}\t.\tgene_id \"{pi}\"; transcript_id \"{pi}.{j}\";\n".format(\
chr=r.sID, s=s.start+1, e=s.end, pi=pb_id, j=isoform_index, strand=r.flag.strand))
f_gff.close()
for pb_id in rep_info:
best_id, best_seq, best_qual = rep_info[pb_id]
_id_ = "{0}|{1}|{2}".format(pb_id, coords[best_id], best_id)
_seq_ = best_seq
if is_fq:
fout.writeRecord(_id_, _seq_, best_qual)
else:
fout.writeRecord(_id_, _seq_)
def sep_by_strand(records):
output = {'+':[], '-':[]}
for r in records:
output[r.flag.strand].append(r)
return output
def is_fusion_compatible(r1, r2, max_fusion_point_dist, max_exon_end_dist, allow_extra_5_exons):
"""
Helper function for: merge_fusion_exons()
Check that:
(1) r1, r2 and both in the 5', or both in the 3'
(2) if single-exon, fusion point must be close by
if multi-exon, every junction identical (plus below is True)
(3) if allow_extra_5_exons is False, num exons must be the same
if allow_extra_5_exons is True, only allow additional 5' exons
"""
assert r1.flag.strand == r2.flag.strand
if r1.qStart <= .5*r1.qLen:
if r2.qStart > .5*r2.qLen:
return False
in_5_portion = True
else:
if r2.qStart <= .5*r2.qLen:
return False
in_5_portion = False
plus_is_5end = (r1.flag.strand == '+')
type = compare_junctions.compare_junctions(r1, r2)
if type == 'exact':
if len(r1.segments) == 1:
if len(r2.segments) == 1:
if in_5_portion and plus_is_5end: dist = abs(r1.sStart - r2.sStart)
else: dist = abs(r1.sEnd - r2.sEnd)
return dist <= max_fusion_point_dist
else:
raise Exception, "Not possible case for multi-exon transcript and " + \
"single-exon transcript to be exact!"
else:
return True
elif type == 'super' or type == 'subset':
if allow_extra_5_exons:
if in_5_portion and plus_is_5end:
if abs(r1.segments[-1].start - r2.segments[-1].start) > max_exon_end_dist: return False
if abs(r1.segments[-1].end - r2.segments[-1].end) > max_fusion_point_dist: return False
return True
elif in_5_portion and (not plus_is_5end):
if abs(r1.segments[0].end - r2.segments[0].end) > max_exon_end_dist: return False
if abs(r1.segments[0].start - r2.segments[0].start) > max_fusion_point_dist: return False
return True
else:
return False
else:
return False
else:
return False
def merge_fusion_exons(records, max_fusion_point_dist, max_exon_end_dist, allow_extra_5_exons):
"""
Records is a list of overlapping GMAP SAM Records (must be on same strand)
Unlike regular (non-fusion) mapping, only merge records if:
(1) for multi-exon, every junction is identical
for single-exon, the fusion point is no bigger than <max_fusion_point_dist> apart
(2) if allow_extra_5_exons is False, number of exons must be the same
if allow_extra_5_exons is True, only merge if the extension is in the 5' direction
Returns a list of grouped records, ex: [[r1,r2], [r3], [r4, r5, r6]]....
which can be sent to BranchSimple.process_records for writing out
"""
output = [[records[0]]]
for r1 in records[1:]:
merged = False
for i, r2s in enumerate(output):
if all(is_fusion_compatible(r1, r2, max_fusion_point_dist, max_exon_end_dist, allow_extra_5_exons) for r2 in r2s):
output[i].append(r1)
merged = True
break
if not merged:
output.append([r1])
return output
def iter_gmap_sam_for_fusion(gmap_sam_filename, fusion_candidates, transfrag_len_dict):
"""
Iterate through a sorted GMAP SAM file
Continuously yield a group of overlapping records {'+': [r1, r2, ...], '-': [r3, r4....]}
"""
records = []
iter = BioReaders.GMAPSAMReader(gmap_sam_filename, True, query_len_dict=transfrag_len_dict)
for r in iter:
if r.qID in fusion_candidates:
records = [r]
break
for r in iter:
if len(records) >= 1 and (r.sID==records[-1].sID and r.sStart < records[-1].sStart):
print >> sys.stderr, "SAM file is NOT sorted. ABORT!"
sys.exit(-1)
if len(records) >= 1 and (r.sID != records[0].sID or r.sStart > records[-1].sEnd):
yield(sep_by_strand(records))
records = []
if r.qID in fusion_candidates:
records.append(r)
if len(records) > 0:
yield(sep_by_strand(records))
def find_fusion_candidates(sam_filename, query_len_dict, min_locus_coverage=.05, min_locus_coverage_bp=1, min_total_coverage=.99, min_dist_between_loci=10000):
"""
Return list of fusion candidates qIDs
(1) must map to 2 or more loci
(2) minimum coverage for each loci is 5% AND minimum coverage in bp is >= 1 bp
(3) total coverage is >= 95%
(4) distance between the loci is at least 10kb
"""
TmpRec = namedtuple('TmpRec', ['qCov', 'qLen', 'qStart', 'qEnd', 'sStart', 'sEnd', 'iden'])
def total_coverage(tmprecs):
tree = ClusterTree(0, 0)
for r in tmprecs: tree.insert(r.qStart, r.qEnd, -1)
return sum(reg[1]-reg[0] for reg in tree.getregions())
d = defaultdict(lambda: [])
reader = BioReaders.GMAPSAMReader(sam_filename, True, query_len_dict=query_len_dict)
for r in reader:
if r.sID == '*': continue
if r.flag.strand == '+':
d[r.qID].append(TmpRec(qCov=r.qCoverage, qLen=r.qLen, qStart=r.qStart, qEnd=r.qEnd, sStart=r.sStart, sEnd=r.sEnd, iden=r.identity))
else:
d[r.qID].append(TmpRec(qCov=r.qCoverage, qLen=r.qLen, qStart=r.qLen-r.qEnd, qEnd=r.qLen-r.qStart, sStart=r.sStart, sEnd=r.sEnd, iden=r.identity))
fusion_candidates = []
for k, data in d.iteritems():
if len(data) > 1 and \
all(a.iden>=.95 for a in data) and \
all(a.qCov>=min_locus_coverage for a in data) and \
all(a.qCov*a.qLen >= min_locus_coverage_bp for a in data) and \
total_coverage(data)*1./data[0].qLen >= min_total_coverage and \
all(max(a.sStart,b.sStart)-min(a.sEnd,b.sEnd)>=min_dist_between_loci \
for a,b in itertools.combinations(data, 2)):
fusion_candidates.append(k)
return fusion_candidates
def fusion_main(fa_or_fq_filename, sam_filename, output_prefix, is_fq=False, allow_extra_5_exons=True, skip_5_exon_alt=True, prefix_dict_pickle_filename=None, min_locus_coverage=.05, min_total_coverage=.99, min_locus_coverage_bp=1, min_dist_between_loci=10000):
"""
(1) identify fusion candidates (based on mapping, total coverage, identity, etc)
(2) group/merge the fusion exons, using an index to point to each individual part
(3) use BranchSimple to write out a tmp GFF where
PBfusion.1.1 is the first part of a fusion gene
PBfusion.1.2 is the second part of a fusion gene
(4) read the tmp file from <3> and modify it so that
PBfusion.1 just represents the fusion gene (a single transcript GFF format)
"""
compressed_records_pointer_dict = defaultdict(lambda: [])
merged_exons = []
merged_i = 0
check_ids_unique(fa_or_fq_filename, is_fq=is_fq)
bs = branch_simple2.BranchSimple(fa_or_fq_filename, is_fq=is_fq)
fusion_candidates = find_fusion_candidates(sam_filename, bs.transfrag_len_dict, min_locus_coverage, min_locus_coverage_bp, min_total_coverage, min_dist_between_loci)
for recs in iter_gmap_sam_for_fusion(sam_filename, fusion_candidates, bs.transfrag_len_dict):
for v in recs.itervalues():
if len(v) > 0:
o = merge_fusion_exons(v, max_fusion_point_dist=100, max_exon_end_dist=0, allow_extra_5_exons=allow_extra_5_exons)
for group in o:
merged_exons.append(group)
for r in group: compressed_records_pointer_dict[r.qID].append(merged_i)
merged_i += 1
f_group = open('branch_tmp.group.txt', 'w')
gene_index = 1
already_seen = set()
for qid,indices in compressed_records_pointer_dict.iteritems():
combo = tuple(indices)
if combo in already_seen:
print "combo seen:", combo
continue
already_seen.add(combo)
for isoform_index,i in enumerate(indices):
bs.cuff_index = gene_index
records = merged_exons[i]
f_group.write("{p}.{i}.{j}\t{ids}\n".format(p="PBfusion", i=gene_index, j=isoform_index, ids=",".join(r.qID for r in records)))
gene_index += 1
f_group.close()
f_group = open(output_prefix + '.group.txt', 'w')
group_info = {}
count = 0
with open('branch_tmp.group.txt') as f:
while True:
line = f.readline().strip()
if len(line) == 0: break
pbid1, groups1 = line.strip().split('\t')
pbid2, groups2 = f.readline().strip().split('\t')
assert pbid1.split('.')[1] == pbid2.split('.')[1]
group = set(groups1.split(',')).intersection(groups2.split(','))
f_group.write("{0}\t{1}\n".format(pbid1[:pbid1.rfind('.')], ",".join(group)))
group_info[pbid1[:pbid1.rfind('.')]] = list(group)
count += 1
f_group.close()
gff_filename = output_prefix + '.gff'
group_filename = output_prefix + '.group.txt'
if is_fq:
output_filename = output_prefix + '.rep.fq'
else:
output_filename = output_prefix + '.rep.fa'
pick_rep(fa_or_fq_filename, sam_filename, gff_filename, group_filename, output_filename, is_fq=is_fq, pick_least_err_instead=False)
print >> sys.stderr, "{0} fusion candidates identified.".format(count)
print >> sys.stderr, "Output written to: {0}.gff, {0}.group.txt, {1}".format(output_prefix, output_filename)
if prefix_dict_pickle_filename is not None:
with open(prefix_dict_pickle_filename) as f:
d = load(f)
d1 = d['HQ']
d1.update(d['LQ'])
tofu_wrap.get_abundance(output_prefix, d1, output_prefix)
print >> sys.stderr, "Count information written to: {0}.abundance.txt".format(output_prefix)
if __name__ == "__main__":
from argparse import ArgumentParser
parser = ArgumentParser()
parser.add_argument("--input", help="Input FA/FQ filename")
parser.add_argument("--fq", default=False, action="store_true", help="Input is a fastq file (default is fasta)")
parser.add_argument("-s", "--sam", required=True, help="Sorted GMAP SAM filename")
parser.add_argument("-o", "--prefix", required=True, help="Output filename prefix")
parser.add_argument("--dun-merge-5-shorter", action="store_false", dest="allow_extra_5exon", default=True, help="Don't collapse shorter 5' transcripts (default: turned off)")
parser.add_argument("--prefix_dict_pickle_filename", default=None, help="Quiver HQ/LQ Pickle filename for generating count information (optional)")
parser.add_argument("-c", "--min_locus_coverage", type=float, default=0.05, help="Minimum per-locus coverage in percentage (default: 0.05)")
parser.add_argument("--min_locus_coverage_bp", type=int, default=1, help="Minimum per-locus coverage in bp (default: 1 bp)")
parser.add_argument("-t", "--min_total_coverage", type=float, default=0.99, help="Minimum total coverage (default: 0.99)")
parser.add_argument("-d", "--min_dist_between_loci", type=int, default=10000, help="Minimum distance between loci, in bp (default: 10000)")
args = parser.parse_args()
fusion_main(args.input, args.sam, args.prefix,
is_fq=args.fq, allow_extra_5_exons=args.allow_extra_5exon,
skip_5_exon_alt=False, prefix_dict_pickle_filename=args.prefix_dict_pickle_filename,
min_locus_coverage=args.min_locus_coverage, min_locus_coverage_bp=args.min_locus_coverage_bp,
min_total_coverage=args.min_total_coverage,
min_dist_between_loci=args.min_dist_between_loci)
|
data/RDFLib/rdfextras/rdfextras/sparql/graph.py
|
from types import FunctionType
from rdflib.graph import ConjunctiveGraph
from rdflib.graph import Graph
from rdflib.term import BNode
from rdflib.term import Literal
from rdflib.term import URIRef
from rdflib.term import Variable
from rdflib.namespace import NamespaceManager
from rdfextras.sparql import _questChar
from rdfextras.sparql import SPARQLError
from rdflib.util import check_object
from rdflib.util import check_subject
__all__ = ['SPARQLGraph', 'GraphPattern', 'BasicGraphPattern']
class SPARQLGraph(object):
"""
A subclass of Graph with a few extra SPARQL bits.
"""
SPARQL_DATASET = 0
NAMED_GRAPH = 1
__slots__ = ("graphVariable",
"DAWG_DATASET_COMPLIANCE",
"identifier",
"graphKind",
"graph")
def __init__(self, graph, graphVariable = None, dSCompliance = False):
assert not graphVariable or graphVariable[0] != '?', repr(graphVariable)
self.graphVariable = graphVariable
self.DAWG_DATASET_COMPLIANCE = dSCompliance
self.graphKind = None
if graph is not None:
self.graph = graph
if isinstance(graph, ConjunctiveGraph):
self.graphKind = self.SPARQL_DATASET
self.identifier = graph.default_context.identifier
else:
self.graphKind = self.NAMED_GRAPH
self.identifier = graph.identifier
def setupGraph(self, store, graphKind=None):
gKind = graphKind and graphKind or self.graphKind
self.graph = gKind(store, self.identifier)
def __reduce__(self):
return (SPARQLGraph,
(None,
self.graphVariable,
self.DAWG_DATASET_COMPLIANCE),
self.__getstate__())
def __getstate__(self):
return (self.graphVariable,
self.DAWG_DATASET_COMPLIANCE,
self.identifier)
def __setstate__(self, arg):
gVar,flag,identifier = arg
self.graphVariable = gVar
self.DAWG_DATASET_COMPLIANCE = flag
self.identifier = identifier
def _clusterForward(self, seed, Cluster):
"""Cluster the triple store: from a seed, transitively get all
properties and objects in direction of the arcs.
:param seed: RDFLib Resource
:param Cluster: a :class:`~rdfextras.sparql.graph.SPARQLGraph`
instance, that has to be expanded with the new arcs
"""
try:
for (p,o) in self.graph.predicate_objects(seed):
if not (seed,p,o) in Cluster.graph:
Cluster.add((seed,p,o))
self._clusterForward(p, Cluster)
self._clusterForward(o, Cluster)
except:
pass
def clusterForward(self, seed, Cluster=None):
"""
Cluster the triple store: from a seed, transitively get all
properties and objects in direction of the arcs.
:param seed: RDFLib Resource
:param Cluster: another sparqlGraph instance; if None, a new
one will be created. The subgraph will be added to this graph.
:return: The :class:`~rdfextras.sparql.graph.SPARQLGraph` triple store
containing the cluster
"""
if Cluster == None:
Cluster = SPARQLGraph()
check_subject(seed)
self._clusterForward(seed, Cluster)
return Cluster
def _clusterBackward(self, seed, Cluster):
"""Cluster the triple store: from a seed, transitively get all
properties and objects in backward direction of the arcs.
:param seed: RDFLib Resource
:param Cluster: a :class:`~rdfextras.sparql.graph.SPARQLGraph`
instance, that has to be expanded with the new arcs
"""
try:
for (s,p) in self.graph.subject_predicates(seed):
if not (s,p,seed) in Cluster.graph:
Cluster.add((s, p, seed))
self._clusterBackward(s, Cluster)
self._clusterBackward(p, Cluster)
except:
pass
def clusterBackward(self, seed, Cluster=None):
"""
Cluster the triple store: from a seed, transitively get all
properties and objects 'backward', ie, following the link back
in the graph.
:param seed: RDFLib Resource
:param Cluster: another sparqlGraph instance; if None, a new
one will be created. The subgraph will be added to this graph.
:return: The :class:`~rdfextras.sparql.graph.SPARQLGraph` triple store
containing the cluster
"""
if Cluster == None:
Cluster = SPARQLGraph()
check_object(seed)
self._clusterBackward(seed, Cluster)
return Cluster
def cluster(self,seed):
"""
Cluster up and down, by summing up the forward and backward
clustering
:param seed: RDFLib Resource
:return: The :class:`~rdfextras.sparql.graph.SPARQLGraph` triple store
containing the cluster
"""
raise "Am I getting here?"
return self.clusterBackward(seed) + self.clusterForward(seed)
"""
Graph pattern class used by the SPARQL implementation
"""
def _createResource(v):
"""
Create an RDFLib Literal instance with the corresponding XML
Schema datatype set. If the variable is already an RDFLib
resource, it simply returns the resource; otherwise the
corresponding Literal. A SPARQLError Exception is raised if the
type is not implemented.
The Literal contains the string representation of the variable (as
Python does it by default) with the corresponding XML Schema URI
set.
:param v: Python variable
:return: either an RDFLib Literal (if 'v' is not an RDFLib Resource),
or the same variable if it is already an RDFLib resource (i.e.,
Literal, BNode, or URIRef)
:raise SPARQLError: if the type of 'v' is not implemented
"""
if isinstance(v, Literal) or isinstance(v, BNode) or isinstance(v, URIRef):
return v
else:
return Literal(v)
def _isResQuest(r):
"""
Is 'r' a request string (ie, of the form "?XXX")?
:rtype: Boolean
"""
if r and isinstance(r, basestring) and r[0] == _questChar:
return True
return False
class GraphPattern:
"""
Storage of one Graph Pattern, ie, the pattern tuples and the
possible (functional) constraints (filters)
"""
def __init__(self, patterns=[]):
"""
:param patterns: an initial list of graph pattern tuples
"""
self.patterns = []
self.constraints = []
self.unbounds = []
self.bnodes = {}
if type(patterns) == list:
self.addPatterns(patterns)
elif type(patterns) == tuple:
self.addPattern(patterns)
else:
raise SPARQLError(
"illegal argument, pattern must be a tuple or a list of tuples")
def _generatePattern(self, tupl):
"""
Append a tuple to the local patterns. Possible type literals
are converted to real literals on the fly. Each tuple should
be contain either 3 elements (for an RDF Triplet pattern) or
four, where the fourth element is a per-pattern constraint
(filter). (The general constraint of SPARQL can be optimized
by assigning a constraint to a specific pattern; because it
stops the graph expansion, its usage might be much more
optimal than the the 'global' constraint).
:param tupl: either a three- or four-element tuple
"""
if type(tupl) != tuple:
raise SPARQLError(
"illegal argument, pattern must be a tuple, got %s" % type(tupl))
if len(tupl) != 3 and len(tupl) != 4:
raise SPARQLError(
"illegal argument, pattern must be a tuple of 3 or 4 element, got %s" % len(tupl))
if len(tupl) == 3:
(s,p,o) = tupl
f = None
else:
(s,p,o,f) = tupl
final = []
for c in (s,p,o):
if _isResQuest(c):
if not c in self.unbounds:
self.unbounds.append(c)
final.append(c)
elif isinstance(c, BNode):
final.append(c)
else:
final.append(_createResource(c))
final.append(f)
return tuple(final)
def addPattern(self, tupl):
"""
Append a tuple to the local patterns. Possible type literals
are converted to real literals on the fly. Each tuple should
be contain either 3 elements (for an RDF Triplet pattern) or
four, where the fourth element is a per-pattern constraint
(filter). (The general constraint of SPARQL can be optimized
by assigning a constraint to a specific pattern; because it
stops the graph expansion, its usage might be much more
optimal than the the 'global' constraint).
:param tupl: either a three- or four-element tuple
"""
self.patterns.append(self._generatePattern(tupl))
def insertPattern(self, tupl):
"""
Insert a tuple to to the start of local patterns. Possible
type literals are converted to real literals on the fly. Each
tuple should be contain either 3 elements (for an RDF Triplet
pattern) or four, where the fourth element is a per-pattern
constraint (filter). (The general constraint of SPARQL can be
optimized by assigning a constraint to a specific pattern;
because it stops the graph expansion, its usage might be much
more optimal than the the 'global' constraint).
Semantically, the behaviour induced by a graphPattern does not
depend on the order of the patterns. However, due to the
behaviour of the expansion algorithm, users may control the
speed somewhat by adding patterns that would 'cut' the
expansion tree soon (ie, patterns that reduce the available
triplets significantly). API users may be able to do that,
hence this additional method.
:param tupl: either a three- or four-element tuple
"""
self.patterns.insert(0, self._generatePattern(tupl))
def addPatterns(self, lst):
"""
Append a list of tuples to the local patterns. Possible type
literals are converted to real literals on the fly. Each
tuple should be contain either three elements (for an RDF
Triplet pattern) or four, where the fourth element is a
per-pattern constraint. (The general constraint of SPARQL can
be optimized by assigning a constraint to a specific pattern;
because it stops the graph expansion, its usage might be much
more optimal than the the 'global' constraint).
:param lst: list consisting of either a three- or four-element tuples
"""
for l in lst:
self.addPattern(l)
def insertPatterns(self, lst):
"""
Insert a list of tuples to the start of the local
patterns. Possible type literals are converted to real
literals on the fly. Each tuple should be contain either
three elements (for an RDF Triplet pattern) or four, where the
fourth element is a per-pattern constraint. (The general
constraint of SPARQL can be optimized by assigning a
constraint to a specific pattern; because it stops the graph
expansion, its usage might be much more optimal than the the
'global' constraint).
Semantically, the behaviour induced by a graphPattern does not
depend on the order of the patterns. However, due to the
behaviour of the expansion algorithm, users may control the
speed somewhat by adding patterns that would 'cut' the
expansion tree soon (ie, patterns that reduce the available
triplets significantly). API users may be able to do that,
hence this additional method.
:param lst: list consisting of either a three- or four-element tuples
"""
for i in xrange(len(lst) -1, -1, -1):
self.insertPattern(lst[i])
def addConstraint(self, func):
"""
Add a global filter constraint to the graph pattern. 'func'
must be a method with a single input parameter (a dictionary)
returning a boolean. This method is I{added} to previously
added methods, ie, I{all} methods must return True to accept a
binding.
:param func: filter function
"""
if type(func) == FunctionType:
self.constraints.append(func)
else:
raise SPARQLError(
"illegal argument, constraint must be a function type, got %s" % type(func))
def addConstraints(self, lst):
"""
Add a list of global filter constraints to the graph
pattern. Each function in the list must be a method with a
single input parameter (a dictionary) returning a
boolean. These methods are I{added} to previously added
methods, ie, I{all} methods must return True to accept a
binding.
:param lst: list of functions
"""
for l in lst:
self.addConstraint(l)
def construct(self, tripleStore, bindings):
"""
Add triples to a tripleStore based on a variable bindings of
the patterns stored locally. The triples are patterned by the
current Graph Pattern. The method is used to construct a graph
after a successful querying.
:param tripleStore: an (rdflib) Triple Store
:param bindings: dictionary
"""
localBnodes = {}
for c in self.bnodes:
localBnodes[c] = BNode()
def bind(st):
if _isResQuest(st):
if st in bindings:
return bindings[st]
else:
if isinstance(self, GraphPattern):
return st
else:
return None
elif isinstance(st, BNode):
for c in self.bnodes:
if self.bnodes[c] == st:
return localBnodes[c]
return st
else:
return st
for pattern in self.patterns:
(s,p,o,f) = pattern
triplet = []
valid = True
for res in (s,p,o):
val = bind(res)
if val != None:
triplet.append(val)
else:
valid = False
break
if valid:
tripleStore.add(tuple(triplet))
def __add__(self, other):
"""Adding means concatenating all the patterns and filters arrays"""
retval = GraphPattern()
retval += self
retval += other
return retval
def __iadd__(self, other):
"""Adding means concatenating all the patterns and filters arrays"""
self.patterns += other.patterns
self.constraints += other.constraints
for c in other.unbounds:
if not c in self.unbounds:
self.unbounds.append(c)
for c in other.bnodes:
if not c in self.bnodes:
self.bnodes[c] = other.bnodes[c]
return self
def __str__(self):
return self.__repr__()
def isEmpty(self):
"""Is the pattern empty?
:return: Boolean
"""
return len(self.patterns) == 0
class BasicGraphPattern(GraphPattern):
"""
One justified, problem with the current definition of
:class:`~rdfextras.sparql.graph.GraphPattern` is that it makes it
difficult for users to use a literal of the type ``?XXX``, because
any string beginning with ``?`` will be considered to be an unbound
variable. The only way of doing this is that the user explicitly
creates a :class:`rdflib.term.Literal` object and uses that as part
of the pattern.
This class is a superclass of :class:`~rdfextras.sparql.graph.GraphPattern`
which does *not* do this, but requires the usage of a separate variable
class instance
"""
def __init__(self, patterns=[], prolog=None):
"""
:param patterns: an initial list of graph pattern tuples
"""
GraphPattern.__init__(self, patterns)
self.prolog = prolog
def canonicalTerm(self, term):
if isinstance(term, URIRef):
if self.prolog is not None:
namespace_manager = NamespaceManager(Graph())
for prefix,uri in self.prolog.prefixBindings.items():
namespace_manager.bind(prefix, uri, override=False)
try:
prefix,uri,localName = namespace_manager.compute_qname(term)
except:
return term
if prefix not in self.prolog.prefixBindings:
return term
else:
return u':'.join([prefix, localName])
else:
return term
elif isinstance(term, Literal):
return term.n3()
elif isinstance(term, BNode):
return term.n3()
else:
assert isinstance(term, Variable)
return term.n3()
def __repr__(self):
if self.constraints:
return "Filter(.. a filter ..,BGP(%s))" % (
','.join([','.join([
self.canonicalTerm(pat[0]),
self.canonicalTerm(pat[1]),
self.canonicalTerm(pat[2])]
)
for pat in self.patterns]))
else:
return "BGP(%s)" % (
','.join(['('+','.join([
self.canonicalTerm(s),
self.canonicalTerm(p),
self.canonicalTerm(o)]
)+')'
for s,p,o,f in self.patterns]))
retval = " Patterns: %s\n" % self.patterns
retval += " Constraints: %s\n" % self.constraints
retval += " Unbounds: %s\n" % self.unbounds
return retval
def _generatePattern(self, tupl):
"""
Append a tuple to the local patterns. Possible type literals
are converted to real literals on the fly. Each tuple should
be contain either 3 elements (for an RDF Triplet pattern) or
four, where the fourth element is a per-pattern constraint
(filter). (The general constraint of SPARQL can be optimized
by assigning a constraint to a specific pattern; because it
stops the graph expansion, its usage might be much more
optimal than the the 'global' constraint).
:param tupl: either a three- or four-element tuple
"""
if type(tupl) != tuple:
raise SPARQLError(
"illegal argument, pattern must be a tuple, got %s" % type(tupl))
if len(tupl) != 3 and len(tupl) != 4:
raise SPARQLError(
"illegal argument, pattern must be a tuple of 3 or 4 element, got %s" % len(tupl))
if len(tupl) == 3:
(s,p,o) = tupl
f = None
else:
(s,p,o,f) = tupl
final=[]
for c in (s,p,o):
if isinstance(c, Variable):
if not c in self.unbounds:
self.unbounds.append(c)
final.append(c)
elif isinstance(c, BNode):
final.append(c)
else:
final.append(_createResource(c))
final.append(f)
return tuple(final)
def fetchTerminalExpression(self):
yield self
if __name__ == '__main__':
from rdfextras.sparql.evaluate import Unbound
v1 = Variable("a")
u1 = Unbound("a")
g = BasicGraphPattern(
[("a","?b",24), ("?r","?c",12345), (v1,"?c",3333), (u1,"?c",9999)])
print g
|
data/SublimeLinter/SublimeLinter-phpcs/linter.py
|
"""This module exports the Phpcs plugin class."""
from SublimeLinter.lint import Linter
class Phpcs(Linter):
"""Provides an interface to phpcs."""
syntax = ('php', 'html', 'html 5')
regex = (
r'.*line="(?P<line>\d+)" '
r'column="(?P<col>\d+)" '
r'severity="(?:(?P<error>error)|(?P<warning>warning))" '
r'message="(?P<message>.*)" source'
)
executable = 'phpcs'
defaults = {
'--standard=': 'PSR2',
}
inline_overrides = ('standard')
tempfile_suffix = 'php'
def cmd(self):
"""Read cmd from inline settings."""
settings = Linter.get_view_settings(self)
if 'cmd' in settings:
command = [settings.get('cmd')]
else:
command = [self.executable_path]
command.append('--report=checkstyle')
return command
|
data/ReactiveX/RxPY/rx/linq/observable/find.py
|
from rx.observable import Observable
from rx.anonymousobservable import AnonymousObservable
from rx.internal import extensionmethod
def find_value(source, predicate, yield_index):
def subscribe(observer):
i = [0]
def on_next(x):
should_run = False
try:
should_run = predicate(x, i, source)
except Exception as ex:
observer.on_error(ex)
return
if should_run:
observer.on_next(i[0] if yield_index else x)
observer.on_completed()
else:
i[0] += 1
def on_completed():
observer.on_next(-1 if yield_index else None)
observer.on_completed()
return source.subscribe(on_next, observer.on_error, on_completed)
return AnonymousObservable(subscribe)
@extensionmethod(Observable)
def find(self, predicate):
"""Searches for an element that matches the conditions defined by the
specified predicate, and returns the first occurrence within the entire
Observable sequence.
Keyword arguments:
predicate -- {Function} The predicate that defines the conditions of the
element to search for.
Returns an Observable {Observable} sequence with the first element that
matches the conditions defined by the specified predicate, if found
otherwise, None.
"""
return find_value(self, predicate, False)
|
data/RoseOu/flasky/venv/lib/python2.7/site-packages/selenium/webdriver/support/expected_conditions.py
|
from selenium.common.exceptions import NoSuchElementException
from selenium.common.exceptions import NoSuchFrameException
from selenium.common.exceptions import StaleElementReferenceException
from selenium.common.exceptions import WebDriverException
from selenium.common.exceptions import NoAlertPresentException
"""
* Canned "Expected Conditions" which are generally useful within webdriver
* tests.
"""
class title_is(object):
"""An expectation for checking the title of a page.
title is the expected title, which must be an exact match
returns True if the title matches, false otherwise."""
def __init__(self, title):
self.title = title
def __call__(self, driver):
return self.title == driver.title
class title_contains(object):
""" An expectation for checking that the title contains a case-sensitive
substring. title is the fragment of title expected
returns True when the title matches, False otherwise
"""
def __init__(self, title):
self.title = title
def __call__(self, driver):
return self.title in driver.title
class presence_of_element_located(object):
""" An expectation for checking that an element is present on the DOM
of a page. This does not necessarily mean that the element is visible.
locator - used to find the element
returns the WebElement once it is located
"""
def __init__(self, locator):
self.locator = locator
def __call__(self, driver):
return _find_element(driver, self.locator)
class visibility_of_element_located(object):
""" An expectation for checking that an element is present on the DOM of a
page and visible. Visibility means that the element is not only displayed
but also has a height and width that is greater than 0.
locator - used to find the element
returns the WebElement once it is located and visible
"""
def __init__(self, locator):
self.locator = locator
def __call__(self, driver):
try:
return _element_if_visible(_find_element(driver, self.locator))
except StaleElementReferenceException:
return False
class visibility_of(object):
""" An expectation for checking that an element, known to be present on the
DOM of a page, is visible. Visibility means that the element is not only
displayed but also has a height and width that is greater than 0.
element is the WebElement
returns the (same) WebElement once it is visible
"""
def __init__(self, element):
self.element = element
def __call__(self, ignored):
return _element_if_visible(self.element)
def _element_if_visible(element):
return element if element.is_displayed() else False
class presence_of_all_elements_located(object):
""" An expectation for checking that there is at least one element present
on a web page.
locator is used to find the element
returns the list of WebElements once they are located
"""
def __init__(self, locator):
self.locator = locator
def __call__(self, driver):
return _find_elements(driver, self.locator)
class text_to_be_present_in_element(object):
""" An expectation for checking if the given text is present in the
specified element.
locator, text
"""
def __init__(self, locator, text_):
self.locator = locator
self.text = text_
def __call__(self, driver):
try :
element_text = _find_element(driver, self.locator).text
return self.text in element_text
except StaleElementReferenceException:
return False
class text_to_be_present_in_element_value(object):
"""
An expectation for checking if the given text is present in the element's
locator, text
"""
def __init__(self, locator, text_):
self.locator = locator
self.text = text_
def __call__(self, driver):
try:
element_text = _find_element(driver,
self.locator).get_attribute("value")
if element_text:
return self.text in element_text
else:
return False
except StaleElementReferenceException:
return False
class frame_to_be_available_and_switch_to_it(object):
""" An expectation for checking whether the given frame is available to
switch to. If the frame is available it switches the given driver to the
specified frame.
"""
def __init__(self, locator):
self.frame_locator = locator
def __call__(self, driver):
try:
if isinstance(self.frame_locator, tuple):
driver.switch_to.frame(_find_element(driver,
self.frame_locator))
else:
driver.switch_to.frame(self.frame_locator)
return True
except NoSuchFrameException:
return False
class invisibility_of_element_located(object):
""" An Expectation for checking that an element is either invisible or not
present on the DOM.
locator used to find the element
"""
def __init__(self, locator):
self.locator = locator
def __call__(self, driver):
try:
return not _find_element(driver, self.locator).is_displayed()
except (NoSuchElementException, StaleElementReferenceException):
return True
class element_to_be_clickable(object):
""" An Expectation for checking an element is visible and enabled such that
you can click it."""
def __init__(self, locator):
self.locator = locator
def __call__(self, driver):
element = visibility_of_element_located(self.locator)(driver)
if element and element.is_enabled():
return element
else:
return False
class staleness_of(object):
""" Wait until an element is no longer attached to the DOM.
element is the element to wait for.
returns False if the element is still attached to the DOM, true otherwise.
"""
def __init__(self, element):
self.element = element
def __call__(self, ignored):
try:
self.element.is_enabled()
return False
except StaleElementReferenceException as expected:
return True
class element_to_be_selected(object):
""" An expectation for checking the selection is selected.
element is WebElement object
"""
def __init__(self, element):
self.element = element
def __call__(self, ignored):
return self.element.is_selected()
class element_located_to_be_selected(object):
"""An expectation for the element to be located is selected.
locator is a tuple of (by, path)"""
def __init__(self, locator):
self.locator = locator
def __call__(self, driver):
return _find_element(driver, self.locator).is_selected()
class element_selection_state_to_be(object):
""" An expectation for checking if the given element is selected.
element is WebElement object
is_selected is a Boolean."
"""
def __init__(self, element, is_selected):
self.element = element
self.is_selected = is_selected
def __call__(self, ignored):
return self.element.is_selected() == self.is_selected
class element_located_selection_state_to_be(object):
""" An expectation to locate an element and check if the selection state
specified is in that state.
locator is a tuple of (by, path)
is_selected is a boolean
"""
def __init__(self, locator, is_selected):
self.locator = locator
self.is_selected = is_selected
def __call__(self, driver):
try:
element = _find_element(driver, self.locator)
return element.is_selected() == self.is_selected
except StaleElementReferenceException:
return False
class alert_is_present(object):
""" Expect an alert to be present."""
def __init__(self):
pass
def __call__(self, driver):
try:
alert = driver.switch_to.alert
alert.text
return alert
except NoAlertPresentException:
return False
def _find_element(driver, by):
""" Looks up an element. Logs and re-raises WebDriverException if thrown.
Method exists to gather data for
http://code.google.com/p/selenium/issues/detail?id=1800
"""
try :
return driver.find_element(*by)
except NoSuchElementException as e:
raise e
except WebDriverException as e:
raise e
def _find_elements(driver, by):
try :
return driver.find_elements(*by)
except WebDriverException as e:
raise e
|
data/YelpArchive/python-gearman/tests/client_tests.py
|
import collections
import random
import unittest
from gearman.client import GearmanClient
from gearman.client_handler import GearmanClientCommandHandler
from gearman.constants import PRIORITY_NONE, PRIORITY_HIGH, PRIORITY_LOW, JOB_UNKNOWN, JOB_PENDING, JOB_CREATED, JOB_FAILED, JOB_COMPLETE
from gearman.errors import ExceededConnectionAttempts, ServerUnavailable, InvalidClientState
from gearman.protocol import submit_cmd_for_background_priority, GEARMAN_COMMAND_STATUS_RES, GEARMAN_COMMAND_GET_STATUS, GEARMAN_COMMAND_JOB_CREATED, \
GEARMAN_COMMAND_WORK_STATUS, GEARMAN_COMMAND_WORK_FAIL, GEARMAN_COMMAND_WORK_COMPLETE, GEARMAN_COMMAND_WORK_DATA, GEARMAN_COMMAND_WORK_WARNING
from tests._core_testing import _GearmanAbstractTest, MockGearmanConnectionManager, MockGearmanConnection
class MockGearmanClient(GearmanClient, MockGearmanConnectionManager):
pass
class ClientTest(_GearmanAbstractTest):
"""Test the public client interface"""
connection_manager_class = MockGearmanClient
command_handler_class = GearmanClientCommandHandler
def setUp(self):
super(ClientTest, self).setUp()
self.original_handle_connection_activity = self.connection_manager.handle_connection_activity
def tearDown(self):
super(ClientTest, self).tearDown()
self.connection_manager.handle_connection_activity = self.original_handle_connection_activity
def generate_job_request(self, submitted=True, accepted=True):
current_request = super(ClientTest, self).generate_job_request()
if submitted or accepted:
self.connection_manager.establish_request_connection(current_request)
self.command_handler.send_job_request(current_request)
if submitted and accepted:
self.command_handler.recv_command(GEARMAN_COMMAND_JOB_CREATED, job_handle=current_request.job.handle)
self.assert_(current_request.job.handle in self.command_handler.handle_to_request_map)
return current_request
def test_establish_request_connection_complex(self):
failed_connection = MockGearmanConnection()
failed_connection._fail_on_bind = True
failed_then_retried_connection = MockGearmanConnection()
failed_then_retried_connection._fail_on_bind = True
good_connection = MockGearmanConnection()
good_connection.connect()
self.connection_manager.connection_list = [failed_connection, failed_then_retried_connection, good_connection]
current_request = self.generate_job_request(submitted=False, accepted=False)
self.failIf(current_request in self.connection_manager.request_to_rotating_connection_queue)
chosen_connection = self.connection_manager.establish_request_connection(current_request)
self.assertEqual(chosen_connection, good_connection)
self.assertFalse(failed_connection.connected)
self.assertFalse(failed_then_retried_connection.connected)
self.assertTrue(good_connection.connected)
chosen_connection = self.connection_manager.establish_request_connection(current_request)
self.assertEqual(chosen_connection, good_connection)
good_connection._reset_connection()
good_connection._fail_on_bind = True
failed_then_retried_connection._fail_on_bind = False
failed_then_retried_connection.connect()
chosen_connection = self.connection_manager.establish_request_connection(current_request)
self.assertEqual(chosen_connection, failed_then_retried_connection)
self.assertFalse(failed_connection.connected)
self.assertTrue(failed_then_retried_connection.connected)
self.assertFalse(good_connection.connected)
def test_establish_request_connection_dead(self):
self.connection_manager.connection_list = []
self.connection_manager.command_handlers = {}
current_request = self.generate_job_request(submitted=False, accepted=False)
self.assertRaises(ServerUnavailable, self.connection_manager.establish_request_connection, current_request)
failed_connection = MockGearmanConnection()
failed_connection._fail_on_bind = True
self.connection_manager.connection_list.append(failed_connection)
self.assertRaises(ServerUnavailable, self.connection_manager.establish_request_connection, current_request)
def test_auto_retry_behavior(self):
current_request = self.generate_job_request(submitted=False, accepted=False)
def fail_then_create_jobs(rx_conns, wr_conns, ex_conns):
if self.connection_manager.current_failures < self.connection_manager.expected_failures:
self.connection_manager.current_failures += 1
self.assertTrue(self.connection.connected)
self.connection_manager.handle_error(self.connection)
self.assertFalse(self.connection.connected)
self.connection_manager.establish_connection(self.connection)
else:
self.assertEquals(current_request.state, JOB_PENDING)
self.command_handler.recv_command(GEARMAN_COMMAND_JOB_CREATED, job_handle=current_request.job.handle)
return rx_conns, wr_conns, ex_conns
self.connection_manager.handle_connection_activity = fail_then_create_jobs
self.connection_manager.expected_failures = 5
self.connection_manager.current_failures = current_request.connection_attempts = 0
current_request.max_connection_attempts = self.connection_manager.expected_failures + 1
current_request.state = JOB_UNKNOWN
accepted_jobs = self.connection_manager.wait_until_jobs_accepted([current_request])
self.assertEquals(current_request.state, JOB_CREATED)
self.assertEquals(current_request.connection_attempts, current_request.max_connection_attempts)
self.connection_manager.current_failures = current_request.connection_attempts = 0
current_request.max_connection_attempts = self.connection_manager.expected_failures
current_request.state = JOB_UNKNOWN
self.assertRaises(ExceededConnectionAttempts, self.connection_manager.wait_until_jobs_accepted, [current_request])
self.assertEquals(current_request.state, JOB_UNKNOWN)
self.assertEquals(current_request.connection_attempts, current_request.max_connection_attempts)
def test_multiple_fg_job_submission(self):
submitted_job_count = 5
expected_job_list = [self.generate_job() for _ in xrange(submitted_job_count)]
def mark_jobs_created(rx_conns, wr_conns, ex_conns):
for current_job in expected_job_list:
self.command_handler.recv_command(GEARMAN_COMMAND_JOB_CREATED, job_handle=current_job.handle)
return rx_conns, wr_conns, ex_conns
self.connection_manager.handle_connection_activity = mark_jobs_created
job_dictionaries = [current_job.to_dict() for current_job in expected_job_list]
job_requests = self.connection_manager.submit_multiple_jobs(job_dictionaries, wait_until_complete=False)
for current_request, expected_job in zip(job_requests, expected_job_list):
current_job = current_request.job
self.assert_jobs_equal(current_job, expected_job)
self.assertEqual(current_request.priority, PRIORITY_NONE)
self.assertEqual(current_request.background, False)
self.assertEqual(current_request.state, JOB_CREATED)
self.assertFalse(current_request.complete)
def test_single_bg_job_submission(self):
expected_job = self.generate_job()
def mark_job_created(rx_conns, wr_conns, ex_conns):
self.command_handler.recv_command(GEARMAN_COMMAND_JOB_CREATED, job_handle=expected_job.handle)
return rx_conns, wr_conns, ex_conns
self.connection_manager.handle_connection_activity = mark_job_created
job_request = self.connection_manager.submit_job(expected_job.task, expected_job.data, unique=expected_job.unique, background=True, priority=PRIORITY_LOW, wait_until_complete=False)
current_job = job_request.job
self.assert_jobs_equal(current_job, expected_job)
self.assertEqual(job_request.priority, PRIORITY_LOW)
self.assertEqual(job_request.background, True)
self.assertEqual(job_request.state, JOB_CREATED)
self.assertTrue(job_request.complete)
def test_single_fg_job_submission_timeout(self):
expected_job = self.generate_job()
def job_failed_submission(rx_conns, wr_conns, ex_conns):
return rx_conns, wr_conns, ex_conns
self.connection_manager.handle_connection_activity = job_failed_submission
job_request = self.connection_manager.submit_job(expected_job.task, expected_job.data, unique=expected_job.unique, priority=PRIORITY_HIGH, poll_timeout=0.01)
self.assertEqual(job_request.priority, PRIORITY_HIGH)
self.assertEqual(job_request.background, False)
self.assertEqual(job_request.state, JOB_PENDING)
self.assertFalse(job_request.complete)
self.assertTrue(job_request.timed_out)
def test_wait_for_multiple_jobs_to_complete_or_timeout(self):
completed_request = self.generate_job_request()
failed_request = self.generate_job_request()
timeout_request = self.generate_job_request()
self.update_requests = True
def multiple_job_updates(rx_conns, wr_conns, ex_conns):
if self.update_requests:
self.command_handler.recv_command(GEARMAN_COMMAND_WORK_COMPLETE, job_handle=completed_request.job.handle, data='12345')
self.command_handler.recv_command(GEARMAN_COMMAND_WORK_FAIL, job_handle=failed_request.job.handle)
self.update_requests = False
return rx_conns, wr_conns, ex_conns
self.connection_manager.handle_connection_activity = multiple_job_updates
finished_requests = self.connection_manager.wait_until_jobs_completed([completed_request, failed_request, timeout_request], poll_timeout=0.01)
del self.update_requests
finished_completed_request, finished_failed_request, finished_timeout_request = finished_requests
self.assert_jobs_equal(finished_completed_request.job, completed_request.job)
self.assertEqual(finished_completed_request.state, JOB_COMPLETE)
self.assertEqual(finished_completed_request.result, '12345')
self.assertFalse(finished_completed_request.timed_out)
self.assert_jobs_equal(finished_failed_request.job, failed_request.job)
self.assertEqual(finished_failed_request.state, JOB_FAILED)
self.assertEqual(finished_failed_request.result, None)
self.assertFalse(finished_failed_request.timed_out)
self.assertEqual(finished_timeout_request.state, JOB_CREATED)
self.assertEqual(finished_timeout_request.result, None)
self.assertTrue(finished_timeout_request.timed_out)
self.assert_(finished_timeout_request.job.handle in self.command_handler.handle_to_request_map)
def test_get_job_status(self):
single_request = self.generate_job_request()
def retrieve_status(rx_conns, wr_conns, ex_conns):
self.command_handler.recv_command(GEARMAN_COMMAND_STATUS_RES, job_handle=single_request.job.handle, known='1', running='0', numerator='0', denominator='1')
return rx_conns, wr_conns, ex_conns
self.connection_manager.handle_connection_activity = retrieve_status
job_request = self.connection_manager.get_job_status(single_request)
request_status = job_request.status
self.failUnless(request_status)
self.assertTrue(request_status['known'])
self.assertFalse(request_status['running'])
self.assertEqual(request_status['numerator'], 0)
self.assertEqual(request_status['denominator'], 1)
self.assertFalse(job_request.timed_out)
def test_get_job_status_unknown(self):
single_request = self.generate_job_request()
current_handle = single_request.job.handle
self.command_handler.recv_command(GEARMAN_COMMAND_WORK_FAIL, job_handle=current_handle)
def retrieve_status(rx_conns, wr_conns, ex_conns):
self.command_handler.recv_command(GEARMAN_COMMAND_STATUS_RES, job_handle=current_handle, known='0', running='0', numerator='0', denominator='1')
return rx_conns, wr_conns, ex_conns
self.connection_manager.handle_connection_activity = retrieve_status
job_request = self.connection_manager.get_job_status(single_request)
request_status = job_request.status
self.failUnless(request_status)
self.assertFalse(request_status['known'])
self.assertFalse(request_status['running'])
self.assertEqual(request_status['numerator'], 0)
self.assertEqual(request_status['denominator'], 1)
self.assertFalse(job_request.timed_out)
def test_get_job_status_timeout(self):
single_request = self.generate_job_request()
def retrieve_status_timeout(rx_conns, wr_conns, ex_conns):
return rx_conns, wr_conns, ex_conns
self.connection_manager.handle_connection_activity = retrieve_status_timeout
job_request = self.connection_manager.get_job_status(single_request, poll_timeout=0.01)
self.assertTrue(job_request.timed_out)
class ClientCommandHandlerInterfaceTest(_GearmanAbstractTest):
"""Test the public interface a GearmanClient may need to call in order to update state on a GearmanClientCommandHandler"""
connection_manager_class = MockGearmanClient
command_handler_class = GearmanClientCommandHandler
def test_send_job_request(self):
current_request = self.generate_job_request()
gearman_job = current_request.job
for priority in (PRIORITY_NONE, PRIORITY_HIGH, PRIORITY_LOW):
for background in (False, True):
current_request.reset()
current_request.priority = priority
current_request.background = background
self.command_handler.send_job_request(current_request)
queued_request = self.command_handler.requests_awaiting_handles.popleft()
self.assertEqual(queued_request, current_request)
expected_cmd_type = submit_cmd_for_background_priority(background, priority)
self.assert_sent_command(expected_cmd_type, task=gearman_job.task, data=gearman_job.data, unique=gearman_job.unique)
def test_get_status_of_job(self):
current_request = self.generate_job_request()
self.command_handler.send_get_status_of_job(current_request)
self.assert_sent_command(GEARMAN_COMMAND_GET_STATUS, job_handle=current_request.job.handle)
class ClientCommandHandlerStateMachineTest(_GearmanAbstractTest):
"""Test single state transitions within a GearmanWorkerCommandHandler"""
connection_manager_class = MockGearmanClient
command_handler_class = GearmanClientCommandHandler
def generate_job_request(self, submitted=True, accepted=True):
current_request = super(ClientCommandHandlerStateMachineTest, self).generate_job_request()
if submitted or accepted:
self.command_handler.requests_awaiting_handles.append(current_request)
current_request.state = JOB_PENDING
if submitted and accepted:
self.command_handler.recv_command(GEARMAN_COMMAND_JOB_CREATED, job_handle=current_request.job.handle)
return current_request
def test_received_job_created(self):
current_request = self.generate_job_request(accepted=False)
new_handle = str(random.random())
self.command_handler.recv_command(GEARMAN_COMMAND_JOB_CREATED, job_handle=new_handle)
self.assertEqual(current_request.job.handle, new_handle)
self.assertEqual(current_request.state, JOB_CREATED)
self.assertEqual(self.command_handler.handle_to_request_map[new_handle], current_request)
def test_received_job_created_out_of_order(self):
self.assertEqual(self.command_handler.requests_awaiting_handles, collections.deque())
self.assertRaises(InvalidClientState, self.command_handler.recv_command, GEARMAN_COMMAND_JOB_CREATED, job_handle=None)
def test_required_state_pending(self):
current_request = self.generate_job_request(submitted=False, accepted=False)
new_handle = str(random.random())
invalid_states = [JOB_UNKNOWN, JOB_CREATED, JOB_COMPLETE, JOB_FAILED]
for bad_state in invalid_states:
current_request.state = bad_state
self.command_handler.requests_awaiting_handles.append(current_request)
self.assertRaises(InvalidClientState, self.command_handler.recv_command, GEARMAN_COMMAND_JOB_CREATED, job_handle=new_handle)
def test_required_state_queued(self):
current_request = self.generate_job_request()
job_handle = current_request.job.handle
new_data = str(random.random())
invalid_states = [JOB_UNKNOWN, JOB_PENDING, JOB_COMPLETE, JOB_FAILED]
for bad_state in invalid_states:
current_request.state = bad_state
self.assertRaises(InvalidClientState, self.command_handler.recv_command, GEARMAN_COMMAND_WORK_DATA, job_handle=job_handle, data=new_data)
self.assertRaises(InvalidClientState, self.command_handler.recv_command, GEARMAN_COMMAND_WORK_WARNING, job_handle=job_handle, data=new_data)
self.assertRaises(InvalidClientState, self.command_handler.recv_command, GEARMAN_COMMAND_WORK_STATUS, job_handle=job_handle, numerator=0, denominator=1)
self.assertRaises(InvalidClientState, self.command_handler.recv_command, GEARMAN_COMMAND_WORK_COMPLETE, job_handle=job_handle, data=new_data)
self.assertRaises(InvalidClientState, self.command_handler.recv_command, GEARMAN_COMMAND_WORK_FAIL, job_handle=job_handle)
def test_in_flight_work_updates(self):
current_request = self.generate_job_request()
job_handle = current_request.job.handle
new_data = str(random.random())
self.command_handler.recv_command(GEARMAN_COMMAND_WORK_DATA, job_handle=job_handle, data=new_data)
self.assertEqual(current_request.data_updates.popleft(), new_data)
self.assertEqual(current_request.state, JOB_CREATED)
self.command_handler.recv_command(GEARMAN_COMMAND_WORK_WARNING, job_handle=job_handle, data=new_data)
self.assertEqual(current_request.warning_updates.popleft(), new_data)
self.assertEqual(current_request.state, JOB_CREATED)
self.command_handler.recv_command(GEARMAN_COMMAND_WORK_STATUS, job_handle=job_handle, numerator=0, denominator=1)
self.assertEqual(current_request.status_updates.popleft(), (0, 1))
self.assertEqual(current_request.state, JOB_CREATED)
def test_work_complete(self):
current_request = self.generate_job_request()
job_handle = current_request.job.handle
new_data = str(random.random())
self.command_handler.recv_command(GEARMAN_COMMAND_WORK_COMPLETE, job_handle=job_handle, data=new_data)
self.assertEqual(current_request.result, new_data)
self.assertEqual(current_request.state, JOB_COMPLETE)
def test_work_fail(self):
current_request = self.generate_job_request()
job_handle = current_request.job.handle
new_data = str(random.random())
self.command_handler.recv_command(GEARMAN_COMMAND_WORK_FAIL, job_handle=job_handle)
self.assertEqual(current_request.state, JOB_FAILED)
def test_status_request(self):
current_request = self.generate_job_request()
job_handle = current_request.job.handle
self.assertEqual(current_request.status, {})
self.command_handler.recv_command(GEARMAN_COMMAND_STATUS_RES, job_handle=job_handle, known='1', running='1', numerator='0', denominator='1')
self.assertEqual(current_request.status['handle'], job_handle)
self.assertTrue(current_request.status['known'])
self.assertTrue(current_request.status['running'])
self.assertEqual(current_request.status['numerator'], 0)
self.assertEqual(current_request.status['denominator'], 1)
if __name__ == '__main__':
unittest.main()
|
data/VikParuchuri/percept/percept/workflows/datastores.py
|
"""
Used to save and load workflows
"""
from percept.utils.input import import_from_string
from percept.conf.base import settings
import pickle
import logging
log = logging.getLogger(__name__)
class BaseStore(object):
"""
Basic datastore
"""
def __init__(self):
self.data_path = settings.DATA_PATH
def save(self, obj, id_code):
"""
Save an object, and use id_code in the filename
obj - any object
id_code - unique identifier
"""
filestream = open('{0}/{1}'.format(self.data_path, id_code), 'w+')
pickle.dump(obj, filestream)
filestream.close()
def load(self, id_code):
"""
Loads a workflow identified by id_code
id_code - unique identifier, previously must have called save with same id_code
"""
filestream = open('{0}/{1}'.format(self.data_path, id_code), 'rb')
workflow = pickle.load(filestream)
return workflow
class FileStore(BaseStore):
"""
Stores everything in pickle dumps to files
"""
pass
|
data/KeepSafe/ks-email-parser/email_parser/cmd.py
|
"""
Handles command line and calls the email parser with corrent options.
"""
import argparse
import logging
from collections import namedtuple
from . import placeholder
logger = logging.getLogger()
ShortenerSettings = namedtuple('ShortenerSettings', [
'name',
'properties'
])
Settings = namedtuple('Settings', [
'source',
'destination',
'templates',
'images',
'pattern',
'right_to_left',
'strict',
'force',
'verbose',
'shortener',
'exclusive',
'default_locale',
'workers_pool',
'local_images',
'save',
'cms_service_host'
])
def default_settings():
return Settings(
verbose=False,
strict=True,
force=False,
source='src',
destination='target',
templates='templates_html',
images='http://www.getkeepsafe.com/emails/img',
right_to_left=['ar', 'he'],
pattern='{locale}/{name}.xml',
shortener={},
exclusive=None,
default_locale='en',
workers_pool=10,
local_images='templates_html/img',
save=None,
cms_service_host="http://localhost:5001"
)
def read_args(argsargs=argparse.ArgumentParser):
settings = default_settings()
logger.debug('reading arguments list')
args = argsargs(epilog='Brought to you by KeepSafe - www.getkeepsafe.com')
args.add_argument('-s', '--source', help='args\'s source folder, default: %s' % settings.source)
args.add_argument(
'-e', '--exclusive', help='Exclusive path of subset emails to compile, default: %s' % settings.exclusive)
args.add_argument('-d', '--destination',
help='args\'s destination folder, default: %s' % settings.destination)
args.add_argument('-t', '--templates', help='Templates folder, default: %s' % settings.templates)
args.add_argument('-rtl', '--right-to-left',
help='Comma separated list of RTL language codes, default: %s' % settings.right_to_left)
args.add_argument('-i', '--images', help='Images base directory, default: %s' % settings.images)
args.add_argument('-p', '--pattern', help='Email file search pattern, default: %s' % settings.pattern)
args.add_argument('-nst', '--not-strict',
help='Disable strict mode, allow templates with unfilled parameters',
action='store_false')
args.add_argument('-f', '--force', help='Generate emails despite errors', action='store_true')
args.add_argument('-wp', '--workers-pool',
help='Number of workers, default: %s' % settings.workers_pool, type=int)
args.add_argument('-vv', '--verbose', help='Generate emails despite errors', action='store_true')
args.add_argument('-v', '--version', help='Show version', action='store_true')
subparsers = args.add_subparsers(help='Parser additional commands', dest='command')
template_parser = subparsers.add_parser('client')
template_parser.add_argument('client', help='Provider name')
template_parser.add_argument('email_name',
help='Name of the email to generate the template for')
config_parser = subparsers.add_parser('config')
config_parser.add_argument('config_name', help='Name of config to generate')
gui_parser = subparsers.add_parser('gui')
gui_parser.add_argument('-P', '--port', type=int, help='Port to serve on', default=8080)
gui_parser.add_argument('-I', '--local-images', type=str, help='Server image directory',
default='templates_html/img')
gui_parser.add_argument('--save', type=str, help='Shell script to call after save action')
gui_parser.add_argument('-s', '--cms-service-host', type=str, help='email-service\'s URL')
return args.parse_args()
def read_settings(args):
args = vars(args)
settings = default_settings()._asdict()
for k in settings:
if k in args and args[k] is not None:
settings[k] = args[k]
return Settings(**settings)
def print_version():
import pkg_resources
version = pkg_resources.require('ks-email-parser')[0].version
print(version)
return True
def generate_config(args):
if args.config_name == 'placeholders':
logger.info('generating config for placeholders')
settings = read_settings(args)
placeholder.generate_config(settings)
return True
return False
def execute_command(args):
if args.command == 'config':
return generate_config(args)
elif args.command == 'gui':
from .gui.gui import serve
serve(args)
return True
return False
|
data/MirantisWorkloadMobility/CloudFerry/cloudferry/lib/os/compute/libvirt.py
|
import json
import os
from xml.etree import ElementTree
from cloudferry.lib.utils import log
LOG = log.getLogger(__name__)
nova_instances_path = "/var/lib/nova/instances/"
def instance_path(instance_id):
return os.path.join(nova_instances_path, instance_id)
def instance_image_path(instance_id):
return os.path.join(instance_path(instance_id), "disk")
def _qemu_img_rebase(src, dst):
return "qemu-img rebase -b {src} {dst}".format(src=src, dst=dst)
class QemuBackingFileMover(object):
def __init__(self, runner, src, instance_id):
self.runner = runner
self.src = src
self.dst = instance_image_path(instance_id)
def __enter__(self):
cmd = _qemu_img_rebase(self.src, self.dst)
self.runner.run(cmd)
return self
def __exit__(self, exc_type, exc_val, exc_tb):
cmd = _qemu_img_rebase(self.dst, self.src)
self.runner.run_ignoring_errors(cmd)
return self
class DestNovaInstanceDestroyer(object):
"""Fake instance is destroyed from libvirt as part of live migration. In
case something fails during live migration, this action must be rolled
back. The only valid rollback scenario is to delete the same instance from
nova DB."""
def __init__(self, dest_libvirt, dest_nova, libvirt_name, nova_vm_id):
self.dest_libvirt = dest_libvirt
self.dest_nova = dest_nova
self.libvirt_name = libvirt_name
self.nova_vm_id = nova_vm_id
def __enter__(self):
self.do()
def __exit__(self, exc_type, exc_val, exc_tb):
self.undo()
def do(self):
self.dest_libvirt.destroy_vm(self.libvirt_name)
def undo(self):
try:
LOG.debug("Rolling back fake VM %s", self.nova_vm_id)
self.dest_nova.reset_state(self.nova_vm_id)
self.dest_nova.delete_vm_by_id(self.nova_vm_id)
except RuntimeError:
pass
class Libvirt(object):
def __init__(self, remote_runner):
"""
:remote_runner: `cloudferry.lib.utils.remote_runner.RemoteRunner`
object
"""
self.runner = remote_runner
def get_backing_file(self, instance_id):
cmd = ("qemu-img info {image_path} --output json".format(
image_path=instance_image_path(instance_id)))
try:
image_info = json.loads(self.runner.run(cmd))
return image_info['backing-filename']
except (ValueError, TypeError) as e:
LOG.error("Invalid value received from qemu: %s!", e)
except KeyError:
LOG.warning("Instance '%s' does not have backing file associated!",
instance_id)
def get_xml(self, libvirt_instance_name):
cmd = ("virsh dumpxml {inst_name}".format(
inst_name=libvirt_instance_name))
return LibvirtXml(self.runner.run(cmd))
def destroy_vm(self, libvirt_instance_name):
cmds = [
"virsh destroy {instance}".format(instance=libvirt_instance_name),
"virsh undefine {instance}".format(instance=libvirt_instance_name)
]
for cmd in cmds:
self.runner.run(cmd)
def move_backing_file(self, source_file, instance_id):
cmd = _qemu_img_rebase(src=source_file,
dst=instance_image_path(instance_id))
self.runner.run(cmd)
def live_migrate(self, libvirt_instance_name, dest_host, migration_xml):
cmd = ("virsh migrate --live --copy-storage-all --verbose {instance} "
"qemu+tcp://{dst_host}/system "
"--xml {migration_xml}".format(instance=libvirt_instance_name,
dst_host=dest_host,
migration_xml=migration_xml))
self.runner.run(cmd)
class LibvirtDeviceInterfaceHwAddress(object):
def __init__(self, element):
self.type = element.get('type')
self.domain = element.get('domain')
self.bus = element.get('bus')
self.slot = element.get('slot')
self.function = element.get('function')
def __repr__(self):
return "HW Address<%s %s %s>" % (self.type, self.bus, self.slot)
def __eq__(self, other):
return (isinstance(other, self.__class__) and
self.type == other.type and
self.domain == other.domain and
self.bus == other.bus and
self.slot == other.slot and
self.function == other.function)
class LibvirtDeviceInterface(object):
def __init__(self, interface):
"""
:interface: - `xml.etree.ElementTree.Element` object
"""
self._xml_element = interface
self.mac = interface.find('mac').get('address')
self.source_iface = interface.find('source').get('bridge')
self.target_iface = interface.find('target').get('dev')
self.hw_address = LibvirtDeviceInterfaceHwAddress(
interface.find('address'))
def __eq__(self, other):
return (isinstance(other, self.__class__) and
self.source_iface == other.source_iface and
self.target_iface == other.target_iface and
self.hw_address == other.hw_address)
def __repr__(self):
return "Iface<mac={mac}, src={src}, dst={dst}>".format(
mac=self.mac, src=self.source_iface, dst=self.target_iface)
@classmethod
def _replace_attr(cls, element, attr, value):
if element.get(attr) != value:
element.clear()
element.attrib = {attr: value}
def element(self):
source = self._xml_element.find('source')
target = self._xml_element.find('target')
self._replace_attr(source, 'bridge', self.source_iface)
self._replace_attr(target, 'dev', self.target_iface)
return self._xml_element
class LibvirtXml(object):
def __init__(self, contents):
"""
:contents - XML file contents (text)
"""
self._xml = ElementTree.fromstring(contents)
self._interfaces = [LibvirtDeviceInterface(i)
for i in self._xml.findall('.//devices/interface')]
self.disk_file = self._get('.//disk/source', 'file')
self.serial_file = self._get('.//serial/source', 'path')
self.console_file = self._get('.//console/source', 'path')
def _get(self, element, attribute):
el = self._xml.find(element)
if el is not None:
return el.get(attribute)
def _set(self, element, attribute, value):
el = self._xml.find(element)
if el is not None:
el.set(attribute, value)
@property
def interfaces(self):
return self._interfaces
@interfaces.setter
def interfaces(self, other):
"""Only <source bridge/> and <target dev/> elements must be updated"""
if len(self.interfaces) != len(other):
raise RuntimeError("Source and dest have different number of "
"network interfaces allocated.")
for other_iface in other:
for this_iface in self.interfaces:
identical = (this_iface.mac == other_iface.mac)
if identical:
this_iface.source_iface = other_iface.source_iface
this_iface.target_iface = other_iface.target_iface
break
def dump(self):
self._set('.//disk/source', 'file', self.disk_file)
self._set('.//serial/source', 'path', self.serial_file)
self._set('.//console/source', 'path', self.console_file)
xml_devices = self._xml.find('.//devices')
xml_interfaces = self._xml.findall('.//devices/interface')
for iface in xml_interfaces:
xml_devices.remove(iface)
for iface in self._interfaces:
xml_devices.append(iface.element())
return ElementTree.tostring(self._xml)
|
data/adaptivdesign/django-sellmo/skeleton/color/admin.py
|
from sellmo import modules
from django.contrib import admin
class ColorAdmin(admin.ModelAdmin):
list_display = ['name', 'value']
admin.site.register(modules.color.Color, ColorAdmin)
|
data/PyHDI/veriloggen/examples/seq_example/seq_example.py
|
from __future__ import absolute_import
from __future__ import print_function
import sys
import os
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
from veriloggen import *
def mkLed():
m = Module('blinkled')
interval = m.Parameter('INTERVAL', 16)
clk = m.Input('CLK')
rst = m.Input('RST')
led = m.OutputReg('LED', 8, initval=0)
count = m.Reg('count', 32, initval=0)
seq = Seq(m, 'seq', clk, rst)
seq.add( Systask('display', 'LED:%d count:%d', led, count) )
seq.add( count(count + 1), cond=count<interval-1 )
seq.add( count(0), cond=count==interval-1 )
seq.add( led(led + 1), cond=count==interval-1 )
seq.make_always()
return m
def mkTest():
m = Module('test')
led = mkLed()
params = m.copy_params(led)
ports = m.copy_sim_ports(led)
clk = ports['CLK']
rst = ports['RST']
uut = m.Instance(led, 'uut',
params=m.connect_params(led),
ports=m.connect_ports(led))
simulation.setup_clock(m, clk, hperiod=5)
init = simulation.setup_reset(m, rst, m.make_reset(), period=100)
init.add(
Delay(1000),
Systask('finish'),
)
return m
if __name__ == '__main__':
test = mkTest()
verilog = test.to_verilog()
print(verilog)
|
data/StackStorm/st2/st2common/st2common/config.py
|
import os
import sys
from oslo_config import cfg
from st2common.constants.system import VERSION_STRING
def do_register_opts(opts, group=None, ignore_errors=False):
try:
cfg.CONF.register_opts(opts, group=group)
except:
if not ignore_errors:
raise
def do_register_cli_opts(opt, ignore_errors=False):
if not isinstance(opt, (list, tuple)):
opts = [opt]
else:
opts = opt
try:
cfg.CONF.register_cli_opts(opts)
except:
if not ignore_errors:
raise
def register_opts(ignore_errors=False):
rbac_opts = [
cfg.BoolOpt('enable', default=False, help='Enable RBAC.'),
]
do_register_opts(rbac_opts, 'rbac', ignore_errors)
system_user_opts = [
cfg.StrOpt('user',
default='stanley',
help='Default system user.'),
cfg.StrOpt('ssh_key_file',
default='/home/vagrant/.ssh/stanley_rsa',
help='SSH private key for the system user.')
]
do_register_opts(system_user_opts, 'system_user', ignore_errors)
schema_opts = [
cfg.IntOpt('version', default=4, help='Version of JSON schema to use.'),
cfg.StrOpt('draft', default='http://json-schema.org/draft-04/schema
help='URL to the JSON schema draft.')
]
do_register_opts(schema_opts, 'schema', ignore_errors)
system_opts = [
cfg.StrOpt('base_path', default='/opt/stackstorm',
help='Base path to all st2 artifacts.')
]
do_register_opts(system_opts, 'system', ignore_errors)
system_packs_base_path = os.path.join(cfg.CONF.system.base_path, 'packs')
content_opts = [
cfg.StrOpt('system_packs_base_path', default=system_packs_base_path,
help='Path to the directory which contains system packs.'),
cfg.StrOpt('packs_base_paths', default=None,
help='Paths which will be searched for integration packs.')
]
do_register_opts(content_opts, 'content', ignore_errors)
db_opts = [
cfg.StrOpt('host', default='0.0.0.0', help='host of db server'),
cfg.IntOpt('port', default=27017, help='port of db server'),
cfg.StrOpt('db_name', default='st2', help='name of database'),
cfg.StrOpt('username', help='username for db login'),
cfg.StrOpt('password', help='password for db login'),
cfg.IntOpt('connection_retry_max_delay_m', help='Connection retry total time (minutes).',
default=3),
cfg.IntOpt('connection_retry_backoff_max_s', help='Connection retry backoff max (seconds).',
default=10),
cfg.IntOpt('connection_retry_backoff_mul', help='Backoff multiplier (seconds).',
default=1),
cfg.BoolOpt('ssl', help='Create the connection to mongodb using SSL', default=False),
cfg.StrOpt('ssl_keyfile',
help='Private keyfile used to identify the local connection against MongoDB.',
default=None),
cfg.StrOpt('ssl_certfile', help='Certificate file used to identify the localconnection',
default=None),
cfg.StrOpt('ssl_cert_reqs', choices='none, optional, required',
help='Specifies whether a certificate is required from the other side of the \
connection, and whether it will be validated if provided',
default=None),
cfg.StrOpt('ssl_ca_certs',
help='ca_certs file contains a set of concatenated CA certificates, which are \
used to validate certificates passed from MongoDB.',
default=None),
cfg.BoolOpt('ssl_match_hostname',
help='If True and `ssl_cert_reqs` is not None, enables hostname verification',
default=True)
]
do_register_opts(db_opts, 'database', ignore_errors)
messaging_opts = [
cfg.StrOpt('url', default='amqp://guest:guest@127.0.0.1:5672//',
help='URL of the messaging server.'),
cfg.ListOpt('cluster_urls', default=[],
help='URL of all the nodes in a messaging service cluster.')
]
do_register_opts(messaging_opts, 'messaging', ignore_errors)
syslog_opts = [
cfg.StrOpt('host', default='127.0.0.1',
help='Host for the syslog server.'),
cfg.IntOpt('port', default=514,
help='Port for the syslog server.'),
cfg.StrOpt('facility', default='local7',
help='Syslog facility level.'),
cfg.StrOpt('protocol', default='udp',
help='Transport protocol to use (udp / tcp).')
]
do_register_opts(syslog_opts, 'syslog', ignore_errors)
log_opts = [
cfg.ListOpt('excludes', default='',
help='Exclusion list of loggers to omit.'),
cfg.BoolOpt('redirect_stderr', default=False,
help='Controls if stderr should be redirected to the logs.'),
cfg.BoolOpt('mask_secrets', default=True,
help='True to mask secrets in the log files.')
]
do_register_opts(log_opts, 'log', ignore_errors)
api_opts = [
cfg.StrOpt('host', default='0.0.0.0', help='StackStorm API server host'),
cfg.IntOpt('port', default=9101, help='StackStorm API server port'),
cfg.ListOpt('allow_origin', default=['http://127.0.0.1:3000'],
help='List of origins allowed for api, auth and stream'),
cfg.BoolOpt('mask_secrets', default=True,
help='True to mask secrets in the API responses')
]
do_register_opts(api_opts, 'api', ignore_errors)
keyvalue_opts = [
cfg.BoolOpt('enable_encryption', default=True,
help='Allow encryption of values in key value stored qualified as "secret".'),
cfg.StrOpt('encryption_key_path', default='',
help='Location of the symmetric encryption key for encrypting values in ' +
'kvstore. This key should be in JSON and should\'ve been ' +
'generated using keyczar.')
]
do_register_opts(keyvalue_opts, group='keyvalue')
auth_opts = [
cfg.StrOpt('api_url', default=None,
help='Base URL to the API endpoint excluding the version'),
cfg.BoolOpt('enable', default=True, help='Enable authentication middleware.'),
cfg.IntOpt('token_ttl', default=86400, help='Access token ttl in seconds.')
]
do_register_opts(auth_opts, 'auth', ignore_errors)
default_python_bin_path = sys.executable
base_dir = os.path.dirname(os.path.realpath(default_python_bin_path))
default_virtualenv_bin_path = os.path.join(base_dir, 'virtualenv')
action_runner_opts = [
cfg.StrOpt('logging', default='conf/logging.conf',
help='location of the logging.conf file'),
cfg.StrOpt('python_binary', default=default_python_bin_path,
help='Python binary which will be used by Python actions.'),
cfg.StrOpt('virtualenv_binary', default=default_virtualenv_bin_path,
help='Virtualenv binary which should be used to create pack virtualenvs.'),
cfg.ListOpt('virtualenv_opts', default=['--system-site-packages'],
help='List of virtualenv options to be passsed to "virtualenv" command that ' +
'creates pack virtualenv.')
]
do_register_opts(action_runner_opts, group='actionrunner')
action_sensor_opts = [
cfg.BoolOpt('enable', default=True,
help='Whether to enable or disable the ability to post a trigger on action.'),
]
do_register_opts(action_sensor_opts, group='action_sensor')
coord_opts = [
cfg.StrOpt('url', default=None, help='Endpoint for the coordination server.'),
cfg.IntOpt('lock_timeout', default=60, help='TTL for the lock if backend suports it.')
]
do_register_opts(coord_opts, 'coordination', ignore_errors)
mistral_opts = [
cfg.StrOpt('v2_base_url', default='http://127.0.0.1:8989/v2', help='v2 API root endpoint.'),
cfg.IntOpt('retry_exp_msec', default=1000, help='Multiplier for the exponential backoff.'),
cfg.IntOpt('retry_exp_max_msec', default=300000, help='Max time for each set of backoff.'),
cfg.IntOpt('retry_stop_max_msec', default=600000, help='Max time to stop retrying.'),
cfg.StrOpt('keystone_username', default=None, help='Username for authentication.'),
cfg.StrOpt('keystone_password', default=None, help='Password for authentication.'),
cfg.StrOpt('keystone_project_name', default=None, help='OpenStack project scope.'),
cfg.StrOpt('keystone_auth_url', default=None, help='Auth endpoint for Keystone.'),
cfg.StrOpt('cacert', default=None, help='Optional certificate to validate endpoint.'),
cfg.BoolOpt('insecure', default=False, help='Allow insecure communication with Mistral.'),
cfg.StrOpt('api_url', default=None, help=('URL Mistral uses to talk back to the API.'
'If not provided it defaults to public API URL. Note: This needs to be a base '
'URL without API version (e.g. http://127.0.0.1:9101)'))
]
do_register_opts(mistral_opts, group='mistral', ignore_errors=ignore_errors)
debug = cfg.BoolOpt('debug', default=False,
help='Enable debug mode. By default this will set all log levels to DEBUG.')
profile = cfg.BoolOpt('profile', default=False,
help=('Enable profile mode. In the profile mode all the MongoDB queries and related '
'profile data are logged.'))
use_debugger = cfg.BoolOpt('use-debugger', default=True,
help='Enables debugger. Note that using this option changes how the '
'eventlet library is used to support async IO. This could result in '
'failures that do not occur under normal operation.')
cli_opts = [debug, profile, use_debugger]
do_register_cli_opts(cli_opts, ignore_errors=ignore_errors)
def parse_args(args=None):
register_opts()
cfg.CONF(args=args, version=VERSION_STRING)
|
data/agronholm/apscheduler/apscheduler/jobstores/sqlalchemy.py
|
from __future__ import absolute_import
from apscheduler.jobstores.base import BaseJobStore, JobLookupError, ConflictingIdError
from apscheduler.util import maybe_ref, datetime_to_utc_timestamp, utc_timestamp_to_datetime
from apscheduler.job import Job
try:
import cPickle as pickle
except ImportError:
import pickle
try:
from sqlalchemy import (
create_engine, Table, Column, MetaData, Unicode, Float, LargeBinary, select)
from sqlalchemy.exc import IntegrityError
from sqlalchemy.sql.expression import null
except ImportError:
raise ImportError('SQLAlchemyJobStore requires SQLAlchemy installed')
class SQLAlchemyJobStore(BaseJobStore):
"""
Stores jobs in a database table using SQLAlchemy.
The table will be created if it doesn't exist in the database.
Plugin alias: ``sqlalchemy``
:param str url: connection string (see `SQLAlchemy documentation
<http://docs.sqlalchemy.org/en/latest/core/engines.html?highlight=create_engine
on this)
:param engine: an SQLAlchemy Engine to use instead of creating a new one based on ``url``
:param str tablename: name of the table to store jobs in
:param metadata: a :class:`~sqlalchemy.MetaData` instance to use instead of creating a new one
:param int pickle_protocol: pickle protocol level to use (for serialization), defaults to the
highest available
"""
def __init__(self, url=None, engine=None, tablename='apscheduler_jobs', metadata=None,
pickle_protocol=pickle.HIGHEST_PROTOCOL):
super(SQLAlchemyJobStore, self).__init__()
self.pickle_protocol = pickle_protocol
metadata = maybe_ref(metadata) or MetaData()
if engine:
self.engine = maybe_ref(engine)
elif url:
self.engine = create_engine(url)
else:
raise ValueError('Need either "engine" or "url" defined')
self.jobs_t = Table(
tablename, metadata,
Column('id', Unicode(191, _warn_on_bytestring=False), primary_key=True),
Column('next_run_time', Float(25), index=True),
Column('job_state', LargeBinary, nullable=False)
)
def start(self, scheduler, alias):
super(SQLAlchemyJobStore, self).start(scheduler, alias)
self.jobs_t.create(self.engine, True)
def lookup_job(self, job_id):
selectable = select([self.jobs_t.c.job_state]).where(self.jobs_t.c.id == job_id)
job_state = self.engine.execute(selectable).scalar()
return self._reconstitute_job(job_state) if job_state else None
def get_due_jobs(self, now):
timestamp = datetime_to_utc_timestamp(now)
return self._get_jobs(self.jobs_t.c.next_run_time <= timestamp)
def get_next_run_time(self):
selectable = select([self.jobs_t.c.next_run_time]).\
where(self.jobs_t.c.next_run_time != null()).\
order_by(self.jobs_t.c.next_run_time).limit(1)
next_run_time = self.engine.execute(selectable).scalar()
return utc_timestamp_to_datetime(next_run_time)
def get_all_jobs(self):
jobs = self._get_jobs()
self._fix_paused_jobs_sorting(jobs)
return jobs
def add_job(self, job):
insert = self.jobs_t.insert().values(**{
'id': job.id,
'next_run_time': datetime_to_utc_timestamp(job.next_run_time),
'job_state': pickle.dumps(job.__getstate__(), self.pickle_protocol)
})
try:
self.engine.execute(insert)
except IntegrityError:
raise ConflictingIdError(job.id)
def update_job(self, job):
update = self.jobs_t.update().values(**{
'next_run_time': datetime_to_utc_timestamp(job.next_run_time),
'job_state': pickle.dumps(job.__getstate__(), self.pickle_protocol)
}).where(self.jobs_t.c.id == job.id)
result = self.engine.execute(update)
if result.rowcount == 0:
raise JobLookupError(id)
def remove_job(self, job_id):
delete = self.jobs_t.delete().where(self.jobs_t.c.id == job_id)
result = self.engine.execute(delete)
if result.rowcount == 0:
raise JobLookupError(job_id)
def remove_all_jobs(self):
delete = self.jobs_t.delete()
self.engine.execute(delete)
def shutdown(self):
self.engine.dispose()
def _reconstitute_job(self, job_state):
job_state = pickle.loads(job_state)
job_state['jobstore'] = self
job = Job.__new__(Job)
job.__setstate__(job_state)
job._scheduler = self._scheduler
job._jobstore_alias = self._alias
return job
def _get_jobs(self, *conditions):
jobs = []
selectable = select([self.jobs_t.c.id, self.jobs_t.c.job_state]).\
order_by(self.jobs_t.c.next_run_time)
selectable = selectable.where(*conditions) if conditions else selectable
failed_job_ids = set()
for row in self.engine.execute(selectable):
try:
jobs.append(self._reconstitute_job(row.job_state))
except:
self._logger.exception('Unable to restore job "%s" -- removing it', row.id)
failed_job_ids.add(row.id)
if failed_job_ids:
delete = self.jobs_t.delete().where(self.jobs_t.c.id.in_(failed_job_ids))
self.engine.execute(delete)
return jobs
def __repr__(self):
return '<%s (url=%s)>' % (self.__class__.__name__, self.engine.url)
|
data/IanLewis/kay/kay/management/__init__.py
|
"""
kay.management
:Copyright: (c) 2009 Accense Technology, Inc.
Takashi Matsuo <tmatsuo@candit.jp>,
All rights reserved.
:license: BSD, see LICENSE for more details.
Taken from django.
"""
import sys
import os
from werkzeug.utils import import_string
from kay.management.shell import (
rshell, shell, clear_datastore, create_user,
)
from kay.management.runserver import runserver_passthru_argv
from kay.management.startapp import startapp
from kay.management.startapp import startproject
from kay.management.appcfg import do_appcfg_passthru_argv
from kay.management.bulkloader import (
do_bulkloader_passthru_argv, dump_all, restore_all,
)
from kay.management.test import do_runtest
from kay.management.preparse import do_preparse_bundle
from kay.management.preparse import do_preparse_apps
from kay.management.extract_messages import do_extract_messages
from kay.management.add_translations import do_add_translations
from kay.management.update_translations import do_update_translations
from kay.management.compile_translations import do_compile_translations
from kay.management.wxadmin import do_wxadmin
from kay.management.compile_media import do_compile_media
from kay.conf import settings
action_dump_all = dump_all
action_restore_all = restore_all
action_shell = shell
action_rshell = rshell
action_startapp = startapp
action_startproject = startproject
action_test = do_runtest
action_preparse_bundle = do_preparse_bundle
action_preparse_apps = do_preparse_apps
action_extract_messages = do_extract_messages
action_add_translations = do_add_translations
action_update_translations = do_update_translations
action_compile_translations = do_compile_translations
action_appcfg = do_appcfg_passthru_argv
action_runserver = runserver_passthru_argv
action_bulkloader = do_bulkloader_passthru_argv
action_clear_datastore = clear_datastore
action_create_user = create_user
action_wxadmin = do_wxadmin
action_compile_media = do_compile_media
additional_actions = []
for app in settings.INSTALLED_APPS:
try:
appmod = import_string(app)
if not os.path.exists(os.path.join(os.path.dirname(appmod.__file__),
'management.py')):
continue
management_mod = import_string("%s.management" % app)
for name, val in vars(management_mod).iteritems():
if name.startswith("action_"):
locals()[name] = getattr(management_mod, name)
additional_actions.append(name)
except Exception, e:
import traceback
sys.stderr.write('\n'.join(traceback.format_exception(*(sys.exc_info()))))
pass
__all__ = [
'runserver_passthru_argv', 'startapp', 'do_appcfg_passthru_argv',
'do_bulkloader_passthru_argv', 'do_runtest', 'do_preparse_bundle',
'do_extract_messages', 'do_add_translations', 'do_update_translations',
'do_compile_translations', 'shell', 'rshell', 'do_preparse_apps',
'startproject', 'do_wxadmin', 'clear_datastore', 'create_user', 'dump_all',
'restore_all', 'do_compile_media',
'action_dump_all', 'action_restore_all', 'action_shell', 'action_rshell',
'action_startapp', 'action_startproject', 'action_test',
'action_preparse_bundle', 'action_preparse_apps', 'action_extract_messages',
'action_add_translations', 'action_update_translations',
'action_compile_translations', 'action_appcfg', 'action_runserver',
'action_bulkloader', 'action_clear_datastore', 'action_create_user',
'action_wxadmin', 'action_compile_media',
] + additional_actions
def print_status(msg):
print(msg)
sys.stdout.flush()
|
data/Robpol86/terminaltables/tests/test_base_table_padded_table_data.py
|
"""Test padding cells."""
import pytest
from terminaltables.tables import AsciiTable, UnixTable
@pytest.mark.parametrize('cls', [AsciiTable, UnixTable])
def test_empty(cls):
"""Test on empty tables."""
table = cls([])
assert table.padded_table_data == []
table = cls([[]])
assert table.padded_table_data == [[]]
table = cls([['']])
assert table.padded_table_data == [[' ']]
table = cls([[' ']])
assert table.padded_table_data == [[' ']]
@pytest.mark.parametrize('cls', [AsciiTable, UnixTable])
def test_simple(cls):
"""Test on simple tables."""
table_data = [
['Name', 'Color', 'Type'],
['Avocado', 'green', 'nut'],
['Tomato', 'red', 'fruit'],
['Lettuce', 'green', 'vegetable'],
]
table = cls(table_data)
expected = [
[' Name ', ' Color ', ' Type '],
[' Avocado ', ' green ', ' nut '],
[' Tomato ', ' red ', ' fruit '],
[' Lettuce ', ' green ', ' vegetable '],
]
assert table.padded_table_data == expected
table_data.append(['Watermelon', 'green'])
table_data.append([])
expected = [
[' Name ', ' Color ', ' Type '],
[' Avocado ', ' green ', ' nut '],
[' Tomato ', ' red ', ' fruit '],
[' Lettuce ', ' green ', ' vegetable '],
[' Watermelon ', ' green ', ' '],
[' ', ' ', ' '],
]
assert table.padded_table_data == expected
@pytest.mark.parametrize('cls', [AsciiTable, UnixTable])
def test_attributes(cls):
"""Test padding on different text justifications."""
table_data = [
['Name', 'Color', 'Type'],
['Avocado', 'green', 'nut'],
['Tomato', 'red', 'fruit'],
['Lettuce', 'green', 'vegetable'],
['Watermelon', 'green']
]
table = cls(table_data)
table.justify_columns[0] = 'right'
expected = [
[' Name ', ' Color ', ' Type '],
[' Avocado ', ' green ', ' nut '],
[' Tomato ', ' red ', ' fruit '],
[' Lettuce ', ' green ', ' vegetable '],
[' Watermelon ', ' green ', ' ']
]
assert table.padded_table_data == expected
table.justify_columns[2] = 'center'
expected = [
[' Name ', ' Color ', ' Type '],
[' Avocado ', ' green ', ' nut '],
[' Tomato ', ' red ', ' fruit '],
[' Lettuce ', ' green ', ' vegetable '],
[' Watermelon ', ' green ', ' ']
]
assert table.padded_table_data == expected
@pytest.mark.parametrize('cls', [AsciiTable, UnixTable])
def test_multi_line(cls):
"""Test on multi-line tables."""
table_data = [
['A', 'B', 'C'],
['aaa', 'b\nbb\nbb', 'cc\nccccc'],
['aa', 'bb\nbb', 'c\ncc\nccc'],
]
table = cls(table_data)
table.justify_columns = {1: 'center', 2: 'right'}
expected = [
[' A ', ' B ', ' C '],
[' aaa \n \n ', ' b \n bb \n bb ', ' cc \n ccccc \n '],
[' aa \n \n ', ' bb \n bb \n ', ' c \n cc \n ccc '],
]
assert table.padded_table_data == expected
|
data/JoelBender/bacpypes/tests/test_pdu/__init__.py
|
"""
Test BACpypes PDU Module
"""
from . import test_address
|
data/PyHDI/veriloggen/tests/extension/seq_/countup/seq_countup.py
|
from __future__ import absolute_import
from __future__ import print_function
import sys
import os
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))))
from veriloggen import *
def mkLed():
m = Module('blinkled')
interval = m.Parameter('INTERVAL', 16)
clk = m.Input('CLK')
rst = m.Input('RST')
led = m.OutputReg('LED', 8, initval=0)
count = m.Reg('count', 32, initval=0)
seq = Seq(m, 'seq', clk, rst)
seq.add( Systask('display', 'LED:%d count:%d', led, count) )
seq.add( count(count + 1), cond=count<interval-1 )
seq.add( count(0), cond=count==interval-1 )
seq.add( led(led + 1), cond=count==interval-1 )
seq.make_always()
return m
def mkTest():
m = Module('test')
led = mkLed()
params = m.copy_params(led)
ports = m.copy_sim_ports(led)
clk = ports['CLK']
rst = ports['RST']
uut = m.Instance(led, 'uut',
params=m.connect_params(led),
ports=m.connect_ports(led))
simulation.setup_clock(m, clk, hperiod=5)
init = simulation.setup_reset(m, rst, m.make_reset(), period=100)
init.add(
Delay(1000),
Systask('finish'),
)
return m
if __name__ == '__main__':
test = mkTest()
verilog = test.to_verilog()
print(verilog)
|
data/Pathoschild/stewbot/CHANGELOG.py
|
"""
2012-12-03 r23
- added support for IPv6 addresses in commands (Issue
2011-04-01 r22
- new configuration: toggle handling of !commit command;
- use new API modules for getGlobalRights;
- use new API modules for getGlobalDetails (merged from getGlobalAccounts and getGlobalEdits);
- simplified package design.
2011-03-29 r21
- bugfix: Wikimedia handler assigned incorrect family for betwikiversity.
2011-03-01 r20
- bugfix: global edit count parsing broken in MW1.17wmf;
- added command parameter trimming.
2010-11-20 r19
- !stabhide conflict detection algorithm revamped;
- !stabhide now has 'hard' option to hide accounts even if they have edits.
2010-10-17 r18
- Wikimedia.py: fixed handling of special *wikimedia wikis.
2010-08-09 r17
- !stabhide overrides no-local-block list.
2010-08-08 r16
- !stab no longer blocks on enwikibooks, per
http://lists.wikimedia.org/pipermail/foundation-l/2010-August/060447.html
2010-07-13 r15
- now raises ValueError when user is assigned multiple access levels in config;
- overrode StrictDict iterators to never iterate over internal __name__ item.
2010-06-29 r14
- BREAKING CHANGE: replaced config.debug* options for straight-to-file state
dumping with new config.components.exceptionLogger. The config.debug*
lines can be safely removed from configuration files without replacement
to send exceptions to ERROR_LOG.txt in the bot directory.
- abstracted string encoding, fixed encoding crash when logging non-latin
characters.
2010-06-28 r13
- added configurable logging/output (messages can now be sent to console, file, or nowhere);
- prefer packaged modules over system modules (resolves version conflicts);
- added stewbot version number.
2010-05-15 r12
- updated CentralAuth scraping for interface changes.
2010-05-13 r11
- disabled !activity for en.wikipedia.
2010-04-30 r10
- added randomized exit messages.
2010-04-27 r9
- bugfix: reblockIfChanged did nothing if reblock=false.
2010-04-18 r8
- bugfix: when hiding an account that is already suppressed, treat 'suppressed' as 'hidden'
to avoid implicitly reducing hide level.
2010-04-17 r7
- added !getblocks command;
- show edit count in !stab* output;
- added IP support in Browser::getBlockStatus(), which now returns array;
- added Browser::getGlobalBlocks() & Browser::getCentralAuthStatus();
- bugfix: page creations counted twice in !stab output if they're also top edits.
2010-04-15 r6
- bugfix: exception when processing queue range with multiple gaps.
2010-04-11 r5
- updated CentralAuth scraping for new interface;
- added !globalOversight command (requires new CentralAuth interface);
- removed disabled global account deletion;
- moved to DefaultSettings & validated __config__ scheme;
- fixed HTTP parser bug when '<br/>' has no space before the slash;
- updated /modules/mechanize.
2010-04-06 r4
- updated for MediaWiki API change: https://bugzilla.wikimedia.org/show_bug.cgi?id=23076 .
2010-03-29 r3
- packaged irclib and simplejson into /modules/.
- added SSL for IRC.
2010-03-27 r2
- bugfix: commands can be queued for !commit even if they're configured as uncommittable (issue
2010-03-26 r1
- now open-source; initial commit.
"""
|
data/Tivix/django-common/django_common/http.py
|
from __future__ import print_function, unicode_literals, with_statement, division
from django.http import HttpResponse
try:
import json
except ImportError:
from django.utils import simplejson as json
class JsonResponse(HttpResponse):
def __init__(self, data=None, errors=None, success=True):
"""
data is a map, errors a list
"""
if not errors:
errors = []
if not data:
data = {}
json_resp = json_response(data=data, errors=errors, success=success)
super(JsonResponse, self).__init__(json_resp, content_type='application/json')
class JsonpResponse(HttpResponse):
"""
Padded JSON response, used for widget XSS
"""
def __init__(self, request, data=None, errors=None, success=True):
"""
data is a map, errors a list
"""
if not errors:
errors = []
if not data:
data = {}
json_resp = json_response(data=data, errors=errors, success=success)
js = "{0}({1})".format(request.GET.get("jsonp", "jsonp_callback"), json_resp)
super(JsonpResponse, self).__init__(js, mimetype='application/javascipt')
def json_response(data=None, errors=None, success=True):
if not errors:
errors = []
if not data:
data = {}
data.update({
'errors': errors,
'success': len(errors) == 0 and success,
})
return json.dumps(data)
class XMLResponse(HttpResponse):
def __init__(self, data):
"""
data is the entire xml body/document
"""
super(XMLResponse, self).__init__(data, mimetype='text/xml')
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.